Package org.springframework.expression

Examples of org.springframework.expression.Expression

172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
    assertTrue((Boolean) expression.getValue(context));
  }

  @Test
  public void testReEvaluationWithDifferentRoot() throws Exception {
    Expression expression = handler.getExpressionParser().parseExpression("#oauth2.isClient()");
    MethodInvocation invocation = new SimpleMethodInvocation(this, ReflectionUtils.findMethod(getClass(),
        "testNonOauthClient"));
    Authentication clientAuthentication = new UsernamePasswordAuthenticationToken("foo", "bar");
    EvaluationContext context = handler.createEvaluationContext(clientAuthentication, invocation);
    assertFalse((Boolean) expression.getValue(context));

    OAuth2Request storedOAuth2Request = RequestTokenFactory.createOAuth2Request("foo", true,
        Collections.singleton("read"));

    OAuth2Authentication oAuth2Authentication = new OAuth2Authentication(storedOAuth2Request, null);
    EvaluationContext anotherContext = handler.createEvaluationContext(oAuth2Authentication, invocation);
    assertTrue((Boolean) expression.getValue(anotherContext));
  }
View Full Code Here
540
541
542
543
544
545
546
547
548
549
550
551
  public static Boolean evaluateExpression(Object obj, String expression) {
    if (StringUtil.isEmpty(expression))
      return false;
    try {
      ExpressionParser parser = new SpelExpressionParser();
      Expression exp = parser.parseExpression(expression);
      return exp.getValue(obj, Boolean.class);    
    } catch (Exception e) {
      _log.debug("Failed to evaluate expression ["+expression+"] for object ["+obj.getClass()+"].");
      _log.debug(e.getMessage());
      return false;
    }
View Full Code Here
29
30
31
32
33
34
35
36
37
38
39
40
    }

    public PreInvocationAttribute createPreInvocationAttribute(PreFilter preFilter, PreAuthorize preAuthorize) {
        try {
         // TODO: Optimization of permitAll
            Expression preAuthorizeExpression = preAuthorize == null ? parser.parseExpression("permitAll") : parser.parseExpression(preAuthorize.value());
            Expression preFilterExpression = preFilter == null ? null : parser.parseExpression(preFilter.value());
            String filterObject = preFilter == null ? null : preFilter.filterTarget();
            return new PreInvocationExpressionAttribute(preFilterExpression, filterObject, preAuthorizeExpression);
        } catch (ParseException e) {
            throw new IllegalArgumentException("Failed to parse expression '" + e.getExpressionString() + "'", e);
        }
View Full Code Here
40
41
42
43
44
45
46
47
48
49
50
51
        }
    }

    public PostInvocationAttribute createPostInvocationAttribute(PostFilter postFilter, PostAuthorize postAuthorize) {
        try {
            Expression postAuthorizeExpression = postAuthorize == null ? null : parser.parseExpression(postAuthorize.value());
            Expression postFilterExpression = postFilter == null ? null : parser.parseExpression(postFilter.value());

            if (postFilterExpression != null || postAuthorizeExpression != null) {
                return new PostInvocationExpressionAttribute(postFilterExpression, postAuthorizeExpression);
            }
        } catch (ParseException e) {
View Full Code Here
55
56
57
58
59
60
61
62
63
64
65
    private int authorizeUsingAccessExpression(Authentication currentUser) throws JspException {
        // Get web expression
        WebSecurityExpressionHandler handler = getExpressionHandler();

        Expression accessExpression;
        try {
            accessExpression = handler.getExpressionParser().parseExpression(access);

        } catch (ParseException e) {
            throw new JspException(e);
View Full Code Here
23
24
25
26
27
28
29
30
31
32
33
34
    private MethodSecurityExpressionHandler expressionHandler = new DefaultMethodSecurityExpressionHandler();

    public boolean before(Authentication authentication, MethodInvocation mi, PreInvocationAttribute attr) {
        PreInvocationExpressionAttribute preAttr = (PreInvocationExpressionAttribute) attr;
        EvaluationContext ctx = expressionHandler.createEvaluationContext(authentication, mi);
        Expression preFilter = preAttr.getFilterExpression();
        Expression preAuthorize = preAttr.getAuthorizeExpression();

        if (preFilter != null) {
            Object filterTarget = findFilterTarget(preAttr.getFilterTarget(), ctx, mi);

            expressionHandler.filter(filterTarget, preFilter, ctx);
View Full Code Here
27
28
29
30
31
32
33
34
35
36
37
38
    public Object after(Authentication authentication, MethodInvocation mi,
            PostInvocationAttribute postAttr, Object returnedObject) throws AccessDeniedException{
        PostInvocationExpressionAttribute pia = (PostInvocationExpressionAttribute) postAttr;
        EvaluationContext ctx = expressionHandler.createEvaluationContext(authentication, mi);
        Expression postFilter = pia.getFilterExpression();
        Expression postAuthorize = pia.getAuthorizeExpression();

        if (postFilter != null) {
            if (logger.isDebugEnabled()) {
                logger.debug("Applying PostFilter expression " + postFilter);
            }
View Full Code Here
145
146
147
148
149
150
151
152
153
154
155
    private String getId(Synchronized annotation, Method method, EvaluationContext context) {
        return parseIdExpression(method, annotation).getValue(context, String.class);
    }

    private Expression parseConditionExpression(Method method, Synchronized annotation) {
        Expression expression = conditionCache.get(method);
        if (expression == null) {
            expression = parser.parseExpression(annotation.condition());
            conditionCache.put(method, expression);
        }
        return expression;
View Full Code Here
154
155
156
157
158
159
160
161
162
163
164
        }
        return expression;
    }

    private Expression parseDiscriminatorExpression(Method method, Synchronized annotation) {
        Expression expression = discriminatorCache.get(method);
        if (expression == null) {
            expression = parser.parseExpression(annotation.discriminator());
            discriminatorCache.put(method, expression);
        }
        return expression;
View Full Code Here
163
164
165
166
167
168
169
170
171
172
173
        }
        return expression;
    }

    private Expression parseIdExpression(Method method, Synchronized annotation) {
        Expression expression = idCache.get(method);
        if (expression == null) {
            expression = parser.parseExpression(annotation.id());
            idCache.put(method, expression);
        }
        return expression;
View Full Code Here
TOP

Related Classes of org.springframework.expression.Expression

  • com.apress.pss.webflow.security.StateExpressionVoter
  • com.foreach.cuke.core.util.MapChecker
  • com.github.overengineer.scope.conversation.expression.eval.Spel
  • com.narirelays.ems.applogic.PrivilegeManagement
  • com.narirelays.ems.applogic.SpreadsheetManagement
  • com.narirelays.ems.struts2.actions.security.AccountManagement
  • com.ontology2.haruhi.flows.AssignmentStep
  • com.ontology2.haruhi.flows.SpringStep
  • grails.plugin.cache.web.filter.ExpressionEvaluator
  • net.gprussell.spel.ArgumentConversionTest
    • Copyright © 2018 www.massapicom. All rights reserved.
    All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.