Java设计模式透析之 —— 模板方法(Template Method)

最新推荐文章于 2022-05-11 16:14:09 发布
最新推荐文章于 2022-05-11 16:14:09 发布
阅读量645 收藏
点赞数
分类专栏： 设计模式 文章标签： XML 扩展 Java SQL 数据库

转载请注明出处：http://blog.csdn.net/sinyu890807/article/details/8744002

今天你还是像往常一样来上班，一如既往地开始了你的编程工作。

项目经理告诉你，今天想在服务器端增加一个新功能，希望写一个方法，能对Book对象进行处理，将Book对象的所有字段以XML格式进行包装，这样以后可以方便与客户端进行交互。并且在包装开始前和结束后要打印日志，这样方便调试和问题定位。

没问题！你觉得这个功能简直是小菜一碟，非常自信地开始写起代码。

Book对象代码如下：

[java]  view plain copy
  1. public class Book {  
  2.   
  3.     private String bookName;  
  4.   
  5.     private int pages;  
  6.   
  7.     private double price;  
  8.   
  9.     private String author;  
  10.   
  11.     private String isbn;  
  12.   
  13.     public String getBookName() {  
  14.         return bookName;  
  15.     }  
  16.   
  17.     public void setBookName(String bookName) {  
  18.         this.bookName = bookName;  
  19.     }  
  20.   
  21.     public int getPages() {  
  22.         return pages;  
  23.     }  
  24.   
  25.     public void setPages(int pages) {  
  26.         this.pages = pages;  
  27.     }  
  28.   
  29.     public double getPrice() {  
  30.         return price;  
  31.     }  
  32.   
  33.     public void setPrice(double price) {  
  34.         this.price = price;  
  35.     }  
  36.   
  37.     public String getAuthor() {  
  38.         return author;  
  39.     }  
  40.   
  41.     public void setAuthor(String author) {  
  42.         this.author = author;  
  43.     }  
  44.   
  45.     public String getIsbn() {  
  46.         return isbn;  
  47.     }  
  48.   
  49.     public void setIsbn(String isbn) {  
  50.         this.isbn = isbn;  
  51.     }  
  52.   
  53. }  

然后写一个类专门用于将Book对象包装成XML格式：
[java]  view plain copy
  1. public class Formatter {  
  2.   
  3.     public String formatBook(Book book) {  
  4.         System.out.println("format begins");  
  5.         String result = "";  
  6.         result += "<book_name>" + book.getBookName() + "</book_name>\n";  
  7.         result += "<pages>" + book.getPages() + "</pages>\n";  
  8.         result += "<price>" + book.getPrice() + "</price>\n";  
  9.         result += "<author>" + book.getAuthor() + "</author>\n";  
  10.         result += "<isbn>" + book.getIsbn() + "</isbn>\n";  
  11.         System.out.println("format finished");  
  12.         return result;  
  13.     }  
  14.   
  15. }  
调用代码如下：
[java]  view plain copy
  1. public class Test {  
  2.       
  3.     public static void main(String[] args) throws Exception {  
  4.         Book book = new Book();  
  5.         book.setBookName("Thinking in Java");  
  6.         book.setPages(880);  
  7.         book.setPrice(68);  
  8.         book.setAuthor("Bruce Eckel");  
  9.         book.setIsbn("9787111213826");  
  10.         Formatter formatter = new Formatter();  
  11.         String result = formatter.formatBook(book);  
  12.         System.out.println(result);  
  13.     }  
  14.   
  15. }  

你写好了之后，迫不及待地开始运行，运行结果也完全符合你的期望。


项目经理看完后，对你非常满意，小伙效率很高的嘛！你也非常的得意。

不过两天之后，项目经理又找到了你，他说之前没有考虑到需要交互的客户端还包括手机设备，而手机设备都比较吃流量，用XML格式来传输太耗流量了，想最好能改成使用JSON格式传输。但是之前的XML格式也要保留，最好可以由客户端指定使用哪种格式。

你有些不开心，心里低估着，为什么一开始不考虑周全呢，现在又要改遗留代码。但对方毕竟是领导，你还是要服从命令的，于是你开始修改Formatter类：

[java]  view plain copy
  1. public class Formatter {  
  2.   
  3.     public static final int XML = 0;  
  4.   
  5.     public static final int JSON = 1;  
  6.   
  7.     public String formatBook(Book book, int format) {  
  8.         System.out.println("format begins");  
  9.         String result = "";  
  10.         if (format == XML) {  
  11.             result += "<book_name>" + book.getBookName() + "</book_name>\n";  
  12.             result += "<pages>" + book.getPages() + "</pages>\n";  
  13.             result += "<price>" + book.getPrice() + "</price>\n";  
  14.             result += "<author>" + book.getAuthor() + "</author>\n";  
  15.             result += "<isbn>" + book.getIsbn() + "</isbn>\n";  
  16.         } else if (format == JSON) {  
  17.             result += "{\n";  
  18.             result += "\"book_name\" : \"" + book.getBookName() + "\",\n";  
  19.             result += "\"pages\" : \"" + book.getPages() + "\",\n";  
  20.             result += "\"price\" : \"" + book.getPrice() + "\",\n";  
  21.             result += "\"author\" : \"" + book.getAuthor() + "\",\n";  
  22.             result += "\"isbn\" : \"" + book.getIsbn() + "\",\n";  
  23.             result += "}";  
  24.         }  
  25.         System.out.println("format finished");  
  26.         return result;  
  27.     }  
  28.   
  29. }  

调用代码如下：
[java]  view plain copy
  1. public class Test {  
  2.   
  3.     public static void main(String[] args) throws Exception {  
  4.         Book book = new Book();  
  5.         book.setBookName("Thinking in Java");  
  6.         book.setPages(880);  
  7.         book.setPrice(68);  
  8.         book.setAuthor("Bruce Eckel");  
  9.         book.setIsbn("9787111213826");  
  10.         Formatter formatter = new Formatter();  
  11.         String result = formatter.formatBook(book, Formatter.XML);  
  12.         System.out.println(result);  
  13.         result = formatter.formatBook(book, Formatter.JSON);  
  14.         System.out.println(result);  
  15.     }  
  16.   
  17. }  
再次运行程序，得到了以下结果。


项目经理看到运行结果后开心地说：“太好了，这正是我想要的！” 

可是你这次却没有那么开心，你觉得代码已经有些混乱了，XML格式的逻辑和JSON格式的逻辑混淆在一起，非常不利于阅读，而且如果以后还需要扩展功能也会非常困难。好在传输格式一般也就XML和JSON了，应该不会再有什么扩展了，你这样安慰自己道。

但幻想总会被现实打破，“我最近听说有个YAML格式挺好玩的.......” 项目经理说道。这个时候你已经有想打人的冲动了！！！


很多时候就是这样，在公司里写的代码乱七八糟，质量极差，很大一部分原因就是因为需求变来变去。我们不断在原有代码基础上补充各种后续加入的情况，在一行行新增的if语句下面，我们的代码变得不堪入目。当然，我们作为程序员，对于需求这种东西没有太多的话语权，在这方面我们无能为力。但是我们可以尽量地把程序的架构设计好，让我们写出的代码更具有扩展性，这样就可以应对各种需求变更了。


下面你将要使用23种设计模式中的模板方法来改进以上程序。

首先将Formatter中的代码进行修改，如下所示：

[java]  view plain copy
  1. public abstract class Formatter {  
  2.   
  3.     public String formatBook(Book book, int format) {  
  4.         beforeFormat();  
  5.         String result = formating(book);  
  6.         afterFormat();  
  7.         return result;  
  8.     }  
  9.   
  10.     protected void beforeFormat() {  
  11.         System.out.println("format begins");  
  12.     }  
  13.   
  14.     protected abstract String formating(Book book);  
  15.   
  16.     protected void afterFormat() {  
  17.         System.out.println("format finished");  
  18.     }  
  19.   
  20. }  
你会发现format_book方法只有四步，第一步调用before_format，去打印格式转换前的日志。第二步调用formating，这个方法是个抽象方法，用于处理具体的转换逻辑，因此每一个继承自Formatter的子类都需要重写此方法，来实现各自的转换逻辑。第三步调用after_format，去打印格式转换后的日志。第四步返回result。由于类中存在了抽象方法，我们也就需要把Formatter声明成抽象类。

然后要定义专门的子类来处理每种传输格式的具体逻辑，这样不同传输格式的逻辑可以从一个方法里分离开，明显便于阅读和理解。

定义类XMLFormatter继承自Formatter，里面加入处理XML格式的具体逻辑：

[java]  view plain copy
  1. public class XMLFormatter extends Formatter {  
  2.   
  3.     @Override  
  4.     protected String formating(Book book) {  
  5.         String result = "";  
  6.         result += "<book_name>" + book.getBookName() + "</book_name>\n";  
  7.         result += "<pages>" + book.getPages() + "</pages>\n";  
  8.         result += "<price>" + book.getPrice() + "</price>\n";  
  9.         result += "<author>" + book.getAuthor() + "</author>\n";  
  10.         result += "<isbn>" + book.getIsbn() + "</isbn>\n";  
  11.         return result;  
  12.     }  
  13.   
  14. }  

定义类JSONFormatter继承自Formatter，里面加入处理JSON格式的具体逻辑：
[java]  view plain copy
  1. public class JSONFormatter extends Formatter {  
  2.   
  3.     @Override  
  4.     protected String formating(Book book) {  
  5.         String result = "";  
  6.         result += "{\n";  
  7.         result += "\"book_name\" : \"" + book.getBookName() + "\",\n";  
  8.         result += "\"pages\" : \"" + book.getPages() + "\",\n";  
  9.         result += "\"price\" : \"" + book.getPrice() + "\",\n";  
  10.         result += "\"author\" : \"" + book.getAuthor() + "\",\n";  
  11.         result += "\"isbn\" : \"" + book.getIsbn() + "\",\n";  
  12.         result += "}";  
  13.         return result;  
  14.     }  
  15.   
  16. }  

最后调用代码如下：

[java]  view plain copy
  1. public class Test {  
  2.   
  3.     public static void main(String[] args) throws Exception {  
  4.         Book book = new Book();  
  5.         book.setBookName("Thinking in Java");  
  6.         book.setPages(880);  
  7.         book.setPrice(68);  
  8.         book.setAuthor("Bruce Eckel");  
  9.         book.setIsbn("9787111213826");  
  10.         XMLFormatter xmlFormatter = new XMLFormatter();  
  11.         String result = xmlFormatter.formatBook(book);  
  12.         System.out.println(result);  
  13.         JSONFormatter jsonFormatter = new JSONFormatter();  
  14.         result = jsonFormatter.formatBook(book);  
  15.         System.out.println(result);  
  16.     }  
  17.   
  18. }  

运行之后，你会发现运行结果和修改前代码的运行结果完全相同。但是使用模板方法之后，代码的可读性有了很大的提高，因为处理格式转换的代码都放到了各自的类当中，而不是全部塞进一个方法中。并且在扩展性上也有了很大的提升，比如你开始感兴趣项目经理说的YAML格式了。

定义类YAMLFormatter继承自Formatter，里面加入处理YAML格式的具体逻辑：

[java]  view plain copy
  1. public class YAMLFormatter extends Formatter {  
  2.   
  3.     @Override  
  4.     protected String formating(Book book) {  
  5.         String result = "";  
  6.         result += "book_name: " + book.getBookName() + "\n";  
  7.         result += "pages: " + book.getPages() + "\n";  
  8.         result += "price: " + book.getPrice() + "\n";  
  9.         result += "author: " + book.getAuthor() + "\n";  
  10.         result += "isbn: " + book.getIsbn() + "\n";  
  11.         return result;  
  12.     }  
  13.   
  14. }  

调用代码只需要加入：
[java]  view plain copy
  1. YAMLFormatter yamlFormatter = new YAMLFormatter();  
  2. String result = yamlFormatter.formatBook(book);  
  3. System.out.println(result);  

好了，令人头疼的YAML格式就这样被支持了，只需要在调用的时候决定是实例化XMLFormatter，JSONFormatter还是YAMLFormatter，就可以按照相应的规格进行格式转换了。而且整体的代码很有条理，看起来也很舒心。这个时候，你会轻松地向项目经理调侃一句，还有需要支持的格式吗？


模板方法： 定义一个操作中的算法的骨架，而将一些步骤延迟到子类中，模板方法使得子类可以不改变一个算法的结构即可重定义该算法的某些特定步骤。

轻云.
关注
专栏目录
设计模式-模板方法模式Template Method(对象行为型)
justkong的博客
08-30 289
一、概述 定义一个操作中的算法的框架，而将一些步骤延迟到子类中。使得子类可以不改变一个算法的结构即可重定义该算法的某些特定步骤。 AbstractClass叫做抽象模板，它的方法分为两类： （1）原始方法，是由子类实现的方法，并且在模板方法被调用 （2）模板方法，可以有一个或几个，实现对原始方法的调度，完成固定的逻辑 class AbstractClass { public: ...
导出文件为word文档
GZSGZSgg的博客
09-14 539
WordUtil word 处理工具类 1.定义要生成的模板 生成ftl 文件 <?xml version="1.0" encoding="utf-8"?> <?mso-application progid="Word.Document"?> <w:wordDocument xmlns:w="http://schemas.microsoft.com/office/word/2003/wordml" xmlns:v="urn:schemas-microsoft-com:vml"
Ruby-StringTemplate一个快速的Rails的模板引擎
08-15
StringTemplate一个快速的Rails的模板引擎，使用Ruby的字符串插值语法专注于速度
Ruby Template "Amrita" 介绍
buaawhl的专栏
06-25 176
HTML模板 + 数据模型 = HTML输出 http://amrita.sourceforge.jp/ What is Amrita? Amrita is a a html/xhtml template library for Ruby. It makes html documents from a template and a model data. [img]ht...
基于Java和Kotlin的HTML整合家庭透析医护端（腹透）设计源码
最新发布
10-02
本项目为基于Java和Kotlin语言开发的HTML整合家庭透析医护端（腹透）设计源码，包含1413个文件，包括661个Java源文件、438个XML配置文件、87个Kotlin源文件、164个PNG图片文件、15个webp图片文件、8个JPG图片文件、8...
轻松搞懂设计模式
06-14
设计模式是一种可以复用的思想，因其可以复用，所以都不会太复杂。...每个模式花费比较大的篇幅从生活现象、模式概念、项目中实际应用、UML类图分析这四个维度进行全方位透析。本课程案例均采用Java编程语言实现。
Java深入解析 透析Java本质的36个话题
08-08
Java深入解析 透析Java本质的36个话题
（新高考适用）4 任务群四　古典诗歌鉴赏4 微视角 高考诗歌鉴赏典型题型归类透析 课件——2021届高考语文冲刺复习.ppt
09-10
（新高考适用）4 任务群四　古典诗歌鉴赏4 微视角 高考诗歌鉴赏典型题型归类透析 课件——2021届高考语文冲刺复习.ppt
yaml格式检查linux,如何在GNU Nano中为YAML(YML)文件启用语法突出显示
weixin_36296064的博客
05-12 1008
本文概述GNU nano是一个简单的基于终端的文本编辑器。尽管不如Emacs或Vim强大, 但它易于学习和使用。许多开发人员都喜欢此编辑器, 因为它只需要在服务器上快速编辑单个文件, 它的使用非常简单且非常有用。你需要在这种编辑器中经常更改的那些文件之一是配置文件, 例如yaml文件。 Nano为许多文件类型提供语法高亮显示, 但对于yaml文件则不提供。如果还要突出显示此类文件, 则需要执行额外...
【java设计模式】之 模板方法（Template Method）模式
武哥聊编程
05-06 1万+
1. 模板方法的一个实例         这一节主要来学习一下设计模式中的模板方法模式。我们先来看一个例子：假如现在老板让你做一个汽车的模型，要求只要完成基本功能即可，不考虑扩展性，那你会怎么做呢？我们首先会根据经验设计一个类图：        由这个类图可知，非常简单的实现了悍马车，该车有两个型号H1和H2。那现在我们开始实现这两个型号的悍马车，首先我们得把抽象类写好，然后两个不同的模型...
设计模式_23种设计模式详细解析
Chill Lyn
05-22 7021
文章目录参考单例模式 Singleton定义与特点结构与实现饿汉式单例懒汉式单例（静态内部类实现）懒汉式单例（DCL实现）应用场景Spring中的单例模式原型模式Prototype定义与特点结构与实现应用场景工厂方法模式（Factory Method）定义与特点结构与实现应用场景Spring中的工厂方法模式JDK中的抽象方法模式扩展-简单工厂模式Spring中的简单工厂模式抽象工厂模式（AbstractFactory）定义和特点结构与实现应用场景建造者模式（Builder）定义与特点结构与实现应用场景Spr
Java设计模式之模板方法模式（Template Method）
一个本科小生的奋斗史
04-15 4万+
本文属于23种设计模式系列，介绍的是模板方法模式。
Java 设计模式 Template Method 模板方法 模式
热门推荐
05-11 5万+
Java 设计模式 Template Method 模板方法 模式 Template Method模式用于在父类中定义处理流程的框架，在子类中实现具体处理。有点是由于在父类的模板方法里编写了算法，因此无需在每个子类中再编写算法。 涉及到的角色 抽象类：负责实现模板方法，定义模板方法中所使用到的抽象方法。 具体类：负责实现抽象类角色定义的抽象方法 /** * 抽象类 * @author 托马斯小火车喷雾又喷烟 * */ public abstract class Teac...
模板方法模式Template method（类行为型）
it_man的专栏
07-18 1607
今天重读了 模板方法 模式，温故而知新 了。 她是基于继承的代码复用的基本技术，她的结构和用法也是面向对象设计的核心。 java方面应用：selvert中就用到了。   命名规范：钩子方法的名字应以do开头。   大家自己去看资料会理解深些。 有问题可以在这里提问。   设计模式的有趣见解 :   TEMPLATE METHOD——看过《如何说服女生上床》这部经典文章吗？女生从认
设计模式之Template Method模式
风哲的博客
03-09 3515
Template Method模式，模板方法模式。顾名思义，其定义就是在父类中定义处理流程的框架，在子类中实现具体的处理方式。先直接上代码，然后我们再来讨论这种模式。现在的大概需求是这样的。 传入一个char型'A'，打印如下结果： 输入“Hello World !”打印出如下结果： 在设计模式中我们用到的例子都是一些很简单的例子，主要阐述的是一种思想，然后在自己的项目中
设计模式在项目中是如何用的？模板方法模式篇（Template Method Pattern）
09-28 524
模板方法模式是什么？有哪些应用场景？ 所谓策略模式，就是一个类的行为或其算法可以在运行时更改 策略模式的应用场景是系统中存在【总分结构】，即对于同一个业务存在有相似的分支逻辑（实现），而区分它们的仅仅是业务类型的不同，这样就可以用策略模式从多种相似的算法中筛选出目标算法，从而避免了使用 if…else 所带来的复杂和难以维护。 模板方法模式的实现 策略模式的实现，关键代码是多个类实现同一个接口（Strategy接口），同时另有一个类持有该接口的所有实现类（持有Strategy所有实现类的Context
透析Java数据库连接池：原理与应用详解
Java数据库连接池是Java应用程序在与数据库交互时提高性能和资源管理的关键组件。它允许在多个应用程序线程之间重用数据库连接，避免了频繁创建和关闭连接带来的开销。本文将深入探讨Apache Commons DBCP（一个常用...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值