Spring学习AOP

---

前言

上一篇文中介绍了spring的控制反转IOC，那么这篇文章来介绍一下面向切面AOP。

面向切面（AOP）是什么？

面向切面（AOP Aspect Oriented Programming）是面向切面变成，与代理模式和接口有许多相同之处。接口是创建一个抽象函数，继承的类去实现其方法，而面向切面则是继承你的实现，然后在不改变原来的基础上，再做一些统一的调整与修改。如下图所示。

比如你在做增删改查，那么在不修改业务逻辑的情况下，去做一些预处理或者后置处理，就可以使用面向切面编程。

代码举例【注解形式】

项目结构如下

pox.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.test</groupId>
    <artifactId>spring-aop</artifactId>
    <version>1.0-SNAPSHOT</version>

    <dependencies>
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.9.4</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>5.3.9</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.13</version>
        </dependency>
    </dependencies>
</project>

AnnotationPointCut

package dly;

import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;


@Aspect
public class AnnotationPointCut {


    //选择切入点  execution([修饰符public] 返回值 包名 类名 方法名 )  .*(..)表示任何方法名，括号表示参数，两个点表示任何参数类型
    @Before("execution(* services.UserServicesImpl.*(..))")
    public void before(){
        System.out.println("-----方法执行前-------");
    }

    @After("execution(* services.UserServicesImpl.add())")
    public void after(){
        System.out.println("-----方法执行后-------");
    }
}

UserService

package services;

public interface UserService {

    public void add();

    public void update();

    public void delete();

    public void select();
}

UserServicesImpl

package services;

public class UserServicesImpl implements UserService {
    public void add() {
        System.out.println("添加了一个用户");
    }

    public void update() {
        System.out.println("更新了一个用户");
    }

    public void delete() {
        System.out.println("删除了一个用户");
    }

    public void select() {
        System.out.println("查找了一个用户");
    }
}

applicationContext.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/aop
       http://www.springframework.org/schema/aop/spring-aop.xsd">

    <!--注册bean-->
    <bean id="userService" class="services.UserServicesImpl"/>
    <bean id="annotationPointCut" class="dly.AnnotationPointCut" />
    <!--开启注解支持-->
    <aop:aspectj-autoproxy/>
</beans>

Test

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import services.UserService;

public class Test {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        UserService userService = (UserService) context.getBean("userService");
        userService.add();
        userService.update();
        userService.delete();
        userService.select();
    }
}

结果：

总结

AOP与代理模式很像，主要需要用到的地方就是不影响业务逻辑的情况下，增加其他的处理。