org.hibernate.validator.engine.ValidatorFactoryImpl Maven / Gradle / Ivy

Go to download
// $Id$
/*
* JBoss, Home of Professional Open Source
* Copyright 2009, Red Hat, Inc. and/or its affiliates, and individual contributors
* by the @authors tag. See the copyright.txt in the distribution for a
* full listing of individual contributors.
*
* 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.hibernate.validator.engine;

import java.io.InputStream;
import java.lang.annotation.Annotation;
import java.lang.reflect.Member;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import javax.validation.ConstraintValidatorFactory;
import javax.validation.MessageInterpolator;
import javax.validation.TraversableResolver;
import javax.validation.ValidationException;
import javax.validation.Validator;
import javax.validation.ValidatorContext;
import javax.validation.ValidatorFactory;
import javax.validation.spi.ConfigurationState;

import org.hibernate.validator.cfg.CascadeDef;
import org.hibernate.validator.cfg.ConstraintDefWrapper;
import org.hibernate.validator.cfg.ConstraintMapping;
import org.hibernate.validator.metadata.AnnotationIgnores;
import org.hibernate.validator.metadata.BeanMetaDataCache;
import org.hibernate.validator.metadata.BeanMetaDataImpl;
import org.hibernate.validator.metadata.ConstraintDescriptorImpl;
import org.hibernate.validator.metadata.ConstraintHelper;
import org.hibernate.validator.metadata.ConstraintOrigin;
import org.hibernate.validator.metadata.MetaConstraint;
import org.hibernate.validator.util.ReflectionHelper;
import org.hibernate.validator.util.annotationfactory.AnnotationDescriptor;
import org.hibernate.validator.util.annotationfactory.AnnotationFactory;
import org.hibernate.validator.xml.XmlMappingParser;

/**
 * Factory returning initialized {@code Validator} instances. This is Hibernate Validator's default
 * implementation of the {@code ValidatorFactory} interface.
 *
 * @author Emmanuel Bernard
 * @author Hardy Ferentschik
 */
public class ValidatorFactoryImpl implements ValidatorFactory {

	private final MessageInterpolator messageInterpolator;
	private final TraversableResolver traversableResolver;
	private final ConstraintValidatorFactory constraintValidatorFactory;
	private final ConstraintHelper constraintHelper;

	/**
	 * Used to cache the constraint meta data for validated entities
	 */
	private final BeanMetaDataCache beanMetaDataCache;

	public ValidatorFactoryImpl(ConfigurationState configurationState) {

		this.messageInterpolator = configurationState.getMessageInterpolator();
		this.constraintValidatorFactory = configurationState.getConstraintValidatorFactory();
		this.traversableResolver = configurationState.getTraversableResolver();
		this.constraintHelper = new ConstraintHelper();
		this.beanMetaDataCache = new BeanMetaDataCache();

		// HV-302; don't load XmlMappingParser if not necessary
		if ( !configurationState.getMappingStreams().isEmpty() ) {
			initXmlConfiguration( configurationState.getMappingStreams() );
		}

		if ( configurationState instanceof ConfigurationImpl ) {
			ConfigurationImpl hibernateSpecificConfig = ( ConfigurationImpl ) configurationState;
			if ( hibernateSpecificConfig.getMapping() != null ) {
				initProgrammaticConfiguration( hibernateSpecificConfig.getMapping() );
			}
		}
	}

	public Validator getValidator() {
		return usingContext().getValidator();
	}

	public MessageInterpolator getMessageInterpolator() {
		return messageInterpolator;
	}

	public TraversableResolver getTraversableResolver() {
		return traversableResolver;
	}

	public ConstraintValidatorFactory getConstraintValidatorFactory() {
		return constraintValidatorFactory;
	}

	public  T unwrap(Class type) {
		throw new ValidationException( "Type " + type + " not supported" );
	}

	public ValidatorContext usingContext() {
		return new ValidatorContextImpl(
				constraintValidatorFactory,
				messageInterpolator,
				traversableResolver,
				constraintHelper,
				beanMetaDataCache
		);
	}

	/**
	 * Reads the configuration from {@code mapping} and creates the appropriate meta-data structures.
	 *
	 * @param mapping The constraint configuration created via the programmatic API.
	 */
	private  void initProgrammaticConfiguration(ConstraintMapping mapping) {
		for ( Class clazz : mapping.getConfiguredClasses() ) {
			@SuppressWarnings("unchecked")
			Class beanClass = ( Class ) clazz;

			// for each configured entity we have to check whether any of the interfaces or super classes is configured
			// vua the programmatic api as well
			List> classes = ReflectionHelper.computeClassHierarchy( beanClass );

			Map, List>> constraints = createEmptyConstraintMap();
			List cascadedMembers = new ArrayList();

			for ( Class classInHierarchy : classes ) {
				// if the programmatic config contains constraints for the class in the hierarchy create a meta constraint
				if ( mapping.getConstraintConfig().keySet().contains( classInHierarchy ) ) {
					addProgrammaticConfiguredConstraints(
							mapping.getConstraintConfig().get( classInHierarchy ),
							beanClass,
							classInHierarchy,
							constraints
					);
				}

				if ( mapping.getCascadeConfig().keySet().contains( classInHierarchy ) ) {
					addProgrammaticConfiguredCascade(
							mapping.getCascadeConfig().get( classInHierarchy ), cascadedMembers
					);
				}
			}

			BeanMetaDataImpl metaData = new BeanMetaDataImpl(
					beanClass,
					constraintHelper,
					mapping.getDefaultSequence( beanClass ),
					constraints,
					cascadedMembers,
					new AnnotationIgnores(),
					beanMetaDataCache
			);

			beanMetaDataCache.addBeanMetaData( beanClass, metaData );
		}
	}

	private  void initXmlConfiguration(Set mappingStreams) {

		XmlMappingParser mappingParser = new XmlMappingParser( constraintHelper );
		mappingParser.parse( mappingStreams );

		Set> xmlConfiguredClasses = mappingParser.getXmlConfiguredClasses();
		AnnotationIgnores annotationIgnores = mappingParser.getAnnotationIgnores();
		for ( Class clazz : xmlConfiguredClasses ) {
			@SuppressWarnings("unchecked")
			Class beanClass = ( Class ) clazz;

			List> classes = ReflectionHelper.computeClassHierarchy( beanClass );
			Map, List>> constraints = createEmptyConstraintMap();
			List cascadedMembers = new ArrayList();
			// we need to collect all constraints which apply for a single class. Due to constraint inheritance
			// some constraints might be configured in super classes or interfaces. The xml configuration does not
			// imply any order so we have to check whether any of the super classes or interfaces of a given bean has
			// as well been configured via xml
			for ( Class classInHierarchy : classes ) {
				if ( xmlConfiguredClasses.contains( classInHierarchy ) ) {
					addXmlConfiguredConstraints( mappingParser, beanClass, classInHierarchy, constraints );
					addXmlCascadedMember( mappingParser, classInHierarchy, cascadedMembers );
				}
			}

			BeanMetaDataImpl metaData = new BeanMetaDataImpl(
					beanClass,
					constraintHelper,
					mappingParser.getDefaultSequenceForClass( beanClass ),
					constraints,
					cascadedMembers,
					annotationIgnores,
					beanMetaDataCache
			);

			beanMetaDataCache.addBeanMetaData( beanClass, metaData );
		}
	}

	@SuppressWarnings("unchecked")
	private  void addXmlConfiguredConstraints(XmlMappingParser mappingParser,
																	   Class rootClass,
																	   Class hierarchyClass, Map, List>> constraints) {
		for ( MetaConstraint constraint : mappingParser.getConstraintsForClass( hierarchyClass ) ) {
			ConstraintOrigin definedIn = definedIn( rootClass, hierarchyClass );
			ConstraintDescriptorImpl descriptor = new ConstraintDescriptorImpl(
					( A ) constraint.getDescriptor().getAnnotation(),
					constraintHelper,
					constraint.getElementType(),
					definedIn
			);
			MetaConstraint newMetaConstraint = new MetaConstraint(
					rootClass, constraint.getMember(), descriptor
			);

			addConstraintToMap( hierarchyClass, newMetaConstraint, constraints );
		}
	}

	@SuppressWarnings("unchecked")
	private  void addProgrammaticConfiguredConstraints(List> definitions,
																				Class rootClass, Class hierarchyClass,
																				Map, List>> constraints) {
		for ( ConstraintDefWrapper config : definitions ) {
			A annotation = ( A ) createAnnotationProxy( config );
			ConstraintOrigin definedIn = definedIn( rootClass, hierarchyClass );
			ConstraintDescriptorImpl constraintDescriptor = new ConstraintDescriptorImpl(
					annotation, constraintHelper, config.getElementType(), definedIn
			);

			Member member = null;
			if ( !config.getProperty().isEmpty() ) {
				member = ReflectionHelper.getMember(
						config.getBeanType(), config.getProperty(), config.getElementType()
				);
			}

			MetaConstraint metaConstraint = new MetaConstraint(
					config.getBeanType(), member, constraintDescriptor
			);
			addConstraintToMap( hierarchyClass, metaConstraint, constraints );
		}
	}

	@SuppressWarnings("unchecked")
	private  void addConstraintToMap(Class hierarchyClass,
															  MetaConstraint constraint,
															  Map, List>> constraints) {
		List> constraintList = constraints.get( hierarchyClass );
		if ( constraintList == null ) {
			constraintList = new ArrayList>();
			constraints.put( hierarchyClass, constraintList );
		}
		constraintList.add( constraint );
	}

	private void addXmlCascadedMember(XmlMappingParser mappingParser,
									  Class hierarchyClass,
									  List cascadedMembers) {
		for ( Member m : mappingParser.getCascadedMembersForClass( hierarchyClass ) ) {
			cascadedMembers.add( m );
		}
	}

	private void addProgrammaticConfiguredCascade(List cascades,
												  List cascadedMembers) {
		if ( cascades == null ) {
			return;
		}
		for ( CascadeDef cascade : cascades ) {
			Member m = ReflectionHelper.getMember(
					cascade.getBeanType(), cascade.getProperty(), cascade.getElementType()
			);
			cascadedMembers.add( m );
		}
	}

	/**
	 * @param rootClass The root class. That is the class for which we currently create a  {@code BeanMetaData}
	 * @param hierarchyClass The class on which the current constraint is defined on
	 *
	 * @return Returns {@code ConstraintOrigin.DEFINED_LOCALLY} if the constraint was defined on the root bean,
	 *         {@code ConstraintOrigin.DEFINED_IN_HIERARCHY} otherwise.
	 */
	private ConstraintOrigin definedIn(Class rootClass, Class hierarchyClass) {
		if ( hierarchyClass.equals( rootClass ) ) {
			return ConstraintOrigin.DEFINED_LOCALLY;
		}
		else {
			return ConstraintOrigin.DEFINED_IN_HIERARCHY;
		}
	}

	@SuppressWarnings("unchecked")
	private  Annotation createAnnotationProxy(ConstraintDefWrapper config) {
		Class constraintType = ( Class ) config.getConstraintType();
		AnnotationDescriptor annotationDescriptor = new AnnotationDescriptor( constraintType );
		for ( Map.Entry parameter : config.getParameters().entrySet() ) {
			annotationDescriptor.setValue( parameter.getKey(), parameter.getValue() );
		}

		A annotation;
		try {
			annotation = AnnotationFactory.create( annotationDescriptor );
		}
		catch ( RuntimeException e ) {
			throw new ValidationException(
					"Unable to create annotation for configured constraint: " + e.getMessage(), e
			);
		}
		return annotation;
	}

	private  Map, List>> createEmptyConstraintMap() {
		return new HashMap, List>>();
	}
}