Notas sobre la cadena de responsabilidad Patrón de patrones de diseño

ilustrar

Registre el método de escritura para aprender el patrón de diseño-cadena de patrón de responsabilidad. La versión de JDK utilizada es la versión 1.8.

Cadena de Responsabilidad

Intención : Brinde a varios objetos la oportunidad de manejar la solicitud, evitando así el acoplamiento entre el remitente y el receptor de la solicitud. Estos objetos están conectados en una cadena y la solicitud se pasa a lo largo de la cadena hasta que un objeto la maneja.
Estructura :

en:

• Handler define una interfaz para procesar solicitudes; (opcional) implementa la cadena sucesora.
• ConcreteHandler maneja la solicitud de la que es responsable; tiene acceso a sus sucesores; si la solicitud puede manejarse, la maneja; de lo contrario, reenvía la solicitud al sucesor.
• El cliente envía una solicitud al objeto controlador de concreto (ConcreteHandler) en la cadena.

aplicabilidad:

• Hay varios objetos que pueden manejar una solicitud y qué objeto maneja la solicitud se determina automáticamente en tiempo de ejecución.
• Quiere enviar una solicitud a uno de varios objetos sin especificar explícitamente el destinatario.
• El conjunto de objetos que pueden manejar una solicitud debe especificarse dinámicamente.

Tabla de contenido

Diagrama de clases de ejemplo de patrón de cadena de responsabilidad

Utilice este diagrama de clases UML para implementar un ejemplo del patrón de cadena de responsabilidad.

Tipo de solicitud de salida

package com.example.deesign_patterns.responsibility;

//请假条类
public class LeaveRequest {
    
    

    //姓名
    private String name;
    //请假天数
    private int num;
    //请假内容
    private String content;

    public LeaveRequest(String name, int num, String content) {
    
    
        this.name = name;
        this.num = num;
        this.content = content;
    }

    public String getName() {
    
    
        return name;
    }

    public int getNum() {
    
    
        return num;
    }

    public String getContent() {
    
    
        return content;
    }
}

clase de controlador abstracto

package com.example.deesign_patterns.responsibility;

//抽象处理者类
public abstract class Handler {
    
    

    protected final static int NUM_ONE=1;
    protected final static int NUM_THREE=3;
    protected final static int NUM_SEVEN=7;

    //该领导处理的请求天数区间
    private int numStart;
    private int numEnd;

    //声明后续者(声明上级领导)
    private Handler nextHandler;

    public Handler(int numStart){
    
    
        this.numStart=numStart;
    }

    public Handler(int numStart,int numEnd){
    
    
        this.numStart=numStart;
        this.numEnd=numEnd;
    }

    //设置上级领导对象
    public void setNextHandler(Handler nextHandler) {
    
    
        this.nextHandler = nextHandler;
    }

    //各级领导处理请假条的方法
    protected abstract void handleLeave(LeaveRequest leave);

    //提交请求条
    public final void submit(LeaveRequest leave){
    
    
        //该领导进行审批
        this.handleLeave(leave);
        //判断是否有上级领导且该领导能否处理
        if(this.nextHandler!=null&&leave.getNum()>this.numEnd){
    
    
            //提交给上级领导进行审批
            this.nextHandler.submit(leave);
        }else {
    
    
            System.out.println("流程结束！");
        }
    }
}

Categoría líder de grupo

package com.example.deesign_patterns.responsibility;

//小组长类(具体的处理者)
public class GroupLeader extends Handler{
    
    

    //定义小组长批准天数为1天
    public GroupLeader() {
    
    
        super(0,Handler.NUM_ONE);
    }

    @Override
    protected void handleLeave(LeaveRequest leave) {
    
    
        System.out.println(leave.getName()+"请假"+leave.getNum()+"天，"+leave.getContent()+"。");
        System.out.println("小组长审批：同意");
    }
}

Clase de gerente de departamento

package com.example.deesign_patterns.responsibility;

//部门经理类(具体的处理者)
public class Manager extends Handler{
    
    

    //部门经理批准天数为1-3天
    public Manager() {
    
    
        super(Handler.NUM_ONE,Handler.NUM_THREE);
    }

    @Override
    protected void handleLeave(LeaveRequest leave) {
    
    
        System.out.println(leave.getName()+"请假"+leave.getNum()+"天，"+leave.getContent()+"。");
        System.out.println("部门经理审批：同意");
    }
}

Gerente general

package com.example.deesign_patterns.responsibility;

//总经理类(具体的处理者)
public class GeneralManager extends Handler{
    
    

    //总经理批准天数为3-7天
    public GeneralManager() {
    
    
        super(Handler.NUM_THREE,Handler.NUM_SEVEN);
    }

    @Override
    protected void handleLeave(LeaveRequest leave) {
    
    
        System.out.println(leave.getName()+"请假"+leave.getNum()+"天，"+leave.getContent()+"。");
        System.out.println("总经理审批：同意");
    }
}

clase de prueba

package com.example.deesign_patterns.responsibility;

//测试类
public class Client {
    
    

    public static void main(String[] args) {
    
    
        //创建一个请假条对象
        LeaveRequest leave=new LeaveRequest("小明",7,"身体不适");
        //创建各级领导对象
        GroupLeader groupLeader=new GroupLeader();
        Manager manager=new Manager();
        GeneralManager generalManager=new GeneralManager();
        //设置处理者链
        groupLeader.setNextHandler(manager);
        manager.setNextHandler(generalManager);
        //小明提交请假申请
        groupLeader.submit(leave);
    }
}

beneficio:

• Reduce el acoplamiento entre objetos. Este patrón reduce el acoplamiento entre remitentes y receptores de solicitudes.
• Escalabilidad mejorada del sistema. Se pueden agregar nuevas clases de procesamiento de solicitudes según sea necesario para cumplir con el principio de apertura y cierre.
• Mayor flexibilidad en la asignación de responsabilidades a los objetos. Cuando cambia el flujo de trabajo, los miembros dentro de la cadena se pueden cambiar dinámicamente o se puede modificar su orden, y también se pueden agregar o eliminar responsabilidades dinámicamente.
• La cadena de responsabilidad simplifica la conexión entre objetos. Un objeto sólo necesita mantener una referencia a su sucesor y no necesita mantener referencias a todos los demás controladores, lo que evita el uso de numerosas declaraciones if o if...else.
• Responsabilidades compartidas. Cada clase solo necesita manejar el trabajo que debe manejar, y el trabajo no procesado se pasa al siguiente objeto para su finalización. El alcance de las responsabilidades de cada tipo está claramente definido, lo que está en línea con el principio de responsabilidad única de la clase.

defecto:

• No hay garantía de que se procesen todas las solicitudes. Dado que una solicitud no tiene un destinatario claro, no hay garantía de que será procesada y es posible que la solicitud no se procese hasta que llegue al final de la cadena.
• En comparación con una cadena de responsabilidades más larga, el procesamiento de solicitudes puede involucrar múltiples objetos de procesamiento y el rendimiento del sistema se verá afectado hasta cierto punto.
• La racionalidad del establecimiento de la cadena de responsabilidad debe ser garantizada por el cliente, lo que aumenta la complejidad del cliente. Pueden ocurrir errores del sistema debido a configuraciones incorrectas de la cadena de responsabilidad, como llamadas circulares.