java设计模式之-代理模式

代理模式

代理模式的特征是代理类与委托类（被代理类）有同样的接口，代理类主要负责为委托类预处理消息、过滤消息、把消息转发给委托类，以及事后处理消息等。代理类与委托类之间通常会存在关联关系，一个代理类的对象与一个委托类的对象关联，代理类的对象本身并不真正实现服务，而是通过调用委托类的对象的相关方法，来提供特定的服务。简单的说就是，我们在访问实际对象时，是通过代理对象来访问的，代理模式就是在访问实际对象时引入一定程度的间接性，因为这种间接性，可以附加多种用途。

1.静态代理

一般来说静态代理是我们自己来实现的，也可以借助工具来生成源码。在程序运行前，代理类、委托类、父接口都已经确定，代理类的.class文件已经生成。

• 简单实现

//父接口，用来生产car
public interface Mlb {
	void produceCar();
}

DasAuto类实现Mlb接口，具有produceCar功能。

public class DasAuto implements Mlb{
	private String factory;
	
	public DasAuto(String factory) {
		this.factory = factory;
	}
	@Override
	public void produceCar() {
		System.out.println(factory+"生产tiguan");
		
	}

}

SaicVw是DasAuto类的代理类，同样也实现了Mlb接口，且它持有了一个DasAuto 类的对象。

public class SaicVw implements Mlb{
	
	DasAuto dasAuto;
	
	public SaicVw(Mlb mlb) {
		if (mlb.getClass() == DasAuto.class) {
			this.dasAuto = (DasAuto) mlb;
		}
	}
	
	@Override
	public void produceCar() {
		dasAuto.produceCar();
	}

}

Test测试

public class Test {
	public static void main(String[] args) {
		Mlb dasAuto = new DasAuto("大众集团");
		Mlb saicVw = new SaicVw(dasAuto);
		saicVw.produceCar();
	}
	
}

运行后结果：

大众集团生产tiguan

这里是由SaicVw的对象saicVw来调用了DasAuto 中的produceCar()方法，即SaicVw代理了DasAuto。然后我们在代理类中加入一些特定的方法。

public class SaicVw implements Mlb{
	
	DasAuto dasAuto;
	
	public SaicVw(Mlb mlb) {
		if (mlb.getClass() == DasAuto.class) {
			this.dasAuto = (DasAuto) mlb;
		}
	}
	
	@Override
	public void produceCar() {
		dasAuto.produceCar();
		System.out.println("上汽大众把它加长了，变成了tiguan L");
	}

}

运行结果：

大众集团生产tiguan
上汽大众把它加长了，变成了tiguan L

通过代理类，我们可以在执行委托类特定的方法之前加入一些自定义的功能，而没有对代理类进行改动。

2.动态代理

动态代理即代理类在程序运行的时候生成，事先我们并没有指定相应的代理类代码，而是在程序运行期间，根据java代码中的“指示”来动态的进行生成。
在静态代理中，只有一个produceCar（）方法，此时若我们需要在其之前加一个before（）方法用来做前处理，这时只需要添加一行代码；但是如果存在很多方法都要做相同的前处理，那就需要写很多次重复的代码。这时候动态代理的优势就体现了出来：他可以很方便的对代理类的函数进行统一的处理，而不用修改每个代理类中的方法。

• JDK提供了Proxy类和InvocationHandler接口来实现动态代理
• Proxy类
  Proxy类中的静态方法newProxyInstance用来生成一个代理对象，代码如下：

public static Object newProxyInstance(ClassLoader loader,
                                          Class<?>[] interfaces,
                                          InvocationHandler h)
        throws IllegalArgumentException
    {
        Objects.requireNonNull(h);
		//interfaces绑定的接口，即代理类需要被绑定在哪些接口下，可以是多个接口。
        final Class<?>[] intfs = interfaces.clone();
        final SecurityManager sm = System.getSecurityManager();
        if (sm != null) {
            checkProxyAccess(Reflection.getCallerClass(), loader, intfs);
        }

        /*
         * Look up or generate the designated proxy class.
         * 查找或生成指定的代理类
         */
        Class<?> cl = getProxyClass0(loader, intfs);

        /*
         * Invoke its constructor with the designated invocation handler.
         * 调用指定的invocation对象的构造器。InvocationHandler 对象中的invoke方法用来执行委托类中的相关方法。
         */
        try {
            if (sm != null) {
                checkNewProxyPermission(Reflection.getCallerClass(), cl);
            }

            final Constructor<?> cons = cl.getConstructor(constructorParams);
            final InvocationHandler ih = h;
            if (!Modifier.isPublic(cl.getModifiers())) {
                AccessController.doPrivileged(new PrivilegedAction<Void>() {
                    public Void run() {
                        cons.setAccessible(true);
                        return null;
                    }
                });
            }
            return cons.newInstance(new Object[]{h});
        } catch (IllegalAccessException|InstantiationException e) {
            throw new InternalError(e.toString(), e);
        } catch (InvocationTargetException e) {
            Throwable t = e.getCause();
            if (t instanceof RuntimeException) {
                throw (RuntimeException) t;
            } else {
                throw new InternalError(t.toString(), t);
            }
        } catch (NoSuchMethodException e) {
            throw new InternalError(e.toString(), e);
        }
    }

一个类作为委托类的代理类，还需要实现InvocationHandler接口。我们来写一个代理类：

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

public class SaicVw implements InvocationHandler{
	
	private Object target;
	/*
	 * SaicVw为代理类，因此在该类中我们需要提供一个获取代理类对象的方法getProxyBean
	 * target:被代理的对象
	 * proxy:代理对象
	 */
	public static Object getProxyBean(Object target) {
		SaicVw saicVw = new SaicVw();
		saicVw.target = target;
		Object proxy = Proxy.newProxyInstance(target.getClass().getClassLoader(),
				target.getClass().getInterfaces(), saicVw);
		return proxy;
	}
	
	/*
	 * target:被代理的对象
	 * args:执行目标方法时传入的参数
	 */
	@Override
	public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
		Object result = method.invoke(target, args);
		System.out.println("上海大众把它加长了,变成了tiguan L");
		return result;
	}
	
	
}

测试代码：

public class Test {
	public static void main(String[] args) {
		Mlb dasAuto = new DasAuto("大众集团");
		Mlb saicVw = (Mlb) SaicVw.getProxyBean(dasAuto);
		saicVw.produceCar();
		
	}
}

输出：

大众集团生产tiguan
上海大众把它加长了,变成了tiguan L

代理对象在调用目标对象的方法时，会自动执行invoke方法，在invoke方法中我们可以添加自定义的方法来增强委托类方法的功能。

动态代理源码的分析会在后面补充。