demo---反射、JDK/CGLIB动态代理

代理模式：

在原有的服务上多加了一个占位(动态代理对象)，通过这个占位去控制服务的访问。

eg：A是某公司工程师，提供技术服务。B是公司客服，不懂技术。C是一个客户，需要公司提供技术服务。显然C只会找公司客服反应自己遇到的情况，和B进行沟通而不是A。而B会根据公司制度和业务规则来决定是否找A来提供服务。这时候B相当于一个代理，B和C直接交流，B控制了是否访问A，除此之外，B还可以提供其他服务。

MyBatis中动态代理分两种：

• 1）JDK动态代理：必须提供接口
• 2）CGLIB动态代理：不需要提供接口

反射demo：通过反射技术创建 ReflectService 对象，获取方法后通过反射调用。

反射的好处：提高了Java的灵活性和可配置性，降低模块之间的耦合。

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
public class ReflectService {
    public void sayHello(String name) {
        System.err.println("hello: " + name);
    }

    public static void main(String[] args) throws ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException {
        //通过反射创建 ReflectService 对象
        Object service = Class.forName(ReflectService.class.getName()).newInstance();
        //获取服务方法 sayHello
        Method method = service.getClass().getMethod("sayHello", String.class);
        //反射调用方法
        method.invoke(service, "xiaoming");
    }
}

JDK动态代理

• (1) 编写服务类和接口，这个是真正的服务提供者，在JDK代理中接口是必须的，这也是它的缺点。
• (2) 编写代理类，提供绑定和代理方法。

服务接口及实现类：HelloService、HelloServiceImpl

public interface HelloService {
    public void sayHello(String name);
}

public class HelloServiceImpl implements HelloService{

    @Override
    public void sayHello(String name) {
        System.err.println("hello " + name);
    }
}

代理类：HelloServiceProxy

public class HelloServiceProxy implements InvocationHandler {

    /**
     * 真实服务对象
     */
    private Object target;

    /**
     * 绑定委托对象并返回一个代理类
     * @param target
     * @return
     */
    public Object bind(Object target) {
        this.target = target;
        //取得代理对象
        return Proxy.newProxyInstance(target.getClass().getClassLoader(),
                target.getClass().getInterfaces(), this);  //jdk 代理需要提供接口
    }

    /**
     * 通过代理对象调用方法，首先进入这个方法
     * @param proxy  代理对象
     * @param method  被调用方法
     * @param args  方法的参数
     * @return
     */
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.err.println("-------------我是 JDK 动态代理-----------");
        Object result = null;
        //反射方法前调用
        System.err.println("我准备说 hello");
        //执行方法，相当于调用 HelloServiceImpl 类的 sayHello 方法
        result = method.invoke(target, args);
        //反射方法后调用
        System.err.println("我说过 hello 了");
        return result;
    }
}

Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), this);

上面这个代码让 JDK 产生一个代理对象。代理对象有三个参数：

• 类加载器：target.getClass().getClassLoader()
• 接口（代理对象挂在哪个接口下）： target.getClass().getInterfaces()
• InvocationHandler：this代表当前的 HelloServiceProxy 类，表示用HelloServiceProxy 的代理方法作为对象的代理执行者

主类：HelloServiceMain

public class HelloServiceMain {
    public static void main(String[] args) {
        HelloServiceProxy helloHandler = new HelloServiceProxy();
        HelloService proxyJdk = (HelloService) helloHandler.bind(new HelloServiceImpl());
        proxyJdk.sayHello("jdk--xiaoming");
    }
}

一旦绑定后，进入代理对象方法调用的时候就会到 HelloServiceProxy 的代理方法上，代理方法有三个参数：

• proxy：代理对象，这里是 new HelloServiceImpl()
• method：当前调用的那个方法 sayHello(String)
• args：方法的参数，这里是 jdk--xiaoming

eg：现在 HelloServiceImpl 对象用 bind 方法绑定后，返回其占位，我们再调用 proxy.sayHello("张三")，那么它就会进入到 HelloServiceProxy 的 invoke() 方法。而 invoke 参数中第一个便是代理对象 proxy，方法便是 sayHello，参数是 张三。

我们已经用 HelloServiceProxy 类的属性 target 保存了真实的服务对象，那么我们可以通过反射技术调度真实对象的方法。

result = method.invoke(target，args);

这里我们演示了 JDK 动态代理的实现，并且在调用方法前后都可以加入我们想要的东西。MyBatis 在使用 Mapper 的时候也是这样的。

结果：

CGLIB 动态代理

JDK 动态代理的一个缺陷，就是你必须要提供接口才能使用，为了克服这个缺陷，我们可以使用开源框架---CGLIB，它是一种流行的动态代理。

HelloService.java 和 HelloServiceImpl.java 都不需要改变，但是我们要实现 CGLIB 的代理类。它的实现 MethodInterceptor 的代理方法如下：

public class HelloServiceCgLib implements MethodInterceptor {

    private Object target;

    public Object getInstance(Object target) {
        this.target = target;
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(this.target.getClass());
        //回调方法
        enhancer.setCallback(this);
        //创建代理对象
        return enhancer.create();
    }

    /**
     * 回调方法
     */
    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        System.err.println("-----我是 CGLIB 的动态代理 ----");
        //反射方法前调用
        System.err.println("我准备说 hello");
        Object returnObj = methodProxy.invokeSuper(o, objects);
        //反射方法后调用
        System.err.println("我说过 hello 了");
        return returnObj;
    }
}

public class HelloServiceMain {
    public static void main(String[] args) {
        HelloServiceCgLib helloCGLIB = new HelloServiceCgLib();
        HelloService proxyCglib = (HelloService) helloCGLIB.getInstance(new HelloServiceImpl());
        proxyCglib.sayHello("cglib--xiaoming");
    }
}

这样便能够实现 CGLIB 动态代理。在 MyBatis 中通常在延迟加载的时候才会用到 CGLIB 的动态代理。