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; }
@Test public void testTemplateParserContext() { TemplateParserContext tpc = new TemplateParserContext("abc","def"); assertEquals("abc", tpc.getExpressionPrefix()); assertEquals("def", tpc.getExpressionSuffix()); assertTrue(tpc.isTemplate()); tpc = new TemplateParserContext(); assertEquals("#{", tpc.getExpressionPrefix()); assertEquals("}", tpc.getExpressionSuffix()); assertTrue(tpc.isTemplate()); ParserContext pc = ParserContext.TEMPLATE_EXPRESSION; assertEquals("#{", pc.getExpressionPrefix()); assertEquals("}", pc.getExpressionSuffix()); assertTrue(pc.isTemplate()); }
private Expression parseExpression() { // Support template parsing with #{ } delimiters ParserContext parserContext = new TemplateParserContext(); Expression expression = expressionParser.parseExpression(expressionString, parserContext); return expression; }
String randomPhrase = parser.parseExpression("random number is #{T(java.lang.Math).random()}", new TemplateParserContext()).getValue(String.class); // evaluates to "random number is 0.7038186818312008"
public SpelExpressionTemplateFactory(String expressionPrefix, char expressionSuffix) { this.expressionPrefix = expressionPrefix; this.templateParserContext = new TemplateParserContext(expressionPrefix, String.valueOf(expressionSuffix)); String quotedSuffix = Pattern.quote(String.valueOf(expressionSuffix)); this.singleExpressionPattern = Pattern.compile( Pattern.quote(expressionPrefix) + "([^" + quotedSuffix + "]+)" + quotedSuffix ); }
public String interpolate(String messageTemplate, Map<String, Object> variables) { Assert.notNull(messageTemplate, "messageTemplate must not be null"); try { Expression expression = parser().parseExpression(messageTemplate, new TemplateParserContext()); return expression.getValue(evalContext, variables, String.class); } catch (ExpressionException ex) { LOG.error("Failed to interpolate message template: {}", messageTemplate, ex); return ""; } }
public SpELStringTemplateCompiler() { parser = new SpelExpressionParser(); parserContext = new TemplateParserContext(); expressionCache = new ConcurrentHashMap<String, Expression>(); }
public SpringExpressionResolver(final String filePathPattern) { requireNonNull(filePathPattern, "log file path/name pattern must not be null"); final ExpressionParser parser = new SpelExpressionParser(); final TemplateParserContext parserContext = new TemplateParserContext("[", "]"); parser.parseExpression(filePathPattern, parserContext); expression = parser.parseExpression(filePathPattern, parserContext); }
@Override public String interpolate(final String template, final Map<String, Object> variables) { Assert.notNull(template, "messageTemplate must not be null"); String result; try { final Expression expression = parser().parseExpression(template, new TemplateParserContext()); result = expression.getValue(this.evalContext, variables, String.class); } catch (final ExpressionException ex) { result = "Failed to interpolate message template, error: " + ex.getMessage(); // TODO test this log.warn("Failed to interpolate message template: {}, variables: {}", template, variables, ex); } return result; }
@Override public String parse(String data, Map<String, Object> parameters) { ExpressionParser parser = new SpelExpressionParser(); Expression expr = parser.parseExpression(data, new TemplateParserContext()); EvaluationContext context = new StandardEvaluationContext(); for (Entry<String, Object> entry : parameters.entrySet()) { context.setVariable(entry.getKey(), entry.getValue()); } return expr.getValue(context, String.class); }
/** * Gets the translated message. * * @param event the event * @param node the node * @param msgFormat the message format * @return the translated message */ private String getTranslatedMessage(Event event, OnmsNode node, String msgFormat) { StandardEvaluationContext context = new StandardEvaluationContext(event); if (node != null) { context.setVariable("node", node); } ExpressionParser parser = new SpelExpressionParser(); Expression exp = parser.parseExpression(msgFormat, new TemplateParserContext("${", "}")); try { final String msg = (String) exp.getValue(context, String.class); LOG.debug("getTranslatedMessage: {} ==> {}", msgFormat, msg); return msg; } catch (Exception e) { LOG.warn("getTranslatedMessage: can't evaluate expression {} for alarm {} because: {}", msgFormat, event.getUei(), e.getMessage()); } return null; }
private Object evaluate (Object aValue, Context aContext) { StandardEvaluationContext context = createEvaluationContext(aContext); if(aValue instanceof String) { Expression expression = parser.parseExpression((String)aValue,new TemplateParserContext(PREFIX,SUFFIX)); try { return(expression.getValue(context)); } catch (SpelEvaluationException e) { logger.debug(e.getMessage()); return aValue; } } else if (aValue instanceof List) { List<Object> evaluatedlist = new ArrayList<>(); List<Object> list = (List<Object>) aValue; for(Object item : list) { evaluatedlist.add(evaluate(item, aContext)); } return evaluatedlist; } else if (aValue instanceof Map) { return evaluateInternal((Map<String, Object>) aValue, aContext); } return aValue; }
public SpelExpressionProcessor(PropertyResolver resolver) { SpelParserConfiguration configuration = new SpelParserConfiguration(true, true); parser = new SpelExpressionParser(configuration); templateContext = new TemplateParserContext(); context = new VariableEvaluationContext(resolver); }
private static final ExpressionParser PARSER = new SpelExpressionParser(); private static final TemplateParserContext TEMPLATE_PARSER_CONTEXT = new TemplateParserContext();
private String evaluateSpel(String in) { StandardEvaluationContext evalContext = new StandardEvaluationContext(); evalContext.setBeanResolver(new ThisBeanResolver(new BeanFactoryResolver(fact))); SpelExpressionParser parser = new SpelExpressionParser(); Expression expr = parser.parseExpression(in, new TemplateParserContext()); return expr.getValue(evalContext).toString(); }
public String doParse(SpelExpressionParser parser, EvaluationContext evaluationContext, boolean isCountQuery) { org.springframework.expression.Expression parsedExpression = parser.parseExpression(this.getStatement(), new TemplateParserContext()); if (isCountQuery) { evaluationContext.setVariable(SPEL_PREFIX, this.getCountContext()); } else { evaluationContext.setVariable(SPEL_PREFIX, this.getStatementContext()); } return parsedExpression.getValue(evaluationContext, String.class); }
public String doParse(SpelExpressionParser parser, EvaluationContext evaluationContext, boolean isCountQuery) { org.springframework.expression.Expression parsedExpression = parser.parseExpression(this.getStatement(), new TemplateParserContext()); if (isCountQuery) { evaluationContext.setVariable(SPEL_PREFIX, this.getCountContext()); } else { evaluationContext.setVariable(SPEL_PREFIX, this.getStatementContext()); } return parsedExpression.getValue(evaluationContext, String.class); }
TemplateParserContext parserContext = new TemplateParserContext();
TemplateParserContext parserContext = new TemplateParserContext();