位置：首页 > Ruby > Ruby模板方法模式应用实例解析与设计模式实践

Ruby模板方法模式应用实例解析与设计模式实践

时间：2026-08-17  |  作者：极客少年  |  阅读：0

想象一下，你像往常一样打开电脑，项目经理突然递过来一个任务：在服务器端加个新功能，把Book对象的所有字段包装成XML格式，方便和服务端交互。而且包装前后要打日志，方便调试。你心想，这还不简单？于是飞快地敲起了代码。

先定义一个Book类：

class Book 
 attr_accessor :book_name, :pages, :price, :author, :isbn 
end

再写一个专门的格式化类：

class Formatter 
 
 def format_book(book) 
  puts "format begins" 
  result = "#{book.book_name}n" 
  result += "#{book.pages}n" 
  result += "#{book.price}n" 
  result += "#{book.author}n" 
  result += "#{book.isbn}n" 
  puts "format finished" 
  result 
 end 
 
end

调用它：

book = Book.new 
book.book_name = "Programming Ruby" 
book.pages = 830 
book.price = 45 
book.author = "Da ve Thomas" 
book.isbn = "9787121038150" 
formatter = Formatter.new 
result = formatter.format_book(book) 
puts result

运行结果完全符合预期，项目经理看了直夸效率高。你也挺得意，觉得这活儿干得漂亮。

2016316160008180.png (357×125)

可没过两天，项目经理又来了，说客户端还包括手机设备，XML太耗流量，最好能改成JSON格式传输，但XML格式也要保留，让客户端自己选。你心里默默吐槽：为什么一开始不想清楚？但没办法，还是得改。于是Formatter类变成了这样：

class Formatter 
 
 def format_book(book, format) 
  puts "format begins" 
  result = "" 
  if format == :xml 
   result += "#{book.book_name}n" 
   result += "#{book.pages}n" 
   result += "#{book.price}n" 
   result += "#{book.author}n" 
   result += "#{book.isbn}n" 
  elsif format == :json 
   result += "{n" 
   result += ""book_name" : "#{book.book_name}",n" 
   result += ""pages" : "#{book.pages}",n" 
   result += ""price" : "#{book.price}",n" 
   result += ""author" : "#{book.author}",n" 
   result += ""isbn" : "#{book.isbn}",n" 
   result += '}' 
  end 
  puts "format finished" 
  result 
 end 
 
end

调用时指定格式：

book = Book.new 
book.book_name = "Programming Ruby" 
book.pages = 830 
book.price = 45 
book.author = "Da ve Thomas" 
book.isbn = "9787121038150" 
formatter = Formatter.new 
result = formatter.format_book(book, :xml) 
puts result 
result = formatter.format_book(book, :json) 
puts result

运行结果也符合预期，项目经理很开心。但你自己却高兴不起来——代码里XML和JSON的逻辑混在一起，看着就乱，以后要扩展怎么办？你安慰自己：传输格式嘛，也就XML和JSON了，不会再变了。

可是现实总爱打脸。项目经理说：“我听说有个YAML格式挺好玩……” 你差点没忍住想打人。

这其实是很多项目中的常态——需求变来变去，代码在不断的if语句中变得不堪入目。作为程序员，我们对需求没有太多话语权，但我们可以把架构设计得更有扩展性，来应对这些变化。下面就用模板方法模式来重构。

思路很简单：把每种格式的具体逻辑放到独立的子类里，这样它们就不会搅在一起了。先定义XMLFormatter：

class XMLFormatter < Formatter 
 
 def formating(book) 
  result = "#{book.book_name}n" 
  result += "#{book.pages}n" 
  result += "#{book.price}n" 
  result += "#{book.author}n" 
  result += "#{book.isbn}n" 
 end 
 
end

再定义JSONFormatter：

class JSONFormatter < Formatter 
  
 def formating(book) 
  result = "{n" 
  result += ""book_name" : "#{book.book_name}",n" 
  result += ""pages" : "#{book.pages}",n" 
  result += ""price" : "#{book.price}",n" 
  result += ""author" : "#{book.author}",n" 
  result += ""isbn" : "#{book.isbn}",n" 
  result += '}' 
 end 
  
end

然后修改父类Formatter，把公共流程（日志、格式化、返回结果）固定下来，具体格式化逻辑由子类实现：

class Formatter 
 
 def format_book(book) 
  before_format 
  result = formating(book) 
  after_format 
  result 
 end 
  
 def before_format 
  puts "format begins" 
 end 
  
 def formating(book) 
  raise "You should override this method in subclass." 
 end 
  
 def after_format 
  puts "format finished" 
 end 
 
end

注意format_book方法只有四步：先调before_format打印日志，再调formating做具体转换（父类中直接抛异常，提示子类必须重写），然后调after_format打印结束日志，最后返回结果。这样，每个子类只需要关注自己格式的转换逻辑，父类负责流程编排。

调用代码也变得清晰干净：

book = Book.new 
book.book_name = "Programming Ruby" 
book.pages = 830 
book.price = 45 
book.author = "Da ve Thomas" 
book.isbn = "9787121038150" 
xmlFormatter = XMLFormatter.new 
result = xmlFormatter.format_book(book) 
puts result 
jsonFormatter = JSONFormatter.new 
result = jsonFormatter.format_book(book) 
puts result

运行结果和之前一模一样，但代码的可读性和扩展性都大大提升。现在想支持项目经理说的YAML格式？简单，再写一个子类：

class YAMLFormatter < Formatter 
 
 def formating(book) 
  result = "book_name: #{book.book_name}n" 
  result += "pages: #{book.pages}n" 
  result += "price: #{book.price}n" 
  result += "author: #{book.author}n" 
  result += "isbn: #{book.isbn}n" 
 end 
 
end

调用时只需把YAMLFormatter实例化就行：

yamlFormatter = YAMLFormatter.new 
result = yamlFormatter.format_book(book) 
puts result

头疼的YAML就这么轻松被支持了。现在你可以笑着问项目经理：“还有需要支持的格式吗？”

实例二

再看一个更贴近日常的场景：学生抄题目、做题目。假设有两个学生，他们的试卷内容几乎一样，只是答案不同。最初代码是这样的：

# -*- encoding: utf-8 -*-

#学生甲的试卷类
class TestPaperA
 
 def question1
  puts '杨过得到，后来给了郭靖，炼成倚天剑，屠龙刀的玄铁可能是[] a.球墨铸铁 b.马口铁 c.高速合金钢 d.碳塑纤维 '
  puts '答案：b'
 end
 
 def question2
  puts '杨过、程英、陆无双铲除了情花，造成了[] a.使这种植物不再害人 b.使一种珍稀物种灭绝 c.破坏了那个生物圈的生态平衡 d.造成该地区沙漠化 '
  puts '答案：a'
 end
 
 def question3
  puts '蓝凤凰的致使华山师徒、桃谷六仙呕吐不止，如果你是大夫，会给他们开什么药[] a.阿司匹林 b.牛黄解毒片 c.氟酸 d.让他们喝大量的生牛奶 e.以上全不对'
  puts '答案：c'
 end

end
#学生乙的试卷类
class TestPaperB
 
 def question1
  puts '杨过得到，后来给了郭靖，炼成倚天剑，屠龙刀的玄铁可能是[] a.球墨铸铁 b.马口铁 c.高速合金钢 d.碳塑纤维 '
  puts '答案：d'
 end
 
 def question2
  puts '杨过、程英、陆无双铲除了情花，造成了[] a.使这种植物不再害人 b.使一种珍稀物种灭绝 c.破坏了那个生物圈的生态平衡 d.造成该地区沙漠化 '
  puts '答案：b'
 end
 
 def question3
  puts '蓝凤凰的致使华山师徒、桃谷六仙呕吐不止，如果你是大夫，会给他们开什么药[] a.阿司匹林 b.牛黄解毒片 c.氟酸 d.让他们喝大量的生牛奶 e.以上全不对'
  puts '答案：a'
 end

end
puts '学生甲抄的试卷'
student1 = TestPaperA.new
student1.question1
student1.question2
student1.question3

puts '学生乙抄的试卷'
student2 = TestPaperB.new
student2.question1
student2.question2
student2.question3

问题很明显：TestPaperA和TestPaperB大量重复的题目内容，如果题目要改，就得改两处。这显然不好维护。

用模板方法解决：先提取一个公共的TestPaper父类，把题目内容放进去，答案部分留给子类去实现。第一步，只把题目内容抽取到父类：

# -*- encoding: utf-8 -*-

class TestPaper
 def question1
  puts '杨过得到，后来给了郭靖，炼成倚天剑，屠龙刀的玄铁可能是[] a.球墨铸铁 b.马口铁 c.高速合金钢 d.碳塑纤维 '
 end
 
 def question2
  puts '杨过、程英、陆无双铲除了情花，造成了[] a.使这种植物不再害人 b.使一种珍稀物种灭绝 c.破坏了那个生物圈的生态平衡 d.造成该地区沙漠化 '
 end
 
 def question3
  puts '蓝凤凰的致使华山师徒、桃谷六仙呕吐不止，如果你是大夫，会给他们开什么药[] a.阿司匹林 b.牛黄解毒片 c.氟酸 d.让他们喝大量的生牛奶 e.以上全不对'
 end
end

#学生甲的试卷类
class TestPaperA < TestPaper
 
 def question1
  super
  puts '答案：b'
 end
 
 def question2
  super
  puts '答案：a'
 end
 
 def question3
  super
  puts '答案：c'
 end

end
#学生乙的试卷类
class TestPaperB < TestPaper
 
 def question1
  super
  puts '答案：d'
 end
 
 def question2
  super
  puts '答案：b'
 end
 
 def question3
  super
  puts '答案：a'
 end

end
puts '学生甲抄的试卷'
student1 = TestPaperA.new
student1.question1
student1.question2
student1.question3

puts '学生乙抄的试卷'
student2 = TestPaperB.new
student2.question1
student2.question2
student2.question3

这样，题目内容统一由父类提供，子类只负责输出答案。但还可以更进一步——把答案也抽象成方法，让父类在题目输出后自动调用答案方法，子类只需重写答案方法即可：

# -*- encoding: utf-8 -*-

class TestPaper
 def question1
  puts '杨过得到，后来给了郭靖，炼成倚天剑，屠龙刀的玄铁可能是[] a.球墨铸铁 b.马口铁 c.高速合金钢 d.碳塑纤维 '
  puts "答案：#{answer1}"
 end
 
 def question2
  puts '杨过、程英、陆无双铲除了情花，造成了[] a.使这种植物不再害人 b.使一种珍稀物种灭绝 c.破坏了那个生物圈的生态平衡 d.造成该地区沙漠化 '
  puts "答案：#{answer2}"
 end
 
 def question3
  puts '蓝凤凰的致使华山师徒、桃谷六仙呕吐不止，如果你是大夫，会给他们开什么药[] a.阿司匹林 b.牛黄解毒片 c.氟酸 d.让他们喝大量的生牛奶 e.以上全不对'
  puts "答案：#{answer3}"
 end
 def answer1; end
 def answer2; end
 def answer3; end
end

#学生甲的试卷类
class TestPaperA < TestPaper
 
 def answer1
  'b'
 end
 
 def answer2
  'a'
 end
 
 def answer3
  'c'
 end

end
#学生乙的试卷类
class TestPaperB < TestPaper
 
 def answer1
  'd'
 end
 
 def answer2
  'b'
 end
 
 def answer3
  'a'
 end

end
puts '学生甲抄的试卷'
student1 = TestPaperA.new
student1.question1
student1.question2
student1.question3

puts '学生乙抄的试卷'
student2 = TestPaperB.new
student2.question1
student2.question2
student2.question3

现在，父类定义了答题的“模板”——先输出题目，再输出答案，而答案的具体值由子类提供。所有重复的代码（题目内容）都上升到了父类，子类只保留差异部分。

这两个例子其实揭示了一个核心原则：当我们在某一细节层次上有一致的过程或步骤，但个别步骤的实现可能不同时，就适合用模板方法模式。它把固定流程封装在父类中，把可变部分留给子类去定制，既减少了重复，又为将来的扩展留好了接口。

《夸克》非常好用的免费AI浏览器

下载APP查看

免责声明：文中图文均来自网络，如有侵权请联系删除，心愿游戏发布此文仅为传递信息，不代表心愿游戏认同其观点或证实其描述。

相关文章

更多

精选合集

更多

大家都在玩

热门话题

大家都在看

更多
手机版 | 关于我们 | 电脑版 | 返回顶部
本站所有游戏都由网友上传，如有侵犯您的版权
请发邮件wishdown2023@163.com