Spring——AOP(Aspect Oriented Programming)面向切面编程

AOP(Aspect Oriented Programming)面向切面编程

1、什么是 AOP?

  1. 面向切面编程(方面), 利用 AOP 可以对业务逻辑的各个部分进行隔离,从而使得 业务逻辑各部分之间的耦合度降低,提高程序的可重用性,同时提高了开发的效率;
  2. 通俗描述:不通过修改源代码方式,在主干功能里面添加新功能
  3. 使用登录例子说明 AOP。

在这里插入图片描述


2、AOP(底层原理)

2.1、AOP 底层使用动态代理

有两种情况动态代理:

第一种:有接口情况,使用 JDK 动态代理

  • 创建接口实现类代理对象,增强类的方法

在这里插入图片描述

第二种:没有接口情况,使用 CGLIB 动态代理

  • 创建子类的代理对象,增强类的方法

在这里插入图片描述


3、AOP( JDK 动态代理)

1、使用 JDK 动态代理,使用 Proxy 类里面的方法创建代理对象:

java.lang.reflect.Proxy:newProxyInstance(ClassLoader loader, 类<?>[] interfaces, InvocationHandler h) 返回指定接口的代理类的实例,该接口将方法调用分派给指定的调用处理程序。

方法里边有三个参数:

  • ClassLoader loader:类加载器
  • 类<?>[] interfaces:增强方法所在的类,这个类实现的接口,支持多个接口
  • InvocationHandler h:实现这个接口 InvocationHandler,创建代理对象,写增强的部分

2、编写 JDK 动态代理代码:

package spring5;

public interface UserDao {
    
    public int add(int a, int b);
    public String update(String id);
}
package spring5;

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 类创建接口代理对象:

package spring5;

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

public class JDKProxy {

    public static void main(String[] args) {
        //创建接口实现类的代理对象
        Class[] interfaces = {UserDao.class};
        /*Proxy.newProxyInstance(JDKProxy.class.getClassLoader(), interfaces, new InvocationHandler() {
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                return null;
            }
        });*/
        UserDaoImpl userDao = new UserDaoImpl();
        UserDao dao =  (UserDao) Proxy.newProxyInstance(JDKProxy.class.getClassLoader(), interfaces, new UserDaoProxy(userDao));
        int result = dao.add(1, 2);
        System.out.println(result);
    }

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

        //1 把创建的是谁的代理对象,把谁传递过来
        //有参数的构造传递
        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 res;
        }
    }
}
方法之前执行...add:传递的参数...[1, 2]
add方法执行了...
方法之后执行...spring5.UserDaoImpl@5034c75a
3

4、AOP(术语)

在这里插入图片描述

4.1、连接点

类里面哪些方法可以被增强,这些方法称为连接点。

4.2、切入点

实际被真正增强的方法,称为切入点。

4.3、通知(增强)

实际增强的逻辑部分称为通知(增强)。

4.4、切面

是动作:把通知应用到切入点过程。


5、AOP 操作(准备工作)

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

    AspectJ 不是 Spring 组成部分,独立 AOP 框架,一般把 AspectJ 和 Spirng 框架一起使用,进行 AOP 操作。

  2. 基于 AspectJ 实现 AOP 操作

    (1)基于 xml 配置文件实现

    (2)基于注解方式实现(使用)

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

  4. 切入点表达式

    (1)切入点表达式作用:知道对哪个类里面的哪个方法进行增强

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

    举例 1:对 com.atguigu.dao.BookDao 类里面的 add 进行增强

    execution(* com.atguigu.dao.BookDao.add(..))

    举例 2:对 com.atguigu.dao.BookDao 类里面的所有的方法进行增强

    execution(* com.atguigu.dao.BookDao.* (..))

    举例 3:对 com.atguigu.dao 包里面所有类,类里面所有方法进行增强

    execution(* com.atguigu.dao.*.* (..))


6、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)进行通知的配置

  1. 在 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="aopanno"></context:component-scan>
    </beans>
    
  2. 使用注解创建 User 和 UserProxy 对象

    import org.springframework.stereotype.Component;
    
    //被增强类
    @Component
    public class User {
        public void add() {
            System.out.println("add...");
        }
    }
    
    import org.springframework.stereotype.Component;
    
    //增强类
    @Component
    public class UserProxy {
    
        //前置通知
        public void before() {
            System.out.println("before...");
        }
    }
    
  3. 在增强类上面添加注解 @Aspect

    import org.aspectj.lang.annotation.Aspect;
    import org.springframework.stereotype.Component;
    
    //增强类
    @Component
    @Aspect //生成代理对象
    public class UserProxy {
    
        //前置通知
        public void before() {
            System.out.println("before...");
        }
    }
    
  4. 在 spring 配置文件中开启生成代理对象

    <!--开启Aspect生成代理对象-->
    <aop:aspectj-autoproxy></aop:aspectj-autoproxy>
    

(4)配置不同类型的通知

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

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

//增强类
@Component
@Aspect //生成代理对象
public class UserProxy {

    //前置通知
    //@Before注解表示作为前置通知
    @Before(value = "execution(* aopanno.User.add(..))")
    public void before() {
        System.out.println("before...");
    }
}

测试代码:

@Test
public void test() {
    ApplicationContext context =
            new ClassPathXmlApplicationContext("bean1.xml");
    User user = context.getBean("user", User.class);

    user.add();
    /*
    before...
	add...
    */
}

剩下的通知类型:

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

//增强类
@Component
@Aspect //生成代理对象
public class UserProxy {

    //前置通知
    //@Before注解表示作为前置通知
    @Before(value = "execution(* aopanno.User.add(..))")
    public void before() {
        System.out.println("before...");
    }

    //最终通知,不有没有异常都执行
    @After(value = "execution(* aopanno.User.add(..))")
    public void after() {
        System.out.println("after...");
    }

    //后置通知
    @AfterReturning(value = "execution(* aopanno.User.add(..))")
    public void afterReturning() {
        System.out.println("AfterReturning...");
    }

    //异常通知
    @AfterThrowing(value = "execution(* aopanno.User.add(..))")
    public void afterThrowing() {
        System.out.println("AfterThrowing...");
    }

    @Around(value = "execution(* aopanno.User.add(..))")
    public void around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
        System.out.println("环绕之前...");
        //被增强的方法要执行
        proceedingJoinPoint.proceed();
        System.out.println("环绕之后...");
    }
}

(5)相同的切入点抽取

定义在代理类之中:

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

在后面的配置中,就可以直接使用方法名即可:

//前置通知
//@Before注解表示作为前置通知
@Before(value = "pointdemo()")
public void before() {
    System.out.println("before...");
}

(6)有多个增强类多同一个方法进行增强,设置增强类优先级

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

@Component
@Aspect //生成代理对象
@Order(1)
public class PersonProxy {
    //前置通知
    //@Before注解表示作为前置通知
    @Before(value = "execution(* aopanno.User.add(..))")
    public void before() {
        System.out.println("Person before...");
    }
}
//增强类
@Component
@Aspect //生成代理对象
@Order(3)
public class UserProxy {

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

    }
    ......

(7)完全使用注解开发

创建配置类,不需要创建 xml 配置文件:

@Configuration
@ComponentScan(basePackages = {"com.atguigu"})
@EnableAspectJAutoProxy(proxyTargetClass = true)
public class ConfigAop {
}

7、AOP 操作(AspectJ 配置文件)

了解即可。

参与评论 您还未登录,请先 登录 后发表或查看评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
©️2022 CSDN 皮肤主题:终极编程指南 设计师:CSDN官方博客 返回首页

打赏作者

前丨尘忆·梦

你的鼓励将是我创作的最大动力

¥2 ¥4 ¥6 ¥10 ¥20
输入1-500的整数
余额支付 (余额:-- )
扫码支付
扫码支付:¥2
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、C币套餐、付费专栏及课程。

余额充值