Visitorパターン（Visitor Design Pattern）調査ドキュメント

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

状況: 複数の異なる型の要素（FileノードとDirectoryノード）から成るファイルシステム
要求: 
  - サイズ計算機能を追加したい
  - 後日、権限チェック機能も追加したい
  - さらに、ウイルススキャン機能も追加したい

従来の方法:
  各要素クラス（File, Directory）にcalcSize(), checkPermission(), scanVirus()メソッドを追加
  → クラスが肥大化し、責任が不明確になる

Visitorパターン:
  SizeVisitor, PermissionVisitor, VirusScanVisitorを個別に作成
  → 要素クラスは変更不要、新しい操作はVisitorとして追加

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

<<interface>> Visitor
  + visitElementA(ElementA)
  + visitElementB(ElementB)
      ↑
      | implements
ConcreteVisitor
  + visitElementA(ElementA) { /* 処理A */ }
  + visitElementB(ElementB) { /* 処理B */ }

<<interface>> Element
  + accept(Visitor)
      ↑
      | implements
ConcreteElementA          ConcreteElementB
  + accept(v) {             + accept(v) {
      v.visitElementA(this)     v.visitElementB(this)
    }                         }

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

# 悪い例：各要素クラスに複数の操作を詰め込む
package File;
sub calc_size { ... }
sub check_permission { ... }
sub scan_virus { ... }
sub compress { ... }
# → クラスが肥大化、責任が不明確

# または、型判定による分岐
sub process_element {
    my ($element) = @_;
    if ($element->isa('File')) {
        # File固有の処理
    } elsif ($element->isa('Directory')) {
        # Directory固有の処理
    }
    # → 新しい型を追加するたびに修正が必要
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

# 各操作を独立したVisitorとして分離
package SizeVisitor;
sub visit_file { ... }
sub visit_directory { ... }

package PermissionVisitor;
sub visit_file { ... }
sub visit_directory { ... }

# 要素クラスはacceptメソッドだけを持つ
package File;
sub accept {
    my ($self, $visitor) = @_;
    $visitor->visit_file($self);
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

interface Expression {
    void accept(ExpressionVisitor visitor);
}

class Number implements Expression {
    int value;
    public void accept(ExpressionVisitor visitor) {
        visitor.visit(this);
    }
}

class Addition implements Expression {
    Expression left, right;
    public void accept(ExpressionVisitor visitor) {
        visitor.visit(this);
    }
}

interface ExpressionVisitor {
    void visit(Number number);
    void visit(Addition addition);
}

// 評価用Visitor
class EvaluationVisitor implements ExpressionVisitor {
    int result;
    public void visit(Number number) {
        result = number.value;
    }
    public void visit(Addition addition) {
        addition.left.accept(this);
        int leftResult = result;
        addition.right.accept(this);
        result = leftResult + result;
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

package File;
sub new {
    my ($class, $name, $size) = @_;
    bless { name => $name, size => $size }, $class;
}
sub accept {
    my ($self, $visitor) = @_;
    $visitor->visit_file($self);
}

package Directory;
sub new {
    my ($class, $name, $items) = @_;
    bless { name => $name, items => $items }, $class;
}
sub accept {
    my ($self, $visitor) = @_;
    $visitor->visit_directory($self);
}

package SizeVisitor;
sub new { bless { total_size => 0 }, shift; }
sub visit_file {
    my ($self, $file) = @_;
    $self->{total_size} += $file->{size};
}
sub visit_directory {
    my ($self, $dir) = @_;
    for my $item (@{$dir->{items}}) {
        $item->accept($self);
    }
}
sub get_total_size { shift->{total_size} }

1
2
3
4
5
6
7

# 新しい操作を追加する場合
package NewOperationVisitor;
sub visit_file { ... }
sub visit_directory { ... }

# 既存の要素クラス（File, Directory）は一切変更不要
# → OCPに準拠した設計

1
2
3
4
5
6
7
8
9

データ構造（Element）側:
  - データの保持
  - Visitorの受け入れ（accept）

処理ロジック（Visitor）側:
  - 具体的な操作の実装
  - 各要素型ごとの処理分岐

→ 責任が明確に分離され、保守性が向上

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

# 新しい要素型SymbolicLinkを追加する場合
package SymbolicLink;
sub accept {
    my ($self, $visitor) = @_;
    $visitor->visit_symbolic_link($self);  # 新メソッド
}

# 問題：すべての既存Visitorに修正が必要
package SizeVisitor;
sub visit_symbolic_link { ... }  # 追加必要

package PermissionVisitor;
sub visit_symbolic_link { ... }  # 追加必要

package BackupVisitor;
sub visit_symbolic_link { ... }  # 追加必要

# → Visitorが多数ある場合、大規模な修正が必要

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

package File;
sub new {
    my ($class, $name, $size, $permissions) = @_;
    bless {
        name => $name,
        _size => $size,          # private想定
        _permissions => $permissions,  # private想定
    }, $class;
}

# Visitorがアクセスするために、getterを公開
sub get_size { shift->{_size} }
sub get_permissions { shift->{_permissions} }

# → カプセル化が弱まる

1
2
3
4
5
6
7

操作の追加頻度 vs 要素の追加頻度

高 ←─ 操作追加頻度 ─→ 低
 |                      |
Visitor有利         Visitor不利
 |                      |
低 ←─ 要素追加頻度 ─→ 高

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

開始
 ↓
要素の種類は安定しているか？
 ├─ No → Visitorパターンは不適切
 ↓ Yes
新しい操作を頻繁に追加するか？
 ├─ No → 他のパターンを検討
 ↓ Yes
要素数とVisitor数は管理可能か？
 ├─ No → 複雑性が高すぎる
 ↓ Yes
Visitorパターンを採用

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66

# Visitor ロールの定義
package Visitor::Role;
use Moo::Role;

requires 'visit_file';
requires 'visit_directory';

1;

# Element ロールの定義
package Element::Role;
use Moo::Role;

requires 'accept';

1;

# 具体的な要素の実装
package File;
use Moo;
with 'Element::Role';

has name => (is => 'ro', required => 1);
has size => (is => 'ro', required => 1);

sub accept {
    my ($self, $visitor) = @_;
    $visitor->visit_file($self);
}

1;

package Directory;
use Moo;
with 'Element::Role';

has name => (is => 'ro', required => 1);
has items => (is => 'ro', default => sub { [] });

sub accept {
    my ($self, $visitor) = @_;
    $visitor->visit_directory($self);
}

1;

# 具体的なVisitorの実装
package SizeVisitor;
use Moo;
with 'Visitor::Role';

has total_size => (is => 'rw', default => 0);

sub visit_file {
    my ($self, $file) = @_;
    $self->total_size($self->total_size + $file->size);
}

sub visit_directory {
    my ($self, $dir) = @_;
    for my $item (@{$dir->items}) {
        $item->accept($self);
    }
}

1;

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

# Element側
sub accept {
    my ($self, $visitor) = @_;
    # 自分の型に応じた適切なvisitメソッドを呼び出す
    $visitor->visit_file($self);  # Fileの場合
    # または
    # $visitor->visit_directory($self);  # Directoryの場合
}

# Visitor側
sub visit_file {
    my ($self, $file) = @_;
    # File固有の処理
}

sub visit_directory {
    my ($self, $directory) = @_;
    # Directory固有の処理
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

sub visit_directory {
    my ($self, $dir) = @_;
    
    # 型チェック
    die "Expected Directory object" unless $dir->isa('Directory');
    
    # 循環参照チェック（簡易版）
    my %visited;
    
    for my $item (@{$dir->items}) {
        next if $visited{$item}++;  # 訪問済みならスキップ
        $item->accept($self);
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

use Test2::V0;
use File;
use Directory;
use SizeVisitor;

subtest 'SizeVisitor calculates total size' => sub {
    my $file1 = File->new(name => 'file1.txt', size => 100);
    my $file2 = File->new(name => 'file2.txt', size => 200);
    my $dir = Directory->new(
        name => 'mydir',
        items => [$file1, $file2]
    );
    
    my $visitor = SizeVisitor->new;
    $dir->accept($visitor);
    
    is $visitor->total_size, 300, 'Total size is correct';
};

done_testing;

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50

// Element interface
interface Element {
    void accept(Visitor visitor);
}

// Concrete Elements
class File implements Element {
    private String name;
    private int size;
    
    public void accept(Visitor visitor) {
        visitor.visit(this);
    }
    
    public int getSize() { return size; }
}

class Directory implements Element {
    private String name;
    private List<Element> items;
    
    public void accept(Visitor visitor) {
        visitor.visit(this);
    }
    
    public List<Element> getItems() { return items; }
}

// Visitor interface
interface Visitor {
    void visit(File file);
    void visit(Directory directory);
}

// Concrete Visitor
class SizeVisitor implements Visitor {
    private int totalSize = 0;
    
    public void visit(File file) {
        totalSize += file.getSize();
    }
    
    public void visit(Directory directory) {
        for (Element item : directory.getItems()) {
            item.accept(this);
        }
    }
    
    public int getTotalSize() { return totalSize; }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

from abc import ABC, abstractmethod

# Element interface
class Element(ABC):
    @abstractmethod
    def accept(self, visitor):
        pass

# Concrete Elements
class File(Element):
    def __init__(self, name, size):
        self.name = name
        self.size = size
    
    def accept(self, visitor):
        visitor.visit_file(self)

class Directory(Element):
    def __init__(self, name, items=None):
        self.name = name
        self.items = items or []
    
    def accept(self, visitor):
        visitor.visit_directory(self)

# Visitor interface
class Visitor(ABC):
    @abstractmethod
    def visit_file(self, file):
        pass
    
    @abstractmethod
    def visit_directory(self, directory):
        pass

# Concrete Visitor
class SizeVisitor(Visitor):
    def __init__(self):
        self.total_size = 0
    
    def visit_file(self, file):
        self.total_size += file.size
    
    def visit_directory(self, directory):
        for item in directory.items:
            item.accept(self)

1
2
3

Visitorパターンは「振る舞いに関するパターン」の一つです。同じカテゴリーの[Strategyパターン](/2025/12/30/164012/)と比較すると理解が深まります。

Perlでの実装には[Mooによるオブジェクト指向プログラミング](/2021/10/31/191008/)の知識が役立ちます。特に[Moo::Role](/2009/02/14/105950/)を活用することで、よりクリーンな設計が可能です。