Spring Boot JPA EntityManager实体管理器示例

深碍√TFBOYSˉ_ 2023-09-25 13:34 31阅读 0赞

在本教程中，您将了解如何在 Spring Boot 示例中使用 JPA EntityManager（使用 CRUD 操作和查询方法）。我将向您展示：

*  在 Spring 引导中访问 JPA 实体管理器的方法
 *  如何使用实体管理器方法：执行SQL查询使用和CRUD操作`createQuery`
 *  带参数的 JPA 实体管理器查询

**内容**

*  [JPA 实体经理][JPA]
 *  [带有 Spring 引导的 JPA 实体管理器示例][Spring _ JPA]
 *  [创建和设置 Spring Boot 项目][Spring Boot]
 *  [配置 Spring 数据源、JPA、Hibernate][Spring _JPA_Hibernate]
 *  [创建实体][Link 1]
 *  [使用 JPA 实体管理器定义存储库][JPA 1]
 *  [JPA EntityManager createQuery][]
 *  [带参数的 JPA 实体管理器查询][JPA 2]
 *  [用于 CRUD 操作的 JPA 实体管理器方法][CRUD _ JPA]
 *  [使用实体管理器运行 Spring 引导示例][Spring]
 *  [结论][Link 2]
 *  [延伸阅读][Link 3]

### **JPA 实体经理** ###

JPA提供了[EntityManager][]接口，可以帮助我们将实体类持久化到数据库中，管理实体实例的生命周期，例如创建，删除，检索和查询。

Anobject 在持久性上下文的帮助下管理由[持久性单元][Link 4]定义的一组实体。在我们的应用程序和持久存储之间，持久性上下文是第一级缓存，用于跟踪所有实体对象的更改，并将更改与数据库同步。使用它们实际上与持久性上下文交互。`EntityManager``EntityManager`

`EntityManager`实例（及其配置）由调用的工厂接口创建。一旦关闭或应用程序关闭，其所有内容都将关闭。`EntityManagerFactory``EntityManagerFactory``EntityManager`

**如何访问 JPA 实体管理器？**

我们可以在 Spring Bean 中注入一个对象，例如存储库、服务或控制器......使用注释。`EntityManager``@Autowired`

@Repository
    public class TutorialRepository {
    
      @Autowired
      private EntityManager entityManager;
    
    }

Spring Data JPA 将在运行时初始化默认持久性单元。该对象将具有类型并包装休眠的对象。`EntityManagerFactory``EntityManager``LocalContainerEntityManagerFactoryBean``Session`

另一种访问方法是使用可以指定持久性单元名称、类型（事务范围或扩展范围）和其他属性的注释：`EntityManager``@PersistenceContext`

@Repository
    public class TutorialRepository {
    
      @PersistenceContext
      private EntityManager entityManager;
    
    }

### **带有 Spring 引导的 JPA 实体管理器示例** ###

–科技：

*  爪哇 8
 *  Spring Boot 2.6.7 （带有 Spring Data JPA）
 *  MySQL/PostgreSQL/H2 （嵌入式数据库）
 *  Maven 3.8.1

– 项目结构：

![eac757f85f084eb797ce11773daf0103.png][]

让我简要解释一下。

*  `Tutorial`数据模型类对应于实体和表*教程*。
 *  `TutorialRepository`用于 CRUD 方法和自定义查找器方法。它将被自动连接。`EntityManager``SpringBootJpaEntitymanagerExampleApplication`
 *  `SpringBootJpaEntitymanagerExampleApplication`是哪个实现。我们将在这里使用运行查询和其他方法。`SpringBootApplication``CommandLineRunner``TutorialRepository`
 *  在**application.properties**中配置Spring Datasource，JPA和Hibernate。
 *  **pom.xml**包含 Spring Boot 和 MySQL/PostgreSQL/H2 数据库的依赖项。

### **创建和设置 Spring Boot 项目** ###

使用 Spring Web 工具或您的开发[工具][Link 5]（[Spring Tool Suite][]、Eclipse、[Intellij][]）创建 Spring Boot 项目。

然后打开**pom.xml**并添加以下依赖项：

<dependency>
    	<groupId>org.springframework.boot</groupId>
    	<artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    
    <dependency>
    	<groupId>org.springframework.boot</groupId>
    	<artifactId>spring-boot-starter-data-jpa</artifactId>
    </dependency>

我们还需要再添加一个依赖项。  
如果你想使用**MySQL**：

<dependency>
    	<groupId>mysql</groupId>
    	<artifactId>mysql-connector-java</artifactId>
    	<scope>runtime</scope>
    </dependency>

– 或**PostgreSQL**：

<dependency>
    	<groupId>org.postgresql</groupId>
    	<artifactId>postgresql</artifactId>
    	<scope>runtime</scope>
    </dependency>

– 或**H2**（嵌入式数据库）：

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

### **配置 Spring 数据源、JPA、Hibernate** ###

在 src/main/resources 文件夹下，打开 application.properties 并编写这些行。

– 对于 MySQL：

spring.datasource.url= jdbc:mysql://localhost:3306/testdb?useSSL=false
    spring.datasource.username= root
    spring.datasource.password= 123456
    
    spring.jpa.properties.hibernate.dialect= org.hibernate.dialect.MySQL5InnoDBDialect
    
    # Hibernate ddl auto (create, create-drop, validate, update)
    spring.jpa.hibernate.ddl-auto= update

对于PostgreSQL：

spring.datasource.url= jdbc:postgresql://localhost:5432/testdb
    spring.datasource.username= postgres
    spring.datasource.password= 123
    
    spring.jpa.properties.hibernate.jdbc.lob.non_contextual_creation= true
    spring.jpa.properties.hibernate.dialect= org.hibernate.dialect.PostgreSQLDialect
    
    # Hibernate ddl auto (create, create-drop, validate, update)
    spring.jpa.hibernate.ddl-auto= update

*  `spring.datasource.username` & `spring.datasource.password`属性与数据库安装相同。
 *  Spring Boot 使用 Hibernate 进行 JPA 实现，我们配置 MySQL 或 PostgreSQL`MySQL5InnoDBDialect``PostgreSQLDialect`
 *  `spring.jpa.hibernate.ddl-auto`用于数据库初始化。我们将值设置为值，以便在数据库中自动创建一个与定义的数据模型对应的表。对模型的任何更改也将触发对表的更新。对于生产，此属性应该是。`update``validate`

– 对于 H2 数据库：

spring.datasource.url=jdbc:h2:mem:testdb
    spring.datasource.driverClassName=org.h2.Driver
    spring.datasource.username=sa
    spring.datasource.password=
     
    spring.jpa.show-sql=true
    spring.jpa.properties.hibernate.dialect=org.hibernate.dialect.H2Dialect
    spring.jpa.hibernate.ddl-auto= update
    
    spring.h2.console.enabled=true
    # default path: h2-console
    spring.h2.console.path=/h2-ui

*  `spring.datasource.url`：用于内存数据库和基于磁盘的数据库。`jdbc:h2:mem:[database-name]``jdbc:h2:file:[path/database-name]`
 *  我们为 H2 数据库配置配置`H2Dialect`
 *  `spring.h2.console.enabled=true`告诉 Spring 启动 H2 数据库管理工具，您可以在浏览器上访问此工具：`http://localhost:8080/h2-console`
 *  `spring.h2.console.path=/h2-ui`用于 H2 控制台的 URL，因此默认 url 将更改为。`http://localhost:8080/h2-console``http://localhost:8080/h2-ui`

### **创建实体** ###

在**模型**包中，我们定义类。`Tutorial`

教程有四个字段：ID、标题、描述、已发布。

**模型**/*教程.java*

package com.bezkoder.spring.jpa.entitymanager.model;
    
    import javax.persistence.*;
    
    @Entity
    @Table(name = "tutorials")
    public class Tutorial {
    
      @Id
      @GeneratedValue(strategy = GenerationType.AUTO)
      private long id;
    
      @Column(name = "title")
      private String title;
    
      @Column(name = "description")
      private String description;
    
      @Column(name = "published")
      private boolean published;
    
      public Tutorial() {
    
      }
    
      public Tutorial(String title, String description, boolean published) {
        this.title = title;
        this.description = description;
        this.published = published;
      }
    
      // getters and setters
    }

–annotation 表示该类是持久性 Java 类。–annotation 提供映射此实体的表。  
`@Entity``@Table`

–注释用于主键。  
–注释用于定义主键的生成策略。`@Id``@GeneratedValue`

### **使用 JPA 实体管理器定义存储库** ###

让我们创建一个存储库来与数据库进行交互。  
在**存储库**包中，创建类和注入注释。`TutorialRepository``EntityManager``@PersistenceContext`

存储库/*教程存储库.java*

package com.bezkoder.spring.jpa.entitymanager.repository;
    
    import java.util.List;
    
    import javax.persistence.EntityManager;
    import javax.persistence.PersistenceContext;
    import javax.persistence.Query;
    import javax.persistence.TypedQuery;
    import javax.transaction.Transactional;
    
    import org.springframework.stereotype.Repository;
    
    import com.bezkoder.spring.jpa.entitymanager.model.Tutorial;
    
    @Repository
    public class TutorialRepository {
    
      @PersistenceContext
      private EntityManager entityManager;
    
    }

在此类中，我们将使用 EntityManager 和其他用于 CRUD 操作的方法编写查询（带参数）。`createQuery`

### **JPA EntityManager createQuery** ###

我们可以使用EntityManager的方法直接在应用程序的业务逻辑中创建动态查询（Java持久性查询语言 - JPQL）。`createQuery`

public class TutorialRepository {
    
      @PersistenceContext
      private EntityManager entityManager;
    
      public List<Tutorial> findAll() {
        TypedQuery<Tutorial> query = entityManager.createQuery("SELECT t FROM Tutorial t", Tutorial.class);
        return query.getResultList();
      }
    }

该方法返回教程对象列表，该列表从数据库中**教程**表中的行映射。`findAll()`

### **带参数的 JPA 实体管理器查询** ###

对于方法，我们还可以使用命名参数对***参数***进行查询。`createQuery`

public class TutorialRepository {
    
      @PersistenceContext
      private EntityManager entityManager;
    
      public List<Tutorial> findByTitleContaining(String title) {
        TypedQuery<Tutorial> query = entityManager.createQuery(
            "SELECT t FROM Tutorial t WHERE LOWER(t.title) LIKE LOWER(CONCAT('%', :title,'%'))",
            Tutorial.class);
        return query.setParameter("title", title).getResultList();
      }
    
      public List<Tutorial> findByPublished(boolean isPublished) {
        TypedQuery<Tutorial> query = entityManager.createQuery(
            "SELECT t FROM Tutorial t WHERE t.published=:isPublished",
            Tutorial.class);
        return query.setParameter("isPublished", isPublished).getResultList();
      }
    
      public List<Tutorial> findByTitleAndPublished(String title, boolean isPublished) {
        TypedQuery<Tutorial> query = entityManager.createQuery(
            "SELECT t FROM Tutorial t WHERE LOWER(t.title) LIKE LOWER(CONCAT('%', :title,'%')) AND t.published=:isPublished",
            Tutorial.class);
        return query.setParameter("title", title).setParameter("isPublished", isPublished).getResultList();
      }
    }

我们用冒号后跟字符串 （，） 声明参数。实际值将在运行时设置。`:title``:isPublished`

在执行查询之前，使用方法设置一个或多个参数。`setParameter`

### **用于 CRUD 操作的 JPA 实体管理器方法** ###

要执行 CRUD（创建、检索、更新、删除）操作，我们可以使用以下 JPA 方法：`EntityManager`

*  `persist`：使给定对象受管理和持久化。实体管理器将跟踪其属性更改，以便与数据库同步。
 *  `find`：搜索指定类和主键的实体。如果实体实例包含在持久性上下文中，则会从该上下文返回该实体实例。
 *  `merge`：将给定实体的状态合并到当前持久性上下文中。
 *  `remove`：删除实体实例。

public class TutorialRepository {
    
      @PersistenceContext
      private EntityManager entityManager;
    
      @Transactional
      public Tutorial save(Tutorial tutorial) {
        entityManager.persist(tutorial);
        return tutorial;
      }
    
      public Tutorial findById(long id) {
        Tutorial tutorial = (Tutorial) entityManager.find(Tutorial.class, id);
        return tutorial;
      }
    
      @Transactional
      public Tutorial update(Tutorial tutorial) {
        entityManager.merge(tutorial);
        return tutorial;
      }
    
      @Transactional
      public Tutorial deleteById(long id) {
        Tutorial tutorial = findById(id);
        if (tutorial != null) {
          entityManager.remove(tutorial);
        }
    
        return tutorial;
      }
    
      @Transactional
      public int deleteAll() {
        Query query = entityManager.createQuery("DELETE FROM Tutorial");
        return query.executeUpdate();
      }
    }

对于删除所有实体实例，我们使用方法。`createQuery`

### **使用实体管理器运行 Spring 引导示例** ###

让我们打开，我们将在这里实现和自动连接接口来运行 JPA 实体管理器方法。`SpringBootJpaEntitymanagerExampleApplication.java``CommandLineRunner``TutorialRepository`

package com.bezkoder.spring.jpa.entitymanager;
    
    import java.util.ArrayList;
    import java.util.List;
    
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.boot.CommandLineRunner;
    import org.springframework.boot.SpringApplication;
    import org.springframework.boot.autoconfigure.SpringBootApplication;
    
    import com.bezkoder.spring.jpa.entitymanager.model.Tutorial;
    import com.bezkoder.spring.jpa.entitymanager.repository.TutorialRepository;
    
    @SpringBootApplication
    public class SpringBootJpaEntitymanagerExampleApplication implements CommandLineRunner {
    
      @Autowired
      TutorialRepository tutorialRepository;
    
      public static void main(String[] args) {
        SpringApplication.run(SpringBootJpaEntitymanagerExampleApplication.class, args);
      }
    
      @Override
      public void run(String... args) throws Exception {
        tutorialRepository.deleteAll();
    
        tutorialRepository.save(new Tutorial("Spring Data", "Tut#1 Description", false));
        tutorialRepository.save(new Tutorial("Java Spring", "Tut#2 Description", false));
        tutorialRepository.save(new Tutorial("Hibernate", "Tut#3 Description", false));
        tutorialRepository.save(new Tutorial("Spring Boot", "Tut#4 Description", false));
        tutorialRepository.save(new Tutorial("Spring Data JPA", "Tut#5 Description", false));
        tutorialRepository.save(new Tutorial("JPA EntityManager", "Tut#6 Description", false));
        tutorialRepository.save(new Tutorial("Spring Security", "Tut#7 Description", false));
    
        List<Tutorial> tutorials = new ArrayList<>();
    
        tutorials = tutorialRepository.findAll();
        show(tutorials);
    /*
    Number of Items: 7
    Tutorial [id=1, title=Spring Data, desc=Tut#1 Description, published=false]
    Tutorial [id=2, title=Java Spring, desc=Tut#2 Description, published=false]
    Tutorial [id=3, title=Hibernate, desc=Tut#3 Description, published=false]
    Tutorial [id=4, title=Spring Boot, desc=Tut#4 Description, published=false]
    Tutorial [id=5, title=Spring Data JPA, desc=Tut#5 Description, published=false]
    Tutorial [id=6, title=JPA EntityManager, desc=Tut#6 Description, published=false]
    Tutorial [id=7, title=Spring Security, desc=Tut#7 Description, published=false]
    */
    
        Tutorial tutorial = tutorialRepository.findById(6);
        System.out.println(tutorial);
    /*
    Tutorial [id=6, title=JPA EntityManager, desc=Tut#6 Description, published=false]
    */
    
        Tutorial tut1 = tutorials.get(0);
        tut1.setPublished(true);
    
        Tutorial tut3 = tutorials.get(2);
        tut3.setPublished(true);
    
        Tutorial tut5 = tutorials.get(4);
        tut5.setPublished(true);
    
        tutorialRepository.update(tut1);
        tutorialRepository.update(tut3);
        tutorialRepository.update(tut5);
    
        tutorials = tutorialRepository.findByTitleContaining("jpa");
        show(tutorials);
    /*
    Number of Items: 2
    Tutorial [id=5, title=Spring Data JPA, desc=Tut#5 Description, published=true]
    Tutorial [id=6, title=JPA EntityManager, desc=Tut#6 Description, published=false]
    */
    
        tutorials = tutorialRepository.findByPublished(true);
        show(tutorials);
    /*
    Number of Items: 3
    Tutorial [id=1, title=Spring Data, desc=Tut#1 Description, published=true]
    Tutorial [id=3, title=Hibernate, desc=Tut#3 Description, published=true]
    Tutorial [id=5, title=Spring Data JPA, desc=Tut#5 Description, published=true]
    */
    
        tutorials = tutorialRepository.findByTitleAndPublished("data", true);
        show(tutorials);
    /*
    Number of Items: 2
    Tutorial [id=1, title=Spring Data, desc=Tut#1 Description, published=true]
    Tutorial [id=5, title=Spring Data JPA, desc=Tut#5 Description, published=true]
    */
    
        Tutorial deletedTutorial = tutorialRepository.deleteById(4);
        System.out.println(deletedTutorial);
    /*
    Tutorial [id=4, title=Spring Boot, desc=Tut#4 Description, published=false]
    */
    
        tutorials = tutorialRepository.findAll();
        show(tutorials);
    /*
    Number of Items: 6
    Tutorial [id=1, title=Spring Data, desc=Tut#1 Description, published=true]
    Tutorial [id=2, title=Java Spring, desc=Tut#2 Description, published=false]
    Tutorial [id=3, title=Hibernate, desc=Tut#3 Description, published=true]
    Tutorial [id=5, title=Spring Data JPA, desc=Tut#5 Description, published=true]
    Tutorial [id=6, title=JPA EntityManager, desc=Tut#6 Description, published=false]
    Tutorial [id=7, title=Spring Security, desc=Tut#7 Description, published=false]
    */
    
        int numberOfDeletedRows = tutorialRepository.deleteAll();
        System.out.println(numberOfDeletedRows);
    /*
    6
    */
    
        tutorials = tutorialRepository.findAll();
        show(tutorials);
    /*
    Number of Items: 0
    */
      }
    
      private void show(List<Tutorial> tutorials) {
        System.out.println("Number of Items: " + tutorials.size());
        tutorials.forEach(System.out::println);
      }
    }

### **结论** ###

今天我们已经知道如何在 Spring Boot 示例中使用 JPA EntityManager。

您可以使用以下方法继续编写 CRUD Rest API：  
Spring [Boot、Spring Data JPA – Rest CRUD API 示例][Boot_Spring Data JPA _ Rest CRUD API]

如果要为 JPA 存储库编写单元测试：  
[Spring 引导单元测试 带有 @DataJpaTest 的 JPA 存储库][Spring _ _ _DataJpaTest _ JPA]

您还可以通过[本教程][Link 6]了解：  
– 如何在 AWS 上部署此 Spring 启动应用程序（免费）。  
– dockerize with[Docker Compose： Spring Boot and][Docker Compose_ Spring Boot and] MySQL 示例  
– 通过[这篇文章][Link 7]  
上传 Excel 文件并将数据存储在 MySQL 数据库中的方法– 通过[这篇文章][Link 8]上传 CSV 文件并将数据存储在 MySQL 中。

祝你学习愉快！再见。

### **延伸阅读** ###

*  [具有 Spring 安全性和 JWT 身份验证的安全 Spring 启动应用程序][Spring _ JWT _ Spring]
 *  [春季数据 JPA 参考文档][JPA 3]
 *  [Spring 引导分页和排序示例][Spring 1]

使用@Query注释：  
Spring [JPA @Query Spring Boot 的示例][JPA _Query Spring Boot]

或本机查询：  
[带有 Spring 引导的 Spring JPA 本机查询示例][Spring _ Spring JPA]

或派生查询：  
Spring [Boot 中的 Spring JPA 派生查询示例][Boot _ Spring JPA]

关联：  
–[JPA 在][JPA 4]春季引导中使用休眠的一对一示例–使用休眠和春季引导的 JPA 一对多示例–[JPA 多对多示例与春季引导][JPA 5]  
  
中的[休眠][Link 9]示例

您可以在以下教程中应用此实现：  
–Spring JPA + H2 示例–Spring JPA + MySQL 示例–Spring JPA + [PostgreSQL][] 示例–Spring [JPA +][JPA 6] Oracle 示例–[Spring][Spring 2] [JPA + SQL][JPA _ SQL] [Server 示例][Server]

全栈 CRUD 应用程序：  
–[Vue][] \+ 弹簧引导示例–角度 8 + 弹簧引导示例–角度 10 + 弹簧引导示例–角度 11 + 弹簧引导示例–[角度 12][12] \+ 弹簧启动示例–角度 13 + 弹簧启动示例–[反应][Link 10] [\+][Link 11] [弹簧启动示例][Link 12]

[JPA]: https://www.bezkoder.com/jpa-entitymanager-spring-boot/#JPA_EntityManager
[Spring _ JPA]: https://www.bezkoder.com/jpa-entitymanager-spring-boot/#JPA_EntityManager_example_with_Spring_Boot
[Spring Boot]: https://www.bezkoder.com/jpa-entitymanager-spring-boot/#Create_038_Setup_Spring_Boot_project
[Spring _JPA_Hibernate]: https://www.bezkoder.com/jpa-entitymanager-spring-boot/#Configure_Spring_Datasource_JPA_Hibernate
[Link 1]: https://www.bezkoder.com/jpa-entitymanager-spring-boot/#Create_Entity
[JPA 1]: https://www.bezkoder.com/jpa-entitymanager-spring-boot/#Define_Repository_with_JPA_EntityManager
[JPA EntityManager createQuery]: https://www.bezkoder.com/jpa-entitymanager-spring-boot/#JPA_EntityManager_createQuery
[JPA 2]: https://www.bezkoder.com/jpa-entitymanager-spring-boot/#JPA_EntityManager_query_with_parameters
[CRUD _ JPA]: https://www.bezkoder.com/jpa-entitymanager-spring-boot/#JPA_EntityManager_methods_for_CRUD_operations
[Spring]: https://www.bezkoder.com/jpa-entitymanager-spring-boot/#Run_Spring_Boot_with_EntityManager_example
[Link 2]: https://www.bezkoder.com/jpa-entitymanager-spring-boot/#Conclusion
[Link 3]: https://www.bezkoder.com/jpa-entitymanager-spring-boot/#Further_Reading
[EntityManager]: https://docs.oracle.com/javaee/7/api/javax/persistence/EntityManager.html
[Link 4]: https://docs.oracle.com/cd/E19798-01/821-1841/bnbrj/index.html
[eac757f85f084eb797ce11773daf0103.png]: https://img-blog.csdnimg.cn/eac757f85f084eb797ce11773daf0103.png
[Link 5]: https://start.spring.io/
[Spring Tool Suite]: https://spring.io/tools
[Intellij]: https://www.jetbrains.com/idea/download/
[Boot_Spring Data JPA _ Rest CRUD API]: https://www.bezkoder.com/spring-boot-jpa-crud-rest-api/
[Spring _ _ _DataJpaTest _ JPA]: https://www.bezkoder.com/spring-boot-unit-test-jpa-repo-datajpatest/
[Link 6]: https://www.bezkoder.com/deploy-spring-boot-aws-eb/
[Docker Compose_ Spring Boot and]: https://www.bezkoder.com/docker-compose-spring-boot-mysql/
[Link 7]: https://www.bezkoder.com/spring-boot-upload-excel-file-database/
[Link 8]: https://www.bezkoder.com/spring-boot-upload-csv-file/
[Spring _ JWT _ Spring]: https://www.bezkoder.com/spring-boot-jwt-authentication/
[JPA 3]: https://docs.spring.io/spring-data/jpa/docs/current/reference/html/#reference
[Spring 1]: https://www.bezkoder.com/spring-boot-pagination-sorting-example/
[JPA _Query Spring Boot]: https://www.bezkoder.com/spring-jpa-query/
[Spring _ Spring JPA]: https://www.bezkoder.com/jpa-native-query/
[Boot _ Spring JPA]: https://www.bezkoder.com/jpa-repository-query/
[JPA 4]: https://www.bezkoder.com/jpa-one-to-one/
[JPA 5]: https://www.bezkoder.com/jpa-many-to-many/
[Link 9]: https://www.bezkoder.com/jpa-one-to-many/
[PostgreSQL]: https://bezkoder.com/spring-boot-postgresql-example/
[JPA 6]: https://bezkoder.com/spring-boot-jpa-crud-rest-api/
[Spring 2]: https://www.bezkoder.com/spring-boot-jpa-h2-example/
[JPA _ SQL]: https://www.bezkoder.com/spring-boot-hibernate-oracle/
[Server]: https://www.bezkoder.com/spring-boot-sql-server/
[Vue]: https://www.bezkoder.com/spring-boot-vue-js-crud-example/
[12]: https://www.bezkoder.com/angular-10-spring-boot-crud/
[Link 10]: https://www.bezkoder.com/react-spring-boot-crud/
[Link 11]: https://www.bezkoder.com/angular-spring-boot-crud/
[Link 12]: https://www.bezkoder.com/angular-12-spring-boot-crud/