模板方法模式

模板方法设计模式，顾名思义它定义好了一个模板，只是具体实现的逻辑不一样。
　　例 去银行办理业务： 排队取号 办理业务 离开。(这是一整套业务流程,只是每个人的业务不一样)。
　　例 例如游戏的角色： 由 头饰 服装 武器组成。可是每个玩家装备不一样，每个人的外型也是不一样的。

案例编写：

1. 模板类

public abstract class ShopTemplate {

    // 定义模板
    public void sendMsg() {
        
        enter();
        // 具体业务
        shopping();

        leave();
    }
    
    private void enter() {
        System.out.println("进店挑选");
    }
    
    public abstract void shopping();
    
    public void leave(){
        System.out.println("结账离开...");
    }
}

2. 创建两个具体的实现

public class Shoe extends ShopTemplate{
    @Override
    public void shopping() {
        System.out.println("买了一双鞋");
    }
}



public class Clothes extends ShopTemplate{
    @Override
    public void shopping() {
        System.out.println("买了一件衣服");
    }
}

 3. 测试

public class Test {
    public static void main(String[] args) {
        ShopTemplate t = new Clothes();
        t.sendMsg();
    }
}
===============
【控制台输出】

进店挑选
买了一件衣服
结账离开...

 那么什么时候应该使用模板方法模式呢？ 实现一些操作时，整体步骤很固定，但是就是其中一小部分容易变，这时候可以使用模板方法模式，将容易变的部分抽象出来，供子类实现，正是由于这种特性，很多情况下模板方法类都是一个抽象类。

例如：servlet每次处理请求都会调用 service()方法，但是由于请求方式不一样,它会调用子类不同的方法来处理具体请求类型。

public abstract class HttpServlet extends GenericServlet {
    /**
     * Receives standard HTTP requests from the public
     * <code>service</code> method and dispatches
     * them to the <code>do</code><i>Method</i> methods defined in
     * this class. This method is an HTTP-specific version of the
     * {@link javax.servlet.Servlet#service} method. There's no
     * need to override this method.
     */
     // 1. 每次都触发 service() 方法
    protected void service(HttpServletRequest req, HttpServletResponse resp)
        throws ServletException, IOException {
        // 2. 获取到请求类型
        String method = req.getMethod();
        // 3. 不同的请求类型，由子类去做具体不同实现。
        if (method.equals(METHOD_GET)) {
            long lastModified = getLastModified(req);
            if (lastModified == -1) {
                // servlet doesn't support if-modified-since, no reason
                // to go through further expensive logic
                doGet(req, resp);
            } else {
                long ifModifiedSince;
                try {
                    ifModifiedSince = req.getDateHeader(HEADER_IFMODSINCE);
                } catch (IllegalArgumentException iae) {
                    // Invalid date header - proceed as if none was set
                    ifModifiedSince = -1;
                }
                if (ifModifiedSince < (lastModified / 1000 * 1000)) {
                    // If the servlet mod time is later, call doGet()
                    // Round down to the nearest second for a proper compare
                    // A ifModifiedSince of -1 will always be less
                    maybeSetLastModified(resp, lastModified);
                    doGet(req, resp);
                } else {
                    resp.setStatus(HttpServletResponse.SC_NOT_MODIFIED);
                }
            }

        } else if (method.equals(METHOD_HEAD)) {
            long lastModified = getLastModified(req);
            maybeSetLastModified(resp, lastModified);
            doHead(req, resp);

        } else if (method.equals(METHOD_POST)) {
            doPost(req, resp);

        } else if (method.equals(METHOD_PUT)) {
            doPut(req, resp);

        } else if (method.equals(METHOD_DELETE)) {
            doDelete(req, resp);

        } else if (method.equals(METHOD_OPTIONS)) {
            doOptions(req,resp);

        } else if (method.equals(METHOD_TRACE)) {
            doTrace(req,resp);

        } else {
            //
            // Note that this means NO servlet supports whatever
            // method was requested, anywhere on this server.
            //

            String errMsg = lStrings.getString("http.method_not_implemented");
            Object[] errArgs = new Object[1];
            errArgs[0] = method;
            errMsg = MessageFormat.format(errMsg, errArgs);

            resp.sendError(HttpServletResponse.SC_NOT_IMPLEMENTED, errMsg);
        }
    }    
}