Java动态代理与CGLIB

1. 静态代理模式

由于须要对一些函数进行二次处理，或是某些函数不让外界知道时，可使用代理模式，经过访问第三方，间接访问原函数的方式，达到以上目的，来看一下代理模式的类图：

interface Hosee{
	String sayhi();
}

class Hoseeimpl implements Hosee{

	@Override
	public String sayhi()
	{
		return "Welcome oschina hosee's blog";
	}
	
}

class HoseeProxy implements Hosee{

	Hosee h;
	
	public HoseeProxy(Hosee h)
	{
		this.h = h;
	}
	
	@Override
	public String sayhi()
	{
		System.out.println("I'm proxy!");
		return h.sayhi();
	}
	
}


public class StaticProxy
{

	public static void main(String[] args)
	{
		Hoseeimpl h = new Hoseeimpl();
		HoseeProxy hp = new HoseeProxy(h);
		System.out.println(hp.sayhi());
	}

}

1.1 静态代理的弊端

    若是要想为多个类进行代理，则须要创建多个代理类，维护难度加大。

    仔细想一想，为何静态代理会有这些问题，是由于代理在编译期就已经决定，若是代理哪一个发生在运行期，这些问题解决起来就比较简单，因此动态代理的存在就颇有必要了。

2. 动态代理

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

interface HoseeDynamic
{
	String sayhi();
}

class HoseeDynamicimpl implements HoseeDynamic
{
	@Override
	public String sayhi()
	{
		return "Welcome oschina hosee's blog";
	}
}

class MyProxy implements InvocationHandler
{
	Object obj;
	public Object bind(Object obj)
	{
		this.obj = obj;
		return Proxy.newProxyInstance(obj.getClass().getClassLoader(), obj
				.getClass().getInterfaces(), this);
	}
	@Override
	public Object invoke(Object proxy, Method method, Object[] args)
			throws Throwable
	{
		System.out.println("I'm proxy!");
		Object res = method.invoke(obj, args);
		return res;
	}
}

public class DynamicProxy
{
	public static void main(String[] args)
	{
		MyProxy myproxy = new MyProxy();
		HoseeDynamicimpl dynamicimpl = new HoseeDynamicimpl();
		HoseeDynamic proxy = (HoseeDynamic)myproxy.bind(dynamicimpl);
		System.out.println(proxy.sayhi());
	}
}

类比静态代理，能够发现，代理类不须要实现原接口了，而是实现InvocationHandler。经过

Proxy.newProxyInstance(obj.getClass().getClassLoader(), obj
				.getClass().getInterfaces(), this);

来动态生成一个代理类，该类的类加载器与被代理类相同，实现的接口与被代理类相同。

经过上述方法生成的代理类至关于静态代理中的代理类。

这样就实现了在运行期才决定代理对象是怎么样的，解决了静态代理的弊端。

当动态生成的代理类调用方法时，会触发invoke方法，在invoke方法中能够对被代理类的方法进行加强。

经过动态代理能够很明显的看到它的好处，在使用静态代理时，若是不一样接口的某些类想使用代理模式来实现相同的功能，将要实现多个代理类，但在动态代理中，只须要一个代理类就行了。

除了省去了编写代理类的工做量，动态代理实现了能够在原始类和接口还未知的时候，就肯定代理类的代理行为，当代理类与原始类脱离直接联系后，就能够很灵活地重用于不一样的应用场景中。

2.1 动态代理的弊端

代理类和委托类须要都实现同一个接口。也就是说只有实现了某个接口的类可使用Java动态代理机制。可是，事实上使用中并非遇到的全部类都会给你实现一个接口。所以，对于没有实现接口的类，就不能使用该机制。

而CGLIB则能够实现对类的动态代理

2.2 回调函数原理

上文说了，当动态生成的代理类调用方法时，会触发invoke方法。

很显然invoke方法并非显示调用的，它是一个回调函数，那么回调函数是怎么被调用的呢？

上述动态代理的代码中，惟一不清晰的地方只有

Proxy.newProxyInstance(obj.getClass().getClassLoader(), obj
				.getClass().getInterfaces(), this);

跟踪这个方法的源码，能够看到程序进行了验证、优化、缓存、同步、生成字节码、显示类加载等操做，前面的步骤并非咱们关注的重点，而最后它调用了

byte[] proxyClassFile = ProxyGenerator.generateProxyClass(
                proxyName, interfaces);

该方法用来完成生成字节码的动做，这个方法能够在运行时产生一个描述代理类的字节码byte[]数组。

在main函数中加入

System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles","true");

加入这句代码后再次运行程序，磁盘中将会产生一个名为"$Proxy().class"的代理类Class文件，反编译（反编译工具我使用的是 JD-GUI ）后能够看见以下代码：

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

public final class $Proxy0 extends Proxy
  implements HoseeDynamic
{
  private static Method m1;
  private static Method m3;
  private static Method m0;
  private static Method m2;

  public $Proxy0(InvocationHandler paramInvocationHandler)
    throws 
  {
    super(paramInvocationHandler);
  }

  public final boolean equals(Object paramObject)
    throws 
  {
    try
    {
      return ((Boolean)this.h.invoke(this, m1, new Object[] { paramObject })).booleanValue();
    }
    catch (Error|RuntimeException localError)
    {
      throw localError;
    }
    catch (Throwable localThrowable)
    {
      throw new UndeclaredThrowableException(localThrowable);
    }
  }

  public final String sayhi()
    throws 
  {
    try
    {
      return (String)this.h.invoke(this, m3, null);
    }
    catch (Error|RuntimeException localError)
    {
      throw localError;
    }
    catch (Throwable localThrowable)
    {
      throw new UndeclaredThrowableException(localThrowable);
    }
  }

  public final int hashCode()
    throws 
  {
    try
    {
      return ((Integer)this.h.invoke(this, m0, null)).intValue();
    }
    catch (Error|RuntimeException localError)
    {
      throw localError;
    }
    catch (Throwable localThrowable)
    {
      throw new UndeclaredThrowableException(localThrowable);
    }
  }

  public final String toString()
    throws 
  {
    try
    {
      return (String)this.h.invoke(this, m2, null);
    }
    catch (Error|RuntimeException localError)
    {
      throw localError;
    }
    catch (Throwable localThrowable)
    {
      throw new UndeclaredThrowableException(localThrowable);
    }
  }

  static
  {
    try
    {
      m1 = Class.forName("java.lang.Object").getMethod("equals", new Class[] { Class.forName("java.lang.Object") });
      m3 = Class.forName("HoseeDynamic").getMethod("sayhi", new Class[0]);
      m0 = Class.forName("java.lang.Object").getMethod("hashCode", new Class[0]);
      m2 = Class.forName("java.lang.Object").getMethod("toString", new Class[0]);
      return;
    }
    catch (NoSuchMethodException localNoSuchMethodException)
    {
      throw new NoSuchMethodError(localNoSuchMethodException.getMessage());
    }
    catch (ClassNotFoundException localClassNotFoundException)
    {
      throw new NoClassDefFoundError(localClassNotFoundException.getMessage());
    }
  }
}

动态代理类不只代理了显示定义的接口中的方法，并且还代理了java的根类Object中的继承而来的equals()、hashcode()、toString()这三个方法，而且仅此三个方法。 

能够在上述代码中看到，不管调用哪一个方法，都会调用到InvocationHandler的invoke方法，只是参数不一样。

2.3 动态代理与静态代理的区别

1. Proxy类的代码被固定下来，不会由于业务的逐渐庞大而庞大；
2. 能够实现AOP编程，这是静态代理没法实现的；
3. 解耦，若是用在web业务下，能够实现数据层和业务层的分离。
4. 动态代理的优点就是实现无侵入式的代码扩展。 静态代理这个模式自己有个大问题，若是类方法数量愈来愈多的时候，代理类的代码量是十分庞大的。因此引入动态代理来解决此类问题

3. CGLIB

cglib是针对类来实现代理的，他的原理是对指定的目标类生成一个子类，并覆盖其中方法实现加强，但由于采用的是继承，因此不能对final修饰的类进行代理。

import java.lang.reflect.Method;

import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;

class CGlibHosee
{
	public String sayhi()
	{
		return "Welcome oschina hosee's blog";
	}
}

class CGlibHoseeProxy
{
	Object obj;

	public Object bind(final Object target)
	{
		this.obj = target;
		Enhancer enhancer = new Enhancer();
		enhancer.setSuperclass(obj.getClass());
		enhancer.setCallback(new MethodInterceptor()
		{
			@Override
			public Object intercept(Object obj, Method method, Object[] args,
					MethodProxy proxy) throws Throwable
			{
				System.out.println("I'm proxy!");
				Object res = method.invoke(target, args);
				return res;
			}
		});
		return enhancer.create();
	}

}

public class CGlibProxy
{
	public static void main(String[] args)
	{
		CGlibHosee cGlibHosee = new CGlibHosee();
		CGlibHoseeProxy cGlibHoseeProxy = new CGlibHoseeProxy();
		CGlibHosee proxy = (CGlibHosee) cGlibHoseeProxy.bind(cGlibHosee);
		System.out.println(proxy.sayhi());
	}
}

cglib须要指定父类和回调方法。固然cglib也能够与Java动态代理同样面向接口，由于本质是继承。

Reference：

1. http://blog.csdn.net/lidatgb/article/details/8941711

2. http://shensy.iteye.com/blog/1698197

3. http://www.cnblogs.com/jqyp/archive/2010/08/20/1805041.html

4. http://www.shangxueba.com/jingyan/1853835.html

5. 《深刻理解Java虚拟机》

6. http://paddy-w.iteye.com/blog/841798