Spring Data JDBC与Spring JDBC和Spring Data JPA对比

Dear 丶 2023-09-26 10:31 58阅读 0赞

> 新成员将添加到“弹簧数据”系列中。弹簧数据 JDBC 使用两者的最佳元素定位在弹簧数据 JPA 和弹簧 JDBC 之间。这篇文章将描述这个产品的当前状态和未来。它还将解释该产品试图解决哪些问题以及如何解决。

## **目录** ##

*  [介绍][Link 1]
 *  [春季 JDBC vs 春季数据 JDBC vs 春季数据 JPA][JDBC vs _ JDBC vs _ JPA]
    
     *  [项目差异][Link 2]
     *  [插入数据][Link 3]
     *  [查询数据库][Link 4]
     *  [更新实例][Link 5]
 *  [使用弹簧数据JDBC的优点][JDBC]
    
     *  [更好的设计][Link 6]
     *  [更易于理解][Link 7]
     *  [性能][Link 8]
 *  [我应该使用它吗][Link 9]

### **介绍** ###

弹簧数据 JDBC 是弹簧数据系列的新成员。它的创建是为了填补位于春季JDBC和春季数据JPA之间的空白。如果你看一下Spring JDBC，你可能会说它太低了，因为它只有助于与数据库的连接。Spring Data JPA可能看起来太复杂了，因为它为您提供了很多选项，并且很难掌握所有这些选项。弹簧数据JDBC是一个框架，它试图为您提供与使用弹簧数据JPA相同的功能，但通过使用DDD原则使其更易于理解。它还通过在较低级别上工作并让您决定何时需要像Spring JDBC那样进行数据库交互来提供更多控制，但以更简单的方式。在本文的其余部分中，将显示弹簧数据 JPA、弹簧数据 JDBC 和弹簧 JDBC 之间的差异。这将希望向您展示Spring Data JDBC是一个非常好的产品，具有很大的潜力，旨在帮助您。

### **春季 JDBC VS 春季数据 JDBC VS 春季数据 JPA** ###

#### **项目差异** ####

春季JDBC，春季数据JPA和春季数据JDBC都是基于不同思维方式的三者。基于这些思维方式，您可以看到如何使用这些技术以及某些部分需要如何构建的差异。春季 JDBC 仅帮助连接到数据库以及在此数据库上执行查询。春之数据JPA希望帮助您管理基于JPA的存储库。它希望删除样板代码，提高实现速度，并为应用程序的性能提供帮助。春季数据JDBC还希望提供访问关系数据库的帮助，但希望保持实现不那么复杂。

**春季京东**

春季 JDBC 提供的帮助是提供一个执行 SQL 的框架。春季 JDBC 处理与数据库的连接，并允许您使用 Jdbc 模板执行查询。此解决方案非常灵活，因为您可以完全控制已执行的查询。您还可以自由定义类结构，因为您可以完全控制映射。

**春季数据JPA**

Spring Data JPA使用实体，因此类结构需要与数据库结构进行比较，因为某些映射是自动完成的。在最简单的形式中，数据库表将分别表示一个实体，并且几乎可以直接映射到实体类上。此映射可以通过使用 Java 配置来完成。通过使用注释，您可以定义在哪个表上映射类，以及如何将表链接在一起。

当使用@Entity注释注释类时，该类被视为实体。最常见的链接是@OneToMany、@ManyToOne和@ManyToMany。例如，如果类 A 与类 B 具有@OneToMany关系，则数据库方案将在表 B 到表 A 中具有外键，并且 JPA 实现将在实体 A 中保留链接的 B 元素的列表。对于如何将实体链接在一起几乎没有任何限制。这意味着完全可以自由地按照自己的方式设计类结构，但这也意味着你需要警惕，不要引起循环依赖关系等问题。这也意味着没有什么可以阻止您创建不易理解的复杂结构，特别是了解您的类结构如何转换为数据库结构。因此，您将始终需要考虑类结构决策如何影响您的数据库。

例如，定义具有多对多关系或双向关系的数据结构很容易。将其转换为数据库结构时，您将需要中间表并创建对单向关系的引用。

**例：**

在此示例中，有一些类可以在 Spring 数据 JPA 中使用。它们表示域模型的一部分，本文的其余部分也将使用该部分。租赁公司包含租赁。这些租赁包含有关租用哪辆车以及何时租用的信息。

@Entity
        public class Rental {
        
         
            @Id
            @GeneratedValue(strategy = GenerationType.AUTO)
            private Long id;
         
            @ManyToOne(fetch = FetchType.LAZY)
            @JoinColumn(name = "company_id")
            private RentalCompany company;
         
            // ...
         
        }
        
        @Entity
        public class RentalCompany {
        
         
            @Id
            @GeneratedValue(strategy = GenerationType.AUTO)
            private Long id;
         
            @OneToMany(fetch = FetchType.LAZY, mappedBy = "company")
            private List<Rental> rentals;
             
            // ...
        }

**春季数据 JDBC**

当您使用春季数据JDBC时，您还需要创建将映射到数据库的实体类。最大的区别在于，在创建类结构时，您需要遵循更多规则。类结构需要遵循 DDD 的聚合设计规则。Spring Data强制执行这一点，因为这将导致创建更简单易懂的项目。如果你不知道这个概念或为什么它是有用的，你可以查看一篇关于这个的非常好的文章：[Vaugn Vernon的有效聚合设计][Vaugn Vernon]。基本上，我们将具有强耦合的不同实体组合在一起，我们称之为聚合。聚合的顶部实体称为聚合根。还有其他一些规则需要遵循：

*  一个实体只能是 1 个聚合的一部分。
 *  聚合中的所有关系都需要是单向的。
 *  聚合根需要管理顶级关系。

这意味着，通过跟踪从聚合根开始的链接，可以找到聚合中的每个实体。因此，我们不需要像Spring数据JPA那样为每个实体提供存储库，而只需要为聚合根创建存储库。若要将实体类链接在一起以形成聚合，需要使用对象引用。聚合中的实体类只能具有一对一关系和一对多关系。如果具有一对一关系，则实体只需要对另一个对象的对象引用。当您具有一对多关系时，您的实体需要包含对象引用的集合。要创建与聚合外部实体的关系，需要使用 id 来获取这些类之间的低耦合。

创建弹簧数据JDBC与弹簧数据JPA使用的类的一个很大区别是，不需要使用@Entity，也不需要使用@OneToMany等关系注释。春季数据 JDBC 知道一个类是聚合根，当它包含该类的存储库时。由于聚合实体通过对象引用连接的规则，Spring Data JDBC 还知道聚合是什么，并且可以将数据作为聚合传输到数据库。

**例：**

在下面的示例中，您可以看到如何在弹簧数据 JDBC 中实现在弹簧数据 JPA 示例中引入的域模型。在此实现中，有 2 个聚合根 租车公司 和 汽车。租赁是租赁公司总和的一部分。本文中的其他示例也将使用此域模型来比较三个框架之间的差异。

public class RentalCompany {
        
        
            @Id
            private Long id;
        
            private String name;
            private Set<Rental> rentals;
        
        }
        
        public class Rental {
        
        
            @Id
            private Long id;
            
            private String renter;
            private Long carId;
            private LocalDate startDate;
            private LocalDate endDate;
        }
        
        public class Car {
        
        
            @Id
            private Long id;
            
            private String color;
            private String brand;
            private String model;
            private String licensePlate;
            private CarType type;
        }

#### **插入数据** ####

要插入数据，您需要使用在上一节中创建的工具。如果您使用春季 JDBC，那么您将编写由 Jdbc 模板直接在数据库上执行的查询。如果使用弹簧数据 JPA 或弹簧数据 JDBC 插入数据，则可以使用已创建的实体或聚合系统。

**春季京东**

使用春季 JDBC，您可以自己编写插入语句，并使用 Jdbc 模板执行它们。自己编写所有查询的优点是您可以完全控制它们。

**例：**

SingleConnectionDataSource dataSource = new SingleConnectionDataSource();
        dataSource.setDriverClassName("org.hsqldb.jdbcDriver");
        dataSource.setUrl("jdbc:hsqldb:data/jdbcexample");
        dataSource.setUsername("sa");
        dataSource.setPassword("");
            
        JdbcTemplate template = new JdbcTemplate(ds);
        template.execute("create table car (id int, model varchar)");
        template.execute("insert into car (id, model) values (1, 'Volkswagen Beetle')");
        
        dataSource.destroy();

**春季数据JPA**

如果使用 Spring 数据 JPA 插入数据，则需要使用存储库和实体。这样就可以在更高的层次上进行思考，并让Spring数据JPA处理查询的创建。当您要为实体创建数据时，您唯一需要做的就是创建一个具有正确值的对象，并在Spring数据存储库上调用 save 方法。然后，Spring Data JPA将查看您的实体及其所有注释，以将其映射到必要的插入或更新语句。

**例**

下面的示例演示如何使用弹簧数据JPA在数据库中插入数据。`Rental`

@Service
        public class RentalService{
        
            
            private RentalRepository rentalRepository;
            
            public RentalService(RentalRepository rentalRepository){
        
                this.rentalRepository = rentalRepository;
            }
            
            public Rental create(Rental rental){
        
                return rentalRepository.save(rental);
            }
        }

**春季数据 JDBC**

弹簧数据 JDBC 使用的语法可与弹簧数据 JPA 相媲美。最大的区别是在引擎盖下。持久性的管理由存储库处理，就像在Spring数据JPA中一样，但只有聚合根具有存储库。这意味着，如果要插入或更新数据，则需要保存整个聚合。您将需要调用聚合根的存储库的 save 方法，这将首先保存聚合根，然后保存所有引用的实体。如果只想插入聚合的一部分（例如，仅创建新的租赁），则将更新整个聚合，并且将删除并再次插入引用的实体。

**例**

该示例演示如何添加 。如果要创建聚合根的新实例，则该代码可与Spring数据JPA的代码相媲美。`Rental`

@Service
        public class RentalCompanyService{
        
            
            private RentalCompanyRepository rentalCompanyRepository;
            
            public RentalCompanyService(RentalCompanyRepository rentalCompanyRepository){
        
                this.rentalCompanyRepository = rentalCompanyRepository;
            }
            
            public RentalCompany addRental(Rental rental, Long rentalCompanyId){
        
                RentalCompany rentalCompany = rentalRepository.findById(rentalCompanyId);
                rentalCompany.getRentals().add(rental);
                return rentalRepository.save(rentalCompany);
            }
        }

#### **查询数据库** ####

为了从我们的数据库中检索数据，我们编写查询。春季 JDBC 将允许您使用 并允许您使用行映射器映射结果。弹簧数据 JDBC 和弹簧数据 JPA 还允许您使用 JPQL 或 SQL 查询创建查询，但您将在存储库中编写它们，框架将帮助您进行映射。`JdbcTemplate`

**春季京东**

春季 JDBC 用于查询的主要工具是 。使用它的缺点是它只提供连接，以及您需要自己做的其他所有事情。如果搜索对象，则需要通过实现 将结果映射到 Java 对象。您还需要通过创建异常转换器来执行异常处理。`JdbcTemplate``RowMapper`

我将向您展示一个有关如何创建查询的简单示例。

**例子**

需要通过实现 来映射此响应。`RowMapper`

public class CarRowMapper implements RowMapper<Car> {
        
        
            @Override
            public Car mapRow(ResultSet resultSet, int rowNumber) throws SQLException {
        
                Car car = new Car();
         
                car.setId(resultSet.getInt("ID"));
                car.setColor(resultSet.getString("COLOR"));
                car.setBrand(resultSet.getString("BRAND"));
                car.setModel(resultSet.getString("MODEL"));
         
                return car;
            }
        }

此映射器可以传递给 将使用它来创建填充的 Java 对象的 。`JdbcTemplate`

List<Car> cars = jdbcTemplate.queryForObject(
            "SELECT * FROM CAR WHERE ID = ?", new Object[] {
        id}, new CarRowMapper());

**春季数据JPA**

当您使用Spring数据框架时，它将帮助您构建查询并获取正确的数据。弹簧数据JPA框架使用JPA规范的实现，如休眠。它们使得使用用户友好的界面查询数据库成为可能。当您想要查询数据库时，Hibernate 将为您提供帮助，而不是自己编写整个查询。有多种方法可以使用Spring数据JPA查询数据库，但它们都需要您扩展要查询的实体的存储库。

可以使用派生查询编写一些基本查询。这方面的一个例子是查找字节。对于这些方法，弹簧数据将完全自行生成SQL。有关如何定义派生查询的详细信息，请参阅 [Spring 数据文档][Spring]。

如果需要编写无法轻松定义为派生查询的更高级查询，可以使用@Query批注自行定义查询。在@Query注释中，您可以编写 JPQL 或 SQL 语句。JPQL 是一种类似 SQL 的语法，它在常规 SQL 之上提供了一个抽象层。当使用JPQL时，弹簧数据可以帮助您处理数据。例如，只需添加一个参数即可完成分页和排序。

如果要进行更多的控制，可以通过将批注的本机属性设置为 true 来使用 SQL。然后你不再使用这个额外的层，但它也不能再帮助你了。请注意，即使您直接使用 SQL，您仍将返回由休眠管理的实体。`@Query`

除了帮助您更轻松地定义要执行的查询外，它还可以帮助您微调性能。当您使用弹簧数据JPA进行查询时，您正在使用实体。这些实体与其他实体有连接。Spring Data JPA将帮助您定义是否要直接返回这些连接的实体。它可以帮助您在需要时搜索这些实体。这被称为急切和延迟加载，这都可以由Spring数据JPA管理。

它还会尝试通过为您提供打开查询缓存的选项来提高性能。启用此功能后，Spring 数据 JPA 将尝试重用生成的 SQL 查询，如果可能的话，还会重用这些查询的结果。

**例子**

调用存储库以获取具有给定 CarType 的所有租赁的服务。

@Service
        public class RentalService {
        
        
            private RentalRepository rentalRepository;
        
            public RentalService(RentalRepository rentalRepository){
        
                this.rentalRepository = rentalRepository;
            }
        
            public List<Rental> getRentalsByCarType(Long rentalCompanyId, CarType carType) {
        
                return rentalRepository.findByCompanyIdAndCarType(rentalCompanyId, carType);
            }
        }

存储库使用派生查询来公开此功能。

public interface RentalRepository extends PagingAndSortingRepository<Rental, Long> {
        
        
            List<Rental> findByCompanyIdAndCarType(Long rentalCompanyId, CarType carType);
        }

**春季数据 JDBC**

弹簧数据 JDBC 的抽象比弹簧数据 JPA 少，但使用弹簧数据概念来使执行 CRUD 操作比弹簧 JDBC 更容易。

它更靠近数据库，因为它在查询数据库时不包含大部分Spring数据魔术。每个查询都直接在 JDBC 上执行，并且没有延迟加载或缓存，因此当您查询数据库时，它将返回整个聚合。

目前，当您想在Spring数据JDBC中向存储库添加方法时，您需要添加一个包含查询的@Query注释。这需要是纯 SQL，而不是春季数据 JPA 中使用的 JPQL。您可以将此查询与添加到Spring数据JPA中的本机查询进行最佳比较。由于春季数据JDBC距离数据库如此之近，因此与春季数据JPA中的本机查询一样，不可能具有分页和排序存储库。这些类型的存储库将在将来添加。这就像派生查询功能一样，它尚未实现，但将来会实现。

当您使用 Spring 数据 JDBC 查询应用程序时，您将收到整个聚合，而不是实体。这使得应用程序更易于理解。应用程序不需要依赖应用程序上下文来获取返回实体的属性状态。由于整个对象都是提取的，因此不需要额外的调用来接收尚未加载的对象的字段值，因为所有字段都已填充。此系统的缺点可能是将加载太多数据。但是，如果发生这种情况，则可能是聚合的边界太大，可能需要拆分聚合。

**例子**

当我们尝试在春季数据JDBC中执行与春季数据JPA相同的操作时，您需要以不同的方式进行操作。第一个区别是我们不能使用租赁存储库，因为它不存在。它不存在，因为租赁不是聚合根，而是具有聚合根的聚合的一部分 租赁公司。这就是为什么我们现在需要使用租赁公司存储库的原因。

@Service
        public class RentalCompanyService {
        
        
            public RentalCompanyRepository rentalCompanyRepository;
        
            public RentalCompanyService(RentalCompanyRepository rentalCompanyRepository){
        
                this.rentalCompanyRepository = rentalCompanyRepository;
            }
        
            public List<Rental> getRentalsByCarType(Long rentalCompanyId, CarType carType) {
        
                return rentalRepository.findByIdAndCarType(rentalCompanyId, carType);
            }
        }

另一个区别是我们不能使用派生查询，因此我们需要使用@Query注释。

public interface RentalCompanyRepository extends CrudRepository<RentalCompany, Long> {
        
        
            @Query(value = "SELECT * " +
                    "FROM Rental rental " +
                    "JOIN Car car ON car.id = rental.car_id " +
                    "WHERE rental.rental_company = :companyId " +
                    "AND car.type = :carType")
            List<Rental> findRentalsByIdAndCarType(@Param("companyId") Long companyId, @Param("carType")String carType);
        }

#### **更新实例** ####

当您要更新数据库中的实例时，您需要编写一个查询并使用弹簧数据JPA或弹簧数据JDBC中的域模型执行它。`JdbcTemplate`

**春季京东**

春季JDBC再次仅在更新数据库中的数据时提供框架。公开更新方法。此方法可以接受查询和可选参数。`JdbcTemplate`

**例**

一个简单的代码示例，我们更新给定汽车的颜色。

String query = "update Car set color = ? where id = ?";
        jdbcTemplateObject.update(query, color, id);

**春季数据JPA**

Spring数据JPA提供了更多工具来更新数据，例如实体周围的代理。这些实体的状态存储在持久性上下文中。通过使用这个，弹簧数据JPA能够跟踪对这些实体的更改。它使用这些更改的信息使数据库保持最新。弹簧数据JPA从这些实体创建托管实体。我们不必总是需要创建查询来更新数据库中的数据，而是可以编辑这些实体。然后，这些更改将始终自动保留。此跟踪称为脏跟踪，因为当您更改实体时，这些更新会使实体“脏”，因为状态与数据库中的状态不同。刷新休眠会话时，这些更改将被保留，并且实体将再次“干净”。这只会对事务中的更改执行此操作。如果未在事务上下文中完成更改，则必须调用存储库的 save 方法来保留这些更改。

如果要进行更大的更改，也可以在存储库中创建更新方法。与查询数据库和创建实体一样，您还可以在存储库中创建方法。使用 JPQL，您可以创建一个可以一次更新多个实体的查询。请确保添加@Modifying注释。这是一项安全措施，因此您无法错误地修改某些内容。

**例**

如果您想更改所有掀背车的颜色，可以通过不同的方式执行此操作。我会给三个。

如果您在事务中执行此操作，则肮脏的跟踪将处理更改。

@Service
           public class CarService {
        
           
               public CarRepository carRepository;
           
               public CarService(CarRepository carRepository){
        
                   this.carRepository = carRepository;
               }
           
               @Transactional
               public List<Car> updateColorOfCarsWithCarType(CarType carType, String color) {
        
                   List<Car> carsWithType = carRepository.findByCarType(rentalCompanyId, carType);
                   for(Car currentCar : carsWithType){
        
                        currentCar.setColor(color);
                   }
                   return carsWithType;
               }
           }

如果没有事务，则还需要添加一个实现来指示 Hibernate 保留更改。

第三种方法是通过查询。

@Service
           public class CarService {
        
           
               public CarRepository carRepository;
           
               public CarService(CarRepository carRepository){
        
                   this.carRepository = carRepository;
               }
           
               @Transactional
               public List<Car> updateColorOfCarsWithCarType(CarType carType, String color) {
        
                   return carRepository.updateColorOfCarsWithCarType(rentalCompanyId, carType);
               }
           }
           
           public interface CarRepository extends CrudRepository<Rental, Long> {
        
           
               @Modifying
               @Query(value = "Update Car car " +
                       "SET car.color = :color "
                       "WHERE car.type = :carType ")
               List<Car> updateColorOfCarsWithCarType(@Param("color") String color, @Param("carType")String carType);
           }

**春季数据 JDBC**

弹簧数据 JDBC 没有像弹簧数据 JPA 那样的持久性上下文。在我看来，这使得春季数据JDBC比春季数据JPA更简单。如果要对数据进行更改，则负责处理持久性。如果不在存储库中调用 save 方法，则不会保留更改。

您还可以选择使用自写查询更新聚合。正如我已经提到的，这些查询直接在数据库上执行，而不使用像Hibernate这样的抽象。更新数据是通过在聚合的存储库上调用 save 方法完成的。

由于弹簧数据 JDBC 不包含像弹簧数据 JPA 这样的持久性上下文，因此它不知道聚合的哪个部分已更新。因此，它将更新聚合根并删除所有引用的实体，然后再次保存它们。作为缺点，即使实体未更新，有时也会被删除和插入，这可能会浪费资源。最大的优点是，您可以确保整个实体在保存聚合后都是最新的。

**例子**

假设我们要更改相同类型的所有颜色的颜色，就像我们在Spring数据JPA示例中所做的那样。

您可以像春季数据JPA的示例2一样执行此操作。

@Service
           public class CarService {
        
           
               public CarRepository carRepository;
           
               public CarService(CarRepository carRepository){
        
                   this.carRepository = carRepository;
               }
           
               public List<Car> updateColorOfCarsWithCarType(CarType carType, String color) {
        
                   List<Car> carsWithType = carRepository.findByCarType(rentalCompanyId, carType);
                   for(Car currentCar : carsWithType){
        
                        currentCar.setColor(color);
                        carRepository.save(currentCar);
                   }
                   return carsWithType;
               }
           }
           
           public interface CarRepository extends CrudRepository<Rental, Long> {
        
                  
              @Query(value = "SELECT * "
                      "FROM Car car " +
                      "WHERE car.type = :carType ")
              List<Car> findByCarType(@Param("color") String color, @Param("carType")String carType);
          }

另一种方法是通过更新查询，该查询与Spring数据JPA示例相同。如果要更新聚合的一部分，则需要遍历聚合根，因为聚合根保持整个聚合的一致性。

@Service
           public class CarService {
        
           
               public CarRepository carRepository;
           
               public CarService(CarRepository carRepository){
        
                   this.carRepository = carRepository;
               }
           
               @Transactional
               public List<Car> updateColorOfCarsWithCarType(CarType carType, String color) {
        
                   return carRepository.updateColorOfCarsWithCarType(rentalCompanyId, carType);
               }
           }
           
           public interface CarRepository extends CrudRepository<Rental, Long> {
        
           
               @Query(value = "UPDATE Car car " +
                       "SET car.color = :color
                       "WHERE car.type = :carType ")
               List<Rental> updateColorOfCarsWithCarType(@Param("color") String color, @Param("carType")String carType);
           }

### **使用弹簧数据JDBC的优点** ###

#### **更好的设计** ####

使用Spring Data JDBC的最大优势之一是，它将迫使您遵循DDD设计的规则，例如使用聚合。可以[在这里][Vaugn Vernon]找到为什么这种设计可以帮助您的一个很好的解释。

由于仅使用一对多关系，因此可以更轻松地查看类之间的确切关系。类只能是 1 个聚合的一部分。再加上一对多规则，这使得不可能创建循环依赖关系。如果需要在聚合之间创建关系，则需要使用 id。这使得聚合体之间的耦合尽可能小。

在哪里可以找到与数据交互的逻辑也很清楚，因为只有聚合根具有存储库，因为它们负责这些交互。

#### **更易于理解** ####

只有聚合根负责处理持久性。这清楚地表明了需要坚持什么以及谁负责这样做。由于持久性始终需要通过调用 save 方法启动，因此与使用 Spring Data JPA 相比，它更容易理解何时将保留更改。

很容易看出哪些类是聚合的一部分，因为聚合是使用对象引用连接的。使用 id 时，这些类是不同聚合的一部分。当您查询数据库时，使用Spring数据JDBC的每次调用都是使用预先加载完成的，而不是春季数据JPA中标准的延迟加载。每次需要数据时，都会对数据库进行调用，因为不使用缓存。这些规则结合在一起，确保很容易知道何时（总是）对数据库的调用，从数据库调用（整个聚合）返回数据的哪些部分，并且很容易知道这些聚合由什么组成。

因为您负责在需要保存某些内容时进行保存，并且当您通过存储库执行调用时，将返回整个聚合。这样做的结果是，您需要自己做更多的事情，但它也使您可以完全控制整个数据流。

#### **性能** ####

使用Spring数据JDBC，您可以更好地控制将在数据库上执行的查询，因为它是直接在JDBC上执行的，而不是通过中间层。所有查询都是急切的，这也是一个优点，因为需要发送到数据库的查询更少。

当您通过 Spring 数据 JDBC 在聚合中创建或更新实体时，它将通过删除并再次保存这些实体来执行此操作。Spring Data JDBC需要这样做，因为它没有持久性上下文，并希望确保所有内容都是最新的。这样做的缺点是，有时可能会执行不必要的操作。

使用弹簧数据JPA，您可以更好地微调性能。例如，使用延迟加载和使用缓存的可能性。由于这些可能性，创建配置以获得良好性能也更加困难。

### **我应该使用它吗？** ###

在我看来，弹簧数据JDBC是弹簧数据系列的一个非常好的补充，具有很大的潜力。随着春季数据JDBC 1.1的发布，它变得更加稳定。如果您知道要遵循的规则，现在使用此技术创建一个简单的应用程序非常容易。使用Spring数据JDBC已经有很多优点，这些优势只有在添加功能时才会增长。

也有一些缺点。最大的缺点是它相当新，版本1.0是在不到2年前发布的。找到有关该技术的大量信息仍然相当困难，因此，如果您要使用该技术，则需要预留一些时间进行实验。

在这种情况下，我建议至少尝试一下这项技术，因为它的潜力很大。我在尝试这项技术时玩得很开心，我注意到它确实帮助我创建了一个好的应用程序。该技术通过使用两全其美的优势，在春季JDBC和春季数据JPA之间达到最佳状态。除此之外，他们还添加了一些不错的DDD原则。

所以简而言之，出去试试吧！

[Link 1]: https://ordina-jworks.github.io/java/2020/01/02/Spring-Data-Jdbc.html#introduction
[JDBC vs _ JDBC vs _ JPA]: https://ordina-jworks.github.io/java/2020/01/02/Spring-Data-Jdbc.html#spring-jdbc-vs-spring-data-jdbc-vs-spring-data-jpa
[Link 2]: https://ordina-jworks.github.io/java/2020/01/02/Spring-Data-Jdbc.html#project-differences
[Link 3]: https://ordina-jworks.github.io/java/2020/01/02/Spring-Data-Jdbc.html#inserting-data
[Link 4]: https://ordina-jworks.github.io/java/2020/01/02/Spring-Data-Jdbc.html#querying-the-database
[Link 5]: https://ordina-jworks.github.io/java/2020/01/02/Spring-Data-Jdbc.html#updating-an-instance
[JDBC]: https://ordina-jworks.github.io/java/2020/01/02/Spring-Data-Jdbc.html#advantages-of-using-spring-data-jdbc
[Link 6]: https://ordina-jworks.github.io/java/2020/01/02/Spring-Data-Jdbc.html#better-design
[Link 7]: https://ordina-jworks.github.io/java/2020/01/02/Spring-Data-Jdbc.html#easier-to-understand
[Link 8]: https://ordina-jworks.github.io/java/2020/01/02/Spring-Data-Jdbc.html#performance
[Link 9]: https://ordina-jworks.github.io/java/2020/01/02/Spring-Data-Jdbc.html#should-i-use-it
[Vaugn Vernon]: https://dddcommunity.org/library/vernon_2011/
[Spring]: https://docs.spring.io/spring-data/jpa/docs/current/reference/html/#repositories.query-methods.details