除了FastJson,你還有選擇: Gson簡易指南

来源:https://www.cnblogs.com/one12138/archive/2019/09/09/11494256.html
-Advertisement-
Play Games

前言 這個周末被幾個技術博主的同一篇公眾號文章 "fastjson又被髮現漏洞，這次危害可導致服務癱瘓！" 刷屏，離之前漏洞事件沒多久，fastjson 又出現嚴重 Bug。目前項目中不少使用了 fastjson 做對象與JSON數據的轉換，又需要更新版本重新部署，可以說是費時費力。與此同時，也帶給 ...


前言

這個周末被幾個技術博主的同一篇公眾號文章 fastjson又被髮現漏洞，這次危害可導致服務癱瘓！ 刷屏，離之前漏洞事件沒多久，fastjson 又出現嚴重 Bug。目前項目中不少使用了 fastjson 做對象與JSON數據的轉換，又需要更新版本重新部署，可以說是費時費力。與此同時，也帶給我新的思考，面對大量功能強大的開源庫，我們不能盲目地引入到項目之中，眾多開源框架中某個不穩定因素就足以讓一個項目遭受滅頂之災。趁著周末，在家學習下同樣具備JSON與對象轉換功能的優秀開源框架 Gson，並且打算將今後項目使用 fastjson 的地方逐漸換成使用 Gson，記錄下學習總結的內容，希望對小伙伴也有所幫助。

本文所涉及所有代碼片段均在下麵倉庫中，感興趣的小伙伴歡迎參考學習：

https://github.com/wrcj12138aaa/gson-actions

版本支持：

  • JDK 8
  • Gson 2.8.5
  • JUnit 5.5.1
  • Lomok 1.18.8

Gson 簡介

在正式介紹 Gson 之前，我們可以先從官方的wiki看下 Gson 的描述，瞭解它是什麼？

Gson is a Java library that can be used to convert Java Objects into their JSON representation. It can also be used to convert a JSON string to an equivalent Java object。

從描述可以看出，Gson 是用於將 Java 對象與 JSON格式字元串數據相互轉換的 Java 庫。它起初在Google 內部廣泛使用在 Android 平臺 和 Java 服務端上。2008 年開源之後，成為了谷歌又一個被廣泛使用的開源框架，截止目前(2019.09.08) 在GitHub 上已有1W6 多星，相同作用的類庫還有 Spring Framework 中集成的 Jackson，以及阿裡開源的 fastjson等。

在特性方面，Gson 提供簡易的API fromJson/toJson 來實現 Java 與 JSON 之間的轉換，並且能生成緊湊，可讀的 JSON 字元串輸出，還支持複雜對象轉換和豐富的自定義表示，足以滿足在日常開發中我們絕大部分的 JSON 數據處理需求。

我們通常將對象與JSON字元串間的轉換稱之為序列化和反序列化(Serialization/Deserialization)。將 對象轉化成 JSON字元串的過程稱為序列化，將JSON 字元串轉化成對象的過程稱為反序列化。

Gson 基本使用

使用 Gson 框架進行序列化與反序列操作，都離不開 com.google.gson.Gson 對象，它也是 Gson 框架的關鍵對象，提供的公共 API 具備了多種序列化和反序列方式。

Gson 對象的創建主要有兩種方式：

  • 使用 new 關鍵字直接創建：Gson gson = new Gson()
  • 由 GsonBuilder 對象構建：Gson gson = new GsonBuilder().create()

通常情況下，上面兩種方式創建的 Gson 對象在進行序列化與反序列操作時行為都是一樣的，但是第二種方式構建 Gson 對象時，允許進行額外的行為定製，比如格式化 JSON 字元串的輸出內容，是否序列化 null 值等等。

Java 序列化

簡單對象的序列化

我們可以通過下麵的例子來看下通過上述兩種方式序列化 Java 對象的不同效果：

public class ResultTest {
    @Test
    void test_serialization() {
        Gson gson = new Gson();
        Result result = new Result(200, "成功", null);
        String json = gson.toJson(result);
        System.out.println("json is " + json);
      
        Gson buildedGson = new GsonBuilder().setPrettyPrinting().serializeNulls().create();
        String buildedJson = buildedGson.toJson(result);
        System.out.println("buildedJson is " + buildedJson);
    }

    class Result {
        private int code;
        private String message;
        private Object data;

        public Result(int code, String message, Object data) {
            this.code = code;
            this.message = message;
            this.data = data;
        }
    }
}

運行該測試用例，在控制台可以看到如下日誌輸出：

從結果可以看出，預設的 Gson 對象行為序列化對象時會將 null 值的欄位忽略，而 com.google.gson.GsonBuilder#serializeNulls 方法將允許 Gson 對象序列化 null 欄位；並且正常序列化後的 JSON 字元串是緊湊格式，節省字元串記憶體，使用 com.google.gson.GsonBuilder#setPrettyPrinting 方法之後最終輸出的 JSON 字元串是更易讀的格式。當然除了這兩個方法，GsonBuilder 還提供了許多定製序列化和反序列化行為的API，我們將後面的內容進一步講解。

JosnObject 生成 JSON

除了上述將自定義類的對象轉換成 JSON 的方式之外，還可以使用 Gson 框架提供的 JsonObject 構建普通對象，然後使用 toJson 方法生成 JSON 字元串，在原測試類中補充下方測試類，並運行查看效果如下

@Test
void test_jsonObject_serialization() {
  Gson gson = new Gson();
  JsonObject jsonObject = new JsonObject();
  jsonObject.addProperty("code", 400);
  jsonObject.addProperty("message", "參數錯誤");
  String toJson = gson.toJson(jsonObject);
  String exceptedJson = "{\"code\":400,\"message\":\"參數錯誤\"}";
  Assertions.assertEquals(exceptedJson, toJson); //true
}

JsonObject 使用 addProperty(property,value) 方法只能用來添加 String，Number，Boolean，Character這四類數據， 因為內部是調用 com.google.gson.JsonObject#add, 將 value 封裝成了 JsonPrimitive 對象，然後保存到了內部自定義的 LinkedTreeMap 集合變數 members 中；如果需要在 JsonObject 對象上添加其他對象時，就需要直接使用 add(String property, JsonElement value) 方法添加一個 JsonElement 對象。這裡的 JsonElement 是一個抽象類，JsonObject 和 JsonPrimitive 都繼承了JsonElement，所以我們最終通過另外的 JsonObject 對象來作為原 JsonObject 上的屬性對象：

Gson gson = new Gson();
JsonObject jsonObject = new JsonObject();
//...
JsonObject nestJsonObject = new JsonObject();
nestJsonObject.addProperty("username", "one");
nestJsonObject.addProperty("score", 99);
jsonObject.add("data", nestJsonObject);
String toJson2 = gson.toJson(jsonObject);
System.out.println(toJson2);
// {"code":400,"message":"參數錯誤","data":{"username":"one","score":99}}

JSON 反序列化

簡單對象的反序列化

現在我們再來看下 JSON 反序列化成 Java 對象用法，這裡主要使用方法是 com.google.gson.Gson#fromJson，它最基礎的用法就是 fromJson(String json, Class<T> classOfT)，嘗試將 JSON 字元串轉為指定 Class 的對象，如果轉換失敗，就會拋出 JsonSyntaxException 異常。我們可以在原來代碼上新增一個測試用例，運行看下效果：

@Test
void test_deserialization() {
    String json = "{\"code\":400,\"message\":\"參數錯誤\"}";
    Result result = new Gson().fromJson(json, Result.class);
    Assertions.assertEquals(400, result.code); // true
    Assertions.assertEquals("參數錯誤", result.message); // true
}

反序列化 Map

除了將JSON 字元串序列化為自定義的Java 對象之外，我們還可以轉為 Map 集合，Gson 提供了對 Map 集合的轉換，使用起來也十分簡單：

@Test
void test_map() {
    String jsonString = "{'employee.name':'one','employee.salary':10}";
    Gson gson = new Gson();
    Map map = gson.fromJson(jsonString, Map.class);
    assertEquals(2, map.size());
        assertEquals("one", map.get("employee.name"));
    assertEquals(Double.class, map.get("employee.name").getClass());
}

需要註意的是轉換後的 Map 對象真實類型並不是我們經常用的 HashMap，而是 Gson 自定義集合LinkedTreeMap ，它實現Map 介面來存儲鍵值對，在新增和刪除上實現上進行了優化，並且將存儲鍵值對的順序作為遍歷順序，也就是先存入的先被遍歷到。除此之外，JSON 字元串里的數值型數據都會轉轉換為 Double 類型，而 true/false 數據被會被轉換成 Boolean 類型，具體判斷依據可以參考 com.google.gson.internal.bind.ObjectTypeAdapter#read 方法的實現。

JSON 與 Array，List 轉換

JSON 轉換 Array

當我們正對 JSON 數據進行數組轉換時，類似普通對象轉換的方式即可， toJson 方法直接使用轉為 JSON 數據，fromJson 指定數組類型轉換為對應類型的數組。

@Test
void test_array() {
  Gson gson = new Gson();
  int[] ints = {1, 2, 3, 4, 5};
  String[] strings = {"abc", "def", "ghi"};
  String s = gson.toJson(ints);// [1,2,3,4,5]
  assertEquals("[1,2,3,4,5]", s); // true

  String s1 = gson.toJson(strings);// ["abc", "def", "ghi"]
  assertEquals("[\"abc\",\"def\",\"ghi\"]", s1);
  String[] strings1 = gson.fromJson(s1, String[].class);
  assertEquals(strings.length, strings1.length); // true
  assertEquals(strings[0], strings1[0]); // true

  int[] ints2 = gson.fromJson("[1,2,3,4,5]", int[].class);
  assertEquals(1, ints2[0]); // true
  assertEquals(5, ints2[4]); // true
}

JSON 轉換 List

要將 List 數據轉換為 JSON數據，使用 Gson 的方式與處理 Array 數據一樣；這裡主要講的是將JSON 數據轉為 List 對象的操作略有不同，要將一個 JSON 數組數據轉換為一個自定義類的List 時，我們按照原來的寫法如下：

@Test
public void givenJsonString_whenIncorrectDeserializing() {
    Gson gson = new Gson();
    String inputString = "[{\"id\":1,\"name\":\"one\"},{\"id\":2,\"name\":\"two\"}]";
    List<Person> outputList = gson.fromJson(inputString, List.class);
        outputList.get(0).getId();
}

但是不幸的是，運行這段代碼後會拋出 ClassCastException 異常，具體描述如下：

java.lang.ClassCastException: com.google.gson.internal.LinkedTreeMap cannot be cast to com.one.learn.Person
...

從上述描述中我們可以知道執行 fromJson 之後，反序列化後得到的 List 元素類型為 LinkedTreeMap，而不是 Person，所以以 Person 對象方式訪問 id 屬性時就會拋出 ClassCastException 異常。那又該如何處理呢, 我們需要調用 Gson 的 另外一個 fromJson 方法：fromJson(String json, Type typeOfT) ，先看下使用方式

@Test
public void givenJsonString_whenCorrectDeserializing_() {
  Gson gson = new Gson();
  String inputString = "[{\"id\":1,\"name\":\"one\"},{\"id\":2,\"name\":\"two\"}]";
  Type type = new TypeToken<List<Person>>(){}.getType();
  List<Person> outputList = gson.fromJson(inputString, type);
  int id = outputList.get(0).getId();
  assertEquals(1, id); // true
  assertEquals("one", outputList.get(0).getName()); // true
}

這個方法中的 Type 對象通過 TypeToken 對象的 getType 方法獲取到，就是 TypeToken 對象所關聯的泛型類型。而這裡 TypeToken 是 Gson 為了支持泛型而引入的類，來解決 Java 無法提供泛型類型表示的問題，由於 TypeToken 的構造方法是protected修飾的，無法直接構造，使用就需要寫成new TypeToken<List<String>>() {}.getType() 形式。

Gson 進階用法

接觸了 Gson 基本的使用之後，我們接著進一步學習 Gson 的其他用法。

泛型對象的反序列化

上節內容簡單接觸了 Gson 對泛型的支持，接下來用代碼來展示下它的強大之處，首先我們將上文的 Result 類調整下接受泛型參數：

class Result<T> {
  private int code;
  private String message;
  private T data;

  public Result(int code, String message, T data) {
    this.code = code;
    this.message = message;
    this.data = data;
  }
}

然後對一個有內嵌對象的 JSON字元串進行解析成 Result<User> 對象，示例代碼如下：

@Test
void test_genric_object() {
  String json = "{\"code\":200,\"message\":\"操作成功\",\"data\":{\"username\": \"one\",\"avater\": \"image.jpg\"" +
    "}}";
  Type type = new TypeToken<Result<User>>(){}.getType();
  Result<User> result = new Gson().fromJson(json, type);
  Assertions.assertEquals(200, result.code);
  Assertions.assertEquals("one", result.data.getUsername());
  Assertions.assertEquals("image.jpg", result.data.getAvater());
}

class User {
  private String username;
  private String avater;

  public String getUsername() {
    return username;
  }

  public String getAvater() {
    return avater;
  }
}

利用 TypeToken 對象獲取具體泛型類型 Result<User> , 然後在 fromJson 方法中傳入就會根據對應類型的執行反序列化操作。

自定義序列化

如果我們要對Java 對象的某些欄位進行特殊處理，比如隱藏某些欄位的序列化，對欄位的數據格式化處理等，我們可以通過實現 JsonSerializer 介面，對序列化邏輯進行自定義。例如，我們需要對 Date 類型屬性進行特定格式的處理，可以聲明 DateSerializer 類實現如下：

class DateSerializer implements JsonSerializer<Date> {
    SimpleDateFormat dateTime = new SimpleDateFormat("yyyy-MM-dd");

    @Override
    public JsonElement serialize(Date src, Type typeOfSrc, JsonSerializationContext context) {
        return new JsonPrimitive(dateTime.format(src));
    }
}

然後在構建 Gson 對象前，利用 GsonBuilder 將 DateSerializer 實例進行註冊，使用方式如下：

Gson gson = new GsonBuilder().registerTypeAdapter(Date.class, new DateSerializer()).create();

這樣一來，一旦遇到要序列化 Date 類型的欄位時，都會通過自定義的 serialize 方法將日期以 yyyy-MM-dd 格式進行輸出，如下方的示例代碼：

@Test
void test_dateSerializer() {
  MyObject myObject = new MyObject(new Date(), "one");
  Gson gson = new GsonBuilder().registerTypeAdapter(Date.class, new DateSerializer()).create();
  String json = gson.toJson(myObject);
  String exceptedJson = "{\"date\":\"2019-09-08\",\"name\":\"one\"}";
  Assertions.assertEquals(exceptedJson, json); // true
}

class MyObject {
    private Date date;
    private String name;

    public MyObject(Date date, String name) {
        this.date = date;
        this.name = name;
    }

    public MyObject() {
    }
}

自定義反序列化

與自定義序列化實現方式類似，想要自定義反序列化邏輯，就需要同樣要實現一個叫 JsonDeserializer 的介面，進行自定義反序列化邏輯的實現。比如現在有個 JSON 字元串內容為 {"CODE": 400, "MESSAGE": "參數錯誤"}，需要被反序列化為前文提到的 Result 對象，由於欄位名不一樣，為了實現對應的轉換，就需要自定義 ResultDeserializer 類，具體實現如下：

class ResultDeserializer implements JsonDeserializer<Result> {
    @Override
    public Result deserialize(JsonElement json, Type typeOfT, JsonDeserializationContext context) throws JsonParseException {
        JsonObject object = json.getAsJsonObject();
        Result<Object> result = new Result<>(object.getAsJsonPrimitive("CODE").getAsInt(),object.getAsJsonPrimitive("MESSAGE").getAsString(), null);
        return result;
    }
}

接下來就是利用 GsonBuilder 註冊 ResultDeserializer 實例，生成對應的 Gson 對象，併進行反序列化操作：

@Test
void test_resultDeserializer() {
    //language=JSON
        String json = "{\"CODE\": 400,\"MESSAGE\": \"參數錯誤\"}";
    Gson gson = new GsonBuilder().registerTypeAdapter(Result.class, new ResultDeserializer())
            .create();
    Result result = gson.fromJson(json, Result.class);
    Assertions.assertEquals(400, result.code); // true
    Assertions.assertEquals("參數錯誤", result.message); // true
}

Gson 常用註解

Gson 除了提供一些 API 供開發者使用之外，還有一些具有特性的註解可以使用，接下來就介紹在 Gson 中最常用的註解。

@Expose

這個註解只能用在欄位上，作用就是註明對應的欄位是否將在序列化或者反序列化時暴露出來，有兩個屬性 serialize 和 deserialize ，預設都為 true。當給一個欄位加上 註解@Expose(serialize = true, deserialize = false)，則表示了該欄位盡在序列化時可見，在反序列化時會忽略賦值。需要額外註意的一點是，@Expose 註解只有在用 GsonBuilder 方式構建 Gson 時有限，並且構建前必須調用 excludeFieldsWithoutExposeAnnotation 方法，下麵是具體的使用示例：


@Test
void test_expose() {
    MySubClass subclass = new MySubClass(42L, "the answer", "Verbose field not to serialize");
    MyClass source = new MyClass(1L, "foo", "bar", subclass);
    Gson gson = new GsonBuilder().excludeFieldsWithoutExposeAnnotation().create();
    String s = gson.toJson(source);
    System.out.println(s);
        // {"id":1,"name":"foo","subclass":{"id":42,"description":"the answer","otherVerboseInfo":"Verbose field not to serialize"}}
}

@Data
@AllArgsConstructor
class MyClass {
    private long id;
    @Expose(serialize = false, deserialize = true)
    private String name;
    private transient String other;
    @Expose
    private MySubClass subclass;
}

@Data
@AllArgsConstructor
class MySubClass {
    @Expose
    private long id;
    @Expose
    private String description;
    @Expose
    private String otherVerboseInfo;
}

在 Gson 中 transient 關鍵字修飾的欄位預設不會被序列化和反序列化，這個行為是與 Java 原生的序列化和反序列化操作一致的。

@Since

該註解用於標記對應欄位或者類型的版本，讓 Gson 可以指定版本號進行序列化和反序列化操作。當Web服務上的 JSON 數據對應的類存在多個版本的欄位時，這個註解就十分有用。

同樣地，該註解只針對使用 GsonBuilder 方式構建的 Gson 對象，並且使用 setVersion 方法指明版本號時有效，只解析對象中對應版本的欄位，下麵為具體示例：

public class VersioningSupportTest {
    @Test
    void test() {
        VersionedClass versionedObject = new VersionedClass();
        Gson gson = new GsonBuilder().setVersion(1.0).create();
        String jsonOutput = gson.toJson(versionedObject);
        System.out.println(jsonOutput); // {"newField":"new","field":"old"}
    }
}

class VersionedClass {
    @Since(1.1)
    private final String newerField;
    @Since(1.0)
    private final String newField;
    private final String field;

    public VersionedClass() {
        this.newerField = "newer";
        this.newField = "new";
        this.field = "old";
    }
}

@SerializedName

這個註解使用起來比較簡單，也很有用。@SerializedName 指定了成員欄位被序列化和反序列化時所採用的名稱下麵是具體使用方式：

public class JSONFieldNamingSupportTest {
    private class SomeObject {
        @SerializedName("custom_naming")
        private final String someField;
        private final String someOtherField;

        public SomeObject(String a, String b) {
            this.someField = a;
            this.someOtherField = b;
        }
    }

    @Test
    void test() {
        SomeObject someObject = new SomeObject("first", "second");
        String jsonRepresentation = gson.toJson(someObject);
        System.out.println(jsonRepresentation);
        // {"custom_naming":"first","someOtherField":"second"}
        SomeObject someObject1 = gson.fromJson(jsonRepresentation, SomeObject.class);
        System.out.println(someObject1);
        // SomeObject{someField='first', someOtherField='second'}
    }
}

@JsonAdapter

不同於上面的註解，@JsonAdapter 只作用於類上，主要作用就是代替 GsonBuilder.registerTypeAdapter 方法的執行，直接通過 @JsonAdapter(aClass.class) 方式指定 JsonDeserializer 對象或者 JsonSerializer 對象，可以起到相同的想過，並且優先順序比GsonBuilder.registerTypeAdapter的優先順序更高，由於只是將 registerTypeAdapter方法執行簡化成了註解方法，這裡就不再演示，直接在前文自定義反序列化一節的 Result 類上使用就可以看到效果。

結語

本文主要學習總結了 Gson 框架的序列化和反序列操作使用方式，以及介紹了 Gson 多種特性用法，希望對處理 JSON 數據感到頭疼的小伙伴有所幫助。

推薦閱讀

參考資料

  • https://github.com/google/gson/blob/master/UserGuide.md
  • https://www.jianshu.com/p/e740196225a4
  • https://juejin.im/post/5aad29f8518825558453c6c9
  • https://www.baeldung.com/gson-deserialization-guide
  • https://www.baeldung.com/gson-string-to-jsonobject

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

-Advertisement-
Play Games
更多相關文章
  • 分散式事務(理論+實戰)
    分佈系統中，如何保證數據的一致性、原子性，分散式事務。分散式事務分為兩大類，柔性事務、剛性事務。 一、方法論篇 分散式事務主要分為兩部分，剛性事務和柔性事務。剛性事務主要針對DB層面，嚴格保證事務的原子性要麼都成功，要麼執行失敗，全部回滾。 柔性事務，相對於剛性事務來的，為了保證DB的利用率，以及系 ...
  • 如何解析一個字元串並返回一個嵌套數組？
    我想要一個Python函數，它接受一個字元串，並返回一個數組，其中數組中的每個項目都是一個字元，或者是另一個這樣的數組。嵌套數組在輸入字元串中以'（'和以'）'開頭標記。 因此，該函數將如下所示： 註意：我更喜歡純粹功能性的解決方案。 解決方案 和， ...
  • Java連載28-記憶體分析
    一、方法在執行過程中是如何分配記憶體的，記憶體是如何變化的? 1.方法只定義，不調用，是不會執行的，並且在JVM中也不會給該方法分配”運行所屬“的記憶體空間，只有在調用這個方法的時候，才會動態的給這個方法分配所屬的記憶體空間。 2.在JVM記憶體劃分上有這樣三個主要的記憶體空間（當然除了這三塊之外還有其他的記憶體 ...
  • HO引擎近況20190910
    這個月公司的項目有點忙,我又生病了,美術同事和我又有幾個周末都有事所以沒有來給我做資源 而我這邊也又遇到了瓶頸,目前是開始攻關飛行道具的部分 UE4的4.23在經歷了8個預覽版之後終於出正式版了,我也第一時間更新下來並且升級了工程 可破壞建築什麼的聽起來可能是不錯的效果,以後做戰爭游戲可能會大量用到 ...
  • Python學習日記(二十七) 反射和幾個內置函數
    isinstance() 判斷isinstance(obj,cls)中obj是否是cls類的對象 issubclass() 判斷issubclass(sub,super)中sub是否是super類的派生類 反射 反射就是用字元串類型的名字去操作變數,python中的一切事物皆為對象(都可以使用反射) ...
  • PlayJava Day007
    今日所學： /* 2019.08.19開始學習，此為補檔。 */ 1.String類 實例化：①String name1 = "張三" ; ②String name2 = new String("李四") ; 2.==比較的是引用，equals比較的是具體內容。 String name3 = nam ...
  • 阿裡《JAVA實習生入職測試題—2019最新》之答案詳解（連載一）
    力爭清晰完整準確（逐步完善，持續更新） 1、String類為什麼是final的 首先分析String的源碼： 類被final關鍵字限定，說明它不可以被繼承，沒有子類。即持有一個String對象的引用，它必然是String類，而不會是其他的類。 value[]是用來存儲值的，被final關鍵字修飾，說 ...
  • JVM的記憶體分配垃圾回收策略
    之前看過《深入瞭解Java虛擬機》感覺容易忘，今天寫一篇博客加深一下印象。 JVM的記憶體分配和垃圾回收（GC）主要發生在Java堆中。而Java堆根據對象的存活時間可以分為新生代和老年代，而新生代又細分為Eden區、From Survivor區、To Survivor區，這是由於新生代中的垃圾回收算 ...
一周排行
    -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.數據驗證 在伺服器端進行嚴格的數據驗證，確保接收到的數據符合預期格 ...
所有分類