SSM框架(STS/Eclipse)

目录

一，工具和环境

1，STS的启动

2，在STS上集成Maven

二，创建Maven项目

1，项目搭建

2，准备依赖

3，准备数据库

4，使用mybatis-generator自动生成代码

5，日志配置

三，Spring和MyBatis的集成

四，测试

五，提供Service组件

六，使用注解方式集成Spring和MyBatis

七，添加事务

八，Spring和SpringMVC的集成

后记：

---

一，工具和环境

STS，Tomcat，Maven，MySQL

STS工具就是加强版的Eclipse，也是免费使用，操作界面和Eclipse一模一样，功能比Eclipse更强大。可以在Spring的官方网站免费下载，下载地址：https://spring.io/tools3/sts/all，我使用的版本是3.9.10。

Tomcat：我使用的是Tomcat8，下载地址：https://tomcat.apache.org/download-80.cgi，我使用的版本是8.0.53。

Maven：下载地址：https://maven.apache.org/download.cgi#，我使用的版本是3.6.1。

JDK：我使用的是JDK1.8

数据库：MySQL 下载地址：https://dev.mysql.com/downloads/mysql/，我使用的版本是5.7.28。

注：关于Tomcat，Maven，JDK的安装或者环境配置等一些设置，这里不做过多讲解，可以自行百度，很容易的。

1，STS的启动

下载好STS的压缩包（zip包）后，直接解压到当前文件夹，解压之后会出现一个sts-bundle文件夹（sts-bundle文件夹的路径不要包含中文字符或者空格），在\sts-bundle\sts-3.9.10.RELEASE下点击STS.exe启动STS工具。第一次启动之后会出现下图所示对话框：

​

这是选择工作空间，建议自己在某个地方新建一个文件夹（我喜欢命名叫workspace）

1,点击Browse...找到这个worksapce文件夹并选中，点击选择文件夹;

2,勾选左下角选择框；

3，点击Launch

进入STS编辑界面，如下图：

​

我们用不了这么多视图框，只留一个Console视图框就可以了，其他的叉掉。如下图：

​

2，在STS上集成Maven

点击Window，Preferences

​

选择Maven，Installations

​

点击右侧的Add...按钮

​

点击Directory...按钮，找到Maven的解压目录，

​

点击右下角选择文件夹按钮，

​

点击Finish按钮

​

点击Apply按钮

选择User Settings如下图：

​

点击Browse...按钮，找到apache-maven-3.6.1\conf目录下的setting.xml文件，如下图，点击下方打开按钮

​

​

之后点击Apply和Apply and Close。

二，创建Maven项目

1，项目搭建

​

点击File，New，Maven Project

​

点击Next>按钮

​

点击Finish按钮，创建项目成功，如下图：

​

我们会发现，项目中有报错，pom.xml文件和项目文件上有小红叉，这是因为我们建立的是web项目，web项目在WEB-INF目录下应该有一个web.xml文件。而Maven创建的项目中没有，如下图，我们还需要改造一下

​

选中webapp文件夹，鼠标右键，新建一个文件夹（Folder）名字叫WEB-INF，注意，这个名字是固定的不能更改，中间的是中线（或者说是一个减号）不是下划线，然后复制Tomcat安装目录中webapps\examples\WEB-INF文件夹下的web.xml文件，粘贴到上面创建的WEB-INF目录中

​

粘贴进去之后，项目中的错误，小红叉就消失了，如下图

​

我们再把web.xml文件整理一下，双击打开，删除<description></description>标签里面的所有内容，再删掉注释

​

metadata-complete属性：当该属性为true时，web应用将不会加载注解配置的Web组件。我们会在项目中使用注解，所以在这里要么将它的值设为false，要么直接将这个属性删除。我就直接删除了。此外，将encoding的值设为UTF-8，如下：

​

web.xml代码如下：

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee
                      http://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd"
	version="3.1">

</web-app>

我们把项目的编码设置一下：

​

右键，Properties

​

编码格式选择UTF-8，点击Apply and Cancel按钮

整个弄完之后，项目的结构是这样的：

​

2，准备依赖

我们首先准备一些基础的依赖

·单元测试   这个是方便我们测试用的，我们会写一个功能测一个功能，而不是把所有功能都写完再测试，这样会帮助我们缩小错误范围，                     方便寻找bug。

·日志组件   这个是方便我们观察SQL语句和一些测试的结果

·MySQL驱动    连接数据库

·Druid连接池   帮我们管理数据库的连接

·MyBatis   持久层   帮助我们对数据库进行操作（增删改查）

·Spring   业务层   帮助我们管理对象

·MyBatis与Spring整合的桥梁

开始就先添加这么多吧，后面需要了再添加

添加依赖

Maven项目不需要拷贝依赖的jar包，只需要在pom.xml文件中添加依赖的坐标，Maven会自动把jar包下载到本地仓库，供我们使用，那么依赖的坐标在哪里找呢？

这里介绍一个网站  https://mvnrepository.com/  ，依赖的坐标都可以在这个网站上找到，打开网站如下图：

​

在搜索框内输入要找的依赖，然后点击Search，我们现在来搜索单元测试所依赖的坐标，在搜索框中输入junit,点击Search，出现如下页面：

​

点进去会看到下图所示的页面：

​

我们选择4.12版本的，点进去会看到如下所示的界面：

​

将方框内的代码复制下来，接下来打开pom.xml文件，如下图所示写一个<dependencies></dependencies>标签，依赖的坐标就往这个标签里面放，

​

按Ctrl+S保存之后，左侧的目录结构会发生变化，会多出一个东西，见下图：

​展开之后是这样的​

这样，我们第一个依赖就添加好了，Maven自动把jar包下载下来放在本地仓库供我们使用，我们再也不用到处找jar包了。

用同样的方式把其他的依赖加入就行了，添加后的pom.xml文件的代码是这样的：

<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/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0</modelVersion>
	<groupId>com.breeze</groupId>
	<artifactId>SSM1</artifactId>
	<version>0.0.1-SNAPSHOT</version>
	<packaging>war</packaging>

	<dependencies>
		<!-- https://mvnrepository.com/artifact/junit/junit -->
		<dependency>
			<groupId>junit</groupId>
			<artifactId>junit</artifactId>
			<version>4.12</version>
			<scope>test</scope>
		</dependency>
		<!-- https://mvnrepository.com/artifact/org.slf4j/slf4j-log4j12 -->
		<dependency>
			<groupId>org.slf4j</groupId>
			<artifactId>slf4j-log4j12</artifactId>
			<version>1.7.25</version>
			<scope>test</scope>
		</dependency>
		<!-- https://mvnrepository.com/artifact/mysql/mysql-connector-java -->
		<dependency>
			<groupId>mysql</groupId>
			<artifactId>mysql-connector-java</artifactId>
			<version>5.1.40</version>
		</dependency>
		<!-- https://mvnrepository.com/artifact/com.alibaba/druid -->
		<dependency>
			<groupId>com.alibaba</groupId>
			<artifactId>druid</artifactId>
			<version>1.1.19</version>
		</dependency>
		<!-- https://mvnrepository.com/artifact/org.mybatis/mybatis -->
		<dependency>
			<groupId>org.mybatis</groupId>
			<artifactId>mybatis</artifactId>
			<version>3.5.0</version>
		</dependency>
		<!-- https://mvnrepository.com/artifact/org.springframework/spring-context -->
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-context</artifactId>
			<version>5.1.0.RELEASE</version>
		</dependency>
	</dependencies>

</project>

Tips：Ctrl+Shift+F是格式化代码

接下来，我们开始分包

​

Tips：文件的展示形式，一种是Flat，一种是Hierarchical 如下图：

​

左侧是Flat形式，右侧是Hierarchical 形式，可以选择自己喜欢的组织形式

​​

3，准备数据库

新建一个数据库，名称为springdemo，再新建一个员工表employee

​

数据库建表语句：

CREATE TABLE `employee` (
  `id` bigint(20) NOT NULL AUTO_INCREMENT,
  `name` varchar(20) DEFAULT NULL,
  `password` varchar(20) DEFAULT NULL,
  `hiredate` date DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=23 DEFAULT CHARSET=utf8;

插入几条数据：

​

4，使用mybatis-generator自动生成代码

在pom.xml中添加mybatis-generator依赖：

<!-- https://mvnrepository.com/artifact/org.mybatis.generator/mybatis-generator-core -->
<dependency>
	<groupId>org.mybatis.generator</groupId>
	<artifactId>mybatis-generator-core</artifactId>
	<version>1.3.7</version>
</dependency>

这个mybatis-generator如何使用呢？我们先去看一下它的文档：http://mybatis.org/generator/index.html

访问这个网址之后会出现这样一个页面：

​

先看XML Configuration Reference，点进去页面如下：

​

可以看到，这是一个XML文件，我们需要做一些配置，首先在\src\main\resources文件下新建一个XML文件（文件名叫generatorConfig.xml），然后将文档中的XML配置代码全部复制粘贴进去，如下图：

​

generatorConfig.xml文件代码如下：

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE generatorConfiguration
  PUBLIC "-//mybatis.org//DTD MyBatis Generator Configuration 1.0//EN"
  "http://mybatis.org/dtd/mybatis-generator-config_1_0.dtd">

<generatorConfiguration>
  <classPathEntry location="/Program Files/IBM/SQLLIB/java/db2java.zip" />

  <context id="DB2Tables" targetRuntime="MyBatis3">
    <jdbcConnection driverClass="COM.ibm.db2.jdbc.app.DB2Driver"
        connectionURL="jdbc:db2:TEST"
        userId="db2admin"
        password="db2admin">
    </jdbcConnection>

    <javaTypeResolver >
      <property name="forceBigDecimals" value="false" />
    </javaTypeResolver>

    <javaModelGenerator targetPackage="test.model" targetProject="\MBGTestProject\src">
      <property name="enableSubPackages" value="true" />
      <property name="trimStrings" value="true" />
    </javaModelGenerator>

    <sqlMapGenerator targetPackage="test.xml"  targetProject="\MBGTestProject\src">
      <property name="enableSubPackages" value="true" />
    </sqlMapGenerator>

    <javaClientGenerator type="XMLMAPPER" targetPackage="test.dao"  targetProject="\MBGTestProject\src">
      <property name="enableSubPackages" value="true" />
    </javaClientGenerator>

    <table schema="DB2ADMIN" tableName="ALLTYPES" domainObjectName="Customer" >
      <property name="useActualColumnNames" value="true"/>
      <generatedKey column="ID" sqlStatement="DB2" identity="true" />
      <columnOverride column="DATE_FIELD" property="startDate" />
      <ignoreColumn column="FRED" />
      <columnOverride column="LONG_VARCHAR_FIELD" jdbcType="VARCHAR" />
    </table>

  </context>
</generatorConfiguration>

然后把generatorConfig.xml文件中的一些参数值改一下，如下图：

​

修改之后的generatorConfig.xml文件：

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE generatorConfiguration
  PUBLIC "-//mybatis.org//DTD MyBatis Generator Configuration 1.0//EN"
  "http://mybatis.org/dtd/mybatis-generator-config_1_0.dtd">

<generatorConfiguration>

  <context id="mysql" targetRuntime="MyBatis3Simple">
    <jdbcConnection driverClass="com.mysql.jdbc.Driver"
        connectionURL="jdbc:mysql://localhost:3306/springdemo"
        userId="root"
        password="1234">
    </jdbcConnection>

    <javaTypeResolver >
      <property name="forceBigDecimals" value="false" />
    </javaTypeResolver>

    <javaModelGenerator 
      targetPackage="com.breeze.domain" 
      targetProject="\src\main\java">
      <property name="enableSubPackages" value="true" />
      <property name="trimStrings" value="true" />
    </javaModelGenerator>

    <sqlMapGenerator 
      targetPackage="mappers"  
      targetProject="\src\main\resources">
      <property name="enableSubPackages" value="true" />
    </sqlMapGenerator>

    <javaClientGenerator 
      type="XMLMAPPER" 
      targetPackage="com.breeze.mapper"  
      targetProject="\src\main\java">
      <property name="enableSubPackages" value="true" />
    </javaClientGenerator>

    <table tableName="employee" domainObjectName="Employee"></table>

  </context>
</generatorConfiguration>

接下来，我们应该运行mybatis-generator，让它来给我们自动生成代码,那么怎么运行呢？我们再看文档：

​

点开Running MyBatis Generator,我们用Java代码的形式运行，所以点击With Java，将右侧的代码复制下来。

在com.breeze包下新建一个Class文件，这个文件是用来启动MyBatis Generator，我将其命名为RunMBG，如下图：

​

然后，我们要把

File configFile = new File("generatorConfig.xml");

这一行里面的值改一下，要让它能找到我们所写的generatorConfig.xml文件，如下：

File configFile = new File("src/main/resources/generatorConfig.xml");

选中类名，右键，Run As， Java Application 

​

运行之后，我们会发现，我们的项目里会多出三个文件，要把项目刷新一下才看得到

​刷新之后，项目结构如右：​

点开其中的一个文件如Employee.java会发现有很多注释，

​

不是那么的一目了然，如果希望在生成代码的时候，不生成注释，只需要给我们的generatorConfig.xml加一个配置就行了，这个也可以看文档（我前面的一些配置也是从文档里面来的，你们可以多看看文档）：

​

看一下XML配置参考（XML Configuration Reference）下面的注释生成器（<commentGenerator>）下面的支持的属性（Supported Properties）下面的属性名称 suppressAllComments，从文档说明中可以知道，当suppressAllComments的值为true时，不会在任何生成的元素上贴注释，继续往下拉，会有一个例子：

​

将这个元素复制粘贴到generatorConfig.xml文件中，把name的值改为suppressAllComments就行了，generatorConfig.xml文件如下：

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE generatorConfiguration
  PUBLIC "-//mybatis.org//DTD MyBatis Generator Configuration 1.0//EN"
  "http://mybatis.org/dtd/mybatis-generator-config_1_0.dtd">

<generatorConfiguration>

	<context id="mysql" targetRuntime="MyBatis3Simple">

		<commentGenerator>
			<property name="suppressAllComments" value="true" />
		</commentGenerator>
		
		<jdbcConnection driverClass="com.mysql.jdbc.Driver"
			connectionURL="jdbc:mysql://localhost:3306/springdemo" userId="root"
			password="1234">
		</jdbcConnection>

		<javaTypeResolver>
			<property name="forceBigDecimals" value="false" />
		</javaTypeResolver>

		<javaModelGenerator
			targetPackage="com.breeze.domain" targetProject=".\src\main\java">
			<property name="enableSubPackages" value="true" />
			<property name="trimStrings" value="true" />
		</javaModelGenerator>

		<sqlMapGenerator targetPackage="mappers"
			targetProject=".\src\main\resources">
			<property name="enableSubPackages" value="true" />
		</sqlMapGenerator>

		<javaClientGenerator type="XMLMAPPER"
			targetPackage="com.breeze.mapper" targetProject=".\src\main\java">
			<property name="enableSubPackages" value="true" />
		</javaClientGenerator>

		<table tableName="employee" domainObjectName="Employee"></table>

	</context>
</generatorConfiguration>

然后，在运行一下RunMBG就可以重新生成了，重新生成的会把以前的覆盖掉（别忘记刷新哦）

再打开一看会觉得很清晰。

新生成的三个文件我简单说一下：

Employee.java是根据我们springdemo数据库中Employee表创建出来的java对象，并提供了Getter和Setter方法。

EmployeeMapper.java也是根据Employee表创建出来的Mapper接口，里面提供了几个方法，一看这几个方法名称就知道这几个方法分别是用来干什么的，我就不赘述了。

EmployeeMapper.xml也是根据Employee表生成的Mapper映射接口，操作数据库，负责处理一些结果集等其他功能。

5，日志配置

同样地，我们日志文件的配置也是从文档里面找，https://mybatis.org/mybatis-3/zh/index.html，打开页面，这是MyBatis的文档，选择“日志”，如下图：

​

往下拉，会看到有一个日志配置，将log4j.properties文件的具体内容复制下来，如下图：

​

在src\main\resources包下新建一个文件（File），命名为log4j.properties，将刚刚复制的内容粘贴进去，将里面的包改为我们自己的包：

​

log4j.properties文件代码如下：

# Global logging configuration
log4j.rootLogger=ERROR, stdout
# MyBatis logging configuration...
log4j.logger.com.breeze=TRACE
# Console output...
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%5p [%t] - %m%n

好了，到这里准备工作才算基本做完。

三，Spring和MyBatis的集成

首先，我们新建一个Spring配置文件，名字叫applicationContext.xml，在src/main/resources包下新建一个Spring Bean Configuration File文件，本质也是一个XML文件，如下图：

​

建好后是这样的：

​

添加<context>命名空间，点击下侧Namespace，将context前面的小方框勾上：

​

再将后面的版本号去掉：

​    ​

然后我们需要做一些配置：

在配置之前我们需要在src/main/resources包下新建一个db.properties文件（File），如下图：

​

db.properties文件内容如下：

jdbc.driverClassName=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/springdemo
jdbc.username=root
jdbc.password=1234

这是连接数据库的四要素，有的同学会发现，我们在前面不是在generatorConfig.xml文件中配过吗？我们在generatorConfig.xml配置的连接数据库的四要素是使用MyBatisGenerator根据数据库中表的信息帮我们自动生成代码（生成代码之后generatorConfig.xml文件也就不再使用了），而这个是我们项目中连接后台数据库的一些配置，我们在增删改查的过程中要通过这个连接数据库。

现在我们来配置applicationContext.xml文件，配置好的applicationContext.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"
	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">

	<!-- ·加载db.properties文件 -->
	<context:property-placeholder location="classpath:db.properties" system-properties-mode="ENVIRONMENT"/>
	
	<!-- ·配置Druid连接池 -->
	<bean id="druidDataSource" class="com.alibaba.druid.pool.DruidDataSource" init-method="init" destroy-method="close">
		<property name="driverClassName" value="${jdbc.driverClassName}"/>
		<property name="url" value="${jdbc.url}"/>
		<property name="username" value="${jdbc.username}"/>
		<property name="password" value="${jdbc.password}"/>
	</bean>
	
	<!-- ·配置SqlSessionFactory -->
	<bean id="sqlSessionFactoryBean" class="org.mybatis.spring.SqlSessionFactoryBean">
		<!-- 1,关联连接池 -->
		<property name="dataSource" ref="druidDataSource"></property>
		<!-- 2,配置MyBatis属性配置 -->
		<property name="configurationProperties">
			<value>
				lazyLoadingEnabled=true
				aggressiveLazyLoading=false
				lazyLoadTriggerMethods=clone
			</value>
		</property>
		<!-- 3,配置为哪个包中的类起别名 -->
		<property name="typeAliasesPackage" value="com.breeze.domain"/>
		<!-- 4,关联Mapper映射文件 -->
		<property name="mapperLocations" value="classpath:mappers/*Mapper.xml"/>
	</bean>
	
	<!-- ·配置MapperFactoryBean,Spring帮我们创建Mapper的代理对象 -->
	<bean id="employeeMapper" class="org.mybatis.spring.mapper.MapperFactoryBean">
		<property name="sqlSessionFactory" ref="sqlSessionFactoryBean"/>
		<property name="mapperInterface" value="com.breeze.mapper.EmployeeMapper"></property>
	</bean>

</beans>

配置完了之后，我们发现有2行报错了，如下图：

​

这个是忘记加入依赖了，在第2步 准备依赖中，说要准备一些基础的依赖，最后一个是加入MyBatis与Spring整合的桥梁这个依赖，不知怎么的搞忘了，不好意思，现在在pom.xml文件中加入依赖：

<!-- https://mvnrepository.com/artifact/org.mybatis/mybatis-spring -->
<dependency>
	<groupId>org.mybatis</groupId>
	<artifactId>mybatis-spring</artifactId>
	<version>2.0.0</version>
</dependency>

加入依赖之后，就没有报错了（加入之后记得保存一下哦），然后我们来测试一下

四，测试

在com.breeze包下，新建一个Class类，命名为App

​

这个类就是我们的测试类，我们以后做测就在这个里面做

第一步，我们要加入spring测试的依赖，在pom.xml文件中加入下面的依赖（也可以在前面介绍的网站中搜spring-test）:

		<!-- https://mvnrepository.com/artifact/org.springframework/spring-test -->
		<dependency>
		    <groupId>org.springframework</groupId>
		    <artifactId>spring-test</artifactId>
		    <version>5.1.0.RELEASE</version>
		    <scope>test</scope>
		</dependency>

导入之后要在类上贴2个注解：

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath:applicationContext.xml")

贴了注解之后，我们发现2个注解都报错了，这是由于它没找到所依赖的jar包，我们先展开Maven Dependencies目录，如下图：

​

大家有没有发现这几个jar包的颜色和别的jar包的颜色不一样？这几个jar包是灰色的，这是由于这几个jar包的使用范围（scope）的值是test，如果我们把测试类写在src/test/java下就不会报错，我为了项目结构清晰一点点，我把测试类写在src/main/java包下了，这样的话，我们把pom.xml文件中的<scope>test</scope>删除或者注释掉就行了，当我们注释掉之后，就会看到那几个灰颜色的jar包颜色变得和其他jar包的颜色一样了，这时我们在App类中引入相应的jar包后就没有报错了，此时的pom.xml文件如下：

<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/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0</modelVersion>
	<groupId>com.breeze</groupId>
	<artifactId>SSM1</artifactId>
	<version>0.0.1-SNAPSHOT</version>
	<packaging>war</packaging>

	<dependencies>
		<!-- https://mvnrepository.com/artifact/junit/junit -->
		<dependency>
			<groupId>junit</groupId>
			<artifactId>junit</artifactId>
			<version>4.12</version>
			<!-- <scope>test</scope> -->
		</dependency>
		<!-- https://mvnrepository.com/artifact/org.slf4j/slf4j-log4j12 -->
		<dependency>
			<groupId>org.slf4j</groupId>
			<artifactId>slf4j-log4j12</artifactId>
			<version>1.7.25</version>
			<!-- <scope>test</scope> -->
		</dependency>
		<!-- https://mvnrepository.com/artifact/mysql/mysql-connector-java -->
		<dependency>
			<groupId>mysql</groupId>
			<artifactId>mysql-connector-java</artifactId>
			<version>5.1.40</version>
		</dependency>
		<!-- https://mvnrepository.com/artifact/com.alibaba/druid -->
		<dependency>
			<groupId>com.alibaba</groupId>
			<artifactId>druid</artifactId>
			<version>1.1.19</version>
		</dependency>
		<!-- https://mvnrepository.com/artifact/org.mybatis/mybatis -->
		<dependency>
			<groupId>org.mybatis</groupId>
			<artifactId>mybatis</artifactId>
			<version>3.5.0</version>
		</dependency>
		<!-- https://mvnrepository.com/artifact/org.mybatis.generator/mybatis-generator-core -->
		<dependency>
			<groupId>org.mybatis.generator</groupId>
			<artifactId>mybatis-generator-core</artifactId>
			<version>1.3.7</version>
		</dependency>
		<!-- https://mvnrepository.com/artifact/org.springframework/spring-context -->
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-context</artifactId>
			<version>5.1.0.RELEASE</version>
		</dependency>
		<!-- https://mvnrepository.com/artifact/org.mybatis/mybatis-spring -->
		<dependency>
			<groupId>org.mybatis</groupId>
			<artifactId>mybatis-spring</artifactId>
			<version>2.0.0</version>
		</dependency>
		<!-- https://mvnrepository.com/artifact/org.springframework/spring-test -->
		<dependency>
		    <groupId>org.springframework</groupId>
		    <artifactId>spring-test</artifactId>
		    <version>5.1.0.RELEASE</version>
		    <!-- <scope>test</scope> -->
		</dependency>
	</dependencies>

</project>

App类引入的包名如下：

​

之后我们编写测试代码如下：

package com.breeze;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import com.breeze.mapper.EmployeeMapper;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath:applicationContext.xml")
public class App {

	@Autowired
	private EmployeeMapper employeeMapper;
	
	//·查询employee表中所有的数据
	@Test
	public void testSelectAll() throws Exception {
		employeeMapper.selectAll().forEach(System.out::println);
	}
}

然后，开始运行，选中testSelectAll()方法，鼠标右键，Run As，2 Junit Test

很不幸，运行报错，

​

不要急，我们来看看报的什么错，在控制台（Console）我们看到下列语句：

 org.springframework.beans.MethodInvocationException: Property 'dataSource' threw exception; nested exception is java.lang.NoClassDefFoundError: org/springframework/jdbc/datasource/TransactionAwareDataSourceProxy

上面写着NoClassDefFoundError：java.lang.NoClassDefFoundError: org/springframework/jdbc/datasource/TransactionAwareDataSourceProxy

这是说我们没有spring-jdbc这个jar包，同样地，我们在pom.xml文件中加入下面的依赖：

<!-- https://mvnrepository.com/artifact/org.springframework/spring-jdbc -->
<dependency>
	<groupId>org.springframework</groupId>
	<artifactId>spring-jdbc</artifactId>
	<version>5.1.0.RELEASE</version>
</dependency>

保存之后，再重新运行，就成功查询了：

​

恰好与我们数据库中的数据是一致的

此时，我们的Spring和MyBatis整合成功。

五，提供Service组件

我们提供一个service组件，把mapper注入给service。

在service包下新建一个接口（interface），命名为IEmployeeService，然后将EmployeeMapper.java中的几个方法拷贝过来：

我做了小小的改动，我把删除，插入，更新这3个方法的返回值改为void,代码如下：

​

再在service包下新建一个包impl，在impl包里写一个实现类EmployeeServiceImpl去实现IEmployeeService接口：

​

再将EmployeeMapper注入进来，代码如下：

package com.breeze.service.impl;

import java.util.List;

import com.breeze.domain.Employee;
import com.breeze.mapper.EmployeeMapper;
import com.breeze.service.IEmployeeService;

public class EmployeeServiceImpl implements IEmployeeService{

	private EmployeeMapper employeeMapper;
	
	public void setEmployeeMapper(EmployeeMapper employeeMapper) {
		this.employeeMapper = employeeMapper;
	}
	
	public void deleteByPrimaryKey(Long id) {
		employeeMapper.deleteByPrimaryKey(id);
	}

	public void insert(Employee record) {
		employeeMapper.insert(record);
	}

	public Employee selectByPrimaryKey(Long id) {
		return employeeMapper.selectByPrimaryKey(id);
	}

	public List<Employee> selectAll() {
		return employeeMapper.selectAll();
	}

	public void updateByPrimaryKey(Employee record) {
		employeeMapper.updateByPrimaryKey(record);
	}

}

在applicationContext.xml文件中添加有关service的配置：

	<!-- ·创建Service对象 -->
	<bean id="employeeService" class="com.breeze.service.impl.EmployeeServiceImpl">
		<property name="employeeMapper" ref="employeeMapper"/>
	</bean>

applicationContext.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"
	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">

	<!-- ·加载db.properties文件 -->
	<context:property-placeholder location="classpath:db.properties" system-properties-mode="ENVIRONMENT"/>
	
	<!-- ·配置Druid连接池 -->
	<bean id="druidDataSource" class="com.alibaba.druid.pool.DruidDataSource" init-method="init" destroy-method="close">
		<property name="driverClassName" value="${jdbc.driverClassName}"/>
		<property name="url" value="${jdbc.url}"/>
		<property name="username" value="${jdbc.username}"/>
		<property name="password" value="${jdbc.password}"/>
	</bean>
	
	<!-- ·配置SqlSessionFactory -->
	<bean id="sqlSessionFactoryBean" class="org.mybatis.spring.SqlSessionFactoryBean">
		<!-- 1,关联连接池 -->
		<property name="dataSource" ref="druidDataSource"></property>
		<!-- 2,配置MyBatis属性配置 -->
		<property name="configurationProperties">
			<value>
				lazyLoadingEnabled=true
				aggressiveLazyLoading=false
				lazyLoadTriggerMethods=clone
			</value>
		</property>
		<!-- 3,配置为哪个包中的类起别名 -->
		<property name="typeAliasesPackage" value="com.breeze.domain"/>
		<!-- 4,关联Mapper映射文件 -->
		<property name="mapperLocations" value="classpath:mappers/*Mapper.xml"/>
	</bean>	
	
	<!-- ·配置MapperFactoryBean,Spring帮我们创建Mapper的代理对象 -->
	<bean id="employeeMapper" class="org.mybatis.spring.mapper.MapperFactoryBean">
		<property name="sqlSessionFactory" ref="sqlSessionFactoryBean"/>
		<property name="mapperInterface" value="com.breeze.mapper.EmployeeMapper"></property>
	</bean>
	
	<!-- ·创建Service对象 -->
	<bean id="employeeService" class="com.breeze.service.impl.EmployeeServiceImpl">
		<property name="employeeMapper" ref="employeeMapper"/>
	</bean>
	
</beans>

接下来我们再测试一下：

​

运行testSelectAll2(),

​

查询成功。

六，使用注解方式集成Spring和MyBatis

因为用注解方式开发项目比较常见，所以这一节我们用注解的方式把我们之前写的项目改造一下

先打开applicationContext.xml文件，删掉一下内容：

<!-- ·配置MapperFactoryBean,Spring帮我们创建Mapper的代理对象 -->
<bean id="employeeMapper" class="org.mybatis.spring.mapper.MapperFactoryBean">
	<property name="sqlSessionFactory" ref="sqlSessionFactoryBean"/>
	<property name="mapperInterface" value="com.breeze.mapper.EmployeeMapper"></property>
</bean>
	
<!-- ·创建Service对象 -->
<bean id="employeeService" class="com.breeze.service.impl.EmployeeServiceImpl">
	<property name="employeeMapper" ref="employeeMapper"/>
</bean>

删除之后，我们要配置mapper接口的扫描器：（扫描之后它会帮我们创建代理对象）

	<!-- Mapper接口扫描器 -->
	<bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
		<property name="basePackage" value="com.breeze.mapper"/>
	</bean>

此外，我们还需要配置DI注解解析器和IoC注解解析器：

    <!-- DI注解解析器 -->
	<context:annotation-config/>
	<!-- IoC注解解析器 -->
	<context:component-scan base-package="com.breeze.service"/>

<context:component-scan base-package="com.breeze.service"/>是扫描类上贴的注解，把需要扫描的包设置给它，我的设置是让它扫描com.breeze.service包，也可以把扫描范围扩大，比如写 com.breeze ,这里可以精确到扫描哪个包，能精确尽量精确点。

applicationContext.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"
	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">


	<!-- DI注解解析器 -->
	<context:annotation-config/>
	<!-- IoC注解解析器 -->
	<context:component-scan base-package="com.breeze.service"/>

	<!-- ·加载db.properties文件 -->
	<context:property-placeholder location="classpath:db.properties" system-properties-mode="ENVIRONMENT"/>
	
	<!-- ·配置Druid连接池 -->
	<bean id="druidDataSource" class="com.alibaba.druid.pool.DruidDataSource" init-method="init" destroy-method="close">
		<property name="driverClassName" value="${jdbc.driverClassName}"/>
		<property name="url" value="${jdbc.url}"/>
		<property name="username" value="${jdbc.username}"/>
		<property name="password" value="${jdbc.password}"/>
	</bean>
	
	<!-- ·配置SqlSessionFactory -->
	<bean id="sqlSessionFactoryBean" class="org.mybatis.spring.SqlSessionFactoryBean">
		<!-- 1,关联连接池 -->
		<property name="dataSource" ref="druidDataSource"></property>
		<!-- 2,配置MyBatis属性配置 -->
		<property name="configurationProperties">
			<value>
				lazyLoadingEnabled=true
				aggressiveLazyLoading=false
				lazyLoadTriggerMethods=clone
			</value>
		</property>
		<!-- 3,配置为哪个包中的类起别名 -->
		<property name="typeAliasesPackage" value="com.breeze.domain"/>
		<!-- 4,关联Mapper映射文件 -->
		<property name="mapperLocations" value="classpath:mappers/*Mapper.xml"/>
	</bean>	

	<!-- Mapper接口扫描器 -->
	<bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
		<property name="basePackage" value="com.breeze.mapper"/>
	</bean>
	
</beans>

配好之后，找到service的实现类EmployeeServiceImpl.java，在EmployeeServiceImpl类上贴一个注解：@Service

如下图：

​

接下来，给Service设置mapper，将上图黄色方框中的内容删除，在蓝色方框上面贴@Autowired注解，此时EmployeeServiceImpl.java文件如下：

package com.breeze.service.impl;

import java.util.List;

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

import com.breeze.domain.Employee;
import com.breeze.mapper.EmployeeMapper;
import com.breeze.service.IEmployeeService;

@Service
public class EmployeeServiceImpl implements IEmployeeService{

	@Autowired
	private EmployeeMapper employeeMapper;

	public void deleteByPrimaryKey(Long id) {
		employeeMapper.deleteByPrimaryKey(id);
	}

	public void insert(Employee record) {
		employeeMapper.insert(record);
	}

	public Employee selectByPrimaryKey(Long id) {
		return employeeMapper.selectByPrimaryKey(id);
	}

	public List<Employee> selectAll() {
		return employeeMapper.selectAll();
	}

	public void updateByPrimaryKey(Employee record) {
		employeeMapper.updateByPrimaryKey(record);
	}

}

之后在测试类App中重新运行testSelectAll2()方法，结果如下图：

​

七，添加事务

在applicationContext.xml文件中，增加tx命名空间（去掉版本号）：

​

再加入如下内容：

<!-- Tx注解解析器 -->
<tx:annotation-driven transaction-manager="transactionManager"/>

	<!-- ·事务管理器 -->
	<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
		<property name="dataSource" ref="druidDataSource"/>
	</bean>

此时，applicationContext.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.xsd
		http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd
		http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd">


	<!-- DI注解解析器 -->
	<context:annotation-config/>
	<!-- IoC注解解析器 -->
	<context:component-scan base-package="com.breeze.service"/>
	<!-- Tx注解解析器 -->
	<tx:annotation-driven transaction-manager="transactionManager"/>

	<!-- ·加载db.properties文件 -->
	<context:property-placeholder location="classpath:db.properties" system-properties-mode="ENVIRONMENT"/>
	
	<!-- ·配置Druid连接池 -->
	<bean id="druidDataSource" class="com.alibaba.druid.pool.DruidDataSource" init-method="init" destroy-method="close">
		<property name="driverClassName" value="${jdbc.driverClassName}"/>
		<property name="url" value="${jdbc.url}"/>
		<property name="username" value="${jdbc.username}"/>
		<property name="password" value="${jdbc.password}"/>
	</bean>
	
	<!-- ·配置SqlSessionFactory -->
	<bean id="sqlSessionFactoryBean" class="org.mybatis.spring.SqlSessionFactoryBean">
		<!-- 1,关联连接池 -->
		<property name="dataSource" ref="druidDataSource"></property>
		<!-- 2,配置MyBatis属性配置 -->
		<property name="configurationProperties">
			<value>
				lazyLoadingEnabled=true
				aggressiveLazyLoading=false
				lazyLoadTriggerMethods=clone
			</value>
		</property>
		<!-- 3,配置为哪个包中的类起别名 -->
		<property name="typeAliasesPackage" value="com.breeze.domain"/>
		<!-- 4,关联Mapper映射文件 -->
		<property name="mapperLocations" value="classpath:mappers/*Mapper.xml"/>
	</bean>	

	<!-- Mapper接口扫描器 -->
	<bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
		<property name="basePackage" value="com.breeze.mapper"/>
	</bean>
	
	<!-- ·事务管理器 -->
	<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
		<property name="dataSource" ref="druidDataSource"/>
	</bean>
	
</beans>

在EmployeeServiceImpl类上贴一个注解：@Transactional

如下图：

​

八，Spring和SpringMVC的集成

第一步，添加springmvc的依赖，在pom.xml文件中添加如下依赖：

<!-- https://mvnrepository.com/artifact/org.springframework/spring-webmvc -->
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-webmvc</artifactId>
			<version>5.1.0.RELEASE</version>
		</dependency>

保存之后会为我们导入下面2个jar包：

​

第二步，在src/main/resources包下新建一个springmvc的配置文件，名字叫mvc.xml

和创建applicationContext.xml文件一样，先创建一个Spring Bean Configuration File文件，命名为mvc.xml,建好之后，添加mvc和context命名空间：

​

​

接下来，我们要在web.xml中配置2个东西，一个是前端控制器，另一个是字符过滤器

配好之后，web.xml是这样的：

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee
                      http://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd"
	version="3.1">

	<!-- 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>
			<param-value>classpath:mvc.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>
		<url-pattern>/</url-pattern>
	</servlet-mapping>

	<!-- ·字符过滤器 -->
	<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>
	</filter>
	<filter-mapping>
		<filter-name>CharacterEncodingFilter</filter-name>
		<url-pattern>/*</url-pattern>
	</filter-mapping>
</web-app>

然后，我们开始配置mvc.xml

1，引入后台的bean配置（连接池，数据源，Mapper，service，事务等）

2，mvc注解解析器

3，静态资源处理

现在我们使用jsp做开发，视图解析器最好配一个前缀和后缀，否则我们在访问资源的时候会写上很长的路径，所以

4，配置视图解析器的前缀和后缀

配置如下：

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

	<!-- ·引入后台的bean配置（连接池，数据源，Mapper，service，事务等） -->
	<import resource="classpath:applicationContext.xml"/>
	<context:component-scan base-package="com.breeze"/>
	<!-- mvc注解解析器 -->
	<mvc:annotation-driven/>
	<!-- ·静态资源处理 -->
	<mvc:default-servlet-handler/>
	<!-- ·视图解析器的前缀和后缀 -->
	<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
		<property name="prefix" value="/WEB-INF/views/"/>
		<property name="suffix" value=".jsp"/>
	</bean>
</beans>

注意，上面我们配置了<context:component-scan base-package="com.breeze"/>，我们在applicationContext.xml中也配置了<context:component-scan base-package="com.breeze"/>，这两个地方只要有一个地方配置就行了，为了看起来清晰一点，我把applicationContext.xml中的注释掉了，保留这里的。

在WEB-INF里面创建2个jsp，目录结构如下：

​

input.jsp:

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<%@ taglib uri="http://java.sun.com/jsp/jstl/fmt" prefix="fmt" %>
<!DOCTYPE html>
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Insert title here</title>
</head>
<body>
	<h3>编辑界面</h3>
	<form action="/employee/saveOrUpdate" method="post">
				 <input type="hidden" name="id" value="${employee.id}">
		姓&emsp;名:<input type="text" name="name" value="${employee.name}"/><br/>
		密&emsp;码:<input type="password" name="password" value="${employee.password}"/><br/>
		入职日期:<input type="date" name="hiredate" value="<fmt:formatDate 
			value="${employee.hiredate}" pattern="yyyy-MM-dd"/>"/><br/>
		<input type="submit" value="保存">
	</form>
</body>
</html>

list.jsp

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
<%@ taglib uri="http://java.sun.com/jsp/jstl/fmt" prefix="fmt" %>
<!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="/employee/input">add</a>
	<table width="80%" border="1" cellpadding="0" cellspacing="0">
		<tr>
			<th>ID</th>
			<th>name</th>
			<th>password</th>
			<th>hiredate</th>
			<th>option</th>
		</tr>
		<c:forEach items="${employees}" var="e">
			<tr align="center">
				<td>${e.id}</td>
				<td>${e.name}</td>
				<td>${e.password}</td>
				<td><fmt:formatDate value="${e.hiredate}" pattern="yyyy-MM-dd"/></td>
				<td>
					<a href="/employee/delete?id=${e.id}">delete</a>
					<a href="/employee/input?id=${e.id}">edit</a>
				</td>
			</tr>
		</c:forEach>
	</table>
</body>
</html>

这时，我们发现上面的项目报错，这时因为我们缺少2个依赖：

<!-- Servlet-API -->
<dependency>
	<groupId>javax.servlet</groupId>
	<artifactId>javax.servlet-api</artifactId>
	<version>3.1.0</version>
	<scope>provided</scope>
</dependency>
<!-- JSTL标签库 -->
<dependency>
	<groupId>jstl</groupId>
	<artifactId>jstl</artifactId>
	<version>1.2</version>
</dependency>

将这两个依赖加入，报错就会消失。

下面我们开始写Controller：

在Controller包下新建一个Class，命名为EmployeeController，EmployeeController.java里面的代码如下：

package com.breeze.controller;

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

import com.breeze.domain.Employee;
import com.breeze.service.IEmployeeService;

@Controller
@RequestMapping("/employee")
public class EmployeeController {

	@Autowired
	private IEmployeeService employeeService;

	// ·列表
	@RequestMapping("/list")
	public String list(Model model) {
		model.addAttribute("employees", employeeService.selectAll());
		return "employee/list";
	}

	// ·删除
	@RequestMapping("/delete")
	public String delete(Long id) {
		employeeService.deleteByPrimaryKey(id);
		return "redirect:/employee/list";
	}

	// ·进入编辑页面
	@RequestMapping("/input")
	public String insert(Long id, Model model) {
		if (id != null) {
			employeeService.selectByPrimaryKey(id);
			model.addAttribute("employee", employeeService.selectByPrimaryKey(id));
		}
		return "employee/input";
	}

	// ·保存或更新操作
	@RequestMapping("/saveOrUpdate")
	public String saveOrUpdate(Employee employee) {
		if (employee.getId() == null) {
			employeeService.insert(employee);
		} else {
			employeeService.updateByPrimaryKey(employee);
		}
		return "redirect:/employee/list";
	}
}

接下来就准备部署运行项目了

在pom.xml文件里加入2个插件的依赖：

<!--Java编译器插件 -->
			<plugin>
				<groupId>org.apache.maven.plugins</groupId>
				<artifactId>maven-compiler-plugin</artifactId>
				<version>3.6.1</version>
				<configuration>
					<source>1.8</source>
					<target>1.8</target>
					<encoding>UTF-8</encoding>
				</configuration>
			</plugin>
			<!--Tomcat7插件 -->
			<plugin>
				<groupId>org.apache.tomcat.maven</groupId>
				<artifactId>tomcat7-maven-plugin</artifactId>
				<version>2.2</version>
				<configuration>
					<uriEncoding>UTF-8</uriEncoding>
					<path>/</path>
					<port>8080</port>
				</configuration>
			</plugin>

最后，pom.xml:

<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/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0</modelVersion>
	<groupId>com.breeze</groupId>
	<artifactId>SSM1</artifactId>
	<version>0.0.1-SNAPSHOT</version>
	<packaging>war</packaging>

	<build>
		<plugins>
			<!--Java编译器插件 -->
			<plugin>
				<groupId>org.apache.maven.plugins</groupId>
				<artifactId>maven-compiler-plugin</artifactId>
				<version>3.6.1</version>
				<configuration>
					<source>1.8</source>
					<target>1.8</target>
					<encoding>UTF-8</encoding>
				</configuration>
			</plugin>
			<!--Tomcat7插件 -->
			<plugin>
				<groupId>org.apache.tomcat.maven</groupId>
				<artifactId>tomcat7-maven-plugin</artifactId>
				<version>2.2</version>
				<configuration>
					<uriEncoding>UTF-8</uriEncoding>
					<path>/</path>
					<port>8080</port>
				</configuration>
			</plugin>
		</plugins>
	</build>

	<dependencies>
		<!-- https://mvnrepository.com/artifact/junit/junit -->
		<dependency>
			<groupId>junit</groupId>
			<artifactId>junit</artifactId>
			<version>4.12</version>
			<!-- <scope>test</scope> -->
		</dependency>
		<!-- https://mvnrepository.com/artifact/org.slf4j/slf4j-log4j12 -->
		<dependency>
			<groupId>org.slf4j</groupId>
			<artifactId>slf4j-log4j12</artifactId>
			<version>1.7.25</version>
			<!-- <scope>test</scope> -->
		</dependency>
		<!-- https://mvnrepository.com/artifact/mysql/mysql-connector-java -->
		<dependency>
			<groupId>mysql</groupId>
			<artifactId>mysql-connector-java</artifactId>
			<version>5.1.40</version>
		</dependency>
		<!-- https://mvnrepository.com/artifact/com.alibaba/druid -->
		<dependency>
			<groupId>com.alibaba</groupId>
			<artifactId>druid</artifactId>
			<version>1.1.19</version>
		</dependency>
		<!-- https://mvnrepository.com/artifact/org.mybatis/mybatis -->
		<dependency>
			<groupId>org.mybatis</groupId>
			<artifactId>mybatis</artifactId>
			<version>3.5.0</version>
		</dependency>
		<!-- https://mvnrepository.com/artifact/org.mybatis.generator/mybatis-generator-core -->
		<dependency>
			<groupId>org.mybatis.generator</groupId>
			<artifactId>mybatis-generator-core</artifactId>
			<version>1.3.7</version>
		</dependency>
		<!-- https://mvnrepository.com/artifact/org.springframework/spring-context -->
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-context</artifactId>
			<version>5.1.0.RELEASE</version>
		</dependency>
		<!-- https://mvnrepository.com/artifact/org.mybatis/mybatis-spring -->
		<dependency>
			<groupId>org.mybatis</groupId>
			<artifactId>mybatis-spring</artifactId>
			<version>2.0.0</version>
		</dependency>
		<!-- https://mvnrepository.com/artifact/org.springframework/spring-test -->
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-test</artifactId>
			<version>5.1.0.RELEASE</version>
			<!-- <scope>test</scope> -->
		</dependency>
		<!-- https://mvnrepository.com/artifact/org.springframework/spring-jdbc -->
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-jdbc</artifactId>
			<version>5.1.0.RELEASE</version>
		</dependency>
		<!-- https://mvnrepository.com/artifact/org.springframework/spring-webmvc -->
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-webmvc</artifactId>
			<version>5.1.0.RELEASE</version>
		</dependency>
		<!-- Servlet-API -->
		<dependency>
			<groupId>javax.servlet</groupId>
			<artifactId>javax.servlet-api</artifactId>
			<version>3.1.0</version>
			<scope>provided</scope>
		</dependency>
		<!-- JSTL标签库 -->
		<dependency>
			<groupId>jstl</groupId>
			<artifactId>jstl</artifactId>
			<version>1.2</version>
		</dependency>
	</dependencies>

</project>

此时，我们发现项目报错，但是子项目却没有报错：

​

此时我们需要这样：

​

然后，小叉叉就没了。

开始运行项目：

选中项目，右键：

​

选择Maven build...

​

出现下面的输出，中间没有报错，说明启动成功：

​

打开浏览器，在地址栏输入：localhost:8080/employee/list     再按Enter键：

​

就可以进行简单的增删改查了

咦？怎么只能删除，增加和修改怎么报400错误呢？

​

这是因为我们在Employee类中定义了一个日期字段：private Date hiredate;  这个要特殊处理一下：

在这个字段上贴一个注解，把格式固定一下，如下图：

​

好了，再重新启动一下就可以了：

注意，重新启动之前一定要先关闭服务，否则会导致端口冲突，启动失败。关闭如下：

​

重启之后，就可以了。

启动之后，我们点击左上角add添加一条数据，如下：

​

插入之后，发现中文乱码：

​

这需要我们设置一下编码：

在db.properties文件中，在 jdbc.url=jdbc:mysql://localhost:3306/springdemo 后面添加 

?useUnicode=true&characterEncoding=UTF-8  如下图：

​

好了，再重新启动一下就好了，这次真的好了

不知道你们成功了没？反正我是成功了。祝你好运哦...

后记：

首先，我是一只菜鸟，我也不怎么会，我所能做的是，把我所知道的尽可能详细，这篇博客是我写的第二篇（第一篇是几年前写的只有几行，我删了），我是很认真写的，前后大概花了我将近30个小时，但不知道你们的观感怎么样，希望能对需要的人有所帮助，谢谢。