Hibernate 1-N单向关联（注解实现）

最新推荐文章于 2019-09-19 19:20:33 发布

深夜程猿

最新推荐文章于 2019-09-19 19:20:33 发布

阅读量585

点赞数

分类专栏： Hibernate 文章标签： hibernate

本文链接：https://blog.youkuaiyun.com/wnl_csdn/article/details/52404247

版权

Hibernate 专栏收录该内容

9 篇文章

订阅专栏

本文介绍了使用Hibernate框架实现1-N单向关联映射的方法，包括无连接表和有连接表两种情况，并提供了详细的Java代码示例。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

无连接表的1-N单向关联

Person.java（1端）

package com.oneToMany;

import java.util.HashSet;
import java.util.Set;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.OneToMany;
import javax.persistence.Table;

@Entity
@Table(name="person_inf")
public class Person {

    @Id
    @Column(name="person_id")//name="person_id"
    @GeneratedValue(strategy=GenerationType.IDENTITY)
    private Integer id;
    private String name;
    private int age;
    @OneToMany(targetEntity=Address.class)
    //映射外键列，此处映射的外键列会添加到关联实体对应的数据库中
    @JoinColumn(name="fk_person_id" ,referencedColumnName="person_id")//name="fk_person_id" ,referencedColumnName="person_id"
    //N的一端以集合set形式出现
    private Set<Address> address=new HashSet<Address>();
    public Integer getId() {
        return id;
    }
    public void setId(Integer id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public Set<Address> getAddress() {
        return address;
    }
    public void setAddress(Set<Address> address) {
        this.address = address;
    }



}

Address.java（N端）

package com.oneToMany;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.Table;
@Entity
@Table(name="address_inf")//catalog="hibernate_oneToMany",name="address_inf"
public class Address {

    @Id
    @Column(name="address_id")//name="address_id"
    @GeneratedValue(strategy=GenerationType.IDENTITY)
    private Integer id;
    private String addressDetail;
    public Address(){}
    public Address(String addressDetail ){
        this.addressDetail=addressDetail;
                }
    public void setId(Integer id) {
        this.id = id;
    }
    public Integer getId() {
        return id;
    }
    public void setAddressDetail(String addressDetail) {
        this.addressDetail = addressDetail;
    }
    public String getAddressDetail() {
        return addressDetail;
    }

}

TestDemo.java

public static void test2() {

        StandardServiceRegistry registry = new StandardServiceRegistryBuilder()
                .configure("hibernate.cfg.xml").build();
        SessionFactory factory = new MetadataSources(registry).buildMetadata()
                .buildSessionFactory();
        // 获取Session
        Session session = factory.openSession();
        Transaction transaction = session.beginTransaction();
        try {

            Person person = new Person();
            // 持久化Person对象
            session.save(person);
            Address address = new Address("GDUT");
            person.setName("Jeff");
            person.setAge(21);
            // 持久化Address对象
            session.persist(address);
            // 添加地址1
            person.getAddress().add(address);

            Address address2 = new Address("SCGT");
            // 添加地址2
            person.getAddress().add(address2);
            // 持久化Address对象
            session.persist(address2);

            transaction.commit();

        } catch (Exception e) {
            transaction.rollback();// 回滚事务
            e.getMessage();
        } finally {
            if (session != null) {
                session.close();
            }
        }
    }
```![效果图片](http://img.blog.youkuaiyun.com/20160901225532760)

----------
**有连接表的1-N单向关联**


----------
Person.java





<div class="se-preview-section-delimiter"></div>

package com.oneToMany;

import java.util.HashSet;
import java.util.Set;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.JoinTable;
import javax.persistence.OneToMany;
import javax.persistence.Table;

@Entity
@Table(name=”person_inf”)
public class Person {

@Id
@Column(name="person_id")//name="person_id"
@GeneratedValue(strategy=GenerationType.IDENTITY)
private Integer id;
private String name;
private int age;
@OneToMany(targetEntity=Address.class)
/*
 * @JoinTable(name="person_address",
 * //定义连接表中名为fk_person_id的外键列，该外键列参照当前实体对应的主键列
 * joinColumns=@JoinColumn(name="fk_person_id"
 * ,referencedColumnName="person_id"),
 * //定义连接表中名为fk_address_id的外键列，该外键列参照当前实体关联实体对应的主键列
 * inverseJoinColumns=@JoinColumn
 * (name="fk_address_id",referencedColumnName="address_id", unique=true))
 *
 * @JoinTable注解映射fk_address_id外键列，添加了唯一约束，说明一个Address实体至多只能关联一个
 * Person实体，而一个Person实体可以关联多个Address实体
 * 
 */

@JoinTable(name="person_address",
        //定义连接表中名为fk_person_id的外键列，该外键列参照当前实体对应的主键列
joinColumns=@JoinColumn(name="fk_person_id",referencedColumnName="person_id"),
        //定义连接表中名为fk_address_id的外键列，该外键列参照当前实体关联实体对应的主键列
inverseJoinColumns=@JoinColumn(name="fk_address_id",referencedColumnName="address_id",
unique=true))
//N的一端以集合set形式出现
private Set<Address> address=new HashSet<Address>();
public Integer getId() {
    return id;
}
public void setId(Integer id) {
    this.id = id;
}
public String getName() {
    return name;
}
public void setName(String name) {
    this.name = name;
}
public int getAge() {
    return age;
}
public void setAge(int age) {
    this.age = age;
}
public Set<Address> getAddress() {
    return address;
}
public void setAddress(Set<Address> address) {
    this.address = address;
}

}

Address.java





<div class="se-preview-section-delimiter"></div>

package com.oneToMany;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.Table;
@Entity
@Table(name=”address_inf”)//catalog=”hibernate_oneToMany”,name=”address_inf”
public class Address {

@Id
@Column(name="address_id")//name="address_id"
@GeneratedValue(strategy=GenerationType.IDENTITY)
private Integer id;
private String addressDetail;
public Address(){}
public Address(String addressDetail ){
    this.addressDetail=addressDetail;
            }
public void setId(Integer id) {
    this.id = id;
}
public Integer getId() {
    return id;
}
public void setAddressDetail(String addressDetail) {
    this.addressDetail = addressDetail;
}
public String getAddressDetail() {
    return addressDetail;
}

}

TestDemo.java





<div class="se-preview-section-delimiter"></div>

public static void test2() {

    StandardServiceRegistry registry = new StandardServiceRegistryBuilder()
            .configure("hibernate.cfg.xml").build();
    SessionFactory factory = new MetadataSources(registry).buildMetadata()
            .buildSessionFactory();
    // 获取Session
    Session session = factory.openSession();
    Transaction transaction = session.beginTransaction();
    try {

        Person person = new Person();
        // 持久化Person对象
        session.save(person);
        Address address = new Address("GDUT");
        person.setName("Jeff");
        person.setAge(21);
        // 持久化Address对象
        session.persist(address);
        // 添加地址1
        person.getAddress().add(address);

        Address address2 = new Address("SCGT");
        // 添加地址2
        person.getAddress().add(address2);
        // 持久化Address对象
        session.persist(address2);

        transaction.commit();

    } catch (Exception e) {
        transaction.rollback();// 回滚事务
        e.getMessage();
    } finally {
        if (session != null) {
            session.close();
        }
    }
}

“`

效果图

通过上面两个例子，我们可以知道，对于采用连接表的单向1-N关联，由于采用连接表维护了关联关系，两个对应的数据表无需增加外键列，所以两个实体对应的数据表就没有主从表关系。程序可以想先持久化哪个实体就先持久化哪个实体，不会引发性能问题。

public static void test2() {

        StandardServiceRegistry registry = new StandardServiceRegistryBuilder()
                .configure("hibernate.cfg.xml").build();
        SessionFactory factory = new MetadataSources(registry).buildMetadata()
                .buildSessionFactory();
        // 获取Session
        Session session = factory.openSession();
        Transaction transaction = session.beginTransaction();
        try {

            Person person = new Person();
            // 持久化Person对象
            session.save(person);
            Address address = new Address("GDUT");
            person.setName("Jeff");
            person.setAge(21);
            // 持久化Address对象
            session.persist(address);
            // 添加地址1
            person.getAddress().add(address);

            Address address2 = new Address("SCGT");
            // 添加地址2
            person.getAddress().add(address2);
            // 持久化Address对象
            session.persist(address2);

            transaction.commit();

        } catch (Exception e) {
            transaction.rollback();// 回滚事务
            e.getMessage();
        } finally {
            if (session != null) {
                session.close();
            }
        }
    }

通过图片知道，我们可以知道，对于采用连接表的单向1-N关联，由于采用连接表维护了关联关系，两个对应的数据表无需增加外键列，所以两个实体对应的数据表就没有主从表关系。程序可以想先持久化哪个实体就先持久化哪个实体，不会引发性能问题。对于没有连接表的关联来说，要想优化性能，在持久化Address类之前，我们需要给Address实体指定关联的实体，就是person.getAddress().add(address)。