IntelliJ IDEA 14.0.3 实战搭建Spring+SpringMVC+MyBatis组合框架

简介

Spring+SpringMVC+MyBatis框架（SSM）是比较热门的中小型企业级项目开发的框架，对于新手来说也是比较容易学习入门的。虽说容易，但在框架搭建过程中仍然遇到了许多问题，因此用实例记录下来吧。

实践部署

一丶创建一个基础的Spring+Spring-MVC项目:

⑴:File>New Project,由于使用maven管理项目所以创建时我们直接选择创建Maven工程,并勾选“Createe from archetype” 表示使用于模板进行创建。并找到maven-archetype-webapp这个选项并选中在点击下一步(Next);

⑵:配置项目工程名字版本信息等...

GroupId:输入是项目组织唯一的标识符，实际对应JAVA的包的结构，是main目录里java的目录结构。命名规则一般是以公司名字或项目名字的缩写来命名的，但是由于有的时候一个公司不止一个项目，所以就有多种命名规则了。一般来说有两种写法。两级和三级的。两级的就是com.公司名字/项目名字， 三级就是com.公司名字.项目名字缩写。

ArtifactID:就是项目的唯一的标识符，实际对应项目的名称，就是项目根目录的名称

Version:对应的就是工程的版本信息,没有过多要求可以保持默认的。

三个属性都填写后直接下一步(Next)

⑶:配置Maven的引用和本地仓库信息

Maven home directory:对应的就是你计算机上的maven根目录

User settings file:对应的是本地计算机上的maven中的settings.xml配置文件,切记：记得修改为maven根目录里面的\conf文件夹下面的settings.xml，并同时修改settings.xml的本地仓库引用的配置文件。

<localRepository>E:\project\mavenrepository</localRepository>内容对应的就是Local repository中的本地仓库根目录。

<?xml version="1.0" encoding="UTF-8"?>
<settings xmlns="http://maven.apache.org/SETTINGS/1.0.0"
          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
          xsi:schemaLocation="http://maven.apache.org/SETTINGS/1.0.0 http://maven.apache.org/xsd/settings-1.0.0.xsd">
  <localRepository>E:\project\mavenrepository</localRepository>

  <pluginGroups>
  </pluginGroups>

  <proxies>
  </proxies>

</settings>

　　Local repository:本地仓库根目录

所有内容修改完毕直接下一步(Next)

⑷填写项目文件夹名字以及保存路径:

以上内容全部操作完毕后直接点击完成(Finish)。点击完成后IDEA会自动创建工程。由于这里使用了模板创建，所以创建过程会略慢一丢丢。

⑸创建完成后的项目结构图:

我们可以先将项目结构完善下:

注意下:默认创建的项目是没有“java”这个文件夹的，所以我们手动创建文件夹后还需要对文件夹进行一个标记注明,如果不进行权限标注标明的话后面配置你会发现找不到java目录下面的内容的:

点击这个小图标进行项目管理

⑹添加Spring核心XML文件 找到项目根目录点击 “Add Framework Support” 看单词就知道顾名思义说的是添加框架的支持

这里选中Spring 这个选项并选中子项Spring MVC 默认进来会选中“Download”这个单选框，选中这里的话默认就会下载Spring所有的相关架包。但是注意这里是下载架包到并自动创建一个lib的文件夹。这就不是maven托管了好吧。所以这里有几种方法添加Spring支持。

1丶使用默认的“Download”选项 然后点击OK。窗口会弹出一个下载jar支持的过程，这个时候立即取消下载所有选项。但是Spring-config.xml文件还是会生成并自动引用。

2丶使用“Use library”页也是同意的方法，取消下载架包然后自动创建核心文件。

以上两种方法只是解决了自动为项目引用Spring-config.xml核心支撑并生成文件。但是maven中和Spring-config.xml的文件还是没有配置对应的bean。这里注意下：建议创建一个文件夹将配置文件进行归类放置。因为一个项目下来肯定不止一个xml文件

添加完成后可以通过项目管理里面查看配置:

⑺修改项目工程的web.xml配置文件

默认创建后的项目“web.xml”配置文件如下，可能每个IDEA版本不一致创建的默认模板会有小差异

<!DOCTYPE web-app PUBLIC
 "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
 "http://java.sun.com/dtd/web-app_2_3.dtd" >

<web-app>
  <display-name>Archetype Created Web Application</display-name>
</web-app>

　　具体配置内容如下:

<!DOCTYPE web-app PUBLIC
 "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
 "http://java.sun.com/dtd/web-app_2_3.dtd" >

<web-app xmlns="http://java.sun.com/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         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>

    <!--添加log4的日志配置文件-->
    <context-param>
        <param-name>log4jConfigLocation</param-name>
        <param-value>classpath:log4j.properties</param-value>
    </context-param>

    <!-- 编码过滤器 -->
    <filter>
        <filter-name>encodingFilter</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>
    </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内存溢出监听器，比如quartz -->
    <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/spring-config.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 形式 -->
        <url-pattern>*.video</url-pattern>
    </servlet-mapping>

    <welcome-file-list>
        <welcome-file>/index.jsp</welcome-file>
    </welcome-file-list>

    <!-- session配置 -->
    <session-config>
        <session-timeout>15</session-timeout>
    </session-config>
</web-app>

　　可能出现的报错情况:提示async-supported报错，这个原因是这个标签是web.xml 3.0的新特性，但是没有引用新特性的支持。

然后再将xsd加入到web.xml中就搞定了。

<!DOCTYPE web-app PUBLIC
 "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
 "http://java.sun.com/dtd/web-app_2_3.dtd" >

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

⑻添加对应的maven支持，修改pom.xml文件

注意:这里添加了一些log4,mybatis的支持,只是方便后面编写数据持久化的。如果不需要可以不引用添加。就添加<!-- 添加spring核心依赖 -->这块代码注释就好了。

<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.0</modelVersion>
    <groupId>com.david.mvc</groupId>
    <artifactId>testMVC</artifactId>
    <packaging>war</packaging>
    <version>1.0-SNAPSHOT</version>
    <name>testMVC Maven Webapp</name>
    <url>http://maven.apache.org</url>
    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <!--便于后期管理同步版本信息，所以这里架包版本信息使用公共参数,也可以在在架包的引用version写死版本信息，但是不推荐这样使用-->
        <!-- spring版本号 -->
        <spring.version>3.1.1.RELEASE</spring.version>

        <!-- mybatis版本号 -->
        <mybatis.version>3.2.8</mybatis.version>

        <!-- mysql驱动版本号 -->
        <mysql-driver.version>5.1.29</mysql-driver.version>

        <!-- log4j日志包版本号 -->
        <slf4j.version>1.7.18</slf4j.version>
        <log4j.version>1.2.17</log4j.version>

    </properties>

    <dependencies>
        <!-- 添加jstl依赖 -->
        <dependency>
            <groupId>jstl</groupId>
            <artifactId>jstl</artifactId>
            <version>1.2</version>
        </dependency>

        <dependency>
            <groupId>javax</groupId>
            <artifactId>javaee-api</artifactId>
            <version>7.0</version>
        </dependency>

        <!-- 添加junit4依赖 -->
        <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-context</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-aop</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>

        <!-- 添加mysql驱动依赖 -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>${mysql-driver.version}</version>
        </dependency>
        <!-- 添加数据库连接池依赖 -->
        <dependency>
            <groupId>commons-dbcp</groupId>
            <artifactId>commons-dbcp</artifactId>
            <version>1.2.2</version>
        </dependency>

        <!-- 添加fastjson -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.1.41</version>
        </dependency>

        <!-- 添加日志相关jar包 -->
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>${log4j.version}</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>
        <!-- https://mvnrepository.com/artifact/com.fasterxml.jackson.core/jackson-core -->
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-core</artifactId>
            <version>2.8.0</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/com.fasterxml.jackson.core/jackson-databind -->
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-databind</artifactId>
            <version>2.8.0</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>

        <!--创建项目时自动生成的单元测试框架-->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>3.8.1</version>
            <scope>test</scope>
        </dependency>
    </dependencies>
    <build>
        <finalName>testMVC</finalName>
    </build>
</project>

　　⑼配置Spring核心文件的bean标签内容

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

    <!-- 自动扫描  @Controller 配置的就是写action方法的文件夹。如果前面没有为java目录标注的话这里会发现找不到子级目录的，返回前面去配置吧-->
    <context:component-scan base-package="com.david.action"/>
    <!--避免IE执行AJAX时，返回JSON出现下载文件 -->
    <bean id="mappingJacksonHttpMessageConverter"
          class="org.springframework.http.converter.json.MappingJacksonHttpMessageConverter">
        <property name="supportedMediaTypes">
            <list>
                <value>application/json;charset=UTF-8</value>
                <value>text/json</value>
                <value>text/html;charset=UTF-8</value>
                <!--兼容在IE10以上的浏览器正常回传解析json-->
            </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 id="stringHttpMessageConverter" class="org.springframework.http.converter.StringHttpMessageConverter"/>
    <!--在拦截器中将handler对象强转成HandlerMethod类型需要配置如下三个bean 否则会初始化报错-->
    <bean class="org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerAdapter"/>
    <bean class="org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping"/>
    <bean class="org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter">
        <property name="messageConverters">
            <list>
                <ref bean="mappingJacksonHttpMessageConverter"/>
                <ref bean="stringHttpMessageConverter"/>
            </list>
        </property>
    </bean>

    <!-- 定义跳转的文件的前后缀 ，视图模式配置 -->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <property name="prefix" value="/WEB-INF/content/"/>
        <property name="suffix" value=".jsp"/>
    </bean>

    <!-- 文件上传配置 -->
    <bean id="multipartResolver" class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
        <!-- 默认编码 -->
        <property name="defaultEncoding" value="UTF-8"/>
        <!-- 上传文件大小限制为31M，31*1024*1024 -->
        <property name="maxUploadSize" value="32505856"/>
        <!-- 内存中的最大值 -->
        <property name="maxInMemorySize" value="4096"/>
    </bean>

</beans>

二丶基础项目配置完成，使用Tomcat服务器进行运行吧

1、点击最右上角的倒三角按钮，并点击“Edit Configurations...”这个选项，进行编辑配置信息

2、选择对应的启动容器，这里使用Tomcat做例子

3、选择对应的war项目包

4、配置Tomcat相关启动端口 默认8080 其中这里的On ‘Update’ action 和On frame deactivation 这两个地方由于我安装了热部署启动，所以选项不一样。

5、启动Tomcat查看项目

三丶在基础框架上进行添加新的模块

1、添加Spring拦截器

1.1 为什么使用拦截器

拦截器？顾名思义就知道是进行拦截请求的。拦截器的用途有哪些呢？比如你登录银行系统进行查看账户余额，不登录可以直接查看余额和转账操作嘛。当然不行。所以这里就需要用到拦截器，进行登录拦截，看你是不是已登录的用户。还有比如异常拦截，做开发的都知道程序如果报错肯定是会反馈异常的，那这个时候我们如果把异常抛出到前台是可取的嘛。当然也是不行的。所以就还有异常拦截器。那这里为什么要使用spring进行配置拦截器呢。没有使用spring框架时肯定很多拦截我们都是使用if去手动判断，这样的话每一个需要做拦截的方法都要加上一段拦截的相关代码。这样是不是很费时和精力。还不便于代码的后期维护升级。一旦改动拦截规则那所有的地方都需要一一修改。同样是银行系统。我们登录成功后,要进行转账操作。这个时候是不是也是需要进行验证看是否已经登录啊。那难道银行的每一步涉及到用户信息的操作都在每一个方法体中手动加一个if判断验证嘛。这当然不可能的了。

1.2 如何实现拦截器

SpringMVC 中的Interceptor 拦截请求是通过HandlerInterceptor 来实现的。在SpringMVC 中定义一个Interceptor 非常简单，主要有两种方式，第一种方式是要定义的Interceptor类要实现了Spring 的HandlerInterceptor 接口，或者是这个类继承实现了HandlerInterceptor 接口的类，比如Spring 已经提供的实现了HandlerInterceptor 接口的抽象类HandlerInterceptorAdapter ；第二种方式是实现Spring的WebRequestInterceptor接口，或者是继承实现了WebRequestInterceptor的类。更多SpringMVC拦截器相关的内容请点传送门:SpringMVC拦截器传送门

1.3 配置拦截器 登录拦截器/异常拦截器

1.3.1 登录拦截器

一·在spring-config.xml配置中添加bean

<!-- 登陆拦截器-->

<mvc:interceptors>
    <bean class="com.david.utils.interceptors.LoginInterceptor"/>
</mvc:interceptors>

二·自定义一个注解类，用来区分哪些请求方法是需要做拦截器的，哪些是不需要的。

package com.david.utils.interceptors;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * 访问注解： 在方法上加 @Access(true) 表示不做登录拦截
 * Created by Administrator on 2015/6/8.
 */
@Target({ElementType.METHOD, ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
public @interface Access {
    boolean login() default false;
}

三·建一个Class(类)并继承“HandlerInterceptorAdapter”类实现其“preHandle”方法

package com.david.utils.interceptors;

import org.springframework.web.method.HandlerMethod;
import org.springframework.web.servlet.handler.HandlerInterceptorAdapter;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;
import java.lang.reflect.Method;

public class LoginInterceptor extends HandlerInterceptorAdapter {
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        HttpSession session=request.getSession();
        HandlerMethod handlerMethod=(HandlerMethod)handler;
        Method method = handlerMethod.getMethod();
        if(session.getAttribute("globalUser") == null){
            if(method != null){
                Access access =method.getAnnotation(Access.class);
                if(access != null){
                    boolean login = access.login();
                    if(login){
                        return true;
                    }
                }
            }
            response.sendRedirect(request.getContextPath()+"/login.jsp");
            return false;
        }
        return true;
    }
}

注意:在搭建基础框架时已经在spring-config.xml中配置了几个bean,这个几个bean是为了支持这里的拦截器的。如果没有配置请加上以下内容，否则会启动异常。

 <bean id="stringHttpMessageConverter" class="org.springframework.http.converter.StringHttpMessageConverter"/>
    <!--在拦截器中将handler对象强转成HandlerMethod类型需要配置如下三个bean 否则会初始化报错-->
    <bean class="org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerAdapter"/>
    <bean class="org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping"/>
    <bean class="org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter">
        <property name="messageConverters">
            <list>
                <ref bean="mappingJacksonHttpMessageConverter"/>
                <ref bean="stringHttpMessageConverter"/>
            </list>
        </property>
    </bean>

1.3.2 异常拦截器

一·在spring-config.xml配置中添加bean

 <!-- 异常拦截 -->
    <bean id="exceptionResolver" class="com.david.utils.exception.ExceptionForWeb"/>

二.定义一个异常拦截的Class(类)

package com.david.utils.exception;

import org.springframework.web.servlet.HandlerExceptionResolver;
import org.springframework.web.servlet.ModelAndView;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.PrintWriter;
import java.io.StringWriter;

public class ExceptionForWeb  implements HandlerExceptionResolver {
    @Override
    public ModelAndView resolveException(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) {
        StringWriter sw = new StringWriter();
        PrintWriter pw = new PrintWriter(sw);
        ex.printStackTrace(pw);
        //将错误栈输出到页面*开发查看
        request.setAttribute("errorStackTrace",sw.toString());
        return new ModelAndView("error");
    }
}

三.新建一个jsp,用来拦截异常后温柔的显示给用户看

<%@ page contentType="text/html;charset=UTF-8" language="java" isErrorPage="true" %>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
    <title>500页面</title>

<div class="hide error-info">${errorStackTrace}</div>
<script>
    console.log("系统错误信息！");
    console.log($(".error-info").html());
</script>
</body>
</html>

2、添加Spring对MyBatis的数据持久化操作

2.1 使用maven添加对应的jar依赖支持,配置基础框架时已在pom添加对应的引用可以跳过次步骤

  <!-- 添加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.</version>
    </dependency>

    <!-- 添加mysql驱动依赖 -->
    <dependency>
      <groupId>mysql</groupId>
      <artifactId>mysql-connector-java</artifactId>
      <version>${mysql-driver.version}</version>
    </dependency>
    <!-- 添加数据库连接池依赖 -->
    <dependency>
      <groupId>commons-dbcp</groupId>
      <artifactId>commons-dbcp</artifactId>
      <version>1.2.</version>
    </dependency>

2.2新建一个jdbc.properties后缀的属性文件并配置对应的属性key与value

#连接驱动
driverClasss=com.mysql.jdbc.Driver
#数据库链接地址
jdbcUrl=jdbc:mysql://192.168.3.5:3306/testDB?useUnicode=true&characterEncoding=utf-8&zeroDateTimeBehavior=convertToNull
#数据库连接账号
username=root
#数据库连接密码
password=newpwd

#定义初始连接数
initialSize=
#定义最大连接数
maxActive=
#定义最大空闲
maxIdle=
#定义最小空闲
minIdle=
#定义最长等待时间
maxWait=

2.3新建一个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:context="http://www.springframework.org/schema/context" xmlns:tx="http://www.springframework.org/schema/tx"
       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/tx
                        http://www.springframework.org/schema/tx/spring-tx.xsd">

    <!-- 自动扫描  -->
    <context:component-scan base-package="com.david.action"/>

    <!-- 第一种方式：加载一个properties文件 value的内容就是刚刚2.2步骤新建一个jdbc.properties文件引用，如出现引用不成功请注意路径是否正确。最好新建一个文件夹，相关配置文件放置一个文件夹下 -->
    <bean id="propertyConfigurer" class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
        <property name="location" value="classpath:jdbc.properties"/>
    </bean>

    <!-- 第二种方式：加载多个properties文件
    <bean id="configProperties" class="org.springframework.beans.factory.config.PropertiesFactoryBean">
        <property name="locations">
            <list>
                <value>classpath:jdbc.properties</value>
                <value>classpath:common.properties</value>
            </list>
        </property>
        <property name="fileEncoding" value="UTF-8"/>
    </bean>
    <bean id="propertyConfigurer" class="org.springframework.beans.factory.config.PreferencesPlaceholderConfigurer">
        <property name="properties" ref="configProperties"/>
    </bean>
    -->

    <!-- 配置数据源 -->
    <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource"
          destroy-method="close">
        <property name="driverClassName" value="${driverClasss}"/>
        <property name="url" value="${jdbcUrl}"/>
        <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>

    <!-- mybatis和spring完美整合，不需要mybatis的配置映射文件 -->
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="dataSource"/>
        <!-- 自动扫描mapping.xml文件 value的内容就是你的dao层下的sql xml文件 -->
        <property name="mapperLocations" value="classpath:mapping/*.xml"></property>
    </bean>

    <!-- DAO接口所在包名，Spring会自动查找其下的类 -->
    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <property name="basePackage" value="com.david.action.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>

    <!-- (事务管理)transaction manager, use JtaTransactionManager for global tx -->
    <tx:annotation-driven transaction-manager="transactionManager"/>
</beans>

2.4 在项目web.xml中配置引用spring-mybatis.xml文件

   <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>classpath:spring-mybatis.xml</param-value>
    </context-param>

框架基本上搭建完毕,后面步骤是写三层并实现

四丶编写三层进行数据持久化操作 手写容易出错并无法提高工作效率,推荐使用:mybatis generaotr工具进行生成三层

1新建一个user.class实体类

Userpackage com.david.model;

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

public class User implements Serializable {
    private String id;

    private String name;

    private Date termValidity;

    private String userType;

    private Integer status;

    private String qqNum;

    private String account;

    private String pwd;

    private String lineCode;

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id == null ? null : id.trim();
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name == null ? null : name.trim();
    }

    public Date getTermValidity() {
        return termValidity;
    }

    public void setTermValidity(Date termValidity) {
        this.termValidity = termValidity;
    }

    public String getUserType() {
        return userType;
    }

    public void setUserType(String userType) {
        this.userType = userType == null ? null : userType.trim();
    }

    public Integer getStatus() {
        return status;
    }

    public void setStatus(Integer status) {
        this.status = status;
    }

    public String getQqNum() {
        return qqNum;
    }

    public void setQqNum(String qqNum) {
        this.qqNum = qqNum == null ? null : qqNum.trim();
    }

    public String getAccount() {
        return account;
    }

    public void setAccount(String account) {
        this.account = account == null ? null : account.trim();
    }

    public String getPwd() {
        return pwd;
    }

    public void setPwd(String pwd) {
        this.pwd = pwd == null ? null : pwd.trim();
    }

    public String getLineCode() {
        return lineCode;
    }

    public void setLineCode(String lineCode) {
        this.lineCode = lineCode == null ? null : lineCode.trim();
    }
}

2在resources文件夹下新建一个mapping文件夹用来存放sql相关的xml。比如UserMapper.xml的sql文件

<?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" >
<mapper namespace="com.david.dao.UserDao">
    <resultMap id="BaseResultMap" type="com.david.model.User" >
        <id column="id" property="id" jdbcType="VARCHAR" />
        <result column="name" property="name" jdbcType="VARCHAR" />
        <result column="term_validity" property="termValidity" jdbcType="TIMESTAMP" />
        <result column="user_type" property="userType" jdbcType="VARCHAR" />
        <result column="status" property="status" jdbcType="INTEGER" />
        <result column="qq_num" property="qqNum" jdbcType="VARCHAR" />
        <result column="account" property="account" jdbcType="VARCHAR" />
        <result column="pwd" property="pwd" jdbcType="VARCHAR" />
        <result column="line_code" property="lineCode" jdbcType="VARCHAR" />
    </resultMap>
    <sql id="Base_Column_List" >
        id, name, term_validity, user_type, status, qq_num, account, pwd, line_code
    </sql>
    <select id="selectByPrimaryKey" resultMap="BaseResultMap" parameterType="java.lang.String" >
        select
        <include refid="Base_Column_List" />
        from u_user
        where id = #{id,jdbcType=VARCHAR}
    </select>
    <delete id="deleteByPrimaryKey" parameterType="java.lang.String" >
        delete from u_user
        where id = #{id,jdbcType=VARCHAR}
    </delete>
    <insert id="insert" parameterType="com.david.model.User" >
        insert into u_user (id, name, term_validity,
        user_type, status, qq_num,
        account, pwd, line_code
        )
        values (#{id,jdbcType=VARCHAR}, #{name,jdbcType=VARCHAR}, #{termValidity,jdbcType=TIMESTAMP},
        #{userType,jdbcType=VARCHAR}, #{status,jdbcType=INTEGER}, #{qqNum,jdbcType=VARCHAR},
        #{account,jdbcType=VARCHAR}, #{pwd,jdbcType=VARCHAR}, #{lineCode,jdbcType=VARCHAR}
        )
    </insert>
    <insert id="insertSelective" parameterType="com.david.model.User" >
        insert into u_user
        <trim prefix="(" suffix=")" suffixOverrides="," >
            <if test="id != null" >
                id,
            </if>
            <if test="name != null" >
                name,
            </if>
            <if test="termValidity != null" >
                term_validity,
            </if>
            <if test="userType != null" >
                user_type,
            </if>
            <if test="status != null" >
                status,
            </if>
            <if test="qqNum != null" >
                qq_num,
            </if>
            <if test="account != null" >
                account,
            </if>
            <if test="pwd != null" >
                pwd,
            </if>
            <if test="lineCode != null" >
                line_code,
            </if>
        </trim>
        <trim prefix="values (" suffix=")" suffixOverrides="," >
            <if test="id != null" >
                #{id,jdbcType=VARCHAR},
            </if>
            <if test="name != null" >
                #{name,jdbcType=VARCHAR},
            </if>
            <if test="termValidity != null" >
                #{termValidity,jdbcType=TIMESTAMP},
            </if>
            <if test="userType != null" >
                #{userType,jdbcType=VARCHAR},
            </if>
            <if test="status != null" >
                #{status,jdbcType=INTEGER},
            </if>
            <if test="qqNum != null" >
                #{qqNum,jdbcType=VARCHAR},
            </if>
            <if test="account != null" >
                #{account,jdbcType=VARCHAR},
            </if>
            <if test="pwd != null" >
                #{pwd,jdbcType=VARCHAR},
            </if>
            <if test="lineCode != null" >
                #{lineCode,jdbcType=VARCHAR},
            </if>
        </trim>
    </insert>
    <update id="updateByPrimaryKeySelective" parameterType="com.david.model.User" >
        update u_user
        <set >
            <if test="name != null" >
                name = #{name,jdbcType=VARCHAR},
            </if>
            <if test="termValidity != null" >
                term_validity = #{termValidity,jdbcType=TIMESTAMP},
            </if>
            <if test="userType != null" >
                user_type = #{userType,jdbcType=VARCHAR},
            </if>
            <if test="status != null" >
                status = #{status,jdbcType=INTEGER},
            </if>
            <if test="qqNum != null" >
                qq_num = #{qqNum,jdbcType=VARCHAR},
            </if>
            <if test="account != null" >
                account = #{account,jdbcType=VARCHAR},
            </if>
            <if test="pwd != null" >
                pwd = #{pwd,jdbcType=VARCHAR},
            </if>
            <if test="lineCode != null" >
                line_code = #{lineCode,jdbcType=VARCHAR},
            </if>
        </set>
        where id = #{id,jdbcType=VARCHAR}
    </update>
    <update id="updateByPrimaryKey" parameterType="com.david.model.User" >
    update u_user
    set name = #{name,jdbcType=VARCHAR},
      term_validity = #{termValidity,jdbcType=TIMESTAMP},
      user_type = #{userType,jdbcType=VARCHAR},
      status = #{status,jdbcType=INTEGER},
      qq_num = #{qqNum,jdbcType=VARCHAR},
      account = #{account,jdbcType=VARCHAR},
      pwd = #{pwd,jdbcType=VARCHAR},
      line_code = #{lineCode,jdbcType=VARCHAR}
    where id = #{id,jdbcType=VARCHAR}
  </update>
    <select id="getUserByParm" parameterType="map" resultType="map">
        SELECT
        <include refid="Base_Column_List"/>
        from u_user s where =
        <if test="qqNum != null">
            and s.qq_num=#{qqNum}
        </if>
        <if test="account != null">
            and s.account=#{account}
        </if>
        <if test="pwd != null">
            and s.pwd=#{pwd}
        </if>
        <if test="status != null">
            and s.status=#{status}
        </if>
        <if test="qqandaccount != null">
            and( s.qq_num=#{qqandaccount} or s.account=#{qqandaccount})
        </if>
    </select>
    <select id="loginUser" parameterType="map" resultType="com.david.model.User">
        SELECT
        <include refid="Base_Column_List"/>
        from u_user s where =
        <if test="qqNum != null">
            and s.qq_num=#{qqNum}
        </if>
        <if test="account != null">
            and s.account=#{account}
        </if>
        <if test="pwd != null">
            and s.pwd=#{pwd}
        </if>
        <if test="status != null">
            and s.status=#{status}
        </if>
        <if test="qqandaccount != null">
            and( s.qq_num=#{qqandaccount} or s.account=#{qqandaccount})
        </if>
    </select>
</mapper>

3新建一个server文件夹并新建 UserService接口 这里例子使用了抽象类AbstractService来实现自动生成的inser/update/select/delete等几个默认方法.可以不继承。

package com.david.service;

import com.david.model.User;
import com.david.utils.abs.AbstractService;

import java.util.List;
import java.util.Map;

/**
 * Created by Administrator on 2017/11/16.
 */
public interface UserService extends AbstractService<User> {
    /**
     * 查询相关用户信息
     * @param params
     * @return
     */
    public List<Map<String,String>>getUserByParm(Map<String,String>params);

    /**
     * 登录账号
     * @param params
     * @return
     */
    public User loginUser(Map<String,String>params);
}

4在server下新建一个imp文件夹来标识是用来实现服务层的接口并新建一个UserServiceImp类并实现接口UserService

package com.david.service.impl;

import com.david.dao.LineDao;
import com.david.dao.UserDao;
import com.david.model.User;
import com.david.service.UserService;
import com.david.utils.abs.AbstractDao;
import com.david.utils.abs.AbstractServiceImpl;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import javax.annotation.Resource;
import java.util.List;
import java.util.Map;

/**
 * Created by Administrator on 2017/11/16.
 */
@Service
@Transactional(rollbackFor = Exception.class)
public class UserServiceImpl extends AbstractServiceImpl<User> implements UserService{
    @Resource
    UserDao userDao;
    @Override
    protected AbstractDao<User> getAbstractDao() {
        return userDao;
    }

    @Override
    public List<Map<String,String>> getUserByParm(Map<String, String> params) {
        return userDao.getUserByParm(params);
    }

    @Override
    public User loginUser(Map<String, String> params) {
        return userDao.loginUser(params);
    }
}

5新建一个dao层用来实现数据持久化UserDao

package com.david.dao;

import com.david.model.User;
import com.david.utils.abs.AbstractDao;
import org.springframework.stereotype.Repository;

import java.util.List;
import java.util.Map;

/**
 * Created by Administrator on 2017/11/16.
 */
@Repository
public interface UserDao extends AbstractDao<User> {
    /**
     * 查询相关用户信息
     * @param params
     * @return
     */
    public List<Map<String,String>> getUserByParm(Map<String,String> params);
    /**
     * 登录账号
     * @param params
     * @return
     */
    public User loginUser(Map<String,String>params);
}

以上就是Spring+SpringMVC+MyBatis的数据持久化基本框架内容