• hibernate 2 一对多、多对一 双向映射


    多对一或一对多中,在多的一方维护关系效率高

    一:java实体类

    1、Classes.java

     1 package cn.gs.ly.school.entity;
     2 
     3 import java.util.Set;
     4 
     5 public class Classes {
     6     private int cid;
     7     private String cname;
     8     private String cdescription;
     9     private Set<Student> students;
    10     public int getCid() {
    11         return cid;
    12     }
    13     public void setCid(int cid) {
    14         this.cid = cid;
    15     }
    16     public String getCname() {
    17         return cname;
    18     }
    19     public void setCname(String cname) {
    20         this.cname = cname;
    21     }
    22     public String getCdescription() {
    23         return cdescription;
    24     }
    25     public void setCdescription(String cdescription) {
    26         this.cdescription = cdescription;
    27     }
    28     public Set<Student> getStudents() {
    29         return students;
    30     }
    31     public void setStudents(Set<Student> students) {
    32         this.students = students;
    33     }
    34     
    35 }

    2、Student.java

     1 package cn.gs.ly.school.entity;
     2 
     3 public class Student {
     4     private int sid;
     5     private String sname;
     6     private String sdescription;
     7     private Classes classes;
     8     
     9     public int getSid() {
    10         return sid;
    11     }    
    12     public void setSid(int sid) {
    13         this.sid = sid;
    14     }
    15     public String getSname() {
    16         return sname;
    17     }
    18     public void setSname(String sname) {
    19         this.sname = sname;
    20     }
    21     public String getSdescription() {
    22         return sdescription;
    23     }
    24     public void setSdescription(String sdescription) {
    25         this.sdescription = sdescription;
    26     }
    27     public Classes getClasses() {
    28         return classes;
    29     }
    30     public void setClasses(Classes classes) {
    31         this.classes = classes;
    32     }
    33     
    34 }

    二:配置映射信息,建立表与类之间关系

    1、Classes.hbm.xml

     1 <?xml version="1.0" encoding="UTF-8"?>
     2 <!DOCTYPE hibernate-mapping PUBLIC 
     3     "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
     4     "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
     5    
     6 <!-- 配置表与实体对象的关系 --> 
     7 <hibernate-mapping>
     8     <class name="cn.gs.ly.school.entity.Classes"  >
     9         <id name="cid" column="cid" type="java.lang.Integer">
    10             <generator class="assigned"></generator>
    11         </id>
    12         <property name="cname" column="cname" type="java.lang.String"></property>
    13         <property name="cdescription" column="cdescription" type="java.lang.String"></property>    
    14         
    15         <!--         
    16             cascade="save-update" 级联操作
    17             当保存班级的时候对学生进行什么操作 
    18             inverse="false" 是否维护关系
    19                 true不维护关系、false维护关系
    20         -->
    21         <set name="students" cascade="save-update" inverse="false">  <!-- 级联 -->
    22             <!-- 
    23                 key 用来描述外键 
    24                 set元素对用classes类中的set集合
    25                 通过key是  通过外键的形式将两张表建立联系
    26                 通过one-to-many让两个类建立关联
    27             -->
    28             <key>
    29                 <column name="cid"></column>
    30             </key>
    31             <one-to-many class="cn.gs.ly.school.entity.Student"/>
    32         </set>                    
    33     </class>
    34     
    35 </hibernate-mapping>

    2、Student.hbm.xml

     1 <?xml version="1.0" encoding="UTF-8"?>
     2 <!DOCTYPE hibernate-mapping PUBLIC 
     3     "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
     4     "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
     5    
     6 <!-- 配置表与实体对象的关系 --> 
     7 <hibernate-mapping>
     8     <class name="cn.gs.ly.school.entity.Student"  >
     9         <id name="sid" column="sid" type="java.lang.Integer">
    10             <generator class="assigned"></generator>
    11         </id>
    12         <property name="sname" column="sname" type="java.lang.String"></property>
    13         <property name="sdescription" column="sdescription" type="java.lang.String"></property>    
    14         <!-- 多对一column 描述外键 -->
    15         <many-to-one name="classes" class="cn.gs.ly.school.entity.Classes" column="cid" cascade="save-update"></many-to-one>    
    16     </class>
    17     
    18 </hibernate-mapping>

    3、编写配置文件,连接数据库,引入映射信息文件

    hibernate.cfg.xml

     1 <?xml version="1.0" encoding="UTF-8"?>
     2 <!DOCTYPE hibernate-configuration PUBLIC
     3     "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
     4     "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">
     5     
     6 <hibernate-configuration>
     7     <!-- 一个session-factory只能链接一个数据库  -->
     8     <session-factory>
     9         <!-- 
    10         进行数据库连接
    11             driver:驱动
    12             url:地址
    13             username:数据库连接用户名
    14             password:数据库连接密码
    15             数据库方言
    16                   不同的数据库中,sql语法略有区别. 指定方言可以让hibernate框架在生成sql语句时.针对数据库的方言生成.
    17               sql99标准: DDL 定义语言  库表的增删改查
    18                       DCL 控制语言  事务 权限
    19                       DML 操纵语言  增删改查
    20              注意: MYSQL在选择方言时,请选择最短的方言.            
    21          -->
    22          <property name="dialect">org.hibernate.dialect.Oracle10gDialect</property>
    23          <property name="connection.driver_class">oracle.jdbc.driver.OracleDriver</property>
    24          <property name="connection.url">jdbc:oracle:thin:@localhost:1521:orcl</property>
    25          <property name="connection.username">liuyang</property>
    26          <property name="connection.password">orcl</property>
    27          <!-- 
    28              自动建表  
    29                auto schema export  自动导出表结构. 自动建表
    30                hibernate.hbm2ddl.auto create      自动建表.每次框架运行都会创建新的表.以前表将会被覆盖,表数据会丢失.(开发环境中测试使用)
    31                hibernate.hbm2ddl.auto create-drop 自动建表.每次框架运行结束都会将所有表删除.(开发环境中测试使用)
    32                hibernate.hbm2ddl.auto update(推荐使用) 自动生成表.如果已经存在不会再生成.如果表有变动.自动更新表(不会删除任何数据).
    33                hibernate.hbm2ddl.auto validate    校验.不自动生成表.每次启动会校验数据库中表是否正确.校验失败.
    34          -->
    35 <!--          <property name="hbm2ddl.auto">update</property> -->
    36          <property name="hbm2ddl.auto">update</property>
    37          
    38          <!-- 将hibernate生成的sql语句打印到控制台 -->
    39          <property name="show_sql">true</property>    
    40          <!-- 添加映射文件 -->        
    41          <mapping resource="cn/gs/ly/entity/Person.hbm.xml"></mapping>     
    42          <mapping resource="cn/gs/ly/school/entity/Student.hbm.xml"></mapping>         
    43          <mapping resource="cn/gs/ly/school/entity/Classes.hbm.xml"></mapping>         
    44     </session-factory>
    45 </hibernate-configuration>

    三:测试类

    oneToManyTest.java

      1 package cn.gs.ly.school.test;
      2 
      3 import java.util.ArrayList;
      4 import java.util.HashSet;
      5 import java.util.List;
      6 import java.util.Set;
      7 
      8 import org.hibernate.SessionFactory;
      9 import org.hibernate.Transaction;
     10 import org.hibernate.cfg.Configuration;
     11 import org.hibernate.classic.Session;
     12 import org.junit.After;
     13 import org.junit.Before;
     14 import org.junit.Test;
     15 
     16 import cn.gs.ly.school.entity.Classes;
     17 import cn.gs.ly.school.entity.Student;
     18 import sun.util.calendar.CalendarSystem;
     19 
     20 /** Hibernate执行流程:
     21  *         Configuration:读取并解析配置文件(hibernate.cfg.xml)
     22  *             一个Configuration实例代表hibernate所有的java类到SQL数据库映射的集合
     23  *         SessionFactory:读取并解析映射信息(***.hbm.xml)
     24  *             将Configuration对象中的所有配置信息拷贝到SessionFactory的缓存中
     25  *         打开Session,让SessionFactory提供连接。
     26  *            SessionFactory factory = con.buildSessionFactory(); 
     27  *        Transaction:开启事务。
     28  *            Transaction tr = se.beginTransaction();
     29  *        数据库操作(get,delete,update,save)完成:提交事务、关闭Session
     30  *            tr.commit(); 
     31  *            se.close();
     32  *
     33  * Hibernate对象三种状态
     34  *         save():将对象由瞬时态转变为持久态
     35  *         liad()/get():获得的对象的状态处于持久态
     36  *         find():获得的List集合中的对象的状态处于持久态
     37  *         upload()/saveOrUpload()/lock():可将托管状态对象转变为持久态
     38  *         close():调用后,Session的缓存会被清空,缓存中所有持久态对象状态都转变为托管态
     39  *             处于托管状态的对象称为游离对象,当游离对象不再被引用时,将被JVM垃圾回收机制清除
     40  *         evict():可将Session缓存中一个指定的持久态对象删除,使其转变为托管态对象
     41  *             当缓存中保存了大量持久态对象时,为了节省内存空间,可以调用此方法删除一些持久态对象
     42  *         
     43  * */
     44 
     45 public class OneToManySingleTest {    
     46     SessionFactory factory =null;
     47     Session se = null;
     48     Transaction tr = null;
     49     
     50     //@Before:读取并解析配置文件、映射信息、打开Session、开启事务
     51     @Before
     52     public void test1(){                
     53         //读取配置文件   //1 创建,调用空参构造
     54         Configuration con = new Configuration();
     55         //2 读取指定主配置文件 => 空参加载方法,加载src下的hibernate.cfg.xml文件
     56         con.configure();
     57         //创建一个session工厂      //4 根据配置信息,创建 SessionFactory对象
     58         factory = con.buildSessionFactory();
     59         //5 获得session  打开一个新的session对象
     60         se = factory.openSession();
     61         //开启事务   //开启事务并获得操作事务的tr对象(建议使用)
     62         tr = se.beginTransaction();
     63     }
     64     //@After:提交事务、关闭Session
     65     @After
     66     public void afterClose(){
     67         //提交事务
     68         tr.commit();
     69         //关闭session
     70         se.close();
     71     }
     72 
     73     //1.新建一个班级
     74     @Test 
     75     public void testCreateClasses(){
     76         Classes classes = new Classes();
     77         classes.setCid(1);
     78         classes.setCname("gs01");
     79         classes.setCdescription("一群大老爷们");
     80         se.save(classes);
     81     }
     82     
     83     //2.新建一个学生
     84     @Test 
     85     public void testCreateStudent(){
     86         Student student = new Student();
     87         student.setSid(1);
     88         student.setSname("张涛");
     89         student.setSdescription("诸城一爷们");
     90         se.save(student);
     91     }
     92     
     93     //3.新建一个班级的同时新建一个学生
     94     @Test 
     95     public void testCreateStudentClasses(){
     96         Student student = new Student();
     97         student.setSid(2);
     98         student.setSname("刘超");
     99         student.setSdescription("中华小题库");        
    100         
    101         Classes classes = new Classes();
    102         classes.setCid(2);
    103         classes.setCname("gs02");
    104         classes.setCdescription("一群学霸");
    105         
    106         Set<Student> stus = new HashSet<Student>();
    107         stus.add(student);
    108         classes.setStudents(stus);
    109         se.save(classes);
    110     }
    111     
    112     //4.已经存在一个班级,新建一个学生。建立联系:inverse(true不维护关系,false不维护关系)
    113     @Test 
    114     public void testUpdateClass_Inverse_createStudent(){
    115         Classes classes = (Classes)se.get(Classes.class, 1); //id为1 的班级即gs01
    116         
    117         Student student = new Student();
    118         student.setSid(3);
    119         student.setSname("萌萌");
    120         student.setSdescription("一个光头的男人");
    121         
    122         classes.getStudents().add(student);
    123         //se.update(classes);
    124     }
    125     
    126     //5.已经存在一个学生,新建一个班级
    127     @Test  
    128     public void testCreateClassLinkStudent(){        
    129         Classes classes = new Classes();
    130         classes.setCid(3);
    131         classes.setCname("gs03");
    132         classes.setCdescription("一个新的班级");
    133         
    134         Student student = (Student)se.get(Student.class, 1);
    135         
    136         Set<Student> stus = new HashSet<Student>();
    137         stus.add(student);        
    138         classes.setStudents(stus);
    139         se.save(classes);
    140     }
    141     
    142     //6.把一个学生从一个班级转到另一个班级
    143     @Test 
    144     public void testMoveStudent(){        
    145         Student student = (Student)se.get(Student.class, 1); //获得要转班的学生
    146         Classes classes = (Classes)se.get(Classes.class, 2); //获得要转到的那个班级
    147         //Classes classes1 = (Classes)se.get(Classes.class, 3);//原来的班级
    148         //classes1.getStudents().remove(student); //把这个学生从原来班级删除
    149         classes.getStudents().add(student);  //把这个学生添加到要转去的那个新班级
    150     }
    151     
    152     //7.解除一个班级和一个学生的关系
    153     @Test 
    154     public void test7(){        
    155         Student student = (Student)se.get(Student.class, 4); //获得要转班的那个学生
    156         Classes classes = (Classes)se.get(Classes.class, 3); //获得这个学生原来所在的班级
    157         classes.getStudents().remove(student); //把这个学生从原来班级删除
    158     }
    159     
    160     //8.解除一个班级和一些学生的关系
    161     @Test 
    162     public void test8(){        
    163         Classes classes = (Classes)se.get(Classes.class, 3); //解除关系的班级
    164         Set<Student> students = classes.getStudents(); //此班级里所有学生,返回set集合
    165         //set无下标,只查看集合不修改集合,所以用list集合进行修改 ,Set转List
    166         List<Student> list = new ArrayList<Student>(students);
    167         for (int i=0;i<list.size();i++) {
    168             if(list.get(i).getSid()==4||list.get(i).getSid()==6){ //id为4和6的学生
    169                 list.remove(i);//移除后,集合大小动态改变,集合大小-1
    170                 i--;           //集合变小,i也需要变化
    171             }
    172         }
    173         //List转Set集合,
    174         students = new HashSet<Student>(list);
    175         classes.setStudents(students);
    176     }
    177     
    178     //9.解除一个班级和所有学生的关系
    179     @Test 
    180     public void test9(){            
    181         Classes classes = (Classes)se.get(Classes.class, 3); //获得一个班级
    182 //        Set<Student> students = classes.getStudents();
    183 //        students.clear();    
    184         classes.setStudents(null);
    185     }
    186     
    187     //10.已经存在了一个班级,也存在一个学生 建立班级与学生的关系
    188     @Test 
    189     public void test10(){        
    190         Classes classes = (Classes)se.get(Classes.class, 2); // id 为1 的班级即gs01
    191         Student student = (Student)se.get(Student.class, 7);        
    192         classes.getStudents().add(student);
    193     }
    194     
    195     @Test //11.已经存在了一个班级,也存在许多学生 建立班级与学生的关系
    196     public void test11(){    //未完成    =====================    
    197 //        Classes classes = (Classes)se.get(Classes.class, 3);
    198 //        Set<Student> students = classes.getStudents();
    199 //        //set无下标,只查看集合不修改集合,所以用list集合 ,set转list
    200 //        List<Student> list = new ArrayList<Student>(students);
    201 //        for (int i=0;i<list.size();i++) {
    202 //            if(list.get(i).getSid()==4||list.get(i).getSid()==5||list.get(i).getSid()==6){
    203 //                
    204 //            }else{
    205 //                list.remove(i);
    206 //            }
    207 //        }
    208 //        //list转set集合
    209 //        students = new HashSet<Student>(list);
    210 //        classes.setStudents(students);
    211     }
    212     
    213     //12.删除学生
    214     @Test 
    215     public void test12(){    
    216         Student student = (Student)se.get(Student.class, 2);
    217         se.delete(student);
    218     }
    219     
    220      // 13.删除班级(需先解除关系)       
    221      //     1.在删除班级前,解除班级与学生之间的关系: inverse="false" 维护关系 删除班级解除关系
    222      //     2.在删除班级的时候同时删除学生: 级联操作  cascade="all" 或  cascade="delete"
    223     @Test  
    224     public void test13(){        
    225         Classes classes = (Classes)se.get(Classes.class, 3);
    226         //classes.setStudents(null);  //解除关系   inverse="true"时需此操作来解除关系
    227         se.delete(classes);        
    228     }
    229         
    230 }

    ManyToOneTest.java

      1 package cn.gs.ly.school.test;
      2 
      3 import java.util.ArrayList;
      4 import java.util.HashSet;
      5 import java.util.List;
      6 import java.util.Set;
      7 
      8 import org.hibernate.SessionFactory;
      9 import org.hibernate.Transaction;
     10 import org.hibernate.cfg.Configuration;
     11 import org.hibernate.classic.Session;
     12 import org.junit.After;
     13 import org.junit.Before;
     14 import org.junit.Test;
     15 
     16 import cn.gs.ly.school.entity.Classes;
     17 import cn.gs.ly.school.entity.Student;
     18 import sun.util.calendar.CalendarSystem;
     19 
     20 public class ManyToOneSingleTest2 {
     21     
     22     SessionFactory factory =null;
     23     Session se = null;
     24     Transaction tr = null;
     25     @Before
     26     public void test1(){
     27         //读取配置文件   //1 创建,调用空参构造
     28         Configuration con = new Configuration();
     29         //2 读取指定主配置文件 => 空参加载方法,加载src下的hibernate.cfg.xml文件
     30         con.configure();
     31         //创建一个session工厂      //4 根据配置信息,创建 SessionFactory对象
     32         factory = con.buildSessionFactory();
     33         //5 获得session  打开一个新的session对象
     34         se = factory.openSession();
     35         //开启事务   //开启事务并获得操作事务的tr对象(建议使用)
     36         tr = se.beginTransaction();
     37     }
     38     @After
     39     public void afterClose(){
     40         //提交事务
     41         tr.commit();
     42         //关闭session
     43         se.close();
     44     }
     45 
     46 // 一对多双向
     47     /**
     48      *     多对一或一对多中,在多的一方维护关系效率高       student角度
     49      * 
     50      * */
     51     
     52     @Test //1.新建一个班级
     53     public void testCreateClasses(){
     54         Classes classes = new Classes();
     55         classes.setCid(10);
     56         classes.setCname("gs010");
     57         classes.setCdescription("一群大老爷们");
     58         se.save(classes);
     59     }
     60     
     61     @Test //2.新建一个学生
     62     public void testCreateStudent(){
     63         Student student = new Student();
     64         student.setSid(10);
     65         student.setSname("张涛");
     66         student.setSdescription("诸城一爷们");
     67         se.save(student);
     68     }
     69     
     70     @Test //3.新建一个班级的同时新建一个学生  
     71     public void testCreateStudentClasses(){
     72         Student student = new Student();
     73         student.setSid(11);
     74         student.setSname("刘杨");
     75         student.setSdescription("学霸");        
     76         
     77         Classes classes = new Classes();
     78         classes.setCid(21);
     79         classes.setCname("gs021");
     80         classes.setCdescription("一群学霸");
     81         
     82         student.setClasses(classes);
     83         se.save(student);
     84     
     85     }
     86     
     87     @Test //4.已经存在一个班级,新建一个学生                  建立联系  inverse(true不维护false维护)
     88     public void testUpdateClass_Inverse_createStudent(){
     89         Classes classes = (Classes)se.get(Classes.class, 21); // id 为1 的班级即gs01
     90         Student student = new Student();
     91         student.setSid(12);
     92         student.setSname("萌萌");
     93         student.setSdescription("一个光头的男人");
     94         
     95         student.setClasses(classes);
     96         se.save(student);
     97     }
     98     
     99 //    @Test //5.已经存在一个学生,新建一个班级 
    100 //    public void testCreateClassLinkStudent(){        
    101 //        Classes classes = new Classes();
    102 //        classes.setCid(3);
    103 //        classes.setCname("gs03");
    104 //        classes.setCdescription("一个新的班级");
    105 //        
    106 //        Student student = (Student)se.get(Student.class, 1);
    107 //        
    108 //        Set<Student> stus = new HashSet<Student>();
    109 //        stus.add(student);        
    110 //        classes.setStudents(stus);
    111 //        se.save(classes);
    112 //    }
    113 //    
    114 //    @Test //6.把一个学生从一个班级转到另一个班级
    115 //    public void testMoveStudent(){        
    116 //        Student student = (Student)se.get(Student.class, 1); //获得要转班的那个学生
    117 //        Classes classes = (Classes)se.get(Classes.class, 2); //获得要转到的那个班级
    118 //        //Classes classes1 = (Classes)se.get(Classes.class, 3);//原来的班级
    119 //        //classes1.getStudents().remove(student); //把这个学生从原来班级删除
    120 //        classes.getStudents().add(student);  //把这个学生添加到要转去的那个新班级
    121 //    }
    122 //    
    123 //    @Test //7.解除一个班级和一个学生的关系
    124 //    public void test7(){        
    125 //        Student student = (Student)se.get(Student.class, 4); //获得要转班的那个学生
    126 //        Classes classes = (Classes)se.get(Classes.class, 3); //获得这个学生原来所在的班级
    127 //        classes.getStudents().remove(student); //把这个学生从原来班级删除
    128 //    }
    129     
    130     @Test //8.解除一个班级和一些学生的关系
    131     public void test8(){        
    132         //Classes classes = (Classes)se.get(Classes.class, 21);
    133         Student s1 = (Student)se.get(Student.class, 4);
    134         Student s2 = (Student)se.get(Student.class, 5);
    135         s1.setClasses(null);
    136         s2.setClasses(null);
    137     }
    138     
    139     @Test //9.解除一个班级和所有学生的关系
    140     public void test9(){            
    141         Classes classes = (Classes)se.get(Classes.class, 3); 
    142 //        Set<Student> students = classes.getStudents();
    143 //        students.clear();    
    144         classes.setStudents(null);
    145     }
    146     
    147     @Test //10.已经存在了一个班级,也存在一个学生 建立班级与学生的关系
    148     public void test10(){        
    149         Classes classes = (Classes)se.get(Classes.class, 2); // id 为1 的班级即gs01
    150         Student student = (Student)se.get(Student.class, 7);        
    151         classes.getStudents().add(student);
    152     }
    153     
    154     @Test //11.已经存在了一个班级,也存在许多学生 建立班级与学生的关系
    155     public void test11(){        
    156         Classes classes = (Classes)se.get(Classes.class, 3);
    157         Set<Student> students = classes.getStudents();
    158         //set无下标,只查看集合不修改集合,所以用list集合 ,set转list
    159         List<Student> list = new ArrayList<Student>(students);
    160         for (int i=0;i<list.size();i++) {
    161             if(list.get(i).getSid()==4||list.get(i).getSid()==5||list.get(i).getSid()==6){
    162                 
    163             }else{
    164                 list.remove(i);
    165             }
    166         }
    167         //list转set集合
    168         students = new HashSet<Student>(list);
    169         classes.setStudents(students);
    170     }
    171     
    172     @Test //12.删除学生
    173     public void test12(){    
    174         Student student = (Student)se.get(Student.class, 2);
    175         se.delete(student);
    176     }
    177     
    178     @Test // 13.删除班级    (解除关系)       
    179           // 1.在删除班级前,解除班级与学生之间的关系: inverse="false" 维护关系 删除班级解除关系
    180           // 2.在删除班级的时候同时删除学生: cascade="all" 或  cascade="delete"  
    181     public void test13(){        
    182         Classes classes = (Classes)se.get(Classes.class, 3);
    183         //classes.setStudents(null);  //解除关系   inverse="true"时需此操作
    184         se.delete(classes);        
    185     }
    186 
    187 }
  • 相关阅读:
    Python保留最后N个元素
    STL算法
    STL迭代器
    STL容器
    C++总结1
    牛客剑指Offer2
    Vue第一天
    UML
    Java继承和组合代码
    Java15后的sealed阻止继承滥用
  • 原文地址:https://www.cnblogs.com/liuyangv/p/8405944.html
Copyright © 2020-2023  润新知