1 创建一个webapp模板的maven项目

首先我们在IDEA中创建一个webapp模板的maven项目，名字随意，设定好工作坐标以及我们自己的maven路径，下面为步骤图解:

1.1 选择模板并创建项目

1.2 设定项目名称并设置工作坐标

1.3 设置maven路径与配置文件，之后点击finish就配置好了

2 导入jar包依赖

之后我们进入项目后，最先显示的就是我们的pom文件，我们接下来需要对pom文件做一些操作：

2.1 删除用不到的坐标依赖，我们删除掉原有的properties标签、dependencies标签和build标签中的所有内容

删除完毕后如图所示：

2.2 导入相应的坐标依赖

将下列依赖粘贴到pom.xml文件中

<properties>
  <spring.version>5.0.2.RELEASE</spring.version>
  <slf4j.version>1.6.6</slf4j.version>
  <log4j.version>1.2.12</log4j.version>
  <mysql.version>5.1.6</mysql.version>
  <mybatis.version>3.4.5</mybatis.version>
  <jackson.version>2.9.4</jackson.version>
</properties>
<dependencies>
  <!--spring-->
  <dependency>
    <groupId>org.aspectj</groupId>
    <artifactId>aspectjweaver</artifactId>
    <version>1.6.8</version>
  </dependency>
  <dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-aop</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-web</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-test</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>junit</groupId>
    <artifactId>junit</artifactId>
    <version>4.12</version>
    <scope>test</scope>
  </dependency>
  <dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>${mysql.version}</version>
  </dependency>
  <dependency>
    <groupId>javax.servlet</groupId>
    <artifactId>servlet-api</artifactId>
    <version>2.5</version>
    <scope>provided</scope>
  </dependency>
  <dependency>
    <groupId>javax.servlet.jsp</groupId>
    <artifactId>jsp-api</artifactId>
    <version>2.0</version>
    <scope>provided</scope>
  </dependency>
  <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>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-->
  <dependency>
    <groupId>org.mybatis</groupId>
    <artifactId>mybatis</artifactId>
    <version>${mybatis.version}</version>
  </dependency>
  <dependency>
    <groupId>org.mybatis</groupId>
    <artifactId>mybatis-spring</artifactId>
    <version>1.3.0</version>
  </dependency>
  <!--连接池-->
  <dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>druid</artifactId>
    <version>1.1.10</version></dependency>
  <dependency>
    <groupId>org.mybatis.generator</groupId>
    <artifactId>mybatis-generator-core</artifactId>
    <version>1.3.5</version>
  </dependency>
  <dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-core</artifactId>
    <version>${jackson.version}</version>
  </dependency>
  <dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-databind</artifactId>
    <version>${jackson.version}</version>
  </dependency>
  <dependency>
    <groupId>com.github.pagehelper</groupId>
    <artifactId>pagehelper</artifactId>
    <version>5.1.10</version>
  </dependency>
  <dependency>
    <groupId>cn.hutool</groupId>
    <artifactId>hutool-all</artifactId>
    <version>5.2.3</version>
  </dependency>
  <dependency>
      <groupId>org.thymeleaf</groupId>
      <artifactId>thymeleaf-spring4</artifactId>
      <version>3.0.9.RELEASE</version>
  </dependency>
</dependencies>
<build>
  <finalName>ssm</finalName>
  <pluginManagement>
    <plugins>
      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-compiler-plugin</artifactId>
        <version>3.2</version>
        <configuration>
          <source>1.8</source>
          <target>1.8</target>
          <encoding>UTF-8</encoding>
          <showWarnings>true</showWarnings>
        </configuration>
      </plugin>
    </plugins>
  </pluginManagement>
  <plugins>
    <plugin>
      <groupId>org.mybatis.generator</groupId>
      <artifactId>mybatis-generator-maven-plugin</artifactId>
      <version>1.3.5</version>
      <!--告诉插件，配置文件所在的位置-->
      <configuration>
        <configurationFile>src/main/resources/mbg.xml</configurationFile>
        <verbose>true</verbose>
        <overwrite>true</overwrite>
      </configuration>
    </plugin>
  </plugins>
</build>

导入好之后我们点击更新来进行依赖的导入：

3.搭建项目基本框架

3.1 创建我们的Java程序目录与资源目录

我们首先要在项目的main目录下创建两个目录，一个是java目录，一个是resource目录，两个目录都应被设定相应的角色，我们要把java目录设定成java源目录，将资源目录设定为资源目录，如下图所示我们分别创建这两个目录：
  

最终目录结构如图所示：

注意一定要一个是java源目录，一个是资源跟目录，图标要和图中一致

3.2 创建我们的Java工作空间

在java目录下创建一个和我们之前定义的工作空间同名的包，如图所示：
  

3.3 创建我们的测试区

在src下创建test目录并创建测试java源目录和测试资源根，如图所示：

分别点击这两个，最终结果为：

4创建项目对应的数据库

create database ssm;
create table account(
id int primary key auto_increment,
name varchar(20),
money double
);

这里是我的创建数据库的代码
ps:这个需要自由发挥

5创建model层

这里我想提的一点就是实际上每个逻辑层本质上都仅仅是一个包，其意义实际上是我们赋予它的，这里的思想实际上就是约定大于配置，对于这些层我们无需配置什么，而是我们要按照约定在里边些什么，我们在里边写的东西，就是我们赋予其真正含义的过程，我们在一个名为model的包下写Service层的代码，那这个包就是Service层的包。因此我们要是想创建一个层，必须要有代码的具体依托，而我们的代码在SSM项目中很大程度上是依托于数据库书写的，典型的如model层，接下来我们书写model层的代码。

model层代码实际上就是java bean的蓝图，我们当前数据库中存在一个实体为account，因此我们就需要创建一个account的java bean蓝图，也就是Account类，经过上面的构建表我们知道数据库中的account表有三个字段：id[类型为int]、name[类型为varchar]、money[类型为double]，因此我们必须创建一个字段名和属性完全与该表一样的类，这个类在哪创建呢？我们首先应该在com.qcby下创建一个新包，名为model，然后今后它就是我们的model层了，之后我们在这个里边创建Account类：
  
在Accout中创建相应的属性并生成get，set，toString方法：

6 Spring框架的导入以及Service层的创建

6.1 创建Service层

Service是严格遵循Spring提供的IOC思路书写的，因此我们会将代码分为两部分，其中一部分是接口部分，另一部分是方法体部分，其中接口部分的作用主要是限制我们方法的声明，以及在controller层中提供生成标准bean的服务。
首先我们先在com.qcby下创建一个service包，然后再service层下创建一个impl目录，用来存放service层方法

然后我们在service包下创建一个新的接口类，名为AccountService，这里边定义的是Account这个javabean相关的业务操作的各种方法，我们书写其代码如下：

package com.qcby.service;

import com.qcby.model.Account;
import java.util.List;

public interface AccountService {

    //查询所有
    public List<Account> findAll();
}

这些代码意味着我们为AccountService的业务方法中定下了一个标准，简而言之就是说我们必须为Account这个实体提供一个查询所有数据库中的信息的方法。有了接口之后，我们就得在impl包中书写接口的实现，否则我们的方法是使用不了的。

之后我们书写接口的实现，我们在impl包中创建一个与刚才的AccountService相对应的AccountServiceImpl类，然后让这个类实现那个接口，代码如下：

package com.qcby.service.impl;

import com.qcby.model.Account;
import com.qcby.service.AccountService;

import java.util.List;

public class AccountServiceImpl implements AccountService {
    @Override
    public List<Account> findAll() {
   		System.out.println("业务层：查询所有");
        return null;
    }
}

最后也是最终要的一点，我们为这个类加上注解@Service，加上这个注解之后，Spring才会扫描到这个类并承认这个类在Spring中存在的资格，之后才能生产这个类的对象，我们可以简单的记作加上注解之后，就可以使用Spring生成它的对象了，Spring中提供的对象生成许可注解有四种：@Component、@Controller、@Service、@Repository，这四个注解的功能都一样，就是创建对象，我们有时甚至可以混用，但是在SSM中我们尽量不要混用，因为这四个注解是分别面向不同的层的对象生成的，如下所示：

因此我们在这里一定要为我们书写的这个实现类加上@Service注解，如图所示：
  
最终代码为：

package com.qcby.service.impl;

import com.qcby.model.Account;
import com.qcby.service.AccountService;
import org.springframework.stereotype.Service;

import java.util.List;

@Service
public class AccountServiceImpl implements AccountService {
    @Override
    public List<Account> findAll() {
        System.out.println("业务层：查询所有");
        return null;
    }
}

6.2 创建Spring配置文件

之后我们来正式配置Spring，我们首先创建配置文件，我们在之前在main中创建好的resource目录下新建一个spring目录，并在里边创建一个spring类型的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:aop="http://www.springframework.org/schema/aop"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop.xsd
http://www.springframework.org/schema/tx
http://www.springframework.org/schema/tx/spring-tx.xsd">
    <!--开启注解扫描，要扫描的是service-->
    <context:component-scan base-package=""/>
</beans>

其中在<context:component-scan base-package=“”/>中，我们为base-package添加属性，这个属性是一个包路径，内容是我们所想要让Spring托管的包，我们填入com.qcby，意思是将整个工程中的类都纳入其管理，我们可以根据自己的需求来缩小这个范围

6.3测试Spring

我们使用Spring的目的在于让Spring为我们生成对象，因此我们要测试这个功能，我们在test下的Java中创建一个和工作空间同名的包com.qcby，并在下面创建一个TestSpring类，如下：

在其中粘贴如下代码：

package com.qcby;

import com.qcby.service.AccountService;
import org.junit.Test;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class TestSpring {
    @Test
    public void run(){
        ClassPathXmlApplicationContext ac = new ClassPathXmlApplicationContext("classpath:spring/spring.xml");//这里是spring.xml的路径，我们一定要书写对，该路径是以resource为出发点的相对路径，我们的目录结构中spring.xml放在了spring目录下，因此这里应该这样书写
        AccountService service = ac.getBean(AccountService.class);
        service.findAll();
    }
}

这段代码就是测试一下Spring的IOC功能是否能用，我们点击test提供的运行按钮尝试一下：

如果输出和图中相同，代表我们的spring配置成功了

7 Spring MVC框架的导入以及controller层的创建

接下来我们开始创建controller层以及导入Spring MVC框架，Spring MVC支持的controller层主要也是使用IOC进行解耦，并且主要功能是实现请求的收发以及页面跳转的，整个项目的逻辑归他控制因此我们叫它控制层，接下来我们首先要配置Spring MVC。

7.1Spring MVC框架的导入

首先我们找到webapp中的web.xml文件

将其中的内容换成下边的：

<web-app version="3.0" 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">

  <!--在web.xml中配置Spring提供的过滤器类 -->
  <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>
  <!--不拦截所有是html的页面请求-->
  <servlet-mapping>
    <servlet-name>default</servlet-name>
    <url-pattern>*.html</url-pattern>
  </servlet-mapping>

  <!--配置前端控制器，对浏览器发送的请求进行统一处理-->
  <servlet>
    <servlet-name>dispatcherServlet</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    <!--加载springmvc.xml配置文件的位置和名称，配置的是Spring配置-->
    <init-param>
      <!--contextConfigLocation:上下文配置路径，固定值-->
      <param-name>contextConfigLocation</param-name>
      <!--classpath:类路径，值得是Java和resources文件夹-->
      <!--springmvc.xml:指的是配置文件的名称：需要配置springmvc.xml，在下面-->
      <param-value>classpath:springMVC/springmvc.xml</param-value>
    </init-param>
    <!--配置启动加载-->
    <load-on-startup>1</load-on-startup>
  </servlet>

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

  <!--开启项目时打开的页面-->
  <welcome-file-list>
    <welcome-file>/index.html</welcome-file>
  </welcome-file-list>

</web-app>

我们会发现这里会爆红：

这是springmvc.xml文件的引用路径，加入这个配置信息意在监听Spring MVC的配置文件，以便于将Spring MVC整合进项目，现在我们还没有创建这个配置文件，因此它标红了，现在我们创建它，我们在resource目录下创建一个新的目录，命名为springMVC，然后在其下边创建springmvc.xml配置文件：

我们直接将下面的配置信息粘贴进去：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:mvc="http://www.springframework.org/schema/mvc"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="
http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/mvc
http://www.springframework.org/schema/mvc/spring-mvc.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context.xsd">
   <!--配置spring创建容器时要扫描的包-->
<context:component-scan base-package=""/>

<!--处理映射器-->
<bean class="org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping"/>
<!--处理器适配器-->
<bean class="org.springframework.web.servlet.mvc.SimpleControllerHandlerAdapter"/>

<!--配置视图解析器-->
<bean id="viewResolver" class="org.thymeleaf.spring4.view.ThymeleafViewResolver">
    <property name="order" value="1"/>
    <property name="characterEncoding" value="UTF-8"/>
    <property name="templateEngine" ref="templateEngine"/>
</bean>
<!-- templateEngine -->
<bean id="templateEngine" class="org.thymeleaf.spring4.SpringTemplateEngine">
    <property name="templateResolver" ref="templateResolver"/>
</bean>
<bean id="templateResolver" class="org.thymeleaf.spring4.templateresolver.SpringResourceTemplateResolver">
    <property name="prefix" value="/html/" />
    <property name="suffix" value=".html" />
    <property name="templateMode" value="HTML5"/>
</bean>

<!-- 配置spring开启注解mvc的支持  默认就是开启的 ，要想让其他组件（不包含映射器、适配器、处理器）生效就必须需要配置了-->
<mvc:annotation-driven/>
</beans>

其中这里有一个和Spring配置文件中一样的标签<context:component-scan base-package=“”/>，我们在此同样要书写我们的com.qcby路径：

 这里根据你的工作空间具体命名确定，只是我的工作空间名称为com.spruce，这里才这样填的。之后Spring MVC就相当于引入了，我们还要搭建相关的层以及目录结构对其进行测试。

7.2搭建相关目录结构

在springmvc.xml中有这样一个标签：

这里边规定的东西是我们项目中的页面信息，在Spring MVC中页面跳转实际上使用到了一个字符串拼接的方式，controller层中的方法返回一个字符，然后根据这里的配置信息进行拼接，然后根据拼接好的字符串进行定位，所以第二三行中都是页面跳转时用到的信息标签，其中第二行是路径的前缀，它意味着我们的controller层中的方法返回了一个字符串之后，在字符串拼接的时候会首先在它前边加上/html/，而第三行中的则是后缀，它意味着会在该字符串的最后加上.html，举个例子，就是说我们的controller层中返回了一个“suc”，我们就会得到一个这样的字符串“/html/suc.html”，这个字符串意味着以webapp目录为起点的绝对定位下的html目录下的suc.html文件。

根据这个信息，我们首先要在webapp目录下创建一个叫html的文件来保存我们的html文件：
  
同时web.xml中还配置了欢迎页面：

其路径是以webapp为起点的绝对路径：/index.html，我们的项目中没有这个文件，只有一个index.jsp，jsp文件现在已经不常用了，因此我们把它换成index.html文件，并在里边书写上如下的代码：

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>主页</title>
</head>
<body>
<html>
<head>
    <meta charset="utf-8">
    <title>入门程序</title>
</head>
<body>
<h3>入门</h3><a href="/SSMStudy/account/hello" >入门程序</a>
</body>
</html>
</body>
</html>

7.3 controller层及相关文件配置

我们首先要在com.qcby下面创建一个名为controller的包，然后我们在这个包里创建我们相关的controller类就行了，我们现在新建一个名为AccountController的类，如图所示：

之后我们将Spring MVC整合到Spring中去，方法为将如下代码粘贴到web.xml文件中去：

<!--配置Spring的监听器-->
  <display-name>Archetype Created Web Application</display-name>
  <listener>
    <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
  </listener>
  <!--配置加载类路径的配置文件-->
  <context-param>
    <param-name>contextConfigLocation</param-name>
    <param-value>classpath:spring/spring.xml</param-value>
  </context-param>

之后我们在AccountController中粘贴如下的代码：

package com.qcby.controller;

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

@Controller
@RequestMapping("/account")
public class AccountController {

    @Autowired
    private AccountService accountService;
    /**
     * 处理超链接发送出来的请求
     * @param model
     * @return
     */
    @RequestMapping(path = "/hello")
    public String sayHello(Model model){
        System.out.println("入门方法执行了2...");
        // 向模型中添加属性msg与值，可以在html页面中取出并渲染
        model.addAttribute("msg","hello,SpringMVC");
        // 配置了视图解析器后，写法
        return "suc";
    }
}

其中我们在代码 private AccountService accountService;的上边加入了一个注解@Autowired，这个注解的意思是依赖注入，也就是让spring为其生成一个对象，我们就无需自己生成对象了，在之后我们就可以直接调用这个对象的方法了，这个对象是AccountService接口类型的，在生成对象的时候，Spring会根据Service的接口及实现方式生产一个新对象，新对象是使用多态的方式(实际上二者结构完全一致，因此并没有明显体现多态的含义)生成了一个接口类型的对象，我们只需调用这个对象，就可以规范的使用我们之前定义的方法。我们必须完成上边的整合步骤之后，才能使用这个依赖注入的功能。

上边我们整合配置的目的在于：**在controller中能成功的调用service对象中的方法。**方法原理是： 在web.xml中配置ContextLoaderListener监听器，该监听器默认加载WEB-INF目录下的applicationContext.xml的配置文件，我们修改全局的路径变量<paramvalue>classpath:spring/spring.xml</param-value>，进而让加载的文件变成我们的目标文件，这样一来，在项目启动的时候，就去加载spring.xml的配置文件了，而我们的spring就可以直接在这里使用了。

在上面的controller代码中，类上边的@Controller代表该类被Spring托管来产生对象，这个对象的调用则是被Spring MVC申请的，这个对象的调用将使用反射的方式在我们进行Servlet请求的时候隐性的被调用，而@RequestMapping("/account")则是其Servlet请求路径，这是一级路径，里边的方法上的注解@RequestMapping(path = "/hello")是二级路径，它们用来进行精确寻址。而这个方法的返回值"suc"，在Spring MVC中被默认解析为一个路径，也就是上边我们提到的文件路径，它返回之后将被拼接成一个完整的路径，用于寻找页面视图。我们在上边配置的是html目录下的html类型文件，因此为了让这个返回有地方可去，我们在html目录下创建一个suc.html，并书写如下代码：

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>成功页面</title>
</head>
<body>
    你好，我是成功页面!
</body>
</html>

7.4 配置Tomcat服务器

首先我们点击这里：

点击第一个选项

点击加号

点击本地

点击部署

点击加号

点击第一个选项

选择第二个选项

将这里的_war_exploded删掉

之后点击应用然后点击确定即可

7.5 测试

点击绿色箭头启动Tomcat

浏览器中会弹出

之后点击

出现如下页面代表配置成功

这里会有乱码，乱码问题等我们完全配置完毕后再解决

8 MyBatis框架的导入以及Dao层的创建

8.1创建数据库信息配置文件

我们首先创建用来填写数据库信息的配置文件，我们可以将数据库信息直接填在xml文件中，也可以新建一个properties文件，然后将数据库信息放在这里边，在xml文件中用变量的形式来填写，两种方法均可，配置文件的方式更利于后人维护时更改，因此我们使用这种更为先进的方法，我们首先创建一个MyBatisConfig目录，然后在下面创建一个SqlMapConfig.xml文件，一个jdbc.properties文件：

我们在jdbc.properties文件中书写下列信息：

driver=com.mysql.jdbc.Driver
url=jdbc:mysql://localhost:你的数据库服务端口名/你的数据库名称?useUnicode=true&characterEncoding=utf-8&serverTimezone=UTC&useSSL=false
username=你的数据库用户名
password=你的数据库用户密码
initialSize=0
maxActive=20
maxIdle=20
minIdle=1
maxWait=60000

然后我们在SqlMapConfig.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.qcby" /> <!--MyBatis托管的包路径-->

    <!-- 引入配置文件 -->
    <bean id="propertyConfigurer"
          class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
        <property name="location" value="classpath:MyBatisConfig/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:mapping/*.xml"></property>  <!--你的mapper类型的xml文件路径-->
    </bean>

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

这里会报错

是因为我们的路径有误，而下面的类找不到问题则是我们没有导入commons-dbcp.jar包，我们在pom文件的坐标依赖中加入下面的语句：

<dependency>
      <groupId>commons-dbcp</groupId>
      <artifactId>commons-dbcp</artifactId>
      <version>1.4</version>
</dependency>

之后就好了
同时这里也会报错

这是因为我们还没有创建这个目录，我们现在来创建这个目录：

等我们往里边创建了实现数据操作的xml配置文件之后就完全不会报错了，这个属于下个步骤的内容。

8.2 搭建Dao层

Dao层分为两部分，一部分为Dao层接口，一部分为mapping中的实现配置文件，我们现在都没创建，我们先创建Dao层接口，我们现在com.qcby下创建一个新包：dao

然后我们在里边书写一个针对account的dao层接口类AccountDao：

如上图所示我们创建好了Dao层的接口，需要注意的是在配置文件中，MyBatis里边也需要用到Spring对Dao层的类进行托管，这个托管的作用是使用IOC的思想生成Dao层对象时用到的。之后我们在Dao层中的接口下书写如下代码：

package com.qcby.dao;

import com.qcby.model.Account;

import java.util.List;

public interface AccountDao {
    public List<Account> findAll();
}

然后我们在mapping中书写一个关于Account的全览方式的实现：

在mapping下的AccountDao文件中粘贴如下代码：

<?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.qcby.dao.AccountDao">
    <!--  在这里书写sql语句  -->
    <!--  查询所有  -->
    <select id="findAll" resultType="com.qcby.model.Account">
        select * from account;
    </select>
</mapper>

之后Dao层就创建好了，最后我们将MyBatis加入到Spring的配置文件中去，我们将将如下代码复制到web.xml文件中去：

<!-- 配置监听器-->
  <listener>
    <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
  </listener>
  <!-- 配置加载类路径下的applicationContext.xml配置文件 -->
  <context-param>
    <param-name>contextConfigLocation</param-name>
    <param-value>classpath:MyBatisConfig/SqlMapConfig.xml</param-value>
  </context-param>

但是我们已经配置过一个监听器了，mybatis的监听器和spring的监听器重名了，而且监听器只能监听这个contextConfigLocation名字的文件，所以我们需要想办法解决这个问题，我们对比之前书写的spring.xml和SqlMapConfig.xml会发现二者在开有一个标签是重复的：

实际上，两个标签是同一个东西，就是Spring托管，因此我们完全可以将spring.xml删除掉，然后将其配置融入进mybatis的配置文件中：

 因此在书写配置文件时，由于Spring的配置文件过于简单并且和其他的配置文件都是相容的，因此我们可以将Spring的配置文件书写进MyBatis的配置文件中去或者书写进Spring MVC的配置文件中去，我个人觉得书写进Spring MVC的里边更好一点。

9 测试

9.1 书写Service层的方法

package com.qcby.service.impl;

import com.qcby.dao.AccountDao;
import com.qcby.model.Account;
import com.qcby.service.AccountService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;

@Service
public class AccountServiceImpl implements AccountService {
    @Autowired
    public AccountDao accountDao;
    @Override
    public List<Account> findAll() {
        System.out.println("业务层：查询所有");
        return this.accountDao.findAll();
    }
}

9.2 书写controller层的方法

package com.qcby.controller;

import com.qcby.model.Account;
import com.qcby.service.AccountService;
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 java.util.List;

@Controller
@RequestMapping("/account")
public class AccountController {

    @Autowired
    private AccountService accountService;
    /**
     * 处理超链接发送出来的请求
     * @param model
     * @return
     */
    @RequestMapping(path = "/hello")
    public String sayHello(Model model){
        System.out.println("入门方法执行了2...");
        List<Account> accounts = accountService.findAll();
        for (Account account: accounts) {
            System.out.println(account.toString());
        }
        // 向模型中添加属性msg与值，可以在html页面中取出并渲染
        model.addAttribute("msg","hello,SpringMVC");
        // 配置了视图解析器后，写法
        return "suc";
    }
}

根据逻辑，我们调用这个方法会使得控制台中输出我们的查询结果，我们运行尝试：

出现这个结果代表执行成功，至此我们的SSM项目搭建完毕

10 解决乱码问题

解决乱码只需在springmvc.xml文件中的这里

加入这行代码即可<property name="characterEncoding" value="utf-8"></property>