• Spring Data JPA实现数据的增删改查操作 ,save()操作，如果id不存在就insert新增，如果id存在就是update

    Spring Data JPA实现数据的增删改查操作
    https://blog.csdn.net/pan_junbiao/article/details/105245983

    1、JPA（Java持久层API）

    1.1 认识Spring Data

    Spring Data 是Spring的一个子项目，旨在统一和简化各类型数据的持久化存储方式，而不拘泥于是关系型数据库还是NoSQL数据库。无论是哪种持久化存储方式，数据访问对象（Data Access Objects，DAO）都会提供对对象的增加、删除、修改和查询的方法，以及排序和分页方法等。
    Spring Data 提供了基于这些层面的统一接口（如：CrudRepository、 PagingAndSortingRepository），以实现持久化的存储。

    1.2 认识JPA

    JPA（Java Persistence API）是Java的持久化API，用于对象的持久化。它是一个非常强大的ORM持久化的解决方案，免去了使用JDBCTemplate开发的编写脚本工作。JPA通过简单约定好接口方法的规则自动生成相应的JPQL语句，然后映射成POJO对象。

    JPA是一个规范化接口，封装了Hibernate的操作作为默认实现，让用户不通过任何配置即可完成数据库的操作。

    2、认识JPA的接口

    JPA提供了操作数据库的接口。在开发过程中继承和使用这些接口，可简化现有的持久化开发工作。可以使Spring找到自定义接口，并生成代理类，后续可以把自定义接口注入Spring容器中进行管理。在自定义接口过程中，可以不写相关的SQL操作，由代理类自动生成。

    2.1 JPA接口JpaRepository

    JpaRepository接口继承自PagingAndSortingRepository接口。该接口提供了JPA的相关实用功能，以及通过Example进行查询的功能。Example对象是JPA提供用来构造查询条件的对象。该接口的关键代码如下：

    1. public interface JpaRepository<T, ID> extends PagingAndSortingRepository<T, ID>, QueryByExampleExecutor<T> 
    2. {
    3. }

    在上述代码中，T 表示实体对象，ID 表示主键。ID必须实现序列号。

    JpaRepository接口的源代码如下：

    1. @NoRepositoryBean
    2. public interface JpaRepository<T, ID> extends PagingAndSortingRepository<T, ID>, QueryByExampleExecutor<T> 
    3. {
    4.     List<T> findAll();
    5.  
    6.     List<T> findAll(Sort var1);
    7.  
    8.     List<T> findAllById(Iterable<ID> var1);
    9.  
    10.     <S extends T> List<S> saveAll(Iterable<S> var1);
    11.  
    12.     void flush();
    13.  
    14.     <S extends T> S saveAndFlush(S var1);
    15.  
    16.     void deleteInBatch(Iterable<T> var1);
    17.  
    18.     void deleteAllInBatch();
    19.  
    20.     T getOne(ID var1);
    21.  
    22.     <S extends T> List<S> findAll(Example<S> var1);
    23.  
    24.     <S extends T> List<S> findAll(Example<S> var1, Sort var2);
    25. }

    JpaRepository接口提供的方法与说明：

    方法描述
    List<T> findAll();查找所有实体。
    List<T> findAll(Sort var1);排序、查找所有实体。
    List<T> findAllById(Iterable<ID> var1);返回制定一组ID的实体。
    <S extends T> List<S> saveAll(Iterable<S> var1);保存集合。
    void flush();执行缓存与数据库同步。
    <S extends T> S saveAndFlush(S var1);强制执行持久化。
    void deleteInBatch(Iterable<T> var1);删除一个实体集合。
    void deleteAllInBatch();删除所有实体。
    T getOne(ID var1);返回ID对应的实体。如果不存在，则返回空值。
    <S extends T> List<S> findAll(Example<S> var1);查询满足Example的所有对象。
    <S extends T> List<S> findAll(Example<S> var1, Sort var2);

    查询满足Example的所有对象，并且进行排序返回。

    2.2 数据操作接口CrudRepository

    CrudRepository接口继承自Repository接口，并新增了增加、删除、修改和查询方法。

    CrudRepository接口的源代码如下：

    1. @NoRepositoryBean
    2. public interface CrudRepository<T, ID> extends Repository<T, ID> 
    3. {
    4.     <S extends T> S save(S var1);
    5.  
    6.     <S extends T> Iterable<S> saveAll(Iterable<S> var1);
    7.  
    8.     Optional<T> findById(ID var1);
    9.  
    10.     boolean existsById(ID var1);
    11.  
    12.     Iterable<T> findAll();
    13.  
    14.     Iterable<T> findAllById(Iterable<ID> var1);
    15.  
    16.     long count();
    17.  
    18.     void deleteById(ID var1);
    19.  
    20.     void delete(T var1);
    21.  
    22.     void deleteAll(Iterable<? extends T> var1);
    23.  
    24.     void deleteAll();
    25. }

    CrudRepository接口提供的方法与说明：

    方法说明
    <S extends T> S save(S var1);保存实体。当实体中包含主键时，JPA会进行更新操作。
    <S extends T> Iterable<S> saveAll(Iterable<S> var1);保存所有实体。实体必须不为空。
    Optional<T> findById(ID var1);根据主键ID检索实体。
    boolean existsById(ID var1);根据主键ID检索实体，返回是否存在。值为布尔类型。
    Iterable<T> findAll();返回所有实体。
    Iterable<T> findAllById(Iterable<ID> var1);根据给定的一组ID值返回一组实体。
    long count();返回实体的数量
    void deleteById(ID var1);根据ID删除数据。
    void delete(T var1);删除给定的实体。
    void deleteAll(Iterable<? extends T> var1);删除实体。
    void deleteAll();删除所有实体。

    3、使用JPA实现数据的增删改查操作

    【实例】创建SpringBoot项目，使用JPA实现数据的增删改查操作。

    3.1 创建数据库表

    使用MySQL数据库，创建 tb_user 用户信息数据表，并添加测试数据。

    1. -- 判断数据表是否存在，存在则删除
    2. DROP TABLE IF EXISTS tb_user;
    3.  
    4. -- 创建“用户信息”数据表
    5. CREATE TABLE IF NOT EXISTS tb_user
    6. ( 
    7. 	user_id INT AUTO_INCREMENT PRIMARY KEY COMMENT '用户编号',
    8. 	user_name VARCHAR(50) NOT NULL COMMENT '用户姓名',
    9. 	blog_url VARCHAR(50) NOT NULL COMMENT '博客地址',
    10. 	remark VARCHAR(50) COMMENT '备注'
    11. ) COMMENT = '用户信息表';
    12.  
    13. -- 添加数据
    14. INSERT INTO tb_user(user_name,blog_url,remark) VALUES('pan_junbiao的博客','https://blog.csdn.net/pan_junbiao','您好，欢迎访问 pan_junbiao的博客');
    15. INSERT INTO tb_user(user_name,blog_url,remark) VALUES('pan_junbiao的博客_02','https://blog.csdn.net/pan_junbiao','您好，欢迎访问 pan_junbiao的博客');

    执行结果：

    3.2 创建项目并配置JPA环境

    （1）创建SpringBoot项目

    创建SpringBoot项目，并创建项目结构：dao（数据访问层）、service（服务层）、entity（实体层），如下图：

    （2）添加JPA和MySQL数据库的依赖

    在pom.xml配置文件中，添加如下依赖：

    1. <!-- Spring Data JPA -->
    2. <dependency>
    3.     <groupId>org.springframework.boot</groupId>
    4.     <artifactId>spring-boot-starter-data-jpa</artifactId>
    5. </dependency>
    6.  
    7. <!-- MySQL的JDBC数据库驱动 -->
    8. <dependency>
    9.     <groupId>mysql</groupId>
    10.     <artifactId>mysql-connector-java</artifactId>
    11.     <version>8.0.19</version>
    12. </dependency>

    （3）配置数据库连接信息

    SpringBoot项目使用MySQL等关系型数据库，需要配置连接信息。

    将默认的application.properties文件的后缀修改为“.yml”，即配置文件名称为：application.yml，并配置以下MySQL数据库的连接信息：

    1. spring:
    2.   datasource:
    3.     url: jdbc:mysql://localhost:3306/db_admin?useSSL=false&amp
    4.     username: root
    5.     password: 123456
    6.     driver-class-name: com.mysql.cj.jdbc.Driver
    7.   jpa:
    8.     database: MYSQL
    9.     show-sql: true
    10.     open-in-view: true
    11.     properties:
    12.       hibernate:
    13.         enable_lazy_load_no_trans: true
    14.         dialect: org.hibernate.dialect.MySQL5Dialect
    15.         ddl-auto: update

    3.3 实现增删改查代码

    （1）实体层（Entity层）

    在实体层（Entity层）中，创建UserInfo.java（用户信息实体类）。

    1. package com.pjb.jpauserdemo.entity;
    2.  
    3. import javax.persistence.*;
    4.  
    5. /**
    6.  * 用户信息实体类
    7.  * @author pan_junbiao
    8.  **/
    9. @Entity
    10. @Table(name = "tb_user")
    11. public class UserInfo
    12. {
    13.     //用户ID
    14.     @Id
    15.     @GeneratedValue(strategy = GenerationType.IDENTITY)
    16.     @Column(name = "user_id")
    17.     private int userId;
    18.  
    19.     //用户姓名
    20.     @Column(name = "user_name")
    21.     private String userName;
    22.  
    23.     //博客地址
    24.     @Column(name = "blog_url")
    25.     private String blogUrl;
    26.  
    27.     //备注
    28.     private String remark;
    29.  
    30.     //省略getter与setter方法...
    31. }

    （2）数据库访问层（Dao层）

    在数据库访问层（Dao层）中，创建UserDao.java（用户信息数据库访问接口），并继承JpaRepository接口。

    1. package com.pjb.jpauserdemo.dao;
    2.  
    3. import com.pjb.jpauserdemo.entity.UserInfo;
    4. import org.springframework.data.jpa.repository.JpaRepository;
    5. import org.springframework.stereotype.Repository;
    6.  
    7. /**
    8.  * 用户信息数据库访问接口
    9.  * @author pan_junbiao
    10.  **/
    11. @Repository
    12. public interface UserDao extends JpaRepository<UserInfo,Integer>
    13. {
    14. }

    （3）业务逻辑层（Service层）

    在业务逻辑层（Service层）中，创建UserService.java（用户业务逻辑接口）。

    1. package com.pjb.jpauserdemo.service;
    2.  
    3. import com.pjb.jpauserdemo.entity.UserInfo;
    4. import java.util.List;
    5.  
    6. /**
    7.  * 用户业务逻辑接口
    8.  * @author pan_junbiao
    9.  **/
    10. public interface UserService
    11. {
    12.     /**
    13.      * 根据用户ID，查询用户信息
    14.      */
    15.     public UserInfo findById(int userId);
    16.  
    17.     /**
    18.      * 查询用户列表
    19.      */
    20.     public List<UserInfo> findAll();
    21.  
    22.     /**
    23.      * 新增用户
    24.      */
    25.     public UserInfo save(UserInfo userInfo);
    26.  
    27.     /**
    28.      * 修改用户
    29.      */
    30.     public UserInfo edit(UserInfo userInfo);
    31.  
    32.     /**
    33.      * 删除用户
    34.      */
    35.     public boolean deleteById(int userId);
    36. }

    在业务逻辑层（Service层）下，创建 impl 目录，在该目录下创建UserServiceImpl.java（用户业务逻辑类）。

    1. package com.pjb.jpauserdemo.service.impl;
    2.  
    3. import com.pjb.jpauserdemo.dao.UserDao;
    4. import com.pjb.jpauserdemo.entity.UserInfo;
    5. import com.pjb.jpauserdemo.service.UserService;
    6. import org.springframework.beans.factory.annotation.Autowired;
    7. import org.springframework.stereotype.Service;
    8.  
    9. import java.util.List;
    10.  
    11. /**
    12.  * 用户业务逻辑类
    13.  * @author pan_junbiao
    14.  **/
    15. @Service
    16. public class UserServiceImpl implements UserService
    17. {
    18.     @Autowired
    19.     private UserDao userDao;
    20.  
    21.     /**
    22.      * 根据用户ID，查询用户信息
    23.      */
    24.     @Override
    25.     public UserInfo findById(int userId)
    26.     {
    27.         return userDao.findById(userId).get();
    28.     }
    29.  
    30.     /**
    31.      * 查询用户列表
    32.      */
    33.     @Override
    34.     public List<UserInfo> findAll()
    35.     {
    36.         return userDao.findAll();
    37.     }
    38.  
    39.     /**
    40.      * 新增用户
    41.      */
    42.     @Override
    43.     public UserInfo save(UserInfo userInfo)
    44.     {
    45.         return userDao.save(userInfo);
    46.     }
    47.  
    48.     /**
    49.      * 修改用户
    50.      */
    51.     @Override
    52.     public UserInfo edit(UserInfo userInfo)
    53.     {
    54.         return userDao.save(userInfo);
    55.     }
    56.  
    57.     /**
    58.      * 删除用户
    59.      */
    60.     @Override
    61.     public boolean deleteById(int userId)
    62.     {
    63.         boolean result = true;
    64.         try
    65.         {
    66.             userDao.deleteById(userId);
    67.         }
    68.         catch(Exception ex)
    69.         {
    70.             result = false;
    71.         }
    72.         return result;
    73.     }
    74. }

    3.4 执行测试

    3.4.1 查询数据

    1. @Autowired
    2. private UserService userService;
    3.  
    4. /**
    5.  * 测试：根据用户ID，查询用户信息
    6.  * @author pan_junbiao
    7.  */
    8. @Test
    9. public void findById()
    10. {
    11.     //查询用户编号为1的用户信息
    12.     UserInfo user = userService.findById(1);
    13.  
    14.     if (user != null)
    15.     {
    16.         //打印结果
    17.         System.out.println("用户编号：" + user.getUserId());
    18.         System.out.println("用户姓名：" + user.getUserName());
    19.         System.out.println("博客地址：" + user.getBlogUrl());
    20.         System.out.println("备注信息：" + user.getRemark());
    21.     }
    22. }

    执行结果：

    3.4.2 查询列表

    1. /**
    2.  * 测试：查询用户列表
    3.  * @author pan_junbiao
    4.  */
    5. @Test
    6. public void findAll()
    7. {
    8.     //查询用户列表
    9.     List<UserInfo> userList = userService.findAll();
    10.  
    11.     if (userList != null && userList.size() > 0)
    12.     {
    13.         for (UserInfo user : userList)
    14.         {
    15.             //打印结果
    16.             System.out.println("用户编号：" + user.getUserId());
    17.             System.out.println("用户姓名：" + user.getUserName());
    18.             System.out.println("博客地址：" + user.getBlogUrl());
    19.             System.out.println("备注信息：" + user.getRemark());
    20.             System.out.println("===========================================");
    21.         }
    22.     }
    23. }

    执行结果：

    3.4.3 新增操作

    1. /**
    2.  * 测试：新增用户
    3.  * @author pan_junbiao
    4.  */
    5. @Test
    6. public void save()
    7. {
    8.     //创建新用户
    9.     UserInfo user = new UserInfo();
    10.     user.setUserName("pan_junbiao的博客_03");
    11.     user.setBlogUrl("https://blog.csdn.net/pan_junbiao");
    12.     user.setRemark("您好，欢迎访问 pan_junbiao的博客");
    13.  
    14.     //执行新增操作
    15.     userService.save(user);
    16.  
    17.     //如果新增成功，则可以获取自增主键
    18.     //否则新增失败，则抛出异常
    19.     if (user.getUserId() > 0)
    20.     {
    21.         System.out.println("新增用户成功，新增的用户信息：");
    22.         System.out.println("用户编号：" + user.getUserId());
    23.         System.out.println("用户姓名：" + user.getUserName());
    24.         System.out.println("博客地址：" + user.getBlogUrl());
    25.         System.out.println("备注信息：" + user.getRemark());
    26.     }
    27. }

    执行结果：

    查询数据表：

    从查询的数据表结果中可以看到，成功新增了ID为3的用户信息。

    3.4.4 修改操作

    1. /**
    2.  * 测试：修改用户
    3.  * @author pan_junbiao
    4.  */
    5. @Test
    6. public void edit()
    7. {
    8.     //创建修改用户
    9.     UserInfo user = new UserInfo();
    10.     user.setUserId(3);
    11.     user.setUserName("pan_junbiao的博客_04");
    12.     user.setBlogUrl("https://blog.csdn.net/pan_junbiao");
    13.     user.setRemark("您好，欢迎访问 pan_junbiao的博客");
    14.  
    15.     //执行修改操作
    16.     userService.edit(user);
    17.  
    18.     //如果没有抛出异常，则表示执行成功
    19.     System.out.println("修改用户成功");
    20. }

    查询数据表：

    从查询的数据表结果中可以看到，ID为3的用户信息已被修改。

    3.4.5 删除操作

    1. /**
    2.  * 测试：删除用户
    3.  * @author pan_junbiao
    4.  */
    5. @Test
    6. public void deleteById()
    7. {
    8.     //执行新增操作
    9.     boolean result = userService.deleteById(3);
    10.  
    11.     //打印结果
    12.     if (result)
    13.     {
    14.         System.out.println("删除用户成功");
    15.     }
    16.     else
    17.     {
    18.         System.out.println("删除用户失败");
    19.     }
    20. }

    查询数据表：

    从查询的数据表结果中可以看到，ID为3的用户信息已被删除。

    3.4.6 完整的测试代码

    1. package com.pjb.jpauserdemo.service.impl;
    2.  
    3. import com.pjb.jpauserdemo.entity.UserInfo;
    4. import com.pjb.jpauserdemo.service.UserService;
    5. import org.junit.Test;
    6. import org.junit.runner.RunWith;
    7. import org.springframework.beans.factory.annotation.Autowired;
    8. import org.springframework.boot.test.context.SpringBootTest;
    9. import org.springframework.test.context.junit4.SpringRunner;
    10.  
    11. import java.util.List;
    12.  
    13.  
    14. /**
    15.  * 用户信息业务逻辑测试类
    16.  * @author pan_junbiao
    17.  **/
    18. @SpringBootTest
    19. @RunWith(SpringRunner.class)
    20. public class UserServiceImplTest
    21. {
    22.     @Autowired
    23.     private UserService userService;
    24.  
    25.     /**
    26.      * 测试：根据用户ID，查询用户信息
    27.      * @author pan_junbiao
    28.      */
    29.     @Test
    30.     public void findById()
    31.     {
    32.         //查询用户编号为1的用户信息
    33.         UserInfo user = userService.findById(1);
    34.  
    35.         if (user != null)
    36.         {
    37.             //打印结果
    38.             System.out.println("用户编号：" + user.getUserId());
    39.             System.out.println("用户姓名：" + user.getUserName());
    40.             System.out.println("博客地址：" + user.getBlogUrl());
    41.             System.out.println("备注信息：" + user.getRemark());
    42.             System.out.println("\n");
    43.         }
    44.     }
    45.  
    46.     /**
    47.      * 测试：查询用户列表
    48.      * @author pan_junbiao
    49.      */
    50.     @Test
    51.     public void findAll()
    52.     {
    53.         //查询用户列表
    54.         List<UserInfo> userList = userService.findAll();
    55.  
    56.         if (userList != null && userList.size() > 0)
    57.         {
    58.             for (UserInfo user : userList)
    59.             {
    60.                 //打印结果
    61.                 System.out.println("用户编号：" + user.getUserId());
    62.                 System.out.println("用户姓名：" + user.getUserName());
    63.                 System.out.println("博客地址：" + user.getBlogUrl());
    64.                 System.out.println("备注信息：" + user.getRemark());
    65.                 System.out.println("===========================================");
    66.             }
    67.         }
    68.     }
    69.  
    70.     /**
    71.      * 测试：新增用户
    72.      * @author pan_junbiao
    73.      */
    74.     @Test
    75.     public void save()
    76.     {
    77.         //创建新用户
    78.         UserInfo user = new UserInfo();
    79.         user.setUserName("pan_junbiao的博客_03");
    80.         user.setBlogUrl("https://blog.csdn.net/pan_junbiao");
    81.         user.setRemark("您好，欢迎访问 pan_junbiao的博客");
    82.  
    83.         //执行新增操作
    84.         userService.save(user);
    85.  
    86.         //如果新增成功，则可以获取自增主键
    87.         //否则新增失败，则抛出异常
    88.         if (user.getUserId() > 0)
    89.         {
    90.             System.out.println("新增用户成功，新增的用户信息：");
    91.             System.out.println("用户编号：" + user.getUserId());
    92.             System.out.println("用户姓名：" + user.getUserName());
    93.             System.out.println("博客地址：" + user.getBlogUrl());
    94.             System.out.println("备注信息：" + user.getRemark());
    95.         }
    96.     }
    97.  
    98.     /**
    99.      * 测试：修改用户
    100.      * @author pan_junbiao
    101.      */
    102.     @Test
    103.     public void edit()
    104.     {
    105.         //创建修改用户
    106.         UserInfo user = new UserInfo();
    107.         user.setUserId(3);
    108.         user.setUserName("pan_junbiao的博客_04");
    109.         user.setBlogUrl("https://blog.csdn.net/pan_junbiao");
    110.         user.setRemark("您好，欢迎访问 pan_junbiao的博客");
    111.  
    112.         //执行修改操作
    113.         userService.edit(user);
    114.  
    115.         //如果没有抛出异常，则表示执行成功
    116.         System.out.println("修改用户成功");
    117.     }
    118.  
    119.     /**
    120.      * 测试：删除用户
    121.      * @author pan_junbiao
    122.      */
    123.     @Test
    124.     public void deleteById()
    125.     {
    126.         //执行新增操作
    127.         boolean result = userService.deleteById(3);
    128.  
    129.         //打印结果
    130.         if (result)
    131.         {
    132.             System.out.println("删除用户成功");
    133.         }
    134.         else
    135.         {
    136.             System.out.println("删除用户失败");
    137.         }
    138.     }
    139. }
  • 相关阅读:
    linux PCI 接口
    Linux 内核链表头数据结构
    Linux内核链表
    spawn-fcgi原理及源代码分析
    TRIZ系列-创新原理-17-转变到新维度原理
    《转》ceilometer的数据採集机制入门
    git配置文件读取顺序
    Android Studio 使用感受 错误解决
    scikit-learn：在实际项目中用到过的知识点（总结）
    //%f表示以十进制格式化输出浮点数 %.2f
  • 原文地址：https://www.cnblogs.com/sunny3158/p/16353791.html
Copyright © 2020-2023  润新知