Java Entity类代码示例

import org.mongodb.morphia.annotations.Entity; //导入依赖的package包/类
@Bean
public Datastore datastore(Morphia morphia) throws ClassNotFoundException, IOException {

    List<String> packageNamesFromApplication = MorphiaUtils.getApplicationPackageName(applicationContext);

    Set<Class<?>> classes = packageNamesFromApplication
            .parallelStream()
            .flatMap(packageName -> MorphiaUtils.getClasses(packageName).parallelStream())
            .collect(Collectors.toSet());

    classes.parallelStream()
            .filter(clazz -> Objects.nonNull(clazz.getAnnotation(Entity.class)))
            .forEach( clazz ->morphia.map(clazz));

    Datastore dataStore = morphia.createDatastore(mongoClient, mongoTemplate.getDb().getName());
    dataStore.ensureIndexes();
    return dataStore;
}
 

import org.mongodb.morphia.annotations.Entity; //导入依赖的package包/类
protected Configuration createConfiguration(RoundEnvironment roundEnv) {
    Class entities = QueryEntities.class;
    Class entity = Entity.class;
    Class superType = QuerySupertype.class;
    Class embedded = Embedded.class;
    Class skip = Transient.class;
    DefaultConfiguration conf = new DefaultConfiguration(roundEnv, this.processingEnv.getOptions(), Collections.emptySet(), entities, entity, superType, (Class)null, embedded, skip);

    try {
        Class e = Class.forName("com.egopulse.querydsl.mongodb.Point");
        conf.addCustomType(Double[].class, e);
        return conf;
    } catch (ClassNotFoundException var9) {
        throw new IllegalStateException(var9);
    }
}
 

import org.mongodb.morphia.annotations.Entity; //导入依赖的package包/类
/**
 * Creates a Query for the given type and collection
 *
 * @param clazz the type to return
 * @param coll  the collection to query
 * @param ds    the Datastore to use
 */
public QueryImpl(final Class<T> clazz, final DBCollection coll, final Datastore ds) {
    super(CriteriaJoin.AND);

    setQuery(this);
    this.clazz = clazz;
    this.ds = ((org.mongodb.morphia.DatastoreImpl) ds);
    dbColl = coll;
    cache = this.ds.getMapper().createEntityCache();

    final MappedClass mc = this.ds.getMapper().getMappedClass(clazz);
    final Entity entAn = mc == null ? null : mc.getEntityAnnotation();
    if (entAn != null) {
        getOptions().readPreference(this.ds.getMapper().getMappedClass(clazz).getEntityAnnotation().queryNonPrimary()
                   ? ReadPreference.secondaryPreferred()
                   : null);
    }
}
 

import org.mongodb.morphia.annotations.Entity; //导入依赖的package包/类
@Override
@Deprecated
public DBObject getFieldsObject() {
    DBObject projection = getOptions().getProjection();
    if (projection == null || projection.keySet().size() == 0) {
        return null;
    }

    final MappedClass mc = ds.getMapper().getMappedClass(clazz);

    Entity entityAnnotation = mc.getEntityAnnotation();
    final BasicDBObject fieldsFilter = copy(projection);

    if (includeFields && entityAnnotation != null && !entityAnnotation.noClassnameStored()) {
        fieldsFilter.put(Mapper.CLASS_NAME_FIELDNAME, 1);
    }

    return fieldsFilter;
}
 

import org.mongodb.morphia.annotations.Entity; //导入依赖的package包/类
@Override
public void check(final Mapper mapper, final MappedClass mc, final Set<ConstraintViolation> ve) {

    if (mc.getEntityAnnotation() != null && mc.getEmbeddedAnnotation() != null) {
        ve.add(new ConstraintViolation(Level.FATAL, mc, getClass(), format("Cannot have both @%s and @%s annotation at class level.",
            Entity.class.getSimpleName(), Embedded.class.getSimpleName())));
    }

}
 

import org.mongodb.morphia.annotations.Entity; //导入依赖的package包/类
/**
 * Update mappings based on fields/annotations.
 */
// TODO: Remove this and make these fields dynamic or auto-set some other way
public void update() {
    embeddedAn = (Embedded) getAnnotation(Embedded.class);
    entityAn = (Entity) getFirstAnnotation(Entity.class);
    // polymorphicAn = (Polymorphic) getAnnotation(Polymorphic.class);
    final List<MappedField> fields = getFieldsAnnotatedWith(Id.class);
    if (fields != null && !fields.isEmpty()) {
        idField = fields.get(0).getField();
    }
}
 

import org.mongodb.morphia.annotations.Entity; //导入依赖的package包/类
@Override
protected void validate(final Class<?> type, final Object value, final List<ValidationFailure> validationFailures) {
    if (value.getClass().getAnnotation(Entity.class) == null) {
        validationFailures.add(new ValidationFailure(format("When type is a Key the value should be an annotated entity. "
                                                            + "Value '%s' was a %s", value, value.getClass())));

    }
}
 

import org.mongodb.morphia.annotations.Entity; //导入依赖的package包/类
/**
 * Gets the write concern for entity or returns the default write concern for this datastore
 *
 * @param clazzOrEntity the class or entity to use when looking up the WriteConcern
 */
private WriteConcern getWriteConcern(final Object clazzOrEntity) {
    WriteConcern wc = defConcern;
    if (clazzOrEntity != null) {
        final Entity entityAnn = getMapper().getMappedClass(clazzOrEntity).getEntityAnnotation();
        if (entityAnn != null && entityAnn.concern().length() != 0) {
            wc = WriteConcern.valueOf(entityAnn.concern());
        }
    }

    return wc;
}
 

import org.mongodb.morphia.annotations.Entity; //导入依赖的package包/类
/**
 * Creates an EntityScanner using the given Morphia instance with the given predicate.
 *
 * @param m         the Morphia instance
 * @param predicate the Predicate to use when determining which classes to map.
 */
public EntityScanner(final Morphia m, final Predicate<String> predicate) {
    Predicate<String> localPredicate = predicate;
    if (localPredicate == null) {
        localPredicate = Predicates.alwaysTrue();
    }
    Assert.parametersNotNull("m, predicate", m, localPredicate);
    final ConfigurationBuilder conf = new ConfigurationBuilder();
    conf.setScanners(new TypeElementsScanner(), new TypeAnnotationsScanner());

    final Set<URL> s = new HashSet<URL>();
    s.addAll(ClasspathHelper.forClassLoader());
    s.addAll(ClasspathHelper.forJavaClassPath());
    final Iterator<URL> iterator = s.iterator();
    while (iterator.hasNext()) {
        final URL url = iterator.next();
        if (url.getPath().endsWith("jnilib")) {
            iterator.remove();
        }
    }
    conf.setUrls(new ArrayList<URL>(s));

    conf.filterInputsBy(localPredicate);
    conf.addScanners(new SubTypesScanner());

    final Reflections r = new Reflections(conf);

    final Set<Class<?>> entities = r.getTypesAnnotatedWith(Entity.class);
    for (final Class<?> c : entities) {
        m.map(c);
    }
}
 

import org.mongodb.morphia.annotations.Entity; //导入依赖的package包/类
/**
 * Return classes from a package name.
 * @param packageName
 * @return list of class
 */
public static Set<Class<?>> getClasses(final String packageName) {
    Reflections reflections = new Reflections(packageName);
    return reflections.getTypesAnnotatedWith(Entity.class);

}
 

import org.mongodb.morphia.annotations.Entity; //导入依赖的package包/类
@Override
public Class entityAnnotation() {
    return (Entity.class);
}
 

import org.mongodb.morphia.annotations.Entity; //导入依赖的package包/类
/**
 * @return the entityAn
 */
public Entity getEntityAnnotation() {
    return entityAn;
}
 

import org.mongodb.morphia.annotations.Entity; //导入依赖的package包/类
/**
 * Returns the @Entity annotation on a Class if present
 *
 * @param c the class to examine
 * @return the annotation.  may be null.
 */
public static Entity getClassEntityAnnotation(final Class c) {
    return getAnnotation(c, Entity.class);
}