行为型模式之模板方法模式

介绍

模板方法模式就是将固定的步骤抽象出来，并将每个步骤不同的细节延伸到不同的子类去做。因为每个子类都不同，所以具有可变信息，然后把不变的行为给他封装到父类中去，这样就去除子类中重复的代码了。

模板方法模式UML图.png

例子

在实际工作中我们数据同步，需要使用token来保证同步数据的用户身份正确，而我们的步骤是首先通过用户名和密码来获取token，然后每次发送Get请求或者Post请求就把token带上发送来执行请求，而我们发现机构同步，账号同步每个模块都是先获取token，再发送请求，而我们可以为此设计一套模板，将固定的步骤提取出来作为一个抽象模板，将不同的同步模块的细节延伸到子类去设计。

样例代码

抽象流程模板类：

public abstract class MyTemplet {

    /**
     * 使用用户名和密码获取token
     * @param username
     * @param password
     * @return
     */
    public abstract String getToken(String username, String password);
    
    /**
     * 使用token发送get请求获取数据
     * @param id
     * @param token
     * @return
     */
    public abstract String doGet(String id, String token);
    
    /**
     * 使用token发送post请求新增数据
     * @param model
     * @param token
     * @return
     */
    public abstract String doPost(Object model, String token);
}

模块A具体实现类：

public class MySystemA extends MyTemplet{

    @Override
    public String getToken(String username, String password) {
        System.out.println("MySystemA 获取 token");
        return null;
    }

    @Override
    public String doGet(String id, String token) {
        System.out.println("MySystemA 发送 Get请求");
        return null;
    }

    @Override
    public String doPost(Object model, String token) {
        System.out.println("MySystemA 发送 Post请求");
        return null;
    }
}

模块B具体实现类：

public class MySystemB extends MyTemplet {

    @Override
    public String getToken(String username, String password) {
        System.out.println("MySystemB 获取 token");
        return null;
    }

    @Override
    public String doGet(String id, String token) {
        System.out.println("MySystemB 发送 Get请求");
        return null;
    }

    @Override
    public String doPost(Object model, String token) {
        System.out.println("MySystemB 发送 Post请求");
        return null;
    }
}

说明：抽象模板类只是规定了系统开发所需的步骤，但是没有定义具体细节，将具体的细节都延伸到了子类来实现，减少了重复代码。因为重复对应更多的是易错和难改。

实际应用的设计

public static void main(String[] args) throws Exception {
    Reader fileReader = new FileReader("D:\\BugReport.txt");
    char[] arr = new char[1024];
    int len = 0;
        
    while ((len = fileReader.read(arr)) != -1) {
        System.out.println(new String(arr, 0, len));
    }
    
    fileReader.close(); 
}

public static void main(String[] args) throws Exception {
    Reader fileReader = new FileReader("D:\\BugReport.txt");
    Reader bufferedReader = new BufferedReader(fileReader);
    char[] arr = new char[1024];
    int len = 0;
        
    while ((len = bufferedReader.read(arr)) != -1) {
        System.out.println(new String(arr, 0, len));
    }
        
    fileReader.close();
    bufferedReader.close();
}

抽象模板类Reader

public abstract class Reader implements Readable, Closeable {
   abstract public int read(char cbuf[], int off, int len) throws IOException;
}

具体实现类InputStreamReader
FileReader实际上还是使用InputStreamReader提供的read方法来实现的。

public class InputStreamReader extends Reader {
    
    private final StreamDecoder sd;
    public int read(char cbuf[], int offset, int length) throws IOException {
        return sd.read(cbuf, offset, length);
    }
}

public class FileReader extends InputStreamReader {
    
}

具体实现类BufferedReader

public class BufferedReader extends Reader {
    public int read(char cbuf[], int off, int len) throws IOException {
        synchronized (lock) {
            ensureOpen();
            if ((off < 0) || (off > cbuf.length) || (len < 0) ||
                ((off + len) > cbuf.length) || ((off + len) < 0)) {
                throw new IndexOutOfBoundsException();
            } else if (len == 0) {
                return 0;
            }

            int n = read1(cbuf, off, len);
            if (n <= 0) return n;
            while ((n < len) && in.ready()) {
                int n1 = read1(cbuf, off + n, len - n);
                if (n1 <= 0) break;
                n += n1;
            }
            return n;
        }
    }
}

说明：
可以看出抽象模板类Reader定义了read方法，但是read方法的具体实现还是延伸到子类InputStreamReader、BufferedReader。而FileReader实际上还是使用的InputStreamReader来实现的。模板方法模式的关键在于将多个类中的公共部分抽取出来，防止产生重复代码。

总结：

模板方法模式应用场景：当系统中存在不变的行为在子类中重复出现时，就将不变的行为和可变的行为分离，将不变的行为抽取出来放到一个单一的地方，让子类们去实现这个单一的地方。避免了大量的重复代码，也同时为子类的设计做了一个统一的规范。
具体的做法就是将重复不变的部分放在抽象父类中，然后让子类们去继承父类，然后重写父类的抽象方法。
模板方法模式的使用提高了代码的复用性。