創建模式--工廠模式、抽象工廠模式

来源:https://www.cnblogs.com/l-y-h/archive/2019/08/05/11305441.html
-Advertisement-
Play Games

一、小案例分析 1、功能需求： 實現一個發送信息的功能，要便於擴展與維護。（1）發送信息的工具有很多，比如簡訊、微信、郵件、QQ等。（2）選擇某個工具進行信息發送。 2、小菜雞去實現： （1）定義一個發送工具的父類（介面），並將各種發送工具作為子類（實現類）。（2）定義一個選擇發送工具的類，用於調用 ...


一、小案例分析

1、功能需求：

　　實現一個發送信息的功能，要便於擴展與維護。
（1）發送信息的工具有很多，比如簡訊、微信、郵件、QQ等。
（2）選擇某個工具進行信息發送。

2、小菜雞去實現：

（1）定義一個發送工具的父類（介面），並將各種發送工具作為子類（實現類）。
（2）定義一個選擇發送工具的類，用於調用發送工具（直接new個子類對象）。
（3）代碼實現：

package creative.pattern.factory.noFactory;

import java.util.Scanner;

/**
 * 測試類
 *
 */
public class Demo {
    public static void main(String[] args) {
        new SendMessage();// 實例化一個選擇發送工具的類
    }
}

/**
 * 定義一個發送工具的介面
 *
 */
interface Sender {
    void sendMessage();
}

/**
 * 定義一個簡訊發送工具，實現介面，重寫方法
 *
 */
class ShortMessageSender implements Sender {

    @Override
    public void sendMessage() {
        System.out.println("發送簡訊");
    }
}

/**
 * 定義一個微信發送工具，實現介面，重寫方法
 *
 */
class WeChatSender implements Sender {

    @Override
    public void sendMessage() {
        System.out.println("發送微信");
    }
}

/**
 * 定義一個郵件發送工具，實現介面，重寫方法
 *
 */
class MailSender implements Sender {

    @Override
    public void sendMessage() {
        System.out.println("發送郵件");
    }
}

/**
 * 定義一個選擇發送工具的類
 */
class SendMessage {
    /**
     * 用於獲取需要發送信息工具
     */
    public Sender getSenderType() {
        System.out.println("輸入發送工具的類型（1-3）：");
        System.out.println("1:簡訊");
        System.out.println("2:微信");
        System.out.println("3:郵件");
        Scanner scanner = new Scanner(System.in);
        String senderType = scanner.nextLine();
        if ("1".equals(senderType)) {
            return new ShortMessageSender();
        } else if ("2".equals(senderType)) {
            return new WeChatSender();
        } else if ("3".equals(senderType)) {
            return new MailSender();
        } else {
            return null;
        }
    }

    public SendMessage() {
        do {
            Sender sender = getSenderType();// 選擇發送信息的工具
            if (sender == null) {
                System.out.println("歡迎下次使用");
                break;
            } else {
                sender.sendMessage();
            }
        } while (true);
    }
}

（4）代碼分析：
　　對於邏輯簡單的代碼，這樣實現沒有問題，但是邏輯稍微複雜一些且需要修改擴展某個地方時，需要改動很多地方。
　　比如：再增加一個 QQSender，其需要實現Sender介面，並重寫相關方法，然後需要在 SendMessage 類中 去修改相關代碼，這裡違反了開閉原則。若需要增加幾個SendMessage 類，比如SendMessage2、SendMessage3時，同樣需要改動很多代碼。
（5）UML圖：

 

二、簡單工廠模式（SimpleFactory）

1、什麼是簡單工廠模式：

　　簡單工廠模式屬於創建型模式，不屬於常見的23種常見模式。簡單的講 簡單工廠模式是由一個工廠對象決定創建出哪一類產品的實例。

2、使用：

（1）簡單工廠模式，定義了一個創建對象的類，然後由這個類來封裝實例化對象的操作。
（2）當需要大量創建某種類或者對象時，可以使用工廠模式。

3、使用簡單工廠模式實現：

（1）定義一個發送工具的父類（介面），並將各種發送工具作為子類（實現類）。
（2）定義一個工廠類，用於調用發送工具。
（2）定義一個選擇發送工具的類，用於調用工廠類。
（3）代碼實現：

package creative.pattern.factory.simpleFactory;

import java.util.Scanner;

/**
 * 測試類
 *
 */
public class SimpleFactoryDemo {
    public static void main(String[] args) {
        new SendMessage();
    }
}

/**
 * 定義一個發送工具的介面
 *
 */
interface Sender {
    void sendMessage();
}

/**
 * 定義一個簡訊發送工具，實現介面，重寫方法
 *
 */
class ShortMessageSender implements Sender {

    @Override
    public void sendMessage() {
        System.out.println("發送簡訊");
    }
}

/**
 * 定義一個微信發送工具，實現介面，重寫方法
 *
 */
class WeChatSender implements Sender {

    @Override
    public void sendMessage() {
        System.out.println("發送微信");
    }
}

/**
 * 定義一個郵件發送工具，實現介面，重寫方法
 *
 */
class MailSender implements Sender {

    @Override
    public void sendMessage() {
        System.out.println("發送郵件");
    }
}

/**
 * 使用簡單工廠模式，管理需要生產的對象
 *
 */
class SimpleFactory {
    /**
     * 用於獲取需要發送信息工具
     */
    public static Sender createSender() {
        System.out.println("輸入發送工具的類型（1-3）：");
        System.out.println("1:簡訊");
        System.out.println("2:微信");
        System.out.println("3:郵件");
        Scanner scanner = new Scanner(System.in);
        String senderType = scanner.nextLine();
        if ("1".equals(senderType)) {
            return new ShortMessageSender();
        } else if ("2".equals(senderType)) {
            return new WeChatSender();
        } else if ("3".equals(senderType)) {
            return new MailSender();
        } else {
            return null;
        }
    }
}

/**
 * 定義一個選擇發送工具的類
 */
class SendMessage {
    public SendMessage() {
        do {
            Sender sender = SimpleFactory.createSender();// 選擇發送信息的工具
            if (sender == null) {
                System.out.println("歡迎下次使用");
                break;
            } else {
                sender.sendMessage();
            }
        } while (true);
    }
}

（4）代碼分析：
　　對於上述代碼，SendMessage 只與工廠類SimpleFactory 相關聯，此時需要擴展代碼時，比如擴展QQSender，讓其實現Sender並重寫方法後，在SimpleFactory 中改變相關代碼即可（違反開閉原則），不需要再改動SendMessage 的代碼。
（5）UML圖：

 

4、使用靜態工廠模式實現（常用形式）：

　　將上例的SimpleFactory 中public Sender createSender()改為 public static Sender createSender()。
　　調用時，直接使用SimpleFactory.createSender() 即可。

 public static Sender createSender() {
        System.out.println("輸入發送工具的類型（1-3）：");
        System.out.println("1:簡訊");
        System.out.println("2:微信");
        System.out.println("3:郵件");
        Scanner scanner = new Scanner(System.in);
        String senderType = scanner.nextLine();
        if ("1".equals(senderType)) {
            return new ShortMessageSender();
        } else if ("2".equals(senderType)) {
            return new WeChatSender();
        } else if ("3".equals(senderType)) {
            return new MailSender();
        } else {
            return null;
        }
    }

三、工廠方法模式

1、什麼是工廠方法模式：

　　在工廠內部定義一個創建對象的抽象方法，由子類去確定要實例化的對象。簡單的講 工廠方法模式將對象實例化的操作推遲到子類去實現。可以看做抽象工廠模式的一個常見類型。

2、使用工廠模式實現：

（1）定義一個發送工具的父類（介面），並將各種發送工具作為子類（實現類）。
（2）定義一個工廠方法介面，並通過工廠實現類去實例化對象。
（3）定義一個選擇發送工具的類，用於調用工廠實現類。
（4）代碼實現：

package creative.pattern.factory.factoryMethod;

import java.util.Scanner;

/**
 * 工廠方法模式測試類
 *
 */
public class factoryMethodDemo {
    public static void main(String[] args) {
        new SendMessage();
    }
}

/**
 * 定義一個發送工具的介面
 *
 */
interface Sender {
    void sendMessage();
}

/**
 * 定義一個簡訊發送工具，實現介面，重寫方法
 *
 */
class ShortMessageSender implements Sender {

    @Override
    public void sendMessage() {
        System.out.println("發送簡訊");
    }
}

/**
 * 定義一個微信發送工具，實現介面，重寫方法
 *
 */
class WeChatSender implements Sender {

    @Override
    public void sendMessage() {
        System.out.println("發送微信");
    }
}

/**
 * 定義一個郵件發送工具，實現介面，重寫方法
 *
 */
class MailSender implements Sender {

    @Override
    public void sendMessage() {
        System.out.println("發送郵件");
    }
}

/**
 * 使用工廠方法模式，讓子類去創建對象
 *
 */
interface FactoryMethod {
    Sender sendMessage();
}

/**
 * 簡訊工廠類，實現工廠方法類並重寫相關方法
 *
 */
class ShortMessageFactory implements FactoryMethod {

    @Override
    public Sender sendMessage() {
        return new ShortMessageSender();
    }
}

/**
 * 微信工廠類，實現工廠方法類並重寫相關方法
 *
 */
class WeChatFactory implements FactoryMethod {

    @Override
    public Sender sendMessage() {
        return new WeChatSender();
    }
}

/**
 * 郵件工廠類，實現工廠方法類並重寫相關方法
 *
 */
class MailFactory implements FactoryMethod {

    @Override
    public Sender sendMessage() {
        return new MailSender();
    }
}

/**
 * 定義一個選擇發送工具的類
 */
class SendMessage {
    public SendMessage() {
        do {
            System.out.println("輸入發送工具的類型（1-3）：");
            System.out.println("1:簡訊");
            System.out.println("2:微信");
            System.out.println("3:郵件");
            Scanner scanner = new Scanner(System.in);
            String senderType = scanner.nextLine();
            if ("1".equals(senderType)) {
                FactoryMethod factoryMethod = new ShortMessageFactory();
                Sender sender = factoryMethod.sendMessage();// 選擇發送簡訊
                sender.sendMessage();
            } else if ("2".equals(senderType)) {
                FactoryMethod factoryMethod = new WeChatFactory();
                Sender sender = factoryMethod.sendMessage();// 選擇發送微信
                sender.sendMessage();
            } else if ("3".equals(senderType)) {
                FactoryMethod factoryMethod = new MailFactory();
                Sender sender = factoryMethod.sendMessage();// 選擇發送郵件
                sender.sendMessage();
            } else {
                System.out.println("歡迎下次使用");
                break;
            }
        } while (true);
    }
}

（5）代碼分析：
　　SendMessage 類只與FactoryMethod 有關，當擴展新的功能時，比如QQSender，只需創建一個QQFactory，實現FactoryMethod 並重寫其方法即可，調用時無需更改其他代碼（必要的邏輯處理除外，符合開閉原則）。
（6）UML圖：

 

四、抽象工廠模式

1、什麼是抽象工廠模式

　　為創建一組相關或相互依賴的對象提供一個介面，而且無需指定他們的具體類。
註：
　　產品族：是指位於不同產品等級結構中功能相關聯的產品組成的家族。
　　產品等級結構：可以理解為一個介面或者一個抽象類。

2、抽象工廠模式與工廠方法模式的區別

（1）抽象工廠模式是工廠方法模式的升級版，其針對的是多個產品等級結構，即抽象工廠模式所提供的產品是衍生自不同的介面或抽象類。
（2）工廠方法模式：針對一個產品等級結構，即工廠方法模式衍生自同一個介面或者抽象類。
（3）如下圖所示，ShortMessage 與 WeChat屬於同一個產品等級，ShortMessage 與 ShortMessage2屬於兩個產品等級，為產品族。所以若存在兩個產品等級及以上的情況，即為抽象工廠模式，若是同一個產品等級，則為工廠方法模式。
　　下圖為工廠方法模式：

下圖為抽象工廠模式：

3、舉例：

　　在之前案例的基礎上，增加一個功能，微信、簡訊均可以圖片。
（1）定義一個發送工具的父類（介面），並將各種發送工具作為子類（實現類）。
（2）定義一個工廠方法介面，在方法中對產品族進行約束，並通過工廠實現類去實例化對象。
（3）定義一個選擇發送工具的類（測試類），用於調用工廠實現類。
（4）代碼實現：

package creative.pattern.factory.absFactory;

/**
 * 抽象工廠模式測試類
 *
 */
public class AbsFactoryDemo {
    public static void main(String[] args) {
        AbsFactory absFactory = new WeChatFactory();
        absFactory.getSender().sendMessage();
        absFactory.getSender2().sendMessage();
        ((WeChatSender2) absFactory.getSender2()).sendPicture();

        AbsFactory absFactory2 = new ShortMessageFactory();
        absFactory2.getSender().sendMessage();
        absFactory2.getSender2().sendMessage();
        ((ShortMessageSender2) absFactory2.getSender2()).sendPicture();
    }
}

/**
 * 定義一個發送工具的介面
 *
 */
interface Sender {
    void sendMessage();
}

/**
 * 定義一個微信發送工具，實現介面，重寫方法
 *
 */
class WeChatSender implements Sender {

    @Override
    public void sendMessage() {
        System.out.println("使用微信，發送簡訊");
    }
}

/**
 * 定義一個微信發送工具，實現介面，重寫方法，並新增自己的方法
 *
 */
class WeChatSender2 implements Sender {

    @Override
    public void sendMessage() {
        System.out.println("使用微信，發送簡訊");
    }

    public void sendPicture() {
        System.out.println("使用微信，發送圖片");
    }
}

/**
 * 定義一個簡訊發送工具，實現介面，重寫方法
 *
 */
class ShortMessageSender implements Sender {

    @Override
    public void sendMessage() {
        System.out.println("使用簡訊，發送簡訊");
    }
}

/**
 * 定義一個簡訊發送工具，實現介面，重寫方法，並新增自己的方法
 *
 */
class ShortMessageSender2 implements Sender {

    @Override
    public void sendMessage() {
        System.out.println("使用簡訊，發送簡訊");
    }

    public void sendPicture() {
        System.out.println("使用簡訊，發送圖片");
    }
}

/**
 * 抽象工廠模式
 *
 */
interface AbsFactory {
    Sender getSender();

    Sender getSender2();
}

/**
 * 工廠子類，實現抽象工廠類，重寫相關方法，
 *
 */
class WeChatFactory implements AbsFactory {

    @Override
    public Sender getSender() {
        return new WeChatSender();
    }

    @Override
    public Sender getSender2() {
        return new WeChatSender2();
    }
}

/**
 * 工廠子類，實現抽象工廠類，重寫相關方法，
 *
 */
class ShortMessageFactory implements AbsFactory {

    @Override
    public Sender getSender() {
        return new ShortMessageSender();
    }

    @Override
    public Sender getSender2() {
        return new ShortMessageSender2();
    }
}

（5）代碼分析：
　　對於產品族，定義在一個介面中，然後通過不同的子類去實現。擴展時，只需要實現介面並重寫相關方法即可，滿足開閉原則。

（6）UML圖：

五、JDK中工廠模式舉例（Calendar）

1、部分源碼

public abstract class Calendar implements Serializable, Cloneable, Comparable<Calendar> {
    /**
     * Gets a calendar using the default time zone and locale. The
     * <code>Calendar</code> returned is based on the current time
     * in the default time zone with the default
     * {@link Locale.Category#FORMAT FORMAT} locale.
     *
     * @return a Calendar.
     */
    public static Calendar getInstance()
    {
        return createCalendar(TimeZone.getDefault(), Locale.getDefault(Locale.Category.FORMAT));
    }
    
     private static Calendar createCalendar(TimeZone zone,
                                           Locale aLocale)
    {
        CalendarProvider provider =
            LocaleProviderAdapter.getAdapter(CalendarProvider.class, aLocale)
                                 .getCalendarProvider();
        if (provider != null) {
            try {
                return provider.getInstance(zone, aLocale);
            } catch (IllegalArgumentException iae) {
                // fall back to the default instantiation
            }
        }

        Calendar cal = null;

        if (aLocale.hasExtensions()) {
            String caltype = aLocale.getUnicodeLocaleType("ca");
            if (caltype != null) {
                switch (caltype) {
                case "buddhist":
                cal = new BuddhistCalendar(zone, aLocale);
                    break;
                case "japanese":
                    cal = new JapaneseImperialCalendar(zone, aLocale);
                    break;
                case "gregory":
                    cal = new GregorianCalendar(zone, aLocale);
                    break;
                }
            }
        }
        if (cal == null) {
            // If no known calendar type is explicitly specified,
            // perform the traditional way to create a Calendar:
            // create a BuddhistCalendar for th_TH locale,
            // a JapaneseImperialCalendar for ja_JP_JP locale, or
            // a GregorianCalendar for any other locales.
            // NOTE: The language, country and variant strings are interned.
            if (aLocale.getLanguage() == "th" && aLocale.getCountry() == "TH") {
                cal = new BuddhistCalendar(zone, aLocale);
            } else if (aLocale.getVariant() == "JP" && aLocale.getLanguage() == "ja"
                       && aLocale.getCountry() == "JP") {
                cal = new JapaneseImperialCalendar(zone, aLocale);
            } else {
                cal = new GregorianCalendar(zone, aLocale);
            }
        }
        return cal;
    }
}

2、源碼分析

　　Calendar內部採用簡單工廠模式進行對象的實例化。其根據不同的邏輯判斷條件來選擇實例化具體的對象。

 

六、總結：

1、工廠模式的意義：

　　將實例化對象的代碼提取出來，放到一個類（工廠類）裡面進行維護，使其與主項目解耦，提高程式的維護性與擴展性。

2、傳統模式：

　　直接在需要的地方實例化某對象。擴展代碼時，需要在使用到的地方進行修改，違反了開閉原則。

3、簡單工廠模式：

　　在需要用到的地方，調用工廠類即可，擴展代碼時，修改工廠類即可，也違反了開閉原則。
（1）簡單工廠模式（普通方法）：
　　使用一個工廠類，在某方法中通過邏輯處理並實例化需要的對象。
（2）簡單工廠模式（靜態方法）：
　　將簡單工廠模式（普通方法）的普通方法改為靜態方法，並通過”類名.方法名“來調用。
（3）簡單工廠模式（多方法）：
　　使用一個工廠類，並通過調用不同的方法去實例化不同的對象。

4、工廠方法模式：

　　使用一個工廠類介面與多個工廠實現類，在不同的工廠實現類中去實例化不同的對象。擴展代碼時，定義一個工廠實現類，實現工廠類介面並重寫相關方法即可，滿足開閉原則。可以理解為抽象工廠模式的一般形式。

5、抽象工廠模式：

　　可以理解為工廠方法模式的升級版，其在一個介面中定義了一個產品族的處理（多個方法），子類實現該介面，並重寫相關方法即可，擴展類似於工廠方法模式，滿足開閉原則。


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

-Advertisement-
Play Games
更多相關文章
  • vue 滑鼠移入移出事件執行多次(尤其ie)
    來自：https://www.cnblogs.com/myfirstboke/p/9150809.html 侵刪 ...
  • jQuery總結
    第一章 JavaScript基礎 --1、JavaScript是一種基於對象和事件驅動的，並具有安全性能的腳本語言。--2、JavaScript的特點: -1、JavaScript主要用來在HTML頁面中添加交互行為 -2、JavaScript是一種腳本語言，語法和Java類似 -3、JavaScr ...
  • 顯示方式
    08.05自我總結 一.顯示方式 1.display 常用的三種方式 2.vertical align 文本垂直對齊方式: |` top bottom` ...
  • javascript原型與原型鏈個人理解
    想瞭解原型和原型鏈，我覺得首先我們得知道javascript里有一個Object 與 Function,它倆都是構造函數，當然函數也是一個對象。我們列印Object 與 Function看一下, 那麼這個Object 與 Function 之間有何關係與區別呢？首先您只需要記住： 1. 所有普通對象 ...
  • 關於ajax非同步請求的一個細節問題
    在使用ajax發送非同步請求時，遇到一個問題，就是在回調函數中接受到了非同步響應的數據，但是在前端頁面中的表單中卻不回顯該數據。 前端頁面在 第一次載入數據的同時 發送非同步請求，但是 這個 非同步響應 是在 頁面載入完數據之後 到達的，因此在 非同步響應 到達之後（這時表單數據已載入完畢） 需要第二次將數... ...
  • vue學習【一】vue引用封裝echarts並展示多個echarts圖表
    大家好，我是一葉，經過一段時間對vue的學習，我打算把vue做一個系列，把踩過的坑和大家分享一下。 現在開始第一章：vue引用並封裝echarts 在文章開始前，我先舔波echarts（真香）。阿裡的G2和百度的echarts都是很不錯的，echarts上手難度小，並且用戶多，文檔多，生態環境較好， ...
  • [目錄] 咱們不寫代碼，只談理論
    這個系列博客專註電腦各種理論知識 如果專註於代碼的優美、或者專註於業務，或許這些知識並不是很重要 如果剛剛編程入門，或許這些知識不太能看懂 但是專註於技術且工作一定時間的話，這些可能還是很有用的 很多都是大學的電腦專業知識，以及軟考高級職稱架構師、分析師中的知識點。 我儘量將知識點與應用實踐向結 ...
  • （1）對比：阻塞與非阻塞、同步與非同步
    阻塞與非阻塞 阻塞：A程式調用B程式，A等待返回結果，等待中A程式線程被占用，不進行其它操作。 非阻塞：A程式調用B程式，A程式線程不被占用。 阻塞--》非阻塞 的最常用解決方案：緩存，A將請求依次裝入緩存中，A不管與B是否執行完成，由B隨後依次處理，返回給A。 同步與非同步 同步：一個線程依次執行所 ...
一周排行
    -Advertisement-
    Play Games
  • 移動開發（一）：使用.NET MAUI開發第一個安卓APP
    移動開發（一）：使用.NET MAUI開發第一個安卓APP 對於工作多年的C#程式員來說，近來想嘗試開發一款安卓APP，考慮了很久最終選擇使用.NET MAUI這個微軟官方的框架來嘗試體驗開發安卓APP，畢竟是使用Visual Studio開發工具，使用起來也比較的順手，結合微軟官方的教程進行了安卓 ...
  • wpf ToggleButton選中效果和一個登錄界面
    前言 QuestPDF 是一個開源 .NET 庫，用於生成 PDF 文檔。使用了C# Fluent API方式可簡化開發、減少錯誤並提高工作效率。利用它可以輕鬆生成 PDF 報告、發票、導出文件等。 項目介紹 QuestPDF 是一個革命性的開源 .NET 庫，它徹底改變了我們生成 PDF 文檔的方 ...
  • 彈幕樹洞項目功能新增篇
    項目地址 項目後端地址： https://github.com/ZyPLJ/ZYTteeHole 項目前端頁面地址： ZyPLJ/TreeHoleVue (github.com) https://github.com/ZyPLJ/TreeHoleVue 目前項目測試訪問地址： http://tree ...
  • 第27篇 sqlserver2022詳細安裝步驟
    話不多說，直接開乾 一.下載 1.官方鏈接下載： https://www.microsoft.com/zh-cn/sql-server/sql-server-downloads 2.在下載目錄中找到下麵這個小的安裝包 SQL2022-SSEI-Dev.exe，運行開始下載SQL server； 二. ...
  • .NET 開源高性能 MQTT 類庫
    前言 隨著物聯網（IoT）技術的迅猛發展，MQTT（消息隊列遙測傳輸）協議憑藉其輕量級和高效性，已成為眾多物聯網應用的首選通信標準。 MQTTnet 作為一個高性能的 .NET 開源庫，為 .NET 平臺上的 MQTT 客戶端與伺服器開發提供了強大的支持。 本文將全面介紹 MQTTnet 的核心功能 ...
  • Serilog文檔翻譯系列（六） - 可用的接收器、增強器、格式化輸出
    Serilog支持多種接收器用於日誌存儲，增強器用於添加屬性，LogContext管理動態屬性，支持多種輸出格式包括純文本、JSON及ExpressionTemplate。還提供了自定義格式化選項，適用於不同需求。 ...
  • 警惕 Visual Studio 屬性求值副作用導致邏輯不符合預期
    目錄簡介獲取 HTML 文檔解析 HTML 文檔測試參考文章 簡介 動態內容網站使用 JavaScript 腳本動態檢索和渲染數據，爬取信息時需要模擬瀏覽器行為，否則獲取到的源碼基本是空的。 本文使用的爬取步驟如下： 使用 Selenium 獲取渲染後的 HTML 文檔 使用 HtmlAgility ...
  • [使用目前最新版]HybridCLR6.9.0+YooAsset2.2.4實現純C# Unity熱更新方案 (一)
    1.前言 什麼是熱更新 游戲或者軟體更新時，無需重新下載客戶端進行安裝，而是在應用程式啟動的情況下，在內部進行資源或者代碼更新 Unity目前常用熱更新解決方案 HybridCLR，Xlua，ILRuntime等 Unity目前常用資源管理解決方案 AssetBundles，Addressable， ...
  • 在 ASP.NET Core Web API 中使用操作篩選器統一處理通用操作
    本文章主要是在C# ASP.NET Core Web API框架實現向手機發送驗證碼簡訊功能。這裡我選擇是一個互億無線簡訊驗證碼平臺，其實像阿裡雲，騰訊雲上面也可以。 首先我們先去 互億無線 https://www.ihuyi.com/api/sms.html 去註冊一個賬號 註冊完成賬號後，它會送 ...
  • 第28篇 如何.net中實現高效可靠數據同步api
    通過以下方式可以高效，並保證數據同步的可靠性 1.API設計 使用RESTful設計，確保API端點明確，並使用適當的HTTP方法（如POST用於創建，PUT用於更新）。 設計清晰的請求和響應模型，以確保客戶端能夠理解預期格式。 2.數據驗證 在伺服器端進行嚴格的數據驗證，確保接收到的數據符合預期格 ...
所有分類