[Js-设计模式]代理模式，JDK动态代理，CGLIB动态代理，静态代理

代理模式分为静态代理和动态代理

静态代理：在程序运行之前，代理类和 目标类之间的关系就已经确立了

动态代理：在程序运行时才确立代理关系

从编写代码上来讲，一般有代理类的是静态代理，没有代理类只有代理对象（通过代理工具或者工厂生成）的成为动态代理

可以理解静态代理类为公司中的法律顾问，在日常没有官司的时候（即以·程序运行之前）就是存在的，而动态代理对象可以理解为在律师事务所（代理工具或者代理类）工作（创建）的律师（即动态代理对象）

以下用代码来演示动态代理与静态代理，

静态代理：

package com.neu.service;

// 主业务接口：本接口中的方法将要被代理类增强
public interface ISomeService {
    public String doFirst();

    public void doSecond();
}

package com.neu.service;

// 目标类：代理类要增强的类
public class SomeServiceImpl implements ISomeService {

    @Override
    public String doFirst() {
        System.out.println("执行doFirst()方法");
        return "abcde";
    }

    @Override
    public void doSecond() {
        System.out.println("执行doFirst()方法");
    }

}

package com.neu.proxy;

import com.neu.service.ISomeService;

// 静态代理，仅继承要增强的接口方法即可
public class ServiceProxy implements ISomeService {
    private ISomeService target;

    public ServiceProxy() {
    }

    public ServiceProxy(ISomeService target) {
        super();
        this.target = target;
    }

    @Override
    public String doFirst() {
        // 调用目标类的方法，该方法返回小写字母
        String result = target.doFirst();
        // 增强：将目标方法返回的小写字母变成大写
        result = result.toUpperCase();
        return result;
    }

    @Override
    public void doSecond() {
        target.doSecond();
    }

}

package com.neu.test;

import org.junit.Test;

import com.neu.proxy.ServiceProxy;
import com.neu.service.ISomeService;
import com.neu.service.SomeServiceImpl;

// 测试类
public class MyTest {

    @Test
    public void test01() {
        // ISomeService service = new SomeServiceImpl();
        ISomeService service = new ServiceProxy(new SomeServiceImpl());
        String result = service.doFirst();
        System.out.println(result);
        service.doSecond();
    }

}
/*
输出结果：
执行doFirst()方法
ABCDE
执行doFirst()方法
*/

动态代理代理的方法有很多，下面讲述两种：

JDK动态代理：

package com.neu.test;

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

import org.junit.Test;

import com.neu.service.ISomeService;
import com.neu.service.SomeServiceImpl;

// 测试类
public class MyTest {

    @Test
    public void test01() {
        ISomeService target = new SomeServiceImpl();
        // 由Proxy类的newProxyInstance()方法生成一个动态代理对象
        ISomeService service = (ISomeService) Proxy.newProxyInstance(target.getClass().getClassLoader(), // 目标类的类加载器
                target.getClass().getInterfaces(), // 目标类所实现的所有接口
                new InvocationHandler() { // 内部匿名类

                    // proxy：代理对象
                    // method：目标方法
                    // args：目标方法的参数列表
                    @Override
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                        Object result = method.invoke(target, args);
                        if (result != null) {
                            result = ((String) result).toUpperCase();
                        }
                        return result;
                    }
                });
        String result = service.doFirst();
        System.out.println(result);
        service.doSecond();
    }

}

Cglib动态代理：（目标类没有实现接口）

package com.neu.service;

// 目标类：代理类要增强的类，没有实现任何的接口
public class SomeService{

    public String doFirst() {
        System.out.println("执行doFirst()方法");
        return "abcde";
    }

    public void doSecond() {
        System.out.println("执行doFirst()方法");
    }

}

package com.neu.factory;

import java.lang.reflect.Method;

import com.neu.service.SomeService;

import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;

public class CglibFactory implements MethodInterceptor {
    private SomeService target;

    public CglibFactory() {
    }

    public CglibFactory(SomeService target) {
        this.target = target;
    }

    public SomeService myCglibCreator() {
        Enhancer enhancer = new Enhancer();
        // 因为目标类没有实现接口，所以Cglib采用指定父类，即目标类，来增强父类
        // Cglib动态代理增强的原理是：子类增强父类，所以也要求目标类不能是final的，因为final类不能被继承
        enhancer.setSuperclass(SomeService.class);
        // 设置回调接口对象
        enhancer.setCallback(this);
        // create()方法用于创建Cglib动态代理对象，即目标类的子类对象
        return (SomeService) enhancer.create();
    }

    // 回调接口的方法
    // 执行的条件是：代理对象执行目标方法时会触发该方法执行
    @Override
    public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
        Object invoke = method.invoke(target, args);
        if (invoke != null) {
            invoke = ((String) invoke).toUpperCase();
        }
        return invoke;
    }

}

package com.neu.test;

import org.junit.Test;

import com.neu.factory.CglibFactory;
import com.neu.service.SomeService;

// 测试类
public class MyTest {

    @Test
    public void test01() {
        SomeService target = new SomeService();
        SomeService service = new CglibFactory(target).myCglibCreator();
        String result = service.doFirst();
        System.out.println(result);
        service.doSecond();
    }

}

 Cglib动态代理：（目标类已经实现接口，接口和实现类用上面的即可）

package com.neu.factory;

import java.lang.reflect.Method;

import com.neu.service.ISomeService;

import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;

public class CglibFactory implements MethodInterceptor {
    private ISomeService target;

    public CglibFactory() {
    }

    public CglibFactory(ISomeService target) {
        this.target = target;
    }

    public ISomeService myCglibCreator() {
        Enhancer enhancer = new Enhancer();
        // 因为目标类没有实现接口，所以Cglib采用指定父类，即目标类，来增强父类
        // Cglib动态代理增强的原理是：子类增强父类，所以也要求目标类不能是final的，因为final类不能被继承
        enhancer.setSuperclass(ISomeService.class);
        // 设置回调接口对象
        enhancer.setCallback(this);
        // create()方法用于创建Cglib动态代理对象，即目标类的子类对象
        return (ISomeService) enhancer.create();
    }

    // 回调接口的方法
    // 执行的条件是：代理对象执行目标方法时会触发该方法执行
    @Override
    public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
        Object invoke = method.invoke(target, args);
        if (invoke != null) {
            invoke = ((String) invoke).toUpperCase();
        }
        return invoke;
    }

}

package com.neu.test;

import org.junit.Test;

import com.neu.factory.CglibFactory;
import com.neu.service.ISomeService;
import com.neu.service.SomeServiceImpl;

// 测试类
public class MyTest {

    @Test
    public void test01() {
        ISomeService target = new SomeServiceImpl();
        ISomeService service = new CglibFactory(target).myCglibCreator();
        String result = service.doFirst();
        System.out.println(result);
        service.doSecond();
    }

}

 总结：

静态代理只能解决有接口的情况，而且必须有代理类方法是创建一个实现同一个（或者几个接口）的类，实现要增强的方法，在方法中调用目标类的方法（此时，我们可以将目标类作为代理类的属性，从而得以调用目标类的方法），并加以处理

动态代理是不需要有代理类的，只需要代理工具或者代理工厂

JDK动态代理只能处理带有接口的目标类，由 Java 提供的 Proxy 类的 newProxyInstance() 方法生成一个代理对象即可，需要传入的参数是目标类的类加载器，目标类所实现的所有接口，和一个实现了 InvocationHandler 接口的类对象，在该对象的 invoke 方法中对要增强的方法进行处理

Cglib动态代理可以处理带接口和不带接口的目标类，而且实现方式相同（除了代入的类名要换成接口名字hhh），原理是没有接口，就把目标类当成父类，具体实现是写一个 Factory 实现 MethodInterceptor 接口，实现 intercept 方法，一般写法是将目标类作为 Factory 的一个属性，编写 Factory 的一个方法，首先设置父类，然后设置回调接口对象，最后返回 Enhancer 代理对象，这样在程序中我们使用返回的这个代理对象调用目标类要增强的方法时，会触发代理对象的 intercept 对方法结果进行处理

相关依赖的 junit 和 cglib 包的链接 https://pan.baidu.com/s/1EgVFhSmzanfA6sITg3i2fg ，密码是7dxz