当计算表达式解析properties, methods, fields，并帮助执行类型转换, 使用接口EvaluationContext 这是一个开箱即用的实现, StandardEvaluationContext，使用反射来操纵对象， 缓存java.lang.reflect的Method，Field，和Constructor实例 提高性能。

该StandardEvaluationContext是你可以指定root object通过使用 setRootObject（）或传递root object到构造函数. 你也可以指定变量和函数 使用方法'的setVariable（）和`registerFunction（）的表达式。 变量和函数的使用将在变量中介绍 ，同时 函数. StandardEvaluationContext也是在那里你可以自定义的注册 ConstructorResolvers, MethodResolvers, and PropertyAccessors to extend how SpEL evaluates expressions. 请参见这些类的Javadoc获得更多信息。

class Simple {
    public List<Boolean> booleanList = new ArrayList<Boolean>();
}

Simple simple = new Simple();

simple.booleanList.add(true);

StandardEvaluationContext simpleContext = new StandardEvaluationContext(simple);

// false is passed in here as a string. SpEL and the conversion service will
// correctly recognize that it needs to be a Boolean and convert it
parser.parseExpression("booleanList[0]").setValue(simpleContext, "false");

// b will be false
Boolean b = simple.booleanList.get(0);

用一个parser configuration object去配置SpEL解析器是可能的, （org.springframework.expression.spel.SpelParserConfiguration）.配置 对象控制的一些表达组件的行为。例如，如果数据为 索引到指定索引处的数组或集合的元素是null 它可以自动地创建的元素。当用表达式组合一个链式属性引用时这将非常有用. 如果索引到一个数组或列表 并指定一个索引超出数组的当前大小或 自动增长的数组或队列去容纳

class Demo {
    public List<String> list;
}

// Turn on:
// - auto null reference initialization
// - auto collection growing
SpelParserConfiguration config = new SpelParserConfiguration(true,true);

ExpressionParser parser = new SpelExpressionParser(config);

Expression expression = parser.parseExpression("list[3]");

Demo demo = new Demo();

Object o = expression.getValue(demo);

// demo.list will now be a real collection of 4 entries
// Each entry is a new empty String

另外，也可以配置一个SpEL表达式编译器的行为。

Spring Framework 4.1 包含了一个基本的表达式编译器. 表达式通常 解释其执行过程中提供了大量的动态灵活性，但 不提供最佳性能。对于偶尔使用的表达 这是好的，而是由其他组件，如Spring集成使用时， 性能是非常重要的，并没有为活力提供真正的需要。

新使用SpEL编译旨在解决这一需要。然后该 编译器将执行这体现了中动态生成一个真正的Java类 表达行为，并用它来实现更快的表达 式执行。由于缺乏各种表达式编译器 使用过程中的一个评估收集的评价的信息 当执行编译的表达。例如，它不知道的类型 参考表达，但在第一属性参考 解释执行会发现它是什么。当然，基于该 编译这些信息可能会造成的麻烦后，如果类型 各种表达元件随着时间而改变。出于这个原因汇编 是最适合返回执行不会改变其表达式类型的信息。

对于基本的表达是这样的：

someArray [0] .someProperty.someOtherProperty <0.1

其中涉及数组访问，部分属性引用和数字运算，性能 增益可以很明显的。在50000迭代一个例子微基准来看，它是 使用了75ms用来执行翻译，而仅仅3ms编译表达式的version。

=====编译器配置

编译器默认是并未开启的，但有两种方式打开 它。它被打开用parser configuration process 或者 通过系统属性将SpEL使用嵌入另一个组件中。本节 讨论这两个选项。

重要的是要明白，编译器可工作在几个模式下，查看详细可以用过一个enum (org.springframework.expression.spel.SpelCompilerMode). 模式如下：

IMMEDIATE 模式的存在是因为MIXED模式可能会导致问题的表达式 有副作用。如果在后面的部分是一个编译表达的摧毁 可能已经做了一些这已经影响到了系统的状态。如果这 已经发生的调用可能不希望它默默地重新运行在解释模式 因为表达的一部分可能运行两次。

选择模式后，使用SpelParserConfiguration配置解析器：

SpelParserConfiguration config = new SpelParserConfiguration(SpelCompilerMode.IMMEDIATE,
    this.getClass().getClassLoader());

SpelExpressionParser parser = new SpelExpressionParser(config);

Expression expr = parser.parseExpression("payload");

MyMessage message = new MyMessage();

Object payload = expr.getValue(message);

当指定编译器模式，也可以指定一个类加载器（传递null是允许的）。 编译表达式将在根据任何被供应创建一个子类加载器来限定。 确保如果指定一个类加载器就可以看到所有涉及的类型是很重要的 表达式求值的过程。 如果没有指定，那么默认的类加载器将使用（一般为上下文类加载器 这是在表达式求值运行的线程）。

来配置编译器的第二种方法是用于当使用SpEL嵌入里面的一些其它 组件和它可能无法通过配置对象来配置。 在这些情况下，有可能使用一个系统属性。属性 spring.expression.compiler.mode可设置到SpelCompilerMode 枚举值（off，immediate或mixed）之一。

一个属性或构造带参数的值可以使用表达式如下所示进行设置。

<bean id="numberGuess" class="org.spring.samples.NumberGuess">
    <property name="randomNumber" value="#{ T(java.lang.Math).random() * 100.0 }"/>

    <!-- other properties -->
</bean>

变量systemProperties是预定义的，所以你可以在你的表达式使用 如下所示。请注意，您不必用``＃前缀的预定义变量 符号于该上下文。

<bean id="taxCalculator" class="org.spring.samples.TaxCalculator">
    <property name="defaultLocale" value="#{ systemProperties['user.region'] }"/>

    <!-- other properties -->
</bean>

还可以参考其他bean属性的名字，例如。

<bean id="numberGuess" class="org.spring.samples.NumberGuess">
    <property name="randomNumber" value="{ T(java.lang.Math).random() * 100.0 }"/>

    <!-- other properties -->
</bean>

<bean id="shapeGuess" class="org.spring.samples.ShapeGuess">
    <property name="initialShapeSeed" value="{ numberGuess.randomNumber }"/>

    <!-- other properties -->
</bean>

@ Value注解可以放在字段，方法和方法/​​构造 参数里，以指定默认值。

这里是一个例子，设置一个字段变量的缺省值。

public static class FieldValueTestBean

    @Value("#{ systemProperties['user.region'] }")
    private String defaultLocale;

    public void setDefaultLocale(String defaultLocale) {
        this.defaultLocale = defaultLocale;
    }

    public String getDefaultLocale() {
        return this.defaultLocale;
    }

}

等效的属性setter方法​​如下所示。

public static class PropertyValueTestBean

    private String defaultLocale;

    @Value("#{ systemProperties['user.region'] }")
    public void setDefaultLocale(String defaultLocale) {
        this.defaultLocale = defaultLocale;
    }

    public String getDefaultLocale() {
        return this.defaultLocale;
    }

}

自动装配方法和构造也可以使用@ Value注解。

public class SimpleMovieLister {

    private MovieFinder movieFinder;
    private String defaultLocale;

    @Autowired
    public void configure(MovieFinder movieFinder,
            @Value("#{ systemProperties['user.region'] }") String defaultLocale) {
        this.movieFinder = movieFinder;
        this.defaultLocale = defaultLocale;
    }

    // ...
}

public class MovieRecommender {

    private String defaultLocale;

    private CustomerPreferenceDao customerPreferenceDao;

    @Autowired
    public MovieRecommender(CustomerPreferenceDao customerPreferenceDao,
            @Value("#{systemProperties['user.country']}") String defaultLocale) {
        this.customerPreferenceDao = customerPreferenceDao;
        this.defaultLocale = defaultLocale;
    }

    // ...
}

支持文字表达的类型是字符串，日期，数值（int， real，十六进制），布尔和空。字符串使用单引号分隔。一个 单引号本身在字符串中使用两个单引号字符表示。下面的列表 显示文字的简单用法。通常，它们将不被使用在隔离像这样， 但作为一个更复杂的表达式的一部分，例如，使用一个文字上的一侧 逻辑比较操作符。

ExpressionParser parser = new SpelExpressionParser();

// evals to "Hello World"
String helloWorld = (String) parser.parseExpression("'Hello World'").getValue();

double avogadrosNumber = (Double) parser.parseExpression("6.0221415E+23").getValue();

// evals to 2147483647
int maxValue = (Integer) parser.parseExpression("0x7FFFFFFF").getValue();

boolean trueValue = (Boolean) parser.parseExpression("true").getValue();

Object nullValue = parser.parseExpression("null").getValue();

数字支持使用负号，指数符号和小数点。 默认情况下，实数使用Double.parseDouble()。

用属性引用引导很简单：只要用一个.表示嵌套 属性值。实现Inventor类, pupin和tesla, 被添加 被添加。在章节classes的例子. 使用表达式引导 "down" 同时获取 Tesla’s 出生年 和 Pupin’s 出生城市

// evals to 1856
int year = (Integer) parser.parseExpression("Birthdate.Year + 1900").getValue(context);

String city = (String) parser.parseExpression("placeOfBirth.City").getValue(context);

不区分大小写允许的属性名称的第一个字母。 数组和列表使用方括号获得内容。

ExpressionParser parser = new SpelExpressionParser();

// Inventions Array
StandardEvaluationContext teslaContext = new StandardEvaluationContext(tesla);

// evaluates to "Induction motor"
String invention = parser.parseExpression("inventions[3]").getValue(
        teslaContext, String.class);

// Members List
StandardEvaluationContext societyContext = new StandardEvaluationContext(ieee);

// evaluates to "Nikola Tesla"
String name = parser.parseExpression("Members[0].Name").getValue(
        societyContext, String.class);

// List and Array navigation
// evaluates to "Wireless communication"
String invention = parser.parseExpression("Members[0].Inventions[6]").getValue(
        societyContext, String.class);

maps的内容由内指定的key值获得. 在这种情况下，因为对于人员的键映射是字符串，我们可以指定 字符串。

// Officer's Dictionary

Inventor pupin = parser.parseExpression("Officers['president']").getValue(
        societyContext, Inventor.class);

// evaluates to "Idvor"
String city = parser.parseExpression("Officers['president'].PlaceOfBirth.City").getValue(
        societyContext, String.class);

// setting values
parser.parseExpression("Officers['advisors'][0].PlaceOfBirth.Country").setValue(
        societyContext, "Croatia");

列表可以直接在表达式中使用{}符号来表示。

// evaluates to a Java list containing the four numbers
List numbers = (List) parser.parseExpression("{1,2,3,4}").getValue(context);

List listOfLists = (List) parser.parseExpression("{{'a','b'},{'x','y'}}").getValue(context);

{}本身意味着空列表。出于性能的考虑，如果列表本身 完全由固定面值的则恒定列表被创建以代表 表达，而不是建立一个新的列表上的每个都执行。

{key:value}记号的maps也可以使用表达式直接表示。

// evaluates to a Java map containing the two entries
Map inventorInfo = (Map) parser.parseExpression("{name:'Nikola',dob:'10-July-1856'}").getValue(context);

Map mapOfMaps = (Map) parser.parseExpression("{name:{first:'Nikola',last:'Tesla'},dob:{day:10,month:'July',year:1856}}").getValue(context);

{：}本身意味着一个空映射。出于性能的考虑，如果map本身是由 固定的文字或其他嵌套结构不变的（list或者map），那么一个恒定的map创建 代表表达，而不是建立新map每次去执行。使用.引用map的key 是可选的，上面的例子并没有使用.引用key。

array可以使用熟悉的Java语法，选择性地提供一个初始建立 有在构造时的数组。

int[] numbers1 = (int[]) parser.parseExpression("new int[4]").getValue(context);

// Array with initializer
int[] numbers2 = (int[]) parser.parseExpression("new int[]{1,2,3}").getValue(context);

// Multi dimensional array
int[][] numbers3 = (int[][]) parser.parseExpression("new int[4][5]").getValue(context);

即未被初始化的多维数组也可以被构造。

方法被调用通过java典型的编程语法实现，您也可以调用方法 在表示式当中。可变参数也支持。

// string literal, evaluates to "bc"
String c = parser.parseExpression("'abc'.substring(2, 3)").getValue(String.class);

// evaluates to true
boolean isMember = parser.parseExpression("isMember('Mihajlo Pupin')").getValue(
        societyContext, Boolean.class);

设置一个属性是通过使用赋值操作完成。这通常是 调用setValue，但也可以在调用getValue内完成。

Inventor inventor = new Inventor();
StandardEvaluationContext inventorContext = new StandardEvaluationContext(inventor);

parser.parseExpression("Name").setValue(inventorContext, "Alexander Seovic2");

// alternatively

String aleks = parser.parseExpression(
        "Name = 'Alexandar Seovic'").getValue(inventorContext, String.class);

T操作可以被用来指定安装一个java.lang.ClassClass (the type). 静态方法也可以使用该运算符调用。然后该 StandardEvaluationContext使用TypeLocator找到类型和 StandardTypeLocator（可替换）是建立与的理解 java.lang package. 这意味着T()引用内的java.lang类型不需要是 完全限定，但所有其他类型的引用必须。

Class dateClass = parser.parseExpression("T(java.util.Date)").getValue(Class.class);

Class stringClass = parser.parseExpression("T(String)").getValue(Class.class);

boolean trueValue = parser.parseExpression(
        "T(java.math.RoundingMode).CEILING < T(java.math.RoundingMode).FLOOR")
        .getValue(Boolean.class);

构造函数可以使用new运算符调用。所有地方的类名应该是符合要求的， ，除了原语类型和字符串（其中整数，浮点，等等，都可以 使用）。

Inventor einstein = p.parseExpression(
        "new org.spring.samples.spel.inventor.Inventor('Albert Einstein', 'German')")
        .getValue(Inventor.class);

//create new inventor instance within add method of List
p.parseExpression(
        "Members.add(new org.spring.samples.spel.inventor.Inventor(
            'Albert Einstein', 'German'))").getValue(societyContext);

变量可以在使用语法＃variableName表达引用。变量 使用在StandardEvaluationContext方法的setVariable设置。

Inventor tesla = new Inventor("Nikola Tesla", "Serbian");
StandardEvaluationContext context = new StandardEvaluationContext(tesla);
context.setVariable("newName", "Mike Tesla");

parser.parseExpression("Name = #newName").getValue(context);

System.out.println(tesla.getName()) // "Mike Tesla"

// create an array of integers
List<Integer> primes = new ArrayList<Integer>();
primes.addAll(Arrays.asList(2,3,5,7,11,13,17));

// create parser and set variable primes as the array of integers
ExpressionParser parser = new SpelExpressionParser();
StandardEvaluationContext context = new StandardEvaluationContext();
context.setVariable("primes",primes);

// all prime numbers > 10 from the list (using selection ?{...})
// evaluates to [11, 13, 17]
List<Integer> primesGreaterThanTen = (List<Integer>) parser.parseExpression(
        "#primes.?[#this>10]").getValue(context);

您可以通过注册，可以在该调用用户自定义函数扩展SpEL 表达式字符串。该函数注册到'StandardEvaluationContext`使用 该方法。

public void registerFunction(String name, Method m)

引用一个Java方法提供了函数的实现。举个例子 一个实用的方法来扭转字符串如下所示。

public abstract class StringUtils {

    public static String reverseString(String input) {
        StringBuilder backwards = new StringBuilder();
        for (int i = 0; i < input.length(); i++)
            backwards.append(input.charAt(input.length() - 1 - i));
        }
        return backwards.toString();
    }
}

这个方法在解析器上线文当中被注册，作为字符串被调用。

ExpressionParser parser = new SpelExpressionParser();
StandardEvaluationContext context = new StandardEvaluationContext();

context.registerFunction("reverseString",
    StringUtils.class.getDeclaredMethod("reverseString", new Class[] { String.class }));

String helloWorldReversed = parser.parseExpression(
    "#reverseString('hello')").getValue(context, String.class);

如果解析上下文已经配置，那么bean解析器能够 从表达式使用（@）符号查找bean类。

ExpressionParser parser = new SpelExpressionParser();
StandardEvaluationContext context = new StandardEvaluationContext();
context.setBeanResolver(new MyBeanResolver());

// This will end up calling resolve(context,"foo") on MyBeanResolver during evaluation
Object bean = parser.parseExpression("@foo").getValue(context);

您可以使用三元运算符内部执行的if-then-else条件逻辑 的表达。一个最简单的例子是：

String falseString = parser.parseExpression(
        "false ? 'trueExp' : 'falseExp'").getValue(String.class);

在这种情况下，在返回字符串值“falseExp'布尔假的结果。 更多案例:

parser.parseExpression("Name").setValue(societyContext, "IEEE");
societyContext.setVariable("queryName", "Nikola Tesla");

expression = "isMember(#queryName)? #queryName + ' is a member of the ' " +
        "+ Name + ' Society' : #queryName + ' is not a member of the ' + Name + ' Society'";

String queryResultString = parser.parseExpression(expression)
        .getValue(societyContext, String.class);
// queryResultString = "Nikola Tesla is a member of the IEEE Society"

同时可以在下一节看到 Elvis 运算符 使用一个更短的三元运算符语法。

Elvis操作符是三元运算符语法的缩短，并用于在 Groovy语言。 与三元运算符的语法，你通常要重复变量两次， 示例：

String name = "Elvis Presley";
String displayName = name != null ? name : "Unknown";

取而代之，你可以使用Elvis操作符，命名灵感来自猫王的发型风格。

ExpressionParser parser = new SpelExpressionParser();

String name = parser.parseExpression("null?:'Unknown'").getValue(String.class);

System.out.println(name); // Unknown

这里是一个更复杂的例子。

ExpressionParser parser = new SpelExpressionParser();

Inventor tesla = new Inventor("Nikola Tesla", "Serbian");
StandardEvaluationContext context = new StandardEvaluationContext(tesla);

String name = parser.parseExpression("Name?:'Elvis Presley'").getValue(context, String.class);

System.out.println(name); // Nikola Tesla

tesla.setName(null);

name = parser.parseExpression("Name?:'Elvis Presley'").getValue(context, String.class);

System.out.println(name); // Elvis Presley

安全导航操作符是用来避免'NullPointerException`和来自 该http://groovy.codehaus.org/Operators#Operators-SafeNavigationOperator(%3F.)[Groovy] 语言。通常情况下，当你有一个参考的对象，你可能需要验证 它不是访问方法或对象的属性之前空。为了避免这种情况，该 安全航行运算符将简单地返回空代替抛出的异常。

ExpressionParser parser = new SpelExpressionParser();

Inventor tesla = new Inventor("Nikola Tesla", "Serbian");
tesla.setPlaceOfBirth(new PlaceOfBirth("Smiljan"));

StandardEvaluationContext context = new StandardEvaluationContext(tesla);

String city = parser.parseExpression("PlaceOfBirth?.City").getValue(context, String.class);
System.out.println(city); // Smiljan

tesla.setPlaceOfBirth(null);

city = parser.parseExpression("PlaceOfBirth?.City").getValue(context, String.class);

System.out.println(city); // null - does not throw NullPointerException!!!

[注意]

@Value("#{systemProperties['pop3.port'] ?: 25}")

选择是一个强大的表达式语言功能，他允许你转换一些 源集合到另一个通过其条目选择。

选择使用语法？[selectionExpression].这将过滤收集和 返回一个包含原有元素的子集的新的集合。例如， 选择使我们能够轻松地获得Serbian inventors的列表：

List<Inventor> list = (List<Inventor>) parser.parseExpression(
        "Members.?[Nationality == 'Serbian']").getValue(societyContext);

选择可以被使用在lists或者maps集合当中。在前者的情况下，选择 标准执行对每个列表元素，同时针对map 选择定义的操作将会对map中的每个key执行。 （对象类似‘Map.Entry’） Map entries have their key and value accessible as properties for use in the selection。

下面这个例子将返回由原始映射（其中条目值小于27）所取得的这些元素的新map。

Map newMap = parser.parseExpression("map.?[value<27]").getValue();

除了返回所有选定的元素，也可以用来获取 第一或最后一个值。以获得第一条目相匹配的选择的语法是 ^ [...]而获得最后一个匹配选择语法是$ [...].

投影允许集合驱动子表达式和解析 生成一个新的集合。语法投影！[projectionExpression]. 多数 功能通过实例容易理解，假设我们有Inventor list，希望得到 他们出生的城市。有效的方式是我们要使用“placeOfBirth.city”解析 在Inventor 中的每个条目。使用投影：

// returns [Smiljan, Idvor ]
List placesOfBirth = (List)parser.parseExpression("Members.![placeOfBirth.city]");

一个map也可以用于驱动投影。 在这种情况下，投影表达式 将解析map中的每一个元素（作为Java Map.Entry方法的一个代理）。 通过投影一个map将获得一个由投影表达式遍历每个元素所得到的list。

表达式模板允许文字文本与一个或多个解析块的混合。 你可以每个解析块分隔前缀和后缀的字符， 当然，常见的选择是使用＃{}作为分隔符。例如，

String randomPhrase = parser.parseExpression(
        "random number is #{T(java.lang.Math).random()}",
        new TemplateParserContext()).getValue(String.class);

// evaluates to "random number is 0.7038186818312008"

该字符串是通过连接文字“random number is”与 计算表达式的＃{}定界符获取的结果，在此情况下的结果 中调用一个随机（）方法。第二个参数的方法parseExpression（） 是类型ParserContext的。在ParserContext接口用于影响如何 表达被解析，以便支持所述表达模板的功能。 的TemplateParserContext的定义如下所示。

public class TemplateParserContext implements ParserContext {

    public String getExpressionPrefix() {
        return "#{";
    }

    public String getExpressionSuffix() {
        return "}";
    }

    public boolean isTemplate() {
        return true;
    }
}