java 反射的一个例子

         最近看董西城老师的书，有介绍到java的反射机制，做一个笔记。

       首先定义一个接口类：

       

public interface CalculatorProtocol {
      public int add(int a,int b);
      public int subtract(int a,int b);
}

     然后写两个类server1和server2来实现这个接口

public class Server1 implements CalculatorProtocol{

	@Override
	public int add(int a, int b) {
		// TODO Auto-generated method stub
		return a+b;
	}

	@Override
	public int subtract(int a, int b) {
		// TODO Auto-generated method stub
		return a-b;
	}

}

public class Server2 implements CalculatorProtocol{

	@Override
	public int add(int a, int b) {
		// TODO Auto-generated method stub
		return a+b+2;
	}

	@Override
	public int subtract(int a, int b) {
		// TODO Auto-generated method stub
		return a-b-2;
	}

}

     然后要自己实现java.lang.reflect.InvocationHandler接口，并在invoke方法中实现对委托类的代理访问。

   

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


//步骤1：通过实现InvocationHandler接口创建自己的调用处理器
public class CalculatorHandler implements InvocationHandler{
//InvocationHandler类，定义了 一个invoke方法，用于处理在动态代理类对象上的方法调用。
//通常开发人员需要实现该接口，并在invoke方法中实现对委托类的代理访问。
	
    private Object objOriginal;
    public CalculatorHandler(Object obj){
    	this.objOriginal=obj;
    }
    
    //invoke方法：负责处理动态代理类上的所有方法调用。包含三个参数，分别代表
    //@Object   代理类实例
    //@method   被调用的方法对象
    //@args    调用参数
    //调用处理器根据这三个参数进行预处理或分派到委托类实例上执行。
	@Override
	public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
		// TODO Auto-generated method stub
		
		Object result = method.invoke(this.objOriginal, args);
		
		return result;
	}

}

调用测试：

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Proxy;

public class DynamicProxyExample {
    public static void main(String args[]) throws NoSuchMethodException, SecurityException, InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException{
    	CalculatorProtocol server = new Server1();
    	
    	//1.创建自己的类调用处理器
    	InvocationHandler handler= new CalculatorHandler(server);
    	
    	
    	//Proxy.newProxyInstance方法封装了以下步骤：
    	/*
    	//1.通过为Proxy类制定ClassLoader对象和一组interface创建动态代理类   
    	Class clazz=Proxy.getProxyClass(server.getClass().getClassLoader(), server.getClass().getInterfaces());
    	//2.通过反射机制获取动态代理类的构造函数，其参数类型是调用处理器接口类型
    	Constructor constructor = clazz.getConstructor(new Class[]{InvocationHandler.class});
    	//3.通过构造函数创建代理类实例
    	CalculatorProtocol proxy = (CalculatorProtocol)constructor.newInstance(new Object[]{handler});
    	*/
    	
    	CalculatorProtocol proxy1 = (CalculatorProtocol)Proxy.newProxyInstance
    			(server.getClass().getClassLoader(), 
    					server.getClass().getInterfaces(),
    					handler);
    	
    	int r=proxy1.add(5, 3);
        System.out.println("5+3="+r);
      
        r=proxy1.subtract(10, 2);
        System.out.println("10-2="+r);
    	
    }
}