Java Document类代码示例

import org.springframework.data.mongodb.core.mapping.Document; //导入依赖的package包/类
private static Set<String> getInititalEntityClasses(String[] domainPackages) {
    if (ArrayUtils.isEmpty(domainPackages)) {
        return null;
    }

    ClassPathScanningCandidateComponentProvider componentProvider = new ClassPathScanningCandidateComponentProvider(false);
    componentProvider.addIncludeFilter(new AnnotationTypeFilter(Document.class));
    componentProvider.addIncludeFilter(new AnnotationTypeFilter(Persistent.class));

    Set<String> classes = new ManagedSet<>();
    for (String domainPackage : domainPackages) {
        if (StringUtils.isBlank(domainPackage)) {
            continue;
        }
        for (BeanDefinition candidate : componentProvider.findCandidateComponents(domainPackage)) {
            classes.add(candidate.getBeanClassName());
        }
    }

    return classes;
}
 

import org.springframework.data.mongodb.core.mapping.Document; //导入依赖的package包/类
protected Set<Class<?>> getInitialEntitySet() throws ClassNotFoundException {

        String basePackage = getMappingBasePackage();
        Set<Class<?>> initialEntitySet = new HashSet<Class<?>>();

        if (StringUtils.hasText(basePackage)) {
            ClassPathScanningCandidateComponentProvider componentProvider = new ClassPathScanningCandidateComponentProvider(
                    false);
            componentProvider.addIncludeFilter(new AnnotationTypeFilter(Document.class));
            componentProvider.addIncludeFilter(new AnnotationTypeFilter(Persistent.class));

            for (BeanDefinition candidate : componentProvider.findCandidateComponents(basePackage)) {
                initialEntitySet.add(ClassUtils.forName(candidate.getBeanClassName(),
                        this.getClass().getClassLoader()));
            }
        }

        return initialEntitySet;
    }
 

import org.springframework.data.mongodb.core.mapping.Document; //导入依赖的package包/类
protected String deriveCollectionName(Class className) throws InvalidAggregationQueryException {

    Document documentAnnotation = AnnotationUtils.findAnnotation(className, Document.class);
    String collectionName;
    if (documentAnnotation != null) {
      collectionName = documentAnnotation.collection();
      if(StringUtils.isEmpty(collectionName)) {
        collectionName = getSimpleCollectionName(className);
      }
      else {
        Expression expression = detectExpression(collectionName);
        if(expression != null) {
          collectionName = expression.getValue(context, String.class);
        }
      }
    }
    else {
      collectionName = getSimpleCollectionName(className);
    }

    Assert.notNull(collectionName);
    return collectionName;
  }
 

import org.springframework.data.mongodb.core.mapping.Document; //导入依赖的package包/类
private Set<Class<?>> getInitialEntitySet(BeanFactory beanFactory)
		throws ClassNotFoundException {
	Set<Class<?>> entitySet = new HashSet<Class<?>>();
	ClassPathScanningCandidateComponentProvider scanner = new ClassPathScanningCandidateComponentProvider(
			false);
	scanner.setEnvironment(this.environment);
	scanner.setResourceLoader(this.resourceLoader);
	scanner.addIncludeFilter(new AnnotationTypeFilter(Document.class));
	scanner.addIncludeFilter(new AnnotationTypeFilter(Persistent.class));
	for (String basePackage : getMappingBasePackages(beanFactory)) {
		if (StringUtils.hasText(basePackage)) {
			for (BeanDefinition candidate : scanner
					.findCandidateComponents(basePackage)) {
				entitySet.add(ClassUtils.forName(candidate.getBeanClassName(),
						this.classLoader));
			}
		}
	}
	return entitySet;
}
 

import org.springframework.data.mongodb.core.mapping.Document; //导入依赖的package包/类
private static String determineCollectionName(Class<?> entityClass) {
	if (entityClass == null) {
		throw new InvalidDataAccessApiUsageException(
				"No class parameter provided, entity collection can't be determined!");
	}
	String collName = entityClass.getSimpleName();
	if (entityClass.isAnnotationPresent(Document.class)) {
		Document document = entityClass.getAnnotation(Document.class);
		collName = document.collection();
	} else {
		collName = collName.replaceFirst(collName.substring(0, 1), collName.substring(0, 1).toLowerCase());
	}
	return collName;
}
 

import org.springframework.data.mongodb.core.mapping.Document; //导入依赖的package包/类
@Bean
@ConditionalOnMissingBean
public MongoMappingContext mongoMappingContext(BeanFactory beanFactory)
		throws ClassNotFoundException {
	MongoMappingContext context = new MongoMappingContext();
	context.setInitialEntitySet(new EntityScanner(this.applicationContext)
			.scan(Document.class, Persistent.class));
	Class<?> strategyClass = this.properties.getFieldNamingStrategy();
	if (strategyClass != null) {
		context.setFieldNamingStrategy(
				(FieldNamingStrategy) BeanUtils.instantiate(strategyClass));
	}
	return context;
}
 

import org.springframework.data.mongodb.core.mapping.Document; //导入依赖的package包/类
@PostConstruct
public void init() {
    Class<ImMessage> messageClass = ImMessage.class;
    Document annotation = messageClass.getAnnotation(Document.class);
    collectionName = annotation == null ? messageClass.getSimpleName() : annotation.collection();
    messageCollection = messageDb.getCollection(collectionName);
}
 

import org.springframework.data.mongodb.core.mapping.Document; //导入依赖的package包/类
public static final String getCollectionName(final Class<?> clazz) {
	String collection = null;
	if (clazz != null) {
		final Annotation annotation = clazz.getAnnotation(Document.class);
		if (annotation instanceof Document) {
			collection = ((Document)annotation).collection();
		}
		if (isBlank(collection)) collection = uncapitalize(clazz.getSimpleName());
	}
	return collection;
}