代理模式与模板模式

参考教程：https://www.bilibili.com/video/BV1G4411c7N4
代码实现 Github：https://github.com/yaokuku123/pattern

代理模式

概述

代理模式

解释：为一个对象提供一个替身，以控制对这个对象的访问。即通过代理对象访问目标对象.这样做的好处是:可以在目标对象实现的基础上,增强额外的功能操作,即扩展目标对象的功能。

分类：代理模式有不同的形式, 主要有三种静态代理、动态代理 (JDK代理、接口代理)和 Cglib代理 (可以在内存动态的创建对象，而不需要实现接口，他是属于动态代理的范畴) 。

静态代理

静态代理

解释：静态代理在使用时,需要定义接口或者父类,被代理对象(即目标对象)与代理对象一起实现相同的接口或者是继承相同父类。

代码实现

具体要求

定义一个接口:ITeacherDao
目标对象TeacherDAO实现接口ITeacherDAO
使用静态代理方式,就需要在代理对象TeacherDAOProxy中也实现ITeacherDAO
调用的时候通过调用代理对象的方法来调用目标对象.
特别提醒：代理对象与目标对象要实现相同的接口,然后通过调用相同的方法来调用目标对象的方法。

1-1592789573674.png

package com.yqj.pattern.proxy.staticproxy;

//接口
interface ITeacherDao{
    public void teach();
}

//被代理对象
class TeacherDao implements ITeacherDao{

    @Override
    public void teach() {
        System.out.println("老师上课");
    }
}

//代理对象，静态代理
class TeacherDaoProxy implements ITeacherDao{

    //代理的目标对象，通过接口聚合
    private ITeacherDao teacherDao;

    public TeacherDaoProxy(ITeacherDao teacherDao) {
        this.teacherDao = teacherDao;
    }

    //扩展功能
    @Override
    public void teach() {
        System.out.println("准备教材");
        teacherDao.teach();
        System.out.println("下课");
    }
}

public class Client {
    public static void main(String[] args) {
        //创建代理对象，同时将被代理对象传递给代理对象
        TeacherDaoProxy teacherDaoProxy = new TeacherDaoProxy(new TeacherDao());
        //通过代理对象，调用被代理对象的增强方法
        teacherDaoProxy.teach();
    }
}

小结

优点：在不修改目标对象的功能前提下, 能通过代理对象对目标功能扩展

缺点：因为代理对象需要与目标对象实现一样的接口,所以会有很多代理类

一旦接口增加方法,目标对象与代理对象都要维护

动态代理

动态代理

解释：代理对象,不需要实现接口，但是目标对象要实现接口，否则不能用动态代理。代理对象的生成，是利用JDK的API，动态的在内存中构建代理对象。动态代理也叫做：JDK代理、接口代理。

代码实现

将前面的静态代理改进成动态代理模式(即：JDK代理模式)

2-1592790233126.png

package com.yqj.pattern.proxy.dynamicproxy;

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

//接口
interface ITeacherDao{
    public void teach();
    public Boolean teachStudent(String name);
}

//被代理对象
class TeacherDao implements ITeacherDao{

    @Override
    public void teach() {
        System.out.println("老师讲课");
    }

    @Override
    public Boolean teachStudent(String name) {
        System.out.println("我教"+name);
        return true;
    }
}

//生成代理对象的工厂
class ProxyFactory{

    //维护一个目标对象 Object
    private Object target;

    public ProxyFactory(Object target) {
        this.target = target;
    }

    public Object getProxyInstance(){

        /*
        参数说明：
            当前目标对象的类加载器；
            当前目标对象的接口类型；
            执行对目标对象的方法时，会触发事情处理器方法，把当前执行的目标对象方法作为参数传入
         */
        return Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), new InvocationHandler() {
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                System.out.println("准备上课材料");
                //反射调用目标对象的方法
                Object result = method.invoke(target, args);
                System.out.println("下课");
                return result;
            }
        });
    }
}

public class Client {
    public static void main(String[] args) {
        //创建代理工厂
        ProxyFactory proxyFactory = new ProxyFactory(new TeacherDao());
        //给目标对象创建代理对象，并将Object类型转换为ITeacherDao类型
        ITeacherDao proxyInstance = (ITeacherDao) proxyFactory.getProxyInstance();
        //通过代理对象调用目标对象的方法
        proxyInstance.teach();
        //调用用传参和返回值的方法
        Boolean result = proxyInstance.teachStudent("yorick");
        System.out.println(result);
    }
}

Cglib代理

Cglib代理

解释：静态代理和JDK代理模式都要求目标对象是实现一个接口,但是有时候目标对象只是一个单独的对象,并没有实现任何的接口,这个时候可使用目标对象子类来实现代理。它是在内存中构建一个子类对象从而实现对目标对象功能扩展。,它可以在运行期扩展java类与实现java接口.它广泛的被许多AOP的框架使用,例如Spring AOP，实现方法拦截。

代理选择：在AOP编程中如何选择代理模式： 1. 目标对象需要实现接口，用JDK代理 2. 目标对象不需要实现接口，用Cglib代理。

代码实现

将前面的案例用Cglib代理模式实现

3-1592791734821.png

package com.yqj.pattern.proxy.cglibproxy;

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

import java.lang.reflect.Method;

class TeacherDao{
    public String teach(){
        System.out.println("老师上课");
        return "OK";
    }
}

//创建代理对象的工厂
class ProxyFactory implements MethodInterceptor{

    private Object target;

    public ProxyFactory(Object target) {
        this.target = target;
    }

    //返回代理对象
    public Object getProxyInstance(){
        //创建一个工具类
        Enhancer enhancer = new Enhancer();
        //设置父类
        enhancer.setSuperclass(target.getClass());
        //设置回调函数
        enhancer.setCallback(this);
        //创建子类对象(代理对象)
        return enhancer.create();
    }

    //重写intercept方法，会调用目标对象的方法
    @Override
    public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
        System.out.println("准备上课材料");
        Object result = method.invoke(target, args);
        System.out.println("下课");
        return result;
    }
}

public class Client {
    public static void main(String[] args) {
        ProxyFactory proxyFactory = new ProxyFactory(new TeacherDao());
        //获取代理对象，由于是通过子类扩展，所以可以使用父类类型
        TeacherDao proxyInstance = (TeacherDao) proxyFactory.getProxyInstance();
        //执行代理对象的方法，触发intercept方法，实现对目标对象的调用
        String result = proxyInstance.teach();
        System.out.println(result);
    }
}

模板模式

案例

编写制作豆浆的程序，说明如下: 1) 制作豆浆的流程选材--->添加配料--->浸泡--->放到豆浆机打碎 2) 通过添加不同的配料，可以制作出不同口味的豆浆 3) 选材、浸泡和放到豆浆机打碎这几个步骤对于制作每种口味的豆浆都是一样的 4) 请使用模板方法模式完成 (说明：因为模板方法模式，比较简单，很容易就想到这个方案，因此就直接使用，不再使用传统的方案来引出模板方法模式 )

模板模式

解释：在一个抽象类公开定义了执行它的方法的模板。它的子类可以按需要重写方法实现，但调用将以抽象类中定义的方式进行。，模板方法模式定义一个操作中的算法的骨架，而将一些步骤延迟到子类中，使得子类可以不改变一个算法的结构，就可以重定义该算法的某些特定步骤。

代码实现

4-1592792731660.png

6-1592792907252.png

package com.yqj.pattern.template;

//抽象类，表示豆浆
abstract class SoyaMilk{
    //模板方法make，可以做成final，不让子类覆盖
    public final void make(){
        select();
        add();
        soak();
        beat();
    }

    protected void select(){
        System.out.println("选择上好原料");
    }

    protected abstract void add();

    protected void soak(){
        System.out.println("浸泡");
    }

    protected void beat(){
        System.out.println("烘培");
    }
}

class BlackBeanSoyaMilk extends SoyaMilk{

    @Override
    protected void add() {
        System.out.println("加入黑豆");
    }
}

class PennutSoyaMilk extends SoyaMilk{

    @Override
    protected void add() {
        System.out.println("加入花生");
    }
}

public class Client {
    public static void main(String[] args) {
        SoyaMilk pennutSoyaMilk = new PennutSoyaMilk();
        pennutSoyaMilk.make();
    }
}

模板模式的勾子方法

解释：在模板方法模式的父类中，我们可以定义一个方法，它默认不做任何事，子类可以视情况要不要覆盖它，该方法称为“钩子”。还是用上面做豆浆的例子来讲解，比如，我们还希望制作纯豆浆，不添加任何的配料，请使用钩子方法对前面的模板方法进行改造。

package com.yqj.pattern.template;

//抽象类，表示豆浆
abstract class SoyaMilk{
    //模板方法make，可以做成final，不让子类覆盖
    public final void make(){
        select();
        //勾子方法控制逻辑
        if(customerWantAdd()){
            add();
        }
        soak();
        beat();
    }

    protected void select(){
        System.out.println("选择上好原料");
    }

    protected abstract void add();

    protected void soak(){
        System.out.println("浸泡");
    }

    protected void beat(){
        System.out.println("烘培");
    }
    //勾子方法
    protected Boolean customerWantAdd(){
        return true;
    }
}

class BlackBeanSoyaMilk extends SoyaMilk{

    @Override
    protected void add() {
        System.out.println("加入黑豆");
    }
}

class PennutSoyaMilk extends SoyaMilk{

    @Override
    protected void add() {
        System.out.println("加入花生");
    }
}

//纯豆浆，不添加任何配料
class PureSoyaMilk extends SoyaMilk{

    //重写，空方法
    @Override
    protected void add() {
        //不会执行
        System.out.println("hehe");
    }

    //重写勾子方法的状态
    @Override
    protected Boolean customerWantAdd() {
        return false;
    }
}

public class Client {
    public static void main(String[] args) {
        SoyaMilk pureSoyaMilk = new PureSoyaMilk();
        pureSoyaMilk.make();
    }
}

小结

基本思想是：算法只存在于一个地方，也就是在父类中，容易修改。需要修改算法时，只要修改父类的模板方法或者已经实现的某些步骤，子类就会继承这些修改 2) 实现了最大化代码复用。父类的模板方法和已实现的某些步骤会被子类继承而直接使用。 3) 既统一了算法，也提供了很大的灵活性。父类的模板方法确保了算法的结构保持不变，同时由子类提供部分步骤的实现。 4) 该模式的不足之处：每一个不同的实现都需要一个子类实现，导致类的个数增加，使得系统更加庞大 5) 一般模板方法都加上final关键字，防止子类重写模板方法. 6) 模板方法模式使用场景：当要完成在某个过程，该过程要执行一系列步骤，这一系列的步骤基本相同，但其个别步骤在实现时可能不同，通常考虑用模板方法模式来处理。

代理模式与模板模式