Java BeanExpressionContext类代码示例

import org.springframework.beans.factory.config.BeanExpressionContext; //导入依赖的package包/类
@Test
public void testExpressionInStringArray() {
	DefaultListableBeanFactory bf = new DefaultListableBeanFactory();
	BeanExpressionResolver beanExpressionResolver = mock(BeanExpressionResolver.class);
	when(beanExpressionResolver.evaluate(eq("#{foo}"), Matchers.any(BeanExpressionContext.class)))
			.thenReturn("classpath:/org/springframework/beans/factory/xml/util.properties");
	bf.setBeanExpressionResolver(beanExpressionResolver);

	RootBeanDefinition rbd = new RootBeanDefinition(PropertiesFactoryBean.class);
	MutablePropertyValues pvs = new MutablePropertyValues();
	pvs.add("locations", new String[]{"#{foo}"});
	rbd.setPropertyValues(pvs);
	bf.registerBeanDefinition("myProperties", rbd);
	Properties properties = (Properties) bf.getBean("myProperties");
	assertEquals("bar", properties.getProperty("foo"));
}
 

import org.springframework.beans.factory.config.BeanExpressionContext; //导入依赖的package包/类
/**
 * Retrieves the service url.
 *
 * @return the service url
 */
private String getServiceUrl() {

    try {
        if (!serviceUrl.isEmpty()) {

            ConfigurableBeanFactory beanFactory = getBeanFactory();
            if(beanFactory != null) {
                return (String) beanFactory.getBeanExpressionResolver()
                        .evaluate(serviceUrl, new BeanExpressionContext(beanFactory, null));
            }
            return serviceUrl;
        }

        return applicationContext.getBean(serviceUrlProvider)
                .getServiceUrl();
    } catch (BeansException e) {
        throw new IllegalStateException("The service url hasn't been specified and " +
                "no ServiceUrlProvider has been registered in application context.", e);
    }
}
 

import org.springframework.beans.factory.config.BeanExpressionContext; //导入依赖的package包/类
private Object resolveValue(Method method) {
    Value val = AnnotationUtils.findAnnotation(method, Value.class);
    if (val != null) {
        if (LOG.isDebugEnabled()) {
            LOG.debug(String.format("Resolving @Value annotation on %s with key %s",
                    method.getName(), val.value()));
        }
        ConfigurableBeanFactory beanFactory = (ConfigurableBeanFactory) getBeanFactory();
        String strValue = beanFactory.resolveEmbeddedValue(val.value());
        BeanExpressionResolver resolver = beanFactory.getBeanExpressionResolver();

        Object unconvertedResult = resolver.evaluate(strValue, new BeanExpressionContext(beanFactory, null));
        TypeConverter converter = beanFactory.getTypeConverter();
        return converter.convertIfNecessary(unconvertedResult, method.getReturnType());
    }
    String message = "Method %s on interface %s must be annotated with @Value for auto-properties to work!";
    throw new AutoPropertiesException(String.format(message, method.getName(), method.getDeclaringClass().getName()));
}
 

import org.springframework.beans.factory.config.BeanExpressionContext; //导入依赖的package包/类
private Map<String, Object> buildExportProperties() {
	Map<String, Object> props = new HashMap<>();
	if (!ObjectUtils.isEmpty(this.properties)) {
		Map<String, String> target = bindProperties();

		BeanExpressionResolver beanExpressionResolver = ((ConfigurableApplicationContext) applicationContext)
				.getBeanFactory().getBeanExpressionResolver();
		BeanExpressionContext expressionContext = new BeanExpressionContext(
				((ConfigurableApplicationContext) applicationContext).getBeanFactory(), null);
		for (Entry<String, String> entry : target.entrySet()) {
			if (isMatch(entry.getKey(), this.properties, null)) {
				String stringValue = ObjectUtils.nullSafeToString(entry.getValue());
				Object exportedValue = null;
				if (stringValue != null) {
					exportedValue = stringValue.startsWith("#{")
							? beanExpressionResolver.evaluate(
									environment.resolvePlaceholders(stringValue), expressionContext)
							: environment.resolvePlaceholders(stringValue);
				}

				props.put(entry.getKey(), exportedValue);
			}
		}
	}
	return props;
}
 

import org.springframework.beans.factory.config.BeanExpressionContext; //导入依赖的package包/类
private String[] resolveName(String name) {
    if (!(getApplicationContext() instanceof ConfigurableApplicationContext)) {
        return wrapInStringArray(name);
    }

    ConfigurableApplicationContext applicationContext = (ConfigurableApplicationContext) getApplicationContext();
    ConfigurableBeanFactory configurableBeanFactory = applicationContext.getBeanFactory();

    String placeholdersResolved = configurableBeanFactory.resolveEmbeddedValue(name);
    BeanExpressionResolver exprResolver = configurableBeanFactory.getBeanExpressionResolver();
    if (exprResolver == null) {
        return wrapInStringArray(name);
    }
    Object result = exprResolver.evaluate(placeholdersResolved, new BeanExpressionContext(configurableBeanFactory, null));
    if (result instanceof String[]) {
        return (String[]) result;
    } else if (result != null) {
        return wrapInStringArray(result);
    } else {
        return wrapInStringArray(name);
    }
}
 

import org.springframework.beans.factory.config.BeanExpressionContext; //导入依赖的package包/类
@Override
public void setBeanFactory(final BeanFactory beanFactory) throws BeansException
{
    this.beanFactory = beanFactory;
    if (beanFactory instanceof ConfigurableListableBeanFactory)
    {
        this.resolver = ((ConfigurableListableBeanFactory) beanFactory).getBeanExpressionResolver();
        this.expressionContext = new BeanExpressionContext((ConfigurableListableBeanFactory) beanFactory, null);
    }
}
 

import org.springframework.beans.factory.config.BeanExpressionContext; //导入依赖的package包/类
@Override
public void setBeanFactory(BeanFactory beanFactory) {
	if (beanFactory instanceof ConfigurableBeanFactory) {
		this.beanFactory = (ConfigurableBeanFactory) beanFactory;
		this.expressionContext = new BeanExpressionContext(this.beanFactory, new RequestScope());
	}
}
 

import org.springframework.beans.factory.config.BeanExpressionContext; //导入依赖的package包/类
/**
 * Returns a property value for the bean with the given name from the dictionary.
 *
 * @param beanName id or name for the bean definition
 * @param propertyName name of the property to retrieve, must be a valid property configured on
 * the bean definition
 * @return Object property value for property
 */
public Object getDictionaryBeanProperty(String beanName, String propertyName) {
    Object bean = ddBeans.getSingleton(beanName);
    if (bean != null) {
        return ObjectPropertyUtils.getPropertyValue(bean, propertyName);
    }

    BeanDefinition beanDefinition = ddBeans.getMergedBeanDefinition(beanName);

    if (beanDefinition == null) {
        throw new RuntimeException("Unable to get bean for bean name: " + beanName);
    }

    PropertyValues pvs = beanDefinition.getPropertyValues();
    if (pvs.contains(propertyName)) {
        PropertyValue propertyValue = pvs.getPropertyValue(propertyName);

        Object value;
        if (propertyValue.isConverted()) {
            value = propertyValue.getConvertedValue();
        } else if (propertyValue.getValue() instanceof String) {
            String unconvertedValue = (String) propertyValue.getValue();
            Scope scope = ddBeans.getRegisteredScope(beanDefinition.getScope());
            BeanExpressionContext beanExpressionContext = new BeanExpressionContext(ddBeans, scope);

            value = ddBeans.getBeanExpressionResolver().evaluate(unconvertedValue, beanExpressionContext);
        } else {
            value = propertyValue.getValue();
        }

        return value;
    }

    return null;
}
 

import org.springframework.beans.factory.config.BeanExpressionContext; //导入依赖的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);
	}
}
 

import org.springframework.beans.factory.config.BeanExpressionContext; //导入依赖的package包/类
@Override
public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
    this.beanFactory = (ConfigurableBeanFactory) beanFactory;
    resolver = this.beanFactory.getBeanExpressionResolver();
    expressionContext = new BeanExpressionContext(this.beanFactory, null);
    typeConverter = this.beanFactory.getTypeConverter();
}
 

import org.springframework.beans.factory.config.BeanExpressionContext; //导入依赖的package包/类
public void setBeanFactory(BeanFactory beanFactory) {
	if (beanFactory instanceof ConfigurableBeanFactory) {
		this.beanFactory = (ConfigurableBeanFactory) beanFactory;
		this.expressionContext = new BeanExpressionContext(
				this.beanFactory, new RequestScope());
	}
}
 

import org.springframework.beans.factory.config.BeanExpressionContext; //导入依赖的package包/类
@Test
public void testGetUserProperties() throws Exception {

    Assert.assertEquals("tagv1", this.context.getBeanFactory().getBeanExpressionResolver().
            evaluate("#{instanceData['tag1']}", new BeanExpressionContext(this.context.getBeanFactory(), null)));
    Assert.assertEquals("tagv2", this.context.getBeanFactory().getBeanExpressionResolver().
            evaluate("#{instanceData['tag2']}", new BeanExpressionContext(this.context.getBeanFactory(), null)));
    Assert.assertEquals("tagv3", this.context.getBeanFactory().getBeanExpressionResolver().
            evaluate("#{instanceData['tag3']}", new BeanExpressionContext(this.context.getBeanFactory(), null)));
    Assert.assertEquals("tagv4", this.context.getBeanFactory().getBeanExpressionResolver().
            evaluate("#{instanceData['tag4']}", new BeanExpressionContext(this.context.getBeanFactory(), null)));
}
 

import org.springframework.beans.factory.config.BeanExpressionContext; //导入依赖的package包/类
private String resolveName(String name) {
    if (!(this.beanFactory instanceof ConfigurableBeanFactory)) {
        return name;
    }

    ConfigurableBeanFactory configurableBeanFactory = (ConfigurableBeanFactory) this.beanFactory;

    String placeholdersResolved = configurableBeanFactory.resolveEmbeddedValue(name);
    BeanExpressionResolver exprResolver = configurableBeanFactory.getBeanExpressionResolver();
    if (exprResolver == null) {
        return name;
    }
    Object result = exprResolver.evaluate(placeholdersResolved, new BeanExpressionContext(configurableBeanFactory, null));
    return result != null ? result.toString() : name;
}
 

import org.springframework.beans.factory.config.BeanExpressionContext; //导入依赖的package包/类
@Override
public boolean canRead(EvaluationContext context, Object target, String name) throws AccessException {
	return ((BeanExpressionContext) target).containsObject(name);
}
 

import org.springframework.beans.factory.config.BeanExpressionContext; //导入依赖的package包/类
@Override
public TypedValue read(EvaluationContext context, Object target, String name) throws AccessException {
	return new TypedValue(((BeanExpressionContext) target).getObject(name));
}