Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * Copyright 2011-2014 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.springframework.data.mongodb.config;
 
 import static org.springframework.data.mongodb.config.BeanNames.*;
 
 import java.util.List;
 import java.util.Set;
 
 import  org.springframework.beans.BeanMetadataElement;
 import  org.springframework.beans.factory.NoSuchBeanDefinitionException;
 import  org.springframework.beans.factory.config.BeanDefinition;
 import  org.springframework.beans.factory.config.BeanDefinitionHolder;
 import  org.springframework.beans.factory.config.RuntimeBeanReference;
 import  org.springframework.beans.factory.parsing.BeanComponentDefinition;
 import  org.springframework.beans.factory.parsing.CompositeComponentDefinition;
 import  org.springframework.beans.factory.support.AbstractBeanDefinition;
 import  org.springframework.beans.factory.support.BeanDefinitionBuilder;
 import  org.springframework.beans.factory.support.BeanDefinitionRegistry;
 import  org.springframework.beans.factory.support.GenericBeanDefinition;
 import  org.springframework.beans.factory.support.ManagedList;
 import  org.springframework.beans.factory.support.ManagedSet;
 import  org.springframework.beans.factory.support.RootBeanDefinition;
 import  org.springframework.beans.factory.xml.AbstractBeanDefinitionParser;
 import  org.springframework.beans.factory.xml.BeanDefinitionParser;
 import  org.springframework.beans.factory.xml.ParserContext;
 import  org.springframework.context.annotation.ClassPathScanningCandidateComponentProvider;
 import  org.springframework.core.convert.converter.Converter;
 import  org.springframework.core.convert.converter.GenericConverter;
 import  org.springframework.core.type.classreading.MetadataReader;
 import  org.springframework.core.type.classreading.MetadataReaderFactory;
 import  org.springframework.core.type.filter.AnnotationTypeFilter;
 import  org.springframework.core.type.filter.AssignableTypeFilter;
 import  org.springframework.core.type.filter.TypeFilter;
 import  org.springframework.util.Assert;
 import  org.springframework.util.ClassUtils;
 import  org.springframework.util.StringUtils;
 import  org.springframework.util.xml.DomUtils;
Bean definition parser for the mapping-converter element.

Author(s):
Jon Brisbin
Oliver Gierke
Maciej Walkowiak
Thomas Darimont
 
 public class MappingMongoConverterParser implements BeanDefinitionParser {
 
 	private static final String BASE_PACKAGE = "base-package";
 	private static final boolean JSR_303_PRESENT = ClassUtils.isPresent("javax.validation.Validator",
 
 	/* (non-Javadoc)
 	 * @see org.springframework.beans.factory.xml.BeanDefinitionParser#parse(org.w3c.dom.Element, org.springframework.beans.factory.xml.ParserContext)
 	 */
 	public BeanDefinition parse(Element element, ParserContext parserContext) {
 
 		BeanDefinitionRegistry registry = parserContext.getRegistry();
 
 		String id = element.getAttribute(AbstractBeanDefinitionParser.ID_ATTRIBUTE);
 		id = StringUtils.hasText(id) ? id : "mappingConverter";
 
 		parserContext.pushContainingComponent(new CompositeComponentDefinition("Mapping Mongo Converter"element));
 
 		BeanDefinition conversionsDefinition = getCustomConversions(elementparserContext);
 		String ctxRef = potentiallyCreateMappingContext(elementparserContextconversionsDefinitionid);
 
 		createIsNewStrategyFactoryBeanDefinition(ctxRefparserContextelement);
 
 		// Need a reference to a Mongo instance
 		String dbFactoryRef = element.getAttribute("db-factory-ref");
		if (!StringUtils.hasText(dbFactoryRef)) {
			dbFactoryRef = ;
		}
		// Converter
		BeanDefinitionBuilder converterBuilder = BeanDefinitionBuilder.genericBeanDefinition(MappingMongoConverter.class);
		converterBuilder.addConstructorArgReference(dbFactoryRef);
		converterBuilder.addConstructorArgReference(ctxRef);
		String typeMapperRef = element.getAttribute("type-mapper-ref");
		if (StringUtils.hasText(typeMapperRef)) {
			converterBuilder.addPropertyReference("typeMapper"typeMapperRef);
		}
		if (conversionsDefinition != null) {
			converterBuilder.addPropertyValue("customConversions"conversionsDefinition);
		}
		try {
			registry.getBeanDefinition();
catch (NoSuchBeanDefinitionException ignored) {
			if (!StringUtils.hasText(dbFactoryRef)) {
				dbFactoryRef = ;
			}
			BeanDefinitionBuilder indexHelperBuilder = BeanDefinitionBuilder
					.genericBeanDefinition(MongoPersistentEntityIndexCreator.class);
			indexHelperBuilder.addConstructorArgReference(ctxRef);
			indexHelperBuilder.addConstructorArgReference(dbFactoryRef);
			indexHelperBuilder.addDependsOn(ctxRef);
			parserContext.registerBeanComponent(new BeanComponentDefinition(indexHelperBuilder.getBeanDefinition(),
		}
		BeanDefinition validatingMongoEventListener = potentiallyCreateValidatingMongoEventListener(elementparserContext);
		if (validatingMongoEventListener != null) {
			parserContext.registerBeanComponent(new BeanComponentDefinition(validatingMongoEventListener,
		}
		parserContext.registerBeanComponent(new BeanComponentDefinition(converterBuilder.getBeanDefinition(), id));
		parserContext.popAndRegisterContainingComponent();
		return null;
	}
	private BeanDefinition potentiallyCreateValidatingMongoEventListener(Element element, ParserContext parserContext) {
		String disableValidation = element.getAttribute("disable-validation");
		boolean validationDisabled = StringUtils.hasText(disableValidation) && Boolean.valueOf(disableValidation);
		if (!validationDisabled) {
			BeanDefinitionBuilder builder = BeanDefinitionBuilder.genericBeanDefinition();
			RuntimeBeanReference validator = getValidator(builderparserContext);
			if (validator != null) {
				builder.getRawBeanDefinition().setBeanClass(ValidatingMongoEventListener.class);
				builder.addConstructorArgValue(validator);
				return builder.getBeanDefinition();
			}
		}
		return null;
	}
	private RuntimeBeanReference getValidator(Object source, ParserContext parserContext) {
			return null;
		}
		RootBeanDefinition validatorDef = new RootBeanDefinition(
				"org.springframework.validation.beanvalidation.LocalValidatorFactoryBean");
		validatorDef.setSource(source);
		validatorDef.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);
		String validatorName = parserContext.getReaderContext().registerWithGeneratedName(validatorDef);
		parserContext.registerBeanComponent(new BeanComponentDefinition(validatorDefvalidatorName));
		return new RuntimeBeanReference(validatorName);
	}
	static String potentiallyCreateMappingContext(Element element, ParserContext parserContext,
			BeanDefinition conversionsDefinitionString converterId) {
		String ctxRef = element.getAttribute("mapping-context-ref");
		if (StringUtils.hasText(ctxRef)) {
			return ctxRef;
		}
		BeanComponentDefinitionBuilder componentDefinitionBuilder = new BeanComponentDefinitionBuilder(element,
				parserContext);
		BeanDefinitionBuilder mappingContextBuilder = BeanDefinitionBuilder
				.genericBeanDefinition(MongoMappingContext.class);
		Set<StringclassesToAdd = getInititalEntityClasses(element);
		if (classesToAdd != null) {
			mappingContextBuilder.addPropertyValue("initialEntitySet"classesToAdd);
		}
		if (conversionsDefinition != null) {
			AbstractBeanDefinition simpleTypesDefinition = new GenericBeanDefinition();
			simpleTypesDefinition.setFactoryBeanName("customConversions");
			simpleTypesDefinition.setFactoryMethodName("getSimpleTypeHolder");
			mappingContextBuilder.addPropertyValue("simpleTypeHolder"simpleTypesDefinition);
		}
		String abbreviateFieldNames = element.getAttribute("abbreviate-field-names");
		if ("true".equals(abbreviateFieldNames)) {
			mappingContextBuilder.addPropertyValue("fieldNamingStrategy"new RootBeanDefinition(
		}
		ctxRef = converterId + "." + ;
		parserContext.registerBeanComponent(componentDefinitionBuilder.getComponent(mappingContextBuilderctxRef));
		return ctxRef;
	}
	private BeanDefinition getCustomConversions(Element element, ParserContext parserContext) {
		List<ElementcustomConvertersElements = DomUtils.getChildElementsByTagName(element"custom-converters");
		if (customConvertersElements.size() == 1) {
			Element customerConvertersElement = customConvertersElements.get(0);
			ManagedList<BeanMetadataElement> converterBeans = new ManagedList<BeanMetadataElement>();
			List<ElementconverterElements = DomUtils.getChildElementsByTagName(customerConvertersElement"converter");
			if (converterElements != null) {
				for (Element listenerElement : converterElements) {
					converterBeans.add(parseConverter(listenerElementparserContext));
				}
			}
			// Scan for Converter and GenericConverter beans in the given base-package
			String packageToScan = customerConvertersElement.getAttribute();
			if (StringUtils.hasText(packageToScan)) {
				ClassPathScanningCandidateComponentProvider provider = new ClassPathScanningCandidateComponentProvider(true);
				provider.addExcludeFilter(new NegatingFilter(new AssignableTypeFilter(Converter.class),
						new AssignableTypeFilter(GenericConverter.class)));
				for (BeanDefinition candidate : provider.findCandidateComponents(packageToScan)) {
					converterBeans.add(candidate);
				}
			}
			BeanDefinitionBuilder conversionsBuilder = BeanDefinitionBuilder.rootBeanDefinition(CustomConversions.class);
			conversionsBuilder.addConstructorArgValue(converterBeans);
			AbstractBeanDefinition conversionsBean = conversionsBuilder.getBeanDefinition();
			conversionsBean.setSource(parserContext.extractSource(element));
			parserContext.registerBeanComponent(new BeanComponentDefinition(conversionsBean"customConversions"));
			return conversionsBean;
		}
		return null;
	}
	private static Set<StringgetInititalEntityClasses(Element element) {
		String basePackage = element.getAttribute();
		if (!StringUtils.hasText(basePackage)) {
			return null;
		}
		ClassPathScanningCandidateComponentProvider componentProvider = new ClassPathScanningCandidateComponentProvider(
				false);
		componentProvider.addIncludeFilter(new AnnotationTypeFilter(Document.class));
		componentProvider.addIncludeFilter(new AnnotationTypeFilter(Persistent.class));
		Set<Stringclasses = new ManagedSet<String>();
		for (BeanDefinition candidate : componentProvider.findCandidateComponents(basePackage)) {
			classes.add(candidate.getBeanClassName());
		}
		return classes;
	}
	public BeanMetadataElement parseConverter(Element element, ParserContext parserContext) {
		String converterRef = element.getAttribute("ref");
		if (StringUtils.hasText(converterRef)) {
			return new RuntimeBeanReference(converterRef);
		}
		Element beanElement = DomUtils.getChildElementByTagName(element"bean");
		if (beanElement != null) {
			BeanDefinitionHolder beanDef = parserContext.getDelegate().parseBeanDefinitionElement(beanElement);
			beanDef = parserContext.getDelegate().decorateBeanDefinitionIfRequired(beanElementbeanDef);
			return beanDef;
		}
		parserContext.getReaderContext().error(
				"Element <converter> must specify 'ref' or contain a bean definition for the converter"element);
		return null;
	}
	public static String createIsNewStrategyFactoryBeanDefinition(String mappingContextRef, ParserContext context,
			Element element) {
		BeanDefinitionBuilder mappingContextStrategyFactoryBuilder = BeanDefinitionBuilder
				.rootBeanDefinition(MappingContextIsNewStrategyFactory.class);
		mappingContextStrategyFactoryBuilder.addConstructorArgReference(mappingContextRef);
		context.registerBeanComponent(builder.getComponent(mappingContextStrategyFactoryBuilder));
	}

TypeFilter that returns false in case any of the given delegates matches.

Author(s):
Oliver Gierke
	private static class NegatingFilter implements TypeFilter {
		private final Set<TypeFilter> delegates;

Creates a new NegatingFilter with the given delegates.

Parameters:
filters
		public NegatingFilter(TypeFilter... filters) {
			Assert.notNull(filters);
			this. = new HashSet<TypeFilter>(Arrays.asList(filters));
		}
		/*
		 * (non-Javadoc)
		 * @see org.springframework.core.type.filter.TypeFilter#match(org.springframework.core.type.classreading.MetadataReader, org.springframework.core.type.classreading.MetadataReaderFactory)
		 */
		public boolean match(MetadataReader metadataReader, MetadataReaderFactory metadataReaderFactorythrows IOException {
			for (TypeFilter delegate : ) {
				if (delegate.match(metadataReadermetadataReaderFactory)) {
					return false;
				}
			}
			return true;
		}
	}
New to GrepCode? Check out our FAQ X