spring框架 - AOP

最新推荐文章于 2024-10-06 15:20:14 发布
最新推荐文章于 2024-10-06 15:20:14 发布
阅读量225 收藏
点赞数
分类专栏： Java高级框架 文章标签： aop 代理模式
原创不易，仅限学习参考，转载请注明出处！更多资讯请移步【公众号：Java那些事儿】
本文链接：https://blog.csdn.net/qq_40414738/article/details/83592646
版权

spring - AOP

  •     一、代理模式

        基本原则

            1. 代理类与委托类具有相似的行为（共同）
            2. 代理类增强委托类的行为

        静态代理

            代理角色固定
            代理类和委托类实现相同的接口
                父接口
                代理类
                委托类
                单元测试

详解参考：静态代理之结婚与婚庆公司案例

 

动态代理

通过反射机制在程序运行期动态的为目标对象创建代理对象

  JDK实现
                实现InvocationHandler接口，重写invoke()
                获取目标类
                程序运行期间动态的创建代理角色
                    获取代理对象
                        1.类加载器
                        2.目标类实现的接口class
                        3.当前类

package com.lwx.jdk;

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

/**
 * By:刘文旭 ~ https://blog.csdn.net/qq_40414738
 * Date：2018/10/30 21:50 .
 */
public class JdkHandler implements InvocationHandler {

    // 目标类
    private Object you;

    public JdkHandler(Object you) {
        this.you = you;
    }

    /**
     * 程序运行期间动态创建代理角色
     * @return
     */
    public Object getProxy() {

        /**
         * 获取代理对象
         * 1.类加载器
         * 2.目标类实现的接口class
         * 3.当前类
         */
        return Proxy.newProxyInstance(this.getClass().getClassLoader(),you.getClass().getInterfaces(),this);
    }

    public void before() {
        System.out.println("正在紧张布置婚礼现场。。。");
        System.out.println("放炮。。。开始~");
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        before();
        // 执行真正的target方法
        Object invoke = method.invoke(you, args);
        after();
        return invoke;
    }

    public void after() {
        System.out.println("婚礼结束。。。开启人生第二阶段");
    }
}

package com.lwx.jdk;

import com.lwx.You;
import org.junit.Test;

import static org.junit.Assert.*;

/**
 * By:刘文旭 ~ https://blog.csdn.net/qq_40414738
 * Date：2018/10/30 21:59 .
 */
public class JdkHandlerTest {

    @Test
    public void invoke() {
        // 委托类
        You you = new You();
        // 创建代理类
        JdkHandler jdkHandler = new JdkHandler(you);
        // 代理对象
        Object proxy = jdkHandler.getProxy();
        // 执行方法
        try {
            jdkHandler.invoke(proxy, You.class.getMethod("toMarry"), null);
        } catch (Throwable throwable) {
            throwable.printStackTrace();
        }
    }
}


            cglib实现

          code generator library ，操作字节码。与jdk 提供的代理区别，Proxy：委托类必须有接口，制作过程比较快，执行慢；cglib：委托类可以没有接口，继承的思维来实现相似性，制作代理过程比较慢，执行快。主要解决没有接口类的代理实现。


                实现MethodInterceptor接口，重写intercept()
                获取目标类
                程序运行期间动态的创建代理角色
                    获取代理对象
                        1.创建Enhancer对象
                        2.设置父类
                        3.设置回调

package com.lwx.cglib;

import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;

import java.lang.reflect.Method;

/**
 * By:刘文旭 ~ https://blog.csdn.net/qq_40414738
 * Date：2018/10/30 23:39 .
 */
public class CglibHandler implements MethodInterceptor {

    private Object you;

    public CglibHandler(Object you) {
        this.you = you;
    }

    /**
     * 运行期间创建代理对象
     */
    public Object getProxy() {
        Enhancer enhancer = new Enhancer();
        // 设置父类
        enhancer.setSuperclass(you.getClass());
        // 设置回调
        enhancer.setCallback(this);
        return enhancer.create();
    }

    public void before() {
        System.out.println("正在紧张布置婚礼现场。。。");
        System.out.println("放炮。。。开始~");
    }

    public void after() {
        System.out.println("婚礼结束。。。开启人生第二阶段");
    }

    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
       before();

       Object obj = method.invoke(you, objects);

       after();
        return obj;
    }
}

package com.lwx.cglib;

import com.lwx.You;
import org.junit.Test;

import static org.junit.Assert.*;

/**
 * By:刘文旭 ~ https://blog.csdn.net/qq_40414738
 * Date：2018/10/30 23:50 .
 */
public class CglibHandlerTest {

    @Test
    public void intercept() {
        // 委托类
        You you = new You();
        // 代理类
        CglibHandler cglibHandler = new CglibHandler(you);
        // 代理对象
        You proxy = (You) cglibHandler.getProxy();
        proxy.toMarry();
    }
}


            两者区别
                JDK：Proxy：委托类必须有接口，制作过程比较快，执行慢
                    原理是实现接口
                cglib：委托类可以没有接口，继承的思维来实现相似性，制作代理过程比较慢，执行快
                    原理是继承

  •     二、日志处理带来的问题

  •     三、理解AOP

        what
             Aspect Oriented Programing 面向切面编程，相比较oop 面向对象编程来说，Aop 关注的不再是程序代码中某个类，某些方法，而aop 考虑的更多的是一种面到面的切入即层与层之间的一种切入，所以称之为切面。


        can
            用于日志记录，性能统计，安全控制,事务处理等方面，实现公共功能性的重复使用


        advantage
            1. 降低模块与模块之间的耦合度，提高业务代码的聚合度。（高内聚低耦合）
            2. 提高了代码的复用性。
            3. 提高系统的扩展性。

  •     四、AOP基本概念

        1.JoinPoint（连接点）
            被拦截到的每个点，spring 中指被拦截到的每一个方法

        2.PointCut（切入点）
            对连接点进行拦截的定义

        3.Advice（通知）
            拦截到每一个连接点即（每一个方法）后所要做的操作
            i. 前置通知（前置增强） --before() 执行方法前通知
            ii.返回通知（返回增强）--afterReturn 方法正常结束返回后的通知
            iii.异常抛出通知（异常抛出增强）--afetrThrow()
            iv.最终通知—after 无论方法是否发生异常，均会执行该通知。
            v.环绕通知—around 包围一个连接点（join point）的通知，如方法调用。

         在环绕通知里面,必须执行目标方法

 

注意:

        虽然环绕通知包含了另外三种,但还是要依据业务逻辑来选择,这样有利于代码的编程量
        并且环绕通知最好不要和另外三种混用,并且并许执行目标方法proceed().

        4.Aspect（切面）
            切入点与通知的结合

        5.Target（目标对象）

        6.Weave（织入）
            将切面应用到目标对象并生成代理对象的这个过程即为织入。

        7.Introduction（引入）
            在不修改原有应用程序代码的情况下，在程序运行期为类动态添加方法或者字段的过程称为引入

  •     五、使用AOP解决日志处理问题

        注解方式

            1.Jar包坐标引入
            2.xml文件配置
                添加命名空间aop
                配置aop代理 <aop:aspectj-autoproxy/>
            3.业务方法
                aop实现类
                切入点

aop实现类

package com.lwx.aop;

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

/**
 * By:刘文旭 ~ https://blog.csdn.net/qq_40414738
 * Date：2018/10/31 21:55 .
 *
 * 声明切面组件
 */
@Component
@Aspect
public class LogCut {
    /**
     * 连接点
     * 切入点
     * 通知
     */
    @Pointcut("execution(* com.lwx.service..*.*(..))")
    public void cut() {

    }

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

    @AfterReturning(value = "cut()")
    public void afterRrturning() {
        System.out.println("afterReturning ...");
    }

    @After(value = "cut()")
    public void after() {
        System.out.println("after ...");
    }

    @AfterThrowing(value = "cut()",throwing = "e")
    public void afterThrowing(Exception e) {
        System.out.println("afterThrowing ..." + e);
    }

    /**
     * 声明环绕通知并将通知应用到切入点上
     * 方法执行前后通过环绕通知定义相应处理
     */
    @Around(value = "cut()")
    public Object around(ProceedingJoinPoint pjp) throws Throwable{
        System.out.println("around before ...");
        System.out.println("around afterReturning ...");
        System.out.println(pjp.getTarget() + "---" + pjp.getSignature());
        Object result = pjp.proceed();
        System.out.println("around after ...");
        return result;
    }
}

切入点

package com.lwx.service;

import org.springframework.stereotype.Service;

/**
 * By:刘文旭 ~ https://blog.csdn.net/qq_40414738
 * Date：2018/10/31 22:20 .
 */
@Service
public class UserService {
    public void test() {
        // int i = 1/0;
        System.out.println("测试 LogCut...");
    }
}

           getSignature()：方法签名
           getArgs()：方法的实参
           getTarget()： 目标对象

        xml配置方式

        Aop 匹配方法规则表达式语言

                  切入点表达式

执行任意公共方法execution(public *(..))
执行任意的set 方法execution(* set*(..))
执行com.lwx.service 包下任意类的任意方法execution(* com.lwx.service.*.*(..))
执行所有类的所有方法execution(* *.*(..))
执行com.lwx.service 包以及子包下任意类的任意方法execution(* com.lwx.service..*.*(..))

  •     六、AOP面试常见问题

 

一只蚊子啊
关注
专栏目录
Spring框架-AOP（面向切面编程）
qq_44715376的博客
01-09 1182
Spring AOP（Aspect-Oriented Programming，面向切面编程）是 Spring 框架的一个重要特性。它提供了一种通过横向切割应用程序的方式来解耦和增强代码的能力。AOP 可以在不修改原有业务逻辑的情况下，通过将通用功能模块化并横向应用于多个不同的对象上，实现横切关注点的统一处理。
Spring框架-----AOP编程
qq_48788523的博客
12-23 2161
面向切面编程,知识点多,看完会有一定的帮助
Spring的AOP（1）
weixin_30691871的博客
07-19 63
6.2 Spring的AOP AOP（Aspect Orient Programming），也就是面向切面编程，作为面向对象编程的一种补充。问世的时间并不太长，甚至在国内的翻译还不太统一（有些书翻译成面向方面编程），但它确实极好地补充了面向对象编程的方式。面向对象编程将程序分解成各个层次的对象，而面向切面编程将程序运行过程分解成各个切面。 可以这样理解，面向对象编程是从静态角度考虑程序结构，面向切...
spring的AOP
四海的学习笔记
10-31 232
Aop 面向切面编程    aspect oriented programing aop关注的不再是程序代码中的某个类，某些方法，考虑更多的是一种面到面的切入，即层与层之间的一种切入。 用处： aop主要用于日志记录，性能统计，安全控制，事务处理等方面，实现公共功能性的重复使用。 好处： 1. 降低模块与模块之间的耦合度，提高业务代码的聚合度。 2. 提高代码的复用性。 3.
AOP基本概念
weixin_33834910的博客
01-04 74
动机和基本概念 AOP并不是一种新的技术或者新的思想，早在60年代的程序员用模块化编程的时候就开始了这样程序思想。通过将不同的关注封装在不同的模块中来实现“关注分离的目的。我们的程序中有些（方面）的代码是分离的或者缠结在一起的，这使得这些代码难以理解和维护。当一个关注（concern）（比如 记录日志）被分散在很多模块中的时候（比如...
Spring框架之AOP详解
qq_45515347的博客
09-05 2029
Spring AOP 详解，并实现demo
spring-boot-starter-aop及其使用场景说明
吴声子夜歌的博客
11-21 1万+
如今，AOP（Aspect Oriented Programming）已经不是什么崭新的概念了，在经历了代码生成、动态代理、字节码增强甚至静态编译等不同时代的洗礼之后，Java 平台上的 AOP 方案基本上已经以 SpringAOP 结合 AspectJ 的方式稳固下来（虽然大家依然可以自己通过各种字节码工具偶尔“打造一些轮子”）。 现在 Spring 框架提供的 AOP 方案倡导了一种各取所长的...
SpringAOP学习--SpringAOP简介及原理
热门推荐
u012098021的博客
05-15 6万+
前文对AOP做了介绍，实际项目中，一般不会直接上手手动实现aop，而是使用一些高级封装的aop实现，如SpringAOP。 Spring是一个广泛应用的框架，SpringAOP则是Spring提供的一个标准易用的aop框架，依托Spring的IOC容器，提供了极强的AOP扩展增强能力，对项目开发提供了极大地便利。 前文提到AOP的实现有AspectJ、JDK动态代理、CGLIB动态代理，SpringAOP不是一种新的AOP实现，其底层采用的是JDK/CGLIB动态代理。 JDK动态代理回顾 上一篇简单介绍了
Spring框架----AOP的概念及术语
Java硬件工程师的博客
08-13 2243
1.什么是AOP AOP：全称是 Aspect Oriented Programming 即：面向切面编程 简单的说它就是把我们程序重复的代码抽取出来，在需要执行的时候，使用动态代理的技术，在不修改源码的基础上，对我们的已有方法进行增强。 2.AOP 的作用及优势 作用： 在程序运行期间，不修改源码对已有方法进行增强。 优势： 减少重复代码，提高开发效率，维护方便 3.AOP 的实现方式 使用动态代理技术 4.AOP 的术语及实现细节 1.Joinpoint(连接点):所谓连接点是指那些被拦截到的点。
spring--aop详细介绍及使用
小乌龟
08-19 3537
aop 可以通过预编译方式和运行期动态代理实现在不修改源代码的情况下给程序动态统一添加功能的一种技术，提高代码的灵活性和可扩展性 动态代理实现 主要用途 日志记录，事务处理 例如：转账看做一个事务，包含两个操作，一方通过sql实现账户钱数增加，另一方通过sql实现钱数减少，只要有一方失败，整个事务都失败 使用动态代理可以实现上面转账事务 动态代理 AOP的使用 切入点：要织入方法执行的时机 如何实现在调用addUser()方法的时候，先调用beforeService方法 即怎么实现动态注入？使用配置
Spring框架-AOP和声明式事务
11-13
Spring框架-AOP和声明式事务
Spring5 框架 ---- AOP ---- 代码
09-12
Spring5 框架 ---- AOP ---- 代码 Spring5 框架 ---- AOP ---- 代码 Spring5 框架 ---- AOP ---- 代码 Spring5 框架 ---- AOP ---- 代码 Spring5 框架 ---- AOP ---- 代码 Spring5 框架 ---- AOP ---- 代码 Spring5 ...
spring-aop-5.1.0.RELEASE.jar
03-09
- 以RELEASE.jar结尾的包是spring框架class文件的jar包。 - 以RELEASE-jdoc.jar结尾的包是spring框架API文档的压缩包。 - 以RELEASE-sources.jar结尾的是Spring框架源文件的压缩包。 ### 在libs目录中，有四个...
spring-aop-jar
12-14
"spring-aop-jar"这个主题涉及到Spring框架中的核心组件之一——Spring AOP。这里我们将深入探讨Spring AOP、相关jar文件以及它们在实际开发中的作用。 首先，我们来看一下提供的文件： 1. aopalliance.jar：这是一...
spring-aop-4.2.xsd.zip
05-31
标题中的"spring-aop-4.2.xsd.zip"表明这是一个与Spring框架的AOP（面向切面编程）相关的资源，版本为4.2，并且是XML Schema Definition（XSD）文件的压缩包。XSD文件用于定义XML文档的结构和数据类型，它在Spring...
设计模式-代理模式
ZSS1753936255的博客
10-03 474
总结：发现这里的代理模式和装饰者模式有点相似。装饰者模式，是需要传入对应的被装饰者的对象，状态增量被装饰的功能。而这里的代理模式，我们外部是不知道 具体代理哪一个类的功能，对外部来说不可见的。在上面的代理模式示例代码中，Java程序员不对外开放，外界无法访问，已经被封装到了代理中。代理模式（Proxy）：为其他对象提供一种代理以控制这个对象的访问呢。
LeetCode 1928.规定时间内到达终点的最小花费：动态规划
<font color="Pink">Tisfy的博客</font>
10-03 1067
LeetCode 1928.规定时间内到达终点的最小花费：动态规划 一个国家有 n 个城市，城市编号为 0 到 n - 1 ，题目保证 所有城市 都由双向道路 连接在一起 。道路由二维整数数组 edges 表示，其中 edges[i] = [xi, yi, timei] 表示城市 xi 和 yi 之间有一条双向道路，耗费时间为 timei 分钟。两个城市之间可能会有多条耗费时间不同的道路，但是不会有道路两头连接着同一座城市。 每次经过一个城市时，你需要付通行费。通行费用一个长度为 n 且下标从 0 开始的
Acwing 区间DP & 计数类DP
qq_43060884的博客
10-06 448
还是熟悉的DP~
comsol模拟不同形状晶粒的煤体、岩体、土体的水力压裂、煤层压裂相场本构模型，内含不同尺寸的骨料、晶粒 案例文件众多，包含不
最新发布
10-10
comsol模拟不同形状晶粒的煤体、岩体、土体的水力压裂、煤层压裂相场本构模型，内含不同尺寸的骨料、晶粒。 案例文件众多，包含不同尺寸方形晶粒、圆形晶粒、椭圆形晶粒、微小晶粒等。
深入理解Spring2-AOP：实战教程与核心原理解析
在Spring框架中，AOP作为一项重要特性，允许开发者定义“切面”，这些切面可以封装横切关注点，如日志、事务管理、安全检查等，从而将它们从核心业务逻辑中解耦。AOP的核心概念包括： 1. **切面（Aspect）**：切面...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值