看懂了这篇文章,就彻底了解动态代理是怎么回事了,原文地址
java 动态代理深度学习,
一.相关类及其方法:
java.lang.reflect.Proxy,
Proxy 提供用于创建动态代理类和实例的静态方法.
newProxyInstance()
返回一个指定接口的代理类实例,该接口可以将方法调用指派到指定的调用处理程序
(详见api文档)
java.lang.reflect.InvocationHandler,
InvocationHandler 是代理实例的调用处理程序 实现的接口。
invoke()
在代理实例上处理方法调用并返回结果。在与方法关联的代理实例上调用方法时,将在调用处理程序上调用此方法。
(详见api文档)
二.源代码:
被代理对象的接口及实现类:
package com.ml.test;
public interface Manager {
public void modify();
}
package com.ml.test;
public class ManagerImpl implements Manager {
@Override
public void modify() {
System.out.println("*******modify()方法被调用");
}
}
业务代理类:
package com.ml.test;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
public class BusinessHandler implements InvocationHandler {
private Object object = null;
public BusinessHandler(Object object) {
this.object = object;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
System.out.println("do something before method");
Object ret = method.invoke(this.object, args);
System.out.println("do something after method");
return ret;
}
}
客户端类:
package com.ml.test;
import java.lang.reflect.Proxy;
public class Client {
public static void main(String[] args) {
// 元对象(被代理对象)
ManagerImpl managerImpl = new ManagerImpl();
// 业务代理类
BusinessHandler securityHandler = new BusinessHandler(managerImpl);
// 获得代理类($Proxy0 extends Proxy implements Manager)的实例.
Manager managerProxy = (Manager) Proxy.newProxyInstance(managerImpl
.getClass().getClassLoader(), managerImpl.getClass()
.getInterfaces(), securityHandler);
managerProxy.modify();
}
}
三.执行结果:
do something before method
*******modify()方法被调用
do something after method
四.机制分析:
Proxy.(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h)做了以下几件事.
(1)根据参数loader和interfaces调用方法 getProxyClass(loader, interfaces)创建代理类$Proxy.
$Proxy0类实现了interfaces的接口,并继承了Proxy类.
(2)实例化$Proxy0并在构造方法中把BusinessHandler传过去,接着$Proxy0调用父类Proxy的构造器,为h赋值,如下:
class Proxy{
InvocationHandler h=null;
protected Proxy(InvocationHandler h) {
this.h = h;
}
...
}
下面是本例的$Proxy0类的源码(好不容易才把它提出来):
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 Manager {
private static Method m1;
private static Method m0;
private static Method m3;
private static Method m2;
static {
try {
m1 = Class.forName("java.lang.Object").getMethod("equals",
new Class[] { Class.forName("java.lang.Object") });
m0 = Class.forName("java.lang.Object").getMethod("hashCode",
new Class[0]);
m3 = Class.forName("com.ml.test.Manager").getMethod("modify",
new Class[0]);
m2 = Class.forName("java.lang.Object").getMethod("toString",
new Class[0]);
} catch (NoSuchMethodException nosuchmethodexception) {
throw new NoSuchMethodError(nosuchmethodexception.getMessage());
} catch (ClassNotFoundException classnotfoundexception) {
throw new NoClassDefFoundError(classnotfoundexception.getMessage());
}
}
public $Proxy0(InvocationHandler invocationhandler) {
super(invocationhandler);
}
@Override
public final boolean equals(Object obj) {
try {
return ((Boolean) super.h.invoke(this, m1, new Object[] { obj }))
.booleanValue();
} catch (Throwable throwable) {
throw new UndeclaredThrowableException(throwable);
}
}
@Override
public final int hashCode() {
try {
return ((Integer) super.h.invoke(this, m0, null)).intValue();
} catch (Throwable throwable) {
throw new UndeclaredThrowableException(throwable);
}
}
public final void modify() {
try {
super.h.invoke(this, m3, null);
return;
} catch (Error e) {
} catch (Throwable throwable) {
throw new UndeclaredThrowableException(throwable);
}
}
@Override
public final String toString() {
try {
return (String) super.h.invoke(this, m2, null);
} catch (Throwable throwable) {
throw new UndeclaredThrowableException(throwable);
}
}
}
接着把得到的$Proxy0实例强制转换成Manager.
当执行managerProxy.modify()方法时,就调用了$Proxy0类中的modify()方法.
在modify方法中,调用父类Proxy中的h的invoke()方法.
即InvocationHandler.invoke();
相关推荐
在Java中,动态代理主要通过`java.lang.reflect.Proxy`类和`java.lang.reflect.InvocationHandler`接口来实现。Proxy类是用于创建一个代理对象,而InvocationHandler接口则定义了代理对象调用方法时的行为。 1. **...
### Java 动态代理Proxy应用和底层源码分析 #### 一、Java动态代理简介 Java动态代理是一种在运行时动态生成代理类的技术,通过该技术可以为一个或多个接口生成一个实现类,该实现类可以拦截接口方法的调用,并...
### 关于JDK动态代理的源码剖析 #### 一、引言 在Java开发过程中,动态代理技术是一项非常实用的技术,它可以帮助我们实现在不修改原有代码的基础上为方法增加额外的功能,比如日志记录、权限校验等。本文将深入...
总结来说,"proxy.rar"压缩包提供了Java编程中三种代理模式的源代码实例,通过学习这些代码,开发者可以深入理解代理模式的原理和实现,同时掌握泛型在实际项目中的应用。对于提高代码的可扩展性和可维护性,这些都...
Java中的`InvocationHandler`接口是Java动态代理机制的核心组成部分,主要用在`java.lang.reflect`包下。这个接口提供了一种方法,使得我们可以在运行时创建具有特定行为的代理对象。这种行为通常体现在调用代理对象...
本文将深入探讨Java中的动态代理,特别是基于`java.lang.reflect.Proxy`类的使用。 首先,`java.lang.reflect.Proxy`是Java标准库中用于生成动态代理类的关键类。它允许我们创建一个新的接口实现类,而无需手动编写...
在Java编程语言中,`InvocationHandler`和`Proxy`机制是动态代理的重要组成部分,它们提供了在运行时创建接口实现的能力,使得我们可以在不修改原有代码的情况下扩展或增强对象的行为。这些概念对于理解和实现面向切...
在Java中,动态代理主要通过两个类来实现:`java.lang.reflect.Proxy` 和 `java.lang.reflect.InvocationHandler`。 1. **Proxy类**: `Proxy` 类是Java提供的一个内部类,它主要用于创建一个实现了指定一组接口的...
Java的动态代理主要通过`java.lang.reflect.Proxy`类和`java.lang.reflect.InvocationHandler`接口实现。这个主题将深入探讨这两个关键组件以及与之相关的CGLIB库。 ### 1. Java动态代理 #### 1.1 Proxy类 `Proxy`...
Java提供了`java.lang.reflect.Proxy`类和`java.lang.reflect.InvocationHandler`接口来实现动态代理。 1. **定义接口**:同样,我们首先定义一个接口。 ```java public interface Service { void execute(); } ``...
本文将深入探讨Java代理方法的假设、验证以及Proxy类的源码分析。 首先,让我们理解Java代理的基本概念。在Java中,代理主要通过两种方式实现:接口代理(基于Java动态代理JDK Proxy)和类代理(基于CGLIB等库)。...
在Java中,有两种实现动态代理的方式:`java.lang.reflect.Proxy` 类和 `java.lang.reflect.InvocationHandler` 接口。 Proxy类是生成代理对象的工厂,而InvocationHandler接口定义了处理代理对象方法调用的逻辑。...
本资源“浪曦经典Java代码--反射+代理reflection_proxy源码”提供了深入理解和实践这两个概念的绝佳材料。 反射(Reflection)是Java的一种特性,它允许运行中的Java程序获取类、接口、字段和方法的信息,并能够...
Java动态代理是Java编程中一个重要的特性,它允许我们在运行时创建代理对象,这些代理对象可以作为原有对象的“代理”,在调用原有方法时添加额外的功能或行为。这一技术在软件开发中广泛应用,特别是在实现设计模式...
动态代理主要由`java.lang.reflect.Proxy`和`java.lang.reflect.InvocationHandler`两个类组成。`Proxy`类用于创建代理对象,而`InvocationHandler`接口定义了处理方法调用的逻辑。我们可以通过实现`...
Proxy类提供了创建动态代理对象的方法,而InvocationHandler接口定义了调用处理程序的接口,它处理对代理对象的所有方法调用。 动态代理的基本步骤如下: 1. 定义接口:首先,你需要定义一个或多个接口,这些接口...
Java反射和动态代理是Java语言中的两个重要特性,它们为程序提供了强大的运行时能力,能够增强软件的灵活性和可扩展性。这篇博文将深入探讨这两个主题,并通过实例解析其核心概念。 **Java反射(Reflection)** ...
在Java中,动态代理主要通过`java.lang.reflect.Proxy`类和`java.lang.reflect.InvocationHandler`接口来实现。数据源连接池则是数据库连接管理的一种优化策略,它可以有效地复用数据库连接,避免频繁地创建和销毁...
在Java编程语言中,`Proxy`和`InvocationHandler`是两个关键的概念,它们主要用于实现动态代理,这是一种在运行时创建接口实例的技术。动态代理在很多场景下都非常有用,比如日志记录、性能监控、事务管理等。下面...