设计模式中的责任链模式
这一周在修改之前的项目，提高代码的性能，之前代码中有很多循环调用http的写法，严重地影响了服务的性能，所以决定做修改，都是批量获取数据，在本地循环做处理。就比如获取了一个列表的gps数据。
需要对他进行处理，首先是将原生的gps数据转化为百度地图的gps数据，然后再调用根据gps数据获取地址的服务来设置地址信息。。。要对这一个list做很多批量处理，渐渐的这个类就变得很庞大，很多私有方法都是处理数据的
，跟这个类本身没什么关系。最近刚好又在看《重构》这本书，书中降到重构很多都使用到设计模式。我就在想能不能通过设计模式可以把这个代码优化下。翻看了设计模式的相关内容就发现责任链模式可以解决我的问题。
下面是我的代码的缩减demo，我实际的比这个复杂多了，所以只写出两个处理过程。
位置类：定义位置
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
|
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 + "]";
}
}
|
处理器抽象类：主要是定义设置下一个处理器和抽象的处理方法，以便于实现类实现。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
| public abstract class Handler {
private Handler nextHandler;
public abstract void operater(List<Position> poList);
public Handler getNextHandler() {
return nextHandler;
}
public void setNextHandler(Handler nextHandler) {
this.nextHandler = nextHandler;
}
}
|
位置偏转处理：主要是遍历位置列表做偏转位置。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
|
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);
}
}
}
|
地址设置处理：设置该位置的地址。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
|
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);
}
}
}
|
执行类：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
| 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、部门经理、老板都可以审批，一个审批就可以了。
那么这个链中只要有一个处理了就不传给下一个处理器。而我的需求是每一个都处理。按照自己的需求可以设计相应的责任链。
感觉设计模式真的很强大，一下子使得代码简洁明了，而且代码之间的耦合也减小了，扩展性提高了。有时间还是要多研读《重构》和《设计模式》。
