Java代理模式的三种实现及说明

当一个对象不适合或者不能被其他对象直接引用时，可以给该对象生成一个代理对象。代理对象具有被代理对象的所有功能，这样其他对象使用代理对象时一样可以达到自己的需求。

静态代理

静态代理在使用时，需要定义接口或者父类，被代理对象与代理对象一起实现相同的接口或者是继承相同父类。
首先定义接口

public interface BaseDao {
    public void add();
}

被代理对象

public class UserDao implements BaseDao {
    @Override
    public void add() {
        System.out.println("add User");
    }
}

静态代理对象

public class UserDaoStaticProxy implements BaseDao {
    private UserDao userDao;

    public UserDaoStaticProxy() {
        userDao = new UserDao();
    }

    @Override
    public void add() {
        System.out.println("执行前准备...");
        userDao.add();
        System.out.println("执行后处理...");
    }
}

使用方式

public class Run {
    public static void main(String[] args) {
        UserDaoStaticProxy userDaoStaticProxy = new UserDaoStaticProxy();
        userDaoStaticProxy.add();
    }
}

直接使用代理对象UserDaoStaticProxy来代替UserDao来使用，因为代理对象和被代理对象有着相同的父类，所以他们有着相同的功能。
静态代理的缺点是必须为每个被代理对象生成一个代理对象，如果有几十个被代理对象的话，明显不适合用这种方式。此时我们必须使用动态代理来解决这个问题。

动态代理

动态代理有两种实现方式，一种是使用jdk自带的方式，一种是使用cglib的方式。下面我们具体演示下两种方式具体如何实现。

jdk方式实现动态代理

代理工厂类

public class DynamicProxyFactory_java {
    private Object object;//被代理对象
    public DynamicProxyFactory_java(Object object) {
        this.object = object;
    }

    public Object getProxyInstance() {
        return Proxy.newProxyInstance(
                object.getClass().getClassLoader(),
                object.getClass().getInterfaces(),//所以这种模式必须实现接口
                new InvocationHandler() {
                    @Override
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                        System.out.println("执行前准备...");
                        Object invoke = method.invoke(object, args);//执行被代理对象的方法
                        System.out.println("执行后处理...");
                        return invoke;
                    }
                }
        );
    }
}

在代理工厂的构造方法中我们传入需要被代理的对象，再通过调用getProxyInstance()方法即可获取代理对象，使用方式如下

public class Run {
    public static void main(String[] args) {
        BaseDao baseDao = new UserDao();
        BaseDao userDao = (BaseDao) new DynamicProxyFactory_java(baseDao).getProxyInstance();
        userDao.add();
        System.out.println("代理前对象：" + baseDao.getClass().getName());
        System.out.println("代理后对象：" + userDao.getClass().getName());
    }
}

执行后结果

执行前准备...
add User
执行后处理...
代理前对象：proxy.UserDao
代理后对象：com.sun.proxy.$Proxy0

我们使用代理工厂，就可以生产出所有符合需求的代理对象，不需要为每个被代理对象创建一个代理对象。
但是这种动态代理不足之处在于被代理对象必须要实现一个接口。如果有一个需要被代理的对象没有实现接口，怎么办呢？往下看！

cglib动态代理

cglib动态代理并不是jdk自带的方式，因此我们必须引入第三方jar包(比如：cglib-3.0.12.jar)。
cglib动态代理工厂

public class DynamicProxyFactory_cglib implements MethodInterceptor {
    private Object object;//被代理对象
    public DynamicProxyFactory_cglib(Object object) {
        this.object = object;
    }

    /**
     * 创建代理对象
     *
     * @return
     */
    public Object getProxyInstance() {
        //工具类
        Enhancer enhancer = new Enhancer();
        //设置父类
        enhancer.setSuperclass(object.getClass());
        //设置回调函数
        enhancer.setCallback(this);
        //创建对象并返回
        return enhancer.create();
    }

    @Override
    public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
        System.out.println("执行前准备...");
        Object invoke = method.invoke(object, args);
        System.out.println("执行后处理...");
        return invoke;
    }
}

假设我们有一个需要被代理的对象，但是没有实现任何的接口

//没有实现任何的接口
public class MenuDao {
    public void add() {
        System.out.println("add Menu");
    }
}

cglib动态代理使用方式

public class Run {
    public static void main(String[] args) {
        MenuDao dao = new MenuDao();
        MenuDao menuDao = (MenuDao) new DynamicProxyFactory_cglib(dao).getProxyInstance();
        System.out.println("代理前对象：" + dao.getClass().getName());
        System.out.println("代理后对象：" + menuDao.getClass().getName());
        menuDao.add();
    }
}

执行后结果如下

代理前对象：proxy.MenuDao
代理后对象：proxy.MenuDao$$EnhancerByCGLIB$$bbcb6715
执行前准备...
add Menu
执行后处理...

Cglib代理，也叫作子类代理，它是在内存中构建一个子类对象从而实现对目标对象功能的扩展。
既然有两种动态代理模式，那么到底使用哪种方式呢？这里我们看下springAop中是如何实现的

public class DefaultAopProxyFactory implements AopProxyFactory, Serializable {
    @Override
    public AopProxy createAopProxy(AdvisedSupport config) throws AopConfigException {
        if (config.isOptimize() || config.isProxyTargetClass() || hasNoUserSuppliedProxyInterfaces(config)) {
            Class<?> targetClass = config.getTargetClass();
            if (targetClass == null) {
                throw new AopConfigException("TargetSource cannot determine target class: " +
                        "Either an interface or a target is required for proxy creation.");
            }
            if (targetClass.isInterface() || Proxy.isProxyClass(targetClass)) {
                return new JdkDynamicAopProxy(config);
            }
            return new ObjenesisCglibAopProxy(config);
        }
        else {
            return new JdkDynamicAopProxy(config);
        }
    }
}

上述代码中，我们只需要关注判断条件：targetClass.isInterface()，看方法名字就知道判断这个类是不是接口。如果是接口，那么就使用jdk动态代理来实现，否则就使用Cglib动态代理来实现。