Java框架之Hibernate

作者: Miss_差不多 | 来源:发表于2017-11-27 20:44 被阅读117次

JAVA高级编程之 hibernate框架学习一
别再用那些已经淘汰的技术了！2020 年 9 大顶级 Java
hibernate初识
Hibernate初识
JAVAEE框架学习——Hibernate——Hibernate
Java三大框架Structs、Spring、Hibernate
Java框架之Hibernate
SSH框架之Hibernate初识入门（一）
Hibernate简介及其与Spring框架的整合开发
Hibernate入门实例

首先,上图...

Hibernate 框架.png

上面的是hibernate中经常用到的知识点,我们一个一个看.

一工作流程

读取并解析配置文件
读取并解析映射信息，创建SessionFactory
打开Sesssion
创建事务Transation
持久化操作
提交事务
关闭Session
关闭SesstionFactory

jdbc 流程:

加载驱动mysql
获取连接
预编译
执行sql
将数据存入结果集
关闭数据库

jdbc和hibernate区别:

jdbc优点:

SQL应用灵活
数据库移植

jdbc缺点:

 不便于维 代码繁琐 护   效率低

hibernate 框架优点:

 真正基于ORM模型
 脱离java代码  降低耦合度
 操作简单,易用

缺点:

    不便于操作表结构复杂的sql
    不便于数据库移植(跨数据库移植)
    代替了jdbc技术,是一个全封装的框架,不便于调试bug

什么时候用hibernate框架

表数量少结构不复杂,快速应用它来开发

hibernate中的缓存技术:

1.只是一次连接数据库,多次使用

数据是存在缓存区里的,操作:session.get() session.save(),session.delete().
3.分为二级缓存:
一级缓存:session 存在内存的缓存区中
清理一级缓存的方式:
clear() 方法清理缓存直接从硬盘中的数据库读取
evict(对象) 执行的是数据库中的查询,第一次查询会失效
二级缓存:sessionFactort 存在硬盘中
Hibernate 缓存执行顺序
当 Hibernate 根据 ID 访问数据对象时，首先会从一级缓存 Session 中查找。若查不到且配置了二级缓存，则会从二级.
缓存中查找；若还查不到，就会查询数据库，把结果按照 ID 放入到缓存中。执行增、删、改操作时，会同步更新缓存。
二级缓存内容分类
根据缓存内容的不同，可以将 Hibernate 二级缓存分为三类：（1）类缓存：缓存对象为实体类对象（2）集合缓存：缓存对象为集合类对象（3）查询缓存：缓存对象为查询结果

hibernate框架中get方法和load方法获取对象的方式有什么不同:

get和load方法都是根据id去获得对应数据的，但是获得机制不同：如果使用get方法，hibernate会去确认该id对应的数据是否存在，它首先会去session中去查询(session缓存其实就hibernate的一级缓存)，如果没有，再去二级缓存中去查询，如果再没有，就去数据库中查询，仍然没有找到的话，就返回null
而使用load方法的话，hibernate会认定该id对应的数据一定存在，它也会先去session缓存中去查找，如果没有找到，hibernate会根据lazy属性值来确定是否使用延迟加载。如果lazy=‘true’ ，就使用延迟加载，返回该代理对象，等到真正访问到该对象的属性时才会去二级缓存中查询，如果没有，再去数据库中查询，如果还没有，就抛出org.hibernate.ObjectNotFoundException异常。如果lazy='false' 则不使用延迟加载，这是load的访问机制就和get一样了。

事物的特性:

1.原子性(不许分割)
2.一致性(两个事物可以有添加和减少)
3.隔离性(两个事物在执行过程中,相互不影响)
4.持久性: (两个事物执行完毕后,影响一直有效)

hibernate对象的状态

1.对象的临时状态 Emp e = new Emp("hah", 1000.0, 21, date);
2.对象的持久化状态 session.save(e);
st.commit();
3.对象的游离状态session.close();
事物是连接java代码和数据库的桥梁

hibernate框架中表之间的关系:

一对多
hibernate中级联删除:更改级联关系为 cascade="delect";
删除班级,删除学生有外键
直接删除:班级信息置为null 学生信息不变
:更改级联关系为 cascade="delect" 根据外键,删除当前表及其有关系的其他表,删除有外键有关系的表
一对多
在进行解除关系或者删除的时候 One-to-many比较简单,执行的效率高其他操作的时候many_to-one效率高
One-to-many 类和集合的关系
many-to-one 类和对象的关系
多对一(双向)
以Student-classes表为例一个班级有更多学生同样更多学生在一个班级
建立 Student 和Classes的实体类

//Classes表中的属性  注意学生集合
    private Integer c_id;
    private String  c_name;
    private Set<Student> stus;

  //student表中的属性
    private Integer s_id;
    private String s_name;
    //建立关系: 多个学生 一个班级
    private Classes cls;

//classes表的映射文件
<hibernate-mapping>
    <class name="cn.lanou3g.vo.Classes" >
        <id name="c_id">
            <generator class="increment" />
        </id>
        <property name="c_name"/>
     
        <!-- 搭建一对多的关系    inverse是否维系关系 默认false
        cascade 级联关系  save-update  保存或更新的时候维系关系
                        delete 级联删除-->
        <set name="stus" inverse="false" cascade="save-update">
        <!--从表的外键  -->
        <key column="c_id"></key>
        <!-- 指定对应关系   它是stus对应的实体类-->
        <one-to-many class="cn.lanou3g.vo.Student"/>
        </set>
       
    </class>
</hibernate-mapping>

//Student的映射文件
<hibernate-mapping>
    <class name="cn.lanou3g.vo.Student">
        <id name="s_id">
           <generator class="increment"/>
        </id>
        <property name="s_name"/>
        <!-- 建立关系 cls 多对一  cascade 级联关系-->
        <many-to-one name="cls" class="cn.lanou3g.vo.Classes" cascade="save-update">
         <!-- 这里的外键,要与one-to-many对应的外键一致 -->
         <!--  column 指定从表的外键-->
         <column name="c_id"></column>
         </many-to-one>
      </class>
</hibernate-mapping>

public class TextCon {
     Session session=HibernateSessionFactory.getSession();
     Transaction ts=session.beginTransaction();
    @Test
    public void textConn(){
       //新建配置对象  目的是自动加载配置文件
       Configuration cfg = new Configuration();
       cfg.configure();//自动加载主配置文件
       //开启session工厂
       SessionFactory sf=cfg.buildSessionFactory();
   
    }
    //保存学生 保存班级
    //@Test
    public void textaddStuandcls(){
       //新增班级
       Student stu = new Student();
       stu.setS_name("momo");
       //新增班级
       Classes cls = new Classes();
       cls.setC_name("java");
       //通过学生保存班级
       stu.setCls(cls);
       session.save(stu);
       ts.commit();
    }
    //更新学生 级联保存班级
    //@Test
       public void textupdateStuandcls(){
         Student stu = (Student)session.get(Student.class, 1);
         stu.setS_name("lida");
         session.save(stu);
         ts.commit();
    }
    //给学生赋班级
    //@Test
    public void testUpdateStu(){
       Student stu = (Student)session.get(Student.class, 2);
       Classes cls = (Classes)session.get(Classes.class, 1);
       stu.setCls(cls);
       session.save(stu);
       ts.commit();
    }
    //解除一个班级和所有学生之间的关系(注意保存班级)
    // delect（）  两表都删除
    //update 外键为null
    @Test
    public void testdelStuandcla(){
    Classes cls = (Classes)session.get(Classes.class, 1);
    //Student stu = (Student)session.get(Student.class, 1);
   //cls.setStus(null);//级联关系改为null
     session.update(cls);
     ts.commit();
    
    } 
}

多对多:
以course-student表为例很多课程被很多学生选择

 //student表中的属性
    private Integer s_id;
    private String s_name;
    private Set<Course> cours;

//coutse表中的属性
   private  Integer c_id;
   private String c_name;
   //建立联系  多对多 多个课程被多了学生选择
   private Set<Student> stus;

//Course表中映射文件
<hibernate-mapping>
    <class name="cn.lanou3g.vo.Student">
        <id name="s_id">
           <generator class="increment"/>
        </id>
        <property name="s_name"/>
        <!-- 建立关系 cls 多对一  cascade 级联关系-->
        <set name="cours" table="student_course" cascade="all">
        <key column="s_id"/>
        <many-to-many class="cn.lanou3g.vo.Course" column="c_id"/>
       
        </set>
     
    </class>
</hibernate-mapping>

//student的映射文件
<hibernate-mapping>
    <class name="cn.lanou3g.vo.Course">
        <id name="c_id">
           <generator class="increment"/>
        </id>
        <property name="c_name"/>
        <!-- 建立关系 cls 多对一  cascade 级联关系-->
        <set name="stus" table="student_course" cascade="all">
        <key column="c_id"/>
        <many-to-many class="cn.lanou3g.vo.Student" column="s_id"/>
       
        </set>
     
    </class>
</hibernate-mapping>

public class TextCon {
     Session session=HibernateSessionFactory.getSession();
     Transaction ts=session.beginTransaction();
    @Test
    public void textConn(){
       Configuration cfg = new Configuration();
       cfg.configure();
       SessionFactory sf = cfg.buildSessionFactory();
   
    }
    //添加一个新课程 添加一个新学生
    //先保存主表 在保存从表
    //@Test
    public void textinsert(){
       Student stu = new Student();
       Course cours =new Course();
       stu.setS_name("box");
       cours.setC_name("java");
       Set<Student> stus = new HashSet<Student>();
       stus.add(stu);
       cours.setStus(stus);
       session.save(cours);
       ts.commit();
       
    }
    //获取学生 修改学生姓名  课程中添加修改后的学生姓名
    //@Test
    public void textUpdatestu(){
       Student stu = (Student)session.get(Student.class, 1);
       stu.setS_name("灿烈");
       Course cours = (Course)session.get(Course.class, 1);
       Set<Student> stus = new HashSet<Student>();
       stus.add(stu);
       cours.setStus(stus);
       session.save(cours);
       ts.commit();
    }
    //解除课程1和所有学生的关系
    //解除课程1和所欲学生之间的关系
    //多对多关系的删除,只影响中间表,其他关联表不动
    //设置学生为null
    //@Test
    public void textdel(){
       Course cours = (Course)session.get(Course.class, 1);
      cours.setStus(null);
      session.save(cours);
      ts.commit();
    }
    //删除课程1下编号为1 的人
    //解除一个学生和一个课程的关系(值删除中间表)
    //多对多中单条删除用集合中的remove()进行删除
    @Test
    public void textdelmid(){
       Course cours = (Course)session.get(Course.class, 2);
       Student stu = (Student)session.get(Student.class, 2);
      Set<Course> c = stu.getCours();
      c.remove(cours);
      session.save(cours);
      ts.commit();
    }
    
}

一对一
以person-card为例一个人只有一个身份证

//card的属性    
    private Integer c_id;
    private String c_name;
    private Person c_p;

//person的属性
     private Integer p_id;//主键
     private String  p_name;
     private Card p_c;

//card的映射文件
<hibernate-mapping>
<!-- 引入实体类的全类名 -->
    <class name="cn.lanou3g.entity.Card">
    <!-- 主键字段 -->
    <id name="c_id">
      <generator class="increment"/>
    </id>
   
    <!--普通字段  -->
    <property name="c_name"/>
    <!-- 直接指定对应关系
    name  在当前类中存在的类类型
     class name属性对应的全类型
     cascade 对当前表的操作crud
    constrained="false"代表当前表是主表-->
    <one-to-one name="c_p" class="cn.lanou3g.entity.Person" cascade="all" constrained="true"/>
   </class>

//Person的映射文件
<hibernate-mapping>
<!-- 引入实体类的全类名 -->
    <class name="cn.lanou3g.entity.Person">
    <!-- 主键字段 -->
    <id name="p_id">
      <generator class="increment"/>
    </id>
   
    <!--普通字段  -->
    <property name="p_name"/>
    <!-- 直接指定对应关系
    name  在当前类中存在的类类型
     class name属性对应的全类型
     cascade 对当前表的操作crud
    constrained="false"代表当前表是主表
              true 代表从表-->
    <one-to-one name="p_c" class="cn.lanou3g.entity.Card" cascade="all" constrained="false"/>
  </class>
</hibernate-mapping>

public class text {
    Session session = HibernateSessionFactory.getSession();
     Transaction ts=session.beginTransaction();
   //自动建表
    
@Test
    public void textConn(){
       //新建配置对象  目的是自动加载配置文件
       Configuration cfg = new Configuration();
       cfg.configure();//自动加载主配置文件
       //开启session工厂
       SessionFactory sf=cfg.buildSessionFactory();
   
    }
// 同时添加人(主表)和身份证
  // @Test
     public void textInser(){
         Person p = new Person("梁靖");
         Card c = new Card("152727199603111025");
         //先保存从表中的关联字段
         c.setC_p(p);
        // p.setP_c(c);
         //保存从表
          session.save(c);
          ts.commit();
   }
   //修改id为1的姓名
    // @Test
     public void textUpdate(){
        Person p = (Person)session.get(Person.class, 2);
        p.setP_name("梁敏");
        session.save(p);
        ts.commit();
     }
     //删除用户 删除身份证 从主表中删除  从表的也删除
     //思路:通过主表获取关联字段
          //关联字段放入主表
          // 删除主表
    // @Test
     public void textdelect(){
        Person p = (Person)session.get(Person.class, 2);
//         Card p_c =p.getP_c();
//         p.setP_c(p_c);
         session.delete(p);
         ts.commit();
     }
}

懒加载

映射文件中加入属性lazy="true"
为什么用它:
防止内存溢出,递归调出方法

解决:
1.去掉任何一方的toString()
2.在不需要查询的一方的配置文件中加入lazy="true"

HQL语句:

是指hibernate sql
查询全部
查询某一个字段
按条件查询0

//分页
     Query q = session.createQuery("from User");
    //起始位置
     q.setFirstResult(0);
    //一次展示多少条
     q.setMaxResults(5);
    //把查询到的结果放入list集合
     List list = q.list();
     System.out.println(list);//遍历并且输出集合

JAVA高级编程之 hibernate框架学习一
JAVA之hibernate框架学习一 hibernate下载地址https://sourceforge.net/...
别再用那些已经淘汰的技术了！2020 年 9 大顶级 Java
目录顶级Java框架#1：Spring顶级Java框架#2：Hibernate顶级Java框架#3：Struts...
hibernate初识
hibernate框架 Hibernate框架简化了java应用程序与数据库交互的开发。 Hibernate是一个...
Hibernate初识
Hibernate框架Hibernate框架简化了java应用程序与数据库交互的开发。Hibernate是一个开源...
JAVAEE框架学习——Hibernate——Hibernate
Hibernate概述 Hibernate是什么 Hibernate是当今主流的java持久层框架。具有简单易学、...
Java三大框架Structs、Spring、Hibernate
Java三大框架研究 Hibernate框架有很多优点。它们分别如下： 1.开源和轻量级：Hibernate框架是...
Java框架之Hibernate
首先,上图... 上面的是hibernate中经常用到的知识点,我们一个一个看. 一工作流程读取并解析配置文件...
SSH框架之Hibernate初识入门（一）
第一节：Hibernate概述 1.1 什么是Hibernate Hibernate框架是当今主流的Java...
Hibernate简介及其与Spring框架的整合开发
Hibernate介绍出现背景在Hibernate等ORM框架出现之前，Java Web应用通常使用JDBC来...
Hibernate入门实例
创建Hibernate框架的程序大致步骤创建java项目为hibernate添加jar文件创建持久类创建持...

Java框架之Hibernate

一工作流程

jdbc 流程:

jdbc和hibernate区别:

jdbc优点:

jdbc缺点:

hibernate 框架优点:

缺点:

什么时候用hibernate框架

hibernate中的缓存技术:

hibernate框架中get方法和load方法获取对象的方式有什么不同:

事物的特性:

hibernate对象的状态

hibernate框架中表之间的关系:

懒加载

HQL语句:

相关文章

JAVA高级编程之 hibernate框架学习一

别再用那些已经淘汰的技术了！2020 年 9 大顶级 Java

hibernate初识

Hibernate初识

JAVAEE框架学习——Hibernate——Hibernate

Java三大框架Structs、Spring、Hibernate