Hibernate 快速上手操做入门

时间 2019-11-20

原文原文链接

本文主要是从技术操做角度去介绍hibernate，而且简单描述如何快速的上手操做hibernate，用于做为与数据库的链接的持久层。html

简单讲述一下hibernate到底是什么，它有什么做用，在理解它的做用以前，咱们先想想，在一个项目当中，咱们须要将项目当中的数据存入数据库，或者从数据库中读取项目当中须要的数据进行操做，咱们往常通常使用什么方法呢？首先想到的就是经过JDBC去对数据库进行手动的操做，编写一个链接数据库的模块，经过加载driver而且手动编写增删改查方法联通程序与数据库当中的数据，这种方式很繁琐，而且在对不一样的表格操做的时候，还须要手动修改SQL语句，与咱们面向对象编程的设计思想不符，因而提出了ORM。java

所谓的ORM（Object ralational mapping）是一种为了解决面向对象与关系型数据库存在的互不匹配的现象的技术，简单说：ORM是经过使用描述对象和数据库之间映射的元数据，将Java程序中的对象自动持久化到关系数据中。即将数据库表当中的一行数据，转化到java当中的某个pojo类的实例，本质上就是将数据从一种形式转换到另一种形式。mysql

从图中的每层之间的关系也能够很直观的看出，本文所介绍的Hibernate主要就是用于作持久层，而且提供ORM的重要组件。sql

经过Hibernate，咱们将对象转换存入数据库，或者反向将数据从数据库提取生成对象就无需再手动编写jdbc的增删改查而且向对象填入字段的代码模块，在创建好orm映射以后，咱们只须要操做咱们所定义的pojo类，而且使用Hibernate提供的方法便可将pojo对象存入对应的数据库当中，无需关注实现细节，便于简化编程。数据库

在理解什么是orm，而且知道Hibernate在咱们编程当中所扮演的角色以及所提供的做用以后，咱们开始来了解如何使用Hibernate来实现咱们的程序持久层，本文采用的是hibernate 5.1版本对mysql数据进行链接，进行demo演示，首先建立一个java project，而且将hibernate根目录下的 /lib/required 文件夹下的全部jar包引入工程，而且再将 /lib/java8 目录下的jar包引入工程当中，除此以外，由于要与mysql数据库进行链接，还须要提供mysql数据库链接的驱动jar包mysql-connector-java-5.1.26-bin.jar，将这些包都引入而且build the path以后，咱们的工程环境就搭建完成。编程

在经过hibernate去进行ORM的时候，通常的设计流程为Domain Object ->mapping ->DB：session

1.须要链接的pojo类对象的设计，这个部分的设计根据所须要实现的程序的功能去进行，好比须要作一个用户信息的统计程序，那么就确定须要一个名为User的Pojo类，而且该Pojo类里头须要定义用户的属性，如：姓名，性别，年龄等。app

2.须要配置的pojo.hbm.xml配置文件，做为类向关系型的映射，即提供pojo类到数据库某张表的对应映射信息。dom

3.在包外配置hibernate.cfg.xml配置文件，其中Sesson-factory做为链接数据库信息的配置。ide

如同上述的设计思路流程，首先咱们先设计咱们的pojo类，就以用户信息为例，代码以下：

package wellhold.hibernate.domain;

import java.util.Date;

public class User {
    
    private int id;
    private String name;
    private Date birthday;

    
    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Date getBirthday() {
        return birthday;
    }

    public void setBirthday(Date birthday) {
        this.birthday = birthday;
    }

    @Override
    public String toString() {
        return "User [id=" + id + ", name=" + name + ", birthday=" + birthday
                + "]";
    }

}

在这里须要额外提示一下，根据笔者查阅的资料当中，大部分人都表示在hibernate由于反射机制的需求，所定义的pojo类须要有一个空白无参数的构造函数才能对对象进行反射，可是笔者在制做测试demo的时候，将这个空白的构造函数进行去除以后，程序仍是没有任何问题，因此这个空白构造函数的必须性还有待商议。

在设计好pojo类以后，咱们须要创建对象到数据库的映射关系，即hbm.xml配置文件的创建，以下：

<?xml version="1.0"?>
<!-- ~ Hibernate, Relational Persistence for Idiomatic Java ~ ~ License: 
    GNU Lesser General Public License (LGPL), version 2.1 or later. ~ See the 
    lgpl.txt file in the root directory or <http://www.gnu.org/licenses/lgpl-2.1.html>. -->
<!DOCTYPE hibernate-mapping PUBLIC
    "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
    "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">

<!-- -->

<hibernate-mapping package="wellhold.hibernate.domain">

    <class name="User">
        <!-- 当类名和代表同样的时候，table="" 这个关键字不须要写 -->

        <id name="id">
            <!-- name指的是属性名，即java类里头的属性 -->
            <!-- 有一次属性名unsaved-value="-1" 指的是若是ID的值为-1的时候则表示这个对象未保存 -->

            <generator class="native" />
            <!-- 主键产生的方式，其中native是主键生成器 -->

        </id>

        <property name="name" />
        <property name="birthday" />

    </class>

</hibernate-mapping>

hibernate会根据咱们提供的这个hbm.xml去创建User这个Pojo类与数据库当中User这张表的映射关系。

以后咱们须要对全局的hibernate进行配置，经过.cfg.xml对hibernate进行配置，包括提供所须要链接的数据库信息，以及一些功能参数的设定，session-factory的设置，注意在hibernate当中，对数据库的全部操做都是经过SessionFactory进行的，因此SessionFactory是一个很重要的概念，能够理解成是一个对jdbc进行更上一层封装的对象。

<?xml version='1.0' encoding='utf-8'?>
<!-- ~ Hibernate, Relational Persistence for Idiomatic Java ~ ~ License: 
    GNU Lesser General Public License (LGPL), version 2.1 or later. ~ See the 
    lgpl.txt file in the root directory or <http://www.gnu.org/licenses/lgpl-2.1.html>. -->
<!DOCTYPE hibernate-configuration PUBLIC
        "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
        "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">

<hibernate-configuration>
    <session-factory>
        <property name="connection.driver_class">com.mysql.jdbc.Driver</property>
        <property name="connection.url">jdbc:mysql:///testconnect</property>
        <property name="connection.username">root</property>
        <property name="connection.password"></property>
        <!-- SQL dialect -->
        <property name="dialect">org.hibernate.dialect.MySQLDialect</property>
        <!-- 使用方言，用于在Sql语句的设计上是存在差别的 -->
        <property name="hbm2ddl.auto">update</property>
        <!-- 在不存在表格的状况，自动在数据库生成表格 -->
        <property name="show_sql">false</property>
        <!-- 显示Hibernate底层调用的SQL -->
        <mapping resource="wellhold/hibernate/domain/User.hbm.xml" />

        <!-- 在数据库当中自动生成表格 -->

    </session-factory>

</hibernate-configuration>

至此，hibernate的映射环境就已经构建完成，接下来咱们经过编写测试用例去进行测试咱们所搭建的hibernate是否能够正常工做。

通常在使用Hibernate，咱们能够先对原生的Hibernate提供的一些方法进行更高一层的封装，好比Hibernate的SessionFactory所提供的sava方法，update方法，delete方法，get方法，制做一个Hibernate的工具类，代码以下：

package wellhold.hibernate;

import java.io.Serializable;

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

public final class HibernateUtil {

    private static SessionFactory sessionFactory;

    static {
        Configuration cfg = new Configuration();
        cfg.configure("hibernate.cfg.xml");
        sessionFactory = cfg.buildSessionFactory();
    }

    public static SessionFactory getSessionFactory() {
        return sessionFactory;
    }

    public static Session getSession() {
        return sessionFactory.openSession();
    }

    public static void add(Object entity) {
        Session s = null;
        Transaction tx = null;
        try {
            s = HibernateUtil.getSession();
            tx = s.beginTransaction();
            s.save(entity);
            tx.commit();
        } finally {
            if (s != null)
                s.close();
        }
    }

    public static void Update(Object entity) {
        Session s = null;
        Transaction tx = null;
        try {
            s = HibernateUtil.getSession();
            tx = s.beginTransaction();
            s.update(entity);
            tx.commit();
        } finally {
            if (s != null)
                s.close();
        }
    }

    public static void delete(Object entity) {
        Session s = null;
        Transaction tx = null;
        try {
            s = HibernateUtil.getSession();
            tx = s.beginTransaction();
            s.delete(entity);
            tx.commit();
        } finally {
            if (s != null)
                s.close();
        }
    }

    public static Object get(Serializable id) {
        Session s = null;

        try {
            s = HibernateUtil.getSession();

            Object obj = s.get(User.class, id);
            return obj;

        } finally {
            if (s != null)
                s.close();
        }
    }

}

在HibernateUtil当中，经过一个static块去加载了hibernate.cfg.xml配置文件，而且获取到sessionfactory实例，以后是对增删改查的封装。这里简单的解释一下为何使用的都是static的方法生命，由于在使用static的方法的时候，能够无需对HibernateUtil对象进行实例，就可使用其静态的方法。

最后，咱们只须要制做一个程序入口，即main函数，测试HibernateUtil当中的方法便可：

package wellhold.hibernate;

import java.util.Date;

import org.hibernate.HibernateException;
import org.hibernate.Session;
import org.hibernate.Transaction;

import wellhold.hibernate.domain.User;

public class maintest {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        
        User user = new User();
        user.setBirthday(new Date());
        user.setName("well");
        
        HibernateUtil.add(user);
        System.out.println("end");
        System.out.println(HibernateUtil.get(1).toString());
    }
    
//    
    
}

查看效果：

至此，Hibernate快速入门demo完成。