`
wx1568844008
  • 浏览: 5412 次
文章分类
社区版块
存档分类
最新评论

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

分享到：
| js的几种表单验证
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    hibernate关联映射详解

    hibernate,hibernate,hibernate,hibernate,hibernate,hibernate,hibernate,hibernate,hibernate,hibernate,hibernate,hibernate,hibernate,hibernate,包含4个说明文档，分别详细解说了hibernate关联映射的关联关系，...

    hibernate一对多关联映射（单向关联）

    这篇博客文章“hibernate一对多关联映射（单向关联）”将深入讲解如何配置和使用这种映射关系。 在单向关联中，只有一个实体知道另一个实体的存在，也就是说，只有父实体（"一"的一端）有对子实体（"多"的一端）的...

    Hibernate关联映射-one to one单向外键关联

    本话题主要探讨的是Hibernate中的一种关联映射方式——一对一（One-to-One）单向外键关联。这种关联模式通常用于两个实体之间存在唯一对应的关系，例如一个用户对应一个唯一的账户。 在Hibernate中，一对一关联可以...

    hibernate多对一单向关联关系实现源码

    以上就是关于Hibernate中实现多对一单向关联关系的基本知识，包括如何在实体类中定义关联、如何进行数据库操作以及如何查询关联对象。这个源代码示例应该提供了更具体的实现细节，你可以通过查看和运行它来深入理解...

    Hibernate一对一主键关联映射（单向关联）

    总结来说，Hibernate中的一对一主键关联映射允许两个实体共享同一个主键，实现单向关联时只需在依赖方添加对另一方的引用。在实际应用中，应根据业务需求谨慎选择关联类型，以确保数据的完整性和一致性。

    Hibernate关联映射总结

    在这种映射关系中，我们只在一端维护关联关系。比如，在`Person`类中添加`IdCard`对象的引用，但`IdCard`类不持有`Person`对象的引用。这意味着我们只能从`Person`对象访问到对应的`IdCard`信息，而不能反向操作。...

    hibernate实体关联关系映射

    ### Hibernate实体关联关系映射详解 #### 一、引言 Hibernate作为一种强大的对象关系映射（Object Relational Mapping，简称ORM）框架，在Java开发领域扮演着极其重要的角色。它不仅简化了持久化层的开发工作，...

    Hibernate 关联关系映射分类

    在深入探讨Hibernate关联关系映射分类之前，我们首先简要回顾一下Hibernate框架的基本概念。Hibernate是一种持久层框架，主要用于Java应用程序中的对象关系映射（ORM），它能够将面向对象的数据模型转换为数据库中的...

    Hibernate教程10_关系映射之多对一单向关联

    本教程主要聚焦于Hibernate中的一个关键概念——关系映射，特别是多对一单向关联的实现。这种关联类型常出现在数据库设计中，比如一个部门可以有多名员工，但一个员工只属于一个部门。 首先，我们要理解多对一关系...

    Hibernate教程04_关系映射之一对一单向外键关联

    **标题详解：**“Hibernate教程04_关系映射之一对一单向外键关联” 在Hibernate框架中，关系映射是数据库表之间的关联在对象模型中的体现。本教程重点讲解了一对一（One-to-One）单向外键关联的实现方法。在数据库...

    Hibernate关联映射

    1. Hibernate 一对一外键单向关联： 在 Hibernate 中，一对一的外键单向关联意味着一个实体类中的属性指向另一个实体类，而另一个实体类并不知道这个关联。这种关联可以通过在 `many-to-one` 元素中添加 `unique=...

    hibernate单向一对多关联映射(注解版)

    例如，当创建一个新的Employee时，你可以先创建一个Department对象，然后将它设置到Employee对象的department属性上，再保存Employee对象，Hibernate会自动处理关联关系。 5. **级联操作**：`@OneToMany`注解还可以...

    Hibernate一对一唯一外键关联映射（单向关联）

    接下来，我们需要在Hibernate的XML映射文件中定义这两个实体的关联关系。在`Person.hbm.xml`文件中： ```xml &lt;!-- Person.hbm.xml --&gt; &lt;hibernate-mapping&gt; &lt;!-- 一对一关联配置 --&gt; &lt;!-- 其他属性映射...

    Hibernate教程11_关系映射之一对多单向关联

    本教程主要探讨的是Hibernate中的一种重要关系映射类型：一对多单向关联。在关系型数据库中，一对多关联是最常见的关系类型，一个实体可以与多个其他实体相关联。在Hibernate中，这种关系可以通过配置XML映射文件或...

    hibernate的关联关系映射

    【hibernate的关联关系映射】在Java持久化框架Hibernate中，关联关系映射是核心功能之一，它允许对象间的复杂关系与数据库中的表结构相匹配。在选课系统这个例子中，主要涉及到的对象包括课题(Course)、教师(Teacher...

    Hibernate一对多单向关联映射

    总结，Hibernate的一对多单向关联映射通过XML映射文件和注解配合，可以方便地管理实体之间的关系。这种方式简化了数据库操作，提高了代码的可读性和可维护性。在实际开发中，应根据业务需求灵活运用，确保数据的一致...

    Hibernate单向关联代码示例

    总的来说，了解并掌握Hibernate的单向关联对于Java开发人员来说至关重要，因为它能有效地处理复杂的数据库关系，提高代码的可读性和可维护性。通过这个示例，你将深入理解如何配置、操作单向关联，并能在实际项目中...

    hibernate 单向多对多关联映射练习

    由于是单向关联，这个表由Hibernate自动创建，无需在实体类中显式声明。中间表通常包含两列，分别对应两个实体的主键。 3. **关联的管理**：在业务操作中，我们通常在单向的一方（如Student）添加或删除关联对象。...

Magicbox
Global site tag (gtag.js) - Google Analytics