Spring Boot Orm 简明教程

Spring Boot ORM - Quick Guide

Spring Boot ORM - Overview

Spring 框架与 Hibernate、Java 持久化 API (JPA)、Java 数据对象 (JDO) 和 iBATIS SQL 映射等 ORM 框架很好地集成。Spring 提供资源管理、数据访问对象 (DAO) 实现和事务策略。Spring 允许通过依赖项管理配置 ORM 库功能。Spring 为其支持的所有 ORM 库维护统一的 DAO 异常层次结构和通用的事务管理。

Spring IoC 容器促进了 ORM 配置和轻松部署。以下是使用 Spring 框架创建 ORM DAO 的主要优点。

Easy to Test −使用 Spring IoC，可以轻松配置 ORM 实现。可以孤立地测试持久单元的每一部分。
Common Data Access Exception −Spring 将 ORM 工具异常包装到一个通用运行时异常（比如 DataAccessException）。此方法可帮助在相应图层中处理大多数持久化异常（不可恢复）。无需处理 ORM 特定的样板捕捉/抛出/异常声明。
General Resource Management −Spring 应用程序上下文轻松地管理持久化对象及其配置。例如，Hibernate SessionFactory 实例、JPA EntityManagerFactory 实例、JDBC DataSource 实例、iBatis SQL 映射配置对象和其他相关对象。Spring 本身处理本地以及 JTA 事务管理。
Integrated transaction management −Spring AOP 可用于使用声明式面向 AOP 的拦截器（例如 @Transaction 注释或在 XML 配置文件中指定事务 AOP 建议）将 ORM 代码包装起来。Spring 处理事务语义、异常处理、回滚等。Spring 允许在不影响 ORM 代码的情况下交换事务管理器。

Spring Boot ORM - Environment Setup

本章将指导您如何准备开发环境，以便使用 Spring Boot Framework 开始您的工作。它还将教您在设置 Spring Boot Framework 之前如何设置机器上的 JDK、Eclipse -

Step 1 - Setup Java Development Kit (JDK)

Java SE 可免费下载。若要下载 click here，请下载与你的操作系统兼容的版本。

按照说明下载 Java，并运行 .exe 在你的计算机上安装 Java。在计算机上安装 Java 后，你需要设置环境变量来指向正确的安装目录。

Setting Up the Path for Windows 2000/XP

假设你已将 Java 安装在 c:\Program Files\java\jdk 目录中 −

右键单击“我的电脑”，然后选择“属性”。
单击“高级”选项卡下的“环境变量”按钮。
现在，编辑“Path”变量并在其末尾添加 Java 可执行目录的路径。例如，如果路径当前设置为 C:\Windows\System32，则以以下方式进行编辑 C:\Windows\System32;c:\Program Files\java\jdk\bin。

Setting Up the Path for Windows 95/98/ME

假设你已将 Java 安装在 c:\Program Files\java\jdk 目录中 −

编辑“C:\autoexec.bat”文件，并在末尾添加以下行 - SET PATH=%PATH%;C:\Program Files\java\jdk\bin

Setting Up the Path for Linux, UNIX, Solaris, FreeBSD

环境变量 PATH 应设置为指向已安装 Java 二进制文件的位置。如果你在这方面遇到问题，请参阅 shell 文档。

例如，如果你使用 bash 作为你的 shell，那么你将在 .bashrc 的末尾添加以下行 −

export PATH=/path/to/java:$PATH'

或者，如果你使用诸如 Borland JBuilder、Eclipse、IntelliJ IDEA 或 Sun ONE Studio 这样的集成开发环境 (IDE)，则必须编译并运行一个简单程序来确认 IDE 知道你在何处安装了 Java。否则，你必须按照 IDE 文档中给出的内容执行正确的设置。

Step 2 - Setup Eclipse IDE

本教程中的所有示例都是使用 Eclipse IDE 编写的。因此，我们建议你应该在你机器上安装 Eclipse 的最新版本。

要安装 Eclipse IDE，请从 https://www.eclipse.org/downloads/ 下载最新的 Eclipse 二进制文件。下载安装后，将二进制发行版解压缩到方便的位置。例如，在 Windows 上的 C:\eclipse，或在 Linux/Unix 上的 /usr/local/eclipse，最后适当设置 PATH 变量。

可以通过在 Windows 机器上执行以下命令启动 Eclipse，或者你只需双击 eclipse.exe

%C:\eclipse\eclipse.exe

可以通过在 Unix（Solaris、Linux 等）机器上执行以下命令启动 Eclipse −

$/usr/local/eclipse/eclipse

成功启动后，如果一切正常，它应该显示以下结果 −

Step 3 - Setup m2eclipse

M2Eclipse 是一个 Eclipse 插件，它对于将 Apache Maven 集成到 Eclipse IDE 中非常有用。我们在本教程中使用 maven 来构建 spring boot 项目，并使用 m2eclipse 在 eclipse 内运行示例。

使用 Eclipse IDE 中的安装新软件对话框安装最新的 M2Eclipse 版本，并将其指向此 p2 存储库： https://download.eclipse.org/technology/m2e/releases/latest/

Step 3 - Setup Spring Boot Project

现在，如果一切正常，则可以继续设置 Spring Boot。以下是下载和在机器上安装 Spring Boot 项目的简单步骤。

转到 spring initializr 链接以创建 spring boot 项目， https://start.spring.io/ 。
选择项目作为 Maven Project 。
Select language as Java.
选择 Spring Boot 版本为 2.5.5 。
设置项目元数据 - 组为 com.tutorialspoint ，Artifact 为 springbootorm ，名称为 springbootorm ，说明为 Demo project for Spring Boot ORM ，包名为 com.tutorialspoint.springbootorm 。
Select packaging as Jar.
Select java as 11.
添加从属关系为 Spring Web, Spring Data JPA, MySQL Driver and Spring Boot DevTools 。

现在点击生成按钮来生成项目结构。

一旦基于 maven 的 Spring Boot 项目下载完成，然后将 maven 项目导入 eclipse，其余操作由 eclipse 处理。它将下载 maven 依赖关系，并构建项目以使之可以进行进一步的开发。

Step 4 - POSTMAN for REST APIs Testing

POSTMAN 是一个测试基于 REST 的 API 的有用工具。要安装 POSTMAN，请从 https://www.postman.com/downloads/ 下载最新的 POSTMAN 二进制文件。下载可安装文件后，按照说明进行安装和使用。

Spring Boot ORM - Create Project

在 eclipse 中，选择 File −> Import * −> *Existing Maven Project ，然后单击下一步。

选择在环境设置过程中从 Spring 初始化程序下载和提取的项目，如下所示：

单击“完成”按钮，将创建新项目。

现在，由于我们的项目已准备就绪，请在 pom.xml 中检查以下依赖项。

Spring Boot Starter Framework 库
MySQL Connector
Other related dependencies.

由于我们正在使用 spring boot，因此它的 starter 项目会自动处理大多数依赖项。

pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
   xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
   <modelVersion>4.0.0</modelVersion>
   <parent>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-parent</artifactId>
      <version>2.5.5</version>
      <relativePath/> <!-- lookup parent from repository -->
   </parent>
   <groupId>com.tutorialspoint</groupId>
   <artifactId>springbootorm</artifactId>
   <version>0.0.1-SNAPSHOT</version>
   <name>Spring Boot ORM</name>
   <description>Demo project for Spring Boot ORM</description>
   <properties>
      <java.version>11</java.version>
   </properties>
   <dependencies>
      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-data-jpa</artifactId>
      </dependency>
      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-web</artifactId>
      </dependency>
      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-devtools</artifactId>
         <scope>runtime</scope>
         <optional>true</optional>
      </dependency>
      <dependency>
         <groupId>mysql</groupId>
         <artifactId>mysql-connector-java</artifactId>
         <scope>runtime</scope>
      </dependency>
      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-test</artifactId>
         <scope>test</scope>
      </dependency>
   </dependencies>
   <build>
      <plugins>
         <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
         </plugin>
      </plugins>
   </build>
</project>

Spring Boot ORM - Application.properties

Spring boot 从 application.properties 中读取应用程序以及与持久性相关的属性。在这里，我们还可以配置 Hibernate 或任何其他 ORM 框架特定属性。我们使用通用属性，以便无需更改太多代码即可在 ORM 之间切换。默认情况下，如果 POM.xml 中没有指定其他 ORM 库，则 spring boot 配置 hibernate 作为 ORM 提供程序。

在 src −> main −> resources * 目录下创建 *application.properties 并如以下所示进行更新。

application.properties

#datasource configurations
spring.datasource.url=jdbc:mysql://localhost:3306/tutorialspoint?useSSL=false&allowPublicKeyRetrieval=true
spring.datasource.username=root
spring.datasource.password=root@123
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
# show SQL
spring.jpa.show-sql: true
# DDL generation
spring.jpa.generate-ddl=true

以下是 application.properties 的 key 属性的描述。

spring.datasource −数据库特定属性，例如连接 URL、用户名、密码、驱动程序类等。
spring.jpa −特定的 jpa 属性，例如显示 sql 以创建表等。

Spring Boot ORM - Update Project

现在，让我们为 Spring 应用程序添加一个 REST API，它可以添加、编辑、删除和显示员工(们)。

Entity − Employee.java

package com.tutorialspoint.springbootorm.entity;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;

@Entity
public class Employee {

   @Id
   @GeneratedValue(strategy = GenerationType.IDENTITY)
   private int id;
   private String name;
   private int age;
   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;
   }
}

Repository − EmployeeRepository.java

package com.tutorialspoint.springbootorm.repository;

import org.springframework.data.repository.CrudRepository;
import org.springframework.stereotype.Repository;

import com.tutorialspoint.springbootorm.entity.Employee;

@Repository
public interface EmployeeRepository extends CrudRepository<Employee, Integer>  {
}

Service − EmployeeService.java

package com.tutorialspoint.springbootorm.service;

import java.util.ArrayList;
import java.util.List;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import com.tutorialspoint.springbootorm.entity.Employee;
import com.tutorialspoint.springbootorm.repository.EmployeeRepository;

@Service
public class EmployeeService {

   @Autowired
   EmployeeRepository repository;

   public Employee getEmployeeById(int id) {
      return repository.findById(id).get();
   }

   public List<Employee> getAllEmployees(){
      List<Employee> employees = new ArrayList<Employee>();
      repository.findAll().forEach(employee -> employees.add(employee));
      return employees;
   }

   public void saveOrUpdate(Employee employee) {
      repository.save(employee);
   }

   public void deleteEmployeeById(int id) {
      repository.deleteById(id);
   }
}

Service − EmployeeController.java

package com.tutorialspoint.springbootorm.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.PutMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import com.tutorialspoint.springbootorm.entity.Employee;
import com.tutorialspoint.springbootorm.service.EmployeeService;

@RestController
@RequestMapping(path = "/emp")
public class EmployeeController {

   @Autowired
   EmployeeService employeeService;

   @GetMapping("/employees")
   public List<Employee> getAllEmployees(){
      return employeeService.getAllEmployees();
   }

   @GetMapping("/employee/{id}")
   public Employee getEmployee(@PathVariable("id") int id) {
      return employeeService.getEmployeeById(id);
   }

   @DeleteMapping("/employee/{id}")
   public void deleteEmployee(@PathVariable("id") int id) {
      employeeService.deleteEmployeeById(id);
   }

   @PostMapping("/employee")
   public void addEmployee(@RequestBody Employee employee) {
      employeeService.saveOrUpdate(employee);
   }

   @PutMapping("/employee")
   public void updateEmployee(@RequestBody Employee employee) {
      employeeService.saveOrUpdate(employee);
   }
}

Main Application − SpringBootOrmApplication.java

package com.tutorialspoint.springbootorm;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class SpringBootOrmApplication {
   public static void main(String[] args) {
      SpringApplication.run(SpringBootOrmApplication.class, args);
   }
}

Spring Boot ORM - Test Hibernate

现在在 eclipse 中，右键单击 SpringBootOrmApplication.java，选择 Run As 上下文菜单，然后选择 Java Application 。查看 eclipse 中的控制台日志。你将看到以下日志：

  .   ____          _            __ _ _
 /\\ / ___'_ __ _ _(_)_ __  __ _ \ \ \ \
( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \
 \\/  ___)| |_)| | | | | || (_| |  ) ) ) )
  '  |____| .__|_| |_|_| |_\__, | / / / /
 =========|_|==============|___/=/_/_/_/
 :: Spring Boot ::                (v2.5.5)

2021-10-05 09:40:27.442  INFO 8704 --- [  restartedMain] c.t.s.SpringBootOrmApplication           : Starting SpringBootOrmApplication using Java 11.0.11 on
...
2021-10-05 09:40:34.775  INFO 8704 --- [  restartedMain] o.s.b.d.a.OptionalLiveReloadServer       : LiveReload server is running on port 35729
2021-10-05 09:40:34.858  INFO 8704 --- [  restartedMain] o.s.b.w.embedded.tomcat.TomcatWebServer  : Tomcat started on port(s): 8080 (http) with context path ''
2021-10-05 09:40:34.880  INFO 8704 --- [  restartedMain] c.t.s.SpringBootOrmApplication           : Started SpringBootOrmApplication in 8.222 seconds (JVM running for 9.564)
2021-10-05 09:41:08.718  INFO 8704 --- [nio-8080-exec-2] o.a.c.c.C.[Tomcat].[localhost].[/]       : Initializing Spring DispatcherServlet 'dispatcherServlet'
2021-10-05 09:41:08.718  INFO 8704 --- [nio-8080-exec-2] o.s.web.servlet.DispatcherServlet        : Initializing Servlet 'dispatcherServlet'
2021-10-05 09:41:08.722  INFO 8704 --- [nio-8080-exec-2] o.s.web.servlet.DispatcherServlet        : Completed initialization in 4 ms

服务器启动并运行后，使用 Postman 先执行 POST 请求以添加记录。

在 POSTMAN 中设置以下参数。

HTTP Method − POST
URL − http://localhost:8080/emp/employee
正文 - An employee JSON

{
   "age": "35",
   "name": "Julie",
   "email": "julie@gmail.com"
}

单击发送按钮并检查响应状态是否为 OK。现在执行 GET 请求以获取所有记录。

在 POSTMAN 中设置以下参数。

HTTP Method − GET
URL − http://localhost:8080/emp/employees

单击发送按钮并验证响应。

[{
   "id": 1,
   "age": 35,
   "name": "Julie",
   "email": "julie@gmail.com"
}]

Spring Boot ORM - Maven EclipseLink

默认情况下，Spring Boot 使用 Hibernate 作为 ORM 实现。为了使用 EclipseLink，我们首先需要从 pom.xml 中的 spring-data-jpa 从属关系中排除 hibernate 从属关系，

<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-data-jpa</artifactId>
   <exclusions>
      <exclusion>
         <groupId>org.hibernate</groupId>
         <artifactId>hibernate-entitymanager</artifactId>
      </exclusion>
      <exclusion>
         <groupId>org.hibernate</groupId>
         <artifactId>hibernate-core</artifactId>
      </exclusion>
   </exclusions>
</dependency>

现在将 eclipse-link 依赖项包含在 pom.xml 中。

<dependency>
   <groupId>org.eclipse.persistence</groupId>
   <artifactId>org.eclipse.persistence.jpa</artifactId>
   <version>2.7.8</version>
</dependency>

以下是完整的 pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
   xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
   <modelVersion>4.0.0</modelVersion>
   <parent>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-parent</artifactId>
      <version>2.5.5</version>
      <relativePath/> <!-- lookup parent from repository -->
   </parent>
   <groupId>com.tutorialspoint</groupId>
   <artifactId>springbootorm</artifactId>
   <version>0.0.1-SNAPSHOT</version>
   <name>Spring Boot ORM</name>
   <description>Demo project for Spring Boot ORM</description>
   <properties>
      <java.version>11</java.version>
   </properties>
   <dependencies>
      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-data-jpa</artifactId>
         <exclusions>
            <exclusion>
               <groupId>org.hibernate</groupId>
               <artifactId>hibernate-entitymanager</artifactId>
            </exclusion>
            <exclusion>
               <groupId>org.hibernate</groupId>
               <artifactId>hibernate-core</artifactId>
            </exclusion>
         </exclusions>
      </dependency>
      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-web</artifactId>
      </dependency>
      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-devtools</artifactId>
         <scope>runtime</scope>
         <optional>true</optional>
      </dependency>
      <dependency>
         <groupId>org.eclipse.persistence</groupId>
         <artifactId>org.eclipse.persistence.jpa</artifactId>
         <version>2.7.8</version>
      </dependency>
      <dependency>
         <groupId>mysql</groupId>
         <artifactId>mysql-connector-java</artifactId>
         <scope>runtime</scope>
      </dependency>
      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-test</artifactId>
         <scope>test</scope>
      </dependency>
   </dependencies>
   <build>
      <plugins>
         <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
         </plugin>
      </plugins>
   </build>
</project>

保存文件，Eclipse 将自动更新从属关系。

Spring Boot ORM - Update Project EclipseLink

Spring Boot 使用 HibernateJpaAutoConfiguration ，默认情况下，其配置 Hibernate 实现。为了切换到 EclipseLink，我们需要创建一个自定义配置类，该类将扩展 JpaBaseConfiguration 类。JpaBaseConfiguration 是用于扩展和配置适用于任何 ORM 实现的 JPA 的基类。以下是 EclipsLinkJpaConfiguration 的代码。

EclipsLinkJpaConfiguration.java

package com.tutorialspoint.springbootorm;

import java.util.HashMap;
import java.util.Map;

import javax.sql.DataSource;

import org.eclipse.persistence.config.PersistenceUnitProperties;
import org.eclipse.persistence.logging.SessionLog;
import org.springframework.beans.factory.ObjectProvider;
import org.springframework.boot.autoconfigure.orm.jpa.JpaBaseConfiguration;
import org.springframework.boot.autoconfigure.orm.jpa.JpaProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.jdbc.datasource.DriverManagerDataSource;
import org.springframework.orm.jpa.vendor.AbstractJpaVendorAdapter;
import org.springframework.orm.jpa.vendor.EclipseLinkJpaVendorAdapter;
import org.springframework.transaction.jta.JtaTransactionManager;

@Configuration
public class EclipsLinkJpaConfiguration extends JpaBaseConfiguration {

   protected EclipsLinkJpaConfiguration(DataSource dataSource, JpaProperties properties,
      ObjectProvider<JtaTransactionManager> jtaTransactionManager) {
      super(dataSource, properties, jtaTransactionManager);
   }

   @Override
   protected AbstractJpaVendorAdapter createJpaVendorAdapter() {
      return new EclipseLinkJpaVendorAdapter();
   }

   @Override
   protected Map<String, Object> getVendorProperties() {
      Map<String, Object> map = new HashMap<>();
      map.put(PersistenceUnitProperties.WEAVING, "false");
      map.put(PersistenceUnitProperties.LOGGING_LEVEL, SessionLog.FINER_LABEL);
      map.put(PersistenceUnitProperties.DDL_GENERATION, PersistenceUnitProperties.CREATE_ONLY);
      map.put(PersistenceUnitProperties.LOGGING_LEVEL, SessionLog.FINER_LABEL);
      return map;
   }

   @Bean
   public static DataSource dataSource() {
      final DriverManagerDataSource dataSource = new DriverManagerDataSource();
      dataSource.setDriverClassName("com.mysql.cj.jdbc.Driver");
      dataSource.setUrl("jdbc:mysql://localhost:3306/tutorialspoint?useSSL=false&allowPublicKeyRetrieval=true");
      dataSource.setUsername("root");
      dataSource.setPassword("root@123");
      return dataSource;
   }
}

我们分别使用 createJpaVendorAdapter()、dataSource() 和 getVendorProperties() 方法添加了 Adapter、DataSource和 Properties。

同时更新实体，使用 Integer 代替 int。

package com.tutorialspoint.springbootorm.entity;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;

@Entity
public class Employee {

   @Id
   @GeneratedValue(strategy = GenerationType.IDENTITY)
   private Integer id;
   private String name;
   private Integer age;
   private String email;

   public Integer getId() {
      return id;
   }

   public void setId(Integer id) {
      this.id = id;
   }

   public String getName() {
      return name;
   }

   public void setName(String name) {
      this.name = name;
   }

   public Integer getAge() {
      return age;
   }

   public void setAge(Integer age) {
      this.age = age;
   }

   public String getEmail() {
      return email;
   }

   public void setEmail(String email) {
      this.email = email;
   }
}

Spring Boot ORM - Test EclipseLink

现在，在 eclipse 中，右键单击 SpringBootOrmApplication.java，选择 Run As 上下文菜单，然后选择 Java Application 。检查 eclipse 中的控制台日志。你可以看到以下日志 −

  .   ____          _            __ _ _
 /\\ / ___'_ __ _ _(_)_ __  __ _ \ \ \ \
( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \
 \\/  ___)| |_)| | | | | || (_| |  ) ) ) )
  '  |____| .__|_| |_|_| |_\__, | / / / /
 =========|_|==============|___/=/_/_/_/
 :: Spring Boot ::                (v2.5.5)

...
2021-10-06 09:52:28.187  INFO 10048 --- [  restartedMain] w.s.c.ServletWebServerApplicationContext : Root WebApplicationContext: initialization completed in 3111 ms
...
[EL Info]: 2021-10-06 09:52:29.063--ServerSession(2026366076)--Thread(Thread[restartedMain,5,main])--EclipseLink, version: Eclipse Persistence Services - 2.7.8.v20201217-ecdf3c32c4
...
[EL Config]: connection: 2021-10-06 09:52:29.424--ServerSession(2026366076)--Connection(460137428)--Thread(Thread[restartedMain,5,main])--Connected: jdbc:mysql://localhost:3306/tutorialspoint?useSSL=false&allowPublicKeyRetrieval=true
	User: root@localhost
	Database: MySQL  Version: 8.0.23
	Driver: MySQL Connector/J  Version: mysql-connector-java-8.0.26 (Revision: 9aae1e450989d62c06616c1dcda3e404ef84df70)
[EL Fine]: connection: 2021-10-06 09:52:29.471--ServerSession(2026366076)--Thread(Thread[restartedMain,5,main])--/file:/F:/tutorialspoint/springbootorm/target/classes/_default login successful
[EL Finer]: metamodel: 2021-10-06 09:52:29.512--ServerSession(2026366076)--Thread(Thread[restartedMain,5,main])--Canonical Metamodel class [com.tutorialspoint.springbootorm.entity.Employee_] not found during initialization.
2021-10-06 09:52:29.796  WARN 10048 --- [  restartedMain] JpaBaseConfiguration$JpaWebConfiguration : spring.jpa.open-in-view is enabled by default. Therefore, database queries may be performed during view rendering. Explicitly configure spring.jpa.open-in-view to disable this warning
2021-10-06 09:52:30.543  INFO 10048 --- [  restartedMain] o.s.b.d.a.OptionalLiveReloadServer       : LiveReload server is running on port 35729
2021-10-06 09:52:30.603  INFO 10048 --- [  restartedMain] o.s.b.w.embedded.tomcat.TomcatWebServer  : Tomcat started on port(s): 8080 (http) with context path ''
2021-10-06 09:52:30.622  INFO 10048 --- [  restartedMain] c.t.s.SpringBootOrmApplication           : Started SpringBootOrmApplication in 6.556 seconds (JVM running for 7.512)
2021-10-06 09:53:38.526  INFO 10048 --- [nio-8080-exec-1] o.a.c.c.C.[Tomcat].[localhost].[/]       : Initializing Spring DispatcherServlet 'dispatcherServlet'
2021-10-06 09:53:38.527  INFO 10048 --- [nio-8080-exec-1] o.s.web.servlet.DispatcherServlet        : Initializing Servlet 'dispatcherServlet'
2021-10-06 09:53:38.532  INFO 10048 --- [nio-8080-exec-1] o.s.web.servlet.DispatcherServlet        : Completed initialization in 5 ms

一旦服务器启动并运行，就使用 Postman 发出 GET 请求来获取所有记录。

在 POSTMAN 中设置以下参数。

HTTP Method − GET
URL − http://localhost:8080/emp/employees

单击发送按钮并验证响应。

[{
   "id": 1,
   "age": 35,
   "name": "Julie",
   "email": "julie@gmail.com"
}]