/** * <code>ExpressionFilenameParser</code> can use any expression language supported by Mule to * construct a file name for the current message. Expressions can be xpath, xquery, ognl, mvel, * header, function and more. For more information see * http://www.mulesoft.org/documentation/display/MULE3USER/Using+Expressions. * * <p>For example an xpath expression can be defined to pull a message id out of an xml message and * use that as the file name - <code> * #[xpath:/message/header/@id] * </code> * * <p>This parser superseeds the (now removed) <code>org.mule.transport.file.SimpleFilenameParser * </code> which has been kept in Mule 2 for compatibility. The following demonstrates how to * achieve the same results when using the <code>ExpressionFilenameParser</code> over the <code> * SimpleFilenameParser</code> * * <ul> * <li>#[DATE] : #[function:datestamp] * <li>#[DATE:yy-MM-dd] : #[function:datestamp-yy-MM-dd] * <li>#[SYSTIME] : #[function:systime] * <li>#[UUID] : #[function:uuid] * <li>#[ORIGINALNAME] : #[header:originalFilename] * <li>#[COUNT] : #[function:count] - note that this is a global counter. * <li>#[<Message Property Name>] : #[header:<Message Property Name>] * </ul> */ public class ExpressionFilenameParser implements FilenameParser, MuleContextAware { public static final String DEFAULT_DATE_FORMAT = "dd-MM-yy_HH-mm-ss.SSS"; public static final String DEFAULT_EXPRESSION = MessageFormat.format( "{0}function:uuid{1}.dat", ExpressionManager.DEFAULT_EXPRESSION_PREFIX, ExpressionManager.DEFAULT_EXPRESSION_POSTFIX); private final TemplateParser wigglyMuleParser = TemplateParser.createMuleStyleParser(); private final TemplateParser squareParser = TemplateParser.createSquareBracesStyleParser(); protected MuleContext muleContext; public void setMuleContext(MuleContext context) { this.muleContext = context; } public String getFilename(MuleMessage message, String expression) { if (expression == null) { expression = DEFAULT_EXPRESSION; } if (expression.indexOf(ExpressionManager.DEFAULT_EXPRESSION_PREFIX) > -1) { return getFilename(message, expression, wigglyMuleParser); } else { return getFilename(message, expression, squareParser); } } protected String getFilename( final MuleMessage message, String expression, TemplateParser parser) { return parser.parse( new TemplateParser.TemplateCallback() { public Object match(String token) { return muleContext.getExpressionManager().evaluate(token, message); } }, expression); } }
/** * Provides universal access for evaluating expressions embedded in Mule configurations, such as * Xml, Java, scripting and annotations. * * <p>Users can register or unregister {@link ExpressionEvaluator} through this interface. */ public class DefaultExpressionManager implements ExpressionManager { /** logger used by this class */ protected static final transient Log logger = LogFactory.getLog(DefaultExpressionManager.class); // default style parser private TemplateParser parser = TemplateParser.createMuleStyleParser(); private ConcurrentMap evaluators = new ConcurrentHashMap(8); public void registerEvaluator(ExpressionEvaluator evaluator) { if (evaluator == null) { throw new IllegalArgumentException(CoreMessages.objectIsNull("evaluator").getMessage()); } final String name = evaluator.getName(); // TODO MULE-3809 Eliminate duplicate evaluators registration if (logger.isDebugEnabled()) { logger.debug( "Evaluators already contain an object named '" + name + "'. The previous object will be overwritten."); } evaluators.put(evaluator.getName(), evaluator); } /** * Checks whether an evaluator is registered with the manager * * @param name the name of the expression evaluator * @return true if the evaluator is registered with the manager, false otherwise */ public boolean isEvaluatorRegistered(String name) { return evaluators.containsKey(name); } /** * Removes the evaluator with the given name * * @param name the name of the evaluator to remove */ public ExpressionEvaluator unregisterEvaluator(String name) { if (name == null) { return null; } ExpressionEvaluator evaluator = (ExpressionEvaluator) evaluators.remove(name); if (evaluator instanceof Disposable) { ((Disposable) evaluator).dispose(); } return evaluator; } /** * Evaluates the given expression. The expression should be a single expression definition with or * without enclosing braces. i.e. "mule:serviceName" and "#[mule:serviceName]" are both valid. For * situations where one or more expressions need to be parsed within a single text, the {@link * org.mule.api.expression.ExpressionManager#parse(String,org.mule.api.MuleMessage,boolean)} * method should be used since it will iterate through all expressions in a string. * * @param expression a single expression i.e. xpath://foo * @param message the current message to process. The expression will evaluata on the message. * @return the result of the evaluation. Expressions that return collection will return an empty * collection, not null. * @throws ExpressionRuntimeException if the expression is invalid, or a null is found for the * expression and 'failIfNull is set to true. */ public Object evaluate(String expression, MuleMessage message) throws ExpressionRuntimeException { return evaluate(expression, message, false); } /** * Evaluates the given expression. The expression should be a single expression definition with or * without enclosing braces. i.e. "mule:serviceName" and "#[mule:serviceName]" are both valid. For * situations where one or more expressions need to be parsed within a single text, the {@link * org.mule.api.expression.ExpressionManager#parse(String,org.mule.api.MuleMessage,boolean)} * method should be used since it will iterate through all expressions in a string. * * @param expression a single expression i.e. xpath://foo * @param message the current message to process. The expression will evaluata on the message. * @param failIfNull determines if an exception should be thrown if expression could not be * evaluated or returns null. * @return the result of the evaluation. Expressions that return collection will return an empty * collection, not null. * @throws ExpressionRuntimeException if the expression is invalid, or a null is found for the * expression and 'failIfNull is set to true. */ public Object evaluate(String expression, MuleMessage message, boolean failIfNull) throws ExpressionRuntimeException { String name; if (expression == null) { throw new IllegalArgumentException(CoreMessages.objectIsNull("expression").getMessage()); } if (expression.startsWith(DEFAULT_EXPRESSION_PREFIX)) { expression = expression.substring(2, expression.length() - 1); } int i = expression.indexOf(":"); if (i > -1) { name = expression.substring(0, i); expression = expression.substring(i + DEFAULT_EXPRESSION_POSTFIX.length()); } else { name = expression; expression = null; } return evaluate(expression, name, message, failIfNull); } /** * Evaluates the given expression. The expression should be a single expression definition with or * without enclosing braces. i.e. "mule:serviceName" and "#[mule:serviceName]" are both valid. For * situations where one or more expressions need to be parsed within a single text, the {@link * org.mule.api.expression.ExpressionManager#parse(String,org.mule.api.MuleMessage,boolean)} * method should be used since it will iterate through all expressions in a string. * * @param expression a single expression i.e. xpath://foo * @param evaluator the evaluator to use when executing the expression * @param message the current message to process. The expression will evaluata on the message. * @param failIfNull determines if an exception should be thrown if expression could not be * evaluated or returns null or if an exception should be thrown if an empty collection is * returned. * @return the result of the evaluation. Expressions that return collection will return an empty * collection, not null. * @throws ExpressionRuntimeException if the expression is invalid, or a null is found for the * expression and 'failIfNull is set to true. */ public Object evaluate( String expression, String evaluator, MuleMessage message, boolean failIfNull) throws ExpressionRuntimeException { ExpressionEvaluator extractor = (ExpressionEvaluator) evaluators.get(evaluator); if (extractor == null) { throw new IllegalArgumentException( CoreMessages.expressionEvaluatorNotRegistered(evaluator).getMessage()); } Object result = extractor.evaluate(expression, message); // TODO Handle empty collections || (result instanceof Collection && // ((Collection)result).size()==0) if (failIfNull && (result == null)) { throw new ExpressionRuntimeException( CoreMessages.expressionEvaluatorReturnedNull(evaluator, expression)); } if (logger.isDebugEnabled()) { logger.debug( MessageFormat.format( "Result of expression: {0}:{1} is: {2}", evaluator, expression, result)); } return result; } /** * Evaluates expressions in a given string. This method will iterate through each expression and * evaluate it. If a user needs to evaluate a single expression they can use {@link * org.mule.api.expression.ExpressionManager#evaluate(String,org.mule.api.MuleMessage,boolean)}. * * @param expression a single expression i.e. xpath://foo * @param message the current message to process. The expression will evaluata on the message. * @return the result of the evaluation. Expressions that return collection will return an empty * collection, not null. * @throws org.mule.api.expression.ExpressionRuntimeException if the expression is invalid, or a * null is found for the expression and 'failIfNull is set to true. */ public String parse(String expression, MuleMessage message) throws ExpressionRuntimeException { return parse(expression, message, false); } /** * Evaluates expressions in a given string. This method will iterate through each expression and * evaluate it. If a user needs to evaluate a single expression they can use {@link * org.mule.api.expression.ExpressionManager#evaluate(String,org.mule.api.MuleMessage,boolean)}. * * @param expression a single expression i.e. xpath://foo * @param message the current message to process. The expression will evaluata on the message. * @param failIfNull determines if an exception should be thrown if expression could not be * evaluated or returns null. * @return the result of the evaluation. Expressions that return collection will return an empty * collection, not null. * @throws ExpressionRuntimeException if the expression is invalid, or a null is found for the * expression and 'failIfNull is set to true. */ public String parse(final String expression, final MuleMessage message, final boolean failIfNull) throws ExpressionRuntimeException { return parser.parse( new TemplateParser.TemplateCallback() { public Object match(String token) { return evaluate(token, message, failIfNull); } }, expression); } /** Clears all registered evaluators from the manager. */ public synchronized void clearEvaluators() { for (Iterator iterator = evaluators.values().iterator(); iterator.hasNext(); ) { ExpressionEvaluator evaluator = (ExpressionEvaluator) iterator.next(); if (evaluator instanceof Disposable) { ((Disposable) evaluator).dispose(); } } evaluators.clear(); } /** * Determines if the expression is valid or not. This method will validate a single expression or * expressions embedded in a string. the expression must be well formed i.e. #[bean:user] * * @param expression the expression to validate * @return true if the expression evaluator is recognised */ public boolean isValidExpression(String expression) { final AtomicBoolean valid = new AtomicBoolean(true); final AtomicBoolean match = new AtomicBoolean(false); final StringBuffer message = new StringBuffer(); parser.parse( new TemplateParser.TemplateCallback() { public Object match(String token) { match.set(true); if (token.indexOf(":") == -1) { if (valid.get()) { valid.compareAndSet(true, false); } message.append(token).append(" is malformed\n"); } return null; } }, expression); if (message.length() > 0) { logger.warn("Expression " + expression + " is malformed: " + message.toString()); } return match.get() && valid.get(); } }
public GetMentionsDefinitionParser() { patternInfo = TemplateParser.createMuleStyleParser().getStyle(); }