Hibernate入门学习

本篇博客知识点
1.了解Hibernate
2.学习Hibernate的配置文件
3.学习写一个Hibernate连接数据库的工具类
4.Hibernate对数据库操作

了解Hibernate

Hibernate 是一个将持久化类与数据库表相映射的工具，每个持久化类实例均对应于数据库表中的一条数据行。可以使用面向对象的方法操作此持久化类实例，完成对数据库表的插入、删除、修改等操作。

就是我们以前用的JDBC，区别在于Hibernate是面向对象的；它操作的是我们的值对象，通过映射文件达到操作数据库的目的。

学习Hibernate的配置文件

1.第一个配置文件是面试实体（值对象），将它与数据库里面的表连接起来。
以描述学生信息为例
Stundet.java

public class Student {
    private String studId;
    private String studName;
    private Integer age;
    private String depId;
    public Student(){
    }
    public String getStudId() {
        return studId;
    }
    public void setStudId(String studId) {
        this.studId = studId;
    }
    public String getStudName() {
        return studName;
    }
    public void setStudName(String studName) {
        this.studName = studName;
    }
    public Integer getAge() {
        return age;
    }
    public void setAge(Integer age) {
        this.age = age;
    }
    public String getDepId() {
        return depId;
    }
    public void setDepId(String depId) {
        this.depId = depId;
    }

}

对应的数据库表是students

create table students(
  id varchar(8) primary key,
  name varchar(40),
  age int,
  deptId varchar(8)
);

将两者对应起来的xml配置文件如下，命名也有规范
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">
<!-- 该配置文件站的立场是Object, 去配置自己和 数据库表之间的映射关系   -->
<hibernate-mapping package="cn.hncu.demo.domain">

    <class name="Student" table="students" catalog="ake">
        <!-- id标记是指Student类中的属性变量,该属性是表主键字段对应 -->
        <id name="studId" type="java.lang.String">
           <!-- column标记是指数据库表中的哪一列(字段)  -->
           <column name="id" length="8"></column>
        </id>

        <!-- 只有主键字段对应的属性变量才能用id，其它字段对应的属性变量都用property -->
        <property name="studName" type="java.lang.String">
           <column name="name" length="40"></column>
        </property>

        <property name="age" type="java.lang.Integer">
           <column name="age"></column>
        </property>

        <property name="depId" type="java.lang.String">
           <column name="deptId" length="8"></column>
        </property>

    </class>


</hibernate-mapping>

2.第二个配置文件是用来连接数据库的，同时把第一个配置文件给添加进来，命名也有规范
hibernate.cfg.xml

<?xml version='1.0' encoding='utf-8'?>
<!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>
        <!-- Database connection settings -->
        <property name="connection.driver_class">com.mysql.jdbc.Driver</property>
        <property name="connection.url">jdbc:mysql://127.0.0.1:3306/ake</property>
        <property name="connection.username">root</property>
        <property name="connection.password">1234</property>

        <!-- SQL dialect -->
        <property name="dialect">
           org.hibernate.dialect.MySQLDialect
        </property>

        <property name="hibernate.cache.use_second_level_cache">false</property>

        <!-- 一定要把我们写的对象映射文件配置进来(可以配置多个)，否则没法使用Hibernate的ORM功能 -->
        <mapping resource="cn/hncu/demo/domain/Student.hbm.xml"/>
    </session-factory>

</hibernate-configuration>

学习写一个Hibernate连接数据库的工具类

类似一个数据库连接词

import org.hibernate.HibernateException;
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;

public class HibernateSessionFactory {

    private static SessionFactory sessionFactory = null;

    private static ThreadLocal<Session> t = new ThreadLocal<Session>();

    static {
        try {
            Configuration config = new Configuration().configure();
            StandardServiceRegistry serviceRegistry = new StandardServiceRegistryBuilder().applySettings( config.getProperties() ).build();
            sessionFactory = config.buildSessionFactory(serviceRegistry);
        }catch (Throwable ex) {
            throw new ExceptionInInitializerError(ex);
        }
    }

    public static SessionFactory getSessionFactory() {
        return sessionFactory;
    }


    public static Session getSession() throws HibernateException{
        Session session = t.get();
        if(session==null || !session.isOpen() ){
            session = (sessionFactory!=null)? sessionFactory.openSession(): null;
            t.set(session);
        }
        return session;
    }


    //关闭与数据库的会话
    public static void closeSession(){
        t.set(null);
    }

}

Hibernate对数据库操作

package cn.hncu.demo.dao;

import java.util.List;

import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.Transaction;

import cn.hncu.demo.domain.Student;
import cn.hncu.utils.HibernateSessionFactory;

public class DemoDaoJdbc {
    public List<Student> queryAllStudents(){

        Session session = HibernateSessionFactory.getSession();
        Query query= session.createQuery("from Student"); //HQL = SQL中的关键字 + Java(类名，属性名)
        List<Student> list= query.list();
        return list;

    }

    public void delStudent(Student stud){
        //Hibernate中建议，每次操作时重新获取session
        Session session = HibernateSessionFactory.getSession();
        Transaction tran = session.beginTransaction();
        //stud.setStudId("S1234");
        session.delete(stud);//如果对应id的stud在数据库中存在则删除，否则删除不了但不会抛出异常!
        tran.commit();

        session.clear();//清缓存!!!!
    }

    public void addStudent(Student stud) {
        //Hibernate中建议，每次操作时重新获取session
        Session session = HibernateSessionFactory.getSession();
        Transaction tran = session.beginTransaction();

        //如果存在，则只修改姓名(ID是一定不能变的)
        Student stud2 = (Student) session.get(Student.class, stud.getStudId());//获取单个对象
        System.out.println(stud2.getStudId()+","+stud2.getStudName());
        stud.setAge(stud2.getAge());
        stud.setDepId(stud2.getDepId());
        session.evict(stud2); //在缓存中要手动清除stud2对象，否则会在缓存中出现两份ID相同的不同instance，因此要删除没用的那个，否则出异常!
        //缓存中的对象(instance，实例)是以id来标识的，必须唯一，不允许在缓存中出现两个id相同的instance

        session.saveOrUpdate(stud);//如果对应id的stud在数据库中存在则是修改，否则是添加!
        tran.commit();

        session.clear();//清缓存!!!!
    }

    public List<Student> queryStudents(Student stud) {
        boolean f1=false,f2=false,f3=false;

        Session session = HibernateSessionFactory.getSession();

        String hql = "from Student s where 1=1";

        if(stud.getStudId()!=null && stud.getStudId().trim().length()>0){
            hql = hql + " and s.studId=:studId";
            f1=true;
        }

        if(stud.getStudName()!=null && stud.getStudName().trim().length()>0){
            hql = hql + " and s.studName like :studName";
            f2=true;
        }

        if(stud.getDepId()!=null && stud.getDepId().trim().length()>0){
            hql = hql + " and s.depId=:deptId";
            f3=true;
        }

        Query query = session.createQuery(hql);
        if (f1) {
            query.setParameter("studId",stud.getStudId().trim());
        }
        if (f2) {
            query.setParameter("studName", "%"+stud.getStudName().trim()+"%");
        }
        if (f3) {
            query.setParameter("deptId",stud.getDepId().trim());
        }

        return query.list();
    }

}