java 高新技术【11】 java 代理类

1. 代理模式

代理模式的作用是：为其他对象提供一种代理以控制对这个对象的访问。在某些情况下，一个客户不想或者不能直接引用另一个对象，而代理对象可以在客户端和目标对象之间起到中介的作用。

代理模式一般涉及到的角色有：

抽象角色：声明真实对象和代理对象的共同接口；

代理角色：代理对象角色内部含有对真实对象的引用，从而可以操作真实对象，同时代理对象提供与真实对象相同的接口以便在任何时刻都能代替真实对象。同时，代理对象可以在执行真实对象操作时，附加其他的操作，相当于对真实对象进行封装。

真实角色：代理角色所代表的真实对象，是我们最终要引用的对象。

<span style="font-size: 18px;">public interface BookFacade {
	public void addBook();
}</span>

public class BookFacadeImpl implements BookFacade {

	@Override
	public void addBook() {
		System.out.println("這個是   增加 圖書 方法");
	}
}

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

public class BookFacadeProxy implements InvocationHandler {
	
	 private Object target;
 	 /**
 	   * 绑定委托对象并返回一个代理类
 	   * @param target
 	   * @return
 	  */
	 public Object bind(Object target) {
		 this.target = target;
		 //取得代理对象
	  	return Proxy.newProxyInstance(target.getClass().getClassLoader(),
			  target.getClass().getInterfaces(), this);   //要绑定接口(这是一个缺陷，cglib弥补了这一缺陷)
	 }

	 /***
	  * 
	  * 调用方法。
	  * 
	  */
	 public Object invoke(Object proxy, Method method, Object[] args)
	   throws Throwable {
		  Object result=null;
		  System.out.println("事物開始");
		  //ִ執行方法。
		  result=method.invoke(target, args);
		  System.out.println("事務結束");
		  return result;
	 }

}

public class TestProxy {  
  
    public static void main(String[] args) {  
        BookFacadeProxy proxy = new BookFacadeProxy();  
        BookFacade bookProxy = (BookFacade) proxy.bind(new BookFacadeImpl());  
        System.out.println("----開始----");
        bookProxy.addBook();  
        System.out.println("----結束----");
    }  
  
}  

2.动态代理类

Java动态代理类位于Java.lang.reflect包下，一般主要涉及到以下两个类：

(1). Interface InvocationHandler：该接口中仅定义了一个方法Object：invoke(Object obj,Method method, Object[] args)。在实际使用时，
第一个参数obj一般是指代理类，method是被代理的方法，如上例中的request()，args为该方法的参数数组。这个抽象方法在代理类中动态实现。


(2).Proxy：该类即为动态代理类，作用类似于上例中的ProxySubject，其中主要包含以下内容：

Protected Proxy(InvocationHandler h)：构造函数，估计用于给内部的h赋值。

Static Class getProxyClass (ClassLoader loader, Class[] interfaces)：获得一个代理类，其中loader是类装载器，interfaces是真实类所拥有的全部接口的数组。

Static Object newProxyInstance(ClassLoader loader, Class[] interfaces, InvocationHandler h)：返回代理类的一个实例，返回后的代理类可以当作被代理类使用(可使用被代理类的在Subject接口中声明过的方法)。


所谓Dynamic Proxy是这样一种class：它是在运行时生成的class，在生成它时你必须提供一组interface给它，然后该class就宣称它实现了这些interface。你当然可以把该class的实例当作这些interface中的任何一个来用。当然啦，这个Dynamic Proxy其实就是一个Proxy，它不会替你作实质性的工作，在生成它的实例时你必须提供一个handler，由它接管实际的工作。
在使用动态代理类时，我们必须实现InvocationHandler接口

package com.itm.itcast;

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.Collection;

public class ProxyTest {

	/**
	 * @param args
	 * @throws Exception 
	 * @throws SecurityException 
	 */
	public static void main(String[] args) throws SecurityException, Exception {
		
		Class clazzProxy1 = Proxy.getProxyClass(Collection.class.getClassLoader(), Collection.class);
		System.out.println(clazzProxy1.getName());
		
		/**
		 * 
		 * 创建动态类及查看其方法列表信息
		 * 
		 */
		System.out.println("=======begin constructors list===========");
		/*
		 *  $Proxy0
			$Proxy0(java.lang.reflect.InvocationHandler)
		*/
		Constructor[] constructors = clazzProxy1.getConstructors();
		for(Constructor constructor : constructors){
			String name = constructor.getName();
			
			StringBuilder sBuilder = new StringBuilder(name);
			sBuilder.append('(');
			Class[] clazzParams = constructor.getParameterTypes();
			for(Class clazzParam : clazzParams){
				sBuilder.append(clazzParam.getName()).append(',');
			}
			if(clazzParams != null && clazzParams.length != 0){
				sBuilder.deleteCharAt(sBuilder.length() - 1);
			}
			sBuilder.append(')');
			System.out.println("...."+ sBuilder.toString());
		}
		
		System.out.println("=======begin methods list===========");
		/*
		 *  $Proxy0
			$Proxy0(java.lang.reflect.InvocationHandler)
		*/
		Method[] methods = clazzProxy1.getMethods();
		for(Method method : methods){
			String name = method.getName();
			
			StringBuilder sBuilder = new StringBuilder(name);
			sBuilder.append('(');
			Class[] clazzParams = method.getParameterTypes();
			for(Class clazzParam : clazzParams){
				sBuilder.append(clazzParam.getName()).append(',');
			}
			if(clazzParams != null && clazzParams.length != 0){
				sBuilder.deleteCharAt(sBuilder.length() - 1);
			}
			sBuilder.append(')');
			System.out.println("...."+ sBuilder.toString());
		}
		
		
		System.out.println("  以下  ：创建动态类的实例对象及调用其方法 ");
		
		Constructor constructor = clazzProxy1.getConstructor(InvocationHandler.class);
		// 
		
		class MyInvocationHandler1 implements InvocationHandler{

			@Override
			public Object invoke(Object proxy, Method method, Object[] args)
					throws Throwable {
				// TODO Auto-generated method stub
				return null;
			}
			
		}
		
		Collection proxy1 = (Collection) constructor.newInstance(new MyInvocationHandler1());
		
		System.out.println(proxy1);
	}

}

$Proxy0
=======begin constructors list===========
....$Proxy0(java.lang.reflect.InvocationHandler)
=======begin methods list===========
....add(java.lang.Object)
....hashCode()
....clear()
....equals(java.lang.Object)
....toString()
....contains(java.lang.Object)
....isEmpty()
....addAll(java.util.Collection)
....iterator()
....size()
....toArray([Ljava.lang.Object;)
....toArray()
....remove(java.lang.Object)
....containsAll(java.util.Collection)
....removeAll(java.util.Collection)
....retainAll(java.util.Collection)
....isProxyClass(java.lang.Class)
....getProxyClass(java.lang.ClassLoader,[Ljava.lang.Class;)
....getInvocationHandler(java.lang.Object)
....newProxyInstance(java.lang.ClassLoader,[Ljava.lang.Class;,java.lang.reflect.InvocationHandler)
....wait()
....wait(long,int)
....wait(long)
....getClass()
....notify()
....notifyAll()

接下来：再看一个网上的例子：

//抽象角色（之前是抽象类，现在改为接口）
  
public interface Subject  
{  
    abstract public void request();  
}  

// 具體角色  局長。
public class RealSubject implements Subject  
{  
  
    public RealSubject()  
    {  
    }  
  
    public void request()  
    {  
        System.out.println("From real subject.");  
    }  
  
} 

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

public class DynamicSubject implements InvocationHandler  
{  
    private Object sub;  
  
    public DynamicSubject()  
    {  
    }  
  
    public DynamicSubject(Object obj)  
    {  
        sub = obj;  
    }  
  
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable  
    {  
        System.out.println("before calling ：" + method);  
        //ִ执行sub下面的method方法 给这个方法传递args参数。
        method.invoke(sub, args);  
        
        System.out.println("after calling ：" + method);  
  
        return null;  
    }  
  
} 

注意些好 客户端程序：

RealSubject rs = new RealSubject(); // 在这里指定被代理类 局长
InvocationHandler ds = new DynamicSubject(rs);
Class<?> cls = rs.getClass();

// 以下是一次性生成代理

Subject subject = (Subject) Proxy.newProxyInstance(
cls.getClassLoader(), cls.getInterfaces(), ds);

subject.request();

// 客戶端。。。。
public class Client  
{  
    static public void main(String[] args) throws Throwable  
    {  
  
        RealSubject rs = new RealSubject(); // 在这里指定被代理类 局长  
        InvocationHandler ds = new DynamicSubject(rs);  
        Class<?> cls = rs.getClass();  
  
        // 以下是一次性生成代理  
  
        Subject subject = (Subject) Proxy.newProxyInstance(  
                cls.getClassLoader(), cls.getInterfaces(), ds);  
        
        subject.request();  
    }  
}