Java开发中的23种设计模式详解----代理模式（Proxy）

静态代理：

其实每个模式名称就表明了该模式的作用，代理模式就是多一个代理类出来，替原对象进行一些操作，比如我们在租房子的时候回去找中介，为什么呢？因为你对该地区房屋的信息掌握的不够全面，希望找一个更熟悉的人去帮你做，此处的代理就是这个意思。再如我们有的时候打官司，我们需要请律师，因为律师在法律方面有专长，可以替我们进行操作，表达我们的想法。先来看看关系图：

 

public interface Sourceable
{
	
	public void method();
}

public class Source implements Sourceable
{

	@Override
	public void method()
	{
		System.out.println("the original method!");

	}

}

public class Proxy implements Sourceable
{

	private Source source;
	public Proxy()
	{
		super();
		this.source = new Source();
		
	}
	@Override
	public void method()
	{
		before();
		source.method();
		after();

	}
	private void after()
	{
		  System.out.println("after proxy!");  
		
	}
	private void before()
	{
		  System.out.println("before proxy!");  
		
	}

}

public class ProxyTest
{
	public static void main(String[] args)
	{
		Sourceable source = new Proxy();
		source.method();
	}
}

输出： 

 before proxy! 

the original method! 

after proxy!  

代理模式的应用场景：  如果已有的方法在使用的时候需要对原有的方法进行改进，此时有两种办法：  1、修改原有的方法来适应。这样违反了“对扩展开放，对修改关闭”的原则。  2、就是采用一个代理类调用原有的方法，且对产生的结果进行控制。这种方法就是代理模式。  使用代理模式，可以将功能划分的更加清晰，有助于后期维护！

JDK自带的动态代理，需要实现一个接口 InvocationHandler

代理模式 
代理模式是常用的java设计模式，他的特征是代理类与委托类有同样的接口，代理类主要负责为委托类预处理消息、过滤消息、把消息转发给委托类，以及事后处理消息等。代理类与委托类之间通常会存在关联关系，一个代理类的对象与一个委托类的对象关联，代理类的对象本身并不真正实现服务，而是通过调用委托类的对象的相关方法，来提供特定的服务。 
按照代理的创建时期，代理类可以分为两种。 
静态代理：由程序员创建或特定工具自动生成源代码，再对其编译。在程序运行前，代理类的.class文件就已经存在了。 
动态代理：在程序运行时，运用反射机制动态创建而成。 

 

package cn.xiaolu;

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

/**
 * 动态代理类使用到了一个接口InvocationHandler和一个代理类Proxy ，这两个类配合使用实现了动态代理的功能。
 * 那么什么是动态代理呢？
 * 我们平常说的代理类是指： 给每个具体类写一个代理类，以后要使用某个具体类时，只要创建它的代理类的对象，然后调用代理类的方法就可以了。
 * 可是如果现在有许多的具体类，那就需要有许多的代理类才可以，这样很显然不合适。所以动态代理就应运而生了，我们只要写一个类实现
 * InvocationHandler 并实现它的invoke方法，然后再用Proxy的工厂方法newProxyInstance（）创建一个代理对象，这个对象同样可以实现对具体类的代理功能。
 * 而且想代理哪个具体类，只要给Handler（以下代码中的Invoker）的构造器传入这个具体对象的实例就可以了。感觉是不是自己为该具体类造了一个代理类呢？呵呵~
 */

//接口类
interface AbstractClass {

	public void show();

}

// 具体类A
class ClassA implements AbstractClass {

	@Override
	public void show() {
		// TODO Auto-generated method stub
		System.out.println("我是A类！");
	}
}

// 具体类B
class ClassB implements AbstractClass {

	@Override
	public void show() {
		// TODO Auto-generated method stub
		System.out.println("我是B类！");
	}
}
//动态代理类，实现InvocationHandler接口
class Invoker implements InvocationHandler {
	AbstractClass ac;

	public Invoker(AbstractClass ac) {
		this.ac = ac;
	}

	@Override
	public Object invoke(Object proxy, Method method, Object[] arg)
			throws Throwable {
		//调用之前可以做一些处理
		method.invoke(ac, arg);
		//调用之后也可以做一些处理
		return null;
	}
}

/**
 * 测试类
 * @author 小路
 */
class DynamicProxyTest {

	public static void main(String[] args) {
		//创建具体类ClassB的处理对象
		Invoker invoker1=new Invoker(new ClassA());
		//获得具体类ClassA的代理
		AbstractClass ac1 = (AbstractClass) Proxy.newProxyInstance(
				AbstractClass.class.getClassLoader(),
				new Class[] { AbstractClass.class }, invoker1);
		//调用ClassA的show方法。
		ac1.show();
		
		
		//创建具体类ClassB的处理对象
		Invoker invoker2=new Invoker(new ClassB());
		//获得具体类ClassB的代理
		AbstractClass ac2 = (AbstractClass) Proxy.newProxyInstance(
				AbstractClass.class.getClassLoader(),
				new Class[] { AbstractClass.class }, invoker2);
		//调用ClassB的show方法。
		ac2.show();

	}
}

但是，JDK的动态代理依靠接口实现，如果有些类并没有实现接口，则不能使用JDK代理，这就要使用cglib动态代理了。 

Cglib动态代理 

JDK的动态代理机制只能代理实现了接口的类，而不能实现接口的类就不能实现JDK的动态代理，cglib是针对类来实现代理的，他的原理是对指定的目标类生成一个子类，并覆盖其中方法实现增强，但因为采用的是继承，所以不能对final修饰的类进行代理。 

/**
 * 这个是没有实现接口的实现类
 * 
 * @author xiaodong
 * 
 */
public class BookFacadeImpl
{
	public void addBook()
	{
		System.out.println("增加图书的普通方法");
	}
	
}

/**
 * 使用cglib动态代理
 * 
 * @author student
 * 
 */
public class BookFacadeCglib implements MethodInterceptor
{

	private Object target;

	/**
	 * 创建代理对象
	 * 
	 * @param target
	 * @return
	 */
	public Object getInstance(Object target)
	{
		this.target = target;
		Enhancer enchance = new Enhancer();
		enchance.setSuperclass(this.target.getClass());
		// 回调方法
		enchance.setCallback(this);
		return enchance.create();

	}

	@Override
	// 回调方法
	public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable
	{
		System.out.println("事物开始");
		proxy.invokeSuper(obj, args);
		System.out.println("事物结束");
		return null;
	}
}

public class TestCglib
{
	public static void main(String[] args)
	{
		BookFacadeCglib cglib = new BookFacadeCglib();
		BookFacadeImpl bookCglib = (BookFacadeImpl) cglib.getInstance(new BookFacadeImpl());
		bookCglib.addBook();
	}
}