【SpringBoot整合系列】SpringBoot整合JPA

已于 2024-04-24 14:16:01 修改
阅读量1k 收藏 19
点赞数 10
分类专栏： Java SpringBoot 文章标签： spring boot java spring 数据库 hibernate mysql javaee
于 2024-04-24 14:14:54 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_37833693/article/details/138152803
版权

目录

前期回顾

ORM解决方案

框架名称所属公司适用场合
Hibernate创始人：Gavin King
公司：JBOSS 所有		适用与需求变化不多的中小型项目中，比如后台管理系统
MybatisApache社区适用于表关联较多的项目，持续维护开发迭代较快的项目，需求变化较多的项目，如互联网项目
Mybatis-Plus苞米豆社区, 为猿类崛起而生MyBatis-Plus是一个 MyBatis的增强工具，在 MyBatis 的基础上只做增强不做改变，为简化开发、提高效率而生。
Spring Data JPASpring的母公司是VMware传统项目或者关系模型较为清晰稳定的项目，建议JPA

JPA

简介

  • JPA是Java Persistence API的简称，中文名Java持久层API，是Sun公司在JDK5.0后提出的一套基于ORM的Java持久化规范。它为Java开发人员提供了一种对象/关联映射工具来管理Java应用中的关系数据。
  • Sun公司引入新的JPA ORM规范出于两个原因：
    • 其一，简化现有Java EE和Java SE应用开发工作；
    • 其二，结束Hibernate、TopLink、JDO等ORM框架各自为营的局面。Sun公司希望整合ORM技术，实现天下归一；
  • JPA是在吸收现有ORM框架的基础上发展而来，具有易于使用，伸缩性强等优点。
  • 由于JPA只是一个规范，它本身不执行任何操作。 它需要一个实现。 因此，像Hibernate，TopLink和iBatis这样的ORM工具实现了JPA数据持久性规范。
  • JSR 338，详细内容可参考：https://github.com/javaee/jpa-spec）

JPA的组成技术

ORM映射元数据

  • JPA支持XML和JDK5.0注解两种元数据的形式，元数据描述对象和表之间的映射关系，框架据此将实体对象持久化到数据库表中；

Java持久化API

  • 用来操作实体对象，执行CRUD操作，框架在后台替代我们完成所有的事情，开发者从繁琐的JDBC和SQL代码中解脱出来。

查询语言（JPQL）

  • 这是持久化操作中很重要的一个方面，通过面向对象的查询语言查询数据，避免程序和SQL语句紧密耦合。

JPA的优势

  1. 简化开发：Jpa提供了一种面向对象的方式来进行数据库操作，开发人员可以使用Java对象来表示数据库表和记录，而不需要编写复杂的SQL语句。这样可以大大简化开发过程，提高开发效率。
  2. 高度抽象：Jpa提供了一套高度抽象的API，隐藏了底层数据库的细节，开发人员可以更加专注于业务逻辑的实现，而不需要关注数据库的具体实现细节。这样可以降低开发的复杂性，提高代码的可维护性。
  3. 跨数据库支持：Jpa支持多种数据库，开发人员可以在不同的数据库之间切换，而不需要修改大量的代码。这样可以提高系统的灵活性和可扩展性。
  4. 自动化的事务管理：Jpa提供了自动化的事务管理机制，开发人员可以使用注解来标识事务的边界，Jpa会自动处理事务的提交和回滚。这样可以简化事务管理的代码，提高系统的稳定性和可靠性。

JPA的缺点

  1. 学习成本较高：Jpa是一种复杂的技术，需要开发人员具备一定的数据库和ORM（对象关系映射）的知识。对于初学者来说，学习和掌握Jpa可能需要一定的时间和精力。
  2. 性能问题：由于Jpa是一种高度抽象的技术，它会对数据库的访问和操作进行一定的封装和转换，这可能会导致一定的性能损失。在对性能要求较高的场景下，可能需要使用原生的SQL语句来进行数据库操作。
  3. 灵活性受限：Jpa提供了一套标准的API，开发人员需要按照这套API来进行开发，这可能会限制一些特定的需求和场景。在一些复杂的业务场景下，可能需要使用原生的SQL语句或其他ORM框架来实现。

Spring Data JPA

Spring Data JPA简介

  • 官网：https://spring.io/projects/spring-data-jpa
  • Spring Data JPA是Spring Data家族的一部分，可以轻松实现基于JPA的存储库。 此模块处理对基于JPA的数据访问层的增强支持。 它使构建使用数据访问技术的Spring驱动应用程序变得更加容易。
  • Spring Data JPA 是 Spring 基于 ORM 框架、JPA 规范的基础上封装的一套JPA应用框架，可使开发者用极简的代码即可实现对数据的访问和操作。它提供了包括增删改查等在内的常用功能，且易于扩展。
  • 在相当长的一段时间内，实现应用程序的数据访问层一直很麻烦。 必须编写太多样板代码来执行简单查询以及执行分页和审计。 Spring Data JPA旨在通过减少实际需要的工作量来显著改善数据访问层的实现。

Spring Data 家族

  • Spring Data的官网：http://projects.spring.io/spring-data/
  • Spring Data是Spring的一个子项目，旨在统一和简化各类型的持久化存储方式，而不拘泥于是关系型数据库还是NoSQL数据库。
  • Spring Data 的使命是给各种数据访问提供统一的编程接口，从而简化开发人员的代码，提高开发效率。
  • 无论是哪种持久化存储方式，数据库访问对象都会提供对对象的增加、删除、修改和查询的方法，以及排序和分页方法等。
    在这里插入图片描述

Spring Data JPA、JPA和其他框架之间的关系

  • JPA是一套规范，而不是具体的ORM框架。
  • Hibernate、TopLink等是JPA规范的具体实现，这样的好处是开发者可以面向JPA规范进行持久层的开发，而底层的实现则是可以切换的。
  • Spring Data Jpa则是在JPA之上添加另一层抽象，极大地简化持久层开发及ORM框架切换的成本
    在这里插入图片描述

SpringBoot整合JPA

JPA的核心注解

在这里插入图片描述在这里插入图片描述

1.依赖

		<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>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.47</version>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>

2.添加配置

server:
  port: 9999
spring:
  datasource:
    driver-class-name: com.mysql.jdbc.Driver
    url: jdbc:mysql://localhost:3306/smbms?useUnicode=true&characterEncoding=utf-8&useSSL=false&serverTimezone=Asia/Shanghai
    username: root
    password: 123456
    type: com.zaxxer.hikari.HikariDataSource
  jpa:
    hibernate:
      ddl-auto: update
      naming:
        physical-strategy: org.hibernate.boot.model.naming.PhysicalNamingStrategyStandardImpl
    show-sql: true
    database-platform: org.hibernate.dialect.MySQL5InnoDBDialect

3.实体类

package cn.smbms.pojo;

import lombok.Data;
import org.springframework.format.annotation.DateTimeFormat;

import javax.persistence.*;
import java.util.Date;

/**
 * @author: zjl
 * @datetime: 2024/4/23
 * @desc:
 */
@Data
@Table(name = "smbms_user")
@Entity
public class User {
    @Id
    @Column(name = "id")
    @GeneratedValue(strategy = GenerationType.AUTO)
    private Integer id;
    @Column(name = "userCode")
    private String userCode;
    private String userName;
    private String userPassword;
    private Integer gender;
    @DateTimeFormat(pattern = "yyyy-MM-dd")
    private Date birthday;
    @Column(name = "phone",nullable = false)
    private String phone;
    private String address;
    @Column(name = "userRole",updatable = false)
    private Integer userRole;
    private Integer createdBy;
    @DateTimeFormat(pattern = "yyyy-MM-dd")
    private Date creationDate;
    private Integer modifyBy;
    @DateTimeFormat(pattern = "yyyy-MM-dd")
    private Date modifyDate;
}

4.创建数据访问层接口继承自JpaRepository<T, ID>接口

  • JpaRepository拥有基本CRUD功能以及分页功能
    在这里插入图片描述

  • JpaRepository继承自PagingAndSortingRepository。
    在这里插入图片描述

    • 分页接口和实现类
      • Pageable 是Spring Data库中定义的一个接口，用于构造翻页查询，是所有分页相关信息的一个抽象，通过该接口，我们可以得到和分页相关所有信息（例如pageNumber、pageSize等），这样，Jpa就能够通过Pageable参数来得到一个带分页信息的Sql语句
      • PageRequest：Pageable接口的实现类
      • Page接口：用于储存查询的结果集
    • 排序

  • 泛型 T 为任意实体对象，ID为主键的数据类型

public interface UserRepository extends JpaRepository<User, Integer> {
}

5.添加用户业务实现类

@Service
public class UserService {
    @Resource
    private UserRepository userRepository;
    public User saveOrUpdate(User user){
        User saveUser = userRepository.save(user);
        return saveUser;
    }
}

6.测试

测试添加

  • 因为设置了主键ID的策略为自增，因此不用传ID就会执行添加操作。
  • 也可以传一个不存在的ID，也会执行新增操作，但是主键并不是自定义的主键值，而是自增的主键值
@SpringBootTest
class JpabootApplicationTests {
    @Resource
    private UserService userService;
    @Test
    void saveOrUpdate() {
        User user = new User();
        user.setUserName("薇恩");
        user.setUserCode("VN");
        user.setAddress("下路");
        user.setPhone("180xxxx4568");
        user.setUserRole(3);
        User saveResult = userService.saveOrUpdate(user);
        System.out.println(saveResult);
    }
}
  • 执行结果如下：
    Hibernate: select next_val as id_val from hibernate_sequence for update
Hibernate: update hibernate_sequence set next_val= ? where next_val=?
Hibernate: insert into smbms_user (address, birthday, createdBy, creationDate, gender, modifyBy, modifyDate, phone, userCode, userName, userPassword, userRole, id) values (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
User(id=31, userCode=VN, userName=暗夜射手, userPassword=null, gender=null, birthday=null, phone=180xxxx4568, address=下路, userRole=3, createdBy=null, creationDate=null, modifyBy=null, modifyDate=null)

如果不传phone的话，会报错，提示phone属性不能为空

测试修改

  • 传一个已存在的ID，会触发修改，若属性为空，会将对应的字段值也修改为空，因此需要特别注意
    @Test
    void saveOrUpdate() {
        User user = new User();
        user.setId(31);
        user.setUserName("暗夜射手");
        user.setUserCode("VN");
        //user.setAddress("下路");
        user.setPhone("180xxxx4568");
        user.setUserRole(3);
        User saveResult = userService.saveOrUpdate(user);
        System.out.println(saveResult);
    }
  • 因为userRole设置了updatable = false，因此数据中这个字段的值还会是3，而不是2
  • 执行结果如下：
    Hibernate: select user0_.id as id1_0_0_, user0_.address as address2_0_0_, user0_.birthday as birthday3_0_0_, user0_.createdBy as createdb4_0_0_, user0_.creationDate as creation5_0_0_, user0_.gender as gender6_0_0_, user0_.modifyBy as modifyby7_0_0_, user0_.modifyDate as modifyda8_0_0_, user0_.phone as phone9_0_0_, user0_.userCode as usercod10_0_0_, user0_.userName as usernam11_0_0_, user0_.userPassword as userpas12_0_0_, user0_.userRole as userrol13_0_0_ from smbms_user user0_ where user0_.id=?
Hibernate: update smbms_user set address=?, birthday=?, createdBy=?, creationDate=?, gender=?, modifyBy=?, modifyDate=?, phone=?, userCode=?, userName=?, userPassword=? where id=?
User(id=31, userCode=VN, userName=暗夜射手, userPassword=null, gender=null, birthday=null, phone=180xxxx4568, address=null, userRole=3, createdBy=null, creationDate=null, modifyBy=null, modifyDate=null)

测试简单查询

service层

    public User findUserById(Integer id){
        return userRepository.findById(id).get();
    }

测试

    @Test
    void findUserById() {
        User user = userService.findUserById(1);
        System.out.println(user);
    }

执行结果如下：

Hibernate: select user0_.id as id1_0_0_, user0_.address as address2_0_0_, user0_.birthday as birthday3_0_0_, user0_.createdBy as createdb4_0_0_, user0_.creationDate as creation5_0_0_, user0_.gender as gender6_0_0_, user0_.modifyBy as modifyby7_0_0_, user0_.modifyDate as modifyda8_0_0_, user0_.phone as phone9_0_0_, user0_.userCode as usercod10_0_0_, user0_.userName as usernam11_0_0_, user0_.userPassword as userpas12_0_0_, user0_.userRole as userrol13_0_0_ from smbms_user user0_ where user0_.id=?
User(id=1, userCode=admin, userName=系统管理员, userPassword=0000aaaa, gender=1, birthday=1983-10-10 00:00:00.0, phone=13688889999, address=北京市海淀区成府路207号, userRole=1, createdBy=1, creationDate=2013-03-21 16:52:07.0, modifyBy=null, modifyDate=null)

测试删除(简单和批量删除)

service层

    public void delete() {
        userRepository.deleteById(27);

        User user1 = userRepository.findById(28).get();
        User user2 = userRepository.findById(29).get();
        User user3 = userRepository.findById(30).get();
        List<User> users = new ArrayList<>(Arrays.asList(user1,user2,user3));

        userRepository.deleteInBatch(users);
    }

测试

    @Test
    void delete() {
        userService.delete();
    }

执行结果如下：

Hibernate: select user0_.id as id1_0_0_, user0_.address as address2_0_0_, user0_.birthday as birthday3_0_0_, user0_.createdBy as createdb4_0_0_, user0_.creationDate as creation5_0_0_, user0_.gender as gender6_0_0_, user0_.modifyBy as modifyby7_0_0_, user0_.modifyDate as modifyda8_0_0_, user0_.phone as phone9_0_0_, user0_.userCode as usercod10_0_0_, user0_.userName as usernam11_0_0_, user0_.userPassword as userpas12_0_0_, user0_.userRole as userrol13_0_0_ from smbms_user user0_ where user0_.id=?
Hibernate: delete from smbms_user where id=?
Hibernate: select user0_.id as id1_0_0_, user0_.address as address2_0_0_, user0_.birthday as birthday3_0_0_, user0_.createdBy as createdb4_0_0_, user0_.creationDate as creation5_0_0_, user0_.gender as gender6_0_0_, user0_.modifyBy as modifyby7_0_0_, user0_.modifyDate as modifyda8_0_0_, user0_.phone as phone9_0_0_, user0_.userCode as usercod10_0_0_, user0_.userName as usernam11_0_0_, user0_.userPassword as userpas12_0_0_, user0_.userRole as userrol13_0_0_ from smbms_user user0_ where user0_.id=?
Hibernate: select user0_.id as id1_0_0_, user0_.address as address2_0_0_, user0_.birthday as birthday3_0_0_, user0_.createdBy as createdb4_0_0_, user0_.creationDate as creation5_0_0_, user0_.gender as gender6_0_0_, user0_.modifyBy as modifyby7_0_0_, user0_.modifyDate as modifyda8_0_0_, user0_.phone as phone9_0_0_, user0_.userCode as usercod10_0_0_, user0_.userName as usernam11_0_0_, user0_.userPassword as userpas12_0_0_, user0_.userRole as userrol13_0_0_ from smbms_user user0_ where user0_.id=?
Hibernate: select user0_.id as id1_0_0_, user0_.address as address2_0_0_, user0_.birthday as birthday3_0_0_, user0_.createdBy as createdb4_0_0_, user0_.creationDate as creation5_0_0_, user0_.gender as gender6_0_0_, user0_.modifyBy as modifyby7_0_0_, user0_.modifyDate as modifyda8_0_0_, user0_.phone as phone9_0_0_, user0_.userCode as usercod10_0_0_, user0_.userName as usernam11_0_0_, user0_.userPassword as userpas12_0_0_, user0_.userRole as userrol13_0_0_ from smbms_user user0_ where user0_.id=?
Hibernate: delete from smbms_user where id=? or id=? or id=?

SpringData JPA的查询

第一种查询方式：约定方法名

  • Spring Data JPA会根据前缀、中间连接词(Or、And、Like、NotNull等类似SQL中的关键词)，内部拼接SQL代理生成方法的实现。
  • 约定方法名一定要符合命名规范
关键词SQL符号样例对应JPQL 语句片段
AndandfindByLastnameAndFirstname… where x.lastname = ?1 and x.firstname = ?2
OrorfindByLastnameOrFirstname… where x.lastname = ?1 or x.firstname = ?2
Is,Equals=findByFirstname,findByFirstnameIs,findByFirstnameEquals… where x.firstname = ?1
Betweenbetween xxx and xxxfindByStartDateBetween… where x.startDate between ?1 and ?2
LessThan<findByAgeLessThan… where x.age < ?1
LessThanEqual<=findByAgeLessThanEqual… where x.age <= ?1
GreaterThan>findByAgeGreaterThan… where x.age > ?1
GreaterThanEqual>=findByAgeGreaterThanEqual… where x.age >= ?1
After>findByStartDateAfter… where x.startDate > ?1
Before<findByStartDateBefore… where x.startDate < ?1
IsNullis nullfindByAgeIsNull… where x.age is null
IsNotNull,NotNullis not nullfindByAge(Is)NotNull… where x.age not null
LikelikefindByFirstnameLike… where x.firstname like ?1
NotLikenot likefindByFirstnameNotLike… where x.firstname not like ?1
StartingWithlike ‘xxx%’findByFirstnameStartingWith… where x.firstname like ?1(parameter bound with appended %)
EndingWithlike ‘xxx%’findByFirstnameEndingWith… where x.firstname like ?1(parameter bound with prepended %)
Containinglike ‘%xxx%’findByFirstnameContaining… where x.firstname like ?1(parameter bound wrapped in %)
OrderByorder byfindByAgeOrderByLastnameDesc… where x.age = ?1 order by x.lastname desc
Not<>findByLastnameNot… where x.lastname <> ?1
Inin()findByAgeIn(Collection ages)… where x.age in ?1
NotInnot in()findByAgeNotIn(Collection ages)… where x.age not in ?1
TRUE=truefindByActiveTrue()… where x.active = true
FALSE=falsefindByActiveFalse()… where x.active = false
IgnoreCaseupper(xxx)=upper(yyyy)findByFirstnameIgnoreCase… where UPPER(x.firstame) = UPPER(?1)

示例

dao层

public interface UserRepository extends JpaRepository<User, Integer> {
    User findByUserCode(String userCode);
}

service层

    public Object findByUserCode(String userCode){
        return userRepository.findByUserCode(userCode);
    }

测试

    @Test
    void findByUserCode() {
        userService.findByUserCode("admin");
    }

执行结果如下：

Hibernate: select user0_.id as id1_0_, user0_.address as address2_0_, user0_.birthday as birthday3_0_, user0_.createdBy as createdb4_0_, user0_.creationDate as creation5_0_, user0_.gender as gender6_0_, user0_.modifyBy as modifyby7_0_, user0_.modifyDate as modifyda8_0_, user0_.phone as phone9_0_, user0_.userCode as usercod10_0_, user0_.userName as usernam11_0_, user0_.userPassword as userpas12_0_, user0_.userRole as userrol13_0_ from smbms_user user0_ where user0_.userCode=?

第二种查询方式：使用JPQL查询

  • JPQL的全称为Java Persistence Query Language,是一种和SQL非常类似的中间性和对象化查询语言，它最终会被编译成针对不同底层数据库的SQL语言，从而屏蔽不同数据库之间的差异。
  • JPQL和SQL很像,查询关键字都是一样的，唯一的区别是JPQL是面向对象的。
  • JPQL里面不能出现表名,列名,只能出现Java的类名,属性名，并且区分大小写。不能使用select *。
  • JPQL通过@Query注解，封装了执行数据库的查询的相关方法

示例

dao层

    @Query(value = "select u.userName from User u where u.userCode=?1")
    //@Query(value = "select u from User u where u.userCode=?1")
    String selByCode(String userCode);

service层

    public Object findByUserCode(String userCode){
        //return userRepository.findByUserCode(userCode);
        return userRepository.selByCode(userCode);
    }

测试执行结果如下：

Hibernate: select user0_.userName as col_0_0_ from smbms_user user0_ where user0_.userCode=?

第三种查询方式：使用Exampler查询

  • 在 JpaRepository<T, ID>接口中定义了如下的方法
    • List findAll(Example var1);
    • List findAll(Example var1, Sort var2);
  • Example接口，代表的是完整的查询条件。由实体对象（查询条件值）和匹配器（查询方式）共同创建。最终根据实例来findAll即可。
  • 匹配器：ExampleMatcher对象，它是匹配“实体对象”的，表示了如何使用“实体对象”中的“值”进行查询，它代表的是“查询方式”，解释了如何去查的问题。
  • 如：要查询姓“王”的客户，即姓名以“王”开头的客户，该对象就表示了“以某某开头的”这个查询方式。

示例

service层

    public List<User> getUser() {
        User user = new User();
        //user.setUserCode("zhanghua");
        user.setUserRole(3);
        user.setCreatedBy(2);
        Example<User> example = Example.of(user);
        return userRepository.findAll(example);
    }

测试

    @Test
    void getUser() {
        List<User> userList = userService.getUser();
        userList.forEach(System.out::println);
    }

执行结果如下:

Hibernate: select user0_.id as id1_0_, user0_.address as address2_0_, user0_.birthday as birthday3_0_, user0_.createdBy as createdb4_0_, user0_.creationDate as creation5_0_, user0_.gender as gender6_0_, user0_.modifyBy as modifyby7_0_, user0_.modifyDate as modifyda8_0_, user0_.phone as phone9_0_, user0_.userCode as usercod10_0_, user0_.userName as usernam11_0_, user0_.userPassword as userpas12_0_, user0_.userRole as userrol13_0_ from smbms_user user0_ where user0_.userRole=3 and user0_.createdBy=2
User(id=8, userCode=zhaoyan, userName=赵燕, userPassword=1, gender=1, birthday=1986-03-07 00:00:00.0, phone=18098764545, address=北京市海淀区回龙观小区10号楼, userRole=3, createdBy=2, creationDate=2016-04-21 13:54:07.0, modifyBy=null, modifyDate=null)
User(id=10, userCode=sunlei, userName=孙磊, userPassword=1, gender=2, birthday=1981-01-04 00:00:00.0, phone=13387676765, address=北京市朝阳区管庄新月小区12楼, userRole=3, createdBy=2, creationDate=2015-05-06 10:52:07.0, modifyBy=null, modifyDate=null)

第四种查询方式：使用原生SQL查询

  • JPQL通过@Query注解，封装了执行数据库的查询的相关方法在

示例

dao层

    @Query(value = "select * from smbms_user where phone = :phone",nativeQuery = true)
    List<User> getUserByPhone(@Param("phone") String phone);

service层

    public  List<User> findUserByPhone() {
        return userRepository.getUserByPhone("13387676765");
    }

测试执行结果如下：

Hibernate: select * from smbms_user where phone = ?
User(id=10, userCode=sunlei, userName=孙磊, userPassword=1, gender=2, birthday=1981-01-04 00:00:00.0, phone=13387676765, address=北京市朝阳区管庄新月小区12楼, userRole=3, createdBy=2, creationDate=2015-05-06 10:52:07.0, modifyBy=null, modifyDate=null)

分页查询：

方式1：PagingAndSortingRepository分页接口，适用于简单的分页查询;

示例1

service层

    public Page<User> page(Integer currentPage) {
        User user = new User();
        //user.setUserCode("zhanghua");
        user.setUserRole(3);
        user.setCreatedBy(1);
        ExampleMatcher matcher = ExampleMatcher.matching()
                .withIgnoreCase()
                .withStringMatcher(ExampleMatcher.StringMatcher.CONTAINING);
        Example<User> example = Example.of(user,matcher);
        Pageable pageable = PageRequest.of(currentPage-1,5, Sort.by(Sort.Order.desc("birthday")));
        return userRepository.findAll(example,pageable);
    }

测试

    @Test
    void page() {
        Page<User> pageResult = userService.page(1);
        System.out.println(pageResult);
    }

执行结果如下：

Hibernate: select user0_.id as id1_0_, user0_.address as address2_0_, user0_.birthday as birthday3_0_, user0_.createdBy as createdb4_0_, user0_.creationDate as creation5_0_, user0_.gender as gender6_0_, user0_.modifyBy as modifyby7_0_, user0_.modifyDate as modifyda8_0_, user0_.phone as phone9_0_, user0_.userCode as usercod10_0_, user0_.userName as usernam11_0_, user0_.userPassword as userpas12_0_, user0_.userRole as userrol13_0_ from smbms_user user0_ where user0_.createdBy=1 and user0_.userRole=3 order by user0_.birthday desc limit ?
Page 1 of 1 containing cn.smbms.pojo.User instances
示例2：

dao层

    Page<User> findByUserCode(String userCode, Pageable pageable);

service层

    public Page<User> page(Integer currentPage) {
        Pageable pageable = PageRequest.of(currentPage-1,5, Sort.by(Sort.Order.desc("birthday")));
        return userRepository.findByUserCode("admin",pageable);
    }

方式2：Specification。自定义方法findAll，适用于动态分页查询；

  • Specification 是Spring Data JPA提供的一种用于构建动态查询条件的接口，可以根据不同的条件动态组合查询条件,自定义的UserRepository 必须实现JpaSpecificationExecutor接口
示例

dao层

Page<SysUser> findAll(Specification<SysUser> specification,Pageable pageable);

service层

@Override
    public Page<SysUser> findUserList(String userName, Integer userRole, Integer currentPageNo, Integer pageSize) throws Exception {
        Specification<SysUser> specification=new Specification<SysUser>() {
            @Override
            public Predicate toPredicate(Root<SysUser> root, CriteriaQuery<?> criteriaQuery, CriteriaBuilder criteriaBuilder) {
                //断言
                List<Predicate> predicateList=new ArrayList<>();
                if(!StringUtils.isEmpty(userName)){
                    Predicate predicate=criteriaBuilder.like(root.get("userName").as(String.class),"%"+userName+"%");
                    predicateList.add(predicate);
                }
                if(!StringUtils.isEmpty(userRole) && userRole>0){
                    Predicate predicate=criteriaBuilder.equal(root.get("userRole").as(Integer.class),userRole);
                    predicateList.add(predicate);
                }
                return criteriaBuilder.and(predicateList.toArray(new Predicate[0]));
            }
        };
        Sort sort=Sort.by(Sort.Order.desc("id"));
        Pageable pageable=PageRequest.of(currentPageNo-1,pageSize,sort);
        return userRepository.findAll(specification,pageable);
    }

SpringData JPA配置多数据源

同源数据库的多源支持

日常项目中因为使用的分布式开发模式，不同的服务有不同的数据源，常常需要在一个项目中使用多个数据源，因此需要配置 Spring Boot Jpa 对多数据源的使用，一般分一下为三步：

  1. 配置多数据源
  2. 不同源的实体类放入不同包路径
  3. 声明不同的包路径下使用不同的数据源、事务支持

异构数据库多源支持

比如我们的项目中，即需要对 mysql 的支持，也需要对 Mongodb 的查询等。实体类声明@Entity 关系型数据库支持类型，声明@Document 为 Mongodb 支持类型，不同的数据源使用不同的实体就可以了。

示例

interface PersonRepository extends Repository<Person, Long> {
 …
}

@Entity
public class Person {
  …
}

interface UserRepository extends Repository<User, Long> {
 …
}

@Document
public class User {
  …
}

如果 User 用户既使用 Mysql 也使用 Mongodb也可以做混合使用

interface JpaPersonRepository extends Repository<Person, Long> {
 …
}

interface MongoDBPersonRepository extends Repository<Person, Long> {
 …
}

@Entity
@Document
public class Person {
  …
}

也可以通过对不同的包路径进行声明，比如 A 包路径下使用 mysql，B 包路径下使用 MongoDB。

@EnableJpaRepositories(basePackages = "com.neo.repositories.jpa")
@EnableMongoRepositories(basePackages = "com.neo.repositories.mongo")
interface Configuration { }

多数据源使用案例

1.依赖

略

2.配置

spring:
  datasource:
    smbms:
      driver-class-name: com.mysql.jdbc.Driver
      url: jdbc:mysql://localhost:3306/smbms?useUnicode=true&characterEncoding=utf-8&useSSL=false&
      username: root
      password: 123456
    news:
      driver-class-name: com.mysql.jdbc.Driver
      url: jdbc:mysql://localhost:3306/news?useUnicode=true&characterEncoding=utf-8&useSSL=false&
      username: root
      password: 123456
  jpa:
    show-sql: true
    properties:
      hibernate:
        hbm2ddl:
          auto: update
        dialect: org.hibernate.dialect.MySQL5InnoDBDialect
        format_sql: true

3.实体类

略

4.配置类

package cn.smbms.config;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.autoconfigure.orm.jpa.HibernateProperties;
import org.springframework.boot.autoconfigure.orm.jpa.HibernateSettings;
import org.springframework.boot.autoconfigure.orm.jpa.JpaProperties;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.boot.jdbc.DataSourceBuilder;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;

import javax.annotation.Resource;
import javax.sql.DataSource;
import java.util.Map;

/**
 * @author: zjl
 * @datetime: 2024/4/24
 * @desc:
 */
@Configuration
public class DataSourceConfig {

    @Resource
    private JpaProperties jpaProperties;

    @Resource
    private HibernateProperties hibernateProperties;

    @Bean(name = "smbmsDataSource")
    @Primary
    @ConfigurationProperties("spring.datasource.smbms")
    public DataSource firstDataSource() {
        return DataSourceBuilder.create().build();
    }

    @Bean(name = "secondaryDataSource")
    @ConfigurationProperties("spring.datasource.secondary")
    public DataSource secondDataSource() {
        return DataSourceBuilder.create().build();
    }

    @Bean(name = "vendorProperties")
    public Map<String, Object> getVendorProperties() {
        return hibernateProperties.determineHibernateProperties(jpaProperties.getProperties(),
                new HibernateSettings());
    }
}

package cn.smbms.config;

import org.springframework.boot.orm.jpa.EntityManagerFactoryBuilder;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;
import org.springframework.data.jpa.repository.config.EnableJpaRepositories;
import org.springframework.orm.jpa.JpaTransactionManager;
import org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean;
import org.springframework.transaction.PlatformTransactionManager;
import org.springframework.transaction.annotation.EnableTransactionManagement;

import javax.annotation.Resource;
import javax.persistence.EntityManager;
import javax.sql.DataSource;
import java.util.Map;

/**
 * @author: zjl
 * @datetime: 2024/4/24
 * @desc:
 */
@Configuration
@EnableTransactionManagement
@EnableJpaRepositories(
        entityManagerFactoryRef = "entityManagerFactoryPrimary",
        transactionManagerRef = "transactionManagerPrimary",
        basePackages = {"cn.smbms.dao"})//设置dao（repo）所在位置
public class SmbmsConfig {

    @Resource(name = "smbmsDataSource")
    private DataSource dataSource;

    @Resource(name = "vendorProperties")
    private Map<String, Object> vendorProperties;

    @Bean(name = "entityManagerFactoryPrimary")
    @Primary
    public LocalContainerEntityManagerFactoryBean entityManagerFactoryPrimary(EntityManagerFactoryBuilder builder) {
        return builder
                .dataSource(dataSource)
                .properties(vendorProperties)
                .packages("cn.smbms.pojo") //设置实体类所在位置
                .persistenceUnit("primaryPersistenceUnit")
                .build();
    }

    @Bean(name = "entityManagerPrimary")
    @Primary
    public EntityManager entityManager(EntityManagerFactoryBuilder builder) {
        return entityManagerFactoryPrimary(builder).getObject().createEntityManager();
    }

    @Bean(name = "transactionManagerPrimary")
    @Primary
    PlatformTransactionManager transactionManagerPrimary(EntityManagerFactoryBuilder builder) {
        return new JpaTransactionManager(entityManagerFactoryPrimary(builder).getObject());
    }

}

package cn.smbms.config;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.orm.jpa.EntityManagerFactoryBuilder;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.jpa.repository.config.EnableJpaRepositories;
import org.springframework.orm.jpa.JpaTransactionManager;
import org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean;
import org.springframework.transaction.PlatformTransactionManager;
import org.springframework.transaction.annotation.EnableTransactionManagement;

import javax.persistence.EntityManager;
import javax.sql.DataSource;
import java.util.Map;

/**
 * @author: zjl
 * @datetime: 2024/4/24
 * @desc:
 */
@Configuration
@EnableTransactionManagement
@EnableJpaRepositories(
        entityManagerFactoryRef = "entityManagerFactorySecondary",
        transactionManagerRef = "transactionManagerSecondary",
        basePackages = {"cn.smbms.news.dao"})
public class NewsConfig {

    @Autowired
    @Qualifier("newsDataSource")
    private DataSource dataSource;

    @Autowired
    @Qualifier("vendorProperties")
    private Map<String, Object> vendorProperties;

    @Bean(name = "entityManagerFactorySecondary")
    public LocalContainerEntityManagerFactoryBean entityManagerFactorySecondary(EntityManagerFactoryBuilder builder) {
        return builder
                .dataSource(dataSource)
                .properties(vendorProperties)
                .packages("com.example.springbootmultijpa.model")
                .persistenceUnit("secondaryPersistenceUnit")
                .build();
    }

    @Bean(name = "entityManagerSecondary")
    public EntityManager entityManager(EntityManagerFactoryBuilder builder) {
        return entityManagerFactorySecondary(builder).getObject().createEntityManager();
    }

    @Bean(name = "transactionManagerSecondary")
    PlatformTransactionManager transactionManagerSecondary(EntityManagerFactoryBuilder builder) {
        return new JpaTransactionManager(entityManagerFactorySecondary(builder).getObject());
    }
}

5.业务逻辑层

略

6.测试

略

苏生Susheng
关注
专栏目录
springboot整合jpa
04-26
SpringBoot 整合 JPA（Java Persistence API）是现代Java应用中常见的数据访问技术栈，它简化了数据库操作，提供了ORM（对象关系映射）功能，使得开发者可以用面向对象的方式来处理数据库事务。以下是对这个主题的...
springboot同时整合JPA和mybatis的demo
08-12
本示例"springboot同时整合JPA和mybatis的demo"旨在演示如何在一个项目中同时使用Spring Boot与两种ORM（对象关系映射）框架：JPA（Java Persistence API）和MyBatis。这为我们提供了更大的灵活性，可以根据不同的...
【Springboot系列】SpringBoot整合Jpa
热门推荐
Venus's Blog
11-30 1万+
Spring Boot是一种快速开发框架，它简化了Java应用程序的开发过程。而Jpa（Java Persistence API）是Java持久化规范的一种实现，它提供了一种方便的方式来访问和操作数据库。将Spring Boot与Jpa整合可以更加方便地进行数据库操作，提高开发效率。本文将介绍如何使用Spring Boot整合Jpa，帮助读者快速上手并应用于实际项目中。Jpa（Java Persistence API）是Java持久化规范的一种实现，它提供了一种方便的方式来访问和操作数据库。
SpringBoot整合JPA
YIYIYI
07-22 9659
SpringBoot整合JPA
SpringBoot 整合JPA
andyliu198571的博客
10-01 1060
采用的是hinbernate的hql语句1")
SpringBoot整合JPA，步骤详解（图文结合）
7
10-07 2914
Hibernate对数据库结构提供了较为完整的封装，Hibernate的O/R Mapping实现了POJO 和数据库表之间的映射，以及SQL 的自动生成和执行。往往只需定义好了POJO 到数据库表的映射关系，即可通过Hibernate 提供的方法完成持久层操作。甚至不需要对SQL 的熟练掌握， Hibernate/OJB 会根据制定的存储逻辑，自动生成对应的SQL 并调用JDBC 接口加以执行。
springboot整合JPA
weixin_44740485的博客
05-21 2103
什么是JPA？ JPA（Java Persistence API)，中文名Java持久层API，是Java持久化规范，它为Java开发人员提供了一种对象/关联映射工具来管理Java应用中的关系数据。 JPA的出现主要是为了简化现有的持久化开发工作和整合ORM技术，结束现在Hibernate，TopLink，JDO等ORM框架各自为营的局面。 JPA是在充分吸收了现有Hibernate，TopLink，JDO 等ORM框架的基础上发展而来的，具有易于使用，伸缩性强等优点。总的来说，JPA包括以下3方面的技术：
springboot 整合 jpa，mysql
weixin_42487883的博客
07-19 419
通过上述步骤，我们已经成功地将 Spring Boot、JPA 和 MySQL 整合在一起，实现了一个简单的用户管理系统。这个系统包括了基本的 CRUD 操作，并且展示了如何配置数据源、创建实体类、Repository 接口、Service 类和 Controller 类。创建一个 Repository 接口，用于访问数据库中的。接下来，创建一个实体类。例如，我们创建一个简单的。在 Spring Boot 应用的主类中添加。
SpringBoot整合JPA 基础使用
cmh1008611的博客
09-29 1919
*** 根据用户姓名查找用户* @param name 用户姓名* @return 找到的用户对象，如果不存在返回 null*//*** 根据用户姓名或电子邮箱查找用户* @param name 用户姓名* @param email 用户电子邮箱* @return 找到的用户对象，如果不存在返回 null*//*** 根据用户姓名计数用户数量* @param name 用户姓名* @return 具有该姓名的用户数量*//*** 根据用户名进行模糊搜索。
SpringBoot--整合JPA
吴声子夜歌的博客
12-18 457
SpringBoot整合JPA 创建工程并导入依赖 <?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...
SpringBoot整合JPA详细代码实例
Andrew_Chenwq的博客
06-28 2018
SpringData：Spring 的一个子项目。用于简化数据库访问，支持NoSQL 和 关系数据存储。其主要目标是使数据库的访问变得方便快捷。JPA：JPA(Java Persistence API，Java持久化API)，定义了对象关系映射(Object Relation Mapping,ORM)以及实体对象持久化的标准接口。Hibernate实现了JPA的一个ORM框架。
SpringBoot整合JPA详解
C1226786216的博客
09-27 822
Data@ToString@Entity@Id@GeneratedValue(strategy = GenerationType.IDENTITY) //自增主键/*** @Column 注解可以接受多个参数，常用的参数包括：* name：指定数据库表中的列名。* nullable：指定该列是否可为空，默认为 true。* unique：指定该列是否唯一，默认为 false。* length：指定该列的长度。* precision 和 scale：用于精度和刻度的数字列。
SpringBoot整合JPA数据源方法及配置解析
09-07
总结来说，Spring Boot整合JPA和数据源涉及到的主要步骤包括：添加依赖、配置数据源、自定义JPA配置、配置实体类、创建Repository接口以及编写业务逻辑。理解这些步骤可以帮助开发者更高效地构建多数据源的Spring ...
Spring Boot集成Spring Security：深入探索授权机制
Mike_18870278351的博客
11-29 627
授权是Spring Security中不可或缺的一部分，它确保了只有经过授权的用户才能访问敏感资源。通过结合使用注解、配置类和灵活的授权机制（如RBAC和ABAC），开发者可以轻松地实现细粒度的访问控制。在构建Spring Boot应用时，充分利用Spring Security的授权功能将有助于提高应用的安全性并保护用户数据。
Spring Boot教程之十七：使用 ModelMapper 将实体映射到 DTO
潜洋的专栏
12-03 942
我们将运行我们的应用程序，由于我们已经完成了数据库配置，JPA 将使用我们添加到实体类的注释自动在数据库中创建 User 表。正如我们在上面的响应中看到的，我们还将收到密码，这对于编写 RESTful API 来说不是一个好习惯。一旦添加了模式的名称，我们就需要单击“应用”按钮，它将弹出另一个窗口，我们需要再次单击“应用”按钮。在此步骤中，我们将使用 postman 运行我们的应用程序并测试我们的 restful 服务。此后，我们将运行我们的应用程序，以查看我们的应用程序是否配置为数据库。
详解日志格式配置：XML 与 Spring Boot 配置文件格式
Java领域优秀创作者
12-03 625
颜色和格式使用Logback提供的ANSI转义码，可以轻松为日志输出添加颜色，帮助开发人员快速定位问题。日志格式中可以控制时间戳、日志级别、记录器、消息内容等部分的颜色，使日志更具可读性。字符数限制通过限制字段长度（如或%M{10}），可以避免日志输出过长，影响日志的整洁性。适用场景更适用于复杂的日志配置和多种输出形式（如文件、控制台）。和提供简单而有效的方式来配置 Spring Boot 项目的日志格式。
Spring Boot 3.4.0 发布：功能概览与示例
weixin_36369910的博客
11-29 710
Spring Boot 3.4.0 带来了许多增强功能，使现代应用开发更加高效、便捷和强大。以下是最新功能的完整概述，以及一些帮助您快速入门的代码示例。启用 JSON 或结构化日志记录时，Spring Boot 的启动横幅会自动禁用，以减少日志混乱。Spring 现原生支持虚拟线程，可用于任务调度和异步处理，无需再添加。支持多个 Docker Compose 文件，适用于不同环境的配置合并。支持 Hibernate 的本机属性，提升了兼容性和配置灵活性。，支持自定义配置的运行和测试。
学习笔记052——Spring Boot 自定义 Starter
最新发布
code__bee的博客
12-03 379
Spring Boot Starter 启动器自动装载 bean。把一个完整的项目（框架）自动组装到我们的项目中Data;
Spring Boot 项目集成camunda流程引擎
liuhm的博客
11-29 1257
使用camunda开源工作流引擎有：通过docker运行、使用springboot集成、部署camunda发行包、基于源代码编译运行等多种方式。 文本重点介绍如何在Spring Boot应用程序中如何集成Camunda Platform开源流程平台，这也是项目中最为常见的一种使用方式。 在本教程中，我们假设您熟悉 Java Web 应用程序开发和 Spring Boot 的基础知识。前提条件是您已经安装了 Eclipse/IDEA等Java开发工具和 Camunda Modeler流程设计器。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值