【Spring篇】AOP案例

🍓系列专栏:Spring系列专栏

🍉个人主页:个人主页

一、案例：业务层接口执行效率

1.需求分析

2.环境准备

• 创建一个Maven项目
• pom.xml添加Spring依赖

"1.0" encoding="UTF-8"?>
 
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0modelVersion>
 
  <groupId>com.itheimagroupId>
  <artifactId>spring_21_case_interface_run_speedartifactId>
  <version>1.0-SNAPSHOTversion>
 
  <dependencies>
    <dependency>
      <groupId>org.springframeworkgroupId>
      <artifactId>spring-contextartifactId>
      <version>5.2.10.RELEASEversion>
    dependency>
 
    <dependency>
      <groupId>org.springframeworkgroupId>
      <artifactId>spring-jdbcartifactId>
      <version>5.2.10.RELEASEversion>
    dependency>
 
    <dependency>
      <groupId>org.springframeworkgroupId>
      <artifactId>spring-testartifactId>
      <version>5.2.10.RELEASEversion>
    dependency>
 
    <dependency>
      <groupId>org.aspectjgroupId>
      <artifactId>aspectjweaverartifactId>
      <version>1.9.4version>
    dependency>
 
    <dependency>
      <groupId>mysqlgroupId>
      <artifactId>mysql-connector-javaartifactId>
      <version>5.1.47version>
    dependency>
 
    <dependency>
      <groupId>com.alibabagroupId>
      <artifactId>druidartifactId>
      <version>1.1.16version>
    dependency>
 
    <dependency>
      <groupId>org.mybatisgroupId>
      <artifactId>mybatisartifactId>
      <version>3.5.6version>
    dependency>
 
    <dependency>
      <groupId>org.mybatisgroupId>
      <artifactId>mybatis-springartifactId>
      <version>1.3.0version>
    dependency>
 
    <dependency>
      <groupId>junitgroupId>
      <artifactId>junitartifactId>
      <version>4.12version>
      <scope>testscope>
    dependency>
  dependencies>
project>

public interface AccountService {
 
    void save(Account account);
 
    void delete(Integer id);
 
    void update(Account account);
 
    List findAll();
 
    Account findById(Integer id);
 
}

@Service
public class AccountServiceImpl implements AccountService {
 
    @Autowired
    private AccountDao accountDao;
 
    public void save(Account account) {
        accountDao.save(account);
    }
 
    public void update(Account account){
        accountDao.update(account);
    }
 
    public void delete(Integer id) {
        accountDao.delete(id);
    }
 
    public Account findById(Integer id) {
        return accountDao.findById(id);
    }
 
    public List findAll() {
        return accountDao.findAll();
    }
}

public interface AccountDao {
 
    @Insert("insert into tbl_account(name,money)values(#{name},#{money})")
    void save(Account account);
 
    @Delete("delete from tbl_account where id = #{id} ")
    void delete(Integer id);
 
    @Update("update tbl_account set name = #{name} , money = #{money} where id = #{id} ")
    void update(Account account);
 
    @Select("select * from tbl_account")
    List findAll();
 
    @Select("select * from tbl_account where id = #{id} ")
    Account findById(Integer id);
}

import java.io.Serializable;
 
public class Account implements Serializable {
 
    private Integer id;
    private String name;
    private Double money;
 
    public Integer getId() {
        return id;
    }
 
    public void setId(Integer id) {
        this.id = id;
    }
 
    public String getName() {
        return name;
    }
 
    public void setName(String name) {
        this.name = name;
    }
 
    public Double getMoney() {
        return money;
    }
 
    public void setMoney(Double money) {
        this.money = money;
    }
 
    @Override
    public String toString() {
        return "Account{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", money=" + money +
                '}';
    }
}

resources 下提供一个 jdbc.properties

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

创建相关配置类

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

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;
    }
}

public class MybatisConfig {
 
    @Bean
    public SqlSessionFactoryBean sqlSessionFactory(DataSource dataSource){
        SqlSessionFactoryBean ssfb = new SqlSessionFactoryBean();
        ssfb.setTypeAliasesPackage("com.itheima.domain");
        ssfb.setDataSource(dataSource);
        return ssfb;
    }
 
    @Bean
    public MapperScannerConfigurer mapperScannerConfigurer(){
        MapperScannerConfigurer msc = new MapperScannerConfigurer();
        msc.setBasePackage("com.itheima.dao");
        return msc;
    }
}

编写Spring整合Junit的测试类

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = SpringConfig.class)
public class AccountServiceTestCase {
    @Autowired
    private AccountService accountService;
 
    @Test
    public void testFindById(){
        Account ac = accountService.findById(2);
    }
 
    @Test
    public void testFindAll(){
        List all = accountService.findAll();
    }
 
}

最终创建好的项目结构如下 :

3.功能开发

步骤 1: 开启 SpringAOP 的注解功能

在 Spring 的主配置文件 SpringConfig 类中添加注解

@EnableAspectJAutoProxy

步骤 2: 创建 AOP 的通知类

该类要被 Spring 管理，需要添加 @Component

要标识该类是一个 AOP 的切面类，需要添加 @Aspect

配置切入点表达式，需要添加一个方法，并添加 @Pointcut

@Component
@Aspect
public class ProjectAdvice {
    //匹配业务层的所有方法
    @Pointcut("execution(* com.itheima.service.*Service.*(..))")
    private void servicePt(){}
 
 
}

步骤 3: 添加环绕通知

在 runSpeed() 方法上添加 @Around, 完成核心业务，记录万次执行的时间

@Component
@Aspect
public class ProjectAdvice {
    //匹配业务层的所有方法
    @Pointcut("execution(* com.itheima.service.*Service.*(..))")
    private void servicePt(){}
 
    //设置环绕通知，在原始操作的运行前后记录执行时间
    @Around("ProjectAdvice.servicePt()")
    public void runSpeed(ProceedingJoinPoint pjp) throws Throwable {
        //获取执行的签名对象
        Signature signature = pjp.getSignature();
        String className = signature.getDeclaringTypeName();
        String methodName = signature.getName();
 
        long start = System.currentTimeMillis();
        for (int i = 0; i < 10000; i++) {
           pjp.proceed();
        }
        long end = System.currentTimeMillis();
        System.out.println("万次执行："+ className+"."+methodName+"---->" +(end-start) + "ms");
    }
 
}

步骤4 : 运行单元测试类

 

补充说明

当前测试的接口执行效率仅仅是一个理论值，并不是一次完整的执行过程。

这块只是通过该案例把 AOP 的使用进行了学习，具体的实际值是有很多因素共同决定的。

二、AOP通知获取数据

目前我们写 AOP 仅仅是在原始方法前后追加一些操作，接下来我们要说说 AOP 中数据相关的内容，我们将从获取参数 、 获取返回值 和 获取异常 三个方面来研究切入点的相关信息。

前面我们介绍通知类型的时候总共讲了五种，那么对于这五种类型都会有参数，返回值和异常吗 ?

我们先来一个个分析下 :

获取切入点方法的参数，所有的通知类型都可以获取参数

• JoinPoint：适用于前置、后置、返回后、抛出异常后通知
• ProceedingJoinPoint：适用于环绕通知

获取切入点方法返回值，前置和抛出异常后通知是没有返回值，后置通知可有可无，所以不做研究

• 返回后通知
• 环绕通知

获取切入点方法运行异常信息，前置和返回后通知是不会有，后置通知可有可无，所以不做研究

• 抛出异常后通知
• 环绕通知

1.环境准备

• 创建一个Maven项目
• pom.xml添加Spring依赖

  <dependencies>
    <dependency>
      <groupId>org.springframeworkgroupId>
      <artifactId>spring-contextartifactId>
      <version>5.2.10.RELEASEversion>
    dependency>
    <dependency>
      <groupId>org.aspectjgroupId>
      <artifactId>aspectjweaverartifactId>
      <version>1.9.4version>
    dependency>
  dependencies>

添加 BookDao 和 BookDaoImpl 类

public interface BookDao {
 public String findName(int id);
 }
 @Repository
 public class BookDaoImpl implements BookDao {
 
 public String findName(int id) {
 System.out.println("id:"+id);
 return "itcast";
 }
 }

创建 Spring 的配置类

@Configuration
@ComponentScan("com.itheima")
 
public class SpringConfig {
}

编写通知类

@Component
 @Aspect
 public class MyAdvice {
 @Pointcut("execution(* com.itheima.dao.BookDao.findName(..))")
 private void pt(){}
 
 @Before("pt()")
 public void before() {
 System.out.println("before advice ..." );
 }
 
 @After("pt()")
 public void after() {
 System.out.println("after advice ...");
 }
 
 @Around("pt()")
 public Object around() throws Throwable{
 Object ret = pjp.proceed();
 return ret;
 }
 @AfterReturning("pt()")
 public void afterReturning() {
 System.out.println("afterReturning advice ...");
 }
 
 
 @AfterThrowing("pt()")
 public void afterThrowing() {
 System.out.println("afterThrowing advice ...");
 }
 }

编写 App 运行类

public class App {
    public static void main(String[] args) {
        ApplicationContext ctx = new AnnotationConfigApplicationContext(SpringConfig.class);
        BookDao bookDao = ctx.getBean(BookDao.class);
        String name = bookDao.findName(100);
        System.out.println(name);
    }
}

最终创建好的项目结构如下 :

2.获取参数 

非环绕通知获取方式

在方法上添加 JoinPoint, 通过 JoinPoint 来获取参数

@Component
@Aspect
public class MyAdvice {
@Pointcut("execution(* com.itheima.dao.BookDao.findName(..))")
private void pt(){}
@Before("pt()")
public void before(JoinPoint jp)
Object[] args = jp.getArgs();
System.out.println(Arrays.toString(args));
System.out.println("before advice ..." );
}
//...其他的略
}

运行 App 类，可以获取如下内容，说明参数 100 已经被获取

思考 : 方法的参数只有一个，为什么获取的是一个数组 ?

因为参数的个数是不固定的，所以使用数组更通配些。

如果将参数改成两个会是什么效果呢 ?

(1) 修改 BookDao 接口和 BookDaoImpl 实现类

public interface BookDao {
public String findName(int id,String password);
}
@Repository
public class BookDaoImpl implements BookDao {
public String findName(int id,String password) {
System.out.println("id:"+id);
return "itcast";
}
}

(2) 修改 App 类，调用方法传入多个参数

public class App {
public static void main(String[] args) {
ApplicationContext ctx = new
AnnotationConfigApplicationContext(SpringConfig.class);
BookDao bookDao = ctx.getBean(BookDao.class);
String name = bookDao.findName(100,"itheima");
System.out.println(name);
}
}

(3) 运行 App ，查看结果 , 说明两个参数都已经被获取到

说明 :

使用 JoinPoint 的方式获取参数适用于 前置 、 后置 、 返回后 、 抛出异常后通知。

环绕通知获取方式

环绕通知使用的是 ProceedingJoinPoint ，因为 ProceedingJoinPoint 是 JoinPoint 类的子

类，所以对于 ProceedingJoinPoint 类中应该也会有对应的 getArgs() 方法，我们去验证下 :

@Component
@Aspect
public class MyAdvice {
@Pointcut("execution(* com.itheima.dao.BookDao.findName(..))")
private void pt(){}
@Around("pt()")
public Object around(ProceedingJoinPoint pjp)throws Throwable {
Object[] args = pjp.getArgs();
System.out.println(Arrays.toString(args));
Object ret = pjp.proceed();
return ret;
}
//其他的略
}

运行 App 后查看运行结果，说明 ProceedingJoinPoint 也是可以通过 getArgs() 获取参数

 

注意 :

pjp.proceed() 方法是有两个构造方法，分别是 :

•  调用无参数的proceed，当原始方法有参数，会在调用的过程中自动传入参数
• 所以调用这两个方法的任意一个都可以完成功能
• 但是当需要修改原始方法的参数时，就只能采用带有参数的方法,如下:

@Component
@Aspect
public class MyAdvice {
@Pointcut("execution(* com.itheima.dao.BookDao.findName(..))")
private void pt(){}
@Around("pt()")
public Object around(ProceedingJoinPoint pjp) throws Throwable{
Object[] args = pjp.getArgs();
System.out.println(Arrays.toString(args));
args[0] = 666;
Object ret = pjp.proceed(args);
return ret;
}
//其他的略
}

有了这个特性后，我们就可以在环绕通知中对原始方法的参数进行拦截过滤，避免由于参数的

问题导致程序无法正确运行，保证代码的健壮性。

3.获取返回值

对于返回值，只有返回后 AfterReturing 和环绕 Around 这两个通知类型可以获取，具体如何获取 ?

环绕通知获取返回值

@Component
@Aspect
public class MyAdvice {
@Pointcut("execution(* com.itheima.dao.BookDao.findName(..))")
private void pt(){}
@Around("pt()")
public Object around(ProceedingJoinPoint pjp) throws Throwable{
Object[] args = pjp.getArgs();
System.out.println(Arrays.toString(args));
args[0] = 666;
Object ret = pjp.proceed(args);
return ret;
}
//其他的略
}

上述代码中， ret 就是方法的返回值，我们是可以直接获取，不但可以获取，如果需要还可以进行修改。

返回后通知获取返回值

@Component
@Aspect
public class MyAdvice {
@Pointcut("execution(* com.itheima.dao.BookDao.findName(..))")
private void pt(){}
@AfterReturning(value = "pt()",returning = "ret")
public void afterReturning(Object ret) {
System.out.println("afterReturning advice ..."+ret);
}
//其他的略
}

注意 :

(1) 参数名的问题

(2)afterReturning 方法参数类型的问题

参数类型可以写成 String ，但是为了能匹配更多的参数类型，建议写成 Object 类型

(3)afterReturning 方法参数的顺序问题

运行App后查看运行结果，说明返回值已经被获取到

4.获取异常 

对于获取抛出的异常，只有抛出异常后 AfterThrowing 和环绕 Around 这两个通知类型可以获取，具

体如何获取 ?

环绕通知获取异常

这块比较简单，以前我们是抛出异常，现在只需要将异常捕获，就可以获取到原始方法的异常信息了

@Component
@Aspect
public class MyAdvice {
@Pointcut("execution(* com.itheima.dao.BookDao.findName(..))")
private void pt(){}
@Around("pt()")
public Object around(ProceedingJoinPoint pjp){
Object[] args = pjp.getArgs();
System.out.println(Arrays.toString(args));
args[0] = 666;
Object ret = null;
try{
ret = pjp.proceed(args);
}catch(Throwable throwable){
t.printStackTrace();
}
return ret;
}
//其他的略
}

在 catch 方法中就可以获取到异常，至于获取到异常以后该如何处理，这个就和你的业务需求有关

了。

抛出异常后通知获取异常

@Component
@Aspect
public class MyAdvice {
@Pointcut("execution(* com.itheima.dao.BookDao.findName(..))")
private void pt(){}
@AfterThrowing(value = "pt()",throwing = "t")
public void afterThrowing(Throwable t) {
System.out.println("afterThrowing advice ..."+t);
}
//其他的略
}

如何让原始方法抛出异常，方式有很多，

@Repository
public class BookDaoImpl implements BookDao {
public String findName(int id,String password) {
System.out.println("id:"+id);
if(true){
throw new NullPointerException();
}
return "itcast";
}
}

注意 :

运行App后，查看控制台，就能看的异常信息被打印到控制台 

至此，AOP通知如何获取数据就已经讲解完了，数据中包含参数、返回值、异常(了解)。  

三、百度网盘密码数据兼容处理

1.需求分析

需求: 对百度网盘分享链接输入密码时尾部多输入的空格做兼容处理。

• 当我们从别人发给我们的内容中复制提取码的时候，有时候会多复制到一些空格，直接粘贴到百度的提取码输入框
• 但是百度那边记录的提取码是没有空格的
• 这个时候如果不做处理，直接对比的话，就会引发提取码不一致，导致无法访问百度盘上的内容
• 所以多输入一个空格可能会导致项目的功能无法正常使用。

• 答案是可以的，我们只需要在业务方法执行之前对所有的输入参数进行格式处理——trim() 是对所有的参数都需要去除空格么?
• 也没有必要，一般只需要针对字符串处理即可。

• 以后涉及到需要去除前后空格的业务可能会有很多，这个去空格的代码是每个业务都写么?
• 可以考虑使用AOP来统一处理。

public interface ResourcesService {
    public boolean openURL(String url ,String password);
 
}

@Service
public class ResourcesServiceImpl implements ResourcesService {
    @Autowired
    private ResourcesDao resourcesDao;
 
    public boolean openURL(String url, String password) {
        return resourcesDao.readResources(url,password);
    }
}

public interface ResourcesDao {
 
    boolean readResources(String url, String password);
}

@Repository
public class ResourcesDaoImpl implements ResourcesDao {
    public boolean readResources(String url, String password) {
        System.out.println(password.length());
        //模拟校验
        return password.equals("root");
    }
}

@Configuration
@ComponentScan("com.itheima")
@EnableAspectJAutoProxy
public class SpringConfig {
}

@Component
@Aspect
public class DataAdvice {
    @Pointcut("execution(boolean com.itheima.service.*Service.*(*,*))")
    private void servicePt(){}
 
    @Around("DataAdvice.servicePt()")
    public Object trimStr(ProceedingJoinPoint pjp) throws Throwable {
        Object[] args = pjp.getArgs();
        for (int i = 0; i < args.length; i++) {
            //判断参数是不是字符串
            if(args[i].getClass().equals(String.class)){
                args[i] = args[i].toString().trim();
            }
        }
        Object ret = pjp.proceed(args);
        return ret;
    }
 
 
}

public class App {
    public static void main(String[] args) {
        ApplicationContext ctx = new AnnotationConfigApplicationContext(SpringConfig.class);
        ResourcesService resourcesService = ctx.getBean(ResourcesService.class);
        boolean flag = resourcesService.openURL("http://pan.baidu.com/haha", "root ");
        System.out.println(flag);
    }
}

 execution(* com.itheima.service.*Service.*(..))