SSM 学习 —— Java设计模式

一、Java反射技术

1、通过反射建立对象

新建一个对象

//ReflectServiceImp1.java
package com.lean.ssm.chapter2.reflect;

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

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

然后通过反射的方法构建(无参数构造方法):

 public ReflectServiceImp1 getInstance(){
        ReflectServiceImp1 object = null;
        try{
            object = (ReflectServiceImp1)
                    Class.forName("com.lean.ssm.chapter2.reflect.ReflectServiceImp1").newInstance();
        }catch(ClassNotFoundException | InstantiationException | IllegalAccessException e){
            e.printStackTrace();
        }
        return object;
    }

若是想要构造带有参数的，如下:

package com.lean.ssm.chapter2.reflect;

import java.lang.reflect.InvocationTargetException;

public class ReflectServiceImp2 {
    private String name;

    public ReflectServiceImp2(String name){
        this.name = name;
    }

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

通过反射构造对象：

    public ReflectServiceImp2 getInstance(){
        ReflectServiceImp2 object = null;
        try{
            object = (ReflectServiceImp2)
                    Class.forName("com.lean.ssm.chapter2.reflect.ReflectServiceImp2").getConstructor(String.class).newInstance("张三");
        }catch (ClassNotFoundException | InstantiationException
                | IllegalAccessException | NoSuchMethodException
                | SecurityException | IllegalArgumentException
                | InvocationTargetException e){
            e.printStackTrace();
        }
        return object;
    }
}

2、反射方法

以ReflectServiceImp1为例子:

public Object reflectMethod(){
        Object returnObj = null;
        ReflectServiceImp1 target = new ReflectServiceImp1();
        try{
            Method method = ReflectServiceImp1.class.getMethod("sayHello", String.class);
            returnObj = method.invoke(target, "张三");
        }catch (NoSuchMethodException | SecurityException
                | IllegalArgumentException | IllegalAccessException
                | InvocationTargetException e){
            e.printStackTrace();
        }
        return returnObj;
    }

其中,可以或许构造方法，方法，甚至是成员对象，有需要可以到网上查阅.

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

动态代理意义在于生成一个代理对象（又称占位），来代理真实对象，从而控制真实对象的访问。

就比如，我是一个软件工程师，根据需求我写了一个类，类中有一个方法，我不必要去管这个方法执行与否，我只需要交给一个代理，让他去判断。

代理必须分为两个步骤：

• 代理对象和真实对象之间建立代理关系
• 实现代理对象的代理逻辑方法（判断一个方法的执行）

Java中有多种动态代理技术，这里只讨论JDK和CGLIB

1、JDK动态代理

JDK动态代理是java.lang.reflect.*种提供的方式，必须实现一个接口才能产生代理对象，所以先定义接口,如下：

public interface HelloWorld{
    public void sayHello();
}

然后提供实现类HelloWorldImp1：

package com.lean.ssm.chapter2.reflect.proxy;

public class HelloWorldImp1 implements HelloWorld{
    @Override
    public void sayHello() {
        System.out.println("Hello World");
    }
}

开始实现代理逻辑，一共分为两个步骤，在JDK动态代理中，实现代理逻辑类必须实现java.lang.reflect.InvocationHandler接口，里面定义了一个invoke方法，并提供接口数据用于下挂代理对象：

package com.lean.ssm.chapter2.reflect.proxy;

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

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

    public static void testJdkProxy(){
        JdkProxyExample jdk = new JdkProxyExample();
        //绑定关系，因为挂在接口HelloWorld下，所以声明代理对象HelloWorld proxy
        HelloWorld proxy = (HelloWorld)jdk.bind(new HelloWorldImp1());
        // 此时HelloWorld 已经是一个代理对象，他会进入代理的逻辑方法invoke中
        proxy.sayHello();
    }

    public static void main(String[] args){
        testJdkProxy();
    }
}

第一步，建立代理对象和真实对象的关系，通过bind方法去完成。
其中，newProxyInstance包含了三个参数

• 第1个是类加载器，传入target本身的类加载器
• 第2个是把生成的动态代理对象挂在哪些接口下，这个写法就是放在target实现的接口下
• 第3个是定义实现方法逻辑的代理类（必须实现InvocationHandler接口的invoke方法。
  第二步，实现代理逻辑方法invoke,invoke方法的参数含义如下
• proxy,代理对象,就是bind方法生成的对象
• method 当前调度的方法
• args 调度的方法的参数
  当代理调用一个方法的时候，会进入这个invoke方法中，处理逻辑，可以选择执行方法或者不执行方法。

  //代表着调度真实对象的方法
  Object obj = method.invoke(target, args);

2、CGLIB动态代理

CGLIB动态代理是第三方包，必须先下载CGLIB包并且导入。
JDK动态代理必须提供接口才能使用（HelloWorld），在一些不能使用接口的环境中，就只能采取第三方代理技术，入CGLIB。

package com.lean.ssm.chapter2.reflect.proxy;

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

import java.lang.reflect.Method;

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.out.println("调用真实对象前");
        //CGLIB反射调用真实对象方法
        Object result = methodProxy.invokeSuper(proxy, args);
        System.out.println("调用真实对象后");
        return result;
    }

    public static void testCGLIBProxy(){
        CglibProxyExample cpe = new CglibProxyExample();
        ReflectServiceImp1 obj = (ReflectServiceImp1)cpe.getProxy(ReflectServiceImp1.class);
        obj.sayHello("张三");
    }

    public static void main(String[] args){
        testCGLIBProxy();
    }
}

这里使用了CGLIB的加强者Enhancer，通过设置超类的方法（setSuperClass），然后通过setCallback设置哪个类为它的代理类(setSuperClass)，参数this是当前对象，必须实现MethodInterceptor方法 —— intercept，然后返回代理对象

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

3个方法的参数为：

• proxy 代理对象
• target 真实对象
• method 方法
• args 方法参数

接口内方法的使用：

• before方法返回一个boolean值，如果为true，则反射真实对象的方法，如果false的时候，则调用around方法
• 在反射真实对象方法或者around方法时，调用after方法

package com.lean.ssm.chapter2.reflect.proxy;

import com.lean.ssm.chapter2.reflect.Interceptor;

import java.lang.reflect.Method;

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 after(Object proxy, Object target, Method method, Object[] args) {
        System.out.println("反射方法后逻辑");
    }

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

在JDK动态代理中使用拦截器:

package com.lean.ssm.chapter2.reflect.proxy;

import com.lean.ssm.chapter2.reflect.Interceptor;

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

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
     * @param interceptorClass
     * @return 代理占位
     */
    public static Object bind(Object target, String interceptorClass){
        return Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(),
                new InterceptorJdkProxy(target,interceptorClass));
    }


    @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{
            interceptor.around(proxy, target, method, args);
        }
        interceptor.after(proxy, target, method, args);
        return result;
    }
}

代码执行步骤：

1. 在bind方法中用JDK动态代理绑定一个对象，然后返回代理对象
2. 如果没有设置拦截器，则直接反射真实对象的方法，然后结束，否则进行第三步
3. 通过反射生成拦截器，并准备使用
4. 调用拦截器的before方法，如果返回的是true，反射原来的方法，否则运行around方法
5. 调用拦截器的after方法
6. 返回结果

测试：

public static void main(String[] args){
    HelloWorld proxy = (HelloWorld) InterceptorJdkProxy.bind(new HelloWorldImp1(),
    "com.lean.ssm.chapter2.interceptor.MyInterceptor");
    proxy.sayHello();
}

会显示:

反射方法前逻辑
取代了被代理对象的方法（真实对象）
反射方法后逻辑

设计模式

1、责任链模式

当一个对象在一条链上被多个拦截器拦截处理，这样的设计模式称为责任链模式。
比如一个部门里面，提出请假，请假流程如下：

请假申请单 - 项目经理 - 部门经历- 人事部
这样，后面的审批都要经过前面的结果进行，这时候可以考虑层层代理：
请假单（target）走到项目经理处，生成第一个proxy1，当走到部门经理是，根据proxy1的基础生成proxy2，以此类推。

package com.lean.ssm.chapter2.reflect;

import java.lang.reflect.Method;

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方法");
    }
}

package com.lean.ssm.chapter2.reflect;

import java.lang.reflect.Method;

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方法");
    }
}

package com.lean.ssm.chapter2.reflect;

import java.lang.reflect.Method;

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方法");
    }
}

public class Main {
    public static void main(String[] args){
        HelloWorld proxy1 = (HelloWorld) InterceptorJdkProxy.bind(new HelloWorldImp1(), "com.lean.ssm.chapter2.reflect.Interceptor1");
        HelloWorld proxy2 = (HelloWorld) InterceptorJdkProxy.bind(proxy1, "com.lean.ssm.chapter2.reflect.Interceptor2");
        HelloWorld proxy3 = (HelloWorld) InterceptorJdkProxy.bind(proxy2, "com.lean.ssm.chapter2.reflect.Interceptor3");
        proxy3.sayHello();
    }
}

运行代码，得出结果：

[拦截器3]的before方法
[拦截器2]的before方法
[拦截器1]的before方法
Hello World
[拦截器1]的after方法
[拦截器2]的after方法
[拦截器3]的after方法

2、观察者模式

在现实生活中，有些条件发生了变化，其他的行为也要发生变化，如果我们用if语句来应对，比如电商的平台，则是如下：

if(产品库有更新){
    推送产品到淘宝;
    推送产品到京东;
}

但是如果又增加了几个公司，那么又要修改if代码：

if(产品库有更新){
    推送产品到淘宝;
    推送产品到京东;
    推动产品带公司x;
    ...
}

这样要不断修改if，所以if的逻辑就十分负责，如果淘宝出错，那么下一个都不会执行，于是有了观察者模式：

当一个可观察对象发生变化的时候，会通知观察者，观察者就根据情况做出逻辑判断

//被观察的产品列表
package com.lean.ssm.chapter2.reflect.Observable;

import java.util.ArrayList;
import java.util.List;
import java.util.Observable;
import java.util.Observer;

public class ProductList extends Observable {

    private List<String> productList = null; //产品列表

    private static ProductList instance; //类唯一实例

    private ProductList() {} //构造方法私有化

    /**
     * 取得唯一实例
     * @return 产品列表唯一实例
     */
    public static ProductList getInstance(){
        if(instance == null){
            instance = new ProductList();
            instance.productList = new ArrayList<String>();
        }
        return instance;
    }

    /**
     * 增加观察者
     * @param observer
     */
    public void addProductListObserver(Observer observer){
        this.addObserver(observer);
    }

    /**
     * 新增产品
     * @param newProduct 新产品
     */
    public void addProduct(String newProduct){
        productList.add(newProduct);
        System.out.println("产品列表新增了产品: " + newProduct);
        this.setChanged();
        this.notifyObservers(newProduct);
    }
}

核心逻辑：addProduct(),当产品列表发生变化的时候，就调用setChanged方法告诉观察者对象当前被观察者发生了变化，如果没有，则不变化，最后通过notufyObservers告知观察者做出相应的动作。

package com.lean.ssm.chapter2.reflect.Observable;

import java.util.Observable;
import java.util.Observer;

public class JingDongObserver implements Observer {
    @Override
    public void update(Observable o, Object product) {
        String newProduct = (String)product;
        System.out.println("发送新产品【" + newProduct + "】同步到京东商城");
    }
}

package com.lean.ssm.chapter2.reflect.Observable;

import java.util.Observable;
import java.util.Observer;

public class TaoBaoObserver implements Observer {

    @Override
    public void update(Observable o, Object product) {
        String newProduct = (String)product;
        System.out.println("发送新产品【" + newProduct + "】同步到淘宝商城");
    }
}

package com.lean.ssm.chapter2.reflect.Observable;

public class Main {
    public static void main(String[] args){
        ProductList observable = ProductList.getInstance();
        TaoBaoObserver taoBaoObserver = new TaoBaoObserver();
        JingDongObserver jingDongObserver = new JingDongObserver();
        observable.addObserver(jingDongObserver);
        observable.addObserver(taoBaoObserver);
        observable.addProduct("产品1");
    }
}

运行main，得到如下结果：

产品列表新增了产品: 产品1
发送新产品【产品1】同步到淘宝商城
发送新产品【产品1】同步到京东商城