Hibernate命名策略详解

@Entity// 隐式命名表名@Tablepublic class TestTable1Impl {  //---------------------------------------------------------------  // Field  //---------------------------------------------------------------  @Id  @Column()  @GeneratedValue(strategy = GenerationType.IDENTITY)  private Long testId;  @Column(length = 20)  private String testName;  @ManyToOne  private TestTable2Impl testForeign;  //---------------------------------------------------------------  // Method  //---------------------------------------------------------------  public Long getId() {    return testId;  }  public void setId(Long id) {    this.testId = id;  }  public String getName(){    return testName;  }  public void setName(String name){    this.testName = name;  }  public TestTable2Impl getTestForeign() {    return testForeign;  }  public void setTestForeign(TestTable2Impl testForeign) {    this.testForeign = testForeign;  }}

@Entity// 显式命名表名@Table(name = "TestTable2Impl")public class TestTable2Impl {  //---------------------------------------------------------------  // Field  //---------------------------------------------------------------  @Id  @Column()  @GeneratedValue(strategy = GenerationType.IDENTITY)  private Long testId;  @Column(length = 20)  private String testName;  //---------------------------------------------------------------  // Method  //---------------------------------------------------------------  public Long getId() {    return testId;  }  public void setId(Long id) {    this.testId = id;  }  public String getName(){    return testName;  }  public void setName(String name){    this.testName = name;  }}

public class MyImplicitNamingStrategyImpl extends ImplicitNamingStrategyJpaCompliantImpl implements ImplicitNamingStrategy {  @Override  public Identifier determinePrimaryTableName(ImplicitEntityNameSource source) {    Identifier name = super.determinePrimaryTableName(source);    Identifier result = toStandard(name, "Impl");    System.out.println("ImplicitNamingStrategy / PrimaryTableName -> /n/t" + name + " => " + result);    return result;  }  private Identifier toStandard(Identifier name, String... removeSuffixes){    if(removeSuffixes == null)      return name;    if(name == null)      return null;    String text = name.getText();    if(removeSuffixes != null){      for(String suffix : removeSuffixes){        if(text.endsWith(suffix))          text = text.substring(0, text.length() - suffix.length());      }    }    return new Identifier(text, name.isQuoted());  }  @Override  public Identifier determineJoinTableName(ImplicitJoinTableNameSource source) {    Identifier name = super.determineJoinTableName(source);    System.out.println("ImplicitNamingStrategy / JoinTableName -> /n/t" + name);    return name;  }  @Override  public Identifier determineCollectionTableName(ImplicitCollectionTableNameSource source) {    Identifier name = super.determineCollectionTableName(source);    System.out.println("ImplicitNamingStrategy / CollectionTableName -> /n/t" + name);    return name;  }  @Override  public Identifier determineDiscriminatorColumnName(ImplicitDiscriminatorColumnNameSource source) {    Identifier name = super.determineDiscriminatorColumnName(source);    System.out.println("ImplicitNamingStrategy / DiscriminatorColumnName -> /n/t" + name);    return name;  }  @Override  public Identifier determineTenantIdColumnName(ImplicitTenantIdColumnNameSource source) {    Identifier name = super.determineTenantIdColumnName(source);    System.out.println("ImplicitNamingStrategy / TenantIdColumnName -> /n/t" + name);    return name;  }  @Override  public Identifier determineIdentifierColumnName(ImplicitIdentifierColumnNameSource source) {    Identifier name = super.determineIdentifierColumnName(source);    System.out.println("ImplicitNamingStrategy / IdentifierColumnName -> /n/t" + name);    return name;  }  @Override  public Identifier determineBasicColumnName(ImplicitBasicColumnNameSource source) {    Identifier name = super.determineBasicColumnName(source);    System.out.println("ImplicitNamingStrategy / BasicColumnName -> /n/t" + name);    return name;  }  @Override  public Identifier determineJoinColumnName(ImplicitJoinColumnNameSource source) {    Identifier name = super.determineJoinColumnName(source);    final String result;    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);    return toIdentifier( result, source.getBuildingContext() );  }  @Override  public Identifier determinePrimaryKeyJoinColumnName(ImplicitPrimaryKeyJoinColumnNameSource source) {    Identifier name = super.determinePrimaryKeyJoinColumnName(source);    System.out.println("ImplicitNamingStrategy / PrimaryKeyJoinColumnName -> /n/t" + name);    return name;  }  @Override  public Identifier determineAnyDiscriminatorColumnName(ImplicitAnyDiscriminatorColumnNameSource source) {    Identifier name = super.determineAnyDiscriminatorColumnName(source);    System.out.println("ImplicitNamingStrategy / AnyDiscriminatorColumnName -> /n/t" + name);    return name;  }  @Override  public Identifier determineAnyKeyColumnName(ImplicitAnyKeyColumnNameSource source) {    Identifier name = super.determineAnyKeyColumnName(source);    System.out.println("ImplicitNamingStrategy / AnyKeyColumnName -> /n/t" + name);    return name;  }  @Override  public Identifier determineMapKeyColumnName(ImplicitMapKeyColumnNameSource source) {    Identifier name = super.determineMapKeyColumnName(source);    System.out.println("ImplicitNamingStrategy / MapKeyColumnName -> /n/t" + name);    return name;  }  @Override  public Identifier determineListIndexColumnName(ImplicitIndexColumnNameSource source) {    Identifier name = super.determineListIndexColumnName(source);    System.out.println("ImplicitNamingStrategy / ListIndexColumnName -> /n/t" + name);    return name;  }  @Override  public Identifier determineForeignKeyName(ImplicitForeignKeyNameSource source) {    Identifier name = super.determineForeignKeyName(source);    String result = null;    String tableName = 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 {      String columnName = 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);    return new Identifier(result, name.isQuoted());  }  @Override  public Identifier determineUniqueKeyName(ImplicitUniqueKeyNameSource source) {    Identifier name = super.determineUniqueKeyName(source);    System.out.println("ImplicitNamingStrategy / UniqueKeyName -> /n/t" + name);    return name;  }  @Override  public Identifier determineIndexName(ImplicitIndexNameSource source) {    Identifier name = super.determineIndexName(source);    System.out.println("ImplicitNamingStrategy / IndexName -> /n/t" + name);    return name;  }}

public class MyPhysicalNamingStrategyImpl implements PhysicalNamingStrategy {  @Override  public Identifier toPhysicalCatalogName(Identifier name, JdbcEnvironment jdbcEnvironment) {    System.out.println("PhysicalNamingStrategy / catalog -> /n/t" + name);    return name;  }  @Override  public Identifier toPhysicalSchemaName(Identifier name, JdbcEnvironment jdbcEnvironment) {    System.out.println("PhysicalNamingStrategy / schema -> /n/t" + name);    return name;  }  @Override  public Identifier toPhysicalTableName(Identifier name, JdbcEnvironment jdbcEnvironment) {    Identifier result = toStandard(name, "tb_");    System.out.println("PhysicalNamingStrategy / table -> /n/t" + name + " => " + result);    return result;  }  @Override  public Identifier toPhysicalSequenceName(Identifier name, JdbcEnvironment jdbcEnvironment) {    System.out.println("PhysicalNamingStrategy / sequence -> /n/t" + name);    return name;  }  @Override  public Identifier toPhysicalColumnName(Identifier name, JdbcEnvironment jdbcEnvironment) {    Identifier result = toStandard(name);    System.out.println("PhysicalNamingStrategy / column -> /n/t" + name + " => " + result);    return result;  }  private Identifier toStandard(Identifier name){    return toStandard(name, null);  }  private Identifier toStandard(Identifier name, String prefix){    if(name == null)      return null;    String text = name.getText();    StringBuffer buffer = new StringBuffer();    if(prefix != null)      buffer.append(prefix);    char[] chars = text.toCharArray();    for(int i=0, len=chars.length; i<len; i++){      char c1 = 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);    }    return new Identifier(buffer.toString(), name.isQuoted());  }}

public class TableNamingConfig {  public static final String TABLE_PREFIX = "tb_";  public static final String FOREIGN_KEY_PREFIX = "fk_";}

<?xml version="1.0" encoding="UTF-8"?><beans xmlns="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/beans    http://www.springframework.org/schema/beans/spring-beans.xsd    http://www.springframework.org/schema/context    http://www.springframework.org/schema/context/spring-context-4.1.xsd">  <!-- 配置数据源 -->  <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">    <property name="driverClass" value="com.mysql.jdbc.Driver"></property>    <property name="jdbcUrl" value="jdbc:mysql://localhost:3306/test?useSSL=false"></property>    <property name="user" value="root"></property>    <property name="password" value="123456"></property>  </bean>  <bean id="physicalNamingStrategy" class="test.MyPhysicalNamingStrategyImpl"></bean>  <bean id="implicitNamingStrategy" class="test.MyImplicitNamingStrategyImpl"></bean>  <bean id="sessionFactory"    class="org.springframework.orm.hibernate5.LocalSessionFactoryBean">    <property name="dataSource" ref="dataSource" />    <property name="packagesToScan">      <list>        <!-- 可以加多个包 -->        <value>test</value>      </list>    </property>    <property name="hibernateProperties">      <props>        <prop key="hibernate.hbm2ddl.auto">create-drop</prop>        <prop key="hibernate.dialect">org.hibernate.dialect.MySQL5Dialect</prop>        <prop key="hibernate.show_sql">true</prop>        <prop key="hibernate.format_sql">true</prop>        <prop key="hibernate.temp.use_jdbc_metadata_defaults">false</prop>      </props>    </property>    <property name="physicalNamingStrategy" ref="physicalNamingStrategy"></property>    <property name="implicitNamingStrategy" ref="implicitNamingStrategy"></property>  </bean></beans>

public class Test {  public static void main(String[] params){    // 命名策略    new Test().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:         alter table tb_test_table1           drop           foreign key fk_test_table1_test_foreign      Hibernate:         drop table if exists tb_test_table1      Hibernate:         drop table if exists tb_test_table2_impl      Hibernate:         create table tb_test_table1 (          test_id bigint not null auto_increment,          test_name varchar(20),          test_foreign bigint,          primary key (test_id)        )      Hibernate:         create table tb_test_table2_impl (          test_id bigint not null auto_increment,          test_name varchar(20),          primary key (test_id)        )      Hibernate:         alter table tb_test_table1           add constraint fk_test_table1_test_foreign           foreign key (test_foreign)           references tb_test_table2_impl (test_id)      Hibernate:         alter table tb_test_table1           drop           foreign key fk_test_table1_test_foreign      Hibernate:         drop table if exists tb_test_table1      Hibernate:         drop table if exists tb_test_table2_impl     */  }  public void test(){    ApplicationContext context = new ClassPathXmlApplicationContext("spring.xml", this.getClass());    SessionFactory factory = null;    try {      factory = (SessionFactory) context.getBean("sessionFactory");    } finally {      if(factory != null){        factory.close();        factory = null;      }    }  }}