Android使用责任链模式处理二维码扫描结果

众所周知，二维码的扫描结果其实就是一个字符串，我们拿到一个结果需要对内容进行校验，是否是我们需要的信息，然后做一些特殊的处理。比如先判断是不是一个url链接，是则打开这个链接，不是的话进行下一种判断，比如是否是项目中的约定的跳转某个功能的信息…依次下去。

普通的做法是使用if-else或者switch-case，但是当有很多种情况需要处理，则会出现很多的if-else，并且每增加一种处理，就需要改动代码新增一个else，一点也不优雅。

这种情况其实可以使用责任链的模式来处理。

先来了解下责任链模式，以下摘自《Android源码设计模式解析与实战》

责任链模式

责任链模式是一个行为模式。责任链就是从一个起点发起请求，然后沿着任务链依次传递给每一个节点上的对象，直到有一个节点处理这个请求为止。

责任链模式的UML图

Handler：抽象处理者角色，声明一个处理请求的方法，并保持对下一个处理节点Handler对象的引用。
ConcreteHandler: 具体的处理者，对请求进行处理，如果不处理就讲请求转发给下一个节点上的处理对象。

抽象处理者：

public abstract class Handler {
    protected Handler successor;
    public abstract void handleRequest(String condition);
}

实际处理者

public class ConcreteHandler1 extends Handler {
    @Override
    public void handleRequest(String condition) {
        if ("ConcreteHandler1".equals(condition)){
            System.out.println("ConcreteHandler1 handled");
            return;
        }else {
            successor.handleRequest(condition);
        }
    }
}

public class ConcreteHandler2 extends Handler {
    @Override
    public void handleRequest(String condition) {
        if ("ConcreteHandler2".equals(condition)) {
            System.out.println("ConcreteHandler2 handled");
            return;
        } else {
            successor.handleRequest(condition);
        }
    }
}

客户端调用,组成一条责任链

public class Client {
    public static void main(String[] args) {
        ConcreteHandler1 concreteHandler1 = new ConcreteHandler1();
        ConcreteHandler2 concreteHandler2 = new ConcreteHandler2();
        concreteHandler1.successor = concreteHandler2;
        concreteHandler2.successor = concreteHandler1;
        concreteHandler1.handleRequest("ConcreteHandler2");
    }
}

应用到处理二维码结果中

我们首先定义一个抽象类，封装一下通用逻辑

import android.content.Context;

/**
 * Created by hubert on 2018/2/2.
 */
public abstract class QRHandler {
    public QRHandler next;
    Context context;

    public QRHandler(Context context) {
        this(context, null);
    }

    public QRHandler(Context context, QRHandler next) {
        this.next = next;
        this.context = context;
    }

    /**
     * 对外暴露的调用方法
     * @param msg
     */
    public final void handleRequest(String msg) {
        if (canHandle(msg)) {
            handle(msg);
        } else {
            passToNext(msg);
        }
    }

    protected void passToNext(String msg) {
        if (next != null) {
            next.handleRequest(msg);
        } else {
            onNotHandled(msg);
        }
    }

    protected void onNotHandled(String msg) {
        //当无法处理结果，且没有下一个处理者时
    }

    /**
     * 处理的实现
     * @param msg
     */
    protected abstract void handle(String msg);

    /**
     * 是否能够处理这个msg
     * @param msg 
     * @return true or false
     */
    protected abstract boolean canHandle(String msg);
}

即调用handleRequest后，先通过canHandle判断需要处理这个信息,是的话则调用handle(String msg)自己处理，否的话交给下一个Handler处理，没有下一个则调用onNotHandled(String msg)触发兜底逻辑。

其次根据需要，实现对应的处理者，如匹配链接跳转页面

import android.content.Context;
import android.content.Intent;
import android.net.Uri;

import com.asiainfo.banbanapp.rxtools.RxRegTool;

/**
 * Created by hubert on 2018/2/2.
 */

public class URLHandler extends QRHandler {
    public URLHandler(Context context) {
        super(context);
    }

    public URLHandler(Context context, QRHandler next) {
        super(context, next);
    }

    @Override
    protected void handle(String msg) {
        Intent intent = new Intent();
        intent.setAction(Intent.ACTION_VIEW);
        Uri content_url = Uri.parse(msg);
        intent.setData(content_url);
        context.startActivity(intent);
    }

    @Override
    protected boolean canHandle(String msg) {
        return RxRegTool.isURL(msg);
    }
}

最后将处理者连接成链，调用链头的Handler开始处理

public interface QRParser {
    void parser(String msg);
}

import android.content.Context;

/**
 * Created by hubert on 2018/2/2.
 */

public class QRParserImpl implements QRParser {

    private QRHandler start;

    private QRParserImpl(Context context) {
        //倒叙处理顺序
        ...
        URLHandler urlHandler = new URLHandler(context, lockerHandler);
        InvoiceHandler invoiceHandler = new InvoiceHandler(context, urlHandler);
        PrintHandler printHandler = new PrintHandler(context, invoiceHandler);
        start = new Base64Handler(context, printHandler);

    }

    public static QRParserImpl getInstance(Context context) {
        return new QRParserImpl(context);
    }

    @Override
    public void parser(String msg) {
        start.handleRequest(msg);
    }
}

使用这种方式降低耦合度，便于拓展，提高代码灵活性。
之后如果新增加一种处理，只需要在增加对应的实现类，并添加到责任链中即可。对于处理优先级也可以通过改变责任链的顺序实现。任何改变都只需要变动责任链的初始化过程。