01.Spring之AOP

1、AOP概述

• 代理（Proxy）
  • SpringAOP的核心本质是采用代理模式实现的
• 连接点（JoinPoint）
  • 在SpringAOP中，理解为任意方法的执行
• 切入点（Pointcut）
  • 匹配连接点的式子，也是具有共性功能的方法描述
  • 例如:update()、delete()方法，select()方法没有被增强所以不是切入点
• 通知（Advice）
  • 在切入点前后执行的操作，也就是增强的共性功能
  • 在SpringAOP中，功能最终以方法的形式呈现
  • 包括了“around”、“before”和“after”等不同类型的通知（advice）
• 通知类
  • 通知方法所在的类叫做通知类
• 切面（Aspect）
  • 描述通知与切入点的对应关系，也就是哪些通知方法对应哪些切入点方法
• 目标对象（Target）
  • 被代理的原始对象成为目标对象

2、AOP案例

• 当匹配到规则的连接点回执行方法，没有匹配的不执行

spring03_aop
├── pom.xml
├── src
│   ├── main
│   │   ├── java
│   │   │   ├── App.java
│   │   │   └── org
│   │   │       └── example
│   │   │           ├── aop  // 切面相关的包
│   │   │           │   └── MyAdvice.java  // 定义了一个切面，用于在BookDao的update方法执行前打印一条日志
│   │   │           ├── config
│   │   │           │   └── SpringConfig.java
│   │   │           └── dao
│   │   │               ├── BookDao.java
│   │   │               └── impl
│   │   │                   └── BookDaoImpl.java

• 1）pom.xml

    <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.2.10.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.9.4</version>
        </dependency>
    </dependencies>

• 2）aop/MyAdvice.java

import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.stereotype.Component;

//指定这个类是一个Spring的组件，Spring会自动扫描和管理这个类的实例
@Component
//Spring AOP的注解，表示这个类是一个切面，用于定义一些针对多个类或者方法的通用行为
@Aspect
public class MyAdvice {
    //Pointcut定义了一个切入点，表示这个切面会影响哪些类或者方法
    @Pointcut("execution(void org.example.dao.BookDao.update())")
    //pt()是切入点的具体方法，但在这里并无实际执行的功能，只是作为一个标记，供@Before("pt()")使用
    private void pt(){}

    //通知（Advice）的注解，表示在切入点方法执行前，要执行的一段代码
    @Before("pt()")
    public void method(){
        System.out.println("执行 MyAdvice.pt() 方法");
    }
}

• 3）dao

// dao/BookDao.java
public interface BookDao {
    public void save();
    public void update();
}

// dao/impl/BookDaoImpl.java
import org.example.dao.BookDao;
import org.springframework.stereotype.Repository;
@Repository
public class BookDaoImpl implements BookDao {

    public void save() {
        System.out.println("book dao save ...");
    }

    public void update(){
        System.out.println("book dao update ...");
    }
}

• 4）config

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

@Configuration
@ComponentScan("org.example")
@EnableAspectJAutoProxy
public class SpringConfig {
}

• 5）App.java

import org.example.config.SpringConfig;
import org.example.dao.BookDao;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class App {
    public static void main(String[] args) {
        ApplicationContext ctx = new AnnotationConfigApplicationContext(SpringConfig.class);
        BookDao bookDao = ctx.getBean(BookDao.class);
          bookDao.update();
         // bookDao.save();
    }
}

3、切入点表达式语法

//1)精确匹配：只有指定这个类中返回类型为void且没有参数的`update`方法
@Pointcut("execution(void com.itheima.dao.impl.BookDaoImpl.update())")

//2)匹配：只有指定这个类中返回类型为void且有且只有一个参数的`update`方法
@Pointcut("execution(* com.itheima.dao.impl.BookDaoImpl.update(*))")

//3)匹配`com`包及其子包下的类中返回类型为void且没有参数的`update`方法
@Pointcut("execution(void com.*.*.*.update())")

//4)应用于任意包下的类中的任意方法
@Pointcut("execution(* *..*(..))")

//5)应用于任意包下的类中方法名以`e`结尾的方法
@Pointcut("execution(* *..*e(..))")

//6)应用于`com`包及其子包下的类中返回类型为void且没有参数的任意方法
@Pointcut("execution(void com..*())")

//7)应用于`com.itheima`包下类名以`Service`结尾且方法名以`find`开头的方法
@Pointcut("execution(* com.itheima.*.*Service.find*(..))")

//8)应用于`com.itheima`包下类名以`Service`结尾且方法名为`save`的方法
@Pointcut("execution(* com.itheima.*.*Service.save(..))")

4、五种通知Advice

• @Before

  • 前置通知，表示在目标方法执行前，会先执行通知方法
  • 例如，可以在调用一个保存数据的方法前，先执行一个检查权限的方法

• @After

  • 后置通知，表示在目标方法执行后，无论目标方法是否发生异常，都会执行通知方法
  • 例如，可以在调用一个修改数据的方法后，执行一个记录日志的方法

• @AfterReturning

  • 返回后通知，表示在目标方法成功执行后，会执行通知方法
  • 例如，可以在调用一个查询数据的方法后，执行一个对查询结果进行处理的方法

• @AfterThrowing

  • 异常通知，表示在目标方法抛出异常后，会执行通知方法
  • 例如，可以在调用一个更新数据的方法抛出异常后，执行一个进行错误处理的方法

• @Around

  • 环绕通知，表示在目标方法执行前后，都会执行通知方法
  • 这是最强大的一种通知类型，可以在方法调用前后完成自定义的行为
  • 例如
    • 可以在调用一个处理数据的方法前，执行一个开始计时的方法
    • 然后在方法调用后，执行一个结束计时的方法，以此来测量方法的执行时间

02.事务案例

1、创建表

create database if not exists spring_db character set utf8;
use spring_db;
create table if not exists tbl_account(
    id int primary key auto_increment,
    name varchar(20),
    money double
);
insert into tbl_account values(null,'Tom',1000);
insert into tbl_account values(null,'Jerry',1000);

USE spring_db;
CREATE TABLE tbl_log(
	id INT PRIMARY KEY AUTO_INCREMENT,
	info VARCHAR(255),
	createDate DATE
);

2、案例

• 需求：实现任意两个账户间转账操作，并对每次转账操作在数据库进行留痕

spring04_transfer
├── pom.xml
├── src
│   ├── main
│   │   ├── java
│   │   │   └── org
│   │   │       └── example
│   │   │           ├── config   // 所有的配置类
│   │   │           │   ├── JdbcConfig.java
│   │   │           │   ├── MybatisConfig.java
│   │   │           │   └── SpringConfig.java   // Spring框架的相关内容
│   │   │           ├── dao     // 数据访问对象(DAO)
│   │   │           │   ├── AccountDao.java
│   │   │           │   └── LogDao.java
│   │   │           ├── domain  // 所有的领域模型类
│   │   │           │   └── Account.java
│   │   │           └── service  // 所有的服务类
│   │   │               ├── AccountService.java
│   │   │               ├── LogService.java
│   │   │               └── impl
│   │   │                   ├── AccountServiceImpl.java
│   │   │                   └── LogServiceImpl.java
│   │   └── resources  // 所有的资源文件
│   │       └── jdbc.properties
│   └── test
│       └── java
│           └── AccountServiceTest.java  // 测试入口

1、pom.xml

    <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.2.10.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.1.16</version>
        </dependency>

        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.5.6</version>
        </dependency>

        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.47</version>
        </dependency>

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

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

        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>5.2.10.RELEASE</version>
        </dependency>

    </dependencies>

2、资源和配置

• 1）resources/jdbc.properties

jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/spring_db?useSSL=false
jdbc.username=root
jdbc.password=123456

• 2）config/SpringConfig.java

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Import;
import org.springframework.context.annotation.PropertySource;
import org.springframework.transaction.annotation.EnableTransactionManagement;

@Configuration
@ComponentScan("org.example")
@PropertySource("classpath:jdbc.properties")
@Import({JdbcConfig.class,MybatisConfig.class})
@EnableTransactionManagement
public class SpringConfig {
}

• 3）config/MybatisConfig.java

import org.mybatis.spring.SqlSessionFactoryBean;
import org.mybatis.spring.mapper.MapperScannerConfigurer;
import org.springframework.context.annotation.Bean;

import javax.sql.DataSource;

public class MybatisConfig {

    @Bean
    public SqlSessionFactoryBean sqlSessionFactory(DataSource dataSource){
        SqlSessionFactoryBean ssfb = new SqlSessionFactoryBean();
        ssfb.setTypeAliasesPackage("org.example.domain");
        ssfb.setDataSource(dataSource);
        return ssfb;
    }

    @Bean
    public MapperScannerConfigurer mapperScannerConfigurer(){
        MapperScannerConfigurer msc = new MapperScannerConfigurer();
        msc.setBasePackage("org.example.dao");
        return msc;
    }
}

• 4）config/JdbcConfig.java

import com.alibaba.druid.pool.DruidDataSource;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;
import org.springframework.transaction.PlatformTransactionManager;

import javax.sql.DataSource;


public class JdbcConfig {
    @Value("${jdbc.driver}")
    private String driver;
    @Value("${jdbc.url}")
    private String url;
    @Value("${jdbc.username}")
    private String userName;
    @Value("${jdbc.password}")
    private String password;

    @Bean
    public DataSource dataSource(){
        DruidDataSource ds = new DruidDataSource();
        ds.setDriverClassName(driver);
        ds.setUrl(url);
        ds.setUsername(userName);
        ds.setPassword(password);
        return ds;
    }

    @Bean
    public PlatformTransactionManager transactionManager(DataSource dataSource){
        DataSourceTransactionManager ptm = new DataSourceTransactionManager();
        ptm.setDataSource(dataSource);
        return ptm;
    }
}

3、dao

• 1）dao/AccountDao.java

import org.apache.ibatis.annotations.Param;
import org.apache.ibatis.annotations.Update;

public interface AccountDao {
    // 当调用inMoney方法时，会执行SQL语句update tbl_account set money = money + ? where name = ?
    // 其中第一个问号会被参数money的值替换，第二个问号会被参数name的值替换
    @Update("update tbl_account set money = money + #{money} where name = #{name}")
    void inMoney(@Param("name") String name, @Param("money") Double money);

    @Update("update tbl_account set money = money - #{money} where name = #{name}")
    void outMoney(@Param("name") String name, @Param("money") Double money);
}

• 2）dao/LogDao.java

import org.apache.ibatis.annotations.Insert;

public interface LogDao {
    @Insert("insert into tbl_log (info,createDate) values(#{info},now())")
    void log(String info);
}

4、domain未使用

5、service

• 1）接口
  • @Transactional
    • 这是Spring框架中的一个注解，表示这个方法需要进行事务管理
    • 如果这个方法在执行过程中出现异常，那么这个方法所做的所有数据库操作都会被回滚
  • @Transactional(rollbackFor = IOException.class):
    • 表示如果这个方法抛出IOException异常，那么这个方法所做的所有数据库操作都会被回滚
  • @Transactional(propagation = Propagation.REQUIRES_NEW)
    • REQUIRES_NEW
      • 在方法执行期间开启一个新的事务，即使当前已经存在一个事务，新事务也会被创建
      • 这个新事务与当前事务无关，它们是两个独立的事务，互相不会影响（保证log日志写入表中）
    • REQUIRED:如果当前没有事务，则创建一个新事务；否则加入当前事务
    • SUPPORTS:支持当前事务，如果当前没有事务，则不使用事务
    • MANDATORY:使用当前事务，如果当前没有事务，则抛出异常

// service/AccountService.java
import org.springframework.transaction.annotation.Transactional;
import java.io.IOException;

public interface AccountService {
    //@Transactional(rollbackFor = IOException.class)
    @Transactional
    public void transfer(String out,String in ,Double money) throws IOException;
}

// service/LogService.java
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;

public interface LogService {
    //propagation设置事务属性：传播行为设置为当前操作需要新事务
    @Transactional(propagation = Propagation.REQUIRES_NEW)
    void log(String out, String in, Double money);
}

• 2）类

// service/impl/AccountServiceImpl.java
import org.example.dao.AccountDao;
import org.example.service.AccountService;
import org.example.service.LogService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class AccountServiceImpl implements AccountService {

    @Autowired
    private AccountDao accountDao;

    @Autowired
    private LogService logService;

    public void transfer(String out,String in ,Double money) {
        try{
            accountDao.outMoney(out,money);
            // int i = 1/0;
            accountDao.inMoney(in,money);
        }finally {
            logService.log(out,in,money);
        }
    }
}

// service/impl/LogServiceImpl.java
import org.example.dao.LogDao;
import org.example.service.LogService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class LogServiceImpl implements LogService {

    @Autowired
    private LogDao logDao;

    public void log(String out,String in,Double money ) {
        logDao.log("转账操作由"+out+"到"+in+",金额："+money);
    }
}

6、test入口

• @RunWith(SpringJUnit4ClassRunner.class)
  • 指定了SpringJUnit4ClassRunner作为测试运行器
  • 它能够为测试提供Spring测试上下文（ApplicationContext）
  • 这意味着Spring容器会在测试开始前初始化并且在测试结束后关闭
• @ContextConfiguration(classes = SpringConfig.class)
  • 告诉Spring测试框架使用SpringConfig.class作为配置信息来创建Spring上下文
  • SpringConfig.class中定义了Spring容器如何装配bean

import org.example.config.SpringConfig;
import org.example.service.AccountService;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import java.io.IOException;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = SpringConfig.class)
public class AccountServiceTest {
    @Autowired
    private AccountService accountService;

    @Test
    public void testTransfer() throws IOException {
        accountService.transfer("Tom","Jerry",50D);
    }
}