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

场景描述

项目客户方收购了一家小公司，这家小公司有自己的工资系统，客户方的工资系统内部采用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());

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