一:Group和Users两个类

假定一个组里有n多用户,但是一个用户只对应一个用户组。

1.所以Group对于Users是“一对多”的关联关系@OneToMany

Users对于Group是“多对一”@ManyToOne

2.CRUD时候,希望是能从具体用户Users查到其对应的Group,反过来也能通过Group查到具体Users,所以是双向关联

(所以要用mappedBy去除冗余信息)

  1.  
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    @Entity  
    //指定一个表名  
    Group   
    {  
    ;  
    ;  
    ;  
      
    @Id  
    //主键用自增序列  
    {  
    ;  
    }  
    //以“多”一方为主导管理,级联用ALL  
    {  
    ;  
    }  
  1.  
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    @Entity  
    )  
    Users   
    {  
    ;  
    ;  
    ;  
      
    @Id  
    @GeneratedValue  
    {  
    ;  
    }  
    //解决1+N,级联用ALL  
    //指定外键名称,不指定的默认值是group_Id  
    {  
    ;  
    }  

二:C增

cascade:级联,只影响cud,不影响r

(all全都级联,persist存储时级联,remove删除时级联)

如果没有设置cascade,默认需要save(Group)和save(users),两个都要存,设置级联之后,只存一个就行了

级联依赖于这句:@ManyToOne(cascade=(CascadeType.ALL))//需要依赖于其他的东西时候
设置好正反向之后,多个有级联关系的对象就一起被保存了

  1.  
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    @Test  
    {     
    ;  
    ;  
      
    ;  
    ;  
    ;  
    ;  
    //u1和u2的id自增  
             
    ;  
    ;  
    //g的id自增  
             
    //正向  
    ;  
             
    //反向  
    //不然u1和u2中的group信息为空  
             
    //因为设置级联,所以存储g时候也把u1和u2存上了。  
    //不设置级联的话,还要存储u1和u2  
      
    ;  
    ;           
    }

三:R查

默认会这样处理(平时管用的思路也是这样):

1.取“多”的时候,把“一”取出来
2.取“一”时,不取“多”的,用到时候再去取(看user信息时候一般看组名,看group时候user信息太多不必看)

fetch管读取,cascade管增删改
@OneToMany(mappedBy=”group”,cascade=(CascadeType.ALL),fetch=FetchType.EAGER)
@OneToMany默认的是LAZY,@ManyToOne默认是EAGER

User u = (User)s.get(User.class,1);
//取user时候,把group也取出来,

  1.  
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    //取id为11号的u  
    //hibernate产生的语句里也把group拿出来了:group1_.id as id0_0_,和group1_.name as name0_0_   
    :   
    select  
    ,  
    ,  
    ,  
    ,  
    _   
    from  
    _   
    join  
    _   
    id   
    where  
    ?  

只取出Group的话,不会去查询里边的user

  1.  
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    //只取出Group的话,不会去查询里边的user  
    ;  
    :   
    select  
    ,  
    _   
    from  
    _   
    where  
    ?

四:U更新

注意:fetch影响两者读取顺序(两边都设成EAGER要多取出一次),反正都要取,具体再试

@OneToMany,@ManyToOne都写cascade=(CascadeType.ALL)
update时候自动关联更新

 
  1.  
    1
    2
    3
    4
    //因为cascade=(CascadeType.ALL),所以自动关联更新  
    //取id为11号的u  
    ;  
    ;

五:D删

删多:实测只删掉目的项目,不关联其他
先load(就是select)一下,确认有之后,再删

没有遇到:不能直接s.delete(u),因为u和group有级联,group和所有users都有级联,一下就够给删掉了的情况
不过严谨起见,还是设置一个u.setGroup(null);比较好

  1.  
    1
    2
    3
    4
    ;  
    ;  
    //严谨起见,应该先让俩表脱离关联  
    ;

HQL对应的语句(作用是一样的):s.createQuery(“delete from User u where u.id = 1”).executeUpdate();//User是类名

删一:如果有子项目,报错不让删除

Group g = (Group)s.load(Group.class,1);
s.delete(g);

    1.  
      1
      2
      3
      4
      5
      6
      7
      8
      :   
      delete   
      from  
      _Group   
      where  
      ?  
      23000  
      - 已找到子记录

       

相关文章:

  • 2021-10-02
  • 2021-06-15
  • 2021-11-27
  • 2021-08-14
  • 2021-08-06
  • 2021-07-03
  • 2022-01-13
  • 2022-03-06
猜你喜欢
  • 2022-12-23
  • 2022-12-23
  • 2021-12-20
  • 2022-12-23
  • 2021-07-20
  • 2022-02-23
  • 2022-12-23
相关资源
相似解决方案