释放双眼，带上耳机，听听看~！
0x01.定义与类型
- 定义：将作用于某种数据结构中的各元素的操作分离出来封装成独立的类，使其在不改变数据结构的前提下可以添加作用于这些元素的新的操作，为数据结构中的每个元素提供多种访问方式。它将对数据的操作与数据结构进行分离，是行为类模式中最复杂的一种模式。
- 补充定义：可以在不改变各元素的类的前提下，定义作用于这些元素的操作。
- 类型：行为型
- UML类图
-
Java实现
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
67
68
69
70
71
72
73
74
75
2 * 访问者接口
3 */
4public interface Visitor {
5
6 /**
7 * 访问A
8 * @param element
9 */
10 void visit(ConcreteElementA element);
11
12 /**
13 * 访问B
14 * @param element
15 */
16 void visit(ConcreteElementB element);
17
18}
19
20/**
21 * 被访问对象接口
22 */
23public interface Element {
24
25 void accept(Visitor visitor);
26
27 String operation();
28}
29
30/**
31 * 具体的访问者
32 */
33public class ConcreteVisitor implements Visitor {
34 @Override
35 public void visit(ConcreteElementA element) {
36 System.out.println("visit: " + element.operation());
37 }
38
39 @Override
40 public void visit(ConcreteElementB element) {
41 System.out.println("visit: " + element.operation());
42 }
43}
44
45/**
46 * 具体实例A
47 */
48public class ConcreteElementA implements Element {
49 @Override
50 public void accept(Visitor visitor) {
51 visitor.visit(this);
52 }
53
54 @Override
55 public String operation() {
56 return "ConcreteElementA";
57 }
58}
59
60/**
61 * 具体实例B
62 */
63public class ConcreteElementB implements Element {
64 @Override
65 public void accept(Visitor visitor) {
66 visitor.visit(this);
67 }
68
69 @Override
70 public String operation() {
71 return "ConcreteElementB";
72 }
73}
74
75
-
测试与应用
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
2 * 测试与应用类
3 */
4public class Test {
5
6 public static void main(String[] args) {
7 //初始化被访问列表
8 List<Element> elements = new ArrayList<>();
9
10 //初始化访问者
11 Visitor visitor = new ConcreteVisitor();
12
13 //初始化元素
14 Element element1 = new ConcreteElementA();
15 Element element2 = new ConcreteElementB();
16
17 //装填
18 elements.add(element1);
19 elements.add(element2);
20
21 //访问
22 elements.forEach(e -> e.accept(visitor));
23 }
24
25}
26
27
-
输入结果
2
3
4
2visit: ConcreteElementB
3
4
-
访问者中的元素
-
抽象访问者（Visitor）角色：定义一个访问具体元素的接口，为每个具体元素类对应一个访问操作 visit() ，该操作中的参数类型标识了被访问的具体元素。
- 具体访问者（ConcreteVisitor）角色：实现抽象访问者角色中声明的各个访问操作，确定访问者访问一个元素时该做什么。
- 抽象元素（Element）角色：声明一个包含接受操作 accept() 的接口，被接受的访问者对象作为 accept() 方法的参数。
- 具体元素（ConcreteElement）角色：实现抽象元素角色提供的 accept() 操作，其方法体通常都是 visitor.visit(this) ，另外具体元素中可能还包含本身业务逻辑的相关操作。
-
注：测试类中，一般都是具有一个包含所有对象的容器，提供让访问者遍历所有元素的方法。
0x02.适用场景
- 一个数据结构如（List/Set/Map等）包含很多类型对象
- 数据结构与数据操作分离
0x03.优缺点
1.优点
- 扩展性好。能够在不修改对象结构中的元素的情况下，为对象结构中的元素添加新的功能。
- 复用性好。可以通过访问者来定义整个对象结构通用的功能，从而提高系统的复用程度。
- 灵活性好。访问者模式将数据结构与作用于结构上的操作解耦，使得操作集合可相对自由地演化而不影响系统的数据结构。
- 符合单一职责原则。访问者模式把相关的行为封装在一起，构成一个访问者，使每一个访问者的功能都比较单一。
2.缺点
- 增加新的元素类很困难。在访问者模式中，每增加一个新的元素类，都要在每一个具体访问者类中增加相应的具体操作，这违背了“开闭原则”。
- 破坏封装。访问者模式中具体元素对访问者公布细节，这破坏了对象的封装性，具体元素变更比较麻烦。
- 违反了依赖倒置原则。访问者模式依赖了具体类，而没有依赖抽象类。
访问者模式案例
使用访问者模式，实现对不同种类课程的访问封装。
-
具体实现
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
67
68
69
70
71
72
73
74
75
76
77
78
79
2 * 访问者接口
3 */
4public interface IVisitor {
5
6 void visit(FreeCourse freeCourse);
7
8 void visit(CodingCourse codingCourse);
9}
10
11/**
12 * 访问者的具体实现
13 */
14public class Visitor implements IVisitor {
15 @Override
16 public void visit(FreeCourse freeCourse) {
17 System.out.println("free course: " + freeCourse.getName());
18 }
19
20 @Override
21 public void visit(CodingCourse codingCourse) {
22 System.out.println("coding course: " + codingCourse.getName() + " price: " + codingCourse.getPrice());
23 }
24}
25
26/**
27 * 抽象类，课程
28 */
29public abstract class Course {
30
31 private String name;
32
33 public void setName(String name) {
34 this.name = name;
35 }
36
37 public String getName() {
38 return name;
39 }
40
41 abstract void accept(IVisitor visitor);
42
43}
44
45
46/**
47 * 具体的实体类，免费课程
48 */
49public class FreeCourse extends Course {
50
51
52 @Override
53 void accept(IVisitor visitor) {
54 visitor.visit(this);
55 }
56}
57
58/**
59 * 具体的实现类，实战课程
60 */
61public class CodingCourse extends Course {
62
63 private int price;
64
65 public int getPrice() {
66 return price;
67 }
68
69 public void setPrice(int price) {
70 this.price = price;
71 }
72
73 @Override
74 void accept(IVisitor visitor) {
75 visitor.visit(this);
76 }
77}
78
79
-
测试与应用类
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
2 * 测试与应用类
3 */
4public class Test {
5
6 public static void main(String[] args) {
7 //初始化容器
8 List<Course> courses = new ArrayList<>();
9
10 //构建课程实现
11 FreeCourse freeCourse = new FreeCourse();
12 freeCourse.setName("SpringMVC.");
13
14 CodingCourse codingCourse = new CodingCourse();
15 codingCourse.setName("Java design pattern.");
16 codingCourse.setPrice(299);
17
18 //装填
19 courses.add(freeCourse);
20 courses.add(codingCourse);
21
22 //访问
23 for (Course course : courses) {
24 course.accept(new Visitor());
25 }
26 }
27}
28
29
-
输入结果
2
3
4
2coding course: Java design pattern. price: 299
3
4
- UML类图
0x05.相关设计模式
-
访问者模式和迭代器模式
-
访问者，对保存在数据结构中的数据进行某种处理
- 迭代器主要是遍历
0x06.源码中的访问者模式
- jdk.nio.FileVisitor
- Spring.BeanDefinitionVisitor
0x07.代码地址
0x08.推荐阅读
- 慕课网设计模式精讲：https://coding.imooc.com/class/270.html
- 访问者模式（Visitor模式）详解: http://c.biancheng.net/view/1397.html
