4.5 JavaEE-SpringTemplate与Spring、MyBatis整合

短命女 2024-03-31 11:23 106阅读 0赞

**目录**

4.5.1 JdbcTemplate

4.5.1.1 JdbcTemplate概述

4.5.1.1.1 什么是JdbcTemplate

4.5.1.1.2 导入坐标

4.5.1.2 手动管理JdbcTemplate

4.5.1.2.1 C3P0

4.5.1.2.2 Druid

4.5.1.3 Spring管理JdbcTemplate

4.5.2 Spring事务

4.5.2.1 概述

4.5.2.1.2 事务管理器 — PlatformTransactionManager 接口

4.5.2.1.3 TransactionDefinition

4.5.2.1.4 TransactionStatus

4.5.2.2 基于 XML 的声明式事务控制

4.5.2.2.1 声明式事务控制

4.5.2.2.2 引入tx命名空间

4.5.2.3 基于注解的声明式事务控制

4.5.3 Spring整合MyBatis

4.5.3.1 概述

4.5.4 Spring与MyBatis整合

4.5.4.1 整合步骤

4.5.4.2 说明

4.5.4.2.1 SqlSessionFactoryBean

4.5.4.2.2 DataSource

4.5.4.2.3 configLocation

4.5.4.2.4 mapperLocations

4.5.4.2.5 MapperScannerConfigurer

4.5.5 Spring与Web环境集成

4.5.5.1 ApplicationContext应用上下文获取方式

4.5.5.2 Spring提供获取应用上下文的工具

4.5.5.3 集成步骤

--------------------

## 4.5.1 JdbcTemplate ##

### 4.5.1.1 JdbcTemplate概述 ###

#### 4.5.1.1.1 什么是JdbcTemplate ####

Spring 框架对 JDBC 进行封装，使用 JdbcTemplate 方便实现对数据库操作，持久层框架

#### 4.5.1.1.2 导入坐标 ####

由于spring-jdbc 依赖于spring-tx、spring-bean、spring-core，所以只需要导入spring-jdbc即可。

另外注意版本冲突问题，spring-jdbc版本要与spring版本一致。

<dependency>
          <groupId>org.springframework</groupId>
          <artifactId>spring-jdbc</artifactId>
          <version>5.0.5.RELEASE</version>
    </dependency>

### 4.5.1.2 手动管理JdbcTemplate ###

#### 4.5.1.2.1 C3P0 ####

**c3p0**

{
            ComboPooledDataSource comboPooledDataSource = new ComboPooledDataSource();
            comboPooledDataSource.setDriverClass("com.mysql.jdbc.Driver");
            comboPooledDataSource.setJdbcUrl("jdbc:mysql://localhost:3306/mydb");
            comboPooledDataSource.setUser("root");
            comboPooledDataSource.setPassword("123456");
             JdbcTemplate jdbcTemplate = new JdbcTemplate(comboPooledDataSource);
           
    }

**增删改查操作**

public void insert(){
            String sql="insert into student (sid,sname,age,phone) values(?,?,?,?)";
            jdbcTemplate.update(sql,1,"sd",27,"123456");
    
    }
    
    public void update(){
            String sql="update student set sname=? where sid=? ";
           jdbcTemplate.update(sql,"老大",2);
    }
    
    
    //注意JdbcTemplate的查询方法里面定义了类，可以返回指定泛型的list
    public void select(){
            String sql="select * from student";
            List<Student> student = jdbcTemplate.query(sql, new BeanPropertyRowMapper<Student>(Student.class));
            System.out.println(student);
    }

### 4.5.1.2.2 Druid ###

**Druid**

DruidDataSource dds = new DruidDataSource();
            dds.setDriverClassName("com.mysql.jdbc.Driver");
            dds.setUrl("jdbc:mysql://localhost:3306/mydb");
            dds.setUsername("root");
            dds.setPassword("123456");
           JdbcTemplate jdbcTemplate = new JdbcTemplate(dds);

增删改查操作一样。

### 4.5.1.3 Spring管理JdbcTemplate ###

手动配置有些麻烦，我们可以偷懒，将JdbcTemplate、数据源DataSource都交由Spring创建。

在Spring容器内部将数据源DataSource注入到JdbcTemplate模版对象中,然后通过Spring容器获得JdbcTemplate对象来执行操作。

以druid为例，首先我们先分析druid连接池的配置

> DruidDataSource dds = new DruidDataSource(); dds.setDriverClassName("com.mysql.jdbc.Driver"); dds.setUrl("jdbc:mysql://localhost:3306/mydb"); dds.setUsername("root"); dds.setPassword("123456");
> 
> JdbcTemplate jdbcTemplate = new JdbcTemplate(); 
> 
> dbcTemplate.setDataSource(dds);
> 
> //也可以直接 JdbcTemplate jdbcTemplate = new JdbcTemplate(dds);

我们将本来由自己new的DruidDataSource、JdbcTemplate交由Spring创建。**(IOC)**

DruidDataSource有三个set属性，因此dds依赖注入基本类型，**(DI)**

JdbcTemplate只有一个set属性，而且传入的是引用类型，因此jdbcTemplate依赖注入引用类型。**(DI)**

**applicationContext\_JdbcTemplate.xml**

**测试**

@Test
        public void test() {
            ClassPathXmlApplicationContext cpxac= new ClassPathXmlApplicationContext("applicationContext_JdbcTemplate.xml");
            JdbcTemplate jdbcTemplate = (JdbcTemplate) cpxac.getBean("jdbcTemplate");
            //执行sql语句
            String sql="select * from student";
            List<Student> student = jdbcTemplate.query(sql, new BeanPropertyRowMapper<Student>(Student.class));
            System.out.println(student);
            
    
        }

## 4.5.2 Spring事务 ##

### 4.5.2.1 概述 ###

4.5.2.1.1

详细事务知识点 【[点击跳转 《2.1数据库-MySQL》][_2.1_-MySQL]】

Spring 支持两种事务方式，分别是编程式事务和声明式事务，常使用声明式事务（注解方式）

Spring通过事务管理器、事务管理类的实现类来管理事务

Spring的事务是一个统一的模型  
（1）指定要使用的事务管理器实现类，使用`<bean>`  
（2）指定哪些类，哪些方法需要加入事务的功能  
（3）指定方法需要的事务的隔离级别、传播行为、超时时间。

#### 4.5.2.1.2 事务管理器 — PlatformTransactionManager 接口 ####

里面提供了常用的操作事务的方法。

<table style="width:500px;"> 
 <tbody> 
  <tr> 
   <td><strong>方法</strong></td> 
   <td><strong>说明</strong></td> 
  </tr> 
  <tr> 
   <td>TransactionStatus getTransaction(TransactionDefination defination)</td> 
   <td>获取事务的状态信息</td> 
  </tr> 
  <tr> 
   <td>void commit(TransactionStatus status)</td> 
   <td>提交事务</td> 
  </tr> 
  <tr> 
   <td>void rollback(TransactionStatus status)</td> 
   <td>回滚事务</td> 
  </tr> 
 </tbody> 
</table>

> **注意：**
> 
> PlatformTransactionManager 是接口类型，不同的 Dao 层技术则有不同的实现类，例如： Dao 层技术是jdbc 或 mybatis 时：org.springframework.jdbc.datasource.DataSourceTransactionManager
> 
> Dao 层技术是hibernate时：org.springframework.orm.hibernate5.HibernateTransactionManager

#### 4.5.2.1.3 TransactionDefinition ####

TransactionDefinition ：事务的定义信息对象

事务的定义包括: **事务的隔离级别**，**事务的传播行为**，**超时时间**，**是否只读** 。

一般不修改使用默认即可。

<table style="width:500px;"> 
 <tbody> 
  <tr> 
   <td style="width:312px;"><strong>方法</strong></td> 
   <td style="width:186px;"><strong>说明</strong></td> 
  </tr> 
  <tr> 
   <td style="width:312px;">int getIsolationLevel ( )</td> 
   <td style="width:186px;">获得事务的隔离级别</td> 
  </tr> 
  <tr> 
   <td style="width:312px;">int getPropogationBehavior()</td> 
   <td style="width:186px;">获得事务的传播行为</td> 
  </tr> 
  <tr> 
   <td style="width:312px;">int getTimeout()</td> 
   <td style="width:186px;">获得超时时间</td> 
  </tr> 
  <tr> 
   <td style="width:312px;">booolean isReadOnly()</td> 
   <td style="width:186px;">是否只读</td> 
  </tr> 
 </tbody> 
</table>

**1、事务的隔离级别**

<table style="width:500px;"> 
 <tbody> 
  <tr> 
   <td><strong>隔离级别</strong></td> 
   <td><strong>说明</strong></td> 
  </tr> 
  <tr> 
   <td>DEFAULT</td> 
   <td>使用数据库默认的隔离级别</td> 
  </tr> 
  <tr> 
   <td>READ_UNCOMMITTED</td> 
   <td>读未提交</td> 
  </tr> 
  <tr> 
   <td>READ_COMMITTED</td> 
   <td>读已提交</td> 
  </tr> 
  <tr> 
   <td>REPEATABLE_READ</td> 
   <td>可重复读</td> 
  </tr> 
  <tr> 
   <td>SERIALIZABLE</td> 
   <td>串行化</td> 
  </tr> 
 </tbody> 
</table>

> 通过以下设置事务隔离级别
> 
>  *  ISOLATION\_DEFAULT
>  *  ISOLATION\_READ\_UNCOMMITTED
>  *  ISOLATION\_READ\_COMMITTED
>  *  ISOLATION\_REPEATABLE\_READ
>  *  ISOLATION\_SERIALIZABLE

**2、事务的传播行为**

<table style="width:500px;"> 
 <tbody> 
  <tr> 
   <td><strong>行为</strong></td> 
   <td><strong>说明</strong></td> 
  </tr> 
  <tr> 
   <td>REQUIRED</td> 
   <td> <p>默认值。</p> <p>若当前没有事务，就新建一个事务，如果存在事务，就加入到这个事务中。</p> </td> 
  </tr> 
  <tr> 
   <td>SUPPORTS</td> 
   <td>支持当前事务，如果没有事务，就以非事务方式执行</td> 
  </tr> 
  <tr> 
   <td>MANDATORY</td> 
   <td>使用当前事务，如果没有事务，就抛出异常</td> 
  </tr> 
  <tr> 
   <td>REQUIRES_NEW</td> 
   <td>新建事务，如果当前已存在有事务，就把当前事务挂起</td> 
  </tr> 
  <tr> 
   <td>NOT_SUPPORTES</td> 
   <td>以非事务的方式执行操作，如果当前存在事务，就把当前事务挂起</td> 
  </tr> 
  <tr> 
   <td>NEVER</td> 
   <td>以非事务的方式运行，如果当前存在事务，抛出异常</td> 
  </tr> 
  <tr> 
   <td>NESTED</td> 
   <td>如果当前存在事务，则嵌套在事务内执行。如果当前没有事务，则执行REQUIRED类似的操作</td> 
  </tr> 
 </tbody> 
</table>

**3、超时时间**

默认值是-1，没有超时限制。如果有，以秒为单位进行设置

**4、是否只读**

建议查询时设置为只读

#### 4.5.2.1.4 TransactionStatus ####

TransactionStatus 接口提供的是事务具体的运行状态，TransactionStatus继承SavepointManager接口，SavepointManager是对事务中上述保存点功能的封装。

**SavepointManager**

public interface SavepointManager {
        Object createSavepoint() throws TransactionException;
        void rollbackToSavepoint(Object savepoint) throws TransactionException;
        void releaseSavepoint(Object savepoint) throws TransactionException;
    }

TransactionStatus本身更多存储的是事务的一些状态信息

<table style="width:500px;"> 
 <tbody> 
  <tr> 
   <td><strong>方法</strong></td> 
   <td><strong>说明</strong></td> 
  </tr> 
  <tr> 
   <td>boolean hasSavepoint()</td> 
   <td>是否存储回滚点</td> 
  </tr> 
  <tr> 
   <td>boolean isCompleted()</td> 
   <td>事务是否完成</td> 
  </tr> 
  <tr> 
   <td>boolean isNewTransaction()</td> 
   <td>是否是新事物</td> 
  </tr> 
  <tr> 
   <td>boolean isRollbackOnly()</td> 
   <td>事务是否回滚</td> 
  </tr> 
 </tbody> 
</table>

### 4.5.2.2 基于 XML 的声明式事务控制 ###

#### 4.5.2.2.1 声明式事务控制 ####

在以前，我们每次都要提交事务、回滚，都要书写代码实现，太麻烦了。学习spring后，我们将事务也交由spring管理。

Spring 的声明式事务：采用声明的方式来处理事务。

声明：指在配置文件中声明，用在 Spring 配置文件中声明式的处理事务来代替编程式的处理事务。

事务管理不会影响到代码，事务服务的开启与关闭，只需在配置文件中修改，无需改变代码重新编译 。

**明确三个关键点：**

**切点**：service层实现类的所有方法，只有service层才可能同时调用多个Dao层一起执行。

**通知：**增强方法，前置通知：关闭自动提交开启事务；后置通知：关闭连接；异常通知：回滚；最终通知：提交。

**切面：**事务管理器，由于spring已经将通知的工作都做好了，但是不能按spring的配置方式配置，而是有自己的一套配置方式。

**Spring 声明式事务控制底层就是AOP**

#### 4.5.2.2.2 引入tx命名空间 ####

**配置事务增强**

<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>
                
                
                <tx:method name="*" />
                <tx:method name="updatePasswordByUid" isolation="DEFAULT" propagation="REQUIRED" timeout="-1" read-only="false"/>
            </tx:attributes>
        </tx:advice>
    
    
    
       
        <aop:config>
            <aop:pointcut id="myPointcut" expression="execution(* com.bl.serviceimpl.*.*(..))"/>
            <aop:advisor advice-ref="txAdvice" pointcut-ref="myPointcut"></aop:advisor>
        </aop:config>

@Override
    public void transfer(String user_out, String user_in, double money) {
        accountDao.transout(user_out,money);
        //模拟报错
        System.out.println(1/0);
        accountDao.transin(user_in,money);
    }

### 4.5.2.3 基于注解的声明式事务控制 ###

<tx:annotation-driven transaction-manager="transactionManager"/>

①使用 @Transactional 在需要进行事务控制的类或是方法上修饰，注解可用的属性同 xml 配置方式，例如隔离级别、传播行为等。

②注解使用在类上，那么该类下的所有方法都使用同一套注解参数配置。

③使用在方法上，不同的方法可以采用不同的事务参数配置。

④Xml配置文件中要开启事务的注解驱动<tx:annotation-driven />

## 4.5.3 Spring整合MyBatis ##

### 4.5.3.1 概述 ###

MyBatis是一个优秀的基于ORM的半自动轻量级持久层框架。Spring虽然有自己的持久化框架，但是仍然可以整合Mybatis框架。

Spring会管理MyBatis的配置，其中mybatis-spring.jar 是关键。

*  mybatis-spring会用将 MyBatis 代码整合到 Spring 中
 *  Spring 将会加载必要的 MyBatis 工厂类和 Session 类
 *  提供一个简单的方式来注入 MyBatis 数据映射器和 SqlSession 到业务层的 bean 中
 *  方便集成 Spring 事务
 *  翻译 MyBatis 的异常到 Spring 的 DataAccessException 异常(数据访问异常)中

另外我们需要考虑Mybatis-Spring 兼容性，我们在选择Spring、MyBatis以及mybatis-spring时，应注意版本之间的兼容性。

<table style="width:500px;"> 
 <tbody> 
  <tr> 
   <td>MyBatis-Spring</td> 
   <td>MyBatis</td> 
   <td>Spring框架</td> 
  </tr> 
  <tr> 
   <td>2.0</td> 
   <td>3.5+</td> 
   <td>5.0+</td> 
  </tr> 
  <tr> 
   <td>1.3</td> 
   <td>3.4+</td> 
   <td>3.2.2+</td> 
  </tr> 
 </tbody> 
</table>

## 4.5.4 Spring与MyBatis整合 ##

### 4.5.4.1 整合步骤 ###

**导入坐标**

<?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">
        <modelVersion>4.0.0</modelVersion>
    
        <groupId>com.bl</groupId>
        <artifactId>spring1128</artifactId>
        <version>1.0-SNAPSHOT</version>
        <packaging>war</packaging>
    
        <name>spring1128 Maven Webapp</name>
        
        <url>http://www.example.com</url>
    
        <properties>
            <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
            <maven.compiler.source>1.7</maven.compiler.source>
            <maven.compiler.target>1.7</maven.compiler.target>
            
            <my.spring>5.3.18</my.spring>
            <my.mybatis>3.5.6</my.mybatis>
            <my.mybatis-spring>2.0.6</my.mybatis-spring>
        </properties>
    
        <dependencies>
            <dependency>
                <groupId>junit</groupId>
                <artifactId>junit</artifactId>
                <version>4.11</version>
            </dependency>
    
            
    
            
            
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-context</artifactId>
                <version>${my.spring}</version>
            </dependency>
            
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-jdbc</artifactId>
                <version>${my.spring}</version>
            </dependency>
            
            <dependency>
                <groupId>org.aspectj</groupId>
                <artifactId>aspectjweaver</artifactId>
                <version>1.8.13</version>
            </dependency>
    
            
            <dependency>
                <groupId>org.mybatis</groupId>
                <artifactId>mybatis</artifactId>
                <version>${my.mybatis}</version>
            </dependency>
            
            <dependency>
                <groupId>mysql</groupId>
                <artifactId>mysql-connector-java</artifactId>
                <version>5.1.47</version>
            </dependency>
            
            <dependency>
                <groupId>com.alibaba</groupId>
                <artifactId>druid</artifactId>
                <version>1.1.10</version>
            </dependency>
    
            <dependency>
                <groupId>log4j</groupId>
                <artifactId>log4j</artifactId>
                <version>1.2.17</version>
            </dependency>
    
    
            
            <dependency>
                <groupId>org.mybatis</groupId>
                <artifactId>mybatis-spring</artifactId>
                <version>${my.mybatis-spring}</version>
            </dependency>
            <dependency>
                <groupId>org.projectlombok</groupId>
                <artifactId>lombok</artifactId>
                <version>RELEASE</version>
                <scope>compile</scope>
            </dependency>
        </dependencies>

**jdbc.properties**

jdbc.driver=com.mysql.jdbc.Driver
    jdbc.url=jdbc:mysql://localhost:3306/mydb
    jdbc.username=root
    jdbc.password=123456
    
    
    # 初始化大小，最小，最大
    initialSize=10
    minIdle=6
    maxActive=50

**mybatis-config.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>
    
        
        <settings>
            
            <setting name="cacheEnabled" value="true"/>
            
            <setting name="lazyLoadingEnabled" value="true"/>
            <setting name="lazyLoadTriggerMethods" value="equals,clone,hashCode,toString"/>
            <setting name="aggressiveLazyLoading" value="false"/>
            
            <setting name="localCacheScope" value="SESSION"/>
            
            <setting name="logImpl" value="STDOUT_LOGGING" />
        </settings>
    
        <typeAliases>
            <package name="com.bl.javabean"/>
        </typeAliases>
    
    </configuration>

> **注意：**
> 
> mybatis文件与之前不同，之前在mybatis-config.xml中配置数据库连接的，现在要把这些放在spring的配置文件中，所以mybatis配置文件中只写setting配置

**spring.xml配置文件**

**StudentMapper接口**

public interface StudentMapper {
        ArrayList<Student> selectAllStudent();
    }

**StudentMapper.xml**

<?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.bl.mapper.StudentMapper">
    
        <select id="selectAllStudent" resultType="com.bl.javabean.Student">
            select * from student
        </select>
    
    </mapper>

**测试类**

public class StudentTest {
        static ClassPathXmlApplicationContext applicationContext;
        static{
            applicationContext= new ClassPathXmlApplicationContext("spring.xml");
        }
        @Test
        public void test(){
            StudentMapper student = applicationContext.getBean(StudentMapper.class);
            ArrayList<Student> students = student.selectAllStudent();
            
    
    
        }
    }

### 4.5.4.2 说明 ###

#### 4.5.4.2.1 **SqlSessionFactoryBean** ####

在基础的 MyBatis 用法中，是通过 SqlSessionFactoryBuilder 来创建 SqlSessionFactory 的。 而在 MyBatis-Spring 中，则使用 SqlSessionFactoryBean 来创建。

<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
            
            <property name="dataSource" ref="dataSource"/>
            
            <property name="configLocation" value="classpath:mybatis-config.xml"/>
            
            <property name="mapperLocations" value="classpath:mapper/*.xml"/>
        </bean>

#### 4.5.4.2.2 **DataSource** ####

SqlSessionFactory 有一个唯一的必要属性：用于 JDBC 的 DataSource。这可以是任意的 DataSource 对象，它的配置方法和其它 Spring 数据库连接是一样的。

#### 4.5.4.2.3**configLocation** ####

一个常用的属性是 configLocation，它用来指定 MyBatis 的 XML 配置文件路径。它在需要修改 MyBatis 的基础配置非常有用。通常，基础配置指的是<settings> 或 <typeAliases> 元素。 需要注意的是，这个配置文件并不需要是一个完整的 MyBatis 配置。确切地说，任何环境配置（<environments>），数据源（<DataSource>）和 MyBatis 的事务管理器（<transactionManager>）都会被忽略。SqlSessionFactoryBean 会创建它自有的 MyBatis 环境配置（Environment），并按要求设置自定义环境的值。

如果 MyBatis 在映射器类对应的路径下找不到与之相对应的映射器 XML 文件，那么也需要配置文件。这时有两种解决办法：第一种是手动在 MyBatis 的 XML 配置文件中的 <mappers> 部分中指定 XML 文件的类路径；第二种是设置工厂 bean 的 mapperLocations 属性。

#### 4.5.4.2.4 **mapperLocations** ####

mapperLocations 属性接受多个资源位置。这个属性可以用来指定 MyBatis 的映射器 XML 配置文件的位置。属性的值是一个 Ant 风格的字符串，可以指定加载一个目录中的所有文件，或者从一个目录开始递归搜索所有目录。

#### 4.5.4.2.5MapperScannerConfigurer ####

**basePackage** MapperScannerConfigurer:有一个重要的属性basePackage用于扫描映射指定包下所有的mapper映射接口，mybatis执行时会与已经加载的mapper对应的xml进行映射调用相应的方法执行sql语句返回结果

## 4.5.5 Spring与Web环境集成 ##

spring总归是要在web项目上运行的。

#### 4.5.5.1 ApplicationContext应用上下文获取方式 ####

应用上下文对象是通过new **ClasspathXmlApplicationContext**(spring配置文件) 方式获取的，但是每次从容器中获得Bean时都要编写new ClasspathXmlApplicationContext(spring配置文件) ，这样的弊端是配置文件加载多次，应用上下文对象创建多次。

在Web项目中，可以使用**ServletContextListener**监听Web应用的启动，我们可以在Web应用启动时，就加载Spring的配置文件，创建应用上下文对象**ApplicationContext**，在将其存储到最大的域**servletContext域**中，这样就可以在任意位置从域中获得应用上下文ApplicationContext对象了。

#### 4.5.5.2 Spring提供获取应用上下文的工具 ####

Spring提供了一个监听器**ContextLoaderListener**就是对上述功能的封装，该监听器内部加载Spring配置文件，创建应用上下文对象，并存储到**ServletContext域**中，提供了一个客户端工具WebApplicationContextUtils供使用者获得应用上下文对象。

所以我们需要做的只有两件事：

①在web.xml中配置ContextLoaderListener监听器（导入spring-web坐标）当服务启动时加载

②使用WebApplicationContextUtils获得应用上下文对象ApplicationContext

### 4.5.5.3 集成步骤 ###

Spring集成web环境步骤：

1.  配置ContextLoaderListener监听器
2.  使用WebApplicationContextUtils获得应用上下文
3.  spring-web提供的监听器spring-webmvc也会提供（同时使用会冲突）

**将项目配置成web项目：配置tomcat**

**导入Spring和SpringMVC的坐标、导入Servlet和Jsp的坐标**

<dependency>
         <groupId>org.springframework</groupId>
         <artifactId>spring-context</artifactId>
         <version>5.0.8.RELEASE</version>
     </dependency>
     
     <dependency>
         <groupId>org.springframework</groupId>
         <artifactId>spring-webmvc</artifactId>
         <version>5.0.8.RELEASE</version>
     </dependency>
        
        <dependency>
          <groupId>javax.servlet.jsp</groupId>
          <artifactId>jsp-api</artifactId>
          <version>2.0</version>
        </dependency>
        
        <dependency>
          <groupId>javax.servlet</groupId>
          <artifactId>javax.servlet-api</artifactId>
          <version>3.1.0</version>
        </dependency>

**在web.xml配置全局参数和监听器**

<context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>classpath:applicationContext.xml</param-value>
    </context-param>
    
    <listener>
    	<listener-class>
           org.springframework.web.context.ContextLoaderListener
       </listener-class>
     </listener>

**测试**

@WebServlet(name = "TestServlet", value = "/my")
    public class TestServlet extends HttpServlet {
        @Override
        protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
            ServletContext servletContext = request.getServletContext();
    
            WebApplicationContext spring = WebApplicationContextUtils.getWebApplicationContext(servletContext);
            StudentMapper student = spring.getBean(StudentMapper.class);
            student.selectAllStudent();
    
    
    
        }
    
        @Override
        protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
    
        }
    }

[_2.1_-MySQL]: https://blog.csdn.net/qq_43757965/article/details/127731494?spm=1001.2014.3001.5501