Problem z nazewnictwem pól hibernacji z Spring Boot (strategia nazewnictwa)

Question

Należy zauważyć, że ten kod działa z prostą sprężyną, ale nie z Spring Boot (v1.3.3), czy jest coś, czego mi brakuje, ponieważ jest importowany z aplikacji źródłowej, która Prace. Poniższy kod jest z aplikacji bagażnika sprężyna

@Entity 
@Table(name="project") 
public class Project implements Serializable{ 

    private static final long serialVersionUID = 1L; 

    @Id 
    @GeneratedValue(strategy=GenerationType.AUTO) 
    @Column(name="id") 
    private int id; 

    @Column(name="teamId") 
    private int teamId; 

    //private String Rentabiliteit; 

    @Column 
    //@Index(name="IProject_status",columnNames="Status") 
    private String status; 

    @Column 
    //@Index(name="IProject_naam",columnNames="Naam") 
    private String naam; 
    //public Prototype m_Prototype; 
    //public Team m_Team; 

} 

SQL

CREATE TABLE IF NOT EXISTS `project` (
`id` int(11) NOT NULL, 
`teamId` int(11) DEFAULT NULL, 
`status` varchar(255) DEFAULT NULL, 
`naam` varchar(255) DEFAULT NULL 
) ENGINE=InnoDB AUTO_INCREMENT=43 DEFAULT CHARSET=latin1; 

ERROR

Caused by: com.mysql.jdbc.exceptions.jdbc4.MySQLSyntaxErrorException:   
Unknown column 'project0_.team_id' in 'field list' 

Zmieniano: Application.yml

spring: 

mvc: 
    view: 
    prefix: /WEB-INF/jsp/ 
    suffix: .jsp 

datasource: 
    url: jdbc:mysql://localhost:3306/oxyplast 
    username: oxyplastuser 
    password: oxyplastuserpw 

jpa: 
    properties: 
    hibernate: 
     current_session_context_class: org.springframework.orm.hibernate4.SpringSessionContext 
     namingStrategy: org.hibernate.cfg.DefaultNamingStrategy 

Answer 1

Wiosna Boot zapewnia ImprovedNamingStrategy jako de strategia nazewnictwa błędów, która wyszukuje Hibernate dla kolumny team_id (wywnioskowanej z pola int teamId). Ponieważ ta kolumna nie istnieje w Twojej tabeli, jest to przyczyną błędu. Od docs Hibernacja:

Ulepszony nazewnictwa strategii, która preferuje osadzonych podkreślenia mieszane nazw przypadków

masz dwie opcje:

1. podać nazwę kolumny wyraźnie jako @Column(name="teamId"). Kiedyś nie było już wersji bug we wczesnych wersjach Boot.

2. zmiany strategii nazewnictwa we właściwościach Boot wiosną i poinformować go używać EJB3NamingStrategy, która nie konwertuje CamelCase do snake_case, ale trzyma go jak to jest.

---

Aktualizacja

Począwszy od 1.4, ze względu na przełączniku do hibernacji 5, strategia nazewnictwa został zaktualizowany do SpringPhysicalNamingStrategy który should be very close 1,3 domyślnych.

Zobacz także:

• Spring's naming strategy

Answer 2

jeśli chcesz korzystać z wielkich liter w nazwie kolumny trzeba użyć go w ten sposób

@Column(name="\"teamId\"") 

private int teamId; 

trzeba wymusić hibernuj nawet przy użyciu EJB3NamingStrategy lub ImprovedStrategyNaming.

Answer 3

Poniżej strategii pracował dla mnie

spring.jpa.hibernate.naming-strategy = org.hibernate.cfg.DefaultComponentSafeNamingStrategy 

Answer 4

z późnej wersji:

spring-boot-starter-data-jpa: ➡ 1.5.2.RELEASE 
    hibernate-core:5.0.12.Final 

ta klasa

PhysicalNamingStrategyStandardImpl 

należy rozszerzyć i dodać do hibernacji właściwości.

Oto pełna wersja robocza

public class PhysicalNamingStrategyImpl extends PhysicalNamingStrategyStandardImpl implements Serializable { 

    public static final PhysicalNamingStrategyImpl INSTANCE = new PhysicalNamingStrategyImpl(); 

    @Override 
    public Identifier toPhysicalTableName(Identifier name, JdbcEnvironment context) { 
     String nameModified; 
     // Do whatever you want with the name modification 
     return new Identifier(nameModified, name.isQuoted()); 
    } 

} 

    @Override 
    public Identifier toPhysicalColumnName(Identifier name, JdbcEnvironment context) { 
     String nameModified; 
     // Do whatever you want with the name modification 
     return new Identifier(nameModified, name.isQuoted()); 
    } 

powiązanie go z hibernacji należy zrobić tak podczas konfigurowania źródła danych.

properties.put("hibernate.physical_naming_strategy", "my.Package.PhysicalNamingStrategyImpl"); 

tutaj jest pełna wersja robocza źródła danych config

import org.springframework.beans.factory.annotation.Qualifier; 
import org.springframework.beans.factory.annotation.Value; 
import org.springframework.boot.autoconfigure.jdbc.DataSourceBuilder; 
import org.springframework.boot.context.properties.ConfigurationProperties; 
import org.springframework.boot.orm.jpa.EntityManagerFactoryBuilder; 
import org.springframework.context.annotation.Bean; 
import org.springframework.context.annotation.Configuration; 
import org.springframework.context.annotation.Primary; 
import org.springframework.data.jpa.repository.config.EnableJpaRepositories; 
import org.springframework.orm.jpa.JpaTransactionManager; 
import org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean; 
import org.springframework.transaction.PlatformTransactionManager; 
import org.springframework.transaction.annotation.EnableTransactionManagement; 

import javax.persistence.EntityManagerFactory; 
import javax.sql.DataSource; 
import java.util.HashMap; 
import java.util.Map; 


@Configuration 
@EnableTransactionManagement 
@EnableJpaRepositories(
     entityManagerFactoryRef = "entityManagerFactory", 
     basePackages = { "com.xxxxxx.repository" } 
) 
public class SharedDataSourceConfig { 

    @Value("${startup.ddl-auto}") 
    String hbm2ddl; 

    @Primary 
    @Bean(name = "dataSource") 
    @ConfigurationProperties("spring.datasource.shared") 
    public DataSource customerDataSource() { 
     return DataSourceBuilder.create().build(); 
    } 

    @Primary 
    @Bean(name = "entityManagerFactory") 
    public LocalContainerEntityManagerFactoryBean entityManagerFactory(
      EntityManagerFactoryBuilder builder, 
      @Qualifier("dataSource") DataSource dataSource) { 
     Map<String, Object> properties = new HashMap<String, Object>(); 
     properties.put("hibernate.hbm2ddl.auto", hbm2ddl); 
     properties.put("hibernate.physical_naming_strategy", "my.package.PhysicalNamingStrategyImpl"); 
     return builder 
       .dataSource(dataSource) 
       .packages(PackageScannerHelper.getPackagesToScan()) 
       .persistenceUnit("shared") 
       .properties(properties) 
       .build(); 
    } 

    @Primary 
    @Bean(name = "transactionManager") 
    public PlatformTransactionManager transactionManager(
      @Qualifier("entityManagerFactory") EntityManagerFactory 
        entityManagerFactory 
    ) { 
     return new JpaTransactionManager(entityManagerFactory); 
    } 
}