Hibernate入门基础-单向多对一关联

1.单向多对一(例子:员工Employee  部门Department):多个员工对应一个部门

单向多对一:

单向 n-1关联只需从n的一端可以访问1的一端

从Employee到Department的多对一单向关联 需要在Employee类中定义一个Department属性,而Department类无需定义存放Epmloyee对象的集合属性。

(多方 管理一方  要知道一方的信息  有个属性能让多方得到一方的信息并管理  那么就是一方表的主键列)

(一方)Department:
fileld:dept_id dept_name;

(多方)Department:
fileld:dept_id dept_name;

package hibernate.model.m2o;

//部门
public class Department {
	private Integer dept_id;//部门ID
	private String dept_name;//部门名称
    //省略get,set方法
}

package hibernate.model.m2o;
//员工
public class Employee {

	private Integer emp_id;
	private String emp_name;
	
	private Department dept;

配置*.hbm.xml

Department.hbm.xml：一的一方，不需要维护关系，所以和普通的配置一样既可以了。

<?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 package="hibernate.model.m2o">
	<class name="Department" table="m2o_dept">
	<id name="dept_id" >
	  <generator class="native"></generator> 
	</id>
	<property name="dept_name"></property>
	
</class>

</hibernate-mapping>

Employee.hbm.xml： 多的一方，需要维护双方关系，所以里面配置有一的一方的引用。

<?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 package="hibernate.model.m2o">
<class name="Employee" table="m2o_emp">
	<id name="emp_id" >
	  <generator class="native"></generator> 
	</id>
	<property name="emp_name"></property>
        <!--dept属性,表达的意思是该Employee类与Department类的多对一的关系
clss属性:关联的实例类型(多对一  相对应的一方的类 )
column属性:该类的外键列(引用关联对象的表的主键列 
-->
 <many-to-one name="dept" class="Department" column="dept_id"></many-to-one>
</class></hibernate-mapping> 

many-to-one的常用属性：  
name：映射类属性的名称（必须） 
class：关联类的完全限定名 
column：关联的字段 
not-null：设置关联的字段的值是否可以为空。 默认值false  
lazy：指定关联对象是否使用延迟加载以及延迟加载的策略。lazy属性有三个取值：false、proxy、no-proxy。 默认值proxy
fetch：设置抓取数据的策略。 默认值是select  
many-to-one没有inverse属性，因为关系的维护是多的一方，不可能放弃对关系的维护。

在hibernate.cfg.xml加载注册映射文件

<mapping resource="hibernate/model/m2o/Department.hbm.xml" />
		<mapping resource="hibernate/model/m2o/Employee.hbm.xml" />

编写一个测试类

package hibernate.model.m2o;

import java.util.List;

import org.hibernate.Session;
import org.hibernate.Transaction;
import org.junit.Test;

import xh.util.HibernateUtil;

public class M2oTest {

    // 保存，有关联关系
    @Test
    public void m2oTest() {
        Employee emp = new Employee();
        emp.setEmp_name("xuhai");

        Employee emp1 = new Employee();
        emp1.setEmp_name("xuhai1");

        Department dept = new Department();
        dept.setDept_name("技术部");

        // 关联起来 告诉员工他属于哪个部门
        emp.setDept(dept);
        emp1.setDept(dept);
        Session session = HibernateUtil.getInstance().getSession();
        Transaction transaction = session.beginTransaction();

        session.save(dept);// 被依赖的一方一般放在前面保存,需要依赖别人的一般放在后面保存
        session.save(emp);

        session.save(emp1);
        transaction.commit();
        session.close();

    }

    // 获取，可以获取到关联的对方的信息
    @Test
    public void queryTest() {
        Session session = HibernateUtil.getInstance().getSession();
        // 获取员工方信息，并显示部门方信息
        List<Employee> list = session.createQuery("from Employee").list();
        for (Employee employee : list) {
            System.out.println("员工名称:" + employee.getEmp_name() + ",部门名称:"
                    + employee.getDept().getDept_name());
        }

    }

    // 解除关联关系
    @Test
    public void RemoveRelationTest() {
        Session session = HibernateUtil.getInstance().getSession();
        session.beginTransaction();
        // 从员工方解除
        Employee emp = (Employee) session.get(Employee.class, 1);
        emp.setDept(null);

        session.getTransaction().commit();
        session.close();
    }

    // 删除对象，对关联对象的影响
    @Test
    public void testDelete() {
        Session session = HibernateUtil.getInstance().getSession();
        session.beginTransaction();

        // 删除员工方(多方)，对对方没有影响
        Employee employee = (Employee) session.get(Employee.class, 1);
        session.delete(employee);

        session.getTransaction().commit();
        session.close();
    }
}

单向 多对一   多方维护管理一方

之所以叫它多对一，是因为他们之间的关系是由多的一方来维护的。我们根据职工Employee的信息就能够知道它对应的Department的信息。

单向多对一：我们可以通过一个员工知道它属于那个部门，而不需要知道一个部门里 有哪些员工，这就是所谓的单向的。 

可以通过保存员工的数据的同时达到保存部门信息的效果，但是不能通过保存部门信息而保存员工数据，这也是单向的。

（映射单单向多对一,多方维护一方，多方通过关联一方的主键列（多方的外键列引用自一方的主键列），获取到一方的信息，进行管理CRUD都可以，而一方不知道多方的信息，也不能管理维护多方）；

一方:                                                        多方:

                        

多方通过关联一方主键column（dept_id）能获取得到  一方的对应的信息   而在一方角度中无法获知关于它其他关系的信息。

单向 多对一   多方维护管理一方  多方是主   一方是从属关系。