第二章 Java设计模式

1.java反射技术

java反射技术应用广泛，它能够配置：类的全限定名、方法和参数，完成对象的初始化，甚至是反射某些方法。
Java的反射内容繁多，包括对象的构建、反射方法、注解、参数、接口等。

1.1通过反射构建对象

ReflectServiceImpl.java

package com.lean.ssm.chapter2.reflect;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

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

}

反射生成对象

//生成一个对象 将其返回
public ReflectServiceImpl getInstance() {
		ReflectServiceImpl object = null;
		try {
		//给类加载器注册了一个类ReflectServiceImpl的全限定名，然后通过newInstance方法初始化了一个类对象
			object = (ReflectServiceImpl) Class.forName("com.lean.ssm.chapter2.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.err.println("hello " + name);
	}
	
	public ReflectServiceImpl2 getInstance() {
	    ReflectServiceImpl2 object = null;
	    try {
	    //反射生成对象
	        object = 
	            (ReflectServiceImpl2) 
	            //先通过forName加载到类的加载器
	            //再通过getConstructor方法 它的参数可以是多个（这里是String.class，意为有且只有一个参数类型为String的构建方法）
	            //再用newInstance方法生成对象
	        Class.forName("com.lean.ssm.chapter2.reflect.ReflectServiceImpl2").
	            getConstructor(String.class).newInstance("张三");
	    } catch (ClassNotFoundException | InstantiationException 
	                | IllegalAccessException | NoSuchMethodException 
	                | SecurityException | IllegalArgumentException 
	                | InvocationTargetException ex) {
	            ex.printStackTrace();
	    }
	    return object;
	}
}

反射的优点是只要配置就可以生成对象，可以解除程序的耦合度，比较灵活。
反射的缺点是运行比较慢。但是大部分情况写为了灵活度，降低程序的耦合度，我们还是会使用反射的，比如Spring IoC容器。

2.反射方法

在使用反射方法前要获取方法对象，得到了方法才能够去反射。

	public Object reflectMethod() {
		Object returnObj = null;
		ReflectServiceImpl target = new ReflectServiceImpl();
		try {
			Method method = ReflectServiceImpl.class.getMethod("sayHello", String.class);
			//当有具体的对象target，而不知道具体是哪个类时可以使用target.getClass().getMethod("sayHello",String.class);代替，第一个参数是方法名，第二个参数是参数类型
			returnObj = method.invoke(target, "张三");			//反射方法的实现 第一个参数target确定哪个对象调用方法，“张三”是参数
		} catch (NoSuchMethodException | SecurityException | IllegalAccessException | IllegalArgumentException
				| InvocationTargetException ex) {
			ex.printStackTrace();
		}
		return returnObj;
	}

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

动态代理模式和责任链模式无论在Spring还是MyBatis中都有重要的应用。
动态代理的意义在于生成一个占位（又称代理对象），来代理真实对象，从而控制真实对象的访问。
Java中有许多动态代理技术，比如JDK、CGLIB、Javassist、ASSM，其中最常用的动态代理技术有两种：一种是JDK动态代理，这是
JDK自带的功能；另一种是CGLIB，这是第三方提供的一个技术。
目前Spring常用JDK和CGLIB，而MyBatis还是用了Javassist。

2.2.1 JDK动态代理

JDK动态代理是java.lang.reflect.*包提供的方式，它必须借助一个借口才能产生代理对象，所以先定义接口：

public interface HelloWorld {
	public void sayHelloWorld();
}

然后提供实现类HelloWordImpl来实现接口：

public class HelloWorldImpl implements HelloWorld {

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

}

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

public class JdkProxyExample implements InvocationHandler {

	// 真实对象
	private Object target = null;

	/**
	 * 建立代理对象和真实对象的代理关系，并返回代理对象
	 * 
	 * @param target真实对象
	 * @return 代理对象
	 */
	public Object bind(Object target) {
		this.target = target;
		return Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), this);
	}

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

测试JDK动态代理

public static void main(String[] args) {
		JDKProxyExample jdkProxyExample = new JDKProxyExample();
		//绑定关系，因为挂在接口HelloWorld下，所以声明代理对象HelloWorld proxy
		Helloworld proxy = (Helloworld) jdkProxyExample.bind(new SayHelloWorld());
		//注意，此时HelloWorld对象已经是一个代理对象，它会进入代理的逻辑方法invoke里
		proxy.SayHelloWorlWd();

	}

输出结果

进入代理逻辑方法
在调度真实对象之前的服务
hello world
在调度真实对象之后的服务

2.2.2 CGLIB动态代理

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

public class CglibProxyExample implements MethodInterceptor {
	/**
	 * 生成CGLIB代理对象
	 * 
	 * @param cls -- Class类
	 * @return Class类的CGLIB代理对象
	 */
	public Object getProxy(Class cls) {
		// CGLIB enhancer增强类对象
		Enhancer enhancer = new Enhancer();
		// 设置增强类型
		enhancer.setSuperclass(cls);
		// 定义代理逻辑对象为当前对象，要求当前对象实现MethodInterceptor方法
		enhancer.setCallback(this);
		// 生成并返回代理对象
		return enhancer.create();
	}

	/**
	 * 代理逻辑方法
	 * 
	 * @param proxy
	 *            代理对象
	 * @param method
	 *            方法
	 * @param args
	 *            方法参数
	 * @param methodProxy
	 *            方法代理
	 * @return 代理逻辑返回
	 * @throws Throwable异常
	 */
	@Override
	public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
		System.err.println("调用真实对象前");
		// CGLIB反射调用真实对象方法
		Object result = methodProxy.invokeSuper(proxy, args);
		System.err.println("调用真实对象后");
		return result;
	}
}

2.2.3 拦截器

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);
}

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

MyInterceptor实现类

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

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

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

在JDK代理中使用拦截器

public class InterceptorJdkProxy implements InvocationHandler {

    private Object target; //真实对象
    private String interceptorClass = null;//拦截器全限定名
    
    public InterceptorJdkProxy(Object target, String interceptorClass) {
        this.target = target;
        this.interceptorClass = interceptorClass;
    }

    /**
     * 绑定委托对象并返回一个【代理占位】
     *
     * @param target 真实对象
     * @return 代理对象【占位】
     */
    public static Object bind(Object target, String interceptorClass) {
        //取得代理对象    
        return Proxy.newProxyInstance(target.getClass().getClassLoader(),
                target.getClass().getInterfaces(), 
                new InterceptorJdkProxy(target, interceptorClass));
    }

    @Override
    /**
     * 通过代理对象调用方法，首先进入这个方法.
     *
     * @param proxy --代理对象
     * @param method --方法，被调用方法
     * @param args -- 方法的参数
     */
    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;
    }

• 第一步，在bind方法中用JDK动态代理绑定了一个对象，然后返回代理对象。
• 第二步，如果没有设置拦截器，则直接反射真实对象的方法，然后结束，否则进行第三步
• 第三步，通过反射生成拦截器，并准备使用它。
• 第四步，调用拦截器的before方法，如果返回false，反射原来的方法；否则运行拦截器的around方法
• 第五步，调用拦截器的after方法
• 第六步，返回结果