English | 简体中文 | 繁體中文 | Русский язык | Français | Español | Português | Deutsch | 日本語 | 한국어 | Italiano | بالعربية

Tutoriais do SpringBoot

Ferramentas online2数据库

SpringBoot H

O que são bancos de dados em memória

Bancos de dados em memória dependem da memória do sistema em vez do espaço de armazenamento de dados em disco. Porque o acesso à memória é mais rápido do que o acesso ao disco. Quando não precisamos de dados persistentes, usamos bancos de dados em memória. Bancos de dados em memória são bancos de dados embarcados. Por padrão, os bancos de dados em memória são voláteis, todos os dados armazenados serão perdidos quando reiniciarmos o aplicativo. H2, HSQLDB (Banco de dados HyperSQL) ,E Apache Derby. Ele cria automaticamente a configuração.

Persistência e bancos de dados em memória

Bancos de dados persistentes armazenam dados de forma persistente na memória física. Mesmo que o servidor do banco de dados volte, os dados estarão disponíveis. Alguns bancos de dados persistentes populares são Oracle, MySQL, Postgres,etc.

No que se refere a 内存数据库，数据存储在 系统内存中。程序关闭时丢失了数据。它对 POC (概念证明)很有帮助，而不对生产应用程序有用。广泛使用的内存数据库是 H2.

什么是H2数据库

H2 是 嵌入式，开源E 内存数据库。它是用 Java 编写的关系数据库管理系统。这是一个 客户端/服务器应用程序。它通常用于 单元测试。它将数据存储在内存中，而不是将数据持久存储在磁盘上。

优点

零配置 易于使用。 轻巧，快速。 它提供了简单的配置，可以在真实数据库和内存数据库之间切换。 它支持标准的SQL和JDBC API。 它提供了一个可在数据库中维护的Web控制台。

配置H2数据库

如果要在应用程序中使用H2数据库，则需要在pom.xml文件中添加以下依赖项:

<dependency>
<groupId>com.h2database</groupId>
<artifactId>h2</artifactId>
<scope>runtime</scope>
</dependency>

添加依赖项后，我们需要配置H2数据库的 数据源URL，驱动程序类名称，用户名E Senha。 Spring Boot提供了一种简单的方法来配置 application.properties 文件中的这些属性。

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.H2Dialeto

在 spring.datasource.url 属性中， mem 是内存数据库的名称，而 testdb 是内存数据库的名称。默认情况下，H2提供的架构。我们还可以定义自己的架构和数据库。默认用户名是 sa ，空白密码表示 空密码。如果要更改用户名和密码，可以覆盖这些值。

将数据保留在H2数据库中

如果要将数据保留在在H2数据库中，我们应该将数据存储在一个文件中。为此，我们需要更改数据源的 URL 属性。

#保存数据
spring.datasource.url=jdbc:h2:file:/data/sampledata
spring.datasource.url=jdbc:h2:C:/data/sampledata

在上面的属性中， sampledata 是一个文件名。

创建Schema构并填充数据

我们可以定义通过在 resource 文件夹(src)中创建 SQL 文件创建架构/src/resource)。

schema.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,
);

We can create a folder by resource folder (src/src/resource) to create a SQL File to fill data in the table.

data.sql 

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

Spring Boot automatically picks up data.sql File and target H2database runs it.

H2console is disabled

By default, H2database console view. When accessing H2database, we must use the following properties to enable it.

#Ativar H2
consolespring.h2.console.enabled=true

Before enabling H2Now we can access the console by calling the URL http://localhost:8080/h2-console accessible in the browser.2Console. The following figure shows H2database console.

In the above screenshot, we defined a console view named w3codebox database.

Spring Boot H2Exemplo

Let's set up a Spring Boot.

Passos1: Open Spring Initializr http://start.spring.io .

Passos2: Select the Spring Boot version 2.3.0.M1.

Passos2: Provide GroupName. We provided interface.3codebox.

Passos3: Provide Artifact ID. We provided spring-boot-h2-database-example.

Passos5: Add dependencies Spring Web, Spring Data JPA ,E H2database.

Passos6: Clique em Generate (Generate) button. When we click the 'Generate' button, it will package the project in Jar the file and download it to the local system.

Passos7: Extract Jar file and paste it into the STS workspace.

The8Step: ImportProject folder to STS.

File-> Import-> Existing Maven project-> Browse-> Select folder spring-boot-h2-database-example-> Completed

Importing takes some time.

Passos9: na pasta/src/the name in the java folder interface.3codebox.model .

Passos10: package interface.3in the codebox.model. We created a class named The Student class. In the 'Book' class, we performed the following operations:

Define four variables id, age, nameE Generate Getter and Setters.
Clique com o botão direito no arquivo-> Fonte-> Gerar Getters e Setters. Uso de anotações @EntityMarque a classe como Entity . Uso de anotações @TableMarque esta classe como Table nomes. usando anotações @Column Defina cada variável como Column .

Student.java 

package com.w3codebox.model;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.Table;
//Marque a classe como entidade
@Entity
//Defina o nome da classe como o nome da tabela
@Table
public class Student　
{
　　　　//Marque id como chave primária
　　　　@Id
　　　　//Defina id como o nome da coluna
　　　　@Column
　　　　private int id;
　　　　//Defina name como o nome da coluna
　　　　@Column
　　　　private String name;
　　　　//Defina a idade age como o nome da coluna
　　　　@Column
　　　　private int age;
　　　　//Defina email como o nome da coluna
　　　　@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;
　　　　}
}

Passos11: studentRepository.deleteById(id); na pasta/src/main interface.3codebox.controller codebox.repository 　

Passos12: No pacote 　 interface.3codebox.controller Crie uma classe Controller no. 　 StudentController Classe controladora. No StudentController, realizamos as seguintes operações:Uso de anotações @RestController marca a classe como RestController . Uso de anotações @Autowired Anotação automática StudentService Classe. Definir os seguintes métodos: getAllStudent(): ele retornará a lista de todos os alunos. getStudent(): ele retornará os detalhes do aluno especificado no parâmetro de caminho. Usando a anotação @PathVariable, passamos o id como parâmetro. A anotação indica que o parâmetro do método deve ser vinculado ao template de URI. deleteStudent(): ele deletará o aluno específico especificado no parâmetro de caminho. saveStudent(): ele armazena os detalhes do aluno. A anotação @RequestBody indica que o parâmetro do método deve ser vinculado ao corpo da solicitação da Web.

StudentController.java 

package com.w3codebox.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.w3codebox.model.Student;
import com.w3codebox.service.StudentService;
//criando RestController
@RestController
public class StudentController　
{
　　　　//injetar automaticamente a classe StudentService
　　　　@Autowired
　　　　StudentService studentService;
　　　　//criar mapeamento GET para检索数据库中所有学生的详细信息
　　　　@GetMapping("/student)
　　　　private List<Student> getAllStudent()　
　　　　{
　　　　　　　　return studentService.getAllStudent();
　　　　}
　　　　//criar mapeamento GET para检索特定学生的详细信息
　　　　@GetMapping("/student/{id}")
　　　　private Student getStudent(@PathVariable("id") int id)　
　　　　{
　　　　　　　　return studentService.getStudentById(id);
　　　　}
　　　　//Criar mapeamento de exclusão para deletar um estudante específico
　　　　@DeleteMapping("/student/{id}")
　　　　private void deleteStudent(@PathVariable("id") int id)　
　　　　{
　　　　　　　　studentService.delete(id);
　　　　}
　　　　//Criar mapeamento POST para publicar detalhes do estudante no banco de dados
　　　　@PostMapping("/student)
　　　　private int saveStudent(@RequestBody Student student)　
　　　　{
　　　　studentService.saveOrUpdate(student);
　　　　return student.getId();
　　　　}
}

Passos13: studentRepository.deleteById(id); 　 na pasta/src/no pacote interface.3codebox.service codebox.repository

Passos14: pacote. 　 Service Criamos a classe 　 interface.3codebox.service。

StudentService.java foi criado o nome 　 StudentService classe de serviço.

package com.w3codebox.service;
import java.util.ArrayList;
import java.util.List;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import com.w3codebox.model.Student;
import com.w3codebox.repository.StudentRepository;
@Service
public class StudentService　
{
　　　　@Autowired
　　　　StudentRepository studentRepository;
　　　　//Obter todos os registros de estudantes
　　　　public List<Student> getAllStudent()　
　　　　{
　　　　List<Student> students = new ArrayList<Student>();
　　　　studentRepository.findAll().forEach(student　-> students.add(student));
　　　　return students;
　　　　}
　　　　//Obter registro específico
　　　　public　Student　getStudentById(int　id)　
　　　　{
　　　　public Student getStudentById(int id)
　　　　}
　　　　return studentRepository.findById(id).get();　
　　　　{
　　　　public void saveOrUpdate(Student student)
　　　　}
　　　　//studentRepository.save(student);
　　　　excluir um registro específico　
　　　　{
　　　　public void delete(int id)
　　　　}
}

Passos15: studentRepository.deleteById(id); 　 na pasta/src/main interface.3em criar um com o nome codebox.repository

Passos16: pacote. 　criar umRepositório 　 interface.3codebox.repository dentro do pacote foi criado com o nome StudentRepository ele estende a interface de repositório. 　 Crud Repository interface.

StudentRepository.java 

package com.w3codebox.repository;
import org.springframework.data.repository.CrudRepository;
import com.w3codebox.model.Student;
public interface StudentRepository extends CrudRepository<Student, Integer>
{
}
　

Agora, vamos em 　 application.properties Configurar o provedor de dados no arquivo 　 URL, nome da classe do driver, nome do usuárioE 　Senha.

Passos17: Abra 　 application.properties Arquivo e configure as seguintes propriedades.

application.properties 

spring.datasource.url=jdbc:h2:mem:w3codebox
spring.datasource.driverClassName=org.h2.Driver
spring.datasource.username=sa
spring.datasource.password=
spring.jpa.database-platform=org.hibernate.dialect.H2Dialeto
#Ativar H2
consolespring.h2.console.enabled=true
Atenção: Não se esqueça de ativar o H2Console.

Após criar todas as classes e pacotes, o diretório do projeto é como mostrado a seguir.

Agora, vamos executar o aplicativo.

Passos18: Abra 　 SpringBootH2DatabaseExampleApplication.java Arquivo e execute-o como aplicativo Java.

SpringBootH2DatabaseExampleApplication.java 

package com.w3codebox;
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 resto dos clientes 　PostmanEnviar 　 POST E 　 GET Solicitação 　. Se o Postman não estiver instalado no seu sistema, execute os seguintes passos:

de https://www.getpostman.com/downloads/ou no navegador https://bit.ly/1HCOCwF adicione a extensão do Google Chrome. bit.ly Inicie o Postman eRegistrarCrie um nome de usuário. Já criamos um nome chamado w3codebox do usuário, e clicou em Enviar

Passos19: Abra 　PostmanE execute as seguintes ações:

Selecione POST Chame a URL http: //localhost: 8080/estudante. SelecioneCorpo Selecione o tipo de conteúdo JSON(aplicação/json). Inserir dados. Inserimos os seguintes dados no corpo: 
{
　　　　"id": "001",
　　　　"age": ""23",
　　　　"name": "Amit",
　　　　"email": "[email protected]"
}
CliqueEnviar

Após a execução bem-sucedida da solicitação, ele mostrará 　Estado: 200 OK Isso significa que o registro foi inserido com sucesso no banco de dados.

Da mesma forma, inserimos os seguintes dados.

{"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 H2Console para ver os dados.

Passos20: Abra o navegador e chame a URL http://localhost:8080/h2-console. Clique em 　 Conectar Como mostrado a seguir.

Clique em 　Botão de ConexãoBotão, veremos no banco de dados 　StudentNa tabela, conforme mostrado a seguir.

Passos21: Clique em 　StudentNa tabela, clique em 　ExecutarBotão. A tabela mostra os dados que inserimos no corpo.

Passos22: Abra o Postman e envie 　 GET Solicitação. Ele retorna os dados que já inserimos no banco de dados.

Vamos usar a URL http: //localhost: 8080/student/{id}enviando 　 GET Solicitação. Já chamamos a URL http://localhost:8080/student/3. Ele retorna o ID3detalhes do aluno.

Da mesma forma, também podemos enviar 　 Delete Solicitação. Suponhamos que queremos deletar o ID2do registro do aluno.

Para deletar o registro do aluno, envie uma solicitação com a URL http://localhost:8080/student/do 　 DELETE Solicitação. Vemos que o ID é 　 2 do aluno foi removido do banco de dados.

provedor de Cache do SpringBootCRUD do SpringBoot