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

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

    展开全文
  • Spring Boot Jackson命名策略

    千次阅读 2020-01-02 10:22:10
    那么,针对此问题,可以使用Jackson命名策略来进行解决。比如所有属性都是基于驼峰标识,需要转化为以下划线“_”进行分割,那么就可以使用@JsonNaming来统一策略指定。 @JsonNaming(PropertyNamingStrategy....

    在Spring Boot的Jackson中我们可以使用@JsonProperty对Java属性转Json字符串的key进行指定。那么,当批量处理统一类型的格式时,@JsonProperty就显得比较麻烦了。

    public class LoginUser {
    
    	@JsonProperty("user_name")
    	private String username;
    }
    

    那么,针对此问题,可以使用Jackson命名策略来进行解决。比如所有属性都是基于驼峰标识,需要转化为以下划线“_”进行分割,那么就可以使用@JsonNaming来统一策略指定。

    @JsonNaming(PropertyNamingStrategy.SnakeCaseStrategy.class)
    public class UserDetail {
        
    }
    

    这样,该类下的所有属性在转化为Json字符串时,均会将驼峰标识转化为以下划线“_”进行分割。

    其中在PropertyNamingStrategy中,提供了多种策略。

    • SNAKE_CASE:示例“userName”转化为“user_name”。
    • UPPER_CAMEL_CASE:示例“userName”转化为“UserName”。
    • LOWER_CAMEL_CASE:默认模式,示例“userName”转化为“userName”。
    • LOWER_CASE:示例“userName”转化为“username”。
    • KEBAB_CASE:示例“userName”转化为“user-name”。
    • LOWER_DOT_CASE:示例“userName”转化为“user.name”。

    CSDN学院:《Spring Boot 视频教程全家桶》


    程序新视界

    公众号“程序新视界”,一个让你软实力、硬技术同步提升的平台

    csdn-微信公众号

    展开全文
  • 此外,引入的 Hibernate 还提供了另外一种物理命名策略,先进行如下配置,再来观察结果: spring: datasource: username: root password: root url: jdbc:mysql://localhost:3306/test?useUnicode=true&...

    本次示例的项目中,定义了如下两个实体:

    @Data
    @Entity
    public class Teacher {
    
        @Id
        @GeneratedValue(strategy = GenerationType.IDENTITY)
        private Integer id;
    
        @Column(name = "Name")
        private String name;
    
    }
    
    @Data
    @Entity
    @Table(name = "teacher_class")
    public class TeacherClass {
    
        @Id
        @GeneratedValue(strategy = GenerationType.IDENTITY)
        private Integer id;
    
        private Integer teacherId;
    
        @Column(name = "ClassName")
        private String className;
    
    }
    

    先来看看 JPA 默认的命名策略,我们可以显示配置如下:

    spring:
      datasource:
        username: root
        password: root
        url: jdbc:mysql://localhost:3306/test?useUnicode=true&characterEncoding=utf-8&useSSL=false
      jpa:
        database-platform: org.hibernate.dialect.MySQL5InnoDBDialect
        show-sql: true
        hibernate:
          ddl-auto: create
          naming:
             # 1. 表名及字段全小写下划线分隔命名策略(默认)
             physical-strategy: org.springframework.boot.orm.jpa.hibernate.SpringPhysicalNamingStrategy
    
    Hibernate: create table teacher (id integer not null auto_increment, name varchar(255), primary key (id)) engine=InnoDB
    Hibernate: create table teacher_class (id integer not null auto_increment, class_name varchar(255), teacher_id integer, primary key (id)) engine=InnoDB
    

    运行项目,通过数据库或输出的SQL语句,默认策略的表现为:表名及字段全小写,并以下划线分隔

    此外,引入的 Hibernate 还提供了另外一种物理命名策略,先进行如下配置,再来观察结果:

    spring:
      datasource:
        username: root
        password: root
        url: jdbc:mysql://localhost:3306/test?useUnicode=true&characterEncoding=utf-8&useSSL=false
      jpa:
        database-platform: org.hibernate.dialect.MySQL5InnoDBDialect
        show-sql: true
        hibernate:
          ddl-auto: create
          naming:
             # 2. 物理命名策略,未定义 @Table 和 @Column 将以实体名和属性名作为表名及字段名
             physical-strategy: org.hibernate.boot.model.naming.PhysicalNamingStrategyStandardImpl
    
    Hibernate: create table Teacher (id integer not null auto_increment, Name varchar(255), primary key (id)) engine=InnoDB
    Hibernate: create table teacher_class (id integer not null auto_increment, ClassName varchar(255), teacherId integer, primary key (id)) engine=InnoDB
    

    以上表明,Hibernate 提供的命名策略是以实体名和属性名分别作为表名及字段名,但如果有定义 @Table@Column ,则以该属性值进行映射命名

    当然,某些场景下,可以通过自定义命名策略来简化操作,或实现自身特定的业务,例如:假设需要为未定义 @Table 实体加上表前缀 tb_,或是以大写字母下划线来分隔定义字段(简单起见,以下配置并不直接实现 PhysicalNamingStrategy):

    public class CustomNamingStrategyConfig extends SpringPhysicalNamingStrategy {
    
        /**
         * 配置映射的数据表名
         *
         * @param name
         * @param jdbcEnvironment
         * @return
         */
        @Override
        public Identifier toPhysicalTableName(Identifier name, JdbcEnvironment jdbcEnvironment) {
            if (name == null) {
                return null;
            }
            // 实体名 or 自定义的@Tabel name属性值
            String text = name.getText();
    
            // 首字母大写(类名),实体未定义@Table, 为表名加上tb_前缀
            if (Character.isUpperCase(text.charAt(0))) {
                final String tb = "tb_";
                if (!text.contains(tb)) {
                    text = "tb" + text;
                }
    
                StringBuilder builder = new StringBuilder(text.replace('.', '_'));
                for (int i = 1, maxLength = builder.length() - 1; i < maxLength; i++) {
                    if (this.isUnderscoreRequired(builder.charAt(i - 1), builder.charAt(i), builder.charAt(i + 1))) {
                        builder.insert(i++, '_');
                    }
                }
                return super.getIdentifier(builder.toString(), name.isQuoted(), jdbcEnvironment);
            } else {
                // 实体定义了@Table(name="xxx"),以name属性值为表名
                return super.getIdentifier(text, name.isQuoted(), jdbcEnvironment);
            }
        }
    
        /**
         * 判断是否前一个字符为小写字母,当前字符为大写字母,下一个字符为小写字母
         *
         * @param before
         * @param current
         * @param after
         * @return
         */
        private boolean isUnderscoreRequired(char before, char current, char after) {
            return Character.isLowerCase(before) && Character.isUpperCase(current) && Character.isLowerCase(after);
        }
    
        /**
         * 配置映射的字段名
         *
         * @param name
         * @param jdbcEnvironment
         * @return
         */
        @Override
        public Identifier toPhysicalColumnName(Identifier name, JdbcEnvironment jdbcEnvironment) {
            // 实体的属性名 or 自定义的@Column name属性值
            String text = name.getText();
    
            if (Character.isUpperCase(text.charAt(0))) {
                // 大写字母下划线分隔命名策略,有在实体字段上自定义@Column(name="Xx_Xxx")
                return new Identifier(text, name.isQuoted());
            } else {
                // 常见的小写驼峰式命名策略
                return super.toPhysicalColumnName(name, jdbcEnvironment);
            }
        }
    
    }
    

    application.yml 中修改如下配置:

    spring:
      datasource:
        username: root
        password: root
        url: jdbc:mysql://localhost:3306/test?useUnicode=true&characterEncoding=utf-8&useSSL=false
      jpa:
        database-platform: org.hibernate.dialect.MySQL5InnoDBDialect
        show-sql: true
        hibernate:
          ddl-auto: create
          naming:
            # 3. 自定义的命名策略
            physical-strategy: cn.mariojd.jpa.naming.config.CustomNamingStrategyConfig
    

    启动项目,查看结果,符合以上预设的实现要求

    Hibernate: create table tb_teacher (id integer not null auto_increment, Name varchar(255), primary key (id)) engine=InnoDB
    Hibernate: create table teacher_class (id integer not null auto_increment, ClassName varchar(255), teacher_id integer, primary key (id)) engine=InnoDB
    

    示例源码
    欢迎关注我的个人公众号:超级码里奥
    如果这对您有帮助,欢迎点赞和分享,转载请注明出处

    展开全文
  • Hibernate5中实体映射命名策略

    千次阅读 2018-12-04 16:11:38
    for org.hibernate.boot.model.naming.ImplicitNamingStrategyJpaCompliantImpl- 符合JPA 2.0标准的命名策略 legacy-hbm for org.hibernate.boot.model.naming.ImplicitNamingStrategyLegacyHbmImpl- 符合原始的...

    对象模型到关系数据库的映射的一部分是将对象模型中的名称映射到相应的数据库名称。

    首先说明一点,Hibernate5中不再支持hibernate.ejb.naming_strategy属性配置,可以使用如下两个属性配置替换:

    hibernate.implicit_naming_strategy
    hibernate.physical_naming_strategy
    

    Hibernate5以前默认命名策略接口类示意图:
    在这里插入图片描述

    Hibernate5将此视为2阶段过程:

    • 第一阶段是从域模型映射中确定正确的逻辑名称。逻辑名可以由用户显式指定(使用@Column或 @Table例如),也可以由Hibernate通过ImplicitNamingStrategy契约隐式确定 。
    • 其次是将此逻辑名解析为PhysicalNamingStrategy合约定义的物理名称。

    【1】 ImplicitNamingStrategy

    当实体没有显式命名它映射到的数据库表时,我们需要隐式确定该表名。或者,当某个特定属性没有显式命名它映射到的数据库列时,我们需要隐式确定该列名。org.hibernate.boot.model.naming.ImplicitNamingStrategy当映射未提供显式名称时,有一些规则用于确定逻辑名称的示例。

    在这里插入图片描述

    ① ImplicitNamingStrategy的实现

    Hibernate定义了多个ImplicitNamingStrategy实现。应用程序也可以插入自定义实现。有多种方法可以指定要使用的ImplicitNamingStrategy。

    首先,应用程序可以使用hibernate.implicit_naming_strategy配置设置指定实现,该配置设置接受:

    • 用于开箱即用的实现的预定义“短名称”
      default
      for org.hibernate.boot.model.naming.ImplicitNamingStrategyJpaCompliantImpl- 别名jpa
      jpa
      for org.hibernate.boot.model.naming.ImplicitNamingStrategyJpaCompliantImpl- 符合JPA 2.0标准的命名策略
      legacy-hbm
      for org.hibernate.boot.model.naming.ImplicitNamingStrategyLegacyHbmImpl- 符合原始的Hibernate NamingStrategy
      legacy-jpa
      for org.hibernate.boot.model.naming.ImplicitNamingStrategyLegacyJpaImpl- 符合为JPA 1.0开发的遗留NamingStrategy,遗憾的是,在很多方面都不清楚隐式命名规则
      component-path
      for org.hibernate.boot.model.naming.ImplicitNamingStrategyComponentPathImpl- 主要遵循ImplicitNamingStrategyJpaCompliantImpl规则,除了它使用完整的复合路径,而不仅仅是结束属性部分

    • 引用实现org.hibernate.boot.model.naming.ImplicitNamingStrategy的类

    其次,应用程序和集成可以利用org.hibernate.boot.MetadataBuilder#applyImplicitNamingStrategy 指定要使用的ImplicitNamingStrategy。


    ② 配置ImplicitNamingStrategy

    方法1

    在Hibernate的配置信息设置的时候,如下:

    Configuration config = new Configuration().configure();
    config.setImplicitNamingStrategy(ImplicitNamingStrategyComponentPathImpl.INSTANCE);
    

    方法二

    ServiceRegistry serviceRegistry = new StandardServiceRegistryBuilder().build();
    MetadataSources sources = new MetadataSources(serviceRegistry);
    MetadataBuilder builder = sources.getMetadataBuilder();
    builder.applyImplicitNamingStrategy(ImplicitNamingStrategyComponentPathImpl.INSTANCE);
    

    方法三

    SpringBoot整合JPA中在application.yml中配置:
    在这里插入图片描述


    【2】PhysicalNamingStrategy

    许多组织围绕数据库对象(表,列,外键等)的命名定义规则。PhysicalNamingStrategy的想法是帮助实现这样的命名规则,而不必通过显式名称将它们硬编码到映射中。

    虽然ImplicitNamingStrategy的目的是确定一个名为accountNumbermap 的属性映射到accountNumber未明确指定的逻辑列名称,但PhysicalNamingStrategy的目的是,例如,应该说缩写物理列名称acct_num。

    默认实现是简单地使用逻辑名称作为物理名称。但是,应用程序和集成可以定义此PhysicalNamingStrategy规则的自定义实现。

    PhysicalNamingStrategy 接口源码如下:

    public interface PhysicalNamingStrategy {
    	public Identifier toPhysicalCatalogName(Identifier name, JdbcEnvironment jdbcEnvironment);
    
    	public Identifier toPhysicalSchemaName(Identifier name, JdbcEnvironment jdbcEnvironment);
    
    	public Identifier toPhysicalTableName(Identifier name, JdbcEnvironment jdbcEnvironment);
    
    	public Identifier toPhysicalSequenceName(Identifier name, JdbcEnvironment jdbcEnvironment);
    
    	public Identifier toPhysicalColumnName(Identifier name, JdbcEnvironment jdbcEnvironment);
    }
    

    其只有一个实现:

    public class PhysicalNamingStrategyStandardImpl implements PhysicalNamingStrategy, Serializable {
    	/**
    	 * Singleton access
    	 */
    	public static final PhysicalNamingStrategyStandardImpl INSTANCE = new PhysicalNamingStrategyStandardImpl();
    
    	@Override
    	public Identifier toPhysicalCatalogName(Identifier name, JdbcEnvironment context) {
    		return name;
    	}
    
    	@Override
    	public Identifier toPhysicalSchemaName(Identifier name, JdbcEnvironment context) {
    		return name;
    	}
    
    	@Override
    	public Identifier toPhysicalTableName(Identifier name, JdbcEnvironment context) {
    		return name;
    	}
    
    	@Override
    	public Identifier toPhysicalSequenceName(Identifier name, JdbcEnvironment context) {
    		return name;
    	}
    
    	@Override
    	public Identifier toPhysicalColumnName(Identifier name, JdbcEnvironment context) {
    		return name;
    	}
    }
    

    默认情况下,使用就是这种策略,将ImplicitNamingStrategy传过来的逻辑名直接作为数据库中的物理名称。它的使用设置与ImplicitNamingStrategy相同。

    方法1:

    在Hibernate的配置信息设置的时候,如下:

    Configuration config = new Configuration().configure();
    config.setPhysicalNamingStrategy(new PhysicalNamingStrategyStandardImpl());
    

    方法二

    ServiceRegistry serviceRegistry = new StandardServiceRegistryBuilder().build();
    MetadataSources sources = new MetadataSources(serviceRegistry);
    MetadataBuilder builder = sources.getMetadataBuilder();
    builder.applyPhysicalNamingStrategy(new PhysicalNamingStrategyStandardImpl());
    

    方法三

    SpringBoot整合JPA中在application.yml中配置:
    在这里插入图片描述

    如上图配置所示,默认情况下如果Entity中不使用@Column指定属性对应数据库的列名,那么将会使用属性作为数据库列名。

    实体类User如下:

    @Entity 
    @Table(name = "tb_user") 
    public class User implements Serializable{
    
        @Id //这是一个主键
        @GeneratedValue(strategy = GenerationType.IDENTITY)//自增主键
        private Integer id;
        private String lastName;
        private String email;
        //...
    }
    

    使用方法三数据库生成属性如下:

      `id` int(11) NOT NULL AUTO_INCREMENT,
      `email` varchar(255) DEFAULT NULL,
      `lastName` varchar(255) DEFAULT NULL,
    

    如果我们想要将其转换成last_name,除了使用@Column注解外,还可以自定义PhysicalNamingStrategy实现。

    如下所示:

    public class ImprovedNamingStrategy implements PhysicalNamingStrategy {
    
        @Override
        public Identifier toPhysicalCatalogName(Identifier identifier, JdbcEnvironment jdbcEnv) {
            return convert(identifier);
        }
    
        @Override
        public Identifier toPhysicalColumnName(Identifier identifier, JdbcEnvironment jdbcEnv) {
            return convert(identifier);
        }
    
        @Override
        public Identifier toPhysicalSchemaName(Identifier identifier, JdbcEnvironment jdbcEnv) {
            return convert(identifier);
        }
    
        @Override
        public Identifier toPhysicalSequenceName(Identifier identifier, JdbcEnvironment jdbcEnv) {
            return convert(identifier);
        }
    
        @Override
        public Identifier toPhysicalTableName(Identifier identifier, JdbcEnvironment jdbcEnv) {
            return convert(identifier);
        }
    
        private Identifier convert(Identifier identifier) {
            if (identifier == null || identifier.getText()==null||identifier.getText().equals("")) {
                return identifier;
            }
    
            String regex = "([a-z])([A-Z])";
            String replacement = "$1_$2";
            String newName = identifier.getText().replaceAll(regex, replacement).toLowerCase();
            return Identifier.toIdentifier(newName);
        }
    }
    

    【3】SpringBoot中推荐的Spring 命名策略

    SpringBoot包下主要有两个:SpringImplicitNamingStrategy和 SpringPhysicalNamingStrategy。

    ① SpringImplicitNamingStrategy

    其继承默认的ImplicitNamingStrategyJpaCompliantImpl ,源码如下:

    public class SpringImplicitNamingStrategy extends ImplicitNamingStrategyJpaCompliantImpl {
    
    	@Override
    	public Identifier determineJoinTableName(ImplicitJoinTableNameSource source) {
    		String name = source.getOwningPhysicalTableName() + "_"
    				+ source.getAssociationOwningAttributePath().getProperty();
    		return toIdentifier(name, source.getBuildingContext());
    	}
    
    }
    

    类继承示意图如下:
    在这里插入图片描述


    ② SpringPhysicalNamingStrategy

    源码如下:

    public class SpringPhysicalNamingStrategy implements PhysicalNamingStrategy {
    
    	@Override
    	public Identifier toPhysicalCatalogName(Identifier name,
    			JdbcEnvironment jdbcEnvironment) {
    		return apply(name, jdbcEnvironment);
    	}
    
    	@Override
    	public Identifier toPhysicalSchemaName(Identifier name,
    			JdbcEnvironment jdbcEnvironment) {
    		return apply(name, jdbcEnvironment);
    	}
    
    	@Override
    	public Identifier toPhysicalTableName(Identifier name,
    			JdbcEnvironment jdbcEnvironment) {
    		return apply(name, jdbcEnvironment);
    	}
    
    	@Override
    	public Identifier toPhysicalSequenceName(Identifier name,
    			JdbcEnvironment jdbcEnvironment) {
    		return apply(name, jdbcEnvironment);
    	}
    
    	@Override
    	public Identifier toPhysicalColumnName(Identifier name,
    			JdbcEnvironment jdbcEnvironment) {
    		return apply(name, jdbcEnvironment);
    	}
    
    	private Identifier apply(Identifier name, JdbcEnvironment jdbcEnvironment) {
    		if (name == null) {
    			return null;
    		}
    		StringBuilder builder = new StringBuilder(name.getText().replace('.', '_'));
    		for (int i = 1; i < builder.length() - 1; i++) {
    			if (isUnderscoreRequired(builder.charAt(i - 1), builder.charAt(i),
    					builder.charAt(i + 1))) {
    				builder.insert(i++, '_');
    			}
    		}
    		return getIdentifier(builder.toString(), name.isQuoted(), jdbcEnvironment);
    	}
    
    	/**
    	 * Get an identifier for the specified details. By default this method will return an
    	 * identifier with the name adapted based on the result of
    	 * {@link #isCaseInsensitive(JdbcEnvironment)}
    	 * @param name the name of the identifier
    	 * @param quoted if the identifier is quoted
    	 * @param jdbcEnvironment the JDBC environment
    	 * @return an identifier instance
    	 */
    	protected Identifier getIdentifier(String name, boolean quoted,
    			JdbcEnvironment jdbcEnvironment) {
    		if (isCaseInsensitive(jdbcEnvironment)) {
    			name = name.toLowerCase(Locale.ROOT);
    		}
    		return new Identifier(name, quoted);
    	}
    
    	/**
    	 * Specify whether the database is case sensitive.
    	 * @param jdbcEnvironment the JDBC environment which can be used to determine case
    	 * @return true if the database is case insensitive sensitivity
    	 */
    	protected boolean isCaseInsensitive(JdbcEnvironment jdbcEnvironment) {
    		return true;
    	}
    
    	private boolean isUnderscoreRequired(char before, char current, char after) {
    		return Character.isLowerCase(before) && Character.isUpperCase(current)
    				&& Character.isLowerCase(after);
    	}
    
    }
    

    进行了大小写处理和"_"符号处理。

    故而,我们也可以在SpringBoot环境下直接使用这两个命名策略。

    application.yml配置文件如下:

    spring: 
    	jpa:
    	      database: mysql
    	      hibernate:
    	        ddl-auto: update
    	        naming:
    	          implicit-strategy: org.springframework.boot.orm.jpa.hibernate.SpringImplicitNamingStrategy
    	          physical-strategy: org.springframework.boot.orm.jpa.hibernate.SpringPhysicalNamingStrategy
    	      show-sql: true
    

    此时再次创建数据表,lastName属性将会自动转换成数据表中last_name列:

    `id` int(11) NOT NULL AUTO_INCREMENT,
     `email` varchar(255) DEFAULT NULL,
     `last_name` varchar(255) DEFAULT NULL,
    

    参考hibernate官方文档:Hibernate官方用户指南

    展开全文
  • 上篇文章中我们介绍了常见的Jackson注解,本篇文章对其进行扩展,重点介绍指定...@JsonNaming:作用于类或属性上,用于指定命名策略。Jackson默认自带了多种策略。该注解可对照@JsonProperty的功能。 比如,根据...
  • 这种命名策略有助于在您的域类和protobuf类之间生成有效的映射代码。 无论和类支载。 注意:取决于mapstruct 1.4.0.CR1 ProtobufAccessor命名策略 扩展DefaultProtobufAccessorNamingStrategy并提供必要的信息以...
  • 品牌命名策略课件.pptx
  • 64. JPA命名策略

    万次阅读 2016-09-17 23:24:28
    【从零开始学习Spirng Boot—常见异常汇总】 在(39.2). Spring Boot Shiro权限管理【从零开始学Spring Boot】  ...这个问题主要是JPA的命名策略不一致导致的。 我们有这么一个配置: spring.jpa.hiber
  • 有时候在实体类映射成...有的则在`@Column`注解中使用`name`属性定义自己的名称,但是有时候比如说设计一个数据库有统一前缀或者后缀,上面两种方式就不适用了,而需要统一的设计命名策略,本篇文章对这部分进行总结!
  • spring boot 中Spring data jpa命名策略

    千次阅读 2018-04-16 12:40:00
    spring boot 中Spring data jpa命名策略 数据库,表字段命名是驼峰命名法(UserID),Spring data jpa 自动更新之后是 user_id, 表字段不对照, Spring data jpa基于Hibernate5.0 application.properties 写法 1、...
  • 单个类的命名策略设置 单个类设置在需要的实体上添加@JsonNaming(PropertyNamingStrategy.SnakeCaseStrategy.class)注解 整个项目命名策略的设置 通过properties设置 (yml格式) spring:  jackso...
  • spring-data-jpa 下自定义命名策略

    千次阅读 2017-10-09 17:25:37
    spring-data-jpa自动命名策略
  • 借助“定位理论”的视角,从服装品牌名称的传播力、品牌名称体现的价值需求及延伸品牌的命名三方面来对服装品牌命名进行了探讨,希望能够为需要创立自有品牌的众多国内服装企业塑造品牌形象、增强竞争力提供有益的帮助...
  • 命名策略采用naming-strategy配置项 spring.jpa.hibernate.naming-strategy = org.hibernate.cfg.DefaultNamingStrategy 1、配置值org.hibernate.cfg.DefaultNamingStrategy hibernate默认配置,采用直接映射的...
  • spring boot 中Spring data jpa命名策略 数据库,表字段命名是驼峰命名法(UserID),Spring data jpa 自动更新之后是 user_id, 表字段不对照, Spring data jpa基于Hibernate5.0 application.properties 写法 1...
  • =hibernate 4命名策略如下= spring.jpa.hibernate.naming-strategy = org.hibernate.cfg.DefaultNamingStrategy 有两种值可以配置分别为: 第一:org.hibernate.cfg.DefaultNamingStrategy 第二:org.hibernate....
  • Spring boot 自定义数据库命名策略

    千次阅读 2018-05-12 11:45:14
    1. Spring boot 默认是有数据库命名策略的,比如实体是AdminUser, 那么映射到数据库的时候是:admin_user。那么如果这样已经符合需求,那就什么都不需要操作。但是一般情况下,我们的数据库表都喜欢加上一些前缀,...
  • hibernate 命名策略

    千次阅读 2013-08-22 16:35:07
    在Java对象里面, 偶们知道一个良好的命名规范会采用大写单词的首字母, 比如订单项这个对象, 偶们会起名为OrderItem, 这样很容易就看出来这个对象是由Order和Item 2个单词组成的, 断词就很容易了, 而属性也是如此, ...
  • JPA命名策略

    2016-11-03 16:46:33
    有人碰到这样一个问题“导入的...这个问题主要是JPA的命名策略不一致导致的。 我们有这么一个配置: spring.jpa.hibernate.naming-strategy = org.hibernate.cfg.DefaultNamingStrategy 这里的值有两
  • Jackson修改字段名和自定义命名策略

    千次阅读 2020-10-03 22:23:46
    使用预定义的命名策略PropertyNamingStrategy,设置全局或单个类的命名策略; 扩展PropertyNamingStrategy,实现自定义命名策略,读和写支持使用不同的命名策略。 本篇内容基于Jackson 2.11.2版本.
  • SpringBoot hibernate中配置hibernate命名策略不起作用(spring.jpa.hibernate.naming.strategy=org.hibernate.cfg.ImprovedNamingStrategy) 首先,出现这种情况的时候看一下IDE工具代码提示是否出现该配置过时错误...
  • 被选择的管理员是可以凌驾于这些策略的,横跨所有组的工作负荷和端点,因此这些管理员可以使用屏蔽词去创建组。下面是不被策略限制的管理员角色列表: Global admin Partner Tier 1 Support Partner Tier 2 ...
  • 我们可以使用组命名策略来为组织中用户创建的Office 365组执行强制命名一致性策略。命名策略可以帮助我们和用户们识别组的功能,成员隶属关系,地理区域或是创建者等。命名策略还有助于在地址簿中对组进行分类。我们...
  • 对于 spring.jpa.hibernate.naming-strategy = org.hibernate.cfg....hibernate命名策略设置之后不起作用的处理方式:http://www.cnblogs.com/sxdcgaq8080/p/7890218.html,查看1.JPA hibernat...
  • 这将导致它的JSON结果看起来很滑稽,但是,这很容易使我们发现多钟命名策略是如何影响它们的。你可以在 GsonBuilder 中添加策略: GsonBuilder gsonBuilder = new GsonBuilder(); gsonBuilder....
  • hibernate 表命名策略

    千次阅读 2013-06-14 10:14:49
    对于Java开发人员,Hibernate 3 ...然而回到现实世界,你还需要考虑到,有时数据库管理员所使用的模糊的命名惯例。本文中,“Java Power Tools”的作者John Ferguson Smart将告诉你如何通过Hibernate自动生成数据库架
  • 2. 通过命名策略来实现自动映射 属性较多时,通过注解显式声明比较麻烦,最好能自动映射,在spring-data整合的Hibernate实现中,Spring提供了默认从驼峰到蛇形命名的映射,但Quarkus和Hibernate本身并没有提供这种...
  • #spring data jpa默认命名策略是遇到大写字母加“_”命名spring.jpa.hibernate.naming.physical-strategy=org.springframework.boot.orm.jpa.hibernate.SpringPhysicalNamingStrategy如果数据库设计是以帕斯卡命名法...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 200,277
精华内容 80,110
关键字:

命名策略