先思考一下，什么是代理？ 为什么要代理？
代理 或称为 proxy 自己不用去做，别人代替你去做。
为其他对象提供一种代理以控制对这个对象的访问。
它在程序中起着非常重要的作用，比如传说中AOP,就是针对代理的一种应用，此外，在设计模式中有一
个 “代理模式”。在公司上外网，要在浏览器里设置一个HTTP代理，可见代理无处不见。
凡事由浅入深，我们先来看看demo：
静态代理
接口的定义
package com.coderpwh.demo;
/**
* Created by coderpwh on 2017/8/23.
*/
public interface Hello {
void say(String name);
}
实现类
package com.coderpwh.demo;
/**
* Created by coderpwh on 2017/8/23.
*/
public class HelloImpl implements Hello {
@Override
public void say(String name) {
System.out.println("hello!"+name);
}
}
我们在来看看代理类
package com.coderpwh.demo;
/**
* Created by coderpwh on 2017/8/23.
*/
public class HelloProxy implements Hello{
private Hello hello;
public HelloProxy() {
hello = new HelloImpl();
}
@Override
public void say(String name) {
before();
hello.say(name);
after();
}
public void before(){
System.out.println("Before");
}
public void after(){
System.out.println("After");
}
}
运行结果:
这样就是实现了一个代理，在网上教程或者设计模式书上看到 ，这个HelloProxy 就是代理设计模式
当然这也只是静态的代理模式 ，当然随着业务需要 如果都去写 HelloProxy 类似这样的代理模式，垃圾
代码会越来越多，此时我么需要动态代理，将这些垃圾Proxy 重构成动态代理。
JDK动态代理
看栗子：
package com.coderpwh.demo;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
/**
* JDK 动态代理类
* Created by coderpwh on 2017/8/23.
*/
public class DynamicProxy implements InvocationHandler {
private Object target; // 代理的目标对象
public DynamicProxy(Object target){ // 构造方法
this.target = target;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
before();
Object result = method.invoke(target,args);
after();
return result;
}
private void before() {
System.out.println("before");
}
private void after(){
System.out.println("After");
}
// 注: <T> 是定义泛型,T 是使用泛型.
/**
* ClassLoader 类加载器
* Interface 目标对象实现的接口
* this 目标对象
* @param <T>
* @return
*/
// <T> 是定义泛型 ,后面的T就是泛型
public <T> T getProxy(){
return (T) Proxy.newProxyInstance(target.getClass().getClassLoader(),target.getClass().getInterfaces(),this);
}
}
DynamicProxy implements InvocationHandler ,DynamictProxy 实现了InvocationHandler
接口 当然要实现它的invoke方法，在该方法中是通过反射的方式去执行 method.invoke 的。
注意 Proxy.newProxyInstance 方法中参数，
ClassLoader 类加载器
Interface 实现类所有接口
this 代理对象
测试类
package com.coderpwh.demo;
/**
* Created by coderpwh on 2017/8/23.
*/
public class DynamicTest {
public static void main(String[] args) {
DynamicProxy dynamicProxy = new DynamicProxy(new HelloProxy()); // 有参构造
Hello helloProxy = dynamicProxy.getProxy();
helloProxy.say("jack");
}
}
运行结果:
此时思考一下JDK动态代理比静态代理好在哪里？
在静态代理中，接口变了，实现类也要变，代理类也要变，而在动态代理中，接口变了，代理类不用变。
接着思考，怎样代理没有接口的类？
CGLib代理
CGLib代理类：
package com.coderpwh.demo;
import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;
import java.lang.reflect.Method;
public class CGLibDynamicProxy implements MethodInterceptor {
/**
* 构造函数私有,成员变量私有
*/
private static CGLibDynamicProxy instance = new CGLibDynamicProxy();
private CGLibDynamicProxy() {
}
public static CGLibDynamicProxy getInstance() {
return instance;
}
// <T> 定义泛型 而后面的T 就是表示泛型 如:String ,Integer
@SuppressWarnings("unchecked")
public <T> T getProxy(Class<T> cls) {
return (T) Enhancer.create(cls, this);
}
@Override
public Object intercept(Object target, Method method, Object[] args, MethodProxy proxy) throws Throwable {
before();
Object result = proxy.invokeSuper(target, args);
after();
return result;
}
private void after() {
System.out.println("After");
}
private void before() {
System.out.println("Before");
}
}
测试类
package com.coderpwh.demo;
/**
* Created by hello world on 2017/8/25.
*/
public class CGLibTest {
public static void main(String[] args) {
Hello helloProxy = CGLibDynamicProxy.getInstance().getProxy(HelloImpl.class);
helloProxy.say("jack");
}
}
实现CGLib代理 ，要实现 MethodInterceptor 接口（要导入CGLib jar包或者依赖） 填充intercept方法，
注意 intercept方法的最后一个参数
public Object intercept(Object target, Method method, Object[] args, MethodProxy proxy)
proxy ,有了这个参数我们就可以直接调用 invokeSuper(Object obj, Object[] args) 了，CGLib
代理是方法级别的代理。仔细看上面的代码，
CGLibDynamicProxy 类的构造方法是私有的，这是什么设计模式？用private 来修饰这个构造方法是为了不让外界new 它了。
最近在复习Spring ，把静态代理，JDK代理，CGLib代理 简单复习了一下。当然代理的世界远比折磨大。
后面会逐渐深入研究代理，研究Spring AOP底层实现。
