@Override public void setBeanFactory(BeanFactory beanFactory) throws BeansException { this.beanFactory = beanFactory; this.evaluationContext.setBeanResolver(new BeanFactoryResolver(beanFactory)); }
@Override public void setBeanFactory(BeanFactory beanFactory) throws BeansException { this.evaluationContext.setBeanResolver(new BeanFactoryResolver(beanFactory)); }
static Object getValue(SpelExpressionParser parser, BeanFactory beanFactory, String entryValue) { Object value; String rawValue = entryValue; if (rawValue != null) { rawValue = rawValue.trim(); } if (rawValue != null && rawValue.startsWith("#{") && entryValue.endsWith("}")) { // assume it's spel StandardEvaluationContext context = new StandardEvaluationContext(); context.setBeanResolver(new BeanFactoryResolver(beanFactory)); Expression expression = parser.parseExpression(entryValue, new TemplateParserContext()); value = expression.getValue(context); } else { value = entryValue; } return value; }
/** * Invokes the internal template methods to create {@code StandardEvaluationContext} * and {@code SecurityExpressionRoot} objects. * * @param authentication the current authentication object * @param invocation the invocation (filter, method, channel) * @return the context object for use in evaluating the expression, populated with a * suitable root object. */ public final EvaluationContext createEvaluationContext(Authentication authentication, T invocation) { SecurityExpressionOperations root = createSecurityExpressionRoot(authentication, invocation); StandardEvaluationContext ctx = createEvaluationContextInternal(authentication, invocation); ctx.setBeanResolver(br); ctx.setRootObject(root); return ctx; }
@Test public void invokeMethodWithoutConversion() throws Exception { final BytesService service = new BytesService(); byte[] bytes = new byte[100]; StandardEvaluationContext context = new StandardEvaluationContext(bytes); context.setBeanResolver(new BeanResolver() { @Override public Object resolve(EvaluationContext context, String beanName) throws AccessException { if ("service".equals(beanName)) { return service; } return null; } }); Expression expression = parser.parseExpression("@service.handleBytes(#root)"); byte[] outBytes = expression.getValue(context, byte[].class); assertSame(bytes, outBytes); }
/** * Invokes the internal template methods to create {@code StandardEvaluationContext} * and {@code SecurityExpressionRoot} objects. * * @param authentication the current authentication object * @param invocation the invocation (filter, method, channel) * @return the context object for use in evaluating the expression, populated with a * suitable root object. */ public final EvaluationContext createEvaluationContext(Authentication authentication, T invocation) { SecurityExpressionOperations root = createSecurityExpressionRoot(authentication, invocation); StandardEvaluationContext ctx = createEvaluationContextInternal(authentication, invocation); ctx.setBeanResolver(br); ctx.setRootObject(root); return ctx; }
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();
public Set<IndexedData> resolveIndexesFor(TypeInformation<?> typeInformation, @Nullable Object value) { if (value == null) { return Collections.emptySet(); } RedisPersistentEntity<?> entity = mappingContext.getPersistentEntity(typeInformation); if (entity == null) { return Collections.emptySet(); } String keyspace = entity.getKeySpace(); Set<IndexedData> indexes = new HashSet<>(); for (IndexDefinition setting : settings.getIndexDefinitionsFor(keyspace)) { if (setting instanceof SpelIndexDefinition) { Expression expression = getAndCacheIfAbsent((SpelIndexDefinition) setting); StandardEvaluationContext context = new StandardEvaluationContext(); context.setRootObject(value); context.setVariable("this", value); if (beanResolver != null) { context.setBeanResolver(beanResolver); } Object index = expression.getValue(context); if (index != null) { indexes.add(new SimpleIndexedPropertyValue(keyspace, setting.getIndexName(), index)); } } } return indexes; }
@Test public void SPR11445_beanReference() { StandardEvaluationContext context = new StandardEvaluationContext(); context.setBeanResolver(new Spr11445Class()); Expression expr = new SpelExpressionParser().parseRaw("@bean.echo(@bean.parameter())"); assertEquals(1, expr.getValue(context)); }
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();
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; }
@Test public void factoryBeanAccess() { // SPR9511 StandardEvaluationContext context = new StandardEvaluationContext(); context.setBeanResolver(new SimpleBeanResolver()); Expression expr = new SpelExpressionParser().parseRaw("@car.colour"); assertEquals("red", expr.getValue(context));
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; }
context.setBeanResolver(new MyBeanResolver());
@Test public void AccessingFactoryBean_spr9511() { StandardEvaluationContext context = new StandardEvaluationContext(); context.setBeanResolver(new MyBeanResolver()); Expression expr = new SpelExpressionParser().parseRaw("@foo"); assertEquals("custard", expr.getValue(context)); expr = new SpelExpressionParser().parseRaw("&foo"); assertEquals("foo factory",expr.getValue(context)); try { expr = new SpelExpressionParser().parseRaw("&@foo"); fail("Illegal syntax, error expected"); } catch (SpelParseException spe) { assertEquals(SpelMessage.INVALID_BEAN_REFERENCE,spe.getMessageCode()); assertEquals(0,spe.getPosition()); } try { expr = new SpelExpressionParser().parseRaw("@&foo"); fail("Illegal syntax, error expected"); } catch (SpelParseException spe) { assertEquals(SpelMessage.INVALID_BEAN_REFERENCE,spe.getMessageCode()); assertEquals(0,spe.getPosition()); } }
ctx.setBeanResolver(new MyBeanResolver()); expectFailNotAssignable(parser, ctx, "@foo++"); expectFailNotAssignable(parser, ctx, "--@foo");
/** * Specify a BeanFactory in order to enable resolution via <code>@beanName</code> in the expression. */ @Override public void setBeanFactory(final @Nullable BeanFactory beanFactory) { if (beanFactory != null) { this.beanFactory = beanFactory; this.typeConverter.setBeanFactory(beanFactory); if (this.evaluationContext != null && this.evaluationContext.getBeanResolver() == null) { this.evaluationContext.setBeanResolver(new BeanFactoryResolver(beanFactory)); } } }
private EvaluationContext createEvaluationContext(Exchange exchange) { StandardEvaluationContext evaluationContext = new StandardEvaluationContext(new RootObject(exchange)); if (beanResolver != null) { evaluationContext.setBeanResolver(beanResolver); } else if (exchange.getContext() instanceof SpringCamelContext) { // Support references (like @foo) in expressions to beans defined in the Registry/ApplicationContext ApplicationContext applicationContext = ((SpringCamelContext) exchange.getContext()).getApplicationContext(); evaluationContext.setBeanResolver(new BeanFactoryResolver(applicationContext)); } else { evaluationContext.setBeanResolver(new RegistryBeanResolver(exchange.getContext().getRegistry())); } return evaluationContext; }
/** * Set a bean resolver for runtime SpEL expressions. Also configures the evaluation * context with a standard type converter and map accessor. * @param beanResolver the resolver. * @since 2.0 */ public void setBeanResolver(BeanResolver beanResolver) { this.evaluationContext.setBeanResolver(beanResolver); this.evaluationContext.setTypeConverter(new StandardTypeConverter()); this.evaluationContext.addPropertyAccessor(new MapAccessor()); }
@Override public StandardEvaluationContext getObject() throws Exception { StandardEvaluationContext evaluationContext = new StandardEvaluationContext(); if (this.typeLocator != null) { evaluationContext.setTypeLocator(this.typeLocator); } evaluationContext.setBeanResolver(this.beanResolver); evaluationContext.setTypeConverter(getTypeConverter()); for (PropertyAccessor propertyAccessor : getPropertyAccessors().values()) { evaluationContext.addPropertyAccessor(propertyAccessor); } evaluationContext.addPropertyAccessor(new MapAccessor()); for (Entry<String, Method> functionEntry : getFunctions().entrySet()) { evaluationContext.registerFunction(functionEntry.getKey(), functionEntry.getValue()); } return evaluationContext; }