优点
1.降低耦合度。它将请求的发送者和接收者解耦。
2.简化了对象。使得对象不需要知道链的结构。
3.增强给对象指派职责的灵活性。通过改变链内的成员或者调动它们的次序，允许动态地新增或者删除责任。
4、增加新的请求处理类很方便。
缺点
1.不能保证请求一定被接收。
2.系统性能将受到一定影响，而且在进行代码调试时不太方便，可能会造成循环调用。
3.可能不容易观察运行时的特征，有碍于除错。
使用场景
1.有多个对象可以处理同一个请求，具体哪个对象处理该请求由运行时刻自动确定。
2.在不明确指定接收者的情况下，向多个对象中的一个提交一个请求。
3.可动态指定一组对象处理请求。
一、实现方式
假设一个场景，学校里，校长的职能大于老师，老师的职能大于学生，基于这样的链路关系，学生处理不了的事情上报给老师，老师处理不了的事情上报给校长。
1、处理抽象类
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
|
package com.asurplus.common.handle.style1;
/**
* 处理抽象类
*/
public abstract class Handler {
/**
* 下一个处理类
*/
protected Handler handler;
public void setHandler(Handler handler) {
this.handler = handler;
}
public Handler getHandler() {
return handler;
}
/**
* 处理事件
*
* @param request
*/
public abstract void handlerRequest(String request);
}
|
2、学生处理类
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
|
package com.asurplus.common.handle.style1;
import lombok.extern.slf4j.Slf4j;
/**
* 学生处理类
*/
@Slf4j
public class StudentHandler extends Handler {
@Override
public void handlerRequest(String request) {
if ("打扫卫生".equals(request)) {
log.info("学生处理中");
} else {
this.handler.handlerRequest(request);
}
}
}
|
学生能处理“打扫卫生”这件事，如果是其他事件，交给他的下一个元素
3、老师处理类
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
|
package com.asurplus.common.handle.style1;
import lombok.extern.slf4j.Slf4j;
/**
* 老师处理类
*/
@Slf4j
public class TeacherHandler extends Handler {
@Override
public void handlerRequest(String request) {
if ("批改试卷".equals(request)) {
log.info("老师处理中");
} else {
this.handler.handlerRequest(request);
}
}
}
|
老师能处理“批改试卷”这件事，如果是其他事件，交给他的下一个元素
4、校长处理类
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
|
package com.asurplus.common.handle.style1;
import lombok.extern.slf4j.Slf4j;
/**
* 校长处理类
*/
@Slf4j
public class HeadHandler extends Handler {
@Override
public void handlerRequest(String request) {
if ("学籍问题".equals(request)) {
log.info("校长处理中");
} else {
log.error("无法处理该事件");
}
}
}
|
校长能处理“学籍问题”这件事，如果是其他事件，由于我们的责任链只有三级，都处理不了，只能打印日志了
5、测试
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
|
package com.asurplus.common.handle.style1;
/**
* 责任链模式
*/
public class TestMain {
public static void main(String[] args) {
// 学生处理器
StudentHandler studentHandler = new StudentHandler();
// 老师处理器
TeacherHandler teacherHandler = new TeacherHandler();
// 校长处理器
HeadHandler headHandler = new HeadHandler();
// 老师的上一级是校长
teacherHandler.setHandler(headHandler);
// 学生的上一级是老师
studentHandler.setHandler(teacherHandler);
// 处理 批改试卷 这件事
studentHandler.handlerRequest("批改试卷");
}
}
|
输出结果
可以看出，“批改试卷”这件事，被老师处理了。
二、实现方式
假设一个场景，在我们的电商系统中，当创建一个订单的时候，我们需要去校验很多的数据，我们需要去判断该商品存不存在，库存还有没有，价格对不对，等等校验。
1、订单信息类
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
package com.asurplus.common.handle.style2;
import lombok.Builder;
import lombok.Data;
/**
* 订单信息
*/
@Data
@Builder
public class Order {
// 库存
private int stock;
// 单价
private int price;
}
|
2、订单校验接口
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
|
package com.asurplus.common.handle.style2;
/**
* 校验器接口
*
* @param <T>
*/
public interface OrderFilter<T> {
/**
* 业务逻辑
*
* @param t
* @return
*/
boolean execute(T t);
}
|
3、库存校验器
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
|
package com.asurplus.common.handle.style2;
import lombok.extern.slf4j.Slf4j;
/**
* 库存校验器
*/
@Slf4j
public class OrderStockFilter implements OrderFilter<Order> {
@Override
public boolean execute(Order order) {
if (0 >= order.getStock()) {
log.error("库存不足");
return false;
}
return true;
}
}
|
4、价格校验器
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
|
package com.asurplus.common.handle.style2;
import lombok.extern.slf4j.Slf4j;
/**
* 价格校验器
*/
@Slf4j
public class OrderPriceFilter implements OrderFilter<Order> {
@Override
public boolean execute(Order order) {
if (0 > order.getPrice()) {
log.error("价格错误");
return false;
}
return true;
}
}
|
5、测试
|
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
|
package com.asurplus.common.handle.style2;
import lombok.extern.slf4j.Slf4j;
import java.util.Arrays;
import java.util.List;
/**
* 责任链模式
*/
@Slf4j
public class TestMain {
public static void main(String[] args) {
// 建造者模式创建一个订单
Order order = Order.builder().stock(0).price(0).build();
// 库存校验器
OrderStockFilter orderQuantityFilter = new OrderStockFilter();
// 价格校验器
OrderPriceFilter orderPriceFilter = new OrderPriceFilter();
// 组装成一个list
List<OrderFilter<Order>> orderFilters = Arrays.asList(orderQuantityFilter, orderPriceFilter);
boolean res = false;
// 循环校验
for (OrderFilter<Order> item : orderFilters) {
res = item.execute(order);
// 其中任何一项不通过就停止校验
if (!res) {
break;
}
}
if (!res) {
log.error("下单失败");
}
}
}
|
被我们的“库存校验器”校验不通过，导致下单失败。
|
