Hibernate

Hibernate详细讲解

一、Hibernate

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

2. 作用：

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

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

• hibernate是跨数据库的

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

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

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

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

6. 配置文件：

   • *.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>
     

   • 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">update</property>
     
            <!--加载映射文件-->
            <mapping resource="Student.hbm.xml"></mapping>
        </session-factory>
     </hibernate-configuration>
     

     (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(