手搓责任链框架 2：核心接口设计

核心接口设计

概述

在责任链框架的设计中，核心接口的设计至关重要。一个好的接口设计应该具备清晰的职责划分、良好的扩展性和易用性。本章将详细介绍责任链框架的核心接口设计。

整体架构

核心接口定义

1. Handler 接口

Handler 是责任链中最核心的接口，定义了处理者的基本行为。

/**
 * 责任链处理者接口
 * 定义了处理者的基本行为规范
 */
public interface Handler {
    
    /**
     * 处理请求的核心方法
     * @param context 处理上下文，包含请求和响应信息
     * @return true表示继续传递给下一个处理者，false表示中断链式调用
     */
    boolean handle(Context context);
    
    /**
     * 设置下一个处理者
     * @param handler 下一个处理者
     */
    void setNext(Handler handler);
    
    /**
     * 获取下一个处理者
     * @return 下一个处理者，如果没有则返回null
     */
    Handler getNext();
}

设计要点：

• 简洁性：接口方法尽可能少，职责单一
• 返回值语义：boolean 返回值明确表示是否继续传递
• 链式结构：通过 setNext 和 getNext 方法维护链式关系

2. Context 上下文接口

Context 负责在处理者之间传递数据，是责任链中的数据载体。

/**
 * 责任链上下文接口
 * 负责在处理者之间传递数据
 * @param <T> 请求类型
 * @param <R> 响应类型
 */
public interface Context<T, R> {
    
    /**
     * 获取请求对象
     * @return 请求对象
     */
    T getRequest();
    
    /**
     * 获取响应对象
     * @return 响应对象
     */
    R getResponse();
    
    /**
     * 设置响应对象
     * @param response 响应对象
     */
    void setResponse(R response);
    
    /**
     * 获取属性值
     * @param key 属性键
     * @return 属性值
     */
    Object getAttribute(String key);
    
    /**
     * 设置属性值
     * @param key 属性键
     * @param value 属性值
     */
    void setAttribute(String key, Object value);
    
    /**
     * 移除属性
     * @param key 属性键
     * @return 被移除的属性值
     */
    Object removeAttribute(String key);
    
    /**
     * 获取所有属性键
     * @return 属性键集合
     */
    Set<String> getAttributeKeys();
    
    /**
     * 类型安全的属性获取方法
     * @param key 属性键
     * @param type 属性值类型
     * @param <V> 泛型类型
     * @return 指定类型的属性值
     */
    <V> V getAttribute(String key, Class<V> type);
}

设计要点：

• 泛型支持：支持类型安全的请求和响应对象
• 属性机制：提供灵活的属性存储机制，便于处理者间数据传递
• 类型安全：提供类型安全的属性获取方法

抽象基类实现

AbstractHandler 抽象类

为了简化具体处理者的实现，我们提供一个抽象基类：

/**
 * 抽象处理者基类
 * 提供了责任链的基本实现和生命周期钩子方法
 * @param <T> 请求类型
 * @param <R> 响应类型
 */
public abstract class AbstractHandler<T, R> implements Handler {
    
    private Handler nextHandler;
    private static final Logger logger = LoggerFactory.getLogger(AbstractHandler.class);
    
    @Override
    public void setNext(Handler handler) {
        this.nextHandler = handler;
    }
    
    @Override
    public Handler getNext() {
        return nextHandler;
    }
    
    @Override
    public final boolean handle(Context context) {
        try {
            // 前置处理
            onBefore(context);
            
            // 检查是否应该跳过当前处理者
            if (shouldSkip(context)) {
                logger.debug("Handler {} skipped", this.getClass().getSimpleName());
                return invokeNext(context);
            }
            
            // 执行具体的处理逻辑
            boolean continueChain = doHandle(context);
            
            // 后置处理
            onAfter(context);
            
            // 根据处理结果决定是否继续传递
            if (continueChain) {
                return invokeNext(context);
            } else {
                logger.debug("Chain stopped at handler {}", this.getClass().getSimpleName());
                return false;
            }
            
        } catch (Exception e) {
            logger.error("Error in handler {}", this.getClass().getSimpleName(), e);
            onError(context, e);
            throw new ChainExecutionException("Handler execution failed", e);
        }
    }
    
    /**
     * 具体的处理逻辑，由子类实现
     * @param context 处理上下文
     * @return true表示继续传递，false表示中断链式调用
     */
    protected abstract boolean doHandle(Context<T, R> context);
    
    /**
     * 判断是否应该跳过当前处理者
     * @param context 处理上下文
     * @return true表示跳过，false表示不跳过
     */
    protected boolean shouldSkip(Context<T, R> context) {
        return false;
    }
    
    /**
     * 前置处理钩子方法
     * @param context 处理上下文
     */
    protected void onBefore(Context<T, R> context) {
        // 默认空实现
    }
    
    /**
     * 后置处理钩子方法
     * @param context 处理上下文
     */
    protected void onAfter(Context<T, R> context) {
        // 默认空实现
    }
    
    /**
     * 异常处理钩子方法
     * @param context 处理上下文
     * @param e 异常信息
     */
    protected void onError(Context<T, R> context, Exception e) {
        // 默认空实现，子类可以重写进行自定义异常处理
    }
    
    /**
     * 调用下一个处理者
     * @param context 处理上下文
     * @return 下一个处理者的处理结果
     */
    private boolean invokeNext(Context context) {
        if (nextHandler != null) {
            return nextHandler.handle(context);
        }
        return true; // 链的末尾，默认返回true
    }
}

设计要点：

• 模板方法模式：handle 方法定义了处理的标准流程
• 生命周期钩子：提供前置、后置、异常处理等钩子方法
• 跳过机制：支持条件性跳过某个处理者
• 异常处理：统一的异常处理机制

上下文实现

DefaultContext 默认实现

/**
 * 默认的上下文实现
 * @param <T> 请求类型
 * @param <R> 响应类型
 */
public class DefaultContext<T, R> implements Context<T, R> {
    
    private final T request;
    private R response;
    private final Map<String, Object> attributes;
    
    public DefaultContext(T request) {
        this.request = request;
        this.attributes = new ConcurrentHashMap<>();
    }
    
    public DefaultContext(T request, R response) {
        this.request = request;
        this.response = response;
        this.attributes = new ConcurrentHashMap<>();
    }
    
    @Override
    public T getRequest() {
        return request;
    }
    
    @Override
    public R getResponse() {
        return response;
    }
    
    @Override
    public void setResponse(R response) {
        this.response = response;
    }
    
    @Override
    public Object getAttribute(String key) {
        return attributes.get(key);
    }
    
    @Override
    public void setAttribute(String key, Object value) {
        if (value == null) {
            attributes.remove(key);
        } else {
            attributes.put(key, value);
        }
    }
    
    @Override
    public Object removeAttribute(String key) {
        return attributes.remove(key);
    }
    
    @Override
    public Set<String> getAttributeKeys() {
        return new HashSet<>(attributes.keySet());
    }
    
    @Override
    @SuppressWarnings("unchecked")
    public <V> V getAttribute(String key, Class<V> type) {
        Object value = getAttribute(key);
        if (value == null) {
            return null;
        }
        if (type.isInstance(value)) {
            return (V) value;
        }
        throw new ClassCastException(
            String.format("Attribute '%s' is not of type %s", key, type.getName())
        );
    }
    
    @Override
    public String toString() {
        return String.format("DefaultContext{request=%s, response=%s, attributes=%s}", 
                           request, response, attributes);
    }
}

异常定义

ChainExecutionException

/**
 * 责任链执行异常
 */
public class ChainExecutionException extends RuntimeException {
    
    public ChainExecutionException(String message) {
        super(message);
    }
    
    public ChainExecutionException(String message, Throwable cause) {
        super(message, cause);
    }
    
    public ChainExecutionException(Throwable cause) {
        super(cause);
    }
}

链式调用方法签名

ChainBuilder 接口

/**
 * 责任链构建器接口
 * 提供流式API来构建责任链
 */
public interface ChainBuilder {
    
    /**
     * 添加处理者到链的末尾
     * @param handler 处理者
     * @return 构建器实例，支持链式调用
     */
    ChainBuilder addHandler(Handler handler);
    
    /**
     * 在指定位置插入处理者
     * @param index 插入位置
     * @param handler 处理者
     * @return 构建器实例，支持链式调用
     */
    ChainBuilder insertHandler(int index, Handler handler);
    
    /**
     * 移除指定的处理者
     * @param handler 要移除的处理者
     * @return 构建器实例，支持链式调用
     */
    ChainBuilder removeHandler(Handler handler);
    
    /**
     * 移除指定位置的处理者
     * @param index 要移除的位置
     * @return 构建器实例，支持链式调用
     */
    ChainBuilder removeHandler(int index);
    
    /**
     * 清空所有处理者
     * @return 构建器实例，支持链式调用
     */
    ChainBuilder clear();
    
    /**
     * 构建责任链
     * @return 责任链的头节点
     */
    Handler build();
    
    /**
     * 获取当前链中的处理者数量
     * @return 处理者数量
     */
    int size();
    
    /**
     * 判断链是否为空
     * @return true表示为空，false表示不为空
     */
    boolean isEmpty();
}

使用示例

基本使用

// 创建具体的处理者
Handler authHandler = new AuthenticationHandler();
Handler validationHandler = new ValidationHandler();
Handler businessHandler = new BusinessHandler();

// 手动构建链
authHandler.setNext(validationHandler);
validationHandler.setNext(businessHandler);

// 创建上下文
Context<UserRequest, UserResponse> context = 
    new DefaultContext<>(new UserRequest("user123"));

// 执行责任链
boolean result = authHandler.handle(context);

// 获取处理结果
UserResponse response = context.getResponse();

使用构建器

// 使用构建器创建链
Handler chain = new DefaultChainBuilder()
    .addHandler(new AuthenticationHandler())
    .addHandler(new ValidationHandler())
    .addHandler(new BusinessHandler())
    .build();

// 执行链
Context<UserRequest, UserResponse> context = 
    new DefaultContext<>(new UserRequest("user123"));
boolean result = chain.handle(context);

设计原则总结

1. 单一职责原则

• 每个接口都有明确的职责
• Handler 负责处理逻辑
• Context 负责数据传递
• ChainBuilder 负责链的构建

2. 开闭原则

• 接口对扩展开放，对修改关闭
• 可以轻松添加新的处理者类型
• 可以扩展上下文的功能

3. 依赖倒置原则

• 依赖抽象而不是具体实现
• 使用接口定义契约
• 便于测试和模拟

4. 接口隔离原则

• 接口尽可能小而专一
• 避免臃肿的接口设计
• 客户端不应该依赖它不需要的接口

总结

良好的核心接口设计是责任链框架成功的基础。通过清晰的职责划分、合理的抽象层次和灵活的扩展机制，我们可以构建出既强大又易用的责任链框架。

在下一章中，我们将详细介绍如何基于这些核心接口实现具体的处理器。