【一】介绍引入

• 当你想要让一个以上的对象有机会能够处理某个请求的时候，就使用责任链模式(Chain of Responsibility Pattern)。

【二】场景引入

• 自从推出Java版本的糖果机之后，万能糖果公司收到的电子邮件数量已超出他们所能处理的范围。
• 据他们自己分析，所收到的电子邮件有四类:
  • 其一、Fans寄来的信，他们喜欢新推出的l in 10游戏;
  • 其二，父母寄来的信，抱怨他们的孩子沉溺于这个游戏;
  • 其三，店家寄来的信，他们希望能够在某些地方也摆设糖果机;
  • 其四，垃圾邮件。
• 所有Fans的邮件都需要直接送到CEO手上，所有的抱怨邮件则是送给法律部门，而所有的新机器请求邮件则交给业务部门，至于垃圾邮件当然是删除了事。

【三】任务需求

• 万能糖果公司已经写了一些人工智能过滤程序,这些程序很厉害，它们会分辨邮件是属于上述哪一类
• 但是他们需要你构造一个设计——使用这个过滤程序处理收到的邮件。

【四】如何使用责任链模式

• 责任链模式是一种行为设计模式，用于构建一条对象链，每个对象都包含了对请求的处理方式。
  • 当一个请求被发送到这个链上，每个对象都会依次尝试处理请求，直到其中一个对象处理成功或者所有对象都不能处理为止。
• 责任链模式的核心思想是将请求的发送者和接收者解耦，使多个对象都有机会处理请求，避免了将请求的发送者与接收者紧密耦合在一起。
• 责任链模式通常包括以下角色
  • Handler（处理者）： 定义了处理请求的接口，通常包括一个处理方法。具体的处理者对象实现这个接口，并决定是否能够处理请求，如果能够处理，则进行处理；如果不能处理，则将请求传递给下一个处理者。
  • ConcreteHandler（具体处理者）： 具体的处理者对象，实现了Handler接口，负责处理请求。如果自己能够处理请求，则进行处理；否则，将请求传递给下一个处理者。
  • Client（客户端）： 创建处理者链并向链中的第一个处理者发送请求。

【五】责任链模式的优点

• 将请求的发送者和接受者解耦。
• 可以简化你的对象，因为它不需要知道链的结构。
• 通过改变链内的成员或调动它们的次序，允许你动态地新增或者删除责任。
• 可以避免请求发送者需要知道接收者的详细信息，降低了耦合度。

【六】责任链模式的用途和缺点

• 经常被使用在窗口系统中，处理鼠标和键盘之类的事件。
• 并不保证请求一定会被执行:如果没有任何象处理它的话，它可能会落到链尾端之外(这可以是优点也可以是缺点)。
• 可能不容易观察运行时的特征,有碍于除错。

【七】代码演示

【1】理论

• Handler

  • successor
  • handleRequest()

• SpanHandler

  • handleRequest()

• FanHandler

  • handleRequest()

• ComplaintHandler

  • handleRequest()

• NewLocalHandler

  • handleRequest()

• 链中的每个对象扮演处理器，并且都有一个后继对象

• 如果他可以处理请求，就进行处理；否则把请求传给后继者

• 当收到电子邮件的时候，它会被送进第一个处理器，也就是SpamHandler。如果SpamHandler无法处理，就将它传给FanHandler。依次类推……

【2】Java代码

// 定义邮件处理器接口
public interface EmailHandler {
    void setNextHandler(EmailHandler handler);
    void handleEmail(Email email);
}

// 实现垃圾邮件处理器
public class SpamHandler implements EmailHandler {
    private EmailHandler nextHandler;

    @Override
    public void setNextHandler(EmailHandler handler) {
        this.nextHandler = handler;
    }

    @Override
    public void handleEmail(Email email) {
        if (isSpam(email)) {
            System.out.println("Deleted spam email: " + email.getContent());
        } else if (nextHandler != null) {
            nextHandler.handleEmail(email);
        }
    }

    private boolean isSpam(Email email) {
        // 判断邮件是否是垃圾邮件的逻辑
        // 这里只是一个示例，实际逻辑需要根据具体情况编写
        return email.getContent().contains("spam");
    }
}

// 实现Fans邮件处理器
public class FansHandler implements EmailHandler {
    private EmailHandler nextHandler;

    @Override
    public void setNextHandler(EmailHandler handler) {
        this.nextHandler = handler;
    }

    @Override
    public void handleEmail(Email email) {
        if (isFansEmail(email)) {
            System.out.println("Forwarded fans email to CEO: " + email.getContent());
        } else if (nextHandler != null) {
            nextHandler.handleEmail(email);
        }
    }

    private boolean isFansEmail(Email email) {
        // 判断邮件是否是Fans邮件的逻辑
        // 这里只是一个示例，实际逻辑需要根据具体情况编写
        return email.getContent().contains("fans");
    }
}

// 实现抱怨邮件处理器
public class ComplaintHandler implements EmailHandler {
    private EmailHandler nextHandler;

    @Override
    public void setNextHandler(EmailHandler handler) {
        this.nextHandler = handler;
    }

    @Override
    public void handleEmail(Email email) {
        if (isComplaintEmail(email)) {
            System.out.println("Forwarded complaint email to legal department: " + email.getContent());
        } else if (nextHandler != null) {
            nextHandler.handleEmail(email);
        }
    }

    private boolean isComplaintEmail(Email email) {
        // 判断邮件是否是抱怨邮件的逻辑
        // 这里只是一个示例，实际逻辑需要根据具体情况编写
        return email.getContent().contains("complaint");
    }
}

// 实现新机器请求邮件处理器
public class NewMachineRequestHandler implements EmailHandler {
    private EmailHandler nextHandler;

    @Override
    public void setNextHandler(EmailHandler handler) {
        this.nextHandler = handler;
    }

    @Override
    public void handleEmail(Email email) {
        if (isNewMachineRequestEmail(email)) {
            System.out.println("Forwarded new machine request email to business department: " + email.getContent());
        } else if (nextHandler != null) {
            nextHandler.handleEmail(email);
        }
    }

    private boolean isNewMachineRequestEmail(Email email) {
        // 判断邮件是否是新机器请求邮件的逻辑
        // 这里只是一个示例，实际逻辑需要根据具体情况编写
        return email.getContent().contains("new machine request");
    }
}

// 定义Email类
public class Email {
    private String content;

    public Email(String content) {
        this.content = content;
    }

    public String getContent() {
        return content;
    }
}

// 客户端代码
public class Client {
    public static void main(String[] args) {
        // 创建邮件处理器
        EmailHandler spamHandler = new SpamHandler();
        EmailHandler fansHandler = new FansHandler();
        EmailHandler complaintHandler = new ComplaintHandler();
        EmailHandler newMachineRequestHandler = new NewMachineRequestHandler();

        // 构建责任链
        spamHandler.setNextHandler(fansHandler);
        fansHandler.setNextHandler(complaintHandler);
        complaintHandler.setNextHandler(newMachineRequestHandler);

        // 模拟收到不同类型的邮件并处理
        Email email1 = new Email("This is a fans email.");
        Email email2 = new Email("This is a complaint email.");
        Email email3 = new Email("This is a spam email.");
        Email email4 = new Email("This is a new machine request email.");

        spamHandler.handleEmail(email1);
        spamHandler.handleEmail(email2);
        spamHandler.handleEmail(email3);
        spamHandler.handleEmail(email4);
    }
}

【2】Python代码

# 定义邮件处理器基类
class EmailHandler:
    def __init__(self):
        self.next_handler = None

    def set_next_handler(self, handler):
        self.next_handler = handler

    def handle_email(self, email):
        pass

# 实现垃圾邮件处理器
class SpamHandler(EmailHandler):
    def handle_email(self, email):
        if "spam" in email.content:
            print("Deleted spam email: " + email.content)
        elif self.next_handler:
            self.next_handler.handle_email(email)

# 实现Fans邮件处理器
class FansHandler(EmailHandler):
    def handle_email(self, email):
        if "fans" in email.content:
            print("Forwarded fans email to CEO: " + email.content)
        elif self.next_handler:
            self.next_handler.handle_email(email)

# 实现抱怨邮件处理器
class ComplaintHandler(EmailHandler):
    def handle_email(self, email):
        if "complaint" in email.content:
            print("Forwarded complaint email to legal department: " + email.content)
        elif self.next_handler:
            self.next_handler.handle_email(email)

# 实现新机器请求邮件处理器
class NewMachineRequestHandler(EmailHandler):
    def handle_email(self, email):
        if "new machine request" in email.content:
            print("Forwarded new machine request email to business department: " + email.content)
        elif self.next_handler:
            self.next_handler.handle_email(email)

# 定义Email类
class Email:
    def __init__(self, content):
        self.content = content

# 客户端代码
if __name__ == "__main__":
    # 创建邮件处理器
    spam_handler = SpamHandler()
    fans_handler = FansHandler()
    complaint_handler = ComplaintHandler()
    new_machine_request_handler = NewMachineRequestHandler()

    # 构建责任链
    spam_handler.set_next_handler(fans_handler)
    fans_handler.set_next_handler(complaint_handler)
    complaint_handler.set_next_handler(new_machine_request_handler)

    # 模拟收到不同类型的邮件并处理
    email1 = Email("This is a fans email.")
    email2 = Email("This is a complaint email.")
    email3 = Email("This is a spam email.")
    email4 = Email("This is a new machine request email.")

    spam_handler.handle_email(email1)
    spam_handler.handle_email(email2)
    spam_handler.handle_email(email3)
    spam_handler.handle_email(email4)

【八】实战项目中的应用--实现用户购票责任链验证

【1】购票请求验证引入

• 在实际购票业务场景中，用户发起一次购票请求后，购票接口在真正完成创建订单和扣减余票行为前，需要验证当前请求中的参数是否正常请求，或者说是否满足购票情况。
• 购票请求用户传递的参数是否为空
  • 比如：车次 ID、乘车人、出发站点、到达站点等。
• 购票请求用户传递的参数是否正确
  • 比如：车次 ID 是否存在、出发和到达站点是否存在等。
• 需要购票的车次是否满足乘车人的数量
  • 也就是列车对应座位的余量是否充足。
• 乘客是否已购买当前车次，或者乘客是否已购买当天时间冲突的车次。
• ...

【2】思路引入

• java

public TicketPurchaseRespDTO purchaseTickets(PurchaseTicketReqDTO requestParam) {
	// 购票请求用户传递的参数是否为空
	// 购票请求用户传递的参数是否正确
	// 需要购票的车次是否满足乘车人的数量
	// 乘客是否已购买当前车次，或者乘客是否已购买当天时间冲突的车次
	// ......
}

• python

from typing import Dict, List


class TicketPurchaseRespDTO:
    def __init__(self, success: bool, message: str, data: Dict):
        self.success = success
        self.message = message
        self.data = data
        ...


class TicketPurchaseReqDTO:
    def __init__(self, user_id: int, train_id: int, passengers: List[int]):
        self.user_id = user_id
        self.train_id = train_id
        self.passengers = passengers
        ...


class TicketPurchaseService:
    def purchase_tickets(self, request_param: TicketPurchaseReqDTO) -> TicketPurchaseRespDTO:
        # 购票请求用户传递的参数是否为空
        # 购票请求用户传递的参数是否正确
        # 需要购票的车次是否满足乘车人的数量
        # 乘客是否已购买当前车次，或者乘客是否已购买当天时间冲突的车次
        # 其他购票逻辑处理
        # 检查车次容量是否足够
        # 检查购票冲突
        # ...
        ...


def main():
    purchase_service = TicketPurchaseService()
    request_param = TicketPurchaseReqDTO(user_id=1, train_id=123, passengers=[101, 102])
    response = purchase_service.purchase_tickets(request_param)
    print(f"Purchase Result: {response.success}, Message: {response.message}, Data: {response.data}")

【3】流程及问题

• 解决前置校验需求需要实现一堆逻辑，常常需要写上几百上千行代码。
• 并且，上面的代码不具备开闭原则，以及代码扩展性，整体来说复杂且臃肿。
• 为了避免这种坏代码味道，我们可以运用责任链设计模式，对购票验证逻辑进行抽象。

【4】责任链模式引入

（1）什么是责任链模式

• 在责任链模式中，多个处理器依次处理同一个请求。
• 一个请求先经过 A 处理器处理，然后再把请求传递给 B 处理器，B 处理器处理完后再传递给 C 处理器，以此类推，形成一个链条
• 链条上的每个处理器各自承担各自的处理职责。

（2）责任链模式优点

• 责任链模式的优点在于，它可以动态地添加、删除和调整处理者对象，从而灵活地构建处理链。
• 同时，它也避免了请求发送者和接收者之间的紧耦合，增强了系统的灵活性和可扩展性。

【5】责任链优化项目

（1）定义购票过滤接口

package org.opengoofy.index12306.biz.ticketservice.service.handler.ticket.filter.purchase;

import org.opengoofy.index12306.biz.ticketservice.common.enums.TicketChainMarkEnum;
import org.opengoofy.index12306.biz.ticketservice.dto.req.PurchaseTicketReqDTO;
import org.opengoofy.index12306.framework.starter.designpattern.chain.AbstractChainHandler;

/**
 * 列车购买车票过滤器
 */
public interface TrainPurchaseTicketChainFilter<T extends PurchaseTicketReqDTO> extends AbstractChainHandler<PurchaseTicketReqDTO> {

    @Override
    default String mark() {
        return TicketChainMarkEnum.TRAIN_PURCHASE_TICKET_FILTER.name();
    }
}

• 这段代码定义了一个购票过滤接口TrainPurchaseTicketChainFilter，它继承了AbstractChainHandler接口，并提供了默认实现方法mark()，用于返回责任链的标识。
• 这个接口将在不同的购票过滤器中实现。

（2）实现列车购买过滤器实现

/**
 * 购票流程过滤器之验证参数必填
 */
@Component
public class TrainPurchaseTicketParamNotNullChainHandler implements TrainPurchaseTicketChainFilter<PurchaseTicketReqDTO> {

    @Override
    public void handler(PurchaseTicketReqDTO requestParam) {
    	// ......
    }

    @Override
    public int getOrder() {
        return 0;
    }
}

/**
 * 购票流程过滤器之验证参数是否有效
 * 验证参数有效这个流程会大量交互缓存，为了优化性能需要使用 Lua。为了方便大家理解流程，这里使用多次调用缓存
 */
@Component
@RequiredArgsConstructor
public class TrainPurchaseTicketParamVerifyChainHandler implements TrainPurchaseTicketChainFilter<PurchaseTicketReqDTO> {

    private final TrainMapper trainMapper;
    private final TrainStationMapper trainStationMapper;
    private final DistributedCache distributedCache;

    @Override
    public void handler(PurchaseTicketReqDTO requestParam) {
        // ......
    }

    @Override
    public int getOrder() {
        return 10;
    }
}

/**
 * 购票流程过滤器之验证列车站点库存是否充足
 */
@Component
@RequiredArgsConstructor
public class TrainPurchaseTicketParamStockChainHandler implements TrainPurchaseTicketChainFilter<PurchaseTicketReqDTO> {

    private final SeatMarginCacheLoader seatMarginCacheLoader;
    private final DistributedCache distributedCache;

    @Override
    public void handler(PurchaseTicketReqDTO requestParam) {
        // ......
    }

    @Override
    public int getOrder() {
        return 20;
    }
}

/**
 * 购票流程过滤器之验证乘客是否重复购买
 */
@Component
@RequiredArgsConstructor
public class TrainPurchaseTicketRepeatChainHandler implements TrainPurchaseTicketChainFilter<PurchaseTicketReqDTO> {

    @Override
    public void handler(PurchaseTicketReqDTO requestParam) {
        // ......
    }

    @Override
    public int getOrder() {
        return 30;
    }
}

• 购票过滤器的实现包括了验证参数是否为空、验证参数是否有效、验证列车站点库存是否充足、验证乘客是否重复购买等。
• 每个过滤器实现了TrainPurchaseTicketChainFilter接口，并根据自身的业务逻辑实现了handler方法和getOrder方法。
• 这些过滤器会在责任链中按照getOrder方法返回的值排序执行。

（3）购票流程使用过滤器

private final AbstractChainContext<PurchaseTicketReqDTO> purchaseTicketAbstractChainContext;

@Override
@Transactional(rollbackFor = Throwable.class)
public TicketPurchaseRespDTO purchaseTickets(PurchaseTicketReqDTO requestParam) {
    // 责任链模式，验证 0：参数必填 1：参数正确性 2：列车车次余量是否充足 3：乘客是否已买当前车次等
    purchaseTicketAbstractChainContext.handler(TicketChainMarkEnum.TRAIN_PURCHASE_TICKET_FILTER.name(), requestParam);
	// ......
}

• 购票服务在实际调用时，使用了责任链模式来处理购票请求。
• 首先创建了一个TicketPurchaseService的实例，然后通过purchaseTicketAbstractChainContext调用责任链中的过滤器，传递购票请求参数，并按照责任链的执行顺序依次处理请求。

【6】购票责任链实现原理

（1）运行时获取责任链具体实现类

• 方法位置：org.opengoofy.index12306.biz.ticketservice.service.impl.TicketServiceImpl#purchaseTickets

private final Map<String, List<AbstractChainHandler>> abstractChainHandlerContainer = new HashMap<>();

/**
 * 责任链组件执行
 *
 * @param mark         责任链组件标识
 * @param requestParam 请求参数
 */
public void handler(String mark, T requestParam) {
    // 通过 mark 获取到本次需要执行的责任链组件
    List<AbstractChainHandler> abstractChainHandlers = abstractChainHandlerContainer.get(mark);
    // 获取为空抛出异常
    if (CollectionUtils.isEmpty(abstractChainHandlers)) {
        throw new RuntimeException(String.format("[%s] Chain of Responsibility ID is undefined.", mark));
    }
    // 获取到的责任链组件依次执行
    abstractChainHandlers.forEach(each -> each.handler(requestParam));
}

• 责任链模式的实现原理在AbstractChainContext类中，它实现了CommandLineRunner接口，表示在Spring Boot启动完成后执行的回调函数。

（2）初始化责任链容器

// CommandLineRunner：SpringBoot 启动完成后执行的回调函数
public final class AbstractChainContext<T> implements CommandLineRunner {

    // 存储责任链组件实现和责任链业务标识的容器
    // 比如：Key：购票验证过滤器 Val：HanlderA、HanlderB、HanlderC、......
    private final Map<String, List<AbstractChainHandler>> abstractChainHandlerContainer = new HashMap<>();

    @Override
    public void run(String... args) throws Exception {
        // 调用 SpirngIOC 工厂获取 AbstractChainHandler 接口类型的 Bean
        Map<String, AbstractChainHandler> chainFilterMap = ApplicationContextHolder
                .getBeansOfType(AbstractChainHandler.class);
        chainFilterMap.forEach((beanName, bean) -> {
            // 获取 mark（责任链业务标识）的处理器集合
            List<AbstractChainHandler> abstractChainHandlers = abstractChainHandlerContainer.get(bean.mark());
            // 如果不存在则创建一个集合
            if (CollectionUtils.isEmpty(abstractChainHandlers)) {
                abstractChainHandlers = new ArrayList();
            }
            // 添加到处理器集合中
            abstractChainHandlers.add(bean);
            // 对处理器集合执行顺序进行排序
            List<AbstractChainHandler> actualAbstractChainHandlers = abstractChainHandlers.stream()
                    .sorted(Comparator.comparing(Ordered::getOrder))
                    .collect(Collectors.toList());
            // 存入容器等待被运行时调用
            abstractChainHandlerContainer.put(bean.mark(), actualAbstractChainHandlers);
        });
    }
}

• 在run方法中，它通过Spring的IoC容器获取所有实现了AbstractChainHandler接口的Bean，然后根据它们的mark方法返回的责任链业务标识将它们分组存储在abstractChainHandlerContainer容器中。
• 这样，在运行时，可以根据具体的业务标识获取到对应的责任链处理器，并按照它们的getOrder方法返回的值排序执行。

【7】Python代码复写项目(伪代码)

from typing import List, Dict


# 定义购票响应DTO
class TicketPurchaseRespDTO:
    def __init__(self, success: bool, message: str, data: Dict):
        self.success = success
        self.message = message
        self.data = data


# 定义购票请求DTO
class TicketPurchaseReqDTO:
    def __init__(self, user_id: int, train_id: int, passengers: List[int]):
        self.user_id = user_id
        self.train_id = train_id
        self.passengers = passengers


# 定义购票过滤器接口
class TrainPurchaseTicketChainFilter:
    def mark(self):
        pass

    def handler(self, request_param: TicketPurchaseReqDTO):
        pass


# 实现列车购买过滤器 - 验证参数必填
class TrainPurchaseTicketParamNotNullChainHandler(TrainPurchaseTicketChainFilter):
    def mark(self):
        return "TRAIN_PURCHASE_TICKET_FILTER"

    def handler(self, request_param: TicketPurchaseReqDTO):
        # 验证参数是否为空
        if not request_param:
            return TicketPurchaseRespDTO(False, "参数为空", None)
        # 其他参数验证逻辑
        # ......

    def getOrder(self):
        return 0


# 实现列车购买过滤器 - 验证参数有效性
class TrainPurchaseTicketParamVerifyChainHandler(TrainPurchaseTicketChainFilter):
    def __init__(self, train_mapper, train_station_mapper, distributed_cache):
        self.train_mapper = train_mapper
        self.train_station_mapper = train_station_mapper
        self.distributed_cache = distributed_cache

    def mark(self):
        return "TRAIN_PURCHASE_TICKET_FILTER"

    def handler(self, request_param: TicketPurchaseReqDTO):
        # 验证参数有效性
        # 具体逻辑根据业务需求实现
        # ......
        ...

    def getOrder(self):
        return 10


# 实现列车购买过滤器 - 验证列车站点库存是否充足
class TrainPurchaseTicketParamStockChainHandler(TrainPurchaseTicketChainFilter):
    def __init__(self, seat_margin_cache_loader, distributed_cache):
        self.seat_margin_cache_loader = seat_margin_cache_loader
        self.distributed_cache = distributed_cache

    def mark(self):
        return "TRAIN_PURCHASE_TICKET_FILTER"

    def handler(self, request_param: TicketPurchaseReqDTO):
        # 验证列车站点库存是否充足
        # 具体逻辑根据业务需求实现
        # ......
        ...

    def getOrder(self):
        return 20


# 实现列车购买过滤器 - 验证乘客是否重复购买
class TrainPurchaseTicketRepeatChainHandler(TrainPurchaseTicketChainFilter):
    def mark(self):
        return "TRAIN_PURCHASE_TICKET_FILTER"

    def handler(self, request_param: TicketPurchaseReqDTO):
        # 验证乘客是否重复购买
        # 具体逻辑根据业务需求实现
        # ......
        ...

    def getOrder(self):
        return 30


# 责任链模式上下文
class AbstractChainContext:
    def __init__(self):
        self.handlers = []

    def add_handler(self, handler):
        self.handlers.append(handler)

    def handler(self, request_param: TicketPurchaseReqDTO):
        for handler in self.handlers:
            result = handler.handler(request_param)
            if not result.success:
                return result  # 停止处理链

def main():
    # 创建购票请求参数
    request_param = TicketPurchaseReqDTO(user_id=1, train_id=123, passengers=[101, 102])

    # 创建责任链上下文
    chain_context = AbstractChainContext()

    # 添加购票过滤器到责任链上下文
    chain_context.add_handler(TrainPurchaseTicketParamNotNullChainHandler())
    chain_context.add_handler(TrainPurchaseTicketParamVerifyChainHandler(train_mapper, train_station_mapper, distributed_cache))
    chain_context.add_handler(TrainPurchaseTicketParamStockChainHandler(seat_margin_cache_loader, distributed_cache))
    chain_context.add_handler(TrainPurchaseTicketRepeatChainHandler())

    # 开始责任链处理
    response = chain_context.handler(request_param)

    # 打印购票响应结果
    print(f"Purchase Result: {response.success}, Message: {response.message}, Data: {response.data}")


# 客户端代码示例
if __name__ == "__main__":
    main()

本栏目推荐文章
• FIFO设计
• spring与设计模式之三代理模式
• 深入理解spring框架：剖析多线程模式下数据库连接
• 代理模式（Proxy）
• 只有家庭教育和学校教育相辅相成，才能培养出健康、快乐、有责任心的下一代
• AntDesignBlazor示例——暗黑模式
• 单例模式（Singleton）的6种实现
• CS5569芯片,CS556,设计资料,CS5569规格书,CS5569原理图,typec转HDMI 8K带PD方案
• 设计模式之中介者模式
• freeswitch: esl inbound模式下外呼拨号

模式 设计模式 HeadFirst 责任模式 设计模式headfirst责任 模式 责任 模式 设计模式 责任 设计模式 模式 责任 设计模式 模式headfirst 模式 行为 责任 模式 设计模式 责任java 架构 源码 模式 责任 设计模式 语言 模式 责任 多个 模式 责任