java反射机制及动态代理

目前正在看Hadoop RPC框架的源码，在深入了解这些之前，有一些基础知识需要回顾下。 1. java反射机制及动态代理 2. java网络编程 3. java NIO 先总结下第一个，java反射机制及动态代理的相关知识点： java反射机制 在看与java反射机制相关的代码前，试着看看

目前正在看Hadoop RPC框架的源码，在深入了解这些之前，有一些基础知识需要回顾下。

• 1. java反射机制及动态代理
• 2. java网络编程
• 3. java NIO

先总结下第一个，java反射机制及动态代理的相关知识点：

java反射机制

在看与java反射机制相关的代码前，试着看看下面这几个问题：

1. 什么是反射? 
2. 为什么使用反射? 
3. 使用它有哪些好处? 
4. 哪些地方需要反射?

在程序运行时，允许改变程序结构和变量名称。如python ,ruby这类，我们称为是动态语言。

而对于java，C++，C# 这类则不能称为动态语言，我们一般称这些为静态语言。

int i = 1
i = “hello world ”   

如上面这段代码，在静态语言中，在编译阶段编译器就会报错。而对于动态语言，是可以修改变量类型的，如下面：

   i = 1
   i = ‘hi’

1. 先尝试看看第一个问题，什么是反射机制？

    在运行时环境，动态获取类的信息以及动态调用对象的方法的功能，就是reflection机制。

2. 哪些地方需要反射？

   * 运行时判断任何一个对象所属的类
   * 运行时构造任何一个类的对象
   * 运行时判断任何一个类所具有的成员变量和方法
   * 运行时调用任何一个对象的方法

3. 反射的使用？

    先看看java reflection api， Class类是反射的入口点。有下面3种方式获取：

   1. Class.forName(“java.util.Data”)
   2. T.getClass()
   3. T.class

 一个Class对象实际表示一个类型，但这个类型不一定是一种类。比如说int不表示类，但是int.class是一个Class类型的对象。

注：数组类型，使用getName会返回一个很奇怪的名字，如：

System.out.println(Double[].class.getName());  
显示打印的值如下：
[Ljava.lang.Double;

创建一个类的实例newInstance方法：使用默认的构造函数，没有参数

T.class.newInstance();
Object objCopy = classType.getConstructor(new Class[]{}).newInstance(new Object[]{});

反射分析类的能力：

• 1. java.lang.reflect包下面有3个类，Field,Method,Constructor,分别用来描述属性，方法，构造函数
• 2. 还有一个修饰符的获取，Modifier

4. 一个反射的简单例子程序：

package com.lifeware.study.reflection;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
public class ReflectTetser {
public Object copy(Object obj) throws IllegalArgumentException, SecurityException, InstantiationException, IllegalAccessException, InvocationTargetException, NoSuchMethodException{
Class> classType = obj.getClass();
System.out.println(classType.getName());
Object objCopy = classType.getConstructor(new Class[]{}).newInstance(new Object[]{});

Field[] fields = classType.getDeclaredFields();
for(Field field:fields){
System.out.println(field.getName());
String firstLetter = field.getName().substring(0,1).toUpperCase();
String getMethodName = “get” + firstLetter + field.getName().substring(1);
String setMethodName = “set” + firstLetter + field.getName().substring(1);

Method getMethod = classType.getMethod(getMethodName, new Class[]{});
Method setMethod = classType.getMethod(setMethodName, new Class[]{field.getType()});

Object value = getMethod.invoke(obj, new Object[]{});
setMethod.invoke(objCopy, new Object[]{value});
}
return objCopy;
}
/**
* @param args
* @throws NoSuchMethodException 
* @throws InvocationTargetException 
* @throws IllegalAccessException 
* @throws InstantiationException 
* @throws SecurityException 
* @throws IllegalArgumentException 
*/
public static void main(String[] args) throws IllegalArgumentException, SecurityException, InstantiationException, IllegalAccessException, InvocationTargetException, NoSuchMethodException {
// TODO Auto-generated method stub
Customer cus = new Customer();
cus.setId(new Long(100));
cus.setAge(new Long(50));
cus.setName(“zhangsan”);
Customer cuscopy = (Customer) new ReflectTetser().copy(cus);
System.out.println(cuscopy.getId() + “,” + cuscopy.getAge() + “,” + cuscopy.getName());
}
}
class Customer{
private Long id;
private Long age;
private String name;

public Customer(){

}

public Long getId(){
return id;
}

public Long getAge(){
return age;
}

public String getName(){
return name;
}

public void setId(Long id){
this.id = id;
}

public void setAge(Long age){
this.age = age;
}

public void setName(String name){
this.name = name;
}
}

5. 当然，反射写通用的数组代码时，还需要用到：java.lang.reflect.Array

public static Object goodArrayGrow(Object a){
Class> c1 = a.getClass();
if(!c1.isArray()){
return null;
}
Class> componentType = c1.getComponentType();
int length = Array.getLength(a);
int newLength = length * 11/10 + 10;
Object newArray = Array.newInstance(componentType, newLength);
System.arraycopy(a, 0, newArray, 0, length);

return newArray;
}

动态代理

动态代理部分：想清楚下面四个问题

1.什么是动态代理? 
    一种用于转发请求，进行特殊处理的机制，“动态”应该指的是“运行期”。 
2.为什么使用动态代理? 
    可以对请求进行任何处理(如事务，日志等，这都是网上说的，我当然可以做任何处理) 
3.使用它有哪些好处? 
    如上 
4.哪些地方需要动态代理? 
    不允许直接访问某些类；对访问要做特殊处理等，我只能想到这些。

1. 和动态代理有关的有两个类 

    1.1  interface InvocationHandler 

          只这一个方法， Object invoke(Object proxy, Method method, Object[] args) 

    1.2   class Proxy 真正表示动态代理的类，提供两个静态方法: 

   Class> getProxyClass(ClassLoader loader, Class>[] interface) 

用来产生代理类，参数要提供interface数组，它会生成这些interface的“虚拟实现”， 

用来冒充真实的对象。 

   Object newProxyInstance(ClassLoader loader, Class>[] interfaces, InvocationHandler h) 

   产生代理对象，多了InvocationHandler参数(只是InvocationHandler接口的实现类)， 

   它与代理对象关联，当请求分发到代理对象后，会自动执行h.invoke(…)方法.

2. 动态机制的实现步骤：

 /**
   * 1. 实现InvocationHandler接口创建自己的调用处理器
   *    InvocationHandler handler = new InvocationHandlerImpl(server);
   * 2. 通过Proxy指定ClassLoader对象和一组interface创建动态代理类
   *    Class clazz = Proxy.getProxyClass(classLoader,new class[]{…})
   * 3. 通过反射机制获取动态代理类的构造函数，其参数类型是调用处理器接口类型:
   *    Constructor constructor  = clazz.getConstructor(new Class[]{InvocationHandler.class})
   * 4. 通过构造函数创建动态代理类实例，将调用处理器对象作为参数被传入
   *    Interface proxy = constructor.newInstance(new Object[]{handler})
   *    
   * Proxy中newProxyInstance方法已经封装了步骤2~4，实例如下：
*/

3. 一个简单实用的例子：

package com.lifeware.study.reflection;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
public class DynamicProxyTest {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
CalculatorProtocol server = new Server();
InvocationHandler handler = new CalculatorHandler(server);
CalculatorProtocol client = (CalculatorProtocol)Proxy.newProxyInstance(server.getClass().getClassLoader(), 
server.getClass().getInterfaces(), handler);
int result = client.add(3, 2);
System.out.println(“3+2=” + result);
result = client.subtract(5, 2);
System.out.println(“5-2=” + result);
}
}
//定义一个接口协议
interface CalculatorProtocol{
public int add(int a,int b);
public int subtract(int a,int b);
}
//实现接口协议
class Server implements CalculatorProtocol{
public int add(int a,int b){
return a+b;
}

public int subtract(int a,int b){
return a-b;
}
}
class CalculatorHandler implements InvocationHandler{
private Object objOriginal;
public CalculatorHandler(Object obj){
this.objOriginal = obj;
}

public Object invoke(Object proxy,Method method,Object[] args) throws Throwable{
//可加入预处理
Object result = method.invoke(this.objOriginal, args);
return result;

}

}

~~EOF~~

原文地址：java反射机制及动态代理, 感谢原作者分享。