開篇
在一門編程語言中，往往會提供大量的運算符。按功能來分的話，有算術運算符、賦值運算符、關系運算符、邏輯運算符、位運算符等。這些對於大家來說都不陌生。但是，本期的主角『位運算』符相對而言是比較少去使用的。因為位運算符主要針對兩個二進制數進行位運算。
巧用位運算能極大的精簡代碼和提高程序效率。所以，在一些優秀的開源代碼中，經常能出現位運算。所以，把位運算這種思想遷移到業務代碼里，有時候往往能起到柳暗花明般的重構。
位運算
在 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;
}
小結
本文為大家展示了如何使用二進制以及位運算來重構代碼。顯而易見，代碼量及其精簡。同時這種思想也大量出現在開源代碼中，值得學習。