Hibernate基础

Hibernate: 是一个开放源代码的对象关系映射框架，对jdbc进行轻量级的封装，持久层的ORM（Object  Relational Mapping对象关系映射）框架。

一、Hibernate目录结构：

　　

　　

　　1.documentation：Hibernate开发文档

　　2.lib:运行时jar包，其中，required下的jar包是必须的。

　　3.project:Hibernate提供的参考项目，主要看etc下的配置文件，如hibernate.cfg.xml与hibernate.properties。

二：Hibernate创建工程步骤

　　1）创建一个项目：

　　　　　　1.在项目下创建一个lib文件夹，把required中的jar包引入。

　　　　　　2.数据库驱动包：

　　2）建表（可自动建表）

　　3）创建ORM类：创建domain

　　4）创建映射关系

　　5）创建Hibernate核心配置文件

　　　　　　1.hibernate.cfg.xml就是其核心配置文件，将其从etc下复制到src下。

　　　　　　2.其内容：

<!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><!--与masql产生会话，相当于连接数据库-->

 <!--连接数据库的基本参数--> <property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property><!--驱动器--> 

<property name="hibernate.connection.url">jdbc:mysql:///hibernate?serverTimezone=GMT%2B8</property><!--数据库名--> 

<property name="hibernate.connection.username">root</property><!--用户名-->

 <property name="hibernate.connection.password">1234</property><!--密码--> <!--配置Hibernate的方言--> 

<property name="hibernate.dialect">org.hibernate.dialect.MySQL5Dialect</property><!--声明使用mysql数据库语言格式,中间要加5--> <!--打印sql--> 

<property name="hibernate.show_sql">true</property><!--生成sql后进行打印--> 
<!--格式化sql--> 

<property name="hibernate.format_sql">true</property> 
<property name="hibernate.hbm2ddl.auto">update</property> <!--自动创建表--> 

<mapping resource="com/ual/domain/customer.hbm.xml"/><!--告诉hibernate要操作哪些表，写入映射的配置文件的全路径--> 

</session-factory> 

</hibernate-configuration>

其中的配置文件在hibernate.properties中可以找到.

　　注意：

<property name="hibernate.hbm2ddl.auto">update</property> <!--自动创建表--> 
　　1.none:不适用hibernate自动建表
　　2.create:如果数据库中已经有表，删除原有表，重新创建，如果没有表，新建表
　　3.create-drop:如果数据库中已经有表，删除原表，执行操作，如果没有表，新建一个，使用完了删除表，最后数据库中没有表，用于测试(执行sessionFactory.close()才有效）
　　4.update:如果数据库中有表，使用原有表，如果没有，创建表，更新表结构，如果表中没有某列，会创建新的一列。
　　5.validate:如果没有表，不会创建表，只会使用数据库中的原有表，校验映射与表结构是否一致，不一致就报错。

　　6）配置映射配置文件：1.在domain下创建，类名.hbm.xml。

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

　　　　　　　　　　　　　3.映射配置文件写法

<?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">
<!--让java中的类与数据库中的表相关联，这样操作domain类就操作了与该类映射的表-->
<hibernate-mapping>
    <class name="com.ual.domain.customer" table="customer"><!--name对应类中，table对应表中，类与表之间的映射-->
        <!--建立类属性，哪一个是主键,该主键需要跟数据库中的主键相对应-->
        <id name="cust_id" column="cust_id"><!--name对应类，column对应表-->
             <generator class="native"/><!--主键生成策略-->
        </id>
        <!--建立类中的普通属性和数据库中的字段进行关联-->
        <property name="cust_name" column="cust_name"/>
        <property name="cust_source" column="cust_source"/>
        <property name="cust_industry" column="cust_industry"/>
        <property name="cust_level" column="cust_level"/>
        <property name="cust_phone" column="cust_phone"/>
        <property name="cust_mobile" column="cust_mobile"/>
    </class>

</hibernate-mapping>

　　6）创建类执行

　　　　

package com.ual.test;

import com.ual.domain.customer;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;
import org.junit.Test;

public class HibernateTest {
    @Test
   public void test1(){
        //1加载配置文件
        Configuration configure = new Configuration().configure();
        //如果配置的是hibernate.properties，需要手动加载映射文件，如下
        //  configure.addResource("com/ual/domain/customer.hbm.xml")
        //2创建sessionFactory 就相当于JDBC中的连接池
        SessionFactory sessionFactory = configure.buildSessionFactory();
        //3.获取session----JDBC连接对象
        Session session = sessionFactory.openSession();
        customer customer1 = new customer();
        customer1.setCust_name("ual");
        customer1.setCust_level("1");
        //4.保存对象
        session.save(customer1);
        //5.释放资源
        session.close();
        sessionFactory.close();
    }
}

注意：需要配置本地dtd

核心Api:

　　1)Configuration:  Hibernate的配置对象，Configuration类的作用是对Hibernate进行配置，以及对它启动，在Hibernate启动过程中，Configuration类的实例首先定位核心配置文件的位置，读取这些配置文件，然后创建一个

　　　　　　　　　　　sessionFactory对象。是启动HIbernate遇到的第一个对象。作用：1.加载核心配置文件 2.加载映射文件

　　2）sessionFactory：sessionFactory接口负责初始化Hibernate，并负责创建Session对象，注意其不是轻量级的，通常一个项目只需要一个sessionFactory。当需要操作多个数据库时，可以为每个数据库指定一个　　　　                                                         sessionFactory，内部维护了Hibernate的连接池以及Hibernate的二级缓存。

　　　　　　　　　　　　配置连接池：默认情况使用系统默认的连接池

　　　　　　　　　　　　　　　　　　把对应连接池jar包导入，在hibernate.cfg.xml中写入相应连接池的配置信息

　　　　由于一个项目中只需要一个sessionFactory，可以把它抽入工具类。 

　　

package com.ual.utils;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;

public class HibernateUtil {
   public static  final SessionFactory sessionFactory;//因为要在外部进行关闭，定义为public,线程安全，可以作为成员变量
    static {
        Configuration configure = new Configuration().configure();
         sessionFactory = configure.buildSessionFactory();
    }
    public static Session openSession(){
            Session session = sessionFactory.openSession();//线程不安全，不可以作为成员变量
            return  session;
    }
}

　　3）  session:代表Hibernate与数据库的连接对象，是与数据库交互的桥梁，通过它来完成数据库的增删改查。

　　　　　　　　session的api:      1.save(Object obj)保存

　　　　　　　　　　　　　　　　2.get(T.class,id)查询

    @Test
    public void  test2(){
        /*查询操作*/
        Session session = HibernateUtil.openSession();
        //查询一条
        customer customer = session.get(customer.class, 2L);//id为Long类型，后加L
        System.out.println(customer);
    }

　　　　　　　　　　　　　　　3.void update(Object obj)修改

　　　　　　　　　　　　　　　　　　　　　　3.1直接创建对象修改：如果没有指定其他字段，会把其他字段设为null

　　　　　　　　　　　　　　　　　　　　　　　　

    @Test
    public void test3(){
        /*直接创建对象修改：如果没有指定其他字段，会把其他字段设为null*/
        Session session = HibernateUtil.openSession();
        Transaction transaction = session.beginTransaction();//开启事务
        //更新操作
        customer customer = new customer();
        customer.setCust_id(1L);
        customer.setCust_name("wzh");
        session.update(customer);
        transaction.commit();//提交事务
        session.close();
        HibernateUtil.sessionFactory.close();
    }

　　　　　　　　　　　　　　　　　　　　　　3.2先查询，再修改，不会把其他字段设为null

　　

    @Test
    public  void test4(){
        /*先查询，再修改，不会把其他字段设为null*/
        Session session = HibernateUtil.openSession();
        Transaction transaction = session.beginTransaction();
        customer customer=session.get(com.ual.domain.customer.class,1L);
        customer.setCust_name("xxx");
        session.update(customer);
        transaction.commit();
        session.close();
        HibernateUtil.sessionFactory.close();
    }

 　　　　　　　　　　　　　　4.delete(Object obj)删除　　　

　　　　　　　　　　　　　　　　　　　　　4.1直接创建对象删除，不支持级联删除

    public void test5(){
        /*删除记录*/
        Session session = HibernateUtil.openSession();
        Transaction transaction = session.beginTransaction();//获取事务
        customer customer = new customer();//创建对象
        customer.setCust_id(1L);//通过id
        session.delete(customer);    //删除记录
        transaction.commit();//提交事务
        //关闭连接
        session.close();
        HibernateUtil.sessionFactory.close();
    }

　　　　　　　　　　　　　　　　　　　　　4.2 先查询再删除，支持级联删除

　　　　　　　　　　　　　　5.保存或更新：void saveOrUpdate(Object obj):如果没有设置id,是一个保存，是一个保存操作，设置了id是修改操作，如果设置的id没有，则会报错。

　　　　　　　　　　　　　　6.查询所有

　　　　　　　　　　　　　　　　　　　　　　　　6.1使用HQL方式：HQL(Hibernate Query Language面向对象的查询语言）

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　Query query = session.createQuery("from customer");//从哪个表里查，from后跟类名　　

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　List<T> list = query.list();

    @Test
    public void test7(){
        /*使用HQL查询所有*/
        Session session = HibernateUtil.openSession();
        Transaction transaction = session.beginTransaction();
         //查询所有HQL
        Query query = session.createQuery("from com.ual.domain.customer");
        List<customer> list = query.list();
        for(customer customer:list){
            System.out.println(customer);
        }

        transaction.commit();
        session.close();
        HibernateUtil.sessionFactory.close();
    }

　　　　　　　　　　　　　　　　　　　　　6.2:使用原声sql （已经过时）