基於二進制位的權限控制（數據庫裏的二進制）

declare @a BINARY(2)

set @a  = 32768

select @a

 

BINARY 字節  1B = 8位 bit

BINARY(2) = 16 位二進制數

換算16進制位4位

 

2進制數

最大值爲524287 轉換16進制OxFFFF (111111111111111)

最高位值32768，轉換16進制Ox8000 即兩個字節位(1000000000000000)

 

如需16位二進制數據，只需聲明BINARY（2） 便可。

 

使用時在代碼中轉換。

 

****************

 

１．一種實用的權限控制算法
這裏我介紹一種很經常使用，也比較Professor的權限控制思路。
這裏我用java語言描述，其實都差很少的。本身轉一下就能夠了。
爲了方便，咱們這裏定義a^b爲：a的b次方
這裏，咱們爲每個操做設定一個惟一的整數值，好比：

刪除Ａ－－－0
修改Ａ－－－1
添加Ａ－－－2

刪除Ｂ－－－3
修改Ｂ－－－4
添加Ｂ－－－5
。。。

理論上能夠有Ｎ個操做
這取決於你用於儲存用戶權限值的數據類型了。

這樣，若是用戶有權限：添加Ａ－－－2；刪除Ｂ－－－3；修改Ｂ－－－4
那用戶的權限值 purview =2^2+2^3+2^4＝28，也就是2的權的和了（以前打錯了）。
化成二進制能夠表示爲11100
這樣，若是要驗證用戶是否有刪除Ｂ的權限，就能夠經過位與運算來實現。
在Ｊａｖａ裏，位與運算運算符號爲＆
便是：int value = purview &((int)Math.pow(2,3));
　　你會發現，當用戶有操做權限時，運算出來的結果都會等於這個操做須要的權限值！
原理：
　　位與運算，顧名思義就是對位進行與運算：
以上面的式子爲例：purview & 2^3 也就是　28&8
將它們化成二進制有
　11100
   ＆  01000
-------------------
　 01000    ==   8(十進制)　＝＝　2^3
同理，若是要驗證是否有刪除Ａ－－－0的權限
能夠用：purview &((int)Math.pow(2,0));
即：
　11100
        ＆     00001
------------------------
　 00000   ==  0(十進制)　　！＝　2^0 

這種算法的一個優勢是速度快。能夠同時處理Ｎ個權限
若是想驗證是否同時有刪除Ａ－－－0和刪除Ｂ－－－3的權限
能夠用purview&(2^0+2^3)==(2^0+2^3)?true:false;
設置多角色用戶。根據權限值判斷用戶的角色。。。

下面提供一個java的單操做權限判斷的代碼：
//userPurview是用戶具備的總權限
//optPurview是一個操做要求的權限爲一個整數（沒有通過權的！）
public static boolean checkPower(int userPurview, int optPurview)
    {
        int purviewValue = (int)Math.pow(2, optPurview);
        return (userPurview & purviewValue) == purviewValue;
    }

固然，多權限的驗證只要擴展一下就能夠了。
幾點注意事項：首先，一個系統可能有不少的操做，所以，請創建數據字典，以便查閱，修改時使用。其次，若是用數據庫儲存用戶權限，請注意數值的有效範圍。操做權限值請用惟一的整數！

若有疑問，請提出！天寒地凍，本人最怕人潑冷水了，知道這裏高手如雲。不要取笑，謝謝！

以後，有空我會將個人一些開發經驗在本帖中提出，和你們一塊兒分享，研究一下。請你們支持

public class Test {

    // 將字符串轉換成二進制字符串，以空格相隔

    public String toBinary(String str) {

       char[] strChar = str.toCharArray();

       String result = "";

       for (int i = 0; i < strChar.length; i++) {

           result += Integer.toBinaryString(strChar[i]) + " ";

       }

       return result;

    }

    // 將二進制字符串轉換成Unicode字符串

    public String toStr(String binStr) {

       String[] tempStr = StrToStrArray(binStr);

       char[] tempChar = new char[tempStr.length];

       for (int i = 0; i < tempStr.length; i++) {

           tempChar[i] = toChar(tempStr[i]);

       }

       return String.valueOf(tempChar);

    }

    // 將二進制字符串轉換爲char

    private char toChar(String binStr) {

       int[] temp = binStrToIntArray(binStr);

       int sum = 0;

       for (int i = 0; i < temp.length; i++) {

           sum += temp[temp.length - 1 - i] << i;

       }

       return (char) sum;

    }

    // 將初始二進制字符串轉換成字符串數組，以空格相隔

    private String[] StrToStrArray(String str) {

       return str.split(" ");

    }

    // 將二進制字符串轉換成int數組

    private int[] binStrToIntArray(String binStr) {

       char[] temp = binStr.toCharArray();

       int[] result = new int[temp.length];

       for (int i = 0; i < temp.length; i++) {

           result[i] = temp[i] - 48;

       }

       return result;

    }

    public static void main(String[] args) {

       Test cTob = new Test();

       System.out.println(cTob.toBinary("橘子，好吃！aaa"));

       System.out.println();

       System.out.println(cTob.toBinary("999111"));

       System.out.println();

       System.out.println(cTob.toBinary("What a nice day!"));

       System.out.println();

       System.out.println(cTob.toBinary("^@^ - -! （）★"));

       System.out.println();

       System.out.println();

       System.out.println(cTob.toStr("110101001011000 101101101010000 "

              + "1111111100001100 101100101111101 "

              + "101010000000011 1111111100000001 "

              + "1100001 1100001 1100001 "));

       System.out.println(cTob.toStr("111001 111001 111001 "

              + "110001 110001 110001"));

       System.out.println(cTob.toStr("1010111 1101000 1100001 "

              + "1110100 100000 1100001 100000 1101110 "

              + "1101001 1100011 1100101 100000 1100100 "

              + "1100001 1111001 100001 "));

       System.out.println(cTob.toStr("1011110 1000000 1011110 "

              + "100000 101101 100000 101101 100001 100000 "

              + "1111111100001000 1111111100001001 10011000000101 "));

    }

}