asato <asato@ncfreak.com>

最終更新日 : 2003/11/2 (2002/9/26 より)

• Visitor パターン (2003/7/5 更新)
• AspectJ を使った Visitor に関するテクニックの種類
  • ダブルディスパッチ不要
  • 直接訪問 (2003/11/1 更新)
  • 無差別訪問
• 実装 - その 4 (2003/7/4 追加)
• 実装 - その 5 (2003/11/1 追加)
• 実装 - その 6 (2003/11/2 追加)
• 参考文献とリソース (2003/11/1 更新)
• 更新履歴
• todo

Visitor パターン

GoF [1] によれば、Visitor パターンの意図は以下のものです:

あるオブジェクト構造上の要素で実行されるオペレーションを表現する。Visitor パターンにより、オペレーションを加えるオブジェクトのクラスに変更を加えずに、新しいオペレーションを定義することができるようになる。

Visitor パターンの問題点の 1 つには、カプセル化を破る、ということが挙げられます。

AspectJ を使った Visitor に関するテクニックの種類

• ダブルディスパッチ不要
• 直接訪問
• 無差別訪問

ダブルディスパッチ不要

意図: ダブルディスパッチを行うようなコードを ConcreteElement に埋め込まずに Visitor パターンを実装する。

結果:

• Visitor を受け入れるメソッドは Element interface のみが定義すればよくなる。
• 新しい ConcreteElement が追加されるときはアスペクトのみのコードを編集すればよい。

GoF パターンと比べた場合の有利な点と不利な点:

• 有利な点:
• 不利な点:

package dp.visitor;

public class Visitor {
}

package dp.visitor;

public interface Element {
}

package dp.visitor;

public class ElementA implements Element {
}

package dp.visitor;

public class ElementB implements Element {
}

package dp.visitor;

public aspect VisitorAspect {

	pointcut accept(Visitor visitor) :
		args(visitor) && call( void Element.accept(Visitor) );

	pointcut elementA(ElementA elementA) : target(elementA);
	pointcut elementB(ElementB elementB) : target(elementB);

	void around(Visitor visitor, ElementA elementA) : accept(visitor) && elementA(elementA) {
		visitor.visit(elementA);
	}

	void around(Visitor visitor, ElementB elementB) : accept(visitor) && elementB(elementB) {
		visitor.visit(elementB);
	}
	
	public void Element.accept(Visitor visitor) {}

	public void Visitor.visit(ElementA elementA) {}
	public void Visitor.visit(ElementB elementB) {}
}

package dp;

import dp.visitor.*;

public class Client {

	public static void main(String[] args) {

		Element[] elements = new Element[2];
		elements[0] = new ElementA();
		elements[1] = new ElementB();


		Visitor visitor = new MyVisitor();

		for(int i = 0 ; i < elements.length ; i++) {
			elements[i].accept( visitor );
		}
	}
	
	public static class MyVisitor extends Visitor {
		public void visit(ElementA elementA) {
			System.out.println("ElementA");
		}
		public void visit(ElementB elementB) {
			System.out.println("ElementB");
		}
	}
}

ElementA
ElementB

疑問:

1. ConcreteElement の増加の管理: ConcreteElement の数が増えるとアスペクトの管理が大変なのではないのか？

   プログラマがコードの追加を行う必要のある部分は以下のものである:

   • ConcreteElement を区別するための pointcut の追加。
   • その pointcut に対する around 文の追加。
   • Visitor に対しての新しい ConcreteElement を訪問するためのメソッドの追加。

   これら 3 つの追加はすべて単純なコピー&ペーストで行うことができる。

   GoF のパターンでは、ConcreteElement を 1 つ追加するだけで以下のような行動が要求される:

   • 新しい ConcreteElement に対して Visitor を受け入れるためのメソッドを実装する。
   • Visitor に対して新しい ConcreteElement を訪問するためのメソッドを実装する。

直接訪問

(AspectJ 1.1.1 OK)

意図: ダブルディスパッチを使うことなく Visitor パターンを実装する。Element の役割を持つクラスは Visitor オブジェクトを受け入れるためのメソッドを定義する必要がなくなる。

結果:

• Element の役割を持つクラスやそのサブクラスである ConcreteElement の役割を持つクラスは、Visitor オブジェクトを引数としてとるようなメソッド (たとえば accept(visitor)) を定義する必要がなくなる。

• ダブルディスパッチの代用となるコードはアスペクトとして定義されるため、関係のあるコードは一箇所に集めることができる。

• もし新しい ConcreteElement クラスを加えることになっても、従来の Visitor パターンの場合に比べるとそれは容易になる。

• Visitor と Element との間の結合が弱まる; Visitor 階層は Element 階層のことを知っているが、その逆はない。つまり、Element 階層は、Visitor 階層のことを知らなくてよい。

サンプルコード:

public interface Visitor { }

public interface Element { }

public class ConcreteElementA implements Element { }

public class ConcreteElementB implements Element { }

public aspect VisitorAspect {

	pointcut visit(Visitor vistor) :
		target(vistor) && call( void Visitor.visit(Element) );

	pointcut elementA(ConcreteElementA elementA) : args(elementA);
	pointcut elementB(ConcreteElementB elementB) : args(elementB);

	void around(Visitor vistor, ConcreteElementA elementA) : visit(vistor) && elementA(elementA) {
		vistor.visit(elementA);
	}
	void around(Visitor vistor, ConcreteElementB elementB) : visit(vistor) && elementB(elementB) {
		vistor.visit(elementB);
	}
	
	public void Visitor.visit(Element element) { }

	public void Visitor.visit(ConcreteElementA elementA) { }
	public void Visitor.visit(ConcreteElementB elementB) { }
}

public class Client {

	public static void main(String[] args) {

		Element[] elements = new Element[2];
		elements[0] = new ConcreteElementA();
		elements[1] = new ConcreteElementB();


		Visitor visitor = new MyVisitor();

		for(int i = 0 ; i < elements.length ; i++) {
			visitor.visit( elements[i] );
		}
	}
	
	public static class MyVisitor implements Visitor {
		public void visit(ConcreteElementA elementA) {
			System.out.println("ConcreteElementA");
		}
		public void visit(ConcreteElementB elementB) {
			System.out.println("ConcreteElementB");
		}
	}
}

ConcreteElementA
ConcreteElementB

実装:

• 新しい ConcreteElement クラスの追加 : 新しい ConcreteElement クラスの追加が必要な時にはアスペクトを変更することになる。たとえば、上記のサンプルコードにたしいて、新たに ConcreteElementC を追加するとしよう:

  public class ConcreteElementC implements Element { }
  

  public aspect VisitorAspect {
  
  	pointcut visit(Visitor vistor) :
  		target(vistor) && call( void Visitor.visit(Element) );
  
  	pointcut elementA(ConcreteElementA elementA) : args(elementA);
  	pointcut elementB(ConcreteElementB elementB) : args(elementB);
  	pointcut elementC(ConcreteElementC elementC) : args(elementC);
  
  	void around(Visitor vistor, ConcreteElementA elementA) : visit(vistor) && elementA(elementA) {
  		vistor.visit(elementA);
  	}
  	void around(Visitor vistor, ConcreteElementB elementB) : visit(vistor) && elementB(elementB) {
  		vistor.visit(elementB);
  	}
  	void around(Visitor vistor, ConcreteElementC elementC) : visit(vistor) && elementC(elementC) {
  		vistor.visit(elementC);
  	}
  	
  	public void Visitor.visit(Element element) {}
  
  	public void Visitor.visit(ConcreteElementA elementA) { }
  	public void Visitor.visit(ConcreteElementB elementB) { }
  	public void Visitor.visit(ConcreteElementC elementC) { }
  }
  

  public class Client {
  
  	public static void main(String[] args) {
  
  		Element[] elements = new Element[3];
  		elements[0] = new ConcreteElementA();
  		elements[1] = new ConcreteElementB();
  		elements[2] = new ConcreteElementC();
  
  
  		Visitor visitor = new MyVisitor();
  
  		for(int i = 0 ; i < elements.length ; i++) {
  			visitor.visit( elements[i] );
  		}
  	}
  	
  	public static class MyVisitor implements Visitor {
  	
  		public void visit(ConcreteElementA elementA) {
  			System.out.println("ConcreteElementA");
  		}
  
  		public void visit(ConcreteElementB elementB) {
  			System.out.println("ConcreteElementB");
  		}
  
  		public void visit(ConcreteElementC elementC) {
  			System.out.println("ConcreteElementC");
  		}
  	}
  }
  

  実行結果は以下のようになる:

  ConcreteElementA
  ConcreteElementB
  ConcreteElementC
  

無差別訪問

意図: あるオブジェクト構造上におけるどんなオブジェクトにたいしても訪問できるような Visitor を実装する。

適用可能性:

• オブジェクト構造を iterate したいとき: Java において、iterate するのによく使用される interface として java.util.Iterator がある。この Iterator interface は Object Iterator.next() という Object の型を戻り値として返すメソッドを定義している。そのような場合でも、ダウンキャストすることなくそのまま visit できる。

適用可能性 (詳細):

• オブジェクト構造を iterate したいとき: アスペクトのコードに関しては、下記のサンプルコードの項目を参照。

  package dp.visitor;
  
  import java.util.List;
  import java.util.Vector;
  
  public class ObjectStructure {
  	
  	private List objects = new Vector();
  	
  	public void add(Object obj) {
  		objects.add(obj);
  	}
  	
  	public List getObjectList() {
  		return objects;
  	}
  }
  

  package dp.visitor;
  
  public class MyVisitor {
  	public void visit(Element element) {
  		System.out.println("Element");
  	}
  	public void visit(Product prodcut) {
  		System.out.println("Product");
  	}
  }
  

  package dp;
  
  import dp.visitor.*;
  import java.util.Iterator;
  
  public class Client {
  
  	public static void main(String[] args) {
  
  		ObjectStructure structure = new ObjectStructure();
  
  		structure.add( new Element() );
  		structure.add( new Product() );
  
  
  		MyVisitor visitor = new MyVisitor();
  
  		Iterator itr = structure.getObjectList().iterator();
  		while( itr.hasNext() ) {
  			visitor.visit( itr.next() );
  		}
  	}
  }
  

  Element
  Product
  

結果:

1. 型チェックの恩恵を失なう: どんなオブジェクトにたいしても visit できることは、意図されていないオブジェクトにたいする visit メソッドの呼び出しをコンパイル時に検出できないことを意味する。

   しかしながら、実行時例外として不正な visit を検出したり、あるいは、visit メソッドを何もしないメソッドとして実装することによる選択肢もある。

2. visit される側のオブジェクトは共通の interface を実装している必要はない: visit される側のオブジェクトは共通の interface を実装している必要はなく、Visitor オブジェクトと visit される側のオブジェクトの結びつきの関係は、より弱い。

変化に対する耐性: 次のようなコードの実装上の変化がありうる:

1. visit される側の型名の変更:
2. 新しい visit される側のオブジェクトの追加:
3. 新しい Visitor の作成:

サンプルコード:

package dp.visitor;

public class Element { }

package dp.visitor;

public class Product { }

package dp.visitor;

public class MyVisitor {
	public void visit(Element element) {
		System.out.println("Element");
	}
	public void visit(Product prodcut) {
		System.out.println("Product");
	}
}

package dp.visitor;

import dp.visitor.*;

public class Client {

	public static void main(String[] args) {

		Object[] objects = new Object[2];
		objects[0] = new Element();
		objects[1] = new Product();


		MyVisitor visitor = new MyVisitor();

		for(int i = 0 ; i < objects.length ; i++) {
			visitor.visit( objects[i] );
		}
	}
}

package dp.visitor;

public aspect VisitorAspect {

	declare parents: MyVisitor implements Visitor;

	private interface Visitor { }

	pointcut visit(Visitor visitor) :
		target(visitor) &&
		call( void Visitor.visit(Object) ) &&
		!this(VisitorAspect);

	void around(Visitor visitor, Element element) : args(element) && visit(visitor) {
		visitor.visit( element );
	}
	void around(Visitor visitor, Product prodcut) : args(prodcut) && visit(visitor) {
		visitor.visit( prodcut );
	}

	public void Visitor.visit(Object obj) {}

	public abstract void Visitor.visit(Element element);
	public abstract void Visitor.visit(Product prodcut);
}

Element
Product

サンプルコード捕捉 - アスペクトの再利用を考慮する:

package dp.visitor;

public abstract aspect VisitorProtocol {

	protected interface Visitor {}

	pointcut visit(Visitor visitor) :
		target(visitor) &&
		call( void Visitor.visit(Object) ) &&
		!this(VisitorProtocol);

	public void Visitor.visit(Object object) { }
}

package dp.visitor;

public aspect VisitorAspect extends VisitorProtocol {

	declare parents: MyVisitor implements Visitor;

	void around(Visitor visitor, Element element) : args(element) && visit(visitor) {
		visitor.visit( element );
	}
	void around(Visitor visitor, Product prodcut) : args(prodcut) && visit(visitor) {
		visitor.visit( prodcut );
	}

	public abstract void Visitor.visit(Element element);
	public abstract void Visitor.visit(Product prodcut);
}

実装:

1. どこに visit メソッドを定義するのか: サンプルコードでは、各オブジェクトを訪問するためのメソッドを抽象メソッドとして Visitor interface に定義した。これにより、Visitor の interface を実装するクラスでは (サンプルコードでは MyVisitor) それら抽象メソッドを実装することが強制される。抽象メソッドとして宣言することで、プログラマが抽象メソッドの実装し忘れたり、タイプミスによるオーバーライドミスなどを防ぐことができる。

   しかしながら、Visitor interface を実装するすべてのクラスが Visitor interface で定義された visit メソッドを必要としないかもしれない。サンプルコードでいえば、次のような意図をもった Visitor interface を実装するクラスがあるかもしれない: Element クラスを visit することを意図していても、Prodcut クラスを visit することは意図していない; つまり、visit(Eolement) メソッドを実装しても、visit(Product) は実装したくない。上記のサンプルコードの実装では、このような要求にたいして柔軟に対応できてない。つまり、Visitor interface を実装するすべてのクラスが考えられるすべての visit メソッドを実装することが強制される。

   解決方法としては、少々コードは複雑になるが、target pointcut を各 Visitor interface を実装するクラスに使うことと、上記のサンプルコードの少し変更と追加によって対処できる方法がある:

   package dp.visitor;
   
   public class YourVisitor {
   	public void visit(Element element) {
   		System.out.println("Element");
   	}
   }
   

   package dp.visitor;
   
   import dp.visitor.*;
   
   public class Client {
   
   	public static void main(String[] args) {
   
   		Object[] objects = new Object[2];
   		objects[0] = new Element();
   		objects[1] = new Product();
   
   
   		MyVisitor visitor1 = new MyVisitor();
   
   		for(int i = 0 ; i < objects.length ; i++) {
   			visitor1.visit( objects[i] );
   		}
   		YourVisitor visitor2 = new YourVisitor();
   
   		for(int i = 0 ; i < objects.length ; i++) {
   			visitor2.visit( objects[i] );
   		}
   	}
   }
   

   package dp.visitor;
   
   public abstract aspect VisitorProtocol {
   
   	protected interface Visitor {}
   
   	pointcut visit() :
   		call( void Visitor.visit(Object) ) && !this(VisitorProtocol);
   
   	public void Visitor.visit(Object object) { }
   }
   

   package dp.visitor;
   
   public aspect VisitorAspect extends VisitorProtocol {
   
   	declare parents: MyVisitor   implements Visitor;
   	declare parents: YourVisitor implements Visitor;
   
   
   	void around(MyVisitor visitor, Element element) :
   		target(visitor) && args(element) && visit()
   	{
   		visitor.visit( element );
   	}
   	void around(MyVisitor visitor, Product prodcut) :
   		target(visitor) && args(prodcut) && visit()
   	{
   		visitor.visit( prodcut );
   	}
   
   	void around(YourVisitor visitor, Element element):
   		target(visitor) && args(element) && visit()
   	{
   		visitor.visit( element );
   	}
   
   
   	public abstract void MyVisitor.visit(Element element);
   	public abstract void MyVisitor.visit(Product prodcut);
   
   	public abstract void YourVisitor.visit(Element element);
   }
   

   Element
   Product
   Element
   

参考文献:

• [1] オブジェクト指向における再利用のためのデザインパターン
• [2] Ouafa Hachani, Daniel Bardou.: Using Aspect-Oriented Programming for Design Patterns Implementation. OOIS 2002 Workshop on Reuse in Object-Oriented Information Systems Design (2002) [PDF]

リソース:

• AspectJ
  (http://www.eclipse.org/aspectj/)

• MixJuice によるデザインパターン改善カタログ - Visitor
  (http://cvs.m17n.org/~akr/mj/design-pattern/Visitor.html)