Spring Boot + JPA: annotazione del nome della colonna ignorata

Ho un'applicazione Spring Boot con dipendenza spring-boot-starter-data-jpa. La mia classe di entità ha un'annotazione di colonna con un nome di colonna. Per esempio:

@Column(name="TestName")
private String testName;

SQL generato da questo creato test_namecome nome delle colonne. Dopo aver cercato una soluzione, ho scoperto che ha spring.jpa.hibernate.naming_strategy=org.hibernate.cfg.EJB3NamingStrategyrisolto il problema (il nome della colonna è preso dall'annotazione della colonna).

Tuttavia, la mia domanda è perché senza naming_strategy impostato su EJB3NamingStrategyJPA si ignora l'annotazione di colonna? Forse il dialetto ibernato ha qualcosa a che fare con questo? Mi sto collegando a MS SQL 2014 Express e i miei log contengono:

Unknown Microsoft SQL Server major version [12] using SQL Server 2000 dialect
Using dialect: org.hibernate.dialect.SQLServerDialect 

Per hibernate5 ho risolto questo problema inserendo le righe successive nel mio file application.properties:

spring.jpa.hibernate.naming.implicit-strategy=org.hibernate.boot.model.naming.ImplicitNamingStrategyLegacyJpaImpl
spring.jpa.hibernate.naming.physical-strategy=org.hibernate.boot.model.naming.PhysicalNamingStrategyStandardImpl

Per impostazione predefinita, Spring utilizza org.springframework.boot.orm.jpa.SpringNamingStrategyper generare i nomi delle tabelle. Questa è un'estensione molto sottile di org.hibernate.cfg.ImprovedNamingStrategy. Al tableNamemetodo in quella classe viene passato un Stringvalore sorgente ma non è a conoscenza se proviene da un @Column.nameattributo o se è stato implicitamente generato dal nome del campo.

Il ImprovedNamingStrategyconvertirà CamelCasea SNAKE_CASEdove, come la EJB3NamingStrategyutilizza solo il nome della tabella invariata.

Se non desideri modificare la strategia di denominazione, puoi sempre specificare il nome della colonna in minuscolo:

@Column(name="testname")

Sembra che

@Column (name = "..")

è completamente ignorato a meno che non ci sia

spring.jpa.hibernate.naming_strategy = org.hibernate.cfg.EJB3NamingStrategy

specificato, quindi per me questo è un bug.

Ho trascorso alcune ore cercando di capire perché @Column (name = "..") è stato ignorato.

La strategia predefinita per @Column(name="TestName")sarà test_name, questo è il comportamento corretto!

Se hai una colonna denominata TestNamenel tuo database, dovresti cambiare l'annotazione della colonna in @Column(name="testname").

Funziona perché al database non interessa se assegni il nome alla colonna TestName o testname (i nomi delle colonne non fanno distinzione tra maiuscole e minuscole !! ).

Ma attenzione, lo stesso non vale per il nome del database e per i nomi delle tabelle, che fanno distinzione tra maiuscole e minuscole su sistemi Unix ma maiuscole e minuscole su sistemi Windows (il fatto che probabilmente teneva sveglie molte persone di notte, lavorando su Windows ma distribuendo su Linux :))

L'unica soluzione che ha funzionato per me è stata quella pubblicata da teteArg sopra. Sono su Spring Boot 1.4.2 con Hibernate 5. Vale a dire

spring.jpa.hibernate.naming.implicit-strategy=org.hibernate.boot.model.naming.ImplicitNamingStrategyLegacyJpaImpl
spring.jpa.hibernate.naming.physical-strategy=org.hibernate.boot.model.naming.PhysicalNamingStrategyStandardImpl

Per ulteriori informazioni, sto postando la traccia delle chiamate in modo che sia chiaro ciò che le chiamate Spring stanno facendo in Hibernate per impostare la strategia di denominazione.

      at org.hibernate.boot.model.naming.PhysicalNamingStrategyStandardImpl.toPhysicalColumnName(PhysicalNamingStrategyStandardImpl.java:46)
  at org.hibernate.cfg.Ejb3Column.redefineColumnName(Ejb3Column.java:309)
  at org.hibernate.cfg.Ejb3Column.initMappingColumn(Ejb3Column.java:234)
  at org.hibernate.cfg.Ejb3Column.bind(Ejb3Column.java:206)
  at org.hibernate.cfg.Ejb3DiscriminatorColumn.buildDiscriminatorColumn(Ejb3DiscriminatorColumn.java:82)
  at org.hibernate.cfg.AnnotationBinder.processSingleTableDiscriminatorProperties(AnnotationBinder.java:797)
  at org.hibernate.cfg.AnnotationBinder.bindClass(AnnotationBinder.java:561)
  at org.hibernate.boot.model.source.internal.annotations.AnnotationMetadataSourceProcessorImpl.processEntityHierarchies(AnnotationMetadataSourceProcessorImpl.java:245)
  at org.hibernate.boot.model.process.spi.MetadataBuildingProcess$1.processEntityHierarchies(MetadataBuildingProcess.java:222)
  at org.hibernate.boot.model.process.spi.MetadataBuildingProcess.complete(MetadataBuildingProcess.java:265)
  at org.hibernate.jpa.boot.internal.EntityManagerFactoryBuilderImpl.metadata(EntityManagerFactoryBuilderImpl.java:847)
  at org.hibernate.jpa.boot.internal.EntityManagerFactoryBuilderImpl.build(EntityManagerFactoryBuilderImpl.java:874)
  at org.springframework.orm.jpa.vendor.SpringHibernateJpaPersistenceProvider.createContainerEntityManagerFactory(SpringHibernateJpaPersistenceProvider.java:60)
  at org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean.createNativeEntityManagerFactory(LocalContainerEntityManagerFactoryBean.java:353)
  at org.springframework.orm.jpa.AbstractEntityManagerFactoryBean.buildNativeEntityManagerFactory(AbstractEntityManagerFactoryBean.java:373)
  at org.springframework.orm.jpa.AbstractEntityManagerFactoryBean.afterPropertiesSet(AbstractEntityManagerFactoryBean.java:362)
  at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.invokeInitMethods(AbstractAutowireCapableBeanFactory.java:1642)
  at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.initializeBean(AbstractAutowireCapableBeanFactory.java:1579)
  at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.doCreateBean(AbstractAutowireCapableBeanFactory.java:553)
  at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.createBean(AbstractAutowireCapableBeanFactory.java:482)
  at org.springframework.beans.factory.support.AbstractBeanFactory$1.getObject(AbstractBeanFactory.java:306)
  at org.springframework.beans.factory.support.DefaultSingletonBeanRegistry.getSingleton(DefaultSingletonBeanRegistry.java:230)
  - locked <0x1687> (a java.util.concurrent.ConcurrentHashMap)
  at org.springframework.beans.factory.support.AbstractBeanFactory.doGetBean(AbstractBeanFactory.java:302)
  at org.springframework.beans.factory.support.AbstractBeanFactory.getBean(AbstractBeanFactory.java:197)
  at org.springframework.context.support.AbstractApplicationContext.getBean(AbstractApplicationContext.java:1081)
  at org.springframework.context.support.AbstractApplicationContext.finishBeanFactoryInitialization(AbstractApplicationContext.java:856)
  at org.springframework.context.support.AbstractApplicationContext.refresh(AbstractApplicationContext.java:542)
  - locked <0x1688> (a java.lang.Object)
  at org.springframework.boot.SpringApplication.refresh(SpringApplication.java:761)
  at org.springframework.boot.SpringApplication.refreshContext(SpringApplication.java:371)
  at org.springframework.boot.SpringApplication.run(SpringApplication.java:315)
  at org.springframework.boot.SpringApplication.run(SpringApplication.java:1186)
  at org.springframework.boot.SpringApplication.run(SpringApplication.java:1175)

teteArg , grazie mille. Solo un'informazione aggiuntiva così, tutti coloro che si imbattono in questa domanda saranno in grado di capire perché.

Ciò che ha detto teteArg è indicato nelle proprietà comuni di Spring Boot: http://docs.spring.io/spring-boot/docs/current/reference/html/common-application-properties.html

Apparentemente, spring.jpa.hibernate.naming.strategy non è una proprietà supportata per l'implementazione di Spring JPA utilizzando Hibernate 5.

Si scopre che devo solo convertire il @columnnome testName in tutte le lettere minuscole, poiché inizialmente era in caso di cammello.

Sebbene non fossi in grado di utilizzare la risposta ufficiale, la domanda è stata in grado di aiutarmi a risolvere il mio problema facendomi sapere su cosa indagare.

Modificare:

@Column(name="testName")
private String testName;

Per:

@Column(name="testname")
private String testName;

Se vuoi usare @Column (...), usa sempre lettere minuscole anche se la tua colonna DB attuale è in camel-case.

Esempio: se il nome effettivo della colonna DB è TestNamequindi utilizzare:

  @Column(name="testname") //all small-case

Se non ti piace, cambia semplicemente il nome effettivo della colonna DB in: test_name

Nel mio caso, l'annotazione era sul metodo getter () invece del campo stesso (portato da un'applicazione legacy).

Anche in questo caso Spring ignora l'annotazione ma non si lamenta. La soluzione era spostarlo sul campo invece che sul getter.