java静态代理和动态代理

按照代理的创建时期，代理类可以分为两种：
静态代理：由程序员创建代理类或特定工具自动生成源代码，再对其编译。在程序运行前代理类的.class文件就已经存在了。
动态代理：在程序运行时用反射机制动态创建。

静态代理

代理对象（Proxy）和目标对象（RealSubject）实现了相同的接口（Subject），目标对象作为代理对象的一个属性，具体接口实现中，代理对象可以在调用目标对象相应方法前后加上其他业务处理逻辑。
（1）Subject接口：

public interface Subject {

    public abstract void dealTask();

}

（2）RealSubject类：继承Subject接口，并实现其中的方法

public class RealSubject implements Subject {
    @Override
    public void dealTask() {
        System.out.println("我要吃饭");
    }
}

（3）代理类Proxy：继承Subject类，并把Subject作为参数通过构造参数传递。
Subject是个接口，因此在调用的时候传递的应该是他的实现类。

public class Proxy implements Subject {

    // 目标对象
    private Subject subject;

    // 通过构造方法传入目标对象
    public Proxy(Subject subject) {
        this.subject = subject;
    }

    @Override
    public void dealTask() {
        System.out.println("代理来帮你做饭");

        subject.dealTask();

        System.out.println("代理来帮你刷碗");
    }

}

（4）Client客户端调用：

public class Client {
    public static void main(String[] args) {
        // Proxy类中构造方法传递的是一个接口，在调用的时候就必须传递这个接口的实现类，因此是RealSubject
        Subject subject = new Proxy(new RealSubject());

        subject.dealTask();
    }

}

控制台输出：

代理来帮你做饭
我要吃饭
代理来帮你刷碗

---

动态代理之JDK

为某个对象提供一个代理，以控制对这个对象的访问。 代理类和委托类有共同的父类或父接口，这样在任何使用委托类对象的地方都可以用代理对象替代。代理类负责请求的预处理、过滤、将请求分派给委托类处理、以及委托类执行完请求后的后续处理。

代理模式：

（1）接口

public interface SubjectService {
    public void getName(String name);

    public void getAge(Integer age);
}

（2）实现类

public class SubjectServiceImpl implements SubjectService{
    @Override
    public void getName(String name) {
        System.out.println("getName方法的实现类:" + name);
    }

    @Override
    public void getAge(Integer age) {
        System.out.println("getage方法的实现类"+age);
    }
}

（3）代理类：继承InvocationHandler接口并重写invole方法，并把目标类作为参数传递进去

public class MyInvocationHandler implements InvocationHandler {
    // 目标方法
    private Object target;

    public MyInvocationHandler() {
    }

    // 把目标方法作为参数传递
    public MyInvocationHandler(Object target) {
        this.target = target;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        // 是getName()方法
        if ("getName".equals(method.getName())) {
            System.out.println("before----" + method.getName());
            Object result = method.invoke(target, args);
            System.out.println("after----" + method.getName());
            return result;
            // 是getAge()方法
        } else if ("getAge".equals(method.getName())) {
            System.out.println("before----" + method.getName());
            Object result = method.invoke(target, args);
            System.out.println("after----" + method.getName());
            return result;
        } else {
            Object result = method.invoke(target, args);
            return result;
        }
    }
}

（4）客户端

public class Client {
    public static void main(String[] args) {
        //多态的方式
        SubjectService subjectService = new SubjectServiceImpl();

        //参数是接口，真正调用传递的就应该是实现类
        InvocationHandler invocationHandler = new MyInvocationHandler(subjectService);

        //创建代理类
        SubjectService serviceproxy = (SubjectService) Proxy.newProxyInstance(
                subjectService.getClass().getClassLoader(), subjectService.getClass().getInterfaces(),
                invocationHandler);

        serviceproxy.getName("小红");
        serviceproxy.getAge(20);
    }
}

控制台打印：

before----getName
getName方法的实现类:小红
after----getName
before----getAge
getage方法的实现类20
after----getAge

动态代理之CGLIB

cglib需要的jar包有asm.jar、cglib.jar
cglib，code generate library，代理类可对类进行代理，使用第三方cglib库来实现，其内部使用asm框架生成代理类的字节码，其字节码文件更加复杂，不能代理final方法，因为代理类是委托类的子类。

代理对象的生成过程由Enhancer类（CGLib的字节码增强器）实现，大概步骤如下：
1、生成代理类Class的二进制字节码；
2、通过Class.forName加载二进制字节码，生成Class对象；
3、通过反射机制获取实例构造，并初始化代理类对象。

（1）定义业务逻辑

public class Subject {
    public void say(String name) {
        System.out.println("hello " + name);
    }
}

（2）实现MethodInterceptor接口，定义方法的拦截器

public class MyInterceptor implements MethodInterceptor {
    @Override
    public Object intercept(Object object, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
        System.out.println("before----------" + method.getName() + "()");

        // 调用MyInterceptor父类的方法，因为在Client类中设置了MyInterceptor的父类是Subject
        Object returnObj = methodProxy.invokeSuper(object, args);

        System.out.println("after----------" + method.getName() + "()");

        return returnObj;
    }
}

（3）使用Enhancer类生成代理类

public class Client {

    public static void main(String[] args) {
        // 利用Enhancer类生成代理类
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(Subject.class);              // 继承被代理类
        enhancer.setCallback(new MyInterceptor());          // 设置回调

        //采用多态的形式，因为上面通过setSuperclass设置了继承关系
        Subject subject = (Subject) enhancer.create();      // 生成代理对象
        subject.say("yes");
    }
}

控制台输出：

before----------say
hello yes
after----------say

---

静态代理和动态代理的比较

静态代理的优点：
（1）代理使客户端不需要知道实现类是什么，怎么做的，而客户端只需知道代理即可（解耦合）

静态代理的缺点：
（1）一个代理类只能代理一个业务类。如果业务类增加方法时，相应的代理类也要增加方法。。
（2）如果接口增加一个方法，除了实现类需要实现这个方法外，代理类也需要实现此方法。增加了代码维护的复杂度。

---

jdk和cglib动态代理实现的区别
1、jdk动态代理生成的代理类和委托类实现了相同的接口；
2、cglib动态代理中生成的字节码更加复杂，生成的代理类是委托类的子类，且不能处理被final关键字修饰的方法；
3、jdk采用反射机制调用委托类的方法，cglib采用类似索引的方式直接调用委托类方法；