Java代理模式

定义：

​ 代理模式是常用的java设计模式，他的特征是代理类与委托类有同样的接口，代理类主要负责为委托类预处理消息、过滤消息、把消息转发给委托类，以及事后处理消息等。代理类与委托类之间通常会存在关联关系，一个代理类的对象与一个委托类的对象关联，代理类的对象本身并不真正实现服务，而是通过调用委托类的对象的相关方法，来提供特定的服务。

​ 代理分为静态代理和动态代理两种：

静态代理：由程序员创建或特定工具自动生成源代码，再对其编译。在程序运行前，代理类的.class文件就已经存在了

动态代理：在程序运行时，运用反射机制动态创建而成

静态代理样例

用户接口类：

package com.statics.proxy;public interface UserDAO{    //用户登录接口    public void login();}

用户实现类：

package com.statics.proxy;public class UserImpl implements UserDAO{    //用户登录操作    @Override    public void login()    {        System.out.println("user login!");    }}

用户代理类：

package com.statics.proxy;public class UserProxy implements UserDAO{    private UserImpl userImpl;    public UserProxy(UserImpl userImpl)    {        super();        this.userImpl = userImpl;    }    @Override    public void login()    {        //在委托类方法执行前调用相应逻辑代码        System.out.println("check username");        userImpl.login();        //在委托类方法执行前调用相应逻辑代码        System.out.println("user login result");    }}

代理测试类：

package com.statics.proxy;public class Test{    public static void main(String[] args)    {        UserProxy proxy =new UserProxy(new UserImpl());        proxy.login();    }}

输出结果：

check username
user login!
user login result

​ 从上面的代码中可以看出，委托类UserImpl执行login方法，其实是通过代理类UserProxy调用UserImpl类的login方法。代理类本身并没有委托类的逻辑方法，只是通过调用委托类的方法，并且在执行委托类的方法前后调用一定的业务逻辑。

​ 静态代理虽然实现了委托类的业务逻辑，但是每一个委托类必须对应一个代理类，当委托类很多的况下，代理类也会变得很多。而且代理方法除了调用的方法不一样，其他的业务逻辑都一样，这样就代码的重用率会变得很低，同时也不利于维护。因而我们引进动态代理。

动态代理

动态代理的实现方法可以分为4种：

• JDK反射机制实现

• CGLIB

• Javassist
• asm

JDK反射机制实现动态代理

UserDAO 接口类：

package com.dynamic.proxy;public interface UserDao{    //唱歌的工作    public void sing();    //跳舞操作    public void dance()}

UserImpl 实现类：

package com.dynamic.proxy;public class UserImp implements UserDao{    //唱歌方法实现    @Override    public void sing()    {        System.out.println("sing a song..");    }    //跳舞方法实现    @Override    public void dance()    {        System.out.println("begin dance!");    }}

JDK动态代理类：

package com.dynamic.proxy;import java.lang.reflect.InvocationHandler;import java.lang.reflect.Method;public class UserProxyHandler implements InvocationHandler{    //传入委托类对象(被代理对象)    private Object realObject;    public UserProxyHandler(Object realObject)    {        super();        this.realObject = realObject;    }    @Override    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable    {        //proxy 代理类 并非委托类        //记录日志        System.out.println("log/-"+method.getName()+"- begin run");        //激活被代理类的方法        Object result = method.invoke(realObject, args);        //记录日志        System.out.println("log/-"+method.getName()+"- end of run");        return result;    }}

测试方法：

package com.dynamic.proxy;import java.lang.reflect.Proxy;public class Test{    public static void main(String[] args)    {        UserImp userImp = new UserImp();        UserProxyHandler userProxyHandler = new UserProxyHandler(userImp);        //生成代理类        UserDao userProxy = (UserDao)Proxy.newProxyInstance(UserDao.class.getClassLoader(),new Class[]{UserDao.class}, userProxyHandler);        userProxy.sing();        userProxy.dance();    }}

输入结果：

log/-method：sing- begin run
sing a song..
log/-method：sing- end of run
log/-method：dance- begin run
begin dance!
log/-method：dance- end of run

​ 上面代码中，给每个被代理类的方法执行前后加入日志记录功能。动态代理与静态代理最大的区别就是，动态代理类的字节码在程序运行的过程时由Java的反射机制动态生成，无需程序员重新编码。动态代理不仅简化了编程工作，而且提高了程序的扩展性，因为通过Java的反射机制可以生成任何类的动态代理类。

​ 但是JDK动态代理需要依靠接口实现，如果被代理类没有接口的话，则动态代理无法实现。cglib方法很好的解决了这个问题。

CGLIB动态代理

UserImpl实现类：

package com.cglib.dynamic.proxy;public class UserImp {    //    public void sing()    {        System.out.println("sing a song..");    }    public void dance()    {        System.out.println("begin dance..");    }}

cglib代理类：

package com.cglib.dynamic.proxy;import java.lang.reflect.Method;import net.sf.cglib.proxy.MethodInterceptor;import net.sf.cglib.proxy.MethodProxy;/*实现方法拦截器接口*/public class UserCglibProxy implements MethodInterceptor{    @Override    public Object intercept(Object object, Method method, Object[] arg2, MethodProxy    methodProxy) throws Throwable    {        System.out.println("log:method-" + method.getName() + "- begin runing");        System.out.println(method.getName());        System.out.println(methodProxy.getSuperName());        Object result = methodProxy.invokeSuper(object, arg2);        return result;    }}

测试类：

package com.cglib.dynamic.proxy;import net.sf.cglib.proxy.Enhancer;public class Test{    public static void main(String[] args)    {        Enhancer enhancer =new Enhancer();        //设置要创建的动态代理的类        enhancer.setSuperclass(UserImp.class);        //设置回调        enhancer.setCallback(new UserCglibProxy());        UserImp userImp =(UserImp) enhancer.create();        userImp.sing();        userImp.dance();    }}

输出结果：

log:method-sing- begin runing
sing
CGLIBsing0
sing a song..
log:method-dance- begin runing
dance
CGLIBdance1
begin dance..