All Classes and Interfaces
Class
Description
An AccessException is thrown by an accessor if it has an unexpected problem.
Represents assignment.
Utilities methods for use in the Ast classes.
Represents a bean reference to a type, for example
@foo or @'foo.bar'.A bean resolver can be registered with the evaluation context and will kick in
for bean references:
@myBeanName and &myBeanName expressions.Represents the literal values
TRUE and FALSE.A
TypedValue for booleans.Manages the class being generated by the compilation process.
Interface used to generate
clinit static initializer blocks.Interface used to generate fields.
A compilable property accessor is able to generate bytecode that represents
the access operation, facilitating compilation to bytecode of expressions
that use the accessor.
Base superclass for compiled expressions.
Represents a template expression broken into pieces.
Represents a DOT separated expression sequence, such as
'property1.property2.methodOne()'.Executors are built by resolvers and can be cached by the infrastructure to repeat an
operation quickly without going back to the resolvers.
Represents the invocation of a constructor.
A constructor resolver attempts to locate a constructor and returns a ConstructorExecutor
that can be used to invoke that constructor.
A
MethodResolver variant for data binding
purposes, using reflection to access instance methods on a given target object.A
PropertyAccessor variant for data binding
purposes, using reflection to access properties for reading and possibly writing.Represents the elvis operator
?:.Expressions are executed in an evaluation context.
Represent an exception that occurs during expression evaluation.
An expression capable of evaluating itself against context objects.
Superclass for exceptions that can occur whilst processing expressions.
This exception wraps (as cause) a checked exception thrown by some method that SpEL
invokes.
Parses expression strings into compiled expressions that can be evaluated.
An ExpressionState is for maintaining per-expression-evaluation state, any changes to
it are not seen by other expressions but it gives a place to hold local variables and
for component expressions in a compound expression to communicate state.
Common utility functions that may be used by any Expression Language provider.
Expression language AST node that represents a float literal.
A function reference is of the form "#someFunction(a,b,c)".
An 'identifier'
SpelNode.An Indexer can index into some proceeding structure to access a particular piece of it.
Represent a list in an expression, e.g.
Represent a map in an expression, e.g.
Wraps a real parse exception.
Expression language AST node that represents an integer literal.
Common superclass for nodes representing literals (boolean, string, number, etc).
A very simple hardcoded implementation of the Expression interface that represents a
string literal.
Expression language AST node that represents a long integer literal.
MethodExecutors are built by the resolvers and can be cached by the infrastructure to
repeat an operation quickly without going back to the resolvers.
MethodFilter instances allow SpEL users to fine tune the behaviour of the method
resolution process.
Expression language AST node that represents a method reference.
A method resolver attempts to locate a method and returns a command executor that can be
used to invoke that method.
Expression language AST node that represents null.
Represents the boolean AND operation.
Decrement operator.
Implements division operator.
Implements the equality operator.
Supported operations that an
OperatorOverloader can implement for any pair of
operands.Common supertype for operators that operate on either one or two operands.
A descriptor comparison encapsulates the result of comparing descriptor
for two operands and describes at what level they are compatible.
Represents the between operator.
The operator 'instanceof' checks if an object is of the class specified in the
right-hand operand, in the same way that
instanceof does in Java.Implements the matches operator.
Represents a NOT operation.
By default the mathematical operators
Operation support simple types
like numbers.The power operator.
Implements greater-than-or-equal operator.
Implements the greater-than operator.
Increment operator.
Implements the less-than-or-equal operator.
Implements the less-than operator.
The minus operator supports:
subtraction of numbers
subtraction of an int from a string of one character
(effectively decreasing that character), so 'd'-3='a'
Implements the modulus operator.
Implements the
multiply operator.Implements the not-equal operator.
Represents the boolean OR operation.
The plus operator will:
add numbers
concatenate strings
Represent an exception that occurs during expression parsing.
Input provided to an expression parser that can influence an expression
parsing/compilation routine.
Represents projection, where a given operation is performed on all elements in some
input sequence, returning a new sequence of the same size.
A property accessor is able to read from (and possibly write to) an object's properties.
Represents a simple property or field reference.
Represents a dot separated sequence of strings that indicate a package qualified type
reference.
Expression language AST node that represents a real literal.
Utility methods used by the reflection resolver code to discover the appropriate
methods/constructors and fields that should be used in expressions.
A simple ConstructorExecutor implementation that runs a constructor using reflective
invocation.
A constructor resolver that uses reflection to locate the constructor that should be invoked.
MethodExecutor that works via reflection.Reflection-based
MethodResolver used by default in StandardEvaluationContext
unless explicit method resolvers have been specified.A powerful
PropertyAccessor that uses reflection to access properties
for reading and possibly also for writing on a target instance.An optimized form of a PropertyAccessor that will use reflection but only knows
how to access a particular property on a particular class.
Represents selection over a map or collection.
A basic implementation of
EvaluationContext that focuses on a subset
of essential SpEL features and customization options, targeting simple
condition evaluation and in particular data binding scenarios.Builder for
SimpleEvaluationContext.A SpelCompiler will take a regular parsed expression and create (and load) a class
containing byte code that does the same thing as that expression.
Captures the possible configuration settings for a compiler that can be
used when evaluating expressions.
Root exception for Spring EL related exceptions.
A
SpelExpression represents a parsed (valid) expression that is ready to be
evaluated in a specified context.SpEL parser.
Contains all the messages that can be produced by the Spring Expression Language.
Message kinds.
Represents a node in the AST for a parsed expression.
The common supertype of all AST nodes in a parsed Spring Expression Language
format expression.
Root exception for Spring EL related exceptions.
Configuration object for the SpEL expression parser.
A powerful and highly configurable
EvaluationContext implementation.Standard implementation of
OperatorOverloader.A basic
TypeComparator implementation: supports comparison of
Number types as well as types implementing Comparable.Default implementation of the
TypeConverter interface,
delegating to a core Spring ConversionService.A simple implementation of
TypeLocator that uses the context ClassLoader
(or any ClassLoader set upon it).Expression language AST node that represents a string literal.
An expression parser that understands templates.
Configurable
ParserContext implementation for template parsing.Represents a ternary expression, for example: "someCheck()?true:false".
Captures primitive types and their corresponding class objects, plus one special entry
that represents all reference (non-primitive) types.
Instances of a type comparator should be able to compare pairs of objects for equality.
A type converter can convert values between different types encountered during
expression evaluation.
Encapsulates an object and a
TypeDescriptor that describes it.Implementers of this interface are expected to be able to locate types.
Represents a reference to a type, for example
"T(String)" or "T(com.somewhere.Foo)".Represents a reference to a value.
A ValueRef for the null value.
A ValueRef holder for a single value, which cannot be set.
Represents a variable reference, eg.