设计模式中的责任链模式

设计模式中的责任链模式

这一周在修改之前的项目,提高代码的性能,之前代码中有很多循环调用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、部门经理、老板都可以审批,一个审批就可以了。
那么这个链中只要有一个处理了就不传给下一个处理器。而我的需求是每一个都处理。按照自己的需求可以设计相应的责任链。

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

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

machineShunMing

谢谢老板

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值