js 關於apply和call的理解使用

admin

　　關於call和apply，以前也思考良久，很多時候都以為記住了，但是，我太難了。今天我特地寫下筆記，希望可以完全掌握這個東西，也希望可以幫助到任何想對學習這個東西的同學。

一.apply函數定義與理解，先從apply函數出發

　　在MDN上，apply的定義是：

　　　　“apply()方法調用一個具有給定this值的函數，以及作為一個數組（或）提供的參數。”

　　我的理解是：apply的前面有個含有this的對象，設為A，apply()的參數里，也含有一個含有this的對象設為B。則A.apply(B)，表示A代碼執行調用了B，B代碼照常執行，執行后的結果作為apply的參數，然後apply把這個結果所指代表示的this替換掉A本身的this，接着執行A代碼。

　　比如：

 1     var aa = {
 2         _name:111,
 3         _age:222,
 4         _f:function(){
 5             console.log(this)
 6             console.log(this._name)
 7         }
 8     }
 9     var cc = {
10         _name:0,
11         _age:0,
12         _f:function(){
13             console.log(this)
14             console.log(this._name)
15         }
16     }
17     cc._f.apply(aa)//此時aa表示的this就是aa本身
18     cc._f.apply(aa._f)//此時aa._f表示的this就是aa._f本身
19     
20     /**
21      * 此時aa._f()表示的this，就是執行后的結果本身。aa._f()執行后，沒有返回值，所以應該是undefined，而undefined作為call和apply的參數時，call和apply前面的方法 cc._f 的this會替換成全局對象window。
22      * 參考MDN：https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Function/apply 的參數說明
23      */
24     cc._f.apply(aa._f())

執行結果：

　　1.參數為aa

　　

　　這兩行的打印的都是來自 cc._f 方法內的那兩句console 。aa的時候算是初始化，裏面的 aa._f 方法沒有執行。

　　2.參數為aa.f

　　

　　這兩行的打印的都是來自 cc._f 方法內的那兩句console 。aa.f 的時候應該也算是初始化，或者是整個函數當參數傳但是不執行這個參數，即 aa._f 方法沒有執行。

　　3.參數為aa.f()

 　　

　　這四行的打印，前面兩行來自 aa._f() 方法執行打印的；後面兩行是來自cc._f()方法打印的。

　　后兩行解析：aa._f()執行后，沒有返回值，所以是undefined，在apply執行解析后，cc._f()的this變成的window，所以打印了window。window裏面沒有_name這個屬性，所以undefined。

 二.apply與call的區分

　　1.apply()

　　　　A.apply(B, [1,2,3]) 後面的參數是arguments對象或類似數組的對象，它會被自動解析為A的參數；

　　　　對於A.apply(B) / A.call(B) , 簡單講，B先執行，執行后根據結果去執行A。這個時候，用A去執行B的內容代碼，然後再執行自己的代碼。

　　比如：

    var f1 = function(a,b){
        console.log(a+b)
    }
    var f2 = function(a,b,c){
        console.log(a,b,c)
    }
    f2.apply(f1,[1,2])//1 2 undefined

 　　先執行f1，f1執行后（f1是f1，不是f1()執行方法，所以console.log(a+b)這行代碼並沒有執行，相當於，初始化了代碼f1），由於沒有返回值，所以結果是undefined，f2執行的時候this指向window；參數中的 ” [1,2] “，解析后變成 f2 的參數 “ 1,2，undefined ”，執行f2方法后，打印出1,2，undefined三個值

　　2.call()

　　　　A.call(B, 1,2,3) 後面的參數都是獨立的參數對象，它們會被自動解析為A的參數；

　　比如：　

    var f1 = function(a,b){
        console.log(a+b)
    }
    var f2 = function(a,b,c){
        console.log(a,b,c)
    }
    f2.call(f1,[1,2])//[1,2] undefined undefined
    f2.call(f1,1,2)//1 2 undefined

 　　參數中的 ” [1,2] “，因為傳入了一個數組，相當於只傳入了第一個參數，b和c參數沒有傳。解析后變成 f2 的參數 “ [1,2]，undefined ，undefined ”，執行f2方法后，打印出 [1,2]，undefined ，undefined 三個值。

三.apply與call帶來的便利

　　1. push();

　　push參數是類似(a,b,c,d,e)如此傳輸的，如果在一個數組的基礎上進行傳輸另一個數組的內容，可以如下：

    //apply用法
    var arr = new Array(1,2,3)
    var arr1 = new Array(11,21,31)
    Array.prototype.push.apply(arr,arr1)
    console.log(arr)//[1, 2, 3, 11, 21, 31]
    
    //call用法
    var arr = new Array(1,2,3)
    var arr1 = new Array(11,21,31)
    Array.prototype.push.call(arr,arr1[0],arr1[1],arr1[2])
    console.log(arr)//[1, 2, 3, 11, 21, 31]

 　　2. 數組利用Math求最大和最小值

　　apply和call的第一個參數，如果是null或者undefined，則apply或call前面的函數會把this指向window

    //apply的用法
    var _maxNum = Math.max.apply(null,[1,3,2,4,5])
    console.log(_maxNum)//5
    var _minNum = Math.min.apply(null,[1,3,2,4,5])
    console.log(_minNum)//1
    
    //call的用法
    var _maxNum = Math.max.call(null,1,3,2,4,5)
    console.log(_maxNum)//5
    var _minNum = Math.min.call(null,1,3,2,4,5)
    console.log(_minNum)//1

 四.總結

　　簡而言之，apply和call函數的第一個參數都是用來替換this指向的對象；apply的第二個參數使用arguments或者類似數組的參數進行傳參，call的第二個或以上的參數，使用獨立單位，一個一個進行傳參；執行順序是apply或call的第一個參數先執行得到結果，然後執行apply或call前面的函數，執行的時候用已經執行的結果所指代的this去執行。apply和call的使用除了參數上的使用方式不同外，功能是一模一樣的。

　　以上內容純屬個人理解，有誤勿噴請指出！謝謝！

本站聲明:網站內容來源於博客園,如有侵權,請聯繫我們,我們將及時處理【其他文章推薦】

※為什麼 USB CONNECTOR 是電子產業重要的元件?

※收購3c,收購IPHONE,收購蘋果電腦-詳細收購流程一覽表

※網頁設計一頭霧水??該從何著手呢? 找到專業技術的網頁設計公司，幫您輕鬆架站!

※想要讓你的商品在網路上成為最夯、最多人討論的話題?

※高價收購3C產品,價格不怕你比較

※想知道最厲害的台北網頁設計公司推薦、台中網頁設計公司推薦專業設計師”嚨底家”!!

【集合系列】- 深入淺出的分析IdentityHashMap

admin

一、摘要

在集合系列的第一章，咱們了解到，Map 的實現類有 HashMap、LinkedHashMap、TreeMap、IdentityHashMap、WeakHashMap、Hashtable、Properties等等。

應該有很多人不知道 IdentityHashMap 的存在，其中不乏工作很多年的 Java 開發者，本文主要從數據結構和算法層面，探討 IdentityHashMap 的實現。

二、簡介

IdentityHashMap 的數據結構很簡單，底層實際就是一個 Object 數組，但是在存儲上並沒有使用鏈表來存儲，而是將 K 和 V 都存放在 Object 數組上。

當添加元素的時候，會根據 Key 計算得到散列位置，如果發現該位置上已經有改元素，直接進行新值替換；如果沒有，直接進行存放。當元素個數達到一定閾值時，Object 數組會自動進行擴容處理。

打開 IdentityHashMap 的源碼，可以看到 IdentityHashMap 繼承了AbstractMap 抽象類，實現了Map接口、可序列化接口、可克隆接口。

public class IdentityHashMap<K,V>
    extends AbstractMap<K,V>
    implements Map<K,V>, java.io.Serializable, Cloneable
{
    /**默認容量大小*/
    private static final int DEFAULT_CAPACITY = 32;
    
    /**最小容量*/
    private static final int MINIMUM_CAPACITY = 4;
    
    /**最大容量*/
    private static final int MAXIMUM_CAPACITY = 1 << 29;
    
    /**用於存儲實際元素的表*/
    transient Object[] table;
    
    /**數組大小*/
    int size;

    /**對Map進行結構性修改的次數*/
    transient int modCount;

    /**key為null所對應的值*/
    static final Object NULL_KEY = new Object();
    
    ......
}

可以看到類的底層，使用了一個 Object 數組來存放元素；在對象初始化時，IdentityHashMap 容量大小為64；

public IdentityHashMap() {
        //調用初始化方法
        init(DEFAULT_CAPACITY);
}
private void init(int initCapacity) {
        //數組大小默認為初始化容量的2倍
        table = new Object[2 * initCapacity];
}

三、常用方法介紹

3.1、put方法

put 方法是將指定的 key, value 對添加到 map 里。該方法首先會對map做一次查找，通過==判斷是否存在key，如果有，則將舊value返回，將新value覆蓋舊value；如果沒有，直接插入，數組長度+1，返回null。

源碼如下：

public V put(K key, V value) {
        //判斷key是否為空，如果為空，初始化一個Object為key
        final Object k = maskNull(key);

        retryAfterResize: for (;;) {
            final Object[] tab = table;
            final int len = tab.length;
            //通過key、length獲取數組小編
            int i = hash(k, len);
            
            //循環遍歷是否存在指定的key
            for (Object item; (item = tab[i]) != null;
                 i = nextKeyIndex(i, len)) {
                 //通過==判斷，是否數組中是否存在key
                if (item == k) {
                        V oldValue = (V) tab[i + 1];
                        //新value覆蓋舊value
                    tab[i + 1] = value;
                    //返回舊value
                    return oldValue;
                }
            }
            
            //數組長度 +1
            final int s = size + 1;
            //判斷是否需要擴容
            if (s + (s << 1) > len && resize(len))
                continue retryAfterResize;

            //更新修改次數
            modCount++;
            //將k加入數組
            tab[i] = k;
            //將value加入數組
            tab[i + 1] = value;
            size = s;
            return null;
        }
}

maskNull 函數，判斷 key 是否為空

private static Object maskNull(Object key) {
        return (key == null ? NULL_KEY : key);
}

hash 函數，通過 key 獲取 hash 值，結合數組長度通過位運算獲取數組散列下標

private static int hash(Object x, int length) {
        int h = System.identityHashCode(x);
        // Multiply by -127, and left-shift to use least bit as part of hash
        return ((h << 1) - (h << 8)) & (length - 1);
}

nextKeyIndex 函數，通過 hash 函數計算得到的數組散列下標，進行加2；因為一個 key、value 都存放在數組中，所以一個 map 對象佔用兩個數組下標，所以加2。

private static int nextKeyIndex(int i, int len) {
        return (i + 2 < len ? i + 2 : 0);
}

resize 函數，通過數組長度，進行擴容處理，擴容之後的長度為當前長度的2倍

private boolean resize(int newCapacity) {
        //擴容后的數組長度，為當前數組長度的2倍
        int newLength = newCapacity * 2;

        Object[] oldTable = table;
        int oldLength = oldTable.length;
        if (oldLength == 2 * MAXIMUM_CAPACITY) { // can't expand any further
            if (size == MAXIMUM_CAPACITY - 1)
                throw new IllegalStateException("Capacity exhausted.");
            return false;
        }
        if (oldLength >= newLength)
            return false;

        Object[] newTable = new Object[newLength];
        //將舊數組內容轉移到新數組
        for (int j = 0; j < oldLength; j += 2) {
            Object key = oldTable[j];
            if (key != null) {
                Object value = oldTable[j+1];
                oldTable[j] = null;
                oldTable[j+1] = null;
                int i = hash(key, newLength);
                while (newTable[i] != null)
                    i = nextKeyIndex(i, newLength);
                newTable[i] = key;
                newTable[i + 1] = value;
            }
        }
        table = newTable;
        return true;
}

3.2、get方法

get 方法根據指定的 key 值返回對應的 value。同樣的，該方法會循環遍曆數組，通過==判斷是否存在key，如果有，直接返回value，因為 key、value 是相鄰的存儲在數組中，所以直接在當前數組下標+1，即可獲取 value；如果沒有找到，直接返回null。

值得注意的地方是，在循環遍歷中，是通過==判斷當前元素是否與key相同，如果相同，則返回value。咱們都知道，在 java 中，==對於對象類型參數，判斷的是引用地址，確切的說，是堆內存地址，所以，這裏判斷的是key的引用地址是否相同，如果相同，則返回對應的 value；如果不相同，則返回null。

源碼如下：

public V get(Object key) {
        Object k = maskNull(key);
        Object[] tab = table;
        int len = tab.length;
        int i = hash(k, len);
        
        //循環遍曆數組，直到找到key或者，數組為空為值
        while (true) {
            Object item = tab[i];
            //通過==判斷，當前數組元素與key相同
            if (item == k)
                return (V) tab[i + 1];
            //數組為空
            if (item == null)
                return null;
            i = nextKeyIndex(i, len);
        }
}

3.3、remove方法

remove 的作用是通過 key 刪除對應的元素。該方法會循環遍曆數組，通過==判斷是否存在key，如果有，直接將key、value設置為null，對數組進行重新排列，返回舊 value。

源碼如下：

public V remove(Object key) {
        Object k = maskNull(key);
        Object[] tab = table;
        int len = tab.length;
        int i = hash(k, len);

        while (true) {
            Object item = tab[i];
            if (item == k) {
                modCount++;
                //數組長度減1
                size--;
                    V oldValue = (V) tab[i + 1];
                //將key、value設置為null
                tab[i + 1] = null;
                tab[i] = null;
                //刪除該元素后，需要把原來有衝突往後移的元素移到前面來
                closeDeletion(i);
                return oldValue;
            }
            if (item == null)
                return null;
            i = nextKeyIndex(i, len);
        }
}

closeDeletion 函數，刪除該元素后，需要把原來有衝突往後移的元素移到前面來，對數組進行重寫排列；

private void closeDeletion(int d) {
        // Adapted from Knuth Section 6.4 Algorithm R
        Object[] tab = table;
        int len = tab.length;

        Object item;
        for (int i = nextKeyIndex(d, len); (item = tab[i]) != null;
             i = nextKeyIndex(i, len) ) {
            int r = hash(item, len);
            if ((i < r && (r <= d || d <= i)) || (r <= d && d <= i)) {
                tab[d] = item;
                tab[d + 1] = tab[i + 1];
                tab[i] = null;
                tab[i + 1] = null;
                d = i;
            }
        }
}

四、總結

  1. IdentityHashMap 的實現不同於HashMap，雖然也是數組，不過IdentityHashMap中沒有用到鏈表，解決衝突的方式是計算下一個有效索引，並且將數據key和value緊挨着存在map中，即table[i]=key、table[i+1]=value；

  2. IdentityHashMap 允許key、value都為null，當key為null的時候，默認會初始化一個Object對象作為key；

  3. IdentityHashMap在保存、刪除、查詢數據的時候，以key為索引，通過==來判斷數組中元素是否與key相同，本質判斷的是對象的引用地址，如果引用地址相同，那麼在插入的時候，會將value值進行替換；

IdentityHashMap 測試例子：

public static void main(String[] args) {
        Map<String, String> identityMaps = new IdentityHashMap<String, String>();

        identityMaps.put(new String("aa"), "aa");
        identityMaps.put(new String("aa"), "bb");
        identityMaps.put(new String("aa"), "cc");
        identityMaps.put(new String("aa"), "cc");
        //輸出添加的元素
        System.out.println("數組長度："+identityMaps.size() + "，輸出結果：" + identityMaps);
    }

輸出結果：

數組長度：4，輸出結果：{aa=aa, aa=cc, aa=bb, aa=cc}

儘管key的內容是一樣的，但是key的堆地址都不一樣，所以在插入的時候，插入了4條記錄。

五、參考

1、JDK1.7&JDK1.8 源碼

2、

3、

作者：炸雞可樂
出處：

本站聲明:網站內容來源於博客園,如有侵權,請聯繫我們,我們將及時處理【其他文章推薦】

※USB CONNECTOR掌控什麼技術要點? 帶您認識其相關發展及效能

※高價3c回收,收購空拍機,收購鏡頭,收購 MACBOOK-更多收購平台討論專區

※評比前十大台北網頁設計、台北網站設計公司知名案例作品心得分享

※收購3c瘋!各款手機、筆電、相機、平板,歡迎來詢價!

※智慧手機時代的來臨，RWD網頁設計已成為網頁設計推薦首選

面試官：你連RESTful都不知道我怎麼敢要你？

admin

目錄

面試官：了解RESTful嗎？

我：聽說過。

面試官：那什麼是RESTful？

我：就是用起來很規範，挺好的

面試官：是RESTful挺好的，還是自我感覺挺好的

我：都挺好的。

面試官：… 把門關上。

我：…. 要幹嘛？先關上再說。

面試官：我說出去把門關上。

我：what ？，奪門而去

@

01 前言

回歸正題，看過很多RESTful相關的文章總結，參齊不齊，結合工作中的使用，非常有必要歸納一下關於RESTful架構方式了，RESTful只是一種架構方式的約束，給出一種約定的標準，完全嚴格遵守RESTful標準並不是很多，也沒有必要。但是在實際運用中，有RESTful標準可以參考，是十分有必要的。

實際上在工作中對api接口規範、命名規則、返回值、授權驗證等進行一定的約束，一般的項目api只要易測試、足夠安全、風格一致可讀性強、沒有歧義調用方便我覺得已經足夠了，接口是給開發人員看的，也不是給普通用戶去調用。

02 RESTful的來源

REST：Representational State Transfer（表象層狀態轉變），如果沒聽說過REST，你一定以為是rest這個單詞，剛開始我也是這樣認為的，後來發現是這三個單詞的縮寫，即使知道了這三個單詞理解起來仍然非常晦澀難懂。如何理解RESTful架構，最好的辦法就是深刻理解消化Representational State Transfer這三個單詞到底意味着什麼。

1.每一個URI代表一種資源；

2.客戶端和服務器之間，傳遞這種資源的某種表現層；

3.客戶端通過四個HTTP動詞（get、post、put、delete），對服務器端資源進行操作，實現”表現層狀態轉化”。

是由美國計算機科學家Roy Fielding（百度百科沒有介紹，真是尷尬了）。Adobe首席科學家、Http協議的首要作者之一、Apache項目聯合創始人。

03 RESTful6大原則

REST之父Roy Fielding在論文中闡述REST架構的6大原則。

1. C-S架構

數據的存儲在Server端，Client端只需使用就行。兩端徹底分離的好處使client端代碼的可移植性變強，Server端的拓展性變強。兩端單獨開發，互不干擾。

2. 無狀態

http請求本身就是無狀態的，基於C-S架構，客戶端的每一次請求帶有充分的信息能夠讓服務端識別。請求所需的一些信息都包含在URL的查詢參數、header、body，服務端能夠根據請求的各種參數，無需保存客戶端的狀態，將響應正確返回給客戶端。無狀態的特徵大大提高的服務端的健壯性和可拓展性。

當然這總無狀態性的約束也是有缺點的，客戶端的每一次請求都必須帶上相同重複的信息確定自己的身份和狀態（這也是必須的），造成傳輸數據的冗餘性，但這種確定對於性能和使用來說，幾乎是忽略不計的。

3.統一的接口

這個才是REST架構的核心，統一的接口對於RESTful服務非常重要。客戶端只需要關注實現接口就可以，接口的可讀性加強，使用人員方便調用。

4.一致的數據格式

服務端返回的數據格式要麼是XML，要麼是Json（獲取數據），或者直接返回狀態碼，有興趣的可以看看博客園的開放平台的操作數據的api，post、put、patch都是返回的一個狀態碼 。

自我描述的信息，每項數據應該是可以自我描述的，方便代碼去處理和解析其中的內容。比如通過HTTP返回的數據裏面有 [MIME type ]信息，我們從MIME type裏面可以知道數據的具體格式，是圖片，視頻還是JSON，客戶端通過body內容、查詢串參數、請求頭和URI（資源名稱）來傳送狀態。服務端通過body內容，響應碼和響應頭傳送狀態給客戶端。這項技術被稱為超媒體（或超文本鏈接）。

除了上述內容外，HATEOS也意味着，必要的時候鏈接也可被包含在返回的body（或頭部）中，以提供URI來檢索對象本身或關聯對象。下文將對此進行更詳細的闡述。

如請求一條微博信息，服務端響應信息應該包含這條微博相關的其他URL，客戶端可以進一步利用這些URL發起請求獲取感興趣的信息，再如分頁可以從第一頁的返回數據中獲取下一頁的URT也是基於這個原理。

4.系統分層

客戶端通常無法表明自己是直接還是間接與端服務器進行連接，分層時同樣要考慮安全策略。

5.可緩存

在萬維網上，客戶端可以緩存頁面的響應內容。因此響應都應隱式或顯式的定義為可緩存的，若不可緩存則要避免客戶端在多次請求後用舊數據或臟數據來響應。管理得當的緩存會部分地或完全地除去客戶端和服務端之間的交互，進一步改善性能和延展性。

6.按需編碼、可定製代碼（可選）

服務端可選擇臨時給客戶端下發一些功能代碼讓客戶端來執行，從而定製和擴展客戶端的某些功能。比如服務端可以返回一些 Javascript 代碼讓客戶端執行，去實現某些特定的功能。
提示：REST架構中的設計準則中，只有按需編碼為可選項。如果某個服務違反了其他任意一項準則，嚴格意思上不能稱之為RESTful風格。

03 RESTful的7個最佳實踐

1. 版本

如github開放平台
https://developer.github.com/v3/

就是將版本放在url，簡潔明了，這個只有用了才知道，一般的項目加版本v1，v2，v3?好吧，這個加版本估計只有大公司大項目才會去使用，說出來不怕尷尬，我真沒用過。有的會將版本號放在header裏面，但是不如url直接了當。

https://example.com/api/v1/

2.參數命名規範

query parameter可以採用駝峰命名法，也可以採用下劃線命名的方式，推薦採用下劃線命名的方式，據說後者比前者的識別度要高，可能是用的人多了吧，因人而異，因團隊規範而異吧。

https://example.com/api/users/today_login 獲取今天登陸的用戶 
https://example.com/api/users/today_login&sort=login_desc 獲取今天登陸的用戶、登陸時間降序排列

3.url命名規範

API 命名應該採用約定俗成的方式，保持簡潔明了。在RESTful架構中，每個url代表一種資源所以url中不能有動詞，只能有名詞，並且名詞中也應該使用複數。實現者應使用相應的Http動詞GET、POST、PUT、PATCH、DELETE、HEAD來操作這些資源即可

不規範的的url，冗餘沒有意義，形式不固定，不同的開發者還需要了解文檔才能調用。

https://example.com/api/getallUsers GET 獲取所有用戶 
https://example.com/api/getuser/1 GET 獲取標識為1用戶信息 
https://example.com/api/user/delete/1 GET/POST 刪除標識為1用戶信息 
https://example.com/api/updateUser/1 POST 更新標識為1用戶信息 
https://example.com/api/User/add POST 添加新的用戶

規範后的RESTful風格的url，形式固定，可讀性強，根據users名詞和http動詞就可以操作這些資源

https://example.com/api/users GET 獲取所有用戶信息 
https://example.com/api/users/1 GET 獲取標識為1用戶信息 
https://example.com/api/users/1 DELETE 刪除標識為1用戶信息 
https://example.com/api/users/1 Patch 更新標識為1用戶部分信息,包含在body中 
https://example.com/api/users POST 添加新的用戶

4. 統一返回數據格式

對於合法的請求應該統一返回數據格式，這裏演示的是json

  • code——包含一個整數類型的HTTP響應狀態碼。
  • status——包含文本：”success”，”fail”或”error”。HTTP狀態響應碼在500-599之間為”fail”，在400-499之間為”error”，其它均為”success”（例如：響應狀態碼為1XX、2XX和3XX）。這個根據實際情況其實是可要可不要的。
  • message——當狀態值為”fail”和”error”時有效，用於显示錯誤信息。參照國際化（il8n）標準，它可以包含信息號或者編碼，可以只包含其中一個，或者同時包含並用分隔符隔開。
  • data——包含響應的body。當狀態值為”fail”或”error”時，data僅包含錯誤原因或異常名稱、或者null也是可以的

返回成功的響應json格式

{
  "code": 200,
  "message": "success",
  "data": {
    "userName": "123456",
    "age": 16,
    "address": "beijing"
  }
}

返回失敗的響應json格式

{
  "code": 401,
  "message": "error  message",
  "data": null
}

下面這個ApiResult的泛型類是在項目中用到的，拓展性強，使用方便。返回值使用統一的 ApiResult 或 ApiResult
錯誤返回 使用 ApiResult.Error 進行返回； 成功返回，要求使用 ApiResult.Ok 進行返回

public class ApiResult: ApiResult
    {
        public new static ApiResult<T> Error(string message)
        {
            return new ApiResult<T>
            {
                Code = 1,
                Message = message,
            };
        }
        [JsonProperty("data")]
        public T Data { get; set; }
    }
    public class ApiResult
    {
        public static ApiResult Error(string message)
        {
            return new ApiResult
            {
                Code = 1,
                Message = message,
            };
        }

        public static ApiResult<T> Ok<T>(T data)
        {
            return new ApiResult<T>()
            {
                Code = 0,
                Message = "",
                Data = data
            };
        }
        /// <summary>
        /// 0 是 正常 1 是有錯誤
        /// </summary>
        [JsonProperty("code")]
        public int Code { get; set; }
        [JsonProperty("msg")]
        public string Message { get; set; }

        [JsonIgnore]
        public bool IsSuccess => Code == 0;
    }

5. http狀態碼

在之前開發的xamarin android博客園客戶端的時候，patch、delete、post操作時body響應裏面沒有任何信息，僅僅只有http status code。HTTP狀態碼本身就有足夠的含義，根據http status code就可以知道刪除、添加、修改等是否成功。(ps:有點linux設計的味道哦，沒有返回消息就是最好的消息，表示已經成功了)服務段向用戶返回這些狀態碼並不是一個強制性的約束。簡單點說你可以指定這些狀態，但是不是強制的。常用HTTP狀態碼對照表
HTTP狀態碼也是有規律的

  • 1**請求未成功
  • 2**請求成功、表示成功處理了請求的狀態代碼。
  • 3**請求被重定向、表示要完成請求，需要進一步操作。 通常，這些狀態代碼用來重定向。
  • 4** 請求錯誤這些狀態代碼錶示請求可能出錯，妨礙了服務器的處理。

  • 5**（服務器錯誤）這些狀態代碼錶示服務器在嘗試處理請求時發生內部錯誤。 這些錯誤可能是服務器本身的錯誤，而不是請求出錯。

    6. 合理使用query parameter

    在請求數據時，客戶端經常會對數據進行過濾和分頁等要求，而這些參數推薦採用HTTP Query Parameter的方式實現

比如設計一個最近登陸的所有用戶
https://example.com/api/users?recently_login_day=3
搜索用戶，並按照註冊時間降序
https://example.com/api/users?recently_login_day=3
搜索用戶，並按照註冊時間升序、活躍度降序
https://example.com/api/users?q=key&sort=create_title_asc,liveness_desc
關於分頁，看看博客園開放平台分頁獲取精華區博文列表
https://api.cnblogs.com/api/blogposts/@picked?pageIndex={pageIndex}&pageSize={pageSize} 
返回示例： 
[ 
{ 
“Id”: 1, 
“Title”: “sample string 2”, 
“Url”: “sample string 3”, 
“Description”: “sample string 4”, 
“Author”: “sample string 5”, 
“BlogApp”: “sample string 6”, 
“Avatar”: “sample string 7”, 
“PostDate”: “2017-06-25T20:13:38.892135+08:00”, 
“ViewCount”: 9, 
“CommentCount”: 10, 
“DiggCount”: 11 
}, 
{ 
“Id”: 1, 
“Title”: “sample string 2”, 
“Url”: “sample string 3”, 
“Description”: “sample string 4”, 
“Author”: “sample string 5”, 
“BlogApp”: “sample string 6”, 
“Avatar”: “sample string 7”, 
“PostDate”: “2017-06-25T20:13:38.892135+08:00”, 
“ViewCount”: 9, 
“CommentCount”: 10, 
“DiggCount”: 11 
} 
]

7. 多表、多參數連接查詢如何設計URL

這是一個比較頭痛的問題，在做單個實體的查詢比較容易和規範操作，但是在實際的API並不是這麼簡單而已，這其中常常會設計到多表連接、多條件篩選、排序等。
比如我想查詢一個獲取在6月份的訂單中大於500元的且用戶地址是北京，用戶年齡在22歲到40歲、購買金額降序排列的訂單列表

https://example.com/api/orders?order_month=6&order_amount_greater=500&address_city=北京&sort=order_amount_desc&age_min=22&age_max=40

從這個URL上看，參數眾多、調用起來還得一個一個仔細對着，而且API本身非常不容易維護，命名看起來不是很容易，不能太長，也不能太隨意。

在.net WebAPI總我們可以使用屬性路由，屬性路由就是講路由附加到特定的控制器或操作方法上裝飾Controll及其使用[Route]屬性定義路由的方法稱為屬性路由。

這種好處就是可以精準地控制URL，而不是基於約定的路由，簡直就是為這種多表查詢量身定製似的的。 從webapi 2開發，現在是RESTful API開發中最推薦的路由類型。
我們可以在Controll中標記Route

[Route(“api/orders/{address}/{month}”)]

Action中的查詢參數就只有金額、排序、年齡。減少了查詢參數、API的可讀性和可維護行增強了。

https://example.com/api/orders/beijing/6?order_amount_greater=500&sort=order_amount_desc&age_min=22&age_max=40

這種屬性路由比如在博客園開放的API也有這方面的應用，如獲取個人博客隨筆列表

請求方式：GET 
請求地址：https://api.cnblogs.com/api/blogs/{blogApp}/posts?pageIndex={pageIndex} 
(ps:blogApp：博客名)

本站聲明:網站內容來源於博客園,如有侵權,請聯繫我們,我們將及時處理【其他文章推薦】

※3c收購,鏡頭 收購有可能以全新價回收嗎?

※台北網頁設計公司這麼多，該如何挑選?? 網頁設計報價省錢懶人包"嚨底家"

※網頁設計公司推薦更多不同的設計風格，搶佔消費者視覺第一線

※想知道購買電動車哪裡補助最多?台中電動車補助資訊懶人包彙整

※賣IPHONE,iPhone回收,舊換新!教你怎麼賣才划算?

小白理解安卓虛擬機以及華為的’諾亞方舟’

admin

虛擬機，提到虛擬機，大家可能第一反應就是java中好像有虛擬機這個玩意。但是安卓中的虛擬機是什麼呢？是和java一樣的嗎？那麼我們先來了解一下java中的JVM！

JVM，搞java的肯定對它了解不少。JVM本質上就是一個軟件，是計算機硬件的一層軟件抽象，在這之上才幹夠運行Java程序，JAVA在編譯後會生成相似於彙編語言的JVM字節碼，與C語言編譯后產生的彙編語言不同的是，C編譯成的彙編語言會直接在硬件上跑。但JAVA編譯後生成的字節碼是在JVM上跑，須要由JVM把字節碼翻譯成機器指令。才幹使JAVA程序跑起來。JVM運行在操作系統上，屏蔽了底層實現的差異。從而有了JAVA吹噓的平台獨立性和Write Once Run Anywhere。依據JVM規範實現的詳細虛擬機有幾十種，主流的JVM包括Hotspot、Jikes RVM等。都是用C/C++和彙編編寫的，每一個JRE編譯的時候針對每一個平台編譯。因此下載JRE（JVM、Java核心類庫和支持文件）的時候是分平台的，JVM的作用是把平台無關的.class裏面的字節碼翻譯成平台相關的機器碼，來實現跨平台。

說白了，簡單點，就是：

                                                                      Java

                                                                      .java文件 -> .class文件 -> .jar文件

最後執行是class文件，有的會被再次打包成jar文件。

了解了這些之後，我們再去了解Android 中的虛擬機。

一、Dalvik虛擬機

Dalvik虛擬機（ Dalvik Virtual Machine ），簡稱Dalvik VM或者DVM。這就是Android中的虛擬機。最初它的產生，是因為Google為了解決與Oracle之間關於Java相關專利和授權的糾紛，開發了DVM。

Android既然存在虛擬機，肯定也是在這個DVM上執行的。它的執行流程和JVM很像：

                                                                       Android

                                                                      .java文件 –> .class文件 -> .dex文件->.apk

DVM執行的是.dex格式文件，JVM執行的是.class文件，android程序編譯完之後生產.class文件，然後，dex工具會把.class文件處理成.dex文件，然後把資源文件和.dex文件等打包成.apk文件，apk就是android package的意思。

除了上面所說的，專利授權的原因除外，其實還有因為如下原因：

    dvm是基於寄存器的虛擬機，而jvm是基於虛擬棧的虛擬機。寄存器存取速度比棧快得多，dvm可以根據硬件實現最大的優化，比較適合移動設備。

    class文件存在很多的冗餘信息，dex工具會去除冗餘信息，並把所有的.class文件整合到.dex文件中，減少了I/O操作，提高了類的查找速度。

不光是上面這些差異，還有運行環境。 　

   Dalvik : 一個應用啟動都運行一個單獨的虛擬機運行在一個單獨的進程中

   JVM: 只能運行一個實例, 也就是所有應用都運行在同一個JVM中

 

 這個是早先的安卓虛擬機，運行速度還是相當慢的。基於寄存器的虛擬機允許更快的執行時間，但代價是編譯后的程序更大。於是新的Dex字節碼格式odex產生了。它的作用等同於dex，只不過是dex優化后的格式。在App安裝的過程中，會通過Socket向/system/bin/install進程發送dex_opt的指令，對Dex文件進行優化。在DexClassLoader動態加載Dex文件時，也會進行Dex的優化，形成odex文件。

 

為了適應硬件速度的提升，隨後在Android 2.2的DVM中加入了JIT 編譯器（Just-In-Time Compiler）。Dalvik 使用 JIT 進行即時編譯，藉助 Java HotSpot VM，JIT 編譯器可以對執行次數頻繁的 dex/odex 代碼進行編譯與優化，將 dex/odex 中的 Dalvik Code（Smali 指令集）翻譯成相當精簡的 Native Code 去執行，JIT 的引入使得 Dalvik 的性能提升了 3~6 倍。

JIT編譯器的引入，提升了安裝速度，減少了佔用的空間，但隨之帶來的問題就是：多個dex加載會非常慢；JIT中的解釋器解釋的字節碼會帶來CPU和時間的消耗；還有熱點代碼的Monitor一直在運行帶來電量的損耗。

 

 這種情況下，手機動不動就卡是難以避免的。相信各位如果那時候用着Android手機，一定印象非常深刻。因為並不是那麼好用。

這樣的狀況一直持續到Andorid 4.4，帶來了全新的虛擬機運行環境 ART（Android RunTime）的預覽版和全新的編譯策略 AOT（Ahead-of-time）。但那時候。 ART 是和 Dalvik 共存的，用戶可以在兩者之間進行選擇（感覺很奇怪，作為一個愛好者，我當時看到這個東西可以切換都是不曉得是什麼玩意，用戶可都是小白啊，沒有必要共存的吧）。在Android 5.0的時候，ART 全面取代 Dalvik 成為 Android 虛擬機運行環境，至此。Dalvik 退出歷史舞台，AOT 也成為唯一的編譯模式。

二、ART 

AOT 和 JIT 的不同之處在於：JIT 是在運行時進行編譯，是動態編譯，並且每次運行程序的時候都需要對 odex 重新進行編譯；而 AOT 是靜態編譯，應用在安裝的時候會啟動 dex2oat 通過靜態編譯的方式，來將所有的dex文件(包括Multidex)編譯oat文件，編譯完后的oat其實是一個標準的ELF文件，只是相對於普通的ELF文件多加了oat data section以及oat exec section這兩個段而已。(這兩個段裏面主要保存了兩種信息：Dex的文件信息以及類信息和Dex文件編譯之後的機器碼)。預編譯成 ELF 文件，每次運行程序的時候不用重新編譯，是真正意義上的本地應用。運行的文件格式也從odex轉換成了oat格式。

 

其實在Android5.0的時候我們能夠明顯感覺手機好用很多就是因為這個原因，從根本上換掉了那種存在着無法解決弊端的虛擬機。在 Android 5.x 和 6.x 的機器上，系統每次 OTA 升級完成重啟的時候都會有個應用優化的過程，這個過程就是剛才所說的 dex2oat 過程，這個過程比較耗時並且會佔用額外的存儲空間。

AOT 模式的預編譯解決了應用啟動和運行速度和耗資源(電等)問題的同時也帶來了另外兩個問題：

      1、應用安裝和系統升級之後的應用優化比較耗時，並且會更耗時間。因為系統和apk都是越來越大的。

      2、優化后的文件會佔用額外的存儲空間

在經過了兩個Android大版本的穩定后，在Android7.0又再次迎來了JIT的 回歸。

JIT的回歸，可不是把AOT模式給取代了，而是形成 了AOT/JIT 混合編譯模式，這種模式至今仍在使用。

應用在安裝的時候 dex 不會被編譯。

應用在運行時 dex 文件先通過解析器（Interpreter）後會被直接執行（這一步驟跟 Android 2.2 – Android 4.4之前的行為一致），與此同時，熱點函數（Hot Code）會被識別並被 JIT 編譯后存儲在 jit code cache 中並生成 profile 文件以記錄熱點函數的信息。

手機進入 IDLE（空閑） 或者 Charging（充電） 狀態的時候，系統會掃描 App 目錄下的 profile 文件並執行 AOT 過程進行編譯。

（Profile文件會在JIT運行的過程中生成：每個APP都會有自己的Profile文件，保存在App本身的Local Storage中。Profile會保存所調用的類以及函數的Index，通過profman工具進行分析生成）

 

 

個人理解：哪種模式擅長干什麼就讓他去干什麼。

混合編譯模式綜合了 AOT 和 JIT 的各種優點，使得應用在安裝速度加快的同時，運行速度、存儲空間和耗電量等指標都得到了優化。

之前一直在說流暢，真的流暢在Android7.0上才感受到了些許。Android7.0系統也被用了相當長的一段時間。之後的Android8.0和Android9.0都是對各方面的優化，例如編譯文件、編譯器、GC。。

其中，值得一提的是華為的方舟編譯器。

  • 首先會判斷該設備支不支持方舟編譯器，如果支持，則從應用商店下發方舟版本的包
  • 方舟編譯器會把dex文件通過自己的IR翻譯方舟格式的機器碼，據資料說也是一個ELF文件，但是會增加一些段，猜測是Dex中類信息相關的段
  • 通過這種方式，來消除Java與JNI之間的通信的損耗，以及提升運行時的效率
  • 在方舟內部，還重新完善了GC算法，使得GC的頻率大大降低，減少應用卡頓的現象
  • 目前方舟只支持64位的So，並且對於加殼的So會出現一些問題。

方舟編譯器適配的應用，下載手機上都是方舟版本的包，特製的包用方舟編譯器編譯效率大大提升，之後直接執行就可以了，直接略過了在ART虛擬機上預編譯的過程。這樣的結果是很完美的，但是卻也沒辦法跳過一個弊端。那就是生態。還是不管是安卓還是iOS，這麼多年的時間沉澱中，他們的生態系統早就達到了一個非常完善的地步。安卓和iOS應用已經多達上千萬，而方舟適配應用的數量還非常有限。

谷歌宣布將停止對華為提供安卓系統更新之後，華為曝光了自主研發的鴻蒙操作系統。當時網友各種力挺。不過後來，華為董事長梁華在談及鴻蒙系統時稱，鴻蒙系統是為物聯網開發的，用於自動駕駛、遠程醫療等低時延場景。鴻蒙系統是不是兩手準備我們不得而知。但是，一個操作系統最重要的就是它的生態環境。縱觀華為現在的整個格局，目的非常明確，用方舟編譯器來擴大自己的用戶群體。當用戶的基數足夠龐大時，可以隨時隨地建立一個完善的生態系統。如果在未來某一天，Android全面限制華為的使用之後，在這危機關頭鴻蒙系統還是很有可能扛起國產手機的一面大旗。哪怕不是鴻蒙，我們也需要這樣一個生態不是嗎?

最初，突然去了解Android中的虛擬機，一個是想要明白到底Android中的虛擬機和JVM是不是一回事，還有就是想要明白華為發布方舟編譯器到底快到了哪裡。

上述相關資料均來自網絡，侵權必刪。

本站聲明:網站內容來源於博客園,如有侵權,請聯繫我們,我們將及時處理【其他文章推薦】

※公開收購3c價格,不怕被賤賣!

※想知道網站建置、網站改版該如何進行嗎?將由專業工程師為您規劃客製化網頁設計及後台網頁設計

※不管是台北網頁設計公司、台中網頁設計公司，全省皆有專員為您服務

※Google地圖已可更新顯示潭子電動車充電站設置地點!!

※帶您來看台北網站建置，台北網頁設計，各種案例分享

遷移桌面程序到MS Store（12）——WPF使用UWP InkToolbar和InkCanvas

admin

我們在提到了對Win10 API的調用，但仍存在無法在WPF中使用UWP控件的問題，雖然都是XAML控件，但卻是兩套命名空間下的同名類型，無法混用。
人總會被現實打敗，強大如某軟也得向生活低頭，UWP一直沒有起色，某軟的老大又一心去搞Azure。Windows平台的重振，似乎想走回頭路，從1903版本開始，支持在.NET Framwork的WPF和WinForm工程中，直接使用部分的UWP控件了。首當其沖的，就是有點騷包的InkToolbar和InkCanvas。

接下來我們就來試試如何在WPF工程中，使用UWP的InkToolbar和InkCanvas。
首先創建一個空的WPF工程，完成后，在Nuget的搜索界面填入 Microsoft.Toolkit.Wpf.UI.Controls ，選中第一個進行安裝。

完成安裝后，打開MainWindow.xaml，添加對命名空間的引用xmlns:Controls=”clr-namespace:Microsoft.Toolkit.Wpf.UI.Controls;assembly=Microsoft.Toolkit.Wpf.UI.Controls”。接着就可以在<Grid>節點中添加UWP版本的InkToolbar和InkCanvas控件了。

<Window x:Class="WPFInkSample.MainWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
        xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
        xmlns:local="clr-namespace:WPFInkSample"
        xmlns:Controls="clr-namespace:Microsoft.Toolkit.Wpf.UI.Controls;assembly=Microsoft.Toolkit.Wpf.UI.Controls"
        mc:Ignorable="d"
        Title="MainWindow" Height="450" Width="800">
    <Grid >
        <Grid.RowDefinitions>
            <RowDefinition Height="Auto"/>
            <RowDefinition Height="*"/>
        </Grid.RowDefinitions>
        <Controls:InkToolbar TargetInkCanvas="{x:Reference myInkCanvas}" Grid.Row="0" />
        <Controls:InkCanvas x:Name="myInkCanvas" Grid.Row="1" />
    </Grid>
</Window>

同時我們還需要在MainWindow.xaml.cs中設置InputDeviceTypes。

    public partial class MainWindow : Window
    {
        public MainWindow()
        {
            InitializeComponent();
            this.myInkCanvas.InkPresenter.InputDeviceTypes = CoreInputDeviceTypes.Mouse | CoreInputDeviceTypes.Pen;
        }
    }

然後按下F5運行，某軟的騷操作來了……因為僅在1903以後的版本才支持這種騷操作（10.0.18226是稍早的preview版），所以需要做額外的處理才可以。

我們這裡有兩種選擇，一是通過來打包這個WPF程序，然後在Packaging工程的屬性里，將Target version和Minimum version同時設置為Windows 10, version 1903 (10.0.18362) 。這是MSDN上推薦的標準做法，這樣做的好處在於，打包好的程序可以直接上傳MS Store。
如果我們想保持exe的可執行文件形式，還有另一種做法，在Project文件上右鍵點擊Add->New Item，添加一個manifest文件。
在這個文件中，找到<!–Windows 10–>，然後做如下編輯：

  <compatibility xmlns="urn:schemas-microsoft-com:compatibility.v1">
    <application>
      <!-- A list of the Windows versions that this application has been tested on
           and is designed to work with. Uncomment the appropriate elements
           and Windows will automatically select the most compatible environment. -->
  
      <!-- Windows Vista -->
      <!--<supportedOS Id="{e2011457-1546-43c5-a5fe-008deee3d3f0}" />-->
  
      <!-- Windows 7 -->
      <!--<supportedOS Id="{35138b9a-5d96-4fbd-8e2d-a2440225f93a}" />-->
  
      <!-- Windows 8 -->
      <!--<supportedOS Id="{4a2f28e3-53b9-4441-ba9c-d69d4a4a6e38}" />-->
  
      <!-- Windows 8.1 -->
      <!--<supportedOS Id="{1f676c76-80e1-4239-95bb-83d0f6d0da78}" />-->
  
      <!-- Windows 10 -->
      <maxversiontested Id="10.0.18362.0"/>
      <supportedOS Id="{8e0f7a12-bfb3-4fe8-b9a5-48fd50a15a9a}" />
  
    </application>
  </compatibility>

保存后，再通過F5運行，即發現一切正常，不在出現之前的運行時錯誤了。
本篇我們介紹了如何在WPF工程中使用UWP InkToolbar和InkCavas。因為這個功能僅在1903后的版本支持，所以下一篇我們會介紹如何簡單地判斷Win10 API 版本，在運行時判斷是否執行對應版本的代碼。
Github：

本站聲明:網站內容來源於博客園,如有侵權,請聯繫我們,我們將及時處理【其他文章推薦】

※收購3c,收購IPHONE,收購蘋果電腦-詳細收購流程一覽表

※網頁設計公司推薦更多不同的設計風格，搶佔消費者視覺第一線

※廣告預算用在刀口上，網站設計公司幫您達到更多曝光效益

※公開收購3c價格,不怕被賤賣!

※自行創業 缺乏曝光? 下一步"網站設計"幫您第一時間規劃公司的門面形象

【併發編程】摩爾定律失效“帶來”并行編程

admin

本博客系列是學習併發編程過程中的記錄總結。由於文章比較多，寫的時間也比較散，所以我整理了個目錄貼（傳送門），方便查閱。

併發和并行

在真正開始聊本文的主題之前，我們先來回顧下兩個老生常談的概念：併發和并行。

  • 併發：是指多個線程任務在同一個CPU上快速地輪換執行，由於切換的速度非常快，給人的感覺就是這些線程任務是在同時進行的，但其實併發只是一種邏輯上的同時進行；
  • 并行：是指多個線程任務在不同CPU上同時進行，是真正意義上的同時執行。

下面貼上一張圖來解釋下這兩個概念：

上圖中的咖啡就可以看成是CPU，上面的只有一個咖啡機，相當於只有一個CPU。想喝咖啡的人只有等前面的人製作完咖啡才能製作自己的開發，也就是同一時間只能有一個人在製作咖啡，這是一種併發模式。下面的圖中有兩個咖啡機，相當於有兩個CPU，同一時刻可以有兩個人同時製作咖啡，是一種并行模式。

我們發現并行編程中，很重要的一個特點是系統具有多核CPU。要是系統是單核的，也就談不上什麼并行編程了。那麼是什麼原因導致了現代CPU架構都是多核架構？如果CPU架構都是單核的架構我們是不是就能不要研究什麼并行編程了？

“摩爾定律”失效

上面章節中留下了一個問題：為什麼現代CPU都是多核架構。為了回答這個問題，我們先來了解一個定律–摩爾定律。

1965年，英特爾聯合創始人戈登·摩爾提出以自己名字命名的「摩爾定律」，意指集成電路上可容納的元器件的數量每隔 18 至 24 個月就會增加一倍，性能也將提升一倍。

根據摩爾定律，CPU的性能每隔18到24個月就能增長一倍。但是從現在的情況來看，單核CPU的主頻已經逼近了極限，以現在的製造工藝，很難再繼續提升單核CPU的主頻。也就是說摩爾定律已經失效。

雖然摩爾定律失效了，但是科技的進度對CPU性能的需求沒有停止。這個也難不倒我們偉大的硬件工程師。一個CPU的性能提升有限，我將兩個CPU拼在一起性能不就提升一倍了么。於是多核CPU的架構就出現了。

提高CPU工作主頻主要受到生產工藝的限制。由於CPU是在半導體硅片上製造的，在硅片上的元件之間需要導線進行聯接，由於在高頻狀態下要求導線越細越短越好，這樣才能減小導線分佈電容等雜散干擾以保證CPU運算正確。因此製造工藝的限制，是CPU主頻發展的最大障礙之一。

多核架構引發并行編程

為了繼續保持性能的高速發展，硬件工程師破天荒地想出了將多個CPU內核塞進一個CPU里的奇妙想法。由此，并行計算就被非常自然地推廣開來，隨之而來的問題也層出不窮，程序員的黑暗時期也隨之到來。簡化的硬件設計方案必然帶來軟件設計的複雜性。換句話說，軟件工程師正在為硬件工程師無法完成的工作負責，他們將摩爾定律失效的責任推給了軟件開發者。

所以，如何讓多個CPU有效並且正確地工作也就成了一門技術，甚至是很大的學問。比如，多線程間如何保證線程安全，如何正確理解線程間的無序性、可見性，如何盡可能地設計并行程序，如何將串行程序改造為并行程序。而對并行計算的研究，也就是希望給這片黑暗帶來光明。

總結

世界就是這樣一個矛盾體，併發編程能讓我們充分地利用CPU資源，提升系統性能。但是同時也給我們帶來了很多問題，比如線程上下文切換對性能消耗的問題、共享變量的線程安全問題、線程死鎖問題和線程間通信等問題。研究并行編程就是研究怎麼在享受多線程編程給我們帶來便利的同時又能規避多線程帶來的坑。

本站聲明:網站內容來源於博客園,如有侵權,請聯繫我們,我們將及時處理【其他文章推薦】

※高價收購3C產品,價格不怕你比較

※如何讓商品強力曝光呢? 網頁設計公司幫您建置最吸引人的網站，提高曝光率!!

※網頁設計一頭霧水??該從何著手呢? 找到專業技術的網頁設計公司，幫您輕鬆架站!

※3c收購,鏡頭 收購有可能以全新價回收嗎?

※想知道最厲害的台北網頁設計公司推薦、台中網頁設計公司推薦專業設計師”嚨底家”!!

ceph中rbd的增量備份和恢復

admin

ceph中rbd的增量備份和恢復

ceph的文檔地址：

​ 在調研OpenStack中虛機的備份和恢復時，發現OpenStack和ceph緊密結合，使用ceph做OpenStack的後端簡直是不要太爽，於是調研了使用ceph中的塊設備rbd來對虛機進行增量備份和恢復。以下是虛機備份和恢復的實驗步驟：

1. 前言：

​ 快照的功能一般是基於時間點做一個標記，然後在某些需要的時候，將狀態恢復到標記的那個點，這個有一個前提是底層的數據沒有破壞，舉個簡單的例子，Vmware 裏面對虛擬機做了一個快照，然後做了一些系統的操作，想恢復快照，前提是存儲快照的存儲系統沒用破壞，一旦破壞了是無法恢復的。

​ ceph也有快照功能，同樣，在這裏的快照是用來保存存儲系統上的狀態的，數據的快照能成功恢復的前提是存儲系統是好的，而一旦存儲系統壞了，快照同時會失效的，所以最好是能夠將數據備份下來。本篇博客主要是調研使用ceph的rbd命令來對存儲設備進行基於快照的增量備份。

2. ceph中rbd的常用命令：

2.1列出存儲池

ceph osd pool ls

2.2 查看存儲池的內容

rbd ls --pool pool_name
例子
rbd ls --pool volumes

2.3 打快照

rbd snap create {pool-name}/{image-name}@{snap-name}
例如
rbd snap create volumes/volume-c18b9782-dc71-4ddc-bb7f-bc0037105ac3@v1

2.4 羅列快照

rbd snap ls {pool-name}/{image-name}
例如：
rbd snap ls volumes/volume-c18b9782-dc71-4ddc-bb7f-bc0037105ac3

2.5 創建image

rbd create --size {pool-name}/{image-name}

3. Nova實例的備份與恢復

以ceph做後端，在創建實例時，需要選擇一個系統盤，系統盤即是我們的目標數據盤。

備份實驗步驟：

  1. 創建虛機。
  2. 在時間點v1對虛機打快照。
  3. 導出從開始創建image到快照v1那個時間點的差異數據，可以視為全量備份。
  4. 使用dd命令寫入文件test.txt
  5. 在時間點v2對虛機打快照。
  6. 導出從開始創建image到快照v2那個時間點的差異數據，可以視為全量備份。
  7. 導出了從v1快照時間點到v2快照時間點的差異數據，可以視為增量備份。

上文實驗過程的數據：

v1時間點數據 + v1_v2之間數據 = v2 時間點數據

虛機的備份

1. 實例第一次快照：

rbd snap create volumes/volume-c18b9782-dc71-4ddc-bb7f-bc0037105ac3@v1

2. 第一次全量備份：

rbd export-diff volumes/volume-c18b9782-dc71-4ddc-bb7f-bc0037105ac3@v1 testimage_v1

這個命令是導出了從開始創建image到快照v1那個時間點的差異數據導出來了testimage_v1，導出成本地文件testimage_v1

3. 寫入文件

dd

寫入文件，以此显示出v1和v2之間的數據變化，並沒有其他作用。

4. 實例第二次快照

rbd snap create volumes/volume-c18b9782-dc71-4ddc-bb7f-bc0037105ac3@v2

5. 第二次全量備份：

rbd export-diff volumes/volume-c18b9782-dc71-4ddc-bb7f-bc0037105ac3@v2  testimage_v2

這個命令是導出了從開始創建image到快照v2那個時間點的差異數據導出來了testimage_v2，導出成本地文件testimage_v2

6. 增量備份

增量備份（第二次和第一次的差異文件）：

rbd export-diff volumes/volume-c18b9782-dc71-4ddc-bb7f-bc0037105ac3@v2 --from-snap v1 testimage_v1_v2

這個命令是導出了從v1快照時間點到v2快照時間點的差異數據，導出成本地文件testimage_v1_v2

注意：

rbd export-diff rbd/testimage testimage_now

這個是導出了從image創建到當前的時間點的差異數據。

虛機恢復

虛機的恢復過程使用的是剛剛上面提到的備份到本地的那些文件。

1.創建塊設備映像

2.將testimage_v1融入塊設備，恢復v1時間的狀態

3.將testimage_v2融入塊設備，恢復v2時間狀態

4.在2基礎上將v1_v2融入塊設備，恢復至v2時間狀態

上述實驗是全量恢復和增量恢復的兩種狀態。下文將詳細總結項目中增量備份和恢復的使用過程。

1. 創建塊設備映像image

首先隨便創建一個image,名稱大小都不限制，因為後面恢復的時候會覆蓋掉大小的信息

rbd create --size 2048 backups/testbacknew

2. 基於v2的時間點的快照做恢復

2.1 基於V2恢復

直接基於v2的時間點的快照做恢復

rbd import-diff testimage_v2 rbd/testbacknew
2.2 基於v1+ v1_v2數據恢復

直接基於v1的時間點的數據，和後面的增量的v1_v2數據(要按順序導入)

rbd import-diff testimage_v1 backups/testbacknew
rbd import-diff testimage_v1_v2 backups/testbacknew

​ 實際項目當中就是，定期做快照，然後導出某個時間點快照的數據，然後導出增量的快照的數據，就可以了

4. 實際使用

​ 在實際項目中使用就是，定期做快照，然後導出某個時間點快照的數據，然後導出增量的快照的數據。

例如：

備份：

​ 對所有的rbd的image做一個基礎快照，然後導出這個快照的數據，然後設置每天定時做快照，導出快照時間點之間的數據，這樣每天導出來的就是一個增量的數據了。

​ 設置循環周期，比如三天為一個周期。每三天循環一次，自動刪除三天前的備份。

恢復：

​ 從第一個快照導入，然後按照順序導入增量的快照即可。

本站聲明:網站內容來源於博客園,如有侵權,請聯繫我們,我們將及時處理【其他文章推薦】

※帶您來了解什麼是 USB CONNECTOR  ?

※平板收購,iphone手機收購,二手筆電回收,二手iphone收購-全台皆可收購

※自行創業 缺乏曝光? 下一步"網站設計"幫您第一時間規劃公司的門面形象

※如何讓商品強力曝光呢? 網頁設計公司幫您建置最吸引人的網站，提高曝光率!!

※綠能、環保無空污,成為電動車最新代名詞，目前市場使用率逐漸普及化

※廣告預算用在刀口上，網站設計公司幫您達到更多曝光效益

jdbc-mysql測試例子和源碼詳解

admin

目錄

簡介

什麼是JDBC

JDBC是一套連接和操作數據庫的標準、規範。通過提供DriverManager、Connection、Statement、ResultSet等接口將開發人員與數據庫提供商隔離，開發人員只需要面對JDBC接口，無需關心怎麼跟數據庫交互。

幾個重要的類

類名 作用
DriverManager 驅動管理器，用於註冊驅動，是獲取 Connection對象的入口
Driver 數據庫驅動，用於獲取Connection對象
Connection 數據庫連接，用於獲取Statement對象、管理事務
Statement sql執行器，用於執行sql
ResultSet 結果集，用於封裝和操作查詢結果
prepareCall 用於調用存儲過程

使用中的注意事項

  1. 記得釋放資源。另外，ResultSet和Statement的關閉都不會導致Connection的關閉。

  2. maven要引入oracle的驅動包，要把jar包安裝在本地倉庫或私服才行。

  3. 使用PreparedStatement而不是Statement。可以避免SQL注入，並且利用預編譯的特點可以提高效率。

使用例子

需求

使用JDBC對mysql數據庫的用戶表進行增刪改查。

工程環境

JDK：1.8

maven：3.6.1

IDE：sts4

mysql driver：8.0.15

mysql：5.7

主要步驟

一個完整的JDBC保存操作主要包括以下步驟：

  1. 註冊驅動（JDK6後會自動註冊，可忽略該步驟）;

  2. 通過DriverManager獲得Connection對象;

  3. 開啟事務;

  4. 通過Connection獲得PreparedStatement對象;

  5. 設置PreparedStatement的參數;

  6. 執行保存操作;

  7. 保存成功提交事務，保存失敗回滾事務;

  8. 釋放資源，包括Connection、PreparedStatement。

創建表

CREATE TABLE `demo_user` (
  `id` bigint(20) unsigned NOT NULL AUTO_INCREMENT COMMENT '用戶id',
  `name` varchar(16) COLLATE utf8_unicode_ci NOT NULL COMMENT '用戶名',
  `age` int(3) unsigned DEFAULT NULL COMMENT '用戶年齡',
  `gmt_create` datetime DEFAULT NULL COMMENT '記錄創建時間',
  `gmt_modified` datetime DEFAULT NULL COMMENT '記錄最近修改時間',
  `deleted` bit(1) DEFAULT b'0' COMMENT '是否刪除',
  PRIMARY KEY (`id`),
  UNIQUE KEY `uk_name` (`name`),
  KEY `index_age` (`age`)
) ENGINE=InnoDB AUTO_INCREMENT=7 DEFAULT CHARSET=utf8 COLLATE=utf8_unicode_ci

創建項目

項目類型Maven Project，打包方式jar

引入依賴

<!-- junit -->
<dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>4.12</version>
    <scope>test</scope>
</dependency>
<!-- mysql驅動的jar包 -->
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>8.0.15</version>
</dependency>
<!-- oracle驅動的jar包 -->
<!-- <dependency>
    <groupId>com.oracle</groupId>
    <artifactId>ojdbc6</artifactId>
    <version>11.2.0.2.0</version>
</dependency> -->

注意：由於oracle商業版權問題，maven並不提供Oracle JDBC driver，需要將驅動包手動添加到本地倉庫或私服。

編寫jdbc.prperties

下面的url拼接了好幾個參數，主要為了避免亂碼和時區報錯的異常。

路徑：resources目錄下

driver=com.mysql.cj.jdbc.Driver
url=jdbc:mysql://localhost:3306/github_demo?useUnicode=true&characterEncoding=utf8&serverTimezone=GMT%2B8&useSSL=true
#這裏指定了字符編碼和解碼格式，時區，是否加密傳輸
username=root
password=root
#注意，xml配置是&採用&amp;替代

如果是oracle數據庫，配置如下：

driver=oracle.jdbc.driver.OracleDriver
url=jdbc:oracle:thin:@//localhost:1521/xe
username=system
password=root

獲得Connection對象

    private static Connection createConnection() throws Exception {
        // 導入配置文件
        Properties pro = new Properties();
        InputStream in = JDBCUtil.class.getClassLoader().getResourceAsStream( "jdbc.properties" );
        Connection conn = null;
        pro.load( in );
        // 獲取配置文件的信息
        String driver = pro.getProperty( "driver" );
        String url = pro.getProperty( "url" );
        String username = pro.getProperty( "username" );
        String password = pro.getProperty( "password" );
        // 註冊驅動,JDK6后不需要再手動註冊，DirverManager的靜態代碼塊會幫我們註冊
        // Class.forName(driver);
        // 獲得連接
        conn = DriverManager.getConnection( url, username, password );
        return conn;
    }

使用Connection對象完成保存操作

這裏簡單地模擬實際業務層調用持久層，並開啟事務。另外，獲取連接、開啟事務、提交回滾、釋放資源都通過自定義的工具類 JDBCUtil 來實現，具體見源碼。

    @Test
    public void save() {
        UserDao userDao = new UserDaoImpl();
        // 創建用戶
        User user = new User( "zzf002", 18, new Date(), new Date() );
        try {
            // 開啟事務
            JDBCUtil.startTrasaction();
            // 保存用戶
            userDao.insert( user );
            // 提交事務
            JDBCUtil.commit();
        } catch( Exception e ) {
            // 回滾事務
            JDBCUtil.rollback();
            e.printStackTrace();
        } finally {
            // 釋放資源
            JDBCUtil.release();
        }
    }

接下來看看具體的保存操作，即DAO層方法。

    public void insert( User user ) throws Exception {
        String sql = "insert into demo_user (name,age,gmt_create,gmt_modified) values(?,?,?,?)";
        Connection connection = JDBCUtil.getConnection();
        //獲取PreparedStatement對象
        PreparedStatement prepareStatement = connection.prepareStatement( sql );
        //設置參數
        prepareStatement.setString( 1, user.getName() );
        prepareStatement.setInt( 2, user.getAge() );
        prepareStatement.setDate( 3, new java.sql.Date( user.getGmt_create().getTime() ) );
        prepareStatement.setDate( 4, new java.sql.Date( user.getGmt_modified().getTime() ) );
        //執行保存
        prepareStatement.executeUpdate();
        //釋放資源
        JDBCUtil.release( prepareStatement, null );
    }

源碼分析

驅動註冊

DriverManager.registerDriver

DriverManager主要用於管理數據庫驅動，併為我們提供了獲取連接對象的接口。其中，它有一個重要的成員屬性registeredDrivers，是一個CopyOnWriteArrayList集合（通過ReentrantLock實現線程安全），存放的是元素是DriverInfo對象。

    //存放數據庫驅動包裝類的集合（線程安全）
    private final static CopyOnWriteArrayList<DriverInfo> registeredDrivers = new CopyOnWriteArrayList<>(); 
    public static synchronized void registerDriver(java.sql.Driver driver)
        throws SQLException {
        //調用重載方法，傳入的DriverAction對象為null
        registerDriver(driver, null);
    }
    public static synchronized void registerDriver(java.sql.Driver driver,
            DriverAction da)
        throws SQLException {
        if(driver != null) {
            //當列表中沒有這個DriverInfo對象時，加入列表。
            //注意，這裏判斷對象是否已經存在，最終比較的是driver地址是否相等。
            registeredDrivers.addIfAbsent(new DriverInfo(driver, da));
        } else {
            throw new NullPointerException();
        }

        println("registerDriver: " + driver);

    }

為什麼集合存放的是Driver的包裝類DriverInfo對象，而不是Driver對象呢？

  1. 通過DriverInfo的源碼可知，當我們調用equals方法比較兩個DriverInfo對象是否相等時，實際上比較的是Driver對象的地址，也就是說，我可以在DriverManager中註冊多個MYSQL驅動。而如果直接存放的是Driver對象，就不能達到這種效果（因為沒有遇到需要註冊多個同類驅動的場景，所以我暫時理解不了這樣做的好處）。

  2. DriverInfo中還包含了另一個成員屬性DriverAction，當我們註銷驅動時，必須調用它的deregister方法后才能將驅動從註冊列表中移除，該方法決定註銷驅動時應該如何處理活動連接等（其實一般在構造DriverInfo進行註冊時，傳入的DriverAction對象為空，根本不會去使用到這個對象，除非一開始註冊就傳入非空DriverAction對象）。

綜上，集合中元素不是Driver對象而DriverInfo對象，主要考慮的是擴展某些功能，雖然這些功能幾乎不會用到。

注意：考慮篇幅，以下代碼經過修改，僅保留所需部分。

class DriverInfo {

    final Driver driver;
    DriverAction da;
    DriverInfo(Driver driver, DriverAction action) {
        this.driver = driver;
        da = action;
    }

    @Override
    public boolean equals(Object other) {
        //這裏對比的是地址
        return (other instanceof DriverInfo)
                && this.driver == ((DriverInfo) other).driver;
    }

}

為什麼Class.forName(com.mysql.cj.jdbc.Driver) 可以註冊驅動？

當加載com.mysql.cj.jdbc.Driver這個類時，靜態代碼塊中會執行註冊驅動的方法。

    static {
        try {
            //靜態代碼塊中註冊當前驅動
            java.sql.DriverManager.registerDriver(new Driver());
        } catch (SQLException E) {
            throw new RuntimeException("Can't register driver!");
        }
    }

為什麼JDK6后不需要Class.forName也能註冊驅動？

因為從JDK6開始，DriverManager增加了以下靜態代碼塊，當類被加載時會執行static代碼塊的loadInitialDrivers方法。

而這個方法會通過查詢系統參數（jdbc.drivers）和SPI機制兩種方式去加載數據庫驅動。

注意：考慮篇幅，以下代碼經過修改，僅保留所需部分。

    static {
        loadInitialDrivers();
    }
    //這個方法通過兩個渠道加載所有數據庫驅動：
    //1. 查詢系統參數jdbc.drivers獲得數據驅動類名
    //2. SPI機制
    private static void loadInitialDrivers() {
        //通過系統參數jdbc.drivers讀取數據庫驅動的全路徑名。該參數可以通過啟動參數來設置，其實引入SPI機制后這一步好像沒什麼意義了。
        String drivers;
        try {
            drivers = AccessController.doPrivileged(new PrivilegedAction<String>() {
                public String run() {
                    return System.getProperty("jdbc.drivers");
                }
            });
        } catch (Exception ex) {
            drivers = null;
        }
        //使用SPI機制加載驅動
        AccessController.doPrivileged(new PrivilegedAction<Void>() {
            public Void run() {
                //讀取META-INF/services/java.sql.Driver文件的類全路徑名。
                ServiceLoader<Driver> loadedDrivers = ServiceLoader.load(Driver.class);
                Iterator<Driver> driversIterator = loadedDrivers.iterator();
                //加載並初始化類
                try{
                    while(driversIterator.hasNext()) {
                        driversIterator.next();
                    }
                } catch(Throwable t) {
                // Do nothing
                }
                return null;
            }
        });

        if (drivers == null || drivers.equals("")) {
            return;
        }
        //加載jdbc.drivers參數配置的實現類
        String[] driversList = drivers.split(":");
        for (String aDriver : driversList) {
            try {
                Class.forName(aDriver, true,
                        ClassLoader.getSystemClassLoader());
            } catch (Exception ex) {
                println("DriverManager.Initialize: load failed: " + ex);
            }
        }
    }

補充：SPI機制本質上提供了一種服務發現機制，通過配置文件的方式，實現服務的自動裝載，有利於解耦和面向接口編程。具體實現過程為：在項目的META-INF/services文件夾下放入以接口全路徑名命名的文件，並在文件中加入實現類的全限定名，接着就可以通過ServiceLoder動態地加載實現類。

打開mysql的驅動包就可以看到一個java.sql.Driver文件，裏面就是mysql驅動的全路徑名。

獲得連接對象

DriverManager.getConnection

獲取連接對象的入口是DriverManager.getConnection，調用時需要傳入url、username和password。

獲取連接對象需要調用java.sql.Driver實現類（即數據庫驅動）的方法，而具體調用哪個實現類呢？

正如前面講到的，註冊的數據庫驅動被存放在registeredDrivers中，所以只有從這個集合中獲取就可以了。

注意：考慮篇幅，以下代碼經過修改，僅保留所需部分。

    public static Connection getConnection(String url, String user, String password) throws SQLException {
        java.util.Properties info = new java.util.Properties();

        if (user != null) {
            info.put("user", user);
        }
        if (password != null) {
            info.put("password", password);
        }
        //傳入url、包含username和password的信息類、當前調用類
        return (getConnection(url, info, Reflection.getCallerClass()));
    }
    private static Connection getConnection(String url, java.util.Properties info, Class<?> caller) throws SQLException {
        ClassLoader callerCL = caller != null ? caller.getClassLoader() : null;
        //遍歷所有註冊的數據庫驅動
        for(DriverInfo aDriver : registeredDrivers) {
            //先檢查這當前類加載器是否有權限加載這個驅動，如果是才進入
            if(isDriverAllowed(aDriver.driver, callerCL)) {
                //這一步是關鍵，會去調用Driver的connect方法
                Connection con = aDriver.driver.connect(url, info);
                if (con != null) {
                    return con;
                }
            } else {
                println("    skipping: " + aDriver.getClass().getName());
            }
        }
    }

com.mysql.cj.jdbc.Driver.connection

由於使用的是mysql的數據驅動，這裏實際調用的是com.mysql.cj.jdbc.Driver的方法。

從以下代碼可以看出，mysql支持支持多節點部署的策略，本文僅對單機版進行擴展。

注意：考慮篇幅，以下代碼經過修改，僅保留所需部分。

    //mysql支持多節點部署的策略，根據架構不同，url格式也有所區別。
    private static final String REPLICATION_URL_PREFIX = "jdbc:mysql:replication://";
    private static final String URL_PREFIX = "jdbc:mysql://";
    private static final String MXJ_URL_PREFIX = "jdbc:mysql:mxj://";
    public static final String LOADBALANCE_URL_PREFIX = "jdbc:mysql:loadbalance://";
    public java.sql.Connection connect(String url, Properties info) throws SQLException {
        //根據url的類型來返回不同的連接對象，這裏僅考慮單機版
        ConnectionUrl conStr = ConnectionUrl.getConnectionUrlInstance(url, info);
        switch (conStr.getType()) {
            case SINGLE_CONNECTION:
                //調用ConnectionImpl.getInstance獲取連接對象
                return com.mysql.cj.jdbc.ConnectionImpl.getInstance(conStr.getMainHost());

            case LOADBALANCE_CONNECTION:
                return LoadBalancedConnectionProxy.createProxyInstance((LoadbalanceConnectionUrl) conStr);

            case FAILOVER_CONNECTION:
                return FailoverConnectionProxy.createProxyInstance(conStr);

            case REPLICATION_CONNECTION:
                return ReplicationConnectionProxy.createProxyInstance((ReplicationConnectionUrl) conStr);

            default:
                return null;
        }
    }

ConnectionImpl.getInstance

這個類有個比較重要的字段session，可以把它看成一個會話，和我們平時瀏覽器訪問服務器的會話差不多，後續我們進行數據庫操作就是基於這個會話來實現的。

注意：考慮篇幅，以下代碼經過修改，僅保留所需部分。

    private NativeSession session = null;
    public static JdbcConnection getInstance(HostInfo hostInfo) throws SQLException {
        //調用構造
        return new ConnectionImpl(hostInfo);
    }
    public ConnectionImpl(HostInfo hostInfo) throws SQLException {
        //先根據hostInfo初始化成員屬性，包括數據庫主機名、端口、用戶名、密碼、數據庫及其他參數設置等等，這裏省略不放入。
        //最主要看下這句代碼 
        createNewIO(false);
    }
    public void createNewIO(boolean isForReconnect) {
        if (!this.autoReconnect.getValue()) {
            //這裏只看不重試的方法
            connectOneTryOnly(isForReconnect);
            return;
        }

        connectWithRetries(isForReconnect);
    }
    private void connectOneTryOnly(boolean isForReconnect) throws SQLException {

        JdbcConnection c = getProxy();
        //調用NativeSession對象的connect方法建立和數據庫的連接
        this.session.connect(this.origHostInfo, this.user, this.password, this.database, DriverManager.getLoginTimeout() * 1000, c);
        return;
    }

NativeSession.connect

接下來的代碼主要是建立會話的過程，首先時建立物理連接，然後根據協議建立會話。

注意：考慮篇幅，以下代碼經過修改，僅保留所需部分。

    public void connect(HostInfo hi, String user, String password, String database, int loginTimeout, TransactionEventHandler transactionManager)
            throws IOException {
        //首先獲得TCP/IP連接
        SocketConnection socketConnection = new NativeSocketConnection();
        socketConnection.connect(this.hostInfo.getHost(), this.hostInfo.getPort(), this.propertySet, getExceptionInterceptor(), this.log, loginTimeout);

        // 對TCP/IP連接進行協議包裝
        if (this.protocol == null) {
            this.protocol = NativeProtocol.getInstance(this, socketConnection, this.propertySet, this.log, transactionManager);
        } else {
            this.protocol.init(this, socketConnection, this.propertySet, transactionManager);
        }

        // 通過用戶名和密碼連接指定數據庫，並創建會話
        this.protocol.connect(user, password, database);
    }

針對數據庫的連接，暫時點到為止，另外還有涉及數據庫操作的源碼分析，後續再完善補充。

本文為原創文章，轉載請附上原文出處鏈接：https://github.com/ZhangZiSheng001/jdbc-demo

本站聲明:網站內容來源於博客園,如有侵權,請聯繫我們,我們將及時處理【其他文章推薦】

※為什麼 USB CONNECTOR 是電子產業重要的元件?

※收購3c,收購IPHONE,收購蘋果電腦-詳細收購流程一覽表

※網頁設計一頭霧水??該從何著手呢? 找到專業技術的網頁設計公司，幫您輕鬆架站!

※想要讓你的商品在網路上成為最夯、最多人討論的話題?

※高價收購3C產品,價格不怕你比較

※想知道最厲害的台北網頁設計公司推薦、台中網頁設計公司推薦專業設計師”嚨底家”!!

canvas入門，就是這個feel！

admin

鈣素

Canvas 是在HTML5中新增的標籤用於在網頁實時生成圖像，並且可以操作圖像內容，基本上它是一個可以用JavaScript操作的位圖。也就是說我們將通過JS完成畫圖而不是css。

canvas 默認布局為 inline-block，可以認為是一種特殊的圖片。

走起 ~

canvas 劃線

<canvas id="can" width="800" height="800"></canvas>

（寬高不能放在style裏面，否則比例不對）

canvas裏面的width和height相當於圖片的原始尺寸，加了外部style的寬高，就相當於對圖片進行壓縮和拉伸。

// 1、獲取原生dom對象
let dom = document.getElementById('can');

// 2、獲取繪圖對象
let can = dom.getContext('2d'); // 3d是webgl

// 定義線條起點
can.moveTo(0,0);

// 定義線條中點（非終點）
can.lineTo(400,400);
can.lineTo(800,0);

// 對標記範圍進行描邊
can.stroke()

// 對標記範圍進行填充
can.fill();

設置線條屬性

線條默認寬度是 1。

（一定要在繪圖之前設置。）

can.lineWidth = 2; //設置線條寬度
can.strokeStyle = '#f00';  // 設置線條顏色

can.fillStyle = '#f00';  // 設置填充區域顏色

折線樣式

  • miter：尖角（當尖角長度值過長時會自動變成折角，如果強制显示尖角：can.miterLimit = 100 設置尖角長度閾值。
  • round：圓角
  • bevel：折角
can.lineJoin = 'miter';
can.moveTo(100, 100);
can.lineTo(300, 100);
can.lineTo(100, 200);
can.stroke()

can.lineJoin = 'round';
can.moveTo(400, 100);
can.lineTo(600, 100);
can.lineTo(400, 200);
can.stroke()

can.lineJoin = 'bevel';
can.moveTo(700, 100);
can.lineTo(900, 100);
can.lineTo(700, 200);
can.stroke()

設置線帽

  • round：加圓角線帽
  • square：加直角線帽
  • butt：不加線帽
    can.lineCap = 'round';
    can.moveTo(100, 100);
    can.lineTo(300, 100);
    can.stroke()
    
     // 新建繪圖，使得上一次的繪畫樣式不會影響下面的繪畫樣式（代碼加在上一次繪畫和下一次繪畫中間。）
    can.beginPath()
    
    can.lineCap = 'square';
    can.moveTo(100, 200);
    can.lineTo(300, 200);
    can.stroke()
    
    can.beginPath()
    
    can.lineCap = 'butt';
    can.moveTo(100, 300);
    can.lineTo(300, 300);
    can.stroke()

畫矩形

// 參數：x,y,寬，高

can.rect(100,100,100,100);
can.stroke();

// 畫完即填充
can.fillRect(100,100,100,100);

畫圓弧

// 參數：圓心x，圓心y，半徑，圓弧起點與圓心的夾角度數，圓弧終點與圓心的夾角度數，true（逆時針繪畫）

can.arc(500,300,200,0,2*Math.PI/360*90,false);
can.stroke()

示例：

can.moveTo(500,300);
can.lineTo(500 + Math.sqrt(100), 300 + Math.sqrt(100))
can.arc(500, 300, 100, 2 * Math.PI / 360 *startDeg, 2 * Math.PI / 360 *endDeg, false);
can.closePath()//將圖形起點和終點用線連接起來使之成為封閉的圖形
can.fill()

Tips:

1、can.beginPath() // 新建繪圖，使得上一次的繪畫樣式不會影響下面的繪畫樣式（代碼加在上一次繪畫和下一次繪畫中間。）

2、can.closePath() //將圖形起點和終點用線連接起來使之成為封閉的圖形。

旋轉畫布

can.rotate(2*Math.PI/360*45); // 一定要寫在開始繪圖之前
can.fillRect(0,0,200, 10);

旋轉整個畫布的坐標系（參考坐標為畫布的(0,0)位置）

縮放畫布

can.scale(0.5,2);
can.fillRect(0,0,200, 10);

示例：

整個畫布：x方向縮放為原來的0.5，y方向拉伸為原來的2倍。

畫布位移

can.translate(100,100)
can.fillRect(0,0,200, 10);

保存與恢復畫布狀態

can.save() // 存檔：保存當前畫布坐標系狀態
can.restore() // 讀檔：恢復之前保存的畫布坐標系狀態

需要正確坐標系繪圖的時候，再讀檔之前的正確坐標系。

can.restore() // 將當前的畫布坐標系狀態恢復成上一次保存時的狀態
can.fillRect(dom.width/2, dom.height/2, 300, 100)

指針時鐘（案例）

<!DOCTYPE html>
<html>

<head>
    <meta charset="utf-8">
    <title>clock</title>
    <style type="text/css">
        #can {
            width: 1000px;
            height: 600px;
            background: linear-gradient(45deg, green, skyblue);
        }
    </style>
</head>

<body>
    <canvas id="can" width="2000" height="1200"></canvas>
</body>

<script type="text/javascript">
    let dom = document.getElementById('can');

    let can = dom.getContext('2d');

    // 把畫布的圓心移動到畫布的中心
    can.translate(dom.width / 2, dom.height / 2);
    // 保存當前的畫布坐標系
    can.save()


    run();



    function run() {
        setInterval(function() {
            clearCanvas();
            draw();
        }, 10);
    }

    // 繪圖
    function draw() {
        let time = new Date();
        let hour = time.getHours();
        let min = time.getMinutes();
        let sec = time.getSeconds();
        let minSec = time.getMilliseconds();

        drawPannl();
        drawHour(hour, min, sec);
        drawMin(min, sec);
        drawSec(sec, minSec);
        drawPoint();
    }

    // 最簡單的方法：由於canvas每當高度或寬度被重設時，畫布內容就會被清空
    function clearCanvas() {
        dom.height = dom.height;
        can.translate(dom.width / 2, dom.height / 2);
        can.save()
    }

    // 畫錶盤
    function drawPannl() {
        can.beginPath();

        can.restore()
        can.save()

        can.lineWidth = 10;
        can.strokeStyle = 'skyblue';
        can.arc(0, 0, 400, 0, 2 * Math.PI);
        can.stroke();

        for (let i = 0; i < 12; i++) {
            can.beginPath();
            can.lineWidth = 16;
            can.strokeStyle = 'greenyellow';

            can.rotate(2 * Math.PI / 12)

            can.moveTo(0, -395);
            can.lineTo(0, -340);
            can.stroke();
        }

        for (let i = 0; i < 60; i++) {
            can.beginPath();
            can.lineWidth = 10;
            can.strokeStyle = '#fff';

            can.rotate(2 * Math.PI / 60)

            can.moveTo(0, -395);
            can.lineTo(0, -370);
            can.stroke();
        }
    }

    // 畫時針
    function drawHour(h, m, s) {
        can.beginPath();

        can.restore()
        can.save()

        can.lineWidth = 24;
        can.strokeStyle = 'palevioletred';
        can.lineCap = 'round'
        can.rotate(2 * Math.PI / (12 * 60 * 60) * (h * 60 * 60 + m * 60 + s))
        can.moveTo(0, 0);
        can.lineTo(0, -200);
        can.stroke();
    }

    // 畫分針
    function drawMin(m, s) {
        can.beginPath();

        can.restore()
        can.save()

        can.lineWidth = 14;
        can.strokeStyle = '#09f';
        can.lineCap = 'round'
        can.rotate(2 * Math.PI / (60 * 60) * (m * 60 + s))
        can.moveTo(0, 0);
        can.lineTo(0, -260);
        can.stroke();
    }

    // 畫秒針
    function drawSec(s, ms) {
        can.beginPath();

        can.restore()
        can.save()

        can.lineWidth = 8;
        can.strokeStyle = '#f00';
        can.lineCap = 'round'
        can.rotate(2 * Math.PI / (60 * 1000) * (s * 1000 + ms));
        can.moveTo(0, 50);
        can.lineTo(0, -320);
        can.stroke();
    }


    // 畫中心點
    function drawPoint() {
        can.beginPath();

        can.restore()
        can.save()

        can.lineWidth = 10;
        can.fillStyle = 'red';
        can.arc(0, 0, 12, 0, 2 * Math.PI);
        can.fill();
    }
</script>

</html>

圓弧時鐘（案例）

<!DOCTYPE html>
<html>

<head>
    <meta charset="utf-8">
    <title>clock</title>
    <style type="text/css">
        #can {
            width: 1000px;
            height: 600px;
            background: linear-gradient(45deg, rgb(94, 53, 6), black);
        }
    </style>
</head>

<body>
    <canvas id="can" width="2000" height="1200"></canvas>
</body>

<script type="text/javascript">
    let dom = document.getElementById('can');

    let can = dom.getContext('2d');

    // 把畫布的圓心移動到畫布的中心
    can.translate(dom.width / 2, dom.height / 2);
    // 保存當前的畫布坐標系
    can.save();

    // 圓形指針起始角度
    let startDeg = 2 * Math.PI / 360 * 270;


    run();
    // draw();


    function run() {
        setInterval(function() {
            clearCanvas();
            draw();
        }, 20);
    }

    // 繪圖
    function draw() {
        let time = new Date();
        // let hour = time.getHours();
        let hour = time.getHours() > 10 ? time.getHours() - 12 : time.getHours();
        let min = time.getMinutes();
        let sec = time.getSeconds();
        let minSec = time.getMilliseconds();

        drawPannl();
        drawTime(hour, min, sec, minSec);
        drawHour(hour, min, sec);
        drawMin(min, sec);
        drawSec(sec, minSec);
        drawPoint();
    }

    // 最簡單的方法：由於canvas每當高度或寬度被重設時，畫布內容就會被清空
    function clearCanvas() {
        dom.height = dom.height;
        can.translate(dom.width / 2, dom.height / 2);
        can.save()
    }

    // 畫錶盤
    function drawPannl() {

        can.restore()
        can.save()

        // 設置時錶盤
        can.beginPath();
        can.lineWidth = 50;
        can.strokeStyle = 'rgba(255,23,87,0.2)';
        can.arc(0, 0, 400, 0, 2 * Math.PI);
        can.stroke();
        // 設置分錶盤
        can.beginPath();
        can.strokeStyle = 'rgba(169,242,15,0.2)';
        can.arc(0, 0, 345, 0, 2 * Math.PI);
        can.stroke();
        // 設置秒錶盤
        can.beginPath();
        can.strokeStyle = 'rgba(21,202,230,0.2)';
        can.arc(0, 0, 290, 0, 2 * Math.PI);
        can.stroke();


        // 小時刻度
        // for (let i = 0; i < 12; i++) {
        //     can.beginPath();
        //     can.lineWidth = 16;
        //     can.strokeStyle = 'rgba(0,0,0,0.2)';

        //     can.rotate(2 * Math.PI / 12)

        //     can.moveTo(0, -375);
        //     can.lineTo(0, -425);
        //     can.stroke();
        // }

        // 分針刻度
        // for (let i = 0; i < 60; i++) {
        //     can.beginPath();
        //     can.lineWidth = 10;
        //     can.strokeStyle = '#fff';

        //     can.rotate(2 * Math.PI / 60)

        //     can.moveTo(0, -395);
        //     can.lineTo(0, -370);
        //     can.stroke();
        // }
    }

    // 畫時針
    function drawHour(h, m, s) {

        let rotateDeg = 2 * Math.PI / (12 * 60 * 60) * (h * 60 * 60 + m * 60 + s);

        can.beginPath();
        can.restore()
        can.save()

        // 時針圓弧
        can.lineWidth = 50;
        can.strokeStyle = 'rgb(255,23,87)';
        can.lineCap = 'round';
        can.shadowColor = "rgb(255,23,87)"; // 設置陰影顏色
        can.shadowBlur = 20; // 設置陰影範圍
        can.arc(0, 0, 400, startDeg, startDeg + rotateDeg);
        can.stroke();

        // 時針指針
        can.beginPath();
        can.lineWidth = 24;
        can.strokeStyle = 'rgb(255,23,87)';
        can.lineCap = 'round'
        can.rotate(rotateDeg)
        can.moveTo(0, 0);
        can.lineTo(0, -100);
        can.stroke();



    }

    // 畫分針
    function drawMin(m, s) {

        let rotateDeg = 2 * Math.PI / (60 * 60) * (m * 60 + s);

        can.beginPath();
        can.restore()
        can.save()

        // 分針圓弧
        can.lineWidth = 50;
        can.strokeStyle = 'rgb(169,242,15)';
        can.lineCap = 'round'
        can.shadowColor = "rgb(169,242,15)";
        can.shadowBlur = 20;
        can.arc(0, 0, 345, startDeg, startDeg + rotateDeg);
        can.stroke();

        // 分針指針
        can.beginPath();
        can.lineWidth = 14;
        can.strokeStyle = 'rgb(169,242,15)';
        can.lineCap = 'round'
        can.rotate(rotateDeg)
        can.moveTo(0, 0);
        can.lineTo(0, -160);
        can.stroke();
    }

    // 畫秒針
    function drawSec(s, ms) {

        let rotateDeg = 2 * Math.PI / (60 * 1000) * (s * 1000 + ms);

        can.beginPath();
        can.restore()
        can.save()

        can.lineWidth = 50;
        can.strokeStyle = 'rgb(21,202,230)';
        can.lineCap = 'round'
        can.arc(0, 0, 290, startDeg, startDeg + rotateDeg);
        can.stroke();

        can.beginPath();
        can.lineWidth = 8;
        can.strokeStyle = 'rgb(21,202,230)';
        can.lineCap = 'round'
        can.shadowColor = "rgb(21,202,230)";
        can.shadowBlur = 20;
        can.rotate(rotateDeg);
        can.moveTo(0, 50);
        can.lineTo(0, -220);
        can.stroke();
    }


    // 畫中心點
    function drawPoint() {
        can.beginPath();
        can.restore()
        can.save()

        can.lineWidth = 10;
        can.fillStyle = 'red';
        can.arc(0, 0, 12, 0, 2 * Math.PI);
        can.fill();
    }

    // 显示数字時鐘
    function drawTime(h, m, s, ms) {
        can.font = '60px Calibri';
        can.fillStyle = '#0f0'
        can.shadowColor = "#fff";
        can.shadowBlur = 20;
        can.fillText(`${h}:${m}:${s}.${ms}`, -140, -100);
    }
</script>

</html>

（啾咪 ^.<）

本站聲明:網站內容來源於博客園,如有侵權,請聯繫我們,我們將及時處理【其他文章推薦】

※USB CONNECTOR掌控什麼技術要點? 帶您認識其相關發展及效能

※高價3c回收,收購空拍機,收購鏡頭,收購 MACBOOK-更多收購平台討論專區

※評比前十大台北網頁設計、台北網站設計公司知名案例作品心得分享

※收購3c瘋!各款手機、筆電、相機、平板,歡迎來詢價!

※智慧手機時代的來臨，RWD網頁設計已成為網頁設計推薦首選

地理文本處理技術在高德的演進(上)

admin

一、背景

地圖App的功能可以簡單概括為定位，搜索，導航三部分，分別解決在哪裡，去哪裡，和怎麼去的問題。高德地圖的搜索場景下，輸入的是，地理相關的檢索query，用戶位置，App圖面等信息，輸出的是，用戶想要的POI。如何能夠更加精準地找到用戶想要的POI，提高滿意度，是評價搜索效果的最關鍵指標。

一個搜索引擎通常可以拆分成query分析、召回、排序三個部分，query分析主要是嘗試理解query表達的含義，為召回和排序給予指導。

地圖搜索的query分析不僅包括通用搜索下的分詞，成分分析，同義詞，糾錯等通用NLP技術，還包括城市分析，wherewhat分析，路徑規劃分析等特定的意圖理解方式。

常見的一些地圖場景下的query意圖表達如下：

query分析是搜索引擎中策略密集的場景，通常會應用NLP領域的各種技術。地圖場景下的query分析，只需要處理地理相關的文本，多樣性不如網頁搜索，看起來會簡單一些。但是，地理文本通常比較短，並且用戶大部分的需求是唯一少量結果，要求精準度非常高，如何能夠做好地圖場景下的文本分析，並提升搜索結果的質量，是充滿挑戰的。

二、整體技術架構

搜索架構

類似於通用檢索的架構，地圖的檢索架構包括query分析，召回，排序三個主要部分。先驗的，用戶的輸入信息可以理解為多種意圖的表達，同時下發請求嘗試獲取檢索結果。后驗的，拿到每種意圖的檢索結果時，進行綜合判斷，選擇效果最好的那個。

query分析流程

具體的意圖理解可分為基礎query分析和應用query分析兩部分，基礎query分析主要是使用一些通用的NLP技術對query進行理解，包括分析，成分分析，省略，同義詞，糾錯等。應用query分析主要是針對地圖場景里的特定問題，包括分析用戶目標城市，是否是where+what表達，是否是從A到B的路徑規劃需求表達等。

整體技術演進

在地里文本處理上整體的技術演進經歷了規則為主，到逐步引入機器學習，到機器學習全面應用的過程。由於搜索模塊是一個高併發的線上服務，對於深度模型的引入有比較苛刻的條件，但隨着性能問題逐漸被解決，我們從各個子方向逐步引入深度學習的技術，進行新一輪的效果提升。

NLP領域技術在最近幾年取得了日新月異的發展，bert，XLNet等模型相繼霸榜，我們逐步統一化各個query分析子任務，使用統一的向量表示對進行用戶需求進行表達，同時進行seq2seq的多任務學習，在效果進一步提升的基礎上，也能夠保證系統不會過於臃腫。

本文就高德地圖搜索的地理文本處理，介紹相關的技術在過去幾年的演進。我們將選取一些點分上下兩篇進行介紹，上篇主要介紹搜索引擎中一些通用的query分析技術，包括糾錯，改寫和省略。下篇着重介紹地圖場景中特有query分析技術，包括城市分析，wherewhat分析，路徑規劃。

三、通用query分析技術演進

3.1 糾錯

在搜索引擎中，用戶輸入的檢索詞（query）經常會出現拼寫錯誤。如果直接對錯誤的query進行檢索，往往不會得到用戶想要的結果。因此不管是通用搜索引擎還是垂直搜索引擎，都會對用戶的query進行糾錯，最大概率獲得用戶想搜的query。

在目前的地圖搜索中，約有6%-10%的用戶請求會輸入錯誤，所以query糾錯在地圖搜索中是一個很重要的模塊，能夠極大的提升用戶搜索體驗。

在搜索引擎中，低頻和中長尾問題往往比較難解決，也是糾錯模塊面臨的主要問題。另外，地圖搜索和通用搜索，存在一個明顯的差異，地圖搜索query結構化比較突出，query中的片段往往包含一定的位置信息，如何利用好query中的結構化信息，更好地識別用戶意圖，是地圖糾錯獨有的挑戰。

常見錯誤分類

(1) 拼音相同或者相近，例如: 盤橋物流園-潘橋物流園
(2) 字形相近，例如: 河北冒黎-河北昌黎
(3) 多字或者漏字，例如: 泉州州頂街-泉州頂街

糾錯現狀

原始糾錯模塊包括多種召回方式，如：

拼音糾錯：主要解決短query的拼音糾錯問題，拼音完全相同或者模糊音作為糾錯候選。
拼寫糾錯：也叫形近字糾錯，通過遍歷替換形近字，用query熱度過濾，加入候選。
組合糾錯：通過翻譯模型進行糾錯替換，資源主要是通過query對齊挖掘的各種替換資源。

組合糾錯翻譯模型計算公式：

其中p(f)是語言模型，p(f|e)是替換模型。

問題1：召回方式存在缺陷。目前query糾錯模塊主要召回策略包括拼音召回、形近字召回，以及替換資源召回。對於低頻case，解決能力有限。

問題2：排序方式不合理。糾錯按照召回方式分為幾個獨立的模塊，分別完成相應的召回和排序，不合理。

技術改造

改造1：基於空間關係的實體糾錯
原始的糾錯主要是基於用戶session挖掘片段替換資源，所以對於低頻問題解決能力有限。但是長尾問題往往集中在低頻，所以低頻問題是當前的痛點。

地圖搜索與通用搜索引擎有個很大的區別在於，地圖搜索query比較結構化，例如北京市朝陽區阜榮街10號首開廣場。我們可以對query進行結構化切分（也就是地圖中成分分析的工作），得到這樣一種帶有類別的結構化描述，北京市【城市】朝陽區【區縣】阜榮街【道路】10號【門址後綴】首開廣場【通用實體】。

同時，我們擁有權威的地理知識數據，利用權威化的地理實體庫進行前綴樹+後綴樹的索引建庫，提取疑似糾錯的部分在索引庫中進行拉鏈召回，同時利用實體庫中的邏輯隸屬關係對糾錯結果進行過濾。實踐表明，這種方式對低頻的區劃或者實體的錯誤有着明顯的作用。

基於字根的字形相似度計算

上文提到的排序策略裏面通過字形的編輯距離作為排序的重要特徵，這裏我們開發了一個基於字根的字形相似度計算策略，對於編輯距離的計算更為細化和準確。漢字信息有漢字的字根拆分詞表和漢字的筆畫數。

將一個漢字拆分成多個字根，尋找兩個字的公共字根，根據公共字根筆畫數來計算連個字的相似度。

改造2：排序策略重構

原始的策略召回和排序策略耦合，導致不同的召回鏈路，存在顧此失彼的情況。為了能夠充分發揮各種召回方式的優勢，急需要對召回和排序進行解耦並進行全局排序優化。為此我們增加了排序模塊，將流程分為召回和排序兩階段。

模型選擇

對於這個排序問題，這裏我們參考業界的實踐，使用了基於pair-wise的gbrank進行模型訓練。

樣本建設

通過線上輸出結合人工review的方式構造樣本。

特徵建設
(1) 語義特徵。如統計語言模型。
(2) 熱度特徵。pv，點擊等。
(3) 基礎特徵。編輯距離，切詞和成分特徵，累積分佈特徵等。

這裏解決了糾錯模塊兩個痛點問題，一個是在地圖場景下的大部分低頻糾錯問題。另一個是重構了模塊流程，將召回和排序解耦，充分發揮各個召回鏈路的作用，召回方式更新后只需要重訓排序模型即可，使得模塊更加合理，為後面的深度模型升級打下良好的基礎。後面在這個框架下，我們通過深度模型進行seq2seq的糾錯召回，取得了進一步的收益。

3.2 改寫

糾錯作為query變換的一種方式的召回策略存在諸多限制，對於一些非典型的query變換表達，存在策略的空白。比如query=永城市新農合辦，目標POI是永城市新農合服務大廳。用戶的低頻query，往往得不到較好搜索效果，但其實用戶描述的語義與主poi的高頻query是相似的。

這裏我們提出一種query改寫的思路，可以將低頻query改寫成語義相似的高頻query，以更好地滿足用戶需求多樣性的表達。

這是一個從無到有的實現。用戶表達的query是多樣的，使用規則表達顯然是難以窮盡的，直觀的思路是通過向量的方式召回，但是向量召回的方式很可能出現泛化過多，不適應地圖場景的檢索的問題，這些都是要在實踐過程中需要考慮的問題。

方案

整體看，方案包括召回，排序，過濾，三個階段。

召回階段

我們調研了句子向量表示的幾種方法，選擇了算法簡單，效果和性能可以和CNN，RNN媲美的SIF（Smooth Inverse Frequency）。向量召回可以使用開源的Faiss向量搜索引擎，這裏我們使用了阿里內部的性能更好的的向量檢索引擎。

排序階段
樣本構建
原query與高頻query候選集合，計算語義相似度，選取語義相似度的TOPK，人工標註的訓練樣本。

特徵建設

1.基礎文本特徵
2.編輯距離
3.組合特徵

模型選擇

使用xgboost進行分數回歸

過濾階段
通過向量召回的query過度泛化非常嚴重，為了能夠在地圖場景下進行應用，增加了對齊模型。使用了兩種統計對齊模型giza和fastalign，實驗證明二者效果幾乎一致，但fastalign在性能上好於giza，所以選擇fastalign。

通過對齊概率和非對齊概率，對召回的結果進行進一步過濾，得到精度比較高的結果。

query改寫填補了原始query分析模塊中一些低頻表達無法滿足的空白，區別於同義詞或者糾錯的顯式query變換表達，句子的向量表示是相似query的一種隱式的表達，有其相應的優勢。

向量表示和召回也是深度學習模型逐步開始應用的嘗試。同義詞，改寫，糾錯，作為地圖中query變換主要的三種方式，以往在地圖模塊里比較分散，各司其職，也會有互相重疊的部分。在後續的迭代升級中，我們引入了統一的query變換模型進行改造，在取得收益的同時，也擺脫掉了過去很多規則以及模型耦合造成的歷史包袱。

3.2 省略

在地圖搜索場景里，有很多query包含無效詞，如果用全部query嘗試去召回很可能不能召回有效結果。如廈門市搜”湖裡區縣后高新技術園新捷創運營中心11樓1101室 縣后brt站”。這就需要一種檢索意圖，在不明顯轉義下，使用核心term進行召回目標poi候選集合，當搜索結果無果或者召回較差時起到補充召回的作用。

在省略判斷的過程中存在先驗后驗平衡的問題。省略意圖是一個先驗的判斷，但是期望的結果是能夠進行POI有效召回，和POI的召回字段的現狀密切相關。如何能夠在策略設計的過程中保持先驗的一致性，同時能夠在後驗POI中拿到相對好的效果，是做好省略模塊比較困難的地方。

原始的省略模塊主要是基於規則進行的，規則依賴的主要特徵是上游的成分分析特徵。由於基於規則擬合，模型效果存在比較大的優化空間。另外，由於強依賴成分分析，模型的魯棒性並不好。

技術改造

省略模塊的改造主要完成了規則到crf模型的升級，其中也離線應用了深度學習模型輔助樣本生成。

模型選擇

識別出來query哪些部分是核心哪些部分是可以省略的，是一個序列標註問題。在淺層模型的選型中，顯而易見地，我們使用了crf模型。

特徵建設

term特徵。使用了賦權特徵，詞性，先驗詞典特徵等。
成分特徵。仍然使用成分分析的特徵。
統計特徵。統計片段的左右邊界熵，城市分佈熵等，通過分箱進行離散化。

樣本建設

項目一期我們使用了使用線上策略粗標，外包細標的方式，構造了萬級的樣本供crf模型訓練。

但是省略query的多樣性很高，使用萬級的樣本是不夠的，在線上模型無法快速應用深度模型的情況下，我們使用了boostraping的方式，藉助深度模型的泛化能力，離線構造了大量樣本。

使用了這種方式，樣本從萬級很容易擴充到百萬級，我們仍然使用crf模型進行訓練和線上應用。

在省略模塊，我們完成了規則到機器學習的升級，引入了成分以外的其他特徵，提升了模型的魯棒性。同時並且利用離線深度學習的方式進行樣本構造的循環，提升了樣本的多樣性，使得模型能夠更加接近crf的天花板。

在後續深度模型的建模中，我們逐步擺脫了對成分分析特徵的依賴，對query到命中poi核心直接進行建模，構建大量樣本，取得了進一步的收益。

 

本站聲明:網站內容來源於博客園,如有侵權,請聯繫我們,我們將及時處理【其他文章推薦】

※3c收購,鏡頭 收購有可能以全新價回收嗎?

※台北網頁設計公司這麼多，該如何挑選?? 網頁設計報價省錢懶人包"嚨底家"

※網頁設計公司推薦更多不同的設計風格，搶佔消費者視覺第一線

※想知道購買電動車哪裡補助最多?台中電動車補助資訊懶人包彙整

※賣IPHONE,iPhone回收,舊換新!教你怎麼賣才划算?