Hibernate类中集合的映射

1 pojo类集合属性的映射

在pojo类中定义集合属性。

1.1  List集合属性的映射

 package org.guangsoft.pojo;
 import java.util.List;
 public class Student
 {
     // 简单属性
     private Integer sno;
     private String sname;
     private String address;
     private String birthday;
     // 定义List集合属性,爱好
     private List<String> hobbys;
     public Integer getSno()
     {
         return sno;
     }
     public void setSno(Integer sno)
     {
         this.sno = sno;
     }
     public String getSname()
     {
         return sname;
     }
     public void setSname(String sname)
     {
         this.sname = sname;
     }
     public String getAddress()
     {
         return address;
     }
     public void setAddress(String address)
     {
         this.address = address;
     }
     public String getBirthday()
     {
         return birthday;
     }
     public void setBirthday(String birthday)
     {
         this.birthday = birthday;
     }
     public List<String> getHobbys()
     {
         return hobbys;
     }
     public void setHobbys(List<String> hobbys)
     {
         this.hobbys = hobbys;
     }
 } 

1.2 建立pojo的映射文件

 <?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE hibernate-mapping PUBLIC
     "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
     "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
 <hibernate-mapping package="org.guangsoft.pojo">
     <!-- 类 到 表 -->
     <class name="Student" table="t_student">
         <id name="sno" column="sno" type="java.lang.Integer">
             <generator class="native"></generator>
         </id>
         <!-- 其他简单属性 -->
         <property name="sname" column="sname" type="java.lang.String"></property>
         <property name="address" column="address" type="java.lang.String"></property>
         <property name="birthday" column="birthday" type="java.lang.String"></property>
         <!-- list集合属性的映射,学生的爱好 -->
         <list name="hobbys" table="t_hobbys">
             <!-- t_hobbys 中的外键 ，引用t_student中的sno t_student 为主表 t_hobbys 为子表，主外键关系是子表中的某个列（外键），引用主表的主键
                 t_hobbys中的主键为联合主键（sno，idx） -->
             <!-- key为爱好表中的外键 -->
             <key column="sno"></key>
             <!-- 元素在List集合中的下标 -->
             <index column="idx" type="java.lang.Integer"></index>
             <element column="hbys" type="java.lang.String"></element>
         </list>
     </class>
 </hibernate-mapping>
  

1.3 加载映射文件产生数据库模型

两张表产生主外键关系

1.4.1 添加学生信息和爱好1.4 进行学生数据的操作

 /**
  * 添加学生信息，同时增加学生的爱好
  * ***/
 @Test
 public void saveStudent(){
     //获得数据库会话对象
     Session session = sf.openSession();
     //开启事务
     Transaction tr = session.beginTransaction();
     //创建Student对象
     Student stu = new  Student();
     stu.setSname("周润发");
     stu.setAddress("香港");
     stu.setBirthday("1988-10-10");
     //封装爱好数据
     List<String> list = new ArrayList<String>();
     list.add("吃");
     list.add("喝");
     list.add("拉");
     //将list集合封装到stu对象
     stu.setHobbys(list);
     //调用session的save方法
     session.save(stu);
     //提交事务
     tr.commit();
     //释放资源
     session.close();
 }

1.4.2 修改学生信息和爱好

 /**
  * 修改学生信息，同时增加学生的爱好
  * ***/
 @Test
 public void updateStudent(){
     //获得数据库会话对象
     Session session = sf.openSession();
     //开启事务
     Transaction tr = session.beginTransaction();
     //获得数据的学生数据
     Student stu = (Student) session.get(Student.class, 1);
     //修改学生对象属性
     stu.setSname("刘德华3");
     //获得stu对象原来的爱好
     List<String> list = stu.getHobbys();
     for(String s:list){
         System.out.println("s="+s);
     }
     //list.add(0, "睡");
     list.clear();//删除了学生的爱好
     //重写添加爱好
     list.add("游戏");
     list.add("敲代码");
     //调用session的update方法
     session.update(stu);
     //提交事务
     tr.commit();
     //释放资源
     session.close();
 }

1.4.3 查询学生信息和爱好

 /***
  * 查询所有学生信息和爱好
  * ***/
 @Test
 public void testSelectStudent(){
     //获得数据库会话对象
     Session session = sf.openSession();
     //定义HQL
     String hql="from Student";
     //执行查询
     List<Student> list = session.createQuery(hql).list();
     //遍历集合
     for(Student stu:list){
         System.out.println(stu.getSname());
         //获得学生的爱好
         List<String> slist=stu.getHobbys();
         for(String s:slist){
             System.out.println("\t\ts="+s);
         }
     }
 }

1.4.4.学生信息和爱好的删除

 /**
  * 删除学生信息，同时删除学生的爱好
  * ***/
 @Test
 public void deleteStudent()
 {
     //获得数据库会话对象
     Session session = sf.openSession();
     //开启事务
     Transaction tr = session.beginTransaction();
     //获得数据的学生数据
     Student stu = (Student) session.get(Student.class, 1);
     //调用session的delete方法
     session.delete(stu);
     //提交事务
     tr.commit();
     //释放资源
     session.close();
 }

1.5 set集合属性的映射

1.5.1 建立pojo加入set集合属性

一个学生多个电话号码

 package com.bjsxt.pojo;
 import java.util.HashSet;
 import java.util.Set;
 public class Student {
     //简单属性
     private Integer sno;
     private String sname;
     private String address;
     private String birthday;
     //一个人多个电话号码
     private Set<String> phones = new HashSet<String>();[A2]
             public Set<String> getPhones() {
         return phones;
     }
     public void setPhones(Set<String> phones) {
         this.phones = phones;
     }
     public Integer getSno() {
         return sno;
     }
     public void setSno(Integer sno) {
         this.sno = sno;
     }
     public String getSname() {
         return sname;
     }
     public void setSname(String sname) {
         this.sname = sname;
     }
     public String getAddress() {
         return address;
     }
     public void setAddress(String address) {
         this.address = address;
     }
     public String getBirthday() {
         return birthday;
     }
     public void setBirthday(String birthday) {
         this.birthday = birthday;
     }
 }

1.5.2 建立pojo的映射文件

 <?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE hibernate-mapping PUBLIC
     "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
     "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
 <hibernate-mapping package="org.guangsoft.pojo">
     <!-- 类 到 表 -->
     <class name="Student" table="t_student">
         <id name="sno" column="sno" type="java.lang.Integer">
             <generator class="native"></generator>
         </id>
         <!-- 其他简单属性 -->
         <property name="sname" column="sname" type="java.lang.String"></property>
         <property name="address" column="address" type="java.lang.String"></property>
         <property name="birthday" column="birthday" type="java.lang.String"></property>
         <!-- 进行set集合属性的映射 name:集合属性名称 table:集合属性对应的子表的名称 总结：集合属性的映射三要求 子表 外键 元素（子表中保存的数据） -->
         <set name="phones" table="t_phone">
             <key column="sno"></key><!-- 外键 -->
             <element column="phs"></element><!-- 集合中元素对应的列 -->
         </set>
     </class>
 </hibernate-mapping>

1.5.3 进行学生数据的操作

完成学生数据的curd操作。

常见问题：需要扩大session的生命周期

 package org.guangsoft.test;
 import java.util.List;
 import java.util.Set;
 import org.hibernate.Criteria;
 import org.hibernate.Session;
 import org.hibernate.SessionFactory;
 import org.hibernate.Transaction;
 import org.hibernate.cfg.Configuration;
 import org.junit.Test;
 import org.guangsoft.pojo.Student;
 public class TestCollection
 {
     /**
      *
      * 通过静态代码块加载配置文件
      *
      * ****/
     static SessionFactory sf = null;
     static
     {
         // 1 创建Configuration对象，用来加载hibernate的配置文件
         Configuration cfg = new Configuration();
         // 2加载配置文件
         cfg.configure("hibernate.cfg.xml");
         // 3通过cfg构造一个会话工厂对象
         sf = cfg.buildSessionFactory();
     }
     /**
      *
      * 添加学生信息，同时增加学生的电话
      *
      * ***/
     @Test
     public void saveStudent()
     {
         // 获得数据库会话对象
         Session session = sf.openSession();
         // 开启事务
         Transaction tr = session.beginTransaction();
         // 创建Student对象
         Student stu = new Student();
         stu.setSname("周润发");
         stu.setAddress("香港");
         stu.setBirthday("1988-10-10");
         // 封装电话数据
         stu.getPhones().add("110");
         stu.getPhones().add("120");
         // 调用session的save方法
         session.save(stu);
         // 提交事务
         tr.commit();
         // 释放资源
         session.close();
     }
     /**
      *
      * 修改学生信息，同时增加学生的爱好
      *
      * ***/
     @Test
     public void updateStudent()
     {
         // 获得数据库会话对象
         Session session = sf.openSession();
         // 开启事务
         Transaction tr = session.beginTransaction();
         // 创建Student对象
         Student stu = (Student) session.load(Student.class, 4);
         stu.setSname("xxx");
         // 修改电话信息
         Set<String> phones = stu.getPhones();
         phones.clear();
         // phones集合添加电话
         phones.add("119");
         phones.add("911");
         // stu.setPhones(phones);
         // 调用session的upate方法
         session.update(stu);
         // 提交事务
         tr.commit();
         // 释放资源
         session.close();
     }
     /***
      *
      * 查询所有学生信息和电话
      *
      * ***/
     @Test
     public void testSelectStudent()
     {
         // 获得session对象
         Session session = sf.openSession();
         // 标准的对象查询
         Criteria c = session.createCriteria(Student.class);
         // 获得集合对象
         List<Student> slist = c.list();
         // session.close();
         // 遍历集合
         for (Student s : slist)
         {
             System.out.println(s.getSname());
             // 通过对象之间的关联加载获得电话的集合
             /**
              *
              * no session or session was close
              *
              * 通过对象关联的加载其他数据的时候，也是需要查询数据的，查询数据库的时候数据库连接已经断开
              *
              * ***/
             Set<String> phones = s.getPhones();
             for (String p : phones)
             {
                 System.out.println("\t\t" + p);
             }
         }
     }
     /**
      *
      * 删除学生信息，同时删除学生的电话
      *
      * ***/
     @Test
     public void deleteStudent()
     {
         //
         Session session = sf.openSession();
         //
         Transaction tr = session.beginTransaction();
         // 通过查询获得需要删除的对象
         Student stu = (Student) session.load(Student.class, 4);
         // 进行删除操作
         session.delete(stu);
         // 提交事务
         tr.commit();
         // 释放资源
         session.close();// 不是真正意义上的关闭（将connection对象归还：连接池）
     }
 }

1.6 Map集合属性的映射

1.6.1建立Pojo类添加Map属性

 package com.bjsxt.pojo;
 import java.util.HashMap;
 import java.util.Map;
 public class Student
 {
     // 简单属性
     private Integer sno;
     private String sname;
     private String address;
     private String birthday;
     // 定义Map属性，一个多个地址，而且对地址进行了编号
     private Map<String, String> addes = new HashMap<String, String>();
     public Map<String, String> getAddes()
     {
         return addes;
     }
     public void setAddes(Map<String, String> addes)
     {
         this.addes = addes;
     }
     public Integer getSno()
     {
         return sno;
     }
     public void setSno(Integer sno)
     {
         this.sno = sno;
     }
     public String getSname()
     {
         return sname;
     }
     public void setSname(String sname)
     {
         this.sname = sname;
     }
     public String getAddress()
     {
         return address;
     }
     public void setAddress(String address)
     {
         this.address = address;
     }
     public String getBirthday()
     {
         return birthday;
     }
     public void setBirthday(String birthday)
     {
         this.birthday = birthday;
     }
 }

1.6.2 建立映射文件

 <?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE hibernate-mapping PUBLIC
     "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
     "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
 <hibernate-mapping package="org.guangsoft.pojo">
     <!-- 类 到 表 -->
     <class name="Student" table="t_student">
         <id name="sno" column="sno" type="java.lang.Integer">
             <generator class="native"></generator>
         </id>
         <!-- 其他简单属性 -->
         <property name="sname" column="sname" type="java.lang.String"></property>
         <property name="address" column="address" type="java.lang.String"></property>
         <property name="birthday" column="birthday" type="java.lang.String"></property>
         <!-- 进行Map集合属性的映射 三要素：子表 ，外键 ，元素 -->
         <map name="addes" table="t_addes">
             <key column="sno"></key><!-- 外键 -->
             <!-- map元素对应的key -->
             <map-key type="java.lang.String" column="ky"></map-key>
             <element column="addes" type="java.lang.String"></element>
         </map>
     </class>
 </hibernate-mapping>

1.6.3 加载配置产生数据模型

1.6.4 进行学生信息的添加

 /**添加学生信息和地址***/
 @Test
 public void testSaveStudent(){
     //获得session
     Session session = sf.openSession();
     //开启事务
     Transaction tr=session.beginTransaction();
     //创建学生对象
     Student stu = new Student();
     stu.setSname("*");
     stu.setAddress("陕西");
     stu.setBirthday("1953-6-26");
     //指定stu对象的地址
     stu.getAddes().put("A", "北京");
     stu.getAddes().put("B", "福建");
     //保存数据
     session.save(stu);
     //提交事务
     tr.commit();
     //释放资源
     session.close();
 }

1.6.5 查询所有学生数据

 /**
  * 查询所有学生信息
  * ***/
 @Test
 public void selectStudent(){
     //获得session
     Session session = sf.openSession();
     //查询学生信息
     List<Student> slist = session.createCriteria(Student.class).list();
     //遍历集合
     for(Student s:slist){
         System.out.println(s.getSname());
         //获得学生对象的地址集合
         Map<String,String> addes=s.getAddes();
         //遍历Map集合
         for(Entry<String, String> e:addes.entrySet()){
             System.out.println("\t\t"+e.getKey()+"   ----    "+e.getValue());
         }
     }
     //释放资源
     session.close();
 }

1.6.6修改学生数据

 @Test
 public void updateStudent(){
     //获得session
     Session session = sf.openSession();
     //开启事务
     Transaction tr=session.beginTransaction();
     //查询学生对象
     Student stu=(Student) session.get(Student.class, 5);
     //修改学生属性
     stu.setSname("小李");
     //修改地址，修改Map集合中指定键的值
     stu.getAddes().put("A", "上海");
     //更新数据
     session.update(stu);
     //提交事务
     tr.commit();
     //释放资源
     session.close();
 }

1.6.7 删除学生数据

 /***删除学生信息
  * 主表子表一起删除
  * ***/
 @Test
 public void deleteStudent(){
     //获得session
     Session session = sf.openSession();
     //开启事务
     Transaction tr=session.beginTransaction();
     //查询学生对象
     Student stu=(Student) session.get(Student.class, 5);
     //删除数据
     session.delete(stu);
     //提交事务
     tr.commit();
     //释放资源
     session.close();
 }