conexão jdbc H2 padrão de boot de mola (e console H2)

107

Estou simplesmente tentando ver o conteúdo do banco de dados H2 para um banco de dados H2 incorporado que o spring-boot cria quando não especifico nada em meu application.properties e começo com mvn spring: run. Eu posso ver o Hibernate JPA criando as tabelas, mas se eu tentar acessar o console h2 na URL abaixo, o banco de dados não terá tabelas.

http://localhost:8080/console/

Vejo sugestões como esta: Ver o conteúdo do banco de dados H2 incorporado iniciado por Spring

Mas não sei onde colocar o XML sugerido no spring-boot e, mesmo que o fizesse, não quero que o h2console esteja mais disponível quando um banco de dados externo for configurado, então é mais provável que eu precise lidar com isso com algum tipo de código condicional (ou talvez apenas permitir que o spring trate-o automaticamente no caso mais ideal, onde eu apenas incluo H2 quando um perfil de maven é ativado).

Alguém tem algum código de amostra mostrando como fazer o console H2 funcionar na inicialização (e também a maneira de descobrir o que está usando a string de conexão jdbc que spring está usando)?

Aaron Zeckoski
fonte
Posso responder parcialmente à minha própria pergunta adicionando isto ao meu application.properties: spring.datasource.url = jdbc: h2: mem: AZ; DB_CLOSE_DELAY = -1; DB_CLOSE_ON_EXIT = FALSE spring.datasource.driverClassName = org.h2.Driver spring .datasource.username = sa spring.datasource.password = Mas o que eu realmente quero saber é como gerenciar a configuração programaticamente (ou pelo menos como descobrir os padrões da primavera)
Aaron Zeckoski
1
geoand - Essa é a mesma coisa que vinculei na pergunta real, então infelizmente isso não ajuda.
Aaron Zeckoski
2
Dave - Ao adicionar essa configuração, posso acessar o console H2 e ver as tabelas, mas não me ajuda a entender se essa é a maneira correta de fazer isso (eu preferiria acessar a configuração na primavera, quando não tenho configurações) ou como obter a mola de conexão JDBC está usando.
Aaron Zeckoski
1
Use JDBC URL: jdbc: h2: mem: testdb
Chinmoy

Respostas:

110

Foi assim que fiz o console H2 funcionar em boot com H2. Não tenho certeza se isso está certo, mas como ninguém mais ofereceu uma solução, vou sugerir que essa é a melhor maneira de fazê-lo.

No meu caso, escolhi um nome específico para o banco de dados para que tivesse algo para inserir ao iniciar o console H2 (neste caso, "AZ"). Acho que tudo isso é necessário, embora pareça que deixar de fora a plataforma spring.jpa.database não prejudica nada.

Em application.properties:

spring.datasource.url=jdbc:h2:mem:AZ;DB_CLOSE_DELAY=-1;DB_CLOSE_ON_EXIT=FALSE
spring.datasource.driverClassName=org.h2.Driver
spring.datasource.username=sa
spring.datasource.password=
spring.jpa.database-platform=org.hibernate.dialect.H2Dialect

Em Application.java (ou alguma configuração):

@Bean
public ServletRegistrationBean h2servletRegistration() {
    ServletRegistrationBean registration = new ServletRegistrationBean(new WebServlet());
    registration.addUrlMappings("/console/*");
    return registration;
}

Em seguida, você pode acessar o console H2 em {server} / console /. Digite isso como o URL JDBC: jdbc: h2: mem: AZ

Aaron Zeckoski
fonte
1
Usando new WebServlet()me dê problemas. Qual classe isso está importando para você? Ele está puxando javax.servlet.annotation.WebServlet para mim como a única opção e é apenas uma interface.
Splaktar
5
Ah, entendi, org.h2.server.web.WebServlet é o que é necessário. Meu projeto não estava sincronizado com o Gradle para obter as novas bibliotecas h2.
Splaktar
21
As peças application.properties não são necessárias. Você pode apenas usar a parte Application.java que colocou e, em seguida, conectar-se jdbc:h2:mem:testdbcom um nome de usuário e uma senha em branco. localhost: 8082 funciona com esta configuração.
Splaktar
2
@Splaktar Obrigado! Eu estava enlouquecendo tentando descobrir como conectar e a peça que faltava no quebra-cabeça era usar "testdb" para o nome do banco de dados.
nerdherd
1
@Splaktar - você deve fazer de seu comentário a resposta. Como você disse, o código-fonte de EmbeddedDatabaseConnection mostra todos os URIs de conexão de banco de dados incorporados padrão
karthik m
55

A partir do Spring Boot 1.3.0.M3, o console H2 pode ser configurado automaticamente.

Os pré-requisitos são:

  • Você está desenvolvendo um aplicativo da web
  • Spring Boot Dev Tools está habilitado
  • H2 está no caminho de classe

Mesmo se você não usar Spring Boot Dev Tools, você ainda pode configurar automaticamente o console definindo spring.h2.console.enabledparatrue

Confira esta parte da documentação para todos os detalhes.

Observe que, ao configurar desta forma, o console pode ser acessado em: http: // localhost: 8080 / h2-console /

geoand
fonte
Ou, conforme explicado no documento, você o habilita com spring.h2.console.enabled = true. Com os pré-requisitos, ele é ativado automaticamente.
keiki
O que significa exatamente Você está desenvolvendo um aplicativo da web ?
garci560
No contexto do Spring Boot, significa que você adicionou spring-boot-starter-webcomo uma dependência
geoand
1
Também acho que quando você abre localhost: 8080 / h2-console, você precisa escrever jdbc: h2: mem: testdb em jdbc url para ver suas tabelas. E na url localhost: 8080 / h2-console após localhost, você precisa especificar a porta do aplicativo.
anujprashar
3
@anujprashar, tenho certeza que jdbc:h2:mem:testdbé para o URL de conexão, não para o URL onde o console está acessível
geoand
44

Eu encontrei um bom tutorial sobre este tópico:

https://springframework.guru/using-the-h2-database-console-in-spring-boot-with-spring-security/

Basicamente, o URL JDBC correto para mim era: jdbc:h2:mem:testdb

Krzysztof Kaczor
fonte
1
pergunta idiota, mas esta parece ser a URL JDBC padrão porque a configuração spring.datasource.name padroniza para testdb. Por que, se esse for o caso, se eu alterar o nome do banco de dados para algo como foodb, o jdbc ainda é o mesmo e não o jdbc: h2: mem: foodb
Dan Vega
2
Este url jdbc jdbc: h2: mem: testdb está correto. Isso me ajudou finalmente a me conectar ao banco de dados padrão criado por spring data jpa.
Kamal Joshi
Você pode definir o nome do banco de dados como: spring.datasource.url = jdbc: h2: mem: test; em application.properties
Aleksei Maide
23

De http://docs.spring.io/spring-boot/docs/current/reference/html/common-application-properties.html

H2 Web Console (H2ConsoleProperties):

spring.h2.console.enabled=true //Enable the console.
spring.h2.console.path=/h2-console //Path at which the console will be available.

Adicionar as duas linhas acima ao meu arquivo application.properties foi o suficiente para acessar o console da web do banco de dados H2, usando o nome de usuário (sa) e a senha padrão (vazio, como em não digite uma senha quando a ui solicitar).

mancini0
fonte
1
Não deveria ser spring.h2.console.enabled=true? False irá desativá-lo. E spring.h2.console.path=/h2-consoleé redundante porque /h2-consoleé o caminho padrão do Spring Boot. Conforme a documentação "Por padrão, o console estará disponível em / h2-console. Você pode personalizar o caminho do console usando a propriedade spring.h2.console.path." Mais detalhes aqui docs.spring.io/spring-boot/docs/current/reference/html/…
georger
Incluí a última propriedade para mostrar OP onde ele pode acessar o console. Obviamente, spring.h2.console.enabled.enabled = false desabilitará o console, o ponto é que isso pode ser configurado como uma propriedade. Vou definir essa propriedade como true para maior clareza.
mancini0
20

Uma resposta semelhante com o guia Passo a Passo.

  1. Adicionar dependência de ferramentas de desenvolvedor ao seu pom.xmloubuild.gradle

Maven

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-devtools</artifactId>
        <optional>true</optional>
    </dependency>
</dependencies>

Gradle

dependencies {
    compile("org.springframework.boot:spring-boot-devtools")
}
  1. Acesse o banco de dados de http://localhost:8080/h2-console/
  2. Especifique jdbc:h2:mem:testdbcomo URL JDBC
  3. Você deve ver a entidade que especificou em seu projeto como uma tabela.
biniam
fonte
2
adicionar isso na seção de dependência funcionou para mim 'runtime ("com.h2database: h2")'
Raja Nagendra Kumar
17

Eu tinha apenas propriedades abaixo em /resources/application.properties. Depois de executar o Spring Boot, usando este URL ( http: // localhost: 8080 / h2-console / ), a tabela no console H2 ficou visível e lida para visualizar os dados da tabela, você também pode executar comandos SQL simples. Uma coisa, em seu código java, ao buscar dados, os nomes das colunas são maiúsculas, embora schema.sql esteja usando nomes em minúsculas :)

spring.datasource.initialize=true
spring.datasource.url=jdbc:h2:mem:testdb;DB_CLOSE_DELAY=- 1;DB_CLOSE_ON_EXIT=FALSE
spring.datasource.driverClassName=org.h2.Driver
spring.datasource.username=sa
spring.datasource.password=
spring.h2.console.enabled=true
rak22
fonte
16

Para Spring Boot 2.1.1 direto do Spring Initialzr:

  1. O padrão com devtools é http://127.0.0.1:8080/h2-console/

    • POM: spring-boot-starter, h2, spring-boot-starter-web, spring-boot-devtools
  2. Sem devtools - você precisa defini-lo nas propriedades:spring.h2.console.enabled=true spring.h2.console.path=/h2-console

    • POM: spring-boot-starter, h2, spring-boot-starter-web

Assim que chegar lá - defina o URL JDBC: jdbc: h2: mem: testdb (o padrão não funcionará)

Witold Kaczurba
fonte
10

Se você usar as ferramentas de desenvolvedor do Spring Boot, ele vem com o Console H2 habilitado por padrão. Ele pode ser acessado em /h2-console/. Na interface de login, para JDBC URLvalor de uso de entrada jdbc:h2:mem:testdb. Preste atenção ao membarbante.

Se você não usar as ferramentas de desenvolvedor do Spring Boot, poderá habilitar o console application.propertiesusando spring.h2.console.enabled=true. Isso habilitará o console em /h2-console. Se você deseja alterar o URL, pode adicionar outra entrada com spring.h2.console.path=my_console_path.

O nome do esquema padrão é testdb.

Mais detalhes na documentação do Spring Boot .

Georger
fonte
4
Por que não está jdbc:h2:mem:testdbdefinido como url jdbc padrão? Passei muito tempo pensando onde minhas entidades jpa deram errado
Sudip Bhandari
10

Verifique spring application.properties

spring.datasource.url = jdbc: h2: mem: testdb; DB_CLOSE_DELAY = -1; DB_CLOSE_ON_EXIT = FALSE

aqui testdbédefinido o banco de dados Certifique-se de que o console h2 tem o mesmo valor enquanto se conecta de outra forma ele se conectará ao banco de dados padrão

insira a descrição da imagem aqui

vaquar khan
fonte
1
resposta perfeita!
gaurav
6

Para obter as tabelas, tudo o que você precisa fazer é criar 2 arquivos sql schema.sql (para a criação da tabela) e data.sql (dados para as tabelas criadas). Esses arquivos devem ser colocados na pasta src / main / resources. O Spring boot auto detecta-os e cuida do resto durante a execução.

Se estiver usando mais de 2 DB em seu projeto, certifique-se de usar arquivos específicos como (schema-h2.sql - para h2 DB, schema-oracle.sql - para Oracle DB). O mesmo a ser seguido para data.sql também.

Certifique-se também de eliminar as tabelas adicionando a instrução drop table em schema.sql como primeira instrução. Para evitar o acréscimo de registros duplicados.

O link para a bota de mola está aqui.

Meu application.properties é o seguinte.

spring.datasource.url=jdbc:h2:~/file/Shiva;DB_CLOSE_DELAY=-1;DB_CLOSE_ON_EXIT=FALSE
spring.datasource.driver-class-name=org.h2.Driver
spring.datasource.username=sa
spring.datasource.password=
spring.datasource.platform=h2
spring.jpa.database-platform=org.hibernate.dialect.H2Dialect
spring.h2.console.enabled=true
spring.datasource.initialize=true 
spring.error.whitelabel.enabled=true
spring.h2.console.path=/console
spring.datasource.continue-on-error=true
spring.jpa.hibernate.ddl-auto=create
spring.hibernate.hbm2ddl.auto=update
spring.hibernate.show_sql=true

Você pode seguir as etapas no link abaixo.

https://springframework.guru/using-the-h2-database-console-in-spring-boot-with-spring-security/

kemparaj565
fonte
"spring.jpa.hibernate.ddl-auto" duas vezes com valores diferentes ...
Yura
3

Descobri que com o spring boot 2.0.2.RELEASE, configurar spring-boot-starter-data-jpa e com.h2database no arquivo POM não é apenas o suficiente para ter o console H2 funcionando. Você deve configurar spring-boot-devtools conforme abaixo. Opcionalmente, você pode seguir as instruções de Aaron Zeckoski nesta postagem

  <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-devtools</artifactId>
        <optional>true</optional>
 </dependency>
Pragnesh Rana
fonte
3

Use jdbc: h2: mem: testdb como seu caminho ao fazer login no console H2.

Obviamente, se você alterou as propriedades do Spring Boot, sua fonte de dados pode ser diferente, mas parece que você está lutando para encontrar o padrão. Isso é tudo que há para fazer! Você verá seu esquema após fazer login no H2.


fonte
1

Eu cometi um erro muito estúpido quando tive esse mesmo problema. Eu adicionei H2 DB para executar casos de teste de unidade e, portanto, configurei scopecomo testem pom.xml. Ao executar o aplicativo usando mvn spring:runeu removi o scopee ele funciona bem agora.

AbhishekB
fonte