本博客主要整理了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,专门用来放这些框架的配置文件
              applicationContext.xml         Spring的配置文件
                mybatis-config.xml       MyBatis全局配置文件
                springMVC-config.xml      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">

 <!-- 配置MyBatis的全局设置,当使用Spring整合后,就不需要配置环境了-->
<configuration>
     <!--开启二级缓存 与EhcachCache整合  -->
     <settings>
        <setting name="cacheEnabled" value="true"/>
    </settings>
    <!-- 别名处理器,批量的加别名,这个包下的所有类的别名是它的类名 -->
    <typeAliases>
        <package name="com.myframe.entities"/>
    </typeAliases>
    <mappers>
       <!--在测试的时候编写接口的映射文件-->
        <!-- 注册映射文件 -->
        <mapper resource="com/myframe/mapper/StudentMapper.xml"/>
    </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   编写配置文件
StudentMapper.xml

<?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.完美的显示所有学生

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

Logo

权威|前沿|技术|干货|国内首个API全生命周期开发者社区

更多推荐