AOP（面向切面编程）

概念：面向切面编程（面向方面编程）利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。

通俗描述：不通过修改源代码方式，在主干功能里添加新功能

底层原理

  1. AOP底层使用动态代理方式
    • 有两种情况的动态代理
    • 有接口情况，使用JDK动态代理
    • 没有接口情况，使用CGLIB动态代理

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

创建UserDao接口实现类代理对象，增强类的方法image-20201007084912912

没有接口情况,使用CGLIB动态代理

创建当前类子类的代理对象image-20201007085245339

AOP（JDK动态代理）

  1. 使用JDK动态代理，使用Proxy类里面的方法创建代理对象image-20201007085625842
  2. 调用newProxyInstance方法来实现，有三个参数
    • 类加载器
    • 增强方法所在的类，类实现的接口，支持多个接口
    • 实现这个接口InvocationHandler，创建代理对象，写增强的方法

image-20201007085805054

  1. 编写JDK动态代理代码

    • 创建接口，定义方法

      public interface UserDao {

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

    • 创建接口实现类，实现方法

      public class UserDaoImpl implements UserDao{
    public int add(int a, int b) {
        return a+b;
    }

    public String update(String id) {
        return id; 
    }
}

    • 使用Proxy创建接口的代理对象

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

//创建代理对象代码
class UserDaoProxy implements InvocationHandler {
    //把创建的代理对象的本体传递过来
    //有惨构造进行传递
    private Object obj;

    public UserDaoProxy(Object obj) {
        this.obj = obj;
    }

    //增强的逻辑
    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 res;
    }
}

AOP术语

  1. 连接点，类里面哪些方法可以被增强，这些方法称为连接点
  2. 切入点，实际被增强的方法，称为切入点
  3. 通知（增强），
    • 实际增强的逻辑部分称为通知（增强）
    • 通知有多种类型，前置通知,后置通知,环绕通知,异常通知，最终通知（finally）
  4. 切面:把通知应用到切入点的过程

AOP操作（准备）

  1. Spring框架中，一般基于AspectJ实现AOP操作

    AspectJ：不是spring组成部分，独立AOP框架，一半把AspectJ与Spring框架一起使用。进行AOP相关操作

  2. 基于AspectJ实现AOP操作

    • 基于xml配置文件
    • 基于注解方式（使用）

  3. 在项目工程中引入AOP相关依赖

    <!-- https://mvnrepository.com/artifact/org.springframework/spring-aspects -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-aspects</artifactId>
    <version>5.2.9.RELEASE</version>
</dependency>

  4. 切入点表达式

    • 切入点表达式的作用：知道对哪个类里面的哪个方法进行增强
    • 语法结构execution([权限修饰符][返回类型][全类名][方法名称]([参数列表])

    举例1：对com.yang.dao.Book类里面的add进行增强

    execution(* com.yang.dao.Book.add(..))

    举例2：对com.yang.dao.Book类里面的所有方法进行增强

    execution(* com.yang.dao.Book.*(..))

    举例3：对com.yang.dao包里面的所有类里面的所有包进行增强

    execution(* com.yang.dao.*.*(..))

AOP操作（AspectJ注解）

  1. 创建类，在类里面定义方法，

    public class User {
    public void add(){
        System.out.println("add,,,,");
    }
}

  2. 创建增强类(编写增强的逻辑)

    在增强类里面创建方法，让不同方法代表不同通知类型

    //增强的类
public class UserProxy {
    //前置通知
    public void before(){
        System.out.println("before........");
    }
}

  3. 进行通知的配置

    • 在Spring配置文件中，开启注解扫描

      <?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:context="http://www.springframework.org/schema/context"
       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/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">
    <!--开启注解扫描-->
    <context:component-scan base-package="com.yang.aopanno"/>
</beans>

    • 使用注解创建Userh和UserProxy对象

      package com.yang.aopanno;

import org.springframework.stereotype.Component;

//被增强类
@Component
public class User {
    public void add(){
        System.out.println("add,,,,");
    }
}

      package com.yang.aopanno;

import org.springframework.stereotype.Component;

//增强的类
@Aspect
@Component
public class UserProxy {
    //前置通知
    public void before(){
        System.out.println("before........");
    }
}

    • 在增强类上面添加注解@Aspect

    • 在Spring配置文件中，开启生成代理对象

      <aop:aspectj-autoproxy/>

    • 配置不同类型的通知

      在增强类的里面，在作为通知方法上面添加通知类型注解，使用切入点表达式

package com.yang.aopanno;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;

//增强的类
@Component
@Aspect //生成代理对象
public class UserProxy {
    //前置通知
    //@Before注解表示作为前置通知
    @Before(value = "execution(* com.yang.aopanno.User.add(..))")
    public void before() {
        System.out.println("before........");
    }
    //最终通知
    @After(value = "execution(* com.yang.aopanno.User.add(..))")
    public void after() {
        System.out.println("after.........");
    }
    //后置通知（返回通知），有异常不执行
    @AfterReturning(value = "execution(* com.yang.aopanno.User.add(..))")
    public void afterReturning() {
        System.out.println("afterReturning....");
    }

    @AfterThrowing(value = "execution(* com.yang.aopanno.User.add(..))")
    public void afterThrowing() {
        System.out.println("afterThrowing....");
    }
    @Around(value = "execution(* com.yang.aopanno.User.add(..))")
    public void around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable{
        System.out.println("环绕之前。。。");
        proceedingJoinPoint.proceed();
        System.out.println("环绕之后。。。");
    }
}

公共切入点提取

//相同切入点抽取
@Pointcut(value = "execution(* com.yang.aopanno.User.add(..))")
public void pointDemo(){

}
@Before(value = "pointDemo()")
public void before() {
    System.out.println("before........");
}

有多个增强类对同一个方法进行增强，设置增强类优先级

  1. 在增强类上面添加注解@Order(数字类型值),数字类型值越小，优先级越高

    @Component//对象创建
@Aspect//代理对象创建
@Order(1)
public class PersonProxy {
    @Before(value = "execution(* com.yang.aopanno.User.add(..))")
    public void before(){
        System.out.println("Person before......");
    }
}

  2. 
@ComponentScan(basePackages = {"com.yang"})
@Configuration
@EnableAspectJAutoProxy(proxyTargetClass = true)
public class MyConfig {

}

AOP操作（AspectJ配置文件）

  1. 创建两个类，增强类和被增强类，创建方法

  2. 在spring配置文件中创建两个类对象

    <!--    创建对象-->
<bean id="book" class="com.yang.aopxml.Book"/>

<bean id="bookProxy" class="com.yang.aopxml.BookProxy"/>

  3. 在spring配置文件中配置切入点

        <!--    创建对象-->
    <bean id="book" class="com.yang.aopxml.Book"/>

    <bean id="bookProxy" class="com.yang.aopxml.BookProxy"/>
<!--    配置aop增强-->
    <aop:config>
<!--        配置切入点-->
        <aop:pointcut id="p" expression="execution(* com.yang.aopxml.Book.buy(..))"/>
<!--        配置切面-->
        <aop:aspect ref="bookProxy">
<!--            增强在具体的方法上-->
            <aop:before method="before" pointcut-ref="p"/>
        </aop:aspect>
    </aop:config>
# spring
Logo
开放原子开发者工作坊

开放原子开发者工作坊旨在鼓励更多人参与开源活动，与志同道合的开发者们相互交流开发经验、分享开发心得、获取前沿技术趋势。工作坊有多种形式的开发者活动，如meetup、训练营等，主打技术交流，干货满满，真诚地邀请各位开发者共同参与！

更多推荐

以智能 致世界 | 操作系统大会2024议程全览

avatar 开放原子开发者工作坊

开放原子开源基金会新增捐赠人（2024年9月）

2024年9月，新增以下单位成为开放原子开源基金会及旗下项目捐赠人。

avatar 开放原子开发者工作坊

2024开放原子开发者大会议题征集正式开启

2024开放原子开发者大会（以下简称“大会”）将于12月中旬重磅来袭,2024开放原子开发者大会议题征集正式开启!

avatar 开放原子开发者工作坊