의 11: 책임 체인 모델

책임 체인 모드 정의:
Avoid coupling the sender of a request to its receiver by giving more than one object a chance to handle the request. Chain the receiving objects and pass the request along the chain until an object handles it.
여러 대상 이 요청 을 처리 할 수 있 도록 요청 한 발송 자 와 수용자 간 의 결합 관 계 를 피 할 수 있 습 니 다.이 수신 자 대상 을 하나의 체인 으로 연결 하고 이 체인 을 따라 대상 이 처리 할 때 까지 요청 을 전달 합 니 다.모든 요 구 는 체인 헤드 의 그 수용자 에 게 만 보 내 면 됩 니 다.
 
책임 체인 모드 의 템 플 릿 코드:
먼저 요청 단 계 를 정의 합 니 다. 요청 과 처리 클래스 의 단계 가 일치 할 때 실행 합 니 다.

public class Level {
    //            

}

 요청 클래스:

public class Request {
    //      
    public Level getRequestLevel() {
        return null;
    }
}

 결과 클래스 되 돌리 기:

public class Response {
    //         
}

 핵심: Handler 추상 클래스:

public abstract class Handler {
    private Handler nextHandler;
    //                
    public final Response handleMessage(Request request) {
        Response response = null;
        //             
        if (this.getHandlerLevel().equals(request.getRequestLevel())) {
            response = this.echo(request);
        } else {
            //            ，    ，          ，    null
            if (this.nextHandler != null) {
                response = this.nextHandler.handleMessage(request);
            } else {
                System.out.println("        ，      ，  null");
            }
        }
        return response;
    }

    //        
    public void setNextHandler(Handler _nextHandler) {
        this.nextHandler = _nextHandler;
    }

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

 구체 적 인 Handler 구현 클래스:

public class ConcreteHandler1 extends Handler {
    @Override
    protected Level getHandlerLevel() {
        //          
        return null;
    }

    @Override
    protected Response echo(Request request) {
        //          
        return null;
    }
}

 

public class ConcreteHandler2 extends Handler {
    @Override
    protected Level getHandlerLevel() {
        //          
        return null;
    }

    @Override
    protected Response echo(Request request) {
        //          
        return null;
    }
}

 

public class ConcreteHandler3 extends Handler {
    @Override
    protected Level getHandlerLevel() {
        //          
        return null;
    }

    @Override
    protected Response echo(Request request) {
        //          
        return null;
    }
}

 마지막 클 라 이언 트 호출 프 리 젠 테 이 션 클래스:

public class Client {
    public static void main(String[] args) {
        //          
        Handler handler1= new ConcreteHandler1();
        Handler handler2= new ConcreteHandler1();
        Handler handler3= new ConcreteHandler1();
        //            
        handler1.setNextHandler(handler2);
        handler2.setNextHandler(handler3);
        //     ，    
        Response response = handler1.handleMessage(new Request());

    }
}

 
책임 체인 모드 장점:
요청 과 처 리 를 분리 하고 요청 자 는 누가 처 리 했 는 지 알 필요 가 없 으 며 처리 자 는 요청 의 전 모 를 알 필요 가 없다. 이들 의 결합 을 해제 하고 시스템 의 유연성 을 높 인 다.
 
책임 체인 모드 의 단점:
첫 번 째 는 성능 문제 입 니 다. 모든 요 구 는 체인 헤드 에서 체인 꼬리 까지 옮 겨 다 니 는데 특히 체인 이 비교적 길 때 성능 이 큰 문제 입 니 다.
두 번 째 는 디 버 깅 이 불편 하고 재 귀적 호출 과 유사 하 며 디 버 깅 이 매우 불편 하 다 는 것 이다.
 
책임 체인 모드 주의사항:
일반적인 방법 은 Handler 에서 1 개의 최 장 노드 수량 을 설정 하고 setNext 방법 에서 한도 값 을 초과 하 는 지 판단 하 며 초과 하면 이 체인 의 구축 을 허용 하지 않 고 시스템 성능 을 파괴 하지 않도록 하 는 것 이다.
 
본인 의 블 로 그 는 이미 이 사 했 습 니 다. 새 주 소 는 다음 과 같 습 니 다. http://yidao620c.github.io/