Acesse o mesmo banco de dados H2 na memória em vários aplicativos de inicialização Spring
1. Visão geral
Neste tutorial rápido, demonstraremoshow to access the same in-memory H2 database from multiple Spring Boot applications.
Para fazer isso, vamos criar dois aplicativos distintos do Spring Boot. O primeiro aplicativo Spring Boot iniciará uma instância H2 na memória, enquanto o segundo acessará uma instância H2 incorporada do primeiro aplicativo por TCP.
2. fundo
Como sabemos, um banco de dados na memória é mais rápido e costuma ser usado no modo incorporado em um aplicativo. No entanto, o banco de dados na memória não persiste os dados nas reinicializações do servidor.
Para obter informações adicionais, verifique nossos artigos sobrethe most commonly used in-memory databaseseusage of an in-memory database in automated testing.
3. As dependências do Maven
Os dois aplicativos Spring Boot neste artigo exigem as mesmas dependências:
org.springframework.boot
spring-boot-starter-data-jpa
com.h2database
h2
4. Configurando a fonte de dados H2
Em primeiro lugar, vamos definir o componente mais importante - um bean Spring para um banco de dados H2 na memória - e expô-lo por meio de uma porta TCP:
@Bean(initMethod = "start", destroyMethod = "stop")
public Server inMemoryH2DatabaseaServer() throws SQLException {
return Server.createTcpServer(
"-tcp", "-tcpAllowOthers", "-tcpPort", "9090");
}Os métodos definidos pelos parâmetrosinitMethodedestroyMethod são chamados pelo Spring para iniciar e parar o banco de dados H2.
O parâmetro-tcp instrui H2 a usar um servidor TCP para iniciar H2. Especificamos a porta TCP a ser usada no terceiro e quarto parâmetros do métodocreateTcpServer.
O parâmetrotcpAllowOthers abre H2 para acesso de aplicativos externos em execução no mesmo host ou hosts remotos.
A seguir, vamos criaroverride the default data source pelo recurso de configuração automática do Spring Boot adicionando algumas propriedades ao arquivoapplication.properties:
spring.datasource.url=jdbc:h2:mem:mydb
spring.datasource.driverClassName=org.h2.Driver
spring.datasource.username=sa
spring.datasource.password=
spring.jpa.hibernate.ddl-auto=createÉ importante substituir essas propriedades porquewe’ll need to use the same properties and values in the other applications deseja compartilhar o mesmo banco de dados H2.
5. Inicializando o primeiro aplicativo de inicialização do Spring
Em seguida, para inicializar nosso aplicativo Spring Boot, criaremos uma classe com a anotação@SpringBootApplication :
@SpringBootApplication
public class SpringBootApp {
public static void main(String[] args) {
SpringApplication.run(SpringBootApp.class, args);
}
}Para testar se tudo está conectado corretamente, vamos adicionar código para criar alguns dados de teste.
Vamos definir um método denominadoinitDbe anotá-lo com@PostConstruct para que o contêiner Spring automaticamente chame este método assim que a classe principal for inicializada:
@PostConstruct
private void initDb() {
String sqlStatements[] = {
"drop table employees if exists",
"create table employees(id serial,first_name varchar(255),last_name varchar(255))",
"insert into employees(first_name, last_name) values('Eugen','Paraschiv')",
"insert into employees(first_name, last_name) values('Scott','Tiger')"
};
Arrays.asList(sqlStatements).forEach(sql -> {
jdbcTemplate.execute(sql);
});
// Query test data and print results
}6. O segundo aplicativo de inicialização do Spring
Agora vamos dar uma olhada nos componentes do aplicativo cliente, que requer as mesmas dependências Maven definidas acima.
Primeiro, vamos substituir as propriedades da fonte de dados. Precisamosensure that the port number in the JDBC URL is the same as the one on which H2 is listening for incoming connections in the first application.
Aqui está o arquivoapplication.properties do aplicativo cliente:
spring.datasource.url=jdbc:h2:tcp://localhost:9090/mem:mydb
spring.datasource.driverClassName=org.h2.Driver
spring.datasource.username=sa
spring.datasource.password=
spring.jpa.hibernate.ddl-auto=createPor fim, criamos uma classe principal do aplicativo Spring Boot do cliente.
Novamente para simplificar, definimos um método@SpringBootApplication contendoan initDb com o método@PostConstruct annotation:
@SpringBootApplication
public class ClientSpringBootApp {
public static void main(String[] args) {
SpringApplication.run(ClientSpringBootApp.class, args);
}
@PostConstruct
private void initDb() {
String sqlStatements[] = {
"insert into employees(first_name, last_name) values('Donald','Trump')",
"insert into employees(first_name, last_name) values('Barack','Obama')"
};
Arrays.asList(sqlStatements).forEach(sql -> {
jdbcTemplate.execute(sql);
});
// Fetch data using SELECT statement and print results
}
}7. Saída de amostra
Agora, quando executamos os aplicativos um por um, podemos verificar os logs do console e confirmar se o segundo aplicativo imprime os dados conforme o esperado.
Aqui estão osconsole logs of the first Spring Boot application:
****** Creating table: Employees, and Inserting test data ******
drop table employees if exists
create table employees(id serial,first_name varchar(255),last_name varchar(255))
insert into employees(first_name, last_name) values('Eugen','Paraschiv')
insert into employees(first_name, last_name) values('Scott','Tiger')
****** Fetching from table: Employees ******
id:1,first_name:Eugen,last_name:Paraschiv
id:2,first_name:Scott,last_name:TigerE aqui estão osconsole logs of the second Spring Boot application:
****** Inserting more test data in the table: Employees ******
insert into employees(first_name, last_name) values('Donald','Trump')
insert into employees(first_name, last_name) values('Barack','Obama')
****** Fetching from table: Employees ******
id:1,first_name:Eugen,last_name:Paraschiv
id:2,first_name:Scott,last_name:Tiger
id:3,first_name:Donald,last_name:Trump
id:4,first_name:Barack,last_name:Obama8. Conclusão
Neste artigo rápido, vimos como podemosaccess the same in-memory H2 database instance from multiple Spring Boot applications.
Como sempre, exemplos de código de trabalho estão disponíveisover on GitHub.