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

開篇

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

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

位運算

在 JAVA 語言中，定義了諸多的位運算符，如下所示：

&(與)

即：對應位都為 1 時，才為 1，否則全為 0，

|(或)

即：對應位只要有 1 時，即為 1，否則全為 0，

~(非)

即：對應位取反，

異或 ^

即：只要對應為不同即為 1，

使用位運算重構專案

當前我們需要設計一個權限模塊，可動態的為用戶指定某個檔案的操作權限，并且，用戶對一個檔案的操作權限分為：讀(R)，寫(W)，執行(X)，

這是一個很簡單的需求，為了描述這種關系，我們會在資料庫表關系設計時，定義如下的結構：

資料表：user_file_permission

映射的模型：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？聰明的你，肯定想到了——二進制，

所以借由這個思想，我們對代碼進行重構，去掉了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 的可選項如下表格所示：

同時，操作權限不是一塵不變的，我們往往需要對其新增、洗掉、查詢，通過位運算，可以非常方便實作，

為當前權限新增一個操作：

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

小結

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

標籤：設計模式

上一篇：圖解Java設計模式之裝飾者模式

下一篇：【遠程醫療】互聯網醫院 衛健委資料上報平臺技術方案