設計模式 - 單例模式(詳解)看看和你理解的是否一樣?

来源:https://www.cnblogs.com/eamonzzz/archive/2019/10/08/11633482.html

一、概述 單例模式是設計模式中相對簡單且非常常見的一種設計模式,但是同時也是非常經典的 高頻 面試題,相信還是有很多人在面試時會掛在這裡。本篇文章主要針對單例模式做一個回顧,記錄單例模式的應用場景、常見寫法、針對線程安全進行調試(看得見的線程)以及總結。相信大家看完這篇文章之後,對單例模式有一個非常 ...


一、概述

單例模式是設計模式中相對簡單且非常常見的一種設計模式,但是同時也是非常經典的高頻面試題,相信還是有很多人在面試時會掛在這裡。本篇文章主要針對單例模式做一個回顧,記錄單例模式的應用場景、常見寫法、針對線程安全進行調試(看得見的線程)以及總結。相信大家看完這篇文章之後,對單例模式有一個非常深刻的認識。

文章中按照常見的單例模式的寫法,由淺入深進行講解記錄;以及指出該寫法的不足,從而進行演進改造。

秉承廢話少說的原則,我們下麵快速開始

二、定義

單例模式(Singleton Pattern)是指確保一個類在任何情況下都絕對只有一個實例,並提供一個全局訪問點。

單例模式是創建型模式。

三、應用場景

  1. 生活中的單例:例如,國家主席、公司 CEO、部門經理等。
  2. Java世界中:ServletContextServletContextConfig 等;
  3. Spring 框架應用中:ApplicationContext、資料庫的連接池也都是單例形式。

四、常見的單例模式寫法

單例模式主要有:餓漢式單例、懶漢式單例(線程不安全型、線程安全型、雙重檢查鎖類型、靜態內部類類型)、註冊式(登記式)單例(枚舉式單例、容器式單例)、ThreadLocal線程單例

下麵我們來看看各種模式的寫法。

1、餓漢式單例

餓漢式單例是在類載入的時候就立即初始化,並且創建單例對象。絕對線程安全,線上程還沒出現以前就是實例化了,不可能存在訪問安全問題。

Spring 中 IOC 容器 ApplicationContext 就是典型的餓漢式單例

優缺點

優點:沒有加任何的鎖、執行效率比較高,在用戶體驗上來說,比懶漢式更好。

缺點:類載入的時候就初始化,不管用與不用都占著空間,浪費了記憶體,有可能占著茅坑不拉屎。

寫法

/**
 * @author eamon.zhang
 * @date 2019-09-30 上午9:26
 */
public class HungrySingleton {
    // 1.私有化構造器
    private HungrySingleton (){}
    // 2.在類的內部創建自行實例
    private static final HungrySingleton instance = new HungrySingleton();
    // 3.提供獲取唯一實例的方法(全局訪問點)
    public static HungrySingleton getInstance(){
        return instance;
    }
}

還有另外一種寫法,利用靜態代碼塊的機制:

/**
 * @author eamon.zhang
 * @date 2019-09-30 上午10:46
 */
public class HungryStaticSingleton {
    // 1. 私有化構造器
    private HungryStaticSingleton(){}

    // 2. 實例變數
    private static final HungryStaticSingleton instance;

    // 3. 在靜態代碼塊中實例化
    static {
        instance = new HungryStaticSingleton();
    }

    // 4. 提供獲取實例方法
    public static HungryStaticSingleton getInstance(){
        return instance;
    }
}

測試代碼,我們創建 10 個線程(具體線程發令槍 ConcurrentExecutor 在文末源碼中獲取):

/**
 * @author eamon.zhang
 * @date 2019-09-30 上午11:17
 */
public class HungrySingletonTest {
    @Test
    public void test() {
        try {
            ConcurrentExecutor.execute(() -> {
                HungrySingleton instance = HungrySingleton.getInstance();
                System.out.println(Thread.currentThread().getName() + " : " + instance);
            }, 10, 10);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

測試結果:

pool-1-thread-6 : [email protected]37cce6
pool-1-thread-1 : [email protected]37cce6
pool-1-thread-9 : [email protected]37cce6
pool-1-thread-10 : [email protected]37cce6
pool-1-thread-2 : [email protected]37cce6
pool-1-thread-7 : [email protected]37cce6
pool-1-thread-5 : [email protected]37cce6
pool-1-thread-3 : [email protected]37cce6
pool-1-thread-4 : [email protected]37cce6
pool-1-thread-8 : [email protected]37cce6
...

可以看到,餓漢式每次獲取實例都是同一個。

使用場景

這兩種寫法都非常的簡單,也非常好理解,餓漢式適用在單例對象較少的情況。

下麵我們來看性能更優的寫法——懶漢式單例。


2、懶漢式單例

懶漢式單例的特點是:被外部類調用的時候內部類才會載入。

懶漢式單例可以分為下麵這幾種寫法來。

簡單懶漢式(線程不安全)

這是懶漢式單例的簡單寫法

/**
 * @author eamon.zhang
 * @date 2019-09-30 上午10:55
 */
public class LazySimpleSingleton {
    private LazySimpleSingleton(){}
    private static LazySimpleSingleton instance = null;

    public static LazySimpleSingleton getInstance(){
        if (instance == null) {
            instance = new LazySimpleSingleton();
        }
        return instance;
    }
}

我們創建一個多線程來測試一下,是否線程安全:

/**
 * @author eamon.zhang
 * @date 2019-09-30 上午11:12
 */
public class LazySimpleSingletonTest {

    @Test
    public void test() {
        try {
            ConcurrentExecutor.execute(() -> {
                LazySimpleSingleton instance = LazySimpleSingleton.getInstance();
                System.out.println(Thread.currentThread().getName() + " : " + instance);
            }, 5, 5);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

}

運行結果:

pool-1-thread-3 : [email protected]abe194f
pool-1-thread-5 : [email protected]abe194f
pool-1-thread-1 : [email protected]748e48d0
pool-1-thread-2 : [email protected]abe194f
pool-1-thread-4 : [email protected]abe194f

從測試結果來看,一定幾率出現創建兩個不同結果的情況,意味著上面的單例存線上程安全隱患。

至於為什麼?由於篇幅問題,我們在後面一篇文章中利用測試工具進行詳細的分析(這可能也是面試中面試官會問到的問題)。大家現在只需要知道簡單的懶漢式會存在這麼一個問題就行了。

簡單懶漢式(線程安全)

通過對上面簡單懶漢式單例的測試,我們知道存線上程安全隱患,那麼,如何來避免或者解決呢?

我們都知道 java 中有一個synchronized可以來對共用資源進行加鎖,保證在同一時刻只能有一個線程拿到該資源,其他線程只能等待。所以,我們對上面的簡單懶漢式進行改造,給getInstance() 方法加上synchronized

/**
 * @author eamon.zhang
 * @date 2019-09-30 上午10:55
 */
public class LazySimpleSyncSingleton {
    private LazySimpleSyncSingleton() {
    }

    private static LazySimpleSyncSingleton instance = null;

    public synchronized static LazySimpleSyncSingleton getInstance() {
        if (instance == null) {
            instance = new LazySimpleSyncSingleton();
        }
        return instance;
    }
}

然後使用發令槍進行測試:

@Test
public void testSync(){
    try {
        ConcurrentExecutor.execute(() -> {
            LazySimpleSyncSingleton instance = LazySimpleSyncSingleton.getInstance();
            System.out.println(Thread.currentThread().getName() + " : " + instance);
        }, 5, 5);
    } catch (Exception e) {
        e.printStackTrace();
    }
}

進行多輪測試,並觀察結果,發現能夠獲取同一個示例:

pool-1-thread-3 : com.eamon.j[email protected]1a7e99de
pool-1-thread-2 : com.eamon.j[email protected]1a7e99de
pool-1-thread-5 : com.eamon.j[email protected]1a7e99de
pool-1-thread-1 : com.eamon.j[email protected]1a7e99de
pool-1-thread-4 : com.eamon.j[email protected]1a7e99de

線程安全問題是解決了,但是,用synchronized加鎖,線上程數量比較多情況下,如果CPU分配壓力上升,會導致大批量線程出現阻塞,從而導致程式運行性能大幅下降。

那麼,有沒有一種更好的方式,既兼顧線程安全又提升程式性能呢?答案是肯定的。

我們來看雙重檢查鎖的單例模式。

雙重檢查鎖懶漢式

上面的線程安全方式的寫法,synchronized鎖是鎖在 getInstance() 方法上,當多個線程過來拿資源的時候,其實需要拿的不是getInstance()這個方法,而是getInstance()方法裡面的instance 實例對象,而如果這個實例對象一旦被初始化之後,多個線程到達時,就可以利用方法中的 if (instance == null) 去判斷是否實例化,如果已經實例化了就直接返回,就沒有必要再進行實例化一遍。所以對上面的代碼進行改造:

第一次改造:

/**
 * @author eamon.zhang
 * @date 2019-09-30 下午2:03
 */
public class LazyDoubleCheckSingleton {
    private LazyDoubleCheckSingleton() {
    }

    private static LazyDoubleCheckSingleton instance = null;

    public static LazyDoubleCheckSingleton getInstance() {
        // 這裡判斷是為了過濾不必要的同步加鎖,因為如果已經實例化了,就可以直接返回了
        if (instance == null) {
            // 如果未初始化,則對資源進行上鎖保護,待實例化完成之後進行釋放
            synchronized (LazyDoubleCheckSingleton.class) {
                instance = new LazyDoubleCheckSingleton();
            }
        }
        return instance;
    }
}

這種方法行不行?答案肯定是不行,代碼中雖然是將同步鎖添加到了實例化操作中,解決了每個線程由於同步鎖的原因引起的阻塞,提高了性能;但是,這裡會存在一個問題:

  • 線程X線程Y同時調用getInstance()方法,他們同時判斷instance == null,得出的結果都是為null,所以進入了if代碼塊了
  • 此時線程X得到CPU的控制權 -> 進入同步代碼塊 -> 創建對象 -> 返回對象
  • 線程X執行完成了以後,釋放了鎖,然後線程Y得到了CPU的控制權。同樣是 -> 進入同步代碼塊 -> 創建對象 -> 返回對象

所以我們明顯可以分析出來:LazyDoubleCheckSingleton 類返回了不止一個實例!所以上面的代碼是不行的!大家可以自行測試,我這裡就不進行測試了!

我們再進行改造,經過分析,由於線程X已經實例化了對象,在線程Y再次進入的時候,我們再加一層判斷不就可以解決 “這個” 問題嗎?確實如此,來看代碼:

/**
 * @author eamon.zhang
 * @date 2019-09-30 下午2:03
 */
public class LazyDoubleCheckSingleton {
    private LazyDoubleCheckSingleton() {
    }
    private static LazyDoubleCheckSingleton instance = null;
    public static LazyDoubleCheckSingleton getInstance() {
        // 這裡判斷是為了過濾不必要的同步加鎖,因為如果已經實例化了,就可以直接返回了
        if (instance == null) {
            // 如果未初始化,則對資源進行上鎖保護,待實例化完成之後進行釋放(註意,可能多個線程會同時進入)
            synchronized (LazyDoubleCheckSingleton.class) {
                // 這裡的if作用是:如果後面的進程在前面一個線程實例化完成之後拿到鎖,進入這個代碼塊,
                // 顯然,資源已經被實例化過了,所以需要進行判斷過濾
                if (instance == null) {
                    instance = new LazyDoubleCheckSingleton();
                }
            }
        }
        return instance;
    }
}

大家覺得經過這樣改造是不是就完美了呢?在我們習慣性的“講道理”的思維模式看來,好像確實沒什麼問題,但是,程式是電腦在執行;什麼意思呢?

instance = new LazyDoubleCheckSingleton(); 這段代碼執行的時候,電腦內部並非簡單的一步操作,也就是非原子操作,在JVM中,這一行代碼大概做了這麼幾件事情:

  1. instance 分配記憶體
  2. 調用 LazyDoubleCheckSingleton 的構造函數來初始化成員變數
  3. instance對象指向分配的記憶體空間(執行完這步 instance 就為非 null 了)

但是在 JVM 中的即時編譯器中存在指令重排序的優化;通俗的來說就是,上面的第二步和第三步的順序是不能保證的,如果執行順序是 1 -> 3 -> 2 那麼在 3 執行完畢、2 未執行之前,被另外一個線程 A 搶占了,這時 instance 已經是非 null 了(但卻沒有初始化),所以線程 A 會直接返回 instance,然後被程式調用,就會報錯。

當然,這種情況是很難測試出來的,但是確實會存在這麼一個問題,所以我們必須解決它,解決方式也很簡單,就是 j 將 instance 加上 volatile 關鍵字。

所以相對較完美的實現方式是:

/**
 * @author eamon.zhang
 * @date 2019-09-30 下午2:03
 */
public class LazyDoubleCheckSingleton {
    private LazyDoubleCheckSingleton() {
    }

    private static volatile LazyDoubleCheckSingleton instance = null;

    public static LazyDoubleCheckSingleton getInstance() {
        // 這裡判斷是為了過濾不必要的同步加鎖,因為如果已經實例化了,就可以直接返回了
        if (instance == null) {
            // 如果未初始化,則對資源進行上鎖保護,待實例化完成之後進行釋放(註意,可能多個線程會同時進入)
            synchronized (LazyDoubleCheckSingleton.class) {
                // 這裡的if作用是:如果後面的進程在前面一個線程實例化完成之後拿到鎖,進入這個代碼塊,
                // 顯然,資源已經被實例化過了,所以需要進行判斷過濾
                if (instance == null) {
                    instance = new LazyDoubleCheckSingleton();
                }
            }
        }
        return instance;
    }
}

測試代碼見文末說明

靜態內部類懶漢式

上面的雙重鎖檢查形式的單例,對於日常開發來說,確實夠用了,但是在代碼中使用synchronized關鍵字 ,總歸是要上鎖,上鎖就會存在一個性能問題。難道就沒有更好的方案嗎?別說,還真有,我們從類初始化的角度來考慮,這就是這裡所要說到的靜態內部類的方式。

廢話不多說,直接看代碼:

/**
 *
 * @author eamon.zhang
 * @date 2019-09-30 下午2:55
 */
public class LazyInnerClassSingleton {

    private LazyInnerClassSingleton() {
    }

    // 註意關鍵字final,保證方法不被重寫和重載
    public static final LazyInnerClassSingleton getInstance() {
        return LazyHolder.INSTANCE;
    }

    private static class LazyHolder {
        // 註意 final 關鍵字(保證不被修改)
        private static final LazyInnerClassSingleton INSTANCE = new LazyInnerClassSingleton();
    }
}

進行多線程測試:

pool-1-thread-9 : com.eamon.[email protected]88b7fa2
pool-1-thread-1 : com.eamon.[email protected]88b7fa2
pool-1-thread-6 : com.eamon.[email protected]88b7fa2
...

結果都是同一個對象實例。

結論

這種方式即解決了餓漢式的記憶體浪費問題,也解決了synchronized 所帶來的性能問題

原理

利用的原理就是類的載入初始化順序:

  1. 當類不被調用的時候,類的靜態內部類是不會進行初始化的,這就避免了記憶體浪費問題;
  2. 當有方法調用 getInstance()方法時,會先初始化靜態內部類,而靜態內部類中的成員變數是 final 的,所以即便是多線程,其成員變數是不會被修改的,所以就解決了添加 synchronized 所帶來的性能問題

首先感謝也恭喜大家能夠看到這裡,因為我想告訴你,上面所有的單例模式似乎還存在一點小問題 —— 暴力破壞。解決這一問題的方式就是下麵提到的枚舉類型單例。

至於緣由和為何枚舉能夠解決這個問題,同樣,篇幅原因,我將在後面單獨開一篇文章來說明。


下麵我們先來講講註冊式單例。

3、註冊式(登記式)單例

註冊式單例又稱為登記式單例,就是將每一個實例都登記到某一個地方,使用唯一的標識獲取實例。

註冊式單例有兩種寫法:一種為容器緩存,一種為枚舉登記。

先來看枚舉式單例的寫法。

枚舉單例

廢話少說,直接看代碼,我們先創建EnumResource 類:

/**
 * @author eamon.zhang
 * @date 2019-09-30 下午3:53
 */
public class EnumResource {
}

然後創建EnumSingleton:

/**
 * @author eamon.zhang
 * @date 2019-09-30 下午3:42
 */
public enum EnumSingleton {
    INSTANCE;

    private Object instance;

    EnumSingleton() {
        instance = new EnumResource();
    }

    public Object getInstance() {
        return instance;
    }

}

來看測試代碼:

/**
 * @author eamon.zhang
 * @date 2019-09-30 下午3:47
 */
public class EnumSingletonTest {

    @Test
    public void test() {
        try {
            ConcurrentExecutor.execute(() -> {
                EnumSingleton instance = EnumSingleton.INSTANCE;
                System.out.println(instance.getInstance());
            }, 10, 10);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

}

測試結果:

[email protected]e7
[email protected]e7
[email protected]e7
[email protected]e7
[email protected]e7
[email protected]e7
[email protected]e7
[email protected]e7
[email protected]e7
[email protected]e7

結果都一樣,說明枚舉類單例是線程安全的,且是不可破壞的;在 JDK 枚舉的語法特殊性,以及反射也為枚舉保駕護航,讓枚舉式單例成為一種比較優雅的實現。

枚舉類單例也是《Effective Java》中所建議使用的。

容器式單例

註冊式單例還有另外一種寫法,利用容器緩存,直接來看代碼:

創建ContainerSingleton類:

/**
 * @author EamonZzz
 * @date 2019-10-06 18:28
 */
public class ContainerSingleton {
    private ContainerSingleton() {
    }

    private static Map<String, Object> ioc = new ConcurrentHashMap<String, Object>();

    public static Object getBean(String className) {
        synchronized (ioc) {
            if (!ioc.containsKey(className)) {
                Object object = null;
                try {
                    object = Class.forName(className).newInstance();
                    ioc.put(className, object);
                } catch (Exception e) {
                    e.printStackTrace();
                }
                return object;
            } else {
                return ioc.get(className);
            }
        }
    }
}

測試代碼:

@Test
    public void test() {
        try {
            ConcurrentExecutor.execute(() -> {
                Object bean = ContainerSingleton
                        .getBean("com.eamon.javadesignpatterns.singleton.container.Resource");
                System.out.println(bean);
            }, 5, 5);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

測試結果:

[email protected]0f
[email protected]0f
[email protected]0f
[email protected]0f
[email protected]0f

容器式寫法適用於創建實例非常多的情況,便於管理。但是,是非線程安全的。

其實 Spring 中也有相關容器史丹利的實現代碼,比如 AbstractAutowireCapableBeanFactory 介面

至此,註冊式單例介紹完畢。


五、拓展

ThreadLocal 線程單例

ThreadLocal 不能保證其創建的對象是唯一的,但是能保證在單個線程中是唯一的,並且在單個線程中是天生的線程安全。

看代碼:

/**
 * @author EamonZzz
 * @date 2019-10-06 21:40
 */
public class ThreadLocalSingleton {
    private ThreadLocalSingleton() {
    }

    private static final ThreadLocal<ThreadLocalSingleton> instance = ThreadLocal.withInitial(ThreadLocalSingleton::new);

    public static ThreadLocalSingleton getInstance() {
        return instance.get();
    }
}

測試程式:

@Test
public void test() {
    System.out.println("-------------- 單線程 start ---------");
    System.out.println(ThreadLocalSingleton.getInstance());
    System.out.println(ThreadLocalSingleton.getInstance());
    System.out.println(ThreadLocalSingleton.getInstance());
    System.out.println(ThreadLocalSingleton.getInstance());
    System.out.println(ThreadLocalSingleton.getInstance());
    System.out.println("-------------- 單線程 end ---------");
    System.out.println("-------------- 多線程 start ---------");
    try {
        ConcurrentExecutor.execute(() -> {
            ThreadLocalSingleton singleton = ThreadLocalSingleton.getInstance();
            System.out.println(Thread.currentThread().getName() + " : " + singleton);

        }, 5, 5);
    } catch (Exception e) {
        e.printStackTrace();
    }
    System.out.println("-------------- 多線程 end ---------");
}

測試結果:

-------------- 單線程 start ---------
com.eamon.javadesignpatterns.singleton.threadloca[email protected]
com.eamo[email protected]1374fbda
com.eamo[email protected]1374fbda
com.eamo[email protected]1374fbda
com.eamo[email protected]1374fbda
-------------- 單線程 end ---------
-------------- 多線程 start ---------
pool-1-thread-5 : com.eamo[email protected]2f540d92
pool-1-thread-1 : com.eamo[email protected]3ef7ab4e
pool-1-thread-2 : com.eamo[email protected]604ffe2a
pool-1-thread-3 : com.eamo[email protected]50f41c9f
pool-1-thread-4 : com.eamo[email protected]40821a7a
-------------- 多線程 end ---------

從測試結果來看,我們不難發現,在主線程中無論調用多少次,獲得到的實例都是同一個;在多線程環境下,每個線程獲取到了不同的實例。

所以,在單線程環境中,ThreadLocal 可以達到單例的目的。這實際上是以空間換時間來實現線程間隔離的。

六、總結

單例模式可以保證記憶體里只有一個實例,減少了記憶體的開銷;可避免對資源的浪費。

單例模式看起來非常簡單,實現起來也不難,但是在面試中卻是一個高頻的面試題。希望大家能夠徹底理解。


本篇文章所涉及的源代碼:

github.com/eamonzzz


您的分享是我們最大的動力!

更多相關文章
  • 本文僅限於入門級,沒有成規模製作,希望能對你有所幫助。 因為在開發多個項目中可能會用到同一個組件,那麼我們通過複製粘貼的形式更新,無異於是笨拙的,我們可以通過上傳到npm後,不斷迭代npm包來實現更新。 前期準備 初始化project 這裡我們使用 來初始化一個vue項目。 or 首先我們來開發一個 ...
  • 垃圾分類,一般是指按一定規定或標准將垃圾分類儲存、分類投放和分類搬運,從而轉變成公共資源的一系列活動的總稱。分類的目的是提高垃圾的資源價值和經濟價值,力爭物盡其用。垃圾在分類儲存階段屬於公眾的私有品,垃圾經公眾分類投放後成為公眾所在小區或社區的區域性準公共資源,垃圾分類搬運到垃圾集中點或轉運站後成... ...
  • 一.開通QQ服務 "點我進入QQ推廣官網" 然後點擊 後面自己看中文 二.頁面a標簽 三.js實現 ...
  • 什麼是微服務?為什麼會有微服務?讓我們帶著這些疑問開始我們的探索。 我們先看下維基百科和百度百科給出的定義: 維基百科:2014年,Martin Fowler 與 James Lewis 共同提出了微服務的概念,定義了微服務是由以單一應用程式構成的小服務,自己擁有自己的行程與輕量化處理,服務依業務功 ...
  • 0--前言 spring cloud的服務註冊中心,該選擇誰?在選擇前,我們首先需要來瞭解下分散式的CAP定理: 所謂CAP,是指: Consistency:一致性;就是在分散式系統中的所有數據備份,在同一時刻是否同樣的值 Availability:可用性;就是負載過大後,集群整體是否還能響應客戶端 ...
  • 淘寶架構 我們以淘寶架構為例,瞭解下大型的電商項目的服務端的架構是怎樣,如圖所示 上面是一些安全體繫系統,如數據安全體系、應用安全體系、前端安全體系等。 中間是業務運營服務系統,如會員服務、商品服務、店鋪服務、交易服務等。 還有共用業務,如分散式數據層、數據分析服務、配置服務、數據搜索服務等。 最下 ...
  • 策略模式: 1、定義:定義了一系列演算法,並將每個演算法封裝起來,使它們可以相互替換,且演算法的變化不會影響使用演算法的客戶 2、模型結構: (1)抽象策略(Strategy)類:定義了一個公共介面,各種不同的演算法以不同的方式實現這個介面, 環境角色使用這個介面調用不同的演算法,一般使用介面或抽象類實現 (2 ...
  • 迭代器模式(Iterator): 迭代器模式允許你訪問一個數據項序列中的所有元素,而無須關心序列是什麼類型(數組、鏈表、列表或任何其他類型)。它能有效地構建一個數據管道,經過一系列不同的轉換或過濾後再從管道的另一端出來。迭代器模式就是提供一種遍歷集合元素的統一介面,用一致的方法遍歷集合元素,不需要知 ...
一周排行
  • 比如要拆分“呵呵呵90909086676喝喝999”,下麵當type=0返回的是中文字元串“呵呵呵,喝喝”,type=1返回的是數字字元串“90909086676,999”, private string GetStrings(string str,int type=0) { IList<strin ...
  • Swagger一個優秀的Api介面文檔生成工具。Swagger可以可以動態生成Api介面文檔,有效的降低前後端人員關於Api介面的溝通成本,促進項目高效開發。 1、使用NuGet安裝最新的包:Swashbuckle.AspNetCore。 2、編輯項目文件(NetCoreTemplate.Web.c ...
  • 2020 年 7 月 30 日, 由.NET基金會和微軟 將舉辦一個線上和為期一天的活動,包括 微軟 .NET 團隊的演講者以及社區的演講者。本次線上大會 專註.NET框架構建微服務,演講者分享構建和部署雲原生應用程式的最佳實踐、模式、提示和技巧。有關更多信息和隨時瞭解情況:https://focu... ...
  • #abp框架Excel導出——基於vue #1.技術棧 ##1.1 前端採用vue,官方提供 UI套件用的是iview ##1.2 後臺是abp——aspnetboilerplate 即abp v1,https://github.com/aspnetboilerplate/aspnetboilerp ...
  • 前言 本文的文字及圖片來源於網路,僅供學習、交流使用,不具有任何商業用途,版權歸原作者所有,如有問題請及時聯繫我們以作處理。 作者:碧茂大數據 PS:如有需要Python學習資料的小伙伴可以加下方的群去找免費管理員領取 input()輸入 Python提供了 input() 內置函數從標準輸入讀入一 ...
  • 從12年到20年,python以肉眼可見的趨勢超過了java,成為了當今It界人人皆知的編程語言。 python為什麼這麼火? 網路編程語言搜索指數 適合初學者 Python具有語法簡單、語句清晰的特點,這就讓初學者在學習階段可以把精力集中在編程對象和思維方法上。 大佬都在用 Google,YouT ...
  • 在社會上存在一種普遍的對培訓機構的學生一種歧視的現象,具體表現在,比如:當你去公司面試的時候,一旦你說了你是培訓機構出來的,那麼基本上你就涼了,那麼你瞞著不說,然後又通過了面試成功入職,但是以後一旦在公司被髮現有培訓經歷,可能會面臨被降薪,甚至被辭退,培訓機構出來的學生,在用人單位眼裡就是能力低下的 ...
  • from typing import List# 這道題看了大佬寫的代碼,經過自己的理解寫出來了。# 從最外圍的四周找有沒有為O的,如果有的話就進入深搜函數,然後深搜遍歷# 判斷上下左右的位置是否為Oclass Solution: def solve(self, board: List[List[s ...
  • import requests; import re; import os; # 1.請求網頁 header = { "user-agent":'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_5) AppleWebKit/537.36 (KHTML, li ...
  • import requests; import re; import os; import parsel; 1.請求網頁 header = { "user-agent":'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_5) AppleWebKit/537. ...