从复杂到优雅：用建造者和责任链重塑代码架构

引用

设计模式是软件开发中的重要工具，它为解决常见问题提供了标准化的解决方案，提高了代码的可维护性和可扩展性，提升了开发效率，促进了团队协作，提高了软件质量，并帮助开发者更好地适应需求变化。通过学习和应用设计模式，开发者可以提升自己的设计能力和解决问题的能力，从而开发出更高质量的软件。

说的直白点，设计模式能让你的代码更加优雅美观；可以脱离shi山的范畴。

一、设计模式的六大原则

设计模式六大原则是面向对象设计中核心指导思想，它们帮助开发者设计出更灵活、可维护和可扩展的系统。以下是这六大原则的详细解释（本篇文章不多做赘述）：

二、建造者设计模式

2.1什么是建造者模式

建造者模式就是使用多个简单的对象一步一步的构建成一个复杂的对象。建造者模式是一种创建型设计模式，它提供了一种创建对象的最佳方式，同时允许用户只关注指定复杂对象的类型和内容，而不必关心其内部的具体构建细节。

建造者模式将复杂对象的构建过程与表示分离，使得相同的构建过程可以创建不同的表示。

建造者模式可以分为以下四种角色：

• 抽象建造者类（Builder）：这个接口规定乣实现复杂对象的那些部分的创建，并不设计具体的对象不见的创建

• 具体建造者类（ConcreteBuilder）：实现Builder接口，完成复杂产品的各个部件的具体创建方法。在构造过程完成后，提供产品的实例。

• 产品类（Productr）：要创建的复杂对象。

• 指挥者类（Director）：调用具体建造者来创建复杂对象的各个部分，在指导者中不涉及具体产品的信息，只负责保证对象各部分完整创建或按梦中顺序创建。

类图如下：

这里只是回顾一下概念，方便后续案例理解。

三、责任链设计模式

3.1什么是责任链设计模式

责任链模式将请求的处理者连接成一条链，并沿着这条链传递请求，直到链上的某个对象处理它为止。每个处理者都包含对下一个处理者的引用，如果当前对象不能处理该请求，它会将请求转发给链上的下一个对象。

它是一种行为设计模式，用于实现请求的发送者与接收者之间的解耦，让多个对象都有机会处理请求，从而避免请求的发送者和接收者之间的耦合关系。

责任链模式主要包含以下三种角色：

• 抽象处理者（Handler） ：定义一个处理请求的接口，包含一个后继连接。通常会有一个抽象方法（如 handleRequest），用于处理请求。

• 具体处理者（ConcreteHandler） ：实现抽象处理者定义的接口，具体处理请求。如果不能处理请求，则将请求转发给链上的下一个对象。

• 客户端（Client） ：创建处理链，并向链的起始对象提交请求。

责任链模式的处理方式：

四、案例：用建造者和责任链重塑代码架构

想用代码来说明一个东西，我们还是要有一定的前因后果，所以下面我将从业务需求，实现方案设计，以及实现代码三个方面来演示。

4.1 需求

我们有一个跨境电商系统，已经达到一定的规模，这就导致一些恶意用户盯上了我们，他们会使用信用卡支付，然后后面收到货了去申诉说自己信用卡被盗了，因为做的跨境电商，一旦这些恶意用户申诉成功，银行会直接退钱给到用户，这就会让我们钱货两空。

要求我们搭建一个风控系统，在发货之前识别订单风险，尽量减少我们的损失。

4.2 实现方案

4.2.1分析需求

目标：拦截风险订单

分析风险项

• 用户账号（账号黑名单）
• 支付信息（信用卡对应黑名单）
• 收货地址信息（收货地址黑名单）
• 下单频率分析（针对货物设计过期换代时间模型，和用户下单频率分析模型）

4.2.2实现代码

上面分析完了，下面来实现代码；注意，这里只会放伪代码，主要是讲清楚用建造者和责任链重塑代码架构；上面的业务场景不会真正的在这里实现。

• 接口

package com.gnz;

public interface Chain {

    void next(Chain next);

    Result start(Order order);

    Result process(Order order);

}

• 抽象类（这里面又用到了模版方法）

package com.gnz;

public abstract class AbstractChain implements Chain {

    protected Chain next;


    public void next(Chain next) {
        this.next = next;
    }


    public Result start(Order order) {
        Result result = process(order);
        if (!result.success()) {
            // 已经有风险，直接结束
            return result;
        }
        if (next != null) {
            // 向下调用传参
            return next.process(order);
        }
        return Result.buildSuccess("一切OK");
    }

    public abstract Result process(Order order);


    public static class Bulider {

        /**
         * 责任链头部
         */
        private AbstractChain head;

        /**
         * 责任链尾
         */
        private AbstractChain tail;


        public Bulider append(AbstractChain handler) {

            if (this.head == null) {
                this.head = this.tail = handler;

                return this;
            }
            this.tail.next(handler);
            this.tail = handler;
            return this;
        }

        public AbstractChain build() {
            return this.head;
        }
    }

}

• 各种具体责任类

用户阻塞名单

package com.gnz;

import org.springframework.stereotype.Service;

import java.util.Arrays;
import java.util.List;

@Service
public class UserBlockListChain extends AbstractChain {

    private List<String> list = Arrays.asList("[email protected]");

    @Override
    public Result process(Order order) {
        if (list.contains(order.getUser().getUsername())) {
            return Result.buildFail("用户被禁用了");
        }
        if (next != null) {
            // 向下调用传参
            return next.process(order);
        }
        return Result.buildSuccess("用户OK");
    }

}

地址阻塞名单

package com.gnz;

import org.springframework.stereotype.Service;

import java.util.Arrays;
import java.util.List;

@Service
public class AddressBlockListChain extends AbstractChain {

    private List<String> list = Arrays.asList("XXYYDD");

    @Override
    public Result process(Order order) {
        if (list.contains(order.getAddress().getAddress())) {
            return Result.buildFail("该地址不在配送范围");
        }
        return Result.buildSuccess("地址OK");
    }

}

支付阻塞账号

package com.gnz;

import org.springframework.stereotype.Service;

import java.util.Arrays;
import java.util.List;

@Service
public class PayBlockListChain extends AbstractChain {

    private List<String> list = Arrays.asList("123456");

    @Override
    public Result process(Order order) {
        if (list.contains(order.getPay().getCardNo())) {
            return Result.buildFail("信用卡在阻塞名单");
        }
        if (next != null) {
            // 向下调用传参
            return next.process(order);
        }
        return Result.buildSuccess("支付OK");
    }

}

异常频率分析

package com.gnz;

import org.springframework.stereotype.Service;

@Service
public class ModelAnalysisChain extends AbstractChain {

    @Override
    public Result process(Order order) {
        if (!Model.analysis(order)) {
            return Result.buildFail("异常下单频率");
        }
        if (next != null) {
            // 向下调用传参
            return next.process(order);
        }
        return Result.buildSuccess("频率OK");
    }

}

• 风控管理服务

package com.gnz;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class RiskService {

    public Result orderRisk(Order order) {
        AbstractChain chain = new AbstractChain.Bulider()
                .append(userBlockListChain)
                .append(payBlockListChain)
                .append(addressBlockListChain)
                .append(modelAnalysisChain)
                .build();
        return chain.process(order);
    }

    @Autowired
    private UserBlockListChain userBlockListChain;
    @Autowired
    private PayBlockListChain payBlockListChain;
    @Autowired
    private AddressBlockListChain addressBlockListChain;
    @Autowired
    private ModelAnalysisChain modelAnalysisChain;

}

五、总结

设计模式，这可是编程界的"武林秘籍"！它能帮程序员们解决各种看似复杂又常见的问题，就像给代码穿上了一件优雅的外衣，让原本乱糟糟的代码瞬间变得有模有样。

有了它，新手也能快速上手，避免走弯路；老手则能更高效地写出高质量代码，少些"重复造轮子"的烦恼。

而且，设计模式还能让团队协作更顺畅，大家一看就知道这是啥套路，沟通成本大大降低。

有了它，代码世界也能变得井井有条，不再"乱糟糟"。

要想脱离江湖小白的名头，成为一代大侠，就得练好设计模式这本秘籍。