IT评测·应用市场-qidao123.com

标题: 聊一聊模板方法模式 [打印本页]

作者: 篮之新喜    时间: 2023-5-15 08:54
标题: 聊一聊模板方法模式
统一抽取,制定规范;
一、概述

模板方法模式,又叫模板模式,属于23种设计模式中的行为型模式。在抽象类中公开定义了执行的方法,子类可以按需重写其方法,但是要以抽象类中定义的方式调用方法。总结起来就是:定义一个操作的算法结构,而将一些步骤延迟到子类中。在不改变算法结构的情况下,子类能重定义该算法的特定步骤。
下面是模板模式的UML图,抽象类(AbstractClass)定义公共的步骤和方法,依次调用实际的模板方法,当然每个方法可以是抽象方法(需交给子类实现),也可以是提供默认的方法。具体的类(ConcreteClass)可以重写所有的方法,但是不能改变抽象类中定义的整体结构。

二、入门案例

相信大家都吃过蛋糕,现在市面上的蛋糕可谓是五花八门,你能想到的造型商家能给你整出来,你想不到的,他们也能整出来。不过无论造型如何变化,不变的有两种东西:“奶油”和“面包”。其余的材料随意搭配,就凑成了各式各样的蛋糕。

基于这个场景,我们来写一个案例,进一步了解下模板模式;创建三个类:Cake(蛋糕)、StrawberryCake(草莓蛋糕)、CherryCake(樱桃蛋糕)。最后创建一个Client类,实现这个制作蛋糕的调用过程。
  1. package com.wsrf.template;
  2. /**
  3. * @author 往事如风
  4. * @version 1.0
  5. * @date 2023/5/4 16:12
  6. * @description:抽象类:蛋糕
  7. */
  8. public abstract class Cake {
  9.     /**
  10.      * 制作
  11.      */
  12.     public void make() {
  13.         System.out.println("开始准备材料。");
  14.         bread();
  15.         cream();
  16.         fruit();
  17.         System.out.println("经过一系列的操作。");
  18.         System.out.println("制作完成。");
  19.     }
  20.     /**
  21.      * 准备面包
  22.      */
  23.     public void bread() {
  24.         System.out.println("准备材料:面包");
  25.     }
  26.     /**
  27.      * 准备奶油
  28.      */
  29.     public void cream() {
  30.         System.out.println("准备材料:奶油");
  31.     }
  32.     /**
  33.      * 准备水果
  34.      */
  35.     protected abstract void fruit();
  36. }
复制代码
  1. package com.wsrf.template;
  2. /**
  3. * @author 往事如风
  4. * @version 1.0
  5. * @date 2023/5/4 16:13
  6. * @description:具体类:草莓蛋糕
  7. */
  8. public class StrawberryCake extends Cake{
  9.     @Override
  10.     protected void fruit() {
  11.         System.out.println("准备材料:草莓");
  12.     }
  13. }
复制代码
  1. package com.wsrf.template;
  2. /**
  3. * @author 往事如风
  4. * @version 1.0
  5. * @date 2023/5/4 16:14
  6. * @description:具体类:樱桃蛋糕
  7. */
  8. public class CherryCake extends Cake{
  9.     @Override
  10.     protected void fruit() {
  11.         System.out.println("准备材料:樱桃");
  12.     }
  13. }
复制代码
  1. package com.wsrf.template;
  2. /**
  3. * @author 往事如风
  4. * @version 1.0
  5. * @date 2023/5/4 16:21
  6. * @description
  7. */
  8. public class Client {
  9.     public static void main(String[] args) {
  10.         Cake c1 = new CherryCake();
  11.         c1.make();
  12.         System.out.println("-------------------------------------");
  13.         Cake c2 = new StrawberryCake();
  14.         c2.make();
  15.     }
  16. }
  17. /**
  18. 输出结果:
  19. 开始准备材料。
  20. 准备材料:面包
  21. 准备材料:奶油
  22. 准备材料:樱桃
  23. 经过一系列的操作。
  24. 制作完成。
  25. -------------------------------------
  26. 开始准备材料。
  27. 准备材料:面包
  28. 准备材料:奶油
  29. 准备材料:草莓
  30. 经过一系列的操作。
  31. 制作完成。
  32. */
复制代码
在Cake类中定义了制作蛋糕的整个步骤,也就是make方法;然后抽取了公用的方法,bread方法和cream方法;最后定义一个抽象方法fruit,这个方法需要交给具体的子类StrawberryCake和CherryCake去实现,从而定制差异化的“蛋糕”。
三、运用场景

通过上面的“蛋糕”案例,在平时开发中我们可以具体分析一下业务需求,首先在父类中定义需求需要实现的步骤,然后将可以公用的方法抽取到父类中,将个性化的方法放到具体的子类中去实现;这样可以很好的培养“抽象化”的思维模式,这是拉开差距的第一步。
最近在开发中,遇到这样的一个业务场景:需要给不同的管理人员计算各种不同的津贴,如区域总监有区域管理津贴、佣金、培养育成津贴等等。通过分析,每种不用类型的津贴,都是需要金额x比例x系数,比例每种津贴都有不同的计算方式,系数也是。所以,大致的想法就是:金额x比例x系数这个计算方式设置为统一的方法,系数和比例让具体的津贴子类去实现。所以大致的伪代码如下;
首先,我定义了一个抽象类AbstractManageAllowanceCalService,用于定义统一的计算方法,并预留了获取比例和获取系数的抽象方法。
  1. /**
  2. * @author 往事如风
  3. * @version 1.0
  4. * @date 2023/5/4 17:12
  5. * @description:津贴计算父类
  6. */
  7. @Slf4j
  8. public abstract class AbstractManageAllowanceCalService {
  9.     /**
  10.      * 计算津贴
  11.      * @param amount
  12.      * @return
  13.      */
  14.     public BigDecimal calAmount(BigDecimal amount) {
  15.         if (Objects.isNull(amount)) {
  16.             return BigDecimal.ZERO;
  17.         }
  18.         BigDecimal ratio = getRatio();
  19.         BigDecimal coefficient = getCoefficient();
  20.         log.info("金额:{},系数:{},比例:{}", amount, coefficient, ratio);
  21.         return amount.multiply(ratio).multiply(coefficient);
  22.     }
  23.     /**
  24.      * 获取比例
  25.      * @return
  26.      */
  27.     protected abstract BigDecimal getRatio();
  28.     /**
  29.      * 获取系数
  30.      * @return
  31.      */
  32.     protected abstract BigDecimal getCoefficient();
  33. }
复制代码
然后,定义两个具体的子类,用于计算区域管理津贴和佣金。
  1. /**
  2. * @author 往事如风
  3. * @version 1.0
  4. * @date 2023/5/4 17:17
  5. * @description:区域管理津贴计算
  6. */
  7. @Service
  8. public class AreaBusinessAllowanceCalService extends AbstractManageAllowanceCalService{
  9.     /**
  10.      * 区域管理津贴比例
  11.      * @return
  12.      */
  13.     @Override
  14.     protected BigDecimal getRatio() {
  15.         return new BigDecimal(0.5).setScale(1, BigDecimal.ROUND_HALF_UP);
  16.     }
  17.     /**
  18.      * 区域管理津贴系数
  19.      * @return
  20.      */
  21.     @Override
  22.     protected BigDecimal getCoefficient() {
  23.         return new BigDecimal(0.92).setScale(2, BigDecimal.ROUND_HALF_UP);
  24.     }
  25. }
复制代码
  1. /**
  2. * @author 往事如风
  3. * @version 1.0
  4. * @date 2023/5/4 17:19
  5. * @description:佣金计算
  6. */
  7. @Service
  8. public class SalaryCalService extends AbstractManageAllowanceCalService{
  9.     /**
  10.      * 佣金比例
  11.      * @return
  12.      */
  13.     @Override
  14.     protected BigDecimal getRatio() {
  15.         return new BigDecimal(0.45).setScale(2, BigDecimal.ROUND_HALF_UP);
  16.     }
  17.     /**
  18.      * 佣金系数
  19.      * @return
  20.      */
  21.     @Override
  22.     protected BigDecimal getCoefficient() {
  23.         return new BigDecimal(0.88).setScale(2, BigDecimal.ROUND_HALF_UP);
  24.     }
  25. }
复制代码
最后,定义一个controller类,用于接口调用,提供计算能力;接收两个参数,金额和计算津贴类型。
  1. /**
  2. * @author 往事如风
  3. * @version 1.0
  4. * @date 2023/5/4 17:21
  5. * @description
  6. */
  7. @RestController
  8. @RequestMapping("/cal")
  9. public class CalController implements ApplicationContextAware {
  10.     private static ApplicationContext applicationContext;
  11.     @PostMapping("/amount")
  12.     public Result<BigDecimal> calAmount(BigDecimal amount, String calType) {
  13.         AbstractManageAllowanceCalService service = null;
  14.         if ("AREA".equals(calType)) {
  15.             // 区域管理津贴
  16.              service = (AbstractManageAllowanceCalService) applicationContext.getBean("areaBusinessAllowanceCalService");
  17.         } else if ("SALARY".equals(calType)) {
  18.             // 佣金
  19.             service = (AbstractManageAllowanceCalService) applicationContext.getBean("salaryCalService");
  20.         }
  21.         if (Objects.nonNull(service)) {
  22.             return Result.success(service.calAmount(amount));
  23.         }
  24.         return Result.fail();
  25.     }
  26.     @Override
  27.     public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
  28.         CalController.applicationContext = applicationContext;
  29.     }
  30. }
复制代码
在这个controller类中,我通过分析“类型”这个参数,来判断需要调用哪个service去实现具体的计算逻辑。这里用了if-else的方式去实现;其实也可以用到另一个设计模式——策略模式,这样写出来的代码就会比较优雅,这里就不对策略模式展开赘述了。
四、源码中运用

4.1、JDK源码中的模板模式

在JDK中其实也有很多地方运用到了模板模式,这里咱挑一个讲。并发包下的AbstractQueuedSynchronizer类,就是一个抽象类,也就是我们先前的文章中提到过的AQS。
  1. public abstract class AbstractQueuedSynchronizer
  2.     extends AbstractOwnableSynchronizer
  3.     implements java.io.Serializable {
  4.        
  5.     public final void acquire(int arg) {
  6.         if (!tryAcquire(arg) &&
  7.             acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
  8.             selfInterrupt();
  9.     }
  10.         public final boolean release(int arg) {
  11.         if (tryRelease(arg)) {
  12.             Node h = head;
  13.             if (h != null && h.waitStatus != 0)
  14.                 unparkSuccessor(h);
  15.             return true;
  16.         }
  17.         return false;
  18.     }
  19.     protected boolean tryAcquire(int arg) {
  20.         throw new UnsupportedOperationException();
  21.     }
  22.     protected boolean tryRelease(int arg) {
  23.         throw new UnsupportedOperationException();
  24.     }
  25. }        
复制代码
其中,tryAcquire和tryRelease这两个方式直接抛了异常,用protected关键词修饰,需要由子类去实现。然后再acquire和release方法中分别去调用这两方法。也就是acquire方法定义了一个统一的结构,差异化的tryAcquire方法需要具体的子类去实现功能,实现了模板模式。
4.2、Spring源码中的模板模式

说到源码,Spring是一个绕不开的话题,那就来学习下Spring中的模板模式。其中,有一个类DefaultBeanDefinitionDocumentReader,它是BeanDefinitionDocumentReader的实现类,是提取spring配置文件中的bean信息,并转化为BeanDefinition。
  1. public class DefaultBeanDefinitionDocumentReader implements BeanDefinitionDocumentReader {
  2.        
  3.     protected void doRegisterBeanDefinitions(Element root) {
  4.         BeanDefinitionParserDelegate parent = this.delegate;
  5.         this.delegate = this.createDelegate(this.getReaderContext(), root, parent);
  6.         //...
  7.         this.preProcessXml(root);
  8.         this.parseBeanDefinitions(root, this.delegate);
  9.         this.postProcessXml(root);
  10.         this.delegate = parent;
  11.     }
  12.     protected void preProcessXml(Element root) {
  13.     }
  14.     protected void postProcessXml(Element root) {
  15.     }
  16. }   
复制代码
这里我截图了其中的一段代码,主要是doRegisterBeanDefinitions这个方法,从跟节点root出发,root下的每个bean注册定义。
该方法中还调用了preProcessXml和postProcessXml这两个方法,但是在DefaultBeanDefinitionDocumentReader类中,这两个方法是未实现的,需要其子类去实现具体的逻辑。所以,这里也是一个很典型的模板模式的运用。
五、总结

模板方法模式其实是一个比较简单的设计模式,它有如下优点:1、封装不变的逻辑,扩展差异化的逻辑;2、抽取公共代码,提高代码的复用性;3、父类控制行为,子类实现细节。
其缺点就是不同的实现都需要一个子类去维护,会导致子类的个数不断增加,造成系统更加庞大。
用一句话总结:将公用的方法抽取到父类,在父类中预留可变的方法,最后子类去实现可变的方法。
模板模式更多的是考察我们对于公用方法的提取;对于编程也是这样,更多的是一种思维能力,不能只局限于代码,要把格局打开。

免责声明:如果侵犯了您的权益,请联系站长,我们会及时删除侵权内容,谢谢合作!




欢迎光临 IT评测·应用市场-qidao123.com (https://dis.qidao123.com/) Powered by Discuz! X3.4