Java代理模式

已于 2023-04-23 05:17:55 修改
阅读量64 收藏
点赞数
分类专栏： 设计模式 文章标签： 代理模式 java
于 2023-04-23 05:14:09 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_53318060/article/details/130302947
版权

静态代理

代理类，代理对象在编译期生成

动态代理

代理类，代理对象在运行时生成
动态代理有JDK和CGLIB两种

public interface SellTickets { void sell(); }
// 火车站
public class TrainStation implements SellTickets{
    public void sell() { System.out.println("火车站卖票"); }
}
// 代售点
// 代理对象和目标对象实现同样的接口
// 代理对象中维护了目标对象的引用
// 代理对象调用相应方法时,实际调用了目标对象的那个方法,只不过可能会在之前或之后做一些处理
public class ProxyPoint implements SellTickets{
    private TrainStation trainStation = new TrainStation();
    public void sell(){
        System.out.println("代售点收取一些服务费用");
        trainStation.sell();// 最终还是火车站\目标对象卖票,只不过代售点可能会在之前或之后做一些处理
    }
}
// 通过代理对象来买票
public static void main(String[] args) {
    ProxyPoint proxyPoint = new ProxyPoint();
    proxyPoint.sell();
}

JDK动态代理

public static void main(String[] args) {
    SellTickets proxy = getProxyObject(); // class com.sun.proxy.$Proxy0
    proxy.sell();
}
private static SellTickets getProxyObject(){
    // 目标对象
    TrainStation station = new TrainStation();
    // 代理对象
    SellTickets proxy = (SellTickets)Proxy.newProxyInstance(
            station.getClass().getClassLoader(),// 类加载器
            station.getClass().getInterfaces(),// 实现的接口
            new InvocationHandler() { // InvocationHandler接口的匿名实现类的对象
                /**
                 * @param proxy: 代理对象proxy自己, 在invoke方法中基本不用
                 * @param method: 代理对象proxy调用的那个方法,比如上面调用的sell方法
                 * @param args: 代理对象调用方法时,传的参数
                 * @return: 代理对象proxy调用的那个方法的返回值
                 */
                @Override
                public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                    System.out.println("代售点收取一定的服务费用(JDK动态代理)");
                    // 调用目标对象的对应方法
                    Object returnValue = method.invoke(station, args);
                    return returnValue;
                }
            }
    );
    return proxy;
}

运行时生成的，内存中的代理类$Proxy0

package com.sun.proxy;

import cn.Code.SellTickets;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
// 目标类和代理类都实现了同样的接口
public final class $Proxy0 extends Proxy implements SellTickets {
    private static Method m3;
    // InvocationHandler的实现类对象,在创建代理对象时已提供
    public $Proxy0(InvocationHandler var1) throws  {
		super(var1);
    }
    // invoke方法的逻辑,在创建代理对象时已提供
    public final void sell() throws  {
		super.h.invoke(this, m3, (Object[])null);
    }
    static {
		m3 = Class.forName("cn.Code.SellTickets").getMethod("sell");
    }
}

将运行时，内存中生成的代理类$Proxy0保存到磁盘中

// main方法的第一行加上这个,可以将内存中生成的代理类保存为class文件
System.setProperty("jdk.proxy.ProxyGenerator.saveGeneratedFiles", "true");
// 或者可以考虑使用下面命令,在UI端中操作
jhsdb hsdb

CGLIB动态代理

如果没有SellTickets接口，只有TrainStation类，这个时候使用CGLIB代理

<dependency>
    <groupId>cglib</groupId>
    <artifactId>cglib</artifactId>
    <version>2.2.2</version>
</dependency>

// 火车站(目标类)
public class TrainStation{
    // 如果sell方法在目标类中是final或private的,代理类中不会有sell方法
    // (protected,public,default), 且不是final, 代理类中才会有增强的sell方法
    // final:此时调用的是目标类中的sell方法,代理类中没有,不会有增强效果
    // private:只能在目标类内部调用
    public void sell() {
        System.out.println("火车站卖票");
    }
}

public static void main(String[] args) {
	// cn.Code.TrainStation$$EnhancerByCGLIB$$e0808941
    TrainStation proxy = getProxyObject();
    proxy.sell();
}
private static TrainStation getProxyObject(){
    // 目标对象
    TrainStation station = new TrainStation();

    Enhancer enhancer = new Enhancer();
    enhancer.setSuperclass(TrainStation.class);//指定父类
    enhancer.setCallback(new MethodInterceptor() {//设置CallBack
        public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
            System.out.println("代售点收取一定的服务费用(CGLIB代理)");
            Object returnValue = method.invoke(station, objects);
            return returnValue;
        }
    });

    // 代理对象
    TrainStation proxy = (TrainStation) enhancer.create();
    return proxy;
}

运行时，生成的代理类TrainStation$$EnhancerByCGLIB$$e0808941

package cn.Code;
import java.lang.reflect.Method;
import net.sf.cglib.core.ReflectUtils;
import net.sf.cglib.core.Signature;
import net.sf.cglib.proxy.Callback;
import net.sf.cglib.proxy.Factory;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;
public class TrainStation$$EnhancerByCGLIB$$e0808941 extends TrainStation implements Factory {
    private boolean CGLIB$BOUND;
    private static final ThreadLocal CGLIB$THREAD_CALLBACKS;
    private static final Callback[] CGLIB$STATIC_CALLBACKS;
    private MethodInterceptor CGLIB$CALLBACK_0;
    private static final Method CGLIB$sell$0$Method;
    private static final MethodProxy CGLIB$sell$0$Proxy;
    private static final Object[] CGLIB$emptyArgs;

    public TrainStation$$EnhancerByCGLIB$$e0808941() {
        CGLIB$BIND_CALLBACKS(this);
    }
    // 设置CGLIB$CALLBACK_0
    private static final void CGLIB$BIND_CALLBACKS(Object var0) {
        TrainStation$$EnhancerByCGLIB$$e0808941 var1 = (TrainStation$$EnhancerByCGLIB$$e0808941)var0;
        if (!var1.CGLIB$BOUND) {
            var1.CGLIB$BOUND = true;
            Object var10000 = CGLIB$THREAD_CALLBACKS.get();
            if (var10000 == null) {
                var10000 = CGLIB$STATIC_CALLBACKS;
                if (var10000 == null) {
                    return;
                }
            }
            var1.CGLIB$CALLBACK_0 = (MethodInterceptor)((Callback[])var10000)[0];
        }
    }
    static {
        CGLIB$THREAD_CALLBACKS = new ThreadLocal();
        CGLIB$emptyArgs = new Object[0];
        Class var0 = Class.forName("cn.Code.TrainStation$$EnhancerByCGLIB$$e0808941");
        Class var1;
        CGLIB$sell$0$Method = ReflectUtils.findMethods(new String[]{"sell", "()V"}, (var1 = Class.forName("cn.Code.TrainStation")).getDeclaredMethods())[0];
        CGLIB$sell$0$Proxy = MethodProxy.create(var1, var0, "()V", "sell", "CGLIB$sell$0");
    }
    public Object newInstance(Callback[] var1) {
        CGLIB$THREAD_CALLBACKS.set(var1);// 设置CallBack
        TrainStation$$EnhancerByCGLIB$$e0808941 var10000 = new TrainStation$$EnhancerByCGLIB$$e0808941();
        CGLIB$THREAD_CALLBACKS.set((Callback[])null);// 清空CallBack
        return var10000;
    }
	// 当目标类中sell方法为protected或public或default,且不为final时,代理类中才会有这个方法
    public final void sell() {
        MethodInterceptor var10000 = this.CGLIB$CALLBACK_0;
        if (var10000 == null) {
            CGLIB$BIND_CALLBACKS(this);
            var10000 = this.CGLIB$CALLBACK_0;
        }
        if (var10000 != null) {
        	// 增强逻辑
            var10000.intercept(this, CGLIB$sell$0$Method, CGLIB$emptyArgs, CGLIB$sell$0$Proxy);
        } else {
            super.sell();
        }
    }
    final void CGLIB$sell$0() {
        super.sell();
    }
}
x_lcw
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java代理模式
02-06
java代理模式
Java 代理模式详解
12-22
代理模式是我们比较常用的设计模式之一。其中新思想是为了提供额外的处理或者不同的操作而在实际对象与调用者之间插入一个代理对象。这些额外的操作通常需要与实际对象进行通信，代理模式一般涉及到的角色有： 　...
Java代理模式详解
LYQ
05-15 6357
由于某些原因需要给某对象提供一个代理以控制对该对象的访问。这时，访问对象不适合或者不能直接引用目标对象，代理对象作为访问对象和目标对象之间的中介。在这个模式中，我们通过创建代理对象作为“替身”替代了原有对象，从而达到我们控制对象访问的目的。通俗来说，代理=代替处理。是由另一个对象来代替原对象来处理某些逻辑。举个例子：房产中介、代跑腿业务、送外卖、火车站卖票...静态代理虽然能够实现我们所说的代理模式，完成了解耦，但是静态代理类的代码维护依然非常复杂。
Java代理模式：如何优雅地控制对象访问？
陈书予
03-17 2081
代理模式（Proxy Pattern）是指用一个代理对象来代表真实的对象，该代理对象可以控制对真实对象的访问。代理对象和真实对象具有相同的接口，代理对象一般需要知道真实对象的实现方式和实现细节。代理模式的作用是隐藏对象的实现细节，降低系统的耦合度，增加系统的扩展性以及提高系统的安全性。代理模式（Proxy Pattern）是一种常见的设计模式，它充当了客户端和实际目标对象之间的中介或代理。代理模式在实际场景中有多种不同的实现方法，但其核心思想是为了提供一个控制对象访问的方式。
java的代理模式
qq_40820916的博客
10-29 1778
java的三种代理模式简介静态代理jdk动态代理cglib实现动态代理 简介 代理模式的定义： 为其他对象提供一种代理以控制对这个对象的访问。在某些情况下，一个对象不适合或者不能直接引用另一个对象，而代理对象可以在客户端和目标对象之间起到中介的作用。 以上为百度百科对代理模式的定义；通俗一点讲，java中的代理模式就是你想要访问一个目标对象，但是不直接访问它，而是通过它的代理对象访问（因为代理对象可以对目标对象做增强操作），这就是java的代理模式。示意图如下： 在java中，有三种代理模式，分别为静态代
Java 代理模式
热门推荐
方志朋的专栏
09-25 4万+
什么是代理代理是一种设计模式，它的核心思想，是将对目标的访问转移到代理对象上。这样做的好处就是，目标对象在不改变代码的情况下，可以通过代理对象加一些额外的功能。这是一种编程思想，在不改变原有代码的情况下，通过代理增加一些扩展功能。代理过程如图所示，用户访问代理对象，代理对象通过访问目标对象，来达到用户访问目标对象的目的，代理模式包含一下三个角色： ISubject：接口对象，该接口是对象和它的代理共
【java】代理模式简单实现
CamphorBlossom的博客
01-28 1563
概念 代理模式（Proxy Pattern）是一种结构型设计模式， 让你能够提供对象的替代品或其占位符。 代理控制着对于原对象的访问， 并允许在将请求提交给对象前后进行一些处理。在代理模式中，一个类代表另一个类的功能，我们创建具有现有对象的对象，以便向外界提供功能接口。 目的 控制访问：为其他对象提供一种代理以控制对这个对象的访问。 功能增强：完成目标对象的调用时，可附加一些额外功能。 问题 为什么要控制对于某个对象的访问呢？ 举个例子： 有这样一个消耗大量系统资源的巨型对象， 你只是偶尔需要使用
java代理模式示例源码
06-05
通过房产中介的例子介绍了java代理的实现
设计模式-代理模式Proxy（结构型）
qq_43676797的博客
06-11 436
可以发现代理类只能代理实现Pay接口的类，不够灵活。开发过程中，经常会有日志、事务等的操作是不区分业务逻辑的，可以使用动态代理。代理模式和装饰模式非常相似，只是在语义上不一样。
享元和代理模式
最新发布
Sun的个人博客
06-15 420
*** Description: 抽象的网站*//*** Description: 接口*//*** Description: 被代理的接口*//*** Description: 被代理的类*/System.out.println(name + "老师授课中，使用的是cglib代理，不需要实现接口");
C++设计模式---代理模式
专注
06-15 196
（1）远程代理（Remote Proxy）：为一个位于不同地址空间的对象提供一个本地的代理对象，这个对象作为该远程对象的代表，以隐藏一个对象存在于不同地址空间的事实。代理对象在客户端和目标对象之间起到中介的作用，可以隐藏目标对象的实现细节，增加额外的功能（如访问控制、日志记录、性能监控等），或者对目标对象的访问进行优化。（2）代理对象（Proxy）：持有目标对象的引用，控制对目标对象的访问，并可能提供额外的功能。（1）目标对象（Real Subject）：代理对象所代表的真实对象，是最终要引用的对象。
代理模式（设计模式）
刘皇叔说Java的博客
06-14 624
代理模式可以在不改变目标对象的情况下，提供额外的功能或控制。代理对象是目标对象的代表，其他需要与这个目标对象打交道的操作都是和这个代理对象在交涉。代理对象可以在客户端和目标对象之间起到中介的作用，这样起到了的作用和保护了目标对象的，同时也在一定程度上面减少了系统的耦合度。代理模式是一种非常实用的设计模式，适用于多种场景，通过代理对象来封装和控制对目标对象的访问，使得系统具备更好的扩展性和维护性。性能开销：由于代理模式需要额外的代理对象，因此会有一定的性能开销，特别是在频繁访问的情况下性能影响更加明显。
279. 完全平方数
m0_63653444的博客
06-09 415
动态规划的转移方程就对应递归的过程，动态规划的初始条件就对应递归的出口。递归相当于先压栈压栈然后出栈出栈，动态规划可以省去压栈的过程。解法一超时，解法二优化通过使用 HashMap 保存。
代理模式与静态代理、动态代理的实现（Proxy.newProxyInstance、InvocationHandler）
李斯维的博客空间
06-12 1065
代理模式是23种设计模式中比较常用的一种，属于结构型设计模式。在 Android 领域中，有大量的库都使用了代理模式，例如 Retrofit 使用动态代理来实现 API 接口的调用，Dagger 使用代码生成和反射机制来创建依赖注入的代理对象等等。本文将带你了解代理模式，并且介绍静态代理和动态代理的实现方式。
DP动态规划（下）
qianzhima2012的博客
06-11 935
确定状态变量及其含义，然后根据问题逻辑构建状态转移方程。边界条件通常用于直接给出或推导出最基本状态的值。明确表示问题状态的方式，这通常通过变量或数据结构来实现。
23种设计模式之代理模式
好我谢特的博客
06-09 584
一文看懂代理模式
「动态规划」如何求粉刷房子的最少花费？
努力学习游泳的鱼的博客
06-11 958
用动态规划的思想求解粉刷房子的问题。
java 代理模式
06-02
Java代理模式是一种结构型设计模式，其目的是为其他对象提供一种代理以控制对这个对象的访问。代理对象可以在客户端和目标对象之间充当中介，以便于客户端访问目标对象时，可以在不改变目标对象的情况下添加一些额外的功能，比如安全性、远程访问、缓存等。 在Java中，代理模式可以通过两种方式实现：静态代理和动态代理。静态代理需要手动编写代理类，而动态代理可以在运行时通过反射机制动态生成代理类，更加灵活。 举个例子，假设我们有一个接口`Subject`，其中定义了一些方法。我们希望在调用这些方法时，增加一些额外的日志记录功能。我们可以编写一个代理类`SubjectProxy`，在代理类中实现接口方法并调用目标对象的方法，同时在方法前后添加日志记录的代码。客户端则通过代理类访问目标对象。 静态代理示例代码如下： ```java public interface Subject { void doSomething(); } public class RealSubject implements Subject { @Override public void doSomething() { System.out.println("RealSubject do something."); } } public class SubjectProxy implements Subject { private Subject realSubject; public SubjectProxy(Subject realSubject) { this.realSubject = realSubject; } @Override public void doSomething() { System.out.println("Before do something."); realSubject.doSomething(); System.out.println("After do something."); } } public class Client { public static void main(String[] args) { Subject realSubject = new RealSubject(); Subject subjectProxy = new SubjectProxy(realSubject); subjectProxy.doSomething(); } } ``` 动态代理示例代码如下： ```java public class SubjectHandler implements InvocationHandler { private Object target; public SubjectHandler(Object target) { this.target = target; } @Override public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { System.out.println("Before " + method.getName()); Object result = method.invoke(target, args); System.out.println("After " + method.getName()); return result; } } public class Client { public static void main(String[] args) { Subject realSubject = new RealSubject(); InvocationHandler handler = new SubjectHandler(realSubject); Subject subjectProxy = (Subject) Proxy.newProxyInstance(realSubject.getClass().getClassLoader(), realSubject.getClass().getInterfaces(), handler); subjectProxy.doSomething(); } } ``` 无论是静态代理还是动态代理，代理模式都可以在不改变目标对象的情况下，为其添加额外的功能，提高代码的可复用性和灵活性。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值