/*
* Copyright 2002-2005 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.springmodules.validation.bean.conf.loader.annotation.handler;
import java.lang.annotation.Annotation;
import java.lang.reflect.Method;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.BeansException;
import org.springframework.util.StringUtils;
import org.springmodules.validation.bean.conf.MutableBeanValidationConfiguration;
import org.springmodules.validation.bean.rule.AbstractValidationRule;
import org.springmodules.validation.bean.rule.resolver.ErrorArgumentsResolver;
import org.springmodules.validation.bean.rule.resolver.FunctionErrorArgumentsResolver;
import org.springmodules.validation.util.cel.ConditionExpressionBased;
import org.springmodules.validation.util.cel.ConditionExpressionParser;
import org.springmodules.validation.util.cel.valang.ValangConditionExpressionParser;
import org.springmodules.validation.util.condition.Condition;
import org.springmodules.validation.util.fel.FunctionExpressionBased;
import org.springmodules.validation.util.fel.FunctionExpressionParser;
import org.springmodules.validation.util.fel.parser.ValangFunctionExpressionParser;
/**
* A parent for all common {@link PropertyValidationAnnotationHandler} implementations that represent validation rules.
* The following attributes are searched for in the handled annotations:
* <ul>
* <li>{@link #ERROR_CODE_ATTR} - A string indicating the error code for the validation rule</li>
* <li>{@link #MESSAGE_ATTR} - A string indicating default error message for the validation rule</li>
* <li>{@link #ARGS_ATTR} - A comma-separated string indicating error arguments (may be expressions to be
* resolved against the validated object)</li>
* <li>{@link #APPLY_IF_ATTR} - A condition expression that represents the applicability condition</li>
* </ul>
*
* @author Uri Boness
*/
public abstract class AbstractMethodValidationAnnotationHandler implements MethodValidationAnnotationHandler,
ConditionExpressionBased, FunctionExpressionBased {
public final static String APPLY_IF_ATTR = "applyIf";
public final static String ERROR_CODE_ATTR = "errorCode";
public final static String MESSAGE_ATTR = "message";
public final static String ARGS_ATTR = "args";
public final static String FOR_PROPERTY_ATTR = "forProperty";
public final static String CONTEXTS_ATTR = "contexts";
private Class[] supportedAnnotationTypes;
private ConditionExpressionParser conditionExpressionParser;
private FunctionExpressionParser functionExpressionParser;
/**
* Constructs a new AbstractPropertyValidationAnnotationHandler with a given supported annotation types.
*
* @param supportedAnnotationTypes The types of the supported annotations.
*/
public AbstractMethodValidationAnnotationHandler(Class... supportedAnnotationTypes) {
this.supportedAnnotationTypes = supportedAnnotationTypes;
conditionExpressionParser = new ValangConditionExpressionParser();
functionExpressionParser = new ValangFunctionExpressionParser();
}
/**
* @see MethodValidationAnnotationHandler#supports(java.lang.annotation.Annotation, Class, java.lang.reflect.Method)
*/
public boolean supports(Annotation annotation, Class clazz, Method method) {
for (Class supportedType : supportedAnnotationTypes) {
if (supportedType.isInstance(annotation)) {
return true;
}
}
return false;
}
/**
* Creates a validation rule out of the given class validation annoation and adds it to the given
* bean validation configuration.
*
* @see ClassValidationAnnotationHandler#handleAnnotation(java.lang.annotation.Annotation, Class, org.springmodules.validation.bean.conf.MutableBeanValidationConfiguration)
*/
public void handleAnnotation(
Annotation annotation,
Class clazz,
Method method,
MutableBeanValidationConfiguration configuration) {
AbstractValidationRule rule = createValidationRule(annotation, clazz, method);
String errorCode = extractErrorCode(annotation);
if (errorCode != null) {
rule.setErrorCode(errorCode);
}
String message = extractDefaultMessage(annotation);
if (message != null) {
rule.setDefaultErrorMessage(message);
}
ErrorArgumentsResolver argumentsResolver = extractArgumentsResolver(annotation);
if (argumentsResolver != null) {
rule.setErrorArgumentsResolver(argumentsResolver);
}
Condition applicabilityCondition = extractApplicabilityContidion(annotation);
if (applicabilityCondition != null) {
rule.setApplicabilityCondition(applicabilityCondition);
}
String[] applicableContexts = extractApplicableContexts(annotation);
if (applicableContexts != null) {
rule.setContextTokens(applicableContexts);
}
String propertyName = extractPropertyName(annotation);
if (StringUtils.hasText(propertyName)) {
validatedPropertyExists(clazz, propertyName);
configuration.addPropertyRule(propertyName, rule);
} else {
configuration.addGlobalRule(rule);
}
}
/**
* Extracts the validation rule error code from the given annotation. Expects a {@link #ERROR_CODE_ATTR} to be
* present.
*
* @param annotation The property validation annotation.
* @return The error code for the represented validation rule.
*/
protected String extractErrorCode(Annotation annotation) {
return (String) extractAnnotationAttribute(annotation, ERROR_CODE_ATTR);
}
/**
* Extracts the validation rule default message from the given annotation. Expects a {@link #MESSAGE_ATTR} to be
* present.
*
* @param annotation The property validation annotation.
* @return The default message for the represented validation rule.
*/
protected String extractDefaultMessage(Annotation annotation) {
return (String) extractAnnotationAttribute(annotation, MESSAGE_ATTR);
}
/**
* Extracts the {@link org.springmodules.validation.bean.rule.resolver.ErrorArgumentsResolver} for the validation rule represented by the given annotation.
* Expects a {@link #ARGS_ATTR} to be present.
*
* @param annotation The property validation annotation.
* @return The {@link org.springmodules.validation.bean.rule.resolver.ErrorArgumentsResolver} for the represented validation rule.
*/
protected ErrorArgumentsResolver extractArgumentsResolver(Annotation annotation) {
String argsAsString = (String) extractAnnotationAttribute(annotation, ARGS_ATTR);
argsAsString = (argsAsString == null) ? "" : argsAsString;
String[] argsExpressions = StringUtils.commaDelimitedListToStringArray(argsAsString);
if (argsExpressions.length == 0) {
return null;
}
return new FunctionErrorArgumentsResolver(argsExpressions, functionExpressionParser);
}
/**
* Extracts the validation rule applicability condition from the given annotation. Expects a {@link #APPLY_IF_ATTR}
* to be present - the value of this attribute is parsed using the {@link org.springmodules.validation.util.cel.ConditionExpressionParser} associated with this
* handler. If the attribute is an empty string or <code>null</code> it is treated as if the validation rule is
* always applicable (that is, the applicability condition is {@link org.springmodules.validation.util.condition.common.AlwaysTrueCondition}).
*
* @param annotation The property validation annotation.
* @return The applicability condition for the represented validation rule.
*/
protected Condition extractApplicabilityContidion(Annotation annotation) {
String expression = (String) extractAnnotationAttribute(annotation, APPLY_IF_ATTR);
return (StringUtils.hasText(expression)) ? conditionExpressionParser.parse(expression) : null;
}
/**
* Extracts the names of the validation context in which the valiation rule is applicable. Expects a "contexts"
* attribute to hold an array of context names. If it holds an empty array, <code>null </code> is returned.
* As the contract of {@link AbstractValidationRule#setContextTokens(String[])}
* defines <code>null</code> means that the rule always applies regardless of the context.
*
* @param annotation The validation rule annoation.
* @return The names of the validation contexts in which the
*/
protected String[] extractApplicableContexts(Annotation annotation) {
String[] contexts = (String[]) extractAnnotationAttribute(annotation, CONTEXTS_ATTR);
return (contexts.length > 0) ? contexts : null;
}
/**
* Extracts the property that the validation method is associated with.
*
* @param annotation The method validation annotation
* @return The property the validation method is associated wit
*/
protected String extractPropertyName(Annotation annotation) {
return (String) extractAnnotationAttribute(annotation, FOR_PROPERTY_ATTR);
}
/**
* Creates and returns the validation rule that is represented and initialized by and with the given annotation.
*
* @param annotation The annotation from which the validation rule should be created.
* @param clazz The class of the valiated object.
* @return The created validation rule.
*/
protected abstract AbstractValidationRule createValidationRule(Annotation annotation, Class clazz, Method method);
//=============================================== Setter/Getter ====================================================
/**
* @see org.springmodules.validation.util.cel.ConditionExpressionBased#setConditionExpressionParser(org.springmodules.validation.util.cel.ConditionExpressionParser)
*/
public void setConditionExpressionParser(ConditionExpressionParser conditionExpressionParser) {
this.conditionExpressionParser = conditionExpressionParser;
}
/**
* Returns the condition expression parser associated with this handler.
*
* @return The condition expression parser associated with this handler.
*/
protected ConditionExpressionParser getConditionExpressionParser() {
return conditionExpressionParser;
}
/**
* @see org.springmodules.validation.util.fel.FunctionExpressionBased#setFunctionExpressionParser(org.springmodules.validation.util.fel.FunctionExpressionParser)
*/
public void setFunctionExpressionParser(FunctionExpressionParser functionExpressionParser) {
this.functionExpressionParser = functionExpressionParser;
}
/**
* Returns the function expression parser associated with this handler.
*
* @return The function expression parser associated with this handler.
*/
protected FunctionExpressionParser getFunctionExpressionParser() {
return functionExpressionParser;
}
//=============================================== Helper Methods ===================================================
/**
* Validates that the given class has a property with the given propertyName. Throws {@link BeansException} if
* the property was not found.
*
* @param clazz The class to check
* @param property The name of the property
*/
protected void validatedPropertyExists(Class clazz, String property) {
BeanUtils.getPropertyDescriptor(clazz, property);
}
protected Object extractAnnotationAttribute(Annotation annotation, String attributeName) {
try {
return annotation.getClass().getMethod(attributeName).invoke(annotation);
} catch (Exception e) {
throw new IllegalArgumentException("Expecting attribute '" + attributeName +
"' in annotation '" + annotation.getClass().getName() + "'", e);
}
}
}