android 责任链模式

责任链模式（Chain of Responsibility Pattern）是一种行为设计模式，它允许多个对象都有机会处理请求，从而避免请求的发送者和接收者之间的耦合。这种模式将这些对象连成一条链，并沿着这条链传递请求，直到有一个对象处理它为止。

在 Android 开发中，责任链模式非常有用，尤其是在处理事件传递、拦截器等方面。下面我们详细讲解它的概念以及如何在 Android 中使用责任链模式。

 

责任链模式的概念

责任链模式主要包含以下几个角色：

1. Handler（处理者）：定义一个处理请求的接口，并实现该接口。
2. ConcreteHandler（具体处理者）：具体的处理者，实现处理请求的逻辑。如果不能处理，则将请求传递给下一个处理者。
3. Client（客户端）：客户端创建具体的处理者对象，并组装成一条链，最终将请求传递给链的起始处理者。

Android 中的使用示例

以下是一个简单的责任链模式示例，在这个示例中，我们创建一个日志处理系统，不同级别的日志处理器（信息、警告、错误）将组成一个责任链，按顺序处理日志请求。

 步骤1：定义处理者接口

public abstract class Logger {
    public static int INFO = 1;
    public static int DEBUG = 2;
    public static int ERROR = 3;

    protected int level;

    // 责任链中的下一个元素
    protected Logger nextLogger;

    public void setNextLogger(Logger nextLogger) {
        this.nextLogger = nextLogger;
    }

    public void logMessage(int level, String message) {
        if (this.level <= level) {
            write(message);
        }
        if (nextLogger != null) {
            nextLogger.logMessage(level, message);
        }
    }

    protected abstract void write(String message);
}

 步骤2：创建具体的处理者

public class InfoLogger extends Logger {
    public InfoLogger(int level) {
        this.level = level;
    }

    @Override
    protected void write(String message) {
        System.out.println("INFO: " + message);
    }
}

public class DebugLogger extends Logger {
    public DebugLogger(int level) {
        this.level = level;
    }

    @Override
    protected void write(String message) {
        System.out.println("DEBUG: " + message);
    }
}

public class ErrorLogger extends Logger {
    public ErrorLogger(int level) {
        this.level = level;
    }

    @Override
    protected void write(String message) {
        System.out.println("ERROR: " + message);
    }
}

 步骤3：创建责任链

public class ChainPatternDemo {
    private static Logger getChainOfLoggers() {
        Logger errorLogger = new ErrorLogger(Logger.ERROR);
        Logger debugLogger = new DebugLogger(Logger.DEBUG);
        Logger infoLogger = new InfoLogger(Logger.INFO);

        infoLogger.setNextLogger(debugLogger);
        debugLogger.setNextLogger(errorLogger);

        return infoLogger;
    }

    public static void main(String[] args) {
        Logger loggerChain = getChainOfLoggers();

        loggerChain.logMessage(Logger.INFO, "This is an information.");
        loggerChain.logMessage(Logger.DEBUG, "This is a debug level information.");
        loggerChain.logMessage(Logger.ERROR, "This is an error information.");
    }
}

 

在 Android 中的实际应用

在 Android 中，责任链模式可以用于处理许多情况，例如：

1. 事件传递：View 的触摸事件传递（onTouchEvent、dispatchTouchEvent 和 onInterceptTouchEvent）。
2. 请求拦截：网络请求拦截器链（如 OkHttp 的 Interceptor）。
3. 日志处理：不同级别的日志记录处理。

示例：自定义事件分发

在 Android 中，我们可以使用责任链模式来自定义视图的事件分发机制：

public class CustomViewGroup extends ViewGroup {
    @Override
    public boolean dispatchTouchEvent(MotionEvent ev) {
        // 自定义事件分发逻辑
        boolean handled = super.dispatchTouchEvent(ev);
        if (!handled) {
            // 责任链模式传递给子视图
            for (int i = 0; i < getChildCount(); i++) {
                View child = getChildAt(i);
                if (child.dispatchTouchEvent(ev)) {
                    return true;
                }
            }
        }
        return handled;
    }

    @Override
    public boolean onInterceptTouchEvent(MotionEvent ev) {
        // 自定义事件拦截逻辑
        return super.onInterceptTouchEvent(ev);
    }

    @Override
    public boolean onTouchEvent(MotionEvent event) {
        // 自定义事件处理逻辑
        return super.onTouchEvent(event);
    }

    // 必须实现的 ViewGroup 抽象方法
    @Override
    protected void onLayout(boolean changed, int l, int t, int r, int b) {
        // 布局子视图
    }
}

总结

责任链模式通过将处理者链成一条链，使得请求在处理者之间传递，直到有一个处理者处理该请求。这种模式在 Android 开发中非常有用，特别是在处理事件传递、拦截器等场景。通过合理使用责任链模式，可以使代码更加模块化和可维护。