SpringBoot整合JPA

JPA简介

JPA（Java Persistence API）是 Java 平台的一个持久化标准，用于将 Java 对象映射到关系型数据库中的表。它是 Java EE（现 Jakarta EE）的一部分，旨在简化数据库操作，使开发者能够通过操作对象来访问和操作数据库，而无需编写复杂的 SQL 语句。

1、ORM（对象关系映射）：

JPA 是一种 ORM 框架，它将 Java 对象（实体类）与数据库表进行映射。

开发者通过操作 Java 对象来实现对数据库的增删改查操作。

2、实体类（Entity）：

使用 @Entity 注解标记的 Java 类，表示数据库中的一张表。

每个实体类的实例对应数据库中的一行记录。

3、持久化上下文（Persistence Context）：

持久化上下文是 JPA 管理的实体对象的集合。

它负责跟踪实体对象的状态变化，并在事务提交时将变化同步到数据库。

4、实体管理器（EntityManager）：

实体管理器是 JPA 的核心接口，用于管理实体对象的生命周期。

通过实体管理器，开发者可以执行 CRUD 操作。

5、JPQL（Java Persistence Query Language）：

JPQL 是一种面向对象的查询语言，类似于 SQL，但操作的是实体对象而非数据库表。

核心注解

1、@Entity：

用于标记一个类为实体类，表示该类与数据库中的一张表映射。

2、@Table：

指定实体类对应的数据库表名。如果表名与类名相同，可以省略。

3、@Id：

用于标记实体类的主键字段。

4、@GeneratedValue：

指定主键的生成策略（如自增、UUID 等）。

5、@Column：

指定字段与数据库列的映射关系。如果字段名与列名相同，可以省略。

6、@OneToMany / @ManyToOne / @ManyToMany / @OneToOne：

用于定义实体类之间的关系（如一对多、多对一等）。

7、@Query：

用于定义自定义查询（JPQL 或原生 SQL）。

核心组件

1、EntityManager：

用于管理实体对象的生命周期，包括持久化、更新、删除和查询操作。

2、Persistence Unit：

在 persistence.xml 中定义的持久化单元，包含数据源、实体类、事务类型等配置。

3、JPQL：

一种面向对象的查询语言，支持动态查询和复杂查询。

4、事务管理：

JPA 支持容器管理的事务（CMT）和用户管理的事务（BMT）。 SpringBoot 整合 JPA

maven依赖

<?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http:// .w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"> <modelVersion>4.0.0</modelVersion> <artifactId>spring-boot-demo-orm-jpa</artifactId> <version>1.0.0-SNAPSHOT</version> <packaging>jar</packaging> <name>spring-boot-demo-orm-jpa</name> <description>Demo project for Spring Boot</description> <parent> <groupId>com.xiaoma</groupId> <artifactId>spring-boot-demo</artifactId> <version>1.0.0-SNAPSHOT</version> </parent> <properties> <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding> <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding> <java.version>1.8</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</artifactId> </dependency> <dependency> <groupId>mysql</groupId> <artifactId>mysql-connector-java</artifactId> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-test</artifactId> <scope>test</scope> </dependency> <dependency> <groupId>cn.hutool</groupId> <artifactId>hutool-all</artifactId> </dependency> <dependency> <groupId>com.google.guava</groupId> <artifactId>guava</artifactId> </dependency> <dependency> <groupId>org.projectlombok</groupId> <artifactId>lombok</artifactId> <optional>true</optional> </dependency> </dependencies> <build> <finalName>spring-boot-demo-orm-jpa</finalName> <plugins> <plugin> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-maven-plugin</artifactId> </plugin> </plugins> </build> </project>

JpaConfig.java

@Configuration @EnableTransactionManagement @EnableJpaAuditing @EnableJpaRepositories(basePackages = "com.xiaoma.orm.jpa.repository", transactionManagerRef = "jpaTransactionManager") public class JpaConfig { @Bean @ConfigurationProperties(prefix = "spring.datasource") public DataSource dataSource() { return DataSourceBuilder.create().build(); } @Bean public LocalContainerEntityManagerFactoryBean entityManagerFactory() { HibernateJpaVendorAdapter japVendor = new HibernateJpaVendorAdapter(); japVendor.setGenerateDdl(false); LocalContainerEntityManagerFactoryBean entityManagerFactory = new LocalContainerEntityManagerFactoryBean(); entityManagerFactory.setDataSource(dataSource()); entityManagerFactory.setJpaVendorAdapter(japVendor); entityManagerFactory.setPackagesToScan("com.xiaoma.orm.jpa.entity"); return entityManagerFactory; } @Bean public PlatformTransactionManager jpaTransactionManager(EntityManagerFactory entityManagerFactory) { JpaTransactionManager transactionManager = new JpaTransactionManager(); transactionManager.setEntityManagerFactory(entityManagerFactory); return transactionManager; } }

User.java

@EqualsAndHashCode(callSuper = true) @NoArgsConstructor @AllArgsConstructor @Data @Builder @Entity @Table(name = "orm_user") @ToString(callSuper = true) public class User extends AbstractAuditModel { /** * 用户名 */ private String name; /** * 加密后的密码 */ private String password; /** * 加密使用的盐 */ private String salt; /** * 邮箱 */ private String email; /** * 手机号码 */ @Column(name = "phone_number") private String phoneNumber; /** * 状态，-1：逻辑删除，0：禁用，1：启用 */ private Integer status; /** * 上次登录时间 */ @Column(name = "last_login_time") private Date lastLoginTime; /** * 关联部门表 * 1、关系维护端，负责多对多关系的绑定和解除 * 2、@JoinTable注解的name属性指定关联表的名字，joinColumns指定外键的名字，关联到关系维护端(User) * 3、inverseJoinColumns指定外键的名字，要关联的关系被维护端(Department) * 4、其实可以不使用@JoinTable注解，默认生成的关联表名称为主表表名+下划线+从表表名， * 即表名为user_department * 关联到主表的外键名：主表名+下划线+主表中的主键列名,即user_id,这里使用referencedColumnName指定 * 关联到从表的外键名：主表中用于关联的属性名+下划线+从表的主键列名,department_id * 主表就是关系维护端对应的表，从表就是关系被维护端对应的表 */ @ManyToMany(cascade = CascadeType.ALL, fetch = FetchType.EAGER) @JoinTable(name = "orm_user_dept", joinColumns = @JoinColumn(name = "user_id", referencedColumnName = "id"), inverseJoinColumns = @JoinColumn(name = "dept_id", referencedColumnName = "id")) private Collection<Department> departmentList; }

Department.java

@EqualsAndHashCode(callSuper = true) @Data @NoArgsConstructor @AllArgsConstructor @Builder @Entity @Table(name = "orm_department") @ToString(callSuper = true) public class Department extends AbstractAuditModel { /** * 部门名 */ @Column(name = "name", columnDefinition = "varchar(255) not null") private String name; /** * 上级部门id */ @ManyToOne(cascade = {CascadeType.REFRESH}, optional = true) @JoinColumn(name = "superior", referencedColumnName = "id") private Department superior; /** * 所属层级 */ @Column(name = "levels", columnDefinition = "int not null default 0") private Integer levels; /** * 排序 */ @Column(name = "order_no", columnDefinition = "int not null default 0") private Integer orderNo; /** * 子部门集合 */ @OneToMany(cascade = {CascadeType.REFRESH, CascadeType.REMOVE}, fetch = FetchType.EAGER, mappedBy = "superior") private Collection<Department> children; /** * 部门下用户集合 */ @ManyToMany(mappedBy = "departmentList") private Collection<User> userList; }

AbstractAuditModel.java

@MappedSuperclass @EntityListeners(AuditingEntityListener.class) @Data public abstract class AbstractAuditModel implements Serializable { /** * 主键 */ @Id @GeneratedValue(strategy = GenerationType.IDENTITY) private Long id; /** * 创建时间 */ @Temporal(TemporalType.TIMESTAMP) @Column(name = "create_time", nullable = false, updatable = false) @CreatedDate private Date createTime; /** * 上次更新时间 */ @Temporal(TemporalType.TIMESTAMP) @Column(name = "last_update_time", nullable = false) @LastModifiedDate private Date lastUpdateTime; }

UserDao.java

@Repository public interface UserDao extends JpaRepository<User, Long> { }

DepartmentDao.java

@Repository public interface DepartmentDao extends JpaRepository<Department, Long> { /** * 根据层级查询部门 * * @param level 层级 * @return 部门列表 */ List<Department> findDepartmentsByLevels(Integer level); }

application.yml

server: port: 8080 servlet: context-path: /demo spring: datasource: jdbc-url: jdbc:mysql://127.0.0.1:3306/test?useUnicode=true&characterEncoding=UTF-8&useSSL=false&autoReconnect=true&failOverReadOnly=false&serverTimezone=GMT%2B8 username: root password: root driver-class-name: com.mysql.cj.jdbc.Driver type: com.zaxxer.hikari.HikariDataSource initialization-mode: always continue-on-error: true schema: - "classpath:db/schema.sql" data: - "classpath:db/data.sql" hikari: minimum-idle: 5 connection-test-query: SELECT 1 FROM DUAL maximum-pool-size: 20 auto-commit: true idle-timeout: 30000 pool-name: SpringBootDemoHikariCP max-lifetime: 60000 connection-timeout: 30000 jpa: show-sql: true hibernate: ddl-auto: validate properties: hibernate: dialect: org.hibernate.dialect.MySQL57InnoDBDialect open-in-view: true logging: level: com.xiaoma: debug org.hibernate.SQL: debug org.hibernate.type: trace

UserDaoTest.java

@Slf4j public class UserDaoTest extends SpringBootDemoOrmJpaApplicationTests { @Autowired private UserDao userDao; /** * 测试保存 */ @Test public void testSave() { String salt = IdUtil.fastSimpleUUID(); User testSave3 = User.builder().name("testSave3").password(SecureUtil.md5("123456" + salt)).salt(salt).email("testSave3@xiaoma ").phoneNumber("17300000003").status(1).lastLoginTime(new DateTime()).build(); userDao.save(testSave3); Assert.assertNotNull(testSave3.getId()); Optional<User> byId = userDao.findById(testSave3.getId()); Assert.assertTrue(byId.isPresent()); log.debug("【byId】= {}", byId.get()); } /** * 测试删除 */ @Test public void testDelete() { long count = userDao.count(); userDao.deleteById(1L); long left = userDao.count(); Assert.assertEquals(count - 1, left); } /** * 测试修改 */ @Test public void testUpdate() { userDao.findById(1L).ifPresent(user -> { user.setName("JPA修改名字"); userDao.save(user); }); Assert.assertEquals("JPA修改名字", userDao.findById(1L).get().getName()); } /** * 测试查询单个 */ @Test public void testQueryOne() { Optional<User> byId = userDao.findById(1L); Assert.assertTrue(byId.isPresent()); log.debug("【byId】= {}", byId.get()); } /** * 测试查询所有 */ @Test public void testQueryAll() { List<User> users = userDao.findAll(); Assert.assertNotEquals(0, users.size()); log.debug("【users】= {}", users); } /** * 测试分页排序查询 */ @Test public void testQueryPage() { // 初始化数据 initData(); // JPA分页的时候起始页是页码减1 Integer currentPage = 0; Integer pageSize = 5; Sort sort = Sort.by(Sort.Direction.DESC, "id"); PageRequest pageRequest = PageRequest.of(currentPage, pageSize, sort); Page<User> userPage = userDao.findAll(pageRequest); Assert.assertEquals(5, userPage.getSize()); Assert.assertEquals(userDao.count(), userPage.getTotalElements()); log.debug("【id】= {}", userPage.getContent().stream().map(User::getId).collect(Collectors.toList())); } /** * 初始化10条数据 */ private void initData() { List<User> userList = Lists.newArrayList(); for (int i = 0; i < 10; i++) { String salt = IdUtil.fastSimpleUUID(); int index = 3 + i; User user = User.builder().name("testSave" + index).password(SecureUtil.md5("123456" + salt)).salt(salt).email("testSave" + index + "@xiaoma ").phoneNumber("1730000000" + index).status(1).lastLoginTime(new DateTime()).build(); userList.add(user); } userDao.saveAll(userList); } }

DepartmentDaoTest.java

@Slf4j public class DepartmentDaoTest extends SpringBootDemoOrmJpaApplicationTests { @Autowired private DepartmentDao departmentDao; @Autowired private UserDao userDao; /** * 测试保存 ,根节点 */ @Test @Transactional public void testSave() { Collection<Department> departmentList = departmentDao.findDepartmentsByLevels(0); if (departmentList.size() == 0) { Department testSave1 = Department.builder().name("testSave1").orderNo(0).levels(0).superior(null).build(); Department testSave1_1 = Department.builder().name("testSave1_1").orderNo(0).levels(1).superior(testSave1).build(); Department testSave1_2 = Department.builder().name("testSave1_2").orderNo(0).levels(1).superior(testSave1).build(); Department testSave1_1_1 = Department.builder().name("testSave1_1_1").orderNo(0).levels(2).superior(testSave1_1).build(); departmentList.add(testSave1); departmentList.add(testSave1_1); departmentList.add(testSave1_2); departmentList.add(testSave1_1_1); departmentDao.saveAll(departmentList); Collection<Department> deptall = departmentDao.findAll(); log.debug("【部门】= {}", JSONArray.toJSONString((List) deptall)); } userDao.findById(1L).ifPresent(user -> { user.setName("添加部门"); Department dept = departmentDao.findById(2L).get(); user.setDepartmentList(departmentList); userDao.save(user); }); log.debug("用户部门={}", JSONUtil.toJsonStr(userDao.findById(1L).get().getDepartmentList())); departmentDao.findById(2L).ifPresent(dept -> { Collection<User> userlist = dept.getUserList(); //关联关系由user维护中间表，department userlist不会发生变化，可以增加查询方法来处理 重写getUserList方法 log.debug("部门下用户={}", JSONUtil.toJsonStr(userlist)); }); userDao.findById(1L).ifPresent(user -> { user.setName("清空部门"); user.setDepartmentList(null); userDao.save(user); }); log.debug("用户部门={}", userDao.findById(1L).get().getDepartmentList()); } }

sql

DROP TABLE IF EXISTS `orm_user`; CREATE TABLE `orm_user` ( `id` INT(11) NOT NULL AUTO_INCREMENT PRIMARY KEY COMMENT '主键', `name` VARCHAR(32) NOT NULL UNIQUE COMMENT '用户名', `password` VARCHAR(32) NOT NULL COMMENT '加密后的密码', `salt` VARCHAR(32) NOT NULL COMMENT '加密使用的盐', `email` VARCHAR(32) NOT NULL UNIQUE COMMENT '邮箱', `phone_number` VARCHAR(15) NOT NULL UNIQUE COMMENT '手机号码', `status` INT(2) NOT NULL DEFAULT 1 COMMENT '状态，-1：逻辑删除，0：禁用，1：启用', `create_time` DATETIME NOT NULL DEFAULT NOW() COMMENT '创建时间', `last_login_time` DATETIME DEFAULT NULL COMMENT '上次登录时间', `last_update_time` DATETIME NOT NULL DEFAULT NOW() COMMENT '上次更新时间' ) ENGINE=InnoDB DEFAULT CHARSET=utf8 COMMENT='Spring Boot Demo Orm 系列示例表'; DROP TABLE IF EXISTS `orm_department`; CREATE TABLE `orm_department` ( `id` INT(11) NOT NULL AUTO_INCREMENT PRIMARY KEY COMMENT '主键', `name` VARCHAR(32) NOT NULL COMMENT '部门名称', `superior` INT(11) COMMENT '上级id', `levels` INT(11) NOT NULL COMMENT '层级', `order_no` INT(11) NOT NULL DEFAULT 0 COMMENT '排序', `create_time` DATETIME NOT NULL DEFAULT NOW() COMMENT '创建时间', `last_update_time` DATETIME NOT NULL DEFAULT NOW() COMMENT '上次更新时间' ) ENGINE=InnoDB DEFAULT CHARSET=utf8 COMMENT='Spring Boot Demo Orm 系列示例表'; DROP TABLE IF EXISTS `orm_user_dept`; CREATE TABLE `orm_user_dept` ( `id` INT(11) NOT NULL AUTO_INCREMENT PRIMARY KEY COMMENT '主键', `user_id` INT(11) NOT NULL COMMENT '用户id', `dept_id` INT(11) NOT NULL COMMENT '部门id', `create_time` DATETIME NOT NULL DEFAULT NOW() COMMENT '创建时间', `last_update_time` DATETIME NOT NULL DEFAULT NOW() COMMENT '上次更新时间' ) ENGINE=InnoDB DEFAULT CHARSET=utf8 COMMENT='Spring Boot Demo Orm 系列示例表';