一、访问者模式
对于一组对象，在不改变数据结构的前提下，增加作用于这些结构元素新的功能。
适用于数据结构相对稳定，它把数据结构和作用于其上的操作解耦，使得操作集合可以相对自由地演化。
访问者模式
二、示例
员工管理系统：本系统需要根据所有员工的剩余年假计算折现的假期补贴薪资
传统方法只需在员工管理的类中定义一个计算薪资的方法，循环遍历所有员工调用该计算方法即可
1.定义员工对象类
/**
* 员工对象的model类
*/
public class Employee {
private String name;
private float income;
private int vacationDays;
private int degree;
public Employee(String name, float income, int vacationDays, int degree) {
this.name = name;
this.income = income;
this.vacationDays = vacationDays;
this.degree = degree;
}
public void setName(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setIncome(float income) {
this.income = income;
}
public float getIncome() {
return income;
}
public void setVacationDays(int vacationDays) {
this.vacationDays = vacationDays;
}
public int getVacationDays() {
return vacationDays;
}
public void setDegree(int degree) {
this.degree = degree;
}
public int getDegree() {
return degree;
}
}
2.定义员工管理类并实现计算方法
/**
* 传统模式，员工对象的管理类，用来存储员工集合和计算薪资
*/
public class Employees {
private HashMap<String, Employee> employees;
public Employees() {
employees = new HashMap<String, Employee>();
}
public void Attach(Employee employee) {
employees.put(employee.getName(), employee);
}
public void Detach(Employee employee) {
employees.remove(employee);
}
public Employee getEmployee(String name) {
return employees.get(name);
}
public void getCompensation() {
for (Employee employee : employees.values()) {
System.out
.println(employee.getName()
+ "'s Compensation is "
+ (employee.getDegree()
* employee.getVacationDays() * 100));
}
}
}
3.循环遍历即可
/**
* 传统模式，直接通过一个管理类管理所有员工，并实现员工薪资的计算
* 管理类里面即包含了员工的集合，又包含薪资的计算，若后续拓展新的行为则管理类只会越来越臃肿
* 应该实现员工的集合管理和计算方法拆分，并且后续新增的每一种行为都是独立开互不影响
*/
public class MainTest {
public static void main(String[] args) {
Employees mEmployees = new Employees();
mEmployees.Attach(new Employee("Tom", 4500, 8, 1));
mEmployees.Attach(new Employee("Jerry", 6500, 10, 2));
mEmployees.Attach(new Employee("Jack", 9600, 12, 3));
mEmployees.getCompensation();
}
}
缺点：
- 员工集合的管理应该和操作方法分开，实现解耦
- 不利于拓展，若后续新增其他计算操作，则管理类只会越来越复杂，并且可能会相互影响
三、访问者模式的改进
访问者模式将数据的管理和对象的操作拆分，将对象定义成被访问者，不同的操作定义成访问对象的访问者，不同的访问者只需处理自己应该实现的操作方法即可
1.定义对象的超类，用于注入访问者
/**
* 访问者模式，被访问对象实现的超类，用于注入访问者
*/
public abstract class Element {
abstract public void Accept(Visitor visitor);
}
2.定义被对象，并实现注入方法
/**
* 员工对象，继承超类，并实现访问者的注入
*/
public class Employee extends Element {
private String name;
private float income;
private int vacationDays;
private int degree;
public Employee(String name, float income, int vacationDays, int degree) {
this.name = name;
this.income = income;
this.vacationDays = vacationDays;
this.degree = degree;
}
public void setName(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setIncome(float income) {
this.income = income;
}
public float getIncome() {
return income;
}
public void setVacationDays(int vacationDays) {
this.vacationDays = vacationDays;
}
public int getVacationDays() {
return vacationDays;
}
public void setDegree(int degree) {
this.degree = degree;
}
public int getDegree() {
return degree;
}
@Override
public void Accept(Visitor visitor) {
visitor.Visit(this);
}
}
3.定义访问者接口
/**
* 访问者模式，访问者接口对象
*/
public interface Visitor {
abstract public void Visit(Element element);
}
4.定义计算薪资的访问者，实现自定义的计算方法
/**
* 访问者模式，计算薪资的访问者，实现访问者的接口，实现访问方法
* 新的访问者若有新需求拓展只需实现访问自定义的操作方法即可
*/
public class CompensationVisitor implements Visitor {
@Override
public void Visit(Element element) {
Employee employee = ((Employee) element);
System.out.println(employee.getName() + "'s Compensation is "
+ (employee.getDegree() * employee.getVacationDays() * 10));
}
}
5.定义管理类，对象的操作通过访问者调用
/**
* 访问者模式，员工管理类，只需管理所有员工的集合对象，若外部需要获取员工信息，则只需通过访问方法获取员工信息进行自定义操作
*/
public class Employees {
private HashMap<String, Employee> employees;
public Employees() {
employees = new HashMap();
}
public void Attach(Employee employee) {
employees.put(employee.getName(), employee);
}
public void Detach(Employee employee) {
employees.remove(employee);
}
public Employee getEmployee(String name) {
return employees.get(name);
}
public void Accept(Visitor visitor) {
for (Employee e : employees.values()) {
e.Accept(visitor);
}
}
}
/**
* 访问者模式，将传统模式中数据的管理和操作拆分，将对象定义成需要访问的对象
* 不同的操作只需实现访问者的接口实现自定义的访问方法即可
* 实现了对象与操作之间的解耦，并且不同的操作方法之间互不干扰
*/
public class MainTest {
public static void main(String[] args) {
Employees mEmployees = new Employees();
mEmployees.Attach(new Employee("Tom", 4500, 8, 1));
mEmployees.Attach(new Employee("Jerry", 6500, 10, 2));
mEmployees.Attach(new Employee("Jack", 9600, 12, 3));
mEmployees.Accept(new CompensationVisitor());
}
}
四、总结
-
优点：
- 符合单一职责原则
- 扩展性良好
- 有益于系统的管理和维护
-
缺点：
- 增加新的元素类变得很困难
- 破坏封装性
-
适用场合：
- 如果一个系统有比较稳定的数据结构，又有经常变化的功能需求，那么访问者模式就是比较合适的
Java设计模式所有示例代码，持续更新中
