TOC

Integrando o Spring Boot ao HSQLDB

Integrando o Spring Boot ao HSQLDB

1. Visão geral

Spring Boot torna realmente fácil trabalhar com diferentes sistemas de banco de dados, sem o incômodo do gerenciamento manual de dependências.

Mais especificamente, oSpring Data JPA starter fornece toda a funcionalidade necessária para uma integração perfeita com várias implementações deDataSource. **

Neste tutorial,we’ll learn how to integrate Spring Boot with HSQLDB.

2. As dependências do Maven

Para demonstrar como é fácil integrar Spring Boot com HSQLDB,we’ll create a simple JPA repository layer that performs CRUD operations on customers entities using an in-memory HSQLDB  database.

Aqui está oSpring Boot starter que usaremos para colocar nossa camada de repositório de amostra em funcionamento: 


    org.springframework.boot
    spring-boot-starter-data-jpa
    2.1.1.RELEASE


    org.hsqldb
    hsqldb
    2.4.0
    runtime

Observe que incluímos a dependênciaHSQLDB também. Sem ele, o Spring Boot tentará configurar automaticamente um beanDataSource e um pool de conexão JDBC para nós por meio deHikariCP.

Como consequência,if we don’t specify a valid DataSource dependency in our pom.xml file, we’ll get a build failure.

Além disso, vamos verificar a versão mais recente despring-boot-starter-data-jpa no Maven Central.

3. Conectando-se a um banco de dados HSQLDB

Para exercitar nossa camada de repositório de demonstração, usaremos um banco de dados na memória. É possível, no entanto, trabalhar com bancos de dados baseados em arquivos também. Exploraremos cada um desses métodos nas seções abaixo.

3.1. Executando um Servidor HSQLDB Externo

Vamos dar uma olhada em como fazer um servidor HSQLDB externo rodar e criar um banco de dados baseado em arquivo. Instalar o HSQLDB e executar o servidor é direto, em geral.

Aqui estão os passos que devemos seguir:

  • Primeiro, vamosdownload HSQLDBe descompactamos em uma pasta

  • Como o HSQLDB não fornece um banco de dados padrão pronto para uso, criaremos um chamado“testdb” para fins de exemplo

  • Vamos lançar um prompt de comando e navegar até a pasta HSQLDBdata

  • Na pastadata, executaremos o seguinte comando: 

    java -cp ../lib/hsqldb.jar org.hsqldb.server.Server --database.0 file.testdb --dbname0.testdb

  • O comando acima irá iniciar o servidor HSQLDB e criar nosso banco de dados cujos arquivos de origem serão armazenados na pastadata

  • Podemos ter certeza de que o banco de dados foi realmente criado indo para a pastadata, que deve conter um conjunto de arquivos chamados“testdb.lck”,“testdb.log”,“testdb.properties” e“testdb.script” (o número de arquivos varia dependendo do tipo de banco de dados que estamos criando)

Uma vez que o banco de dados foi configurado, precisamos criar uma conexão com ele.

To do this on Windows, vamos para a pasta do banco de dadosbin e execute o arquivorunManagerSwing.bat. Isso abrirá a tela inicial do HSQLDB Database Manager, onde podemos inserir as credenciais de conexão:

  • Type: Mecanismo de banco de dados HSQL

  • URL: jdbc:hsqldb:hsql://localhost/testdb

  • User: “SA” (Administrador do sistema)

  • Password: deixe o campo vazio

On Linux/Unix/Mac, podemos usar NetBeans, Eclipse ou IntelliJ IDEA para criar a conexão do banco de dados por meio das ferramentas visuais do IDE, usando as mesmas credenciais.

Em qualquer uma dessas ferramentas, é simples criar uma tabela de banco de dados executando um script SQL no Database Manager ou no IDE.

Uma vez conectado, podemos criar uma tabelacustomers: 

CREATE TABLE customers (
   id INT  NOT NULL,
   name VARCHAR (45),
   email VARCHAR (45),
   PRIMARY KEY (ID)
);

Em apenas algumas etapas fáceis, criamos um banco de dados HSQLDB baseado em arquivo contendo uma tabelacustomers.

3.2. O arquivoapplication.properties

Se desejarmos conectar ao banco de dados anterior baseado em arquivo do Spring Boot, aqui estão as configurações que devemos incluir no arquivoapplication.properties: 

spring.datasource.driver-class-name=org.hsqldb.jdbc.JDBCDriver
spring.datasource.url=jdbc:hsqldb:hsql://localhost/testdb
spring.datasource.username=sa
spring.datasource.password=
spring.jpa.hibernate.ddl-auto=update

Como alternativa, se usarmos um banco de dados na memória, devemos usar estes: 

spring.datasource.driver-class-name=org.hsqldb.jdbc.JDBCDriver
spring.datasource.url=jdbc:hsqldb:mem:testdb;DB_CLOSE_DELAY=-1
spring.datasource.username=sa
spring.datasource.password=
spring.jpa.hibernate.ddl-auto=create

Observe o parâmetroDB_CLOSE_DELAY=-1 anexado ao final do URL do banco de dados. Ao trabalhar com um banco de dados na memória, precisamos especificar isso,so the JPA implementation, which is Hibernate, won’t close the database while the application is running.

4. A EntidadeCustomer

Com as configurações de conexão do banco de dados já configuradas, a seguir precisamos definir nossa entidadeCustomer: 

@Entity
@Table(name = "customers")
public class Customer {

    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    private long id;

    private String name;

    private String email;

    // standard constructors / setters / getters / toString
}

5. O repositórioCustomer

Além disso, precisamos implementar uma camada de persistência fina, que nos permite ter a funcionalidade CRUD básica em nossas entidadesCustomer JPA.

Podemos implementar facilmente essa camada apenas estendendo a interfaceCrudRepository: 

@Repository
public interface CustomerRepository extends CrudRepository {}

6. Testando o RepositórioCustomer

Por fim, devemos garantir que o Spring Boot possa realmente se conectar ao HSQLDB. Podemos fazer isso facilmente testando a camada do repositório.

Vamos começar a testar os métodosfindById()efindAll() do repositório: 

@RunWith(SpringRunner.class)
@SpringBootTest
public class CustomerRepositoryTest {

    @Autowired
    private CustomerRepository customerRepository;

    @Test
    public void whenFindingCustomerById_thenCorrect() {
        customerRepository.save(new Customer("John", "[email protected]"));
        assertThat(customerRepository.findById(1L)).isInstanceOf(Optional.class);
    }

    @Test
    public void whenFindingAllCustomers_thenCorrect() {
        customerRepository.save(new Customer("John", "[email protected]"));
        customerRepository.save(new Customer("Julie", "[email protected]"));
        assertThat(customerRepository.findAll()).isInstanceOf(List.class);
    }
}

Finalmente, vamos testar o métodosave(): 

@Test
public void whenSavingCustomer_thenCorrect() {
    customerRepository.save(new Customer("Bob", "[email protected]"));
    Customer customer = customerRepository.findById(1L).orElseGet(()
      -> new Customer("john", "[email protected]"));
    assertThat(customer.getName()).isEqualTo("Bob");
}

7. Conclusão

Neste artigo,we learned how to integrate Spring Boot with HSQLDB,e como usar um banco de dados baseado em arquivo ou na memória no desenvolvimento de uma camada de repositório JPA básica.

Como de costume, todos os exemplos de código mostrados neste artigo estão disponíveis emGitHub.

Related