org.hibernate.HibernateException: l'accesso a DialectResolutionInfo non può essere nullo quando 'hibernate.dialect' non è impostato

Sto provando a eseguire un'applicazione di avvio a molla che utilizza l'ibernazione tramite spring-jpa, ma sto ottenendo questo errore:

Caused by: org.hibernate.HibernateException: Access to DialectResolutionInfo cannot be null when 'hibernate.dialect' not set
        at org.hibernate.engine.jdbc.dialect.internal.DialectFactoryImpl.determineDialect(DialectFactoryImpl.java:104)
        at org.hibernate.engine.jdbc.dialect.internal.DialectFactoryImpl.buildDialect(DialectFactoryImpl.java:71)
        at org.hibernate.engine.jdbc.internal.JdbcServicesImpl.configure(JdbcServicesImpl.java:205)
        at org.hibernate.boot.registry.internal.StandardServiceRegistryImpl.configureService(StandardServiceRegistryImpl.java:111)
        at org.hibernate.service.internal.AbstractServiceRegistryImpl.initializeService(AbstractServiceRegistryImpl.java:234)
        at org.hibernate.service.internal.AbstractServiceRegistryImpl.getService(AbstractServiceRegistryImpl.java:206)
        at org.hibernate.cfg.Configuration.buildTypeRegistrations(Configuration.java:1885)
        at org.hibernate.cfg.Configuration.buildSessionFactory(Configuration.java:1843)
        at org.hibernate.jpa.boot.internal.EntityManagerFactoryBuilderImpl$4.perform(EntityManagerFactoryBuilderImpl.java:850)
        at org.hibernate.jpa.boot.internal.EntityManagerFactoryBuilderImpl$4.perform(EntityManagerFactoryBuilderImpl.java:843)
        at org.hibernate.boot.registry.classloading.internal.ClassLoaderServiceImpl.withTccl(ClassLoaderServiceImpl.java:398)
        at org.hibernate.jpa.boot.internal.EntityManagerFactoryBuilderImpl.build(EntityManagerFactoryBuilderImpl.java:842)
        at org.hibernate.jpa.HibernatePersistenceProvider.createContainerEntityManagerFactory(HibernatePersistenceProvider.java:152)
        at org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean.createNativeEntityManagerFactory(LocalContainerEntityManagerFactoryBean.java:336)
        at org.springframework.orm.jpa.AbstractEntityManagerFactoryBean.afterPropertiesSet(AbstractEntityManagerFactoryBean.java:318)
        at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.invokeInitMethods(AbstractAutowireCapableBeanFactory.java:1613)
        at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.initializeBean(AbstractAutowireCapableBeanFactory.java:1550)
        ... 21 more

il mio file pom.xml è questo:

<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>1.1.8.RELEASE</version>
</parent>

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-actuator</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.security</groupId>
        <artifactId>spring-security-web</artifactId>
       </dependency>
    <dependency>
        <groupId>org.springframework.security</groupId>
        <artifactId>spring-security-config</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.security</groupId>
        <artifactId>spring-security-taglibs</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-jpa</artifactId>
    </dependency>
    <dependency>
        <groupId>commons-dbcp</groupId>
        <artifactId>commons-dbcp</artifactId>
    </dependency>
</dependencies>

la mia configurazione di ibernazione è che (la configurazione dialettale è nell'ultimo metodo di questa classe):

@Configuration
@EnableTransactionManagement
@ComponentScan({ "com.spring.app" })
public class HibernateConfig {

   @Bean
   public LocalSessionFactoryBean sessionFactory() {
      LocalSessionFactoryBean sessionFactory = new LocalSessionFactoryBean();

      sessionFactory.setDataSource(restDataSource());
      sessionFactory.setPackagesToScan(new String[] { "com.spring.app.model" });
      sessionFactory.setHibernateProperties(hibernateProperties());

      return sessionFactory;
   }

   @Bean
   public DataSource restDataSource() {
      BasicDataSource dataSource = new BasicDataSource();

      dataSource.setDriverClassName("org.postgresql.Driver");
      dataSource.setUrl("jdbc:postgresql://localhost:5432/teste?charSet=LATIN1");
      dataSource.setUsername("klebermo");
      dataSource.setPassword("123");

      return dataSource;
   }

   @Bean
   @Autowired
   public HibernateTransactionManager transactionManager(SessionFactory sessionFactory) {
      HibernateTransactionManager txManager = new HibernateTransactionManager();
      txManager.setSessionFactory(sessionFactory);
      return txManager;
   }

   @Bean
   public PersistenceExceptionTranslationPostProcessor exceptionTranslation() {
      return new PersistenceExceptionTranslationPostProcessor();
   }

   Properties hibernateProperties() {
      return new Properties() {
         /**
         * 
         */
        private static final long serialVersionUID = 1L;

        {
            setProperty("hibernate.hbm2ddl.auto", "create");
            setProperty("hibernate.show_sql", "false");
            setProperty("hibernate.dialect", "org.hibernate.dialect.PostgreSQLDialect");
         }
      };
   }
}

cosa sto facendo di sbagliato qui?

Innanzitutto rimuovi tutta la configurazione Spring Boot la avvierà per te.

Assicurati di avere un application.propertiesnel tuo percorso di classe e aggiungi le seguenti proprietà.

spring.datasource.url=jdbc:postgresql://localhost:5432/teste?charSet=LATIN1
spring.datasource.username=klebermo
spring.datasource.password=123

spring.jpa.database-platform=org.hibernate.dialect.PostgreSQLDialect
spring.jpa.show-sql=false
spring.jpa.hibernate.ddl-auto=create

Se hai davvero bisogno di accedere a SessionFactorye che è fondamentalmente per la stessa origine dati, puoi fare quanto segue (che è anche documentato qui anche se per XML, non JavaConfig).

@Configuration        
public class HibernateConfig {

    @Bean
    public HibernateJpaSessionFactoryBean sessionFactory(EntityManagerFactory emf) {
         HibernateJpaSessionFactoryBean factory = new HibernateJpaSessionFactoryBean();
         factory.setEntityManagerFactory(emf);
         return factory;
    }
}

In questo modo hai sia an EntityManagerFactoryche a SessionFactory.

AGGIORNAMENTO: A partire da Hibernate 5 in SessionFactoryrealtà estende il EntityManagerFactory. Quindi per ottenere un SessionFactorypuoi semplicemente lanciarlo EntityManagerFactoryo usare il unwrapmetodo per ottenerne uno.

public class SomeHibernateRepository {

  @PersistenceUnit
  private EntityManagerFactory emf;

  protected SessionFactory getSessionFactory() {
    return emf.unwrap(SessionFactory.class);
  }

}

Supponendo che tu abbia una classe con un mainmetodo con @EnableAutoConfigurationcui non hai bisogno @EnableTransactionManagementdell'annotazione, poiché ciò sarà abilitato da Spring Boot per te. Una classe di applicazione di base nel com.spring.apppacchetto dovrebbe essere sufficiente.

@Configuration
@EnableAutoConfiguration
@ComponentScan
public class Application {


    public static void main(String[] args) throws Exception {
        SpringApplication.run(Application.class, args);
    }

} 

Qualcosa del genere dovrebbe essere sufficiente per rilevare tutte le classi (incluse entità e repository basati su Spring Data).

AGGIORNAMENTO: queste annotazioni possono essere sostituite con una singola @SpringBootApplicationnelle versioni più recenti di Spring Boot.

@SpringBootApplication
public class Application {

    public static void main(String[] args) throws Exception {
        SpringApplication.run(Application.class, args);
    }
} 

Vorrei anche suggerire di rimuovere la commons-dbcpdipendenza in quanto ciò consentirebbe a Spring Boot di configurare l' HikariCPimplementazione più rapida e robusta .

Stavo affrontando un problema simile all'avvio dell'applicazione (utilizzando Spring Boot) con il server di database inattivo .

Hibernate può determinare il dialetto corretto da utilizzare automaticamente, ma per fare ciò ha bisogno di una connessione live al database.

aggiungi spring.jpa.properties.hibernate.dialect = org.hibernate.dialect.MySQLDialectnel file application.properties

Ho ricevuto questo errore quando il mio database non è stato creato. Dopo aver creato il DB manualmente, ha funzionato bene.

Ho anche affrontato un problema simile. Ma era a causa della password non valida fornita. Inoltre, vorrei dire che il tuo codice sembra essere un codice vecchio stile usando spring. Hai già detto che stai utilizzando lo stivale a molla, il che significa che la maggior parte delle cose verrà configurata automaticamente per te. il dialetto ibernazione verrà selezionato automaticamente in base al driver DB disponibile sul percorso di classe insieme a credenziali valide che possono essere utilizzate per testare correttamente la connessione. In caso di problemi con la connessione, si verificherà nuovamente lo stesso errore. sono necessarie solo 3 proprietà in application.properties

# Replace with your connection string
spring.datasource.url=jdbc:mysql://localhost:3306/pdb1

# Replace with your credentials
spring.datasource.username=root
spring.datasource.password=

Ho riscontrato lo stesso problema e il mio problema era che il DB a cui stavo tentando di connettermi non esisteva.

Ho creato il DB, verificato l'URL / stringa di connessione e rieseguito e tutto ha funzionato come previsto.

questo sta accadendo perché il tuo codice non è balla per connettere il database. Assicurati di avere il driver mysql e il nome utente, la password corretta.

Assicurati di application.propertiesavere tutte le informazioni corrette: (Ho cambiato la mia porta db da 8889a 3306ha funzionato)

 db.url: jdbc:mysql://localhost:3306/test

In Spring Boot per jpa java config è necessario estendere JpaBaseConfiguration e implementare i suoi metodi astratti.

@Configuration
public class JpaConfig extends JpaBaseConfiguration {

    @Override
    protected AbstractJpaVendorAdapter createJpaVendorAdapter() {
        final HibernateJpaVendorAdapter vendorAdapter = new HibernateJpaVendorAdapter();
        return vendorAdapter;
    }

    @Override
    protected Map<String, Object> getVendorProperties() {
        Map<String, Object> properties = new HashMap<>();
        properties.put("hibernate.dialect", "org.hibernate.dialect.PostgreSQLDialect");
    }

}

Rimuovere la configurazione di ibernazione ridondante

Se si utilizza Spring Boot, non è necessario fornire esplicitamente la configurazione JPA e Hibernate, poiché Spring Boot può farlo per te.

Aggiungi proprietà di configurazione del database

Nel application.propertiesfile di configurazione di Spring Boot, devi aggiungere le proprietà di configurazione del database:

spring.datasource.driverClassName = "org.postgresql.Driver
spring.datasource.url = jdbc:postgresql://localhost:5432/teste?charSet=LATIN1
spring.datasource.username = klebermo
spring.datasource.password = 123

Aggiungi proprietà specifiche di ibernazione

E, nello stesso application.propertiesfile di configurazione, puoi anche impostare proprietà di ibernazione personalizzate:

# Log SQL statements
spring.jpa.show-sql = false

# Hibernate ddl auto for generating the database schema
spring.jpa.hibernate.ddl-auto = create

# Hibernate database Dialect
spring.jpa.properties.hibernate.dialect = org.hibernate.dialect.PostgreSQLDialect

Questo è tutto!

Ho avuto lo stesso problema. l'aggiunta di questo a application.properties ha risolto il problema:

spring.jpa.properties.hibernate.dialect=org.hibernate.dialect.MySQLDialect

Nel mio caso l'utente non è riuscito a connettersi al database. Se avrà lo stesso problema se il registro contiene un avviso appena prima dell'eccezione:

WARN HHH000342: Could not obtain connection to query metadata : Login failed for user 'my_user'.

Assicurati di avere il tuo database nel tuo pom come ha fatto OP. Questo era il mio problema.

Il mio problema era che il database incorporato era già connesso. stretta connessione

Ho riscontrato questo problema quando Eclipse non è stato in grado di trovare il driver JDBC. Ho dovuto fare un aggiornamento graduale dall'eclissi per ottenere questo lavoro.

Di seguito sono riportati alcuni dei motivi del hibernate.dialectproblema non impostato. La maggior parte di queste eccezioni sono mostrate nel registro di avvio che è infine seguito dal problema menzionato.

Esempio: nell'app di avvio Spring con Postgres DB

1. Controllare se il database è effettivamente installato e il suo server è avviato.

• org.postgresql.util.PSQLException: connessione a localhost: 5432 rifiutata. Verificare che il nome host e la porta siano corretti e che il postmaster accetti connessioni TCP / IP.
• java.net.ConnectException: connessione rifiutata: connessione
• org.hibernate.service.spi.ServiceException: Impossibile creare il servizio richiesto [org.hibernate.engine.jdbc.env.spi.JdbcEnvironment]

2. Verificare che il nome del database sia menzionato correttamente.

• org.postgresql.util.PSQLException: FATAL: il database "foo" non esiste

  Nel application.propertiesfile,

  spring.datasource.url = jdbc:postgresql://localhost:5432/foo

  ma foonon esisteva. Quindi ho creato il database da pgAdmin per Postgres

  CREATE DATABASE foo;

3. Controllare se il nome host e la porta del server sono accessibili.

• org.postgresql.util.PSQLException: connessione a localhost: 5431 rifiutata. Verificare che il nome host e la porta siano corretti e che il postmaster accetti connessioni TCP / IP.
• java.net.ConnectException: connessione rifiutata: connessione

4. Controllare se le credenziali del database sono corrette.

• come menzionato da @Pankaj

• org.postgresql.util.PSQLException: FATAL: autenticazione password non riuscita per l'utente "postgres"

  spring.datasource.username= {DB USERNAME HERE}

  spring.datasource.password= {DB PASSWORD HERE}

Se stai usando questa linea:

sessionFactory.getHibernateProperties().put("hibernate.dialect", env.getProperty("hibernate.dialect"));

assicurarsi che env.getProperty("hibernate.dialect")non sia nullo.

Lo stesso, ma in un JBoss WildFly AS .

Risolto con proprietà nel mio META-INF/persistence.xml

<properties>
            <property name="hibernate.transaction.jta.platform"
                value="org.hibernate.service.jta.platform.internal.JBossAppServerJtaPlatform" />
            <property name="spring.jpa.database-platform" value="org.hibernate.dialect.PostgreSQLDialect" />
            <property name="spring.jpa.show-sql" value="false" />
</properties>

Per coloro che lavorano con AWS MySQL RDS, può verificarsi quando non si è in grado di connettersi al database. Vai alle impostazioni dei gruppi di sicurezza AWS per MySQL RDS e modifica la regola IP in entrata aggiornando MyIP.

Ho affrontato questo problema e facendo sopra ho risolto il problema per me.

Ho avuto anche questo problema. Nel mio caso è stato a causa dell'assenza di sovvenzioni assegnate all'utente MySQL. L'assegnazione di sovvenzioni all'utente MySQL che la mia app utilizza ha risolto il problema:

grant select, insert, delete, update on my_db.* to 'my_user'@'%';

Ho avuto lo stesso problema e dopo il debug risulta che Spring application.properties aveva un indirizzo IP errato per il server DB

spring.datasource.url=jdbc:oracle:thin:@WRONG:1521/DEV

Ho riprodotto questo messaggio di errore nei tre casi seguenti:

• Non esiste un utente del database con nome utente scritto nel file application.properties o nel file persistence.properties o, come nel tuo caso, nel file HibernateConfig
• Il database distribuito ha quell'utente ma l'utente è identificato da una password diversa da quella in uno dei file sopra
• Il database ha quell'utente e le password corrispondono ma quell'utente non ha tutti i privilegi necessari per eseguire tutte le attività del database che l'app di avvio di primavera ha

La soluzione ovvia è quella di creare un nuovo utente del database con lo stesso nome utente e password dell'app per l'avvio a molla o modificare nome utente e password nei file dell'app per l'avvio a molla in modo che corrispondano a un utente del database esistente e concedere privilegi sufficienti a tale utente del database. Nel caso del database MySQL questo può essere fatto come mostrato di seguito:

mysql -u root -p 
>CREATE USER 'theuser'@'localhost' IDENTIFIED BY 'thepassword';
>GRANT ALL ON *.* to theuser@localhost IDENTIFIED BY 'thepassword';
>FLUSH PRIVILEGES;

Ovviamente ci sono comandi simili in Postgresql ma non ho testato se in questi tre casi questo messaggio di errore può essere riprodotto in Postgresql.

Ho avuto lo stesso problema ed è stato causato dall'incapacità di connettersi all'istanza del database. Cerca l'errore di ibernazione HHH000342 nel registro sopra quell'errore, dovrebbe darti un'idea di dove la connessione db non riesce (nome utente / passaggio errati, url, ecc.)

Questo mi è successo perché non avevo aggiunto il conf.configure();prima di iniziare la sessione:

Configuration conf = new Configuration();
conf.configure();

Assicurarsi di aver inserito dettagli validi in application.properties e se il proprio server di database è disponibile. Ad esempio, quando ti colleghi a MySQL, controlla se XAMPP funziona correttamente.

Ho riscontrato lo stesso problema: il db che stavo cercando di connettere non esisteva. Ho usato jpa.database=default(il che immagino significhi che proverà a connettersi al database e quindi a selezionare automaticamente il dialetto). Una volta avviato il database, ha funzionato bene senza alcuna modifica.

Ho riscontrato questo problema a causa della versione Mysql 8.0.11 che tornava alla versione 5.7 risolta per me

Ho avuto lo stesso errore dopo aver utilizzato la generazione del codice di ibernazione

https://www.mkyong.com/hibernate/how-to-generate-code-with-hibernate-tools/

quindi è hibernate.cfg.xmlstato creato /src/main/java ma senza i parametri di connessione dopo averlo rimosso - il mio problema è stato risolto

Se l'errore precedente nel registro era questo: "ERRORE - HikariPool-1 - jdbcUrl è richiesto con driverClassName", la soluzione è riscrivere "url" in "jdbc-url" secondo questo: Database application.yml per l'avvio di Spring dalle applicazioni .proprietà

Ho avuto lo stesso errore,

 Caused by: org.hibernate.HibernateException: Access to DialectResolutionInfo cannot be null when 'hibernate.dialect' not set

nel mio caso il WAR aveva application.properties all'interno che indicava il server di sviluppo in
cui application.properties esterno puntava al server DB giusto.

assicurati di non avere altre application.properties nel classpath / jars ...