6、JPA对象关系-单向一对多(多用)

单向一对多， 默认中间表维护关系

JPA 在一对多关系时，默认会多出一个关系表，维护关系；
其实用多对一的思想考虑，把关系维护在多的一方列上，也是可以的。但是JPA 默认设计的一对多就是多出一个关系表

1、类定义

@Data
@Entity
public class Employee {
    @Id
    @GeneratedValue
    private long id;
    private String name;
}

@Data
@Entity
public class Department {
    @Id
    @GeneratedValue
    private long id;
    private String name;

    //1对多
    @OneToMany
    private List<Employee> employees;
}

2、persistence.xml配置

 <class>com.hongying.entity.one2many.Department</class>
        <class>com.hongying.entity.one2many.Employee</class>
        <exclude-unlisted-classes>true</exclude-unlisted-classes>

3、保存

@Test
    public void save(){
        Department d=new Department();
        d.setName("人事部");

        Employee gg=new Employee();
        gg.setName("gg");
        Employee jl=new Employee();
        jl.setName("jl");

        //设置关系
        List<Employee> employees=new ArrayList<>();
        employees.add(gg);
        employees.add(jl);
        d.setEmployees(employees);

        //保存数据库
        EntityManager entityManager = JpaUtil.getEntityManager();
        entityManager.getTransaction().begin();

        //一对多时，不管先保存哪一方都一样，都是执行5条SQL
        entityManager.persist(gg);
        entityManager.persist(jl);
        entityManager.persist(d);

        entityManager.getTransaction().commit();
        entityManager.close();

    }

控制台输出：
先保存单表数据，保存时，都会触发ID赋值，依赖对象属性都会变化；
事务提交时，判断缓存中对象和快照区对象不一致，从而把关系数据进行插入到关系表中

Hibernate: insert into Employee (name) values (?)
Hibernate: insert into Employee (name) values (?)
Hibernate: insert into Department (name) values (?)
Hibernate: insert into Department_Employee (Department_id, employees_id) values (?, ?)
Hibernate: insert into Department_Employee (Department_id, employees_id) values (?, ?)

4、单向一对多总结

1. JPA 默认会添加1个关系表，维护一对多关系；
2. 先保存哪一方执行的SQL都一样，不会减少对数据库的交互次数；
3. 一对多查询，默认就是懒加载。先查询主表，用到子表时，再次查询子表；
4. 一对多，对应属性是个集合，这个集合支持查询时进行排序，3种排序规则；

单向一对多查询

1、查询，默认一对多是懒加载的

@Before
    public void save(){
        Department d=new Department();
        d.setName("人事部");

        Employee gg=new Employee();
        gg.setName("gg");
        Employee jl=new Employee();
        jl.setName("jl");

        //设置关系
        List<Employee> employees=new ArrayList<>();
        employees.add(gg);
        employees.add(jl);
        d.setEmployees(employees);

        //保存数据库
        EntityManager entityManager = JpaUtil.getEntityManager();
        entityManager.getTransaction().begin();

        //一对多时，不管先保存哪一方都一样，都是执行5条SQL
        entityManager.persist(gg);
        entityManager.persist(jl);
        entityManager.persist(d);

        entityManager.getTransaction().commit();
        entityManager.close();

    }
@Test
    public void find(){
        EntityManager entityManager = JpaUtil.getEntityManager();
        Department department = entityManager.find(Department.class, 1L);
        
        //一对多关系，查询时，默认是懒加载的
        List<Employee> employees = department.getEmployees();
        System.out.println("employees.size() = " + employees.size());
        entityManager.close();
    }

一对多关系查询时，默认就是懒加载的

select department0_.id as id1_0_0_, department0_.name as name2_0_0_ from Department department0_ where department0_.id=?
Hibernate: select employees0_.Department_id as Departme1_0_1_, employees0_.employees_id as employee2_1_1_, employee1_.id as id1_2_0_, employee1_.name as name2_2_0_ from Department_Employee employees0_ inner join Employee employee1_ on employees0_.employees_id=employee1_.id where employees0_.Department_id=?

2、查询、实时查询

只需要在集合上添加 @OneToMany(fetch = FetchType.EAGER)

集合3种实现排序

@Test
    public void find(){
        EntityManager entityManager = JpaUtil.getEntityManager();
        Department department = entityManager.find(Department.class, 1L);

        //一对多关系，查询时，默认是懒加载的
        List<Employee> employees = department.getEmployees();
        System.out.println("查看集合JPA代理类型：" + employees.getClass());
        System.out.println("employees() = " + employees);
        entityManager.close();
    }

1、PersistentBag 类型（元素有序，不允许重复）@OrderBy

当集合类型为List 时，JPA集合代理类型是class org.hibernate.collection.internal.PersistentBag类型，这个类型实现了List接口。JPA 默认使用此类型。
可在集合属性上添加@OrderBy("name DESC") 注解进行排序

@Data
@Entity
public class Department {
    @Id
    @GeneratedValue
    private long id;
    private String name;

    @OneToMany
    @OrderBy("name DESC")
    private List<Employee> employees;
}

2、PersistentSet 类型（元素无序，不允许重复）@OrderBy

当集合类型是Set类型时，JPA动态代理类型org.hibernate.collection.internal.PersistentSet,实现了Set接口。排序也可以指定@OrderBy("name DESC")

@OneToMany
    @OrderBy("name asc")
    private Set<Employee> employees;

3、PersistentList 类型（元素有序，允许重复）@OrderColumn

普通的List集合，但是子表内容可以重复，也就是有2条记录完全一致。此时需要使用PersistentList类型,org.hibernate.collection.internal.PersistentList。如果子表2条数据完全一致，此时根据什么排序？@OrderColumn(name = "seq")

此时可在集合属性上添加注解@OrderColumn(name = "seq")，JPA会在生成的关系表中添加一列 seq，插入关系时会自动插入这个值，按照数据关系保存顺序排序。很少使用

@Data
@Entity
public class Department {
    @Id
    @GeneratedValue
    private long id;
    private String name;

    @OneToMany
    @OrderColumn(name = "seq")
    private List<Employee> employees;
}

如何不生成中间表？@JoinColumn

JPA 默认 一对多会生成中间表维护关系，大部分情况下一对多和多对一关系是一样的，我们可以把关系维护到多的一方，而不用另外维护一张表，如何实现。
在@OneToMany或@ManyToMany对应的关系属性上，可以添加@JoinColumn指定关联的列名称，从而告诉JPA，中间表或关系列我已经创建好了，JPA直接映射关系即可，不需要再创建了

解决方法：在@OneToMany 一对多关系属性上添加注解@JoinColumn。name指定外键列名称即可

@Data
@Entity
public class Department {
    @Id
    @GeneratedValue
    private long id;
    private String name;

    @OneToMany
    //一对多JPA默认生成中间表,如何不生成中间表，把外键关系添加到多的一方列上
    //手动设置关系，name：外键列名称，员工表哪个列是外键
    //referencedColumnName:当前实体哪个列作为外键值，默认主键列名称
    @JoinColumn(name = "department_id",referencedColumnName = "id")
    private List<Employee> employees;
}