标签：school name 关联 public PA import users id 加载

这次具体讲述一下，对于懒加载遇到（循环引用，N+1，使用关联对象）的解决方案。

为了方便大家模拟操作，我会完整说一下

不想看过程的，直接看总结。

一建表

创建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

四配置注入

通过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;
    }
 
}

五对象

School对象

@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;
    }
 
 
    @Fetch(FetchMode.SUBSELECT)
    @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> {
}

七 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 使用@Fetch(FetchMode.SUBSELECT) 解决N+1问题

3 使用@JsonIgnoreProperties(value = { "users" }) 避免循环引用
4 使用Optional.ofNullable(xxx).toString(); 是为了避免 null.toString();

标签：school,name,关联,public,PA,import,users,id,加载
From： https://www.cnblogs.com/hanjun0612/p/17283742.html

PA 懒加载（循环引用，N+1，使用关联对象）（二）

一建表

二 POM

三 application.yml

四配置注入

五对象

六 Dao

七 Controller

八测试

总结

相关文章

赞助商

阅读排行

PA 懒加载（循环引用，N+1，使用关联对象）（二）

一 建表

二 POM

三 application.yml

四 配置注入

五 对象

六 Dao

七 Controller

八 测试

总结

相关文章

赞助商

阅读排行

一建表

四配置注入

五对象

八测试