Hibernate

Hibernate概述与配置

一、Hibernate

1. hibernate是对JDBC进行的轻量级封装，位于数据持久层

2. 作用：

• 和数据库做增、删、改、查

• 它是一个ORM的实现是面向对象编程与关系型 数据库之间的桥梁，是以对象的形式操作数据库的

• hibernate是跨数据库的

3. 优缺点：开发效率高，执行效率低

4. • 核心思想:Hibernate是基于对象来操作数据库的，但它最终还是被转换成SQL进行操作

5. ORM（Object Relation Mapping）：对象关系型的映射模型

• 关系型数据库：Mysql、SqlServer、Orcal

6. 配置文件：

   • *.hbm.xml(映射文件):

   • hibernate.cfg.xml(主配置文件):

     (1)Hibernate运行的底层信息：数据库连接信息、JDBC驱动、数据库Dialect(方言)等

     *注意：Hiberate之所以能和不同的数据库打交道，原因是因为它可以配置不同的方言，这就是Hibernate跨数据库的原因。

7. herbinate运行原理：

   • 首先通过configuration去加载hibernate.cfg.xml这个配置文件；
   • 根据配置文件的信息去创建Session Factory是线程安全的。是一个session工厂；
   • 来创建seesion对象
   • session是线程不安全的，相当于jdbc的connection，所以要，开启事务使线程安全；
   • 最后通过session去进行数据库的各种操作，在进行操作的时候通过transaction进行事物的控制

8. Hibernate不支持sql语句，它支持HQL语句

   • hql查询的是类和属性，不支持*
   • sql语句查的是表和字段

二、Hibernate封装

1. 没封装之前

   package test;
   
   
   import entity.Student;
   import org.hibernate.SessionFactory;
   import org.hibernate.Transaction;
   import org.hibernate.cfg.Configuration;
   import org.hibernate.classic.Session;
   
   public class TestHibernate {
       /*
            1.首先通过configuration去加载hibernate.cfg.xml这个配置文件,
            2.根据配置文件的信息去创建sessionFactory,
            3.sessionFactory是线程是不安全的，是一个session工厂,
            4.用来创建session,session是线程不安全的,相当于jdbc的connection,
            5. 最后通过session去进行数据库的各种操作，在进行操作的时候通过transaction进行事务的控制。
        */
       public static void main(String[] args) {
           //1.运行hibernate.cfg.xml文件
           Configuration configuration = new Configuration().configure("hibernate.cfg.xml");
           //2.创建session的工厂
           SessionFactory factory = configuration.buildSessionFactory();
           //3.创建session对象
           Session session = factory.openSession();
           //开启事务使线程安全
           Transaction transaction = session.beginTransaction();
           //4.创建对象
           Student student = new Student();
           student.setId(1);
           student.setName("张三");
           student.setScore(20);
           student.setAddress("团结屯");
           transaction.begin();
           //5.增加
           session.save(student);
           transaction.commit();
   
   
       }
   }
   
   

2. 封装之后

   • util可以不写

     package util;
     
     import org.hibernate.Session;
     import org.hibernate.SessionFactory;
     import org.hibernate.cfg.Configuration;
     
     public class HibernateUtils {
         private static Configuration configure = null;
         private static SessionFactory sessionFactory = null;
     
         //静态块:优先级高
         static {
             configure = new Configuration().configure("hibernate.cfg.xml");
             sessionFactory = configure.buildSessionFactory();
     
         }
     
         public static Session getSession() {
             Session session = sessionFactory.openSession();
             return session;
         }
     }
     
     

   • junit

     package junit;
     
     
     import org.hibernate.Session;
     import org.hibernate.SessionFactory;
     import org.hibernate.Transaction;
     import org.hibernate.cfg.Configuration;
     import org.junit.After;
     import org.junit.Before;
     import util.HibernateUtils;
     
     //Junit4 包括3个注解 @before @Test @After
     public class HibernateJunit {
         protected Transaction transaction = null;
         protected Session session = null;
     
         @Before
         public void startUp() {
     //        1.运行hibernate.cfg.xml文件
     //        Configuration configuration = new Configuration().configure("hibernate.cfg.xml");
     //        2.创建session的工厂
     //        SessionFactory factory = configuration.buildSessionFactory();
     //        3.创建session对象
     //        session = factory.openSession();
             //多进行了一次封装,可以将util删除，然后把上面的注释打开
             session = HibernateUtils.getSession();
             transaction = session.beginTransaction();
             transaction.begin();
         }
     
         @After
         public void end() {
             transaction.commit();
         }
     }
     
     

   • test类

     package test;
     
     import entity.Student;
     import junit.HibernateJunit;
     
     import org.hibernate.Query;
     import org.junit.Test;
     
     
     import java.util.List;
     
     public class TestHibernates extends HibernateJunit {
         @SuppressWarnings("deprecation")
     
         //增加
         @Test
         public void addStudent() {
             Student student = new Student();
             student.setName("22");
             student.setScore(20);
             student.setAddress("厦门");
             session.save(student);
             /*
                session.saveOrUpdate(student);
                增加和更新都可以使用这个方法
              */
         }
     
         //删除
         @Test
         public void deleteStudent() {
             Student student = new Student();
             student.setId(1);
             session.delete(student);
             //session.delete(session.get(Student.class,5));
         }
     
         //更新
         public void updateStudent() {
             Student student = (Student) session.load(Student.class, 1);
             student.setName("关于");
             student.setAddress("sss");
             session.update(student);
             /*
              增加和更新都可以使用这个方法
              session.saveOrUpdate(student);
              */
         }
         
         
     
         //查询一条数据
         @Test
         public void getStudent() {
             Student student = (Student) session.get(Student.class, 2);
             System.out.println(student.toString());
         }
     
         //加载一个学生
         @Test
         public void loadStudent() {
             //serializable:对象序列化
             Student student = (Student) session.load(Student.class, 1);
             System.out.println(student.toString());
         }
     
         //查询所有
         /*
         Query
     
     　　　　（1）使用该方法查询时，不需要编写sql语句，但是需要编写hql（Hibernate Query Language）语句，该语句是Hibernate查询语言。
     
     　　　　（2）hql语言操作的是实体类和实体类的属性，比如查询所有数据的hql语句为：from 实体类名称。
     
     　　　　（3）使用方法：首先创建Query对象，然后调用该对象的List方法返回数据集合。
          */
         @Test
         public void Query() {
             /**
              * 使用session对象的createQuery方法创建Query对象。
              * 参数为hql语句
              * 使用QUERY对象的list方法获取数据集合
              */
             Query query = session.createQuery("from Student");
             List<Student> list = query.list();
             使用forEach遍历集合
             for (Student student : list) {
                 System.out.println(student);
             }
         }
     }
     
     

3. 查询一条数据有两种方式：load和get

   • load是延迟加载(懒加载，按需加载)，当访问实体属性的时候才会发送sql语句，如果访问的实体不存在，则返回Object NotFound Excepetion

   • get是立即加载，当调用get方法后立即发送sql语句；当访问实体类不存在的时候，返回null

   • *注意：load支持延迟加载是通过lazy="true:,Student.hbm.xml中<class name="entity.Student" table="STUDENT" lazy="true">，进行配置，如果lazy=“false”,则load不在进行加载，变成立即加载

   。。。。默认情况下lazy=”true“

三、Hibernate对象的生命周期

1. 持久化对象的状态 :

   • 瞬时对象(Transient Object)：如果对象从未与Session对象关联 ，称对象处瞬时对象

   • 持久化对象(Persistent Object)：如果对象与session对象关联起来，且该对象对应到数据库记录，则称该对象对应到数据库记录中

   • 离线对象(Detached Object)：如果对象曾经与session关联过，但因为session被关闭或调用了session的evict或clear方法把它从session中移除了，则该对象脱离了session的管理，这种状态为托管状态

     [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-hfzTcIja-1629075542557)(C:\Users\lfc\AppData\Roaming\Typora\typora-user-images\1628928317629.png)]

2. Hibernate主键生成策略

   • 主配置文件(hibernate.cfg.xml)

     <?xml version="1.0" encoding="UTF-8" ?>
     <!DOCTYPE hibernate-configuration PUBLIC
             "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
             "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">
     <hibernate-configuration>
         <!--
         security:安全
         factory:工厂
         -->
     
         <session-factory>
             <!--
             相当于建了工厂要买机器
             属性连接数据库
              oracle.jdbc.driver.OracleDriver
             -->
     
             <!--
             Hibernate运行的底层信息:数据库连接信息、JDBC驱动、数据库Dialect(方言)等
             -->
             <property name="connection.driver_class">com.mysql.jdbc.Driver</property>
             <!--数据库连接信息-->
             <property name="connection.url">jdbc:mysql://localhost:3306/j2ee</property>
             <!--JDBC驱动-->
             <property name="connection.username">root</property>
             <property name="connection.password">123456</property>
             <!--方言:方言是为了数据库跨库-->
             <property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>
             <!--在控制台上显示数据-->
             <property name="show_sql">true</property>
             <!--格式化sql语句-->
             <property name="format_sql">true</property>
     
             <!--hbm  2  ddl(由映射文件到数据定义语言)-->
             <!--由实体类的配置文件去生成数据库的表结构-->
             <!--
             create:表示启动的时侯先drop,在creat
             create-drop:也表示创建,只不过在系统关闭前执行下一个drop
             update:更新 这个操作启动的时候会去检查schema是否一致,如果不一致会做schema更新
             validate:验证 启动时验证现有schema与你配置的hibernate是否一致,如果不一致就会抛出异常,并不做更新
             -->
             <property name="hibernate.hbm2ddl.auto">create</property>
     
             <!--加载映射文件-->
             <mapping resource="Student.hbm.xml"></mapping>
         </session-factory>
     </hibernate-configuration>
     

   • 映射文件 (Student.hbm.xml)

   <?xml version="1.0" encoding="UTF-8" ?>
   <!DOCTYPE hibernate-mapping PUBLIC
   
           "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
           "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
   <hibernate-mapping>
       <!--
       类对应表,属性对应字段
       lazy="true":默认为true,懒加载,如果改为false, 查询一条数据时get=load
       1.load是延迟加载（懒加载，按需加载），当访问实体属性的时候才会去发送sql语句,如果访问的实体不存在，则返回ObjectNotFoundException
   
       2.get是立即加载，当调用get方法后立即发送sql语句;当访问的实体不存在的时候，返回null,
       
       注意:load支持延迟加载通过lazy="true"进行配置，如果lazy="false"则load不再进行延迟加载。
        默认情况下lazy="true"
       -->
       <class name="entity.Student" table="STUDENT" lazy="true">
           <id name="id" type="java.lang.Integer" column="id">
               <!--
               主键生成策略
               generator:生成器
               主键类型(常见的6种):
                               assigned:(不建议使用)
                               identity:支持Mysql,不支持oracle(mysql专用)
                               sequence:支持oracle,不支持Mysql(Oracle专用)
                               increment:不依赖与数据库,可以进行跨数据库操作(都可以使用)
                               uuid:字符串(主键为字符串)32位,6进制,随机生成
                               native(自然):不管用的是什么数据库都会自动匹配主键生成策略,效率较低
                               foreign外键部署
               -->
               <generator class="identity"></generator>
   
        </id>
           <property name="name" type="java.lang.String" column="name"></property>
        <property name="score" type="java.lang.Double" column="score"></property>
           <property name="address" type="java.lang.String" column="address"></property>
   
   
       </class>
   </hibernate-mapping>
   

   三、HQL

lass=“identity”>

    </id>
       <property name="name" type="java.lang.String" column="name"></property>
    <property name="score" type="java.lang.Double" column="score"></property>
       <property name="address" type="java.lang.String" column="address"></property>


   </class>