javax.persistence.Embeddable的实例源码

项目：lams    文件：Configuration.java   

public AnnotatedClasstype addClasstype(XClass clazz) {
    AnnotatedClasstype type;
    if ( clazz.isAnnotationPresent( Entity.class ) ) {
        type = AnnotatedClasstype.ENTITY;
    }
    else if ( clazz.isAnnotationPresent( Embeddable.class ) ) {
        type = AnnotatedClasstype.EMbedDABLE;
    }
    else if ( clazz.isAnnotationPresent( javax.persistence.MappedSuperclass.class ) ) {
        type = AnnotatedClasstype.EMbedDABLE_SUPERCLASS;
    }
    else {
        type = AnnotatedClasstype.NONE;
    }
    classtypes.put( clazz.getName(),type );
    return type;
}

项目：lams    文件：AbstractPropertyHolder.java   

private void buildHierarchyColumnOverride(XClass element) {
    XClass current = element;
    Map<String,Column[]> columnOverride = new HashMap<String,Column[]>();
    Map<String,JoinColumn[]> joinColumnOverride = new HashMap<String,JoinColumn[]>();
    Map<String,JoinTable> joinTableOverride = new HashMap<String,JoinTable>();
    while ( current != null && !mappings.getReflectionManager().toXClass( Object.class ).equals( current ) ) {
        if ( current.isAnnotationPresent( Entity.class ) || current.isAnnotationPresent( MappedSuperclass.class )
                || current.isAnnotationPresent( Embeddable.class ) ) {
            //FIXME is embeddable override?
            Map<String,Column[]> currentOverride = buildColumnOverride( current,getPath() );
            Map<String,JoinColumn[]> currentJoinOverride = buildJoinColumnOverride( current,JoinTable> currentJoinTableOverride = buildJoinTableOverride( current,getPath() );
            currentOverride.putAll( columnOverride ); //subclasses have precedence over superclasses
            currentJoinOverride.putAll( joinColumnOverride ); //subclasses have precedence over superclasses
            currentJoinTableOverride.putAll( joinTableOverride ); //subclasses have precedence over superclasses
            columnOverride = currentOverride;
            joinColumnOverride = currentJoinOverride;
            joinTableOverride = currentJoinTableOverride;
        }
        current = current.getSuperclass();
    }

    holderColumnOverride = columnOverride.size() > 0 ? columnOverride : null;
    holderJoinColumnOverride = joinColumnOverride.size() > 0 ? joinColumnOverride : null;
    holderJoinTableOverride = joinTableOverride.size() > 0 ? joinTableOverride : null;
}

项目：katharsis-framework    文件：AbstractJpaDataObjectProvider.java   

@Override
public void onInitialized(MetaProviderContext context,MetaElement element) {
    super.onInitialized(context,element);
    if (element.getParent() instanceof MetaJpaDataObject && element instanceof MetaAttribute) {
        MetaAttribute attr = (MetaAttribute) element;
        MetaDataObject parent = attr.getParent();
        Type implementationType = PropertyUtils.getPropertyType(parent.getImplementationClass(),attr.getName());

        Class<?> elementType = getElementType(implementationType);

        boolean jpaObject = attr.isAssociation() || elementType.getAnnotation(Embeddable.class) != null;

        Class<? extends MetaType> MetaClass = jpaObject ? MetaJpaDataObject.class : MetaType.class;
        MetaType MetaType = context.getLookup().getMeta(implementationType,MetaClass);
        attr.setType(MetaType);
    }
}

项目：cibet    文件：DefaultExecutor.java   

@Override
public void jpaResultListQuery(EventMetadata Metadata,Query query,CEntityManager entityManager) {
   List<?> result = new ArrayList<Object>();

   if (!Context.requestScope().isPlaying()) {
      result = query.getResultList();
      for (Object object : result) {
         if (object != null && entityManager.isLoadEager()
               && (object.getClass().getAnnotation(Embeddable.class) != null
                     || object.getClass().getAnnotation(Entity.class) != null)) {
            CibetUtil.loadLazyEntities(object,object.getClass());
            List<Object> references = new ArrayList<Object>();
            references.add(object);
            CibetUtil.deepDetach(object,references);
         }
      }
   }
   Metadata.getResource().setResultObject(result);
}

项目：rice    文件：StaticWeavingTest.java   

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

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

项目：screensaver    文件：ModelTestCoverageTest.java   

public void testModelTestCoverage()
{
  assertNotNull(entityManagerFactory);
  for (ManagedType<?> managedType : entityManagerFactory.getmetamodel().getManagedTypes()) {
    Class<?> entityClass = managedType.getJavaType();
    String entityClassName = entityClass.getSimpleName();
    if (Modifier.isAbstract(entityClass.getModifiers())) {
      continue;
    }
    if (entityClass.getAnnotation(Embeddable.class) != null) {
      continue;
    }
    try {
      Class.forName(entityClass.getName() + "Test");
    }
    catch (ClassNotFoundException e) {
      fail("missing test class for " + entityClassName);
    }
  }
}

项目：lams    文件：AnnotationBinder.java   

private static void processId(
        PropertyHolder propertyHolder,PropertyData inferredData,SimpleValue idValue,HashMap<String,IdGenerator> classGenerators,boolean isIdentifierMapper,Mappings mappings) {
    if ( isIdentifierMapper ) {
        throw new AnnotationException(
                "@IdClass class should not have @Id nor @EmbeddedId properties: "
                        + BinderHelper.getPath( propertyHolder,inferredData )
        );
    }
    XClass returnedClass = inferredData.getClassOrElement();
    XProperty property = inferredData.getproperty();
    //clone classGenerator and override with local values
    HashMap<String,IdGenerator> localGenerators = ( HashMap<String,IdGenerator> ) classGenerators.clone();
    localGenerators.putAll( buildLocalGenerators( property,mappings ) );

    //manage composite related Metadata
    //guess if its a component and find id data access (property,field etc)
    final boolean isComponent = returnedClass.isAnnotationPresent( Embeddable.class )
            || property.isAnnotationPresent( EmbeddedId.class );

    GeneratedValue generatedValue = property.getAnnotation( GeneratedValue.class );
    String generatorType = generatedValue != null ?
            generatorType( generatedValue.strategy(),mappings ) :
            "assigned";
    String generatorName = generatedValue != null ?
            generatedValue.generator() :
            BinderHelper.ANNOTATION_STRING_DEFAULT;
    if ( isComponent ) {
        generatorType = "assigned";
    } //a component must not have any generator
    BinderHelper.makeIdGenerator( idValue,generatorType,generatorName,mappings,localGenerators );

    if ( LOG.isTraceEnabled() ) {
        LOG.tracev( "Bind {0} on {1}",( isComponent ? "@EmbeddedId" : "@Id" ),inferredData.getPropertyName() );
    }
}

项目：lams    文件：JPAOverriddenAnnotationReader.java   

private Embeddable getEmbeddable(Element tree,XMLContext.Default defaults) {
    if ( tree == null ) {
        return defaults.canUseJavaAnnotations() ? getPhysicalAnnotation( Embeddable.class ) : null;
    }
    else {
        if ( "embeddable".equals( tree.getName() ) ) {
            AnnotationDescriptor entity = new AnnotationDescriptor( Embeddable.class );
            return AnnotationFactory.create( entity );
        }
        else {
            return null; //this is not an entity
        }
    }
}

项目：oma-riista-web    文件：ClassInventory.java   

@Nonnull
@SuppressWarnings("unchecked")
public static Set<Class<?>> getManagedJpaClasses() {
    return getMainClasses(Predicates.or(
            withAnnotation(Entity.class),withAnnotation(Embeddable.class),withAnnotation(MappedSuperclass.class)));
}

项目：katharsis-framework    文件：EmbeddableMetaProvider.java   

@Override
public boolean accept(Type type,Class<? extends MetaElement> MetaClass) {
    boolean hasAnnotation = ClassUtils.getRawType(type).getAnnotation(Embeddable.class) != null;
    boolean hasType = MetaClass == MetaElement.class || MetaClass == MetaEmbeddable.class
            || MetaClass == MetaJpaDataObject.class;
    return hasAnnotation && hasType;
}

项目：https-github.com-g0t4-jenkins2-course-spring-boot    文件：EntityScannerTests.java   

@Test
public void scanShouldFilterOnAnnotation() throws Exception {
    AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(
            ScanConfig.class);
    EntityScanner scanner = new EntityScanner(context);
    assertthat(scanner.scan(Entity.class)).containsOnly(EntityA.class,EntityB.class,EntityC.class);
    assertthat(scanner.scan(Embeddable.class)).containsOnly(EmbeddableA.class,EmbeddableB.class,EmbeddableC.class);
    assertthat(scanner.scan(Entity.class,Embeddable.class)).containsOnly(
            EntityA.class,EntityC.class,EmbeddableA.class,EmbeddableC.class);
    context.close();
}

项目：engerek    文件：ClassDeFinitionParser.java   

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;
}

项目：jpa-unit    文件：EntityUtilsTest.java   

@Test
public void testGetNamesOfIdPropertiesFromASingleClassHavingAFieldAnnotatedWithEmbeddedId() throws Exception {
    // GIVEN
    final String simpleClassName = "EntityClass";
    final String compositeIdPropertyName = "compositeKey";
    final String id1PropertyName = "key1";
    final String id2PropertyName = "key2";

    final JPackage jp = jcodemodel.rootPackage();
    final JDefinedClass jIdTypeClass = jp._class(JMod.PUBLIC,"IdType");
    jIdTypeClass.annotate(Embeddable.class);
    jIdTypeClass.field(JMod.PRIVATE,Integer.class,id1PropertyName);
    jIdTypeClass.field(JMod.PRIVATE,String.class,id2PropertyName);

    final JDefinedClass jClass = jp._class(JMod.PUBLIC,simpleClassName);
    jClass.annotate(Entity.class);
    jClass.field(JMod.PRIVATE,jIdTypeClass,compositeIdPropertyName).annotate(EmbeddedId.class);

    buildModel(testFolder.getRoot(),jcodemodel);

    compileModel(testFolder.getRoot());

    final Class<?> entityClass = loadClass(testFolder.getRoot(),jClass.name());

    // WHEN
    final List<String> namesOfIdProperties = EntityUtils.getNamesOfIdProperties(entityClass);

    // THEN
    assertthat(namesOfIdProperties.size(),equalTo(2));
    assertthat(namesOfIdProperties,hasItems(compositeIdPropertyName + "." + id1PropertyName,compositeIdPropertyName + "." + id2PropertyName));
}

项目：jpa-unit    文件：EntityUtilsTest.java   

@Test
public void testGetNamesOfIdPropertiesFromASingleClassHavingAMethodAnnotatedWithEmbeddedId() throws Exception {
    // GIVEN
    final String simpleClassName = "EntityClass";
    final String compositeIdPropertyName = "compositeKey";
    final String id1PropertyName = "key1";
    final String id2PropertyName = "key2";

    final JPackage jp = jcodemodel.rootPackage();
    final JDefinedClass jIdTypeClass = jp._class(JMod.PUBLIC,simpleClassName);
    jClass.annotate(Entity.class);
    final JMethod method = jClass.method(JMod.PUBLIC,"getCompositeKey");
    method.annotate(EmbeddedId.class);
    method.body()._return(JExpr._null());

    buildModel(testFolder.getRoot(),compositeIdPropertyName + "." + id2PropertyName));
}

项目：jpa-unit    文件：EntityUtilsTest.java   

@Test
public void testGetNamesOfIdPropertiesFromAClassHierarchyHavingAFieldAnnotatedWithEmbeddedId() throws Exception {
    // GIVEN
    final String simpleClassNameBase = "EntityClass";
    final String simpleClassNameB = "SubEntityClass";
    final String compositeIdPropertyName = "compositeKey";
    final String id1PropertyName = "key1";
    final String id2PropertyName = "key2";

    final JPackage jp = jcodemodel.rootPackage();

    final JDefinedClass jIdTypeClass = jp._class(JMod.PUBLIC,id2PropertyName);

    final JDefinedClass jbaseClass = jp._class(JMod.PUBLIC,simpleClassNameBase);
    jbaseClass.annotate(Entity.class);
    jbaseClass.annotate(Inheritance.class).param("strategy",InheritanceType.TABLE_PER_CLASS);
    jbaseClass.field(JMod.PRIVATE,compositeIdPropertyName).annotate(EmbeddedId.class);

    final JDefinedClass jSubclass = jp._class(JMod.PUBLIC,simpleClassNameB)._extends(jbaseClass);
    jSubclass.annotate(Entity.class);

    buildModel(testFolder.getRoot(),jSubclass.name());

    // WHEN
    final List<String> namesOfIdProperties = EntityUtils.getNamesOfIdProperties(entityClass);

    // THEN
    assertthat(namesOfIdProperties.size(),compositeIdPropertyName + "." + id2PropertyName));
}

项目：jpa-unit    文件：EntityUtilsTest.java   

@Test
public void testGetNamesOfIdPropertiesFromAClassHierarchyHavingAMethodAnnotatedWithEmbeddedId() throws Exception {
    // GIVEN
    final String simpleClassNameBase = "EntityClass";
    final String simpleClassNameB = "SubEntityClass";
    final String compositeIdPropertyName = "compositeKey";
    final String id1PropertyName = "key1";
    final String id2PropertyName = "key2";

    final JPackage jp = jcodemodel.rootPackage();

    final JDefinedClass jIdTypeClass = jp._class(JMod.PUBLIC,InheritanceType.TABLE_PER_CLASS);
    final JMethod method = jbaseClass.method(JMod.PUBLIC,"getCompositeKey");
    method.annotate(EmbeddedId.class);
    method.body()._return(JExpr._null());

    final JDefinedClass jSubclass = jp._class(JMod.PUBLIC,compositeIdPropertyName + "." + id2PropertyName));
}

项目：cibet    文件：DefaultExecutor.java   

@Override
public void jpaSingleResultQuery(EventMetadata Metadata,CEntityManager entityManager) {
   if (!Context.requestScope().isPlaying()) {
      Object result = query.getSingleResult();
      if (result != null && entityManager.isLoadEager() && (result.getClass().getAnnotation(Embeddable.class) != null
            || result.getClass().getAnnotation(Entity.class) != null)) {
         CibetUtil.loadLazyEntities(result,result.getClass());
         List<Object> references = new ArrayList<Object>();
         references.add(result);
         CibetUtil.deepDetach(result,references);
      }
      Metadata.getResource().setResultObject(result);
   }
}

项目：cuba    文件：MetaClassRepresentation.java   

public String getTableName() {
    boolean isEmbeddable = Meta.getJavaClass().isAnnotationPresent(Embeddable.class);
    if (isEmbeddable)
        return "not defined for embeddable entities";

    MetadataTools MetadataTools = AppBeans.get(MetadataTools.NAME);

    String databaseTable = MetadataTools.getDatabaseTable(Meta);
    return databaseTable != null ? databaseTable : "not defined";
}

项目：Metaworks_framework    文件：EntityMarkerClasstransformer.java   

/**
 * 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;
}

项目：kc-rice    文件：StaticWeavingTest.java   

@Test
public void testStaticWeaving() {
    // first,Message.class.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,embeddableTypes);
}

项目：kc-rice    文件：StaticWeavingTest.java   

@Test
public void testStaticWeaving() {
    // first,scan for all files on the classpath with an @Entity or @MappedSuperClass annotation
    Reflections reflections = new Reflections("org.kuali.rice.krad");
    Set<Class<?>> entityTypes = reflections.getTypesAnnotatedWith(Entity.class,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,scan for all files on the classpath with an @Entity or @MappedSuperClass annotation
    Reflections reflections = new Reflections(
            PersistableBusinessObjectBase.class.getPackage().getName());
    Set<Class<?>> entityTypes = reflections.getTypesAnnotatedWith(Entity.class,scan for all files on the classpath with an @Entity or @MappedSuperClass annotation
    Reflections reflections = new Reflections("org.kuali.rice.kew","org.kuali.rice.kim","org.kuali.rice.kcb","org.kuali.rice.ken");
    Set<Class<?>> entityTypes = reflections.getTypesAnnotatedWith(Entity.class,embeddableTypes);
}

项目：SparkCommerce    文件：EntityMarkerClasstransformer.java   

/**
 * 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;
}

项目：pedal-dialect    文件：EmbeddedColumnEvaluator.java   

@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();
    }
}

项目：blcdemo    文件：EntityMarkerClasstransformer.java   

/**
 * 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;
}

项目：querybean-generator    文件：Processor.java   

@Override
public Set<String> getSupportedAnnotationTypes() {

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

项目：hyperjaxb3    文件：DefaultProcesspropertyInfos.java   

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;
    }
}

项目：hyperjaxb3    文件：DefaultProcesspropertyInfos.java   

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;
    }
}

项目：midpoint    文件：ClassDeFinitionParser.java   

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;
}

项目：lutece-core    文件：JPAPersistenceUnitPostProcessor.java   

/**
 * 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 );
    }
}