一对多，多对多，一对一的理解

标签：关系   enc   测试的   代码   级联删除   序列   登录   bsp   懒加载   

关系维护方和被维护方的理解：关系维护方就是hibernate会主动去修改维护的，比如one1设置为关系维护方，one2为被维护方，那么在one1.save时，会主动修改one2，但是当one2save时就不会去管one1，除非你设置one2.save（one1），

当多的一方满足1、关系维护方和2、设置了级联属性。那么在做save操作前，只需要对多的一方做设置（如order.setUser(user)）就可以了，不需要一的一方做设置（即不需要user.setOrders()）。所以如果是一的一方做save操作时，必须两方都做设置（order.setUser(user)和user.setOrders()）。因为在注解中，一的一方不能满足它是关系维护方这个条件。

所以我们将一的一方是设置级联，多的一方不设置级联，但设置为关系维护方是不合理的，我们可以将多的一方也设置级联，但如果将多的一方的cascade 设为 CascadeType.ALL，那么如果删除多的一方，会将一的一方也删除，所以设为 cascade = {CascadeType.PERSIST,CascadeType.REFRESH}即可。

所以如果你要person删除所有，那么设置person为ALL，而order设置为PERSIST，这就可以实现人没了，订单也没了，删除订单不会删除人。
---------------------

原文：https://blog.csdn.net/u011302734/article/details/76868090

mappedBy的理解：

声明于关系的被维护方，声明的值为关系的维护方的关系对象属性名。
在实例中，mappedBy被声明于person类中，其值为Order类中的Set对象"person"。即，Order为关系维护方，person为被维护方。

级联的理解：级联的定义是一方操作会影响另一方。比如one1和one2进行级联，在one1设置级联cascade，那么在修改one1的时候也会修改one2，比如删除one1，设置cascade为ALL，就会删除one2。

@OneToOne(cascade =CascadeType.ALL)
private One2 one2;

Cascade的几种级联操作

指定cascade = CascadeType.PERSIST在实体类关联的实体字段上，那么保存该实体类时会级联保存该实体类关联的实体。即可以在添加one1保存时可以级联保存one2；

cascade = CascadeType.All，执行所有操作，包含PERSIST，即可以在添加one1保存时可以级联保存one2，级联删除时也可以删除one1，并且顺带删除one2;

cascade = CascadeType.REMOVE,级联删除，但是必须one1和one2在数据库中都有，才可以级联删除，测试的时候，你要new one1，还要new one2，然后保存one1，one2到数据库才可以进行级联删除。

cascade = CascadeType.MERGE CascadeType.MERGE
Cascade merge operation，级联更新（合并）操作。
当one中的数据改变，会相应地更新Course中的数据。

CascadeType.DETACH
Cascade detach operation，级联脱管/游离操作。
如果你要删除一个实体，但是它有外键无法删除，你就需要这个级联权限了。它会撤销所有相关的外键关联。

Cascade refresh operation，级联刷新操作。
假设场景 有一个订单,订单里面关联了许多商品,这个订单可以被很多人操作,那么这个时候A对此订单和关联的商品进行了修改,与此同时,B也进行了相同的操作,但是B先一步比A保存了数据,那么当A保存数据的时候,就需要先刷新订单信息及关联的商品信息后,再将订单及商品保存。(来自“汪三”的简书)

加载的理解：

1、FetchType.LAZY：懒加载，加载一个实体时，定义懒加载的属性不会马上从数据库中加载。 2、FetchType.EAGER：急加载，加载一个实体时，定义急加载的属性会立即从数据库中加载。 3、比方User类有两个属性，name跟address，就像百度知道，登录后用户名是需要显示出来的，此属性用到的几率极大，要马上到数据库查，用急加载； 而用户地址大多数情况下不需要显示出来，只有在查看用户资料是才需要显示，需要用了才查数据库，用懒加载就好了。所以，并不是一登录就把用户 的所有资料都加载到对象中，于是有了这两种加载模式。

多的一方默认使用饥饿加载，一的一方默认使用懒加载。当多的一方使用delete时，没有级联操作时，即使是维护方（维护方一定要指定）也能做删除操作。但是如果此时一的一方使用饥饿加载，那么多的一方使用delete时会报错：org.hibernate.ObjectDeletedException: deleted object would be re-saved by cascade (remove deleted object from associations)。

那怎么办？解除要删除对象的多对一关系，两方都要设置，因为此时一的一方已经加载了多的一方，做法比如（order.getTblUser().getTblOrders().remove(order);
order.setTblUser(null);）。本来我以为维护方只要设置order.setTblUser(null)即可。但因为session缓存中一的一方已经有了它所对应的所有多的一方，此时它不能被删。

---------------------
原文：https://blog.csdn.net/u010082453/article/details/43339031

OPTIONAL的理解：

如果为true，在你数据库插入的时候，就不可以为空

这是@Onetoone

package edu.zut.cs.zutnlp.platform.dao;

import edu.zut.cs.zutnlp.platform.base.domain.BaseEntity;

import javax.persistence.*;

@Table(name = "ONE1")
@Entity
public class One1 extends BaseEntity {

    @Column(name = "NAME")
    private String name;

    @OneToOne(cascade =CascadeType.ALL)//看这里看这里！！！！！！！！！！！！

package edu.zut.cs.zutnlp.platform.dao;

import edu.zut.cs.zutnlp.platform.base.domain.BaseEntity;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.Table;

@Table
@Entity
public class One2 extends BaseEntity {//这里的BaseEntity是我写的抽象层代码，里面也就是序列化了一下，还有个baseDao，baseDao就配置了一下Jpa接口。

    @Column(name = "NAME")
    private String name;

    public String getAge() {
        return age;
    }

    public void setAge(String age) {
        this.age = age;
    }

    public String getName() {

        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Column(name = "Age")
    private String age;
}

package edu.zut.cs.zutnlp.platform.dao;

import edu.zut.cs.zutnlp.platform.base.dao.GenericDaoTestCase;
import org.junit.Test;
import org.springframework.beans.factory.annotation.Autowired;

public class One1DaoTest extends GenericDaoTestCase<Long, One1,One1Dao> {//

    @Autowired
    One1Dao one1Dao;

    @Autowired
    One2Dao one2Dao;

    public void setOne2Dao(One2Dao one2Dao) {
        this.one2Dao = one2Dao;
    }

    public void setOne1Dao(One1Dao one1Dao) {
        this.one1Dao = one1Dao;
        this.dao=this.one1Dao;
    }

    @Test
    public void set(){
        One1 one1=new One1();
//        one1.setName("2");
//        One2 one2=new One2();
//        one2.setName("2de");
//        one2.setAge("15");
//        one1.setOne2(one2);
        one1=this.one1Dao.findByOne1_name("1");
        this.one1Dao.delete(one1);
        System.out.println("删除成功");
    }
}

！！！！！！！我删除了one1，就可以删除了one2，保存，更新，都可以
    private One2 one2;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public One2 getOne2() {
        return one2;
    }

    public void setOne2(One2 one2) {
        this.one2 = one2;
    }
}

此博文只是作为笔者学习记录之用，如有冒犯还请联系我

一对多，多对多，一对一的理解

标签：关系   enc   测试的   代码   级联删除   序列   登录   bsp   懒加载   

原文地址：https://www.cnblogs.com/czrb/p/9949251.html