给定一个复杂的对象层次结构，幸运的是它不包含循环引用，我如何实现支持各种格式的序列化？我不是来讨论实际实现的。相反，我正在寻找可能会派上用场的设计模式提示。

更准确地说:我正在使用 Ruby，我想解析 XML 和 JSON 数据以构建复杂的对象层次结构。此外，应该可以将该层次结构序列化为 JSON、XML 和可能的 HTML。

我可以为此使用Builder 模式吗？在任何提到的情况下，我都有某种结构化数据 - 无论是在内存中还是文本中 - 我想用它来构建其他东西。

我认为将序列化逻辑与实际业务逻辑分开会很好，这样我以后就可以轻松支持多种 XML 格式。

最佳答案

我最终创建了一个基于构建器和策略模式的解决方案。我正在使用 Builder 模式将解析和构建逻辑提取到自己的类中。这使我可以轻松地分别添加新的解析器和构建器。我正在使用策略模式来实现单独的解析和构建逻辑，因为该逻辑取决于我的输入和输出格式。

下图显示了我的解决方案的 UML 图。

下面的 list 显示了我的 Ruby 实现。实现有些微不足道，因为我正在构建的对象相当简单。对于那些认为这段代码臃肿和 Java 风格的人，我认为这实际上是一个很好的设计。我承认，在这种微不足道的情况下，我可以直接将构造方法构建到我的业务对象中。但是，我没有在我的其他应用程序中构建水果，而是构建相当复杂的对象，因此分离解析、构建和业务逻辑似乎是个好主意。

require 'nokogiri'
require 'json'

class Fruit

  attr_accessor :name
  attr_accessor :size
  attr_accessor :color

  def initialize(attrs = {})
    self.name = attrs[:name]
    self.size = attrs[:size]
    self.color = attrs[:color]
  end

  def to_s
    "#{size} #{color} #{name}"
  end

end

class FruitBuilder

  def self.build(opts = {}, &block)
    builder = new(opts)
    builder.instance_eval(&block)
    builder.result
  end

  def self.delegate(method, target)
    method = method.to_sym
    target = target.to_sym

    define_method(method) do |*attrs, &block|
      send(target).send(method, *attrs, &block)
    end
  end

end

class FruitObjectBuilder < FruitBuilder

  attr_reader :fruit

  delegate :name=,  :fruit
  delegate :size=,  :fruit
  delegate :color=, :fruit

  def initialize(opts = {})
    @fruit = Fruit.new
  end

  def result
    @fruit
  end

end

class FruitXMLBuilder < FruitBuilder

  attr_reader :document

  def initialize(opts = {})
    @document = Nokogiri::XML::Document.new
  end

  def name=(name)
    add_text_node(root, 'name', name)
  end

  def size=(size)
    add_text_node(root, 'size', size)
  end

  def color=(color)
    add_text_node(root, 'color', color)
  end

  def result
    document.to_s
  end

  private

  def add_text_node(parent, name, content)
    text = Nokogiri::XML::Text.new(content, document)
    element = Nokogiri::XML::Element.new(name, document)

    element.add_child(text)
    parent.add_child(element)
  end

  def root
    document.root ||= create_root
  end

  def create_root
    document.add_child(Nokogiri::XML::Element.new('fruit', document))
  end

end

class FruitJSONBuilder < FruitBuilder

  attr_reader :fruit

  def initialize(opts = {})
    @fruit = Struct.new(:name, :size, :color).new
  end

  delegate :name=,  :fruit
  delegate :size=,  :fruit
  delegate :color=, :fruit

  def result
    Hash[*fruit.members.zip(fruit.values).flatten].to_json
  end

end

class FruitParser

  attr_reader :builder

  def initialize(builder)
    @builder = builder
  end

  def build(*attrs, &block)
    builder.build(*attrs, &block)
  end

end

class FruitObjectParser < FruitParser

  def parse(other_fruit)
    build do |fruit|
      fruit.name  = other_fruit.name
      fruit.size  = other_fruit.size
      fruit.color = other_fruit.color
    end
  end

end

class FruitXMLParser < FruitParser

  def parse(xml)
    document = Nokogiri::XML(xml)

    build do |fruit|
      fruit.name  = document.xpath('/fruit/name').first.text.strip
      fruit.size  = document.xpath('/fruit/size').first.text.strip
      fruit.color = document.xpath('/fruit/color').first.text.strip
    end
  end

end

class FruitJSONParser < FruitParser

  def parse(json)
    attrs = JSON.parse(json)

    build do |fruit|
      fruit.name  = attrs['name']
      fruit.size  = attrs['size']
      fruit.color = attrs['color']
    end
  end

end

# -- Main program ----------------------------------------------------------

p = FruitJSONParser.new(FruitXMLBuilder)
puts p.parse('{"name":"Apple","size":"Big","color":"Red"}')

p = FruitXMLParser.new(FruitObjectBuilder)
puts p.parse('<fruit><name>Apple</name><size>Big</size><color>Red</color></fruit>')

p = FruitObjectParser.new(FruitJSONBuilder)
puts p.parse(Fruit.new(:name => 'Apple', :color => 'Red', :size => 'Big'))

关于ruby - 是否有用于序列化和反序列化各种格式的对象层次结构的模式？，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/6733317/