编程思想：巧用位运算重构代码

开篇

在一门编程语言中，往往会提供大量的运算符。按功能来分的话，有算术运算符、赋值运算符、关系运算符、逻辑运算符、位运算符等。这些对于大家来说都不陌生。但是，本期的主角『位运算』符相对而言是比较少去使用的。因为位运算符主要针对两个二进制数进行位运算。

巧用位运算能极大的精简代码和提高程序效率。所以，在一些优秀的开源代码中，经常能出现位运算。所以，把位运算这种思想迁移到业务代码里，有时候往往能起到柳暗花明般的重构。

位运算

在 JAVA 语言中，定义了诸多的位运算符，如下所示：

运算符	描述
&	与
|	或
~	非
^	异或
<<	左移
>>	右移

&(与)

十进制	二进制
3	0 0 1 1
5	0 1 0 1
& 后结果：1	0 0 0 1

即：对应位都为 1 时，才为 1，否则全为 0。

|(或)

十进制	二进制
3	0 0 1 1
5	0 1 0 1
| 后结果 ：7	0 1 1 1

即：对应位只要有 1 时，即为 1，否则全为 0。

~(非)

十进制	二进制
3	0 0 1 1
~ 后结果：12	1 1 0 0

即：对应位取反。

异或 ^

十进制	二进制
3	0 0 1 1
5	0 1 0 1
^ 后结果：6	0 1 1 0

即：只要对应为不同即为 1。

使用位运算重构项目

当前我们需要设计一个权限模块，可动态的为用户指定某个文件的操作权限。并且，用户对一个文件的操作权限分为：读(R)，写(W)，执行(X)。

这是一个很简单的需求，为了描述这种关系，我们会在数据库表关系设计时，定义如下的结构：

数据表：user_file_permission

字段	类型	备注
userId	int	用户
fileId	int	文件
readable	bit	是否可读
writable	bit	是否可写
executable	bit	是否可执行

映射的模型：UserFilePermission

public class UserFilePermission {
    /**
     * 用户
     */
    private User user;

    /**
     * 文件
     */
    private File file;

    /**
     * 读操作
     */
    private Boolean readable;
    /**
     * 写操作
     */
    private Boolean writable;
    /**
     * 执行操作
     */
    private Boolean executable;
}

这是常见的实现方式。但考虑下，业务需求千变万化，倘若需要再新增一个下载(D) 操作，是不是需要去额外扩展一个字段。所以，对于长期来讲，有值得重构的空间。

故缺点很明显：

• 难扩展
• 繁琐，比如判断是否包含读和执行的操作权限，需要这样写if(xx.IsReadable() && xx.IsExecutable())，但随着权限操作越来越多时，if代码块也越来越大。

位运算重构

了解 Linux 的同学一定知道利用 chmod 来控制文件如何被他人调用。比如针对一个文件，可分别给 User、Group、Other 设置访问的权限。同时权限操作分为：r(读)，w(写)，x(执行)。很巧，和我们的需求一样。那我们来看下Linux 是如何实现权限控制的。

核心是定义一个整数来代表操作权限，即：r=4，w=2，x=1

• 若要 rwx 权限，则：4+2+1=7；
• 若要 rw- 权限，则：4+2=6；
• 若要 r-x 权限，则：4+1=5。

所以使用 chmod 也可以用数字来表示权限，如下即给 User、Group、Other 三个维度的对象都设置了代表可读、可写、可执行的权限，代号：7。

chmod 777 file

你可能会想，为什么 r=4，w=2，x=1？聪明的你，肯定想到了——二进制。

权限操作	二进制	十进制
r	0100	4
w	0010	2
x	0001	1

所以借由这个思想，我们对代码进行重构，去掉了readable，writable，executable 这三个字段，而统一由一个 permissoin 字段来表示，如下所示：

public class UserFilePermission {

    /**
     * 可执行(x)：0001
     */
    public static final int OP_EXECUTABLE = 1;

    /**
     * 可写(w)：左移一位：0010
     */
    public static final int OP_WRITABLE = 1 << 1;

    /**
     * 可读(r)：左移二位：0100
     */
    public static final int OP_READABLE = 1 << 2;

    /**
     * 用户
     */
    private User user;
    /**
     * 文件
     */
    private File file;

    /**
     * 权限
     */
    private int permission;
}

其中 permission 的可选项如下表格所示：

permission	r	w	x	描述
1(0001)	0	0	1	可执行
2(0010)	0	1	0	可写
4(0100)	1	0	0	可读
3(0011)	0	1	1	可写、可执行
7(0111)	1	1	1	可读、可写、可执行
0(0000)	0	0	0	禁止

同时，操作权限不是一尘不变的，我们往往需要对其新增、删除、查询。通过位运算，可以非常方便实现。

为当前权限新增一个操作：

public void addOp(int op) {
    permission |= op;
}

为当前权限删除一个操作：

public void removeOp(int op) {
    permission &= ~op;
}

判断当前权限是否包含指定的操作权限：

public boolean containsOp(int op) {
    return (permission & op) == op;
}

判断当前权限是否不包含指定的操作权限：

public boolean notContainsOp(int op) {
    return (permission & op) == 0;
}

当然，这样的重构唯一的缺点就是可读性变差。当然，如果团队对位运算达成共识之后，大家都有一定的了解。相反，可读性还是可以的。同时，位运算的计算非常快，也在一定程度上提升了执行效率。

位运算在 Netty 中的体现

我们可以在诸多优秀的开源代码看到位运算的身影。比如 JDK 中有非常多的案例。在此，抛砖引玉，谈谈在 Netty 的体现。

Netty 的内部提供了 Skip 的注解，用来表明一个 ChannelHandler 的某个方法不需要被执行，即跳过。我们来看下Netty 是如何实现的。

final class ChannelHandlerMask {

    // Using to mask which methods must be called for a ChannelHandler.
    static final int MASK_EXCEPTION_CAUGHT = 1;
    static final int MASK_CHANNEL_REGISTERED = 1 << 1;
    static final int MASK_CHANNEL_UNREGISTERED = 1 << 2;
    static final int MASK_CHANNEL_ACTIVE = 1 << 3;
    static final int MASK_CHANNEL_INACTIVE = 1 << 4;
    static final int MASK_CHANNEL_READ = 1 << 5;
    static final int MASK_CHANNEL_READ_COMPLETE = 1 << 6;
    static final int MASK_USER_EVENT_TRIGGERED = 1 << 7;
    static final int MASK_CHANNEL_WRITABILITY_CHANGED = 1 << 8;
    static final int MASK_BIND = 1 << 9;
    static final int MASK_CONNECT = 1 << 10;
    static final int MASK_DISCONNECT = 1 << 11;
    static final int MASK_CLOSE = 1 << 12;
    static final int MASK_DEREGISTER = 1 << 13;
    static final int MASK_READ = 1 << 14;
    static final int MASK_WRITE = 1 << 15;
    static final int MASK_FLUSH = 1 << 16;

    private static final int MASK_ALL_INBOUND = MASK_EXCEPTION_CAUGHT | MASK_CHANNEL_REGISTERED |
            MASK_CHANNEL_UNREGISTERED | MASK_CHANNEL_ACTIVE | MASK_CHANNEL_INACTIVE | MASK_CHANNEL_READ |
            MASK_CHANNEL_READ_COMPLETE | MASK_USER_EVENT_TRIGGERED | MASK_CHANNEL_WRITABILITY_CHANGED;
    private static final int MASK_ALL_OUTBOUND = MASK_EXCEPTION_CAUGHT | MASK_BIND | MASK_CONNECT | MASK_DISCONNECT |
            MASK_CLOSE | MASK_DEREGISTER | MASK_READ | MASK_WRITE | MASK_FLUSH;

    /**
     * Calculate the {@code executionMask}.
     */
    private static int mask0(Class<? extends ChannelHandler> handlerType) {
        int mask = MASK_EXCEPTION_CAUGHT;
        try {
            if (ChannelInboundHandler.class.isAssignableFrom(handlerType)) {
                mask |= MASK_ALL_INBOUND;

                if (isSkippable(handlerType, "channelRegistered", ChannelHandlerContext.class)) {
                    mask &= ~MASK_CHANNEL_REGISTERED;
                }
                if (isSkippable(handlerType, "channelUnregistered", ChannelHandlerContext.class)) {
                    mask &= ~MASK_CHANNEL_UNREGISTERED;
                }
                if (isSkippable(handlerType, "channelActive", ChannelHandlerContext.class)) {
                    mask &= ~MASK_CHANNEL_ACTIVE;
                }
                if (isSkippable(handlerType, "channelInactive", ChannelHandlerContext.class)) {
                    mask &= ~MASK_CHANNEL_INACTIVE;
                }
                if (isSkippable(handlerType, "channelRead", ChannelHandlerContext.class, Object.class)) {
                    mask &= ~MASK_CHANNEL_READ;
                }
                if (isSkippable(handlerType, "channelReadComplete", ChannelHandlerContext.class)) {
                    mask &= ~MASK_CHANNEL_READ_COMPLETE;
                }
                if (isSkippable(handlerType, "channelWritabilityChanged", ChannelHandlerContext.class)) {
                    mask &= ~MASK_CHANNEL_WRITABILITY_CHANGED;
                }
                if (isSkippable(handlerType, "userEventTriggered", ChannelHandlerContext.class, Object.class)) {
                    mask &= ~MASK_USER_EVENT_TRIGGERED;
                }
            }
           ...

            if (isSkippable(handlerType, "exceptionCaught", ChannelHandlerContext.class, Throwable.class)) {
                mask &= ~MASK_EXCEPTION_CAUGHT;
            }
        } catch (Exception e) {
            // Should never reach here.
            PlatformDependent.throwException(e);
        }

        return mask;
    }
}

上述代码将主干代码剥离出后，其实核心逻辑很简单：

// 添加了所有
mask |= MASK_ALL_INBOUND;
// 如果该 Handler 的 xx 方法标注了 @Skip 注解，则将他剔除
if (isSkippable(handlerType, "xx", ChannelHandlerContext.class)) {
    mask &= ~xx;
}

因为 Netty 的 pipeline 是个职责链，它需要判断当前的 method是否被允许执行。使用 (ctx.executionMask & mask) == 0 来表示当前是否被禁止调用。如果是的话，则忽略，继续迭代，直到找到允许被调用的 handler。 如下所示：

private AbstractChannelHandlerContext findContextInbound(int mask) {
    AbstractChannelHandlerContext ctx = this;
    do {
        ctx = ctx.next;
    } while ((ctx.executionMask & mask) == 0);
    return ctx;
}

小结

本文为大家展示了如何使用二进制以及位运算来重构代码。显而易见，代码量及其精简。同时这种思想也大量出现在开源代码中，值得学习。