Java动态代理

最新推荐文章于 2025-07-20 18:42:29 发布
原创 最新推荐文章于 2025-07-20 18:42:29 发布 · 230 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

文章目录


动态代理其实是面向切面编程AOP。实现有两种，一个是Java SDK提供的，另外一个是第三方库提供，比如cglib

Java SDK

下面是Java SDK提供的代理

静态代理

package aop;

public class SimpleStaticProxyDemo {

	static interface IService {
		public void sayHello();
	}

	static class RealService implements IService {
		@Override
		public void sayHello() {
			System.out.println(" hello");
		}
	}

	static class TraceProxy implements IService {

		private IService realService;

		public TraceProxy(IService realService) {
			this.realService = realService;
		}

		@Override
		public void sayHello() {
			System.out.println(" entering sayHello");
			this.realService.sayHello();
			System.out.println(" leaving sayHello");
		}
	}

	public static void main(String[] args) {
		IService realService = new RealService();
		IService proxyService = new TraceProxy(realService);
		proxyService.sayHello();
	}
}

动态代理

package dynamic.proxy;

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

public class ProxyDemo {
	static interface IService {
		public void sayHello();
	}

	static class RealService implements IService {
		@Override
		public void sayHello() {
			System.out.println(" hello");
		}
	}

	static class SimpleInvocationHandler implements InvocationHandler {
		private Object realObj;

		public SimpleInvocationHandler(Object realObj) {
			this.realObj = realObj;
		}

		@Override
		public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
			System.out.println(" entering " + method.getName());
			Object result = method.invoke(realObj, args);
			System.out.println(" leaving " + method.getName());
			return result;
		}
	}

	public static void main(String[] args) {
		//保留$Proxy0.class文件
		System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles", "true");
		IService realService = new RealService();
		IService proxyService = (IService) Proxy.newProxyInstance(IService.class.getClassLoader(),
				new Class<?>[] { IService.class }, new SimpleInvocationHandler(realService));
		//输出代理类对象
       System.out.println("Proxy : "+ proxyService.getClass().getName());
       System.out.println("Proxy super : "+ proxyService.getClass().getSuperclass().getName());
       System.out.println("Proxy interfaces : "+ proxyService.getClass().getInterfaces()[0].getName());
       /*
       //等同效果，注意加上异常处理
       //throws NoSuchMethodException, SecurityException, InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException
       
       	Class<?> proxyCls = Proxy.getProxyClass(IService.class.getClassLoader(), new Class<?>[] { IService.class });
		Constructor<?> ctor = proxyCls.getConstructor(new Class<?>[] { InvocationHandler.class });
		InvocationHandler handler = new SimpleInvocationHandler(realService);
		IService proxyService = (IService) ctor.newInstance(handler);
       */
       //手动生成。然后在路径下创建$Proxy0.class文件。根目录下建，还要包和文件夹对应
		//System.out.println("$Proxy0.class全名: "+Proxy.getProxyClass(IService.class.getClassLoader(), IService.class));
		proxyService.sayHello();
	}

}

IService proxyService = (IService) Proxy.newProxyInstance(IService.class.getClassLoader(), new Class<?>[] { IService.class }, new SimpleInvocationHandler(realService));这一句等同于下面代码。

       	Class<?> proxyCls = Proxy.getProxyClass(IService.class.getClassLoader(), new Class<?>[] { IService.class });
		Constructor<?> ctor = proxyCls.getConstructor(new Class<?>[] { InvocationHandler.class });
		InvocationHandler handler = new SimpleInvocationHandler(realService);
		IService proxyService = (IService) ctor.newInstance(handler);

看一下原函数

 public static Object newProxyInstance(ClassLoader loader,
                                          Class<?>[] interfaces,
                                          InvocationHandler h)
        throws IllegalArgumentException
    {
        Objects.requireNonNull(h);

        final Class<?>[] intfs = interfaces.clone();//复制对象，与原来完全独立
        final SecurityManager sm = System.getSecurityManager();
        if (sm != null) {
            checkProxyAccess(Reflection.getCallerClass(), loader, intfs);
        }

        /*
         * Look up or generate the designated proxy class.
         */
        Class<?> cl = getProxyClass0(loader, intfs);

        /*
         * Invoke its constructor with the designated invocation handler.
         */
        try {
            if (sm != null) {
                checkNewProxyPermission(Reflection.getCallerClass(), cl);
            }

            final Constructor<?> cons = cl.getConstructor(constructorParams);
            final InvocationHandler ih = h;
            if (!Modifier.isPublic(cl.getModifiers())) {
                AccessController.doPrivileged(new PrivilegedAction<Void>() {
                    public Void run() {
                        cons.setAccessible(true);
                        return null;
                    }
                });
            }
            return cons.newInstance(new Object[]{h});
        } catch (IllegalAccessException|InstantiationException e) {
            throw new InternalError(e.toString(), e);
        } catch (InvocationTargetException e) {
            Throwable t = e.getCause();
            if (t instanceof RuntimeException) {
                throw (RuntimeException) t;
            } else {
                throw new InternalError(t.toString(), t);
            }
        } catch (NoSuchMethodException e) {
            throw new InternalError(e.toString(), e);
        }
    }

new Class<?>[] { InvocationHandler.class }是新建类对象。
这里先找到构造类，再newInstance。
通过反射创建新的类示例，有两种方式：

  • Class.newInstance()
    只能够调用无参的构造函数，调用默认的构造函数。
    要求被调用的构造函数是可见的，必须是public类型的。
  • Constructor.newInstance()
    可以根据传入的参数，调用任意构造构造函数。
    可以调用私有的构造函数（Constructor .setAccessible(true)）。

注意到这里proxyService.sayHello();好像没看到proxyService怎么加载sayHello方法进去就突然有这个方法执行呢？这个可以看下编译出来的$Proxy0.class文件

package ProxyDemo;

import ProxyDemo.ProxyDemo.IService;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.lang.reflect.UndeclaredThrowableException;

final class $Proxy0 extends Proxy implements IService {
	private static Method m1;
	private static Method m3;
	private static Method m2;
	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});
      } catch (RuntimeException | Error var3) {
         throw var3;
      } catch (Throwable var4) {
         throw new UndeclaredThrowableException(var4);
      }
   }

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

	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 int hashCode() throws  {
      try {
         return (Integer)super.h.invoke(this, m0, (Object[])null);
      } catch (RuntimeException | Error var2) {
         throw var2;
      } catch (Throwable var3) {
         throw new UndeclaredThrowableException(var3);
      }
   }

	static {
		try {
			m1 = Class.forName("java.lang.Object").getMethod("equals", Class.forName("java.lang.Object"));
			m3 = Class.forName("ProxyDemo.ProxyDemo$IService").getMethod("sayHello");
			m2 = Class.forName("java.lang.Object").getMethod("toString");
			m0 = Class.forName("java.lang.Object").getMethod("hashCode");
		} catch (NoSuchMethodException var2) {
			throw new NoSuchMethodError(var2.getMessage());
		} catch (ClassNotFoundException var3) {
			throw new NoClassDefFoundError(var3.getMessage());
		}
	}
}

通用型

package generalProxyDemo;

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

public class GeneralProxyDemo {
	static interface IServiceA {
		public void sayHello();
	}

	static class ServiceAImpl implements IServiceA {
		@Override
		public void sayHello() {
			System.out.println(" hello");
		}
	}

	static interface IServiceB {
		public void fly();
	}

	static class ServiceBImpl implements IServiceB {
		@Override
		public void fly() {
			System.out.println(" flying");
		}
	}

	static class SimpleInvocationHandler implements InvocationHandler {
		private Object realObj;

		public SimpleInvocationHandler(Object realObj) {
			this.realObj = realObj;
		}

		@Override
		public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
			System.out.println(" entering " + realObj.getClass().getSimpleName() + "::" + method.getName());
			Object result = method.invoke(realObj, args);
			System.out.println(" leaving " + realObj.getClass().getSimpleName() + "::" + method.getName());
			return result;
		}
	}

	@SuppressWarnings("unchecked")
	private static <T> T getProxy(Class<T> intf, T realObj) {
		return (T) Proxy.newProxyInstance(intf.getClassLoader(), new Class<?>[] { intf },
				new SimpleInvocationHandler(realObj));
	}

	public static void main(String[] args) throws Exception {
		IServiceA a = new ServiceAImpl();
		IServiceA aProxy = getProxy(IServiceA.class, a);
		aProxy.sayHello();
		IServiceB b = new ServiceBImpl();
		IServiceB bProxy = getProxy(IServiceB.class, b);
		bProxy.fly();
	}

}

第三方库

Cglib

package simpleCGLibDemo;

import java.lang.reflect.Method;

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

public class SimpleCGLibDemo {
	static class RealService {
		public void sayHello() {
			System.out.println(" hello");
		}
	}

	static class SimpleInterceptor implements MethodInterceptor {
		@Override
		public Object intercept(Object object, Method method, Object[] args, MethodProxy proxy) throws Throwable {
			System.out.println(" entering " + method.getName());
			Object result = proxy.invokeSuper(object, args);
			System.out.println(" leaving " + method.getName());
			return result;
		}
	}

	private static <T> T getProxy(Class<T> cls) {
		Enhancer enhancer = new Enhancer();
		enhancer.setSuperclass(cls);
		enhancer.setCallback(new SimpleInterceptor());
		return (T) enhancer.create();
	}

	public static void main(String[] args) throws Exception {
		RealService proxyService = getProxy(RealService.class);
		proxyService.sayHello();
	}

}

我这里用的是cglib编译库是：cglib_3.2.5.jar和asm_5.2.jar
cglib 的特点是不需要有接口都可以代理。它是通过生成子类的形式来代理，所以父类如果有final那些方法就代理不了。Java sdk的代理是需要有接口才能代理。

Java 动态代理详解
技术杠精的博客
05-26 1765
Java 动态代理详解，包括JDK动态代理和CGLIB动态代理
一文带你搞懂Java动态代理
01-21
在说动态代理之前，先来简单看下代理模式。代理是最基本的设计模式之一。它能够插入一个用来替代“实际”对象的“代理”对象，来提供额外的或不同的操作。这些操作通常涉及与“实际”对象的通信，因此“代理”对象...
JAVA动态代理
qq_32117059的博客
02-25 1722
java中有两种常见的动态代理方式 JDK原生动态代理和CGLIB动态代理使用以及原理
Java代理模式快速解析：从静态代理到动态代理
热门推荐
曾经“等你生日那天”都遥远得像未来，如今却可欢愉的挥手说“下个十年见”
05-21 168万+
本文深入探讨了代理模式的核心概念、类型划分（静态代理与动态代理）及其典型应用场景，并通过代码示例详细演示了不同实现方式。静态代理以编译时绑定的方式增强功能，而动态代理则通过运行时生成实现高灵活性，特别适用于复杂多变的需求。文章还结合实际案例，展示了代理模式在日志记录、权限控制和分布式系统中的广泛应用，帮助读者全面掌握该模式的理论与实践。
java动态代理
qq_31856061的博客
02-27 1345
通过继承的方式实现动态代理，通过继承目标类，创建它的子类，在子类中重写父类的同名方法，实现功能的修改。（因为是继承重写的方式实现代理，因此要求目标类不能是。④ 创建工厂类，为了简化创建代理对象的过程(这里用了泛型约束，可以不用)反射包中的接口和类实现动态代理，要求。② 创建目标类实现目标接口。工具库，能够创建代理对象。修饰，要重写的方法也不能是。目标类是实现目标功能的类。③ 创建对应的处理器实现。方法(里面写增强业务)④ 创建代理对象，测试。
Java动态代理实现全解析：原理、实战与最佳实践
持续输出Java相关知识
07-20 1426
Java动态代理是Java语言核心反射机制的重要应用，它允许在运行时动态生成代理类，用于增强方法行为，广泛应用于AOP、日志、权限控制等场景。本文系统讲解了Java动态代理的原理、实现方式（JDK与CGLIB）、静态与动态代理的对比、常见应用场景、最佳实践与易错点，辅以大量实用代码示例，帮助开发者深入理解和灵活运用动态代理技术。
java动态代理详细介绍
weixin_47874230的博客
02-17 1461
java动态代理详细介绍
Java动态代理Proxy
m0_73249076的博客
03-07 1259
本文章讲述了Java动态代理的理解与使用。
Java动态代理原理
weixin_75207021的博客
02-29 1614
介绍Java代理模式，以及其中的静态代理和动态代理模式
什么是Java动态代理？
weixin_46072507的博客
05-07 1064
Override@OverrideJava 动态代理是一种在运行时生成代理对象并处理方法调用的机制。JDK 动态代理：基于接口，通过Proxy类和实现。CGLIB 动态代理：基于类，通过Enhancer类生成目标类的子类来实现。动态代理的优势在于，它能够在不修改目标类的情况下，为其添加额外的功能（如日志、事务、性能监控等），大大增强了代码的灵活性和可扩展性。如果你对某一部分的实现有疑问，或者想了解更多细节，随时可以问我！
Java 动态代理详解（学习资料）
06-17
JDK 动态代理JDK 提供了 java.lang.reflect.Proxy 类和 java.lang.reflect.InvocationHandler 接口来支持动态代理。Proxy 类用于创建一个代理对象，而 InvocationHandler 接口则定义了代理对象的方法调用处理逻辑。...
Java动态代理语法Proxy类原理详解
08-19
"Java动态代理语法Proxy类原理详解" Java动态代理语法Proxy类原理详解是Java语言中的一种非常重要的语法机制，它可以动态地生成代理对象，从而对目标对象进行增强和修改。本文将详细介绍Java动态代理语法Proxy类...
JAVA动态代理示例代码
01-08
Java动态代理是Java语言中一种极为重要的代理机制，它允许在运行时为某些类创建代理对象。动态代理通常用于实现中间层，比如日志记录、事务管理、安全检查等。在动态代理中，可以使用不同的方法来实现代理模式，如...
mamba-ssm-2.2.2-cp310-cp310-win-amd64.whl+安装环境+测试脚本.7z
最新发布
12-15
编译环境： vs2022 win10 x64 anaconda3+python3.10 torch==2.3.1+cu118 cuda11.8.0+cudnn8.9.7 triton==2.1.0 causal_conv1d==1.4.0 mamba==2.2.2 RTX2070显卡 注意编译的whl是不能用于RTX50显卡的，可以用于RTX20-RTX40系列显卡，安装时候尽量和模块一致
toplus1s_calculator_32040_1765656584703.zip
12-15
toplus1s_calculator_32040_1765656584703.zip
【创新无忧】基于多元宇宙优化算法MVO优化相关向量机RVM实现数据多输入单输出回归预测附matlab代码.zip
12-15
1.版本：matlab2014a/2019b/2024b 2.附赠案例数据可直接运行。 3.代码特点：参数化编程、参数可方便更改、代码编程思路清晰、注释明细。 4.适用对象：计算机，电子信息工程、数学等专业的大学生课程设计、期末大作业和毕业设计。
基于可靠性评估序贯蒙特卡洛模拟法的配电网可靠性评估研究（Matlab代码实现）
12-15
基于可靠性评估序贯蒙特卡洛模拟法的配电网可靠性评估研究（Matlab代码实现）内容概要：本文围绕“基于可靠性评估序贯蒙特卡洛模拟法的配电网可靠性评估研究”，介绍了利用Matlab代码实现配电网可靠性的仿真分析方法。重点采用序贯蒙特卡洛模拟法对配电网进行长时间段的状态抽样与统计，通过模拟系统元件的故障与修复过程，评估配电网的关键可靠性指标，如系统停电频率、停电持续时间、负荷点可靠性等。该方法能够有效处理复杂网络结构与设备时序特性，提升评估精度，适用于含分布式电源、电动汽车等新型负荷接入的现代配电网。文中提供了完整的Matlab实现代码与案例分析，便于复现和扩展应用。; 适合人群：具备电力系统基础知识和Matlab编程能力的高校研究生、科研人员及电力行业技术人员，尤其适合从事配电网规划、运行与可靠性分析相关工作的人员； 使用场景及目标：①掌握序贯蒙特卡洛模拟法在电力系统可靠性评估中的基本原理与实现流程；②学习如何通过Matlab构建配电网仿真模型并进行状态转移模拟；③应用于含新能源接入的复杂配电网可靠性定量评估与优化设计； 阅读建议：建议结合文中提供的Matlab代码逐段调试运行，理解状态抽样、故障判断、修复逻辑及指标统计的具体实现方式，同时可扩展至不同网络结构或加入更多不确定性因素进行深化研究。
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值