# All Classes and Interfaces

Class
Description
AccessException
An AccessException is thrown by an accessor if it has an unexpected problem.
Assign
Represents assignment.
BeanReference
Represents a reference to a bean, for example `@orderService` or `@'order.service'`.
BeanResolver
A bean resolver can be registered with the evaluation context and will kick in for bean references: `@myBeanName` and `&myBeanName` expressions.
BooleanLiteral
Represents the literal values `TRUE` and `FALSE`.
BooleanTypedValue
A `TypedValue` for booleans.
CodeFlow
Manages the class being generated by the compilation process.
CodeFlow.ClinitAdder
Interface used to generate `clinit` static initializer blocks.
CodeFlow.FieldAdder
Interface used to generate fields.
CompilableIndexAccessor
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.
CompilablePropertyAccessor
A compilable `PropertyAccessor` is able to generate bytecode that represents the access operation, facilitating compilation to bytecode of expressions that use the accessor.
CompiledExpression
Base superclass for compiled expressions.
CompositeStringExpression
Represents a template expression broken into pieces.
CompoundExpression
Represents a DOT separated expression sequence, such as `property1.property2.methodOne()` or `property1?.property2?.methodOne()` when the null-safe navigation operator is used.
ConstructorExecutor
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.
ConstructorReference
Represents the invocation of a constructor: either a constructor on a regular type or construction of an array.
ConstructorResolver
A constructor resolver attempts to locate a constructor and returns a `ConstructorExecutor` that can be used to invoke that constructor.
DataBindingMethodResolver
An `MethodResolver` variant for data binding purposes, using reflection to access instance methods on a given target object.
DataBindingPropertyAccessor
An `PropertyAccessor` variant for data binding purposes, using reflection to access properties for reading and possibly writing.
Elvis
Represents the Elvis operator `?:`.
EvaluationContext
Expressions are executed in an evaluation context.
EvaluationException
Represent an exception that occurs during expression evaluation.
Expression
An expression capable of evaluating itself against context objects.
ExpressionException
Superclass for exceptions that can occur whilst processing expressions.
ExpressionInvocationTargetException
This exception wraps (as cause) a checked exception thrown by some method that SpEL invokes.
ExpressionParser
Parses expression strings into compiled expressions that can be evaluated.
ExpressionState
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.
ExpressionUtils
Common utility functions that may be used by any Expression Language provider.
FloatLiteral
Expression language AST node that represents a float literal.
FunctionReference
A function reference is of the form "#someFunction(a,b,c)".
Identifier
An 'identifier' `SpelNode`.
IndexAccessor
An index accessor is able to read from and possibly write to an indexed structure of a target object.
Indexer
An `Indexer` can index into some proceeding structure to access a particular element of the structure.
InlineList
Represent a list in an expression, for example, '{1,2,3}'.
InlineMap
Represent a map in an expression, for example, '{name:'foo',age:12}'.
InternalParseException
Wraps a real parse exception.
IntLiteral
Expression language AST node that represents an integer literal.
Literal
Common superclass for nodes representing literals (boolean, string, number, etc).
LiteralExpression
A very simple, hard-coded implementation of the `Expression` interface that represents a string literal.
LongLiteral
Expression language AST node that represents a long integer literal.
MethodExecutor
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
MethodFilter instances allow SpEL users to fine tune the behavior of the method resolution process.
MethodReference
Expression language AST node that represents a method reference.
MethodResolver
A method resolver attempts to locate a method and returns a `MethodExecutor` that can be used to invoke that method.
NullLiteral
Expression language AST node that represents null.
OpAnd
Represents the boolean AND operation.
OpDec
Decrement operator.
OpDivide
Implements division operator.
OpEQ
Implements the equality operator.
Operation
Supported operations that an `OperatorOverloader` can implement for any pair of operands.
Operator
Common supertype for operators that operate on either one or two operands.
Operator.DescriptorComparison
A descriptor comparison encapsulates the result of comparing descriptor for two operands and describes at what level they are compatible.
OperatorBetween
Represents the `between` operator.
OperatorInstanceof
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.
OperatorMatches
Implements the matches operator.
OperatorNot
Represents a NOT operation.
OperatorOverloader
By default, the mathematical operators defined in `Operation` support simple types like numbers.
OperatorPower
The power operator.
OpGE
Implements greater-than-or-equal operator.
OpGT
Implements the greater-than operator.
OpInc
Increment operator.
OpLE
Implements the less-than-or-equal operator.
OpLT
Implements the less-than operator.
OpMinus
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'`
OpModulus
Implements the modulus operator.
OpMultiply
Implements the `multiply` operator.
OpNE
Implements the not-equal operator.
OpOr
Represents the boolean OR operation.
OpPlus
The plus operator will: add numbers concatenate strings
ParseException
Represent an exception that occurs during expression parsing.
ParserContext
Input provided to an expression parser that can influence an expression parsing/compilation routine.
Projection
Represents projection, where a given operation is performed on all elements in some input sequence, returning a new sequence of the same size.
PropertyAccessor
A property accessor is able to read from (and possibly write to) an object's properties.
PropertyOrFieldReference
Represents a simple property or field reference.
QualifiedIdentifier
Represents a dot separated sequence of strings that indicate a package qualified type reference.
RealLiteral
Expression language AST node that represents a real literal.
ReflectionHelper
Utility methods used by the reflection resolver code to discover the appropriate methods, constructors, and fields that should be used in expressions.
ReflectiveConstructorExecutor
A simple ConstructorExecutor implementation that runs a constructor using reflective invocation.
ReflectiveConstructorResolver
A constructor resolver that uses reflection to locate the constructor that should be invoked.
ReflectiveIndexAccessor
A flexible `IndexAccessor` that uses reflection to read from and optionally write to an indexed structure of a target object.
ReflectiveMethodExecutor
`MethodExecutor` that works via reflection.
ReflectiveMethodResolver
Reflection-based `MethodResolver` used by default in `StandardEvaluationContext` unless explicit method resolvers have been specified.
ReflectivePropertyAccessor
A powerful `PropertyAccessor` that uses reflection to access properties for reading and possibly also for writing on a target instance.
Selection
Represents selection over a map or collection.
SimpleEvaluationContext
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.
SimpleEvaluationContext.Builder
Builder for `SimpleEvaluationContext`.
SpelCompiler
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.
SpelCompilerMode
Captures the possible configuration settings for a compiler that can be used when evaluating expressions.
SpelEvaluationException
Root exception for Spring EL related exceptions.
SpelExpression
A `SpelExpression` represents a parsed (valid) expression that is ready to be evaluated in a specified context.
SpelExpressionParser
SpEL parser.
SpelMessage
Contains all the messages that can be produced by the Spring Expression Language.
SpelMessage.Kind
Message kinds.
SpelNode
Represents a node in the abstract syntax tree (AST) for a parsed Spring Expression Language (SpEL) expression.
SpelNodeImpl
The common supertype of all AST nodes in a parsed Spring Expression Language format expression.
SpelParseException
Root exception for Spring EL related exceptions.
SpelParserConfiguration
Configuration object for the SpEL expression parser.
StandardEvaluationContext
A powerful and highly configurable `EvaluationContext` implementation.
StandardOperatorOverloader
Standard implementation of `OperatorOverloader`.
StandardTypeComparator
A basic `TypeComparator` implementation: supports comparison of `Number` types as well as types implementing `Comparable`.
StandardTypeConverter
Default implementation of the `TypeConverter` interface, delegating to a core Spring `ConversionService`.
StandardTypeLocator
A simple implementation of `TypeLocator` that uses the default `ClassLoader` or a supplied `ClassLoader` to locate types.
StringLiteral
Expression language AST node that represents a string literal.
TargetedAccessor
Strategy for types that access elements of specific target classes.
TemplateAwareExpressionParser
Abstract base class for expression parsers that support templates.
TemplateParserContext
Configurable `ParserContext` implementation for template parsing.
Ternary
Represents a ternary expression, for example: "someCheck()?true:false".
TypeCode
Captures primitive types and their corresponding class objects, plus one special `TypeCode.OBJECT` entry that represents all reference (non-primitive) types.
TypeComparator
Instances of a type comparator should be able to compare pairs of objects for equality.
TypeConverter
A type converter can convert values between different types encountered during expression evaluation.
TypedValue
Encapsulates an object and a `TypeDescriptor` that describes it.
TypeLocator
Implementors of this interface are expected to be able to locate types.
TypeReference
Represents a reference to a type, for example `"T(String)"` or `"T(com.example.Foo)"`.
ValueRef
Represents a reference to a value.
ValueRef.NullValueRef
A ValueRef for the null value.
ValueRef.TypedValueHolderValueRef
A ValueRef holder for a single value, which cannot be set.
VariableReference
Represents a variable reference — for example, `#root`, `#this`, `#someVar`, etc.