JPA 懒加载（循环引用，N+1，使用关联对象，No session问题）（二）
这次具体讲述一下，对于懒加载遇到（循环引用，N+1，使用关联对象，No session问题）的解决方案。
为了方便大家模拟操作，我会完整说一下
不想看过程的，直接看总结。
一 建表
创建School和User
School
SET NAMES utf8mb4; SET FOREIGN_KEY_CHECKS = 0; -- ---------------------------- -- Table structure for school -- ---------------------------- DROP TABLE IF EXISTS `school`; CREATE TABLE `school` ( `id` int NOT NULL AUTO_INCREMENT, `name` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci NULL DEFAULT NULL, PRIMARY KEY (`id`) USING BTREE ) ENGINE = InnoDB AUTO_INCREMENT = 5 CHARACTER SET = utf8mb4 COLLATE = utf8mb4_general_ci ROW_FORMAT = Dynamic; -- ---------------------------- -- Records of school -- ---------------------------- INSERT INTO `school` VALUES (1, 'h1'); INSERT INTO `school` VALUES (2, 'h2'); INSERT INTO `school` VALUES (3, 't3'); INSERT INTO `school` VALUES (4, 'h4'); SET FOREIGN_KEY_CHECKS = 1;
User
SET NAMES utf8mb4; SET FOREIGN_KEY_CHECKS = 0; -- ---------------------------- -- Table structure for user -- ---------------------------- DROP TABLE IF EXISTS `user`; CREATE TABLE `user` ( `id` int NOT NULL AUTO_INCREMENT, `name` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci NULL DEFAULT NULL, `schoolId` int NULL DEFAULT NULL, PRIMARY KEY (`id`) USING BTREE, INDEX `FK3o0riaw95im7i0xlbrwujumpa`(`schoolId` ASC) USING BTREE, CONSTRAINT `FK3o0riaw95im7i0xlbrwujumpa` FOREIGN KEY (`schoolId`) REFERENCES `school` (`id`) ON DELETE RESTRICT ON UPDATE RESTRICT ) ENGINE = InnoDB AUTO_INCREMENT = 5 CHARACTER SET = utf8mb4 COLLATE = utf8mb4_general_ci ROW_FORMAT = Dynamic; -- ---------------------------- -- Records of user -- ---------------------------- INSERT INTO `user` VALUES (1, 'u1', 1); INSERT INTO `user` VALUES (2, 'u2', 1); INSERT INTO `user` VALUES (3, 'u3', 2); INSERT INTO `user` VALUES (4, 'u4', NULL); SET FOREIGN_KEY_CHECKS = 1;
二 POM
简单说一下：
1 jackson-datatype-hibernate5 懒加载数据，转换json时，避免错误。
2 其他不赘述了。
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
<groupId>com.fasterxml.jackson.datatype</groupId>
<artifactId>jackson-datatype-hibernate5</artifactId>
<version>2.14.2</version>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
</dependency>
</dependencies>
三 application.yml
spring: datasource: url: jdbc:mysql://localhost:3306/test1?serverTimezone=Asia/Shanghai username: root password: root driver-class-name: com.mysql.cj.jdbc.Driver jpa: hibernate: ddl-auto: update naming: physical-strategy: org.hibernate.boot.model.naming.PhysicalNamingStrategyStandardImpl show-sql: true
四 配置注入
SpringBoot方式
通过jackson-datatype-hibernate5配置，解决懒加载序列化的问题。
import com.fasterxml.jackson.databind.ObjectMapper; import com.fasterxml.jackson.datatype.hibernate5.Hibernate5Module; import org.springframework.amqp.core.Queue; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; import org.springframework.http.converter.json.MappingJackson2HttpMessageConverter; import java.text.SimpleDateFormat; @Configuration public class WebMvcConfig { @Bean public MappingJackson2HttpMessageConverter mappingJackson2HttpMessageConverter() { MappingJackson2HttpMessageConverter converter = new MappingJackson2HttpMessageConverter(); ObjectMapper mapper = converter.getObjectMapper(); //JPA 懒加载 Hibernate5Module hibernate5Module = new Hibernate5Module(); mapper.registerModule(hibernate5Module); mapper.setDateFormat(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss")); return converter; } }
SpringMVC方式
application.xml
<!-- 消息转换器 -->
<mvc:annotation-driven>
<mvc:message-converters>
<bean class="org.springframework.http.converter.StringHttpMessageConverter">
<property name="defaultCharset" value="UTF-8" />
</bean>
<bean class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter">
<property name="objectMapper">
<bean class="com.kintech.common.MyObjectMapper" />
</property>
</bean>
</mvc:message-converters>
</mvc:annotation-driven>
MyObjectMapper
import java.text.SimpleDateFormat; import com.fasterxml.jackson.databind.DeserializationFeature; import com.fasterxml.jackson.databind.ObjectMapper; import com.fasterxml.jackson.databind.SerializationFeature; import com.fasterxml.jackson.datatype.hibernate5.Hibernate5Module; public class MyObjectMapper extends ObjectMapper { private static final long serialVersionUID = -7171816038924552983L; public MyObjectMapper(){ SimpleDateFormat format = new MySimpleDateFormat("yyyy-MM-dd HH:mm:ss"); this.setDateFormat(format); this.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false); //反序列化时忽略多出的属性 this.disable(SerializationFeature.FAIL_ON_EMPTY_BEANS); //序列化时忽略映射空属性bean //json 懒加载对象 Hibernate5Module hibernate5Module = new Hibernate5Module(); hibernate5Module.disable(Hibernate5Module.Feature.USE_TRANSIENT_ANNOTATION); //防止@Transient注解，不序列化Json this.registerModule(hibernate5Module); } }
五 对象
School对象
@BatchSize(size=100) , @Fetch(FetchMode.SUBSELECT) 解决N+1问题。
关联表产生的sql变为：select * from XXX where id in (....)
import org.hibernate.annotations.Fetch; import org.hibernate.annotations.FetchMode; import org.hibernate.annotations.GenericGenerator; import javax.persistence.*; import java.util.List; @Entity @Table(name = "school", catalog = "test1") public class School implements java.io.Serializable { private Integer id; private String name; private List<User> users; @Id @GenericGenerator(name = "generator", strategy = "identity") @Column(name = "id") public Integer getId() { return id; } public void setId(Integer id) { this.id = id; } @Column(name = "name") public String getName() { return name; } public void setName(String name) { this.name = name; } @JsonIgnoreProperties(value = { "school" }) @BatchSize(size=100) @OneToMany(fetch = FetchType.LAZY) @JoinColumn(name = "schoolId", referencedColumnName = "id", insertable = false, updatable = false) public List<User> getUsers() { return users; } public void setUsers(List<User> users) { this.users = users; } }
User对象
@JsonIgnoreProperties(value = { "users" }) 防止循环引用，指向School表中的users对象
import com.fasterxml.jackson.annotation.JsonIgnoreProperties; import org.hibernate.annotations.GenericGenerator; import javax.persistence.*; @Entity @Table(name = "user",catalog = "test1") public class User { private Integer id; private String name; private Integer schoolId; private School school; @Id @GenericGenerator(name = "generator", strategy = "identity") @Column(name = "id") public Integer getId() { return id; } public void setId(Integer id) { this.id = id; } @Column(name = "name") public String getName() { return name; } public void setName(String name) { this.name = name; } @Column(name = "schoolId") public Integer getSchoolId() { return schoolId; } public void setSchoolId(Integer schoolId) { this.schoolId = schoolId; } @JsonIgnoreProperties(value = { "users" }) @ManyToOne(fetch = FetchType.LAZY) @JoinColumn(name="schoolId",referencedColumnName = "id",insertable = false,updatable = false) public School getSchool() { return school; } public void setSchool(School school) { this.school = school; } }
六 Dao
SchoolDao
import com.example.test_project.model.School; import org.springframework.data.jpa.repository.JpaRepository; import org.springframework.stereotype.Repository; @Repository public interface SchollDao extends JpaRepository<School,Integer> { }
UserDao
import com.example.test_project.model.User; import org.springframework.data.jpa.repository.JpaRepository; import org.springframework.stereotype.Repository; @Repository public interface UserDao extends JpaRepository<User,Integer> { }
Service中的查询方法需要添加，防止no session问题
@Transactional(readOnly = true)
七 Controller
package com.example.test_project.controller; import com.example.test_project.dao.SchoolDao; import com.example.test_project.dao.UserDao; import com.example.test_project.model.School; import com.example.test_project.model.User; import org.springframework.amqp.core.AmqpTemplate; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.web.bind.annotation.*; import java.util.List; import java.util.Optional; @RestController @RequestMapping("api/test") public class TestController { @Autowired SchoolDao schoolDao; @Autowired UserDao userDao; /** * School -- findAll users为null * @param reqVo * @return */ @RequestMapping(value = "t1", method = RequestMethod.POST) @ResponseBody public List<School> t1(@RequestBody String reqVo) { List<School> schollList=schoolDao.findAll(); return schollList; } /** * School -- findAll，通过遍历调用，users有值 * @param reqVo * @return */ @RequestMapping(value = "t2", method = RequestMethod.POST) @ResponseBody public List<School> t2(@RequestBody String reqVo) { List<School> schollList=schoolDao.findAll(); schollList.forEach(x->Optional.ofNullable(x.getUsers()).toString()); return schollList; } /** * School -- findOne users为null * @param reqVo * @return */ @RequestMapping(value = "t3", method = RequestMethod.POST) @ResponseBody public School t3(@RequestBody String reqVo) { School scholl=schoolDao.findById(1).get(); return scholl; } /** * School -- findOne，通过遍历调用，users有值 * @param reqVo * @return */ @RequestMapping(value = "t4", method = RequestMethod.POST) @ResponseBody public School t4(@RequestBody String reqVo) { School scholl=schoolDao.findById(1).get(); Optional.ofNullable(scholl.getUsers()).toString(); return scholl; } /** * User -- findAll 通过遍历 school有值 * @return */ @RequestMapping(value = "t5", method = RequestMethod.POST) @ResponseBody public List<User> t5() { List<User> list=userDao.findAll(); list.forEach(x-> Optional.ofNullable(x.getSchool()).toString()); return list; } /** * User -- findOne school为null * @return */ @RequestMapping(value = "t6", method = RequestMethod.POST) @ResponseBody public User t6() { User user=userDao.findById(1).get(); return user; } }
八 测试
1 api/test/t1
没有调用users，所以users为null
[ { "id": 1, "name": "h1", "users": null }, { "id": 2, "name": "h2", "users": null }, { "id": 3, "name": "t3", "users": null }, { "id": 4, "name": "h4", "users": null } ]
2 api/test/t2
调用了schollList.forEach(x->Optional.ofNullable(x.getUsers()).toString());
所以users有数据
[ { "id": 1, "name": "h1", "users": [ { "id": 1, "name": "u1", "schoolId": 1, "school": { "id": 1, "name": "h1" } }, { "id": 2, "name": "u2", "schoolId": 1, "school": { "id": 1, "name": "h1" } } ] }, { "id": 2, "name": "h2", "users": [ { "id": 3, "name": "u3", "schoolId": 2, "school": { "id": 2, "name": "h2" } } ] }, { "id": 3, "name": "t3", "users": [] }, { "id": 4, "name": "h4", "users": [] } ]
3 api/test/t3
没有调用users
{ "id": 1, "name": "h1", "users": null }
4 api/test/t4
调用了Users Optional.ofNullable(scholl.getUsers()).toString();
{ "id": 1, "name": "h1", "users": [ { "id": 1, "name": "u1", "schoolId": 1, "school": { "id": 1, "name": "h1" } }, { "id": 2, "name": "u2", "schoolId": 1, "school": { "id": 1, "name": "h1" } } ] }
5 api/test/t5
调用了school list.forEach(x-> Optional.ofNullable(x.getSchool()).toString());
[ { "id": 1, "name": "u1", "schoolId": 1, "school": { "id": 1, "name": "h1" } }, { "id": 2, "name": "u2", "schoolId": 1, "school": { "id": 1, "name": "h1" } }, { "id": 3, "name": "u3", "schoolId": 2, "school": { "id": 2, "name": "h2" } }, { "id": 4, "name": "u4", "schoolId": null, "school": null } ]
6 api/test/t6
没有调用School
{ "id": 1, "name": "u1", "schoolId": 1, "school": null }
总结
可以看到，满足了Lazy (循环引用，N+1，使用关联对象)的功能。
1 使用jackson-datatype-hibernate5 配置 WebMvcConfig 解决懒加载的序列化问题。
2 使用@BatchSize(size=100) 解决N+1问题(支持JPA和EntityManager)
@Fetch(FetchMode.SUBSELECT) 也可以，但是无法支持EntityManager的查询
3 使用@JsonIgnoreProperties(value = { "school" }) 避免循环引用,school指向关联对象中的school
一般设置在主表就可以。此处演示，我也设置了@JsonIgnoreProperties(value = { "users" })
4 使用Optional.ofNullable(xxx).toString(); 是为了避免 null.toString();
5 不要使用Debug断点，不然永远会加载关联对象
6 Service中的查询方法需要添加@Transactional(readOnly = true)，防止no session问题
