SSM整合可以作为学习借鉴

SSM整合概念说明

整合思路

1. 编写Spring配置文件 测试是否成功
2. 编写SpringMVC配置文件 测试是否成功
3. 整合Spring和SpringMVC 测试
4. 编写Mybati配置文件
5. 整合mybatis和Spring 测试
6. SSM三个一起整合 测试

点击Finish完成

可以看见文件目录结构，这里idea的bug原因，没有java跟resources目录，为了符合maven目录结构

选择其中的java跟resources目录，右键

创建一个Test包，这里，注意是在<font color="red>src上面创建


maven结构已经满足，引入依赖，相当于复制jar包到项目中

扫描二维码关注公众号，回复： 13125322 查看本文章

<?xml version="1.0" encoding="UTF-8"?>
<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">
  <!-- pom版本的项目描述。-->
  <modelVersion>4.0.0</modelVersion>
  <!-- 坐标 -->
  <groupId>club.adger</groupId>
  <artifactId>ssm-project</artifactId>
  <version>1.0-SNAPSHOT</version>
  <!-- 打包方式 web项目 一定war包 其他为jar 如果是maven拆分聚合多模块，父工程一定是pom-->
  <packaging>war</packaging>

  <!-- 名字 可以删除 这两个-->
  <name>ssm-project Maven Webapp</name>
  <!-- FIXME change it to the project's website -->
  <url>http://www.example.com</url>

  <!-- 版本控制 -->
  <properties>
    <!-- 项目构建编译之后输出编码 -->
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <!-- 编译源代码的版本 -->
    <maven.compiler.source>1.8</maven.compiler.source>
    <maven.compiler.target>1.8</maven.compiler.target>
    <!-- Spring版本 -->
    <spring.version>5.2.7.RELEASE</spring.version>
    <!-- 日志输出版本 -->
    <slf4j.version>1.7.30</slf4j.version>
    <log4j.version>1.2.12</log4j.version>
    <!-- 驱动版本 -->
    <mysql.version>5.1.6</mysql.version>
    <!-- mybatis版本 -->
    <mybatis.version>3.5.5</mybatis.version>
    <!-- 跳过单元测试 就是会不会编译测试类 -->
    <maven.test.skip>true</maven.test.skip>
  </properties>

  <dependencies>
    <!-- Spring AOP相关的技术 -->
    <dependency>
      <groupId>org.aspectj</groupId>
      <artifactId>aspectjweaver</artifactId>
      <version>1.9.5</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>

    <!-- SpringMVC 依赖 -->
    <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>

    <!-- Spring单元测试 -->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-test</artifactId>
      <version>${spring.version}</version>
    </dependency>
    <!-- Spring 事务 -->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-tx</artifactId>
      <version>${spring.version}</version>
    </dependency>

    <!-- SpringJDBC模板技术 SpringTemplate-->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-jdbc</artifactId>
      <version>${spring.version}</version>
    </dependency>

    <!-- 单元测试 -->
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.13</version>
      <!-- 这里的 <scope></scope>代表maven中的 测试范围 表示依赖项目仅仅参与测试相关的工作，包括测试代码的编译，执行-->
      <scope>compile</scope>
    </dependency>

    <!-- mysql驱动包 -->
    <dependency>
      <groupId>mysql</groupId>
      <artifactId>mysql-connector-java</artifactId>
      <version>${mysql.version}</version>
    </dependency>

    <!--
    servlet的依赖
    <scope>provided</scope>
    provided 避免 jar包 冲突 因为tomcat中也有servlet-api
    compile，缺省值，适用于所有阶段，会随着项目一起发布。
    provided，类似compile，期望JDK、容器或使用者会提供这个依赖。如servlet.jar。
    runtime，只在运行时使用，如JDBC驱动，适用运行和测试阶段。
    test，只在测试时使用，用于编译和运行测试代码。不会随项目发布。
    system，类似provided，需要显式提供包含依赖的jar，Maven不会在Repository中查找它。
    -->
    <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>
    <!-- jsp 表达式 -->
    <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 -->

    <!-- mybatis 需要的jar包-->
    <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.3.0</version>
    </dependency>

    <!-- c3p0连接池的jar包-->
    <!-- https://mvnrepository.com/artifact/c3p0/c3p0 -->
    <dependency>
      <groupId>com.mchange</groupId>
      <artifactId>c3p0</artifactId>
      <version>0.9.5.2</version>
    </dependency>
  </dependencies>

  <build>
    <finalName>ssm-project</finalName>
    <!-- maven插件 -->
    <pluginManagement><!-- lock down plugins versions to avoid using Maven defaults (may be moved to parent pom) -->
      <plugins>
        <plugin>
          <artifactId>maven-clean-plugin</artifactId>
          <version>3.1.0</version>
        </plugin>
        <!-- see http://maven.apache.org/ref/current/maven-core/default-bindings.html#Plugin_bindings_for_war_packaging -->
        <plugin>
          <artifactId>maven-resources-plugin</artifactId>
          <version>3.0.2</version>
        </plugin>
        <plugin>
          <artifactId>maven-compiler-plugin</artifactId>
          <version>3.8.0</version>
        </plugin>
        <plugin>
          <artifactId>maven-surefire-plugin</artifactId>
          <version>2.22.1</version>
        </plugin>
        <plugin>
          <artifactId>maven-war-plugin</artifactId>
          <version>3.2.2</version>
        </plugin>
        <plugin>
          <artifactId>maven-install-plugin</artifactId>
          <version>2.5.2</version>
        </plugin>
        <plugin>
          <artifactId>maven-deploy-plugin</artifactId>
          <version>2.8.2</version>
        </plugin>
      </plugins>
    </pluginManagement>
  </build>
</project>

编写MVC模式的包，这里我已经提前写好了测试类

其中Service中写测试Spring环境的接口跟实现类，让Spring来管理这个Service

接口

package club.adger.service;

/**
 * Created with IntelliJ IDEA.
 *
 * @Auther: Adger
 * @Date: 2020/07/01/7:34
 */
public interface TestService {
    
    
    void TestSpring();
}

实现类

package club.adger.service.impl;

import club.adger.service.TestService;
import org.springframework.stereotype.Service;

/**
 * Created with IntelliJ IDEA.
 *
 * @Auther: Adger
 * @Date: 2020/07/01/7:34
 */
@Service("testServiceImpl")
public class TestServiceImpl implements TestService {
    
    
    @Override
    public void TestSpring() {
    
    
        System.out.println("Spring环境成功");
    }
}

编写Spring配置文件

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns: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">

    <!-- 开启注解扫描 Spring只负责业务层跟持久层-->
    <context:component-scan base-package="club.adger">
        <!-- exclude不包含 不扫描 controller-->
        <context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
    </context:component-scan>
</beans>

测试Spring环境

package club.adger.TestSpring;

import club.adger.service.TestService;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
 * Created with IntelliJ IDEA.
 *
 * @Auther: Adger
 * @Date: 2020/07/01/7:41
 */
public class TestServiceImplTest{
    
    
    /**
     * 1.加载配置文件
     * 2.获取对象
     * 3.调用方法
     */
    @Test
    public void testTestSpring() {
    
    
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("classpath:spring/applicationContext.xml");
        TestService testService = (TestService) applicationContext.getBean("testServiceImpl");
        testService.TestSpring();
    }
}

运行测试，可以看见，成功了

直接在resouces目录下面放置log4j.properties文件

这个日志文件是比较多的输出，下图中还有一个简化版本的

# Log4j有三个主要的组件：Loggers(记录器)，Appenders (输出源)和Layouts(布局)
# Loggers组件在此系统中被分为五个级别：DEBUG、INFO、WARN、ERROR和FATAL。这五个级别是有顺序的，DEBUG < INFO < WARN < ERROR < FATAL，
# 禁用和使用日志请求只是Log4j的基本功能，Log4j日志系统还提供许多强大的功能，比如允许把日志输出到不同的地方，如控制台（Console）、文件（Files）等
log4j.rootLogger=debug,info,error,DEBUG,CONSOLE

log4j.appender.CONSOLE=org.apache.log4j.ConsoleAppender
log4j.appender.CONSOLE.layout=org.apache.log4j.PatternLayout
# %d{yyyy-MM-dd-HH-mm} 年月日
log4j.appender.CONSOLE.layout.ConversionPattern=%d{yyyy-MM-dd-HH-mm} [%t] [%c] [%p] - %m%n

log4j.logger.info=info
log4j.appender.info=org.apache.log4j.DailyRollingFileAppender
log4j.appender.info.layout=org.apache.log4j.PatternLayout
log4j.appender.info.layout.ConversionPattern=%d{yyyy-MM-dd-HH-mm} [%t] [%c] [%p] - %m%n
log4j.appender.info.datePattern='.'yyyy-MM-dd
log4j.appender.info.Threshold = info
log4j.appender.info.append=true
# 这里的第一个一般是项目名 这里日志输出 为 相对路径 因为 在 Linux中是没有盘符的概念的
log4j.appender.info.File=/ssm/logs/info/info.log

log4j.logger.error=error
log4j.appender.error=org.apache.log4j.DailyRollingFileAppender
log4j.appender.error.layout=org.apache.log4j.PatternLayout
log4j.appender.error.layout.ConversionPattern=%d{yyyy-MM-dd-HH-mm} [%t] [%c] [%p] - %m%n
log4j.appender.error.datePattern='.'yyyy-MM-dd
log4j.appender.error.Threshold = error
log4j.appender.error.append=true
log4j.appender.error.File=/ssm/logs/error/error.log

log4j.logger.DEBUG=debug
log4j.appender.DEBUG=org.apache.log4j.DailyRollingFileAppender
log4j.appender.DEBUG.layout=org.apache.log4j.PatternLayout
log4j.appender.DEBUG.layout.ConversionPattern=%d{yyyy-MM-dd-HH-mm} [%t] [%c] [%p] - %m%n
log4j.appender.DEBUG.datePattern='.'yyyy-MM-dd
log4j.appender.DEBUG.Threshold = debug
log4j.appender.DEBUG.append=true
log4j.appender.DEBUG.File=/ssm/logs/debug/debug.log

简化版本的log4j

log4j.appender.stdout.Target = System.out
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.layout = org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern =  %d{ABSOLUTE} %5p %c{1}:%L - %m%n
log4j.rootLogger=INFO, stdout

下图被更改过下，不用太在意

可以看见log4j的日志输出在文件夹

配置SpringMVC

编写SpringMVC配置文件

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

    <!--开启注解扫描，只扫描包含Controller注解-->
    <context:component-scan base-package="club.adger">
        <context:include-filter type="annotation" expression="org.springframework.stereotype.Controller" />
    </context:component-scan>

    <!--配置的视图解析器对象-->
    <bean id="internalResourceViewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <property name="prefix" value="/WEB-INF/pages/"/>
        <property name="suffix" value=".jsp"/>
    </bean>

    <!--过滤静态资源-->
    <!--<mvc:resources location="/css/" mapping="/css/**" />
    <mvc:resources location="/images/" mapping="/images/**" />
    <mvc:resources location="/js/" mapping="/js/**" />-->
    <mvc:resources location="/static/" mapping="/static/**" />

    <!--开启SpringMVC注解的支持-->
    <mvc:annotation-driven/>
	
	<!-- 后续可能你们会配置拦截器吗，文件上传 -->
</beans>

然后配置web.xml
这里换成了，4.0的配置头，他就不会报错了

<!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>
  <!-- 配置前端控制器 所有请求走这里 -->
  <servlet>
    <servlet-name>dispatcherServlet</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    <!-- 加载SpringMVC的配置文件 -->
    <init-param>
      <param-name>contextConfigLocation</param-name>
      <param-value>classpath:Spring/springMVC.xml</param-value>
    </init-param>
    <!-- 启动服务器 创建该Servlet-->
    <load-on-startup>1</load-on-startup>
  </servlet>
  <servlet-mapping>
    <servlet-name>dispatcherServlet</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>

这里属于idea的误报问题，可以选择不让他误报，我这里喜欢换版本搞定

<?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_4_0.xsd"
         version="4.0">
  <!-- 配置前端控制器 所有请求走这里 -->
  <servlet>
    <servlet-name>dispatcherServlet</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    <!-- 加载SpringMVC的配置文件 -->
    <init-param>
      <param-name>contextConfigLocation</param-name>
      <param-value>classpath:Spring/springMVC.xml</param-value>
    </init-param>
    <!-- 启动服务器 创建该Servlet-->
    <load-on-startup>1</load-on-startup>
  </servlet>
  <servlet-mapping>
    <servlet-name>dispatcherServlet</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>

<?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_4_0.xsd"
         version="4.0">

编写一个Controller用于测试

package club.adger.controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.GetMapping;

/**
 * Created with IntelliJ IDEA.
 *
 * @Auther: Adger
 * @Date: 2020/07/01/8:39
 */
@Controller
public class TestController {
    
    

    @GetMapping("/Test")
    public String testSpringMVC(){
    
    
        System.out.println("SpringMVC环境成功");
        return "springMVC";
    }
}

编写jsp页面

<%--
  Created by IntelliJ IDEA.
  User: Adger
  Date: 2020/7/1
  Time: 8:38
  To change this template use File | Settings | File Templates.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
<a href="/Test">测试</a>
</body>
</html>

配置tomcat运行测试

选择第二个，这两个区别就是 在热编译那里，

启动发现控制台，乱码

tomcat乱码问题解决

首先这个只是输出在控制台乱码问题，并没有在页面上造成乱码问题，解决办法

改变之后，重新启动发现正常

可以看见没有什么问题

Spring整合SpringMVC

怎么算整合成功，调用业务层能成功就代表成功了，这里我们从头到尾是没有加载Spring的，里面的扫描没有生效，就没有加到ioc的容器里面去，就没有注入，启动tomcat的时候也加因该加载Spring当时，当时加载了SpringMVC，启动服务器加载Spring

配置开始，需要一个监听器，肯定是写在web.xml里面的啊，JavaWeb三大组件：　Servlet，Filter，Listener。

<!-- spring-web 提供 -->
  <!-- 配置Spring监听器 默认只加载WEB-INF目录下的applicationContext.xml -->
  <listener>
    <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
  </listener>
  <!-- 指定加载位置 -->
  <context-param>
    <param-name>contextConfigLocation</param-name>
    <param-value>classpath:Spring/applicationContext.xml</param-value>
  </context-param>

继承了ContextLoader实现了ServletContextListener，点击源码查看

public interface ServletContextListener extends EventListener {
    
    
    void contextInitialized(ServletContextEvent var1);

    void contextDestroyed(ServletContextEvent var1);
}

编写测试方法

package club.adger.controller;

import club.adger.service.TestService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.GetMapping;

/**
 * Created with IntelliJ IDEA.
 *
 * @Auther: Adger
 * @Date: 2020/07/01/8:39
 */
@Controller
public class TestController {
    
    
    @Autowired
    private TestService testService;

    @GetMapping("/Test")
    public String testSpringMVC(){
    
    
        System.out.println("SpringMVC环境成功");
        // 如果注入成功这里输出地址对象，Spring跟SPringMVC就整合成功了
        System.out.println(testService);
        testService.TestSpring();
        return "springMVC";
    }
}

页面点击

成功 中间对象地址输出了也，找到了实现类

搭建mybatis环境 再去想整合的事情

这里在创建一个装实体类的包，里面承载Dao数据模型，看到持久层框架那是不是应该操作数据库对吧，导入SQL文件

/*
 Navicat Premium Data Transfer

 Source Server         : learn
 Source Server Type    : MySQL
 Source Server Version : 50730
 Source Host           : localhost:3306
 Source Schema         : test

 Target Server Type    : MySQL
 Target Server Version : 50730
 File Encoding         : 65001

 Date: 01/07/2020 17:32:14
*/

SET NAMES utf8mb4;
SET FOREIGN_KEY_CHECKS = 0;

-- ----------------------------
-- Table structure for testmybatis
-- ----------------------------
DROP TABLE IF EXISTS `testmybatis`;
CREATE TABLE `testmybatis`  (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `username` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci NULL DEFAULT NULL,
  `password` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci NULL DEFAULT NULL,
  PRIMARY KEY (`id`) USING BTREE
) ENGINE = InnoDB AUTO_INCREMENT = 4 CHARACTER SET = utf8mb4 COLLATE = utf8mb4_general_ci ROW_FORMAT = Dynamic;

-- ----------------------------
-- Records of testmybatis
-- ----------------------------
INSERT INTO `testmybatis` VALUES (1, '刘杰', '123');
INSERT INTO `testmybatis` VALUES (2, '刘勇', '123');
INSERT INTO `testmybatis` VALUES (3, '黄涛', '123');

SET FOREIGN_KEY_CHECKS = 1;

创建entity包，写实体类

package club.adger.entity;

/**
 * Created with IntelliJ IDEA.
 *
 * @Auther: Adger
 * @Date: 2020/07/01/17:29
 */
public class TestMybatis {
    
    
    private Integer id;
    private String username;
    private String password;

    public Integer getId() {
    
    
        return id;
    }

    public void setId(Integer id) {
    
    
        this.id = id;
    }

    public String getUsername() {
    
    
        return username;
    }

    public void setUsername(String username) {
    
    
        this.username = username;
    }

    public String getPassword() {
    
    
        return password;
    }

    public void setPassword(String password) {
    
    
        this.password = password;
    }

    /**
     * 方便测试 输出信息 我见过一些伙伴从不重写toString()方法 一个字 牛逼
     * @return
     */
    @Override
    public String toString() {
    
    
        return "TestMybatis{" +
                "id=" + id +
                ", username='" + username + '\'' +
                ", password='" + password + '\'' +
                '}';
    }
}

编写 dao 接口的方法 这里用的是xml方式其中还有注解的方式

package club.adger.dao;

import club.adger.entity.TestMybatis;

import java.util.List;

/**
 * Created with IntelliJ IDEA.
 *
 * @Auther: Adger
 * @Date: 2020/07/01/17:27
 */
public interface TestDao {
    
    
    /**
     * 查询所有
     * @return
     */
    public List<TestMybatis> findAll();
}

编写配置文件

<?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">
<!-- 这里的namespace属性是你dao接口的全限定类名 -->
<mapper namespace="club.adger.dao.TestDao">
    <!-- id是你的 方法名字 不能随便填 resultTyp是你的返回值类型 这里是不建议用 select * 的这里 只是测试-->
    <select id="findAll" resultType="club.adger.entity.TestMybatis">
        select * from testmybatis
    </select>
</mapper>

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
    <!-- 配置连接数据库的信息 这里一般都会放在外部 不会编写内部 -->
    <properties resource="db.properties"></properties>
    <!-- 配置mybatis的环境 -->
    <environments default="mysql">
        <environment id="mysql">
            <!-- 配置事务管理 -->
            <transactionManager type="JDBC"></transactionManager>
            <dataSource type="pooled">
                <property name="driver" value="${jdbc.driver}"/>
                <property name="url" value="${jdbc.url}"/>
                <property name="username" value="${jdbc.username}"/>
                <property name="password" value="${jdbc.password}"/>
            </dataSource>
        </environment>
    </environments>
    <!-- 指定映射文件位置 -->
    <mappers>
        <!-- 配置文件方式 -->
        <mapper resource="mapper/TestDao.xml"/>
            <!-- dao 里面的类会全部被扫到 -->
            <!-- <package name="club.adger.dao"/> -->
    </mappers>
</configuration>

编写测试类

package club.adger.dao;

import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
import org.junit.Test;

import java.io.IOException;
import java.io.InputStream;
import java.util.List;

/**
 * Created with IntelliJ IDEA.
 *
 * @Auther: Adger
 * @Date: 2020/07/01/17:49
 */
public class TestMybatis {
    
    
    /**
     * 1. 加载配置文件 可能加载不到所以会有异常
     * 2. 创建SQlSessionFactory对象
     * 3. 创建SqlSession对象
     * 4. 获取代理对象 没有写实现类 用的代理的方式
     * #### 上面步骤以后如果测试多的话可以放在@BeFore
     *
     * 5. 具体的操作 CRUD
     *
     *  #### 可以放在 @After
     * 6. 关闭 资源
     */
    @Test
    public void testMybatis() throws IOException {
    
    
        InputStream resourceAsStream = Resources.getResourceAsStream("mybatis/mybatis-config.xml");
        SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(resourceAsStream);
        SqlSession sqlSession = factory.openSession();
        TestDao testDao = sqlSession.getMapper(TestDao.class);

        //这里因为 有toString()方法才能打印 注意
        List<club.adger.entity.TestMybatis> dataList = testDao.findAll();
        for (club.adger.entity.TestMybatis testMybatis : dataList) {
    
    
            System.out.println(dataList);
        }
        sqlSession.close();
        resourceAsStream.close();;
    }
}

mybatis中注解方式

只需要在你的方法上面添加相应的注解，不需要mapper中的配置文件，我这里把删除掉

增删改查操作 对照着

@Insert(“SQL语句”) 增加

@Delete(“SQL语句”) 删除

@Update(“修改操作”) 修改

@Select(“SQL语句”) 查询 其中查询是最复杂的

测试 照样输出了

Spring整合Mybatis

这两个怎么才算整合成功 就是Service 能成功的调用到dao对象 然后可以做查询，就算整合成功了 就是把dao生成的代理对象存入到IOC的容器当中

大致三个步骤：1. 配置连接池 2.配置SqlSessionFactory 3. 配置接口所在的包

现在就是让Spring代理存入到IOC容器中去 在applicationContext中配置

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

    <!-- 开启注解扫描 Spring只负责业务层跟持久层-->
    <context:component-scan base-package="club.adger">
        <!-- exclude不包含 不扫描 controller-->
        <context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
    </context:component-scan>

    <!-- Spring整合mybatis框架 引入属性文件，在配置中占位使用-->
    <context:property-placeholder location="classpath:db.properties" />
    <!-- 配置连接池 取个 id 名字-->
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="driverClass" value="${jdbc.driver}"/>
        <!-- 跟外面的db.properties文件对应,方便修改 如果没有配置外部的注意里面如果有参数拼接的话 第一个使用? 后面 使用&amp;  -->
        <property name="jdbcUrl" value="${jdbc.url}"/>
        <property name="user" value="${jdbc.username}"/>
        <property name="password" value="${jdbc.password}"/>
    </bean>
    <!-- 配置SqlSessionFactory 工厂 -->
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <!-- 传入连接池 ref 引入上面的名字-->
        <property name="dataSource" ref="dataSource"></property>
    </bean>
    <!-- 配置接口所在的包 -->
    <bean id="mapperScan" class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <!-- 扫描谁 value写上你的dao包名 -->
        <property name="basePackage" value="club.adger.dao"></property>
    </bean>
</beans>

改造Controller中的方法

package club.adger.controller;

import club.adger.entity.TestMybatis;
import club.adger.service.TestService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.GetMapping;

import java.util.List;

/**
 * Created with IntelliJ IDEA.
 *
 * @Auther: Adger
 * @Date: 2020/07/01/8:39
 */
@Controller
public class TestController {
    
    
    @Autowired
    private TestService testService;

    @GetMapping("/Test")
    public String testSpringMVC(Model model){
    
    
        List<TestMybatis> testMybatisAndSpringList = testService.TestSpring();
        //遍历
        for (TestMybatis testMybatis: testMybatisAndSpringList) {
    
    
            System.out.println(testMybatis);
        }
        // 取一个名字 存入 域对象中
        model.addAttribute("TestList",testMybatisAndSpringList);
        //在界面拿出
        return "springMVC";
    }
}

在Service上改造方法

package club.adger.service.impl;

import club.adger.dao.TestDao;
import club.adger.entity.TestMybatis;
import club.adger.service.TestService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;

/**
 * Created with IntelliJ IDEA.
 *
 * @Auther: Adger
 * @Date: 2020/07/01/7:34
 */
@Service("testServiceImpl")
public class TestServiceImpl implements TestService {
    
    
    /**
     * 注入dao 对象
     */
    @Autowired
    private TestDao testDao;

    @Override
    public List<TestMybatis> TestSpring() {
    
    
        return testDao.findAll();
    }
}

注意Dao上面加上 @Repository 交给 Spring来管理

整套流程就完毕了
页面中编写

<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<%--
  Created by IntelliJ IDEA.
  User: Adger
  Date: 2020/7/1
  Time: 8:43
  To change this template use File | Settings | File Templates.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
    <h1>SpringMVC环境成功</h1>
    ${TestList}
    <!-- 两个属性 items 遍历的集合  var 变量名-->
    <c:forEach items="${TestList}" var="test">
        ${test.id}
        ${test.username}
        ${test.password}
    </c:forEach>
</body>
</html>

启动tomcat测试

可以看见整合成功

在数据库操作中有一个 是转账的案列，要么都成功，要么失败 配置Spring声明式事务管理

众所周知，事务有四大特性（ACID）

1.原子性（Atomicity）事务是一个原子操作，由一系列动作组成。事务的原子性确保动作要么全部完成，要么完全不起作用。

2.一致性（Consistency）事务在完成时，必须是所有的数据都保持一致状态。

3.隔离性（Isolation）并发事务执行之间无影响，在一个事务内部的操作对其他事务是不产生影响，这需要事务隔离级别来指定隔离性。

4.持久性（Durability）一旦事务完成，数据库的改变必须是持久化的。

在企业级应用中，多用户访问数据库是常见的场景，这就是所谓的事务的并发。事务并发所可能存在的问题：
1.脏读：一个事务读到另一个事务未提交的更新数据。
2.不可重复读：一个事务两次读同一行数据，可是这两次读到的数据不一样。
3.幻读：一个事务执行两次查询，但第二次查询比第一次查询多出了一些数据行。
4.丢失更新：撤消一个事务时，把其它事务已提交的更新的数据覆盖了。

我们可以在java.sql.Connection中看到JDBC定义了五种事务隔离级别来解决这些并发导致的问题：

是为了对多表操作，或者是多个数据操作的时候，防止出现，脏数据的一种方法，同时成功，或者同时失败

事务通知配置在Spring中的applicationContext中

 <!-- 配置Spring声明式事务管理 -->
    <!-- 配置事务管理器 -->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <!-- 传入连接池 对象 -->
        <property name="dataSource" ref="dataSource"></property>
    </bean>
    <!-- 配置事务通知 引入事务管理器 事务提交 或者回滚-->
    <tx:advice id="txAdvice" transaction-manager="transactionManager">
        <!-- 定义事务传播属性 -->
        <tx:attributes>
            <!-- 这里代表以 find方法 开头的 具体设置 表示只读的事务-->
            <tx:method name="find*" read-only="true"/>
            <!-- 隔离级别 -->
            <tx:method name="*" isolation="DEFAULT"/>
        </tx:attributes>
    </tx:advice>
    <!-- 配置AOP增强 -->
    <aop:config>
        <!-- 引入 txAdvice pointcut是切入点的表达式 其中 public 可以省略不写* club.adger.service.impl.*ServiceImpl.*(..) 所有方法 -->
        <aop:advisor advice-ref="txAdvice" pointcut="execution(* club.adger.service.impl.*ServiceImpl.*(..))"></aop:advisor>
    </aop:config>

事务通知配置

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

    <!-- 开启注解扫描 Spring只负责业务层跟持久层-->
    <context:component-scan base-package="club.adger">
        <!-- exclude不包含 不扫描 controller-->
        <context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
    </context:component-scan>

    <!-- Spring整合mybatis框架 引入属性文件，在配置中占位使用-->
    <context:property-placeholder location="classpath:db.properties" />
    <!-- 配置连接池 取个 id 名字-->
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="driverClass" value="${jdbc.driver}"/>
        <!-- 跟外面的db.properties文件对应,方便修改 如果没有配置外部的注意里面如果有参数拼接的话 第一个使用? 后面 使用&amp;  -->
        <property name="jdbcUrl" value="${jdbc.url}"/>
        <property name="user" value="${jdbc.username}"/>
        <property name="password" value="${jdbc.password}"/>
    </bean>
    <!-- 配置SqlSessionFactory 工厂 -->
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <!-- 传入连接池 ref 引入上面的名字-->
        <property name="dataSource" ref="dataSource"></property>
    </bean>
    <!-- 配置接口所在的包 -->
    <bean id="mapperScan" class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <!-- 扫描谁 value写上你的dao包名 -->
        <property name="basePackage" value="club.adger.dao"></property>
    </bean>
    <!-- 配置Spring声明式事务管理 -->
    <!-- 配置事务管理器 -->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <!-- 传入连接池 对象 -->
        <property name="dataSource" ref="dataSource"></property>
    </bean>
    <!-- 配置事务通知 引入事务管理器 事务提交 或者回滚-->
    <tx:advice id="txAdvice" transaction-manager="transactionManager">
        <!-- 定义事务传播属性 -->
        <tx:attributes>
            <!-- 这里代表以 find方法 开头的 具体设置 表示只读的事务-->
            <tx:method name="find*" read-only="true"/>
            <!-- 隔离级别 -->
            <tx:method name="*" isolation="DEFAULT"/>
        </tx:attributes>
    </tx:advice>
    <!-- 配置AOP增强 -->
    <aop:config>
        <!-- 引入 txAdvice pointcut是切入点的表达式 其中 public 可以省略不写* club.adger.service.impl.*ServiceImpl.*(..) 所有方法 -->
        <aop:advisor advice-ref="txAdvice" pointcut="execution(* club.adger.service.impl.*ServiceImpl.*(..))"></aop:advisor>
    </aop:config>
</beans>

编写页面的测试数据提交

<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<%--
  Created by IntelliJ IDEA.
  User: Adger
  Date: 2020/7/1
  Time: 8:43
  To change this template use File | Settings | File Templates.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
    <h1>SpringMVC环境成功</h1>
    ${TestList}
    <!-- 两个属性 items 遍历的集合  var 变量名-->
    <c:forEach items="${TestList}" var="test">
        ${test.id}
        ${test.username}
        ${test.password}
    </c:forEach>
    <h1>保存</h1>
    <form action="/Test/save" method="post">
        用户名：<input type="text" name="username"/><br>
        密码：<input type="password" name="password"/><br>
        <input type="submit">
    </form>
</body>
</html>

编写dao方法

编写Service方法

 public void save(TestMybatis testMybatis);

package club.adger.service.impl;

import club.adger.dao.TestDao;
import club.adger.entity.TestMybatis;
import club.adger.service.TestService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.List;

/**
 * Created with IntelliJ IDEA.
 *
 * @Auther: Adger
 * @Date: 2020/07/01/7:34
 */
@Transactional
@Service("testServiceImpl")
public class TestServiceImpl implements TestService {
    
    
    /**
     * 注入dao 对象
     */
    @Autowired
    private TestDao testDao;

    @Override
    public List<TestMybatis> TestSpring() {
    
    
        return testDao.findAll();
    }

    /**
     * 保存的方法
     * @param testMybatis
     */
    @Override
    public void save(TestMybatis testMybatis) {
    
    
        testDao.save(testMybatis);
    }
}

编写Controller方法

package club.adger.controller;

import club.adger.entity.TestMybatis;
import club.adger.service.TestService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;

import java.util.List;

/**
 * Created with IntelliJ IDEA.
 *
 * @Auther: Adger
 * @Date: 2020/07/01/8:39
 */
@Controller
public class TestController {
    
    
    @Autowired
    private TestService testService;

    @GetMapping("/Test")
    public String testSpringMVC(Model model){
    
    
        List<TestMybatis> testMybatisAndSpringList = testService.TestSpring();
        //遍历
        for (TestMybatis testMybatis: testMybatisAndSpringList) {
    
    
            System.out.println(testMybatis);
        }
        // 取一个名字 存入 域对象中
        model.addAttribute("TestList",testMybatisAndSpringList);
        //在界面拿出
        return "springMVC";
    }

    /**
     *
     * @param model
     * @return
     */
    @PostMapping("/Test/save")
    public String save(TestMybatis testMybatis,Model model){
    
    
        testService.save(testMybatis);
        //在界面拿出
        return this.testSpringMVC(model);
    }
}

整合就完毕了

把整合的代码放到码云上面去

你们的控制台可能跟我的窗口不一样，这里需要一点git基础

解决办法 就是设置一下 成git命令行的窗口

搜索 terminal

就行了 不过建议你关闭项目 之后 在外部配 里面只是这一个 项目起作用

git init

稍等一会儿

这里idea中颜色的区分

绿色，已经加入控制暂未提交
红色，未加入版本控制
蓝色，加入，已提交，有改动
白色，加入，已提交，无改动
灰色：版本控制已忽略文件。

这里 .gitgnore是git中的忽略不提交的文件，以前我是 直接 commit的

2020版本idea不知道怎么回事，比以前好些，有好也有坏吧，这里我直接 先 add 加速 暂存区，然后commit ，只需要提交src中和pom文件

可以看见 已经加入了版本控制 变成了绿色 但是还位提交

下一步 点击 commit 下面的 pull 不用点击

可以看见

下面是没有加入的 一定要输入 提交信息

这里我没有去掉检查项，所以会报这个 直接 点两次 commit 我忘记截图了☹ 原谅我

登录码云 自己注册登录一个 建一个仓库

私有的是 别人看不见，也拉取不到

点击创建

你的代码库(repository)可以存放在你的电脑里，同时你也可以把代码库托管到Github的服务器上，这里我用的是 中国版本的github，码云

Ctrl + V 也可以

输入码云上面的用户名和密码 这里我比较尴尬，忘记了用户名和密码，我的一个小技巧，这里需要Chrome浏览器 保存过用户名和密码

默认有

或者F12

就可以看见密码了

输入用户名和密码 点击确定

打开网址可以看见

db.properties强化版本

datasource.connection.driver_class=com.mysql.jdbc.Driver
datasource.connection.url=jdbc:mysql://localhost:3306/
datasource.connection.username=root
datasource.connection.password=123
#连接池保持的最小连接数,default : 3（建议使用）
datasource.connection.minPoolSize=3
#连接池中拥有的最大连接数，如果获得新连接时会使连接总数超过这个值则不会再获取新连接，而是等待其他连接释放，所以这个值有可能会设计地很大,default : 15（建议使用）
datasource.connection.maxPoolSize=15
#连接的最大空闲时间，如果超过这个时间，某个数据库连接还没有被使用，则会断开掉这个连接。如果为0，则永远不会断开连接,即回收此连接。default : 0 单位 s（建议使用）
datasource.connection.maxIdleTime=0
#连接池在无空闲连接可用时一次性创建的新数据库连接数,default : 3（建议使用）
datasource.connection.acquireIncrement=3
#连接池为数据源缓存的PreparedStatement的总数。由于PreparedStatement属于单个Connection,所以这个数量应该根据应用中平均连接数乘以每个连接的平均PreparedStatement来计算。同时maxStatementsPerConnection的配置无效。default : 0（不建议使用）
datasource.connection.maxStatements=0
#连接池为数据源单个Connection缓存的PreparedStatement数，这个配置比maxStatements更有意义，因为它缓存的服务对象是单个数据连接，如果设置的好，肯定是可以提高性能的。为0的时候不缓存。default : 0（看情况而论）
datasource.connection.maxStatementsPerConnection=0
#连接池初始化时创建的连接数,default : 3（建议使用）
datasource.connection.initialPoolSize=3
#用来配置测试空闲连接的间隔时间。测试方式还是上面的两种之一，可以用来解决MySQL8小时断开连接的问题。因为它保证连接池会每隔一定时间对空闲连接进行一次测试，从而保证有效的空闲连接能每隔一定时间访问一次数据库，将于MySQL8小时无会话的状态打破。为0则不测试。default : 0(建议使用)
datasource.connection.idleConnectionTestPeriod=0
#连接池在获得新连接失败时重试的次数，如果小于等于0则无限重试直至连接获得成功。default : 30（建议使用）
datasource.connection.acquireRetryAttempts=30
#如果为true，则当连接获取失败时自动关闭数据源，除非重新启动应用程序。所以一般不用。default : false（不建议使用）
datasource.connection.breakAfterAcquireFailure=false
#性能消耗大。如果为true，在每次getConnection的时候都会测试，为了提高性能,尽量不要用。default : false（不建议使用）
datasource.connection.testConnectionOnCheckout=false
#配置当连接池所有连接用完时应用程序getConnection的等待时间。为0则无限等待直至有其他连接释放或者创建新的连接，不为0则当时间到的时候如果仍没有获得连接，则会抛出SQLException。其实就是acquireRetryAttempts*acquireRetryDelay。default : 0（与上面两个，有重复，选择其中两个都行）
datasource.connection.checkoutTimeout=30000
#如果为true，则在close的时候测试连接的有效性。default : false（不建议使用）
datasource.connection.testConnectionOnCheckin=false
#配置一个表名，连接池根据这个表名用自己的测试sql语句在这个空表上测试数据库连接,这个表只能由c3p0来使用，用户不能操作。default : null（不建议使用）
datasource.connection.automaticTestTable=c3p0TestTable
#连接池在获得新连接时的间隔时间。default : 1000 单位ms（建议使用）
datasource.connection.acquireRetryDelay=1000
#为0的时候要求所有的Connection在应用程序中必须关闭。如果不为0，则强制在设定的时间到达后回收Connection，所以必须小心设置，保证在回收之前所有数据库操作都能够完成。这种限制减少Connection未关闭情况的不是很适用。建议手动关闭。default : 0 单位 s（不建议使用）
datasource.connection.unreturnedConnectionTimeout=0
#这个配置主要是为了快速减轻连接池的负载，比如连接池中连接数因为某次数据访问高峰导致创建了很多数据连接，但是后面的时间段需要的数据库连接数很少，需要快速释放，必须小于maxIdleTime。其实这个没必要配置，maxIdleTime已经配置了。default : 0 单位 s（不建议使用）
datasource.connection.maxIdleTimeExcessConnections=0
#配置连接的生存时间，超过这个时间的连接将由连接池自动断开丢弃掉。当然正在使用的连接不会马上断开，而是等待它close再断开。配置为0的时候则不会对连接的生存时间进行限制。default : 0 单位 s（不建议使用）
datasource.connection.maxConnectionAge=0

applicationContext.xml之mapper映射器配置 其中配置别名

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

    <!-- 开启注解扫描 Spring只负责业务层跟持久层-->
    <context:component-scan base-package="club.adger">
        <!-- exclude不包含 不扫描 controller-->
        <context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
    </context:component-scan>

    <!-- Spring整合mybatis框架 引入属性文件，在配置中占位使用-->
    <context:property-placeholder location="classpath:db.properties" />
    <!-- 配置连接池 取个 id 名字-->
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="driverClass" value="${jdbc.driver}"/>
        <!-- 跟外面的db.properties文件对应,方便修改 如果没有配置外部的注意里面如果有参数拼接的话 第一个使用? 后面 使用&amp;  -->
        <property name="jdbcUrl" value="${jdbc.url}"/>
        <property name="user" value="${jdbc.username}"/>
        <property name="password" value="${jdbc.password}"/>
    </bean>
    <!-- 配置SqlSessionFactory 工厂 -->
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <!-- 传入连接池 ref 引入上面的名字-->
        <property name="dataSource" ref="dataSource"></property>
        <property name="typeAliasesPackage" value="club.adger.entity"></property>
        <!-- mapper映射交给Spring来管理-->
        <property name="mapperLocations" value="classpath:mapper/*.xml"></property>
        <!--<property name="configuration" value="classpath:mybatis/mybatis-config.xml"></property>-->
     </bean>

    <!-- 配置接口所在的包  -->
    <bean id="mapperScan" class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <!-- 扫描谁 value写上你的dao包名 -->
        <property name="basePackage" value="club.adger.dao"></property>
    </bean>
    <!-- 配置Spring声明式事务管理 -->
    <!-- 配置事务管理器 -->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <!-- 传入连接池 对象 -->
        <property name="dataSource" ref="dataSource"></property>
    </bean>
    <!-- 配置事务通知 引入事务管理器 事务提交 或者回滚-->
    <tx:advice id="txAdvice" transaction-manager="transactionManager">
        <!-- 定义事务传播属性 -->
        <tx:attributes>
            <!-- 这里代表以 find方法 开头的 具体设置 表示只读的事务-->
            <tx:method name="find*" read-only="true"/>
            <!-- 隔离级别 -->
            <tx:method name="*" isolation="DEFAULT"/>
        </tx:attributes>
    </tx:advice>
    <!-- 配置AOP增强 -->
    <aop:config>
        <!-- 引入 txAdvice pointcut是切入点的表达式 其中 public 可以省略不写* club.adger.service.impl.*ServiceImpl.*(..) 所有方法 -->
        <aop:advisor advice-ref="txAdvice" pointcut="execution(* club.adger.service.impl.*ServiceImpl.*(..))"></aop:advisor>
    </aop:config>
</beans>

升级版本 web.xml 支持Restul风格的API

<?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_4_0.xsd"
         version="4.0">
  
  	<!-- 中文乱码处理 -->
  	<filter>
  		<filter-name>CharacterEncodingFilter</filter-name>
  		<filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
  	
  		<init-param>
  			<param-name>encoding</param-name>
  			<param-value>UTF-8</param-value>
  		</init-param>
  		<init-param>
  			<param-name>forceEncoding</param-name>
  			<param-value>true</param-value>
  		</init-param>
  	</filter>
  	
  	<filter-mapping>
  		<filter-name>CharacterEncodingFilter</filter-name>
  		<url-pattern>/*</url-pattern>
  	</filter-mapping>
  	
    <!-- 支持Restul风格的API-->
  	<filter>
  		<filter-name>HiddenHttpMethodFilter</filter-name>
  		<filter-class>org.springframework.web.filter.HiddenHttpMethodFilter</filter-class>
  	</filter>
  	
  	<filter-mapping>
  		<filter-name>HiddenHttpMethodFilter</filter-name>
  		<url-pattern>/*</url-pattern>
  	</filter-mapping>
  
  	<!-- Spring配置文件信息 -->
  	<context-param>
  		<param-name>contextConfigLocation</param-name>
  		<param-value>classpath:config/spring/applicationContext.xml</param-value>
  	</context-param>
  	<!-- ContextLoaderListener监听器 -->
  	<listener>
  		<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
  	</listener>
  	<!-- 日志配置 位置指定-->
	  <context-param>
	   <param-name>log4jConfigLocation</param-name>
	   <param-value>classpath:config/log4j.properties</param-value>
	</context-param>
	<listener>
	   <listener-class>org.springframework.web.util.Log4jConfigListener</listener-class>
	</listener>
  
  	<!-- 配置前端控制器 -->
	<servlet>
		<servlet-name>DispatcherServlet</servlet-name>
		<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
	
		<init-param>
			<param-name>contextConfigLocation</param-name>
			<param-value>classpath:config/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>
	
	<error-page>
		<error-code>404</error-code>
		<location>/WEB-INF/errors/404.jsp</location>
	</error-page>

	<error-page>
		<error-code>500</error-code>
		<location>/WEB-INF/errors/500.jsp</location>
	</error-page>
  
	  <welcome-file-list>
	    <welcome-file>index.jsp</welcome-file>
	  </welcome-file-list>
</web-app>

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

    <!-- 开启注解扫描 Spring只负责业务层跟持久层-->
    <context:component-scan base-package="club.adger">
        <!-- exclude不包含 不扫描 controller-->
        <context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
    </context:component-scan>

    <!-- Spring整合mybatis框架 引入属性文件，在配置中占位使用-->
    <context:property-placeholder location="classpath:db.properties" />
    <!-- 配置连接池 取个 id 名字-->
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="driverClass" value="${jdbc.driver}"/>
        <!-- 跟外面的db.properties文件对应,方便修改 如果没有配置外部的注意里面如果有参数拼接的话 第一个使用? 后面 使用&amp;  -->
        <property name="jdbcUrl" value="${jdbc.url}"/>
        <property name="user" value="${jdbc.username}"/>
        <property name="password" value="${jdbc.password}"/>
    </bean>
    <!-- 配置SqlSessionFactory 工厂 -->
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <!-- 传入连接池 ref 引入上面的名字-->
        <property name="dataSource" ref="dataSource"></property>
        <property name="typeAliasesPackage" value="club.adger.entity"></property>
        <!-- mapper映射交给Spring来管理-->
        <property name="mapperLocations" value="classpath:mapper/*.xml"></property>
        <!--<property name="configuration" value="classpath:mybatis/mybatis-config.xml"></property>-->
     </bean>

    <!-- 配置接口所在的包  -->
    <bean id="mapperScan" class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <!-- 扫描谁 value写上你的dao包名 -->
        <property name="basePackage" value="club.adger.dao"></property>
    </bean>
    <!-- 配置Spring声明式事务管理 -->
    <!-- 配置事务管理器 -->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <!-- 传入连接池 对象 -->
        <property name="dataSource" ref="dataSource"></property>
    </bean>
    <!-- 配置事务通知 引入事务管理器 事务提交 或者回滚-->
    <tx:advice id="txAdvice" transaction-manager="transactionManager">
        <!-- 定义事务传播属性 -->
        <tx:attributes>
            <!-- 这里代表以 find方法 开头的 具体设置 表示只读的事务-->
            <tx:method name="find*" read-only="true"/>
            <!-- 隔离级别 -->
            <tx:method name="*" isolation="DEFAULT"/>
        </tx:attributes>
    </tx:advice>
    <!-- 配置AOP增强 -->
    <aop:config>
        <!-- 引入 txAdvice pointcut是切入点的表达式 其中 public 可以省略不写* club.adger.service.impl.*ServiceImpl.*(..) 所有方法 -->
        <aop:advisor advice-ref="txAdvice" pointcut="execution(* club.adger.service.impl.*ServiceImpl.*(..))"></aop:advisor>
    </aop:config>
</beans>