View Javadoc

1   /*
2    * $Id: ExpressionFilter.java 12370 2008-07-17 13:11:17Z tcarlson $
3    * --------------------------------------------------------------------------------------
4    * Copyright (c) MuleSource, Inc.  All rights reserved.  http://www.mulesource.com
5    *
6    * The software in this package is published under the terms of the CPAL v1.0
7    * license, a copy of which has been included with this distribution in the
8    * LICENSE.txt file.
9    */
10  package org.mule.routing.filters;
11  
12  import org.mule.api.MuleMessage;
13  import org.mule.api.routing.filter.Filter;
14  import org.mule.config.i18n.CoreMessages;
15  import org.mule.util.expression.ExpressionEvaluatorManager;
16  
17  import org.apache.commons.logging.Log;
18  import org.apache.commons.logging.LogFactory;
19  
20  /**
21   * Allows boolean expressions to be executed on a message
22   */
23  public class ExpressionFilter implements Filter
24  {
25      /**
26       * logger used by this class
27       */
28      protected transient final Log logger = LogFactory.getLog(ExpressionFilter.class);
29  
30      private String evaluator;
31      private String expression;
32      private String customEvaluator;
33      private String fullExpression;
34      private boolean nullReturnsTrue = false;
35      private static final String TRUE = "true";
36  
37      /** For evaluators that are not expression languages we can delegate the execution to another filter */
38      private Filter delegateFilter;
39  
40      public ExpressionFilter(String evaluator, String customEvaluator, String expression)
41      {
42          this.customEvaluator = customEvaluator;
43          this.evaluator = evaluator;
44          this.expression = expression;
45      }
46  
47      public ExpressionFilter(String evaluator, String expression)
48      {
49          this.evaluator = evaluator;
50          this.expression = expression;
51      }
52  
53      public ExpressionFilter(String expression)
54      {
55          int i = expression.indexOf(":");
56          if(i < 0)
57          {
58              throw new IllegalArgumentException("Expression is invalid: " + expression);
59          }
60          this.evaluator = expression.substring(0, i);
61          this.expression = expression.substring(i+1);
62      }
63  
64      public ExpressionFilter()
65      {
66          super();
67      }
68  
69      /**
70       * Check a given message against this filter.
71       *
72       * @param message a non null message to filter.
73       * @return <code>true</code> if the message matches the filter
74       */
75      public boolean accept(MuleMessage message)
76      {
77          String expr = getFullExpression();
78          if (delegateFilter != null)
79          {
80              return delegateFilter.accept(message);
81          }
82  
83          Object result = ExpressionEvaluatorManager.evaluate(expr, message);
84          if (result == null)
85          {
86              return nullReturnsTrue;
87          }
88          else if (result instanceof Boolean)
89          {
90              return ((Boolean) result).booleanValue();
91          }
92          else if (result instanceof String)
93          {
94              return ((String) result).toLowerCase().equals(TRUE);
95          }
96          else
97          {
98              logger.warn("Expression: " + expr + ", returned an non-boolean result. Returning: "
99                          + !nullReturnsTrue);
100             return !nullReturnsTrue;
101         }
102     }
103 
104     protected String getFullExpression()
105     {
106         if(fullExpression==null)
107         {
108             if(evaluator==null)
109             {
110                 throw new IllegalArgumentException(CoreMessages.objectIsNull("evaluator").getMessage());
111             }
112             if(evaluator.equals("custom"))
113             {
114                 if(customEvaluator==null)
115                 {
116                     throw new IllegalArgumentException(CoreMessages.objectIsNull("customEvaluator").getMessage());
117                 }
118                 else
119                 {
120                     evaluator = customEvaluator;
121                 }
122             }
123             if(evaluator.equals("header"))
124             {
125                 delegateFilter = new MessagePropertyFilter(expression);
126             }
127             else if(evaluator.equals("regex"))
128             {
129                 delegateFilter = new RegExFilter(expression);
130             }
131             else if(evaluator.equals("wildcard"))
132             {
133                 delegateFilter = new WildcardFilter(expression);
134             }
135             else if(evaluator.equals("payload-type"))
136             {
137                 try
138                 {
139                     delegateFilter = new PayloadTypeFilter(expression);
140                 }
141                 catch (ClassNotFoundException e)
142                 {
143                     IllegalArgumentException iae = new IllegalArgumentException();
144                     iae.initCause(e);
145                     throw iae;
146                 }
147             }
148             else if(evaluator.equals("exception-type"))
149             {
150                 try
151                 {
152                     delegateFilter = new ExceptionTypeFilter(expression);
153                 }
154                 catch (ClassNotFoundException e)
155                 {
156                     IllegalArgumentException iae = new IllegalArgumentException();
157                     iae.initCause(e);
158                     throw iae;
159                 }
160             }
161             else
162             {
163                 //In the case of 'payload' the expression can be null
164                 fullExpression = evaluator + ":" + (expression==null ? "" : expression);
165             }
166         }
167         return fullExpression;
168     }
169 
170     public String getCustomEvaluator()
171     {
172         return customEvaluator;
173     }
174 
175     public void setCustomEvaluator(String customEvaluator)
176     {
177         this.customEvaluator = customEvaluator;
178     }
179 
180     public String getEvaluator()
181     {
182         return evaluator;
183     }
184 
185     public void setEvaluator(String evaluator)
186     {
187         this.evaluator = evaluator;
188     }
189 
190     public String getExpression()
191     {
192         return expression;
193     }
194 
195     public void setExpression(String expression)
196     {
197         this.expression = expression;
198     }
199 
200     public boolean isNullReturnsTrue()
201     {
202         return nullReturnsTrue;
203     }
204 
205     public void setNullReturnsTrue(boolean nullReturnsTrue)
206     {
207         this.nullReturnsTrue = nullReturnsTrue;
208     }
209 }