javax.persistence.DiscriminatorValue的实例源码

项目：org.fastnate    文件：EntityClass.java   

/**
 * Determine the inheritance type and discriminator properties.
 */
private void buildInheritance() {
    // Check,if we've got an explicit inheritance type
    final Inheritance inheritance = this.entityClass.getAnnotation(Inheritance.class);
    if (inheritance != null) {
        this.inheritanceType = inheritance.strategy();
    }

    // Find the root of our hierarchy
    this.hierarchyRoot = this;
    findHierarchyRoot(this.entityClass.getSuperclass());

    // We scan only classes that we are about to write
    // So we don't kNow,that there is a subclass entity - until we find one
    // This Could be to late for InheritanceType.SINGLE_TABLE - the defaault type
    // That's why we build a discriminator,if one of the inheritance annotations exists
    if (this.inheritanceType == null && this.entityClass.isAnnotationPresent(discriminatorColumn.class)
            || this.entityClass.isAnnotationPresent(discriminatorValue.class)) {
        this.inheritanceType = InheritanceType.SINGLE_TABLE;
    }

    builddiscriminator();
}

项目：lams    文件：JPAOverriddenAnnotationReader.java   

private discriminatorValue getdiscriminatorValue(Element tree,XMLContext.Default defaults) {
    Element element = tree != null ? tree.element( "discriminator-value" ) : null;
    if ( element != null ) {
        AnnotationDescriptor ad = new AnnotationDescriptor( discriminatorValue.class );
        copyStringElement( element,ad,"value" );
        return AnnotationFactory.create( ad );
    }
    else if ( defaults.canUseJavaAnnotations() ) {
        return getPhysicalAnnotation( discriminatorValue.class );
    }
    else {
        return null;
    }
}

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

@Test
public void testGetEntityClassFromNodeLabelsHavingTheLabelDeclaredByTheClassNameWithSingleTableInheritance() throws Exception {
    final String simpleClassNameBase = "EntityClass";
    final String simpleClassNameA = "SubEntityClassA";
    final String simpleClassNameB = "SubEntityClassB";

    final JPackage jp = jcodemodel.rootPackage();
    final JDefinedClass jbaseClass = jp._class(JMod.PUBLIC,simpleClassNameBase);
    jbaseClass.annotate(Entity.class);
    jbaseClass.annotate(Inheritance.class).param("strategy",InheritanceType.SINGLE_TABLE);
    jbaseClass.annotate(discriminatorColumn.class).param("name","TYPE");

    final JDefinedClass jSubclassA = jp._class(JMod.PUBLIC,simpleClassNameA)._extends(jbaseClass);
    jSubclassA.annotate(Entity.class);
    jSubclassA.annotate(discriminatorValue.class).param("value","A");

    final JDefinedClass jSubclassB = jp._class(JMod.PUBLIC,simpleClassNameB)._extends(jbaseClass);
    jSubclassB.annotate(Entity.class);
    jSubclassB.annotate(discriminatorValue.class).param("value","B");

    buildModel(testFolder.getRoot(),jcodemodel);

    compileModel(testFolder.getRoot());

    final Class<?> baseClass = loadClass(testFolder.getRoot(),jbaseClass.name());
    final Class<?> subClassA = loadClass(testFolder.getRoot(),jSubclassA.name());
    final Class<?> subClassB = loadClass(testFolder.getRoot(),jSubclassB.name());

    final Class<?> clazz = EntityUtils.getEntityClassFromNodeLabels(Arrays.asList(simpleClassNameBase),Arrays.asList(baseClass,subClassA,subClassB));

    assertthat(clazz,equalTo(baseClass));
}

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

@Test
public void testGetEntityClassFromNodeLabelsHavingTheLabelDeclaredByTheTableAnnotationWithSingleTableInheritance() throws Exception {
    final String simpleClassNameBase = "EntityClass";
    final String simpleClassNameA = "SubEntityClassA";
    final String simpleClassNameB = "SubEntityClassB";

    final String nodeLabel = "ENTITY_CLASS";

    final JPackage jp = jcodemodel.rootPackage();
    final JDefinedClass jbaseClass = jp._class(JMod.PUBLIC,simpleClassNameBase);
    jbaseClass.annotate(Entity.class);
    jbaseClass.annotate(Table.class).param("name",nodeLabel);
    jbaseClass.annotate(Inheritance.class).param("strategy",jSubclassB.name());

    final Class<?> clazz = EntityUtils.getEntityClassFromNodeLabels(Arrays.asList(nodeLabel),equalTo(baseClass));
}

项目：org.fastnate    文件：EntityClass.java   

private ColumnExpression builddiscriminator(final EntityClass<?> c,final discriminatorColumn column) {
    final discriminatorType type;
    final int maxLength;
    if (column == null) {
        type = discriminatorType.STRING;
        final int defaultMaxLength = 31;
        maxLength = defaultMaxLength;
    } else {
        type = column.discriminatorType();
        maxLength = column.length();
    }

    final discriminatorValue value = this.entityClass.getAnnotation(discriminatorValue.class);
    if (type == discriminatorType.INTEGER) {
        return PrimitiveColumnExpression.create(
                value == null ? c.getEntityName().hashCode() : Integer.parseInt(value.value()),getContext().getDialect());
    }
    final String v = value == null ? c.getEntityName() : value.value();
    if (StringUtils.isEmpty(v)) {
        throw new IllegalArgumentException("Missing discriminator value for: " + c.getEntityClass());
    }
    if (type == discriminatorType.STRING) {
        return PrimitiveColumnExpression.create(v.length() <= maxLength ? v : v.substring(0,maxLength),getContext().getDialect());
    } else if (type == discriminatorType.CHAR) {
        return PrimitiveColumnExpression.create(v.substring(0,1),getContext().getDialect());
    }
    throw new IllegalArgumentException("UnkNown discriminator type: " + type);
}

项目：stdlib    文件：QEntity.java   

public String getdiscriminatorValue()
{
    final discriminatorValue annotation = clazz.getAnnotation(discriminatorValue.class);

    if (annotation != null)
        return annotation.value();
    else
        return clazz.getName();
}

项目：lams    文件：AnnotationBinder.java   

/**
 * Process all discriminator-related Metadata per rules for "single table" inheritance
 */
private static Ejb3discriminatorColumn processSingleTablediscriminatorProperties(
        XClass clazzToProcess,Mappings mappings,InheritanceState inheritanceState,EntityBinder entityBinder) {
    final boolean isRoot = !inheritanceState.hasParents();

    Ejb3discriminatorColumn discriminatorColumn = null;
    javax.persistence.discriminatorColumn discAnn = clazzToProcess.getAnnotation(
            javax.persistence.discriminatorColumn.class
    );
    discriminatorType discriminatorType = discAnn != null
            ? discAnn.discriminatorType()
            : discriminatorType.STRING;

    org.hibernate.annotations.discriminatorFormula discFormulaAnn = clazzToProcess.getAnnotation(
            org.hibernate.annotations.discriminatorFormula.class
    );
    if ( isRoot ) {
        discriminatorColumn = Ejb3discriminatorColumn.builddiscriminatorColumn(
                discriminatorType,discAnn,discFormulaAnn,mappings
        );
    }
    if ( discAnn != null && !isRoot ) {
        LOG.invaliddiscriminatorAnnotation( clazzToProcess.getName() );
    }

    final String discriminatorValue = clazzToProcess.isAnnotationPresent( discriminatorValue.class )
            ? clazzToProcess.getAnnotation( discriminatorValue.class ).value()
            : null;
    entityBinder.setdiscriminatorValue( discriminatorValue );

    discriminatorOptions discriminatorOptions = clazzToProcess.getAnnotation( discriminatorOptions.class );
    if ( discriminatorOptions != null) {
        entityBinder.setForcediscriminator( discriminatorOptions.force() );
        entityBinder.setInsertablediscriminator( discriminatorOptions.insert() );
    }

    return discriminatorColumn;
}

项目：lams    文件：AnnotationBinder.java   

/**
 * Process all discriminator-related Metadata per rules for "joined" inheritance
 */
private static Ejb3discriminatorColumn processJoineddiscriminatorProperties(
        XClass clazzToProcess,EntityBinder entityBinder) {
    if ( clazzToProcess.isAnnotationPresent( discriminatorFormula.class ) ) {
        throw new MappingException( "@discriminatorFormula on joined inheritance not supported at this time" );
    }


    // discriminatorValue handling ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

    final discriminatorValue discriminatorValueAnnotation = clazzToProcess.getAnnotation( discriminatorValue.class );
    final String discriminatorValue = discriminatorValueAnnotation != null
            ? clazzToProcess.getAnnotation( discriminatorValue.class ).value()
            : null;
    entityBinder.setdiscriminatorValue( discriminatorValue );


    // discriminatorColumn handling ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

    final discriminatorColumn discriminatorColumnAnnotation = clazzToProcess.getAnnotation( discriminatorColumn.class );
    if ( !inheritanceState.hasParents() ) {
        // we want to process the discriminator column if either:
        //      1) There is an explicit discriminatorColumn annotation && we are not told to ignore them
        //      2) There is not an explicit discriminatorColumn annotation && we are told to create them implicitly
        final boolean generatediscriminatorColumn;
        if ( discriminatorColumnAnnotation != null ) {
            if ( mappings.ignoreExplicitdiscriminatorColumnForJoinedInheritance() ) {
                LOG.debugf( "Ignoring explicit discriminatorColumn annotation on ",clazzToProcess.getName() );
                generatediscriminatorColumn = false;
            }
            else {
                LOG.applyingExplicitdiscriminatorColumnForJoined(
                        clazzToProcess.getName(),AvailableSettings.IGnorE_EXPLICIT_disCRIMINATOR_COLUMNS_FOR_JOINED_SUBCLASS
                );
                generatediscriminatorColumn = true;
            }
        }
        else {
            if ( mappings.useImplicitdiscriminatorColumnForJoinedInheritance() ) {
                LOG.debug( "Applying implicit discriminatorColumn using discriminatorColumn defaults" );
                generatediscriminatorColumn = true;
            }
            else {
                LOG.debug( "Ignoring implicit (absent) discriminatorColumn" );
                generatediscriminatorColumn = false;
            }
        }

        if ( generatediscriminatorColumn ) {
            final discriminatorType discriminatorType = discriminatorColumnAnnotation != null
                    ? discriminatorColumnAnnotation.discriminatorType()
                    : discriminatorType.STRING;
            return Ejb3discriminatorColumn.builddiscriminatorColumn(
                    discriminatorType,discriminatorColumnAnnotation,null,mappings
            );
        }
    }
    else {
        if ( discriminatorColumnAnnotation != null ) {
            LOG.invaliddiscriminatorAnnotation( clazzToProcess.getName() );
        }
    }

    return null;
}