Example usage for org.springframework.expression Expression getValue

List of usage examples for org.springframework.expression Expression getValue

  1. HOME
  2. Java
  3. org.springframework
  4. org.springframework.expression.*
  5. Expression
  6. getValue

Introduction

In this page you can find the example usage for org.springframework.expression Expression getValue.

Prototype

@Nullable
<T> T getValue(EvaluationContext context, Object rootObject, @Nullable Class<T> desiredResultType)
        throws EvaluationException;

Source Link

Document

Evaluate the expression in a specified context which can resolve references to properties, methods, types, etc.

Usage

From source file:org.gerzog.jstataggr.expressions.spel.SpelExpressionHandler.java

@SuppressWarnings("unchecked")
@Override/* w  ww .  j  a v a 2  s.  com*/
public <T> T invokeExpression(final String expression, final T originalValue) throws Exception {
    notNull(originalValue, "Context value cannot be null");
    notEmpty(expression, "Expression cannot be null or empty");

    final Expression parsedExpression = expressionParser.parseExpression(expression);

    return (T) parsedExpression.getValue(context, originalValue, originalValue.getClass());
}

From source file:cz.jirutka.spring.exhandler.interpolators.SpelMessageInterpolator.java

public String interpolate(String messageTemplate, Map<String, Object> variables) {
    Assert.notNull(messageTemplate, "messageTemplate must not be null");

    try {//from ww  w  . j  a  va 2  s . com
        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 "";
    }
}

From source file:com.google.code.activetemplates.impl.CompileContext.java

public <T> T parseExpression(String expression, Object rootObject, Class<T> clazz) {
    Expression expr = expressionParser.parseExpression(expression);
    return expr.getValue(getEvaluationContext(), rootObject, clazz);
}

From source file:org.ldaptive.beans.spring.SpringClassDescriptor.java

/** {@inheritDoc} */
@Override// www  . j  a v  a2s.  c  o  m
public void initialize(final Class<?> type) {
    // check for entry annotation
    final Entry entryAnnotation = AnnotationUtils.findAnnotation(type, Entry.class);
    if (entryAnnotation != null) {
        if (!entryAnnotation.dn().equals("")) {
            setDnValueMutator(new DnValueMutator() {
                @Override
                public String getValue(final Object object) {
                    final ExpressionParser parser = new SpelExpressionParser();
                    final Expression exp = parser.parseExpression(entryAnnotation.dn());
                    return exp.getValue(context, object, String.class);
                }

                @Override
                public void setValue(final Object object, final String value) {
                }
            });
        }
        for (final Attribute attr : entryAnnotation.attributes()) {
            final String expr = attr.property();
            final ExpressionParser parser = new SpelExpressionParser();
            final Expression exp = parser.parseExpression(expr);
            addAttributeValueMutator(new AttributeValueMutator() {
                @Override
                public String getName() {
                    return attr.name();
                }

                @Override
                public boolean isBinary() {
                    return attr.binary();
                }

                @Override
                public SortBehavior getSortBehavior() {
                    return attr.sortBehavior();
                }

                @Override
                public Collection<String> getStringValues(final Object object) {
                    @SuppressWarnings("unchecked")
                    final Collection<String> values = (Collection<String>) exp.getValue(context, object,
                            Collection.class);
                    return values;
                }

                @Override
                public Collection<byte[]> getBinaryValues(final Object object) {
                    @SuppressWarnings("unchecked")
                    final Collection<byte[]> values = (Collection<byte[]>) exp.getValue(context, object,
                            Collection.class);
                    return values;
                }

                @Override
                public void setStringValues(final Object object, final Collection<String> values) {
                    exp.setValue(context, object, values);
                }

                @Override
                public void setBinaryValues(final Object object, final Collection<byte[]> values) {
                    exp.setValue(context, object, values);
                }
            });
        }
    }
}

From source file:org.shredzone.commons.view.manager.ViewPattern.java

/**
 * Evaluates the given {@link EvaluationContext} and builds an URL to the appropriate
 * view./*  w  w w  .j a v  a  2 s . c o  m*/
 *
 * @param context
 *            {@link EvaluationContext} to be used
 * @param data
 *            {@link PathContext} containing all data required for building the URL
 * @return URL that was built, or {@code null} if the {@link PathContext} did not
 *         contain all necessary data for building the URL
 */
public String evaluate(EvaluationContext context, PathContext data) {
    StringBuilder sb = new StringBuilder();
    for (Expression expr : expression) {
        String value = expr.getValue(context, data, String.class);
        if (value == null) {
            // A part resolved to null, so this ViewPattern is unable
            // to build a path from the given PathData.
            return null;
        }
        sb.append(value);
    }

    // Remove ugly double slashes
    int pos;
    while ((pos = sb.indexOf("//")) >= 0) {
        sb.deleteCharAt(pos);
    }

    return sb.toString();
}

From source file:guru.qas.martini.DefaultMixologist.java

protected Collection<Martini> getMartinis(Expression expression) {
    StandardEvaluationContext context = new StandardEvaluationContext();
    List<MethodResolver> methodResolvers = context.getMethodResolvers();
    ArrayList<MethodResolver> modifiedList = Lists.newArrayList(methodResolvers);
    modifiedList.add(new TagResolver(this.context, categories));
    context.setMethodResolvers(modifiedList);

    ImmutableList<Martini> martinis = getMartinis();
    List<Martini> matches = Lists.newArrayListWithCapacity(martinis.size());
    for (Martini martini : martinis) {
        Boolean match = expression.getValue(context, martini, Boolean.class);
        if (null != match && match) {
            matches.add(martini);/*from www .j a v a2 s  .co m*/
        }
    }
    return matches;
}

From source file:org.springframework.cloud.gateway.discovery.DiscoveryClientRouteDefinitionLocator.java

@Override
public Flux<RouteDefinition> getRouteDefinitions() {

    SpelExpressionParser parser = new SpelExpressionParser();
    Expression includeExpr = parser.parseExpression(properties.getIncludeExpression());
    Expression urlExpr = parser.parseExpression(properties.getUrlExpression());

    Predicate<ServiceInstance> includePredicate;
    if (properties.getIncludeExpression() == null
            || "true".equalsIgnoreCase(properties.getIncludeExpression())) {
        includePredicate = instance -> true;
    } else {/*  w  w w . j  a v a2  s. c  o m*/
        includePredicate = instance -> {
            Boolean include = includeExpr.getValue(evalCtxt, instance, Boolean.class);
            if (include == null) {
                return false;
            }
            return include;
        };
    }

    return Flux.fromIterable(discoveryClient.getServices()).map(discoveryClient::getInstances)
            .filter(instances -> !instances.isEmpty()).map(instances -> instances.get(0))
            .filter(includePredicate).map(instance -> {
                String serviceId = instance.getServiceId();

                RouteDefinition routeDefinition = new RouteDefinition();
                routeDefinition.setId(this.routeIdPrefix + serviceId);
                String uri = urlExpr.getValue(evalCtxt, instance, String.class);
                routeDefinition.setUri(URI.create(uri));

                final ServiceInstance instanceForEval = new DelegatingServiceInstance(instance, properties);

                for (PredicateDefinition original : this.properties.getPredicates()) {
                    PredicateDefinition predicate = new PredicateDefinition();
                    predicate.setName(original.getName());
                    for (Map.Entry<String, String> entry : original.getArgs().entrySet()) {
                        String value = getValueFromExpr(evalCtxt, parser, instanceForEval, entry);
                        predicate.addArg(entry.getKey(), value);
                    }
                    routeDefinition.getPredicates().add(predicate);
                }

                for (FilterDefinition original : this.properties.getFilters()) {
                    FilterDefinition filter = new FilterDefinition();
                    filter.setName(original.getName());
                    for (Map.Entry<String, String> entry : original.getArgs().entrySet()) {
                        String value = getValueFromExpr(evalCtxt, parser, instanceForEval, entry);
                        filter.addArg(entry.getKey(), value);
                    }
                    routeDefinition.getFilters().add(filter);
                }

                return routeDefinition;
            });
}

From source file:org.springframework.cloud.gateway.discovery.DiscoveryClientRouteDefinitionLocator.java

String getValueFromExpr(SimpleEvaluationContext evalCtxt, SpelExpressionParser parser, ServiceInstance instance,
        Map.Entry<String, String> entry) {
    try {//from  w  ww .j  a  v  a  2  s  . co m
        Expression valueExpr = parser.parseExpression(entry.getValue());
        return valueExpr.getValue(evalCtxt, instance, String.class);
    } catch (ParseException | EvaluationException e) {
        if (log.isDebugEnabled()) {
            log.debug("Unable to parse " + entry.getValue(), e);
        }
        throw e;
    }
}

From source file:org.springframework.integration.util.AbstractExpressionEvaluator.java

protected <T> T evaluateExpression(Expression expression, Object input, Class<T> expectedType) {
    return expression.getValue(this.getEvaluationContext(), input, expectedType);
}