工作中常用的设计模式--责任链模式

一般做业务开发,不太容易有大量使用设计模式的场景。这里总结一下在业务开发中使用较为频繁的设计模式。当然语言为Java,基于Spring框架。

1 责任链模式(Chain of Responsibility Pattern)

对数据流、对象做一系列过滤、校验、处理等操作,该操作通常是有序的。该场景在生活中还是很常见的,如大家经常举例的各种审批流。再如面试,需要通过一面、二面、三面、HR面等,最终拿下Offer。这些都属于责任链的场景,

责任链模式一般有3个角色:

  • Client: 客户端。用来编排处理器,可静态、也可运行时动态生成。类似单链表。
  • Handler: 接口或抽象类。约定处理函数名称、参数等。
  • ConcreteHandler: 具体处理器。

这种出现的场景其实挺多,但真正使用的却不是很多。这就要提到责任链的几个缺点:灵活动态既是优点也是缺点,使得程序不够直观,流程不够明了。甚至可能出现循环引用(死循环)的情况。

责任链的编排一般有两种:

  • 外部编排:具体处理器,仅根据Contex参数进行处理,并将结果回写Contex。内部不做编排。相对比较独立(纯粹)的逻辑处理单元。
  • 内部编排:类似单链表。在执行过程中,根据Context参数的处理结果,判断是否需要进行下一步(进入下一个处理器)。相对外部编排,灵活度略低一些。

1.1 实际业务场景

在用户留资进线场景中,我们需要根据线索的渠道号、落地页来源、学科等做不同的逻辑处理。但在未得到实际参数前,我们是不能确定具体要走哪些处理器。一些业务规则(简化):

  • 渠道号(channel)不能为空
  • 某些特殊渠道号,推荐人不能为空
  • 某些落地页来源(lpv),偏好语言不能为空

只有全部符合条件的线索,才能实际进入到CRM系统中。

线索 LeadsBO
@Data
@Builder
public class LeadsBO {
    // 渠道号
    private String channel;
    // 推荐人ID
    private Long referrerId;
    // 学科 1:中文 2:英文
    private Integer subject;
    // 落地页版本(Landing Page Version)
    private String lpv;
    // 偏好语言
    private String preferenceLanguage;

    // 责任链回写
    // 数据是否有效
    @Builder.Default
    private boolean valid = true;
    // 异常信息(错误日志)
    private String errMsg;
}
线索过滤器(即Handler处理器) Filter
/**
 * 线索过滤器
 */
public interface Filter {

    void process(LeadsBO bo);
}
4个具体处理器

/**
 * 渠道号过滤器
 */
@Component("channel")
public class ChannelFilter implements Filter {

    @Override
    public void process(LeadsBO bo) {
        if (StringUtils.isBlank(bo.getChannel())) {
            bo.setValid(false);
            bo.setErrMsg("channel为空");
        }
    }
}

/**
 * 推荐人过滤
 */
@Component("referrer")
public class ReferrerFilter implements Filter {
    private static final Set CHANNELS = Set.of(
            "LP-XX-XX-01", "LP-XX-XX-02"
    );

    @Override
    public void process(LeadsBO bo) {
        final String channel = bo.getChannel();
        final Long referrerId = bo.getReferrerId();
        if (CHANNELS.contains(channel) && Objects.isNull(referrerId)) {
            bo.setValid(false);
            bo.setErrMsg("特定渠道号, 推荐人不能为空");
        }
    }
}

/**
 * 落地页版本号校验
 */
@Component("lpv")
public class LpvFilter implements Filter {

    @Override
    public void process(LeadsBO bo) {
        final String lpv = bo.getLpv();
        if (StringUtils.isNoneBlank(lpv) && lpv.startsWith("XZ") && StringUtils.isBlank(bo.getPreferenceLanguage())) {
            bo.setValid(false);
            bo.setErrMsg("偏好语言不能为空");
        }
    }
}

/**
 * 学科过滤器
 *
 */
@Component("subject")
public class SubjectFilter implements Filter {

    @Override
    public void process(LeadsBO bo) {
        final Integer subject = bo.getSubject();
        if (Objects.isNull(subject) || (subject != 1 && subject != 2)) {
            bo.setSubject(1);
        }
    }
}

可以看到,我们在定义处理器时,并没有在处理器内部动态指定下一个处理。我们将处理器的编排放在外部设置,这样更加的灵活一下。借助于Spring,给具体处理添加别名,方便后续使用。

下面再定义一个线索拦截服务,其实就是将Client的部分逻辑进行封装,使得调用更加简单一些。只需要外部传递参数(LeadsBO),以及处理器别名的编排序列(List)即可。

LeadsFilterService
/**
 * 线索拦截器
 */
public interface LeadsFilterService {

    void filter(LeadsBO bo, List filterChain);
}

/**
 * 线索拦截器
 */
@Slf4j
@Service
public class LeadsFilterServiceImpl implements LeadsFilterService, ApplicationContextAware {
    private ApplicationContext appCtx;

    @Override
    public void filter(LeadsBO bo, List filterChain) {
        for (String fc : filterChain) {
            final Filter filter = appCtx.getBean(fc, Filter.class);
            filter.process(bo);
            if (!bo.isValid()) {
                log.error("[线索拦截] 数据异常 errMsg=>{}", bo.getErrMsg());
                return;
            }
        }
    }

    @Override
    public void setApplicationContext(ApplicationContext ctx) throws BeansException {
        appCtx = ctx;
    }
}

借助ApplicationContextAware拿到Spring容器上下文,方便根据别名获取Bean对象。

1.2 单测

@SpringBootTest
class LeadsFilterServiceTest {

    @Autowired
    LeadsFilterService service;

    @Test
    void testChannel() {
        final LeadsBO bo = LeadsBO.builder().build();
        service.filter(bo, List.of("channel", "subject", "lpv", "referrer"));
        assertFalse(bo.isValid());
    }

    @Test
    void testReferrer() {
        final LeadsBO bo = LeadsBO.builder().channel("LP-XX-XX-01").referrerId(123L).build();
        service.filter(bo, List.of("channel", "subject", "lpv", "referrer"));
        assertEquals(1, bo.getSubject());
        assertTrue(bo.isValid());
    }
}

2 思考

责任链模式能带来什么?

  1. 高内聚低耦合,将具体业务逻辑浓缩到具体处理器。
  2. 易于拓展,有新逻辑,直接继承、或实现处理器即可。
  3. 若有多种场景,需要不同的编排时,可高效复用这些处理器。

跟策略模式有啥区别?

  1. 策略模式一般只会由某个具体的策略去处理,其他策略不会参与。
  2. 责任链模式则是每个处理器都有可能获得处理权限。重点在于链式。

有啥注意事项呢?

  1. 避免滥用。但在合适的场景要大胆去使用。
  2. 一定要避免出现循环引用的情况。

封面图来源:https://refactoring.guru/desi...


echo '5Y6f5Yib5paH56ugOiDmjpjph5Eo5L2g5oCO5LmI5Zad5aW26Iy25ZWKWzkyMzI0NTQ5NzU1NTA4MF0pL+aAneWQpihscGUyMzQp' | base64 -d

你可能感兴趣的:(工作中常用的设计模式--责任链模式)