public class TestStringSub{
public static void main(String [] args){
String str = "hello world".subString(5,6);
System.out.println(str);
}
}
整个spring表达式操作之中可以将一个完全的字符串变为了一个可以用于程序执行的语句,这系系列的执行语句需要有一系列的支持类完成,但是至少我可以发现字符串的功能又一次被加强了。
public class TestStringSubExpression{
public static void main(String [] args){
String expression = "\"hello world\".subString(5,6)";
ExpressionParser expressionParser = new SpelExpressionParser();// 指定spelExpressionParser解析器实现类
Expression expression = parser.parseExpression(expression);//解析表达式
EvaluationContext context = new StandardEvaluationContext(expression);//设置对象模型基础。
System.out.println(expression.getValue(evaluationContext);
}
}
专门解析传入对象的指定属性数值,这里做了下处理,如果获取失败,则直接返回当前传入的属性名称,方便大家做静态解析和动态解析,比如你传入一个8,因为8的这个属性肯定会不对,所以最后会返回一个8。
private static ExpressionParser expressionParser = new SpelExpressionParser();
public static Object getValueByExpression(Object targetObject,String propertyName){
try {
EvaluationContext evaluationContext = new StandardEvaluationContext();
evaluationContext.setVariable("model",targetObject);
Expression expression =expressionParser.parseExpression(String.format("#{#model.%s}",propertyName),new TemplateParserContext());
return expression.getValue(evaluationContext,Object.class);
} catch (ParseException e) {
log.warn("ParseException analysis the parameter is {}",propertyName);
} catch (EvaluationException e) {
log.warn("EvaluationException analysis the parameter is {}",propertyName);
}
return propertyName;
}
org.springframework.expression.expressionparser
主要负责根据给定的表达式字符串内容对解析器进行处理.
org.springframework.expression.spel.standard.spelexpressionparsr
Expressionparser本身只是一个操作的标准,但是它对应的处理类必须单独设置,本次使用的是spel的标准处理
org.springframework.expression.Expression
将字符串根据指定的解析器进行解析,而后使用这个生成表达式:
org.springframework.expression.evaluationcontext
因为表达式操作之中可能会存在有某些占位符需要进行处理
public class TestStringSubExpression{
public static void main(String [] args){
String expression = "\"hello world\".subString(#start,#end)";
ExpressionParser expressionParser = new SpelExpressionParser();// 指定spelExpressionParser解析器实现类
Expression expression = parser.parseExpression(expression);//解析表达式
EvaluationContext context = new StandardEvaluationContext(expression);//设置对象模型基础。
context.setVariable("start",1);
context.setVariable("end",2);
System.out.println(expression.getValue(evaluationContext);
}
}
import org.springframework.expression.EvaluationContext;
import org.springframework.expression.Expression;
import org.springframework.expression.ExpressionParser;
import org.springframework.expression.common.TemplateParserContext;
import org.springframework.expression.spel.standard.SpelExpressionParser;
import org.springframework.expression.spel.support.StandardEvaluationContext;
public class Test {
public static void main(String[] args) {
//测试SpringEL解析器
String template = "#{#name},早上好";//设置文字模板,其中#{}表示表达式的起止,#user是表达式字符串,表示引用一个变量。
ExpressionParser paser = new SpelExpressionParser();//创建表达式解析器
//通过evaluationContext.setVariable可以在上下文中设定变量。
EvaluationContext context = new StandardEvaluationContext();
context.setVariable("name","Alex");
//解析表达式,如果表达式是一个模板表达式,需要为解析传入模板解析器上下文。
Expression expression = paser.parseExpression(template,new TemplateParserContext());
//使用Expression.getValue()获取表达式的值,这里传入了Evalution上下文,第二个参数是类型参数,表示返回值的类型。
System.out.println(expression.getValue(context,String.class));
}
}
除了编写字符串之外还可以编写数字.甚至各种字符串的数据.
一定要首先对其一个判断,判断表达式应该由那些组成,而后要拆分组成的内容,最后要进行字符串的相关数据类型的转换,从而得出最终的计算结果.
任何的表达式其组成之中一定会包含相应的边界形式,例如:在jsp中的el里面使用${表达式},在spring里面,如果用户有需要也可以定义我们的边界.首先观察解析表达式的操作类:Expressionparser
就是用户自己设计边界符的:
boolean isTemplate();
String getExpressionPrefix();
String getExpressionSubffix();
使用匿名内部类的方式完成.可以在这步定义表达式的边界.定义的表达式在计算的过程中都会自动的忽略掉,大部分我们不会用到自定义边界。
Expression parser = new SpelExpressionParser().parseExpression(str,new ParserContext(){
public boolean isTemplate() {
return true;
}
public String getExpressionPrefix() {
return "[";
}
public String getExpressionSuffix() {
return "]";
}
});
// 默认的ParserContext
public interface ParserContext {
ParserContext TEMPLATE_EXPRESSION = new ParserContext() {
public boolean isTemplate() {
return true;
}
public String getExpressionPrefix() {
return "#{";
}
public String getExpressionSuffix() {
return "}";
}
};
boolean isTemplate();
String getExpressionPrefix();
String getExpressionSuffix();
}
Expression exp = parser.parseExpression("1+2+4+5/2");
Expression exp = parser.parseExpression("1%2");
Expression exp = parser.parseExpression("1 MOD 2");
Expression exp = parser.parseExpression("1 ^ 2");
Expression exp = parser.parseExpression("1 / 2");
Expression exp = parser.parseExpression("1 == 2");
Expression exp = parser.parseExpression("1 EQ 2");
Expression exp = parser.parseExpression("1 != 2");
Expression exp = parser.parseExpression("1 NE 2");
Expression exp = parser.parseExpression("1 > 2");
Expression exp = parser.parseExpression("1 GT 2");
Expression exp = parser.parseExpression("1 >= 2");
Expression exp = parser.parseExpression("1 GE 2");
Expression exp = parser.parseExpression("1 BETWEEN {5,20}");
其他的以此类推就不过多赘述了!
Expression exp = parser.parseExpression("1 = 1 AND 2 = 2");
Expression exp = parser.parseExpression("1 = 1 or 2 = 2");
Expression exp = parser.parseExpression("1 > 1? 1:2);
例如:#{bean.属性?:默认值},注意bean.属性必须是要存在的,当为null时匹配
请注意它是否能用,跟bean的初始化时间有关.
例如:${属性:默认值},如果属性为null或者不存在的话,就是用默认值填充
@Value("#{test.username?:'默认的username'}")
private String userName;
@Value("#{test.password}")
private Integer password;
@Value("${username}")
private String userName;
@Value("${other.undefindValue}") // 直接使用属性名称输入
@Value("${xxxxx:other.undefindValue}") // 当xxxxx不存在时,使用other.undefindValue进行赋值
@Value("${xxxxx:123}") // 当xxxxx不存在时,使用123进行赋值
private Integer password;
@Value("${other.undefindValue}")
private String undefindValue;
// 申明bean需要使用的resource
@PropertySource("classpath:config.properties")
public class ClazzName{
// 获取resource
@Autowired private Environment environment;
/** 获取config配置文件 */
public String getStr(String key){
return environment.getProperty(key);
}
}