オブジェクト階層をさまざまな形式でシリアライズおよびデシリアライズするためのパターンはありますか？

Question

幸いにも循環参照が含まれていない複合オブジェクト階層がある場合、さまざまなフォーマットをサポートしてシリアル化を実装するにはどうすればよいですか？私は実際の実装について議論するためにここにはいません。代わりに、私は便利になるかもしれないデザインパターンのヒントを探しています。

もう少し具体的には：私はRubyを使用しています。XMLとJSONデータを解析して複雑なオブジェクト階層を構築したいと考えています。さらに、この階層をJSON、XML、場合によってはHTMLにシリアル化することも可能です。

ビルダーのパターンを利用できますか？上記のいずれの場合でも、何らかの構造化されたデータ（メモリまたはテキストのいずれか）があります。これは、ビルドのものです。

シリアル化ロジックを実際のビジネスロジックから分離して、後で複数のXMLフォーマットを簡単にサポートできるようになるといいと思います。

Answer 1

ビルダーと戦略パターンに基づいたソリューションを作成しました。私は、Builderパターンを使用してパースを抽出し、そこにロジックを組み込んでクラスを作成しています。これにより、新しいパーサとビルダーをそれぞれ簡単に追加することができます。私はこのロジックが自分の入力と出力のフォーマットに依存するので、Strategyパターンを使って個々のパースとロジックを実装しています。

下の図は、私のソリューションのUML図です。

以下のリストは私のRubyの実装を示しています。私が構築しているオブジェクトはかなり単純なので、実装はやや簡単です。このコードが肥大化し、Java-ishだと思う人のためには、これは実際には良いデザインだと思います。私は、このような単純なケースでは、構築メソッドをビジネスオブジェクトに直接組み込むことができたことは認めています。しかし、私は他のアプリケーションで果物を作っていませんが、かなり複雑なオブジェクトなので、構文解析、ビルド、ビジネスロジックを分離するのは良い考えです。

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')) 

Answer 2

誰かが異なるアルゴリズムを使用して同じ操作を実行し、実行時に使用するアルゴリズムを選択したいと言うときは、常にStrategy patternが気になります。さまざまな種類のシリアライゼーション（XML、JSON、バイナリなど）は、オブジェクトを純粋なデータの移植可能な構造に変換するためのすべての戦略です。これはあなたの状況に当てはまるかもしれないようです。

Answer 3

パターン指向ソフトウェアアーキテクチャ、反射パターンを見てみましょう。私はそれがそのような構造を実装する方法についていくつかの良いヒントを与えるべきだと思います。