设计模式之（13）--模板方法模式

　　今天我们来学习下模板方法设计模式。

　　模板方法(Template Method Pattern)：抽象的父类中定义一个操作中算法的骨架，而将一些步骤延迟到子类中。使得子类可以不改变一个算法的结构，即可重新定义该算法的某些特定步骤。简单地讲，就是“父类的模板方法定义不变的流程，子类重写流程中的方法”。

　　类图如下所示：

　　

　　在上面UML类图中我们定义了两种角色：

　　1、抽象模板（AbstractSuperClass）：抽象模板类，定义了一套算法框架/流程；

　　2、具体实现（ConcreteClass）：具体实现类，对算法框架/流程的某些步骤进行了实现。

　　我们在上面两种角色中定义的方法可以分为两类：

　　第一类：诸如baseOperation()或者customOperation()方法，我们认为是基本操作方法，定义类算法的某些步骤，可以交由子类去实现，按照“迪米特法则”，这些方法应根据需要保持最小的可见性，通常我们将不需要重写的方法权限定义为private，而需要重写的方法访问权限设置为protected。

　　第一类：templateMethod()，我们称之为模板方法，可以有一个或多个，定义算法的骨架，实现对基本方法的调用，完成固定的逻辑。为了防止恶意操作，这些方法通常定义为final，不容许子类去重写。

　　这里有个小技巧：我们尽量不要将这些需要子类实现基本操作方法设置为抽象方法，这是因为有些具体子类实现并不需要重写这种方法，在抽象模板类中将这些基本方法定义为abstract强迫所有子类去实现就有点强人所难了。但是有些基本操作的方法，在某些特定的模板方法中去调用必须交由子类去实现，我们可以在这个方法定义中抛出一个异常，强迫子类去实现。这类设计在JDK源码中很常见，如AbstractQueuedSynchronizer类中的acquire(int)、acquireShared(int)、release(int)、releaseShared(int)就是定义的模板方法，而tryAcquire()、tryAcquireShared()、tryReleaseShared()就是基本方法，在AQS中都没有提供具体的实现逻辑，只是抛出了UnsupportedOperationException()异常，这就需要类似ReentrantLock.Sync、Semaphore.Sync这些子类去按需实现了。

　　故事背景：我司有款产品，被几个第三方开发商看中，与我司签订协议，需要使用他们自身的帐号体系登录我们的产品直接使用，我司领导为了拿下这些单子，给我们部门下达了这项任务。经过双方的友好协商，第三方提供用户的验证接口，我们只需要去对接就行了。系统用户登录验证的流程基本都是一致的，只是不同的对接方提供的用户验证接口和返回结果不同，我们只需要将用户验证的骨架流程定义出来，然后针对不同对接渠道定制开发某些特定的步骤就可以了，这也符合程序设计的“开闭原则”。通过上面分析，我脑子里迅速地过了下，就想到了模版方法设计模式。

　　以下就是一个简单的测试demo：

package cn.com.pep.model.template;
/**
 * @ClassName: AbstractSuperClass
 * @Description: 验证用户的模版类
 * @author: wwh
 * @date: 2023年2月24日 下午1:45:06
 */
public abstract class AbstractUserCheck {
    
    /**
     * @Title: domainCheck
     * @Description: 检测第三方提供的域名是否可用
     * @param domain
     * @return 
     * String 返回类型
     */
    private String domainCheck(Object domain){
        //伪代码
        System.err.println("域名可访问...");
        return "ok";
    };
    
    /**
     * @Title: tryCheckUser
     * @Description: 不同渠道用户验证的逻辑，强制子类趋势线
     * @param obj
     * @return Object 返回类型
     */
    protected Object tryCheckUser(Object ...obj) {
        throw new UnsupportedOperationException();
    }
    
    /**
     * @Title: wrapperResult
     * @Description: 对各个渠道的验证结果进行转换，包装为系统的响应结果
     * @param response
     * @return 
     * Map 返回类型
     */
    protected Object wrapperResult(Object ...obj) {
        throw new UnsupportedOperationException();
    }
    
    /**
     * 
     * @Title: userCheck
     * @Description: 用户验证的核心流程（模版方法），定义算法的骨架
     * @param domain
     * @param userInfo
     * @return 
     * Map 返回类型
     */
    public final Object userCheck(Object...obj) {
        //1、验证第三方域名是否可用
        domainCheck(obj);
        //2、向第三方发起http请求，验证用户帐号信息是否合法
        Object response = tryCheckUser(obj);
        //3、将第三方响应的信息包装成我们系统的标准信息
        return wrapperResult(response);
    }
}

 

package cn.com.pep.model.template;
/**
 * @ClassName: UserCheck4ClientA
 * @Description: 渠道A用户的认证实现
 * @author: wwh
 * @date: 2023年2月24日 下午2:17:44
 */
public class UserCheck4ClientA extends AbstractUserCheck {

    /**
     * @Title: wrapperResult
     * @Description: 包装渠道B的认证结果
     * @param obj
     * @return
     * @see cn.com.pep.model.template.AbstractUserCheck#wrapperResult(java.lang.Object[])
     */
    @Override
    protected Object wrapperResult(Object...obj) {
        //伪代码
        System.err.println("包装渠道到A的返回的认证结果...");
        return "OK";
    }

    /**
     * @Title: tryCheckUser
     * @Description: 渠道A的具体的用户认证逻辑
     * @param obj
     * @return
     * @see cn.com.pep.model.template.AbstractUserCheck#tryCheckUser(java.lang.Object[])
     */
    @Override
    protected Object tryCheckUser(Object ...obj) {
        //伪代码
        System.err.println("****【组织渠道A的请求参数...】****");
        System.err.println("****【向渠道A开发的域名接口发起用户认证...】");
        System.err.println("****【将渠道A的认证结果返回...】****");
        return "OK";
    }
}

package cn.com.pep.model.template;
/**
 * @ClassName: UserCheck4ClientB
 * @Description: 渠道B的用户认证实现
 * @author: wwh
 * @date: 2023年2月24日 下午2:20:09
 */
public class UserCheck4ClientB extends AbstractUserCheck{
    
    /**
     * @Title: wrapperResult
     * @Description: 包装渠道B的认证结果
     * @param obj
     * @return
     * @see cn.com.pep.model.template.AbstractUserCheck#wrapperResult(java.lang.Object[])
     */
    @Override
    protected Object wrapperResult(Object ...obj) {
        //伪代码
        System.err.println("包装渠道到B的返回的认证结果...");
        return "OK";
    }

    /**
     * @Title: tryCheckUser
     * @Description: 渠道B的用户的具体的认证逻辑
     * @param obj
     * @return
     * @see cn.com.pep.model.template.AbstractUserCheck#tryCheckUser(java.lang.Object[])
     */
    @Override
    protected Object tryCheckUser(Object ...obj) {
        //伪代码
        System.err.println("****【组织渠道B的请求参数...】****");
        System.err.println("****【向渠道B开发的域名接口发起用户认证...】****");
        System.err.println("****【将渠道B的认证结果返回...】****");
        return "OK";
    }
}

 

package cn.com.pep.model.template;
/**
 * 
 * @ClassName: Client
 * @Description: 调用类
 * @author: wwh
 * @date: 2023年2月24日 下午2:49:34
 */
public class Client {
    
    public static void main(String[] args) {
        //1、登录端登录，传入渠道标识
        AbstractUserCheck userCheck = null;
        if ("渠道A") {
            userCheck = new UserCheck4ClientA();
        }else if ("渠道B") {
            userCheck = new UserCheck4ClientB();
        }
        userCheck.userCheck("用户输入的信息...");
        System.err.println("用户验证成功...");
    }
}

　　模版方法的优点：

　　1、把一个算法中认为是不可变的方法封装到父类中实现，并禁止继承，而可变的部分可以通过子类继承来进行重写，简单来讲就是“封装不可变、扩展可变”，符合程序设计的开闭原则；

　　2、提取公共部分代码，便于后期维护，基本方法是由子类来实现的，因此可以通过扩展子类的方式来增加响应的功能；

　　模版方法的缺点：

　　1、子类的执行结果影响了父类，可能会造成阅读上的难度；

·　  2、每一个不同的实现都需要一个子类来实现，导致类的个数增加，使得系统更加庞大；

　　注意事项：

　　为了防止模版方法被恶意重写，一般模版方法加上final修饰。

　　JDK源码中模版方法的应用：

　　1、上面提到的AQS中的模版方法acquire(int)、acquireShared(int)、release(int)、releaseShared(int)等；

　　2、JDK1.8中Map接口中的putIfAbsent(K key, V value)方法就是一个模版方法，其中调用了get(K key)和put(K key,V value)基本操作方法，但是这两个方法在Map接口中并没有实现，而是交由它的实现类去实现。

　　3、JDK1.8中HashMap中的putVal()方法就是一个模版方法，而afterNodeAccess()、afterNodeInsertion()、afterNodeRemoval()都是基本操作方法，需要具体的子类去按需实现。