# spring-learn

**Repository Path**: hrbu2023/spring-learn

## Basic Information

- **Project Name**: spring-learn
- **Description**: spring-ioc、AOP学习
- **Primary Language**: Unknown
- **License**: Not specified
- **Default Branch**: master
- **Homepage**: None
- **GVP Project**: No

## Statistics

- **Stars**: 0
- **Forks**: 0
- **Created**: 2026-03-10
- **Last Updated**: 2026-03-13

## Categories & Tags

**Categories**: Uncategorized

**Tags**: None

## README

# Spring  Core

Spring使得创建Java企业级应用变得轻松。它提供了在企业环境中使用Java语言所需的一切功能，支持Groovy和Kotlin作为JVM上的替代语言，并具备根据应用需求灵活构建多种架构的能力。自Spring Framework 6.0起，Spring要求Java 17+版本

IOC 容器( Inversion of Control ): 控制翻转：  类与类之间的依赖关系，由工厂（容器）管理，被依赖的对象什么时候创建、怎么创建都交给Spring  工厂

- Controller
- Service
- Dao(Mapper)

public  class UserController{

    private IUserService userService = new UserService

- list
- save
- update

}

## 实例

项目名称--  spring-01-ioc-xml

![image-20260310085152357](assets/image-20260310085152357.png)

在父项目中使用 dependencyManagement 统一定义 依赖的版本号方便统一修改管理

```xml
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>

  <groupId>com.neuedu.sm</groupId>
  <artifactId>spring-learn</artifactId>
  <version>1.0</version>
  <packaging>pom</packaging>

  <name>spring-learn</name>
  <url>http://maven.apache.org</url>
  <modules>
    <module>spring-01-ioc-xml</module>
  </modules>

  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <junit.version>5.13.4</junit.version>
  </properties>


<!--  dependencyManagement 中定义的依赖  在项目中没有实际应用
      当项目（parent、子项目）使用了以来，可以忽略版本号

 -->
  <dependencyManagement>
      <dependencies>
        <!-- Source: https://mvnrepository.com/artifact/org.junit.jupiter/junit-jupiter-api -->
        <dependency>
          <groupId>org.junit.jupiter</groupId>
          <artifactId>junit-jupiter-api</artifactId>
          <version>${junit.version}</version>
          <scope>test</scope>
        </dependency>

      </dependencies>
  </dependencyManagement>



</project>

```

在父项目中 添加Spring的版本，然后在 01-ioc-xml项目中真正的添加依赖（不需要版本号）

### 父项目

```xml
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>

  <groupId>com.neuedu.sm</groupId>
  <artifactId>spring-learn</artifactId>
  <version>1.0</version>
  <packaging>pom</packaging>

  <name>spring-learn</name>
  <url>http://maven.apache.org</url>
  <modules>
    <module>spring-01-ioc-xml</module>
  </modules>

  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <junit.version>5.13.4</junit.version>
    <spring.version>6.2.16</spring.version>
  </properties>


<!--  dependencyManagement 中定义的依赖  在项目中没有实际应用
      当项目（parent、子项目）使用了以来，可以忽略版本号


 -->
  <dependencyManagement>
      <dependencies>
        <!-- Source: https://mvnrepository.com/artifact/org.junit.jupiter/junit-jupiter-api -->
        <dependency>
          <groupId>org.junit.jupiter</groupId>
          <artifactId>junit-jupiter-api</artifactId>
          <version>${junit.version}</version>
          <scope>test</scope>
        </dependency>

        <!-- 此依赖会关联引用Spring中的所有基础jar包 -->
        <dependency>
          <groupId>org.springframework</groupId>
          <artifactId>spring-context</artifactId>
          <version>${spring.version}</version>
        </dependency>

        <dependency>
          <groupId>org.springframework</groupId>
          <artifactId>spring-beans</artifactId>
          <version>${spring.version}</version>
        </dependency>

        <dependency>
          <groupId>org.springframework</groupId>
          <artifactId>spring-core</artifactId>
          <version>${spring.version}</version>
        </dependency>

        <dependency>
          <groupId>org.springframework</groupId>
          <artifactId>spring-expression</artifactId>
          <version>${spring.version}</version>
        </dependency>

      </dependencies>
  </dependencyManagement>



</project>

```

### 子项目添加具体的依赖

![image-20260310090802522](assets/image-20260310090802522.png)

使用UserService  依赖 UserDao 说明 IOC的关系

- IUserService  :  service层的接口
- UserServiceImpl  : 实现IUserService  的实现类
- IUserDao  :  dao层的接口
- UserDaoImpl  : 实现IUserDao    的实现类

创建工厂:  管理   IUserService    实例、IUserDao

从工厂中获取一个UserService 调用里面的方法

### 编写代码

实现使用工厂管理 UserService

IUserService

```java
package com.neuedu.sm.service;

public interface IUserService {

    /**
     * 查询用户列表
     */
    public void list();

}
```

UserServiceImpl

```java
package com.neuedu.sm.service.impl;

import com.neuedu.sm.service.IUserService;

public class UserServiceImpl implements IUserService {
    @Override
    public void list() {
        System.out.println("查询用户信息");
    }
}
```

### 使用XML定义工厂

```xml
<?xml version="1.0" encoding="UTF-8"?>
<beans
        xmlns="http://www.springframework.org/schema/beans"
        xmlns:context="http://www.springframework.org/schema/context"
        xmlns:aop="http://www.springframework.org/schema/aop"
        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/context
  http://www.springframework.org/schema/context/spring-context.xsd
  http://www.springframework.org/schema/aop
  http://www.springframework.org/schema/aop/spring-aop-4.1.xsd">


        <!--  定义 Bean (使用容器管理的对象)
            name=""   name的属性 是为了兼容其他框架，现在不用了
            使用ID形式定义的名称

         -->
    <bean id="userService"  class="com.neuedu.sm.service.impl.UserServiceImpl"></bean>




</beans>
```

### 测试

从容器中获取对象（UserService）

使用XML文件的形式构造容器（工厂）,使用ClassPathXmlApplicationContext 加载 xml 构建工厂

![image-20260310092722735](assets/image-20260310092722735.png)

### 使用工厂

```
package com.neuedu.sm;

import com.neuedu.sm.service.IUserService;
import org.junit.jupiter.api.Test;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class UseBeanFactory {

    @Test
    public void test(){

        //1 构造工厂
        // "spring-ioc.xml" 配置文件
        //  context 工厂对象 ： 作用 管理对象的全部生命周期（创建、销毁......）
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("spring-ioc.xml");


        //2 从工厂中获取对象
        IUserService userService = context.getBean(IUserService.class);
        System.out.println("userService = " + userService);


        //3 调用对象 list方法
        userService.list();


    }


}

```

## 依赖注入(构造器子注入)

使用IOC容器管理Dao

- IUserDao
- UserDaoImpl

IUserDao

```java
package com.neuedu.sm.dao;

public interface IUserDao {


    public void selectList();
}
```

UserDaoImpl

```java
package com.neuedu.sm.dao.impl;

import com.neuedu.sm.dao.IUserDao;

public class UserDaoImpl implements IUserDao {
    @Override
    public void selectList() {
        System.out.println("UserDaoImpl.selectList 实现");
    }
}
```

使用容器管理

```xml
<?xml version="1.0" encoding="UTF-8"?>
<beans
        xmlns="http://www.springframework.org/schema/beans"
        xmlns:context="http://www.springframework.org/schema/context"
        xmlns:aop="http://www.springframework.org/schema/aop"
        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/context
  http://www.springframework.org/schema/context/spring-context.xsd
  http://www.springframework.org/schema/aop
  http://www.springframework.org/schema/aop/spring-aop-4.1.xsd">


        <!--  定义 Bean (使用容器管理的对象)
            name=""   name的属性 是为了兼容其他框架，现在不用了
            使用ID形式定义的名称

         -->
    <bean id="userService"  class="com.neuedu.sm.service.impl.UserServiceImpl"></bean>



    <bean id="userDao"  class="com.neuedu.sm.dao.impl.UserDaoImpl"></bean>




</beans>
```

维护依赖关系

UserService 需要使用UserDao

在容器配置文件中 给UserService 设置一个UserDao

![image-20260310095943537](assets/image-20260310095943537.png)

```xml
<?xml version="1.0" encoding="UTF-8"?>
<beans
        xmlns="http://www.springframework.org/schema/beans"
        xmlns:context="http://www.springframework.org/schema/context"
        xmlns:aop="http://www.springframework.org/schema/aop"
        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/context
  http://www.springframework.org/schema/context/spring-context.xsd
  http://www.springframework.org/schema/aop
  http://www.springframework.org/schema/aop/spring-aop-4.1.xsd">


        <!--  定义 Bean (使用容器管理的对象)
            name=""   name的属性 是为了兼容其他框架，现在不用了
            使用ID形式定义的名称

         -->
    <bean id="userService"  class="com.neuedu.sm.service.impl.UserServiceImpl">
        <!--   依赖注入 1 使用 构造器的方式注入       -->
        <constructor-arg name="userDao" ref="userDao"></constructor-arg>

    </bean>



    <bean id="userDao"  class="com.neuedu.sm.dao.impl.UserDaoImpl"></bean>




</beans>
```

## 依赖注入(设值注入 setter)

使用IOC容器管理Dao

- IRoleService
- RoleServiceImp;
- IRoleDao
- RoleDaoImpl

### IRoleService

```java
package com.neuedu.sm.service;

public interface IRoleService {

    /**
     * 查询角色列表
     */
    public void list();

}

```

### RoleServiceImp

注意需要给注入的属性添加setter属性

```java
package com.neuedu.sm.service.impl;

import com.neuedu.sm.dao.IRoleDao;
import com.neuedu.sm.dao.IUserDao;
import com.neuedu.sm.service.IRoleService;
import com.neuedu.sm.service.IUserService;

public class RoleServiceImpl implements IRoleService {

    private IRoleDao roleDao;

    @Override
    public void list() {
        System.out.println("service 查询查询角色 信息");
        roleDao.selectList();
    }

    public IRoleDao getRoleDao() {
        return roleDao;
    }

    public void setRoleDao(IRoleDao roleDao) {
        this.roleDao = roleDao;
    }
}

```

### IRoleDao（Dao层）

```java
package com.neuedu.sm.dao;

public interface IRoleDao {


    public void selectList();
}

```

### RoleDaoImpl

```java
package com.neuedu.sm.dao.impl;

import com.neuedu.sm.dao.IRoleDao;
import com.neuedu.sm.dao.IUserDao;

public class RoleDaoImpl implements IRoleDao {

    @Override
    public void selectList() {
        System.out.println("RoleDaoImpl.selectList 实现");
    }
}

```

### 声明依赖

```xml
 <!--    使用容器管理 RoleServic  RoleDao-->

<bean id="roleService" class="com.neuedu.sm.service.impl.RoleServiceImpl">
    <!--   依赖注入 2  使用 设值方式注入（setter）  需要给  roleDao 添加setter方法       -->
    <property name="roleDao" ref="roleDao"/>
</bean>
<bean id="roleDao" class="com.neuedu.sm.dao.impl.RoleDaoImpl"></bean>
```

![image-20260310101247381](assets/image-20260310101247381.png)

### 单元测试（UseBeanFactory）

```java
 @Test
    public void testSetterDI(){

        //1 构造工厂
        // "spring-ioc.xml" 配置文件
        //  context 工厂对象 ： 作用 管理对象的全部生命周期（创建、销毁......）
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("spring-ioc.xml");


        //2 从工厂中获取对象
        IRoleService roleService = context.getBean(IRoleService.class);


        //3 调用对象 list方法
        roleService.list();


    }
```

# 各种输入的属性类型

在类中注入常见的数据类型 int、String double、float long、array List Map Properties

## 可以被依赖注入的一个Bean类型

```java
package com.neuedu.sm.dao;

import java.util.List;
import java.util.Map;
import java.util.Properties;
import java.util.Set;

public class DeptDao {

    private String url;
    private Integer maxConnection;
    private double salary;

    private String[] names;

    private List<String> users;

    private Set<Integer> ages;
    private Map personInfo;


    private Properties jdbcInfo;


    //setter
    public String getUrl() {
        return url;
    }

    public void setUrl(String url) {
        this.url = url;
    }

    public Integer getMaxConnection() {
        return maxConnection;
    }

    public void setMaxConnection(Integer maxConnection) {
        this.maxConnection = maxConnection;
    }

    public double getSalary() {
        return salary;
    }

    public void setSalary(double salary) {
        this.salary = salary;
    }

    public String[] getNames() {
        return names;
    }

    public void setNames(String[] names) {
        this.names = names;
    }

    public List<String> getUsers() {
        return users;
    }

    public void setUsers(List<String> users) {
        this.users = users;
    }

    public Set<Integer> getAges() {
        return ages;
    }

    public void setAges(Set<Integer> ages) {
        this.ages = ages;
    }

    public Map getPersonInfo() {
        return personInfo;
    }

    public void setPersonInfo(Map personInfo) {
        this.personInfo = personInfo;
    }

    public Properties getJdbcInfo() {
        return jdbcInfo;
    }

    public void setJdbcInfo(Properties jdbcInfo) {
        this.jdbcInfo = jdbcInfo;
    }
}

```

## 在容器中声明（管理）Bean对象

![image-20260310103658897](assets/image-20260310103658897.png)

## 使用

```xml
 <!--    演示各种数据类型 的注入-->

<bean id="deptDao1" class="com.neuedu.sm.dao.DeptDao">
    <property name="url" value="jdbc:mysql://localhost:3306/his?chartxxxxx=utf-8"/>
    <property name="maxConnection" value="100"/>
    <property name="salary" value="500.02"/>
    <!--        <property name="names" value="张三,李四"></property>-->
    <property name="names">
        <array>
            <value>张三</value>
            <value>李四</value>
            <value>王五</value>
            <value>王五</value>
        </array>
    </property>

    <property name="users">
        <list>
            <value>张飞</value>
            <value>刘备</value>
            <value>李逵</value>
            <value>李逵</value>
        </list>
    </property>

    <property name="ages">
        <set>
            <!--set 特性，重复数据，只保留一个 -->
            <value>100</value>
            <value>25</value>
            <value>33</value>
            <value>33</value>
        </set>
    </property>

    <property name="personInfo">
        <map>
            <entry key="name" value="张三"></entry>
            <entry key="age" value="25"></entry>
            <entry key="sex" value="男"></entry>
        </map>
    </property>

    <property name="jdbcInfo">
        <props>
            <prop key="jdbc.url">jdbc:mysql://localhost:3306/his?chartxxxxx=utf-8</prop>
            <prop key="jdbc.driver">com.mysql.jdbc.cj.Driver</prop>
            <prop key="jdbc.user">root</prop>
            <prop key="jdbc.password">root</prop>
        </props>
    </property>


</bean>

```

```java
package com.neuedu.sm.dao;

import org.junit.jupiter.api.Test;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import static org.junit.jupiter.api.Assertions.*;

class DeptDaoTest {

    /**
     *
     * DI   dependency  Injection  依赖注入
     */
    @Test
    public void testDI() {

        //获取容器 工厂
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("spring-ioc.xml");

        //获取DeptDao
//        DeptDao deptDao = (DeptDao) context.getBean("deptDao");
//        DeptDao deptDao =  context.getBean("deptDao", DeptDao.class);

        DeptDao deptDao = context.getBean(DeptDao.class);

        System.out.println(deptDao);

        System.out.println("deptDao.getNames().length = " + deptDao.getNames().length);

    }

}
```

## 控制台打印

```ini
DeptDao{url='jdbc:mysql://localhost:3306/his?chartxxxxx=utf-8', maxConnection=100, salary=500.02, names=[张三, 李四, 王五, 王五], users=[张飞, 刘备, 李逵, 李逵], ages=[100, 25, 33], personInfo={name=张三, age=25, sex=男}, jdbcInfo={jdbc.password=root, jdbc.user=root, jdbc.url=jdbc:mysql://localhost:3306/his?chartxxxxx=utf-8, jdbc.driver=com.mysql.jdbc.cj.Driver}}
deptDao.getNames().length = 4

Process finished with exit code 0
```

# 使用注解的形式声明Bean

- 在xml中使用   包扫描的方式声明Bean

```xml

<context:component-scan base-package="com.neuedu.sm.service"/>
```

在需要声明Bean的类上面使用 @Component注解

```java
package com.neuedu.sm.service;

import org.springframework.stereotype.Component;

/**
 * 当包扫描的时候  需要在容器中注册Bean
 * 作用同    <bean class="com.neuedu.sm.service.UserService"></bean>
 */
@Component
public class UserService {

    public void list() {
        System.out.println("UserService.list--Service层");
    }
}

```

各种注解的含义

除了@Component这个泛指组件的注解外，Spring还提供了与@Component功能相同的三个语义化注解。

1. @Service 业务层组件
2. @Controller 控制层组件
3. @Repository 数据层组件

修改上面代码，使用@Repository 和 @Service 替换 dao 与 service 组件上的注解。

# 使用Autowired注入属性

基于注解的依赖 使用@Autowired注解，`@Target({ElementType.CONSTRUCTOR, ElementType.METHOD, ElementType.PARAMETER, ElementType.FIELD, ElementType.ANNOTATION_TYPE})`

## 构造方法注入

```java
package com.neuedu.sm.controller;


import com.neuedu.sm.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;

@Controller
public class UserController {


    private UserService userService;


    /**
     * 构造器的方式注入
     * @param userService
     */
    @Autowired
    public UserController(UserService userService) {
        this.userService = userService;
    }

    public void queryList() {
        System.out.println("UserController.queryList --Controller层");
        userService.list();
    }


}

```

## 属性注入

```java
package com.neuedu.sm.service;

import com.neuedu.sm.dao.UserDao;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.stereotype.Controller;
import org.springframework.stereotype.Service;

/**
 * 当包扫描的时候  需要在容器中注册Bean
 * 作用同    <bean class="com.neuedu.sm.service.UserService"></bean>
 */

@Service
public class UserService {

    /**
     * 属性注入
     */
    @Autowired
    private UserDao userDao;

    public void list() {
        System.out.println("UserService.list--Service层");
        userDao.selectList();
    }

   /* public UserDao getUserDao() {
        return userDao;
    }


    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }*/
}

```

```java
package com.neuedu.sm.dao;


import org.springframework.stereotype.Repository;

@Repository
public class UserDao {

    public void selectList() {
        System.out.println("UserDao.selectList 实现");
    }
}

```

    存在同一个类型 由多个实例

使用注解 Qualifier 按名称查找，

![image-20260310115754053](assets/image-20260310115754053.png)

# Spring的测试框架

使用的框架 是 **Junit5** 在编写代码过程中经常的会测试  Bean，代码的逻辑是使用@BeforeEach的注解，获取容器，然后在从容器中获取Bean（Controller、Service、Dao等）

可以使用 Spring-test框架对 Junit进行扩展（自动启动容器-Bean工厂 ），然他默认加载某一个配置文件，可以使用@Autowired从容器中获取Bean

## 引入依赖

- Junit-4
- junit-5
- Spring-test

在父项目的pom.xml中声明依赖的版本

```xml
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>

  <groupId>com.neuedu.sm</groupId>
  <artifactId>spring-learn</artifactId>
  <version>1.0</version>
  <packaging>pom</packaging>

  <name>spring-learn</name>
  <url>http://maven.apache.org</url>
  <modules>
    <module>spring-01-ioc-xml</module>
    <module>spring-02-ico-xml-component-scan</module>
    <module>spring-03-ico-xml-component-scan-DI</module>
  </modules>

  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <junit4.version>4.13.2</junit4.version>
    <junit.version>5.13.4</junit.version>
    <spring.version>6.2.16</spring.version>
  </properties>


<!--  dependencyManagement 中定义的依赖  在项目中没有实际应用
      当项目（parent、子项目）使用了以来，可以忽略版本号


 -->
  <dependencyManagement>
      <dependencies>
        <!-- Source: https://mvnrepository.com/artifact/org.junit.jupiter/junit-jupiter-api -->
        <dependency>
          <groupId>org.junit.jupiter</groupId>
          <artifactId>junit-jupiter-api</artifactId>
          <version>${junit.version}</version>
          <scope>test</scope>
        </dependency>

        <dependency>
          <groupId>junit</groupId>
          <artifactId>junit</artifactId>
          <version>${junit4.version}</version>
          <scope>test</scope>
        </dependency>

        <!-- 此依赖会关联引用Spring中的所有基础jar包 -->
        <dependency>
          <groupId>org.springframework</groupId>
          <artifactId>spring-context</artifactId>
          <version>${spring.version}</version>
        </dependency>

        <dependency>
          <groupId>org.springframework</groupId>
          <artifactId>spring-beans</artifactId>
          <version>${spring.version}</version>
        </dependency>

        <dependency>
          <groupId>org.springframework</groupId>
          <artifactId>spring-core</artifactId>
          <version>${spring.version}</version>
        </dependency>

        <dependency>
          <groupId>org.springframework</groupId>
          <artifactId>spring-expression</artifactId>
          <version>${spring.version}</version>
        </dependency>
        <dependency>
          <groupId>org.springframework</groupId>
          <artifactId>spring-test</artifactId>
          <scope>test</scope>
          <version>${spring.version}</version>
        </dependency>

      </dependencies>
  </dependencyManagement>



</project>

```

## 创建一个子项目

spring-04-ioc-xml-scan-autowired-test-framework

子项目的依赖

```xml
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>com.neuedu.sm</groupId>
        <artifactId>spring-learn</artifactId>
        <version>1.0</version>
    </parent>

    <artifactId>spring-04-ioc-xml-scan-autowired-test-framework</artifactId>
    <packaging>jar</packaging>

    <name>spring-04-ioc-xml-scan-autowired-test-framework</name>
    <url>http://maven.apache.org</url>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>

    <dependencies>

        <!-- spring framwork 基础包 -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
        </dependency>

        <!--  Spring  测试框架-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
        </dependency>


        <!-- junit 5        -->
        <dependency>
            <groupId>org.junit.jupiter</groupId>
            <artifactId>junit-jupiter-api</artifactId>
        </dependency>

        <!--        junit4  -->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
        </dependency>



    </dependencies>
</project>

```

## 使用03的代码(Junit-5)

在单元测试类上添加 `@SpringJUnitConfig(locations = "classpath:spirng-ioc-scan-di.xml")` 会自动的注册Bean工厂，可以在当前的测试类中使用@Autowired从容器中获取 Bean

```java
package com.neuedu.sm.controller;

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.junit.jupiter.SpringJUnitConfig;


//使用Spring-test 对 Junit的扩展
@SpringJUnitConfig(locations = "classpath:spirng-ioc-scan-di.xml")
class UserControllerJunit5Test {


    @Autowired
    UserController userController;

    @Test
    void queryList() {
        userController.queryList();
    }
}
```

## Junit4的支持

```java

package com.neuedu.sm.controller;

//import org.junit.jupiter.api.Test;

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

//使用Spring-test 对 Junit的扩展
//@SpringJUnitConfig(locations = "classpath:spirng-ioc-scan-di.xml")

//RunWith 对  Junit进行扩展
//@RunWith(value=SpringJUnit4ClassRunner.class)
//@ContextConfiguration(locations = "classpath:spirng-ioc-scan-di.xml")
//@ContextConfiguration(value = "classpath:spirng-ioc-scan-di.xml")

/**
 * 使用Junit4
 */
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:spirng-ioc-scan-di.xml")
public class UserControllerJunit4Test {


    @Autowired
    UserController userController;

    @Test
    public void queryList() {
        userController.queryList();
    }
}
```

# Java配置类

## 普通的Bean声明

```java
public class UserController {


    public void queryList(){
        System.out.println("UserController.queryList --Controller层");
    }


}
```

## 使用配置类的方式注册Bean（替代配置文件）

```java
package com.neuedu.sm;


import com.neuedu.sm.controller.UserController;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;


/**
 * 相当于配置文件
 *
 * Configuration
 */

public class SpirngIocConfiguration {


    /**
     * @Bean 相当与 <bean class=“com.neuedu.sm.controller.UserController” />
     *
     * @Bean 一般用于注册第三方的  包（拿不到源码 ）
     * @return
     */
    @Bean
    public UserController userController() {
        return new UserController();
    }


}
```

## 使用@ComponentScan注解进行包扫描

![image-20260310152102427](assets/image-20260310152102427.png)

# 使用@Bean注册第三方类

在容器中注册  Mybatis的SQLSessionFactory

- 添加依赖
  - 父项目中版本控制
  - 子项目中添加依赖（不需要版本号）

## 父项目的pom.xml

```xml
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>

  <groupId>com.neuedu.sm</groupId>
  <artifactId>spring-learn</artifactId>
  <version>1.0</version>
  <packaging>pom</packaging>

  <name>spring-learn</name>
  <url>http://maven.apache.org</url>
  <modules>
    <module>spring-01-ioc-xml</module>
    <module>spring-02-ioc-xml-component-scan</module>
    <module>spring-03-ioc-xml-component-scan-DI</module>
    <module>spring-04-ioc-xml-scan-autowired-test-framework</module>
    <module>spring-05-javaconfig</module>
  </modules>

  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <junit4.version>4.13.2</junit4.version>
    <junit.version>5.13.4</junit.version>
    <spring.version>6.2.16</spring.version>
    <mysql.version>8.2.0</mysql.version>
    <mybatis.version>3.5.19</mybatis.version>
<!--    <spring.version>7.0.5</spring.version>-->
  </properties>


<!--  dependencyManagement 中定义的依赖  在项目中没有实际应用
      当项目（parent、子项目）使用了以来，可以忽略版本号


 -->
  <dependencyManagement>
      <dependencies>
        <!-- Source: https://mvnrepository.com/artifact/org.junit.jupiter/junit-jupiter-api -->
        <dependency>
          <groupId>org.junit.jupiter</groupId>
          <artifactId>junit-jupiter-api</artifactId>
          <version>${junit.version}</version>
          <scope>test</scope>
        </dependency>

        <dependency>
          <groupId>junit</groupId>
          <artifactId>junit</artifactId>
          <version>${junit4.version}</version>
          <scope>test</scope>
        </dependency>

        <!-- 此依赖会关联引用Spring中的所有基础jar包 -->
        <dependency>
          <groupId>org.springframework</groupId>
          <artifactId>spring-context</artifactId>
          <version>${spring.version}</version>
        </dependency>

        <dependency>
          <groupId>org.springframework</groupId>
          <artifactId>spring-beans</artifactId>
          <version>${spring.version}</version>
        </dependency>

        <dependency>
          <groupId>org.springframework</groupId>
          <artifactId>spring-core</artifactId>
          <version>${spring.version}</version>
        </dependency>

        <dependency>
          <groupId>org.springframework</groupId>
          <artifactId>spring-expression</artifactId>
          <version>${spring.version}</version>
        </dependency>
        <dependency>
          <groupId>org.springframework</groupId>
          <artifactId>spring-test</artifactId>
          <scope>test</scope>
          <version>${spring.version}</version>
        </dependency>


        <dependency>
          <groupId>com.mysql</groupId>
          <artifactId>mysql-connector-j</artifactId>
          <version>${mysql.version}</version>
        </dependency>
        <!--    mybaits框架-->
        <dependency>
          <groupId>org.mybatis</groupId>
          <artifactId>mybatis</artifactId>
          <version>${mybatis.version}</version>
        </dependency>

      </dependencies>
  </dependencyManagement>



</project>

```

## 子项目添加依赖

```xml
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>com.neuedu.sm</groupId>
        <artifactId>spring-learn</artifactId>
        <version>1.0</version>
    </parent>

    <artifactId>spring-05-javaconfig</artifactId>
    <packaging>jar</packaging>

    <name>spring-05-javaconfig</name>
    <url>http://maven.apache.org</url>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>


    <dependencies>

        <!-- spring framwork 基础包 -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
        </dependency>

        <!--  Spring  测试框架-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
        </dependency>


        <!-- junit 5        -->
        <dependency>
            <groupId>org.junit.jupiter</groupId>
            <artifactId>junit-jupiter-api</artifactId>
        </dependency>



        <!--       数据库持久层 依赖 -->
        <dependency>
            <groupId>com.mysql</groupId>
            <artifactId>mysql-connector-j</artifactId>
        </dependency>
        <!--    mybaits框架-->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
        </dependency>


    </dependencies>
</project>
```

# Bean的作用域

| Scope                                                                                                                         | Description                                                                                                                                                                  |
| :---------------------------------------------------------------------------------------------------------------------------- | :--------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| [singleton](https://docs.spring.io/spring-framework/reference/6.2/core/beans/factory-scopes.html#beans-factory-scopes-singleton) | （默认）将单个 Bean 定义映射到每个 Spring IoC 的单个对象实例 容器。                                                                                                          |
| prototype                                                                                                                     | 将单个豆定义作用域为任意数量的对象实例。                                                                                                                                     |
| request                                                                                                                       | 将单个 bean 定义作用域到单个 HTTP 请求的生命周期。也就是说， 每个HTTP请求都有自己由单个豆子创建的豆子实例 定义。仅在具备网页功能的 Spring 环境中有效。`ApplicationContext` |
| session                                                                                                                       | 将单个豆定义作用域到HTTP的生命周期。仅在 一个具备网络感知的春季环境。`Session``ApplicationContext`                                                                         |
| application                                                                                                                   | 用单一豆子定义范围到一个的生命周期。仅在 一个具备网络感知的春季环境。`ServletContext``ApplicationContext`                                                                  |
| [websocket](https://docs.spring.io/spring-framework/reference/6.2/web/websocket/stomp/scope.html)                                | 用单一豆子定义范围到一个的生命周期。仅在 网络感知春季的背景 `WebSocket``ApplicationContext`.                                                                               |

# AOP 面相切面编程

## 代理机制

Spring AOP使用了两种代理机制：一种是基于JDK的动态代理；另一种是基于CGLib的动态代理。之所以需要两种代理机制，是因为JDK本身只提供接口的代理，而不支持类的代理。

### JDK动态代理

Spring的AOP的默认实现就是采用jdk的动态代理机制实现的。

自Java1.3以后，Java提供了动态代理技术，允许开发者在运行期创建接口的代理实例。

### CGLib代理

JDK只能为接口创建代理实例，对于那些没有通过接口定义业务方法的类，可以通过CGLib创建代理实例。

CGLib采用底层字节码技术，可以为一个类创建子类，并在子类中采用方法拦截技术拦截所有父类方法的调用，这时可以顺势织入横切逻辑。

代理对象的伪代码

```java
package com.neuedu.sm.service;

public class UserService {

    public void save() {
        //方法之前 开启 事务
        System.out.println("保存用户数据");
        // 提交事务

        //回滚实物
    }


}

```

## 代理对象

```java
package com.neuedu.sm.service;

public class UserServiceProxy extends UserService {

    @Override
    public void save() {
        System.out.println("开启事务");
        super.save();
        System.out.println("提交事务");
    }


    public static void main(String[] args) {

        UserService userService = new UserServiceProxy();
        userService.save();
    }
}

```

![image-20260311103543751](assets/image-20260311103543751.png)

可以通过AOP的机制 实现动态代理

### 4.3.1. 切面（Aspect）

切面是切点和通知组成，通知和切点共同定义了切面的全部内容即：它是什么，在何时何处完成其功能；

举例：将pointcut和Advice配置整合的过程切面

### 4.3.2. 连接点（Joinpoint）

连接点是在应用执行过程中能够插入切面的一个点，Spring仅支持方法的连接点，即仅能在方法调用前，方法调用后，方法抛出异常时及方法调用前后插入切面代码。 .

举例：如果在insert之前执行扩展（增强、通知），简单理解insert这个方法可以称之为连接点。

连接点: 1 Com.neuedu.service.StuServiceImpl.insert()

连接点: 2 Com.neuedu.service.UserServiceImpl.insert()

### 4.3.3. 切点(Pointcut）

```
Com.neuedu.service.*Impl.insert() 
```

### 4.3.4. 通知（Advice）、增强

切面的工作被成为通知，定义了切面是什么及何时使用。除了描述切面要完成的工作，通知还解决了何时执行这个工作的问题，它应该在某个方法被调用之前？之后？等。

举例：额外定义一个方法想要在连接点上进行扩展的功能

#### 4.3.4.1. Spring切面可以应用5种类型的通知：

前置通知（Before）在目标方法被调用之前调用通知功能；

后置通知（After）在目标方法被完成之后调用通知功能，不关心方法的输出是什么；

环绕通知（Around advice）通知包裹了目标方法，在目标方法调用之前和之后执行自定义的行为；

异常通知（After-throwing)在目标方法抛出异常后调用通知；

返回通知（After-returning）在目标方法成功执行之后调用通知；

### 4.3.5. 目标对象(Target)

通知逻辑的织入目标类。如果没有AOP，那么目标业务类需要自己实现所有的逻辑，在AOP的帮助下，目标类只需要实现那些非横切逻辑的程序逻辑，而比如事务管理等这些横切逻辑就可以使用AOP动态织入特定的连接点上。

举例：两个Service即是目标对象

### 4.3.6. 引入（Introduction）

引介是一种特殊的通知，为类添加一些属性和方法。这样，即使一个业务类原本没有实现某个接口，通过AOP的引介功能，也可以动态地为该业务类添加接口的实现逻辑，使业务类成为这个接口的实现类。

几乎由框架完成，我们可以暂时透明

### 4.3.7. 代理（Proxy）

一个类被AOP织入通知后，就产生一个结果类，它是融合了原类和通知逻辑的代理类。根据不同的代理方式，代理类既可能是和原类具有相同接口的类，也可能就是原类的子类，所以可以采用与调用原类相同的方式调用代理类。

举例：IOC容器创建的两个Service类型对象

### 4.3.8. 织入(Weaving)

织入是将通知添加到目标类的具体连接点上的过程.AOP就像一台织布机，将目标类，通知或引介编织到一起。 AOP有三种织入方式： ①编译期织入：切面在目标类编译时被织入，需要特殊的编译器； ②类装载期织入：切面在目标类加载到JVM时被织入，需要特殊的类装载器； ③动态代理织入：切面在应用运行的某个时刻呗织入，AOP容器会为目标对象动态创建一个代理对象；

## 面相切面编程（AOP） 需要编写的代码

- 目标对象( UserService、RoleService   各种Bean)
- 通知:  在目标对象方法基础上添加的功能（属性、加方法  加代码 ）
- 编写切面
  - 切点
  - 通知
- 使用目标对象--- 从容器中获取-- 由容器调用AOP （织入）  代理对象

# AOP案例

定义 UseService、RoleService 包含  save功能，

> 需求  需要给 save功能 执行之前  添加一个开启事务的功能

- 创建项目  spring-07-aop-xml
- 添加依赖    spirng-context(core、bean、express、context)、spirng-aop 、aspectjweaver
- 编写  UseService、RoleService

子项目中需要的依赖

```xml
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>com.neuedu.sm</groupId>
        <artifactId>spring-learn</artifactId>
        <version>1.0</version>
    </parent>

    <artifactId>spring-07-aop-xml</artifactId>
    <packaging>jar</packaging>

    <name>spring-07-aop-xml</name>
    <url>http://maven.apache.org</url>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>

    <dependencies>


        <!-- 此依赖会关联引用Spring中的所有基础jar包 -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>${spring.version}</version>
        </dependency>

        <!--      AOP  -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aop</artifactId>
        </dependency>

        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
        </dependency>


        <!--        测试框架  -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <scope>test</scope>
        </dependency>
        <!-- Source: https://mvnrepository.com/artifact/org.junit.jupiter/junit-jupiter-api -->
        <dependency>
            <groupId>org.junit.jupiter</groupId>
            <artifactId>junit-jupiter-api</artifactId>
            <version>${junit.version}</version>
            <scope>test</scope>
        </dependency>


    </dependencies>
</project>

```

## 编写AOP基础环境代码

- UseService、RoleService   @Service
- 配置文件  spring-aop   使用包扫描  component-scan

```xml
<?xml version="1.0" encoding="UTF-8"?>
<beans
        xmlns="http://www.springframework.org/schema/beans"
        xmlns:context="http://www.springframework.org/schema/context"
        xmlns:aop="http://www.springframework.org/schema/aop"
        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/context
  http://www.springframework.org/schema/context/spring-context.xsd
  http://www.springframework.org/schema/aop
  http://www.springframework.org/schema/aop/spring-aop-4.1.xsd" >




<!--    使用  注解 扫描的方式 注册  Bean组件 -->
    <context:component-scan base-package="com.neuedu.sm"/>


</beans>
```

编写单元测试 获取UserService、RoleService测试save功能

```java
package com.neuedu.sm;

import com.neuedu.sm.service.UserService;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.junit.jupiter.SpringJUnitConfig;


@SpringJUnitConfig(locations = "classpath:spring-aop.xml")
public class UserServiceTest {

    @Autowired
    UserService userService;

    @Test
    public void test() {

        userService.save();
    }
}

```

测试结果

![image-20260311110059653](assets/image-20260311110059653.png)

## 配置AOP（代完成）

**前置通知（Before）在目标方法被调用之前调用通知功能；**

后置通知（After）在目标方法被完成之后调用通知功能，不关心方法的输出是什么；

环绕通知（Around advice）通知包裹了目标方法，在目标方法调用之前和之后执行自定义的行为；

异常通知（After-throwing)在目标方法抛出异常后调用通知；

返回通知（After-returning）在目标方法成功执行之后调用通知

### 编写通知方法（Before）

在容器中注册Bean(通知类)

````java
package com.neuedu.sm.service.advice;


import org.springframework.stereotype.Component;

@Component
public class MyAdvice {

    public void before() {
        System.out.println("在service方法之前执行");
        System.out.println("在service方法之前执行");
        System.out.println("在service方法之前执行");
        System.out.println("在service方法之前执行");
    }

}

````

## 配置切面(使用XML)

```xml
<?xml version="1.0" encoding="UTF-8"?>
<beans
        xmlns="http://www.springframework.org/schema/beans"
        xmlns:context="http://www.springframework.org/schema/context"
        xmlns:aop="http://www.springframework.org/schema/aop"
        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/context
  http://www.springframework.org/schema/context/spring-context.xsd
  http://www.springframework.org/schema/aop
  http://www.springframework.org/schema/aop/spring-aop-4.1.xsd">


    <!--    使用  注解 扫描的方式 注册  Bean组件 -->
    <context:component-scan base-package="com.neuedu.sm"/>


    <!--   配置切面-->
    <aop:config>
        <!--    1 配置切点    -->
        <aop:pointcut id="serviceSave" expression="execution(* com.neuedu.sm.service.*.save(..) )"/>
        <!--   2 配置切面 myAdvice 表示的 通知的类     -->
        <aop:aspect ref="myAdvice">
            <aop:before method="before" pointcut-ref="serviceSave"></aop:before>
        </aop:aspect>

    </aop:config>


</beans>
```

### 测试代码

```java
package com.neuedu.sm;

import com.neuedu.sm.service.UserService;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.junit.jupiter.SpringJUnitConfig;


@SpringJUnitConfig(locations = "classpath:spring-aop.xml")
public class UserServiceTest {

    @Autowired
    UserService userService;

    @Test
    public void test() {

        userService.save();
    }
}

```

![image-20260311112657235](assets/image-20260311112657235.png)

## 其他通知类型

基础的Bean代码

```java
package com.neuedu.sm.service;


import org.springframework.stereotype.Service;

@Service
public class RoleService {


    public void save() {
        System.out.println("RoleService.save --保存[角色 ]");
    }

    public void queryList() {
        System.out.println("RoleService.queryList --查询角色");
    }


    public void update(boolean success) throws Exception {
        System.out.println("RoleService.update --更新角色");
        if (!success) {
            throw new Exception("产生错误了");
        }
    }

    public Object getById(boolean success) throws Exception {
        System.out.println("RoleService.queryById --查询对象");
        if (!success) {
            throw new Exception("产生错误了");
        }

        return "查询对象-Role ";
    }


}

```

```java
package com.neuedu.sm.service;


import org.springframework.stereotype.Service;

@Service
public class UserService {


    public void save() {
        System.out.println("UserService.save --保存用户");
    }

    public void queryList() {
        System.out.println("UserService.queryList --查询用户");
    }


    /**
     * 可能产生异常的方法
     * @param success
     * @throws Exception
     */
    public void update(boolean success) throws Exception {
        System.out.println("UserService.update --更新用户");
        if (!success) {
            throw new Exception("产生错误了");
        }
    }


    public Object getById(boolean success) throws Exception {
        System.out.println("UserService.queryById --查询对象");
        if (!success) {
            throw new Exception("产生错误了");
        }

        return "查询对象-User ";
    }


}

```

### 配置通知

```xml
<?xml version="1.0" encoding="UTF-8"?>
<beans
        xmlns="http://www.springframework.org/schema/beans"
        xmlns:context="http://www.springframework.org/schema/context"
        xmlns:aop="http://www.springframework.org/schema/aop"
        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/context
  http://www.springframework.org/schema/context/spring-context.xsd
  http://www.springframework.org/schema/aop
  http://www.springframework.org/schema/aop/spring-aop-4.1.xsd">


    <!--    使用  注解 扫描的方式 注册  Bean组件 -->
    <context:component-scan base-package="com.neuedu.sm"/>


    <!--   配置切面-->
    <aop:config>
        <!--    1 配置切点    -->
        <aop:pointcut id="serviceSave" expression="execution(* com.neuedu.sm.service.*.save(..) )"/>
        <aop:pointcut id="serviceQuery" expression="execution(* com.neuedu.sm.service.*.query*(..) )"/>
        <aop:pointcut id="serviceUpdate" expression="execution(* com.neuedu.sm.service.*.update*(..) )"/>
        <aop:pointcut id="serviceGetById" expression="execution(* com.neuedu.sm.service.*.getById(..) )"/>
        <!--   2 配置切面 myAdvice 表示的 通知的类     -->
        <aop:aspect ref="myAdvice">
            <aop:before method="before" pointcut-ref="serviceSave"></aop:before>
            <aop:after method="afterAdvice" pointcut-ref="serviceSave"/>
            <aop:around method="around" pointcut-ref="serviceQuery"/>
            <aop:after-throwing method="cathException" pointcut-ref="serviceUpdate" throwing="ex"/>
            <aop:after-returning method="returnAdvice" pointcut-ref="serviceGetById"/>
        </aop:aspect>

    </aop:config>


</beans>
```

### 测试代码

```java
package com.neuedu.sm;

import com.neuedu.sm.service.RoleService;
import com.neuedu.sm.service.UserService;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.junit.jupiter.SpringJUnitConfig;


@SpringJUnitConfig(locations = "classpath:spring-aop.xml")
public class RoleServiceTest {

    @Autowired
    RoleService roleService;

    @Test
    public void test() {

        roleService.save();
    }


    @Test
    public void testQuery() {

        roleService.queryList();
    }

    @Test
    public void testUpdate() throws Exception {
//        boolean success = true;
        boolean success = false;
        roleService.update(success);
    }


    @Test
    public void testQueryById() throws Exception {
//        boolean success = true;
        boolean success = false;
        roleService.getById(success);
    }


}

```

## 使用xml注解扫描+AOP注解

将spring-07-aop-xml 复制一份 spring-08-aop-xml-annotation

将xml中 aop:config标签的配置  换成注解

### 使用配置类

```java
package com.neuedu.sm.service.advice;


import org.aopalliance.intercept.Joinpoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.Signature;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;

@Component
@Aspect
public class MyAdvice {


    /**
     *
     * 使用XML的形式注册切点
     *      <aop:pointcut id="serviceSave" expression="execution(* com.neuedu.sm.service.*.save(..) )"/>
     *         <aop:pointcut id="serviceQuery" expression="execution(* com.neuedu.sm.service.*.query*(..) )"/>
     *         <aop:pointcut id="serviceUpdate" expression="execution(* com.neuedu.sm.service.*.update*(..) )"/>
     *         <aop:pointcut id="serviceGetById" expression="execution(* com.neuedu.sm.service.*.getById(..) )"/>
     */
    @Pointcut("execution(* com.neuedu.sm.service.*.save(..) )")
    public void serviceSave() {
    }

    @Pointcut("execution(* com.neuedu.spring.service.*.query*(..) )")
    public void serviceQuery() {
    }

    @Pointcut("execution(* com.neuedu.spring.service.*.update*(..) )")
    public void serviceUpdate() {
    }

    @Pointcut("execution(* com.neuedu.spring.service.*.getById(..))")
    public void serviceGetById() {
    }


    /**
     * 前置通知  @Before("serviceSave()")
     *   <aop:before method="before" pointcut-ref="serviceSave"></aop:before>
     */
    @Before("serviceSave()")
    public void before() {
        System.out.println("1在service方法之前执行");
        System.out.println("1在service方法之前执行");
        System.out.println("1在service方法之前执行");
    }

    /**
     * 前置通知  @After("serviceSave()")
     *   <aop:after method="afterAdvice"   pointcut-ref="serviceSave"/>
     */
    @After("serviceSave()")
    public void afterAdvice() {
        System.out.println("2在service方法之后执行");
        System.out.println("2在service方法之后执行");
        System.out.println("2在service方法之后执行");
    }


    /**
     * 环绕通知 @Around("serviceQuery()")
     *  <aop:around method="around"   pointcut-ref="serviceQuery"/>
     * @param pjp
     */
    @Around("serviceQuery()")
    public void around(ProceedingJoinPoint pjp) {
        // 执行方法
        System.out.println("环绕通知  1  ");
        try {
            Object target = pjp.getTarget();
            System.out.println("target = " + target);
            Object[] args = pjp.getArgs();
            Signature signature = pjp.getSignature();
            System.out.println("signature = " + signature);
            Object aThis = pjp.getThis();
            //System.out.println("aThis = " + aThis);


            pjp.proceed();   //原始目标的方法
            //提交事务
        } catch (Throwable e) {
            //回滚事务
            throw new RuntimeException(e);
        }
        System.out.println("环绕通知 2   ");


    }


    /**
     * 异常通知 @AfterThrowing(pointcut = "serviceUpdate()",throwing = "ex")
     * <aop:after-throwing method="cathException"   pointcut-ref="serviceUpdate" throwing="ex"/>
     * @param ex
     */
    @AfterThrowing(pointcut = "serviceUpdate()", throwing = "ex")
    public void cathException(Exception ex) {
        System.out.println("异常通知   " + ex.getMessage());
        System.out.println("把异常写入到数据库中。。。。");
    }


    /**
     * 返回后通知 @AfterReturning("serviceGetById()")
     *             <aop:after-returning method="returnAdvice"   pointcut-ref="serviceGetById" />
     */
    @AfterReturning("serviceGetById()")
    public void returnAdvice() {
        System.out.println("返回之后执行");
    }


}

```

![image-20260311135815764](assets/image-20260311135815764.png)

## 使用Java配置类管理AOP

新建项目spring-09-aop-javaconfig

### 配置类

```java
package com.neuedu.sm;


import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.EnableAspectJAutoProxy;

/**
 * ComponentScan 默认扫描 当前配置所在的包 和子包
 */
@Configuration
//@ComponentScan("com.neuedu.sm")
@ComponentScan()
@EnableAspectJAutoProxy
public class App {
}

```

### 测试类

````java
package com.neuedu.sm;

import com.neuedu.sm.service.RoleService;
import com.neuedu.sm.service.UserService;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.junit.jupiter.SpringJUnitConfig;


@SpringJUnitConfig(classes = App.class)
public class RoleServiceTest {

    @Autowired
    RoleService roleService;

    @Test
    public void test() {

        roleService.save();
    }


    @Test
    public void testQuery() {

        roleService.queryList();
    }

    @Test
    public void testUpdate() throws Exception {
//        boolean success = true;
        boolean success = false;
        roleService.update(success);
    }


    @Test
    public void testQueryById() throws Exception {
        //boolean success = true;
        boolean success = false;
        roleService.getById(success);
    }


}

````

```java
package com.neuedu.sm;

import com.neuedu.sm.service.UserService;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.junit.jupiter.SpringJUnitConfig;


@SpringJUnitConfig(classes = App.class)
public class UserServiceTest {

    @Autowired
    UserService userService;

    @Test
    public void test() {

        userService.save();
    }

    @Test
    public void testQuery() {
        userService.queryList();
    }

}

```

# 代理模式

实现动态代理有两种形式：

1. jdk动态代理：根据目标类接口获取代理类实现规则，生成代理对象。这个代理对象，也是目标类接口的一个实现类。
2. cglib动态代理：根据目标类本身获取代理类实现规则，生成代理对象。这个代理对象，也是目标类的一个子类。 （如果目标类为final，则不能使用CGLib实现动态代理）

SpringAOP可以自动在jdk动态代理和CGLib动态代理之间进行切换，规则如下：

1. 如果目标对象实现了接口，采用jdk动态代理实现aop。
2. 如果目标对象没有实现接口，采用CGLib动态代理实现aop。
3. 如果目标对象实现了接口，但仍然想要使用CGLIB实现aop，可以手动进行配置。

![image-20260311142112760](assets/image-20260311142112760.png)

![image-20260311142954125](assets/image-20260311142954125.png)

# 整合MyBatis

整合的思路  将SQLSessionFactory、Mapper(dao)由 Spring的IOC工厂托管,需要用的时候 @Autowired 自动从容器中获取。

- spring（xml+包扫描注册Bean）+MyBatis (mybaits-spring.jar :  写好了  创建SQLSessionFactory的代码)
- spring（配置类）+MyBatis (mybaits-spring.jar :  写好了  创建SQLSessionFactory的代码)

## 基于xml的Spirng整合MyBatis

- 创建spring的ioc项目
  - 添加依赖
    - spring-context  、Spring-aop 、aspectjweaver 、spring-test、
    - spring-jdbc、
    - junit、 Mybaits、
    - MYSQL驱动  、druidDatasource  、
    - mybatis-spring 整合的包
  - 创建一个配置文件spring-mybaits.xml
    - 编写一个Bean      @Service  UserService 类
  - 测试
    - 从容器中获取  Userservice
- 添加 MyBaits
  - 编写 SQLMapConfig.xml
  - 基于数据库生成PO、Mapper.xml、Mapper.java
  - 在IOC容器中配置SQLSessionFactory、
  - 将Mapper的创建过程    `session.getMapper(XXXXMapper.class);  交给Spring IOC
  - 测试
    - 从IOC容器中拿到Mapper并测试

## spring-10-spring-xml-mybaits-configxml

### 1 添加依赖

```xml
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>com.neuedu.spring</groupId>
        <artifactId>spring-learn</artifactId>
        <version>1.0</version>
    </parent>

    <artifactId>spring-10-spring-xml-mybaits-configxml</artifactId>
    <packaging>jar</packaging>

    <name>spring-10-spring-xml-mybaits-configxml</name>
    <url>http://maven.apache.org</url>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>

    <dependencies>
        <!-- 此依赖会关联引用Spring中的所有基础jar包 -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>${spring.version}</version>
        </dependency>

        <!--      AOP  -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aop</artifactId>
        </dependency>
        <!--        测试框架  -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
        </dependency>
        <!--事务支持 -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
        </dependency>
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
        </dependency>

        <!-- Source: https://mvnrepository.com/artifact/org.junit.jupiter/junit-jupiter-api -->
        <dependency>
            <groupId>org.junit.jupiter</groupId>
            <artifactId>junit-jupiter-api</artifactId>
            <version>${junit.version}</version>
        </dependency>



        <!--    数据库驱动-->
        <dependency>
            <groupId>com.mysql</groupId>
            <artifactId>mysql-connector-j</artifactId>
        </dependency>
        <!--数据源 阿里开源的DRUID https://github.com/alibaba/druid-->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
        </dependency>

        <!--    mybaits框架-->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
        </dependency>
        <!-- mybaits  跟spring 整合用的  主要用于管理SQlSessionFactory Mapper  交给IOC容器（工厂）-->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis-spring</artifactId>
        </dependency>



        <!-- Source: https://mvnrepository.com/artifact/org.projectlombok/lombok -->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>




    </dependencies>
</project>

```

### 2 ioc的配置文件

spring-mybatis.xml

基础包 ： **com.neuedu.sm**

- po
- mapper
- service
- controller

```xml
<?xml version="1.0" encoding="UTF-8"?>
<beans
        xmlns="http://www.springframework.org/schema/beans"
        xmlns:context="http://www.springframework.org/schema/context"
        xmlns:aop="http://www.springframework.org/schema/aop"
        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/context
  http://www.springframework.org/schema/context/spring-context.xsd
  http://www.springframework.org/schema/aop
  http://www.springframework.org/schema/aop/spring-aop-4.1.xsd" >




    <!--    使用  注解 扫描的方式 注册  Bean组件 -->
    <context:component-scan base-package="com.neuedu.sm"/>




</beans>
```

### 3 编写测试的Bean（Userservice）

```java
package com.neuedu.sm.service;


import org.springframework.stereotype.Service;

@Service
public class UserService{


    public void list(){
        System.out.println("UserService.list--Service层");
    }

}

```

### 4 使用单元测试 获取Bean 测试IOC

```java
package com.neuedu.sm.service;

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.junit.jupiter.SpringJUnitConfig;

import static org.junit.jupiter.api.Assertions.*;

@SpringJUnitConfig(locations = "classpath:spring-mybatis.xml")
class UserServiceTest {
    @Autowired
    private UserService userService;

    @Test
    void list() {
        userService.list();
    }
}
```

![image-20260312085703044](assets/image-20260312085703044.png)

### 5 添加Mybaits的配置文件

#### SQLMapconfig.xml

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


    <!--    加载jdbc配置文件 -->
    <properties resource="jdbc.properties"></properties>


    <settings>
        <!--   打印日志            -->
        <setting name="logImpl" value="STDOUT_LOGGING"/>
    </settings>


    <!-- 配置数据源相关属性和事务 -->
    <environments default="development">
        <!-- 可以配置多个数据源环境，默认使用default中的值 -->
        <environment id="development">
            <!-- 使用jdbc的事务管理 -->
            <transactionManager type="JDBC"/>
            <!-- 配置数据源，并使用自带数据库连接池 -->
            <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>
        <package name="com.neuedu.sm.mapper"/>
    </mappers>
</configuration>
```

#### jdbc.properties

```properties
jdbc.driver=com.mysql.cj.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/assica?characterEncoding=utf-8
jdbc.username=root
jdbc.password=root
```

### 6 生成po、mapper

DBMS: MySQL (ver. 8.0.30)
Case sensitivity: plain=lower, delimited=lower
Driver: MySQL Connector/J (ver. mysql-connector-j-8.2.0 (Revision: 06a1f724497fd81c6a659131fda822c9e5085b6c), JDBC4.2)

Ping: 61 ms
SSL: yes

![image-20260312092350896](assets/image-20260312092350896.png)

![image-20260312092411862](assets/image-20260312092411862.png)

![image-20260312092500978](assets/image-20260312092500978.png)\

![image-20260312092544378](assets/image-20260312092544378.png)

![image-20260312092629437](assets/image-20260312092629437.png)

### 7 让容器管理SQLSessionFactory Mapper

- mybatis-spring

父项目 家版本号，子项目直接依赖（不需要版本号）

```xml
<!-- Source: https://mvnrepository.com/artifact/org.mybatis/mybatis-spring -->
<dependency>
    <groupId>org.mybatis</groupId>
    <artifactId>mybatis-spring</artifactId>
    <version>4.0.0</version>
    <scope>compile</scope>
</dependency>
```

##### 在IOC配置文件中注册 SqlSessionFactory  、数据源

```xml
<?xml version="1.0" encoding="UTF-8"?>
<beans
        xmlns="http://www.springframework.org/schema/beans"
        xmlns:context="http://www.springframework.org/schema/context"
        xmlns:aop="http://www.springframework.org/schema/aop"
        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/context
  http://www.springframework.org/schema/context/spring-context.xsd
  http://www.springframework.org/schema/aop
  http://www.springframework.org/schema/aop/spring-aop-4.1.xsd" >




    <!--    使用  注解 扫描的方式 注册  Bean组件 -->
    <context:component-scan base-package="com.neuedu.sm"/>



    <!--配置数据源  -->
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="url" value="jdbc:mysql://localhost:3306/assica?characterEncoding=utf-8"/>
        <property name="username" value="root"/>
        <property name="password" value="root"/>
        <property name="driverClassName" value="com.mysql.cj.jdbc.Driver"/>

        <!--<property name="initialSize" value="10"/>-->
        <!--<property name="maxActive" value="20"/>-->
    </bean>

    <bean class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="dataSource"></property>
        <property name="configLocation" value="SqlMapConfig.xml"/>
    </bean>


</beans>
```

##### 测试SqlSessionFactory

```java
package com.neuedu.sm.service;


import org.apache.ibatis.session.SqlSessionFactory;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.junit.jupiter.SpringJUnitConfig;

@SpringJUnitConfig(locations = "classpath:spring-mybatis.xml")
public class SqlSessionFactoryTest {

    @Autowired
    private SqlSessionFactory sqlSessionFactory;



    @Test
    public void testSqlSessionFactory() {
        System.out.println(sqlSessionFactory);
    }
}

```

#### 使用MapperBean  在 容器中注册  Mapper的的代理对象

![image-20260312103130217](assets/image-20260312103130217.png)

```xml
<!--在 容器中声明  Mapper代理对象 -->
<bean id="usersMapper"  class="org.mybatis.spring.mapper.MapperFactoryBean">
    <property name="mapperInterface" value="com.neuedu.sm.mapper.UsersMapper"></property>
    <property name="sqlSessionFactory" ref="sessionFactory"/>
</bean>
```

```java
package com.neuedu.sm.mapper;

import com.neuedu.sm.po.Users;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.junit.jupiter.SpringJUnitConfig;

import static org.junit.jupiter.api.Assertions.*;

@SpringJUnitConfig(locations = "classpath:spring-mybatis.xml")
class UsersMapperTest {
    @Autowired
    private UsersMapper usersMapper;

    @Test
    void selectByPrimaryKey() {
        long id = 1L;
        Users users = usersMapper.selectByPrimaryKey(id);
        System.out.println("users = " + users);
    }
}
```

#### 使用 spring 加载  jdbc.properties属性文件

```xml
 <!--读取配置文件到内存  -->
    <context:property-placeholder location="classpath*:jdbc.properties"></context:property-placeholder>
     <!--配置数据源  -->
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="url" value="${jdbc.url}"/>
        <property name="username" value="${jdbc.username}"/>
        <property name="password" value="${jdbc.password}"/>
        <property name="driverClassName" value="${jdbc.driver}"/>


    </bean>
```

![image-20260312103854286](assets/image-20260312103854286.png)

### 批量注册Mapper到IOC工厂

- 使用MapperScannerConfigurer 批量注册Mapper到IOC
- 给sessionFactory 注入配置项，代替SqlMapConfig配置文件

```xml
<?xml version="1.0" encoding="UTF-8"?>
<beans
        xmlns="http://www.springframework.org/schema/beans"
        xmlns:context="http://www.springframework.org/schema/context"
        xmlns:aop="http://www.springframework.org/schema/aop"
        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/context
  http://www.springframework.org/schema/context/spring-context.xsd
  http://www.springframework.org/schema/aop
  http://www.springframework.org/schema/aop/spring-aop-4.1.xsd" >




    <!--    使用  注解 扫描的方式 注册  Bean组件 -->
    <context:component-scan base-package="com.neuedu.sm"/>

    <!--读取配置文件到内存  -->
    <context:property-placeholder location="classpath*:jdbc.properties"></context:property-placeholder>


    <!--配置数据源  -->
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="url" value="${jdbc.url}"/>
        <property name="username" value="${jdbc.username}"/>
        <property name="password" value="${jdbc.password}"/>
        <property name="driverClassName" value="${jdbc.driver}"/>


    </bean>





    <!-- 注册SQlSessionFactory -->
    <bean id="sessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="dataSource"></property>

        <!--<property name="configLocation" value="SqlMapConfig.xml"/>-->

        <!--使用配置的方式  代替 SQLMapConfig.xml-->
        <property name="configuration" >
            <bean id="configuration" class="org.apache.ibatis.session.Configuration">
                <!--setting 中的 日期 -->
                <property name="logImpl" value="org.apache.ibatis.logging.stdout.StdOutImpl"/>
            </bean>
        </property>

    </bean>


    <!--使用包扫描的形式 在 IOC容器中注册 Mapper-->
    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <property name="basePackage" value="com.neuedu.sm.mapper"></property>
        <property name="sqlSessionFactoryBeanName" value="sessionFactory"></property>
    </bean>

</beans>
```

## 使用事务

编写了一个需要事务的方法（常见的方式 是在  service层上添加事务              查询（select） 、更新（update、insert、delete）       ）

```java

package com.neuedu.sm.service;


import com.neuedu.sm.mapper.UsersMapper;
import com.neuedu.sm.po.Users;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.mybatis.spring.SqlSessionFactoryBean;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class UserService{

    @Autowired
    private UsersMapper usersMapper;



    /**
     * 保存的功能
     * @param
     * @return
     */
    public boolean update(boolean error){

        Users user1 = usersMapper.selectByPrimaryKey(1L);
        Users user2 = usersMapper.selectByPrimaryKey(2L);

        user1.setEmail("+100");
        int insert = usersMapper.updateByPrimaryKey(user1);

        if(error){
            throw new RuntimeException("过程出错了");
        }
        user2.setEmail("-100");
        insert  += usersMapper.updateByPrimaryKey(user2);
        return insert + insert == 2 ;
    }


    public void list(){
        System.out.println("UserService.list--Service层");
    }

}


```

```java
package com.neuedu.sm.service;

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.junit.jupiter.SpringJUnitConfig;

import static org.junit.jupiter.api.Assertions.*;

@SpringJUnitConfig(locations = "classpath:spring-mybatis.xml")
class UserServiceTest {
    @Autowired
    private UserService userService;

    @Test
    void list() {
        userService.list();
    }

    @Test
    void update() {

        boolean error = true;
        boolean success = userService.update(error);
        System.out.println("success = " + success);
    }
}
```

当boolean  error的值为true的时候  出现一个 第一个账户 有“+100” 标记，但是第二个账户因为代码报错而没有执行

![1773294575302](assets/1773294575302.png)

### 使用spirng-tx中支持的事务管理器 配置aop切面，实现事务的功能

- 配置事务管理（相当于是通知）TxManager(DataSourceTransactionManager)
- 给事务管理器配置切面
  - 在什么方法上添加通知（开启事务、提交事务 ）

在spring-mybaits.xml中添加事务配置

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


    <!--配置事务的Advice（增强）-->
    <tx:advice id="txAdvice" transaction-manager="transactionManager">
       <tx:attributes>
           <!--
            name : 表示那些方法需要开启事务
            propagation
            rollback-for 那些异常类型 需要回滚
            -->
           <tx:method name="update*" propagation="REQUIRED"  rollback-for="java.lang.Exception"/>
       </tx:attributes>
    
    </tx:advice>



    <!--配置切面，使事务管理器生效-->
    <aop:config>

        <!--切点 期望的是配置到 所有的  service方法  -->
        <aop:pointcut id="serviceMethods" expression="execution(* com.neuedu.sm.service.*.*(..))"/>

        <!--引用tx的通知 -->
        <aop:advisor advice-ref="txAdvice" pointcut-ref="serviceMethods"/>

    </aop:config>

```

![1773295230081](assets/1773295230081.png)

再次测试发现  UserService的 update功能室有事务的


事务的传播特性


**注解中的 propagation 属性，可以设置事务传播行为。属性值为：**

1. **REQUIRED：如果当前没有事务，就新建一个事务，如果已经存在一个事务中，就加入到这个事务中。这是最常见的选择。**
2. **SUPPORTS：支持当前事务，如果当前没有事务，就以非事务方式执行。**
3. **MANDATORY：使用当前的事务，如果当前没有事务，就抛出异常。**
4. **REQUIRES_NEW：新建事务，如果当前存在事务，把当前事务挂起。**
5. **NOT_SUPPORTED：以非事务方式执行操作，如果存在事务，就把当前事务挂起。**
6. **NEVER：以非事务方式执行，如果当前存在事务，则抛出异常。**

事务的隔离特性


1️⃣ Read uncommitted (读未提交)：最低级别，任何情况都无法保证。
  第一隔离级别怕回滚，因为它能读取到别的事务未提交的数据。如果当前事务将这个数据当成真正的数据，那么如果别的事务回滚，那么就会数据错误，导致脏读。

2️⃣ Read committed (读已提交)：可避免脏读的发生。
第二个隔离级别怕提交，因为提交会导致不可重复读。

3️⃣ Repeatable read (可重复读)：可避免脏读、不可重复读的发生。*MySQL默认隔离级别
4️⃣ Serializable (串行化)：可避免脏读、不可重复读、幻读的发生
———————————————

为啥Oracle默认隔离级别是Read committer

为啥MySQL默认隔离级别是Repeatable read 


### 使用Transactional注解替代 切面的xml配置

详见 spring-13-spring-xml-mybaits-tx-annotation 项目 在  12的基础上，修改 Service添加注解，并将spring配置文件中的切面配置去掉， 添加注解驱动
    <tx:annotation-driven transaction-manager="transactionManager"  proxy-target-class="true"  />

```java


package com.neuedu.sm.service;


import com.neuedu.sm.mapper.UsersMapper;
import com.neuedu.sm.po.Users;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.mybatis.spring.SqlSessionFactoryBean;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.EnableTransactionManagement;
import org.springframework.transaction.annotation.Isolation;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;

@Service
public class UserService{

    @Autowired
    private UsersMapper usersMapper;



    /**
     * 保存的功能
     * @param
     * @return
     */
    @Transactional(propagation = Propagation.REQUIRED,isolation= Isolation.DEFAULT,rollbackFor = Exception.class)
    public boolean update(boolean error) throws Exception {

        Users user1 = usersMapper.selectByPrimaryKey(1L);
        Users user2 = usersMapper.selectByPrimaryKey(2L);

        user1.setEmail("+100");
        int insert = usersMapper.updateByPrimaryKey(user1);

        if(error){
            throw new Exception("过程出错了");
        }
        user2.setEmail("-100");
        insert  += usersMapper.updateByPrimaryKey(user2);
        return insert + insert == 2 ;
    }


    public void list(){
        System.out.println("UserService.list--Service层");
    }

}


```


```xml
<?xml version="1.0" encoding="UTF-8"?>
<beans
        xmlns="http://www.springframework.org/schema/beans"
        xmlns:context="http://www.springframework.org/schema/context"
        xmlns:aop="http://www.springframework.org/schema/aop"
        xmlns:tx="http://www.springframework.org/schema/tx"
        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/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" >




    <!--    使用  注解 扫描的方式 注册  Bean组件 -->
    <context:component-scan base-package="com.neuedu.sm"/>

    <!--读取配置文件到内存  -->
    <context:property-placeholder location="classpath*:jdbc.properties"></context:property-placeholder>


    <!--配置数据源  -->
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="url" value="${jdbc.url}"/>
        <property name="username" value="${jdbc.username}"/>
        <property name="password" value="${jdbc.password}"/>
        <property name="driverClassName" value="${jdbc.driver}"/>
    </bean>


    <!-- 注册SQlSessionFactory -->
    <bean id="sessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="dataSource"></property>

        <!--<property name="configLocation" value="SqlMapConfig.xml"/>-->

        <!--使用配置的方式  代替 SQLMapConfig.xml-->
        <property name="configuration" >
            <bean id="configuration" class="org.apache.ibatis.session.Configuration">
                <!--setting 中的 日期 -->
                <property name="logImpl" value="org.apache.ibatis.logging.stdout.StdOutImpl"/>
            </bean>
        </property>

    </bean>


    <!--使用包扫描的形式 在 IOC容器中注册 Mapper-->
    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <property name="basePackage" value="com.neuedu.sm.mapper"></property>
        <property name="sqlSessionFactoryBeanName" value="sessionFactory"></property>
    </bean>


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


    <!-- 注解驱动 ，让 IOC生成代理对象的时候启用  Transactional   -->
    <tx:annotation-driven transaction-manager="transactionManager"  proxy-target-class="true"  />


</beans>
```


## 使用配置类替代spring的配置文件 

参考 

spring-14-spring-mybaits-javaconfig-all

Java配置类

```java
package com.neuedu.sm;

import com.alibaba.druid.pool.DruidDataSource;
import org.apache.ibatis.logging.stdout.StdOutImpl;
import org.apache.ibatis.session.SqlSessionFactory;
import org.mybatis.spring.SqlSessionFactoryBean;
import org.mybatis.spring.mapper.MapperScannerConfigurer;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;
import org.springframework.transaction.TransactionManager;
import org.springframework.transaction.annotation.EnableTransactionManagement;

import javax.sql.DataSource;

@Configuration
//扫描包 注册组件
@ComponentScan
//启动事务
@EnableTransactionManagement
public class SpringApp {

    /**
     * 配置数据源
     * @return
     */
    @Bean
    public DataSource dataSource(){
        DruidDataSource dataSource = new DruidDataSource();
        dataSource.setUrl("jdbc:mysql://localhost:3306/assica?characterEncoding=utf-8");
        dataSource.setDriverClassName("com.mysql.cj.jdbc.Driver");
        dataSource.setUsername("root");
        dataSource.setPassword("root");
        return dataSource;
    }


    /**
     * 配置SQLSessionFactory
     * @param dataSource
     * @return
     * @throws Exception
     */
    //@Bean("sqlSessionFactory")
    @Bean
    public SqlSessionFactory sqlSessionFactory( DataSource dataSource) throws Exception {
        SqlSessionFactoryBean sqlSessionFactoryBean = new SqlSessionFactoryBean();
        sqlSessionFactoryBean.setDataSource(dataSource);
        org.apache.ibatis.session.Configuration configuration = new org.apache.ibatis.session.Configuration();
        configuration.setLogImpl(StdOutImpl.class);
        sqlSessionFactoryBean.setConfiguration(configuration);
        return sqlSessionFactoryBean.getObject();
    }


    //注册Mapper
    @Bean
    public MapperScannerConfigurer mapperScannerConfigurer(){
        MapperScannerConfigurer mapperScannerConfigurer = new MapperScannerConfigurer();
        mapperScannerConfigurer.setBasePackage("com.neuedu.sm.mapper");
        //mapperScannerConfigurer.setSqlSessionTemplateBeanName("sqlSessionFactory");
        mapperScannerConfigurer.setSqlSessionFactoryBeanName("sqlSessionFactory");
        return mapperScannerConfigurer;
    }


    //注册事务管理器到IOC容器
    @Bean
    public TransactionManager txManager( DataSource dataSource){

        TransactionManager txmanager = new DataSourceTransactionManager(dataSource);

        return txmanager;
    }

}

```

 测试类

```java
package com.neuedu.sm.service;

import com.neuedu.sm.SpringApp;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.junit.jupiter.SpringJUnitConfig;

import static org.junit.jupiter.api.Assertions.*;

@SpringJUnitConfig(classes = SpringApp.class)
class UserServiceTest {
    @Autowired
    private UserService userService;

    @Test
    void list() {
        userService.list();
    }

    @Test
    void update() throws Exception {

        //boolean error = true;
        boolean error = false;
        boolean success = userService.update(error);
        System.out.println("success = " + success);
    }
}
```

可以发现事务生效了

### 使用@MapperScan注解

在Spring配置类中我们声明了 MapperScannerConfigurer 用于注册 Mapper 到IOC容器中，

- 可以通过在XXXMapper接口上添加@Mapper 实现单个Mapper的注册
- 可以在配置类上添加@MapperScan("com.neuedu.sm.mapper") 用于替代 MapperScannerConfigurer  实现批量注册
- 最终的配置类如下：（后面使用的SpirngBoot就是类似如下的写法）

```java
package com.neuedu.sm;

import com.alibaba.druid.pool.DruidDataSource;
import org.apache.ibatis.logging.stdout.StdOutImpl;
import org.apache.ibatis.session.SqlSessionFactory;
import org.mybatis.spring.SqlSessionFactoryBean;
import org.mybatis.spring.annotation.MapperScan;
import org.mybatis.spring.mapper.MapperScannerConfigurer;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;
import org.springframework.transaction.TransactionManager;
import org.springframework.transaction.annotation.EnableTransactionManagement;

import javax.sql.DataSource;

@Configuration
//扫描包 注册组件
@ComponentScan
//启动事务
@EnableTransactionManagement
//相当于 MapperScannerConfigurer 的功能， 自动注册Mapper接口代理对象到IOC容器
@MapperScan("com.neuedu.sm.mapper")
public class SpringApp {

    /**
     * 配置数据源
     * @return
     */
    @Bean
    public DataSource dataSource(){
        DruidDataSource dataSource = new DruidDataSource();
        dataSource.setUrl("jdbc:mysql://localhost:3306/assica?characterEncoding=utf-8");
        dataSource.setDriverClassName("com.mysql.cj.jdbc.Driver");
        dataSource.setUsername("root");
        dataSource.setPassword("root");
        return dataSource;
    }


    /**
     * 配置SQLSessionFactory
     * @param dataSource
     * @return
     * @throws Exception
     */
    //@Bean("sqlSessionFactory")
    @Bean
    public SqlSessionFactory sqlSessionFactory(  DataSource dataSource) throws Exception {
        SqlSessionFactoryBean sqlSessionFactoryBean = new SqlSessionFactoryBean();
        sqlSessionFactoryBean.setDataSource(dataSource);
        org.apache.ibatis.session.Configuration configuration = new org.apache.ibatis.session.Configuration();
        configuration.setLogImpl(StdOutImpl.class);
        sqlSessionFactoryBean.setConfiguration(configuration);
        return sqlSessionFactoryBean.getObject();
    }


    /**
     *
     * 注册Mapper
     * @return
     */
    //@Bean
    //public MapperScannerConfigurer mapperScannerConfigurer(){
    //    MapperScannerConfigurer mapperScannerConfigurer = new MapperScannerConfigurer();
    //    mapperScannerConfigurer.setBasePackage("com.neuedu.sm.mapper");
    //    // 错误的  ：  mapperScannerConfigurer.setSqlSessionTemplateBeanName("sqlSessionFactory");
    //    mapperScannerConfigurer.setSqlSessionFactoryBeanName("sqlSessionFactory");
    //    return mapperScannerConfigurer;
    //}


    //注册事务管理器到IOC容器
    @Bean
    public TransactionManager txManager( DataSource dataSource){

        TransactionManager txmanager = new DataSourceTransactionManager(dataSource);

        return txmanager;
    }

}

```