Hibernate关系映射（单向关联）

单向关联

many-to-one (多对一)

    <many-to-one  name=“dept” class=“com.tfsoft.pojo.Dept”>       

            <column name="deptId"></column>

</many-to-one>

 

新建Dept类

         private int deptId;

         private String deptName;

         private String deptAdd;

         private String deptTel;

新建Employee类

         private int empId;

         private String empName;

         private int empAge;

         private Dept dept;

Dept.hbm.xml文件配置

             <class name="com.hou.pojo.Dept" table="dept">

                       <id name="deptId" column="deptId" type="int">

                                <generator></generator>

                       </id>

                       <property name="deptName" column="deptName" type="string" length="20"></property>

                       <property name="deptAdd" column="deptAdd" type="string" length="20"></property>

                       <property name="deptTel" column="deptTel" type="string" length="20"></property>

             </class>

Emp.hbm.xml文件配置

             <class name="com.hou.pojo.Employee" table="emp">

                       <id name="empId" column="empId" type="int">

                                <generator></generator>

                       </id>

                       <property name="empName" column="empName" type="string" length="20"></property>

                       <property name="empAge" column="empAge" type="int"></property>

 

                       <!--多对一 -->

           <!-- lazy懒加载，默认为true，不写；设为false后，查询员工时，会连同部门信息一同查出来 -->

            <!-- name是部门对象在员工类中的名称 ；class是指员工跟哪个类是多对一关系-->

                  <!—多对一可以使用cascade级联操作，不符合实际操作，在一对多中使用-->

                       <many-to-one name="dept" class="com.hou.pojo.Dept" not-null="true" lazy=”false”>

                                <column name="deptFk"></column>

                       </many-to-one>

             </class>

Hibernate.cfg.xml文件映射

             <mapping resource="com/hou/pojo/Dept.hbm.xml"/>

             <mapping resource="com/hou/pojo/Emp.hbm.xml"/>

测试运行类

public class Test {

         private static Configuration cf =null;

         private static SessionFactory sf=null;

        

         static{

                   cf =new Configuration().configure();

                   sf=cf.buildSessionFactory();

         }

         public void addDept(Dept dept){

                   Session session =sf.openSession();

                   Transaction ts=session.beginTransaction();

                   session.save(dept);

                   ts.commit();

                   session.close();

         }

         public void updateDept(Dept dept){

                   Session session =sf.openSession();

                   Transaction ts=session.beginTransaction();

                   session.update(dept);

                   ts.commit();

                   session.close();

                  

         }

         //新增修改部门

         public void saveorupdateDept(Dept dept){

                   Session session=sf.openSession();

                   Transaction ts=session.beginTransaction();

                   session.saveOrUpdate(dept);

                   ts.commit();

                   session.close();

                  

         }//新增修改员工

         public void saveorupdateEmp(Employee emp){

                   Session session=sf.openSession();

                   Transaction ts=session.beginTransaction();

                   session.saveOrUpdate(emp);

                   ts.commit();

                   session.close();

                  

         }

         //通过Id获取部门

         public Dept getDeptById(int deptId){

                   Session session =sf.openSession();

                   Transaction ts=session.beginTransaction();

                   Dept dept=(Dept)session.get(Dept.class, deptId);

                   ts.commit();

                   session.close();

                   return dept;

         }

         //通过Id获取员工

         public Employee getEmpById(int empId){

                   Session session =sf.openSession();

                   Transaction ts=session.beginTransaction();

                   Employee emp=(Employee)session.get(Employee.class, empId);

                   ts.commit();

                   session.close();

                  

                   return emp;

         }

         //删除部门

         public void deleteDept(int deptId){

                   Session session =sf.openSession();

                   Transaction ts=session.beginTransaction();

                  //先删除员工，后删除部门

方法一Query query=session.createQuery("delete from Employee where dept.deptId="+deptId);直接删除员工

                   query.executeUpdate();

 

方法二Query query = session.createQuery("from Employee where dept.deptId="+deptId);查询返回的是个集合

                   List list = query.list();

                   for(int i=0;i<list.size();i++){

                            Employee emp = (Employee)list.get(i);

                            session.delete(emp);                循环删除员工

                   }                

                  

                   session.delete(getDeptById(deptId));              删除部门

                   ts.commit();

                   session.close();

         }

         public static void main(String[] args) {

                   // TODO Auto-generated method stub

                   Test test=new Test();

                   Dept dept=new Dept();

 

//               dept.setDeptName("侯强强");

//               dept.setDeptId(1);

//               test.updateDept(dept);

                  修改员工姓名，修改部门

                   /*Employee emp=new Employee();

                   emp.setEmpName("123");

                   emp.setEmpId(2);

                   emp.setDept(test.getDeptById(1));

                   test.saveorupdateEmp(emp);*/

                  /*新增员工，添加部门

                   Employee emp=test.getEmpById(2);

                   emp.setEmpName("张三");

                   emp.setDept(test.getDeptById(2));

                   test.saveorupdateEmp(emp);*/

                  删除部门

                   test.deleteDept(2);

 

 

 

//员工属性包含部门对象，只能查询到部门的Id， 其他的不能查询，如果查询部门的信息，需要配置lazy

        Employee emp = mt.getEmployeeById(2);

        System.out.println(emp.getEmpName()+"::"+emp.getEmpAge());

        Dept dept = emp.getDept();

        System.out.println("deptid=="+dept.getDeptId());

        System.out.println("deptName=="+dept.getDeptName());

         }

 

}

 

 

one-to-many (一对多)

    <set name="emps“>

           <key column="deptId" not-null="true"></key>

          <one-to-many class="com.tfsoft.pojo.Employee"  />

   </set>

新建学生类

         private int studId;

         private String studName;

新建班级类

         private int claId;

         private String claName;

         private Set emps = new HashSet();

新建Classes.hbm.xml文件

<class name="com.tfsoft.onetomany.Classes">

         <id name="claId">

           <generator></generator>

         </id>

         <property name="claName" length="10"></property>

        

         <!-- 一对多 -->

         <set name="emps" cascade="save-update"><!-- 集合在类中的名称 ；cascade级联操作-->

            <key column="claFk" not-null="true"></key><!-- 一方在多方中外键名称 -->

            <one-to-many class="com.tfsoft.onetomany.Student"/><!-- 一方对应多方的类 -->

         </set>

      </class>

cascade属性的值有:

all: 所有情况下均进行关联操作，即save-update和 delete。

none: 所有情况下均不进行关联操作。这是默认值。

save-update: 在执行save/update/saveOrUpdate时进行关联操作。

delete: 在执行delete 时进行关联操作。

cascade通常情况下都不会使用。特别是删除，一定要慎重

新建Student.hbm.xml文件

<class name="com.tfsoft.onetomany.Student">

         <id name="studId">

           <generator></generator>

         </id>

         <property name="studName" length="10"></property>

</class>

新建测试类

public class Onetomany {

         private static Configuration cf = null;

         private static SessionFactory sf = null;

         static{

                   cf = new Configuration().configure();

                   sf = cf.buildSessionFactory();

         }

        

         //新增学生

         public void saveOrUpdateStudent(Student stud){

                   Session session = sf.openSession();

                   Transaction ts = session.beginTransaction();          

 

                   Classes cla = (Classes)session.get(Classes.class, 1);先获取班级对象，调里面的学生集合，将学生放入集合

                   Set emps = cla.getEmps();                流程：先将学生姓名和外键为0添加进学生表，再根据学生Id把外键修改

                   emps.add(stud);

                  

                   session.saveOrUpdate(stud);

                   ts.commit();

                   session.close();

         }

        

         //删除班级               配置级联操作可以直接删除班级cascade=”all”

         public void deleteCla(int claId){

                   Session session = sf.openSession();

             Transaction ts = session.beginTransaction();

             Classes cla = (Classes)session.get(Classes.class, 1);

                   session.delete(cla);

                   ts.commit();

                   session.close();

         }

        

         //新增班级，级联加学生

         public void addCla(Classes cla){

                   Session session = sf.openSession();

                   Transaction ts = session.beginTransaction();

                   session.saveOrUpdate(cla);

                   ts.commit();

                   session.close();

         }

 

         public static void main(String[] args) {

                   // TODO Auto-generated method stub

        Onetomany mt = new Onetomany();

        Student stud = new Student();

        stud.setStudName("学生一");

        mt.saveOrUpdateStudent(stud);

       

//        mt.deleteCla(1);

       

        Classes cla = new Classes();    //添加班级，新建集合，将新建的学生放到集合中，把集合放到班级

        cla.setClaName("二班");

       

        Set set = new HashSet();

        Student stud1 = new Student("学生1");

        Student stud2 = new Student("学生2");

        set.add(stud1);

        set.add(stud2);

       

        cla.setEmps(set);

       

        mt.addCla(cla);

       

         }

}

转载于:https://my.oschina.net/u/2353689/blog/476068