Padrão de Design_Padrão de Cadeia de Responsabilidade

Cadeia de responsabilidade O modelo de cadeia de responsabilidade
refere-se principalmente à cadeia , e seu núcleo também está na cadeia ; é uma linha de processamento em cadeia composta por vários processadores, e as solicitações de processamento são passadas ao longo dessa cadeia até que haja um objeto para lidar com a solicitação.

Diagrama de Classe:

Esta é uma demonstração que implementou o modelo de cadeia de responsabilidade. Alguns lugares não são escritos com muito rigor e irei apontá-los a seguir.
ICar: é a interface do objeto de solicitação.
Carro: Um objeto de solicitação específico, que define o status da solicitação e as informações da solicitação correspondentes.
Manipulador: classe abstrata de processamento de solicitações.
Iniciar/Executar/Parar: Objeto específico de processamento de solicitação, solicitação correspondente.

Quando um objeto carro faz uma solicitação, se a solicitação puder ser interrompida, uma solicitação de transferência em cadeia será feita, a julgar pelo tipo, de Iniciar para Executar e depois para Parar. Quando passado para a classe Stop. O processamento é iniciado e pode ser interrompido, se necessário. Esta é uma cadeia de entrega de solicitações.

Ao usar o modelo de cadeia de responsabilidade, você precisa prestar atenção a:
1. Questões de desempenho: Cada vez que é passado do início da cadeia para o final da cadeia, se a cadeia for relativamente longa, haverá grande desempenho problemas.
2. Depuração: Depurar a cadeia de responsabilidade não é muito conveniente, pois você saberá se usá-la.

Vários métodos que são muito importantes na cadeia de responsabilidade:
método handlerMessage: método de processamento de solicitação, usado para determinar se a solicitação atual pode ser processada.
setNext: O método organiza a cadeia e define o próximo processador.
nível: Defina o nível que você pode controlar. Escrevi muito no código, mas na prática posso usar um encapsulamento de classe. É relativamente mais flexível.
resposta (ou eco): método de processamento específico. A forma como os nomes são chamados é um pouco diferente.

Código:

public interface ICar {

    public int getType();

    public String getRequest();
}

public class Car implements ICar {
    
    

    //定义一个级别描述现在的状况
    private int type = 0 ;

    private String request = "";

    public Car(int  _type, String _request){
        this.type = _type;

        switch (this.type) {
        case 1:
            this.request = "汽车的请求是" + _request;
            break;
        case 2:
            this.request = "汽车的请求是" + _request;
            break;
        case 3:
            this.request = "汽车的请求是" + _request;
            break;

        }
    }

    @Override
    public int getType() {
        return this.type;
    }

    @Override
    public String getRequest() {
        return this.request;
    }

}

public abstract class Handler {
    
    

    public final static int START_LEVEL_REQUEST = 1;

    public final static int RUN_LEVEL_REQUEST = 2;

    public final static int STOP_LEVEL_REQUEST = 3;

    //能处理的级别
    private int level = 0;

    private Handler nextHandler;

    //构造函数，每个类都要声明自己的处理级别.用于处理哪些请求
    public Handler(int _level){
        this.level = _level;
    }

    //判断请求是否属于你的
    public final void HandlerMessage(ICar _car){
        if(_car.getType() == this.level){
            this.response(_car);
        }else{
            if(this.nextHandler != null){
                this.nextHandler.HandlerMessage(_car);
            }else{
                System.out.println("没有后续环节了，车子已报废。");
            }
        }
    }

    /*
     * 如果不属于你的请求、你应该找到下一个环节
     * 汽车已经启动，在像启动环节询问的时候，应该告诉他你可以跑起来环节
     */
    public void setNext(Handler _handler){
        this.nextHandler = _handler;
    }

    //回应部分
    protected abstract void response(ICar _car); 

}

public class Start extends Handler {
    
    

    public Start() {
        super(Handler.START_LEVEL_REQUEST);
    }

    @Override
    protected void response(ICar _car) {
        System.out.println("-----------------汽车未启动，请示启动---------------- \n");
        System.out.println(_car.getRequest());
        System.out.println("-----------------汽车可以启动--------------- \n");
    }
}

public class Run extends Handler {
    
    

    public Run() {
        super(Handler.RUN_LEVEL_REQUEST);
    }

    @Override
    protected void response(ICar _car) {
        System.out.println("-----------------汽车已启动，请示跑路---------------- \n");
        System.out.println(_car.getRequest());
        System.out.println("-----------------汽车可以跑路--------------- \n");
    }
}

public class Stop extends Handler {
    
    

    public Stop() {
        super(Handler.STOP_LEVEL_REQUEST);
    }

    @Override
    protected void response(ICar _car) {
        System.out.println("-----------------汽车已跑路，请示停止---------------- \n");
        System.out.println(_car.getRequest());
        System.out.println("-----------------汽车可以停止--------------- \n");
    }
}

public class Client {

    public static void main(String args[]){
        Handler start = new Start();
        Handler run = new Run();
        Handler stop = new Stop();

        start.setNext(run);
        run.setNext(stop);

        ICar car = new Car(1,"我要启动汽车");

        ICar car1 = new Car(3,"我要停止汽车");

        start.HandlerMessage(car1);
        start.HandlerMessage(car);
    }
}

Em circunstâncias normais, a classe cliente será encapsulada e o objeto inicial será retornado diretamente. Basta ligar diretamente.

Existe um cenário de uso: quando um usuário se registra, um é um usuário membro registrado e o outro é um usuário convidado registrado. Você pode usar uma entrada e lidar com elas separadamente usando uma abordagem de cadeia de responsabilidade.