JAVA设计模式（六）代理模式

概述

代理模式：首先要有接口，代理类和被代理类都实现相同的接口，最终代理的是被代理类的方法。

代理模式是Java开发中使用较多的一种设计模式。
代理设计就是为对象提供一种代理以控制对这个对象的访问。任何对原始对象的调用都要通过代理，代理对象决定是否以及何时将方法调用转到原始对象上，也即代理类方法是对被代理类方法的封装。

静态代理

静态定义代理类：代理类和被代理类在编译期间就能够确定。
局限性：不利于程序的扩展，每一个代理类只能为一个接口服务，这样一来程序开发中必然产生过多的代理。
最好可以通过一个代理类完成同一类型的全部接口的代理功能。

代理类创建步骤：
声明一个接口类型的属性；
定义构造器（接口类型参数），创建对象时传入被代理类对象，用于调用被代理类的方法；
实现接口方法。

举例：

// 接口服务
public interface Network {
	public void browse();
}
// 被代理类
class RealServer implements Network { 
	@Override
	public void browse() {
		System.out.println("真实服务器上网浏览信息");
} }
// 代理类
class ProxyServer implements Network {
	// 声明一个接口类型的属性
	private Network network;
	// 构造器初始化时 传入被代理类，用于调用被代理类的方法
	public ProxyServer(Network network) {
		this.network = network; }
	public void check() {
		System.out.println("检查网络连接等操作");
	}
	public void browse() {
		check();
		network.browse();
	} }
// 测试
public class ProxyDemo {
	public static void main(String[] args) {
		// 创建代理类对象，传入被代理类对象
		Network net = new ProxyServer(new RealServer());
		// 访问代理类对象的方法
		net.browse();
} }

动态代理

动态生成代理类。
JDK自带的动态代理，运行时动态地创建代理类，让代理类和被代理类实现相同的接口。
动态代理是指客户通过代理类来调用其它对象的方法，并且是在程序运行时根据需要动态创建目标类的代理对象。

需要用到一个类Proxy，一个接口InvokationHandler：
java.lang.reflect.Proxy ：专门完成代理的操作类，是所有动态代理类的父类。通过此类为一个或多个接口动态地生成代理类。

实现动态代理需要解决三个问题：
1 如何根据加载到内存中的被代理类及其实现的接口，动态创建一个代理类及其对象？
调用Proxy.newProxyInstance(可以使用被代理类的类加载器,被代理类实现的接口,InvokationHandler接口的匿名内部类)，利用反射创建代理类对象。
定义一个getProxyInstance(Object obj)的方法来返回代理类对象。

2 当通过代理类对象调方法时，如何动态地调用被代理类的同名方法？
通过InvokationHandler接口的来实现。
代理类对象调用方法时可以动态调用被代理类的同名方法（利用invokationHandler实现），接口声明的所有方法都被转移到调用处理器InvokationHandler一个集中的方法中处理，可以更加灵活和统一的处理众多的方法。

3 按照invokationHandler的invoke方法调用时，所有被代理类的方法都按照相同的流程进行处理，那么怎么定制的扩展不同被代理类的方法？以及同一个代理类的不同方法？
只能对于相似功能的接口类型提供代理。
可以定义好动态代理增加的通用方法（对每个动态方法都适用的扩展方法），然后再动态调用。参考面向切面编程。
写一个定义被代理类通用方法的工具类Utils，在代理方法中作为被代理方法的前后处理过程。

实现动态代理需要有接口和被代理类对象，提前创建好。
在测试类中获取该对象时需要先进行类型强转，强转成接口类型。
问题：如果一个被代理类实现了多个接口？生成的代理类可以声明为每个接口类型吗？- yes

举例：

//先有共同接口（多个接口）
public interface Interface1 {
    void interfacetest1();
}
public interface Interface2 {
    void interfacetest2();
}
//然后是被代理类，实现了多个接口
public class Interface1Impl implements Interface1,Interface2 {
    @Override
    public void interfacetest1() {
        System.out.println("执行被代理类方法：interfacetest1!");
    }

    @Override
    public void interfacetest2() {
        System.out.println("执行被代理类方法：interfacetest2!");
    }
}
//然后写动态代理方法中增加的通用方法类
public class ProxyMethodUtils {
    public static void preProcess(){
        System.out.println("代理类前处理方法");
    }
    public static void postProcess(){
        System.out.println("代理类后处理方法");
    }
}
//动态代理类
public class ProxyFactory1 {

    /**
     * @param object object是被代理类对象
     * @return
     */
    public static Object getProxyInstance(Object object){
    	//由接口object.getClass().getInterfaces()，被代理类对象object 以及 InvocationHandler实现类，动态创建代理类
		//newProxyInstance中的InvokationHandler使用了匿名实现类
        return Proxy.newProxyInstance(object.getClass().getClassLoader(),
                object.getClass().getInterfaces(), 
                该接口可以通过反射得到proxy调用的同名method(Method类型) 以及 传入方法的参数
                new InvocationHandler() {
                //invoke方法中定义了动态调用被代理类方法的加工处理流程。proxy是代理类的对象
               
                    @Override
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                    	//前处理
                        ProxyMethodUtils.preProcess();
                        //调用通过反射获取的被代理类的方法
                        Object retval = method.invoke(object,args);
                        System.out.println("被代理方法返回值：" + retval);
                        //后处理
                        ProxyMethodUtils.postProcess();
                        return retval;
                    }
                });
    }
}

public class ProxyTest {
    public static void main(String[] args) {
        //被代理类对象
        Interface1Impl interface1 = new Interface1Impl();

        //创建代理类，并声明为Interface1接口类型（被代理类实现的两个接口之一）
        Interface1 proxy1Interface1 = (Interface1) ProxyFactory1.getProxyInstance(interface1);
        
        proxy1Interface1.interfacetest1();
    }
}

参考下面面向切面编程，可以定义好动态代理增加的通用方法（对每个动态方法都适用的扩展方法），然后再动态调用。

AOP面向切面编程：抽取出通用的方法作为 真正被代理方法 的切面，再实现切面方法（被代理方法）即可，面向切面编程。
AOP代理包含了目标对象的全部方法。
但AOP代理中的方法与目标对象的方法存在差异：AOP代理里的方法可以在执行目标方法之前、之后插入一些通用处理。

反射相关知识

Class类是Reflection的根源，通过Class可以完整地得到一个类中的所有被加载的结构，针对任何你想动态加载、运行的类，唯有先获得相应的Class对象。
获取Class类的对象实例：
1）前提：若已知具体的类，通过类的class属性获取，该方法最为安全可靠，程序性能最高实例：Class clazz = String.class;
2）前提：已知某个类的实例，调用该实例的getClass()方法获取Class对象实例：Class clazz = obj.getClass();
3）前提：已知一个类的全类名，且该类在类路径下，可通过Class类的静态方法forName()获取。实例：Class clazz = Class.forName(“java.lang.String”);

通过反射，调用类中的方法:
1、找到方法：通过Class类的getMethod(String name,Class…parameterTypes)方法取得一个Method对象，并设置此方法操作时所需要的参数类型。
Method declaredMethod= clazz.getDeclaredMethod(“methodName”, Class…parameterTypes)
2、调用方法：之后使用Object invoke(Object obj, Object[] args)进行调用，并向方法中传递要设置的obj对象的参数信息。
declaredMethod.invoke(obj,Object… args) ，obj是调用方法的对象。
注：若原方法声明为private,则需要在调用此invoke()方法前，显式调用方法对象的setAccessible(true)方法，将可访问private的方法。
declaredMethod.setAccessible(true);