精华内容
下载资源
问答
  • Hibernate命名策略详解

    2020-08-31 13:33:27
    本文主要介绍了Hibernate命名策略。具有很好的参考价值,下面跟着小编一起来看下吧
  • Hibernate命名策略

    2017-01-24 00:28:00
    hibernate的命名策略,可以减少对数据库标识符命名的维护,进一步减少这部份命名的重复性代码量,以提高维护。 hibernate的命名方式,有两类,一类是显式命名,一类是隐式命名。 显式命名:在映射配置时,设置的...

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

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

    • 显式命名:在映射配置时,设置的数据库表名,列名等,就是进行显式命名。
    • 隐式命名:显式命名一般不是必要的,所以可以选择当不设置名称,这时就交由hibernate进行隐式命名,另外隐式命名还包括那些不能进行显式命名的数据库标识符。接口ImplicitNamingStrategy,就是用于实现隐式命名。
    • 过滤命名:接口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;
                }
            }
        }
    }

     

    转载于:https://www.cnblogs.com/hvicen/p/6345559.html

    展开全文
  • 本文讨论了hibernate提供的不同命名策略,以及命名策略从hibernate 4中的hibernate.ejb.naming_strategy到hibernate 5中的hibernate.implicit_naming_strategy和hibernate.physical_naming_strategy的转变。...

    本文讨论了hibernate提供的不同命名策略,以及命名策略从hibernate 4中的hibernate.ejb.naming_strategy到hibernate 5中的hibernate.implicit_naming_strategy和hibernate.physical_naming_strategy的转变。最后,我们将研究一下在Hibernate和配置中实施自定义命名策略以与Spring Boot应用程序一起运行。

    Hibernate 4命名策略

    Hibernate使用这些策略将Java实体和属性名称与相应的关系数据库和列名称进行映射。 在Hibernate4中,使用的命名策略是hibernate.ejb.naming_strategy。 该策略使用EJB3NamingStrategy改良的 NamingStrategyDefaultComponentSafeNamingStrategyDefaultNamingStrategy来映射名称。 EJB3NamingStrategy是使用的默认命名策略,它提供驼峰字段和表名。在命名外键列时,它使用undescore(_)作为分隔符。 例如,如果您有一个名称为table1且名称为id和name的表,则在table2中,外键列将被创建为table1_id,并且此EJB3NamingStrategy实现了NamingStrategy接口。

    Hibernate 5命名策略

    Hibernate 5发布后,由于NamingStrategy合同通常不够灵活以至于无法正确应用给定的命名“规则”,因此hibernate.ejb.naming_strategy不再适用。 取而代之的是,引入了两种新策略来提供对命名策略的深度定制,它们是ImplicitNamingStrategy和PhysicalNamingStrategy。 要使用此策略,有两个要使用的键:implicit_naming_strategy和physical_naming_strategy。Hibernate5仅提供了PhysicalNamingStrategy的一种实现– PhysicalNamingStrategyStandardImpl,但是提供了ImplicitNamingStrategy的几种实现。

    当您在实体定义中未明确提供数据库名称和列名称时,将使用ImplicitNamingStrategy,因为PhysicalNamingStrategy可用于显式定义实体名称和属性名称与数据库名称和列名称的映射规则。

    隐式命名策略

    当实体未明确命名其映射到的数据库表时或当特定属性未明确命名其映射到的数据库列时,将使用ImplicitNamingStrategy。我们可以使用hibernate.implicit_naming_strategy配置设置指定要使用的ImplicitNamingStrategy。默认值是jpa,legacy-hbm,legacy-jpa和component-path。

    物理命名策略

    PhysicalNamingStrategy的想法是定义自定义命名规则,而不必通过显式名称将其硬编码到映射中。以下是PhysicalNamingStrategy的一种实现,用于定义自定义表名和列名。

    package com.devglan;
    
    import java.util.LinkedList;
    import java.util.List;
    import java.util.Locale;
    
    import org.hibernate.boot.model.naming.Identifier;
    import org.hibernate.boot.model.naming.PhysicalNamingStrategy;
    import org.hibernate.engine.jdbc.env.spi.JdbcEnvironment;
    
    import org.apache.commons.lang3.StringUtils;
    
    public class CustomPhysicalNamingStrategy implements PhysicalNamingStrategy {
    
        @Override
        public Identifier toPhysicalCatalogName(Identifier name, JdbcEnvironment jdbcEnvironment) {
            return name;
        }
    
        @Override
        public Identifier toPhysicalSchemaName(Identifier name, JdbcEnvironment jdbcEnvironment) {
            return name;
        }
    
        @Override
        public Identifier toPhysicalTableName(Identifier name, JdbcEnvironment jdbcEnvironment) {
            final List parts = splitAndReplace( name.getText() );
            return jdbcEnvironment.getIdentifierHelper().toIdentifier(
                    join( parts ),
                    name.isQuoted()
            );
        }
    
        @Override
        public Identifier toPhysicalSequenceName(Identifier name, JdbcEnvironment jdbcEnvironment) {
            return name;
        }
    
        @Override
        public Identifier toPhysicalColumnName(Identifier name, JdbcEnvironment jdbcEnvironment) {
            final List parts = splitAndReplace( name.getText() );
            return jdbcEnvironment.getIdentifierHelper().toIdentifier(
                    join( parts ),
                    name.isQuoted()
            );
        }
    
        private LinkedList splitAndReplace(String name) {
            LinkedList result = new LinkedList<>();
            for ( String part : StringUtils.splitByCharacterTypeCamelCase( name ) ) {
                if ( part == null || part.trim().isEmpty() ) {
                    continue;
                }
                result.add( part.toUpperCase( Locale.ROOT ) );
            }
            return result;
        }
    
        private String join(List parts) {
            boolean firstPass = true;
            String separator = "";
            StringBuilder joined = new StringBuilder();
            for ( String part : parts ) {
                joined.append( separator ).append( part );
                if ( firstPass ) {
                    firstPass = false;
                    separator = "_";
                }
            }
            return joined.toString();
        }
    }

    要在Hibernate状态下使用此自定义策略,请执行以下配置。

    jpaProperties.put("hibernate.physical_naming_strategy", "com.devglan.config.CustomPhysicalNamingStrategy");

    Spring Boot中的Hibernate命名策略

    正如我们所讨论的那样,hibernate提供了两种不同的命名策略,而Spring Boot使用SpringPhysicalNamingStrategy配置物理命名策略,其中所有点都由下划线替换,并且驼峰式大写字母由下划线替换,并且所有表名均以小写形式生成。例如,USERDETAILS实体映射到user_details表。

    如果要使用上面实现的自定义命名策略,则可以在application.properties中进行以下配置。

    spring.jpa.hibernate.naming.physical-strategy=com.devglan.config.CustomPhysicalNamingStrategy);

    结论

    在本文中,我们了解了Spring Boot和Hibernate提供的不同命名策略以及实现我们自己的自定义命名策略的方法。 如果您有任何要添加或共享的内容,请在下面的评论部分中共享。

    翻译自: https://www.javacodegeeks.com/2018/03/different-hibernate-naming-strategy.html

    展开全文
  • 不同的休眠命名策略

    2020-06-09 01:19:24
    本文讨论了hibernate提供的不同命名策略,以及命名策略从hibernate 4中的hibernate.ejb.naming_strategy到hibernate 5中的hibernate.implicit_naming_strategy和hibernate.physical_naming_strategy的转变。...

    本文讨论了hibernate提供的不同命名策略,以及命名策略从hibernate 4中的hibernate.ejb.naming_strategy到hibernate 5中的hibernate.implicit_naming_strategy和hibernate.physical_naming_strategy的转变。最后,我们将研究一下在休眠和配置中实施自定义命名策略以与Spring Boot应用程序一起运行。

    Hibernate 4命名策略

    Hibernate使用这些策略将Java实体和属性名称与相应的关系数据库和列名称进行映射。 在休眠4中,使用的命名策略是hibernate.ejb.naming_strategy。 该策略使用EJB3NamingStrategy改良的 NamingStrategyDefaultComponentSafeNamingStrategyDefaultNamingStrategy来映射名称。 EJB3NamingStrategy是使用的默认命名策略,它提供驼峰字段和表名。在命名外键列时,它使用undescore(_)作为分隔符。 例如,如果您有一个名称为table1且表名分别为id和name的表,那么在table2中,外键列将被创建为table1_id,并且此EJB3NamingStrategy实现了NamingStrategy接口。

    Hibernate 5命名策略

    Hibernate 5发布后,由于NamingStrategy合同通常不够灵活以至于无法正确应用给定的命名“规则”,因此hibernate.ejb.naming_strategy不再适用。 取而代之的是,引入了两种新策略来提供命名策略的深度自定义,它们是ImplicitNamingStrategy和PhysicalNamingStrategy。 要使用此策略,有两个密钥需要使用implicit_naming_strategy和physical_naming_strategy。Hibernate5仅提供了PhysicalNamingStrategy的一种实现– PhysicalNamingStrategyStandardImpl,但是提供了ImplicitNamingStrategy的几种实现。

    当您在实体定义中未明确提供数据库名称和列名称时,将使用ImplicitNamingStrategy,因为PhysicalNamingStrategy可以用于显式定义实体名称和属性名称与数据库和列名称的映射规则。

    隐式命名策略

    当实体未明确命名其映射到的数据库表时或当特定属性未明确命名其映射到的数据库列时,将使用ImplicitNamingStrategy。我们可以使用hibernate.implicit_naming_strategy配置设置指定要使用的ImplicitNamingStrategy来接受默认值是jpa,legacy-hbm,legacy-jpa和component-path。

    物理命名策略

    PhysicalNamingStrategy的思想是定义自定义命名规则,而不必通过显式名称将其硬编码到映射中。以下是PhysicalNamingStrategy的一种实现,用于定义自定义表名和列名。

    package com.devglan;
    
    import java.util.LinkedList;
    import java.util.List;
    import java.util.Locale;
    
    import org.hibernate.boot.model.naming.Identifier;
    import org.hibernate.boot.model.naming.PhysicalNamingStrategy;
    import org.hibernate.engine.jdbc.env.spi.JdbcEnvironment;
    
    import org.apache.commons.lang3.StringUtils;
    
    public class CustomPhysicalNamingStrategy implements PhysicalNamingStrategy {
    
        @Override
        public Identifier toPhysicalCatalogName(Identifier name, JdbcEnvironment jdbcEnvironment) {
            return name;
        }
    
        @Override
        public Identifier toPhysicalSchemaName(Identifier name, JdbcEnvironment jdbcEnvironment) {
            return name;
        }
    
        @Override
        public Identifier toPhysicalTableName(Identifier name, JdbcEnvironment jdbcEnvironment) {
            final List parts = splitAndReplace( name.getText() );
            return jdbcEnvironment.getIdentifierHelper().toIdentifier(
                    join( parts ),
                    name.isQuoted()
            );
        }
    
        @Override
        public Identifier toPhysicalSequenceName(Identifier name, JdbcEnvironment jdbcEnvironment) {
            return name;
        }
    
        @Override
        public Identifier toPhysicalColumnName(Identifier name, JdbcEnvironment jdbcEnvironment) {
            final List parts = splitAndReplace( name.getText() );
            return jdbcEnvironment.getIdentifierHelper().toIdentifier(
                    join( parts ),
                    name.isQuoted()
            );
        }
    
        private LinkedList splitAndReplace(String name) {
            LinkedList result = new LinkedList<>();
            for ( String part : StringUtils.splitByCharacterTypeCamelCase( name ) ) {
                if ( part == null || part.trim().isEmpty() ) {
                    continue;
                }
                result.add( part.toUpperCase( Locale.ROOT ) );
            }
            return result;
        }
    
        private String join(List parts) {
            boolean firstPass = true;
            String separator = "";
            StringBuilder joined = new StringBuilder();
            for ( String part : parts ) {
                joined.append( separator ).append( part );
                if ( firstPass ) {
                    firstPass = false;
                    separator = "_";
                }
            }
            return joined.toString();
        }
    }

    要在休眠状态下使用此自定义策略,请执行以下配置。

    jpaProperties.put("hibernate.physical_naming_strategy", "com.devglan.config.CustomPhysicalNamingStrategy");

    Spring Boot中的休眠命名策略

    正如我们所讨论的那样,hibernate提供了两种不同的命名策略,而Spring Boot使用SpringPhysicalNamingStrategy配置了物理命名策略,其中所有的点都由下划线代替,而驼峰的大小写由下划线代替,并且所有表名均以小写形式生成。例如,USERDETAILS实体映射到user_details表。

    如果要使用上面实现的自定义命名策略,可以在application.properties中进行以下配置。

    spring.jpa.hibernate.naming.physical-strategy=com.devglan.config.CustomPhysicalNamingStrategy);

    结论

    在本文中,我们了解了Spring Boot和Hibernate提供的不同命名策略以及实现我们自己的自定义命名策略的方法。 如果您有任何要添加或共享的内容,请在下面的评论部分中共享。

    翻译自: https://www.javacodegeeks.com/2018/03/different-hibernate-naming-strategy.html

    展开全文
  • 命名实体识别 本文讨论了hibernate提供的不同命名策略,以及命名策略从hibernate 4中的hibernate.ejb.naming_strategy到hibernate 5中的hibernate.implicit_naming_strategy和hibernate.physical_naming_strategy的...
    命名实体识别

    命名实体识别

    本文讨论了hibernate提供的不同命名策略,以及命名策略从hibernate 4中的hibernate.ejb.naming_strategy到hibernate 5中的hibernate.implicit_naming_strategy和hibernate.physical_naming_strategy的转变。最后,我们将研究一下在Hibernate和配置中实施自定义命名策略以与Spring Boot应用程序一起运行。

    Hibernate 4命名策略

    Hibernate使用这些策略将Java实体和属性名称与相应的关系数据库和列名称进行映射。 在Hibernate4中,使用的命名策略是hibernate.ejb.naming_strategy。 该策略使用EJB3NamingStrategy改良的NamingStrategyDefaultComponentSafeNamingStrategyDefaultNamingStrategy来映射名称。 EJB3NamingStrategy是使用的默认命名策略,它提供驼峰字段和表名。在命名外键列时,它使用undescore(_)作为分隔符。 例如,如果您有一个名称为table1且名称为id和name的表,则在table2中,外键列将被创建为table1_id,并且此EJB3NamingStrategy实现了NamingStrategy接口。

    Hibernate 5命名策略

    Hibernate 5发布后,由于NamingStrategy合同通常不够灵活以至于无法正确应用给定的命名“规则”,因此hibernate.ejb.naming_strategy不再适用。 取而代之的是,引入了两种新策略来提供对命名策略的深度定制,它们是ImplicitNamingStrategy和PhysicalNamingStrategy。 要使用此策略,有两个要使用的键:implicit_naming_strategy和physical_naming_strategy。Hibernate5仅提供了PhysicalNamingStrategy的一种实现– PhysicalNamingStrategyStandardImpl,但是提供了ImplicitNamingStrategy的几种实现。

    当您没有在实体定义中显式提供数据库和列名称时,将使用ImplicitNamingStrategy,其中,如PhysicalNamingStrategy可以用于显式定义实体和属性名称与数据库和列名称的映射规则。

    隐式命名策略

    当实体未明确命名其映射到的数据库表时或当特定属性未明确命名其映射到的数据库列时,将使用ImplicitNamingStrategy。我们可以使用hibernate.implicit_naming_strategy配置设置指定要使用的ImplicitNamingStrategy默认值是jpa,legacy-hbm,legacy-jpa和component-path。

    物理命名策略

    PhysicalNamingStrategy的思想是定义自定义命名规则,而不必通过显式名称将其硬编码到映射中。以下是PhysicalNamingStrategy的一种实现,用于定义自定义表名和列名。

    package com.devglan;
    
    import java.util.LinkedList;
    import java.util.List;
    import java.util.Locale;
    
    import org.hibernate.boot.model.naming.Identifier;
    import org.hibernate.boot.model.naming.PhysicalNamingStrategy;
    import org.hibernate.engine.jdbc.env.spi.JdbcEnvironment;
    
    import org.apache.commons.lang3.StringUtils;
    
    public class CustomPhysicalNamingStrategy implements PhysicalNamingStrategy {
    
        @Override
        public Identifier toPhysicalCatalogName(Identifier name, JdbcEnvironment jdbcEnvironment) {
            return name;
        }
    
        @Override
        public Identifier toPhysicalSchemaName(Identifier name, JdbcEnvironment jdbcEnvironment) {
            return name;
        }
    
        @Override
        public Identifier toPhysicalTableName(Identifier name, JdbcEnvironment jdbcEnvironment) {
            final List parts = splitAndReplace( name.getText() );
            return jdbcEnvironment.getIdentifierHelper().toIdentifier(
                    join( parts ),
                    name.isQuoted()
            );
        }
    
        @Override
        public Identifier toPhysicalSequenceName(Identifier name, JdbcEnvironment jdbcEnvironment) {
            return name;
        }
    
        @Override
        public Identifier toPhysicalColumnName(Identifier name, JdbcEnvironment jdbcEnvironment) {
            final List parts = splitAndReplace( name.getText() );
            return jdbcEnvironment.getIdentifierHelper().toIdentifier(
                    join( parts ),
                    name.isQuoted()
            );
        }
    
        private LinkedList splitAndReplace(String name) {
            LinkedList result = new LinkedList<>();
            for ( String part : StringUtils.splitByCharacterTypeCamelCase( name ) ) {
                if ( part == null || part.trim().isEmpty() ) {
                    continue;
                }
                result.add( part.toUpperCase( Locale.ROOT ) );
            }
            return result;
        }
    
        private String join(List parts) {
            boolean firstPass = true;
            String separator = "";
            StringBuilder joined = new StringBuilder();
            for ( String part : parts ) {
                joined.append( separator ).append( part );
                if ( firstPass ) {
                    firstPass = false;
                    separator = "_";
                }
            }
            return joined.toString();
        }
    }

    要在Hibernate状态下使用此自定义策略,请执行以下配置。

    jpaProperties.put("hibernate.physical_naming_strategy", "com.devglan.config.CustomPhysicalNamingStrategy");

    Spring Boot中的Hibernate命名策略

    正如我们所讨论的那样,hibernate提供了两种不同的命名策略,而Spring Boot使用SpringPhysicalNamingStrategy配置了物理命名策略,其中所有的点都由下划线代替,而驼峰的大小写由下划线代替,并且所有表名均以小写形式生成。映射到user_details表。

    如果要使用自己实现的自定义命名策略,则可以在application.properties中进行以下配置。

    spring.jpa.hibernate.naming.physical-strategy=com.devglan.config.CustomPhysicalNamingStrategy);

    结论

    在本文中,我们了解了Spring Boot和Hibernate提供的不同命名策略,以及实现我们自己的自定义命名策略的方法。 如果您有任何要添加或共享的内容,请在下面的评论部分中共享。

    翻译自: https://www.javacodegeeks.com/2018/03/different-hibernate-naming-strategy.html

    命名实体识别

    展开全文
  • JPA命名策略

    2016-11-03 16:46:33
    有人碰到这样一个问题“导入的...这个问题主要是JPA的命名策略不一致导致的。 我们有这么一个配置: spring.jpa.hibernate.naming-strategy = org.hibernate.cfg.DefaultNamingStrategy 这里的值有两
  • 我们可以使用组命名策略来为组织中用户创建的Office 365组执行强制命名一致性策略。命名策略可以帮助我们和用户们识别组的功能,成员隶属关系,地理区域或是创建者等。命名策略还有助于在地址簿中对组进行分类。我们...
  • 最近在梳理数据生命周期管理的细节时,发现了一个小问题,那就是MySQL的主键命名策略,似乎会忽略任何形式的自定义命名。也就意味着你给主键命名为idx_pk_id这种形式,在MySQL里面会统一按照PRIMARY来处理。当然我们...
  • hibernate创建命名策略

    2015-08-12 16:37:00
    同时提供两种参考的命名策略。DefaultNamingStaregy 和ImporvedNamingStartegy 覆盖对应的方法就可以了。 2.如何在定义数据库表的时候,没有定义table ,则调用,定义了就按定义的命名策略。 3.类的属性同上。 4....
  • Jackson修改字段名和自定义命名策略

    千次阅读 2020-10-03 22:23:46
    使用预定义的命名策略PropertyNamingStrategy,设置全局或单个类的命名策略; 扩展PropertyNamingStrategy,实现自定义命名策略,读和写支持使用不同的命名策略。 本篇内容基于Jackson 2.11.2版本.
  • 单个类的命名策略设置 单个类设置在需要的实体上添加@JsonNaming(PropertyNamingStrategy.SnakeCaseStrategy.class)注解 整个项目命名策略的设置 通过properties设置 (yml格式) spring:  jackso...
  • 最近有个项目因为命名策略的原因导致数据库表的不符合标准,所以看了下源码,废话不多说上代码! 现有的命名策略 jpa现有的命名策略设置:hibernate.implicit_naming_strategy(隐式),hibernate.physical_naming...
  • Spring boot 自定义数据库命名策略

    千次阅读 2018-05-12 11:45:14
    1. Spring boot 默认是有数据库命名策略的,比如实体是AdminUser, 那么映射到数据库的时候是:admin_user。那么如果这样已经符合需求,那就什么都不需要操作。但是一般情况下,我们的数据库表都喜欢加上一些前缀,...
  • Hibernate之创建命名策略 [url]http://www.cnblogs.com/wangyong/p/Hibernate.html[/url] hibernate 表 命名策略 [url]...spring管理Hibernate时,对于hibernate命名策略的配置 [...
  • 64. JPA命名策略

    万次阅读 2016-09-17 23:24:28
    【从零开始学习Spirng Boot—常见异常汇总】 在(39.2). Spring Boot Shiro权限管理【从零开始学Spring Boot】  ...这个问题主要是JPA的命名策略不一致导致的。 我们有这么一个配置: spring.jpa.hiber
  • hibernate3命名策略

    2015-01-21 15:44:49
    数据库必须建立column名称为USER_NAME,这是因为在项目搭建过程中实现了hibernate3.jar的org.hibernate.cfg.NamingStrategy接口,重写了类名和属性名的命名策略。 例如下: import org.hibernate.AssertionFailure...
  • 2. 通过命名策略来实现自动映射 属性较多时,通过注解显式声明比较麻烦,最好能自动映射,在spring-data整合的Hibernate实现中,Spring提供了默认从驼峰到蛇形命名的映射,但Quarkus和Hibernate本身并没有提供这种...
  • EntityBinder使用ObjectNameNormalizer.NamingStrategyHelper提供名称,它从Configuration.namingStrategy(全局一个)获取命名策略,或从复杂路径获取,该路径通过MetadataImpl并且无处可去(没有用法).因此,您可能会...
  • Hibernate 命名策略

    2010-11-06 19:16:24
    定制自己的命名策略,必须要实现一个接口,或继承自这两个类   接口:org.hibernate.cfg.NamingStrategy; 类:org.hibernate.cfg.ImprovedNamingStrategy; 类:org.hibernate.cfg.DefaultNamingStrategy;   ...
  • 今天在配置spring boot和jpa集成的时候遇到...主要原因是新版本的hibernate(即hibernate4以上的版本)实体映射到数据表时的命名策略 可以参考这个: https://www.cnblogs.com/sxdcgaq8080/p/7910474.html ...
  • #spring data jpa默认命名策略是遇到大写字母加“_”命名spring.jpa.hibernate.naming.physical-strategy=org.springframework.boot.orm.jpa.hibernate.SpringPhysicalNamingStrategy如果数据库设计是以帕斯卡命名法...
  • spring boot 中Spring data jpa命名策略 数据库,表字段命名是驼峰命名法(UserID),Spring data jpa 自动更新之后是 user_id, 表字段不对照, Spring data jpa基于Hibernate5.0 application.properties 写法 1...
  • 命名策略采用naming-strategy配置项 spring.jpa.hibernate.naming-strategy = org.hibernate.cfg.DefaultNamingStrategy 1、配置值org.hibernate.cfg.DefaultNamingStrategy hibernate默认配置,采用直接映射的...
  • hibernage命名策略

    2010-04-17 20:44:48
    关于使用Hibernate annotation注解映射和命名策略的方式及相关问题解决 一、首先引出以下几个观点: 1).开发项目时,不管是否使用Hibernate,都应该为项目所涉及到的表名取个前缀(如果还有特别需要也可以再加个...
  • 命名策略将一个对象模型的名字映射到响应的数据库名字是映射一个对象模型到关系数据库的一部分。Hibernate 将这个分为两个步骤: 第一步是从领域模型映射中确定一个合适的逻辑名称。一个逻辑名称即可以被用户明确的...
  • spring-data-jpa 下自定义命名策略

    千次阅读 2017-10-09 17:25:37
    spring-data-jpa自动命名策略
  • 有的则在@Column注解中使用name属性定义自己的名称,但是有时候比如说设计一个数据库有统一前缀或者后缀,上面两种方式就不适用了,而需要统一的设计命名策略,本篇文章对这部分进行总结!1、 历史版本中命名策略...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,720
精华内容 688
关键字:

命名策略