静态代理和动态代理对比

静态代理相对动态代理

  缺点：每当你需要代理的方法越多的时候，那么你需要编写的重复代码就越多；

            假如需要代理的主体类有很多个方法需要委托代理，那么代理类需要编写很多的实现方法，并且有时候在执行Proxy代理的Before、Afte业务逻辑r操作代码都是相同的，这样就尴尬了，重复的代码太多，没有营养，这时候就出现了动态代理的概念

1、编写一个接口Subject

package com.neusoft.pattern.staticProxy;

/**
 * <p>Title:</p>
 * <p>Description:代理接口对象</p>
 * <p>Copyright:Copyright (c) 2018</p>
 * <p>Company:东软集团股份有限公司</p>
 * CreateDate:2018/4/19 0019 下午 18:00
 * Author:段美林[duanml@neusoft.com]
 * Version:1.0
 */
public interface Subject {

    void request();

    void response();
}

2、编写一个实现了接口的被代理类 RealSubject

package com.neusoft.pattern.staticProxy;

/**
 * <p>Title:</p>
 * <p>Description:需要被代理实现的主体类</p>
 * <p>Copyright:Copyright (c) 2018</p>
 * <p>Company:东软集团股份有限公司</p>
 * CreateDate:2018/4/19 0019 下午 18:14
 * Author:段美林[duanml@neusoft.com]
 * Version:1.0
 */
public class RealSubject implements Subject {


    @Override
    public void request() {
        System.out.println("real subject execute request=========");
    }

    @Override
    public void response() {
        System.out.println("real subject execute response=========");
    }
}

*********下面分别采用动态代理的方式实现 对主体类的代理*************************

*********动态代理：实现方式有两种分别如下：***********************

第一种方式：基于接口的代理实现方式；  ----------> 标准的JDK动态代理；  有如下几个要点

    a、基于Java.lang.reflect.Proxy 来动态生成被代理的主体类；

    b、必须实现接口：InvocationHandler接口；

    c、只能基于接口进行动态代理，即被代理类必须是基于接口的编程类，否则不能进行动态代理；

    d、必须拥有被代理类的引用 RealSubject，并且通过构造方法传入引用；

    e、利用JAVA反射 method.invoke(realSubject,args) 执行被代理类的本身业务逻辑；

3、编写JDK动态代理类的实现 JDKProxySubject

package com.neusoft.pattern.JDKProxy;

import com.neusoft.pattern.staticProxy.RealSubject;

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

/**
 * <p>Title:</p>
 * <p>Description:JDK的动态代理实现方式</p>
 * <p>Copyright:Copyright (c) 2018</p>
 * <p>Company:东软集团股份有限公司</p>
 * CreateDate:2018/4/19 0019 下午 19:13
 * Author:段美林[duanml@neusoft.com]
 * Version:1.0
 */
public class JDKProxySubject implements InvocationHandler{

    private RealSubject realSubject;

    public JDKProxySubject(RealSubject realSubject) {
        this.realSubject = realSubject;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

        System.out.println("JDK动态代理运行，执行：Before " + method.getName() + " is invoked~~~~~~");

        Object result = null;

        try {
            result = method.invoke(realSubject,args);
        } catch (Exception e) {
            System.out.println("ex:"+e.getMessage());
            throw e;
        } finally {
            System.out.println("JDK动态代理运行，执行：After " + method.getName() + " is invoked~~~~~~");
        }
        return result;
    }
}

编写客户端调用类 JDKClient

package com.neusoft.pattern.JDKProxy;

import com.neusoft.pattern.staticProxy.RealSubject;
import com.neusoft.pattern.staticProxy.Subject;

import java.lang.reflect.Proxy;

/**
 * <p>Title:</p>
 * <p>Description:JDK动态代理类的客户端</p>
 * <p>Copyright:Copyright (c) 2018</p>
 * <p>Company:东软集团股份有限公司</p>
 * CreateDate:2018/4/19 0019 下午 19:23
 * Author:段美林[duanml@neusoft.com]
 * Version:1.0
 */
public class JDKClient {

    public static void main(String[] args) {

        Subject subject = (Subject) Proxy.newProxyInstance(JDKClient.class.getClassLoader(),
                new Class[]{Subject.class}, new JDKProxySubject(new RealSubject()));

        subject.response();
    }
}

执行结果为：

第二种方式：基于继承的代理实现方式； -----------> CgLib的第三方架构实现；有如下几个要点：

a、必须实现接口 MethodInterceptor  ；

b、重写intercept()方法，实现嵌入业务逻辑代码；

c、利用JAVA反射 methodProxy.invokeSuper(object,args)  执行被代理类的本身业务逻辑；

d、客户端调用类采用 Enhancer  类来操作设置相应的关系；

4、编写CgLibdon动态代理类的实现：CgLibProxySubject

package com.neusoft.pattern.CgLibProxy;

import org.springframework.cglib.proxy.MethodInterceptor;
import org.springframework.cglib.proxy.MethodProxy;

import java.lang.reflect.Method;

public class CgLibProxySubject implements MethodInterceptor{


    @Override
    public Object intercept(Object object, Method method, Object[] args,
                            MethodProxy methodProxy) throws Throwable {

        System.out.println("CgLib动态代理运行，执行：Before " + method.getName() + " is invoked~~~~~~");
        Object result = null;
        try {
            result = methodProxy.invokeSuper(object,args);
        } catch (Exception e) {
            System.out.println("ex:"+e.getMessage());
            throw e;
        } finally {
            System.out.println("CgLib动态代理运行，执行：After " + method.getName() + " is invoked~~~~~~");
        }
        return result;
    }
}

 编写客户端调用类：CgLibClient

package com.neusoft.pattern.CgLibProxy;

import com.neusoft.pattern.staticProxy.RealSubject;
import com.neusoft.pattern.staticProxy.Subject;
import org.springframework.cglib.proxy.Enhancer;

public class CgLibClient {

    public static void main(String[] args) {
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(RealSubject.class);
        enhancer.setCallback(new CgLibProxySubject());
        Subject subject = (Subject) enhancer.create();
        subject.request();

    }
}

执行运行结果如下：

写在最后：  JDK动态代理和CgLib动态代理对比

1、JDK动态代理只能针对实现了某个接口的类，然后对这个接口方法进行动态代理；

2、CgLib动态代理是基于类继承的方式来实现代理，无法对static、final类进行动态代理；

3、CgLib动态代理是基于类继承的方式来实现代理，无法对private、static方法进行动态代理；

4、JDK动态代理是基于接口实现的代理，因为接口中不能申明为private类型的方法，所以JDK也不能对private的方法进行动态代理；