Prefácio
Olá a todos, sou um programador inteligente . Apresentei o modelo singleton na última edição . Amigos interessados podem ler o compartilhamento anterior. A seguir, apresentarei outro padrão de design comumente usado no trabalho: o padrão de cadeia de responsabilidade .
definição
O que é uma cadeia de responsabilidade e quais são as suas características?
O padrão de cadeia de responsabilidade é um padrão de design comportamental. No padrão de cadeia de responsabilidade, cada objeto contém uma referência ao próximo objeto a ser processado, formando assim uma cadeia. Quando o cliente inicia uma solicitação, a solicitação será passada ao longo dessa cadeia e cada objeto terá a chance de lidar com a solicitação. Isso permite que o sistema se reorganize e aloque responsabilidades dinamicamente sem afetar o cliente.
O processo específico é o seguinte:
Cenários de aplicação
- Fluxo de aprovação do OA (como iniciar um processo de férias e determinar a quais líderes de departamento o processo atual precisa ir para aprovação com base no número de dias de férias)
- Filtro de filtro (como o processo de registro de conta, que precisa passar pela verificação de legalidade do número da conta, senha, etc.)
Método para realizar
- Histórico de demanda
Crie um processo de aprovação de férias do funcionário. Quando os dias de férias do funcionário forem <= 1, o líder direto irá aprová-lo. Quando os dias de férias forem <= 2, o chefe direto e o líder do departamento de primeiro nível irão aprová-los respectivamente. Quando os dias de férias forem >= 3, o processo de aprovação será feito respectivamente.A aprovação estará sujeita à liderança direta, líderes de departamento de primeiro nível e líderes responsáveis.
Primeiro, construa um corpo de solicitação RequestParam , incluindo o nome do solicitante e o número de dias de férias.
/**
* 审批请求体
* @author coder_smart
*/
@Getter
@Setter
public class RequestParam {
// 申请人
private String name;
// 休假时间
private int time;
public RequestParam(String name, int time) {
this.name = name;
this.time = time;
}
public RequestParam() {}
}
É assim que você pode escrever seu código sem usar truques sofisticados.
public class Main{
public static void main(String[] args) {
// 初始化请求参数
RequestParam requestParam = new RequestParam("张三", 3);
if (requestParam.getTime() >= 1) {
// 直接领导审批
if (requestParam.getTime() >= 2) {
// 一级部门领导审批
if (requestParam.getTime() >= 3) {
// 分管领导审批
}
}
}
}
}
Pode-se ver claramente que cada lógica de processamento é cercada por uma ramificação if. Quando os requisitos de negócios não são complexos ou o número de nós de processamento não é grande, não há problema algum. No entanto, se o gerente de produto propor uma pequena opinião , quando o número de dias de férias for igual a 0,5, será aprovado pelo RH. Quando o número de dias de férias for igual a 2,5, será aprovado pelo líder do departamento de segundo nível. Neste momento, você deve alterar o código de ramificação if aninhado, o que reduz bastante a legibilidade do código e a escalabilidade.
- Transformação usando o modelo de cadeia de responsabilidade
/**
* 抽象审批类
* @author coder_smart
*/
public abstract class AuditHandler {
// 下一个处理节点
protected AuditHandler nextAuditHandler;
// 设置下一个处理节点
public void setNextAuditHandler(AuditHandler nextAuditHandler) {
this.nextAuditHandler = nextAuditHandler;
}
// 抽象方法，子类实现各自处理的逻辑
public abstract void audit(RequestParam requestParam);
}
A classe de aprovação abstrata AuditHandler contém a referência nextAuditHandler do próximo processador , que é injetada através do método setNextAuditHandler , formando assim uma cadeia. O método de auditoria abstrata usa a classe de implementação de cada processador para implementar sua própria lógica de aprovação.
/**
* 直接领导审批处理类
* @author coder_smart
*/
public class FirstLeaderAuditHandler extends AuditHandler{
@Override
public void audit(RequestParam requestParam) {
System.out.print("start");
System.out.print("---> 直接领导审批 ");
if (requestParam.getTime() <= 1) {
// do Something
System.out.print("---> end");
return;
}
nextAuditHandler.audit(requestParam);
}
}
/**
* 一级部门领导审批处理类
* @author coder_smart
*/
public class SecondLeaderAuditHandler extends AuditHandler{
@Override
public void audit(RequestParam requestParam) {
System.out.print("---> 一级部门领导审批 ");
if (requestParam.getTime() <= 2) {
// do Something
System.out.print("---> end");
return;
}
nextAuditHandler.audit(requestParam);
}
}
/**
* 分管领导审批处理类
* @author coder_smart
*/
public class ThirdLeaderAuditHandler extends AuditHandler{
@Override
public void audit(RequestParam requestParam) {
// do Something
System.out.print("---> 分管部门领导审批 ");
System.out.print("---> end");
return;
}
}
/**
* 客户端
*
* @author coder_smart
*/
public class Main {
public static void main(String[] args) {
// 初始化请求参数
// RequestParam requestParam = new RequestParam("张三", 1);
// RequestParam requestParam = new RequestParam("张三", 2);
RequestParam requestParam = new RequestParam("张三", 3);
// 构建各处理节点对象
AuditHandler firstLeaderHandler = new FirstLeaderAuditHandler();
AuditHandler secondLeaderHandler = new SecondLeaderAuditHandler();
AuditHandler thirdLeaderHandler = new ThirdLeaderAuditHandler();
// 组装成责任链
firstLeaderHandler.setNextAuditHandler(secondLeaderHandler);
secondLeaderHandler.setNextAuditHandler(thirdLeaderHandler);
// 开始审批
firstLeaderHandler.audit(requestParam);
// console log
// time=1, start---> 直接领导审批 ---> end
// time=2, start---> 直接领导审批 ---> 一级部门领导审批 ---> end
// time=3, start---> 直接领导审批 ---> 一级部门领导审批 ---> 分管部门领导审批 ---> end
}
}
Resumir
No processo de trabalho, amigos, por favor, não usem padrões de design em seu próprio código de negócios apenas para mostrar suas habilidades.Um bom padrão de design é aquele que é adequado para o negócio atual.
Existem muitos tipos de padrões de design, e a cadeia de responsabilidade é a mais interessante para mim e vale a pena aprender.
Se este artigo for útil para você, clique três vezes para curtir , coletar e assistir !
想更深入的了解设计模式原理以及相关面试题，更多详细资料请见：https://cloud.fynote.com/share/d/qinfK72