下面列出了怎么用javax.persistence.DiscriminatorColumn的API类实例代码及写法，或者点击链接到github查看源代码。
private DiscriminatorColumn getDiscriminatorColumn(Element tree, XMLContext.Default defaults) {
Element element = tree != null ? tree.element( "discriminator-column" ) : null;
if ( element != null ) {
AnnotationDescriptor ad = new AnnotationDescriptor( DiscriminatorColumn.class );
copyStringAttribute( ad, element, "name", false );
copyStringAttribute( ad, element, "column-definition", false );
String value = element.attributeValue( "discriminator-type" );
DiscriminatorType type = DiscriminatorType.STRING;
if ( value != null ) {
if ( "STRING".equals( value ) ) {
type = DiscriminatorType.STRING;
}
else if ( "CHAR".equals( value ) ) {
type = DiscriminatorType.CHAR;
}
else if ( "INTEGER".equals( value ) ) {
type = DiscriminatorType.INTEGER;
}
else {
throw new AnnotationException(
"Unknown DiscrimiatorType in XML: " + value + " (" + SCHEMA_VALIDATION + ")"
);
}
}
ad.setValue( "discriminatorType", type );
copyIntegerAttribute( ad, element, "length" );
return AnnotationFactory.create( ad );
}
else if ( defaults.canUseJavaAnnotations() ) {
return getPhysicalAnnotation( DiscriminatorColumn.class );
}
else {
return null;
}
}
@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));
}
@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", 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(nodeLabel),
Arrays.asList(baseClass, subClassA, subClassB));
assertThat(clazz, equalTo(baseClass));
}
public static Ejb3DiscriminatorColumn buildDiscriminatorColumn(
DiscriminatorType type, DiscriminatorColumn discAnn,
DiscriminatorFormula discFormulaAnn,
MetadataBuildingContext context) {
Ejb3DiscriminatorColumn discriminatorColumn = new Ejb3DiscriminatorColumn();
discriminatorColumn.setBuildingContext( context );
discriminatorColumn.setImplicit( true );
if ( discFormulaAnn != null ) {
discriminatorColumn.setImplicit( false );
discriminatorColumn.setFormula( discFormulaAnn.value() );
}
else if ( discAnn != null ) {
discriminatorColumn.setImplicit( false );
if ( !BinderHelper.isEmptyAnnotationValue( discAnn.columnDefinition() ) ) {
discriminatorColumn.setSqlType(
discAnn.columnDefinition()
);
}
if ( !BinderHelper.isEmptyAnnotationValue( discAnn.name() ) ) {
discriminatorColumn.setLogicalColumnName( discAnn.name() );
}
discriminatorColumn.setNullable( false );
}
if ( DiscriminatorType.CHAR.equals( type ) ) {
discriminatorColumn.setDiscriminatorTypeName( "character" );
discriminatorColumn.setImplicit( false );
}
else if ( DiscriminatorType.INTEGER.equals( type ) ) {
discriminatorColumn.setDiscriminatorTypeName( "integer" );
discriminatorColumn.setImplicit( false );
}
else if ( DiscriminatorType.STRING.equals( type ) || type == null ) {
if ( discAnn != null ) discriminatorColumn.setLength( discAnn.length() );
discriminatorColumn.setDiscriminatorTypeName( "string" );
}
else {
throw new AssertionFailure( "Unknown discriminator type: " + type );
}
discriminatorColumn.bind();
return discriminatorColumn;
}
/**
* Process all discriminator-related metadata per rules for "single table" inheritance
*/
private static Ejb3DiscriminatorColumn processSingleTableDiscriminatorProperties(
XClass clazzToProcess,
MetadataBuildingContext context,
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,
context
);
}
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;
}
/**
* Process all discriminator-related metadata per rules for "joined" inheritance
*/
private static Ejb3DiscriminatorColumn processJoinedDiscriminatorProperties(
XClass clazzToProcess,
MetadataBuildingContext context,
InheritanceState inheritanceState,
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 ( context.getBuildingOptions().ignoreExplicitDiscriminatorsForJoinedInheritance() ) {
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 ( context.getBuildingOptions().createImplicitDiscriminatorsForJoinedInheritance() ) {
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,
context
);
}
}
else {
if ( discriminatorColumnAnnotation != null ) {
LOG.invalidDiscriminatorAnnotation( clazzToProcess.getName() );
}
}
return null;
}