org.hibernate.HibernateException: o acesso ao DialectResolutionInfo não pode ser nulo quando 'hibernate.dialect' não está definido

Estou tentando executar um aplicativo spring-boot que usa o hibernate via spring-jpa, mas estou recebendo este erro:

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

meu arquivo pom.xml é este:

<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>

minha configuração de hibernação é a seguinte (a configuração de dialeto está no último método desta 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");
         }
      };
   }
}

o que estou fazendo de errado aqui?

Primeiro remova todas as suas configurações que o Spring Boot iniciará para você.

Verifique se você possui um application.propertiescaminho de classe e adicione as seguintes propriedades.

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 você realmente precisar acessar ae SessionFactorybasicamente para a mesma fonte de dados, poderá fazer o seguinte (que também está documentado aqui, embora seja para XML, não para JavaConfig).

@Configuration        
public class HibernateConfig {

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

Dessa forma, você tem um EntityManagerFactorye um SessionFactory.

ATUALIZAÇÃO: A partir do Hibernate 5, na SessionFactoryverdade, estende o EntityManagerFactory. Portanto, para obter um, SessionFactoryvocê pode simplesmente convertê EntityManagerFactory-lo ou usar o unwrapmétodo para obter um.

public class SomeHibernateRepository {

  @PersistenceUnit
  private EntityManagerFactory emf;

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

}

Supondo que você tenha uma classe com um mainmétodo @EnableAutoConfiguration, não precisa da @EnableTransactionManagementanotação, pois isso será ativado pelo Spring Boot para você. Uma classe de aplicativo básica no com.spring.apppacote deve ser suficiente.

@Configuration
@EnableAutoConfiguration
@ComponentScan
public class Application {


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

} 

Algo assim deve ser suficiente para que todas as suas classes (incluindo entidades e repositórios baseados em Spring Data) sejam detectadas.

ATUALIZAÇÃO: essas anotações podem ser substituídas por uma única @SpringBootApplicationnas versões mais recentes do Spring Boot.

@SpringBootApplication
public class Application {

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

Eu também sugeriria remover a commons-dbcpdependência, pois isso permitiria ao Spring Boot configurar a HikariCPimplementação mais rápida e robusta .

Eu estava enfrentando um problema semelhante ao iniciar o aplicativo (usando o Spring Boot) com o servidor de banco de dados inativo .

O Hibernate pode determinar o dialeto correto a ser usado automaticamente, mas para fazer isso, ele precisa de uma conexão ativa com o banco de dados.

adicionar spring.jpa.properties.hibernate.dialect = org.hibernate.dialect.MySQLDialectno arquivo application.properties

Eu recebi esse erro quando meu banco de dados não foi criado. Depois de criar o banco de dados manualmente, funcionou bem.

Eu também enfrentei um problema semelhante. Mas isso ocorreu devido à senha inválida fornecida. Além disso, gostaria de dizer que seu código parece ser antigo usando a primavera. Você já mencionou que está usando a bota de mola, o que significa que a maioria das coisas será configurada automaticamente para você. O dialeto de hibernação será selecionado automaticamente com base no driver DB disponível no caminho de classe, juntamente com credenciais válidas que podem ser usadas para testar a conexão corretamente. Se houver algum problema com a conexão, você novamente enfrentará o mesmo erro. são necessárias apenas 3 propriedades em 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=

Encontrei o mesmo problema e meu problema era que o banco de dados ao qual estava tentando conectar não existia.

Criei o banco de dados, verifiquei a URL / string de conexão e reran e tudo funcionou conforme o esperado.

isso está acontecendo porque seu código não é fardo para conectar o banco de dados. Verifique se você possui o driver mysql e o nome de usuário, a senha correta.

Verifique se application.propertiestodas as informações estão corretas: (mudei minha porta db 8889para a 3306que funcionou)

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

Na inicialização do Spring para jpa java config, você precisa estender o JpaBaseConfiguration e implementar seus métodos abstratos.

@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");
    }

}

Remova a configuração de hibernação redundante

Se você estiver usando o Spring Boot, não precisará fornecer explicitamente a configuração JPA e Hibernate, pois o Spring Boot pode fazer isso por você.

Adicionar propriedades de configuração do banco de dados

No application.propertiesarquivo de configuração do Spring Boot, adicione as propriedades de configuração do banco de dados:

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

Adicionar propriedades específicas do Hibernate

E, no mesmo application.propertiesarquivo de configuração, você também pode definir propriedades personalizadas do Hibernate:

# 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

É isso aí!

Eu tive o mesmo problema. adicionar isso ao application.properties resolveu o problema:

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

No meu caso, o usuário não pôde se conectar ao banco de dados. Se terá o mesmo problema se o log contiver um aviso antes da exceção:

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

Certifique-se de ter seu banco de dados no seu pom, como o OP. Esse foi o meu problema.

Meu problema era que o banco de dados incorporado já estava conectado. conexão próxima

Eu obtive esse problema quando o Eclipse não conseguiu encontrar o driver JDBC. Tive que fazer uma atualização gradual do eclipse para obter esse trabalho.

A seguir, estão alguns dos motivos para a hibernate.dialect problema não definido. A maioria dessas exceções é mostrada no log de inicialização, que é finalmente seguido pelo problema mencionado.

Exemplo: no aplicativo de inicialização Spring com o Postgres DB

1. Verifique se o banco de dados está realmente instalado e se o servidor foi iniciado.

• org.postgresql.util.PSQLException: Conexão com o host local: 5432 recusada. Verifique se o nome do host e a porta estão corretos e se o postmaster está aceitando conexões TCP / IP.
• java.net.ConnectException: conexão recusada: conectar
• org.hibernate.service.spi.ServiceException: Não foi possível criar o serviço solicitado [org.hibernate.engine.jdbc.env.spi.JdbcEnvironment]

2. Verifique se o nome do banco de dados está mencionado corretamente.

• org.postgresql.util.PSQLException: FATAL: o banco de dados "foo" não existe

  Em application.propertiesarquivo,

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

  mas foonão existia. Então eu criei o banco de dados a partir do pgAdmin para o postgres

  CREATE DATABASE foo;

3. Verifique se o nome do host e a porta do servidor estão acessíveis.

• org.postgresql.util.PSQLException: Conexão com o host local: 5431 recusada. Verifique se o nome do host e a porta estão corretos e se o postmaster está aceitando conexões TCP / IP.
• java.net.ConnectException: conexão recusada: conectar

4. Verifique se as credenciais do banco de dados estão corretas.

• como @Pankaj mencionado

• org.postgresql.util.PSQLException: FATAL: falha na autenticação da senha para o usuário "postgres"

  spring.datasource.username= {DB USERNAME HERE}

  spring.datasource.password= {DB PASSWORD HERE}

Se você estiver usando esta linha:

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

verifique se env.getProperty("hibernate.dialect")não é nulo.

O mesmo, mas em um JBoss WildFly AS .

Resolvido com propriedades no meu 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>

Para aqueles que trabalham com o AWS MySQL RDS, isso pode ocorrer quando você não consegue se conectar ao banco de dados. Vá para a configuração de Grupos de segurança da AWS para MySQL RDS e edite a regra de IP de entrada atualizando o MyIP.

Eu enfrentei esse problema e, acima, resolvi o problema para mim.

Eu também tive esse problema. No meu caso, foi por causa de nenhuma concessão ter sido atribuída ao usuário do MySQL. A atribuição de concessões ao usuário MySQL que meu aplicativo usa resolveu o problema:

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

Eu tive o mesmo problema e, após a depuração, verifica-se que o Spring application.properties tinha um endereço IP incorreto para o servidor DB

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

Reproduzi essa mensagem de erro nos três casos a seguir:

• Não existe usuário do banco de dados com nome de usuário gravado no arquivo application.properties ou no arquivo persistence.properties ou, como no seu caso, no arquivo HibernateConfig
• O banco de dados implantado possui esse usuário, mas o usuário é identificado por uma senha diferente daquela em um dos arquivos acima
• O banco de dados possui esse usuário e as senhas correspondentes, mas esse usuário não possui todos os privilégios necessários para realizar todas as tarefas do banco de dados executadas pelo aplicativo de inicialização por primavera

A solução óbvia é criar um novo usuário de banco de dados com o mesmo nome de usuário e senha do aplicativo de inicialização por mola ou alterar o nome de usuário e a senha nos arquivos do aplicativo de inicialização por inicialização para corresponder a um usuário de banco de dados existente e conceder privilégios suficientes para esse usuário de banco de dados. No caso do banco de dados MySQL, isso pode ser feito conforme mostrado abaixo:

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

Obviamente, existem comandos semelhantes no Postgresql, mas não testei se, no caso do Postgresql, essa mensagem de erro pode ser reproduzida nesses três casos.

Eu tive o mesmo problema e foi causado por não conseguir conectar-se à instância do banco de dados. Procure o erro de hibernação HHH000342 no log acima desse erro; ele deve dar uma idéia de onde a conexão db está falhando (nome de usuário / senha incorreto, URL, etc.)

Isso aconteceu comigo porque eu não tinha adicionado o conf.configure();antes de iniciar a sessão:

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

Certifique-se de inserir detalhes válidos em application.properties e se seu servidor de banco de dados está disponível. Como exemplo, quando você está se conectando ao MySQL, verifique se o XAMPP está sendo executado corretamente.

Eu enfrentei o mesmo problema: o banco de dados que estava tentando conectar não existia. Eu usei jpa.database=default(o que eu acho que significa que ele tentará se conectar ao banco de dados e depois selecionar automaticamente o dialeto). Depois que iniciei o banco de dados, ele funcionou bem, sem nenhuma alteração.

Eu enfrentei esse problema devido à versão do MySQL 8.0.11 revertendo para 5.7 resolvida para mim

Eu tive o mesmo erro depois de usar a geração de código de hibernação

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

então o hibernate.cfg.xmlfoi criado, /src/main/java mas sem os parâmetros de conexão após removê-lo - meu problema foi resolvido

Se o erro anterior no log foi este: "ERRO - HikariPool-1 - jdbcUrl é necessário com driverClassName", a solução é reescrever "url" para "jdbc-url" de acordo com o seguinte: Database application.yml para inicialização do Spring a partir de aplicativos .properties

Eu tive o mesmo erro,

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

no meu caso, o WAR tinha application.properties dentro dele, que apontava para o servidor de desenvolvimento em
que application.properties externo apontava para o servidor DB correto.

verifique se você não possui outros aplicativos.properties no caminho de classe / jars ...