Spring+Spring MVC+MyBatis的整合

一、概述

　　在WEB开发中我们往往会借助框架来简化自己的开发过程，本文介绍了SSM框架的整合，从而搭建一个简单的Web框架。
　　
　　环境参数：
　　操作系统：windows10 64位
　　jdk版本：jdk1.8 64位
　　Maven版本：3.50
　　MySql版本：mysql-server 5.7
　　Tomcat版本：apache-tomcat-7.
　　数据库管理和设计工具：navicat
　　开发工具及版本：IntelliJ IDEA 2017.2.5

二、SSM整合前的准备

　　一、使用IntelliJ IDEA创建一个基于Maven构建的web工程，工程名称暂时叫SSM。在创建好的工程中先创建几个包，如下所示：

　　二、新建一个数据库，命名为ssm。在ssm数据库中创建一张员工表命名为tbl_emp，一张部门表，命名为 tbl_dept。每个表的结构如下所示：

　　OK，项目与数据库都创建好之后，我们开始Spring+Spring MVC+MyBatis的整合。

三、配置pom文件

　　由于本项目是一个基于Maven构建的web工程，所以需要配置pom.xml文件来管理Spring、Spring MVC、MyBatis以及他们整合时所需的jar包。
　　Spring各个jar包作用如下：

Spring AOP：Spring的面向切面编程，提供AOP（面向切面编程）的实现。
Spring Aspects：Spring提供的对AspectJ框架的整合。
Spring Beans：Spring IOC的基础实现，包含访问配置文件、创建和管理bean等。
Spring Context：在基础IOC功能上提供扩展服务，此外还提供许多企业级服务的支持，有邮件服务、任务调度、JNDI定位，EJB集成、远程访问、缓存以及多种视图层框架的支持。
Spring Context Support：Spring context的扩展支持，用于MVC方面。
Spring Core：Spring的核心工具包。
Spring expression：Spring表达式语言。
Spring JDBC：对JDBC 的简单封装。
Spring JMS：为简化jms api的使用而做的简单封装。
Spring orm：整合第三方的orm实现，如hibernate，ibatis，jdo以及spring 的jpa实现。
Spring oxm：Spring对于object/xml映射的支持，可以让JAVA与XML之间来回切换。
Spring test：对JUnit等测试框架的简单封装。
Spring tx：为JDBC、Hibernate、JDO、JPA等提供的一致的声明式和编程式事务管理。
Spring web：包含Web应用开发时，用到Spring框架时所需的核心类，包括自动载入WebApplicationContext特性的类、Struts与JSF集成类、文件上传的支持类、Filter类和大量工具辅助类。
Spring webmvc：包含Spring MVC框架相关的所有类。包含国际化、标签、Theme、视图展现的FreeMarker、JasperReports、 Tiles、Velocity、XSLT相关类。当然，如果你的应用使用了独立的MVC框架，则无需这个JAR文件里的任何类。
Spring websocket：提供 Socket通信， web端的推送功能

　　pom文件的示例代码如下：

<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/maven-v4_0_0.xsd">
  <modelVersion>4.0.0modelVersion>
  <groupId>SSMgroupId>
  <artifactId>SSMartifactId>
  <packaging>warpackaging>
  <version>1.0-SNAPSHOTversion>
  <name>SSM Maven Webappname>
  <url>http://maven.apache.orgurl>

  <properties>
    <project.build.sourceEncoding>UTF-8project.build.sourceEncoding>
    <project.reporting.outputEncoding>UTF-8project.reporting.outputEncoding>
    <maven.compiler.encoding>UTF-8maven.compiler.encoding>
    
    <org.springframework.version>4.3.12.RELEASEorg.springframework.version>
    
    <org.mybatis.version>3.4.4org.mybatis.version>
    
    <org.mybatis.spring.version>1.3.0org.mybatis.spring.version>
  properties>

  <dependencies>
    
    <dependency>
      <groupId>org.hibernategroupId>
      <artifactId>hibernate-validatorartifactId>
      <version>5.4.1.Finalversion>
    dependency>

    
    <dependency>
      <groupId>javax.servletgroupId>
      <artifactId>javax.servlet-apiartifactId>
      <version>3.0.1version>
      <scope>providedscope>
    dependency>

    <dependency>
      <groupId>javax.servlet.jspgroupId>
      <artifactId>jsp-apiartifactId>
      <version>2.2version>
    dependency>

    <dependency>
      <groupId>jstlgroupId>
      <artifactId>jstlartifactId>
      <version>1.2version>
    dependency>


    
    <dependency>
      <groupId>org.springframeworkgroupId>
      <artifactId>spring-contextartifactId>
      <version>${org.springframework.version}version>
    dependency>

    
    <dependency>
      <groupId>org.springframeworkgroupId>
      <artifactId>spring-jdbcartifactId>
      <version>${org.springframework.version}version>
    dependency>

    
    <dependency>
      <groupId>org.springframeworkgroupId>
      <artifactId>spring-txartifactId>
      <version>${org.springframework.version}version>
    dependency>

    
    <dependency>
      <groupId>org.springframeworkgroupId>
      <artifactId>spring-testartifactId>
      <version>${org.springframework.version}version>
    dependency>

    
    <dependency>
      <groupId>org.springframeworkgroupId>
      <artifactId>spring-aopartifactId>
      <version>${org.springframework.version}version>
    dependency>

    
    <dependency>
      <groupId>org.springframeworkgroupId>
      <artifactId>spring-aspectsartifactId>
      <version>${org.springframework.version}version>
    dependency>

    
    <dependency>
      <groupId>org.springframeworkgroupId>
      <artifactId>spring-webmvcartifactId>
      <version>${org.springframework.version}version>
    dependency>

    <dependency>
      <groupId>org.springframeworkgroupId>
      <artifactId>spring-oxmartifactId>
      <version>${org.springframework.version}version>
    dependency>

    
    <dependency>
      <groupId>org.mybatisgroupId>
      <artifactId>mybatisartifactId>
      <version>${org.mybatis.version}version>
    dependency>

    
    <dependency>
      <groupId>org.mybatisgroupId>
      <artifactId>mybatis-springartifactId>
      <version>${org.mybatis.spring.version}version>
    dependency>

    
    
    <dependency>
      <groupId>c3p0groupId>
      <artifactId>c3p0artifactId>
      <version>0.9.1.2version>
    dependency>

    
    
    
    
    
    
    

    
    <dependency>
      <groupId>mysqlgroupId>
      <artifactId>mysql-connector-javaartifactId>
      <version>5.1.6version>
    dependency>


    
    <dependency>
      <groupId>org.apache.commonsgroupId>
      <artifactId>commons-lang3artifactId>
      <version>3.5version>
    dependency>

    <dependency>
      <groupId>commons-collectionsgroupId>
      <artifactId>commons-collectionsartifactId>
      <version>3.2.1version>
    dependency>

    
    <dependency>
      <groupId>com.google.guavagroupId>
      <artifactId>guavaartifactId>
      <version>20.0version>
    dependency>


    
    <dependency>
      <groupId>com.fasterxml.jackson.coregroupId>
      <artifactId>jackson-databindartifactId>
      <version>2.9.1version>
    dependency>

    <dependency>
      <groupId>junitgroupId>
      <artifactId>junitartifactId>
      <version>4.11version>
      <scope>testscope>
    dependency>

    
    <dependency>
      <groupId>org.mybatis.generatorgroupId>
      <artifactId>mybatis-generator-coreartifactId>
      <version>1.3.5version>
    dependency>

    
    <dependency>
      <groupId>com.github.pagehelpergroupId>
      <artifactId>pagehelperartifactId>
      <version>5.0.0version>
    dependency>


    
    <dependency>
      <groupId>commons-netgroupId>
      <artifactId>commons-netartifactId>
      <version>3.1version>
    dependency>

    
    <dependency>
      <groupId>commons-fileuploadgroupId>
      <artifactId>commons-fileuploadartifactId>
      <version>1.2.2version>
    dependency>

    <dependency>
      <groupId>commons-iogroupId>
      <artifactId>commons-ioartifactId>
      <version>2.0.1version>
    dependency>

    
    <dependency>
      <groupId>com.googlecode.json-simplegroupId>
      <artifactId>json-simpleartifactId>
      <version>1.1.1version>
    dependency>
  dependencies>
  <build>
    <finalName>SSMfinalName>

    <plugins>
      
      <plugin>
        <groupId>org.apache.maven.pluginsgroupId>
        <artifactId>maven-compiler-pluginartifactId>
        <configuration>
          <source>1.8source>
          <target>1.8target>
          <encoding>UTF-8encoding>
          <compilerArguments>
            <extdirs>${project.basedir}/src/main/webapp/WEB-INF/libextdirs>
          compilerArguments>
        configuration>
      plugin>
    plugins>
  build>
project>

四、配置web.xml文件

　　配置web.xml文件，主要对Spring的配置，在Web项目初始化的时候，加载Spring的IOC容器。以及对SpringMVC配置，配置SpringMVC的前端控制器，并拦截所有请求。
　　
　　web.xml配置文件的代码及注释如下所示：

<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xmlns="http://java.sun.com/xml/ns/javaee"
         xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
         id="WebApp_ID" version="2.5">

  <display-name>Archetype Created Web Applicationdisplay-name>

  
  <listener>
    <listener-class>org.springframework.web.context.request.RequestContextListenerlistener-class>
  listener>

  
  
  
  <listener>
    <listener-class>org.springframework.web.context.ContextLoaderListenerlistener-class>
  listener>

  
  <context-param>
    <param-name>contextConfigLocationparam-name>
    <param-value>classpath:applicationContext.xmlparam-value>
  context-param>


  
  
  
  <servlet>
    <servlet-name>dispatcherServletservlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServletservlet-class>
    
    
    

    
    <load-on-startup>1load-on-startup>
  servlet>

  
  <servlet-mapping>
    <servlet-name>dispatcherServletservlet-name>
    <url-pattern>/url-pattern>
  servlet-mapping>

  
  <filter>
    <filter-name>CharacterEncodingFilterfilter-name>
    <filter-class>org.springframework.web.filter.CharacterEncodingFilterfilter-class>
    <init-param>
      <param-name>encodingparam-name>
      <param-value>utf-8param-value>
    init-param>
    <init-param>
      <param-name>forceRequestEncodingparam-name>
      <param-value>trueparam-value>
    init-param>
    <init-param>
      <param-name>forceResponseEncodingparam-name>
      <param-value>trueparam-value>
    init-param>
  filter>
  <filter-mapping>
    <filter-name>CharacterEncodingFilterfilter-name>
    <url-pattern>/*url-pattern>
  filter-mapping>

  
  <filter>
    <filter-name>HiddenHttpMethodFilterfilter-name>
    <filter-class>org.springframework.web.filter.HiddenHttpMethodFilterfilter-class>
  filter>
  <filter-mapping>
    <filter-name>HiddenHttpMethodFilterfilter-name>
    <url-pattern>/*url-pattern>
  filter-mapping>
  <filter>
    <filter-name>HttpPutFormContentFilterfilter-name>
    <filter-class>org.springframework.web.filter.HttpPutFormContentFilterfilter-class>
  filter>
  <filter-mapping>
    <filter-name>HttpPutFormContentFilterfilter-name>
    <url-pattern>/*url-pattern>
  filter-mapping>

web-app>

注：在web.xml文件编写完成之后，需要创建两个配置文件，即Spring的配置文件applicationContext.xml和Spring MVC的配置文件dispatcherServlet-servlet.xml。

五、编写Spring MVC的配置文件

　　由于本例中没有通过 contextConfigLocation 来配置 SpringMVC 的配置文件的位置, 所以使用的是默认的配置文件。默认的配置文件为: /WEB-INF/-servlet.xml。下面我们需要在WEB-INF路径下创建一个名为dispatcherServlet-servlet.xml的文件，编写SpringMVC的配置文件即对dispatcherServlet-servlet.xml文件的编写。
　
　　对dispatcherServlet-servlet.xml文件的编写，主要是：
　　1、配置自动扫描的包，需要交给Spring MVC管理的类。
　　2、配置视图解析器，方便页面返回（看情况）。
　　3、两个标准配置，如下：
　　

<mvc:default-servlet-handler/>
<mvc:annotation-driven/>

　　4、 Spring MVC的文件上传（可选）
　　

    <bean id="multipartResolver" class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
        <property name="maxUploadSize" value="10485760"/> 
        <property name="maxInMemorySize" value="4096" />
        <property name="defaultEncoding" value="UTF-8">property>
    bean>

　　dispatcherServlet-servlet.xml 的示例代码以及其中的注释如下：
　　

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

    

    
    <context:component-scan base-package="com.ssm.controller" use-default-filters="false">
        
        <context:include-filter type="annotation"
                                expression="org.springframework.stereotype.Controller"/>
    context:component-scan>


    
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <property name="prefix" value="/WEB-INF/views/">property>
        <property name="suffix" value=".jsp">property>
    bean>

    
    
    <mvc:default-servlet-handler/>
    

    
    
    <mvc:annotation-driven/>


    
    <bean id="multipartResolver" class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
        <property name="maxUploadSize" value="10485760"/> 
        <property name="maxInMemorySize" value="4096" />
        <property name="defaultEncoding" value="UTF-8">property>
    bean>

beans>

注：此配置文件不能照抄， 需要根据实际的项目做相应的修改：
　　　　1、base-package所对应包的具体位置。
　　　　2、视图解析器的prefix和suffix的value值。
　　　　其次Spring MVC文件上传的配置本例没有用到。

六、编写Spring的配置文件

　　在web.xml中配置的Spring的配置文件为类路径下的applicationContext.xml，所以需要在类路径下创建一个applicationContext.xml文件，并完成对其的编写。

　　编写Spring的配置文件，主要配置和业务逻辑有关的。
　　1、配置自动扫描的包，需要交给Spring管理的类。
　　2、数据源。
　　3、事务控制。
　　4、与mybatis的整合。
　　
　applicationContext.xml 的示例代码以及其中的注释如下：
　

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

    
    

    
    <context:component-scan base-package="com.ssm">
        <context:exclude-filter
                type="annotation"
                expression="org.springframework.stereotype.Controller" />
    context:component-scan>

    
    <context:property-placeholder location="classpath:db.properties" />

    
    
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="jdbcUrl" value="${jdbc.jdbcUrl}">property>
        <property name="driverClass" value="${jdbc.driverClass}">property>
        <property name="user" value="${jdbc.user}">property>
        <property name="password" value="${jdbc.password}">property>
    bean>

    
    <aop:aspectj-autoproxy/>

    
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        
        <property name="dataSource" ref="dataSource">property>
        
        <property name="rollbackOnCommitFailure" value="true"/>
    bean>

    
    <tx:annotation-driven transaction-manager="transactionManager"/>
    
    <aop:config>
        
        <aop:pointcut expression="execution(* com.ssm.service..*(..))" id="txPoint"/>
        
        <aop:advisor advice-ref="txAdvice" pointcut-ref="txPoint"/>
    aop:config>

    
    <tx:advice id="txAdvice" transaction-manager="transactionManager">
        <tx:attributes>
            
            <tx:method name="*"/>
            
            <tx:method name="get*" read-only="true"/>
        tx:attributes>
    tx:advice>

    
    
    <bean id="sqlSessionFactoryBean" class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="dataSource">property>
        
        <property name="configLocation" value="classpath:mybatis-config.xml">property>
        
        <property name="mapperLocations" value="classpath:mapper/*.xml">property>
    bean>

    
    <bean id="sqlSession" class="org.mybatis.spring.SqlSessionTemplate">
        <constructor-arg name="sqlSessionFactory" ref="sqlSessionFactoryBean">constructor-arg>
        <constructor-arg name="executorType" value="BATCH">constructor-arg>
    bean>

    
    <mybatis-spring:scan base-package="com.ssm.dao"/>

beans>

　　在Spring的配置文件里面， 使用 引用了外部数据库的配置文件，类路径下的db.properties代码如下：
　　

jdbc.jdbcUrl=jdbc:mysql://localhost:3306/ssm
jdbc.driverClass=com.mysql.jdbc.Driver

jdbc.user=root
jdbc.password=1234

　　在创建SqlSessionFactory对象的时候，使用configLocation属性指定了全局配置文件（mybatis-config.xml）的位置，使用mapperLocations:属性指定了mapper文件的位置。mybatis-config.xml文件配置了一些MyBaits的全局属性与基本设置，示例代码如下：
　　

<configuration>
    <settings>
        
        <setting name="mapUnderscoreToCamelCase" value="true"/>
        <setting name="jdbcTypeForNull" value="NULL"/>
        
        <setting name="logImpl" value="STDOUT_LOGGING" />
        
        <setting name="cacheEnabled" value="true"/>
    settings>

    
    <plugins>
        <plugin interceptor="com.github.pagehelper.PageInterceptor">
            
            
        plugin>
    plugins>

    <databaseIdProvider type="DB_VENDOR">
        <property name="MySQL" value="mysql"/>
        <property name="Oracle" value="oracle"/>
    databaseIdProvider>

configuration>

注1：此配置文件不能照抄， 需要根据实际的项目做相应的修改：
　　　　1、base-package所对应包的具体位置。
　　　　2、创建SqlSessionFactory对象的时候，mapperLocations 所指定mapper文件的具体位置。
　　　　3、扫描所有的mapper接口的实现，使用base-package:指定mapper接口的包名。
　　　　
注2： 在配置扫描器，将mybatis接口的实现加入到ioc容器中的时候，除了上面的写法，如下：

    
    <mybatis-spring:scan base-package="com.ssm.dao"/>

也可以这样写，一些老的项目会有这样写的，如下：

    
    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        
        <property name="basePackage" value="com.ssm.dao">property>
    bean>

注3： 在Spring的配置文件中，我们还配置了Spring的事物管理，以及开启了基于AspectJ注解的方式来配置AOP。如果需要了解Spring的事物管理，传送门：
　　Spring框架（三）——AOP
　　Spring框架（四）——Spring中的事务管理

　　到此，SSM框架的基本整合就差不多了，接下来我们来编写测试代码。

七、测试

　　在编写好了一系列的配置文件之后，我们来编写测试的代码。
　　需求：
　　1）编写一个接口，用来获取数据库中部门id为2的员工。入参为dId,通过json将查询的结果返回。
　　2）编写一个接口，用来获取数据库中部门id为2的员工。入参为dId,返回jsp页面。
　　项目的代码结构如下所示：

一、根据数据库中的属性编写Employee的实体类

public class Employee {
    private Integer empId;
    private String empName;
    private String email;
    private String gender;
    private Integer dId;

    public Employee() {
    }

    public Employee(Integer empId, String empName, String email, String gender, Integer dId) {
        this.empId = empId;
        this.empName = empName;
        this.email = email;
        this.gender = gender;
        this.dId = dId;
    }

    public Integer getEmpId() {
        return empId;
    }

    public void setEmpId(Integer empId) {
        this.empId = empId;
    }

    public String getEmpName() {
        return empName;
    }

    public void setEmpName(String empName) {
        this.empName = empName;
    }

    public String getEmail() {
        return email;
    }

    public void setEmail(String email) {
        this.email = email;
    }

    public String getGender() {
        return gender;
    }

    public void setGender(String gender) {
        this.gender = gender;
    }

    public Integer getdId() {
        return dId;
    }

    public void setdId(Integer dId) {
        this.dId = dId;
    }
}

二、DAO层代码的编写
　　DAO层主要是做数据持久层的工作，负责与数据库进行联络的一些任务都封装在此，DAO层的设计首先是设计DAO的接口，然后在Spring的配置文件中定义此接口的实现类（本例是配置mapper文件），然后就可在模块中调用此接口来进行数据业务的处理，而不用关心此接口的具体实现类是哪个类，显得结构非常清晰，DAO层的数据源配置，以及有关数据库连接的参数都在Spring的配置文件中进行配置。
　　DAO层代码的编写主要是对EmployeeMapper接口类与EmployeeMapper.xml配置文件的编写。
　　
　　EmployeeMapper接口类的示例代码如下：
　　

public interface EmployeeMapper {
    List getEmpList(@Param("dId") Integer dId);
}

　　mapper/EmployeeMapper.xml文件的示例代码如下：
　　

<mapper namespace="com.ssm.dao.EmployeeMapper">

  <select id="getEmpList" parameterType="Integer" resultType="com.ssm.pojo.Employee" >
    SELECT *
    FROM tbl_emp
    WHERE d_id = #{dId}
  select>
mapper>

三、Service层代码的编写
　　Service层主要负责业务模块的逻辑应用设计。同样是首先设计接口，再设计其实现的类，接着再Spring的配置文件中配置其实现的关联。这样我们就可以在应用中调用Service接口来进行业务处理。Service层的业务实现，具体要调用到已定义的Dao层的接口，封装Service层的业务逻辑有利于通用的业务逻辑的独立性和重复利用性，程序显得非常简洁。
　　Service层是建立在DAO层之上的，建立了DAO层后才可以建立Service层，而Service层又是在Controller层之下的，因而Service层应该既调用DAO层的接口，又要提供接口给Controller层的类来进行调用，它刚好处于一个中间层的位置。每个模型都有一个Service接口，每个接口分别封装各自的业务处理方法。
　
　　Service层部分示例代码如下：
　　

public interface IEmployeeService {
    List getEmpList(int dId);
}

@Service("iEmployeeService")
public class EmployeeServiceImpl implements IEmployeeService {

    @Autowired
    private EmployeeMapper employeeMapper;
    @Override
    public List getEmpList(int dId) {
        List empList = employeeMapper.getEmpList(dId);
        return empList;
    }
}

四、Controller层代码的编写
　　Controller层负责具体的业务模块流程的控制，在此层里面要调用Service层的接口来控制业务流程，控制的配置也同样是在Spring的配置文件里面进行，针对具体的业务流程，会有不同的控制器，我们具体的设计过程中可以将流程进行抽象归纳，设计出可以重复利用的子单元流程模块，这样不仅使程序结构变得清晰，也大大减少了代码量。
　　
　　Controller层部分示例代码如下：

@Controller
@RequestMapping("emp")
public class EmployeeController {

    @Autowired
    private IEmployeeService iEmployeeService;

    /**
     * 获取数据库中部门id为dId的员工。
     * 入参为`dId`,通过json将查询的结果返回。
     * @param dId
     * @return
     */
    @RequestMapping("list")
    @ResponseBody
    public Map getEmpList(@RequestParam("dId") Integer dId){
        Map empMap = new HashMap<>();
        List empList = iEmployeeService.getEmpList(dId);
        empMap.put("empList", empList);
        empMap.put("code", "200");
        empMap.put("message", "查询成功");
        return empMap;
    }

    /**
     * 获取数据库中部门id为dId的员工。
     * 入参为`dId`,返回jsp页面。
     * @param dId
     * @param map
     * @return
     */
    @RequestMapping("view")
    public String getEmpView(@RequestParam("dId") Integer dId,Map map){

        List empList = iEmployeeService.getEmpList(dId);
        map.put("allEmps", empList);
        return "emp";
    }
}

五、View层代码的编写

　　View层：此层与控制层结合比较紧密，需要二者结合起来协同工发。View层主要负责前台jsp页面的显示。

　　View层部分示例代码如下：

<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>EMPLOYEE LISTtitle>
    <table>
        <tr>
            <td>empIdtd>
            <td>empNametd>
            <td>emailtd>
            <td>gendertd>
        tr>
        <c:forEach items="${allEmps}" var="emp">
            <tr>
                <td>${emp.empId}td>
                <td>${emp.empName}td>
                <td>${emp.email}td>
                <td>${emp.gender}td>
            tr>
        c:forEach>

    table>
head>
<body>

body>
html>

　　OK，测试代码终于编写完成。接下来配置Tomcat服务器，将项目发布到Tomcat服务器上。查看控制台Tomcat是否正常启动后，在浏览器输入以下地址http://localhost:8080/emp/view?dId=2可以看到服务器返回的jsp页面。

　　在浏览器输入http://localhost:8080/emp/list?dId=2可以得到服务器返回的json数据。

　　OK，Spring+Spring MVC+MyBatis的整合结束，一个简单的Web框架搭建完成。