編程思想：巧用位運算重構代碼

開篇在一門編程語言中，往往會提供大量的運算符。按功能來分的話，有算術運算符、賦值運算符、關係運算符、邏輯運算符、位運算符等。這些對於大家來說都不陌生。但是，本期的主角『位運算』符相對而言是比較少去使用的。因為位運算符主要針對兩個二進位數進行位運算。巧用位運算能極大的精簡代碼和提高程式效率。所以， ...

開篇

在一門編程語言中，往往會提供大量的運算符。按功能來分的話，有算術運算符、賦值運算符、關係運算符、邏輯運算符、位運算符等。這些對於大家來說都不陌生。但是，本期的主角『位運算』符相對而言是比較少去使用的。因為位運算符主要針對兩個二進位數進行位運算。

巧用位運算能極大的精簡代碼和提高程式效率。所以，在一些優秀的開源代碼中，經常能出現位運算。所以，把位運算這種思想遷移到業務代碼里，有時候往往能起到柳暗花明般的重構。

位運算

在 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;
}

小結

本文為大家展示瞭如何使用二進位以及位運算來重構代碼。顯而易見，代碼量及其精簡。同時這種思想也大量出現在開源代碼中，值得學習。