设计模式(一) 动态代理初尝试

  • 摘要
      之前老是听说动态代理,一直没有机会好好看过,现在就把动态代理的实现逻辑和用处整理一下。
    首先提两个概念,委托类和代理类。委托类就是实际业务逻辑的处理者,代理类是处于请求发起者与委托类之间的角色,所有对委托类的请求都会经过代理类。
    就是委托类将请求处理委托给代理类,代理类可以起到方法拦截、功能增强的作用。
    实现动态代理的方式有很多,现在主流的主要jdk和cglib这两个。下面就用示例代码说明下动态代理的过程,以及用动态代理实现拦截器。
  • 用JDK实现动态代理
      jdk实现动态代理的包是java.lang.reflect.*,jdk实现动态代理有限制,委托类必须要实现接口,所以先要创建一个接口
    public interface MyInterface {
    
        //jdk
        public void tes1();
    
        //cglib
        public void test2(String val);
    
    }


    创建接口实现类

    public class MyTarget implements MyInterface {
    
        //jdk
        @Override
        public void tes1() {
            System.out.println("委托类业务处理!");
        }
    
        //cglib
        @Override
        public void test2(String val) {
            System.out.println("业务处理结果:"+val);
        }
    }


    动态代理逻辑代码

    package proxy;
    
    import java.lang.reflect.InvocationHandler;
    import java.lang.reflect.Method;
    import java.lang.reflect.Proxy;
    
    public class MyProxyTest implements InvocationHandler {  //继承InvocationHandler,拦截方法
    
        private Object target=null;
    
        //构造函数
        public MyProxyTest(Object target){
            this.target = target ;
        }
    
        //获取代理类的方法
        public static Object getProxy(Object target){
            //通过proxy创建代理类,需要三个参数,委托类的类加载器、委托类实现的接口、代理类
            /**
             * 这是jdk的动态代理模式,必须要有接口
             * proxy会把代理类挂载到所有接口下面
             * 如果委托类没有实现任何接口会有问题,改用CGLIB的enhancer增强类做动态代理
             */
            return Proxy.newProxyInstance(target.getClass().getClassLoader(),
                    target.getClass().getInterfaces(),new MyProxyTest(target));
        }
    
        //拦截方法
        @Override
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
            System.out.println("进入代理逻辑!");
            System.out.println("代理类处理逻辑!");
            Object result=null;
            result = method.invoke(target,args);
            System.out.println("委托类处理完后的逻辑!");
            return result;
        }
    }

      getProxy方法就是绑定委托类和代理类之间关系的方法,这里绑定的代理类是this当前对象,也就是MyProxyTest 的实例对象,由于实现了InvocationHandler接口,所以在方法调用之前都会
    通过invoke方法,在这里就可以写功能增强的代码。method.invoke(target,args)是通过反射运行委托类的方法。

    测试用例

    public class JunitTest {
        public static void main(String[] args) {
            /**
             * jdk动态代理
             */
            System.out.println("---------jdk动态代理--------");
            //委托类
            MyTarget target = new MyTarget();
            //给委托类绑定代理类
            MyInterface proxy = (MyInterface)MyProxyTest.getProxy(target);
            proxy.tes1();
        }
    }


    运行结果

    ---------jdk动态代理--------
    进入代理逻辑!
    代理类处理逻辑!
    委托类业务处理!
    委托类处理完后的逻辑!

    我们发现进入了代理类的处理逻辑。



  • CGLIB实现动态代理
      CGLIB实现动态代理和JDK大同小异,不过CGLIB是通过创建增强类Enhancer,并且设置Enhancer的委托类和代理类来实现动态代理。CGLIB的委托类不需要实现接口。
    动态代理逻辑
    package proxy;
    
    import org.springframework.cglib.proxy.Enhancer;
    import org.springframework.cglib.proxy.MethodInterceptor;
    import org.springframework.cglib.proxy.MethodProxy;
    
    import java.lang.reflect.Method;
    
    public class MyCgLibProxy implements MethodInterceptor {
    
        public Object getProxy(Class target){
            //创建增强类
            Enhancer enhancer = new Enhancer();
            //设置委托类
            enhancer.setSuperclass(target);
            //设置代理类
            enhancer.setCallback(this);
            return enhancer.create();
        }
    
    
        @Override
        public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
            System.out.println("进入代理逻辑!");
            System.out.println("代理类处理逻辑!");
            Object result=null;
            result = methodProxy.invokeSuper(o,objects);
            System.out.println("委托类处理完后的逻辑!");
            return result;
        }
    }

    这里的getProxy接收的不是委托类的实例对象而是委托类。代理类是this,MyCgLibProxy 的实例对象,由于实现了MethodInterceptor拦截器,所以方法调用都会经过intercept。

    测试用例

    package proxy;
    
    public class JunitTest {
        public static void main(String[] args) {
            /**
             * cglib动态代理
             */
            System.out.println("---------cglib动态代理--------");
            MyCgLibProxy cgLib = new MyCgLibProxy();
            MyInterface cgLibProxy = (MyInterface)cgLib.getProxy(MyTarget.class);
            cgLibProxy.test2("cglib动态代理");
        }
    }

    运行结果

    ---------cglib动态代理--------
    进入代理逻辑!
    代理类处理逻辑!
    业务处理结果:cglib动态代理
    委托类处理完后的逻辑!

    简单的实现动态代理的两种方式就完成了,之后再讲解拦截器和责任链模式

转载于:https://www.cnblogs.com/zhouyun-yx/p/10438383.html

你可能感兴趣的:(设计模式(一) 动态代理初尝试)