Java 设计模式(23) —— 访问者模式

一、访问者模式

对于一组对象，在不改变数据结构的前提下，增加作用于这些结构元素新的功能。

适用于数据结构相对稳定，它把数据结构和作用于其上的操作解耦，使得操作集合可以相对自由地演化。

访问者模式

二、示例

员工管理系统：本系统需要根据所有员工的剩余年假计算折现的假期补贴薪资

传统方法只需在员工管理的类中定义一个计算薪资的方法，循环遍历所有员工调用该计算方法即可

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 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 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 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设计模式所有示例代码，持续更新中