java类javax.persistence.Embeddable的实例源码

@Test
public void testStaticWeaving() {
    // first, scan for all files on the classpath with an @Entity or @MappedSuperClass annotation
    Reflections reflections = new Reflections(getClass().getPackage().getName());
    Set<Class<?>> entityTypes = reflections.getTypesAnnotatedWith(Entity.class, true);
    Set<Class<?>> superTypes = reflections.getTypesAnnotatedWith(MappedSuperclass.class, true);
    Set<Class<?>> embeddableTypes = reflections.getTypesAnnotatedWith(Embeddable.class, true);

    // next, let's assert that they have been statically weaved
    assertStaticWeaved(entityTypes, superTypes, embeddableTypes);
}

/**
 * Determines if a given annotation set contains annotations that correspond to ones that someone would expect to appear
 * in a persistence.xml
 * 
 * @param annotations
 * @return
 */
protected boolean containsTypeLevelPersistenceAnnotation(Annotation[] annotations) {
    for (Annotation annotation : annotations) {
        if (annotation.getTypeName().equals(Entity.class.getName())
                || annotation.getTypeName().equals(Embeddable.class.getName())
                || annotation.getTypeName().equals(MappedSuperclass.class.getName())) {
            return true;
        }
    }
    return false;
}

@Override
public void evaluate(Method method, EvaluatorChain chain) {
    if (method.getReturnType().isAnnotationPresent(Embeddable.class) &&
            !method.isAnnotationPresent(Transient.class)) {
        Map<String, AttributeOverride> overrides = getAttributeOverrides(method);

        Class<?> embeddedClz = method.getReturnType();
        for (Method embeddedMethod : Arrays.stream(embeddedClz.getMethods()) //
                .filter(it -> it.isAnnotationPresent(Column.class)) //
                .collect(toList())) {
            String name = getPropertyName(embeddedMethod);
            String columnName = null;
            if (overrides.containsKey(name)) {
                columnName = overrides.get(name).column().name();
            } else {
                columnName = embeddedMethod.getAnnotation(Column.class).name();
            }
            CopyAttribute attribute = new CopyAttribute();
            attribute.getMethods().add(method);
            attribute.getMethods().add(embeddedMethod);
            attribute.setColumnName(columnName);
            chain.add(attribute);
        }
    } else {
        chain.doNext();
    }
}

/**
 * Determines if a given annotation set contains annotations that correspond to ones that someone would expect to appear
 * in a persistence.xml
 * 
 * @param annotations
 * @return
 */
protected boolean containsTypeLevelPersistenceAnnotation(Annotation[] annotations) {
    for (Annotation annotation : annotations) {
        if (annotation.getTypeName().equals(Entity.class.getName())
                || annotation.getTypeName().equals(Embeddable.class.getName())
                || annotation.getTypeName().equals(MappedSuperclass.class.getName())) {
            return true;
        }
    }
    return false;
}

@Override
public Set<String> getSupportedAnnotationTypes() {

  Set<String> annotations = new LinkedHashSet<>();
  annotations.add(Entity.class.getCanonicalName());
  annotations.add(Embeddable.class.getCanonicalName());
  return annotations;
}

public boolean isRootClass(Class<?> theClass) {
    final boolean notMappedSuperclassAndNotEmbeddable = theClass
            .getAnnotation(MappedSuperclass.class) == null
            && theClass.getAnnotation(Embeddable.class) == null;
    if (theClass.getSuperclass() != null) {
        return notMappedSuperclassAndNotEmbeddable
                && !isSelfOrAncestorRootClass(theClass.getSuperclass());
    } else {
        return notMappedSuperclassAndNotEmbeddable;
    }
}

public boolean isSelfOrAncestorRootClass(Class<?> theClass) {
    if (isRootClass(theClass)) {
        return true;
    } else if (theClass.getSuperclass() != null) {
        return isSelfOrAncestorRootClass(theClass.getSuperclass());
    } else {
        return theClass.getAnnotation(MappedSuperclass.class) == null
                && theClass.getAnnotation(Embeddable.class) == null;
    }
}

private boolean isEntity(Class type) {
    if (RPolyString.class.isAssignableFrom(type)) {
        //it's hibernate entity but from prism point of view it's property
        return false;
    }
    return type.getAnnotation(Entity.class) != null || type.getAnnotation(Embeddable.class) != null;
}

@Override
public void evaluate(Method method, EvaluatorChain chain) {
    if (method.getReturnType().isAnnotationPresent(Embeddable.class) &&
            !method.isAnnotationPresent(Transient.class)) {
        Map<String, AttributeOverride> overrides = getAttributeOverrides(method);

        Class<?> embeddedClz = method.getReturnType();
        for (Method embeddedMethod : Arrays.stream(embeddedClz.getMethods()) //
                .filter(it -> it.isAnnotationPresent(Column.class)) //
                .collect(toList())) {
            String name = getPropertyName(embeddedMethod);
            String columnName = null;
            if (overrides.containsKey(name)) {
                columnName = overrides.get(name).column().name();
            } else {
                columnName = embeddedMethod.getAnnotation(Column.class).name();
            }
            CopyAttribute attribute = new CopyAttribute();
            attribute.getMethods().add(method);
            attribute.getMethods().add(embeddedMethod);
            attribute.setColumnName(columnName);
            chain.add(attribute);
        }
    } else {
        chain.doNext();
    }
}

/**
 * Scans for *.orm.xml and adds Entites from classpath.
 *
 * @param pui
 *            the pui
 */
@Override
public void postProcessPersistenceUnitInfo( MutablePersistenceUnitInfo pui )
{
    _Log.info( "Scanning for JPA orm.xml files" );

    for ( File ormFile : getListORMFiles( ) )
    {
        String ormAbsolutePath = ormFile.getAbsolutePath( );
        _Log.info( "Found ORM file : " + ormAbsolutePath );
        pui.addMappingFileName( ormAbsolutePath.substring( ormAbsolutePath.indexOf( CLASSPATH_PATH_IDENTIFIER ) ) );
    }

    _Log.info( "Scanning for JPA entities..." );

    Set<String> entityClasses = AnnotationUtil.find( Entity.class.getName( ) );
    entityClasses.addAll( AnnotationUtil.find( Embeddable.class.getName( ) ) );
    entityClasses.addAll( AnnotationUtil.find( MappedSuperclass.class.getName( ) ) );

    for ( String strClass : entityClasses )
    {
        _Log.info( "Found entity class : " + strClass );

        if ( !pui.getManagedClassNames( ).contains( strClass ) )
        {
            pui.addManagedClassName( strClass );
        }
    }

    if ( _Log.isDebugEnabled( ) )
    {
        dumpPersistenceUnitInfo( pui );
    }
}