代理模式，相信大多数人都非常熟悉，常见的实现方式是通过公共接口的方式，让我们的目标类和代理类实现同一接口，在代理类中调用目标类对象的方法。具体请看我另一个博客中的文章：Java的代理模式（通过公共接口实现） 。通过接口的方式，有个不好的地方，就是对每个目标类都要写一对与之相对应的接口和代理类，如果业务类很多，就是非常繁锁的工作了。
而加入反射机制的代理模式，可实现一个公共的代理类，省去我们不少功夫。Java的java.lang.reflect包及其子包中提供了Class、Method、Annotation等有用的类。下面，写个方法代理的类MethodProxy，实现动态地调用对象的方法。
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
/**
* 方法代理类
* @author rongxinhua
*
*/
public class MethodProxy {
private Class clazz; //对象所属的类
private Object target; //目标对象
private Method method; //目标方法
private Object[] params; //参数数组
@SuppressWarnings("unchecked")
public MethodProxy(Object target, String methodName, Object ... params) {
rebindTarget(target, methodName, params); //设置目标对象与方法
}
/**
* 重新设置目标对象与方法
* @param target
* @param methodName
* @param params
*/
public void rebindTarget(Object target, String methodName, Object ... params) {
this.target = target;
this.clazz = target.getClass();
rebindMethod(methodName, params); //设置目标方法
}
/**
* 重新设置目标方法
* @param methodName
* @param params
*/
public void rebindMethod(String methodName, Object ...params) {
this.params = params;
int paramLength = params.length;
Class[] paramTypes = new Class[paramLength];
for(int i = 0 ; i < paramLength ; i ++ ) {
paramTypes[i] = params[i].getClass();
}
try {
this.method = clazz.getMethod(methodName, paramTypes);
} catch (SecurityException e) {
e.printStackTrace();
} catch (NoSuchMethodException e) {
e.printStackTrace();
}
}
/**
* 动态调用已绑定的方法
*/
public void doMethod() {
try {
this.method.invoke(target, params);
} catch (IllegalArgumentException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (InvocationTargetException e) {
e.printStackTrace();
}
}
}
这样就可以实现动态地调用某个对象的某个方法了，写个测试代码如下：
public class Manager {
public void say() {
System.out.println("Nobody say nothing");
}
public void love(String boy, String girl) {
System.out.println(boy + " love " + girl);
}
}
我们通过代理类来调用Manager类中的say()和love()方法，测试代码如下：
Manager man = new Manager(); //目标对象
MethodProxy proxy = new MethodProxy(man, "say"); //方法代理对象
proxy.doMethod(); //调用被代理的方法
proxy.rebindMethod("love", "Tom", "Marry"); //重新绑定方法
proxy.doMethod(); //调用被代理的方法
这样就实现了动态代理调用对象的方法，上面代码输出结果就不贴出来了。如果要设置前置通知和后置通知等功能，也很容易实现，只需在“proxy.doMethod()”代码处的前面和后面设置即行。
扩展应用：我们在上面的MethodProxy类中加入以下方法：
/**
* 获取方法上的注解
* @param anClazz 注解类
* @return
*/
public Annotation getAnnotation(Class anClazz) {
return this.method.getAnnotation(anClazz);
}
这个方法用来读取方法上的注解（Annotation），有什么用呢？我们写一个注解来测试下。
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
@interface Low {
int boyAge(); //男孩法定的谈恋爱年龄
int girlAge(); //女孩法定的谈恋爱年龄
}
我们要引进Annotation相关的类：
import java.lang.annotation.Annotation;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
我们另外写一个测试用的业务类：
public class LoveManager {
@Low(boyAge=12, girlAge=10)
public void beAbleToLove(Person boy, Person girl) {
System.out.println(boy.getName() + " is able to love " + girl.getName());
}
}
public class Person {
private String name;
private int age;
public Person(String name, int age) {
this.name = name;
this.age = age;
}
//getter方法略
}
接写上例中的proxy对象测试代码：
LoveManager loveManager = new LoveManager();
Person boy = new Person("Tom", 13);
Person girl = new Person("Marry", 10);
proxy.rebindTarget(loveManager, "beAbleToLove", boy, girl); //重新绑定对象和方法
Low low = (Low)proxy.getAnnotation(Low.class);
if(boy.getAge() < low.boyAge()) {
System.out.println(boy.getName() + "还不到法定年龄，不能谈恋爱！");
} else if(girl.getAge() < low.girlAge()) {
System.out.println(girl.getName() + "还不到法定年龄，不能谈恋爱！");
} else {
proxy.doMethod();
}
根据boy和girl的年龄大小，会相应地输出下列之一：
Tom还不到法定年龄，不能谈恋爱！
Marry还不到法定年龄，不能谈恋爱！
Tom is able to love Marry
这就实现了，通过Java的反射来读取Annotation的值，并根据Annotation的值，来处理业务数据有效性的判断，或者面向切面动态地注入对象，或者作日志、拦截器等等。这种用法在所多框架中都常常看到， 我们在开发自己的Java组件时，不妨也采用一下吧！
分享到：
相关推荐
Java的反射机制与动态代理是Java编程中两个非常重要的高级特性，它们在许多实际场景中发挥着关键作用，如框架开发、插件系统、元数据处理等。下面将详细讲解这两个概念及其应用。 首先，Java的反射机制允许我们在...
### Java反射机制详解 #### 一、什么是Java反射机制？ Java反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的...
总的来说，Java反射机制和动态代理是Java平台强大而灵活的特性，它们使得Java程序能够在运行时具有更高的灵活性和可扩展性。然而，使用反射也可能带来性能开销和安全风险，因此在实际应用中需要权衡利弊，合理使用。
主要讲述Java反射机制与设计模式之一：代理模式的原理与应用；同时详细讲述了Java对代理模式的支持以及Java中动态代理的原理，应用与实践。
Java反射机制是Java编程语言中一项强大的工具，它允许程序在运行时检查和操作类、接口、对象等的内部信息。反射机制的核心在于能够在运行时动态地获取类的信息，并且可以动态调用对象的方法，创建对象，甚至修改对象...
### Java反射机制详解 #### 一、反射机制是什么 反射机制是Java编程语言的一个核心特性，它允许程序在运行时动态地获取类的信息，并且能够动态地创建对象和调用对象的方法。简单来说，反射机制使得Java程序可以...
Java反射机制是Java语言的一个强大特性，它允许程序在运行时检查和操作类、接口、字段和方法的信息。通过反射，我们可以在不知道具体类的情况下，动态地获取类的信息并创建对象，调用方法，修改字段值。这种机制在...
总之，Java反射机制与动态代理为开发者提供了强大的灵活性，可以在运行时探索和修改程序行为，实现更复杂的设计模式和编程策略。然而，由于它们涉及底层操作，过度使用可能会影响程序性能和安全性，因此在实际应用中...
Java动态代理是基于Java反射机制的一种实现方式，它允许我们在运行时动态地创建一个实现了某些接口的新类。Java动态代理主要用于创建代理对象，这些代理对象可以实现在特定时刻的行为增强。 **1. Java动态代理类的...
总的来说，这份“JAVA反射机制与动态代理综合资料”应该是一个全面的学习资源，涵盖了从基础概念到实际应用的多个方面，对于想要提升Java技能或深入理解J2EE开发的程序员来说，是非常宝贵的学习材料。通过学习和实践...
Java反射机制是Java编程语言的核心特性之一，它赋予了程序在运行时检查和操作对象的能力。反射机制使得Java代码能够动态地获取类的信息（如类名、方法、字段），并且能够在运行时创建和调用对象的方法，这为编程带来...
Java反射机制是Java编程语言中的一个强大特性，它允许程序在运行时检查和操作类、接口、字段和方法。在Java中，反射机制是通过java.lang.Class类和相关的API实现的，它为我们提供了动态访问和操作类的能力。下面将...
Java反射机制是Java语言的一种强大的特性，它允许程序在运行时动态地获取类的信息并操作类的对象。在Java中，反射主要涉及到`java.lang.Class`类、`java.lang.reflect`包中的类（如Constructor、Method、Field）以及...
在本篇“java反射机制学习(五)：工厂模式”中，我们将探讨如何利用反射与工厂模式结合，提升代码的灵活性和可扩展性。 首先，工厂模式是一种常用的创建型设计模式，它提供了一种创建对象的最佳方式。传统的工厂模式...
7. 动态代理：Java反射机制可以结合java.lang.reflect.Proxy类创建动态代理，实现代理模式，为接口的方法提供动态处理逻辑。 在实际开发中，反射机制常用于以下场景： - 插件化开发：通过反射加载插件中的类，实现...
通过阅读《Java反射机制-较全面PPT.ppt》这样的资源，你可以更深入地理解这些概念，并学习如何在实际项目中安全有效地使用反射。这不仅有助于提高代码的灵活性，也有助于解决某些特定场景下的编程难题。在学习过程中...
6. **代理模式的其他实现**：除了Java的动态代理，还有其他实现方式，比如CGLIB库，它通过字节码生成技术创建代理对象，即使目标类没有实现接口也能进行代理。 学习AOP动态代理有助于我们理解面向切面编程的核心...