【SSM整合】SSM整合详细流程步骤，Spring整合SpringMVC，Spring整合MyBatis，c3p0数据库连接池使用，事务配置。

秒速五厘米 2022-12-15 11:20 164阅读 0赞

### 文章目录 ###

*  SSM整合
 *   *  整合思路
     *  1. 搭建SSM环境
     *  2. Spring配置测试IOC和DI
     *  3. Spring整合SpringMVC框架
     *   *  3.1 web.xml配置
         *  3.2 配置SpringMVC核心配置文件springmvc.xml
         *  3.3 编写数据进行测试
     *  4. Spring整合MyBatis
     *   *  4.1 配置Mybatis，并测试MyBatis
         *  4.2 Spring整合MyBatis，配置数据库连接池c3p0，整合mybatis核心配置到spring核心配置文件中。
         *   *  4.2.1 创建数据库连接的属性文件\`c3p0.properties\`
             *  4.2.2 在applicationContext.xml中配置c3p0数据库连接池
             *  4.2.3 在applicationContext.xml中配置session工厂和编译后dao目录文件扫描
             *  4.2.4 测试配置c3p0数据源能否拿到连接，并测试查询和新增
         *  4.3 Spring整合MyBatis，配置事务管理，让Spring来管理事务
         *   *  4.3.1 applicationContext.xml配置事务管理
             *  4.3.2 dao、service和serviceImpl写\`savePersonList\`保存多个person
             *  4.3.3 映射文件IPersonDao.xml插入多个person
             *  4.3.4 测试
     *  5. 整合代码源码

# SSM整合 #

整合Spring、SpringMVC、MyBatis，搭建SSM环境，用于开发其他功能。

## 整合思路 ##

> 1.  搭建整合的环境，初始化环境
> 2.  搭建Spring环境，配置完成并测试
> 3.  再使用Spring整合SpringMVC框架，并测试
> 4.  最后使用Spring整合MyBatis框架，并测试

整合方法：`xml配置+注解`的方式进行整合。

## 1. 搭建SSM环境 ##

1.1 准备一个ssm数据库，并创建person表用于测试

CREATE DATEBASE ssm;
    USE ssm;
    SET FOREIGN_KEY_CHECKS=0;
    DROP TABLE IF EXISTS `person`;
    CREATE TABLE `person` (
      `id` int(11) NOT NULL AUTO_INCREMENT,
      `name` varchar(20) DEFAULT NULL,
      `money` double DEFAULT NULL,
      PRIMARY KEY (`id`)
    ) ENGINE=InnoDB AUTO_INCREMENT=3 DEFAULT CHARSET=utf8;
    
    INSERT INTO `person` VALUES ('1', 'striveday', '10000');
    INSERT INTO `person` VALUES ('2', 'studyday', '20000');

1.2 `pom.xml`导入依赖

<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.version>5.2.9.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>
      </properties>
    
      <dependencies>
        
        <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>
    
        
        <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>
    
        
        <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>c3p0</groupId>
          <artifactId>c3p0</artifactId>
          <version>0.9.1.2</version>
          <type>jar</type>
          <scope>compile</scope>
        </dependency>
      </dependencies>

1.3 配置log4j日志属性文件`log4j.properties`

# Set root category priority to INFO and its only appender to CONSOLE.
    #log4j.rootCategory=INFO, CONSOLE debug info warn error fatal
    log4j.rootCategory=debug, CONSOLE, LOGFILE
    
    # Set the enterprise logger category to FATAL and its only appender to CONSOLE.
    log4j.logger.org.apache.axis.enterprise=FATAL, CONSOLE
    
    # CONSOLE is set to be a ConsoleAppender using a PatternLayout.
    log4j.appender.CONSOLE=org.apache.log4j.ConsoleAppender
    log4j.appender.CONSOLE.layout=org.apache.log4j.PatternLayout
    log4j.appender.CONSOLE.layout.ConversionPattern=%d{ ISO8601} %-6r [%15.15t] %-5p %30.30c %x - %m\n
    
    # LOGFILE is set to be a File appender using a PatternLayout.
    # 输出到控制台
    log4j.appender.LOGFILE=org.apache.log4j.FileAppender
    # 输出到日志文件
    log4j.appender.LOGFILE.File=E:\logFile\SSM\ssm.log
    log4j.appender.LOGFILE.Append=true
    log4j.appender.LOGFILE.layout=org.apache.log4j.PatternLayout
    log4j.appender.LOGFILE.layout.ConversionPattern=%d{ ISO8601} %-6r [%15.15t] %-5p %30.30c %x - %m\n

## 2. Spring配置测试IOC和DI ##

2.1 创建测试类，测试控制反转和依赖注入，测试方法调用

//用spring自带的test测试
    @RunWith(SpringJUnit4ClassRunner.class)
    @ContextConfiguration("classpath:applicationContext.xml")
    public class TestPersonService { 
        //日志
        private static final Logger log = Logger.getLogger(TestPersonService.class.getName());
    
        //自动装载
        @Autowired
        IPersonService personService;
    
        //测试IOC DI依赖注入是否成功
        @Test
        public void test01(){ 
            System.out.println(personService);
        }
        
        //测试查询方法
        @Test
        public void test02(){ 
            //记录日志
            log.info(personService+"");
            //查询所有
            List<Person> list = personService.findAll();
            //调用保存
            log.info("allPerson："+list+"");
        }
    
        //测试增加方法
        @Test
        public void test03(){ 
            Person person = new Person(null,"striveday",20000000.68);
            personService.savePerson(person);
    
            List<Person> list = personService.findAll();
            log.info("allPerson："+list+"");
        }
    }

2.2 创建javabean对象`person`

public class Person { 
        private Integer id;
        private String name;
        private Double money;
        //省略get/set方法
    }

2.3 创建测试业务接口`IPersonService`及其实现类`PersonServiceImpl`

public interface IPersonService { 
        //查找所有person
        List<Person> findAll();
        //新增一个person
        int savePerson(Person person);
    }

@Service
    public class PersonServiceImpl implements IPersonService { 
    
        @Autowired
        private IPersonDao personDao;
    
        @Override
        public List<Person> findAll() { 
            List<Person> allPersonList = personDao.findAll();
            return allPersonList;
        }
    
        @Override
        public int savePerson(Person person) { 
            int code = personDao.savePerson(person);
            return code;
        }
    }

2.4 创建dao层接口`IPersonDao`及其实现类`PersonDaoImpl`，因为没有整合MyBatis，所以就不进行xml映射配置，所以这里用PersonDaoImpl实现类

public interface IPersonDao { 
        //查询所有用户
        List<Person> findAll();
        //新增一个person
        int savePerson(Person person);
    }

@Repository
    public class PersonDaoImpl implements IPersonDao { 
        @Override
        public List<Person> findAll() { 
            System.out.println("findAll");
            //因为没有整合mybatis，这里设置初始化数据进行模拟
            List<Person> personList = null;
            personList.add(new Person(null,"studyday",10000.0));
            personList.add(new Person(null,"striveday",20000.0));
            return personList;
        }
    
        @Override
        public int savePerson(Person person) { 
            System.out.println("savePerson");
            return 1;
        }
    }

2.5 配置spring核心配置文件`applicationContext.xml`  
这里面很多xml约束还没有用到，但是一起弄过来了，反正后面会用到

2.6 测试IOC（DI）是否可以注入，测试方法是否可以执行。

> 1.  测试（IOC/DI）测试test01方法  
>     ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwNTQyNTM0_size_16_color_FFFFFF_t_70_pic_center]
> 2.  测试查询方法test02  
>     ![在这里插入图片描述][20201016174019502.png_pic_center]
> 3.  测试save方法test03  
>     ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwNTQyNTM0_size_16_color_FFFFFF_t_70_pic_center 1]

测试Spring没有什么bug，我们就可以继续往下整合了。

## 3. Spring整合SpringMVC框架 ##

我们知道servlet做三件事（接收请求，处理参数，返回结果）  
springmvc就只有一个servlet，也就是`DispatcherServlet`前端控制器，但是它不处理参数，只是**将请求分发**，交给对应的`controller`控制器来处理参数

### 3.1 web.xml配置 ###

**`web.xml`中配置前端控制器`DispatcherServlet`、编码过滤器`CharacterEncodingFilter`、监听器`ContextLoaderListener`和spring核心配置文件的路径参数context-param**

*  （1） **web.xml中配置前端控制器`DispatcherServlet`**

> SpringMVC的**核心就是DispatcherServlet**，DispatcherServlet实质也是一个HttpServlet。DispatcherSevlet负责将请求分发给对应的`Controller`，所有的请求都有经过它来统一分发。

*  （2）**web.xml中配置编码过滤器`CharacterEncodingFilter`**

> 在 SpringMVC 中，框架直接给我们提供了一个用来解决请求和响应的乱码问题的过滤器 CharacterEncodingFilter

*  （3）**web.xml中配置编码监听器`ContextLoaderListener`**

> web.xml中的配置文件中ContextLoaderListener作为监听器，会监听web容器相关事件，在web容器启动或者关闭时触发执行响应程序。

<!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>
    
      
    
    
      <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>classpath:applicationContext.xml</param-value>
      </context-param>
    
    
      <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>
    
    
    
      <listener>
        
        <listener-class>org.springframework.web.context.ContextLoaderListener</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: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>
    
    </web-app>

【注意】配置是有顺序的，要按照这个顺序来执行（参数 -> 过滤器 -> 监听器 -> servlet前端控制器）。

> 这是配置顺序：  
> icon?,display-name?,description?,distributable?,context-param\*,filter\*,filter-mapping\*,listener\*,servlet\*,servlet-mapping\*,session-config?,mime-mapping\*,welcome-file-list?,error-page\*,taglib\*,resource-env-ref\*,resource-ref\*,security-constraint\*,login-config?,security-role\*,env-entry\*,ejb-ref\*,ejb-local-ref\*  
> ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwNTQyNTM0_size_16_color_FFFFFF_t_70_pic_center 2]  
>   
>

### 3.2 配置SpringMVC核心配置文件springmvc.xml ###

在springmvc中配置视图解析器，开启组件扫描，开启注解驱动，配置springmvc对静态资源文件的放行（前端控制器`DispatcherServlet`拦截所有请求，我们需要对静态资源文件css/js/img之类的方向不拦截）。

<?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">
    
        
        
        <context:component-scan base-package="com.xgf">
            
            <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="/fonts/" mapping="/fonts/**" />
    
        
        <mvc:annotation-driven/>
    </beans>

### 3.3 编写数据进行测试 ###

1.  编写一个`PersonController`

@Controller
    @RequestMapping("/person")
    public class PersonController { 
        @Autowired
        private IPersonService personService;
    
        @RequestMapping(path="/list",method = RequestMethod.GET)
        public String list(Model model){ 
            //显示所有的person数据
            List<Person> personList = personService.findAll();
            System.out.println("list() personList= "+personList);
            //数据放在Model对象，由Model传给页面
            model.addAttribute("personList",personList);//参1 key 参2 value
            return "personList";//返回list页面
    
        }
    }

1.  编写一个`perosnList.jsp`页面进行展示数据

<%@ page contentType="text/html;charset=UTF-8" language="java" isELIgnored="false" %>
    <%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
    <html>
    <head>
        <title>Title</title>
    </head>
    <body>
    <table border="1px" width="100%">
        <c:forEach items="${personList}" var="person">
            <tr>
                <td>${person.id}</td>
                <td>${person.name}</td>
                <td>${person.money}</td>
            </tr>
        </c:forEach>
    </table>
    </body>
    </html>

1.  运行结果，显示成功，Spring整合SpringMVC成功。  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwNTQyNTM0_size_16_color_FFFFFF_t_70_pic_center 3]

## 4. Spring整合MyBatis ##

整合记得一点，先测试没有问题，再整合进去！！（Spring整合MyBatis 需要`mybatis-spring`整合包）

### 4.1 配置Mybatis，并测试MyBatis ###

1.  配置MyBatis核心配置文件 `SqlMapConfig.xml`

<?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>
    
        
        <typeAliases>
            <package name="com.xgf.bean"/>
        </typeAliases>
        <environments default="mysql">
            <environment id="mysql">
                <transactionManager type="JDBC"/>
                
                <dataSource type="POOLED">
                    <property name="driver" value="com.mysql.jdbc.Driver"/>
                    <property name="url" value="jdbc:mysql://localhost:3306/ssm"/>
                    <property name="username" value="root"/>
                    <property name="password" value="861221293"/>
                </dataSource>
            </environment>
        </environments>
        
        <mappers>
            <package name="com.xgf.dao"/>
        </mappers>
    </configuration>

1.  测试MyBatis连接数据库进行操作是否有问题`TestMyBatis`

public class TestMyBatis { 
        private static SqlSessionFactory factory;
        private SqlSession session;
    
        //@BeforeClass只在类中执行一次, 必须声明为public static
        @BeforeClass
        public static void getFactory(){ 
            // 加载配置文件
            InputStream in = TestMyBatis.class.getClassLoader().getResourceAsStream("SqlMapConfig.xml");
            // 创建SqlSessionFactory对象
            factory = new SqlSessionFactoryBuilder().build(in);
        }
    
        //@Before在每个测试方法之前都执行一次, 方法需要声明为public
        @Before
        public void init(){ 
            // 每个方法执行前创建SqlSession对象
            session = factory.openSession();
        }
        //每个方法执行结束进行提交和关闭
        @After
        public void destory(){ 
            session.commit();
            session.close();
        }
        //查询所有person
        @Test
        public void test01(){ 
            //最核心对象是session
            // System.out.println(session);
            //Mybastis的特点是sql与代码是分开的，需要映射文件，通过getMapper生成代理类
            IPersonDao personDao =  session.getMapper(IPersonDao.class);
            List<Person> personList = personDao.findAll();
            System.out.println(personList);
        }
        //保存person
        @Test
        public void test02(){ 
            //最核心对象是session
            IPersonDao dao =  session.getMapper(IPersonDao.class);
            dao.savePerson(new Person(null,"strive_day",200.00));
        }
    }

1.  创建dao层接口映射文件`IPersonDao.xml`  
    （这里就不需要有dao层的实现类了，可以注释掉`PersonDaoImpl`或者在上面加注解`@Deprecated`表示该类过时）  
    在`resources`目录下创建和`IPersonDao`相同的路径（因为idea会将接口和文件编译合在一起叫类路径）

<?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.xgf.dao.IPersonDao">
        
        <select id="findAll" resultType="person">
                select id,name,money from person;
        </select>
    
        <insert id="savePerson" parameterType="person">
            insert into person (name,money)values(#{name},#{money})
        </insert>
    </mapper>

1.  测试MyBatis环境，执行测试方法  
    测试`test01`查询所有person  
    ![在这里插入图片描述][20201017152519269.png_pic_center]  
    测试`test02`增加person  
    ![在这里插入图片描述][20201017152605263.png_pic_center]  
    ![在这里插入图片描述][20201017152623501.png_pic_center]

> 测试MyBatis没有什么问题，我们就可以将MyBatis整合到Spring中去了。

### 4.2 Spring整合MyBatis，配置数据库连接池c3p0，整合mybatis核心配置到spring核心配置文件中。 ###

Spring整合MyBatis需要一个整合包`mybatis-spring`，前面已经导入了，这里只是强调一下。

<dependency>
                <groupId>org.mybatis</groupId>
                <artifactId>mybatis-spring</artifactId>
                <version>1.3.0</version>
            </dependency>

> `MyBatis-Spring`会帮助你将 MyBatis 代码无缝地整合到 Spring 中。它将允许 MyBatis 参与到 Spring 的事务管理之中，创建映射器 mapper 和 SqlSession 并注入到 bean 中。  
> 以后不需要调用 session.getMapper(IpersonDao.class)来获取代理类了，事务的提交和删除(写操作)也不需要了（session.commit()，session.close()）

#### 4.2.1 创建数据库连接的属性文件`c3p0.properties` ####

#c3p0连接池属性文件
    # 四大基本信息
    c3p0.driverClass=com.mysql.jdbc.Driver
    c3p0.jdbcUrl=jdbc:mysql://localhost:3306/ssm?useUnicode=true&characterEncoding=UTF-8&useSSL=false
    c3p0.user=root
    c3p0.password=861221293
    
    # 初始化连接数 取值要在minPoolSize和maxPoolSize之间（可包含，闭区间） 默认值：3
    c3p0.initialPoolSize=10
    # 最大连接数 （连接池中的连接数不能超过maxPoolSize最大连接数） 默认值：15
    c3p0.maxPoolSize=50
    #最小连接数 默认值：3
    c3p0.minPoolSize=5
    #c3p0连接池中数据连接不够时（无空闲连接可用）,一次增长的个数（增长不能超过maxPoolSize最大连接个数） 默认值：3
    c3p0.acquireIncrement=5
    #连接的最大空闲时间，如果超过这个时间还没有被使用，就断开这个连接（设置为0或负数，就永远都不会被断开） 单位：秒 默认值 ：0
    c3p0.maxIdleTime=600
    #从数据库获取新连接失败后重复尝试的次数。小于等于0表示无限次 默认值: 30
    c3p0.acquireRetryAttempts=30
    #两次连接的中间间隔时间（重新尝试的时间间隔） 单位：毫秒 默认值：1000
    c3p0.acquireRetryDelay=1000
    #连接关闭时，是否将所有未提交的操作进行事务回滚 默认值：false
    c3p0.autoCommitOnClose = false
    #当连接池用完时,客户端调用getConnection()后等待获取新连接的时间 单位：毫秒 默认值：0 (无限期等待) 按照设置的值，超时将抛出SQLException异常
    c3p0.checkoutTimeout = 0
    #每隔多少秒检查所有连接池中的空闲连接 单位：秒 默认值：0
    c3p0.idleConnectionTestPeriod=60
    #配置PreparedStatement缓存，设置连接池为数据源缓存的PreparedStatement的总数，为0的时候不缓存，同时maxStatementsPerConnection的配置无效。
    # 由于PreparedStatement属于单个Connection,所以这个数量应该根据应用中平均连接数乘以每个连接的平均PreparedStatement来计算
    c3p0.maxStatements=1000
    
    
    # 连接池为数据源单个Connection缓存的PreparedStatement数，这个配置比maxStatements更有意义，因为它缓存的服务对象是单个数据连接，如果设置的好，肯定是可以提高性能的。为0的时候不缓存。
    # c3p0.maxStatementsPerConnection

#### 4.2.2 在applicationContext.xml中配置c3p0数据库连接池 ####

**将MyBatis核心配置文件 `SqlMapConfig` 都整入Spring核心配置文件`applicationContext.xml` 中，交给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">
    
        
        <context:property-placeholder location="classpath:c3p0.properties" />
    
        
        
        
        <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
            
            <property name="driverClass" value="${c3p0.driverClass}"/>
            <property name="jdbcUrl" value="${c3p0.jdbcUrl}"/>
            <property name="user" value="${c3p0.user}"/>
            <property name="password" value="${c3p0.password}"/>
    
            
            <property name="initialPoolSize" value="${c3p0.initialPoolSize}"/>
            
            <property name="maxPoolSize" value="${c3p0.maxPoolSize}"/>
            
            <property name="minPoolSize" value="${c3p0.minPoolSize}"/>
            
            <property name="acquireIncrement" value="${c3p0.acquireIncrement}"/>
            
            <property name="maxIdleTime" value="${c3p0.maxIdleTime}"/>
    
            
            <property name="acquireRetryAttempts" value="${c3p0.acquireRetryAttempts}"/>
            
            <property name="acquireRetryDelay" value="${c3p0.acquireRetryDelay}"/>
            
            <property name="autoCommitOnClose" value="${c3p0.autoCommitOnClose}"/>
            
            <property name="checkoutTimeout" value="${c3p0.checkoutTimeout}"/>
            
            <property name="idleConnectionTestPeriod" value="${c3p0.idleConnectionTestPeriod}"/>
    
            
            <property name="maxStatements" value="${c3p0.maxStatements}"/>
    
        </bean>
    
        
        <context:component-scan base-package="com.xgf">
            
            <context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
        </context:component-scan>
    
    </beans>

#### 4.2.3 在applicationContext.xml中配置session工厂和编译后dao目录文件扫描 ####

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwNTQyNTM0_size_16_color_FFFFFF_t_70_pic_center 4]

<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
            
            <property name="dataSource" ref="dataSource"/>
            
            <property name="typeAliasesPackage" value="com.xgf.bean"/>
        </bean>
        
        <bean id="mapperScanner" class="org.mybatis.spring.mapper.MapperScannerConfigurer">
            
            <property name="basePackage" value="com.xgf.dao"/>
            <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory"/>
        </bean>

#### 4.2.4 测试配置c3p0数据源能否拿到连接，并测试查询和新增 ####

//测试c3p0数据库连接池，数据源是否配置对，能否拿到连接
    //测试查询person、增加person
    @RunWith(SpringJUnit4ClassRunner.class)
    @ContextConfiguration("classpath:applicationContext.xml")
    public class TestC3p0DataSource { 
        private static final Logger log = Logger.getLogger(TestC3p0DataSource.class.getName());
    
        @Autowired
        DataSource dataSource;
        //测试能否通过链接拿到数据
        @Test
        public void testDataSource() throws SQLException { 
            log.info("testDataSource获取连接："+dataSource.getConnection());
        }
    
        @Autowired
        IPersonDao personDao;
    
        //测试查询
        @Test
        public void test01(){ 
            List<Person> personList = personDao.findAll();
            System.out.println(personList);
        }
        //测试新增
        @Test
        public void test02(){ 
            Person person =  new Person(null,"TestC3p0DataSource",200.00);
            personDao.savePerson(person);
        }
    
    }

测试testDataSource()，看能否从c3p0拿到连接

> 测试testDataSource()  
> 测试结果：**能够拿到连接，并初始化了十个连接**![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwNTQyNTM0_size_16_color_FFFFFF_t_70_pic_center 5]  
> ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwNTQyNTM0_size_16_color_FFFFFF_t_70_pic_center 6]

测试配置c3p0数据库连接池之后对数据库操作：

> 测试test01方法，进行查询所有person  
> ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwNTQyNTM0_size_16_color_FFFFFF_t_70_pic_center 7]
> 
> 测试test02方法，保存一个person  
> ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwNTQyNTM0_size_16_color_FFFFFF_t_70_pic_center 8]  
> ![在这里插入图片描述][20201017195140293.png_pic_center]

### 4.3 Spring整合MyBatis，配置事务管理，让Spring来管理事务 ###

spring事务的底层是AOP，做一个转账功能或者批量保存功能来验证是否能满足条件（一个事务必须全部执行或者全部不执行，查看错误是否发生事务回滚就行）  
  这里通过批量增加person，出现除零(1/0)错误，查看是否事务回滚。

#### 4.3.1 applicationContext.xml配置事务管理 ####

这里配置的事务，是以`find*、save*、delete*、update*`开头的，所以按照这种配置，只有以这些开头的才进行事务管理，且find\*开头的是不进行事务管理的（查询不需要），其他修改操作就需要进行事务管理。

<tx:advice id="txAdvice" transaction-manager="transactionManager">
            
            <tx:attributes>
                
                <tx:method name="find*" read-only="true"/>
                
                <tx:method name="delete*" isolation="DEFAULT"/>
                <tx:method name="save*" isolation="DEFAULT"/>
                <tx:method name="update*" isolation="DEFAULT"/>
            </tx:attributes>
        </tx:advice>
    
        
        <aop:config>
            
            <aop:pointcut id="service" expression="execution(* com.xgf.service.impl.*ServiceImpl.*(..))"/>
            
            <aop:advisor advice-ref="txAdvice" pointcut-ref="service"/>
        </aop:config>

#### 4.3.2 dao、service和serviceImpl写`savePersonList`保存多个person ####

IPersonDao

@Repository
    public interface IPersonDao { 
        //保存多个person
        int savePersonList(List<Person> personList);
    }

IPersonService

public interface IPersonService { 
        //增加多个person
        int savePersonList(List<Person> personList);
    }

@Service
    public class PersonServiceImpl implements IPersonService { 
    
        @Autowired
        private IPersonDao personDao;
    
        @Override
        public int savePersonList(List<Person> personList) { 
            int code = personDao.savePersonList(personList);
            return code;
        }
    }

#### 4.3.3 映射文件IPersonDao.xml插入多个person ####

<insert id="savePersonList" parameterType="java.util.List">
    
            insert into person(name,money)values
            <foreach item="item" index="index" separator="," collection="list">
                (#{item.name},#{item.money})
            </foreach>
        </insert>

#### 4.3.4 测试 ####

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwNTQyNTM0_size_16_color_FFFFFF_t_70_pic_center 9]

1.  正常测试，没有1/0错误代码

//模拟看是否发生事务回滚 批量保存（保存的过程中有一个地方抛出异常，就应该全部回滚）
        @Test
        public void test04(){ 
            List<Person> personList = new ArrayList<>();
            personList.add(new Person(null,"savePerson_001",100.00));
            personList.add(new Person(null,"savePerson_002",200.00));
            personList.add(new Person(null,"savePerson_003",300.00));
    
            int code = personService.savePersonList(personList);
            log.info("插入" + code + "条person数据");
        }

![在这里插入图片描述][2020101721184971.png_pic_center]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwNTQyNTM0_size_16_color_FFFFFF_t_70_pic_center 10]

1.  有异常抛出（1/0） by zero异常，看事务是否回滚

//模拟看是否发生事务回滚 批量保存（保存的过程中有一个地方抛出异常，就应该全部回滚）
        @Test
        public void test04(){ 
            List<Person> personList = new ArrayList<>();
            personList.add(new Person(null,"savePerson_001",100.00));
            personList.add(new Person(null,"savePerson_002",200.00));
            //抛出1/0异常
            System.out.println(1/0);
            personList.add(new Person(null,"savePerson_003",300.00));
    
            int code = personService.savePersonList(personList);
            log.info("插入" + code + "条person数据");
        }

![在这里插入图片描述][20201017212113904.png_pic_center]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwNTQyNTM0_size_16_color_FFFFFF_t_70_pic_center 11]

## 5. 整合代码源码 ##

[SSM整合-https://github.com/strive-xgf/SSMIntegration][SSM_-https_github.com_strive-xgf_SSMIntegration]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwNTQyNTM0_size_16_color_FFFFFF_t_70_pic_center]: /images/20221123/cd08e17e83a0434ba341048e4a141fee.png
[20201016174019502.png_pic_center]: /images/20221123/e74dcbd964c5431cb01df433ea747d68.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwNTQyNTM0_size_16_color_FFFFFF_t_70_pic_center 1]: /images/20221123/9980d3b293c343f29c66ceb6b54671c9.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwNTQyNTM0_size_16_color_FFFFFF_t_70_pic_center 2]: /images/20221123/72ed3830cc4a4245b58271260d5562fb.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwNTQyNTM0_size_16_color_FFFFFF_t_70_pic_center 3]: /images/20221123/3054460011574fc29ea11027cd92eb5f.png
[20201017152519269.png_pic_center]: /images/20221123/6798c6001cef46b2b1ccbc19ddde5ce9.png
[20201017152605263.png_pic_center]: /images/20221123/2d49beeff3d049cbb8bcb7aedd054b28.png
[20201017152623501.png_pic_center]: /images/20221123/13b51ba475df468eb9246879cc5c1274.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwNTQyNTM0_size_16_color_FFFFFF_t_70_pic_center 4]: /images/20221123/0e7f546e99b740a6b57817bdc821724d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwNTQyNTM0_size_16_color_FFFFFF_t_70_pic_center 5]: /images/20221123/7e3d15dfc3be4995ad1c7a81948bb5af.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwNTQyNTM0_size_16_color_FFFFFF_t_70_pic_center 6]: /images/20221123/31ca3c5ef64e42138359c90616855310.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwNTQyNTM0_size_16_color_FFFFFF_t_70_pic_center 7]: /images/20221123/d6b4ec2d997f49c4a516c547ad33fa47.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwNTQyNTM0_size_16_color_FFFFFF_t_70_pic_center 8]: /images/20221123/4419862142c84373b5aae22ba209dcda.png
[20201017195140293.png_pic_center]: /images/20221123/f91981cddae6434e9468f5b95aa10ec9.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwNTQyNTM0_size_16_color_FFFFFF_t_70_pic_center 9]: /images/20221123/0a1ca5b30fd3435c8baa7267b157374c.png
[2020101721184971.png_pic_center]: /images/20221123/9c3c5a4c76c14db4be351f9283c40e24.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwNTQyNTM0_size_16_color_FFFFFF_t_70_pic_center 10]: /images/20221123/57a0bc8a232a41f59f12cf2e84e0982a.png
[20201017212113904.png_pic_center]: /images/20221123/6eb884ab65044efd92b90e0f9a35cdf8.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwNTQyNTM0_size_16_color_FFFFFF_t_70_pic_center 11]: /images/20221123/bd5ce24fd2664781ad86f14414fa38e2.png
[SSM_-https_github.com_strive-xgf_SSMIntegration]: https://github.com/strive-xgf/SSMIntegration