设计模式中的责任链模式

设计模式中的责任链模式

这一周在修改之前的项目，提高代码的性能，之前代码中有很多循环调用http的写法，严重地影响了服务的性能，所以决定做修改，都是批量获取数据，在本地循环做处理。就比如获取了一个列表的gps数据。
需要对他进行处理，首先是将原生的gps数据转化为百度地图的gps数据，然后再调用根据gps数据获取地址的服务来设置地址信息。。。要对这一个list做很多批量处理，渐渐的这个类就变得很庞大，很多私有方法都是处理数据的
，跟这个类本身没什么关系。最近刚好又在看《重构》这本书，书中降到重构很多都使用到设计模式。我就在想能不能通过设计模式可以把这个代码优化下。翻看了设计模式的相关内容就发现责任链模式可以解决我的问题。

下面是我的代码的缩减demo，我实际的比这个复杂多了，所以只写出两个处理过程。

位置类：定义位置

/**
 * 位置
 * 
 * @author lusm
 *
 */
public class Position {

    private String address;
    private Float longitude;
    private Float latitude;

    public Position(Float longitude, Float latitude) {
        super();
        this.longitude = longitude;
        this.latitude = latitude;
    }

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }

    public Float getLongitude() {
        return longitude;
    }

    public void setLongitude(Float longitude) {
        this.longitude = longitude;
    }

    public Float getLatitude() {
        return latitude;
    }

    public void setLatitude(Float latitude) {
        this.latitude = latitude;
    }

    @Override
    public String toString() {
        return "Position [address=" + address + ", longitude=" + longitude + ", latitude=" + latitude + "]";
    }



}

处理器抽象类：主要是定义设置下一个处理器和抽象的处理方法，以便于实现类实现。

public abstract class Handler {

    private Handler nextHandler;

    /**
     * 位置处理器
     * 
     * @param poList
     */
    public abstract void operater(List<Position> poList);

    public Handler getNextHandler() {
        return nextHandler;
    }

    public void setNextHandler(Handler nextHandler) {
        this.nextHandler = nextHandler;
    }

}

位置偏转处理：主要是遍历位置列表做偏转位置。

/**
 * 位置偏转
 * 
 * @author lusm
 *
 */
public class DeflectHandler extends Handler {

    @Override
    public void operater(List<Position> poList) {
        for (Position position : poList) {
            position.setLatitude(position.getLatitude() + 1);
            position.setLongitude(position.getLongitude() + 1);
            System.out.println("偏转地址");
        }
        if (this.getNextHandler() != null) {
            this.getNextHandler().operater(poList);
        }

    }

}

地址设置处理：设置该位置的地址。

/**
 * 地址设置
 * 
 * @author lusm
 *
 */
public class AddressHandler extends Handler {

    @Override
    public void operater(List<Position> poList) {
        for (Position position : poList) {
            position.setAddress("地址" + new Random().nextInt());
            System.out.println("地址设置");
        }
        if (this.getNextHandler() != null) {
            this.getNextHandler().operater(poList);
        }

    }

}

执行类：

public class Client {
    public static void main(String[] args) {
        List<Position> list = new ArrayList<Position>();
        list.add(new Position(1f, 1f));
        list.add(new Position(2f, 2f));
        list.add(new Position(3f, 3f));
        System.out.println("处理前：");
        for (Position position : list) {
            System.out.println(position.toString());
        }
        AddressHandler addressHandler = new AddressHandler();
        DeflectHandler deflectHandler = new DeflectHandler();
        deflectHandler.setNextHandler(addressHandler);
        deflectHandler.operater(list);
        System.out.println("处理后：");
        for (Position position : list) {
            System.out.println(position.toString());
        }
    }

}

这个最主要的链就是要在本次处理中调用下一个处理器的处理方法，一直流传下去，一直到最后一个处理结束。当然这个链中也可以只有一个做处理，比如你发出请假申请，你的leader、部门经理、老板都可以审批，一个审批就可以了。
那么这个链中只要有一个处理了就不传给下一个处理器。而我的需求是每一个都处理。按照自己的需求可以设计相应的责任链。

感觉设计模式真的很强大，一下子使得代码简洁明了，而且代码之间的耦合也减小了，扩展性提高了。有时间还是要多研读《重构》和《设计模式》。