SSMSSM整合步骤和流程细化

Posted 假正经的小柴

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了SSMSSM整合步骤和流程细化相关的知识，希望对你有一定的参考价值。

整合SSM

参考文献

卤蛋的SSM整合完整流程讲解

一、SSM整合前概述

1. 各个框架在三层架构模式中所担任的角色

  • SpringMVC：表示层（Web），处理浏览器端发送给服务器端的请求，完成业务逻辑层（Service）与持久化层（DAO）进行数据交互时得到的信息响应给浏览器。
  • Spring：整合型框架，通过IOC容器去管理对象，通过AOP去实现将业务逻辑程序和其他程序（日志、事务管理等）分离。
  • Mybatis：持久化层（DAO），连接数据库、操纵数据库、查询数据库数据。

SpringMVC 是 Spring 家族中的一个框架，可以选择整合，也可以选择不整合，不整合就是指 Spring 和 SpringMVC 创建了同一个 IOC 容器，整合是指 Spring 和 SpringMVC 各自创建自己的 IOC 容器，管理各自的组件。（建议整合）

  • 两个 IOC 容器如何关联呢？
    • SpringMVC 是子容器，Spring 是父容器，子容器可以访问父容器中的 Bean，父容器访问不了子容器（借鉴上述文章的，小编还没细看源码）。

2. 两个IOC容器的创建

SpringMVC 是管理表示层（Web）的组件，其他组件是交给 Spring 去管理，表示层依赖于Service组件，这里需要进行自动装配对该组件进行注入，即需要从IOC容器中获取，上面解释了SpringMVC这个子容器可以访问Spring这个父容器的Bean。
而对Service组件进行装配是在表示层的，应该从 SpringMVC 容器中获取，那么Spring 创建 IOC 容器要先于SpringMVC 的创建时间，才能完成自动装配。

而小编在学Spring的时候，不管是使用注解式注入，还是使用配置式注入，都得通过一行代码去将对象交给 IOC 容器管理（针对singleton范围的）。也就是说Spring创建 IOC 是有代码的。

ApplicationContext applicationContext = new ClassPathXmlApplicationContext(??);
或
ApplicationContext applicationContext = new AnnotationConfigApplicationContext(??);
  1. Spring的IOC容器要创建在SpringMVC的前面；
  2. Spring去创建IOC容器是有代码的。

1）整合时Spring中IOC容器的创建时间

Tomcat服务器提供了三大组件：监听器，过滤器，Servlet。这三大组件的执行顺序为：监听器，过滤器，Servlet。

SpringMVC 中 IOC 容器的创建是在其核心组件DispatcherServlet初始化的时候创建的，根据自下往上的排除法，可以猜测 Spring 要先创建IOC容器的话，很可能就发生在过滤器或者监听器这俩大组件中（因为是Spring提供的整合，所以也排除在DispatcherServlet生命周期中创建）。

过滤器中有俩次过滤，一次是对请求的过滤，执行doFilter方法之前，一次是响应的过滤，执行doFilter方法之后。如果把对Spring IOC容器创建的代码放在过滤器中，缺点很多：

  1. 与其过滤器这个组件作用不符；
  2. doFilter方法用不上，被浪费；
  3. 不利于开发者理解。

所以可以考虑使用监听器进行实现。

2）Spring提供的监听器（ContextLoaderListener）

监听器的种类挺多，但根据 Tomcat 运行Servlet的执行顺序，符合要求的只有 ServletContextListener 一个。

为什么这么说？ServletContextListener，顾名思义是去监听ServletContext对象的，它作为WebApp中的上下文对象，其中的初始化参数可以被这整个应用去使用。之所以说它符合要求，首先是一个webapp就一个ServletContext对象，还有就是和它的以下运行流程有关：

  • 启动一个WEB项目的时候,容器(如:Tomcat)会去读它的配置文件web.xml.读两个节点: < listener > < /listener > 和 < context-param></ context-param>
  • 然后创建ServletContext对象
  • 然后就将context-param中配置的转换成键值对转交给ServletContext对象，对ServletContext对象进行初始化
  • 再然后就去创建 listener 标签下的监听器，该监听器必须实现 ServletContextListener 接口
  • 监听器监听到ServletContext 进行了初始化，就会执行对应重写的contextInitialized方法，下面是ServletContextListener接口中的方法（监听器可以通过其事件参数，通过event.getServletContext()获取ServletContext对象，然后获取其初始化参数，然后进行操作）
public interface ServletContextListener extends EventListener 
    void contextInitialized(ServletContextEvent var1);
 
    void contextDestroyed(ServletContextEvent var1);

下面再看看 ContextLoaderListener 监听器的实现，一切都变得清晰起来了。

public class ContextLoaderListener extends ContextLoader implements ServletContextListener 
    public ContextLoaderListener() 
    
 
    public ContextLoaderListener(WebApplicationContext context) 
        super(context);
    
 
    public void contextInitialized(ServletContextEvent event) 
        this.initWebApplicationContext(event.getServletContext());
    
 
    public void contextDestroyed(ServletContextEvent event) 
        this.closeWebApplicationContext(event.getServletContext());
        ContextCleanupListener.cleanupAttributes(event.getServletContext());

当 Tomcat 去解析 web.xml ，启动项目然后创建 ServletContext 对象进行初始化后，就会去执行这个 initWebApplicationContext 方法，见方法名知其意，这就是先去创建 Spring IOC 容器的实现。

随后为什么要在web.xml 中配置以下内容也很清晰了：

	<listener>
        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
    </listener>
 
    <!--设置spring配置文件自定义的位置和名称-->
    <context-param>
        <param-name>contextConfigLocation</param-name>
        <!--这里是小编将spring配置分成了俩，一个配置mybatis的，是spring-mapper.xml，然后下面的spring-service.xml导入了上面的那个，所以...-->
        <!--名字没关系，只要对应的上就行-->
        <param-value>classpath:spring-service.xml</param-value>
    </context-param>

二、SSM整合步骤

1）建库建表（这个由于是整合练习，可以按照自己的需求进行建库建表）

2）新建maven项目，选择webapp模块

3）修改目录，新建目录，如下所示：

4）修改 pom.xml文件（添加以下依赖，下面只是提供了整合依赖，如果需要其他具体实现，比如aspects，jdbc事务，jsp依赖，分页操作…都得另外配置依赖）

<dependencies>
<!--添加spring的测试依赖-->
  <dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>4.13</version>
    <scope>test</scope>
  </dependency>
  <dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-test</artifactId>
    <version>5.2.5.RELEASE</version>
  </dependency>

  <!--spring-context和spring-beans依赖-->
  <!--spring-context依赖本身就依赖spring-beans-->
  <!--所以只需要配置spring-context依赖即可-->
  <dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context</artifactId>
    <version>$spring.version</version>
  </dependency>
  <!--springmvc依赖-->
  <dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-webmvc</artifactId>
    <version>$spring.version</version>
  </dependency>
  <!--mybatis核心-->
  <dependency>
    <groupId>org.mybatis</groupId>
    <artifactId>mybatis</artifactId>
    <version>3.5.11</version>
  </dependency>

  <!--数据库连接池-->
  <dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>druid</artifactId>
    <version>1.2.16</version>
  </dependency>
  <!--mysql驱动-->
  <dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>8.0.31</version>
  </dependency>
、<!--Tomcat10的Servlet依赖-->
  <dependency>
    <groupId>org.apache.tomcat</groupId>
    <artifactId>tomcat-servlet-api</artifactId>
    <version>10.1.0</version>
  </dependency>
  <dependency>

  <!--mybatis和spring的整合包-->
  <dependency>
    <groupId>org.mybatis</groupId>
    <artifactId>mybatis-spring</artifactId>
    <version>2.0.6</version>
  </dependency>
  <!--jackson依赖，springmvc框架默认进行JSON转换的依赖工具-->
  <dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-databind</artifactId>
    <version>2.14.2</version>
  </dependency>
</dependencies>

5）添加jdbc.properties

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

6）添加mybatis-config.xml文件,其他一些mybatis主要配置可以在spring配置SqlSessionFactoryBean时进行配置。

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>

    <settings>
        <!--驼峰命名自动映射，默认false-->
        <setting name="mapUnderscoreToCamelCase" value="false"/>
        <setting name="lazyLoadingEnabled" value="true"/>
        <setting name="logImpl" value="STDOUT_LOGGING"/>
    </settings>

</configuration>

7）添加spring-mapper.xml文件

<!--读取属性文件-->
<context:property-placeholder location="classpath:jdbc.properties"/>
<!--配置数据源-->
<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
       <property name="driverClassName" value="$jdbc.driver"/>
        <property name="url" value="$jdbc.url"/>
    <property name="name" value="$jdbc.username"/>
    <property name="password" value="$jdbc.password"/>
</bean>
<!--配置SqlSessionFactoryBean-->
<bean class="org.mybatis.spring.SqlSessionFactoryBean">
    <!--配置数据源-->
    <property name="dataSource" ref="dataSource"/>
    <!--配置mybatis-config.xml核心配置-->
    <property name="configLocation" value="classpath:mybatis-config.xml"/>
    <!--注册实体类-->
    <property name="typeAliasesPackage" value="com.ncpowernode.bean"/>
</bean>
<!--注册mapper.xml文件-->
<bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
    <property name="basePackage" value="com.ncpowernode.controller"/>
</bean>

8）添加spring-service.xml文件，因为没有使用事务，这个不添加也没关系，但是这个包扫描就得添加到上面去。

<import resource="spring-mapper.xml"/>
<!--添加包扫描-->
<context:component-scan base-package="com.ncpowernode.service"/>
<!--添加事务管理器-->
<bean id="tx" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    <property name="dataSource" ref="dataSource"/>
</bean>
<!--启动事务注解-->
<tx:annotation-driven transaction-manager="tx"/>

9）添加springmvc.xml文件

<!--添加包扫描-->
<context:component-scan base-package="com.ncpowernode.controller"/>
<!--添加注解驱动-->
<!--使用@ResponseBody注解需要-->
<!--添加就对了-->
<mvc:annotation-driven/>

10）在web.xml文件中注册springmvc框架（添加DispatcherServlet），注册spring框架（全局配置，监听器）

    <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:springmvc.xml</param-value>
        </init-param>
    </servlet>
    <servlet-mapping>
        <servlet-name>dispatcherServlet</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>

    <!--注册spring框架，目的就是先启动Spring容器-->
    <listener>
        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
    </listener>
    <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>classpath:spring-service.xml</param-value>
    </context-param>
</web-app>

11）整合配置结束，开始写Java程序，由于所建的数据库，所建的表不一致，下面我就直接给出小编所写类，类中所用注解，测试。

以上测试可以证明sm整合成功。


以上测试说明ss整合成功，即ssm整合成功。

ssmssm的maven工程整合（超详细步骤）

spring、SpringMVC和Mybatis

使用框架都是较新的版本：

Spring 4.0.2 RELEASE
Spring MVC 4.0.2 RELEASE
MyBatis 3.2.6

项目基本安排

1.1、Maven引入需要的JAR包
pom.xml

<properties>  
        <!-- spring版本号 -->  
        <spring.version>4.0.2.RELEASE</spring.version>  
        <!-- mybatis版本号 -->  
        <mybatis.version>3.2.6</mybatis.version>  
        <!-- log4j日志文件管理包版本 -->  
        <slf4j.version>1.7.7</slf4j.version>  
        <log4j.version>1.2.17</log4j.version>  
    </properties>  

    <dependencies>  
        <dependency>  
            <groupId>junit</groupId>  
            <artifactId>junit</artifactId>  
            <version>4.11</version>  
            <!-- 表示开发的时候引入，发布的时候不会加载此包 -->  
            <scope>test</scope>  
        </dependency>  
        <!-- spring核心包 -->  
        <dependency>  
            <groupId>org.springframework</groupId>  
            <artifactId>spring-core</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-oxm</artifactId>  
            <version>$spring.version</version>  
        </dependency>  
        <dependency>  
            <groupId>org.springframework</groupId>  
            <artifactId>spring-tx</artifactId>  
            <version>$spring.version</version>  
        </dependency>  

        <dependency>  
            <groupId>org.springframework</groupId>  
            <artifactId>spring-jdbc</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-aop</artifactId>  
            <version>$spring.version</version>  
        </dependency>  

        <dependency>  
            <groupId>org.springframework</groupId>  
            <artifactId>spring-context-support</artifactId>  
            <version>$spring.version</version>  
        </dependency>  

        <dependency>  
            <groupId>org.springframework</groupId>  
            <artifactId>spring-test</artifactId>  
            <version>$spring.version</version>  
        </dependency>  
        <!-- mybatis核心包 -->  
        <dependency>  
            <groupId>org.mybatis</groupId>  
            <artifactId>mybatis</artifactId>  
            <version>$mybatis.version</version>  
        </dependency>  
        <!-- mybatis/spring包 -->  
        <dependency>  
            <groupId>org.mybatis</groupId>  
            <artifactId>mybatis-spring</artifactId>  
            <version>1.2.2</version>  
        </dependency>  
        <!-- 导入java ee jar 包 -->  
        <dependency>  
            <groupId>javax</groupId>  
            <artifactId>javaee-api</artifactId>  
            <version>7.0</version>  
        </dependency>  
        <!-- 导入Mysql数据库链接jar包 -->  
        <dependency>  
            <groupId>mysql</groupId>  
            <artifactId>mysql-connector-java</artifactId>  
            <version>5.1.30</version>  
        </dependency>  
        <!-- 导入dbcp的jar包，用来在applicationContext.xml中配置数据库 -->  
        <dependency>  
            <groupId>commons-dbcp</groupId>  
            <artifactId>commons-dbcp</artifactId>  
            <version>1.2.2</version>  
        </dependency>  
        <!-- JSTL标签类 -->  
        <dependency>  
            <groupId>jstl</groupId>  
            <artifactId>jstl</artifactId>  
            <version>1.2</version>  
        </dependency>  
        <!-- 日志文件管理包 -->  
        <!-- log start -->  
        <dependency>  
            <groupId>log4j</groupId>  
            <artifactId>log4j</artifactId>  
            <version>$log4j.version</version>  
        </dependency>  


        <!-- 格式化对象，方便输出日志 -->  
        <dependency>  
            <groupId>com.alibaba</groupId>  
            <artifactId>fastjson</artifactId>  
            <version>1.1.41</version>  
        </dependency>  


        <dependency>  
            <groupId>org.slf4j</groupId>  
            <artifactId>slf4j-api</artifactId>  
            <version>$slf4j.version</version>  
        </dependency>  

        <dependency>  
            <groupId>org.slf4j</groupId>  
            <artifactId>slf4j-log4j12</artifactId>  
            <version>$slf4j.version</version>  
        </dependency>  
        <!-- log end -->  
        <!-- 映入JSON -->  
        <dependency>  
            <groupId>org.codehaus.jackson</groupId>  
            <artifactId>jackson-mapper-asl</artifactId>  
            <version>1.9.13</version>  
        </dependency>  
        <!-- 上传组件包 -->  
        <dependency>  
            <groupId>commons-fileupload</groupId>  
            <artifactId>commons-fileupload</artifactId>  
            <version>1.3.1</version>  
        </dependency>  
        <dependency>  
            <groupId>commons-io</groupId>  
            <artifactId>commons-io</artifactId>  
            <version>2.4</version>  
        </dependency>  
        <dependency>  
            <groupId>commons-codec</groupId>  
            <artifactId>commons-codec</artifactId>  
            <version>1.9</version>  
        </dependency>  


    </dependencies>

1.2、Spring与MyBatis的整合
所有需要的JAR包都引入以后，首先进行Spring与MyBatis的整合，然后再进行JUnit测试，先看一个项目结构图：

1.2.1、建立JDBC属性文件
jdbc.properties（文件编码修改为utf-8）

driver=com.mysql.jdbc.Driver  
url=jdbc:mysql://127.0.0.1:3306/ssm  
username=root  
password=root  
#定义初始连接数  
initialSize=0  
#定义最大连接数  
maxActive=20  
#定义最大空闲  
maxIdle=20  
#定义最小空闲  
minIdle=1  
#定义最长等待时间  
maxWait=60000

1.2.2、建立spring-mybatis.xml配置文件
这个文件就是用来完成spring和mybatis的整合的。这里面也没多少行配置，主要的就是自动扫描，自动注入，配置数据库。注释也很详细，大家看看就明白了。
spring-mybatis.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:p="http://www.springframework.org/schema/p"  
    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-3.1.xsd    
                        http://www.springframework.org/schema/context    
                        http://www.springframework.org/schema/context/spring-context-3.1.xsd    
                        http://www.springframework.org/schema/mvc    
                        http://www.springframework.org/schema/mvc/spring-mvc-4.0.xsd">  
    <!-- 自动扫描 -->  
    <context:component-scan base-package="com.yjq.ssm" />  
    <!-- 引入配置文件 -->  
    <bean id="propertyConfigurer"  
        class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">  
        <property name="location" value="classpath:jdbc.properties" />  
    </bean>  

    <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource"  
        destroy-method="close">  
        <property name="driverClassName" value="$driver" />  
        <property name="url" value="$url" />  
        <property name="username" value="$username" />  
        <property name="password" value="$password" />  
        <!-- 初始化连接大小 -->  
        <property name="initialSize" value="$initialSize"></property>  
        <!-- 连接池最大数量 -->  
        <property name="maxActive" value="$maxActive"></property>  
        <!-- 连接池最大空闲 -->  
        <property name="maxIdle" value="$maxIdle"></property>  
        <!-- 连接池最小空闲 -->  
        <property name="minIdle" value="$minIdle"></property>  
        <!-- 获取连接最大等待时间 -->  
        <property name="maxWait" value="$maxWait"></property>  
    </bean>  

    <!-- spring和MyBatis完美整合，不需要mybatis的配置映射文件 -->  
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">  
        <property name="dataSource" ref="dataSource" />  
        <!-- 自动扫描mapping.xml文件 -->  
        <property name="mapperLocations" value="classpath:com/yjq/ssm/mapper/*.xml"></property>  
    </bean>  

    <!-- DAO接口所在包名，Spring会自动查找其下的类 -->  
    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">  
        <property name="basePackage" value="com.yjq.ssm.dao" />  
        <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory"></property>  
    </bean>  

    <!-- (事务管理)transaction manager, use JtaTransactionManager for global tx -->  
    <bean id="transactionManager"  
        class="org.springframework.jdbc.datasource.DataSourceTransactionManager">  
        <property name="dataSource" ref="dataSource" />  
    </bean>  

</beans>

1.2.3、Log4j的配置
log4j.properties

#定义LOG输出级别  
log4j.rootLogger=INFO,Console,File  
#定义日志输出目的地为控制台  
log4j.appender.Console=org.apache.log4j.ConsoleAppender  
log4j.appender.Console.Target=System.out  
#可以灵活地指定日志输出格式，下面一行是指定具体的格式  
log4j.appender.Console.layout = org.apache.log4j.PatternLayout  
log4j.appender.Console.layout.ConversionPattern=[%c] - %m%n  

#文件大小到达指定尺寸的时候产生一个新的文件  
log4j.appender.File = org.apache.log4j.RollingFileAppender  
#指定输出目录  
log4j.appender.File.File = logs/ssm.log  
#定义文件最大大小  
log4j.appender.File.MaxFileSize = 10MB  
# 输出所以日志，如果换成DEBUG表示输出DEBUG以上级别日志  
log4j.appender.File.Threshold = ALL  
log4j.appender.File.layout = org.apache.log4j.PatternLayout  
log4j.appender.File.layout.ConversionPattern =[%p] [%dyyyy-MM-dd HH\\:mm\\:ss][%c]%m%n

1.2.4、JUnit测试
经过以上步骤（到4.2.2，log4j不配也没影响），已经完成了Spring和mybatis的整合，这样我们就可以编写一段测试代码来试试是否成功了。

4.2.4.1、创建测试用表
既然需要测试，那么就需要建立在数据库中建立一个测试表，_t是为了体现mybatis的自动驼峰命名。SQL语句为：

DROP TABLE IF EXISTS `user_t`;  

CREATE TABLE `user_t` (  
  `id` int(11) NOT NULL AUTO_INCREMENT,  
  `user_name` varchar(40) NOT NULL,  
  `password` varchar(255) NOT NULL,  
  `age` int(4) NOT NULL,  
  PRIMARY KEY (`id`)  
) ENGINE=InnoDB AUTO_INCREMENT=2 DEFAULT CHARSET=utf8;  

/*Data for the table `user_t` */  

insert  into `user_t`(`id`,`user_name`,`password`,`age`) values (1,'测试','sfasgfaf',24);

1.2.4.2、利用MyBatis Generator自动创建代码
这个可根据表自动创建实体类、MyBatis映射文件以及DAO接口，当然，我习惯将生成的接口名改为IUserDao，而不是直接用它生成的UserMapper。如果不想麻烦就可以不改。完成后将文件复制到工程中。如图：

1.2.4.3、建立Service接口和实现类
IUserService.jave 

package com.yjq.ssm.service;

import com.yjq.ssm.model.UserT;

public interface UserTService   
    public UserT getUserById(int userId);

UserServiceImpl.java

package com.yjq.ssm.service.impl;

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

import com.yjq.ssm.dao.UserTMapper;
import com.yjq.ssm.model.UserT;
import com.yjq.ssm.service.UserTService;

@Service
public class UserTServiceImpl implements UserTService   
    @Autowired
    private UserTMapper userTDao;  

    public UserT getUserById(int userId)   
        return this.userTDao.selectByPrimaryKey(userId);

1.2.4.4、建立测试类

package com.yjq.ssm.test;  

import org.apache.log4j.Logger;
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 com.alibaba.fastjson.JSON;
import com.yjq.ssm.model.UserT;
import com.yjq.ssm.service.UserTService;  

@RunWith(SpringJUnit4ClassRunner.class)     //表示继承了SpringJUnit4ClassRunner类  
@ContextConfiguration(locations = "classpath:spring.xml")  

public class TestMyBatis   
    private static Logger logger = Logger.getLogger(TestMyBatis.class);  
//  private ApplicationContext ac = null;   未引入spring，则需要getbean方式测试
    @Autowired  
    private UserTService userTService = null;  

//  @Before  
//  public void before()   
//      ac = new ClassPathXmlApplicationContext("applicationContext.xml");  
//      userService = (IUserService) ac.getBean("userService");  
//    

    @Test  
    public void test1()   
        UserT user = userTService.getUserById(1);  
        // System.out.println(user.getUserName());  
        // logger.info("值："+user.getUserName());  
        logger.info(JSON.toJSONString(user));

至此，完成Spring和mybatis这两大框架的整合，下面在继续进行SpringMVC的整合。

1.3、整合SpringMVC

1.3.1、配置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:p="http://www.springframework.org/schema/p"  
    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-3.1.xsd    
                        http://www.springframework.org/schema/context    
                        http://www.springframework.org/schema/context/spring-context-3.1.xsd    
                        http://www.springframework.org/schema/mvc    
                        http://www.springframework.org/schema/mvc/spring-mvc-4.0.xsd">  
    <!-- 自动扫描该包，使SpringMVC认为包下用了@controller注解的类是控制器 -->  
    <context:component-scan base-package="com.yjq.ssm.controller" />  
    <!--避免IE执行AJAX时，返回JSON出现下载文件 -->  
    <bean id="mappingJacksonHttpMessageConverter"  
        class="org.springframework.http.converter.json.MappingJacksonHttpMessageConverter">  
        <property name="supportedMediaTypes">  
            <list>  
                <value>text/html;charset=UTF-8</value>  
            </list>  
        </property>  
    </bean>  
    <!-- 启动SpringMVC的注解功能，完成请求和注解POJO的映射 -->  
    <bean  
        class="org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerAdapter">  
        <property name="messageConverters">  
            <list>  
                <ref bean="mappingJacksonHttpMessageConverter" /> <!-- JSON转换器 -->  
            </list>  
        </property>  
    </bean>  
    <!-- 定义跳转的文件的前后缀 ，视图模式配置-->  
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">  
        <!-- 这里的配置我的理解是自动给后面action的方法return的字符串加上前缀和后缀，变成一个 可用的url地址 -->  
        <property name="prefix" value="/WEB-INF/jsp/" />  
        <property name="suffix" value=".jsp" />  
    </bean>  

    <!-- 配置文件上传，如果没有使用文件上传可以不用配置，当然如果不配，那么配置文件中也不必引入上传组件包 -->  
    <bean id="multipartResolver"    
        class="org.springframework.web.multipart.commons.CommonsMultipartResolver">    
        <!-- 默认编码 -->  
        <property name="defaultEncoding" value="utf-8" />    
        <!-- 文件大小最大值 -->  
        <property name="maxUploadSize" value="10485760000" />    
        <!-- 内存中的最大值 -->  
        <property name="maxInMemorySize" value="40960" />    
    </bean>   

</beans>

1.3.2、配置web.xml文件
web.xml

<?xml version="1.0" encoding="UTF-8"?>  
<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_3_0.xsd"  
    version="3.0">  
    <display-name>Archetype Created Web Application</display-name>  
    <!-- Spring和mybatis的配置文件 -->  
    <context-param>  
        <param-name>contextConfigLocation</param-name>  
        <param-value>classpath:spring-mybatis.xml</param-value>  
    </context-param>  
    <!-- 编码过滤器 -->  
    <filter>  
        <filter-name>encodingFilter</filter-name>  
        <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>  
        <async-supported>true</async-supported>  
        <init-param>  
            <param-name>encoding</param-name>  
            <param-value>UTF-8</param-value>  
        </init-param>  
    </filter>  
    <filter-mapping>  
        <filter-name>encodingFilter</filter-name>  
        <url-pattern>/*</url-pattern>  
    </filter-mapping>  
    <!-- Spring监听器 -->  
    <listener>  
        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>  
    </listener>  
    <!-- 防止Spring内存溢出监听器 -->  
    <listener>  
        <listener-class>org.springframework.web.util.IntrospectorCleanupListener</listener-class>  
    </listener>  

    <!-- Spring MVC servlet -->  
    <servlet>  
        <servlet-name>SpringMVC</servlet-name>  
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>  
        <init-param>  
            <param-name>contextConfigLocation</param-name>  
            <param-value>classpath:spring-mvc.xml</param-value>  
        </init-param>  
        <load-on-startup>1</load-on-startup>  
        <async-supported>true</async-supported>  
    </servlet>  
    <servlet-mapping>  
        <servlet-name>SpringMVC</servlet-name>  
        <!-- 此处可以可以配置成*.do，对应struts的后缀习惯 -->  
        <url-pattern>/</url-pattern>  
    </servlet-mapping>  
    <welcome-file-list>  
        <welcome-file>/index.jsp</welcome-file>  
    </welcome-file-list>  

</web-app>

1.3.3、测试

1.3.3.1、新建jsp页面
showUser.jsp
此页面仅输出一下用户名，完成一个完整的简单流程。

<%@ page language="java" import="java.util.*" pageEncoding="utf-8"%>  
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">  
<html>  
  <head>  
    <title>测试</title>  
  </head>  

  <body>  
    $user.userName  
  </body>  
</html>

1.3.3.2、建立UserController类
UserController.java 控制器

package com.yjq.ssm.controller;

import javax.servlet.http.HttpServletRequest;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;

import com.yjq.ssm.model.UserT;
import com.yjq.ssm.service.UserTService;

@Controller
@RequestMapping("/user")
public class UserTController 

    @Autowired
    private UserTService userTService;  

    @RequestMapping("/showUser")  
    public String toIndex(HttpServletRequest request,Model model)  
        int userId = Integer.parseInt(request.getParameter("id"));  
        UserT user = this.userTService.getUserById(userId);  
        model.addAttribute("user", user);  
        return "showUser";

1.3.3.3、部署项目
输入地址：localhost:8080/项目名称/user/showUser?id=1
原文地址：http://blog.csdn.net/zhshulin/article/details/37956105

以上是关于SSMSSM整合步骤和流程细化的主要内容，如果未能解决你的问题，请参考以下文章

ssmssm的maven工程整合（超详细步骤）

spring mvc mybatis 整合 大体步骤

springMVC整合mybatis

MyBatis与Spring整合

mybatis 详解------ mybatis和spring整合

SSM整合步骤