AOP介绍

最新推荐文章于 2024-10-12 17:55:45 发布
最新推荐文章于 2024-10-12 17:55:45 发布
阅读量159 收藏 1
点赞数
分类专栏： Spring5 文章标签： java spring apache
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_57437175/article/details/127178125
版权

AOP

4.1 什么是AOP？

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

4.2 AOP底层原理

4.2.1 AOP的底层使用到了** 动态代理 \textcolor{red}{动态代理} 动态代理**

  1. 有两种情况的动态代理

    第一种：有接口情况，使用JDK中的动态代理

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

    第一种情况图解：👇

    创建接口实现类代理对象，增强类方法

image-20221005100828516

​ 第二种情况图解：👇

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

image-20221005101158631

4.2.2 AOP(JDK动态代理)

  1. 使用JDK动态代理，使用Proxy类里面的方法创建代理对象
1. 调用new ProxyInstance方法
image-20221005102133370 
static Object	newProxyInstance(ClassLoader loader, 类<?>[] interfaces, InvocationHandler h)
//返回指定接口的代理类的实例，该接口将方法调用分派给指定的调用处理程序。

第一个参数：类加载器

第二个参数：增强方法所实现的接口，支持多个接口

第三个参数：实现里边的接口InvocationHandler，创建代理对象，写增强的部分

2. 编写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) {
        return a+b;
    }
    @Override
    public String update(String id) {
        return id;
    }
}
    1. 使用Proxy类创建接口的代理对象
public class JDKProxy {
    public static void main(String[] args) {
        //创建接口实现类的代理对象
        Class[] interfaces = {UserDao.class};
        UserDao userDao = new UserDaoImpl();
       UserDao userDao1 =(UserDao) Proxy.newProxyInstance(JDKProxy.class.getClassLoader(), interfaces, new UserDaoProxy(userDao));
        int add = userDao1.add(1, 2);
        System.out.println(add);
    }
}
//创建代理对象的代码
class UserDaoProxy implements  InvocationHandler{
    //1. 把创建的是谁的代理对象，将这个“谁”给传过来；通过有参构造进行传递
    private Object obj ;
    public UserDaoProxy(Object o){
        this.obj = o;
    }
    //增强的逻辑写到invoke中
    @Override
    //proxy表示代理对象
    //method表示当前方法
    //args表示参数
    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(this==proxy);
        //方法之后处理
        System.out.println("方法之后执行..."+obj);

        return res;
    }
}
1. 练习

  1. 创建相关接口

    public interface Human {
    public void eat(String s);
    public void play(String s);
}

  2. 创建接口实现类

    public class SuperMan implements Human {
    @Override
    public void eat(String s) {
        System.out.println("我喜欢吃"+s);
    }

    @Override
    public void play(String s) {
        System.out.println("我会+"+s);
    }

    public static void main(String[] args) {
        SuperMan man = new SuperMan();
        Class[] intefaces = {Human.class};
        //获取代理类
        Human supperMan = (Human) Proxy.newProxyInstance(SuperMan.class.getClassLoader(), intefaces, new InvocationHandler() {
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                System.out.println("调用方法之前做了一些事。。。。");
                Object invoke = method.invoke(man, args);
                System.out.println("调用方法之后做了一些事。。。。");
                return invoke;
            }
        });
        supperMan.play("玩");
    }
}

4.3 AOP 相关术语

4.3.1 连接点

类里边那些方法可以被增强，这些方法称为连接点

4.3.2 切入点

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

4.3.3 通知（增强）

  1. 实际增强的逻辑的部分就称为通知（增强）

比如：登录过程中的权限判断

  1. 通知有多种类型
  1. 前置通知：切入点方法的后面执行
  2. 后置通知：切入点方法的后面执行
  3. 环绕通知：切入点的前后都执行
  4. 异常通知：当切入点方法出现异常我们去执行
  5. 最终通知：类似java中的try-catch的finally

4.3.4 切面

事动作，将我们的通知应用到切入点的过程就是通知；将权限判断加入到登录方法的过程

4.4 AOP的操作

4.4.1 AspctJ

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

    什么事AspectJ❓

    AspectJ不是Spring组成部分，独立的AOP框架，可以独立使用，一般AspectJ和Spring框架一起来使用，一起案例进行AOP的操作

  2. 基于AspectJ实现AOP操作

    1. 基于xml配置文件
    2. 基于注解方式实现

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

    image-20221005142341277

image-20221005142451195

  1. 切入点的表达式

    1. 切入点表达式的作用：知道要对那个类里边的那个方法进行增强

    2. 语法结构

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

      举例一：对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.*.*(…))

4.4.2 A O P 操作（ A s p e c t J 注解）重点 \textcolor{red}{AOP操作（AspectJ注解）重点} AOP操作（AspectJ注解）重点

  1. 创建一个类，在类中定义方法
public class User {
    public void add(){
        System.out.println("add...");
    }
}
  1. 创建增强类（编写增强逻辑）
    1. 在增强类中，创建方法，让不同的方法代表不同的通知类型
//增强类
public class UserProxy {
    //前置通知
    public void before(){
        System.out.println("before...");
    }
}

  1. 进行配置

    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="com.atguigu.spring5.aop"></context:component-scan>
</beans>

    2. 使用注解来创建User和UserProxy对象

      image-20221005145308760

    3. 在增强类上边添加注解 @ A s p e c t \textcolor{red}{Aspect} Aspect

      image-20221005145352144

    4. 在spring配置文件中开启生成代理对象

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

    5. 配置不同类型通知

      1. 在增强类里边，作为通知的方法上边，添加通知类型的注解，并且使用切入点表达式来配置
      @Component
@Aspect
public class UserProxy {
    //前置通知
    //@Before表示作为前置通知
    @Before(value="execution(* com.atguigu.spring5.aop.User.add(..))")
    public void before(){
        System.out.println("before...");
    }
}

  2. 进行测试

@Test
public void testAopAnno(){
    ApplicationContext context = new ClassPathXmlApplicationContext("bean1.xml");

    User user = context.getBean("user", User.class);
    user.add();
}
image-20221005151033181

  1. 测试所有的通知类型

    //增强类
@Component
@Aspect
public class UserProxy {
    //前置通知
    //@Before表示作为前置通知
    @Before(value="execution(* com.atguigu.spring5.aop.User.add(..))")
    public void before(){
        System.out.println("before...");
    }
    @After(value="execution(* com.atguigu.spring5.aop.User.add(..))")
    public void after(){
        System.out.println("after...");
    }

    @AfterReturning(value="execution(* com.atguigu.spring5.aop.User.add(..))")
    public void afterReturning(){
        System.out.println("afterReturning...");
    }
    @AfterThrowing(value="execution(* com.atguigu.spring5.aop.User.add(..))")
    public void afterThrowing(){
        System.out.println("afterThrowing...");
    }
    @Around(value="execution(* com.atguigu.spring5.aop.User.add(..))")
    //表示会在add之前和之后都会执行
    public void around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
        System.out.println("环绕之前");
        //被增强的方法调用
        proceedingJoinPoint.proceed();

        System.out.println("环绕之后");
    }
}

测试：依旧用的那个测试类

结果：

image-20221005152216628
注意⚠ \textcolor{yellow}{注意⚠} 注意⚠

after和Returning的区别

after表示在方法执行之后执行（最终通知）无论是否有异常都会执行

afterReturning表示在方法返回结果之后执行（后置/返回通知），一旦发生异常就不会执行

AfterThrowing

异常通知：只有在发生异常的时候执行

测试：

image-20221005152815861

发现：如果有异常：则执行顺序如上，但是afterReturing不会执行

1. 公共切入点进行抽取
public class UserProxy {
    //相同的切入点进行抽取
    @Pointcut(value="execution(* com.atguigu.spring5.aop.User.add(..))")
    public void pointdemo(){
        
    }
    //前置通知
    //@Before表示作为前置通知
    @Before(value="pointdemo()")
    public void before(){
        System.out.println("before...");
    }
}
2. 多个增强类对同一个方法进行增强

设置增强类优先级

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

4.4.3 AOP操作（AspctJ配置文件)

  1. 创建增强类和被增强类
  2. 在spring的配置文件中创建两个类的对象
  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: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 id="book" class="com.atguigu.spring5.aopxml.Book"></bean>
    <bean id="bookProxy" class="com.atguigu.spring5.aopxml.BookProxy"></bean>
    <!--配置aop的增强-->
    <aop:config>
        <!--配置切入点-->
        <aop:pointcut id="p" expression="execution(* com.atguigu.spring5.aopxml.Book.buy(..))"/>
        <!--配置切面-->
        <aop:aspect ref="bookProxy">
            <!--配置你的增强作用在具体的方法上-->
            <aop:before method="before" pointcut-ref="p"/><!--将before方法作用到buy方法上面-->
        </aop:aspect>
    </aop:config>
</beans>

public class Book {
    public  void buy(){
        System.out.println("buy............");
    }
}

public class BookProxy {
    public void before(){
        System.out.println("before看.........");
    }
}

4.4.4 AOP操作(全注解模式)

  1. 创建配置类，不需要创建xml配置对象
@Configuration
@ComponentScan(basePackages = {"com.atguigu"})//开启组件扫描
@EnableAspectJAutoProxy(proxyTargetClass = true)//相当于配置文件中的开启Aspect代理对象<aop:aspectj-autoproxy></aop:aspectj-autoproxy>
public class ConfigAop { 
}

上面的代码想到于 基于AspctJ注解的配置文件中的👇

<!--开启注解/组件扫描-->
<context:component-scan base-package="com.atguigu.spring5.aop"></context:component-scan>
<!--开启Aspect生成代理对象-->
<aop:aspectj-autoproxy></aop:aspectj-autoproxy>

下集更精彩…

预告 JdbcTemplate框架

笙箫语陌
关注
专栏目录
.NET中的AOP介绍
Man_Humble
12-03 3318
.NET中的AOP
SpringAOP介绍1
10-06
【Spring AOP介绍1】 Spring AOP，全称为Spring面向切面编程，是Spring框架的重要组成部分，它提供了一种在不修改源代码的情况下，对现有代码进行增强的技术，以实现程序功能的统一控制。AOP的主要目的是降低业务...
Spring的AOP介绍
bankser的博客
04-14 6262
文章目录前言一、AOP是什么？二、 AOP 的作用及其优势三、AOP 的底层实现四、AOP 的动态代理技术4.1、JDK 的动态代理4.2、cglib 的动态代理五、AOP 相关概念六、AOP 开发明确的事项1)需要编写的内容2）AOP 技术实现的内容3）AOP 底层使用哪种代理方式七、知识要点总结 前言 在正式学习这个内容之前，我们一定要对这个东西有一个清楚的认知，不然就会学的很迷茫。 一、AOP是什么？ AOP 为 Aspect Oriented Programming 的缩写，意思为面向切面编程，
Java的AOP介绍
热门推荐
liaoxuewu的博客
04-22 1万+
1.概念 AOP是Aspect Oriented Programming的缩写，意思是面向方面编程，与OOP(Object Oriented Programming)面向对象编程对等，都是一种编程思想。从OOP角度分析，我们关注业务的处理逻辑，是属于纵向的行为，从AOP角度分析，我们关注对象行为发生时的问题，是属于横向的行为。AOP有以下概念术语： Aspect（切面）：一个关注点的模块化，这个关注点可能会横切多个对象。事务管理是J2EE应用中一个关于横切关注点的很好的例子。在Spring AOP中，切面可
AOP介绍和使用
u012919352的博客
03-08 265
关注点分离：不同的问题交给不同的部分去解决 AOP的三种织入方式 代理模式：接口+真实实现类+代理类
SpringAOP介绍
IT修真院：初学者转行到互联网的聚集地
05-25 648
这里是修真院后端小课堂，每篇分享文从 【背景介绍】【知识剖析】【常见问题】【解决方案】【编码实战】【扩展思考】【更多讨论】【参考文献】 八个方面深度解析后端知识/技能，本篇分享的是： 【SpringAOP介绍 】 1.背景介绍、 我们在任务中会接触到Spring，而Spring最关键的两处就是IOC和AOP；今天我们不看IOC，只讲AOP。 2.知识剖析 什么是AOP？ 面向切...
003 AOP介绍
m0_46695127的博客
06-18 572
003 AOP介绍
aop介绍
weixin_57763462的博客
01-24 995
毫无疑问，利用AOP技术，我们可以分离出系统的核心关注点和横切关注点，从横向的角度，截取业务管理行为的内部消息，以达到织入权限管理逻辑的目 的。对于核心关注点而言，通常来说，实现这些关注点的模块是 相互独立的，他们分别完成了系统需要的商业逻辑，这些逻辑与具体的业务需求有关。例如一个复杂的系统，它由许多关注点组合实现，如业务逻辑、性能，数据存储、日志和调度信息、授权、安全、线程、错误检查等，还有开发过程中的关注点，如易懂、易维护、易追查、易扩展等，图2.1演示了由不同模块实现的一批关注点组成一个系统。
spring AOP介绍
a18792721831的博客
02-19 339
Spring AOP介绍1.什么是AOP2.AOP框架3.AOP术语 1.什么是AOP Aspect-Oriented Programming:面向切面编程。 面向过程编程：C语言，适合算法等； 面向对象编程：绝大数编程语言，抽象，封装； 面向切面编程：大型，超大型企业级应用，封装业务，逻辑等； AOP的全称是Aspect-Oriented Programming,面向切面编程。 面向切面编程是对...
AOP介绍及注解代码实现
java知识整理
10-05 1042
文章目录一、AOP概念二、AOP底层原理三、JDK动态代理四、AOP相关术语五、AOP操作准备 一、AOP概念 1、什么是AOP （1）面向切面编程（Aspect Oriented Programming），利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。 （2）通俗描述：不通过修改源代码的方式，在主干功能里面添加新功能。 （3）如下图，登录例子：如果想要添加一个权限判断功能。 以前是要修改源代码的，而现在可以写一个模块，然后横切
SpringAOP介绍及源码分析
03-02
那么面向切面编程AOP（Aspect-OrientedProgramming）则可以对系统需求进行很好的模软件开发经历了从汇编语言到高级语言和从过程化编程到面向对象编程；前者是为了提高开发效率，而后者则使用了归纳法，把具有共性的...
Spring AOP介绍及源码分析
03-24
**Spring AOP介绍** Spring AOP（Aspect Oriented Programming，面向切面编程）是Spring框架的一个重要组成部分，它提供了一种在程序运行期间通过代理机制动态地将关注点（如日志、事务管理等）与业务逻辑分离的...
【JAVA开源】基于Vue和SpringBoot的高校学科竞赛平台
杨荧的CSDN博客
10-10 1442
教师功能有个人中心，题目类型管理，竞赛题库管理，竞赛类型管理，竞赛信息管理，报名信息管理，竞赛评分管理，参赛名单管理，晋级名单管理，获奖名单管理，竞赛总结管理，报销清单管理，成绩申诉管理，参赛信息管理，参赛信息管理，往年成绩管理，获奖情况管理。
Puppeteer自动化：使用JavaScript定制PDF下载
ip16yun的博客
10-08 914
Puppeteer 是一个强大的Node.js库，提供了对无头Chrome或Chromium的控制，可以用于生成网页快照、抓取数据、自动化测试等任务。其中，生成PDF文件是一个常见的需求，本文将通过使用Puppeteer展示如何自动化生成定制的PDF，并使用代理IP、设置user-agent、cookie等技术来增强自动化过程的灵活性与稳定性。为了更好地理解如何定制Puppeteer生成的PDF文件，我们提供一个生成A4纸张格式的网页PDF的实例。用户可以根据需求自定义输出的PDF格式或内容。
Netty 相比原生IO模型的优势
lssffy的博客
10-09 654
Java提供了多种I/O模型，每种模型都有其适用的场景和特点，随着网络应用需求的变化，I/O模型也在不断发展。阻塞I/O（BIO，Blocking I/O）传统的I/O模型，使用简单，但每次I/O操作都会阻塞线程。每个请求需要独立的线程来处理，这在并发请求较少时问题不大，但在高并发情况下，线程资源将成为瓶颈。非阻塞I/O（NIO，Non-Blocking I/O）引入了多路复用技术，一个线程可以处理多个连接，避免了BIO中每个连接占用一个线程的问题。通过Selector。
JavaSE——认识异常
最新发布
wx2023_10_15的博客
10-12 941
本文主要是正在学习异常的总结，主要讲了异常的概念、体系结构、分类、处理以及捕获，还有自定义异常类
springboot 用request.setAttribute 传值到控制层
qq56477643的博客
10-09 598
【代码】springboot 用request.setAttribute 传值到控制层。
spring aop 介绍一下
06-28
Spring AOP（Aspect-Oriented Programming，面向切面编程）是Spring框架中的一个重要特性，它提供了一种声明式的方式来进行系统级别的横切关注点（如日志、事务管理、安全检查等）的处理，而无需在每个具体业务模块...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值