设计模式—责任链模式

定义

使多个对象都有机会处理请求，从而避免了请求的发送者和接受者之间的耦合关系。将这些对象连成一条链，并沿着这条链传递该请求，直到有对象处理它为止。

代码

定义级别来区分请求

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
public enum Level {

    LEVELONE(1), LEVELTWO(2), LEVELTHREE(3);


    private int level;

    Level(int level) {
        this.level = level;
    }

    public static Level getLeve(int index) {
        for (Level level : Level.values()) {
            if (level.getLevel() == index) {
                return level;
            }
        }
        return null;
    }

    public int getLevel() {
        return level;
    }
}

定义请求

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
public class Request {

    private int level;

    private String requestString;

    public Request(int level, String requestString) {
        this.level = level;
        this.requestString = requestString;
    }

    public int getLevel() {
        return level;
    }

    public void setLevel(int level) {
        this.level = level;
    }

    public String getRequestString() {
        return requestString;
    }

    public void setRequestString(String requestString) {
        this.requestString = requestString;
    }

    public Level getMyLevel(){
        return Level.getLeve(this.level);
    }
}

定义响应

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public class Response {

    private String message;

    public Response(String message) {
        this.message = message;
    }

    public String getMessage() {
        return message;
    }

    public void setMessage(String message) {
        this.message = message;
    }
}

定义处理器,使用了模板方法，关键在处理的时候通过nextHandler传递请求

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
public abstract class MyHandler {

    private MyHandler nextHandler;

    public final Response handleMassege(Request request){
        Response response;
        if(this.getHandlerLevel() == request.getMyLevel()){
            response= this.echo(request);
        }else{
            if(this.nextHandler!=null){
                response = this.nextHandler.handleMassege(request);
            }else{
                response=null;
            }
        }
        return response;
    }


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

    protected  abstract Level getHandlerLevel();
    protected abstract Response echo(Request request);
}

定义不同处理的具体实现

1
2
3
4
5
6
7
8
9
10
11
public class ConcreteHandler01 extends MyHandler {
    @Override
    protected Level getHandlerLevel() {
        return Level.LEVELONE;
    }

    @Override
    protected Response echo(Request request) {
        return new Response(request.getRequestString()+": 一级响应");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
public class ConcreteHandler02 extends MyHandler {

    @Override
    protected Level getHandlerLevel() {
        return Level.LEVELTWO;
    }

    @Override
    protected Response echo(Request request) {
        return new Response(request.getRequestString()+":二级响应");
    }
}
1
2
3
4
5
6
7
8
9
10
11
public class ConcreteHandler03 extends MyHandler {
    @Override
    protected Level getHandlerLevel() {
        return Level.LEVELTHREE;
    }

    @Override
    protected Response echo(Request request) {
        return new Response(request.getRequestString()+":三级响应");
    }
}

测试

1
2
3
4
5
6
7
8
9
10
11
12
13
14
@Test
public void testMyHandler(){

    MyHandler handler1 = new ConcreteHandler01();
    MyHandler handler2 = new ConcreteHandler02();
    MyHandler handler3 = new ConcreteHandler03();
    handler1.setNextHandler(handler2);
    handler2.setNextHandler(handler3);
    for (int i = 1; i < 4; i++) {
        Request request = new Request(i,"去学校");
        Response response = handler1.handleMassege(request);
        System.out.println(response.getMessage());
    }
}