一篇了解责任链模式-责任链模式

[[411174]]

本文转载自微信公众号「我好困啊」，作者mengxin。转载本文请联系我好困啊公众号。

责任链模式：

定义一条加工链，请求发起者发起请求(原料)，请求(原料)通过这条加工链进行一步步的处理后。输出最终的产品产出。

意图

请求的发起者和接收者，通过这条加工链条，进行解耦。将各种处理器进行连接，形成一条加工链条，请求一步步的进行传递，进行处理，直到处理完毕输出。

主要解决

职责链上的处理者负责处理请求，请求发起者将请求发送到职责链上即可，无须关心请求的处理细节和请求的传递。

关键代码

将各种职责处理器进行一步步连接，组装成一条责任链。

优点

1.降低了耦合

2.简化了对象，使得对象不需要知道责任链的具体实现

3.增强给对象指派职责的灵活性。如新增一个职责只需要加处理器加工到链上即可。

使用场景

有多个对象可以处理同一个请求。比如：定义了一个用户对象，需要对这个用户对象进行一系列处理。那么可以将各种处理抽象成处理器，将各种处理器进行连接形成一条加工链。将对象送入到加工链上进行处理。

示例图：

具体实现

创建用户类

 1/** 
 2 * 用户对象，对其进行加工 
 3 */ 
 4@Data 
 5@AllArgsConstructor 
 6@NoArgsConstructor 
 7public class User { 
 8 
 9    private int id; 
10 
11    private String name; 
12 
13} 
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.

创建各种组装器

1/** 
2 * 组装器（处理者） 
3 */ 
4public interface Seter<T> { 
5 
6    //设置参数 
7    void doSet(T request); 
8} 
1.
2.
3.
4.
5.
6.
7.
8.

ID组装器

1/** 
2 * ID 组装器 
3 */ 
4public class IdSeter implements Seter<User>{ 
5 
6    @Override 
7    public void doSet(User user) { 
8        user.setId(1); 
9    } 
0} 
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.

name组装器

1/** 
2 *  
3 * name 组装器 
4 */ 
5public class NameSeter implements Seter<User>{ 
6 
7    @Override 
8    public void doSet(User user) { 
9        user.setName("mengxin"); 
0    } 
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.

接下来定义责任链，将组装器连接起来

1/** 
2 * 责任链模式(抽象责任链,可定义多种链) 
3 */ 
4public interface Chain<T> { 
5 
6    //组装 
7    void assemble(T request); 
8 
9} 
1.
2.
3.
4.
5.
6.
7.
8.
9.

用户责任链

 1/** 
 2 * 用户责任链 
 3 */ 
 4public class UserChain implements Chain<User>{ 
 5 
 6    private final List<Seter<User>> seters = new LinkedList<>(); 
 7 
 8    //初始化（组装责任链），注入seter处理器处理 
 9    public UserChain(){ 
10        //注入id设置器 
11        seters.add(new IdSeter()); 
12        //注入名称设置器 
13        seters.add(new NameSeter()); 
14    } 
15 
16    /** 
17     * 用户责任链，调用seter，组装参数 
18     * @param request 
19     */ 
20    @Override 
21    public void assemble(User request) { 
22        seters.forEach(userSeter -> userSeter.doSet(request)); 
23    } 
24} 
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.

测试调用

 1/** 
 2 * 责任链测试类 
 3 */ 
 4public class Test { 
 5 
 6 
 7    public static void main(String[] args) { 
 8        //用户责任链 
 9        UserChain userChain = new UserChain(); 
10        User user = new User(); 
11        //调用责任链，设置参数 
12        userChain.assemble(user); 
13        //加工完后获取到的对象值 
14        System.out.println(user.getId()+","+user.getName()); 
15    } 
16} 
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.