Template Method Design Pattern in Java: Theory, Code Examples, and Framework Applications

The Template Method pattern defines an algorithm skeleton in an abstract class, delegating specific steps to subclasses so they can customize behavior without altering the overall structure.

Typical usage scenarios include a tea‑making process, API request handling (parameter parsing, validation, business logic, response assembly), and payment order processing, each illustrating how the skeleton can be adapted.

Algorithm class (abstract template) :

package com.tian.springbootdemo.controller;
import com.tian.springbootdemo.rep.Result;
/**
 * @auther: 老田
 * @Description: 模板类
 */
public abstract class AbstractTemplate {
    /**
     * Algorithm skeleton
     */
    public Result execute() {
        // Step 1: parse parameters
        parseRequestParameters();
        // Step 2: validate parameters
        checkRequestParameters();
        // Step 3: business processing
        Object data = doBusiness();
        // Step 4: assemble response
        return assembleResponseParameters(data);
    }
    public abstract void parseRequestParameters();
    public abstract void checkRequestParameters();
    public abstract Object doBusiness();
    public abstract Result assembleResponseParameters(Object object);
}

Concrete implementation 1 (MyApiController) :

import com.tian.springbootdemo.rep.Result;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.ResponseBody;
/**
 * @auther: 老田
 * @Description: api接口
 */
@RequestMapping("/api")
@Controller
public class MyApiController extends AbstractTemplate {
    @RequestMapping(value = "/users", method = RequestMethod.POST)
    @ResponseBody
    @Override
    public Result execute() {
        return super.execute();
    }
    @Override
    public void parseRequestParameters() {
        System.out.println("*****解析参数*****");
    }
    @Override
    public void checkRequestParameters() {
        System.out.println("*****校验参数*****");
    }
    @Override
    public Object doBusiness() {
        System.out.println("*****处理业务*****");
        User user = new User();
        user.setName("小田哥");
        user.setId(1);
        user.setAge(20);
        user.setSex("man");
        return user;
    }
    @Override
    public Result assembleResponseParameters(Object object) {
        System.out.println("*****返回参数*****");
        Result result = new Result("200", "处理成功");
        result.setData(object);
        return result;
    }
}

Concrete implementation 2 (LoginController) :

import com.tian.springbootdemo.dao.domain.User;
import com.tian.springbootdemo.rep.Result;
import org.springframework.web.bind.annotation.*;
/**
 * @auther: 老田
 * @Description: api接口
 */
@RequestMapping("/api")
@RestController
public class LoginController extends AbstractTemplate {
    @PostMapping(value = "/login")
    @Override
    public Result execute() {
        return super.execute();
    }
    @Override
    public void parseRequestParameters() {
        System.out.println("解析登录参数");
    }
    @Override
    public void checkRequestParameters() {
        System.out.println("校验登录用户名是否为空，密码是否为空");
    }
    @Override
    public Object doBusiness() {
        System.out.println("通过用户名查询是否存在此用户");
        System.out.println("校验用户密码是否正确");
        System.out.println("登录成功");
        User user = new User();
        user.setName("小田哥");
        user.setId(1);
        user.setAge(20);
        user.setSex("man");
        return user;
    }
    @Override
    public Result assembleResponseParameters(Object object) {
        System.out.println("*****返回参数*****");
        Result result = new Result("200", "登录成功");
        result.setData(object);
        return result;
    }
}

The supporting Result and User classes provide simple POJOs for response data and domain objects.

Testing is performed with IDEA's REST Client, showing request/response logs and console output.

Advantages of the pattern include code reuse, extensibility, and inversion of control; drawbacks involve increased class count and potential complexity.

Real‑world framework examples:

In Spring, AbstractApplicationContext.refresh() is a template method orchestrating container startup.

In MyBatis, BaseExecutor.update() defines the skeleton, while subclasses like SimpleExecutor and ReuseExecutor implement doUpdate .

Overall, the Template Method pattern offers a simple yet powerful way to structure algorithms, making it a frequent topic in Java backend interviews.