trunk/bval-jsr303/src/main/java/org/apache/bval/jsr303/Jsr303MetaBeanFactory.java - bval - Git at Google

 /*
  * Licensed to the Apache Software Foundation (ASF) under one
  * or more contributor license agreements.  See the NOTICE file
  * distributed with this work for additional information
  * regarding copyright ownership.  The ASF licenses this file
  * to you 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.apache.bval.jsr303;

 import java.lang.annotation.Annotation;
 import java.lang.reflect.Field;
 import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Method;
 import java.security.AccessController;
 import java.security.PrivilegedAction;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.logging.Level;
 import java.util.logging.Logger;

 import javax.validation.Constraint;
 import javax.validation.GroupDefinitionException;
 import javax.validation.GroupSequence;
 import javax.validation.ValidationException;
 import javax.validation.groups.Default;

 import org.apache.bval.MetaBeanFactory;
 import org.apache.bval.jsr303.groups.Group;
 import org.apache.bval.jsr303.util.ClassHelper;
 import org.apache.bval.jsr303.util.SecureActions;
 import org.apache.bval.jsr303.xml.MetaConstraint;
 import org.apache.bval.model.MetaBean;
 import org.apache.bval.model.MetaProperty;
 import org.apache.bval.util.AccessStrategy;
 import org.apache.bval.util.FieldAccess;
 import org.apache.bval.util.MethodAccess;

 /**
  * Description: process the class annotations for JSR303 constraint validations to build the MetaBean with information
  * from annotations and JSR303 constraint mappings (defined in xml)<br/>
  */
 public class Jsr303MetaBeanFactory implements MetaBeanFactory {
     /** Shared log instance */
     // of dubious utility as it's static :/
     protected static final Logger log = Logger.getLogger(Jsr303MetaBeanFactory.class.getName());

     /** {@link ApacheFactoryContext} used */
     protected final ApacheFactoryContext factoryContext;

     /**
      * {@link AnnotationProcessor} used.
      */
     protected AnnotationProcessor annotationProcessor;

     /**
      * Create a new Jsr303MetaBeanFactory instance.
      *
      * @param factoryContext
      */
     public Jsr303MetaBeanFactory(ApacheFactoryContext factoryContext) {
         this.factoryContext = factoryContext;
         this.annotationProcessor = new AnnotationProcessor(factoryContext);
     }

     /**
      * {@inheritDoc} Add the validation features to the metabean that come from JSR303 annotations in the beanClass.
      */
     public void buildMetaBean(MetaBean metabean) {
         try {
             final Class<?> beanClass = metabean.getBeanClass();
             processGroupSequence(beanClass, metabean);

             // process class, superclasses and interfaces
             List<Class<?>> classSequence = new ArrayList<Class<?>>();
             ClassHelper.fillFullClassHierarchyAsList(classSequence, beanClass);

             // start with superclasses and go down the hierarchy so that
             // the child classes are processed last to have the chance to
             // overwrite some declarations
             // of their superclasses and that they see what they inherit at the
             // time of processing
             for (int i = classSequence.size() - 1; i >= 0; i--) {
                 Class<?> eachClass = classSequence.get(i);
                 processClass(eachClass, metabean);
                 processGroupSequence(eachClass, metabean, "{GroupSequence:" + eachClass.getCanonicalName() + "}");
             }

         } catch (IllegalAccessException e) {
             throw new IllegalArgumentException(e);
         } catch (InvocationTargetException e) {
             throw new IllegalArgumentException(e.getTargetException());
         }
     }

     /**
      * Process class annotations, field and method annotations.
      *
      * @param beanClass
      * @param metabean
      * @throws IllegalAccessException
      * @throws InvocationTargetException
      */
     private void processClass(Class<?> beanClass, MetaBean metabean) throws IllegalAccessException,
         InvocationTargetException {

         // if NOT ignore class level annotations
         if (!factoryContext.getFactory().getAnnotationIgnores().isIgnoreAnnotations(beanClass)) {
             annotationProcessor.processAnnotations(null, beanClass, beanClass, null, new AppendValidationToMeta(
                 metabean));
         }

         final Field[] fields = doPrivileged(SecureActions.getDeclaredFields(beanClass));
         for (Field field : fields) {
             MetaProperty metaProperty = metabean.getProperty(field.getName());
             // create a property for those fields for which there is not yet a
             // MetaProperty
             if (!factoryContext.getFactory().getAnnotationIgnores().isIgnoreAnnotations(field)) {
                 AccessStrategy access = new FieldAccess(field);
                 boolean create = metaProperty == null;
                 if (create) {
                     metaProperty = addMetaProperty(metabean, access);
                 }
                 if (!annotationProcessor.processAnnotations(metaProperty, beanClass, field, access,
                     new AppendValidationToMeta(metaProperty)) && create) {
                     metabean.putProperty(metaProperty.getName(), null);
                 }
             }
         }
         final Method[] methods = doPrivileged(SecureActions.getDeclaredMethods(beanClass));
         for (Method method : methods) {
             String propName = null;
             if (method.getParameterTypes().length == 0) {
                 propName = MethodAccess.getPropertyName(method);
             }
             if (propName != null) {
                 if (!factoryContext.getFactory().getAnnotationIgnores().isIgnoreAnnotations(method)) {
                     AccessStrategy access = new MethodAccess(propName, method);
                     MetaProperty metaProperty = metabean.getProperty(propName);
                     boolean create = metaProperty == null;
                     // create a property for those methods for which there is
                     // not yet a MetaProperty
                     if (create) {
                         metaProperty = addMetaProperty(metabean, access);
                     }
                     if (!annotationProcessor.processAnnotations(metaProperty, beanClass, method, access,
                         new AppendValidationToMeta(metaProperty)) && create) {
                         metabean.putProperty(propName, null);
                     }
                 }
             } else if (hasValidationConstraintsDefined(method)) {
                 throw new ValidationException("Property " + method.getName() + " does not follow javabean conventions.");
             }
         }

         addXmlConstraints(beanClass, metabean);
     }

     /**
      * Learn whether a given Method has validation constraints defined via JSR303 annotations.
      *
      * @param method
      * @return <code>true</code> if constraints detected
      */
     protected boolean hasValidationConstraintsDefined(Method method) {
         for (Annotation annot : method.getDeclaredAnnotations()) {
             if (hasValidationConstraintsDefined(annot)) {
                 return true;
             }
         }
         return false;
     }

     private boolean hasValidationConstraintsDefined(Annotation annot) {
         // If it is annotated with @Constraint
         if (annot.annotationType().getAnnotation(Constraint.class) != null) {
             return true;
         }

         // Check whether it is a multivalued constraint:
         if (ConstraintAnnotationAttributes.VALUE.isDeclaredOn(annot.annotationType())) {
             Annotation[] children = ConstraintAnnotationAttributes.VALUE.getValue(annot);
             if (children != null) {
                 for (Annotation child : children) {
                     if (hasValidationConstraintsDefined(child)) {
                         return true;
                     }
                 }
             }
         }

         return false;
     }

     /**
      * Add cascade validation and constraints from xml mappings
      *
      * @param beanClass
      * @param metabean
      * @throws IllegalAccessException
      * @throws InvocationTargetException
      */
     private void addXmlConstraints(Class<?> beanClass, MetaBean metabean) throws IllegalAccessException,
         InvocationTargetException {
         for (MetaConstraint<?, ? extends Annotation> meta : factoryContext.getFactory().getMetaConstraints(beanClass)) {
             MetaProperty metaProperty;
             AccessStrategy access = meta.getAccessStrategy();
             boolean create = false;
             if (access == null) { // class level
                 metaProperty = null;
             } else { // property level
                 metaProperty = metabean.getProperty(access.getPropertyName());
                 create = metaProperty == null;
                 if (create) {
                     metaProperty = addMetaProperty(metabean, access);
                 }
             }
             if (!annotationProcessor.processAnnotation(meta.getAnnotation(), metaProperty, beanClass,
                 meta.getAccessStrategy(), new AppendValidationToMeta(metaProperty == null ? metabean : metaProperty))
                 && create) {
                 metabean.putProperty(access.getPropertyName(), null);
             }
         }
         for (AccessStrategy access : factoryContext.getFactory().getValidAccesses(beanClass)) {
             MetaProperty metaProperty = metabean.getProperty(access.getPropertyName());
             boolean create = metaProperty == null;
             if (create) {
                 metaProperty = addMetaProperty(metabean, access);
             }
             if (!annotationProcessor.addAccessStrategy(metaProperty, access) && create) {
                 metabean.putProperty(access.getPropertyName(), null);
             }
         }
     }

     private void processGroupSequence(Class<?> beanClass, MetaBean metabean) {
         processGroupSequence(beanClass, metabean, Jsr303Features.Bean.GROUP_SEQUENCE);
     }

     private void processGroupSequence(Class<?> beanClass, MetaBean metabean, String key) {
         GroupSequence annotation = beanClass.getAnnotation(GroupSequence.class);
         List<Group> groupSeq = metabean.getFeature(key);
         if (groupSeq == null) {
             groupSeq = new ArrayList<Group>(annotation == null ? 1 : annotation.value().length);
             metabean.putFeature(key, groupSeq);
         }
         Class<?>[] groupClasses = factoryContext.getFactory().getDefaultSequence(beanClass);
         if (groupClasses == null || groupClasses.length == 0) {
             if (annotation == null) {
                 groupSeq.add(Group.DEFAULT);
                 return;
             } else {
                 groupClasses = annotation.value();
             }
         }
         boolean containsDefault = false;
         for (Class<?> groupClass : groupClasses) {
             if (groupClass.getName().equals(beanClass.getName())) {
                 groupSeq.add(Group.DEFAULT);
                 containsDefault = true;
             } else if (groupClass.getName().equals(Default.class.getName())) {
                 throw new GroupDefinitionException("'Default.class' must not appear in @GroupSequence! Use '"
                     + beanClass.getSimpleName() + ".class' instead.");
             } else {
                 groupSeq.add(new Group(groupClass));
             }
         }
         if (!containsDefault) {
             throw new GroupDefinitionException("Redefined default group sequence must contain " + beanClass.getName());
         }
         log.log(Level.FINEST, String.format("Default group sequence for bean %s is: %s", beanClass.getName(), groupSeq));
     }

     /**
      * Add a {@link MetaProperty} to a {@link MetaBean}.
      * @param parentMetaBean
      * @param access
      * @return the created {@link MetaProperty}
      */
     public static MetaProperty addMetaProperty(MetaBean parentMetaBean, AccessStrategy access) {
         final MetaProperty result = new MetaProperty();
         final String name = access.getPropertyName();
         result.setName(name);
         result.setType(access.getJavaType());
         parentMetaBean.putProperty(name, result);
         return result;
     }


     /**
      * Perform action with AccessController.doPrivileged() if a security manager is installed.
      *
      * @param action
      *  the action to run
      * @return
      *  result of the action
      */
     private static <T> T doPrivileged(final PrivilegedAction<T> action) {
         if (System.getSecurityManager() != null) {
             return AccessController.doPrivileged(action);
         } else {
             return action.run();
         }
     }
 }
	/*
	* Licensed to the Apache Software Foundation (ASF) under one
	* or more contributor license agreements. See the NOTICE file
	* distributed with this work for additional information
	* regarding copyright ownership. The ASF licenses this file
	* to you 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.apache.bval.jsr303;

	import java.lang.annotation.Annotation;
	import java.lang.reflect.Field;
	import java.lang.reflect.InvocationTargetException;
	import java.lang.reflect.Method;
	import java.security.AccessController;
	import java.security.PrivilegedAction;
	import java.util.ArrayList;
	import java.util.List;
	import java.util.logging.Level;
	import java.util.logging.Logger;

	import javax.validation.Constraint;
	import javax.validation.GroupDefinitionException;
	import javax.validation.GroupSequence;
	import javax.validation.ValidationException;
	import javax.validation.groups.Default;

	import org.apache.bval.MetaBeanFactory;
	import org.apache.bval.jsr303.groups.Group;
	import org.apache.bval.jsr303.util.ClassHelper;
	import org.apache.bval.jsr303.util.SecureActions;
	import org.apache.bval.jsr303.xml.MetaConstraint;
	import org.apache.bval.model.MetaBean;
	import org.apache.bval.model.MetaProperty;
	import org.apache.bval.util.AccessStrategy;
	import org.apache.bval.util.FieldAccess;
	import org.apache.bval.util.MethodAccess;

	/**
	* Description: process the class annotations for JSR303 constraint validations to build the MetaBean with information
	* from annotations and JSR303 constraint mappings (defined in xml)<br/>
	*/
	public class Jsr303MetaBeanFactory implements MetaBeanFactory {
	/** Shared log instance */
	// of dubious utility as it's static :/
	protected static final Logger log = Logger.getLogger(Jsr303MetaBeanFactory.class.getName());

	/** {@link ApacheFactoryContext} used */
	protected final ApacheFactoryContext factoryContext;

	/**
	* {@link AnnotationProcessor} used.
	*/
	protected AnnotationProcessor annotationProcessor;

	/**
	* Create a new Jsr303MetaBeanFactory instance.
	*
	* @param factoryContext
	*/
	public Jsr303MetaBeanFactory(ApacheFactoryContext factoryContext) {
	this.factoryContext = factoryContext;
	this.annotationProcessor = new AnnotationProcessor(factoryContext);
	}

	/**
	* {@inheritDoc} Add the validation features to the metabean that come from JSR303 annotations in the beanClass.
	*/
	public void buildMetaBean(MetaBean metabean) {
	try {
	final Class<?> beanClass = metabean.getBeanClass();
	processGroupSequence(beanClass, metabean);

	// process class, superclasses and interfaces
	List<Class<?>> classSequence = new ArrayList<Class<?>>();
	ClassHelper.fillFullClassHierarchyAsList(classSequence, beanClass);

	// start with superclasses and go down the hierarchy so that
	// the child classes are processed last to have the chance to
	// overwrite some declarations
	// of their superclasses and that they see what they inherit at the
	// time of processing
	for (int i = classSequence.size() - 1; i >= 0; i--) {
	Class<?> eachClass = classSequence.get(i);
	processClass(eachClass, metabean);
	processGroupSequence(eachClass, metabean, "{GroupSequence:" + eachClass.getCanonicalName() + "}");
	}

	} catch (IllegalAccessException e) {
	throw new IllegalArgumentException(e);
	} catch (InvocationTargetException e) {
	throw new IllegalArgumentException(e.getTargetException());
	}
	}

	/**
	* Process class annotations, field and method annotations.
	*
	* @param beanClass
	* @param metabean
	* @throws IllegalAccessException
	* @throws InvocationTargetException
	*/
	private void processClass(Class<?> beanClass, MetaBean metabean) throws IllegalAccessException,
	InvocationTargetException {

	// if NOT ignore class level annotations
	if (!factoryContext.getFactory().getAnnotationIgnores().isIgnoreAnnotations(beanClass)) {
	annotationProcessor.processAnnotations(null, beanClass, beanClass, null, new AppendValidationToMeta(
	metabean));
	}

	final Field[] fields = doPrivileged(SecureActions.getDeclaredFields(beanClass));
	for (Field field : fields) {
	MetaProperty metaProperty = metabean.getProperty(field.getName());
	// create a property for those fields for which there is not yet a
	// MetaProperty
	if (!factoryContext.getFactory().getAnnotationIgnores().isIgnoreAnnotations(field)) {
	AccessStrategy access = new FieldAccess(field);
	boolean create = metaProperty == null;
	if (create) {
	metaProperty = addMetaProperty(metabean, access);
	}
	if (!annotationProcessor.processAnnotations(metaProperty, beanClass, field, access,
	new AppendValidationToMeta(metaProperty)) && create) {
	metabean.putProperty(metaProperty.getName(), null);
	}
	}
	}
	final Method[] methods = doPrivileged(SecureActions.getDeclaredMethods(beanClass));
	for (Method method : methods) {
	String propName = null;
	if (method.getParameterTypes().length == 0) {
	propName = MethodAccess.getPropertyName(method);
	}
	if (propName != null) {
	if (!factoryContext.getFactory().getAnnotationIgnores().isIgnoreAnnotations(method)) {
	AccessStrategy access = new MethodAccess(propName, method);
	MetaProperty metaProperty = metabean.getProperty(propName);
	boolean create = metaProperty == null;
	// create a property for those methods for which there is
	// not yet a MetaProperty
	if (create) {
	metaProperty = addMetaProperty(metabean, access);
	}
	if (!annotationProcessor.processAnnotations(metaProperty, beanClass, method, access,
	new AppendValidationToMeta(metaProperty)) && create) {
	metabean.putProperty(propName, null);
	}
	}
	} else if (hasValidationConstraintsDefined(method)) {
	throw new ValidationException("Property " + method.getName() + " does not follow javabean conventions.");
	}
	}

	addXmlConstraints(beanClass, metabean);
	}

	/**
	* Learn whether a given Method has validation constraints defined via JSR303 annotations.
	*
	* @param method
	* @return <code>true</code> if constraints detected
	*/
	protected boolean hasValidationConstraintsDefined(Method method) {
	for (Annotation annot : method.getDeclaredAnnotations()) {
	if (hasValidationConstraintsDefined(annot)) {
	return true;
	}
	}
	return false;
	}

	private boolean hasValidationConstraintsDefined(Annotation annot) {
	// If it is annotated with @Constraint
	if (annot.annotationType().getAnnotation(Constraint.class) != null) {
	return true;
	}

	// Check whether it is a multivalued constraint:
	if (ConstraintAnnotationAttributes.VALUE.isDeclaredOn(annot.annotationType())) {
	Annotation[] children = ConstraintAnnotationAttributes.VALUE.getValue(annot);
	if (children != null) {
	for (Annotation child : children) {
	if (hasValidationConstraintsDefined(child)) {
	return true;
	}
	}
	}
	}

	return false;
	}

	/**
	* Add cascade validation and constraints from xml mappings
	*
	* @param beanClass
	* @param metabean
	* @throws IllegalAccessException
	* @throws InvocationTargetException
	*/
	private void addXmlConstraints(Class<?> beanClass, MetaBean metabean) throws IllegalAccessException,
	InvocationTargetException {
	for (MetaConstraint<?, ? extends Annotation> meta : factoryContext.getFactory().getMetaConstraints(beanClass)) {
	MetaProperty metaProperty;
	AccessStrategy access = meta.getAccessStrategy();
	boolean create = false;
	if (access == null) { // class level
	metaProperty = null;
	} else { // property level
	metaProperty = metabean.getProperty(access.getPropertyName());
	create = metaProperty == null;
	if (create) {
	metaProperty = addMetaProperty(metabean, access);
	}
	}
	if (!annotationProcessor.processAnnotation(meta.getAnnotation(), metaProperty, beanClass,
	meta.getAccessStrategy(), new AppendValidationToMeta(metaProperty == null ? metabean : metaProperty))
	&& create) {
	metabean.putProperty(access.getPropertyName(), null);
	}
	}
	for (AccessStrategy access : factoryContext.getFactory().getValidAccesses(beanClass)) {
	MetaProperty metaProperty = metabean.getProperty(access.getPropertyName());
	boolean create = metaProperty == null;
	if (create) {
	metaProperty = addMetaProperty(metabean, access);
	}
	if (!annotationProcessor.addAccessStrategy(metaProperty, access) && create) {
	metabean.putProperty(access.getPropertyName(), null);
	}
	}
	}

	private void processGroupSequence(Class<?> beanClass, MetaBean metabean) {
	processGroupSequence(beanClass, metabean, Jsr303Features.Bean.GROUP_SEQUENCE);
	}

	private void processGroupSequence(Class<?> beanClass, MetaBean metabean, String key) {
	GroupSequence annotation = beanClass.getAnnotation(GroupSequence.class);
	List<Group> groupSeq = metabean.getFeature(key);
	if (groupSeq == null) {
	groupSeq = new ArrayList<Group>(annotation == null ? 1 : annotation.value().length);
	metabean.putFeature(key, groupSeq);
	}
	Class<?>[] groupClasses = factoryContext.getFactory().getDefaultSequence(beanClass);
	if (groupClasses == null \|\| groupClasses.length == 0) {
	if (annotation == null) {
	groupSeq.add(Group.DEFAULT);
	return;
	} else {
	groupClasses = annotation.value();
	}
	}
	boolean containsDefault = false;
	for (Class<?> groupClass : groupClasses) {
	if (groupClass.getName().equals(beanClass.getName())) {
	groupSeq.add(Group.DEFAULT);
	containsDefault = true;
	} else if (groupClass.getName().equals(Default.class.getName())) {
	throw new GroupDefinitionException("'Default.class' must not appear in @GroupSequence! Use '"
	+ beanClass.getSimpleName() + ".class' instead.");
	} else {
	groupSeq.add(new Group(groupClass));
	}
	}
	if (!containsDefault) {
	throw new GroupDefinitionException("Redefined default group sequence must contain " + beanClass.getName());
	}
	log.log(Level.FINEST, String.format("Default group sequence for bean %s is: %s", beanClass.getName(), groupSeq));
	}

	/**
	* Add a {@link MetaProperty} to a {@link MetaBean}.
	* @param parentMetaBean
	* @param access
	* @return the created {@link MetaProperty}
	*/
	public static MetaProperty addMetaProperty(MetaBean parentMetaBean, AccessStrategy access) {
	final MetaProperty result = new MetaProperty();
	final String name = access.getPropertyName();
	result.setName(name);
	result.setType(access.getJavaType());
	parentMetaBean.putProperty(name, result);
	return result;
	}




	/**
	* Perform action with AccessController.doPrivileged() if a security manager is installed.
	*
	* @param action
	* the action to run
	* @return
	* result of the action
	*/
	private static <T> T doPrivileged(final PrivilegedAction<T> action) {
	if (System.getSecurityManager() != null) {
	return AccessController.doPrivileged(action);
	} else {
	return action.run();
	}
	}
	}