spring boot - create - Cómo configurar spring-boot para usar una base de datos H2 basada en archivos

spring boot jdbc h2

Question

He creado con éxito una aplicación de arranque de primavera que utiliza la base de datos embebida H2 en memoria. Ahora me gustaría cambiar esto a una versión basada en archivos que persistirá.

Intenté cambiar las propiedades spring.datasource.* En mi archivo application.properties y se ven así:

spring.datasource.url=jdbc:h2:file:~/test;DB_CLOSE_ON_EXIT=FALSE
spring.datasource.username=test
spring.datasource.password=test
spring.datasource.driverClassName=org.h2.Driver`  

Parece que el arranque de primavera simplemente ignora esta configuración porque simplemente comienza de la siguiente manera:

o.s.j.d.e.EmbeddedDatabaseFactory        : Starting embedded database: url=''jdbc:h2:mem:testdb;DB_CLOSE_DELAY=-1;DB_CLOSE_ON_EXIT=false'', username=''sa''

Mi pom.xml contiene las siguientes dependencias que pueden ser relevantes para esta publicación:

<parent>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-parent</artifactId>
  <version>1.3.5.RELEASE</version>
</parent>
....
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency> 
<dependency>
    <groupId>com.h2database</groupId>
    <artifactId>h2</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-devtools</artifactId>
</dependency>

Según la documentación y varias publicaciones, entiendo que la configuración debería funcionar, pero no tengo suerte. Solo para evitar algunos de los errores básicos que probé y verifiqué lo siguiente:

1. Las propiedades de mi aplicación están en classspath:
2. He intentado excluir la configuración automática en la anotación @EnableAutoConfiguration
3. He intentado inyectar un bean dataSource con combinaciones de anotaciones @Primary , @ConfigurationProperties(prefix = "spring.datasource") y establecer las propiedades mediante programación con DataSourceBuilder . Esto provoca otros errores relacionados con que el tipo sea null .

Parece que me falta un concepto clave o algo así. Alguien puede ayudar.

ACTUALIZACIÓN 1: Extracto de mi informe de configuración automática:

Positive matches:
-----------------

    DataSourceAutoConfiguration matched
  - @ConditionalOnClass classes found: javax.sql.DataSource,org.springframework.jdbc.datasource.embedded.EmbeddedDatabaseType (OnClassCondition)

   DataSourceAutoConfiguration.DataSourceInitializerConfiguration matched
  - @ConditionalOnMissingBean (types: org.springframework.boot.autoconfigure.jdbc.DataSourceInitializer; SearchStrategy: all) found no beans (OnBeanCondition)

   DataSourceAutoConfiguration.EmbeddedConfiguration matched
  - embedded database H2 detected (DataSourceAutoConfiguration.EmbeddedDataSourceCondition)
  - @ConditionalOnMissingBean (types: javax.sql.DataSource,javax.sql.XADataSource; SearchStrategy: all) found no beans (OnBeanCondition)

   DataSourceAutoConfiguration.JdbcTemplateConfiguration matched
  - existing auto database detected (DataSourceAutoConfiguration.DataSourceAvailableCondition)

   DataSourceAutoConfiguration.JdbcTemplateConfiguration#jdbcTemplate matched
  - @ConditionalOnMissingBean (types: org.springframework.jdbc.core.JdbcOperations; SearchStrategy: all) found no beans (OnBeanCondition)

   DataSourceAutoConfiguration.JdbcTemplateConfiguration#namedParameterJdbcTemplate matched
  - @ConditionalOnMissingBean (types: org.springframework.jdbc.core.namedparam.NamedParameterJdbcOperations; SearchStrategy: all) found no beans (OnBeanCondition)

   DataSourceTransactionManagerAutoConfiguration matched
  - @ConditionalOnClass classes found: org.springframework.jdbc.core.JdbcTemplate,org.springframework.transaction.PlatformTransactionManager (OnClassCondition)

   DataSourceTransactionManagerAutoConfiguration.TransactionManagementConfiguration matched
  - @ConditionalOnMissingBean (types: org.springframework.transaction.annotation.AbstractTransactionManagementConfiguration; SearchStrategy: all) found no beans (OnBeanCondition)

    H2ConsoleAutoConfiguration matched
  - @ConditionalOnClass classes found: org.h2.server.web.WebServlet (OnClassCondition)
  - found web application StandardServletEnvironment (OnWebApplicationCondition)
  - matched (OnPropertyCondition)

   HibernateJpaAutoConfiguration matched
  - @ConditionalOnClass classes found: org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean,org.springframework.transaction.annotation.EnableTransactionManagement,javax.persistence.EntityManager (OnClassCondition)
  - found HibernateEntityManager class (HibernateJpaAutoConfiguration.HibernateEntityManagerCondition)

Negative matches:
-----------------

    DataSourceAutoConfiguration.NonEmbeddedConfiguration did not match
  - missing supported DataSource (DataSourceAutoConfiguration.NonEmbeddedDataSourceCondition)

``

ACTUALIZACIÓN 2: se agregó un actuador y se examinó el punto final /configprops . Lo interesante aquí es que mi configuración ha sido tomada y la base de datos existe pero cuando la aplicación se ejecuta no utiliza esta dataSource .

"spring.datasource.CONFIGURATION_PROPERTIES":
    {"prefix":"spring.datasource",
     "properties":{
        "schema":null,
        "data":null,
        "xa":{"dataSourceClassName":null,
               "properties":{}
             },
        "type":null,
        "separator":";",
        "url":"jdbc:h2:file:~/test;DB_CLOSE_ON_EXIT=FALSE",
        "platform":"all",
        "continueOnError":false,
        "jndiName":null,               
        "sqlScriptEncoding":null,
        "password":"******",
        "name":"testdb",
        "driverClassName":"org.h2.Driver",
        "initialize":true,
        "username":"test"
        }
    }  

Answer 1

Acabo de generar un nuevo proyecto Spring Boot con start.spring.io con algunas dependencias h2, JPA, web, devtools, actuator . Después de agregar un repositorio simple de Entity y Spring Data, la base de datos se crea en la memoria de manera predeterminada.

Agregar lo siguiente a mi application.properties definitivamente crea el archivo de base de datos en el lugar correcto:

spring.datasource.url=jdbc:h2:file:~/test;DB_CLOSE_ON_EXIT=FALSE
spring.datasource.username=test
spring.datasource.password=test
spring.datasource.driverClassName=org.h2.Driver

Incluso puedo conectarme a él con la consola H2 cuando devtools está habilitado http://localhost:8080/h2-console/ .

El siguiente paso lógico es visitar el punto final http://localhost:8080/autoconfig y verificar el estado de la configuración automática.

En mi caso, lo siguiente es positiveMatches :

DataSourceAutoConfiguration.NonEmbeddedConfiguration: [
{
  condition: "DataSourceAutoConfiguration.NonEmbeddedDataSourceCondition",
  message: "supported DataSource class found"
},
{
  condition: "OnBeanCondition",
  message: "@ConditionalOnMissingBean (types: javax.sql.DataSource,javax.sql.XADataSource; SearchStrategy: all) found no beans"
}
],

y lo siguiente en negativeMatches :

DataSourceAutoConfiguration.EmbeddedConfiguration: [
{
  condition: "DataSourceAutoConfiguration.EmbeddedDataSourceCondition",
  message: "existing non-embedded database detected"
}
],

¿Podría intentar lo siguiente y verificar el informe de configuración automática para esos?

Answer 2

Consulte http://www.h2database.com/html/cheatSheet.html

Supongo que podría ser un problema con el jdbc.url, cámbielo de esta manera:

# from:
spring.datasource.url=jdbc:h2:file:~/test;DB_CLOSE_ON_EXIT=FALSE

# to:
spring.datasource.url=jdbc:h2:~/test;DB_CLOSE_ON_EXIT=FALSE

Answer 3

Cree un archivo .h2.server.properties en su ruta de clase y coloque debajo de las cosas e intente nuevamente. Puede crear este archivo en la carpeta de recursos.

#H2 Server Properties
0=H2 File|org.h2.Driver|jdbc/:h2/:file/:~/test;DB_CLOSE_ON_EXIT=FALSE

# Enable if you want other applications to connect
#webAllowOthers=true
#webPort=8082
#webSSL=false

Answer 4

Estoy agregando esta respuesta para evitar confusiones y futuras investigaciones.

En realidad, tengo el mismo problema y ninguna de las respuestas funcionó para mí por completo, en lugar de que la combinación de algunas respuestas funcionó.

Aquí está la configuración mínima que se requiere para persistir H2 db en el arranque de primavera.

application.properties

# H2
spring.h2.console.enabled=true
spring.h2.console.path=/h2
# Datasource
spring.datasource.url=jdbc:h2:file:~/spring-boot-h2-db
spring.datasource.username=sa
spring.datasource.password=
spring.datasource.driver-class-name=org.h2.Driver
spring.jpa.hibernate.ddl-auto=update

Aquí spring.jpa.hibernate.ddl-auto=update hace el truco. No se requiere nada más.

No es necesario agregar spring-boot-starter-jdbc en pom.xml

No es necesario agregar ningún parámetro en la URL de jdbc.

Answer 5

Utilizando la siguiente configuración en application.properties, logro mantener los datos persistentes incluso después de apagar y reiniciar SpringBoot, e incluso después de reiniciar la computadora.

spring.datasource.name=japodb
spring.datasource.initialize=false
spring.datasource.driverClassName=org.h2.Driver

spring.datasource.url=jdbc:h2:file:~/japodb;DB_CLOSE_ON_EXIT=FALSE;IFEXISTS=TRUE;DB_CLOSE_DELAY=-1;

No cierre una base de datos cuando la máquina virtual salga , sí, pero tampoco cree una nueva base de datos si ya está allí.

jdbc:h2:<url>;IFEXISTS=TRUE

spring.jpa.hibernate.ddl-auto = update