慕课网Hibernate初探之一对多映射实验及总结

慕课网Hibernate初探之一对多映射实验及总结

一、本课核心

* 1、如何在MyEclipse中使用Hibernate
* 2、如何实现Hibernate中一对多的映射
* 3、如何创建Session对象
* 4、Hibernate如何使用增删改查

1、如何在MyEclipse中使用Hibernate

* Hibernat框架创建
* MyEclipse2016 CI 7版本
* Hibernate release-5.2.10.Final
* 方法一：自动创建
* 1、新建一个Java项目
* 2、右击项目，选择myeclipse，选择hibernate支持Project Facets[Capabilities]
* 3、然后点下一步就给你创建好了
*
* 方法二：手动创建
* 1、将需要的hibernate包以及MySql的jdbc添加并创建好路径（hibernate中lib中的required文件夹中的所有包）
* 2、在hebernate解压缩包下进行检索cfg.xml，找到配置文件
* 3、修改配置文件
* 4、在MyEclipse中创建sql文件
* 5、创建持久化类，也就是对应的实体类
* 6、创建映射文件，也可以在hebernate解压缩包下进行检索hbm.xml，拷到实体包下

2、如何实现Hibernate中一对多的映射

     //在一方（班级）去定义一个多方（学生）的集合来表示一对多的关系
     //set集合元素不能重复
     private Set<Student> students = new HashSet<Student>();
     /*
      * 总结：
      * 一对多映射的核心：
      * 通过在grade中添加student的集合来实现
      * 1、grade里面的这个集合类，需要映射的时候给这个类里面加学生
      * 2、grade这个类对应的映射文件中的
      * <!-- 配置单向的一对多关联关系 -->
         <set name="students" table="students">
             <!-- 指定关联的外键列 -->
             <key >
                 <column name="gid"></column>
             </key>
             <!-- 指定一对多的类名 -->
             <one-to-many class="com.imooc.entity.Student" />
         </set>
      */

3、如何创建Session对象

* 创建会话，四步：
* 1、建立配置文件对象，处理我们写的那些配置文件，包括数据库配置文件和映射文件
* 2、开启Hibernate服务，就像我们生活中用什么东西要开启什么样的服务一样，而且要注册
* 3、创建会话工厂
* 4、创建会话

         //创建配置对象
 Configuration config = new Configuration().configure();
         //创建服务注册对象
 ServiceRegistry serviceRegistry =  new
                 StandardServiceRegistryBuilder().applySettings(config.getProperties()).configure().build();//这里有点不一样
         //创建会话工厂对象
 sessionFactory = config.buildSessionFactory(serviceRegistry);
 session = sessionFactory.openSession();

4、Hibernate如何使用增删改查

Session使用：save():（增） delete():（删） update():（改） get()/load():（查）

二、实例代码

1、数据库配置文件：hibernate.cfg.xml

 <!--
   ~ Hibernate, Relational Persistence for Idiomatic Java
   ~
   ~ License: GNU Lesser General Public License (LGPL), version 2.1 or later.
   ~ See the lgpl.txt file in the root directory or <http://www.gnu.org/licenses/lgpl-2.1.html>.
   -->
 <!DOCTYPE hibernate-configuration PUBLIC
         "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
         "http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">

 <hibernate-configuration>
     <session-factory>
         <property name="hibernate.dialect">org.hibernate.dialect.MySQL5InnoDBDialect</property>
         <property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
         <property name="hibernate.connection.username">root</property>
         <property name="hibernate.connection.password">1314</property>
         <property name="hibernate.connection.url">
             <![CDATA[
                 jdbc:mysql://localhost:3306/Hibernate2?useUnicode=true&characterEncoding=utf8
             ]]>
         </property>

         <property name="show_sql">true</property>
         <property name="hbm2ddl.auto">update</property>

         <!-- 指定映射文件的路径 -->
         <mapping resource="Grade.hbm.xml" />
         <mapping resource="Student.hbm.xml" />

     </session-factory>
 </hibernate-configuration>

2、实体类一Student.java

 package com.imooc.entity;

 import java.io.Serializable;

 public class Student implements Serializable {
     private int sid; //学生id
     private String sname; //学生姓名
     private String sex; //性别

     //构造函数

     public Student() {
         super();
     }

     public Student(String sname, String sex) {
         super();
         this.sname = sname;
         this.sex = sex;
     }

     public int getSid() {
         return sid;
     }

     public void setSid(int sid) {
         this.sid = sid;
     }
     public String getSname() {
         return sname;
     }
     public void setSname(String sname) {
         this.sname = sname;
     }
     public String getSex() {
         return sex;
     }
     public void setSex(String sex) {
         this.sex = sex;
     }

 }

3、Student类对应的映射文件 Student.hbm.xml

 <?xml version="1.0"?>

 <!DOCTYPE hibernate-mapping PUBLIC
     "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
     "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">

 <!-- 配置的是学生到班级的单向的一对多 -->
 <hibernate-mapping>
     <class name="com.imooc.entity.Student" table="student">
     <!-- name是类名，table是那么对应的类对应的数据库中的表名 -->
     <!-- id是主键 -->
         <id name="sid" type="java.lang.Integer">
             <column name="sid"></column>
             <generator class="increment"></generator>
             <!-- generator是主键生成策略 increment查找主键最大值，并且在最大值的基础上加1 -->
         </id>
         <property name="sname" type="java.lang.String">
             <column name="sname" length="20" not-null="true"></column>
         </property>
         <property name="sex">
             <column name="sex"></column>
         </property>

     </class>

 </hibernate-mapping>

4、班级实体类 Grade.java

 package com.imooc.entity;

 import java.io.Serializable;
 import java.util.HashSet;
 import java.util.Set;

 //班级类
 //添加集合表示一对多的关系
 public class Grade implements Serializable {
     private int gid; //班级id
     private String gname; //班级名
     private String gdesc; //班级描述

     //在一方（班级）去定义一个多方（学生）的集合来表示一对多的关系
     //set集合元素不能重复
     private Set<Student> students = new HashSet<Student>();
     /*
      * 总结：
      * 一对多映射的核心：
      * 通过在grade中添加student的集合来实现
      * 1、grade里面的这个集合类，需要映射的时候给这个类里面加学生
      * 2、grade这个类对应的映射文件中的
      * <!-- 配置单向的一对多关联关系 -->
         <set name="students" table="students">
             <!-- 指定关联的外键列 -->
             <key >
                 <column name="gid"></column>
             </key>
             <!-- 指定一对多的类名 -->
             <one-to-many class="com.imooc.entity.Student" />
         </set>
      */

     //构造方法
     public Grade(int gid, String gname, String gdesc, Set<Student> students) {
         super();
         this.gid = gid;
         this.gname = gname;
         this.gdesc = gdesc;
         this.students = students;
     }

     public Grade(String gname, String gdesc) {
         super();
         this.gname = gname;
         this.gdesc = gdesc;
     }

     public Grade() {
         super();
     }

     public int getGid() {
         return gid;
     }

     public void setGid(int gid) {
         this.gid = gid;
     }

     public String getGname() {
         return gname;
     }

     public void setGname(String gname) {
         this.gname = gname;
     }

     public String getGdesc() {
         return gdesc;
     }

     public void setGdesc(String gdesc) {
         this.gdesc = gdesc;
     }

     public Set<Student> getStudents() {
         return students;
     }

     public void setStudents(Set<Student> students) {
         this.students = students;
     }

 }

5、班级实体类对应的映射文件 Grade.hbm.xml

 <?xml version="1.0"?>

 <!DOCTYPE hibernate-mapping PUBLIC
     "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
     "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">

 <hibernate-mapping>

     <class name="com.imooc.entity.Grade" table="grade">
     <!-- name是类名，table是那么对应的类对应的数据库中的表名 -->
     <!-- id是主键 -->
         <id name="gid"  type="java.lang.Integer">
             <column name="gid"></column>
             <generator class="increment"></generator>
             <!-- generator是主键生成策略 increment查找主键最大值，并且在最大值的基础上加1 -->
         </id>
         <property name="gname" type="java.lang.String">
             <column name="gname" length="20" not-null="true"></column>
         </property>
         <property name="gdesc">
             <column name="gdesc"></column>
         </property>
         <!-- 配置单向的一对多关联关系 -->
         <set name="students" table="students">
             <!-- 指定关联的外键列 -->
             <key >
                 <column name="gid"></column>
             </key>
             <!-- 指定一对多的类名 -->
             <one-to-many class="com.imooc.entity.Student" />
         </set>

     </class>

 </hibernate-mapping>

6、获取session的工具类：HibernateUtil.java

 package com.imooc.util;

 /*
  * 总结：
  * 创建会话，四步：
  * 1、建立配置文件对象，处理我们写的那些配置文件，包括数据库配置文件和映射文件
  * 2、开启Hibernate服务，就像我们生活中用什么东西要开启什么样的服务一样，而且要注册
  * 3、创建会话工厂
  * 4、创建会话
  */
 import org.hibernate.Session;
 import org.hibernate.SessionFactory;
 import org.hibernate.boot.registry.StandardServiceRegistry;
 import org.hibernate.boot.registry.StandardServiceRegistryBuilder;
 import org.hibernate.cfg.Configuration;
 import org.hibernate.service.ServiceRegistry;

 //工具类，用来进行会话的获取和关闭
 public class HibernateUtil {
     private static SessionFactory sessionFactory;
     private static Session session;

     //通过静态代码块来加载
     static{
         //创建Configuration对象，读取hibernate.cfg.xml文件，完成初始化
         //        Configuration config = new Configuration().configure();
         //        StandardServiceRegistryBuilder ssrb = new StandardServiceRegistryBuilder().
         //                applySettings(config.getProperties());
         //        StandardServiceRegistry ssr = ssrb.build();
         //        sessionFactory=config.buildSessionFactory(ssr);
         //创建配置对象
         Configuration config = new Configuration().configure();
         //创建服务注册对象
         ServiceRegistry serviceRegistry =  new
                 StandardServiceRegistryBuilder().applySettings(config.getProperties()).configure().build();//这里有点不一样
         //创建会话工厂对象
         sessionFactory = config.buildSessionFactory(serviceRegistry);

         /*
          * 总结：
          * 创建会话，四步：
          * 1、建立配置文件对象，处理我们写的那些配置文件，包括数据库配置文件和映射文件
          * 2、开启Hibernate服务，就像我们生活中用什么东西要开启什么样的服务一样，而且要注册
          * 3、创建会话工厂
          * 4、创建会话
          */
     }

     //获取sessionFactory
     public static SessionFactory getSessionFactory(){
         return sessionFactory;
     }

     //获取Session
     public static Session getSession(){
         session = sessionFactory.openSession();
         return session;
     }

     //关闭Session
     public static void closeSession(Session session){
         if (session!=null) {
             session.close();
         }
     }

 }

7、测试功能类，测试增删改查：Test.java

 /*
  * 一定要主要总结啊，要把学到的东西变成自己的东西
  * 其实Hibernate说难也难，说简单也简单，两步：
  * 1、成功获取Session对象的环境搭建
  * 2、Session使用：save():（增） delete():（删） update():（改） get()/load():（查）
  *
  * 这一次课的核心：
  * 1、如何在MyEclipse中使用Hibernate
  * 2、如何实现Hibernate中一对多的映射
  * 3、如何创建Session对象
  * 4、如何使用增删改查
  *
  */
 package com.imooc.entity;
 /*
  * 错误一：
  * 出现错误：Dialect不对
  * 解决方法：把配置文件方言改成org.hibernate.dialect.MySQL5InnoDBDialect就好
  * 错误二：
  * 出现错误：org.hibernate.MappingException: Unknown entity: com.imooc.entity.Grade
  * 错误分析：映射文件错误，根本就没有成功读取Grade的映射文件
  *              将配置文件中的添加实体映射删掉，报的错误一样，说明错误是这里或之前
  *              修改这之前的，出现新的错误，说明错误就在这里
  *              既然是报错找不到com.imooc.entity.Grade，我把所有出现这个的地方都改下，查到底是那里错句
  *              错误提示session.save(g);这一句是错的，注释掉之后出现没有学生实体类的错误
  *              说明两个映射文件根本都没有加进去
  *              com.imooc.entity.Grade这个包名是我在test里面引包，其实就是session没有找到Grade实体
  *              待会去用eclipse试一下
  * 解决方法：还是生产session会话那里有问题，用之前的eclipse里面hibernate生成会话的方式就解决了
  *              还是因为hibernate的版本和他的版本不一样，用的hibernate里面的required也不一样
  * 解决心得：其实这种看视频，真的要用的软件、包、工具和他一模一样才好
  *              仔细分析，找错还是挺好找的
  */

 import java.util.Set;

 import org.hibernate.Hibernate;
 import org.hibernate.Session;
 import org.hibernate.Transaction;

 import com.imooc.util.HibernateUtil;

 /*
  * 单向一对多关系
  * （班级--->学生）
  * 建立关联关系后，可以方便的从一个对象导航到另一个对象
  * 注意关联的关系
  */
 public class Test {
     public static void main(String[] args){
         //add();
         //findStudentsByGrade();
         //update();
         delete();
     }

     //将学生添加到班级
     /*
      * 方法测试对应的输出结果:
      *
 Hibernate: select max(gid) from grade
 Hibernate: select max(sid) from student
 Hibernate: insert into grade (gname, gdesc, gid) values (?, ?, ?)
 Hibernate: insert into student (sname, sex, sid) values (?, ?, ?)
 Hibernate: insert into student (sname, sex, sid) values (?, ?, ?)
 Hibernate: update student set gid=? where sid=?
 Hibernate: update student set gid=? where sid=?
      *
      *
      */
     public static void add(){
         Grade g = new Grade("Java一班","Java软件开发一班");
         Student stu1 = new Student("张三","男");
         Student stu2 = new Student("穆女神","女");

         //将这两个学生添加到班级中
         //如果希望在学生表中添加对应的班级编号，需要在班级中添加学生，建立关联关系
         g.getStudents().add(stu1); //set集合students集合汇总添加，是Grade中的属性
         g.getStudents().add(stu2);

         //得到会话
         Session session = HibernateUtil.getSession();
         //开启事务
         Transaction tx = (Transaction) session.beginTransaction();
         //保存班级，学生
         session.save(g);
         session.save(stu1);
         session.save(stu2);
         //提交事务
         tx.commit();
         //关闭session
         HibernateUtil.closeSession(session);
         /*
          * 总结：
          * 1、新建班级对象和学生对象
          * 2、将学生对象加入班级对象属性中的学生集合中
          * 3、调用Session对象保存班级对象和学生对象
          * save学生对象是把学生信息添加到学生表中
          * save班级对象是把班级信息添加到班级表中
          * 将学生对象加入班级对象属性中的学生集合中：其实是为了和映射文件一起完成主外键的连接
          *
          */
     }

     //查询班级中包含的学生，根据班级获取对应的信息
     /*
      * 方法测试对应的输出结果:
      * Hibernate: select grade0_.gid as gid1_0_0_, grade0_.gname as gname2_0_0_, grade0_.gdesc as gdesc3_0_0_ from grade grade0_ where grade0_.gid=?
      * Java一班,Java软件开发一班
      * Hibernate: select students0_.gid as gid4_1_0_, students0_.sid as sid1_1_0_, students0_.sid as sid1_1_1_, students0_.sname as sname2_1_1_, students0_.sex as sex3_1_1_ from student students0_ where students0_.gid=?
      * 穆女神,女
      * 张三,男
      */
     public static void findStudentsByGrade(){
         //1、建立会话
         Session session=HibernateUtil.getSession();
         //2、通过session从数据库取出班级消息
         Grade grade= session.get(Grade.class, 1);
         System.out.println(grade.getGname()+","+grade.getGdesc());
         //3、从班级消息中取出学生消息，其实就已经达到目的了
         Set<Student> students=grade.getStudents();
         //4、for遍历输出学生的消息
         for (Student student : students) {
             System.out.println(student.getSname()+","+student.getSex());
         }
         /*
          * 总结：
          * 1、
          * 其实核心语句就是Session的get方法，因为这个本事就是一个查询啊
          * get里面的一个参数是类，那么另一个参数就是主键，类对应的表的主键
          * 同理，后面的改就是先get，然后update
          * 删就直接delete对应的类对象就好
          * 2、
          * 通过session给对象发送sql，连接数据库，返回数据库消息，这些都是session给对象来完成的
          * 我们只用享受胜利的果实即可
          *
          */
     }

     //修改学生信息
     //这里将学生信息添加到一个新的班级
     /*
      * 心得：
      * 前面总结和一下之后，他这里说啥我能接上下面的
      *
      * 方法测试对应的输出结果:
 Hibernate: select student0_.sid as sid1_1_0_, student0_.sname as sname2_1_0_, student0_.sex as sex3_1_0_ from student student0_ where student0_.sid=?
 Hibernate: select max(gid) from grade
 Hibernate: insert into grade (gname, gdesc, gid) values (?, ?, ?)
 Hibernate: update student set gid=? where sid=?
      *
      */
     public static void update(){
         //这里数据库的结果是班级表里面多了下面的这一条记录
         //并且对应的学生也修改到了这个班级
         Grade grade = new Grade("Java二班","Java软件开发二班");
         //开启事务
         Session session=HibernateUtil.getSession();
         //因为是进行的数据库的更新，所以必须开启事务
         Transaction transaction= session.beginTransaction();
         //这里是Session得到的是学生表中的信息
         Student student=session.get(Student.class, 1);
         grade.getStudents().add(student);
         session.save(grade);
         transaction.commit();
         HibernateUtil.closeSession(session);

         /*
          * 总结：
          * 1、不管对数据库的什么操作，首先肯定要先打开Session
          * 2、更新就是先get，后update，但是在这里是save，
          * 3、但凡修改数据库的，加上事务，事务开了肯定也要关闭
          * 4、因为这里是映射，所以这里还要在班级中加入学生对象
          *
          */

     }

     //删除学生信息
     /*
      * 总结：
      * 得益于前面的总结，这里是自己写的，而且和他写的一样
      * 自己写的时候还是犹豫了一下要不要开transaction
      * 但是对数据库的修改肯定是要开session的
      *
      * 方法测试对应的输出结果:
 Hibernate: select student0_.sid as sid1_1_0_, student0_.sname as sname2_1_0_, student0_.sex as sex3_1_0_ from student student0_ where student0_.sid=?
 Hibernate: delete from student where sid=?
      * 在数据库的表中成功的删除了主键为4的学生
      */
     public static void delete(){

         Session session = HibernateUtil.getSession();
         //因为是进行的数据库的改变的操作，所以必须开启事务
         Transaction transaction= session.beginTransaction();
         Student student = session.get(Student.class, 4);
         session.delete(student);
         transaction.commit();
         HibernateUtil.closeSession(session);
     }

 }

文件对应的目录结构如下