研磨设计模式之迭代器业务场景

版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/oXinYangonly/article/details/78119019

场景描述

项目客户方收购了一家小公司，这家小公司有自己的工资系统，客户方的工资系统内部采用List来记录工资列表，新收购的小公司的工资系统内部采用数组来记录工资列表，整合两个系统的工资表数据

已有系统代码示例

• 一个统一了的工资描述模型

/**
 * 
 * 工资描述模型对象
 */
public class PayModel {

    /**
     * 支付工资的人员
     */
    private String userName;
    /**
     * 支付的工资数额
     */
    private double pay;

    public String getUserName() {
        return userName;
    }
    public void setUserName(String userName) {
        this.userName = userName;
    }
    public double getPay() {
        return pay;
    }
    public void setPay(double pay) {
        this.pay = pay;
    }

    @Override
    public String toString() {
        return "userName="+userName+",pay="+pay;
    }


}

• 客户方已有的工资管理系统中的工资管理类，内部使用List来管理

/**
 * 客户方已有的工资管理对象 
 *
 */
public class PayManager {
    /**
     * 聚合对象,使用List管理
     */
    private List<PayModel> list = new ArrayList<>();
    /**
     * 获取工资列表
     * @return 工资列表
     */
    public List<PayModel> getPayList() {
        return list;
    }
    /**
     * 计算工资
     */
    public void calcPay() {
        //计算工资，把工资信息填充到工资列表中
        PayModel pm1 = new PayModel();
        pm1.setUserName("张三");
        pm1.setPay(3000);
        PayModel pm2 = new PayModel();
        pm2.setUserName("李四");
        pm2.setPay(5000);
        list.add(pm1);
        list.add(pm2);
    }
}

• 被收购公司的工资系统中的工资管理类，内部通过数组来管理

/**
 * 
 * 被客户方收购的公司的工资管理类
 *
 */
public class SalaryManager {
    /**
     * 使用数组管理
     */
    private PayModel[] pms = null;

    /**
     * 获取工资列表
     * 
     * @return 工资列表
     */
    public PayModel[] getPays() {
        return pms;
    }
    /**
     * 计算工资
     */
    public void calcSalary() {
        PayModel pm1 = new PayModel();
        pm1.setUserName("王五");
        pm1.setPay(3300);
        PayModel pm2 = new PayModel();
        pm2.setUserName("赵六");
        pm2.setPay(4100);
        pms = new PayModel[2];
        pms[0] = pm1;
        pms[1] = pm2;
    }
}

• 此时来访问两个系统的工资列表，外部要采用不同的访问方式，一个是访问数组，一个是访问集合对象

PayManager payManager = new PayManager();
payManager.calcPay();
Iterator<PayModel> it = payManager.getPayList().iterator();
System.out.println("集团工资列表");
while(it.hasNext()) {
    PayModel m = it.next();
    System.out.println(m);
}

SalaryManager sm = new SalaryManager();
sm.calcSalary();
PayModel[] pms = sm.getPays();
System.out.println("新收购公司工资列表");
for(int i=0;i<pms.length;i++) {
    System.out.println(pms[i]);
}

• 为了能让客户端以一个统一的方式进行访问，最容易的方式就是为它们定义一个统一的接口

/**
 * 迭代器接口，定义访问和遍历元素的操作
 *
 */
public interface Iterator {

    /**
     * 移动到聚合对象的第一个位置
     */
    public void first();
    /**
     * 移动到聚合对象的下一个位置
     */
    public void next();

    /**
     * 判断是否已经移动到聚合对象的最后一个位置
     * @return true表示已经移动到聚合对象的最后一个位置
     *         false 表示还没有移动到聚合对象的最后一个位置
     */
    public boolean isDone();
    /**
     * 获取迭代的当前元素
     * @return 迭代的当前元素
     */
    public Object currentItem();
}

• 定义统一接口来获取聚合对象

/**
 * 聚合对象的接口，定义创建相应迭代器对象接口
 *
 */
public abstract class Aggregate {

    /**
     * 工厂方法，创建相应迭代器对象的接口
     * @return 相应迭代器对象的接口
     */
    public abstract Iterator createIterator();
}

• 定义好了统一的接口，就需要分别实现这个接口，一个采用数组实现

/**
 * 
 *  用来实现访问数组的迭代接口
 */
public class ArrayIteratorImpl implements Iterator{

    /**
     * 用来存放被迭代的聚合对象
     */
    private SalaryManager aggregate = null;
    /**
     * 用来记录当前被迭代到的位置索引
     * -1 表示刚开始的时候，迭代器指向聚合对象第一个元素之前
     */
    private int index = -1;

    public ArrayIteratorImpl(SalaryManager aggregate) {
        this.aggregate = aggregate;
    }

    @Override
    public void first() {

        index = 0;
    }

    @Override
    public void next() {
        if(index<this.aggregate.size()) {
            index = index + 1;
        }
    }

    @Override
    public boolean isDone() {
        if(index == this.aggregate.size()) {
            return true;
        }
        return false;
    }

    @Override
    public Object currentItem() {
        return this.aggregate.get(index);
    }

}

• 用List实现的统一接口

/**
 * 用来实现访问Collection集合的迭代几口，为了外部统一访问方式 
 *
 */
public class CollectionIteratorImpl implements Iterator{

    /**
     * 用来存放被迭代的对象
     */
    private PayManager aggregate = null;

    private int index = -1;

    public CollectionIteratorImpl(PayManager aggregate) {
        this.aggregate = aggregate;
    }


    @Override
    public void first() {
        index = 0;
    }

    @Override
    public void next() {
        if(index < this.aggregate.size()) {
            index = index + 1;
        }
    }

    @Override
    public boolean isDone() {
        if(index == this.aggregate.size()) {
            return true;
        }
        return false;
    }

    @Override
    public Object currentItem() {
        return this.aggregate.get(index);
    }

}

• 让PayManager和SalaryManager继承Aggregate，提供分别访问它们的访问聚合的接口

/**
 * 客户方已有的工资管理对象 
 *
 */
public class PayManager extends Aggregate{

    @Override
    public Iterator createIterator() {
        return new CollectionIteratorImpl(this);
    }

    public PayModel get(int index) {
        PayModel ret = null;
        if(index<this.list.size()) {
            ret = this.list.get(index);
        }
        return ret;
    }

    public int size() {
        return this.list.size();
    }
    /**
     * 聚合对象,使用List管理
     */
    private List<PayModel> list = new ArrayList<>();
    /**
     * 获取工资列表
     * @return 工资列表
     */
    public List<PayModel> getPayList() {
        return list;
    }
    /**
     * 计算工资
     */
    public void calcPay() {
        //计算工资，把工资信息填充到工资列表中
        PayModel pm1 = new PayModel();
        pm1.setUserName("张三");
        pm1.setPay(3000);
        PayModel pm2 = new PayModel();
        pm2.setUserName("李四");
        pm2.setPay(5000);
        list.add(pm1);
        list.add(pm2);
    }

}

/**
 * 
 * 被客户方收购的公司的工资管理类
 *
 */
public class SalaryManager extends Aggregate{


    @Override
    public Iterator createIterator() {
        return new ArrayIteratorImpl(this);
    }

    public PayModel get(int index) {
        PayModel ret = null;
        if(index < this.pms.length) {
            ret = pms[index];
        }
        return ret;
    }
    public int size() {
        return this.pms.length;
    }


    /**
     * 使用数组管理
     */
    private PayModel[] pms = null;

    /**
     * 获取工资列表
     * 
     * @return 工资列表
     */
    public PayModel[] getPays() {
        return pms;
    }
    /**
     * 计算工资
     */
    public void calcSalary() {
        PayModel pm1 = new PayModel();
        pm1.setUserName("王五");
        pm1.setPay(3300);
        PayModel pm2 = new PayModel();
        pm2.setUserName("赵六");
        pm2.setPay(4100);
        pms = new PayModel[2];
        pms[0] = pm1;
        pms[1] = pm2;
    }

}

• 把通过访问聚合接口来访问聚合对象的功能独立成一个方法，虽然是不同的聚合对象，但是都调用这个方法去访问

public static void test(Iterator it) {
    it.first();
    while(!it.isDone()) {
        Object obj = it.currentItem();
        System.out.println(obj);
        it.next();
    }
}

• 客户端调用

PayManager payManager = new PayManager();
payManager.calcPay();
System.out.println("集团工资列表");
test(payManager.createIterator());
SalaryManager sm = new SalaryManager();
sm.calcSalary();
System.out.println("新收购公司工资列表");
test(sm.createIterator());

如同上面的代码示例，提供一个统一访问聚合对象的接口，通过这个接口就能顺序的访问聚合对象的元素，对于客户端而言，只是面向这个接口在访问，根本不需要知道聚合对象内部的表示方法