码农小汪-Hibernate学习9-hibernate双向关联关系注解表示@OneToMany mappedBy @ManyToMany @JoinTable

之前我学习了单向的关联，现在继续学习，双向的关联。这个关联关系的理解还是有点复杂，慢慢的理解懂了就好啦！这个过程不是一蹴而就的。我们需要不断的积累，才可以有所成绩的。

年轻人，不要怕~慢慢来

对啦，有的时候我们可能会采用逆向工程产生实体哦。所以我们要看得懂，会修改，会改变

双向1-N关联

对于1-N的关联，Hibernate 推荐使用双向的关联，而不要让1的端（也就是有Set这个集合的那一个）控制关联的关系。而是使用N的一端控制关联关系。双向的1-N和N-1关联其实就是一回事。两端都需要增加对关联属性的访问，N的一端增加引用关联实体的属性，1的一端增加集合属性，集合元素为关联的实体.

Hibernate 同样对月双向关联的映射提供了两种技术支持：一种是有连接表的，一种是无连接表的。​对于大部分来说，对于1-N的双向关联我们采用无连接表的策略即可。​

无连接的双向的1-N关联

无连接的双向的1-N关联，N的一端肯定是使用@ManyToOne 我们肯定不会默生的涩，1的一端使用@OneToMany.

底层的数据库在记录这种1-N的关联关系的时候，其实就是我们的外键而已，只需要在N的一端增加一个外键列就好啦。因此在使用@ManyToOne的同时，还需要使用@JointColumn来映射外键列。

对于双向的1-N关联的映射，​通常不会让1（set集合）的端控制关系，这样没次都需要更新我们的set集合，很不方便的说​。而是该由我们的N的一端控制关联的关系。​因此我们使用@OneToMany的时候中应该指明mappedBy (映射由谁控制)​ mappedBy属性—–一但为@OneToMany，@ManyToMany指定了这个属性，则表明当前的实体不能控制关联的关系。放弃控制关系之后，就不能指明@JoinColumn 或@JointTable 来修饰关联实体的属性啦（这两个实体都是外键和第三张表啊来维护关系）

例子：下面的@OneToMany在关联实体的set集合，指明了mappedBy那么1 的端放弃控制关联关系，其实这样也好。每次都更新set集合好累啊。

这个所谓的维护关联关系，主要是看底层的表中是否有外键，如果有外键的话，肯定的先有外键生成，才可以产生现在的嘛。不能乱了顺序涩。

比如 person这个一的端 现在不维护关联关系了 这么说嘛person的 底层表中没得关于地址的任何消息所以我可以随便的保存person实体。而不需要任何的条件。 但是address就不行了，因为现在表中有了person_id这个外键。，所以必须等到有了person实体的属性，才可以让我的地址产生并且维护他们之间的关系。 后面有例子的。这个只是我自己的看法。以后忘了再来看看当时的心德。

例子~~

Person 1个人 多个地址

@Entity
@Table(name="person_inf")
public class Person
{
    @Id @Column(name="person_id")
    @GeneratedValue(strategy=GenerationType.IDENTITY)
    private Integer id;
    private String name;
    private int age;
    // 定义该Person实体所有关联的Address实体
    // 指定mappedBy属性表明该Person实体不控制关联关系
    //这里的person是address中的person
    @OneToMany(targetEntity=Address.class
        , mappedBy="person")
    private Set<Address> addresses
        = new HashSet<>();
...

}

然后Address中只需要增加一个Person person这个属性。需要使用@ManyToOne @JoinColumn 设置外键

继续看例子

@Entity
@Table(name="address_inf")
public class Address
{
    @Id @Column(name="address_id")
    @GeneratedValue(strategy=GenerationType.IDENTITY)
    private int addressId;
    private String addressDetail;
    // 定义该Address实体关联的Person实体
    @ManyToOne(targetEntity=Person.class)
    // 定义名为person_id外键列，该外键列引用person_inf表的person_id列。
    @JoinColumn(name="person_id" , referencedColumnName="person_id"
        , nullable=false)
    private Person person;

...

}

不知道你是不是觉得好神奇啊，我们的底层的数据库都是一样的都是增加了外键，只是在person中增加了个set然后呢，我们就双向关联了，任意的获得对方的属性啦。开源的力量特别叼

底层数据和我们的1-N的一样的哦~我是觉得很厉害~不知道你认为呢

Session session = HibernateUtil.currentSession();
    Transaction tx = session.beginTransaction();
    // 创建一个瞬态的Person对象
    Person p = new Person();
    p.setName("Test");
    p.setAge(29);

你说现在我可以保存到数据库？ Person中的set没有赋值哦。可能你忘记啦，我们表的关系是有address维护的，在address中有个外键咯。所以现在我们的person表和address没有关系。我的person当然可以持久化啦。这个 毫无疑问

// 持久化Person对象(对应于插入主表记录)
    session.save(p);
没问题

创建address啦

Address a = new Address("遵义市海龙坝");

现在可以保存？当然不可以，我们必须有外键呢，外键都没得，所以得设置关联关系。并且我们还必须是个持久化的对象，不能是瞬态的对象，上面的person是个持久态的，所以可以。为啥瞬态的不行呢？因为我们没有设置级联关系，插入的时候不会级联的操作，这样的话，外键表Id不存在，会报错的出现异常。你懂了？我也是慢慢的自己分析懂啦

// 先设置Person和Address之间的关联关系
    a.setPerson(p);
    // 再持久化Address对象(对应于插入从表记录)
    session.persist(a); //a 作为外键必须是持久化对象，不然会报错的
    tx.commit();
    HibernateUtil.closeSession();

你懂了吧？这个理解很重要哦，Hibernate的难点，持久化对象，关联关系。记得大二的时候觉得框架好特别，没得人带我飞，自己看这个Hibernate，看的那个各种晕，现在好辣，终于可以懂啦。不错，说明在进步。

有连接表的双向1-N关联

我们的关注底层数据库以怎么样的形式呈现给我们呢，因为增加第三张表来维护关系。Person和Address表中都没有外键啦！这样子不需要担心保存我们的Person 信息和Address 信息。只是在建立两者之间的关联关系的时候，放在第三张表中，要保证我们的外键有效，什么是有效呢？address.setPonsen(b) 这种情况下要保证adress 和 b都是有效的，数据库中存在的，才会插入第三张表中没得问题。

对于有连接表的1-N，让N端控制关系的话，1的端无需改变，N的端和单向有连接表的类似

@Id 
    @Column(name="address_id")
    @GeneratedValue(strategy=GenerationType.IDENTITY)
    private int addressId;
    private String addressDetail;
    // 定义该Address实体关联的Person实体
    @ManyToOne(targetEntity=Person.class)
    // 映射连接表，指定连接表为person_address
    @JoinTable(name="person_address",
        // 指定连接表中address_id列参照当前实体对应数据表的address_id主键列
        joinColumns=@JoinColumn(name="address_id"
            , referencedColumnName="address_id", unique=true),
        // 指定连接表中person_id列参照当前实体的关联实体对应数据表的person_id主键列
        inverseJoinColumns=@JoinColumn(name="person_id"
            , referencedColumnName="person_id")
    )
    private Person person;
    ...
}

person –我们还是不维持关系吧。其实吧，这里谁维持关系都一样。都是插入第三张表中，性能没得影响。person中也可以使用@JoinTableb 表名一样就行啦。不需要指定谁维护，都一样啊！

因为是第三张表中的哈哈。

@Entity
@Table(name="person_inf")
public class Person
{
    @Id @Column(name="person_id")
    @GeneratedValue(strategy=GenerationType.IDENTITY)
    private Integer id;
    private String name;
    private int age;
    // 定义该Person实体所有关联的Address实体
    @OneToMany(targetEntity=Address.class ,mappedBy="person")
这两种的区别就是把，维护关系不啊~
    /*@OneToMany(targetEntity=Address.class)
    // 映射连接表，指定连接表为person_address
    @JoinTable(name="person_address",
        // 指定连接表中person_id列参照当前实体对应数据表的person_id主键列
        joinColumns=@JoinColumn(name="person_id"
            , referencedColumnName="person_id"),
        // 指定连接表中address_id列参照当前实体的关联实体对应数据表的address_id主键列
        inverseJoinColumns=@JoinColumn(name="address_id"
            , referencedColumnName="address_id", unique=true)
    )*/
    private Set<Address> addresses
        = new HashSet<>();

看上面的两种关系都可以，维护维护关系影响不大的，自己看着办就是啦。因为第三张表啦。对于性能没影响，不是更新，是插入第三张表。两者都可以维护关系

看你理解没理解，不需要维护关系是啥子意思呢？

我们来操作就知道啦

// 创建一个瞬态的Person对象
        Person p = new Person();
        p.setName("Test");
        p.setAge(21);

// 创建一个瞬态的Address对象
        Address a = new Address("遵义市海龙坝");

现在可以a.setPerson？ 答案不可以的，第三张表中有两个外键，作为主键，引用了我们的Person和Address .现在的Person和address对象都不是持久化对象在数据库中不存在。不行吧？？

session.save(p);
session.save(a)
a.setPerson(p)
.commit()...
这样子就行啦

下面的也是可以的

a.setPerson(p);
// 持久化Address对象
session.persist(a);
// 持久化Person对象
session.save(p);
tx.commit();

​为啥子 可以呢，persist并不是立即转换为insert语句的，save是立即的。所以这样子就好像可以啦~两个外键都存在。​

双向的N-N关联

双向的N-N 两端都需要set集合，两端都需要增加对Set集合的属性的访问，这里的Set集合是关联关系的，不要和以前的不是关联关系的搞混了。双向的有太多的可能，所以只能采用连接表来操作啦。来表示实体之间的关系。

双向的N-N关联，两端都要set分别使用@ManyToMany 都要使用@JoinTable 显示的连接在一起，和刚刚一对N不同的是（1-N增加了unique约束）

需要说明的是，哪端想放弃控制关联关系，可以使用mappBy。也就不能使用@joinTable啦。其实吧上面都是说过了的。建立第三张表啦。我们两端都可以随意的控制关联关系。重点在于底层的数据库怎么实现的。理解清楚啦，你就知道现在可以持久化？没有控制关系诶！

来来例子，虽然都是差不多，但是还是来啊~

@Entity
@Table(name="person_inf")
public class Person
{
    @Id @Column(name="person_id")
    @GeneratedValue(strategy=GenerationType.IDENTITY)
    private Integer id;
    private String name;
    private int age;
    @ManyToMany(targetEntity=Address.class)
    // 映射连接表，指定连接表的表名为person_address
    @JoinTable(name="person_address",
        // 映射连接表中名为person_id的外键列，
        // 该列参照当前实体对应表的person_id主键列
        joinColumns=@JoinColumn(name="person_id"
            , referencedColumnName="person_id"),
        // 映射连接表中名为address_id的外键列，
        // 该列参数当前实体的关联实体对应表的address_id主键列
        inverseJoinColumns=@JoinColumn(name="address_id"
            , referencedColumnName="address_id")
    )
    private Set<Address> addresses
        = new HashSet<>();

一样的继续

@Entity
@Table(name="address_inf")
public class Address
{
    // 标识属性
    @Id @Column(name="address_id")
    @GeneratedValue(strategy=GenerationType.IDENTITY)
    private int addressId;
    // 定义地址详细信息的成员变量
    private String addressDetail;
    // 定义该Address实体所有关联的Person实体
    @ManyToMany(targetEntity=Person.class)
    // 映射连接表，指定连接表的表名为person_address
    @JoinTable(name="person_address",
        // 映射连接表中名为address_id的外键列，
        // 该列参照当前实体对应表的address_id主键列
        joinColumns=@JoinColumn(name="address_id"
            , referencedColumnName="address_id"),
        // 映射连接表中名为person_id的外键列，
        // 该列参照当前实体对应表的person_id主键列
        inverseJoinColumns=@JoinColumn(name="person_id"
            , referencedColumnName="person_id")
    )
    private Set<Person> persons
        = new HashSet<>();
...
}

两面都没放弃控制权，哈哈。没必要！就是晓得原理啦，随意来啊~~

我就是任性

// 创建一个Person对象
        Person p = new Person();

// 持久化Person对象(对应于插入主表记录)
        session.save(p);

// 创建一个瞬态的Address对象
        Address a = new Address("遵义市海龙坝");
        // 先设置Person和Address之间的关联关系
        a.getPersons().add(p);
        // 再持久化Address对象
        session.persist(a);

这上面没错的，我先持久化了person，创建关联关系。在持久化地址。地值在持久化的时候，会先创建插入地址，在插入到关系表中的。

也可以这样写

session.save(a);

a.getPersons().add(p);

这样也是可以的，最后提交的时候就插入到了数据库中。多自己分析哈，自然的就懂了。

双向的1-1关联

基于外键的哦

直接的代码。前面的懂了，这点还不是小意思。你维护不维护实体关系呢？一方维护，一方不维护涩

总有一方要先把实体存到数据库中，然后另一方才有外键存在呢。

有mappedBy的不维护，那么低层的数据表中就不会出现啦，所以，可以自己创建并保存到数据库，不用去理会这个属性。

@Entity
@Table(name="person_inf")
public class Person
{
    // 标识属性
    @Id @Column(name="person_id")
    @GeneratedValue(strategy=GenerationType.IDENTITY)
    private Integer id;
    private String name;
    private int age;
    // 定义该Person实体关联的Address实体
    @OneToOne(targetEntity=Address.class , mappedBy="person")
    private Address address;
    ...
}

所以下面

Person p=new Person();

session.save(p)没有压力

…

继续地址，这里没有使用连接表哦。还是有先后顺序的。必须先有person在有address;

@Entity
@Table(name="address_inf")
public class Address
{
    // 标识属性
    @Id @Column(name="address_id")
    @GeneratedValue(strategy=GenerationType.IDENTITY)
    private int addressId;
    // 定义地址详细信息的成员变量
    private String addressDetail;
    // 定义该Address实体关联的Person实体
    @OneToOne(targetEntity=Person.class)
    // 用于映射person_id外键列，参照person_inf表的person_id列
    // 指定了unique=true表明是1-1关联
    @JoinColumn(name="person_id" , referencedColumnName="person_id"
        , unique=true)
    private Person person;
..
}

地层的数据库中多了个person_id 外键列

Address address=new Address();

address.addPerson(持久化的Person)；

session.save(address)

没有问题涩。

下面继续。有链接表的

可以两端​都有JoinTable unique熟悉必须的涩，因为是1-1必须具有唯一性​另外一段不想控制关系，可以使用mappedBy涩.简单搞定

@Entity
@Table(name="person_inf")
public class Person
{
    @Id @Column(name="person_id")
    @GeneratedValue(strategy=GenerationType.IDENTITY)
    private Integer id;
    private String name;
    private int age;
    // 定义该Person实体关联的Address实体
    @OneToOne(targetEntity=Address.class)
    // 映射底层连接表，表名为person_address
    @JoinTable(name="person_address",
        // 映射连接表的外键列，增加unique=true表明是1-1关联
        joinColumns=@JoinColumn(name="person_id"
            , referencedColumnName="person_id" , unique=true),
        // 映射连接表的外键列，增加unique=true表明是1-1关联
        inverseJoinColumns=@JoinColumn(name="address_id"
            , referencedColumnName="address_id", unique=true)
    )
    private Address address;

… 不想贴了