Java Proxy类及代理模式 探究

代理模式：为其他对象提供一种代理，并以控制对这个对象的访问

本文通过一个超市的场景对代理模式进行探究，希望可以抛砖引玉，与大家分享。

场景

有一个接口叫超市即Supermarket,所有的超市都要实现这个接口，超市这个接口有两个方法，buy()和sell()，buy()用来进货，sell()用来销售。常见的超市有Walmart(沃尔玛)，Carrefour(家乐福)等。

现在突然有一个需求，当地的管理部门要对沃尔玛进行监控，现在的要求是只监控卖出行为，在每个sell()动作之前需要注册，卖完之后需要公布。对buy()需求暂时没有要求。

 

解决方法

解决方法一： 静态代理

声明一个新类，继承自Walmart，重写sell()动作，将监控动作写入sell()中，该解决方法类图如下：

（由于这不是动态代理的核心，在方法二中的代码进行对比，这个顶多算一个静态代理….）

上述解决方法有两个问题，一是如果对其他超市也需要监控时，就需要重写其他超市类；

二是如果需要对沃尔玛的buy()也要监控时，就需要再次重写类，这时就引出动态代理。

解决方法二：动态代理 

动态代理将代理目标推迟到运行时刻，即在运行时可以根据需要动态地生成代理对象。

在上述方法中的场景中添加需求，对所有的超市都要进行监控，按照之前的改动，需要对所有的类都要进行改动，而且这两个超市都实现了Supermarket接口。

能不能对所有实现了Supermarket的接口的类都进行监控呢？可以，由于在编译时不能提前知道究竟是哪个类需要代理，因此需要在运行时动态地做出一些改变，需要用到jdk中Proxy类。

由于可能有多个超市，因此先用一个抽象超市类实现接口，所有超市都继承自抽象超市，由jdk中的Proxy.getProxyClass()获取代理类，再由代理类Class.getConstructor.newInstance()新建一个代理实例；或者可以直接通过Proxy.newProxyInstance()方法生成一个代理对象。在Proxy生成代理类对象的时候需要传入一个实现InvocationHandler接口的对象通过在InvocationHandler的invoke()方法中添加动作从而实现对代理对象的动态代理。两种实现如下代码所示。在代码中我把代理类的名字也打了出来，很有趣。

关于Class类可以参考java Class类探究。

关于Proxy类原理请参考java Proxy类深度探究。

类图如下：

 

代码如下：

自定义的实现InvocationHandler的类

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

public class ManagerInvocationHandler implements InvocationHandler {
	Object agent;

	public ManagerInvocationHandler(Object agent) {
		this.agent = agent;
	}

	@Override
	public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
		// TODO Auto-generated method stub
		if (method.getName().equals("sell")) {
			System.out.println(" ***** manager : before sell : register  **");
			// System.out.println("the object is instance of
			// "+proxy.getClass().getName());
			method.invoke(agent, args);
			System.out.println(" ***** manager : after sell : publish **");
		} else {
			method.invoke(agent, args);
		}
		return null;
	}

}

 Supermarket接口

public interface Supermarket {
	public void buy();
	public void sell();

}

AbstractSupermarket类

public abstract class AbstractSupermarket implements Supermarket{
	public String name;
	
	AbstractSupermarket(String name){
		this.name = name;
	}
	@Override
	public void buy() {
		// TODO Auto-generated method stub
		System.out.println(" ------ supermarket: "+name+" : buy ---------");
	}

	@Override
	public void sell() {
		// TODO Auto-generated method stub
		System.out.println(" ------ supermarket: "+name+" : sell ---------");
	}

}

Walmart类和Carrefour类

public class Walmart extends AbstractSupermarket {
	private static String marketName = "Walmart";

	Walmart() {
		super(marketName);
	}
}

public class Carrefour extends AbstractSupermarket{
	public static String name = "Carrefour";
	Carrefour() {
		super(name);
	}
}

manager类，该类中有动态代理的两种实现方法

import java.io.FileOutputStream;
import java.io.IOException;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

import sun.misc.ProxyGenerator;

public class Manager {

	// 静态代理
	public static void monitorSell(){
		ProxyWalmart walmart = new ProxyWalmart();
		walmart.sell();

	}
	
	// 动态代理的两种方法
	public static void monitorProxySell(){
		// 常规对象
		Supermarket walmart = new Walmart();
		Supermarket carrefour = new Carrefour();
		
		// 获取代理Supermarket接口的代理类
		Class proxySupermarket = Proxy.getProxyClass(walmart.getClass().getClassLoader(), walmart.getClass().getSuperclass().getInterfaces());
		try {
			// 不用代理时操作
			System.out.println(" -  -----   ###  agent : without dynamic proxy pattern ####     -----        ");
			walmart.sell();
			carrefour.sell();
			System.out.println(" -  ----- ###  agent end  ####     -----       \n ");
	
			
			System.out.println(" -  -----   ###  proxy 1 : dynamic proxy pattern   ####     -----      ");
	
			// 输出代理类的类名
			System.out.println(" The proxy class name is : " + proxySupermarket.getName()+"\n");
		    		
			// 获取代理类的Constructor，该Construtor的参数是InvocationHandler
			Constructor construtor = proxySupermarket.getConstructor(new Class[]{InvocationHandler.class});
			
			// 将被代理对象传入InvocationHandler
			ManagerInvocationHandler warlmartHandler = new ManagerInvocationHandler(walmart);
			ManagerInvocationHandler carrefourHandler = new ManagerInvocationHandler(carrefour);
	
			// 通过代理Class object的Constructor 声明一个代理对象
			Supermarket proxyWalmart = (Supermarket)construtor.newInstance(new Object[]{warlmartHandler});			
			Supermarket proxyCarrefour = (Supermarket)construtor.newInstance(new Object[]{carrefourHandler});
			
			// 调用代理类的代理方法，实质是调用InvocationHandler.invoke()方法
			proxyWalmart.sell();
			proxyCarrefour.sell();
			System.out.println(" -  -----   ###  proxy 1 end  ####     -----      \n");
	
			
	
			System.out.println(" -  -----   ###  proxy 2  : dynamic proxy pattern ####     -----        ");
			Supermarket proxyObject2 = (Supermarket) Proxy.newProxyInstance(Supermarket.class.getClassLoader(), new Class[]{Supermarket.class}, warlmartHandler);  
			proxyObject2.sell();
			proxyObject2.buy();
			System.out.println(" -  -----   ###  proxy 2 end  ####     -----      \n");
	
			
			
			
		} catch (InstantiationException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IllegalAccessException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IllegalArgumentException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (InvocationTargetException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (NoSuchMethodException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (SecurityException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
	public static void main(String [] args){
		monitorSell();
		monitorProxySell();	
	}
}

运行结果如下：

 ***** manager : before sell : register  **
 ------ supermarket: Walmart : sell ---------
 ***** manager : before sell : publish  **
 -  -----   ###  agent : without dynamic proxy pattern ####     -----        
 ------ supermarket: Walmart : sell ---------
 ------ supermarket: Carrefour : sell ---------
 -  ----- ###  agent end  ####     -----       
 
 -  -----   ###  proxy 1 : dynamic proxy pattern   ####     -----      
 The proxy class name is : com.sun.proxy.$Proxy0


 ***** manager : before sell : register  **
 ------ supermarket: Walmart : sell ---------
 ***** manager : after sell : publish **
 ***** manager : before sell : register  **
 ------ supermarket: Carrefour : sell ---------
 ***** manager : after sell : publish **
 -  -----   ###  proxy 1 end  ####     -----      


 -  -----   ###  proxy 2  : dynamic proxy pattern ####     -----        
 ***** manager : before sell : register  **
 ------ supermarket: Walmart : sell ---------
 ***** manager : after sell : publish **
 ------ supermarket: Walmart : buy ---------
 -  -----   ###  proxy 2 end  ####     -----      

解决方法三：升级版动态代理（工厂）:

利用一个工厂来制作代理对象，要求将需要代理的对象和实现的接口（jdk Proxy类需要传入接口）传入工厂。由于本文工厂模式不是重点，只是用了一个简单的工厂。

 

代码如下：

生成代理类的工厂ProxyFactory

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

public class ProxyFactory {
    public static Object getProxy(Object agent, Class[] interfaces)
            throws InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException,
            NoSuchMethodException, SecurityException {
        // 生成代理类
        Class proxyClassObj = Proxy.getProxyClass(agent.getClass().getClassLoader(), interfaces);
        InvocationHandler h = new ManagerInvocationHandler(agent);

        // 利用代理类的构造方法生成一个代理对象
        Object proxyObj = proxyClassObj.getConstructor(new Class[] { InvocationHandler.class }).newInstance(h);
        return proxyObj;
    }
}

利用工厂生成代理对象

import java.io.FileOutputStream;
import java.io.IOException;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

import sun.misc.ProxyGenerator;

public class Manager {

    public static void proxyFactorySell() {
        Supermarket walmart = new Walmart();
        try {
            Supermarket proxySupermarket = (Supermarket) ProxyFactory.getProxy(walmart,
                    walmart.getClass().getSuperclass().getInterfaces());
            proxySupermarket.sell();
        } catch (InstantiationException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IllegalArgumentException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (NoSuchMethodException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (SecurityException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {
        proxyFactorySell();

    }
}

运行结果如下：

 ***** manager : before sell : register  **
 ------ supermarket: Walmart : sell ---------

 ***** manager : after sell : publish **