java - hibernate naming strategy

La estrategia de nombres mejorada ya no funciona en Hibernate 5

Question

Tengo una configuración simple de spring-jpa donde configuré ImprovedNamingStrategy de Hibernate. Esto significa que si mi clase de entidad tiene una variable userName , Hibernate debería convertirla en user_name para consultar la base de datos. Pero esta conversión de nombres dejó de funcionar después de actualizar a Hibernate 5. Recibo el error:

ERROR: columna desconocida ''user0_.userName'' en ''lista de campos''

Esta es mi configuración de Hibernate:

@Configuration
@EnableJpaRepositories("com.springJpa.repository")
@EnableTransactionManagement
public class DataConfig {

    @Bean
    public DataSource dataSource(){
        DriverManagerDataSource ds = new DriverManagerDataSource();
        ds.setDriverClassName("com.mysql.jdbc.Driver");
        ds.setUrl("jdbc:mysql://localhost:3306/test");
        ds.setUsername("root");
        ds.setPassword("admin");
        return ds;
    }


    @Bean
    public LocalContainerEntityManagerFactoryBean entityManagerFactory(){ 

        HibernateJpaVendorAdapter vendorAdapter = new HibernateJpaVendorAdapter();
        vendorAdapter.setShowSql(Boolean.TRUE);
        vendorAdapter.setDatabase(Database.MYSQL);

        LocalContainerEntityManagerFactoryBean factory = new LocalContainerEntityManagerFactoryBean();
        factory.setJpaVendorAdapter(vendorAdapter);
        factory.setDataSource(dataSource());
        factory.setPackagesToScan("com.springJpa.entity");


        Properties jpaProperties = new Properties();

        jpaProperties.put("hibernate.ejb.naming_strategy","org.hibernate.cfg.ImprovedNamingStrategy");
        jpaProperties.put("hibernate.dialect","org.hibernate.dialect.MySQL5InnoDBDialect");

        factory.setJpaProperties(jpaProperties);
        factory.afterPropertiesSet();
        return factory;
    }

    @Bean
    public SharedEntityManagerBean entityManager() {
        SharedEntityManagerBean entityManager = new SharedEntityManagerBean();
        entityManager.setEntityManagerFactory(entityManagerFactory().getObject());
        return entityManager;
    }



    @Bean
    public PlatformTransactionManager transactionManager() {
        JpaTransactionManager txManager = new JpaTransactionManager();
        txManager.setEntityManagerFactory(entityManagerFactory().getObject());
        return txManager;
    }

    @Bean
    public ImprovedNamingStrategy namingStrategy(){
        return new ImprovedNamingStrategy();
    }
}

Esta es mi clase de entidad:

@Getter
@Setter
@Entity
@Table(name="user")
public class User{

    @Id
    @GeneratedValue
    private Long id;

    private String userName;
    private String email;
    private String password;
    private String role;

}

No quiero nombrar explícitamente los campos de mi base de datos dentro de las anotaciones @Column. Quiero mi configuración que implícitamente puede convertir el caso de camello en subrayado.

Por favor guía.

Answer 1

Acabo de resolver el problema, la configuración es absolutamente buena cuando se usa una versión de Hibernate <5.0 pero no para Hibernate> = 5.0.

Estaba usando Hibernate 5.0.0.Final con Spring 4.2.0.RELEASE. Supongo que el Hibernate 5 no es totalmente compatible con Spring 4.2. Acabo de bajar Hibernate a 4.2.1. Final y las cosas comenzaron a funcionar bien.

La clase NamingStrategy de Hibernate está en desuso en Hibernate 5.

Answer 2

Cada respuesta publica una solución implementando PhysicalNamingStrategy , pero todo lo que necesita (y debe hacer) es implementar ImplicitNamingStrategy .

Cuando una entidad no nombra explícitamente la tabla de la base de datos a la que se asigna, necesitamos determinar implícitamente ese nombre de tabla. O cuando un atributo particular no nombra explícitamente la columna de la base de datos a la que se asigna, necesitamos determinar implícitamente ese nombre de columna. Hay ejemplos del rol del contrato org.hibernate.boot.model.naming.ImplicitNamingStrategy para determinar un nombre lógico cuando la asignación no proporcionó un nombre explícito.

Y el código puede ser tan fácil como esto (usando los addUnderscores originales como en otras respuestas):

public class ImplicitNamingStrategyImpl extends ImplicitNamingStrategyJpaCompliantImpl {

    @Override
    protected Identifier toIdentifier(String stringForm, MetadataBuildingContext buildingContext) {
        return super.toIdentifier(addUnderscores(stringForm), buildingContext);
    }

    protected static String addUnderscores(String name) {
        final StringBuilder buf = new StringBuilder(name.replace(''.'', ''_''));
        for (int i = 1; i < buf.length() - 1; i++) {
            if (Character.isLowerCase(buf.charAt(i - 1))
                    && Character.isUpperCase(buf.charAt(i))
                    && Character.isLowerCase(buf.charAt(i + 1))) {
                buf.insert(i++, ''_'');
            }
        }
        return buf.toString().toLowerCase(Locale.ROOT);
    }
}

Answer 3

Gracias por publicar su propia solución. ¡Me ayuda mucho establecer la estrategia de nombres de Hibernate 5!

La propiedad hibernate.ejb.naming_strategy de pre-Hibernate 5.0 parece dividida en dos partes:

• hibernate.physical_naming_strategy
• hibernate.implicit_naming_strategy

Los valores de estas propiedades no implementan la interfaz NamingStrategy como hibernate.ejb.naming_strategy . Hay dos nuevas interfaces para estos fines:

• org.hibernate.boot.model.naming.PhysicalNamingStrategy
• org.hibernate.boot.model.naming.ImplicitNamingStrategy

Hibernate 5 proporciona solo una implementación de PhysicalNamingStrategy ( PhysicalNamingStrategyStandardImpl ) que supone que los nombres de los identificadores físicos son los mismos que los lógicos.

Hay varias implementaciones de ImplicitNamingStrategy pero no encontré ninguna equivalente a la antigua ImprovedNamingStrategy . (Ver: org.hibernate.boot.model.naming.ImplicitNamingStrategyLegacyHbmImpl )

Entonces, implementé mi propia PhysicalNamingStrategy que es muy simple:

public class PhysicalNamingStrategyImpl extends PhysicalNamingStrategyStandardImpl implements Serializable {

 public static final PhysicalNamingStrategyImpl INSTANCE = new PhysicalNamingStrategyImpl();

 @Override
 public Identifier toPhysicalTableName(Identifier name, JdbcEnvironment context) {
     return new Identifier(addUnderscores(name.getText()), name.isQuoted());
 }

 @Override
 public Identifier toPhysicalColumnName(Identifier name, JdbcEnvironment context) {
     return new Identifier(addUnderscores(name.getText()), name.isQuoted());
 }


 protected static String addUnderscores(String name) {
     final StringBuilder buf = new StringBuilder( name.replace(''.'', ''_'') );
     for (int i=1; i<buf.length()-1; i++) {
        if (
             Character.isLowerCase( buf.charAt(i-1) ) &&
             Character.isUpperCase( buf.charAt(i) ) &&
             Character.isLowerCase( buf.charAt(i+1) )
         ) {
             buf.insert(i++, ''_'');
         }
     }
     return buf.toString().toLowerCase(Locale.ROOT);
 }
}

Tenga en cuenta que el método addUnderscores() es del org.hibernate.cfg.ImprovedNamingStrategy original.

Luego, configuro esta estrategia física en el archivo persistence.xml:

  <property name="hibernate.physical_naming_strategy" value="my.package.PhysicalNamingStrategyImpl" />

Es una trampa establecer la estrategia de nombres de Hibernate 5 como configuración de la versión anterior.

Answer 4

Sin utilidades de guayaba y apache

public class PhysicalNamingStrategyImpl extends PhysicalNamingStrategyStandardImpl {

    public Identifier toPhysicalTableName(Identifier name, JdbcEnvironment context) {
        return context.getIdentifierHelper().toIdentifier(
                name.getText().replaceAll("((?!^)[^_])([A-Z])", "$1_$2").toLowerCase(),
                name.isQuoted()
        );
    }

    public Identifier toPhysicalColumnName(Identifier name, JdbcEnvironment context) {
        return context.getIdentifierHelper().toIdentifier(
                name.getText().replaceAll("((?!^)[^_])([A-Z])", "$1_$2").toLowerCase(),
                name.isQuoted()
        );
    }
}

Answer 5

espero que esto ayude:

hibernate.implicit_naming_strategy = .... ImplicitNamingStrategy hibernate.physical_naming_strategy = .... PhysicalNamingStrategyImpl

y aquí está el código (solo reordenado del código existente):

import java.io.Serializable;
import java.util.Locale;
import org.hibernate.boot.model.naming.Identifier;
import org.hibernate.boot.model.naming.PhysicalNamingStrategyStandardImpl;
import org.hibernate.engine.jdbc.env.spi.JdbcEnvironment;

public class PhysicalNamingStrategyImpl extends PhysicalNamingStrategyStandardImpl implements Serializable {

    public static final PhysicalNamingStrategyImpl INSTANCE = new PhysicalNamingStrategyImpl();

    @Override
    public Identifier toPhysicalTableName(Identifier name, JdbcEnvironment context) {
        return new Identifier(addUnderscores(name.getText()), name.isQuoted());
    }

    @Override
    public Identifier toPhysicalColumnName(Identifier name, JdbcEnvironment context) {
        return new Identifier(addUnderscores(name.getText()), name.isQuoted());
    }

    protected static String addUnderscores(String name) {
        final StringBuilder buf = new StringBuilder( name.replace(''.'', ''_'') );
        for (int i=1; i<buf.length()-1; i++) {
            if (
                Character.isLowerCase( buf.charAt(i-1) ) &&
                Character.isUpperCase( buf.charAt(i) ) &&
                Character.isLowerCase( buf.charAt(i+1) )
            ) {
                buf.insert(i++, ''_'');
            }
        }
        return buf.toString().toLowerCase(Locale.ROOT);
    }

}

Answer 6

gracias por ese post Poco molesto que la actualización rompe la tabla y la estrategia de nombre de columna. En lugar de copiar la lógica de ImprovedNamingStrategy , también podría usar la delegación.

public class TableNamingStrategy extends PhysicalNamingStrategyStandardImpl {
    private static final String TABLE_PREFIX = "APP_";
    private static final long serialVersionUID = 1L;
    private static final ImprovedNamingStrategy STRATEGY_INSTANCE = new ImprovedNamingStrategy();

    @Override
    public Identifier toPhysicalTableName(Identifier name, JdbcEnvironment context) {
        return new Identifier(classToTableName(name.getText()), name.isQuoted());
    }

    @Override
    public Identifier toPhysicalColumnName(Identifier name, JdbcEnvironment context) {
        return new Identifier(STRATEGY_INSTANCE.classToTableName(name.getText()), name.isQuoted());
    }

    private String classToTableName(String className) {
        return STRATEGY_INSTANCE.classToTableName(TABLE_PREFIX + className);
    }
}

Answer 7

Gracias y +1 a Samuel Andrés por la útil respuesta , sin embargo, probablemente sea una buena idea evitar la lógica de la carcasa de la serpiente escrita a mano. Aquí está la misma solución, usando guayaba.

Asume que los nombres de sus entidades están escritos en StandardJavaClassFormat y los nombres de columna en standardJavaFieldFormat

Espero que esto ahorre a algunas personas que vienen aquí en el futuro a buscar en Google :-)

import org.hibernate.boot.model.naming.Identifier;
import org.hibernate.boot.model.naming.PhysicalNamingStrategyStandardImpl;
import org.hibernate.engine.jdbc.env.spi.JdbcEnvironment;
import static com.google.common.base.CaseFormat.*;

public class SnakeCaseNamingStrategy extends PhysicalNamingStrategyStandardImpl {

  public Identifier toPhysicalTableName(Identifier name, JdbcEnvironment context) {
    return new Identifier(
      UPPER_CAMEL.to(LOWER_UNDERSCORE, name.getText()),
      name.isQuoted()
    );
  }

  public Identifier toPhysicalColumnName(Identifier name, JdbcEnvironment context) {
    return new Identifier(
      LOWER_CAMEL.to(LOWER_UNDERSCORE, name.getText()),
      name.isQuoted()
    );
  }
}