aop学习笔记之代理模式（三）

最新推荐文章于 2024-07-22 16:55:54 发布
最新推荐文章于 2024-07-22 16:55:54 发布
阅读量346 收藏
点赞数 3
分类专栏： aop 文章标签： 代理模式 Aop spring代理 SpringAop
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zyb2017/article/details/79528343
版权

1 代理概念

织入的时机分三种：
1.编译期织入（Aspect）
2.类加载时织入（AspectJ 5+）
3.运行时织入（Spring AOP）

那如何实现运行时织入呢？通过代理。
这里写图片描述

上面这张图描述了调用方、代理对象、目标对象之间的关系，目标对象将自己托管给代理对象。比如当调用方发起请求执行目标对象中的方法，代理对象会响应并决定自己在其之前或之后执行相关动作，而原本目标对象该执行的方法代理对象并不去管它，依然抛给目标对象自己执行。代理对象只处理目标对象方法中没有的动作。

2 代理模式

代理又分为哪些呢？
这里写图片描述
这里列出了两种动态代理的代表，Aop在创建代理时就是从他们之中选择。

3 静态代理

接下来我们用代码模拟一下静态代理的实现

这里写图片描述
通过我上面画的这张图我们可以看到，Proxy和RealSubject都继承了一个叫做Subject的接口，当请求从Client发起时，会被代理对象进行处理，执行一些额外的方法，然后又委托目标对象执行目标对象的方法

我们按照这个思路来写代码

3.1 Subject

首先我们创建一个接口叫做Subject，里面只有一个叫做request的方法

package com.example.proxy.pattern;

/**
 * Subject class
 *
 * @author TransientBa
 * @date 2018/3/10
 */
public interface Subject {
    void request();
}

3.2 RealSubject

创建目标对象继承上面的Subject接口，重写一下request方法

package com.example.proxy.pattern;

/**
 * RealSubject class
 *
 * @author TransientBa
 * @date 2018/3/10
 */
public class RealSubject implements Subject{
    @Override
    public void request() {
        System.out.println("real subject execute request");
    }
}

3.3 Proxy

写完了目标对象接下来就是代理对象了，同样继承Subject接口

package com.example.proxy.pattern;

/**
 * Proxy class
 *
 * aspect
 * @author TransientBa
 * @date 2018/3/10
 */
public class Proxy implements Subject{
    /**私有一个目标对象的属性**/
    private RealSubject realSubject;

    public Proxy(RealSubject realSubject){
        this.realSubject = realSubject;
    }

    /**
     * 静态代理 通过重写request 将目标方法委托给目标对象realSubject执行，自己执行其他额外的操作
     */
    @Override
    public void request() {
        System.out.println("before do something");
        try{
            realSubject.request();
        }catch (Exception e){
            System.out.println("exception:" + e.getMessage());
            /** 代理对象不会真正改变方法  还是要把异常抛出来**/
            throw e;
        }finally {
            System.out.println("after do something");
        }
    }
}

3.4 Client测试

接下来我们测试一下整个流程

package com.example.proxy.pattern;

/**
 * Client class
 *
 * @author TransientBa
 * @date 2018/3/10
 */
public class Client {
    /**
     * 静态代理
     * 缺点:
     * 代理对象要对目标对象中的方法进行委托  代理的逻辑越多 重复的逻辑越多
     * @param args
     */
    public static void main(String[] args) {
        /**客户端通过接口引用目标对象  引入的实现类是代理的实现类  其本身又委托给了目标对象去执行  自己只执行边缘的操作**/
        Subject subject = new Proxy(new RealSubject());
        subject.request();
    }

运行结果：
这里写图片描述

这样我们就完成一个简单的静态代理，那这种代理模式有哪些问题呢？我们回到代理类Proxy中，每当我们在Subject中新增一个方法，我们都需要手动的在Proxy中将新增的方法重写。这样实现起来很麻烦，我们可不可以用一种更通用的办法去解决呢？

4 jdk动态代理

为了解决上面提到的问题，我们重写代理类

4.1 JdkProxySubject

抛弃了原来的Proxy类，重写JdkProxySubject去替代它，在jdk动态代理中需要继承InvocationHandler接口，重写invoke方法

package com.example.proxy.dynamic;

import com.example.proxy.pattern.RealSubject;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;

/**
 * JdkProxySubject class
 *
 * aspect
 * @author TransientBa
 * @date 2018/3/10
 */
public class JdkProxySubject implements InvocationHandler{
    private RealSubject realSubject;

    public JdkProxySubject(RealSubject realSubject) {
        this.realSubject = realSubject;
    }

    /***
     * 通过method 利用反射去动态的代理目标类方法  无需像静态代理一样去写每一个要代理的方法
     * @param proxy
     * @param method
     * @param args
     * @return
     * @throws Throwable
     */
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("before do something");
        Object result = null;
        try{
            result = method.invoke(realSubject,args);
        }catch (Exception e){
            //依然不能对异常进行捕获 还是要抛出去
            System.out.println("exception:"+e.getMessage());
            throw e;
        }finally {
            System.out.println("after do something");
        }
        return result;
    }
}

4.2 Client测试

在新建一个Client测试类

package com.example.proxy.dynamic;


import com.example.proxy.pattern.RealSubject;
import com.example.proxy.pattern.Subject;

import java.lang.reflect.Proxy;


/**
 * Client class
 *
 * @author TransientBa
 * @date 2018/3/10
 */
public class Client {
    /**
     * 基于接口的Jdk动态代理
     * 优点：
     * 当Subject中新增一个方法时，静态代理必须要重新实现新增的方法，而动态代理则根据反射无需再次添加
     * @param args
     */
    public static void main(String[] args) {
        //通过设置系统变量  把生成的字节码保存下来
        System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles","true");

        /**
         * newProxyInstance传入三个参数
         * ClassLoader：当前类的类加载器
         * Subject.Class：目标接口
         * JdkProxySubject：InvocationHandler以及创建时引用的目标对象RealSubject
         *
         * */
        Subject subject = (Subject) Proxy.newProxyInstance(Client.class.getClassLoader(),
                new Class[]{Subject.class},
                new JdkProxySubject(new RealSubject()));

        subject.request();
    }
}

运行结果如下：
这里写图片描述
为了验证jdk动态代理是否解决了静态代理的问题，我们在添加一个方法dynamicRequest
在Subject中添加

 void dynamicRequest();

在RealSubject中添加

@Override
    public void dynamicRequest() {
        System.out.println("real subject execute dynamicRequest");
    }

回到client中，调用刚才添加的方法

    subject.request();
    System.out.println();
    subject.dynamicRequest();

运行结果如下：
这里写图片描述

可以看到通过反射动态的代理了目标接口的方法，无需像静态代理一样重写方法。
为了弄清楚在这个过程中代理类到底做了什么，我们在Client中添加这样一句话

 //通过设置系统变量  把生成的字节码保存下来
        System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles","true");

正常运行程序后会在项目的目录下找到
这里写图片描述
打开该文件后可以看到

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//

package com.sun.proxy;

import com.example.proxy.pattern.Subject;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.lang.reflect.UndeclaredThrowableException;

public final class $Proxy0 extends Proxy implements Subject {
    private static Method m1;
    private static Method m2;
    private static Method m3;
    private static Method m4;
    private static Method m0;

    public $Proxy0(InvocationHandler var1) throws  {
        super(var1);
    }

    public final boolean equals(Object var1) throws  {
        try {
            return ((Boolean)super.h.invoke(this, m1, new Object[]{var1})).booleanValue();
        } catch (RuntimeException | Error var3) {
            throw var3;
        } catch (Throwable var4) {
            throw new UndeclaredThrowableException(var4);
        }
    }

    public final String toString() throws  {
        try {
            return (String)super.h.invoke(this, m2, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    public final void dynamicRequest() throws  {
        try {
            super.h.invoke(this, m3, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    public final void request() throws  {
        try {
            super.h.invoke(this, m4, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    public final int hashCode() throws  {
        try {
            return ((Integer)super.h.invoke(this, m0, (Object[])null)).intValue();
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    static {
        try {
            m1 = Class.forName("java.lang.Object").getMethod("equals", new Class[]{Class.forName("java.lang.Object")});
            m2 = Class.forName("java.lang.Object").getMethod("toString", new Class[0]);
            m3 = Class.forName("com.example.proxy.pattern.Subject").getMethod("dynamicRequest", new Class[0]);
            m4 = Class.forName("com.example.proxy.pattern.Subject").getMethod("request", new Class[0]);
            m0 = Class.forName("java.lang.Object").getMethod("hashCode", new Class[0]);
        } catch (NoSuchMethodException var2) {
            throw new NoSuchMethodError(var2.getMessage());
        } catch (ClassNotFoundException var3) {
            throw new NoClassDefFoundError(var3.getMessage());
        }
    }
}

我们可以看到该类中编译了5个方法
这里写图片描述
其中dynamicRequest和request是我们要代理的方法

5 Cglib动态代理

上面的jdk动态代理基于接口，而Cglib基于继承

5.1 CglibProxySubject

不同的是jdk动态代理继承了InvocationHandler接口 ，而Cglib继承了MethodInterceptor

package com.example.proxy.cglib;


import org.springframework.cglib.proxy.MethodInterceptor;
import org.springframework.cglib.proxy.MethodProxy;

import java.lang.reflect.Method;

/**
 * CglibProxySubject class
 *
 * @author TransientBa
 * @date 2018/3/10
 */
public class CglibProxySubject implements MethodInterceptor {
    /**
     * 同样类似于jdkProxy ,调用methodProxy.invoke传入要反射的对象和参数
     */
    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        System.out.println("before in chlib");
        Object result = null;
        try{
            result = methodProxy.invokeSuper(o,objects);
        }catch (Exception e){
            System.out.println("get exception:" + e.getMessage());
            throw e;
        }finally {
            System.out.println("after in cglib");
        }
        return result;
    }
}

5.2 Client测试

package com.example.proxy.cglib;

import com.example.proxy.pattern.RealSubject;
import com.example.proxy.pattern.Subject;
import org.springframework.aop.framework.DefaultAopProxyFactory;
import org.springframework.cglib.proxy.Enhancer;

/**
 * Client class
 *
 * @author TransientBa
 * @date 2018/3/10
 */
public class Client {
    /**
     * 基于继承的cglib动态代理
     * 优点：
     * 同jdkProxy一样为动态代理，但其基于继承所以无接口的类同样可以进行代理
     * @param args
     */
    public static void main(String[] args) {
        Enhancer enhancer = new Enhancer();
        //传入目标对象
        enhancer.setSuperclass(RealSubject.class);
        enhancer.setCallback(new CglibProxySubject());
        Subject subject = (Subject) enhancer.create();
        subject.dynamicRequest();
    }
}

运行结果如下：
这里写图片描述

6 Aop代理的选择

上面我们了解了Aop代理的模式，那Spring在创建Aop代理时是如何选择应用哪一种模式的呢？
首先我们要了解Aop在创建代理时都调用了哪些类的哪些方法
这里写图片描述

我们可以看到在最后DefaultAopProxyFactory中调用了createAopProxy方法

  public AopProxy createAopProxy(AdvisedSupport config) throws AopConfigException {
        if(!config.isOptimize() && !config.isProxyTargetClass() && !this.hasNoUserSuppliedProxyInterfaces(config)) {
            return new JdkDynamicAopProxy(config);
        } else {
            Class<?> targetClass = config.getTargetClass();
            if(targetClass == null) {
                throw new AopConfigException("TargetSource cannot determine target class: Either an interface or a target is required for proxy creation.");
            } else {
                return (AopProxy)(!targetClass.isInterface() && !Proxy.isProxyClass(targetClass)?new ObjenesisCglibAopProxy(config):new JdkDynamicAopProxy(config));
            }
        }
    }

其中 

return (AopProxy)(!targetClass.isInterface() && !Proxy.isProxyClass(targetClass)?new ObjenesisCglibAopProxy(config):new JdkDynamicAopProxy(config));

反过来说，当代理对象原本就是一个接口时，或本身就是jdk代理，spring选择Jdk代理，不然选择Cglib
当if(!config.isOptimize() && !config.isProxyTargetClass() && !this.hasNoUserSuppliedProxyInterfaces(config))都不满足时也选择应用Jdk动态代理

6.1 强制使用Cglib代理

当proxyTargetClass为True时，Spring强制使用Cglib代理，例如
这里写图片描述

7 总结

  1. JDK动态代理方法只能针对有接口的类的接口方法进行动态代理 因接口中不允许private方法 所以同样不能对private方法进行代理
  2. cglib基于继承来实现代理，无法对static、final这种类进行代理，也无法对private、static方法进行代理
  3. 目标对象实现了接口，则采用JDK代理
  4. 目标对象没有实现接口，采用Cglib代理
  5. 目标对象实现了接口，但强制使用Cglib代理，也是采用Cglib代理
TransientBa
关注
  • 3
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Mule4 踩坑记： dynamic http request url
sinat_35627460的博客
07-18 595
其实是很基础的用法，不过网上对这一点提的比较少，这里简单记录一下   首先 mule4 的 message structure整体迭代过一次：   我们希望能通过 http listener 传入参数，并在之后的request中使用这个参数，通常都是#[attribute.query.{para}]的方式来传参，但是今天尝试在http request 的url 里面使用这个参数报错： ...
java中dynamic_dynamic
weixin_36258891的博客
02-25 1979
dynamic介绍像动态语言一样玩的Java安装教程com.gitee.feiznsdynamic2.4-RELEASE介绍像动态语言一样玩的Java在java中实体类几乎在任何地方都会出现。在web开发中，对于一个请求。你可能会声明一个处理请参数的实体对象，接着声明一个业务层的实体对象，在最后你还需要声明 ORM 相关的对象。而上诉的流程又可以从数据开始出发，再到真正响应的实体的对象的路上，你可...
Dynamic Web Project 的学习笔记
09-28 1万+
文章框架： 1.Dynamic  Web Project 概念     2.eclipse 中的动态Web 项目与 Myeclipse 中的web项目有何区别   3.动态的运行原理及目录结构---是否都涉及到由类生成表的技术（如果没的话，也应该 把这个搞清楚） 4,如何
从事务问题分析SpringAop
weixin_34392843的博客
08-26 83
前些月在项目中碰到个关于事务的问题，今天抽空来整理了一波，简单分享下。情况描述：大家在项目中应该都会碰到初始化某些数据的问题，有些会采用没有数据则插入的方式。这个时候大家可能会很自然的在select方法中直接this.insert方法，咋一看由于默认的事务传播级别是PROPAGATION_REQUIRED(如果当前存在事务，则加入该事务；如果当前没有事务，则创建一个新的事务)，没有开启事务的lis...
公开课：AOP
qq_28764557的博客
09-01 180
aop： 在运行的时候织入并且在初始化的时候织入 1.aop的应用 打开spring的官网： https://spring.io/projects/spring-framework#overview 术语的中英文介绍 中文： ...
设计模式之代理模式分析使用
热门推荐
张彦峰的博客
05-21 164万+
代理模式原理和使用分析总结
【Java学习笔记】代理模式详解
Xcong_Zhu的博客
03-30 703
前面已经提到了，动态代理就是【在内存】中动态生成【字节码代理类】的技术。（虽然不需要开发者书写，但是在内存层面依然存在该代理对象】优点减少了代理类的数量并且解决了代码复用的问题。
springboot AOP学习笔记之代理模式简单理解 静态代理
xyccz的博客
03-14 1019
springboot的AOP实现需要借助代理来实现的，但我们为什么需要AOP呢？ 我来举一个例子：假定第三方提供给我们一套完整的登录代码，这时候我们需要在登录功能上增加一个日志功能，用来记录登陆的时间等信息，但这时候因为第三方的规定，我们不能更改原来的代码，所以在此基础上我们要增加日志功能，可以依赖AOP来实现。 图片：https://blog.csdn.net/qq_34515002/artic...
spring aop 学习笔记
05-27
本学习笔记将深入探讨Spring AOP的核心概念、工作原理以及实际应用。 1. **核心概念** - **切面（Aspect）**：切面是关注点的模块化，包含业务逻辑之外的横切关注点，如日志、事务管理。 - **连接点（Join Point...
SpringAop学习笔记以及实现Demo
06-17
**Spring AOP 学习笔记及实现Demo** Spring AOP（Aspect Oriented Programming，面向切面编程）是Spring框架中的一个重要组成部分，它提供了一种在不修改源代码的情况下，对程序进行功能增强的技术。AOP的主要目的...
SpringBoot-事务&AOP-黑马程序员学习笔记
05-21
在Spring中，AOP通过代理模式实现，分为JDK动态代理和CGLIB代理。 1. **切面（Aspect）**：定义了关注点的模块化，包含通知（Advice）和切点（Pointcut）。 2. **通知（Advice）**：在特定连接点执行的代码，如前置...
设计模式：设计模式学习笔记
02-08
例如，Spring AOP（面向切面编程）利用代理模式实现切面逻辑，JDBC模板使用模板方法模式简化数据库操作，而Collections框架中的迭代器则是迭代器模式的典型应用。 总结，设计模式是软件开发中的宝贵经验总结，通过...
Javaq备战秋招面试题-重点学习笔记.zip
09-03
这份"Javaq备战秋招面试题-重点学习笔记.zip"文件包含了面试必备的Java知识点，帮助你全面复习并提升技能。 1. **基础语法**：理解并掌握Java的基础语法是所有Java程序员的起点，包括变量、数据类型（基本类型和...
Java二十三种设计模式-代理模式模式（8/23）
探索IT世界
07-21 782
代理模式是一种结构型设计模式，其核心思想是为一个对象提供一种代理，以控制对这个对象的访问。代理模式可以在不修改目标对象的基础上，通过引入一个代理层来间接操作实际对象，从而实现对目标对象的访问控制、延迟初始化、日志记录、权限校验等功能。定义：定义了真实对象和代理对象的共同接口，这样代理可以代替真实对象被使用。角色：充当代理和真实对象的契约。代理模式提供了一种灵活的方式来控制对对象的访问，同时允许在不修改对象自身的情况下添加额外的职责。
【二叉树】【动态规划】1、斐波那契数+2、零钱兑换
weixin_50512050的博客
07-18 1104
1、遍历：在遍历的过程中就能够解决问题，只需要递归函数的参数即可。2、子树：只有在遍历完成之后才能解决问题，还需要递归函数的返回值。（需要在后序位置写代码）动态规划：子树 核心思想是穷举求最值明确状态，明确选择，定义dp数组回溯算法：树枝DFS算法：节点。
java设计模式：03-07-代理模式
Mr_Air_Boy的博客
07-22 915
代理模式（Proxy Pattern）是一种结构型设计模式，它为其他对象提供一种代理以控制对这个对象的访问。代理模式通过创建一个代理对象来控制对实际对象的访问，通常用于在访问实际对象时增加额外的功能或进行额外的处理。
力扣213题详解：打家劫舍 II 的动态规划解决方案与多种解法解析
10年数据\经营分析经验，现任大厂数据分析负责人
07-19 257
本文详细解读了力扣第213题“打家劫舍 II”，通过使用动态规划高效地解决了这一问题，并提供了详细的解释和模拟面试问答。希望读者通过本文的学习，能够在力扣刷题的过程中更加得心应手。
【动态规划】打家劫舍
weixin_50512050的博客
07-21 657
【动态规划】打家劫舍
设计模式-代理模式
最新发布
qq_25699299的博客
07-22 204
代理模式是常用的设计模式之一，其目的是为其他对象提供一个代理以控制对这个对象的访问。在C#中，代理模式可以通过使用委托和事件来实现。
Spring框架详解：轻量级与设计模式
- 代理设计模式：Spring的AOP（面向切面编程）就是基于代理模式实现，可以方便地进行横切关注点的处理，如日志、事务管理等。 - 模板方法设计模式：Spring的Template类（如JdbcTemplate、RestTemplate）使用此模式，...

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

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值