Maven搭建Hibernate4开发环境并整合Spring3

前面整合maven和spring3，struts2，这篇整合hibernate。
1.下载Hibernate4需要的jar包
在pom.xml文件中编写Hibernate4所需要的jar包，Maven会自动下载这些包。

<!-- hibernate4 -->
         <dependency>
             <groupId>org.hibernate</groupId>
             <artifactId>hibernate-core</artifactId>
             <version>4.1.7.Final</version>
         </dependency>

注意：一定要排除掉Struts2中的javassist，否则就冲突了。
也就是将pom.xml里配置strust2内取消这段代码注释：

<exclusions>
        <exclusion>
          <groupId>javassist</groupId>
           <artifactId>javassist</artifactId>
        </exclusion>
</exclusions> 

2.添加数据库驱动包
这里我用的数据库是mysql

<!-- mysql驱动包 -->
2         <dependency>
3             <groupId>mysql</groupId>
4             <artifactId>mysql-connector-java</artifactId>
5             <version>5.1.34</version>
6         </dependency>

3.添加数据库连接池jar包
在平时开发中，我们一般都会使用数据库连接池，应用系统初始化时，由数据库连接池向数据库申请一定数量的数据库连接，然后放到一个连接池中，当需要操作数据库时，就从数据库连接池中取出一个数据库连接，通过从连接池中获取到的数据库连接对象连接上数据库，然后进行CRUD操作，关于数据库连接池的选择，常用的有DBCP，C3P0和Druid，这里我们使用Druid作为我们的数据库连接池。

在pom.xml文件中编写Druid的jar包，Maven会自动下载，如下：

<!--Druid连接池包 -->
         <dependency>
             <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
             <version>1.0.12</version>
         </dependency>

4.添加aspectjweaver包
使用Spring的aop时需要使用到aspectjweaver包，所以需要添加aspectjweaver包，在pom.xml文件中添加aspectjweaver的jar包，Maven会自动下载，如下：

 <!--aspectjweaver包 -->
         <dependency>
             <groupId>org.aspectj</groupId>
             <artifactId>aspectjweaver</artifactId>
             <version>1.8.5</version>
         </dependency>

5、编写连接数据库的配置信息
之前我们在src/main/resources目录下创建了一个config.properties文件，里面的内容是空的，现在我们就在这个config.properties文件中编写连接数据库需要使用到的相关信息，如下所示：

#hibernate.dialect=org.hibernate.dialect.OracleDialect
#driverClassName=oracle.jdbc.driver.OracleDriver
#validationQuery=SELECT 1 FROM DUAL
#jdbc_url=jdbc:oracle:thin:@127.0.0.1:1521:orcl
#jdbc_username=sshe
#jdbc_password=sshe

hibernate.dialect=org.hibernate.dialect.MySQLDialect
driverClassName=com.mysql.jdbc.Driver
validationQuery=SELECT 1
jdbc_url=jdbc:mysql://localhost:3306/ssh?useUnicode=true&characterEncoding=UTF-8&zeroDateTimeBehavior=convertToNull
jdbc_username=root
jdbc_password=18324

#hibernate.dialect=org.hibernate.dialect.SQLServerDialect
#driverClassName=net.sourceforge.jtds.jdbc.Driver
#validationQuery=SELECT 1
#jdbc_url=jdbc:jtds:sqlserver://127.0.0.1:1433/sy
#jdbc_username=sa
#jdbc_password=123456

#jndiName=java:comp/env/dataSourceName

hibernate.hbm2ddl.auto=update
hibernate.show_sql=true
hibernate.format_sql=true

sessionInfoName=sessionInfo

uploadFieldName=filedata
uploadFileMaxSize=20971520
uploadFileExts=txt,rar,zip,doc,docx,xls,xlsx,jpg,jpeg,gif,png,swf,wmv,avi,wma,mp3,mid
uploadDirectory=attached

这里的jdbc_url=jdbc:mysql://localhost:3306/ssh?useUnicode=true&characterEncoding=UTF-8&zeroDateTimeBehavior=convertToNull代码，3306后面是数据库名ssh。

在src/main/resources目录下新建一个spring-hibernate.xml文件，如下图所示：

内容如下：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:tx="http://www.springframework.org/schema/tx" xmlns:aop="http://www.springframework.org/schema/aop" xsi:schemaLocation="
http://www.springframework.org/schema/beans 
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd 
http://www.springframework.org/schema/tx 
http://www.springframework.org/schema/tx/spring-tx-3.0.xsd
http://www.springframework.org/schema/aop 
http://www.springframework.org/schema/aop/spring-aop-3.0.xsd
">

    <!-- JNDI方式配置数据源 -->
    <!-- <bean id="dataSource" class="org.springframework.jndi.JndiObjectFactoryBean"> <property name="jndiName" value="${jndiName}"></property> </bean> -->

    <!-- 配置数据源 -->
    <bean name="dataSource" class="com.alibaba.druid.pool.DruidDataSource" init-method="init" destroy-method="close">
        <property name="url" value="${jdbc_url}" />
        <property name="username" value="${jdbc_username}" />
        <property name="password" value="${jdbc_password}" />

        <!-- 初始化连接大小 -->
        <property name="initialSize" value="0" />
        <!-- 连接池最大使用连接数量 -->
        <property name="maxActive" value="20" />
        <!-- 连接池最大空闲 -->
        <property name="maxIdle" value="20" />
        <!-- 连接池最小空闲 -->
        <property name="minIdle" value="0" />
        <!-- 获取连接最大等待时间 -->
        <property name="maxWait" value="60000" />

        <!-- <property name="poolPreparedStatements" value="true" /> <property name="maxPoolPreparedStatementPerConnectionSize" value="33" /> -->

        <property name="validationQuery" value="${validationQuery}" />
        <property name="testOnBorrow" value="false" />
        <property name="testOnReturn" value="false" />
        <property name="testWhileIdle" value="true" />

        <!-- 配置间隔多久才进行一次检测，检测需要关闭的空闲连接，单位是毫秒 -->
        <property name="timeBetweenEvictionRunsMillis" value="60000" />
        <!-- 配置一个连接在池中最小生存的时间，单位是毫秒 -->
        <property name="minEvictableIdleTimeMillis" value="25200000" />

        <!-- 打开removeAbandoned功能 -->
        <property name="removeAbandoned" value="true" />
        <!-- 1800秒，也就是30分钟 -->
        <property name="removeAbandonedTimeout" value="1800" />
        <!-- 关闭abanded连接时输出错误日志 -->
        <property name="logAbandoned" value="true" />

        <!-- 监控数据库 -->
        <!-- <property name="filters" value="stat" /> -->
        <property name="filters" value="mergeStat" />
    </bean>

    <!-- 配置hibernate session工厂 -->
    <bean id="sessionFactory" class="org.springframework.orm.hibernate4.LocalSessionFactoryBean">
        <property name="dataSource" ref="dataSource" />
        <property name="hibernateProperties">
            <props>
                <prop key="hibernate.hbm2ddl.auto">${hibernate.hbm2ddl.auto}</prop>
                <prop key="hibernate.dialect">${hibernate.dialect}</prop>
                <prop key="hibernate.show_sql">${hibernate.show_sql}</prop>
                <prop key="hibernate.format_sql">${hibernate.format_sql}</prop>
            </props>
        </property>

        <!-- 自动扫描注解方式配置的hibernate类文件 -->
        <property name="packagesToScan">
            <list>
                <value>sy.model</value>
            </list>
        </property>

        <!-- 自动扫描hbm方式配置的hibernate文件和.hbm文件 -->
        <!-- 
        <property name="mappingDirectoryLocations">
            <list>
                <value>classpath:sy/hbm</value>
            </list>
        </property>
         -->
    </bean>

    <!-- 配置事务管理器 -->
    <bean name="transactionManager" class="org.springframework.orm.hibernate4.HibernateTransactionManager">
        <property name="sessionFactory" ref="sessionFactory"></property>
    </bean>

    <!-- 注解方式配置事物 -->
    <!-- <tx:annotation-driven transaction-manager="transactionManager" /> -->

    <!-- 拦截器方式配置事物 -->
    <tx:advice id="transactionAdvice" transaction-manager="transactionManager">
        <tx:attributes>
            <tx:method name="add*" />
            <tx:method name="save*" />
            <tx:method name="update*" />
            <tx:method name="modify*" />
            <tx:method name="edit*" />
            <tx:method name="delete*" />
            <tx:method name="remove*" />
            <tx:method name="repair" />
            <tx:method name="deleteAndRepair" />

            <tx:method name="get*" propagation="SUPPORTS" />
            <tx:method name="find*" propagation="SUPPORTS" />
            <tx:method name="load*" propagation="SUPPORTS" />
            <tx:method name="search*" propagation="SUPPORTS" />
            <tx:method name="datagrid*" propagation="SUPPORTS" />

            <tx:method name="*" propagation="SUPPORTS" />
        </tx:attributes>
    </tx:advice>
    <aop:config>
        <aop:pointcut id="transactionPointcut" expression="execution(* sy.service..*Impl.*(..))" />
        <aop:advisor pointcut-ref="transactionPointcut" advice-ref="transactionAdvice" />
    </aop:config>


</beans>

7、编写单元测试代码
1、在MySQL中创建ssh数据库

　　SQL脚本：

CREATE DATABASE ssh;

2.在src/main/java中创建sy.model包，在包中编写一个 Tuer类，如下图所示：

Tuser内容:

package sy.model;

import java.util.Date;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.Table;
import javax.persistence.Temporal;
import javax.persistence.TemporalType;
import javax.persistence.UniqueConstraint;

/**
 * Tuser entity. @author MyEclipse Persistence Tools
 */
@Entity
@Table(name = "TUSER", schema = "ssh", uniqueConstraints = @UniqueConstraint(columnNames = "NAME"))
public class Tuser implements java.io.Serializable {

    // Fields

    private String id;
    private String name;
    private String pwd;
    private Date createdatetime;
    private Date modifydatetime;

    // Constructors

    /** default constructor */
    public Tuser() {
    }

    /** minimal constructor */
    public Tuser(String id, String name, String pwd) {
        this.id = id;
        this.name = name;
        this.pwd = pwd;
    }

    /** full constructor */
    public Tuser(String id, String name, String pwd, Date createdatetime, Date modifydatetime) {
        this.id = id;
        this.name = name;
        this.pwd = pwd;
        this.createdatetime = createdatetime;
        this.modifydatetime = modifydatetime;
    }

    // Property accessors
    @Id
    @Column(name = "ID", unique = true, nullable = false, length = 36)
    public String getId() {
        return this.id;
    }

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

    @Column(name = "NAME", unique = true, nullable = false, length = 100)
    public String getName() {
        return this.name;
    }

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

    @Column(name = "PWD",length = 32)
    public String getPwd() {
        return this.pwd;
    }

    public void setPwd(String pwd) {
        this.pwd = pwd;
    }

    @Temporal(TemporalType.TIMESTAMP)
    @Column(name = "CREATEDATETIME", length = 7)
    public Date getCreatedatetime() {
        return this.createdatetime;
    }

    public void setCreatedatetime(Date createdatetime) {
        this.createdatetime = createdatetime;
    }

    @Temporal(TemporalType.TIMESTAMP)
    @Column(name = "MODIFYDATETIME", length = 7)
    public Date getModifydatetime() {
        return this.modifydatetime;
    }

    public void setModifydatetime(Date modifydatetime) {
        this.modifydatetime = modifydatetime;
    }

}

3、在src/main/java中创建sy.dao包，在包中编写一个 UserDaoI接口，如下图所示：
代码如下:

package sy.dao;

import java.io.Serializable;

import sy.model.Tuser;

public interface UserDaoI {
     /**
          * 保存用户
          * @param user
          * @return
          */
         Serializable save(Tuser user); 

}

在src/main/java中创建sy.dao.impl包，在包中编写 UserDaoImpl实现类，如下图所示：

代码:

package sy.dao.impl;

import java.io.Serializable;

import org.hibernate.SessionFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Repository;

import sy.dao.UserDaoI;
import sy.model.Tuser;

@Repository("userDao")
public class UserDaoImpl implements UserDaoI{

      /**
     * 使用@Autowired注解将sessionFactory注入到UserDaoImpl中
     */
    @Autowired
    private SessionFactory sessionFactory;

    @Override
    public Serializable save(Tuser user) {
        // TODO Auto-generated method stub
        return this.sessionFactory.getCurrentSession().save(user);
    }

}

这里使用@Repository(“userDao”)注解完成dao注入， 使用@Autowired注解将sessionFactory注入到UserDaoImpl中。

4、在之前创建好的UserServiceI接口中添加一个save方法的定义，如下：

package sy.service;

import java.io.Serializable;

import sy.model.Tuser;

public interface UserserviceI {

    public void test1();

    Serializable save(Tuser user); 

}

5、在UserServiceImpl类中实现save方法，如下：

package sy.service.impl;

import java.io.Serializable;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import sy.dao.UserDaoI;
import sy.model.Tuser;
import sy.service.UserserviceI;


//使用Spring提供的@Service注解将UserServiceImpl标注为一个Service
@Service("userService")
public class UserserviceImpl implements UserserviceI {

    /**
     * 注入userDao
     */
    private UserDaoI userDao;

    public UserDaoI getUserDao() {
        return userDao;
    }
    @Autowired
    public void setUserDao(UserDaoI userDao) {
        this.userDao = userDao;
    }

    public void test1() {
        System.out.print("ssss");

    }
    @Override
    public Serializable save(Tuser user) {
        // TODO Auto-generated method stub
        return userDao.save(user);
    }

}

6、在src/main/test下的me.gacl.test包中编写 TestHibernate类，代码如下：

package yf.test;

import java.util.Date;
import java.util.UUID;

import org.junit.Before;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import sy.model.Tuser;
import sy.service.UserserviceI;

public class TestHibernate {
      private UserserviceI userService;

        /**
         * 这个before方法在所有的测试方法之前执行，并且只执行一次
         * 所有做Junit单元测试时一些初始化工作可以在这个方法里面进行
         * 比如在before方法里面初始化ApplicationContext和userService
         */
        @Before
        public void before(){
            ApplicationContext ac = new ClassPathXmlApplicationContext(new String[]{"spring.xml","spring-hibernate.xml"});
            userService = (UserserviceI) ac.getBean("userService");
        }

        @Test
        public void testSaveMethod(){
            //ApplicationContext ac = new ClassPathXmlApplicationContext(new String[]{"spring.xml","spring-hibernate.xml"});
            //UserServiceI userService = (UserServiceI) ac.getBean("userService");
            Tuser user = new Tuser();
            user.setId(UUID.randomUUID().toString().replaceAll("-", ""));
            user.setName("yy");
            user.setPwd("123456");
            user.setCreatedatetime(new Date()); 
            userService.save(user);
        }

}

执行Junit单元测试，如下所示：

　测试通过，再看看sshe数据库，如下图所示：
　
　

　Hibernate在执行过程中，先帮我们在ssh数据库中创建一张tuser表，tuser的表结构根据Tuser实体类中的属性定义来创建的，然后再将数据插入到tuser表中.
　tuser表数据如下图所示：
　
　

到此，Hibernate4开发环境的搭建并且与Spring整合的工作算是全部完成并且测试通过了。

**注意：如果你执行maven install ，将TestSpring里的内容注释，否则会报错：
org.springframework.beans.factory.BeanCreationException: Error creating bean with name ‘userDao’。**