脚本之家 服务器常用软件
快捷导航
您的位置：首页 → 软件编程 → java → Hibernate命名策略

Hibernate命名策略详解

 更新时间：2017年01月24日 09:39:34   作者：突破渴望  
本文主要介绍了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;
      }
    }
  }
}

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

您可能感兴趣的文章:

相关文章

  • 基于Jpa中ManyToMany和OneToMany的双向控制

    基于Jpa中ManyToMany和OneToMany的双向控制

    这篇文章主要介绍了Jpa中ManyToMany和OneToMany的双向控制，具有很好的参考价值，希望对大家有所帮助。如有错误或未考虑完全的地方，望不吝赐教
    2021-12-12
  • 解决java编译错误（ 程序包javax.servlet不存在javax.servlet.*）

    解决java编译错误（ 程序包javax.servlet不存在javax.servlet.*）

    这篇文章主要介绍了解决java编译错误的相关资料,主要解决 程序包javax.servlet不存在javax.servlet.*的问题，需要的朋友可以参考下
    2017-08-08
  • SpringBoot解决跨域问题的五种方案

    SpringBoot解决跨域问题的五种方案

    跨域问题指的是不同站点之间,使用 ajax 无法相互调用的问题,跨域问题本质是浏览器的一种保护机制,它的初衷是为了保证用户的安全,防止恶意网站窃取数据,那怎么解决这个问题呢？接下来我们一起来看,需要的朋友可以参考下
    2024-07-07
  • Spring中配置和读取多个Properties文件的方式方法

    Spring中配置和读取多个Properties文件的方式方法

    本篇文章主要介绍了Spring中配置和读取多个Properties文件的方式方法，具有一定的参考价值，感兴趣的小伙伴们可以参考一下。
    2017-04-04
  • java9学习笔记之模块化详解

    java9学习笔记之模块化详解

    Java 9中最重要的功能，毫无疑问就是模块化（Module），下面这篇文章主要给大家介绍了关于java9学习笔记之模块化的相关资料，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面来一起看看吧。
    2018-04-04
  • Java并发编程之Semaphore的使用简介

    Java并发编程之Semaphore的使用简介

    这篇文章主要介绍了Java并发编程之Semaphore的使用简介，帮助大家更好的理解和学习使用Java，感兴趣的朋友可以了解下
    2021-04-04
  • JAVA获得域名IP地址的方法

    JAVA获得域名IP地址的方法

    这篇文章主要介绍了JAVA获得域名IP地址的方法,涉及java域名操作的相关技巧,需要的朋友可以参考下
    2015-06-06
  • Java Swing组件文件选择器JFileChooser简单用法示例

    Java Swing组件文件选择器JFileChooser简单用法示例

    这篇文章主要介绍了Java Swing组件文件选择器JFileChooser简单用法,结合实例形式分析了Swing组件中的文件选择器JFileChooser的简单使用方法,需要的朋友可以参考下
    2017-11-11
  • Spring Boot整合 NoSQL 数据库 Redis详解

    Spring Boot整合 NoSQL 数据库 Redis详解

    这篇文章主要为大家介绍了Spring Boot整合 NoSQL 数据库 Redis详解，有需要的朋友可以借鉴参考下，希望能够有所帮助，祝大家多多进步，早日升职加薪
    2022-09-09
  • SpringBoot结合Swagger2自动生成api文档的方法

    SpringBoot结合Swagger2自动生成api文档的方法

    这篇文章主要介绍了SpringBoot结合Swagger2自动生成api文档的方法，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
    2019-05-05

最新评论