月份: 2020 年 1 月

SpringBoot源碼學習系列之SpringMVC自動配置

admin

目錄

源碼學習系列之WebMvc自動配置原理筆記

@

web的自動配置在SpringBoot項目中是一個很重要的方面，實現代碼在spring-boot-autoconfigure工程里：

按照官方文檔的說法，SpringBoot官方的說法，Springboot的SpringMVC自動配置，主要提供了如下自動配置：

WebMvcAutoConfiguration.java這個類很關鍵，這個就是SpringBoot Springmvc自動配置的一個很關鍵的配置類

@Configuration(proxyBeanMethods = false)//指定WebMvcAutoConfiguration不代理方法
@ConditionalOnWebApplication(type = Type.SERVLET)//在web環境(selvlet)才會起效
@ConditionalOnClass({ Servlet.class, DispatcherServlet.class, WebMvcConfigurer.class })//系統有有Servlet，DispatcherServlet(Spring核心的分發器)，WebMvcConfigurer的情況，這個自動配置類才起效
@ConditionalOnMissingBean(WebMvcConfigurationSupport.class)//系統沒有WebMvcConfigurationSupport這個類的情況，自動配置起效
@AutoConfigureOrder(Ordered.HIGHEST_PRECEDENCE + 10)
@AutoConfigureAfter({ DispatcherServletAutoConfiguration.class, TaskExecutionAutoConfiguration.class,
        ValidationAutoConfiguration.class })
public class WebMvcAutoConfiguration {
....
}

翻下源碼，可以看到WebMvcAutoConfiguration自動配置類里還有一個WebMvcConfigurer類型的配置類，2.2.1版本是implements WebMvcConfigurer接口，1.+版本是extends WebMvcConfigurerAdapter 

@Configuration(proxyBeanMethods = false)//定義為配置類
    @Import(EnableWebMvcConfiguration.class)//spring底層註解,將EnableWebMvcConfiguration加到容器
    @EnableConfigurationProperties({ WebMvcProperties.class, ResourceProperties.class })//使WebMvcProperties、ResourceProperties配置類生效
    @Order(0)
    public static class WebMvcAutoConfigurationAdapter implements WebMvcConfigurer {
    ....
}

1、ContentNegotiatingViewResolver

如圖，是視圖解析器的自動配置，這個類起效的情況是系統沒有ContentNegotiatingViewResolver類的情況，就調用改方法自動創建ContentNegotiatingViewResolver類

關鍵的是ContentNegotiatingViewResolver類，翻下ContentNegotiatingViewResolver類，找到如下重要的初始化方法

@Override
    protected void initServletContext(ServletContext servletContext) {
    //調用Spring的BeanFactoryUtils掃描容器里的所有視圖解析器ViewResolver類
        Collection<ViewResolver> matchingBeans =
                BeanFactoryUtils.beansOfTypeIncludingAncestors(obtainApplicationContext(), ViewResolver.class).values();
        if (this.viewResolvers == null) {
            this.viewResolvers = new ArrayList<>(matchingBeans.size());
            //遍歷候選的viewResolvers，封裝到this.viewResolvers列表
            for (ViewResolver viewResolver : matchingBeans) {
                if (this != viewResolver) {
                    this.viewResolvers.add(viewResolver);
                }
            }
        }
        else {
            for (int i = 0; i < this.viewResolvers.size(); i++) {
                ViewResolver vr = this.viewResolvers.get(i);
                if (matchingBeans.contains(vr)) {
                    continue;
                }
                String name = vr.getClass().getName() + i;
                obtainApplicationContext().getAutowireCapableBeanFactory().initializeBean(vr, name);
            }

        }
        AnnotationAwareOrderComparator.sort(this.viewResolvers);
        this.cnmFactoryBean.setServletContext(servletContext);
    }

所以ContentNegotiatingViewResolver類的作用就是組合所有的視圖解析器，自動配置了ViewResolver(視圖解析器作用，根據方法返回值得到視圖對象view)

往下翻代碼，可以看到resolveViewName方法，裏面代碼是從this.viewResolvers獲取候選的視圖解析器，遍歷容器里所有視圖，然後通過如圖所標記的獲取候選視圖的方法，獲取候選的視圖列表，再通過getBestView獲取最合適的視圖

遍歷所有的視圖解析器對象，從視圖解析器里獲取候選的視圖，封裝成list保存

ok，跟了源碼就是只要將視圖解析器丟到Spring容器里，就可以加載到

寫個簡單的視圖解析類

DispatcherServlet是Spring核心分發器，找到doDispatch方法，debug，可以看到加的視圖解析器加載到了

2、靜態資源

也就是官方說的，如下圖所示：

翻譯過來就是支持靜態資源包括webjars的自動配置，webjars，就是以maven等等方式打成jar包的靜態資源，可以去看看文檔：

使用的話，直接去webjars官網負責對應的配置，加到項目里就可以

路徑都是在META-INF/webjars/**

WebMvcAutoConfiguration.addResourceHandlers，這個是比較重要的資源配置方法

@Override
        public void addResourceHandlers(ResourceHandlerRegistry registry) {
            if (!this.resourceProperties.isAddMappings()) {
                logger.debug("Default resource handling disabled");
                return;
            }
            Duration cachePeriod = this.resourceProperties.getCache().getPeriod();
            //CacheControl是Spring框架提供的http緩存
            CacheControl cacheControl = this.resourceProperties.getCache().getCachecontrol().toHttpCacheControl();
            //讀取到webjars資源，將classpath:/META-INF/resources/webjars/的webjars資源都掃描出來
            if (!registry.hasMappingForPattern("/webjars/**")) {
                customizeResourceHandlerRegistration(registry.addResourceHandler("/webjars/**")
                        .addResourceLocations("classpath:/META-INF/resources/webjars/")
                        .setCachePeriod(getSeconds(cachePeriod)).setCacheControl(cacheControl));
            }
            String staticPathPattern = this.mvcProperties.getStaticPathPattern();
            if (!registry.hasMappingForPattern(staticPathPattern)) {
                customizeResourceHandlerRegistration(registry.addResourceHandler(staticPathPattern)
                        .addResourceLocations(getResourceLocations(this.resourceProperties.getStaticLocations()))
                        .setCachePeriod(getSeconds(cachePeriod)).setCacheControl(cacheControl));
            }
        }

ok，通過源碼可以知道，Springboot支持webjars和其它等等靜態資源，其它的靜態資源要放在如下目錄里，Springboot就能自動加載到

  • classpath:/META-INF/resources/
  • classpath:/resources/
  • classpath:/static/
  • classpath:/public/
  • classpath:/

3、自動註冊 Converter, GenericConverter, and Formatter beans.

翻譯過來就是自動註冊了 Converter, GenericConverter, and Formatter beans.

  • Converter：轉換器 ，作用就是能自動進行類型轉換
    eg： public String hello(User user)，這是一個方法，然後前端視圖傳來的參數通過轉換器能夠根據屬性進行映射，然後進行屬性類型轉換
  • Formatter ：格式化器，eg：比如對前端傳來的日期2019/11/25，進行格式化處理

源碼在這裏，WebMvcAutoConfiguration.addFormatters方法是添加格式化器的方法

同理，也是從Spring容器里將這幾種類拿過來

當然，還有其它的，比如WebMvcAutoConfiguration.localeResolver方法是實現i18n國際化語言支持的自動配置

@Bean
        @ConditionalOnMissingBean//沒有自定義localeResolver的情況
        @ConditionalOnProperty(prefix = "spring.mvc", name = "locale")//application.properties有配置了spring.mvc.locale
        public LocaleResolver localeResolver() {
            if (this.mvcProperties.getLocaleResolver() == WebMvcProperties.LocaleResolver.FIXED) {
                return new FixedLocaleResolver(this.mvcProperties.getLocale());
            }
            //默認使用AcceptHeaderLocaleResolver 
            AcceptHeaderLocaleResolver localeResolver = new AcceptHeaderLocaleResolver();
            localeResolver.setDefaultLocale(this.mvcProperties.getLocale());
            return localeResolver;
        }

具體的源碼參考我之前博客：，博客裏面有涉及源碼的

4、支持HttpMessageConverters

HttpMessageConverters ：消息轉換器，Springmvc中用來轉換http請求和響應的

源碼里是通過configureMessageConverters方法實現，很顯然也是從容器里獲取的

官方文檔里也進行了比較詳細描述，Springboot已經為我們自動配置了json的、xml的自動轉換器，當然你也可以自己添加

5、支持MessageCodesResolver

MessageCodesResolver：是消息解析器，WebMvcAutoConfiguration.getMessageCodesResolver是實現Exception異常信息格式的

WebMvcProperties配置文件定義的一個異常枚舉值

格式為如圖所示，定了了錯誤代碼是生成規則：

6、首頁支持

Springboot默認的首頁是index.html，也就是你在classpath路徑丟個index.html文件，就被Springboot默認為首頁，或者說歡迎頁

如圖示代碼，就是遍歷靜態資源文件，然後獲取index.html作為歡迎頁面

7、網站logo設置

Springboot1.+版本，是有默認的logo圖標的，2.2.1版本，經過全局搜索，沒有發現給自定義的圖標，使用的話，是直接丟在classpath路徑，文件命名為favicon.ico，不過在2.2.1代碼並沒有找到相應的配置代碼，1.+版本是有的，不過文檔還是有描述了

8、ConfigurableWebBindingInitializer 初始綁定器

跟下源碼，也是從Spring容器里獲取的，然後注意到，如果沒有這個ConfigurableWebBindingInitializer ，代碼就會調用基類的getConfigurableWebBindingInitializer

源碼，這裏也是創建一個getConfigurableWebBindingInitializer

ConfigurableWebBindingInitializer 是Springboot為系統自動配置的，當然我們也可以自己定義一個ConfigurableWebBindingInitializer ，然後加載到容器里即可

初始化綁定的方法，ok，本博客簡單跟一下源碼

注意：
ok，Springboot官方文檔里還有這樣的描述，如圖所示

意思是，在使用webmvcConfigurer配置的時候，不要使用@EnableWebMvc註解，為什麼不要使用呢？因為使用了@EnableWebMvc，就是實現全面接管SpringMVC自動配置，也就是說其它的自動配置都會失效，全部自己配置

原理是為什麼？可以簡單跟一下源碼，如圖，SpringMVC自動配置類，有這個很關鍵的註解，這個註解的意思是@WebMvcConfigurationSupport註解不在系統時候自動配置才起效

然後為什麼加了@EnableWebMvc自動配置就可以被全面接管？點一下@EnableWebMvc源碼

很顯然，DelegatingWebMvcConfiguration類extends WebMvcConfigurationSupport類，所以這也就是為什麼@EnableWebMvc註解能實現全面接管自動配置的原理

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

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

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

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

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

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

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

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網頁設計已成為網頁設計推薦首選