23种设计模式_MODE14模板模式_手写代码实现

迈不过友情╰ 2023-10-10 16:51 10阅读 0赞

![在这里插入图片描述][59fd4d34b01f4df8b6f2a85f0f998bf9.png]

### 1.模板方法测试 ###

package com.zhaoshuangjian.mode14_模板模式;
 
 import com.zhaoshuangjian.mode14_模板模式.mode14.JDBC模板And回调实现.GoodsQueryServiceImpl;
 import com.zhaoshuangjian.mode14_模板模式.mode14.JDBC模板And回调实现.UserQueryServiceImpl;
 import com.zhaoshuangjian.mode14_模板模式.mode14.JDBC模板方法实现.AbstractJdbcTemplate;
 import com.zhaoshuangjian.mode14_模板模式.mode14.JDBC模板方法实现.GoodsTemplateImpl;
 import com.zhaoshuangjian.mode14_模板模式.mode14.JDBC模板方法实现.UserTemplateImpl;
 import com.zhaoshuangjian.mode14_模板模式.mode14.父类固定算法步骤.AbstractCalculator;
 import com.zhaoshuangjian.mode14_模板模式.mode14.父类固定算法步骤.Plus;
 import com.zhaoshuangjian.mode14_模板模式.mode14.父类固定算法步骤.Sub;
 
 import java.sql.SQLException;
 
 /**
 * 模板方法测试
 *
 * @Author zhaoshuangjian 2023-03-25 下午21:44
 */
 public class TemplateTest {
 
 public static void main(String[] args) throws SQLException{
 calculate();
 jdbc();
 jdbcCallBack();
 }
 
 private static void calculate(){
 
 System.out.println("====================== 11 + 2 加法公式计算 ");
 AbstractCalculator plus = new Plus();
 System.out.println(plus.calculate("11 + 2", "\\+"));
 
 System.out.println("====================== 11 - 2 减法公式计算");
 AbstractCalculator sub = new Sub();
 System.out.println(sub.calculate("11 - 2", "\\-"));
 
 }
 
 private static void jdbc() throws SQLException {
 
 System.out.println("====================== 用户数据层操作实现 ");
 AbstractJdbcTemplate userTemplate = new UserTemplateImpl();
 userTemplate.execute("select * from user ");
 System.out.println("====================== 商品数据层操作实现 ");
 AbstractJdbcTemplate goodsTemplate = new GoodsTemplateImpl();
 goodsTemplate.execute("select * from goods ");
 
 }
 
 private static void jdbcCallBack() throws SQLException {
 
 System.out.println("====================== 用户数据层操作实现（模板+回调） ");
 UserQueryServiceImpl queryService = new UserQueryServiceImpl();
 queryService.query("select * from user ");
 System.out.println("====================== 商品数据层操作实现（模板+回调）");
 GoodsQueryServiceImpl goodsQueryService = new GoodsQueryServiceImpl();
 goodsQueryService.query("select * from goods ");
 
 }
 
 /**
 *
 * 百科中如此描述模板方法：
 * 模板方法模式定义了一个算法的步骤，并允许子类别为一个或多个步骤提供其实践方式。
 * 让子类别在不改变算法架构的情况下，重新定义算法中的某些步骤。
 *
 * 模板方法和策略模式有点像，都是由子类最终实现算法，二者区别是：
 * （1）策略模式定义了一个统一的算法接口，由具体的算法子类实现，所有的算法方法必须暴露给子类，
 * 由子类来实现，这样会产生一个问题，就是在执行算法之前如果有大量的数据准备工作，则会
 * 增加子算法方法块代码的臃肿度，使得大量代码重复得不到复用！
 * （2）模板方法定一个抽象的类，由父类统一定义实现算法的步骤，具体实现延迟到子类，
 * 属于算法"定制"，对特定的重复的算法部分实现了封装，只对扩展的部分暴露给子类！
 *
 * 优点：
 * 想必不用说，我们都可以看出来，模板方法的一个最大的好处就是实现了重复代码的复用！
 * 另外一个就是，扩展很方便！
 * 缺点：
 * 和策略模式一样，也存在子类过多的情况出现，类一多，维护起来的复杂度就增加了！
 *
 * 假如，一个抽象类有4个子类，你可能会说，也就才4个啊，半个小时都能看的透透彻彻了
 * 假如，一个抽象类有100个子类，你可能会皱着眉头说，卧槽，这特么还是人吗，怎么写了这么多？
 * 所以，类并不是越多越能体现系统的健壮性，反而多了会适得其反噢！
 */
 
 
 }

### 2.商品查询业务类 ###

package com.zhaoshuangjian.mode14_模板模式.mode14.JDBC模板And回调实现;
 
 import java.sql.SQLException;
 import java.sql.Statement;
 
 /**
 * 商品查询业务类
 *
 * @Author zhaoshuangjian 2023-03-25 下午21:44
 */
 public class GoodsQueryServiceImpl {
 public Object query(String sql) throws SQLException{
 return new JdbcTemplate().executeQuery(new GoodsQueryStatementCallBack(sql));
 }
 }
 
 /**
 * 内部类 == 用户查询数据库操作对象回调类
 */
 class GoodsQueryStatementCallBack implements StatementCallback {
 
 private String sql;
 
 public GoodsQueryStatementCallBack(String sql) {
 this.sql = sql;
 }
 
 @Override
 public Object doInStatement(Statement stmt) throws SQLException {
 System.out.println("执行SQL语句：" + sql);
 System.out.println("数据集处理成功，返回Goods数据实体对象");
 return null;
 }
 
 }

### 3.数据库操作模板类 ###

package com.zhaoshuangjian.mode14_模板模式.mode14.JDBC模板And回调实现;
 
 import java.sql.Connection;
 import java.sql.SQLException;
 import java.sql.Statement;
 
 /**
 * 数据库操作模板类
 *
 * @Author zhaoshuangjian 2023-03-25 下午21:44
 */
 public class JdbcTemplate {
 
 public final Object execute(StatementCallback callback) throws SQLException {
 
 // 1、首先获取数据库连接对象
 Connection connection = getConnection();
 // 2、根据连接获取statement对象（数据库操作对象）
 Statement stmt = getStament(connection);
 // 3、根据stmt回调子类方法 --> 执行sql语句获取最终结果
 return callback.doInStatement(stmt);
 
 // 资源的释放这里我就省略了
 }
 
 private Connection getConnection(){
 System.out.println("获取数据库连接");
 return null;
 }
 
 private Statement getStament(Connection connection){
 System.out.println("获取数据库操作对象");
 return null;
 }
 
 public Object executeQuery(StatementCallback callback) throws SQLException{
 return execute(callback);
 }
 
 /**
 * 如果该类是抽象类，则定义以下四个抽象方法，则其子类必须全部实现
 * 回调的好处，即子类只需要实现父类中的某一个方法即可，该方法可以抽离成一个接口的方法
 */
 // protected abstract void A();
 // protected abstract void B();
 // protected abstract void C();
 // protected abstract void D();
 }

### 4.数据库操作回调接口 ###

package com.zhaoshuangjian.mode14_模板模式.mode14.JDBC模板And回调实现;
 
 import java.sql.SQLException;
 import java.sql.Statement;
 
 /**
 * 数据库操作回调接口
 *
 * @Author zhaoshuangjian 2023-03-25 下午21:44
 */
 public interface StatementCallback {
 
 Object doInStatement(Statement stmt) throws SQLException;
 
 }

### 5.用户查询业务类 ###

package com.zhaoshuangjian.mode14_模板模式.mode14.JDBC模板And回调实现;
 
 import java.sql.SQLException;
 import java.sql.Statement;
 
 /**
 * 用户查询业务类
 *
 * @Author zhaoshuangjian 2023-03-25 下午21:44
 */
 public class UserQueryServiceImpl{
 
 public Object query(String sql) throws SQLException{
 return new JdbcTemplate().executeQuery(new UserQueryStatementCallBack(sql));
 }
 
 }
 
 /**
 * 内部类 == 用户查询数据库操作对象回调类
 */
 class UserQueryStatementCallBack implements StatementCallback{
 
 private String sql ;
 
 public UserQueryStatementCallBack(String sql){
 this.sql = sql;
 }
 
 @Override
 public Object doInStatement(Statement stmt) throws SQLException {
 System.out.println("执行SQL语句："+sql);
 System.out.println("数据集处理成功，返回User数据实体对象");
 return null;
 }
 
 }

### 6.模拟JDB模板类（可以理解为伪代码说明） ###

package com.zhaoshuangjian.mode14_模板模式.mode14.JDBC模板方法实现;
 
 import java.sql.Connection;
 import java.sql.ResultSet;
 import java.sql.SQLException;
 import java.sql.Statement;
 
 /**
 * 模拟JDB模板类（可以理解为伪代码说明）
 *
 * @Author zhaoshuangjian 2023-03-25 下午21:44
 */
 public abstract class AbstractJdbcTemplate {
 
 public final Object execute(String sql) throws SQLException {
 
 // 1、首先获取数据库连接对象
 Connection connection = getConnection();
 // 2、根据连接获取statement对象（数据库操作对象）
 getStament(connection);
 // 3、使用数据库操作对象来执行对应的SQL语句
 ResultSet rs = executeQuery(sql);
 // 4、最后基于查询的数据集，处理并返回最终结果
 return doInStatement(rs);
 
 // 资源的释放这里我就省略了
 }
 
 private Connection getConnection(){
 System.out.println("获取数据库连接");
 return null;
 }
 
 private Statement getStament(Connection connection){
 System.out.println("获取数据库操作对象");
 return null;
 }
 
 private ResultSet executeQuery(String sql){
 System.out.println("执行SQL语句："+sql);
 return null;
 }
 
 /**
 * 基于结果集进行定制，由具体的子类实现
 * @param rs 结果集
 * @return 数据模型对象
 */
 protected abstract Object doInStatement(ResultSet rs) throws SQLException;
 
 }

### 7.商品数据库操作（模板）实现类 ###

package com.zhaoshuangjian.mode14_模板模式.mode14.JDBC模板方法实现;
 
 import java.sql.ResultSet;
 import java.sql.SQLException;
 
 /**
 * 商品数据库操作（模板）实现类
 *
 * @Author zhaoshuangjian 2023-03-25 下午21:44
 */
 public class GoodsTemplateImpl extends AbstractJdbcTemplate {
 
 @Override
 protected Object doInStatement(ResultSet rs) throws SQLException {
 
 // 遍历数据集
 // while (rs.next()){
 // // dosomething
 // }
 
 System.out.println("数据集处理成功，返回Goods数据实体对象");
 return null;
 }
 
 }

### 8.用户数据库操作（模板）实现类 ###

package com.zhaoshuangjian.mode14_模板模式.mode14.JDBC模板方法实现;
 
 import java.sql.ResultSet;
 import java.sql.SQLException;
 
 /**
 * 用户数据库操作（模板）实现类
 *
 * @Author zhaoshuangjian 2023-03-25 下午21:44
 */
 public class UserTemplateImpl extends AbstractJdbcTemplate {
 
 @Override
 protected Object doInStatement(ResultSet rs) throws SQLException {
 
 // 遍历数据集
 // while (rs.next()){
 // // dosomething
 // }
 
 System.out.println("数据集处理成功，返回User数据实体对象");
 return null;
 }
 }

### 9.定义抽象算法类 ###

package com.zhaoshuangjian.mode14_模板模式.mode14.父类固定算法步骤;
 
 /**
 * 定义抽象算法类
 *
 * @Author zhaoshuangjian 2023-03-25 下午21:44
 */
 public abstract class AbstractCalculator {
 
 public final double calculate(String formula , String splitChar){
 // 1、第一步，先根据计算公式和分隔符，拿到要计算的数值（假设这个是核心，不对外公布）
 double[] splitArry = split(formula, splitChar);
 // 2、第二步，各个算法类代表发个言吧（默认不发言的，一律按父类说的来）
 hookSay();
 // 3、第三步，话说完了，各个算法（子）类开始干活吧（这时候别再指望父类帮你默认实现了，休想！）
 return calculate(splitArry[0], splitArry[1]);
 }
 
 
 /**
 * 根据字符分割公式，提取double数组
 * @param formula 计算公式
 * @param splitChar 分隔字符
 * @return double数组
 */
 private double[] split(String formula , String splitChar){
 String array[] = formula.trim().split(splitChar);
 double arrayDouble[] = new double[2];
 arrayDouble[0] = Double.parseDouble(array[0]);
 arrayDouble[1] = Double.parseDouble(array[1]);
 return arrayDouble;
 }
 
 /**
 * 公开（钩子）方法，子类和父类进行信息交互，子类可以使用默认的父类方法，也可以重写改方法
 */
 public void hookSay(){
 System.out.println("父类说：算法步骤的顺序我已经定好了，尔等子类照着做就行！");
 }
 
 /**
 * 根据a和b的值计算结果，这个必须由子类来实现，父类帮不了了
 * @param numA 第一个数字
 * @param numB 第二个数字
 * @return 两个数字计算的结果
 */
 protected abstract double calculate(double numA ,double numB);
 
 }

### 10.加法运算 ###

package com.zhaoshuangjian.mode14_模板模式.mode14.父类固定算法步骤;
 
 /**
 * 加法运算
 *
 * @Author zhaoshuangjian 2023-03-25 下午21:44
 */
 public class Plus extends AbstractCalculator{
 
 
 @Override
 protected double calculate(double numA, double numB) {
 return numA + numB ;
 }
 
 
 /**
 * 重写父类钩子方法
 */
 @Override
 public void hookSay() {
 System.out.println("子类Plus说：接下来，由我来计算结果！");
 }
 
 }

### 11.减法运算 ###

package com.zhaoshuangjian.mode14_模板模式.mode14.父类固定算法步骤;
 
 /**
 * 减法运算
 *
 * @Author zhaoshuangjian 2023-03-25 下午21:44
 */
 public class Sub extends AbstractCalculator{
 
 @Override
 protected double calculate(double numA, double numB) {
 return numA - numB ;
 }
 
 }

[59fd4d34b01f4df8b6f2a85f0f998bf9.png]: https://img-blog.csdnimg.cn/59fd4d34b01f4df8b6f2a85f0f998bf9.png