All Classes and Interfaces
Class
Description
An AccessException is thrown by an accessor if it has an unexpected problem.
Represents assignment.
Represents a reference to a bean, for example
@orderService or
@'order.service'.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
IndexAccessor is able to generate bytecode that represents
the operation for reading the index, facilitating compilation to bytecode of
expressions that use the accessor.A compilable
PropertyAccessor 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() or
property1?.property2?.methodOne() when the null-safe navigation
operator is used.A
ConstructorExecutor is built by a ConstructorResolver and
can be cached by the infrastructure to repeat an operation quickly without
going back to the resolvers.Represents the invocation of a constructor: either a constructor on a regular type or
construction of an array.
A constructor resolver attempts to locate a constructor and returns a
ConstructorExecutor that can be used to invoke that constructor.An
MethodResolver variant for data binding
purposes, using reflection to access instance methods on a given target object.An
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.
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 index accessor is able to read from and possibly write to an indexed
structure of a target object.
An
Indexer can index into some proceeding structure to access a
particular element of the structure.Represent a list in an expression, for example, '{1,2,3}'.
Represent a map in an expression, for example, '{name:'foo',age:12}'.
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, hard-coded implementation of the
Expression interface
that represents a string literal.Expression language AST node that represents a long integer literal.
A
MethodExecutor is built by a MethodResolver 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 (i.e., a
method invocation other than a simple property reference).
A method resolver attempts to locate a method and returns a
MethodExecutor 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 defined in
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 public 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.
A flexible
IndexAccessor
that uses reflection to read from and optionally write to an indexed structure
of a target object.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.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 abstract syntax tree (AST) for a parsed Spring
Expression Language (SpEL) 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 default
ClassLoader or a supplied
ClassLoader to locate types.Expression language AST node that represents a string literal.
Strategy for types that access elements of specific target classes.
Abstract base class for expression parsers that
support 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
TypeCode.OBJECT 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.example.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 — for example,
#root, #this,
#someVar, etc.