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