Spring+SpringMVC+MyBatis(SSM)框架整合

本博客主要整理了Spring+SpringMVC+MyBatis+c3p0+ehcache在整合过程的一些细节。

框架简介：

Spring是一个轻量级的控制反转（IoC）和面向切面（aop）的容器框架，同时Spring利用面向AOP的思想对原生web应用的事务处理也提出了优秀的解决方案。

作用：使用Spring的IoC容器来整合其他框架，同时使用Spring来完成web项目中的事务处理

SpringMVC分离了控制器、模型对象、过滤器以及处理程序对象的角色，这样我们就可以随心所欲的配置这些东西。

作用：替代原生web中的Servlet，过滤器等这些交给SpringMVC来进行管理

MyBatis是支持普通SQL查询，存储过程和高级映射的优秀的持久层框架。MyBatis 消除了几乎所有的JDBC代码和参数的手工设置以及结果集的检索。MyBatis 使用简单的 XML或注解用于配置和原始映射，将接口和 Java 的POJOs（Plain Old Java Objects，普通的 Java对象）映射成数据库中的记录。

作用：将接口的实现通过映射文件来实现，将POJO与数据库记录实现映射

EhCache是一个纯Java的进程内缓存框架，具有快速、精干等特点，是Hibernate中默认的CacheProvider。

作用：解决web项目中的缓存问题

c3p0开源的JDBC连接池。

作用：解决web项目中数据库连接的问题

框架整合步骤：

环境搭建：

环境基础（工程，jar包，文件）：

1.创建一个动态的web工程

2.导入相关jar包

数据库连接池包和数据库驱动包

 
   mysql-connector-java-5.1.37-bin.jar（驱动包） 
  
   c3p0-0.9.1.2.jar（c3p0数据库连接池包）

Spring框架包

 
     IOC容器核心包 
    
    spring-beans-4.0.0.RELEASE.jar 
   
    spring-context-4.0.0.RELEASE.jar 
   
    spring-core-4.0.0.RELEASE.jar 
   
    spring-expression-4.0.0.RELEASE.jar 
   
         aop相关的包 
   
    spring-aop-4.0.0.RELEASE.jar 
   
    spring-aspects-4.0.0.RELEASE.jar 
   
         aop增强包 
   
    com.springsource.net.sf.cglib-2.2.0.jar 
   
    com.springsource.org.aopalliance-1.0.0.jar 
   
    com.springsource.org.aspectj.weaver-1.6.8.RELEASE.jar 
   
         jdbc连接和事务控制的包 
   
    spring-jdbc-4.0.0.RELEASE.jar 
   
    spring-orm-4.0.0.RELEASE.jar 
   
    spring-tx-4.0.0.RELEASE.jar 
   
         Spring必备的日志包 
   
    commons-logging-1.1.3.jar

SpringMVC包

         实现web基础包 
   
    spring-web-4.0.0.RELEASE.jar 
  
    spring-webmvc-4.0.0.RELEASE.jar 
  
         在页面写EL表达式的包 
   
    jstl.jar 
  
    standard.jar 
  
         使用json所需要的包 
   
    jackson-annotations-2.1.5.jar 
  
    jackson-core-2.1.5.jar 
  
    jackson-databind-2.1.5.jar 
  
         文件上传下载 
   
    commons-fileupload-1.2.1.jar 
  
    commons-io-2.0.jar 
  
        验证，异常信息处理包 
   
    classmate-0.8.0.jar 
  
    hibernate-validator-5.0.0.CR2.jar 
  
    hibernate-validator-annotation-processor-5.0.0.CR2.jar 
  
    jboss-logging-3.1.1.GA.jar 
  
    validation-api-1.1.0.CR1.jar

MyBatis包（联合查询和ehcache整合）

         MyBatis基础包 
  
    mybatis-3.2.8.jar 
  
    asm-3.3.1.jar 
  
    cglib-2.2.2.jar

日志记录包

    log4j.jar（MyBatis要用）

ehcache包(与mybatis整合)

     ehcache-core-2.6.8.jar 
   
     mybatis-ehcache-1.0.3.jar 
   
          ehcache的日志使用slf4j做的，slf4j是用来整合所有的日志厂商的这样日志的整合就会变得容易了。 
   
     slf4j-api-1.6.1.jar 
   
     slf4j-log4j12-1.6.2.jar 
    
    mybatis与spring整合包 
    
 mybatis-spring-1.2.2.jar

若要添加其他功能，可以增加一些其他的jar包，直接与框架整合即可。

3.建立包结构，并在其中放上一些必要的类以作测试使用

4.创建这几个框架所需要的文件

新建一个资源包conf，专门用来放这些框架的配置文件

Spring的配置文件

MyBatis全局配置文件

SpringMVC配置文件

框架整合配置（编写框架环境配置信息和整合所需要的配置）：

注意：彩色区域表示比较重要的配置

配置Spring环境

①在SpringSpringMVCMyBatis2/WebContent/WEB-INF/web.xml中配置自动初始化容器

配置信息：

       <!-- 初始化ioc容器 --> 
   
       <context-param> 
   
           <param-name>contextConfigLocation</param-name> 
   
           <!--classpath:表示从类路径下开始，这里只需要将spring配置文件的文件名copy过来即可 
   
    配置Spring配置文件所在位置 
   
            --> 
   
           <param-value> 
    classpath:applicationContext.xml</param-value> 
   
       </context-param> 
   
       <listener> 
   
           <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class> 
   
       </listener>

c3p0数据库连接池外部的数据库连接信息

配置信息：

     jdbc.driverClass=com.mysql.jdbc.Driver 
   
     jdbc.jdbcUrl=jdbc:mysql://127.0.0.1:3306/mybatistest?useUnicode=true&amp;characterEncoding=UTF8 
   
     jdbc.user=root 
   
     jdbc.password=123456

②编写Spring配置文件，设置IoC容器的初始化参数，并在这个配置文件中整合其他框架。

其中SpringMVC和Spring不需要整合

 
    <?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:mybatis-spring="http://mybatis.org/schema/mybatis-spring" 
   
        xmlns:aop="http://www.springframework.org/schema/aop" 
   
        xsi:schemaLocation="http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.0.xsd 
   
            http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd 
   
            http://mybatis.org/schema/mybatis-spring http://mybatis.org/schema/mybatis-spring-1.2.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"> 
   
        <!-- 
   
            Spring作用，IOC容器，整合其他框架，提供数据源，事务处理 
   
         --> 
   
        <!-- 开启包扫描，同时来区分Spring和SpringMVC管理的包 
   
              自动扫描所有非控制器的组件 
   
         --> 
   
        <context:component-scan base-package="com.myframe"> 
   
            <!-- 指出哪些注解不扫描，这些注解修饰的POJO由SpringMVC管理 --> 
   
            <context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller"/> 
   
            <context:exclude-filter type="annotation" expression="org.springframework.web.bind.annotation.ControllerAdvice"/> 
   
        </context:component-scan> 
   
        <!-- 配置数据源 
   
                ①引入外部连接数据库的信息 
   
                ②配置这些信息 
   
             spring与c3p0整合
 
        --> 
   
        <context:property-placeholder location="classpath:c3p0-config.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> 
   
        <!-- 使用MyBatis操作数据库，替代以前使用的JdbcTemplate 
   
              spring与myBatis整合，给myBatis框架配置执行环境
 
         --> 
   
        <bean id="sqlSessionFactoryBean" class="org.mybatis.spring.SqlSessionFactoryBean"> 
   
            <!-- 设置MyBatis全局配置文件所在的位置 --> 
   
            <property name="configLocation" value="classpath:mybatis-config.xml"></property> 
   
            <!-- 使用ioc容器管理的数据源 --> 
   
            <property name="dataSource" ref="dataSource"></property> 
   
        </bean> 
   
        <!-- 要想让Spring完成事务控制，必须使用Spring能操作的SqlSession，因此配置下面的SqlSessionTemplate 
   
            并使用上边配置好的工厂来获取SqlSessionTemplate对象 
   
            这个对象就是openSession拿到的那个对象，可以与数据库建立会话 
   
              SqlSessionTemplate和我们openSession拿到的对象功能类似  
   
            可以声明为属性，线程安全 
   
        --> 
   
        <bean id="sqlSession" class="org.mybatis.spring.SqlSessionTemplate"> 
   
            <constructor-arg name="sqlSessionFactory" ref="sqlSessionFactoryBean"></constructor-arg> 
   
        </bean> 
   
         <!--使用SpringMVC完成事务控制 --> 
   
        <!-- 配置事务管理器 --> 
   
        <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager"> 
   
            <property name="dataSource" ref="dataSource"></property> 
   
        </bean> 
   
        <!-- 开启基于注解的事务管理 --> 
   
        <tx:annotation-driven transaction-manager="transactionManager"/> 
   
        <!-- 开启基于注解aop --> 
   
        <aop:aspectj-autoproxy></aop:aspectj-autoproxy> 
   
    </beans>

Spring环境配置完成后：

@Repository @Service注解修饰的都有了小s

配置 SpringMVC环境

①web.xml中配置（前端控制器，解决请求响应乱码，配置RestFul编程环境）

      <!-- 使用SpringMVC框架，配置一个前端控制器来拦截所有请求 --> 
   
       <!-- The front controller of this Spring Web application, responsible for handling all application requests --> 
   
         <servlet> 
   
             <servlet-name>springDispatcherServlet</servlet-name> 
   
             <servlet-class> 
    org.springframework.web.servlet.DispatcherServlet</servlet-class> 
   
             <init-param> 
   
                 <param-name>contextConfigLocation</param-name> 
   
                 <!--设置springMVC配置文件的位置--> 
   
                 <param-value> 
    classpath:springMVC-config.xml</param-value> 
   
             </init-param> 
   
             <load-on-startup>1</load-on-startup> 
   
         </servlet> 
   
         <!-- Map all requests to the DispatcherServlet for handling --> 
   
         <servlet-mapping> 
   
             <servlet-name>springDispatcherServlet</servlet-name> 
   
             <!-- 拦截所有请求，不拦截*.jsp --> 
   
     <url-pattern>/</url-pattern> 
   
         </servlet-mapping> 
   
         <!-- 配置一个Filter来解决请求，响应乱码 (POST请求)GET请求乱码在Servles中server.xml中修改--> 
   
         <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>forceEncoding</param-name> 
   
                <param-value>true</param-value> 
   
            </init-param> 
   
         </filter> 
   
         <filter-mapping> 
   
             <filter-name>CharacterEncodingFilter</filter-name> 
   
             <!-- 拦截所有请求，包含*.jsp --> 
   
    <url-pattern>/*</url-pattern> 
   
         </filter-mapping> 
   
         <!-- 
      
    配置一个支持发送PUT，DELETE请求的filter 
   
          适应RestFul风格的编程 
   
          --> 
   
         <filter> 
   
             <filter-name>HiddenHttpMethodFilter</filter-name> 
   
             <filter-class> 
    org.springframework.web.filter.HiddenHttpMethodFilter</filter-class> 
   
         </filter> 
   
         <filter-mapping> 
   
             <filter-name>HiddenHttpMethodFilter</filter-name> 
   
    <url-pattern>/*</url-pattern> 
   
         </filter-mapping>

GET请求乱码解决方式：

设置位置： Servers\ Tomcat v6.0 Server at localhost-config\server.xml

     64行左右，在此处设置红笔 
   
     <Connector 
     URIEncoding="utf-8" connectionTimeout="20000" port="8080" protocol="HTTP/1.1" redirectPort="8443"/>

②SpringMVC配置文件编写

     <?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:mvc="http://www.springframework.org/schema/mvc" 
   
         xmlns:context="http://www.springframework.org/schema/context" 
   
         xsi:schemaLocation="http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-4.0.xsd 
   
             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-4.0.xsd"> 
   
         <!-- 开启包扫描主要管理控制，拦截相关的包 --> 
   
        <context:component-scan base-package="com.myframe.controller"/> 
   
         <!-- 配置视图解析器 --> 
   
         <bean id="viewResolver" class=" 
    org.springframework.web.servlet.view.InternalResourceViewResolver"> 
   
             <property name="prefix" value="/WEB-INF/"></property> 
   
             <property name="suffix" value=".jsp"></property> 
   
         </bean> 
   
          <!--这两个是标配--> 
   
         <!-- 启动基于注解的mvc --> 
   
    <mvc:annotation-driven/> 
   
         <!-- 当这个解析器解析不了的时候使用默认的servlet --> 
   
    <mvc:default-servlet-handler/> 
   
     </beans>

SpringMVC环境配置完成后 controller包中的POJO加上小s了

MyBatis配置文件编写（配置MyBatis全局环境，Mapper映射文件的编写在测试的时候演示）

<?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">

</settings>

</typeAliases>

</mappers>

</configuration>

配置Ehcache环境（替代MyBatis自己的二级缓存）

配置文件

      <ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
    
        xsi:noNamespaceSchemaLocation="../config/ehcache.xsd"> 
    
        <!--设置缓存保存在硬盘上的位置--> 
    
     <diskStore path="D:\my\encache" /> 
    
       <defaultCache 
     
         maxElementsInMemory="1000" 
     
         maxElementsOnDisk="10000000" 
    
         eternal="false" 
     
         overflowToDisk="false" 
     
         timeToIdleSeconds="120" 
    
         timeToLiveSeconds="120" 
     
         diskExpiryThreadIntervalSeconds="120" 
    
         memoryStoreEvictionPolicy="LRU"> 
    
       </defaultCache> 
    
      </ehcache>

              
      log4j配置文件配置信息 
     
 <?xml version="1.0" encoding="UTF-8"?> 
    
      <!DOCTYPE log4j:configuration SYSTEM "log4j.dtd"> 
    
      <log4j:configuration xmlns:log4j="http://jakarta.apache.org/log4j/"> 
    
       <appender name="STDOUT" class="org.apache.log4j.ConsoleAppender"> 
    
         <param name="Encoding" value="UTF-8" /> 
    
         <layout class="org.apache.log4j.PatternLayout"> 
    
          <param name="ConversionPattern" value="%-5p %d{MM-dd HH:mm:ss,SSS} %m  (%F:%L) \n" /> 
    
         </layout> 
    
       </appender> 
    
       <logger name="java.sql"> 
    
         <level value="debug" /> 
    
       </logger> 
    
       <logger name="org.apache.ibatis"> 
    
         <level value="debug" /> 
    
       </logger> 
    
       <root> 
    
         <level value="debug" /> 
    
         <appender-ref ref="STDOUT" /> 
    
       </root> 
    
      </log4j:configuration>

基本配置信息配置好后，框架环境基本搭建完成。

环境测试（测试环境好使不？）

编写StudentMapper接口

     package com.myframe.mapper; 
   
     import java.util.List; 
   
     import org.springframework.stereotype.Repository; 
   
     import com.myframe.entities.Student; 
   
     //用于测试环境能不能用 
   
     @Repository 
   
     public interface StudentMapper { 
   
         //获取所有学生 
   
         public List<Student> getAll(); 
   
     }

根据这个接口中的方法，创建一个映射文件（实现定义接口的具体过程）

演示映射文件的编写（与EhcachCache整合）

在conf中新建一个包conf\com\myframe\mapper专门来保存映射文件

根据上边的StudentMapper 编写配置文件

 
    <?xml version="1.0" encoding="UTF-8"?> 
   
    <!DOCTYPE mapper 
   
      PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" 
   
      "http://mybatis.org/dtd/mybatis-3-mapper.dtd"> 
   
    <!--整合EhcacheCache配置信息  --> 
   
    <mapper namespace="com.myframe.mapper.StudentMapper"> 
   
        <cache type="org.mybatis.caches.ehcache.EhcacheCache"></cache> 
   
        <sql id="allFileds"> 
   
            id, name, score, birth, age 
   
        </sql> 
   
        <!--对接口的实现--> 
   
        <select id="getAll" resultType="Student"> 
   
            select 
   
                <include refid="allFileds"/> 
   
            from 
   
                tbl_student 
   
        </select> 
   
    </mapper>

创建一个StudentDao来执行mapper

     package com.myframe.dao; 
   
     import java.util.List; 
   
     import org.apache.ibatis.session.SqlSession; 
   
     import org.springframework.beans.factory.annotation.Autowired; 
   
     import org.springframework.stereotype.Repository; 
   
     import com.myframe.entities.Student; 
   
     import com.myframe.mapper.StudentMapper; 
   
     /** 
   
      * 在StudentDao中调用mapper，执行操作 
   
      * @author LENOVO 
   
      * 
   
      */ 
   
    @Repository 
   
     public class StudentDao { 
   
         //自动装配SqlSession对象 
   
    @Autowired 
   
        private SqlSession sqlSession; 
   
         public List<Student> getAll() { 
   
             //获取到映射对象 
   
             StudentMapper mapper = sqlSession.getMapper(StudentMapper.class); 
   
             //执行映射方法 
   
             return mapper.getAll(); 
   
         } 
   
     }

service调Dao

package com.myframe.service;

import java.util.List;

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

import org.springframework.stereotype.Service;

import com.myframe.dao.StudentDao;

import com.myframe.entities.Student;

@Service

public class StudentService {

@Autowired

private StudentDao studentDao;

public List<Student> getAll() {

return studentDao.getAll();

}

SpringMVC框架处理请求（控制器）

package com.myframe.controller;

import java.util.List;

import java.util.Map;

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

import org.springframework.stereotype.Controller;

import org.springframework.web.bind.annotation.RequestMapping;

import com.myframe.entities.Student;

import com.myframe.service.StudentService;

@Controller

public class TestHandle {

@Autowired

private StudentService studentService;

//请求地址

@RequestMapping("/list")

public String getAll(Map<String, Object> map) {

List<Student> stus = studentService.getAll();

map.put("list", stus);

return "list";

}

设置两个页面，实现在浏览器上的简单显示。

通过index.jsp页面发送请求

        <%@ page language="java" contentType="text/html; charset=UTF-8" 
      
            pageEncoding="UTF-8"%> 
      
        <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd"> 
      
        <html> 
      
        <head> 
      
        <meta http-equiv="Content-Type" content="text/html; charset=UTF-8"> 
      
        <title>Insert title here</title> 
      
        </head> 
      
        <body> 
      
            <a 
         
       href="list">查询所有学生</a> 
      
        </body> 
      
        </html>

将响应信息在list.jsp页面显示

         <%@ page language="java" contentType="text/html; charset=UTF-8" 
       
             pageEncoding="UTF-8"%> 
       
         <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd"> 
       
         <html> 
       
         <head> 
       
         <meta http-equiv="Content-Type" content="text/html; charset=UTF-8"> 
       
         <title>Insert title here</title> 
       
         </head> 
       
         <body> 
       
             <h1 align="center">显示所有学生</h1> 
       
        ${requestScope.list} 
       
         </body> 
       
         </html>

基本和原生的web项目调用过程一致，只不过用框架替代了一些手写的部分。

激动人心的时刻

1.启动服务器

2.点击查询所有学生

3.完美的显示所有学生

框架基本搭建完成，可以实现基本的功能。

Spring+SpringMVC+MyBatis(SSM)框架整合

猜你喜欢