2020 Java设计模式 - 动态代理和责任链模式

Java 设计模式

1 Java 反射技术

  Java 反射技术应用广泛，它能够配置：类的全限定名、方法和参数，完成对象的初始化，甚至是反射某些方法。这样大大增强Java的可配置性，Spring IoC 的基本原理也是如此，当然Spring IoC 的代码要复杂得多。
  Java的反射内容繁多，包括对象构建、反射方法、注解、参数、接口等。下面主要讲解：对象构建（包括么有参数的和有参数的构建方法）和方法的反射调用。在Java中，反射是通过包java.lang.reflect.*来实现的。
  反射的优点：只要配置就可以生成对象，可以解除程序的耦合度，比较灵活。缺点：运行比较慢。但是大部分情况下为了灵活度，降低程序的耦合度，我们还是会使用反射的，比如：Spring IoC 容器。

1.1 通过反射构建对象

通过反射生成带有无参的构建方法：

	public class ReflectServiceImpl {
	    public void sayHello(String name){
	        System.out.println("Hello " + name );
	    }
	}

通过反射生成一个对象，然后将其返回：

    public ReflectServiceImpl getInstance(){
        ReflectServiceImpl object = null;
        try {
            // 通过反射生成一个对象，然后将其返回。
            object = (ReflectServiceImpl)Class.forName("com.feike.reflect.ReflectServiceImpl")
                    .newInstance();
        } catch (ClassNotFoundException | InstantiationException | IllegalAccessException ex){
            ex.printStackTrace();
        }
        return object;
    }

通过反射生成带有有参的构建方法：

public class ReflectServiceImpl2 {
    private String name;
    public ReflectServiceImpl2(String name ){
        this.name = name;
    }
    public void sayHello(){
        System.out.println("hello " + name);
    }
    public ReflectServiceImpl2 getInstance(){
        ReflectServiceImpl2 object = null;
        try {
            object = (ReflectServiceImpl2)Class.forName("com.feike.reflect.ReflectServiceImpl2")
                    .getConstructor(String.class).newInstance("张三");
        } catch (ClassNotFoundException | InstantiationException
                | IllegalAccessException | NoSuchMethodException
                | SecurityException | IllegalArgumentException
                | InvocationTargetException ex){
            ex.printStackTrace();
        }
        return object;
    }
}

1.2 调用反射对象的方法：

    private static void reflectMethod(){
        ReflectServiceImpl target = getInstance();
        try {
        	// 第一个参数是方法名称，第二个参数是参数类型，是一个列表，多个参数可以继续编写多个类型。
            Method method = ReflectServiceImpl.class.getMethod("sayHello", String.class);
            method.invoke(target,"张三");
        } catch (NoSuchMethodException | SecurityException | IllegalAccessException | IllegalArgumentException
                | InvocationTargetException ex){
            ex.printStackTrace();
        }
    }

2 动态代理模式和责任链模式

  动态代理和责任链无论在Spring还是MyBatis中都有重要的应用。
  动态代理的意义在于生成一个占位（又称代理对象），来代理真实对象，从而控制真实对象的访问。

代理模式示意图：

代理必须分为两个步骤：

• 代理对象和真实对象建立代理关系。
• 实现代理对象的代理逻辑方法。

  在Java中有多种动态代理技术，比如：JDK、CGLIB、Javassist、ASM，其中最常用的动态代理技术有两种：一种是JDK动态代理，这是JDK自带的功能；另一种是CGLIB，这是第三方提供的一个技术。目前，Spring 常用JDK和CGLIB，而MyBatista还使用了Javassist,无论哪种代理，他们的理念是相似的。在JDK动态代理中我们必须使用接口，而CGLIB不需要。

2.1 JDK 动态代理

第一步：建立代理对象和真实对象的关系。
第二步：实现代理逻辑方法。
定义接口：

public interface HelloWorld {
    public void sayHelloWorld();
}

实现接口：

public class HelloWorldImpl implements HelloWorld {

    @Override
    public void sayHelloWorld() {
        System.out.println("Hello World !");
    }
}

动态代理绑定和代理逻辑实现：
  在JDK动态代理中，要实现代理逻辑必须去实现java.lang.reflect.InvocationHandler接口，他里面定义了一个invoke方法，并提供接口数组用于下挂代理对象

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

public class JdkProxyExample implements InvocationHandler {
    // 真实对象
    private Object target = null;

    /**
     * @method bind
     * @author Feike
     * @version  1.0
     * @description 建立代理对象和真实对象的代理关系，并返回代理对象。
     * @param target 真实对象
     * @return java.lang.Object 代理对象
     * @date 2020/6/18 22:30
     */
    public Object bind(Object target){
        this.target = target;
        return Proxy.newProxyInstance(target.getClass().getClassLoader(),target.getClass().getInterfaces(),this);
    }

    /**
     * @method invoke
     * @author Feike
     * @version  1.0
     * @description 代理方法逻辑
     * @param proxy 代理对象
     * @param method 当前调度方法
     * @param args 当前方法参数
     * @return 代理结果返回
     * @exception Throwable 异常
     * @date 2020/6/18 22:32
     */
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("进入代理逻辑方法");
        System.out.println("在调度真实对象之前的服务");
        //相当于调用sayHelloWorld 方法
        Object obj = method.invoke(target,args);
        System.out.println("在调用真实对象之后的服务");
        return obj;
    }
}

测试 JDK 动态代理

    @Test
    public void testJdkProxy(){
        JdkProxyExample jdkProxyExample = new JdkProxyExample();
        // 绑定关系，因为挂在HelloWorld 下，所以申明代理对象HelloWorld proxy
        HelloWorld proxy = (HelloWorld) jdkProxyExample.bind(new HelloWorldImpl());
        // 注意，此时的HelloWorld对象已经是一个代理对象，它会进入代理的逻辑invoke里
        proxy.sayHelloWorld();
    }

测试结果

进入代理逻辑方法
在调度真实对象之前的服务
Hello World !
在调用真实对象之后的服务

2.2 CGLIB 动态代理

  JDK 动态代理必须提供接口才能实现，在一些不能提供接口的环境中，只能采取第三方技术，比如CGLIB动态代理。它的的优势在于不需要提供接口，只要一个非抽象类就能实现动态代理。
写法一：
生成CGLIB代理对象，实现代理方法：

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

import java.lang.reflect.Method;

/**
 * @ProjectName: chapter2
 * @Package: com.feike.proxy
 * @ClassName: CglibProxyExample
 * @author: Feike
 * @description: 生成CGLIB代理对象，实现代理方法
 * @date: 2020/6/21 10:51
 * @version: 1.0
 */
public class CglibProxyExample implements MethodInterceptor {

    /**
     * @method getProxy
     * @author Feike
     * @version  1.0
     * @description 生成CGLIB代理对象
     * @param cls -- Class类
     * @return java.lang.Object
     * @date 2020/6/21 11:57
     */
    public Object getProxy(Class cls){
        // CGLIB enhancer 增强类对象
        Enhancer enhancer = new Enhancer();
        // 设置增强类型
        enhancer.setSuperclass(cls);
        // 定义代理逻辑对象为当前对象，要求当前对象实现 MethodInterceptor方法
        enhancer.setCallback(this);
        // 生成并返回代理对象
        return enhancer.create();
    }

    /**
     * @method intercept
     * @author Feike
     * @version  1.0
     * @description 代理方法
     * @param o 代理对象
     * @param method 方法
     * @param objects 方法参数
     * @param methodProxy 方法代理
     * @return java.lang.Object
     * @exception Throwable 异常
     * @date 2020/6/21 11:57
     */
    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        System.out.println("调用真实对象前，时间戳："+ System.currentTimeMillis());
        // CGLIB反射调用真实对象方法
        Object result = methodProxy.invokeSuper(o,objects);
        System.err.println("调用真实对象后，时间戳："+ System.currentTimeMillis());
        return result;
    }
}

测试方法：

    @Test
    public void testCGLIBProxy(){
        CglibProxyExample cglibProxyExample = new CglibProxyExample();
        ReflectServiceImpl obj = (ReflectServiceImpl) cglibProxyExample.getProxy(ReflectServiceImpl.class);
        obj.sayHello("Feike");
    }

测试结果：

调用真实对象前，时间戳：1592828869335
Hello Feike
调用真实对象后，时间戳：1592828869343

方法二：

import com.feike.reflect.ReflectServiceImpl;
import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.InvocationHandler;

/**
 * @ProjectName: chapter2
 * @Package: com.feike.proxy
 * @ClassName: testCglib
 * @author: Feike
 * @description:
 * @date: 2020/6/22 19:51
 * @version: 1.0
 */
public class TestCglib {
    public static void main(String[] args) {
        // 创建目标对象
        final ReflectServiceImpl carService=new ReflectServiceImpl();
        // 创建代理对象
        // 创建增强器对象
        Enhancer e=new Enhancer();
        // 设置增强器的类加载器
        e.setClassLoader(carService.getClass().getClassLoader());
        // 设置代理对象父类类型
        e.setSuperclass(carService.getClass());
        // 设置回调函数
        e.setCallback((InvocationHandler) (proxy, method, args1) -> {
            System.out.println("调用真实对象前。。。");
            Object obj = method.invoke(carService, args1);
            System.out.println("调用真实对象后。。。");
            return obj;
        });
        // 创建代理对象
        ReflectServiceImpl proxy =(ReflectServiceImpl) e.create();
        // 执行代理对象业务
        proxy.sayHello("Feike");
    }
}

测试结果：

调用真实对象前。。。
Hello Feike
调用真实对象后。。。.

2.3 拦截器

  由于动态代理比较难理解，程序设计者设计一个拦截器接口供开发者使用，开发者只要知道拦截器接口的方法含义和作用即可，无须知道动态代理是怎么实现的。下面用JDK动态代理来实现一个拦截器逻辑。
定义拦截器接口：
定义了3个方法，before、around、after方法，分别给予这些方法如下逻辑定义。

• 3个方法的参数为：proxy代理对象、target 真实对象、method 方法、args运行方法参数
• before方法返回boolean值，它在真实对象前调用。当返回为true时，则反射真实对象的方法；当返回为false时，则调用around方法。
• 在before方法返回为false的情况下，调用around方法。
• 在反射真实对象方法或者around方法执行后，调用after方法。

import java.lang.reflect.Method;

/**
 - @ProjectName: chapter2
 - @Package: com.feike.intercept
 - @ClassName: Interceptor
 - @author: Feike
 - @description: 定义拦截器接口
 - @date: 2020/6/22 21:09
 - @version: 1.0
 */
public interface Interceptor {
    public boolean before(Object proxy, Object target, Method method,Object[] args);
    public void around(Object proxy, Object target, Method method,Object[] args);
    public void after(Object proxy, Object target, Method method,Object[] args);
}

实现拦截器接口：
这里有两个属性，一个是target，它是真实对象；另一个是字符串interceptorClass,它是一个拦截器的全限定名。
执行步骤：

• 在bind方法中使用JDK动态代理绑定了一个对象，然后返回代理对象。
• 如果没有设置拦截器，则直接反射真实对象的方法，然后结束，否则就进行第2步。
• 通过反射生成拦截器，并准备使用它。
• 调用拦截器的before方法，如果返回为true，反射原来的方法；否则运行拦截器的around方法。
• 调用拦截器的after方法。
• 返回结果。
  拦截器的工作流程图：
  
• 开发者只要知道拦截器的作用就可以编写拦截器了，编写完成后可以设置拦截器，这样就完成了任务，所以对于开发者而言相对简单了。
• 设计者可能是精通Java的开发人员，他来完成动态代理的逻辑。
• 设计者只会把拦截器接口暴露给开发者使用，让动态代理的逻辑在开发者的视野中“消失”。

import java.lang.reflect.Method;

/**
 * @ProjectName: chapter2
 * @Package: com.feike.intercept
 * @ClassName: MyInterceptor
 * @author: Feike
 * @description: 实现拦截器接口
 * @date: 2020/6/22 21:11
 * @version: 1.0
 */
public class MyInterceptor implements Interceptor{

    @Override
    public boolean before(Object proxy, Object target, Method method, Object[] args) {
        System.out.println("反射方法前逻辑。");
        // 不反射被代理对象原有方法
        return false;
    }

    @Override
    public void around(Object proxy, Object target, Method method, Object[] args) {
        System.out.println("取代了被代理对象的方法。");
    }

    @Override
    public void after(Object proxy, Object target, Method method, Object[] args) {
        System.out.println("反射方法后逻辑。");
    }
}

在 JDK 代理中使用拦截器：
拦截器可以进一步简化动态代理的使用方法，使程序变得更简单。

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

/**
 * @ProjectName: chapter2
 * @Package: com.feike.intercept
 * @ClassName: InterceptorJdkProxy
 * @author: Feike
 * @description: 在 JDK 代理中使用拦截器
 * @date: 2020/6/22 21:15
 * @version: 1.0
 */
public class InterceptorJdkProxy implements InvocationHandler {
    /**
     * 真实对象
     */
    private Object target;
    /**
     * 拦截器全限定名
     */
    private String interceptorClass = null;

    public InterceptorJdkProxy(Object target,String interceptorClass){
        this.target = target;
        this.interceptorClass = interceptorClass;
    }

    /**
     * @method bind
     * @author Feike
     * @version  1.0
     * @description 绑定委托对象并返回一个【代理占位】
     * @param target 真实对象
     * @param interceptorClass 拦截器全限定名
     * @return java.lang.Object
     * @date 2020/6/22 21:22
     */
    public static Object bind(Object target, String interceptorClass){
        // 取得代理对象
        return Proxy.newProxyInstance(target.getClass().getClassLoader(),
                target.getClass().getInterfaces(),
                new InterceptorJdkProxy(target,interceptorClass));
    }

    /**
     * @method invoke
     * @author Feike
     * @version  1.0
     * @description
     * @param proxy 代理对象
     * @param method 方法，被调用的方法
     * @param args 方法的参数
     * @return java.lang.Object
     * @exception Throwable 异常
     * @date 2020/6/22 21:24
     */
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        if (interceptorClass == null){
            // 没有设置拦截器则直接反射原有方法
            return method.invoke(target,args);
        }
        Object result = null;
        // 通过反射生成拦截器
        Interceptor interceptor = (Interceptor) Class.forName(interceptorClass).newInstance();
        if (interceptor.before(proxy,target,method,args)){
            // 反射原有对象方法
            result = method.invoke(target,args);
        } else {
            // 返回false执行around方法
            interceptor.around(proxy,target,method,args);
        }
        // 调用后置方法
        interceptor.after(proxy,target,method,args);
        return result;
    }
}

测试Myinterceptor拦截器

    @Test
    public void testInterceptor(){
        HelloWorld proxy = (HelloWorld) InterceptorJdkProxy.bind(new HelloWorldImpl(),"com.feike.intercept.MyInterceptor");
        proxy.sayHelloWorld();
    }

测试结果：

反射方法前逻辑。
取代了被代理对象的方法。
反射方法后逻辑。

2.4 责任链模式

  当一个对象在一条链上被多个拦截器处理（拦截器也可以选择不拦截处理它）时，我们把这样的设计模式称为责任链模式。
  责任链的优点：我们可以在传递链上加入新的拦截器，增加拦截逻辑。缺点是：会增加代理和反射，而代理和反射的性性能不高。

拦截器1：

public class Interceptor1 implements Interceptor {

    @Override
    public boolean before(Object proxy, Object target, Method method, Object[] args) {
        System.out.println("【拦截器1】的before方法");
        return true;
    }
    
    @Override
    public void around(Object proxy, Object target, Method method, Object[] args) {
        System.out.println("【拦截器1】的around方法");
    }

    @Override
    public void after(Object proxy, Object target, Method method, Object[] args) {
        System.out.println("【拦截器1】的after方法");
    }
}

拦截器2：

public class Interceptor2 implements Interceptor {

    @Override
    public boolean before(Object proxy, Object target, Method method, Object[] args) {
        System.out.println("【拦截器2】的before方法");
        return true;
    }

    @Override
    public void around(Object proxy, Object target, Method method, Object[] args) {
        System.out.println("【拦截器2】的around方法");
    }

    @Override
    public void after(Object proxy, Object target, Method method, Object[] args) {
        System.out.println("【拦截器2】的after方法");
    }
}

拦截器3：

public class Interceptor3 implements Interceptor {

    @Override
    public boolean before(Object proxy, Object target, Method method, Object[] args) {
        System.out.println("【拦截器3】的before方法");
        return true;
    }

    @Override
    public void around(Object proxy, Object target, Method method, Object[] args) {
        System.out.println("【拦截器3】的around方法");
    }

    @Override
    public void after(Object proxy, Object target, Method method, Object[] args) {
        System.out.println("【拦截器3】的after方法");
    }
}

测试：

    @Test
    public void testChain(){
        HelloWorld proxy1 = (HelloWorld) InterceptorJdkProxy.bind(new HelloWorldImpl(),"com.feike.intercept.Interceptor1");
        HelloWorld proxy2 = (HelloWorld) InterceptorJdkProxy.bind(proxy1,"com.feike.intercept.Interceptor2");
        HelloWorld proxy3 = (HelloWorld) InterceptorJdkProxy.bind(proxy2,"com.feike.intercept.Interceptor3");
        proxy3.sayHelloWorld();

    }

测试结果：

【拦截器3】的before方法
【拦截器2】的before方法
【拦截器1】的before方法
Hello World !
【拦截器1】的after方法
【拦截器2】的after方法
【拦截器3】的after方法