Hibernate学习10（映射一对一关联(外键)）

如部门经理对应一个部门

基于外键的一对一关联关系

• 1.外键可以存放在任意一边，在需要存放外键的一端增加many-to-one元素 并为其添加唯一约束unique="true"

• 2.另一端需要使用one-to-one元素，并使用property-ref属性指定被关联实体主键以外字段作为关联字段

通过外键方式映射一对一关联

对象一（部门）

//部门
public class Department {
    private Integer depId;
    private String depName;
    private Manager mgr;

    public Manager getMgr() {
        return mgr;
    }

    public void setMgr(Manager mgr) {
        this.mgr = mgr;
    }

    public Integer getDepId() {
        return depId;
    }

    public void setDepId(Integer depId) {
        this.depId = depId;
    }

    public String getDepName() {
        return depName;
    }

    public void setDepName(String depName) {
        this.depName = depName;
    }

}

对象二（部门经理）

//经理
public class Manager {

    private Integer mId;
    private String mName;
    private Department dep;
    public Integer getmId() {
        return mId;
    }
    public void setmId(Integer mId) {
        this.mId = mId;
    }
    public String getmName() {
        return mName;
    }
    public void setmName(String mName) {
        this.mName = mName;
    }
    public Department getDep() {
        return dep;
    }
    public void setDep(Department dep) {
        this.dep = dep;
    }
    
}

对象一(部门)映射文件： 建立一对多关系 为外键添加唯一约束

• 使用many-to-one 映射一对一关联更新 unique="true"唯一约束

<hibernate-mapping>
    <class name="chen.Department" table="DEPARTMENT">
        <id name="depId" type="java.lang.Integer">
            <column name="DEPID" />
            <generator class="native" />
        </id>
        <property name="depName" type="java.lang.String">
            <column name="DEPNAME" />
        </property>
        <!-- 使用many-to-one 映射一对一关联更新
        unique="true"唯一约束
         -->
        <many-to-one name="mgr" class="chen.Manager" column="MGR_ID" unique="true"> </many-to-one>
    </class>
</hibernate-mapping>

部门数据表

对象二(经理)映射文件： 建立一对一关联

• 使用 one-to-one映射一对一关联关系
• 默认关联对方OID
• property-ref="mgr"指定使用关联实体主键以外的字段关联 （对象属性名）

<hibernate-mapping>
    <class name="chen.Manager" table="MANAGER">
        <id name="mId" type="java.lang.Integer" access="field">
            <column name="MID" />
            <generator class="native" />
        </id>
        <property name="mName" type="java.lang.String" access="field">
            <column name="MNAME" />
        </property>
        <!-- 使用 one-to-one映射一对一关联关系 -->
        <!-- property-ref="mgr"指定使用关联实体主键以外的字段关联 （对象属性名） -->
        <one-to-one name="dep" class="chen.Department"
            property-ref="mgr"></one-to-one>
    </class>
</hibernate-mapping>

经理数据表

保存

• 建议先保存没有外键列 减少update语句

    /**
     * 一对一关联(外键) 保存
     */
    public static void testOneToOneWSave() {
        StandardServiceRegistry registry = new StandardServiceRegistryBuilder().configure().build();// 配置文件configure()
        SessionFactory sessionFactory = new MetadataSources(registry).buildMetadata().buildSessionFactory();
        Session session = sessionFactory.openSession();
        Transaction transaction = session.beginTransaction();

        Department department = new Department();
        department.setDepName("研发部");

        Manager manager = new Manager();
        manager.setmName("张三");

        // 设置关联
        department.setMgr(manager);
        manager.setDep(department);

        // 建议先保存没有外键列 减少update语句
        session.save(manager);
        session.save(department);

        transaction.commit();
        session.close();
        sessionFactory.close();
    }

查询

• 1.默认对关联属性使用懒加载
• 2.会出现懒加载异常
• 3.查询manager 对象链接条件不对 property-ref="mgr"指定使用关联实体主键以外的字段关联

    /**
     * 一对一关联(外键) 查询
     */
    public static void testOneToOneWGetA() {
        StandardServiceRegistry registry = new StandardServiceRegistryBuilder().configure().build();// 配置文件configure()
        SessionFactory sessionFactory = new MetadataSources(registry).buildMetadata().buildSessionFactory();
        Session session = sessionFactory.openSession();
        Transaction transaction = session.beginTransaction();

        // 1.默认对关联属性使用懒加载
        // 2.会出现懒加载异常
        Department department = session.get(Department.class, 1);
        System.out.println(department.getDepName());

        // 3.查询manager 对象链接条件不对
        Manager manager = department.getMgr();
        System.out.println(manager.getmName());

        transaction.commit();
        session.close();
        sessionFactory.close();
    }

• 在查询没有外键的实体对象，使用的左外链接查询，一并查询出其关联对象

    /**
     * 一对一关联(外键) 查询
     */
    public static void testOneToOneWGetB() {
        StandardServiceRegistry registry = new StandardServiceRegistryBuilder().configure().build();// 配置文件configure()
        SessionFactory sessionFactory = new MetadataSources(registry).buildMetadata().buildSessionFactory();
        Session session = sessionFactory.openSession();
        Transaction transaction = session.beginTransaction();

        Manager manager = session.get(Manager.class, 1);
        System.out.println(manager.getmName());
        // 在查询没有外键的实体对象，使用的左外链接查询，一并查询出其关联对象
        System.out.println(manager.getDep().getDepName());

        transaction.commit();
        session.close();
        sessionFactory.close();
    }