手把手教你搭建一个简单Hibernate项目

1、项目环境: Jdk7 + Idea2017 + MySQL5 + Hibernate4

2、基础步骤

2.1新建项目

利用Idea新建项目,在右边的Addtional Libraries And FrameWorks中选择Hibernate，该选项下的Hibernate的库一般而言是最新版本的，若是你想要用自己的库，可在下方的Libraries中选择Use Libraries->create,然后选择你自己的Jar包，如果想要让Idea下载以前版本的库，可点击Configure按钮选择对应版本。如图2-1所示:

图2-1

此后点击next，输入项目名，项目初始架构搭建完成，需要注意的是log4j以及mysql驱动包是笔者自行引入的包，项目需要，读者可自行将Jar包复制进lib目录下，大致结构如图2-2所示:

图2-2

2.2文件配置

2.2.1日志配置

利用log4j可方便查看相应的信息，所以在该项目中笔者引入了log4j的jar，如前面描述，将jar包复制进lib目录下即可。然后在src目录下新建log4j.properties，以下是其具体代码:

log4j.rootLogger = debug,stdout,D,E
### 输出信息到控制抬 ###
log4j.appender.stdout = org.apache.log4j.ConsoleAppender
log4j.appender.stdout.Target = System.out
log4j.appender.stdout.layout = org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern = [%-5p] %d{yyyy-MM-dd HH:mm:ss,SSS} method:%l%n%m%n
### 输出DEBUG 级别以上的日志到=E://logs/error.log ###
log4j.appender.D = org.apache.log4j.DailyRollingFileAppender
log4j.appender.D.File = E://logs/2017_11_13_hiberTest_log.log
log4j.appender.D.Append = true
log4j.appender.D.Threshold = DEBUG 
log4j.appender.D.layout = org.apache.log4j.PatternLayout
log4j.appender.D.layout.ConversionPattern = %-d{yyyy-MM-dd HH:mm:ss}  [ %t:%r ] - [ %p ]  %m%n
### 输出ERROR 级别以上的日志到=E://logs/error.log ###
log4j.appender.E = org.apache.log4j.DailyRollingFileAppender
log4j.appender.E.File =E://logs/2017_11_13_hiberTest_error.log 
log4j.appender.E.Append = true
log4j.appender.E.Threshold = ERROR 
log4j.appender.E.layout = org.apache.log4j.PatternLayout
log4j.appender.E.layout.ConversionPattern = %-d{yyyy-MM-dd HH:mm:ss}  [ %t:%r ] - [ %p ]  %m%n

2.2.2hibernate配置文件的配置

在项目初始化之后，可在src下看到一个hibernate.cfg.xml文件，该文件是hibernate的配置文件，笔者相应的配置如下:

xml version='1.0' encoding='utf-8'?>
hibernate-configuration PUBLIC  "-//Hibernate/Hibernate Configuration DTD//EN"
        "http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd"> <hibernate-configuration>
    <session-factory>
        <property name="hibernate.connection.driver_class">com.mysql.jdbc.Driverproperty>

        <property name="hibernate.connection.password">123property>

        <property name="hibernate.connection.url">jdbc:mysql://localhost:3306/practiceproperty>

        <property name="hibernate.connection.username">rootproperty>

        <property name="hibernate.dialect">org.hibernate.dialect.MySQLDialectproperty>

        

        <property name="connectio.useUnicode">trueproperty>

        <property name="connection.characterEncoding">utf-8property>

        

        <property name="hibernate.show_sql">trueproperty>

        <property name="hibernate.format_sql">trueproperty>

        <property name="hibernate.current_session_context_class">threadproperty>

        

        <property name="hibernate.hbm2ddl.auto">updateproperty>

        <property name="hibernate.generate_statistics">trueproperty>

        

        
        <mapping resource="panda/bean/User.hbm.xml">mapping>

    session-factory>
hibernate-configuration>

2.2.3实体类以及映射文件

在完成hibernate.cfg.xml的配置之后，需要完成对象关系映射，完成方式一般有两种，第一种是手动编写实体类以及映射文件，运行项目，在数据库中生成对应的数据库表以及字段；第二种方式是通过数据库表和字段逆向生成实体类和映射文件。首先介绍第一种方式，新建一个bean包，在bean包下新建一个User实体类，类的具体信息如下:

package com.panda.bean;

import java.io.Serializable;

public class User implements Serializable{
    private Integer id;
    private String name;
    private String sex;
    private Integer age;
    ## setter和getter方法##
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;

        User user = (User) o;

        if (age != user.age) return false;
        if (name != null ? !name.equals(user.name) : user.name != null) return false;
        return sex != null ? sex.equals(user.sex) : user.sex == null;
    }

    @Override
    public int hashCode() {
        int result = name != null ? name.hashCode() : 0;
        result = 31 * result + (sex != null ? sex.hashCode() : 0);
        result = 31 * result + age;
        return result;
    }
}

需要注意的是，新建的实体类需要实现Serializable接口，同时为了提高查询效率，还需要重写equals和hashCode方法。此后在对应的包下再新建一个User.hbm.xml文件，这个文件是User的映射文件，格式必须固定为:类名.hbm.xml，笔者配置信息如下所示:

xml version="1.0"?>
hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
        "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd"> 
<hibernate-mapping>
    <class name="com.panda.bean.User" table="user" >
        
        <id name="id" type="java.lang.Integer">
            <column name="id" />
            <generator class="increment"/>
        id>
        
        
        <property name="name" type="java.lang.String">
            <column name="name" length="50" not-null="true"/>
        property>

        <property name="sex" type="java.lang.String">
            <column name="sex" length="50" not-null="true" />
        property>

        <property name="age" type="java.lang.Integer">
            <column name="age" not-null="true" />
        property>

    class>
hibernate-mapping>

相应的配置注释都在上面，读者可自行深入。文件配置完成之后，可运行项目初始化时生成的Main.class，生成数据表。图2-3对应相应的SQL语句，图2-4对应于在命令行窗口查看数据库生成的表。

图2-3

图2-4

第二种方式是通过数据库表逆向生成实体类以及映射表，拿上述中的User表为例，在Idea中的左下角选择Persistence

图2-5

单击之后出现你的项目名，然后右键选择最后一个选项，如图2-6所示:

图2-6

然后出现图2-7的配置界面：

图2-7

步骤1是选择你的DataSource，如果笔者没有配置DataSource，可查阅相关资料配置，步骤2是选择将实体类生成在哪个包下，步骤3是选择对应的表，点击OK。

图2-8

在图2-8中，生成了UserEntity实体类，并且在hibernate.cfg.xml中添加了mapping

3、项目运行

为了保证严谨性，在项目下新建一个dao以及daoImpl包，在dao下新建一个UserDao接口，并写一个insertUser方法，在daoImpl包下新建一个UserDaoImpl类，继承UserDao，实现方法，相关代码如下:

package com.panda.daoImpl;

import com.panda.bean.User;
import com.panda.dao.UserDao;
import com.panda.tool.HibernateUtil;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.junit.Test;
public class UserDaoImpl implements UserDao {
    @Test
    public void insertUser() {
        Session session = HibernateUtil.getSession();
        Transaction transaction = session.beginTransaction();
        try {
            User user = new User();
            user.setName("Mack");
            user.setSex("男");
            user.setAge(25);
            session.save(user);
            transaction.commit();
        }catch (Exception e) {
            e.printStackTrace();
            transaction.rollback();
        }

    }

}

上述代码中的HibernateUtil是一个工具类，虽然项目初始化的Main类也具有相同作用，但笔者更喜欢自己的方式，代码如下:

package com.panda.tool;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;
import org.hibernate.service.ServiceRegistryBuilder;
public class HibernateUtil {
    private static SessionFactory sessionFactory;
    /**
     * 利用getSession方法时切记在Hibernate的配置文件中
     * @return Session
     */
    public static Session getSession(){
        return getSessionFactory().getCurrentSession();
    }
    /**
     * SessionFactory是重量级的
     * 最好做成单例模式
     * @return SessionFactory
     */
    public static SessionFactory getSessionFactory(){
        //保证SessionFactory为单例
        if (sessionFactory == null ||sessionFactory.isClosed()) {
            Configuration configure = new Configuration();
            configure.configure();
            sessionFactory = configure.buildSessionFactory(new ServiceRegistryBuilder().applySettings(configure.getProperties()).buildServiceRegistry());
        }
        return sessionFactory;
    }
}

完成之后，运行项目，出现如图2-9和2-10的结果，项目运行成功。

图2-9

图2-10

如有任何建议和疑问，欢迎共同探讨！