Qual é o banco de dados na memória

O banco de dados na memória depende da memória do sistema em oposição ao espaço em disco para armazenamento de dados. Porque o acesso à memória é mais rápido que o acesso ao disco. Usamos o banco de dados na memória quando não precisamos persistir os dados. O banco de dados na memória é um banco de dados incorporado. Os bancos de dados na memória são voláteis, por padrão, e todos os dados armazenados são perdidos quando reiniciamos o aplicativo.

Os bancos de dados em memória amplamente usados ​​são H2, HSQLDB (banco de dados hiperSQL) , e Apache Derby. Ele cria a configuração automaticamente.

Persistência vs. banco de dados na memória

O banco de dados persistente persiste os dados na memória física. Os dados estarão disponíveis mesmo se o servidor de banco de dados for devolvido. Alguns bancos de dados de persistência populares são Oráculo, MySQL , Postgres , etc.

uma matriz em java

No caso do banco de dados na memória, armazenamento de dados no memoria do sistema . Perdeu os dados quando o programa foi fechado. É útil para PEQUENO s (Prova de Conceitos), não para um aplicativo de produção. O banco de dados na memória amplamente utilizado é H2.

O que é o banco de dados H2

H2 é um incorporado, de código aberto, e em memória base de dados. É um sistema de gerenciamento de banco de dados relacional escrito em Java . É um servidor cliente aplicativo. Geralmente é usado em teste unitário . Ele armazena dados na memória, não persiste os dados no disco.

Vantagens

• Configuração zero
• É fácil de usar.
• É leve e rápido.
• Ele fornece configuração simples para alternar entre um banco de dados real e um banco de dados na memória.
• Ele suporta SQL padrão e API JDBC.
• Ele fornece um console web para manter no banco de dados.

Configurar banco de dados H2

Se quisermos usar o banco de dados H2 em uma aplicação, precisamos adicionar a seguinte dependência no arquivo pom.xml:

 com.h2database h2 runtime 

Depois de adicionar a dependência, precisamos configurar URL da fonte de dados, nome da classe do driver, nome de usuário, e senha do banco de dados H2. Spring Boot fornece uma maneira fácil de configurar essas propriedades em aplicação.propriedades arquivo.

 spring.datasource.url=jdbc:h2:mem:testdb spring.datasource.driverClassName=org.h2.Driver spring.datasource.username=sa spring.datasource.password= spring.jpa.database-platform=org.hibernate.dialect.H2Dialect 

No primavera.datasource.url propriedade, mem é o nome de um banco de dados na memória e banco de teste é o nome do esquema que H2 fornece, por padrão. Também podemos definir nosso próprio esquema e banco de dados. O nome de usuário padrão é sobre e a senha em branco denota um vazio senha. Se quisermos alterar o nome de usuário e a senha, podemos substituir esses valores.

Persistir os dados no banco de dados H2

Se quisermos persistir os dados no banco de dados H2, devemos armazenar os dados em um arquivo. Para conseguir o mesmo, precisamos alterar a propriedade URL da fonte de dados.

 #persist the data spring.datasource.url=jdbc:h2:file:/data/sampledata spring.datasource.url=jdbc:h2:C:/data/sampledata 

Na propriedade acima, o dados de amostra é um nome de arquivo.

Criar esquema e preencher dados

Podemos definir o esquema criando um SQL arquivo no recurso pasta (src/principal/recurso).

esquema.sql

 DROP TABLE IF EXISTS CITY; CREATE TABLE CITY ( City_code INT AUTO_INCREMENT PRIMARY KEY, city_name VARCHAR(50) NOT NULL, city_pincode INT(8) NOT NULL ); 

Podemos preencher os dados na tabela criando um SQL arquivo no recurso pasta (src/principal/recurso).

dados.sql

 INSERT INTO CITY VALUES (11, 'Delhi', 110001); INSERT INTO CITY VALUES (12, 'Kanpur', 208001); INSERT INTO CITY VALUES (13, 'Lucknow', 226001); 

Spring Boot pega automaticamente o dados.sql arquivo e executá-lo no banco de dados H2 durante a inicialização do aplicativo.

Consola H2

Por padrão, a visualização do console do banco de dados H2 está desabilitada. Antes de acessar o banco de dados H2, devemos habilitá-lo usando a seguinte propriedade.

 #enabling the H2 console spring.h2.console.enabled=true 

Depois de habilitar o console H2, agora podemos acessá-lo no navegador invocando a URL http://localhost:8080/h2-console. A figura a seguir mostra a visualização do console do banco de dados H2.

Na captura de tela acima, definimos nosso próprio banco de dados denominado ponto java .

Exemplo de inicialização Spring H2

Vamos configurar uma aplicação Spring Boot com o banco de dados H2.

Passo 1: Abra o Spring Initializr http://start.spring.io.

Passo 2: Selecione a versão do Spring Boot 2.3.0.M1.

Passo 2: Proporciona a Grupo nome. Nós fornecemos com.javatpoint.

Etapa 3: Proporciona a Artefato Eu ia. Nós fornecemos exemplo de banco de dados spring-boot-h2.

Etapa 5: Adicione as dependências Spring Web, Spring Data JPA, e Banco de dados H2.

Etapa 6: Clique no Gerar botão. Quando clicamos no botão Gerar, ele envolve o projeto em um Jarra arquivo e baixa-o para o sistema local.

Etapa 7: Extrair o arquivo Jar e cole-o no espaço de trabalho STS.

Etapa 8: Importar a pasta do projeto no STS.

Arquivo -> Importar -> Projetos Maven Existentes -> Navegar -> Selecione a pasta spring-boot-h2-database-example -> Concluir

Demora algum tempo para importar.

Etapa 9: Crie um pacote com o nome com.javatpoint.model na pasta src/main/java.

Etapa 10: Crie uma classe de modelo no pacote com.javatpoint.model. Criamos uma classe de modelo com o nome Estudante. Na classe Livros, fizemos o seguinte:

• Defina quatro variáveis id, idade, nome, e
• Gere getters e setters.
  Clique com o botão direito no arquivo -> Fonte -> Gerar Getters e Setters.
• Marcar a turma como Entidade usando a anotação @Entidade.
• Marcar a turma como Mesa nome usando a anotação @Mesa.
• Defina cada variável como Coluna usando a anotação @Coluna.

Aluno.java

quantos MB tem um GB

 package com.javatpoint.model; import javax.persistence.Column; import javax.persistence.Entity; import javax.persistence.Id; import javax.persistence.Table; //mark class as an Entity @Entity //defining class name as Table name @Table public class Student { //mark id as primary key @Id //defining id as column name @Column private int id; //defining name as column name @Column private String name; //defining age as column name @Column private int age; //defining email as column name @Column private String email; public int getId() { return id; } public void setId(int id) { this.id = id; } public String getName() { return name; } public void setName(String name) { this.name = name; } public int getAge() { return age; } public void setAge(int age) { this.age = age; } public String getEmail() { return email; } public void setEmail(String email) { this.email = email; } } 

Etapa 11: Crie um pacote com o nome com.javatpoint.controller na pasta src/main/java.

Etapa 12: Crie uma classe Controller no pacote com.javatpoint.controller . Criamos uma classe de controlador com o nome Controlador de Aluno . Na classe StudentController, fizemos o seguinte:

• Marcar a turma como RestController usando a anotação @RestController.
• Conectar automaticamente o Serviço Estudantil classe usando a anotação @Autowired .
• Defina os seguintes métodos:
  getAllStudent():Ele retorna uma lista de todos os alunos.
getAluno():Ele retorna um detalhe do aluno que especificamos na variável path. Passamos id como argumento usando a anotação @PathVariable. A anotação indica que um parâmetro de método deve ser vinculado a uma variável de modelo URI.deletarAluno():Exclui um aluno específico que especificamos na variável path.salvarAluno():Ele salva os detalhes do aluno. A anotação @RequestBody indica que um parâmetro de método deve ser vinculado ao corpo da solicitação web.

StudentController.java

 package com.javatpoint.controller; import java.util.List; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.web.bind.annotation.DeleteMapping; import org.springframework.web.bind.annotation.GetMapping; import org.springframework.web.bind.annotation.PathVariable; import org.springframework.web.bind.annotation.PostMapping; import org.springframework.web.bind.annotation.RequestBody; import org.springframework.web.bind.annotation.RestController; import com.javatpoint.model.Student; import com.javatpoint.service.StudentService; //creating RestController @RestController public class StudentController { //autowired the StudentService class @Autowired StudentService studentService; //creating a get mapping that retrieves all the students detail from the database @GetMapping('/student') private List getAllStudent() { return studentService.getAllStudent(); } //creating a get mapping that retrieves the detail of a specific student @GetMapping('/student/{id}') private Student getStudent(@PathVariable('id') int id) { return studentService.getStudentById(id); } //creating a delete mapping that deletes a specific student @DeleteMapping('/student/{id}') private void deleteStudent(@PathVariable('id') int id) { studentService.delete(id); } //creating post mapping that post the student detail in the database @PostMapping('/student') private int saveStudent(@RequestBody Student student) { studentService.saveOrUpdate(student); return student.getId(); } } 

Etapa 13: Crie um pacote com o nome com.javatpoint.service na pasta src/main/java.

Etapa 14: Criar uma Serviço aula. Criamos uma classe de serviço com o nome Serviço Estudantil Na embalagem com.javatpoint.service.

StudentService.java

 package com.javatpoint.service; import java.util.ArrayList; import java.util.List; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Service; import com.javatpoint.model.Student; import com.javatpoint.repository.StudentRepository; @Service public class StudentService { @Autowired StudentRepository studentRepository; //getting all student records public List getAllStudent() { List students = new ArrayList(); studentRepository.findAll().forEach(student -> students.add(student)); return students; } //getting a specific record public Student getStudentById(int id) { return studentRepository.findById(id).get(); } public void saveOrUpdate(Student student) { studentRepository.save(student); } //deleting a specific record public void delete(int id) { studentRepository.deleteById(id); } } 

Etapa 15: Crie um pacote com o nome com.javatpoint.repository na pasta src/main/java.

Etapa 16: Criar uma Repositório interface. Criamos uma interface de repositório com o nome Repositório de Alunos Na embalagem com.javatpoint.repositório. Ele estende o Repositório Crud interface.

StudentRepository.java

 package com.javatpoint.repository; import org.springframework.data.repository.CrudRepository; import com.javatpoint.model.Student; public interface StudentRepository extends CrudRepository { } 

Agora vamos configurar a fonte de dados URL, nome da classe do driver, nome de usuário, e senha, no aplicação.propriedades arquivo.

Etapa 17: Abra o aplicação.propriedades arquivo e configure as propriedades a seguir.

aplicação.propriedades

 spring.datasource.url=jdbc:h2:mem:javatpoint spring.datasource.driverClassName=org.h2.Driver spring.datasource.username=sa spring.datasource.password= spring.jpa.database-platform=org.hibernate.dialect.H2Dialect #enabling the H2 console spring.h2.console.enabled=true 

Nota: Não esqueça de habilitar o console H2.

Depois de criar todas as classes e pacotes, o diretório do projeto terá a seguinte aparência.

Agora vamos executar o aplicativo.

Etapa 18: Abrir SpringBootH2DatabaseExampleApplication.java arquivo e execute-o como aplicativo Java.

SpringBootH2DatabaseExampleApplication.java

 package com.javatpoint; import org.springframework.boot.SpringApplication; import org.springframework.boot.autoconfigure.SpringBootApplication; @SpringBootApplication public class SpringBootH2DatabaseExampleApplication { public static void main(String[] args) { SpringApplication.run(SpringBootH2DatabaseExampleApplication.class, args); } } 

Na próxima etapa, usaremos o cliente rest Carteiro para enviar o PUBLICAR e PEGAR solicitar . Caso o Postman não esteja instalado em seu sistema, siga os passos abaixo:

• Baixe o Carteiro em https://www.getpostman.com/downloads/ ou adicione a extensão do Google Chrome no navegador https://bit.ly/1HCOCwF .
• Inicie o Postman e Inscrever-se . Crie um nome de usuário. Criamos um usuário com o nome ponto java e clicou em Enviar

Etapa 19: Abra o Carteiro e faça o seguinte:

• Selecione os PUBLICAR
• Invoque a URL http://localhost:8080/student.
• Selecione os Corpo
• Selecione o tipo de conteúdo JSON (aplicativo/json).
• Insira os dados. Inserimos os seguintes dados no corpo:

 { 'id': '001', 'age': '23', 'name': 'Amit', 'email': '[email protected]' } 

• Clique no Enviar

Quando a solicitação é executada com sucesso, ele mostra o Estado: 200 OK . Significa que o registro foi inserido com sucesso no banco de dados.

Da mesma forma, inserimos os seguintes dados.

bater senão se

 { 'id': '002', 'age': '24', 'name': 'Vadik', 'email': '[email protected]' } { 'id': '003', 'age': '21', 'name': 'Prateek', 'email': '[email protected]' } { 'id': '004', 'age': '25', 'name': 'Harsh', 'email': '[email protected]' } { 'id': '005', 'age': '24', 'name': 'Swarit', 'email': '[email protected]' } 

Vamos acessar o console H2 para ver os dados.

Etapa 20: Abra o navegador e invoque a URL http://localhost:8080/h2-console. Clique no Conectar botão, conforme mostrado abaixo.

Depois de clicar no Conectar botão, vemos o Estudante tabela no banco de dados, conforme mostrado abaixo.

Etapa 21: Clique no Estudante tabela e clique no botão Correr botão. A tabela mostra os dados que inserimos no corpo.

Etapa 22: Abra o Postman e envie um PEGAR solicitar. Ele retorna os dados que inserimos no banco de dados.

Vamos enviar um PEGAR solicitação com o URL http://localhost:8080/student/{id}. Invocamos a URL http://localhost:8080/student/3. Retorna o detalhe do aluno cujo id é 3.

Da mesma forma, também podemos enviar um EXCLUIR solicitar. Suponha que queiramos excluir um registro de aluno cujo id seja 2.

Para excluir um registro de aluno, envie um EXCLUIR solicitação com a URL http://localhost:8080/student/2. Vemos que o aluno cujo id é 2 foi excluído do banco de dados.