Spring AOP应用一看就懂系列

最新推荐文章于 2023-06-18 22:27:03 发布

啊～小 l i

最新推荐文章于 2023-06-18 22:27:03 发布

阅读量184

点赞数

分类专栏： spring 文章标签： aop spring java 编程语言

本文链接：https://blog.csdn.net/xiao_yan_/article/details/109111612

版权

spring 专栏收录该内容

13 篇文章 1 订阅

订阅专栏

文章目录

Spring AOP简介
- 什么是AOP
- AOP术语
动态代理

Spring AOP简介

什么是AOP

AOP即面向切面的编程（也称面向方向编程）。它是面向对象（OOP）的一种补充。
AOP采用横向抽取机制，将分散在各个方法中的重复代码提取出来，然后再程序编译或运行的时，再将代码提取出来，应用到需要执行的地方。
目前最流行的AOP框架有两个，分别为Spring AOP和AspectJ。Spring AOP使用纯Java代码实现，不需要专门的编译过程和类加载器，在运行期间通过代理方式向目标组织织入增强代码。AspectJ是一个基于Java语言的AOP框架，从Spring2.0开始，Spring AOP引入了对AspecJ的支持，AspectJ扩展了对Java语言，提供了专门的编译器，在编译的时提供横向代码植入。

AOP术语

Aspect（切面）：切面通常指封装用于横向插入系统的功能（如事务、日志等）的类，该类要被Spring容器识别为切面需要在配置文件中通过
< bean >元素指定。
Joinpoint（连接点）：在程序执行过程中的某个阶段点，它实际上是对象的一个操作，例如方法的调用或异常的抛出。在Spring AOP中，连接点就是指方法的调用。
Advice（切入点）：是指切面与程序流程的交叉点，即那些需要处理的连接点，通常在程序中，切入点指类或方法名；如某个通知要应用到所有以Add开头的方法中，那么满足这一规则的方法就是切入点。
Advice（通知/增强处理）：AOP框架中在特定的切入点执行的程序代码。可以将其理解为切面的类方法，他是切面的具体实现。
Target Object（目标对象）：是指所有被通知的对象，也称为被增强的对象。如果AOP框架采用的是动态AOP实现，那么该对象就是一个被代理的对象。
Proxy（代理）：将所有通知应用到目标对象之后，被动态创建的对象。
Weaving（织入）：将切面代码插入到目标对象上，从而生成代理对象的过程。
AOP设计与原理(连接点，切入点与代理模式)—>点此处

动态代理

JDK动态代理

JDK代理是通过java.lang.reflect.Proxy类来实现的，我们可以调用Proxy类的newProxyInstance()方法来创建对象。对于对接业务的类Spring会默认使用JDK动态代理来实现AOP。
包结构
在这里插入图片描述
接口方法

package com.it;

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

被增强的方法

package com.it;

public class User implements UserDao{

    @Override
    public int add(int a, int b) {
        System.out.println("方法执行了");
        return a+b;
    }

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

package com.it;

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) {
        User user = new User();
        //创建接口实现类的接口对象
        Class[] interfaces = {UserDao.class};
        UserDao dao = (UserDao) Proxy.newProxyInstance(JDKProxy.class.getClassLoader(),interfaces,new UserDaoPoxy(user));
          //三个参数，第一个是类加载器，第二个是Class数组类型接口 第三个InvocationHandler
        int resout = dao.add(1, 2);
        System.out.println(resout);
    }
}


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

    //1. 创建的是谁的代理对象把谁传递过来
    //有参构造传递
    private Object object;
    public UserDaoPoxy(Object object){
        this.object = object;
    }

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

AOP操作准备

1.Spring框架一般都是基于AspectJ实现AOP
2.基于AspectJ实现AOP操作
3.引入依赖
在这里插入图片描述
4.切入点的表达式
Advice（切入点）：是指切面与程序流程的交叉点，即那些需要处理的连接点，通常在程序中，切入点指类或方法名；如某个通知要应用到所有以Add开头的方法中，那么满足这一规则的方法就是切入点。
1、切入点的表达式作用：知道对哪个类的那个方法进行增强
2、语法结构
execution([权限修饰符][返回类型] [类全路径][方法名称]([参数列表]))
3、例子1：对it.dao.book类里面的add方法增强。
execution(* it.dao.book.add(..))

* 代表所有修饰符
第二个返回类型可以省略
..代表参数列表的参数
例子2：对it.dao.book类里面的所有方法增强。
execution(* it.dao.book.*)
例子3：对it.dao包里面的所有方法增强。
execution(* it.dao.*.*)

AOP操作（AspectJ注解）

创建类，在里面定义方法

package com.aop;
public class User {
    public void add(){
        System.out.println("Add>>>>>>>>");
    }
}

创建增强类（编写增强逻辑）
1. 在增强类里面，创建方法，让不同的方法代表不同通知类型
进行通知配置
1. 在spring配置文件中，开启注解扫描
  <xmls:component-scan base-package="com.aop"></xmls:component-scan>
2. 使用注解创建User和UserProxy
3. 在增强类上添加注解@Aspect
4. 在spring 配置文件中开启生成代理对象
  <aop:aspectj-autoproxy></aop:aspectj-autoproxy>
配置类型的通知
在增强类里，在作为通知方法上添加通知注解类型，使用切入点表达式

package com.aop;
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(* com.aop.User.add())")
    public void before(){
        System.out.println("before>>>>>>>>");

    }
}

测试

package com.test;

import com.aop.User;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class test {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("spring-config.xml");
        User user = context.getBean("user",User.class);
        user.add();
    }
}

所有注解展示

package com.aop;

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.aop.User.add())")
    public void before(){
        System.out.println("before>>>>>>>>");
    }

    @After(value = "execution(* com.aop.User.add())")
    public void after(){
        System.out.println("After>>>>>");
    }

    @AfterReturning(value = "execution(* com.aop.User.add())")
    public void AfterReturning(){
        System.out.println("AfterReturning>>>>>");
    }

    @AfterThrowing(value = "execution(* com.aop.User.add())")
    public void AfterThrowing(){
        System.out.println("AfterThrowing>>>>>");
    }
    //环绕通知
    @Around(value = "execution(* com.aop.User.add())")
    public void Around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
        System.out.println("Around>>>>>1");
        proceedingJoinPoint.proceed();
        System.out.println("Around>>>>>2");
    }
}

在这里插入图片描述

@AfterReturning与@After区别

After是方法执行后运行 —>有没有异常都执行
@AfterReturning返回结果后执行（返回通知）——>有异常不执行

@Around

    @Around(value = "execution(* com.aop.User.add())")
    public void Around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
        System.out.println("Around>>>>>1");
        proceedingJoinPoint.proceed();
        System.out.println("Around>>>>>2");
    }
}

add()执行前后都会执行

@AfterThrowing

有异常才会执行,没有异常不执行

细节

相同的切入点抽取

@Component
@Aspect  //生成代理对象
//增强类
public class UserProxy {
    //切入点抽取
    @Pointcut(value = "execution(* com.aop.User.add())")
    public void point(){

    }
//前置通知  Before是前置通知
    @Before(value = "point()")
    public void before(){
        System.out.println("before>>>>>>>>");
    }

多个增强类对同一个增强，设置优先级

加入一个注解@Order(数字类型的值)———》数值越小优先级越高

AspectJ配置文件配置（AOP）

创建对象
配置AOP增强

完全注解开发

package com.aop;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.EnableAspectJAutoProxy;

@Configuration                                     //定义配置类
@ComponentScan(basePackages = {"com.aop"})         //开启组件扫描
@EnableAspectJAutoProxy(proxyTargetClass = true)   //生成AspectJ
public class Config {
}

不需要创建xml文件

啊～小 l i

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
Spring AOP应用一看就懂系列

文章目录Spring AOP简介什么是AOPAOP术语动态代理JDK动态代理实例1（此处使用的是spring自动装配）Spring AOP简介什么是AOPAOP即面向切面的编程（也称面向方向编程）。它是面向对象（OOP）的一种补充。AOP采用横向抽取机制，将分散在各个方法中的重复代码提取出来，然后再程序编译或运行的时，再将代码提取出来，应用到需要执行的地方。目前最流行的AOP框架有两个，分别为Spring AOP和AspectJ。Spring AOP使用纯Java代码实现，不需要专门的编译过程和
复制链接

扫一扫