springmvc整合hibernate含单元测试

springmvc+hibernate也是一种实用价值比较高的框架组合。此文将介绍，springmvc整合hibernate的框架。以及相关的单元测试怎样编写。

源码下载

提前准备

为了更好的完成此文内容，读者需提前准备一下内容：

JDK1.8：java开发基础环境

Maven环境：包管理工具，不用到处找jar包。

IDEA开发工具：操作方便，更加人性化。

目录

配置

1. ​ 使用IDEA新建Maven项目

2. ​ 配置入口文件web.xml

3. ​ 配置springmvc

4. ​ 配置hibernate

应用

1. ​ springmvc页面跳转

2. ​ springmvc实现ajax

3. ​ springmvc单元测试

4. ​ hibernate实现持久化

5. ​ hibernate单元测试

其他

1. ​ 代码清单

2. ​ 引用

结语

配置部分

使用IDEA新建Maven项目

确保已经完成《提前准备》内容后。

新建maven项目

1. 打开IDEA

2. 执行File->New->Project…

3. 在New Project面板中选择Maven（Create from archetype不用勾选），点击Next

4. GroupId填入com.saoft，ArtifactId填入SpringmvcHibernateDemo，点击Next

5. Project name,Project location保持默认，点击Finish

6. 出现选择面板，选择New Window（This Window选项表示在当前窗口打开这个项目，会关闭当前项目。New Window会新建窗口。）

导入需要的jar包

新建Maven项目就完成了，接下来在pom.xml中配置我们项目中需要的jar包。Maven是一个jar包管理工具，在pom.xml中通过GroupId,ArtifactId,Version来标识我们需要的jar包，自动下载这些jar包。由于Maven默认的n镜像仓库在国外，自动下载会很慢。所以设置阿里云的maven镜像仓库，代码如下：

    <repositories>
        <repository>
            <id>alimaven</id>
            <name>aliyun maven</name>
            <url>http://maven.aliyun.com/nexus/content/groups/public/</url>
            <releases>
                <enabled>true</enabled>
            </releases>
            <snapshots>
                <enabled>false</enabled>
            </snapshots>
        </repository>
    </repositories>

在pom.xml中需要重点设置以下几点：

基础设置

1. ​ 设置jdk版本：<maven.compiler.source>1.8</maven.compiler.source><maven.compiler.target>1.8</maven.compiler.target>

2. ​ 设置编码方式：<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>

3. ​ 设置镜像仓库

需要的jar包

1. ​ spring基础包：core,context,aop,beans,web(支撑mvc),orm（支撑hibernate）

2. ​ springmvc相关包：jsp,jackson（ajax返回结果将java对象格式化为json）,commons-fileupload（文件上传）

3. ​ hibernate相关包：mysql数据库，hibernate，druid连接池

4. ​ 测试相关包：junit（代码预检）

完整配置在文末《代码清单》中pom.xml。

配置web.xml入口文件

此文使用tomcat做为服务容器。web.xml就作为入口文件。相当于java类中的main方法。在web.xml中我们需要配置以下几点：

• ​ servlet的字符集（编码）设置为UTF-8

• ​ 初始化spring上下文。

完整配置在文末《代码清单》中web.xml。

配置springmvc

这里的配置springmvc也包含了spring的基本配置。

context:component-scan 这个配置扫描所有@Component组件。其中@Repository，@Service，@Controller都属于@Component的子类。都会被扫描到。

mvc:annotation-driven 开启springmvc注解功能，对应的注解@RequestMapping，@GetMapping，@PostMapping，@ResponseBody等注解。

InternalResourceViewResolver：配置视图解析，我们这里配置的是jsp，前缀路径为/WEB-INF/view/,后缀.jsp。如UserController 中 的index()方法的返回值为return “index”，那么通过视图解析就得到/WEB-INF/view/index.jsp。

CommonsMultipartResolver：文件上传解析器。让controller能够接收文件，同时控制上传文件的大小。

完整配置在文末《代码清单》中spring-mvc.xml。

配置hibernate

applicationContext.xml文件里面配置了关于持久层的一些配置。在spring-mvc.xml中 通过import标签引入了。

context:property-placeholder：用来加载properties文件，并在xml配置文件中使用。比如 ${jdbc.url}，${jdbc.username}

配置数据源：此文使用的是阿里巴巴的Druid做为数据源连接池。

配置hibernate的sessionFactory：主要包含扫描实体类跟数据库的对应关系（xx.hbm.xml）,使用的数据库类型Mysql，显示sql。

开启事务：通过spring的aop动态设置方法的事务，简单来说就是：动态配置一个方法能不能修改数据表。

完整配置在文末《代码清单》中applicationContext.xml。

应用

springmvc页面跳转

配置springmvc中mvc:annotation-driven开启了注解形式。有如下代码

@Controller
@RequestMapping("user")
public class UserController {

    @GetMapping("index")
    public String index(){
        return "index";
    }
}

@Controller会被spring的context:component-scan扫描到spring的上下文里面。

@GetMapping(“index”)等价于@RequestMapping(value = “index”,method = RequestMethod.GET)

index()方法在浏览器上的访问路径为 localhost:8080(系统路径,一般没有或跟系统名称一致)/user(controller上的RequestMappping)/index（方法上面的路径）

return “index”：到视图解析器，结果是 /WEB-INF/view/index.jsp

springmvc实现ajax

相对于页面跳转，ajax比页面跳转多了@ReponseBody注解。

@Controller
@RequestMapping("user")
public class UserController {

    @GetMapping("index")
    public String index(){
        return "index";
    }

    @ResponseBody
    @GetMapping("ajax")
    public Map<String,Object> ajax(){
        Map<String, Object> map = new HashMap<>();
        map.put("code", "0");
        map.put("data", "test");
        return map;
    }
}

访问路径 localhost:8080/user/ajax GET方式

springmvc单元测试

针对UserController进行一个简单的测试。测试视图解析是否正确。ajax是否能够返回正确数据。

测试代码：

SpringmvcHibernateDemo\src\test\java\com\saoft\shd\controller\UserControllerTest.java

package com.saoft.shd.controller;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("/spring/spring-mvc.xml")
@WebAppConfiguration
public class UserControllerTest {

    private MockMvc mockMvc;

    @Autowired
    private WebApplicationContext wac;

    @Before
    public void setup() {
        this.mockMvc = MockMvcBuilders.webAppContextSetup(this.wac).build();
    }


    @Test
    public void pageTest() throws Exception {
        MockHttpServletRequestBuilder builder = 				  MockMvcRequestBuilders.get("/user/index");

        MvcResult mvcResult = mockMvc.perform(builder)
                .andExpect(MockMvcResultMatchers.status().isOk())
                .andExpect(MockMvcResultMatchers.view().name("index"))
                .andExpect(MockMvcResultMatchers.forwardedUrl("/WEB-INF/view/index.jsp"))
                .andDo(MockMvcResultHandlers.print()) //输出MvcResult到控制台
                .andReturn();

    }

    @Test
    public void ajaxTest() throws Exception {
        MockHttpServletRequestBuilder builder = MockMvcRequestBuilders.get("/user/ajax");

        MvcResult mvcResult = mockMvc.perform(builder)
                .andExpect(MockMvcResultMatchers.status().isOk())
                .andDo(MockMvcResultHandlers.print()) //输出MvcResult到控制台
                .andReturn();

        MockHttpServletResponse response = mvcResult.getResponse();

        System.out.println(response.getContentAsString());
    }

}

测试通过。打印信息片段：

MockHttpServletResponse:
           Status = 200
    Error message = null
          Headers = {Content-Type=[application/json;charset=UTF-8]}
     Content type = application/json;charset=UTF-8
             Body = {"code":"0","data":"test"}
    Forwarded URL = null
   Redirected URL = null
          Cookies = []

hibernate实现持久化

hibernate保存到数据库的功能，需要继承HibernateDaoSupport。HibernateDaoSupport提供了一个HibernateTemplate能够方便的进行数据库操作。但是需要设置SessionFactory或者HibernateTemplate。

在applicationContext.xml中我们配置了SessionFactory和HibernateTemplate。我们可以用自动注入方便的注入。如下代码所示：

package com.saoft.shd.dao;

import com.saoft.shd.entity.User;
import org.hibernate.SessionFactory;
import org.springframework.orm.hibernate5.support.HibernateDaoSupport;
import org.springframework.stereotype.Repository;

import java.io.Serializable;

@Repository
public class UserDao extends HibernateDaoSupport {

    public UserDao(SessionFactory sessionFactory) {
        super.setSessionFactory(sessionFactory);
    }

    public Serializable add(User user){
        return getHibernateTemplate().save(user);
    }

}

其中@Repository表示这个UserDao会被spring上下文扫描到。所以可以自动注入SessionFacotry的值。

有一个add方法，实现了添加一个用户的功能。其中User对象的映射关系使用的是注解方法。如下所示

package com.saoft.shd.entity;

import javax.persistence.*;

@Entity
@Table(name = "user")
public class User {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Integer id;

    @Column
    private String name;

    getxxx
    setxxx
}

@Entity持久层实体。

@Table指定表名。

@Id主键，@GeneratedValue(strategy = GenerationType.IDENTITY)整形自增。

@Column数据库列不写值表示：属性名同数据库表列名。

hibernate单元测试

hibernate新增User单元测试代码如下所示：

package com.saoft.shd.dao;

import com.saoft.shd.entity.User;
import org.junit.Assert;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import java.io.Serializable;
import java.util.Date;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("/spring/spring-mvc.xml")
@Transactional
public class UserDaoTest {

    @Autowired
    UserDao userDao;

    @Test
    @Rollback(false)
    public void add(){

        User user = new User();
        user.setName("TestMain" + new Date());
        Serializable add = userDao.add(user);
        System.out.println(add);
        Assert.assertNotNull(add);
    }
}

注意：@Transactional这里是新增功能，需要开启事务。测试的时候默认会回滚事务，不会真的加入数据库，加上@Rollback(false)就能够增加数据到数据库了。

在applicationContext.xml配置的是service的事务，这里需要单独开启。

其他

代码清单

完整代码，到附件下载。

以下为部分代码。

pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.saoft</groupId>
    <artifactId>SpringmvcHibernateDemo</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <maven.compiler.source>1.8</maven.compiler.source>
        <maven.compiler.target>1.8</maven.compiler.target>
        <spring.version>4.3.7.RELEASE</spring.version>
        <hibernate.version>5.2.11.Final</hibernate.version>
        <aspectjweaver.version>1.6.8</aspectjweaver.version>
        <mysql.version>5.1.32</mysql.version>
        <druid.version>1.0.9</druid.version>
        <jstl.version>1.2</jstl.version>
        <servlet-api.version>3.1.0</servlet-api.version>
        <jsp-api.version>2.2</jsp-api.version>
        <jackson.version>2.7.3</jackson.version>
        <commons-fileupload.version>1.3.1</commons-fileupload.version>
        <slf4j.version>1.6.4</slf4j.version>
    </properties>
    <dependencies>
        <!--spring依赖-->
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.6.8</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aop</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-web</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-beans</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-expression</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-orm</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-web</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>${spring.version}</version>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aspects</artifactId>
            <version>${spring.version}</version>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>

        <!-- hibernate begin -->
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-core</artifactId>
            <version>${hibernate.version}</version>
        </dependency>
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-entitymanager</artifactId>
            <version>${hibernate.version}</version>
        </dependency>
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-validator</artifactId>
            <version>5.2.1.Final</version>
        </dependency>

        <dependency>
            <groupId>javax.el</groupId>
            <artifactId>javax.el-api</artifactId>
            <version>2.2.4</version>
        </dependency>
        <!-- hibernate 缓存, 视情况添加-->
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-ehcache</artifactId>
            <version>${hibernate.version}</version>
        </dependency>
        <!-- hibernate end -->

        <!-- 日志处理 -->
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-log4j12</artifactId>
            <version>${slf4j.version}</version>
        </dependency>

        <!--jsp/servlet-->
        <dependency>
            <groupId>jstl</groupId>
            <artifactId>jstl</artifactId>
            <version>${jstl.version}</version>
        </dependency>
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>javax.servlet-api</artifactId>
            <version>${servlet-api.version}</version>
            <scope>provided</scope>
        </dependency>
        <dependency>
            <groupId>taglibs</groupId>
            <artifactId>standard</artifactId>
            <version>1.1.2</version>
        </dependency>

        <!-- MySql -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>${mysql.version}</version>
        </dependency>
        <!-- 连接池 -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>${druid.version}</version>
        </dependency>

        <!-- Jackson-->
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-core</artifactId>
            <version>${jackson.version}</version>
        </dependency>
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-annotations</artifactId>
            <version>${jackson.version}</version>
        </dependency>

        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-databind</artifactId>
            <version>${jackson.version}</version>
        </dependency>
        <!-- 文件上传组件 -->
        <dependency>
            <groupId>commons-fileupload</groupId>
            <artifactId>commons-fileupload</artifactId>
            <version>${commons-fileupload.version}</version>
        </dependency>

    </dependencies>

    <repositories>
        <repository>
            <id>alimaven</id>
            <name>aliyun maven</name>
            <url>http://maven.aliyun.com/nexus/content/groups/public/</url>
            <releases>
                <enabled>true</enabled>
            </releases>
            <snapshots>
                <enabled>false</enabled>
            </snapshots>
        </repository>
    </repositories>

    <build>
        <resources>
            <!--解决找不到xml文件问题-->
            <resource>
                <directory>src/main/java</directory>
                <includes>
                    <include>**/*.xml</include>
                </includes>
                <filtering>true</filtering>
            </resource>
        </resources>

        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.1</version>
                <configuration>
                    <source>1.8</source> <!-- 源代码使用的开发版本 -->
                    <target>1.8</target> <!-- 需要生成的目标class文件的编译版本 -->
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.apache.tomcat.maven</groupId>
                <artifactId>tomcat7-maven-plugin</artifactId>
                <version>2.2</version>
                <configuration>
                    <path>/</path>
                    <port>8080</port>
                    <uriEncoding>UTF-8</uriEncoding><!-- 非必需项 -->
                </configuration>
            </plugin>
        </plugins>
    </build>

</project>

web.xml

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
         version="4.0">

    <!-- 过滤器编码 -->
    <filter>
        <filter-name>characterEncodingFilter</filter-name>
        <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
        <init-param>
            <param-name>encoding</param-name>
            <param-value>UTF-8</param-value>
        </init-param>
        <init-param>
            <param-name>enabled</param-name>
            <param-value>true</param-value>
        </init-param>
    </filter>
    <filter-mapping>
        <filter-name>characterEncodingFilter</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>

    <!-- springmvc的前端控制器 -->
    <servlet>
        <servlet-name>dispatcherServlet</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:spring/spring-mvc.xml</param-value>
        </init-param>
        <!--servlet容器启动加载-->
        <load-on-startup>1</load-on-startup>
    </servlet>
    <servlet-mapping>
        <servlet-name>dispatcherServlet</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>

</web-app>

spring-mvc.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:context="http://www.springframework.org/schema/context"
       xmlns:mvc="http://www.springframework.org/schema/mvc"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/mvc
       http://www.springframework.org/schema/mvc/spring-mvc.xsd
       http://www.springframework.org/schema/context
       http://www.springframework.org/schema/context/spring-context.xsd">

    <!--springmm IOC只扫描controller-->
    <context:component-scan base-package="com.saoft.shd.**" />

    <!--导入数据库配置-->
    <import resource="applicationContext.xml"/>

    <!--两个标准配置  -->
    <!-- 支持springmvc更高级的一些功能，JSR303校验，快捷的ajax...映射动态请求 -->
    <!--<mvc:annotation-driven/>-->
    <!-- 将springmvc不能处理的请求交给默认的处理器 -->
    <mvc:default-servlet-handler default-servlet-name="default"/>

    <mvc:annotation-driven conversion-service="conversionService" ignore-default-model-on-redirect="true">
        <mvc:message-converters>
            <bean class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter" >
                <property name="objectMapper">
                    <bean class="com.fasterxml.jackson.databind.ObjectMapper">
                        <property name="dateFormat">
                            <bean class="java.text.SimpleDateFormat">
                                <!-- 设置全局返回JSON到前端时日期格式化 -->
                                <constructor-arg type="java.lang.String" value="yyyy-MM-dd HH:mm:ss"/>
                            </bean>
                        </property>
                    </bean>
                </property>
            </bean>
        </mvc:message-converters>
    </mvc:annotation-driven>

    <!-- 日期转换 -->
    <bean id="conversionService" class="org.springframework.format.support.FormattingConversionServiceFactoryBean">
        <!-- 转换器 -->
        <property name="converters">
            <set>
                <!-- 日期类型转换 -->
                <bean class="com.saoft.shd.common.StringToDateConvert"/>
            </set>
        </property>
    </bean>


    <!--视图解析器-->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <property name="prefix" value="/WEB-INF/view/"/>
        <property name="suffix" value=".jsp"/>
    </bean>


    <!-- 资源映射 -->
    <!--<mvc:resources location="/WEB-INF/css/" mapping="/css/**"/>-->
    <!--<mvc:resources location="/WEB-INF/js/" mapping="/js/**"/>-->

    <!-- 文件上传解析器 -->
    <bean id="multipartResolver"
          class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
        <!-- 文件默认编码 -->
        <property name="defaultEncoding" value="UTF-8"></property>
        <!-- 文件上传的最大值5MB，5*1024*1024 -->
        <property name="maxUploadSize" value="5242880"></property>
    </bean>
</beans>

applicationContext.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:context="http://www.springframework.org/schema/context" 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.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd">

    <!-- 加载配置文件 -->
    <context:property-placeholder location="classpath:jdbc.properties"/>

    <!-- 数据库连接池 -->
    <!-- Druid数据源 -->
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource"
          destroy-method="close">
        <property name="url" value="${jdbc.url}"/>
        <property name="username" value="${jdbc.username}"/>
        <property name="password" value="${jdbc.password}"/>
        <property name="driverClassName" value="${jdbc.driver}"/>
        <property name="maxActive" value="10"/>
        <property name="minIdle" value="5"/>

        <!-- 配置获取连接等待超时的时间 -->
        <property name="maxWait" value="10000"/>

        <!-- 配置间隔多久才进行一次检测，检测需要关闭的空闲连接，单位是毫秒 -->
        <property name="timeBetweenEvictionRunsMillis" value="60000"/>

        <!-- 配置一个连接在池中最小生存的时间，单位是毫秒 -->
        <property name="minEvictableIdleTimeMillis" value="300000"/>

        <property name="testWhileIdle" value="true"/>

        <!-- 这里建议配置为TRUE，防止取到的连接不可用 -->
        <property name="testOnBorrow" value="true"/>
        <property name="testOnReturn" value="false"/>

        <!-- 打开PSCache，并且指定每个连接上PSCache的大小 -->
        <property name="poolPreparedStatements" value="true"/>
        <property name="maxPoolPreparedStatementPerConnectionSize"
                  value="20"/>

        <!-- 这里配置提交方式，默认就是TRUE，可以不用配置 -->
        <property name="defaultAutoCommit" value="true"/>
    </bean>


    <!--**********************配置hibernate*************************-->
    <!--无配置文件方式-->
    <bean id="sessionFactory" class="org.springframework.orm.hibernate5.LocalSessionFactoryBean">
        <property name="dataSource" ref="dataSource"/>
        <property name="packagesToScan" value="com.saoft.shd.entity"/>
        <property name="hibernateProperties">
            <props>
                <prop key="hibernate.hbm2ddl.auto">update</prop> <!--hibernate根据实体自动生成数据库表-->
                <prop key="hibernate.dialect">org.hibernate.dialect.MySQL5InnoDBDialect</prop>   <!--指定数据库方言-->
                <prop key="hibernate.show_sql">true</prop>     <!--在控制台显示执行的数据库操作语句-->
                <prop key="hibernate.format_sql">true</prop>     <!--在控制台显示执行的数据哭操作语句（格式）-->
            </props>
        </property>
    </bean>

    <!--
       配置一个hibernateTemplate对象，这个对象spring中XXXTemplate类似，代替了session，
       在需要session的地方注入hibernateTemplate，代替session来执行持久化操作。
       -->
    <bean id="hibernateTemplate" class="org.springframework.orm.hibernate5.HibernateTemplate"
          depends-on="sessionFactory">
        <property name="sessionFactory" ref="sessionFactory"/>
    </bean>
    <!--配置一个事务管理器-->
    <bean id="hibernateTransactionManager"
          class="org.springframework.orm.hibernate5.HibernateTransactionManager">
        <property name="sessionFactory" ref="sessionFactory"/>
    </bean>

    <tx:annotation-driven transaction-manager="hibernateTransactionManager"/>

    <!-- 切面 -->
    <aop:config>
        <!-- 切入点表达式 -->
        <aop:pointcut id="pointCut" expression="execution(* com.saoft.shd.service.*.*(..))"/>
        <!-- 配置事务增强 -->
        <aop:advisor advice-ref="txAdvice" pointcut-ref="pointCut"/>
    </aop:config>

    <!-- 通知 -->
    <tx:advice id="txAdvice" transaction-manager="hibernateTransactionManager">
        <tx:attributes>
            <!-- 事务传播 -->
            <tx:method name="save*" propagation="REQUIRED"/>
            <tx:method name="insert*" propagation="REQUIRED"/>
            <tx:method name="add*" propagation="REQUIRED"/>
            <tx:method name="create*" propagation="REQUIRED"/>
            <tx:method name="delete*" propagation="REQUIRED"/>
            <tx:method name="update*" propagation="REQUIRED"/>
            <tx:method name="find*" propagation="SUPPORTS" read-only="true"/>
            <tx:method name="select*" propagation="SUPPORTS" read-only="true"/>
            <tx:method name="get*" propagation="SUPPORTS" read-only="true"/>
        </tx:attributes>
    </tx:advice>

</beans>

jdbc.propeties

jdbc.driver = com.mysql.jdbc.Driver
jdbc.url = jdbc:mysql://localhost:3306/mvc_hql?useUnicode=true&characterEncoding=utf8&autoReconnect=true
jdbc.username = root
jdbc.password = root

引用

SpringMVC 测试 mockMVC

SpringSpringMvcHibernateDemo

结语

以上就是springmvc整合hibernate的配置，以及单元测试的教程。有没写明白的，欢迎指正提问。