Hibernate命名策略详解

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

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

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

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

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

示例：

testtable1impl.java

@entity
// 隐式命名表名
@table
public 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;
  }
}

testtable2impl.java

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

myimplicitnamingstrategyimpl.java

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

myphysicalnamingstrategyimpl.java

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

tablenamingconfig.java

public class tablenamingconfig {
  public static final string table_prefix = "tb_";
  public static final string foreign_key_prefix = "fk_";
}

spring.xml

<?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>

test.java

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

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