import org.springframework.expression.spel.support.StandardTypeConverter; //导入依赖的package包/类
@Test
public void testConvertAndHandleNull() { // SPR-9445
	// without null conversion
	evaluateAndCheckError("null or true", SpelMessage.TYPE_CONVERSION_ERROR, 0, "null", "boolean");
	evaluateAndCheckError("null and true", SpelMessage.TYPE_CONVERSION_ERROR, 0, "null", "boolean");
	evaluateAndCheckError("!null", SpelMessage.TYPE_CONVERSION_ERROR, 1, "null", "boolean");
	evaluateAndCheckError("null ? 'foo' : 'bar'", SpelMessage.TYPE_CONVERSION_ERROR, 0, "null", "boolean");

	// with null conversion (null -> false)
	GenericConversionService conversionService = new GenericConversionService() {
		@Override
		protected Object convertNullSource(TypeDescriptor sourceType, TypeDescriptor targetType) {
			return targetType.getType() == Boolean.class ? false : null;
		}
	};
	eContext.setTypeConverter(new StandardTypeConverter(conversionService));

	evaluate("null or true", Boolean.TRUE, Boolean.class, false);
	evaluate("null and true", Boolean.FALSE, Boolean.class, false);
	evaluate("!null", Boolean.TRUE, Boolean.class, false);
	evaluate("null ? 'foo' : 'bar'", "bar", String.class, false);
}
 

import org.springframework.expression.spel.support.StandardTypeConverter; //导入依赖的package包/类
private void registerConversionServiceInSpelExpressions(Expression parsedExpression) {
  if (conversionService == null) {
    return;
  }
  StandardTypeConverter converter = new StandardTypeConverter(conversionService);
  StandardEvaluationContext context = new StandardEvaluationContext();
  context.setTypeConverter(converter);
  setContextIfSpelExpression(parsedExpression, context);

  if (parsedExpression instanceof CompositeStringExpression) {
    CompositeStringExpression composite = (CompositeStringExpression) parsedExpression;
    for (Expression childExpresion : composite.getExpressions()) {
      setContextIfSpelExpression(childExpresion, context);
    }
  }
}
 

import org.springframework.expression.spel.support.StandardTypeConverter; //导入依赖的package包/类
public CoreMappingEvaluationContext(Object root) {
	super(root);
	try {
		// Add functions for use in the mapping expressions.
		registerFunction("substring", StringUtils.class.getMethod("substring", String.class, int.class, int.class));
		registerFunction("upperCase", StringUtils.class.getMethod("upperCase", String.class));
		registerFunction("leftPad", StringUtils.class.getMethod("leftPad", String.class, int.class, String.class));
		registerFunction("rightPad", StringUtils.class.getMethod("rightPad", String.class, int.class, String.class));
		registerFunction("trim", StringUtils.class.getMethod("trim", String.class));
		registerFunction("capitalize", WordUtils.class.getMethod("capitalizeFully", String.class));
		registerFunction("isBlank", StringUtils.class.getMethod("isBlank", CharSequence.class));
		registerFunction("split", StringUtils.class.getMethod("split", String.class, char.class));
		registerFunction("join", StringUtils.class.getMethod("join", Object[].class, char.class));
		registerFunction("toBoolean", BooleanUtils.class.getMethod("toBoolean", String.class));

		DefaultFormattingConversionService conversionService = new DefaultFormattingConversionService();
		conversionService.addFormatterForFieldType(Date.class, new DateFormatter("MM/dd/yyyy"));
		setTypeConverter(new StandardTypeConverter(conversionService));
	} catch (Exception e) {
		throw new RuntimeException(e);
	}
}
 

import org.springframework.expression.spel.support.StandardTypeConverter; //导入依赖的package包/类
private EvaluationContext createEvaluationContext(PageContext pageContext) {
	StandardEvaluationContext context = new StandardEvaluationContext();
	context.addPropertyAccessor(new JspPropertyAccessor(pageContext));
	context.addPropertyAccessor(new MapAccessor());
	context.addPropertyAccessor(new EnvironmentAccessor());
	context.setBeanResolver(new BeanFactoryResolver(getRequestContext().getWebApplicationContext()));
	ConversionService conversionService = getConversionService(pageContext);
	if (conversionService != null) {
		context.setTypeConverter(new StandardTypeConverter(conversionService));
	}
	return context;
}
 

import org.springframework.expression.spel.support.StandardTypeConverter; //导入依赖的package包/类
@Test
public void test_binaryPlusWithTimeConverted() {

	final SimpleDateFormat format = new SimpleDateFormat("hh :--: mm :--: ss", Locale.ENGLISH);

	GenericConversionService conversionService = new GenericConversionService();
	conversionService.addConverter(new Converter<Time, String>() {
		@Override
		public String convert(Time source) {
			return format.format(source);
		}
	});

	StandardEvaluationContext evaluationContextConverter = new StandardEvaluationContext();
	evaluationContextConverter.setTypeConverter(new StandardTypeConverter(conversionService));

	ExpressionState expressionState = new ExpressionState(evaluationContextConverter);

	Time time = new Time(new Date().getTime());

	VariableReference var = new VariableReference("timeVar", -1);
	var.setValue(expressionState, time);

	StringLiteral n2 = new StringLiteral("\" is now\"", -1, "\" is now\"");
	OpPlus o = new OpPlus(-1, var, n2);
	TypedValue value = o.getValueInternal(expressionState);

	assertEquals(String.class, value.getTypeDescriptor().getObjectType());
	assertEquals(String.class, value.getTypeDescriptor().getType());
	assertEquals(format.format(time) + " is now", value.getValue());
}
 

import org.springframework.expression.spel.support.StandardTypeConverter; //导入依赖的package包/类
public Object evaluate(String value, BeanExpressionContext evalContext) throws BeansException {
	if (!StringUtils.hasLength(value)) {
		return value;
	}
	try {
		Expression expr = this.expressionCache.get(value);
		if (expr == null) {
			expr = this.expressionParser.parseExpression(value, this.beanExpressionParserContext);
			this.expressionCache.put(value, expr);
		}
		StandardEvaluationContext sec = this.evaluationCache.get(evalContext);
		if (sec == null) {
			sec = new StandardEvaluationContext();
			sec.setRootObject(evalContext);
			sec.addPropertyAccessor(new BeanExpressionContextAccessor());
			sec.addPropertyAccessor(new BeanFactoryAccessor());
			sec.addPropertyAccessor(new MapAccessor());
			sec.addPropertyAccessor(new EnvironmentAccessor());
			sec.setBeanResolver(new BeanFactoryResolver(evalContext.getBeanFactory()));
			sec.setTypeLocator(new StandardTypeLocator(evalContext.getBeanFactory().getBeanClassLoader()));
			ConversionService conversionService = evalContext.getBeanFactory().getConversionService();
			if (conversionService != null) {
				sec.setTypeConverter(new StandardTypeConverter(conversionService));
			}
			customizeEvaluationContext(sec);
			this.evaluationCache.put(evalContext, sec);
		}
		return expr.getValue(sec);
	}
	catch (Exception ex) {
		throw new BeanExpressionException("Expression parsing failed", ex);
	}
}