Banco de dados H2 — prototipagem

A camada de dados geralmente é um elemento central da arquitetura da aplicação. Não apenas durante o desenvolvimento, ao criar algumas amostras e casos de teste, você pode se encontrar na necessidade de algo leve. Em alguns casos, os únicos requisitos para o banco de dados são poder configurá-lo e executá-lo rapidamente sem muito trabalho ou pensamento. Muitas vezes, você nem precisa de nenhum tipo de aplicação de console para acessar os dados. Esse geralmente é o caso ao executar alguns testes automatizados/de integração. No entanto, durante a prototipagem do modelo de dados (inicialização do banco de dados JPA) ou a criação de testes que se baseiam em colunas do banco de dados, eu realmente gosto de ver o que está dentro.

Inicialmente, eu usava bancos de dados autônomos como MySQL ou Oracle DB. Não era muito agradável configurá-los a cada vez em qualquer novo ambiente ou pedir a qualquer outra pessoa para fazê-lo. Mais tarde, ao ouvir sobre o Docker, mudei imediatamente para ele. Foi como uma bênção até certo ponto. No entanto, mais tarde percebi que não precisava de tanto excesso de trabalho quando estava fazendo algum projeto de pequeno porte (ainda não pronto para produção) ou amostras de demonstração. A partir desse ponto, tenho usado diferentes bancos de dados em memória como HSQLDB, Apache Derby, SQLite e H2 Database.

Só recentemente descobri que o H2 Database tem tudo o que preciso para prototipagem e testes. Posso configurá-lo quase instantaneamente junto com o Spring Boot adicionando uma dependência ao arquivo pom:

<dependency>
    <groupId>com.h2database</groupId>
    <artifactId>h2</artifactId>
    <version>1.4.194</version>
</dependency>

Eu seleciono o escopo dependendo do que preciso. Compile — se eu quiser usar algumas ferramentas adicionais da biblioteca. Runtime para uso normal da aplicação (prototipagem). Finalmente, test — para executar testes de integração. Isso me dá a sensação de facilidade. Não preciso pensar em iniciar e configurar o banco de dados — pelo menos neste ponto — já que o Spring Boot cuida disso (JPA starter).

Console e modo em memória

Além disso, o H2 vem com um console de servidor web. Usando o Spring Boot (starters web e JPA), você pode habilitá-lo adicionando spring.h2.console.enabled=true ao seu application.properties. O console web iniciará na porta padrão sob o caminho 'h2-console', por exemplo, http://localhost:8080/h2-console. Supondo que você tenha suas classes de entidade preparadas, você verá suas tabelas inicializadas automaticamente na instância padrão do banco de dados em memória jdbc:h2:mem:testdb.

Não está usando o Spring Boot? Não se preocupe, iniciar os servidores é tão fácil quanto executar org.h2.tools.Server.main(). Em um contexto de servlet, org.h2.server.web.DbStarter também pode ser útil. Para uma explicação detalhada, consulte a documentação. Há também uma seção avançada que contém informações sobre o uso do banco de dados em outras estruturas/linguagens (.NET). Uma conexão manual com o banco de dados junto com o início do servidor web em Java padrão pode ser feita com o seguinte código:

Connection connection = DriverManager.getConnection("jdbc:h2:mem:testdb", "sa", "");
Statement statement = connection.createStatement();
if(statement.execute("Select * from dual")) {
    System.out.println("Successfully connected to the jdbc:h2:mem:testdb");
}
Server.startWebServer(connection);

Isso também deve iniciar e abrir o console no seu navegador web em alguma porta aleatória.

Modo servidor

Outro caso útil que você pode considerar é conectar-se ao banco de dados de fora da aplicação, de um processo/host diferente. Isso geralmente é um pouco difícil, pois o banco de dados está sendo executado em memória. Por padrão, o banco de dados pode ser acessado dentro da mesma máquina virtual e carregador de classes. No entanto, também é possível expô-lo usando o servidor TCP graças às ferramentas do H2. Um bean exemplar no Spring, responsável por criar, iniciar e parar o servidor, pode ser definido da seguinte forma:

@Bean(initMethod = "start", destroyMethod = "stop")
public Server inMemoryH2DatabaseServer() throws SQLException {
    return Server.createTcpServer("-tcp", "-tcpAllowOthers", "-tcpPort", "9090");
}

Agora, o banco de dados pode ser acessado na porta 9090, usando o driver jdbc (org.h2.Driver) no caminho jdbc:h2:tcp://localhost:9090/mem:testdb. Com isso, é possível conectar-se ao banco de dados de uma aplicação diferente, por exemplo, do JMeter, para verificar os dados ou executar testes de carga. Para usar a classe org.h2.tools.Server, você precisa adicionar a dependência do H2 com escopo de compilação (padrão). Isso é o chamado Modo Servidor.

Modo embarcado

Por último, também é possível configurar o H2 para ser executado no modo embarcado. Desta forma, seus dados serão mantidos em um arquivo e persistirão ao longo das execuções da aplicação. A configuração no Spring Boot é direta — defina o caminho para o arquivo do banco de dados no application.properties:

spring.datasource.url=jdbc:h2:./testdb
spring.jpa.hibernate.ddl-auto=update

Temos que usar spring.jpa.hibernate.ddl-auto=update para sobrescrever o padrão valor create-drop. Você pode até combinar esses modos e usar um para "produção" e o outro para executar testes. É tão fácil quanto criar um arquivo properties separado no diretório test/resources.

Note que, por melhor que qualquer abordagem possa parecer, ela sempre vem com algumas vantagens e desvantagens, e é por isso que cabe sempre à pessoa escolher a ferramenta e decidir o que sacrificar em troca (talvez nada, dependendo do caso de uso). Saúde!