首页 > > 网络编程 > Mysql >

Hibernate初探

2018-06-17 23:24:18来源：未知阅读 ()

　　Hibernate对数据库结构提供了较为完整的封装，Hibernate的O/R Mapping实现了POJO 和数据库表之间的映射，以及SQL 的自动生成和执行。程序员往往只需定义好了POJO 到数据库表的映射关系，即可通过Hibernate 提供的方法完成持久层操作。程序员甚至不需要对SQL 的熟练掌握， Hibernate/OJB 会根据制定的存储逻辑，自动生成对应的SQL 并调用JDBC 接口加以执行。

　　今天我们就一起对Hibernate的应用初步进行一下学习。

　　首先公欲善其事必先利其器，为了更方便我们书写Hibernate的配置文件，我们这里需要为我们的eclipse安装一个Hibernate Tools的插件，这样就可以很方便的让我们完成Hibernate的配置文件编写。

　　这里我采用的是在线安装：

1.启动eclipse
2.选择Help > Install New Software...>
3.添加如下地址：http://download.jboss.org/jbosstools/updates/stable/helios/
4.选择性安装：hibernate tools在All Jboss tools节点下面

　　到这里我们的Hibernate Tools就算安装好了，接下来我们就可以通过eclipse很方便的生成相应的配置文件

　　接下来我们创建一个Java工程，然后将我们的下载好的hibernate JAR包文件导入，这里个人建议大家将这些JAR包添加为一个新的User Liberary，方便以后我们在其他项目中调用，这里我们现在只是为了初步探究Hibernate的使用，这里我们只需要将必要的JAR包文件导入即可，

解压我们下载的Hibernate压缩包，里面有一个lib文件夹，顾名思义，这就是我们会用的JAR包文件，文件里面有很多子目录，我们现在只需要将required文件夹下的JAR包文件导入即可。

　　导入过hibernate JAR包后，一定要记得导入我们的数据库驱动JAR包，还有就是为了方便我们测试，这里我使用的是Junit单元测试工具，需要一并导入相应的JAR包文件。

　　导入后所有的JAR包文件后，我们就可以开始我们的代码编写了，首先我们需要创建一个Hibernate配置文件：hibernate.cfg.xml

　　创建好我们的Hibernate的配置文件后，打开，添加数据库连接驱动地址+数据库连接用户名+数据库连接密码+数据库连接地址+数据库方言等等。

<?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>
        <!-- 数据库驱动地址 -->
        <property name="connection.driver_class">org.gjt.mm.mysql.Driver</property>
        <!-- 数据连接用户名 -->
        <property name="connection.username">root</property>
        <!-- 数据库连接密码 -->
        <property name="connection.password">123456</property>
        <!--设置数据库的连接url:jdbc:mysql://localhost/hibernate,其中localhost表示mysql服务器名称，此处为本机，hibernate是数据库名-->
        <property name="connection.url">jdbc:mysql://localhost:3306/hibernate</property>
        <!-- 数据库方言 -->
        <property name="dialect">org.hibernate.dialect.MySQLDialect</property>
    
        <!-- 控制台打印sql语句 -->
        <property name="show_sql">true</property>
        <!-- 控制台格式化输出sql语句 -->
        <property name="format_sql">true</property>
        <!-- 数据库生产策略 -->
        <property name="hbm2ddl.auto">update</property>
        
        <!-- 如果使用的是本地事务（jdbc事务） -->
        <!-- <property name="current_session_context_class">thread</property> -->
        
        <!-- 如果使用的是本地事务（JTA事务） -->
        <!-- <property name="current_session_context_class">jta</property> -->
        
    </session-factory>
</hibernate-configuration>

　　有了Hibernate的配置文件接下来我们就要创建我们的实例对象和数据库映射文件xx.hbm.xml

　　这里我通过创建学生对象和大家一起熟悉这个过程：

/**
 * 创建一个实体类
 * @author gaoshang
 */
public class Student {
    
    //不带参数的构造方法
    public Student(){}
    
    private int id;//学生I
    private String name;//学生姓名
    private int birthday;//学生出生年月
    private String home;//学生住宅
    private Date joinTime;//学生入学时间
    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 int getBirthday() {
        return birthday;
    }
    public void setBirthday(int birthday) {
        this.birthday = birthday;
    }
    public String getHome() {
        return home;
    }
    public void setHome(String home) {
        this.home = home;
    }
    public Date getJoinTime() {
        return joinTime;
    }
    public void setJoinTime(Date joinTime) {
        this.joinTime = joinTime;
    }
    //学生对象的ToString方法
    public String toString() {
        return "Student [id=" + id + ", name=" + name + ", birthday=" + birthday + ", home=" + home + ", joinTime="
                + joinTime + "]";
    }
    //带参数的构造方法
    public Student(int id, String name, int birthday, String home, Date joinTime) {
        super();
        this.id = id;
        this.name = name;
        this.birthday = birthday;
        this.home = home;
        this.joinTime = joinTime;
    }
    
}

　　接下来创建我们的数据库映射文件xx.hbm.xml:

　　点击next，选择我们的实例对象，点击finash完成。最后eclispe就可以帮我们的生产一个Student学生类对于的数据库映射文件：

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<!-- Generated 2017-2-15 14:17:57 by Hibernate Tools 3.5.0.Final -->
<hibernate-mapping>
    <class name="hibernate.Student" table="STUDENT">
        <id name="id" type="int">
            <column name="ID" />
            <generator class="assigned" />
            <!-- generator:属性的生成策略 -->
            <!-- assigned:通过赋值的形式进行设置 -->
            <!-- native:自动生成，从0或1开始编号 -->
            <!-- uuid:使用uuid进行生成 -->
        </id>
        <property name="name" type="java.util.String" length="10">
            <column name="NAME" />
        </property>
        <property name="birthday" type="int">
            <column name="BIRTHDAY" />
        </property>
        <property name="home" type="java.util.String" length="10">
            <column name="HOME" />
        </property>
        <property name="joinTime" type="java.util.Date">
            <column name="JOINTIME" />
        </property>
    </class>
</hibernate-mapping>

　　到这里我们的Hibernate配置就算完成了。下面我们来通过使用Junit单元测试工具进行持久化操作。

package hibernate;

import java.util.Date;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.boot.MetadataSources;
import org.hibernate.boot.registry.StandardServiceRegistry;
import org.hibernate.boot.registry.StandardServiceRegistryBuilder;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;

/**
 * Junit做单元测试时，测试方法不能使用private修饰，否则会报method initializationerror not found
 * 解决方法：http://www.cnblogs.com/sxdcgaq8080/p/5649819.html
 * @author gaoshang
 */
public class StudentTest {
    
    private SessionFactory sessionFactory;
    private Session session;
    private Transaction transaction;

    @Before
    public void init(){
        System.out.println("Junit测试配置");
        /**
         * hibernate4.x创建SessionFactory
         */
        //创建配置对象
        //Configuration configraction = new Configuration().configure();
        //创建会话工厂对象回调
        //ServiceRegistry serviceRegistry = new ServiceRegistryBuilder().applySettings(configraction.getProperties()).buildServiceRegistry();
        //创建会话工厂
        //sessionFactory = configraction.buildSessionFactory(serviceRegistry);
        
        /**
         * hibernate5.x创建SessionFactory
         */
        //创建会话工厂对象回调
        final StandardServiceRegistry serviceRegistry = new StandardServiceRegistryBuilder().configure().build();// 使用hibernate.cfg.xml进行配置  
        //创建会话工程
        sessionFactory = new MetadataSources(serviceRegistry).buildMetadata().buildSessionFactory();
        
        //创建session对象
        session = sessionFactory.openSession();
        //创建事物对象
        transaction = session.beginTransaction();
    }
    
    @After
    public void close(){
        System.out.println("Junit测试完成");
        if(transaction!=null)
            transaction.commit();//提交事物，hibernate是事物驱动的，只有提交事物才能完成持久化操作
        if(session!=null)
            session.close();//关闭session对象
        if(sessionFactory!=null)
            sessionFactory.close();//关闭sessionFactory对象
    }
    
    @Test
    public void run(){
        System.out.println("Junit测试");
        Student s = new Student(1, "hpu", 24, "河南", new Date());//创建学生对象
        session.save(s);//提交持久化操作
    }
    
}

　　最后在奉上一个对学生对象进行增删改查的完整操作测试类：

package hibernate;

import java.util.Date;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.boot.MetadataSources;
import org.hibernate.boot.registry.StandardServiceRegistry;
import org.hibernate.boot.registry.StandardServiceRegistryBuilder;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;

public class StudentManagerTest {

    private SessionFactory sessionFactory;
    private Session session;
    private Transaction transaction;
    
    @After
    public void close(){
        if(transaction!=null)
            transaction.commit();
        if(session!=null)
            session.close();
        if(sessionFactory!=null)
            sessionFactory.close();
    }
    
    @Before
    public void init(){
        final StandardServiceRegistry serviceRegistry = new StandardServiceRegistryBuilder().configure().build();
        sessionFactory = new MetadataSources(serviceRegistry).buildMetadata().buildSessionFactory();
        session = sessionFactory.openSession();
        transaction = session.beginTransaction();
    }
    
    @Test
    public void saveStudent(){
        Student s = new Student(1, "123", 45, "中国", new Date());
        session.save(s);
    }
    
    @Test
    public void updateStudent(){
        Student s = new Student(1, "123", 20, "china", new Date());
        session.update(s);
    }
    
    @Test
    public void delStudent(){
        Student s = new Student();
        s.setId(3);
        session.delete(s);
    }
    
    /**
     * get方法当对象不存在时返回NULL
     */
    @Test
    public void getStudent(){
        System.out.println(session.get(Student.class, 6));
    }
    
    /**
     * load方法当对象不存在是报org.hibernate.ObjectNotFoundException
     */
    @Test
    public void loadStudent(){
        System.out.println(session.load(Student.class, 5));
    }
}