Hibernate命名策略详解

2024-03-01 18:52:02 53

hibernate的命名策略，可以减少对数据库标识符命名的维护，进一步减少这部份命名的重复性代码量，以提高维护。

hibernate的命名方式，有两类，一类是显式命名，一类是隐式命名。

1）显式命名：在映射配置时，设置的数据库表名，列名等，就是进行显式命名。

2）隐式命名：显式命名一般不是必要的，所以可以选择当不设置名称，这时就交由hibernate进行隐式命名，另外隐式命名还包括那些不能进行显式命名的数据库标识符。接口ImplicitNamingStrategy，就是用于实现隐式命名。

3）过滤命名：接口PhysicalNamingStrategy，用于对显式命名或隐式命名进一步过滤处理。

示例：

TestTable1Impl.java

@Entity
//隐式命名表名
@Table
publicclassTestTable1Impl{
//---------------------------------------------------------------
//Field
//---------------------------------------------------------------
@Id
@Column()
@GeneratedValue(strategy=GenerationType.IDENTITY)
privateLongtestId;
@Column(length=20)
privateStringtestName;
@ManyToOne
privateTestTable2ImpltestForeign;
//---------------------------------------------------------------
//Method
//---------------------------------------------------------------
publicLonggetId(){
returntestId;
}
publicvoidsetId(Longid){
this.testId=id;
}
publicStringgetName(){
returntestName;
}
publicvoidsetName(Stringname){
this.testName=name;
}
publicTestTable2ImplgetTestForeign(){
returntestForeign;
}
publicvoidsetTestForeign(TestTable2ImpltestForeign){
this.testForeign=testForeign;
}
}

TestTable2Impl.java

@Entity
//显式命名表名
@Table(name="TestTable2Impl")
publicclassTestTable2Impl{
//---------------------------------------------------------------
//Field
//---------------------------------------------------------------
@Id
@Column()
@GeneratedValue(strategy=GenerationType.IDENTITY)
privateLongtestId;
@Column(length=20)
privateStringtestName;
//---------------------------------------------------------------
//Method
//---------------------------------------------------------------
publicLonggetId(){
returntestId;
}
publicvoidsetId(Longid){
this.testId=id;
}
publicStringgetName(){
returntestName;
}
publicvoidsetName(Stringname){
this.testName=name;
}
}

MyImplicitNamingStrategyImpl.java

publicclassMyImplicitNamingStrategyImplextendsImplicitNamingStrategyJpaCompliantImplimplementsImplicitNamingStrategy{
@Override
publicIdentifierdeterminePrimaryTableName(ImplicitEntityNameSourcesource){
Identifiername=super.determinePrimaryTableName(source);
Identifierresult=toStandard(name,"Impl");
System.out.println("ImplicitNamingStrategy/PrimaryTableName->\n\t"+name+"=>"+result);
returnresult;
}
privateIdentifiertoStandard(Identifiername,String...removeSuffixes){
if(removeSuffixes==null)
returnname;
if(name==null)
returnnull;
Stringtext=name.getText();
if(removeSuffixes!=null){
for(Stringsuffix:removeSuffixes){
if(text.endsWith(suffix))
text=text.substring(0,text.length()-suffix.length());
}
}
returnnewIdentifier(text,name.isQuoted());
}
@Override
publicIdentifierdetermineJoinTableName(ImplicitJoinTableNameSourcesource){
Identifiername=super.determineJoinTableName(source);
System.out.println("ImplicitNamingStrategy/JoinTableName->\n\t"+name);
returnname;
}
@Override
publicIdentifierdetermineCollectionTableName(ImplicitCollectionTableNameSourcesource){
Identifiername=super.determineCollectionTableName(source);
System.out.println("ImplicitNamingStrategy/CollectionTableName->\n\t"+name);
returnname;
}
@Override
publicIdentifierdetermineDiscriminatorColumnName(ImplicitDiscriminatorColumnNameSourcesource){
Identifiername=super.determineDiscriminatorColumnName(source);
System.out.println("ImplicitNamingStrategy/DiscriminatorColumnName->\n\t"+name);
returnname;
}
@Override
publicIdentifierdetermineTenantIdColumnName(ImplicitTenantIdColumnNameSourcesource){
Identifiername=super.determineTenantIdColumnName(source);
System.out.println("ImplicitNamingStrategy/TenantIdColumnName->\n\t"+name);
returnname;
}
@Override
publicIdentifierdetermineIdentifierColumnName(ImplicitIdentifierColumnNameSourcesource){
Identifiername=super.determineIdentifierColumnName(source);
System.out.println("ImplicitNamingStrategy/IdentifierColumnName->\n\t"+name);
returnname;
}
@Override
publicIdentifierdetermineBasicColumnName(ImplicitBasicColumnNameSourcesource){
Identifiername=super.determineBasicColumnName(source);
System.out.println("ImplicitNamingStrategy/BasicColumnName->\n\t"+name);
returnname;
}
@Override
publicIdentifierdetermineJoinColumnName(ImplicitJoinColumnNameSourcesource){
Identifiername=super.determineJoinColumnName(source);
finalStringresult;
if(source.getNature()==ImplicitJoinColumnNameSource.Nature.ELEMENT_COLLECTION||source.getAttributePath()==null){
result=transformEntityName(source.getEntityNaming());
}else{
result=transformAttributePath(source.getAttributePath());
}
System.out.println("ImplicitNamingStrategy/JoinColumnName->\n\t"+name+"=>"+result);
returntoIdentifier(result,source.getBuildingContext());
}
@Override
publicIdentifierdeterminePrimaryKeyJoinColumnName(ImplicitPrimaryKeyJoinColumnNameSourcesource){
Identifiername=super.determinePrimaryKeyJoinColumnName(source);
System.out.println("ImplicitNamingStrategy/PrimaryKeyJoinColumnName->\n\t"+name);
returnname;
}
@Override
publicIdentifierdetermineAnyDiscriminatorColumnName(ImplicitAnyDiscriminatorColumnNameSourcesource){
Identifiername=super.determineAnyDiscriminatorColumnName(source);
System.out.println("ImplicitNamingStrategy/AnyDiscriminatorColumnName->\n\t"+name);
returnname;
}
@Override
publicIdentifierdetermineAnyKeyColumnName(ImplicitAnyKeyColumnNameSourcesource){
Identifiername=super.determineAnyKeyColumnName(source);
System.out.println("ImplicitNamingStrategy/AnyKeyColumnName->\n\t"+name);
returnname;
}
@Override
publicIdentifierdetermineMapKeyColumnName(ImplicitMapKeyColumnNameSourcesource){
Identifiername=super.determineMapKeyColumnName(source);
System.out.println("ImplicitNamingStrategy/MapKeyColumnName->\n\t"+name);
returnname;
}
@Override
publicIdentifierdetermineListIndexColumnName(ImplicitIndexColumnNameSourcesource){
Identifiername=super.determineListIndexColumnName(source);
System.out.println("ImplicitNamingStrategy/ListIndexColumnName->\n\t"+name);
returnname;
}
@Override
publicIdentifierdetermineForeignKeyName(ImplicitForeignKeyNameSourcesource){
Identifiername=super.determineForeignKeyName(source);
Stringresult=null;
StringtableName=source.getTableName().getText();
if(tableName.startsWith(TableNamingConfig.TABLE_PREFIX))
tableName=tableName.substring(TableNamingConfig.TABLE_PREFIX.length());
if(source.getColumnNames().size()==1){
result=TableNamingConfig.FOREIGN_KEY_PREFIX+tableName+"_"+source.getColumnNames().get(0).getText();
}else{
StringcolumnName=source.getReferencedTableName().getText();
if(columnName.startsWith(TableNamingConfig.TABLE_PREFIX))
columnName=columnName.substring(TableNamingConfig.TABLE_PREFIX.length());
result=TableNamingConfig.FOREIGN_KEY_PREFIX+tableName+"_"+columnName;
}
System.out.println("ImplicitNamingStrategy/ForeignKeyName->\n\t"+name+"=>"+result);
returnnewIdentifier(result,name.isQuoted());
}
@Override
publicIdentifierdetermineUniqueKeyName(ImplicitUniqueKeyNameSourcesource){
Identifiername=super.determineUniqueKeyName(source);
System.out.println("ImplicitNamingStrategy/UniqueKeyName->\n\t"+name);
returnname;
}
@Override
publicIdentifierdetermineIndexName(ImplicitIndexNameSourcesource){
Identifiername=super.determineIndexName(source);
System.out.println("ImplicitNamingStrategy/IndexName->\n\t"+name);
returnname;
}
}

MyPhysicalNamingStrategyImpl.java

publicclassMyPhysicalNamingStrategyImplimplementsPhysicalNamingStrategy{
@Override
publicIdentifiertoPhysicalCatalogName(Identifiername,JdbcEnvironmentjdbcEnvironment){
System.out.println("PhysicalNamingStrategy/catalog->\n\t"+name);
returnname;
}
@Override
publicIdentifiertoPhysicalSchemaName(Identifiername,JdbcEnvironmentjdbcEnvironment){
System.out.println("PhysicalNamingStrategy/schema->\n\t"+name);
returnname;
}
@Override
publicIdentifiertoPhysicalTableName(Identifiername,JdbcEnvironmentjdbcEnvironment){
Identifierresult=toStandard(name,"tb_");
System.out.println("PhysicalNamingStrategy/table->\n\t"+name+"=>"+result);
returnresult;
}
@Override
publicIdentifiertoPhysicalSequenceName(Identifiername,JdbcEnvironmentjdbcEnvironment){
System.out.println("PhysicalNamingStrategy/sequence->\n\t"+name);
returnname;
}
@Override
publicIdentifiertoPhysicalColumnName(Identifiername,JdbcEnvironmentjdbcEnvironment){
Identifierresult=toStandard(name);
System.out.println("PhysicalNamingStrategy/column->\n\t"+name+"=>"+result);
returnresult;
}
privateIdentifiertoStandard(Identifiername){
returntoStandard(name,null);
}
privateIdentifiertoStandard(Identifiername,Stringprefix){
if(name==null)
returnnull;
Stringtext=name.getText();
StringBufferbuffer=newStringBuffer();
if(prefix!=null)
buffer.append(prefix);
char[]chars=text.toCharArray();
for(inti=0,len=chars.length;i<len;i++){
charc1=chars[i];
if(c1>='A'&&c1<='Z'){
if(i>0&&i+1<len){
if(chars[i+1]<'A'||chars[i+1]>'Z')
buffer.append('_');
}
c1=(char)(c1-'A'+'a');
}
buffer.append(c1);
}
returnnewIdentifier(buffer.toString(),name.isQuoted());
}
}

TableNamingConfig.java

publicclassTableNamingConfig{
publicstaticfinalStringTABLE_PREFIX="tb_";
publicstaticfinalStringFOREIGN_KEY_PREFIX="fk_";
}

spring.xml

<?xmlversion="1.0"encoding="UTF-8"?>
<beansxmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xmlns:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="
http://www.springframework.org/schema/beanshttp://www.springframework.org/schema/beans/spring-beans.xsdhttp://www.springframework.org/schema/contexthttp://www.springframework.org/schema/context/spring-context-4.1.xsd">
<!--配置数据源-->
<beanid="dataSource"class="com.mchange.v2.c3p0.ComboPooledDataSource">
<propertyname="driverClass"value="com.mysql.jdbc.Driver"></property>
<propertyname="jdbcUrl"value="jdbc:mysql://localhost:3306/test?useSSL=false"></property>
<propertyname="user"value="root"></property>
<propertyname="password"value="123456"></property>
</bean>
<beanid="physicalNamingStrategy"class="test.MyPhysicalNamingStrategyImpl"></bean>
<beanid="implicitNamingStrategy"class="test.MyImplicitNamingStrategyImpl"></bean>
<beanid="sessionFactory"class="org.springframework.orm.hibernate5.LocalSessionFactoryBean">
<propertyname="dataSource"ref="dataSource"/>
<propertyname="packagesToScan">
<list>
<!--可以加多个包-->
<value>test</value>
</list>
</property>
<propertyname="hibernateProperties">
<props>
<propkey="hibernate.hbm2ddl.auto">create-drop</prop>
<propkey="hibernate.dialect">org.hibernate.dialect.MySQL5Dialect</prop>
<propkey="hibernate.show_sql">true</prop>
<propkey="hibernate.format_sql">true</prop>
<propkey="hibernate.temp.use_jdbc_metadata_defaults">false</prop>
</props>
</property>
<propertyname="physicalNamingStrategy"ref="physicalNamingStrategy"></property>
<propertyname="implicitNamingStrategy"ref="implicitNamingStrategy"></property>
</bean>
</beans>

Test.java

publicclassTest{
publicstaticvoidmain(String[]params){
//命名策略
newTest().test();
/*
PhysicalNamingStrategy/catalog->
null
PhysicalNamingStrategy/catalog->
null
PhysicalNamingStrategy/column->
DTYPE=>dtype
ImplicitNamingStrategy/PrimaryTableName->
TestTable1Impl=>TestTable1
PhysicalNamingStrategy/table->
TestTable1=>tb_test_table1
ImplicitNamingStrategy/BasicColumnName->
testId
PhysicalNamingStrategy/column->
testId=>test_id
ImplicitNamingStrategy/BasicColumnName->
testId
ImplicitNamingStrategy/BasicColumnName->
testForeign
PhysicalNamingStrategy/column->
testForeign=>test_foreign
ImplicitNamingStrategy/BasicColumnName->
testName
PhysicalNamingStrategy/column->
testName=>test_name
ImplicitNamingStrategy/BasicColumnName->
testName
PhysicalNamingStrategy/column->
DTYPE=>dtype
PhysicalNamingStrategy/table->
TestTable2Impl=>tb_test_table2_impl
ImplicitNamingStrategy/BasicColumnName->
testId
PhysicalNamingStrategy/column->
testId=>test_id
ImplicitNamingStrategy/BasicColumnName->
testId
ImplicitNamingStrategy/BasicColumnName->
testName
PhysicalNamingStrategy/column->
testName=>test_name
ImplicitNamingStrategy/BasicColumnName->
testName
ImplicitNamingStrategy/JoinColumnName->
testForeign_testId=>testForeign
PhysicalNamingStrategy/column->
testForeign=>test_foreign
ImplicitNamingStrategy/ForeignKeyName->
FKlnurug7wfle1u6fc5oulnrx94=>fk_test_table1_test_foreign
Hibernate:
altertabletb_test_table1
drop
foreignkeyfk_test_table1_test_foreign
Hibernate:
droptableifexiststb_test_table1
Hibernate:
droptableifexiststb_test_table2_impl
Hibernate:
createtabletb_test_table1(
test_idbigintnotnullauto_increment,
test_namevarchar(20),
test_foreignbigint,
primarykey(test_id)
)
Hibernate:
createtabletb_test_table2_impl(
test_idbigintnotnullauto_increment,
test_namevarchar(20),
primarykey(test_id)
)
Hibernate:
altertabletb_test_table1
addconstraintfk_test_table1_test_foreign
foreignkey(test_foreign)
referencestb_test_table2_impl(test_id)
Hibernate:
altertabletb_test_table1
drop
foreignkeyfk_test_table1_test_foreign
Hibernate:
droptableifexiststb_test_table1
Hibernate:
droptableifexiststb_test_table2_impl
*/
}
publicvoidtest(){
ApplicationContextcontext=newClassPathXmlApplicationContext("spring.xml",this.getClass());
SessionFactoryfactory=null;
try{
factory=(SessionFactory)context.getBean("sessionFactory");
}finally{
if(factory!=null){
factory.close();
factory=null;
}
}
}
}

以上就是本文的全部内容，希望本文的内容对大家的学习或者工作能带来一定的帮助，同时也希望多多支持毛票票！

Hibernate命名策略详解

热门推荐

随机推荐