jpa03

1.单向一对多

单向一对多用得比较少(性能差)，但是依然要求必须掌握，因为我们在使用双向一对多还会用到单向一对多的相应配置

多对一即n多1关系。
在从表中与主表有外键关系的列的get方法上添加@ManyToOne注解后，该属性则表示为外键，该外键关系为其属性类型对应的类型。用JoinColumn注解设置外键的列名。

1.1配置

多方

@Entity@Table(name="t_product")
public class Product {   
    @Id    
    @GeneratedValue   
    private Long id;   
    private String name;
}

一方配置

 

@Entity
@Table(name="t_productDir")
public class ProductDir {
    @Id
    @GeneratedValue
    private Long id;
    private  String name;
    //泛型必须添加进去
    @OneToMany
    @JoinColumn(name="dir_id")
    private Set<Product> products = new HashSet<>();
 }

1.2 保存

无论怎么保存，都在额外发送sql ，所有一般不用单向一对多

1.3查询

lazy加载

现在使用 Set集合 HashSet 打印出来 PersistentSet
PersistentSet 它是Set的实现类 和 HashSet一样 ，PersistentSet 和 HashSet都是
Set的实现类，是兄弟关系 --在定义实体的集合的时候，不要定义HashSet
PersistentBag 也是 List的实现类，和ArrayList一样，ArrayList和PersistentBag都是
List的实现 ，是兄弟关系 --在定义实体的集合的时候，不要定义ArrayList

1.4集合的使用

声明的时候必需使用接口

现在在定义集合的时候，什么情况下使用List ，什么情况下使用Set？

List/Set区别?

List是有序 可以重复 Set 无顺序，不能重复

set没有重复，没有顺序，一般用在多对多manytomany,也有一对多 onetomany

list有重复，顺序要求一般只是用在组合关系 --订单 单据

1.5 集合排序 orderby

配置

@OneToMany
@JoinColumn(name = "dir_id")
@OrderBy("price DESC")       
private List<ProductSet> products = new ArrayList<ProductSet>();  = new HashSet<ProductSet>(); 

2 双向的一对多 或者 多对一

1.同时保存你要保存一方与多方相互知道

2.一方放弃关系的维护(MapperBy)

3.级联  级联危险，不要随便用

4.一般组合关系会用到它

 @OneToMany(mappedBy = "dir")
    private List<Product> products = new ArrayList<>();

5.级联操作保存

级联：就是我操作一方数据，就同时可以多方的数据也一并操作

persist(dir);

级联分为：级联保存 级联删除

@OneToMany(cascade = CascadeType.PRESIST）

级联删除

@OneToMany(cascade = CascadeType.REMOVE）

孤儿删除

@OneToMany(cascade = CascadeType.REMOVE,mappedBy = "dir",orphanRemoval = true)

强级联

@OneToMany(cascade = CascadeType.ALL,mappedBy = "dir",orphanRemoval = true)

3 单向多对多

1单向多对多配置

假设有角色(trole)和用户组(tgroup)两个表，是多对多的关系，即一个角色可以多个用户组拥有，一个用户组也可以拥有多个角色。这里需要增加一个角色-组的对应表tgroup_role，用来记录多对多的对应关系。

User

@Entity
@Table(name="t_user")
public class User {
    @Id
    @GeneratedValue
    private Long id;
    private String name;
    @ManyToMany
    @JoinTable(name="t_user_role",joinColumns={@JoinColumn(name="user_id")},
            inverseJoinColumns ={@JoinColumn(name="role_id")} )
    private Set<Role> roles = new HashSet<>();
}

Role

@Entity
@Table(name="t_role")
public class Role {   
    @Id    
    @GeneratedValue    
    private Long id;    
    private String name;
}

2.双向多对多

role

@ManyToMany(fetch = FetchType.LAZY,cascade = CascadeType.REMOVE)
    @JoinTable(name="t_user_role",joinColumns={@JoinColumn(name="role_id")},
            inverseJoinColumns ={@JoinColumn(name="user_id")} )
    private Set<User> users = new HashSet<>();

user

@ManyToMany(fetch = FetchType.LAZY,cascade = CascadeType.REMOVE)
    @JoinTable(name="t_user_role",joinColumns={@JoinColumn(name="user_id")},
            inverseJoinColumns ={@JoinColumn(name="role_id")} )
    private Set<Role> roles = new HashSet<>();