一文带你厉害Java设计模式中的模板方法

什么是模板方法

模板方法是一种设计模式，其基本思路是定义一个算法的框架，而将一些步骤延迟到子类中。模板方法使得子类可以在不改变算法框架的情况下重新定义算法中的某些步骤。

模板方法的结构

模板方法包含两部分：抽象父类和具体实现子类。抽象父类定义了算法的框架，包括一些抽象方法；具体实现子类实现了抽象父类中的抽象方法。

以下是模板方法的结构：

public abstract class AbstractClass {
    protected abstract void primitiveOperation1();
    protected abstract void primitiveOperation2();

    final public void templateMethod() {
        primitiveOperation1();
        primitiveOperation2();
    }
}

public class ConcreteClass extends AbstractClass {
    @Override
    protected void primitiveOperation1() {
        // 具体实现1
    }

    @Override
    protected void primitiveOperation2() {
        // 具体实现2
    }
}

模板方法的优缺点

优点

1. 提高代码的复用性，将公共部分抽象到父类中，避免重复代码。
2. 提高扩展性，可以很方便地增加新的算法流程。
3. 提高安全性，由于模板方法中的算法框架是固定的，避免了子类不当操作造成的风险。

缺点

1. 需要把算法的框架固定下来，使得算法不能灵活变化。
2. 继承关系过多，导致程序复杂。

示例1：炒菜模板方法

现在我们来写一个简单的例子，来解释模板方法的使用。

假设我们要用模板方法来实现一个“炒菜”的过程。

首先，我们需要定义一个抽象类Cook，其内部包含了一个炒菜的方法cook()，该方法是一个固定的算法框架。然后，我们再定义一个具体实现类Eggplant和Pork分别实现Cook类，并重写cook()方法，完成炒茄子和炒肉的过程。

下面是示例代码：

public abstract class Cook {
    public final void cook() {
        prepare();
        stir_fry();
        cookRice();
    }

    abstract void prepare();

    abstract void stir_fry();

    void cookRice() {
        System.out.println("煮米饭");
    }
}

public class Eggplant extends Cook {
    @Override
    void prepare() {
        System.out.println("准备茄子");
    }

    @Override
    void stir_fry() {
        System.out.println("炒茄子");
    }
}

public class Pork extends Cook {
    @Override
    void prepare() {
        System.out.println("准备肉");
    }

    @Override
    void stir_fry() {
        System.out.println("炒肉");
    }
}

我们可以通过以下代码来调用：

Cook c1 = new Eggplant();
c1.cook();  // 准备茄子、炒茄子、煮米饭

Cook c2 = new Pork();
c2.cook();  // 准备肉、炒肉、煮米饭

运行结果如下：

准备茄子
炒茄子
煮米饭

准备肉
炒肉
煮米饭

示例2：JDBC模板方法

JDBC模板方法是一种常见的模板方法模式的应用。在JDBC中，我们可以使用模板方法来处理数据库的连接、事务以及SQL语句的执行，提高代码的复用性和可维护性。

下面是一个简单的JDBC模板方法的示例：

public abstract class JdbcTemplate {
    protected abstract String getUrl();
    protected abstract String getUsername();
    protected abstract String getPassword();

    public final <T> T execute(String sql, RowMapper<T> rowMapper) {
        Connection conn = null;
        PreparedStatement ps = null;
        ResultSet rs = null;
        try {
            // 获取数据库连接
            conn = DriverManager.getConnection(getUrl(), getUsername(), getPassword());
            // 开始事务
            conn.setAutoCommit(false);
            // 执行SQL语句
            ps = conn.prepareStatement(sql);
            rs = ps.executeQuery();
            // 处理结果集
            List<T> result = new ArrayList<>();
            while (rs.next()) {
                result.add(rowMapper.mapRow(rs));
            }
            // 提交事务
            conn.commit();
            return result;
        } catch (SQLException e) {
            // 回滚事务
            try {
                conn.rollback();
            } catch (SQLException e1) {
                e1.printStackTrace();
            }
            throw new RuntimeException(e);
        } finally {
            // 释放资源
            try {
                if (rs != null) rs.close();
                if (ps != null) ps.close();
                if (conn != null) conn.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }
}

public interface RowMapper<T> {
    T mapRow(ResultSet rs) throws SQLException;
}

我们可以使用以下代码来调用：

String sql = "SELECT id, name FROM person";
List<Person> result = new JdbcTemplate() {
    @Override
    protected String getUrl() {
        return "jdbc:mysql://localhost:3306/test";
    }

    @Override
    protected String getUsername() {
        return "root";
    }

    @Override
    protected String getPassword() {
        return "123456";
    }
}.execute(sql, rs -> {
    Person p = new Person();
    p.setId(rs.getInt("id"));
    p.setName(rs.getString("name"));
    return p;
});

总结：

模板方法是一种十分常用的设计模式，其可以大大减少代码的重复量，同时提高代码的可读性以及可维护性。在实践中，我们可以针对不同情况应用不同的模板方法模式，来达到我们想要的效果。