Java編程的利器：Pair和Triple無縫解決多值返回問題，助力編寫高效代碼

来源:https://www.cnblogs.com/coderacademy/p/18044476
-Advertisement-
Play Games

Pair和Triple類是commons-lang3庫提供的實用工具，可以方便地將多個值組合在一起，實現多個返回值的效果，提高了代碼的可讀性和可維護性，使得處理多值情景更加輕鬆。 ...


在實際編碼中，經常會遇到一個方法需要返回多個值的情況，你編寫一個方法，需要同時返回某個操作的結果和一些相關的附加信息。使用傳統的方式，你可能需要創建一個包含這些信息的自定義類或者使用集合（如 Map）來存儲這些值。然而，這往往使得代碼變得臃腫，而且對於調用方來說，理解和提取這些值可能會顯得有些繁瑣。

這時使用org.apache.commons.lang3.tuple下的Pair 或 Triple 及其子類是一種非常便捷的解決方案。這些類提供了一種清晰、簡單的方式來組織和傳遞多個相關聯的值，使得代碼更加直觀和易於理解。

使用 Pair 或 Triple 就能輕鬆解決這個問題。你可以在一個方法中返回一個 Pair 或 Triple 對象，其中包含你想要傳遞的多個值。這樣，你可以清晰地表示這些值之間的關係，而且調用方可以輕鬆地訪問和使用這些值，而無需繁瑣的解包過程。

在接下來的部分，我們將深入研究如何在這類場景中使用 Pair 和 Triple 及其子類，以及它們如何簡化我們在編碼中常遇到的多值返回問題。

引入依賴：

<dependency>
    <groupId>org.apache.commons</groupId>
    <artifactId>commons-lang3</artifactId>
    <version>3.12.0</version>
</dependency>

Pair 類介紹

Pair 類是org.apache.commons.lang3庫提供的一個簡單的鍵值對容器，用於表示兩個相關聯的值。其主要作用是將兩個值組織在一起，提供一種便捷的方式進行傳遞和處理。

首先我們來看一下Pair的源碼：

/**
 * 抽象類，表示簡單的鍵值對。
 * 實現了 Map.Entry 介面，支持在各種集合中使用。
 * 實現了 Comparable 介面，用於比較兩個 Pair 對象的大小。
 * 可序列化，支持對象的序列化和反序列化。
 *
 * @param <L> 左值的類型
 * @param <R> 右值的類型
 */
public abstract class Pair<L, R> implements Map.Entry<L, R>, Comparable<Pair<L, R>>, Serializable {

    private static final long serialVersionUID = 4954918890077093841L;

    // 空數組，用於表示空的 Pair 對象數組
    public static final Pair<?, ?>[] EMPTY_ARRAY = new PairAdapter[0];

    /**
     * 返回一個空的 Pair 數組。
     *
     * @return 空的 Pair 數組
     */
    public static <L, R> Pair<L, R>[] emptyArray() {
        return (Pair[]) EMPTY_ARRAY;
    }

    /**
     * 靜態工廠方法，創建一個新的 ImmutablePair 對象，表示給定的左右值的鍵值對。
     *
     * @param left  左值
     * @param right 右值
     * @param <L>   左值的類型
     * @param <R>   右值的類型
     * @return ImmutablePair 對象
     */
    public static <L, R> Pair<L, R> of(L left, R right) {
        return ImmutablePair.of(left, right);
    }

    /**
     * 靜態工廠方法，創建一個新的 ImmutablePair 對象，表示給定 Map.Entry 對象的鍵值對。
     *
     * @param pair Map.Entry 對象
     * @param <L>  左值的類型
     * @param <R>  右值的類型
     * @return ImmutablePair 對象
     */
    public static <L, R> Pair<L, R> of(Map.Entry<L, R> pair) {
        return ImmutablePair.of(pair);
    }

    /**
     * 返回左值，實現了 Map.Entry 介面。
     *
     * @return 左值
     */
    public final L getKey() {
        return this.getLeft();
    }

    /**
     * 抽象方法，由子類實現，用於獲取左值。
     *
     * @return 左值
     */
    public abstract L getLeft();

    /**
     * 抽象方法，由子類實現，用於獲取右值。
     *
     * @return 右值
     */
    public abstract R getRight();

    /**
     * 返回右值，實現了 Map.Entry 介面。
     *
     * @return 右值
     */
    public R getValue() {
        return this.getRight();
    }
}

Pair類是一個抽象類，它有兩個子類ImmutablePair和MutablePair。接下來我們介紹一下這兩個子類，也是我們要使用的兩個類。

MutablePair

MutablePair是一個可變的。它允許在創建後動態修改鍵和值，提供了更大的靈活性。但是它是線程不安全的。
我們可以根據它提供的幾個靜態方法或者它的構造器去構造一個MutablePair:

// 靜態工廠方法，返回一個空的 MutablePair
public static <L, R> MutablePair<L, R>[] emptyArray();

// 靜態工廠方法，傳入給定的左右值的鍵值對，創建並返回一個MutablePair 對象
public static <L, R> MutablePair<L, R> of(L left, R right);

// 靜態工廠方法，傳入給定 Map.Entry 對象的鍵值對，創建並返回一個新的MutablePair 對象
public static <L, R> MutablePair<L, R> of(Map.Entry<L, R> pair);

// 無參構造器
public MutablePair()

// 指定左右值的鍵值對的構造器
public MutablePair(L left, R right)

我們可以根據它的幾個方法修改鍵和值：

// 修改左值
public void setLeft(L left);

// 修改右值
public void setRight(R right);

// 修改新的右值，並返回之前的右值。
public R setValue(R value);

我們可以根據它的幾個方法獲取鍵和值：

// 獲取左值
public L getLeft();

// Pair中的方法  獲取左值
public final L getKey();

// 獲取右值
public R getRight();

// Pair中的方法  獲取右值 
public R getValue();

當然我們看到它的left以及right都是public的。所以我們也可以直接取值，不用使用它的get方法。

ImmutablePair

ImmutablePair是Pair的一個不可變的子類。它在創建完成之後，不允許改變鍵和值。它是線程安全的。

我們可以看一下它如何進行構造的：

// 靜態工廠方法，返回一個空的 ImmutablePair 數組。
public static <L, R> ImmutablePair<L, R>[] emptyArray();

// 靜態工廠方法，返回一個包含 null 左值和 null 右值的 ImmutablePair 對象，表示空值。
public static <L, R> ImmutablePair<L, R> nullPair();

// 靜態工廠方法，返回一個包含指定左值和 null 右值的 ImmutablePair 對象。
public static <L, R> Pair<L, R> left(L left);

// 靜態工廠方法，返回一個包含 null 左值和指定右值的 ImmutablePair 對象。
public static <L, R> Pair<L, R> right(R right);

// 靜態工廠方法，創建並返回一個新的 ImmutablePair 對象，表示給定的左右值的鍵值對。
public static <L, R> ImmutablePair<L, R> of(L left, R right);

// 靜態工廠方法，創建並返回一個新的 ImmutablePair 對象，表示給定 Map.Entry 對象的鍵值對。
public static <L, R> ImmutablePair<L, R> of(Map.Entry<L, R> pair);

// 有參構造器 傳入給定的左右值的鍵值對。
public ImmutablePair(L left, R right);

我們可以根據它的幾個方法獲取鍵和值：

// 獲取左值
public L getLeft();

// Pair中的方法  獲取左值
public final L getKey();

// 獲取右值
public R getRight();

// Pair中的方法  獲取右值 
public R getValue();

當然我們看到它的left以及right都是public的。所以我們也可以直接取值，不用使用它的get方法。

那我們再看一下為什麼ImmutablePair是不可變的，並且是線程安全的。
首先我們看一下它的左值以及右值都是final的，不可更改的。並且調用它的setValue會拋出UnsupportedOperationException。

public final L left;  
public final R right;

public R setValue(R value) {  
    throw new UnsupportedOperationException();  
}

類中的 left 和 right 成員變數被聲明為 final，這意味著它們在對象創建後不能被修改，確保了線程安全性。ImmutablePair 被設計為不可變的鍵值對類，即一旦創建，其內容不可更改。這確保了在多線程環境中，不會有併發修改的問題。

使用示例

/**  
 * 返回MutablePair  
 * @param userDO  
 * @return  
 */  
private static MutablePair<String, Integer> handleUserInfo1(UserDO userDO){  
    return MutablePair.of(userDO.getUserId(), userDO.getAge());  
}  
  
/**  
 * 返回ImmutablePair  
 * @param userDO  
 * @return  
 */  
private static ImmutablePair<String, Integer> handleUserInfo2(UserDO userDO){  
    return ImmutablePair.of(userDO.getUserId(), userDO.getAge());  
}  
  
public static void main(String[] args) {  
    UserDO userDO = new UserDO();  
    userDO.setUserId("coderacademy");  
    userDO.setAge(35);  
  
    MutablePair<String, Integer> mutablePair = handleUserInfo1(userDO);  
    System.out.println(mutablePair.getLeft()+" MutablePair修改前："+ mutablePair.right);  
    mutablePair.setRight(40);  
    System.out.println(mutablePair.getLeft()+" MutablePair修改後："+ mutablePair.right);  
  
    ImmutablePair<String, Integer> immutablePair = handleUserInfo2(userDO);  
    System.out.println(mutablePair.getLeft()+" ImmutablePair修改前："+ mutablePair.right);  
    immutablePair.setValue(50);  
    System.out.println(mutablePair.getLeft()+" ImmutablePair修改後："+ mutablePair.right);  
}

執行結果，我們發現ImmutablePair在修改value時報錯：
image.png

Pair 類及其子類 ImmutablePair 和 MutablePair 是用於表示鍵值對的實用工具類。ImmutablePair 是不可變的、線程安全的，適用於安全共用；MutablePair 允許動態修改值，但不具備線程安全性，適用於單線程環境。它們在方法返回多個值時提供了簡便的解決方案，提高了代碼的靈活性。

Triple介紹

Triple 是一個用於表示三元組的抽象類。三元組是由三個元素組成的有序集合，其中每個元素都有特定的位置，分別稱為左值（Left）、中間值（Middle）和右值（Right）。Triple 類提供了一種便捷的方式來組織和處理這種具有固定順序的數據。可以在不創建專門類的情況下輕鬆返回三個值。通過 Triple，開發者可以更方便地處理包含三個元素的數據，減少了創建和維護多個變數的複雜性，使代碼更加簡潔。

我們來看一下Triple的源碼：

/**
 * 表示包含三個元素的三元組的抽象類 Triple。
 *
 * 該類是一個抽象實現，定義了基本的 API，將元素分別稱為 'left'、'middle' 和 'right'。
 *
 * 子類的實現可以是可變的或不可變的。對存儲的對象類型沒有限制。
 * Triple 對象的可變性取決於其中存儲的對象是否是可變的。如果存儲的是可變對象，那麼 Triple 本身也就變得可變，因為存儲的對象狀態可以被修改。
 * 如果存儲的是不可變對象，那麼Triple 對象在創建後就保持不可變。
 *
 */
public abstract class Triple<L, M, R> implements Comparable<Triple<L, M, R>>, Serializable {

    /**
     * 一個空數組。
     */
    public static final Triple<?, ?, ?>[] EMPTY_ARRAY = new TripleAdapter[0];

    /**
     * 返回可分配而無需編譯器警告的空數組單例。
     *
     */
    @SuppressWarnings("unchecked")
    public static <L, M, R> Triple<L, M, R>[] emptyArray() {
        return (Triple<L, M, R>[]) EMPTY_ARRAY;
    }

    /**
     * 獲取由三個對象組成的不可變三元組，推斷出泛型類型。
     *
     * 此工廠方法允許使用推斷類型來創建三元組以獲取泛型類型。
     *
     * @param left   左元素，可以為 null
     * @param middle 中間元素，可以為 null
     * @param right  右元素，可以為 null
     * @return 由三個參數形成的三元組，非 null
     */
    public static <L, M, R> Triple<L, M, R> of(final L left, final M middle, final R right) {
        return new ImmutableTriple<>(left, middle, right);
    }

    /**
     * 獲取此三元組的左元素。
     *
     * @return 左元素，可以為 null
     */
    public abstract L getLeft();

    /**
     * 獲取此三元組的中間元素。
     *
     * @return 中間元素，可以為 null
     */
    public abstract M getMiddle();

    /**
     * 獲取此三元組的右元素。
     *
     * @return 右元素，可以為 null
     */
    public abstract R getRight();
}

Triple是一個抽象類，它有兩個子類：可變MutableTriple 以及不可變 ImmutableTriple。

MutableTriple

MutableTriple 是可變的，原因在於它提供了公共的設置（set）方法，允許在創建後修改其內部值。具體來說，MutableTriple 提供了 setLeft、setMiddle 和 setRight 方法，使得在對象創建後可以修改左、中、右元素的值。

/**
 * 表示由三個 {@code Object} 元素組成的可變三元組。
 *
 * 非線程安全
 *
 */
public class MutableTriple<L, M, R> extends Triple<L, M, R> {


    /**
     * 通過推斷泛型類型獲取三個對象的可變三元組。
     *
     * 該工廠允許通過推斷泛型類型創建三元組。
     *
     */
    public static <L, M, R> MutableTriple<L, M, R> of(final L left, final M middle, final R right) {
        return new MutableTriple<>(left, middle, right);
    }

    /** 左對象 */
    public L left;
    /** 中間對象 */
    public M middle;
    /** 右對象 */
    public R right;

    /**
     * 創建一個新的三元組實例，包含三個 null 值。
     */
    public MutableTriple() {
    }

    /**
     * 創建一個新的三元組實例。
     *
     * @param left   左值，可以為 null
     * @param middle 中間值，可以為 null
     * @param right  右值，可以為 null
     */
    public MutableTriple(final L left, final M middle, final R right) {
        this.left = left;
        this.middle = middle;
        this.right = right;
    }

    /**
     * 設置三元組的左元素。
     */
    public void setLeft(final L left) {
        this.left = left;
    }

    /**
     * 設置三元組的中間元素。
     */
    public void setMiddle(final M middle) {
        this.middle = middle;
    }

    /**
     * 設置三元組的右元素。
     */
    public void setRight(final R right) {
        this.right = right;
    }
}

MutableTriple 被明確標記為非線程安全。

ImmutableTriple

ImmutableTriple 是一個不可變的三元組類，由三個泛型元素（left、middle、right）組成。不可變意味著一旦創建，其狀態無法修改。該類被設計為線程安全的，但需要註意，如果存儲在三元組中的對象是可變的，那麼三元組本身實際上就不再是不可變的。

/**
 * 一個由三個元素組成的不可變三元組。
 *
 * ImmutableTriple 是一個最終類，被設計成不可變的，即在實例化後其狀態不可更改。
 * 如果存儲在三元組中的三個對象都是線程安全的，則該類是線程安全的。類的最終性防止了子類化，確保不會添加不希望的行為。
 *
 * 線程安全的 如果三個對象都是線程安全的
 *
 */
public final class ImmutableTriple<L, M, R> extends Triple<L, M, R> {

    /**
     * 返回可以在不觸發編譯器警告的情況下分配的空數組單例。
     * @return 可以在不觸發編譯器警告的情況下分配的空數組單例。
     */
    @SuppressWarnings("unchecked")
    public static <L, M, R> ImmutableTriple<L, M, R>[] emptyArray() {
        return (ImmutableTriple<L, M, R>[]) EMPTY_ARRAY;
    }

    /**
     * 返回一個由 null 組成的不可變三元組。
     *
     * @return 一個由 null 組成的不可變三元組。
     */
    public static <L, M, R> ImmutableTriple<L, M, R> nullTriple() {
        return NULL;
    }

    /**
     * 通過推斷泛型類型獲得由三個對象組成的不可變三元組。
     *
     * 此工廠允許使用推斷創建三元組以獲得泛型類型。
     *
     * @return 由三個參數形成的不可變三元組，不為 null
     */
    public static <L, M, R> ImmutableTriple<L, M, R> of(final L left, final M middle, final R right) {
        return new ImmutableTriple<>(left, middle, right);
    }

    /** 左對象 */
    public final L left;
    /** 中間對象 */
    public final M middle;
    /** 右對象 */
    public final R right;

    /**
     * 構造方法 創建一個新的三元組實例。
     *
     */
    public ImmutableTriple(final L left, final M middle, final R right) {
        this.left = left;
        this.middle = middle;
        this.right = right;
    }
}

ImmutableTriple 被聲明為 final，表示不可繼承，確保不可變性。確保不會有子類添加或修改行為。然後類中的屬性 left、middle、right 被聲明為 final，表示它們在實例化後無法被修改。類中沒有提供修改元素的公共方法。ImmutableTriple 主張不可變性，不提供修改實例狀態的方法。當然如果存儲在三元組中的對象是可變的，則整個三元組就變得可變。這是因為雖然 ImmutableTriple 本身是不可變的，但如果存儲的對象是可變的，它們的狀態可能會發生變化。

類聲明中使用 #ThreadSafe# 標記，表示在存儲的三個對象都是線程安全的情況下，ImmutableTriple 是線程安全的。

示例

/**  
* 返回可變Truple  
* @param userDO  
* @return  
*/  
private static MutableTriple<String, Integer, UserDO> handleUserInfo1(UserDO userDO){  
	return MutableTriple.of(userDO.getUserId(), userDO.getSex(), userDO);  
}  
  
/**  
* 返回不可變Triple  
* @param userDO  
* @return  
*/  
private static ImmutableTriple<String, Integer, UserDO> handleUserInfo2(UserDO userDO){  
	return ImmutableTriple.of(userDO.getUserId(), userDO.getSex(), userDO);  
}  
  
  
public static void main(String[] args) {  
	UserDO userDO = new UserDO();  
	userDO.setUserId("coderacademy");  
	userDO.setUserName("碼農Academy");  
	userDO.setSex(1);  
	  
	MutableTriple<String, Integer, UserDO> mutableTriple = handleUserInfo1(userDO);  
	System.out.println("mutableTriple改變前的值：" + mutableTriple);  
	mutableTriple.setMiddle(2);  
	System.out.println("mutableTriple改變後的值：" + mutableTriple);  
	  
	ImmutableTriple<String, Integer, UserDO> immutableTriple = handleUserInfo2(userDO);  
	System.out.println("ImmutableTriple改變前的值：" + immutableTriple);  
	UserDO userFromTriple = immutableTriple.right;  
	userFromTriple.setSex(2);  
	System.out.println("ImmutableTriple改Right鍵值對象的值：" + immutableTriple);  
	// 因ImmutableTriple 不可變，無法通過set方法修改鍵值。
}

總結

使用 Pair 和 Triple 類可以簡化代碼、提高可讀性，使關聯數據更清晰，保持類型安全，增強代碼清晰度，提高擴展性，並提供豐富的功能，從而使開發人員更高效地處理相關數據，編寫更簡潔可讀的代碼，提升代碼質量和開發效率。

本文已收錄於我的個人博客：碼農Academy的博客，專註分享Java技術乾貨，包括Java基礎、Spring Boot、Spring Cloud、Mysql、Redis、Elasticsearch、中間件、架構設計、面試題、程式員攻略等


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

-Advertisement-
Play Games
更多相關文章
  • 多線程系列(十二) -生產者和消費者模型
    一、簡介 在 Java 多線程編程中，還有一個非常重要的設計模式，它就是：生產者和消費者模型。 這種模型可以充分發揮 cpu 的多線程特性，通過一些平衡手段能有效的提升系統整體處理數據的速度，減輕系統負載，提高程式的效率和穩定性，同時實現模塊之間的解耦。 那什麼是生產者和消費者模型呢？ 簡單的說，生 ...
  • 使用 Java 在Excel中創建下拉列表
    下拉列表（下拉框）可以確保用戶僅從預先給定的選項中進行選擇，這樣不僅能減少數據輸入錯誤，還能節省時間提高效率。在MS Excel中，我們可以通過 “數據驗證” 提供的選項來創建下拉列表，但如果要在Java程式中通過代碼實現這一功能，可能需要藉助一些第三方庫。本文將分享兩種使用免費Java庫在Exce ...
  • 【自動化】使用PlayWright+代理IP實現多環境隔離
    Playwright是由微軟公司2020年初發佈的新一代自動化測試工具，相較於目前最常用的Selenium，它僅用一個API即可自動執行Chromium、Firefox、WebKit等主流瀏覽器自動化操作。 對各種開發語言也有非常好的支持。常用的NodeJs、Java、python都有支持，且有豐富 ...
  • 總結的Java知識點集合
    這是我讀大學時的Java知識點總結，還不全面，後續會逐漸增加完善。 知識點集合 實例變數 實例變數是指在類中聲明的變數，其值是針對類的每個實例而獨立存儲的。每個類的實例都有自己的一組實例變數，它們的值可以在對象創建時初始化，併在整個對象的生命周期中保持不變或者隨著對象的狀態而改變。 實例變數也被稱為 ...
  • 詳解Python中sys模塊的功能與應用
    本文分享自華為雲社區《深入Python：sys模塊的功能與應用詳解》，作者： 檸檬味擁抱。 在Python的標準庫中，sys 模塊是一個常用而強大的工具，它提供了與Python解釋器交互的函數和變數。本文將介紹sys模塊的一些常用函數和方法，並通過實際的代碼實例來解析它們的用法。 1. sys.ar ...
  • Python實現snap：對齊多張遙感影像的空間範圍
    本文介紹基於Python中ArcPy模塊，實現基於柵格圖像批量裁剪柵格圖像，同時對齊各個柵格圖像的空間範圍，統一其各自行數與列數的方法~ ...
  • 多線程系列(十一) -淺析併發讀寫鎖StampedLock
    一、摘要 在上一篇文章中，我們講到了使用ReadWriteLock可以解決多線程同時讀，但只有一個線程能寫的問題。 如果繼續深入的分析ReadWriteLock，從鎖的角度分析，會發現它有一個潛在的問題：如果有線程正在讀數據，寫線程準備修改數據的時候，需要等待讀線程釋放鎖後才能獲取寫鎖，簡單的說就是 ...
  • Java 21 終於對這些功能動刀了！！
    來源：https://medium.com/@benweidig 儘管 Java 是我使用過的向後相容程度最高的語言和環境之一，但始終存在功能棄用甚至刪除的可能性。Java 21 將棄用兩個功能，這就是我們今天要討論的內容。 推薦一個開源免費的 Spring Boot 實戰項目： https://g ...
一周排行
    -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.數據驗證 在伺服器端進行嚴格的數據驗證，確保接收到的數據符合預期格 ...
所有分類