Hibernate多表映射之多对一

太过爱你忘了你带给我的痛 2024-02-17 22:12 45阅读 0赞

#### 多表映射之多对一（many-to-one） ####

在此以员工和部门的关系为例，员工与部门的关系是典型的多对一关系。  
**员工实体类：**

public class Employee {
        
    
        private int id;
        private String name;
        private Date birthday;
        private Department department;
    
        public Employee() {
            super();
            // TODO Auto-generated constructor stub
        }
    
        public Employee(String name, Date birthday, Department department) {
            super();
            this.name = name;
            this.birthday = birthday;
            this.department = department;
        }
        //...省略getter和setter方法
        }

**员工的映射文件**

<?xml version="1.0"?>
    <!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
    "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
    
    <hibernate-mapping>
        <class name="com.walter.vo.Employee" table="EMPLOYEE">
            <id name="id" type="int">
                <column name="ID" />
                <generator class="native" />
            </id>
            <property name="name" type="java.lang.String">
                <column name="NAME" />
            </property>
            <property name="birthday" type="date">
                <column name="BIRTHDAY" />
            </property>
            
            <many-to-one name="department" class="com.walter.vo.Department" fetch="join">
                <column name="DEPARTMENT" />
            </many-to-one>
        </class>
    </hibernate-mapping>

**部门实体类**

public class Department {
        
    
        private int id;
        private String name;
        //...省略构造方法和getter/setter方法
        }

**部门映射文件**

--------------------

实体类和映射文件配置完成后记得要在Hibernate核心配置文件中配置映射文件。  
**测试**

*  工具类

public class HibernateUtil {
        
    
        private static SessionFactory sessionFactory;
        static{
            Configuration configuration = new Configuration();
            configuration.configure();
            sessionFactory = configuration.buildSessionFactory();
        }
    
        public static SessionFactory getSessionFactory(){
            return sessionFactory;
        }
        public static Session getSession(){
            return sessionFactory.openSession();
        }
        public static void close(Session s){
            if(s!=null)
                s.close();
        }
    }

*  测试类

/**
         * 增加数据
         */
        public static void save(){
            Session session = HibernateUtil.getSession();
            Transaction transaction = session.beginTransaction();
            // 创建一个部门对象
            Department department = new Department("技术部");
            // 创建一个员工对象，同时告知该员工对象属于哪个部门。如果在此没有设置employee的department，则该员工的外键值为null
            Employee employee = new Employee("张三", new Date(), department);
            Employee employee2 = new Employee("李四", new Date(), department);
    
            /*
                如果先保存一的一方(departnment)，在保存多的一方(employee),只有insert语句产生。其原理是：
                先保存department，department表中的主键会自动生成，然后在保存employee的时候，会自动引用department中相应的主键
            */
            session.save(department);
            session.save(employee);
            session.save(employee2);
            /*
                如果先保存多的一方(employee)，再保存保存一的一方(departnment)，除了产生insert语句，还会在insert语句后面产生update语句。其原理是：
                当我们保存员工时，由于还没有保存部门，所以员工的外键没有部门的主键可以引用，所以为null；当我们保存完部门后，会根据部门的主键对相应员工的外键进行更新操作。
            */
            session.save(employee);
            session.save(employee2);
            session.save(department);
    
            transaction.commit();
            HibernateUtil.close(session);
        }
    
        /**
         * 根据id查询数据
         */
        public static Employee getById(int id){
            Session session = HibernateUtil.getSession();
            Employee employee = (Employee) session.get(Employee.class, 1);
            /*初始化代理对象:
                Hibernate.initialize(employee.getDepartment());
            */
            HibernateUtil.close(session);
            return employee;
        }
    
        public static void main(String[] args){
            Employee employee = getById(1);
            System.out.println(employee.getName());//此时name可以正常输出       
            /*下面代码回报错,错误信息是:Exception in thread "main" org.hibernate.LazyInitializationException: could not initialize proxy - no Session.
            说明在查询雇员时默认情况下是不查询部门的，当前查询部门时session已经关闭了，才报上面的错误。
             结论：在多对一关联映射中，默认情况下对一的加载时存在延迟(懒)加载的。
             解决延时加载有两种办法:
                 1.初始化代理对象:
                 ibernate.initialize(employee.getDepartment());
                 2.在多的一方的<many-to-one>标签中配置属性lazy="false"或者fetch="join"
            */
            System.out.println(employee.getDepartment()
            .getName);

在此主要介绍了Hibernate中多表映射的一种,在后续文章中会继续介绍其他的映射关系。如果对Hibernate配置文件不是太清楚的小伙伴可以移步到[Hibernate笔记一（Hibernate简单配置和操作）][Hibernate_Hibernate]来看看。  
欢迎大家讨论和指正。

[Hibernate_Hibernate]: http://blog.csdn.net/wuchenxiwalter/article/details/72426345