【Spring5】AOP面向切面？程序不可多得的Buff

---

---

1 什么是AOP

在软件业，AOP为Aspect Oriented Programming的缩写，意为：面向切面编程，通过预编译方式和运行期间动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。

举个例子： 在一个登录功能中添加一个权限验证
登录流程图如下：

原始情况下，如果想要在这样一个完善的登录功能中进行增强：添加上权限验证的功能，则需要通过修改源代码的方式实现：

if 管理员{
    
    
...
}else if 用户{
    
    
...
}...

耦合度很高，后期如果需要维护，或者不需要权限验证这一功能时，还需要更改代码，相当麻烦。

而AOP则可以让你在不修改源代码的情况下添加新的功能，只需要写好对应的权限验证模块，以AOP提供的方式，对登录模块进行增强即可。 当你不需要的时候，只需要删除这个模块，而不必修改源代码。

---

2 AOP底层原理

2.1 AOP底层使用的动态代理

• 有接口的情况，使用JDK动态代理

创建接口实现类对象，增强类的方法。

• 无接口的情况，使用CGLTB动态代理

创建子类的代理对象，增强类的方法。

2.2 JDK动态代理机制刨析

首先先介绍一个类：Proxy，Proxy提供了创建动态代理类和实例的静态方法，它也是由这些方法创建的所有动态代理类的超类。

扫描二维码关注公众号，回复： 14712345 查看本文章

在JDK动态代理刨析过程中，需要使用到 newProxyInstance方法：
该方法存在三个参数：
第一个参数：类加载器
第二个参数：增强方法所在的类，这个类实现的接口，支持多个接口
第三个参数：实现接口InvocationHandler，创建代理对象，写增强的部分

JDK动态代理刨析，编写JDK动态代理代码
1.先准备一个接口定义方法

/**
 * 创建接口
 */
public interface UserDao {
    
    

    public int add(int a, int b);
    public String update(String id);
}

2.创建接口实现类，并实现方法

/**
 * 接口实现类
 */
public class UserDaoImpl implements UserDao {
    
    
    @Override
    public int add(int a, int b) {
    
    
        System.out.println("add方法执行");
        return (a + b);
    }

    @Override
    public String update(String id) {
    
    
        System.out.println("update方法执行");
        return id;
    }
}

3.使用Proxy类创建接口代理对象，增强代码如下：

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.Arrays;

/**
 * @author 兴趣使然黄小黄
 * @version 1.0
 * JDK代理增强
 */
@SuppressWarnings({
    
    "all"})
public class JDKProxy {
    
    

    public static void main(String[] args) {
    
    
        //创建接口实现类的代理对象
        Class[] interfaces = {
    
    UserDao.class};
        //类似于 UserDao userDao = new UserDaoImpl()
        UserDaoImpl userDaoImpl = new UserDaoImpl();
        UserDao userDao = (UserDao) Proxy.newProxyInstance(
                JDKProxy.class.getClassLoader(), interfaces, new UserDaoProxy(userDaoImpl));
        int res = userDao.add(1, 2);
        System.out.println("res = " + res);
    }
}

//创建代理对象
class UserDaoProxy implements InvocationHandler {
    
    

    //创建谁的代理对象，就把谁传过来
    //有参构造传递
    private Object obj;
    public UserDaoProxy(Object obj){
    
    
        this.obj = obj;
    }

    //增强的逻辑
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
    
    
        //方法之前
        System.out.println("方法之前执行......" + method.getName() + " :传递的参数......" + Arrays.toString(args));

        //被增强的方法执行
        Object res = method.invoke(obj, args);

        //方法之后
        System.out.println("方法之后执行......" + obj);

        return null;
    }
}

---

3 AOP面向切面操作

3.1 AOP术语

1. 连接点： 类里面哪些方法可以被增强，这些方法称为连接点。
2. 切入点： 实际被真正增强的方法，称为切入点。
3. 通知（增强）
   3.1 实际增强的逻辑部分为通知
   3.2 通知分为：前置通知、后置通知、环绕通知、异常通知、最终通知
4. 切面： 是动作，即把通知应用到切入点的过程。

上面所说的各种通知类型，顾名思义，就是在被增强的方法执行前，执行，则称为前置通知；在被增强的方法执行后则称后置通知；异常通知则是在原方法发生异常时才会执行。

3.2 操作准备

Spring框架一般都是基于AspectJ实现AOP操作

什么是AspectJ?
AspectJ不是Spring的组成部分，只是一般把AspectJ和Spring框架一起使用进行AOP操作。

同之前所学的Spring IOC类似，想要进行AOP操作同样需要导入对应的依赖，所需要的 jar 包如图所示：

tips：需要的 jar 包文末附下载链接！

基于AspectJ实现AOP操作同样有两种方式：

1. 基于注解的方式
2. 基于xml配置文件的方式实现（不怎么用，就不介绍了）

在进行AOP操作的学习前，需要补充切入点表达式的相关知识！

3.3 切入点表达式

切入点表达式：表达哪个类里面的哪个方法需要增强

语法如下：

execution([权限修饰符][返回类型][类全路径][方法名称]([参数列表]))

示例如下：

• 对 com.hxh.spring.User 类的 method 进行增强

execution(*com.hxh.spring.User.method(..))

• 对 com.hxh.spring.User 类的里的所有方法进行增强

execution(*com.hxh.spring.User.*(..))

3.4 基于AspectJ注解的AOP操作

实例演示：

增强User类中的method方法

1.编写User类

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

/**
 * @author 兴趣使然黄小黄
 * @version 1.0
 * 被增强的类
 */
@Component
public class User {
    
    
    public void method(){
    
    
        System.out.println("method......");
    }
}

2.创建增强类，用于编写增强的逻辑

import org.springframework.stereotype.Component;

/**
 * @author 兴趣使然黄小黄
 * @version 1.0
 * 增强类
 */
public class UserProxy {
    
    
    
    public void before(){
    
    
        System.out.println("before......");
    }
}

3.进行通知的配置

（1）在spring配置文件中，开启注解扫描。

（2）使用注解创建User和UserProxy对象，并在增强类上添加注解@Aspect。并开启Aspect生成代理对象。

（3）在增强类对应的增强方法上添加注解，比如 @Before 就是前置通知，会在被增强的方法执行前执行，其value传的就是刚才我们学习过的切入表达式！

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

/**
 * @author 兴趣使然黄小黄
 * @version 1.0
 * 增强类
 */
@Component
@Aspect //生成代理对象
public class UserProxy {
    
    

	//前置通知
    @Before(value = "execution(* com.ithxh.spring5.aopanno.User.method(..))")
    public void before(){
    
    
        System.out.println("before......");
    }
}

（4）编写测试类，进行测试。

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

/**
 * @author 兴趣使然黄小黄
 * @version 1.0
 * 测试类
 */
public class UserProxyDemo {
    
    
    public static void main(String[] args) {
    
    
        ApplicationContext context = new ClassPathXmlApplicationContext("bean1.xml");
        User user = context.getBean("user", User.class);
        user.method();
    }
}

以上对前置通知进行了举例，除此之外，还有如下注解
@Before：前置通知：追加功能到方法执行前。
@AfterReturning：后置通知：追加功能到方法执行后，只有方法正常执行结束后才进行。
@Around：环绕通知：环绕通知功能比较强大，它可以追加功能到方法执行的前后，这也是比较常用的方式，它可以实现其他四种通知类型的功能。
@AfterThrowing：异常通知：追加功能到方法抛出异常后，只有方法执行出异常才进行。
@After：最终通知：无论是否发生异常，都会执行！

除了案例中的AOP增强方式以外，也可以使用@Pointcut 注解设置切入点：

---

4 基于纯注解的AOP操作

同样，AOP也可以使用纯注解的方式实现。需要编写配置类来代替配置文件，其中：@EnableAspectJAutoProxy 开启注解格式AOP功能

配置类：

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

/**
 * @author 兴趣使然黄小黄
 * @version 1.0
 */
@Configuration
@ComponentScan(basePackages = {
    
    "com.ithxh.spring5"})
@EnableAspectJAutoProxy(proxyTargetClass = true)
public class ConfigAop {
    
    
}

测试类更改：

import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;


/**
 * @author 兴趣使然黄小黄
 * @version 1.0
 * 测试类
 */
public class UserProxyDemo {
    
    
    public static void main(String[] args) {
    
    
        ApplicationContext applicationContext = new AnnotationConfigApplicationContext(ConfigAop.class);
        User user = applicationContext.getBean("user", User.class);
        user.method();
    }
}

---

写在最后

 到这里，Spring中的AOP部分就已经讲解完了，AOP实验使用到的jar包下载链接附上：com.springsource.org.aspectj.weaver-1.6.4.RELEASE等AOP操作相关jar包