xxl-job源碼分析

来源:https://www.cnblogs.com/guoyinli/archive/2019/09/20/11555035.html
-Advertisement-
Play Games

xxl job 系統說明 安裝 安裝部署參考文檔： "分散式任務調度平臺xxl job" 功能 定時調度、服務解耦、靈活控制跑批時間（停止、開啟、重新設定時間、手動觸發） XXL JOB是一個輕量級分散式任務調度平臺，其核心設計目標是開發迅速、學習簡單、輕量級、易擴展。現已開放源代碼並接入多家公司線 ...


xxl-job

系統說明

安裝

安裝部署參考文檔：分散式任務調度平臺xxl-job

功能

定時調度、服務解耦、靈活控制跑批時間（停止、開啟、重新設定時間、手動觸發）

XXL-JOB是一個輕量級分散式任務調度平臺，其核心設計目標是開發迅速、學習簡單、輕量級、易擴展。現已開放源代碼並接入多家公司線上產品線，開箱即用

概念

執行器列表：一個執行器是一個項目

任務：一個任務是一個項目中的 JobHandler

一個xxl-job服務可以有多個執行器（項目），一個項目下可以有多個任務（JobHandler），他們是如何關聯的？

頁面操作：

  1. 在管理平臺可以新增執行器（項目）
  2. 在任務列表可以指定執行器（項目）下新增多個任務（JobHandler）

代碼操作：

  1. 項目配置中增加 xxl.job.executor.appname = "執行器名稱"
  2. 在實現類中增加 @JobHandler(value="xxl-job-demo") 註解，並繼承 IJobHandler

架構圖

拋出疑問

  1. 調度中心啟動過程？
  2. 執行器啟動過程？
  3. 執行器如何註冊到調度中心？
  4. 調度中心怎麼調用執行器？
  5. 集群調度時如何控制一個任務在該時刻不會重覆執行
  6. 集群部署應該註意什麼？

系統分析

執行器依賴jar包

com.xuxueli:xxl-job-core:2.1.0

com.xuxueli:xxl-registry-client:1.0.2

com.xuxueli:xxl-rpc-core:1.4.1

調度中心啟動過程

// 1. 載入 XxlJobAdminConfig，adminConfig = this
XxlJobAdminConfig.java

// 啟動過程代碼
@Component
public class XxlJobScheduler implements InitializingBean, DisposableBean {
    private static final Logger logger = LoggerFactory.getLogger(XxlJobScheduler.class);

    @Override
    public void afterPropertiesSet() throws Exception {
        // init i18n
        initI18n();

        // admin registry monitor run
        // 2. 啟動註冊監控器（將註冊到register表中的IP載入到group表）/ 30執行一次
        JobRegistryMonitorHelper.getInstance().start();

        // admin monitor run
        // 3. 啟動失敗日誌監控器（失敗重試，失敗郵件發送）
        JobFailMonitorHelper.getInstance().start();

        // admin-server
        // 4. 初始化RPC服務
        initRpcProvider();

        // start-schedule
        // 5. 啟動定時任務調度器（執行任務，緩存任務）
        JobScheduleHelper.getInstance().start();

        logger.info(">>>>>>>>> init xxl-job admin success.");
    }
    
    ......
}

執行器啟動過程

@Override
public void start() throws Exception {

    // init JobHandler Repository
    // 將執行 JobHandler 註冊到緩存中 jobHandlerRepository（ConcurrentMap）
    initJobHandlerRepository(applicationContext);

    // refresh GlueFactory
    // 刷新GLUE
    GlueFactory.refreshInstance(1);

    // super start
    // 核心啟動項
    super.start();
}

public void start() throws Exception {
    // 初始化日誌路徑 
    // private static String logBasePath = "/data/applogs/xxl-job/jobhandler";
    XxlJobFileAppender.initLogPath(this.logPath);
    // 初始化註冊中心列表 （把註冊地址放到 List）
    this.initAdminBizList(this.adminAddresses, this.accessToken);
    // 啟動日誌文件清理線程 （一天清理一次）
    // 每天清理一次過期日誌，配置參數必須大於3才有效
    JobLogFileCleanThread.getInstance().start((long)this.logRetentionDays);
    // 開啟觸發器回調線程
    TriggerCallbackThread.getInstance().start();
    // 指定埠
    this.port = this.port > 0 ? this.port : NetUtil.findAvailablePort(9999);
    // 指定IP
    this.ip = this.ip != null && this.ip.trim().length() > 0 ? this.ip : IpUtil.getIp();
    // 初始化RPC 將執行器註冊到調度中心 30秒一次
    this.initRpcProvider(this.ip, this.port, this.appName, this.accessToken);
}

執行器註冊到調度中心

執行器

// 註冊執行器入口
XxlJobExecutor.java->initRpcProvider()->xxlRpcProviderFactory.start();

// 開啟註冊
XxlRpcProviderFactory.java->start();

// 執行註冊
ExecutorRegistryThread.java->start();
// RPC 註冊代碼
for (AdminBiz adminBiz: XxlJobExecutor.getAdminBizList()) {
    try {
        ReturnT<String> registryResult = adminBiz.registry(registryParam);
        if (registryResult!=null && ReturnT.SUCCESS_CODE == registryResult.getCode()) {
            registryResult = ReturnT.SUCCESS;
            logger.debug(">>>>>>>>>>> xxl-job registry success, registryParam:{}, registryResult:{}", new Object[]{registryParam, registryResult});
            break;
        } else {
            logger.info(">>>>>>>>>>> xxl-job registry fail, registryParam:{}, registryResult:{}", new Object[]{registryParam, registryResult});
        }
    } catch (Exception e) {
        logger.info(">>>>>>>>>>> xxl-job registry error, registryParam:{}", registryParam, e);
    }

}

調度中心

// RPC 註冊服務
AdminBizImpl.java->registry();

資料庫

調度中心調用執行器

/* 調度中心執行步驟 */
// 1. 調用執行器
XxlJobTrigger.java->runExecutor();

// 2. 獲取執行器
XxlJobScheduler.java->getExecutorBiz();

// 3. 調用
ExecutorBizImpl.java->run();

/* 執行器執行步驟 */
// 1. 執行器介面
ExecutorBiz.java->run();

// 2. 執行器實現
ExecutorBizImpl.java->run();

// 3. 把jobInfo 從 jobThreadRepository (ConcurrentMap) 中獲取一個新線程，並開啟新線程
XxlJobExecutor.java->registJobThread();

// 4. 保存到當前線程隊列
JobThread.java->pushTriggerQueue();

// 5. 執行
JobThread.java->handler.execute(triggerParam.getExecutorParams());

調度中心（Admin）

實現 org.springframework.beans.factory.InitializingBean類，重寫 afterPropertiesSet 方法，在初始化bean的時候都會執行該方法

DisposableBean spring停止時執行

結束載入項

  1. 停止定時任務調度器（中斷scheduleThread，中斷ringThread）
  2. 停止觸發線程池（JobTriggerPoolHelper）
  3. 停止註冊監控器（registryThread）
  4. 停止失敗日誌監控器（monitorThread）
  5. 停止RPC服務（stopRpcProvider）

手動執行方式

JobInfoController.java

@RequestMapping("/trigger")
@ResponseBody
//@PermissionLimit(limit = false)
public ReturnT<String> triggerJob(int id, String executorParam) {
    // force cover job param
    if (executorParam == null) {
        executorParam = "";
    }

    JobTriggerPoolHelper.trigger(id, TriggerTypeEnum.MANUAL, -1, null, executorParam);
    return ReturnT.SUCCESS;
}

定時調度策略

調度策略執行圖

調度策略源碼

JobScheduleHelper.java->start();

路由策略

第一個

固定選擇第一個機器

ExecutorRouteFirst.java->route();
最後一個

固定選擇最後一個機器

ExecutorRouteLast.java->route();
輪詢

隨機選擇線上的機器

ExecutorRouteRound.java->route();

private static int count(int jobId) {
    // cache clear
    if (System.currentTimeMillis() > CACHE_VALID_TIME) {
        routeCountEachJob.clear();
        CACHE_VALID_TIME = System.currentTimeMillis() + 1000*60*60*24;
    }

    // count++
    Integer count = routeCountEachJob.get(jobId);
    count = (count==null || count>1000000)?(new Random().nextInt(100)):++count;  // 初始化時主動Random一次，緩解首次壓力
    routeCountEachJob.put(jobId, count);
    return count;
}
隨機

隨機獲取地址列表中的一個

ExecutorRouteRandom.java->route();
一致性HASH

一個job通過hash演算法固定使用一臺機器，且所有任務均勻散列在不同機器

ExecutorRouteConsistentHash.java->route();

public String hashJob(int jobId, List<String> addressList) {

    // ------A1------A2-------A3------
    // -----------J1------------------
    TreeMap<Long, String> addressRing = new TreeMap<Long, String>();
    for (String address: addressList) {
        for (int i = 0; i < VIRTUAL_NODE_NUM; i++) {
            long addressHash = hash("SHARD-" + address + "-NODE-" + i);
            addressRing.put(addressHash, address);
        }
    }

    long jobHash = hash(String.valueOf(jobId));
    // 取出鍵值 >= jobHash
    SortedMap<Long, String> lastRing = addressRing.tailMap(jobHash);
    if (!lastRing.isEmpty()) {
        return lastRing.get(lastRing.firstKey());
    }
    return addressRing.firstEntry().getValue();
}
最不經常使用

使用頻率最低的機器優先被選舉
把地址列表加入到記憶體中，等下次執行時剔除無效的地址，判斷地址列表中執行次數最少的地址取出
頻率、次數

ExecutorRouteLFU.java->route();

public String route(int jobId, List<String> addressList) {

    // cache clear
    if (System.currentTimeMillis() > CACHE_VALID_TIME) {
        jobLfuMap.clear();
        CACHE_VALID_TIME = System.currentTimeMillis() + 1000*60*60*24;
    }

    // lfu item init
    HashMap<String, Integer> lfuItemMap = jobLfuMap.get(jobId);     // Key排序可以用TreeMap+構造入參Compare；Value排序暫時只能通過ArrayList；
    if (lfuItemMap == null) {
        lfuItemMap = new HashMap<String, Integer>();
        jobLfuMap.putIfAbsent(jobId, lfuItemMap);   // 避免重覆覆蓋
    }

    // put new
    for (String address: addressList) {
        if (!lfuItemMap.containsKey(address) || lfuItemMap.get(address) >1000000 ) {
            // 0-n隨機數，包括0不包括n
            lfuItemMap.put(address, new Random().nextInt(addressList.size()));  // 初始化時主動Random一次，緩解首次壓力
        }
    }
    // remove old
    List<String> delKeys = new ArrayList<>();
    for (String existKey: lfuItemMap.keySet()) {
        if (!addressList.contains(existKey)) {
            delKeys.add(existKey);
        }
    }
    if (delKeys.size() > 0) {
        for (String delKey: delKeys) {
            lfuItemMap.remove(delKey);
        }
    }
    
    /*********************** 優化 START ***********************/
    // 優化  remove old部分
    Iterator<String> iterable = lfuItemMap.keySet().iterator();
    while (iterable.hasNext()) {
        String address = iterable.next();
        if (!addressList.contains(address)) {
            iterable.remove();
        }
    }
    /*********************** 優化 START ***********************/

    // load least userd count address
    // 從小到大排序
    List<Map.Entry<String, Integer>> lfuItemList = new ArrayList<Map.Entry<String, Integer>>(lfuItemMap.entrySet());
    Collections.sort(lfuItemList, new Comparator<Map.Entry<String, Integer>>() {
        @Override
        public int compare(Map.Entry<String, Integer> o1, Map.Entry<String, Integer> o2) {
            return o1.getValue().compareTo(o2.getValue());
        }
    });

    Map.Entry<String, Integer> addressItem = lfuItemList.get(0);
    String minAddress = addressItem.getKey();
    addressItem.setValue(addressItem.getValue() + 1);

    return addressItem.getKey();
}
最近最久未使用

最久未使用的機器優先被選舉
用鏈表的方式存儲地址，第一個地址使用後下次該任務過來使用第二個地址，依次類推（PS：有點類似輪詢策略）
與輪詢策略的區別：

  1. 輪詢策略是第一次隨機找一臺機器執行，後續執行會將索引加1取餘
  2. 輪詢策略依賴 addressList 的順序，如果這個順序變了，索引到下一次的機器可能不是期望的順序
  3. LRU演算法第一次執行會把所有地址載入進來並緩存，從第一個地址開始執行，即使 addressList 地址順序變了也不影響
    次數
ExecutorRouteLRU.java->route();

public String route(int jobId, List<String> addressList) {

    // cache clear
    if (System.currentTimeMillis() > CACHE_VALID_TIME) {
        jobLRUMap.clear();
        CACHE_VALID_TIME = System.currentTimeMillis() + 1000*60*60*24;
    }

    // init lru
    LinkedHashMap<String, String> lruItem = jobLRUMap.get(jobId);
    if (lruItem == null) {
        /**
         * LinkedHashMap
         *      a、accessOrder：ture=訪問順序排序（get/put時排序）；false=插入順序排期；
         *      b、removeEldestEntry：新增元素時將會調用，返回true時會刪除最老元素；可封裝LinkedHashMap並重寫該方法，比如定義最大容量，超出是返回true即可實現固定長度的LRU演算法；
         */
        lruItem = new LinkedHashMap<String, String>(16, 0.75f, true);
        jobLRUMap.putIfAbsent(jobId, lruItem);
    }

    /*********************** 舉個例子 START ***********************/
    // 如果accessOrder為true的話，則會把訪問過的元素放在鏈表後面，放置順序是訪問的順序 
    // 如果accessOrder為flase的話，則按插入順序來遍歷
    LinkedHashMap<String, String> lruItem = new LinkedHashMap<String, String>(16, 0.75f, true);
        jobLRUMap.putIfAbsent(1, lruItem);
        lruItem.put("192.168.0.1", "192.168.0.1");
        lruItem.put("192.168.0.2", "192.168.0.2");
        lruItem.put("192.168.0.3", "192.168.0.3");
        String eldestKey = lruItem.entrySet().iterator().next().getKey();
        String eldestValue = lruItem.get(eldestKey);
        System.out.println(eldestValue + ": " + lruItem);
        eldestKey = lruItem.entrySet().iterator().next().getKey();
        eldestValue = lruItem.get(eldestKey);
        System.out.println(eldestValue + ": " + lruItem);
    
    // 輸出結果：
    192.168.0.1: {192.168.0.2=192.168.0.2, 192.168.0.3=192.168.0.3, 192.168.0.1=192.168.0.1}
192.168.0.2: {192.168.0.3=192.168.0.3, 192.168.0.1=192.168.0.1, 192.168.0.2=192.168.0.2}
    /*********************** 舉個例子 END ***********************/
    
    // put new
    for (String address: addressList) {
        if (!lruItem.containsKey(address)) {
            lruItem.put(address, address);
        }
    }
    // remove old
    List<String> delKeys = new ArrayList<>();
    for (String existKey: lruItem.keySet()) {
        if (!addressList.contains(existKey)) {
            delKeys.add(existKey);
        }
    }
    if (delKeys.size() > 0) {
        for (String delKey: delKeys) {
            lruItem.remove(delKey);
        }
    }

    // load
    String eldestKey = lruItem.entrySet().iterator().next().getKey();
    String eldestValue = lruItem.get(eldestKey);
    return eldestValue;
}
故障轉移

按照順序依次進行心跳檢測，第一個心跳檢測成功的機器選定為目標執行器併發起調度

ExecutorRouteFailover.java->route();
忙碌轉移

按照順序依次進行空閑檢測，第一個空閑檢測成功的機器選定為目標執行器併發起調度

ExecutorRouteBusyover.java->route();
分片廣播

廣播觸發對應集群中所有機器執行一次任務，同時傳遞分片參數；可根據分片參數開發分片任務

阻塞處理策略

為瞭解決執行線程因併發問題、執行效率慢、任務多等原因而做的一種線程處理機制，主要包括 串列、丟棄後續調度、覆蓋之前調度，一般常用策略是串列機制

ExecutorBlockStrategyEnum.java

SERIAL_EXECUTION("Serial execution"), // 串列
DISCARD_LATER("Discard Later"), // 丟棄後續調度
COVER_EARLY("Cover Early"); // 覆蓋之前調度

ExecutorBizImpl.java->run();

// executor block strategy
if (jobThread != null) {
    ExecutorBlockStrategyEnum blockStrategy = ExecutorBlockStrategyEnum.match(triggerParam.getExecutorBlockStrategy(), null);
    if (ExecutorBlockStrategyEnum.DISCARD_LATER == blockStrategy) {
        // discard when running
        if (jobThread.isRunningOrHasQueue()) {
            return new ReturnT<String>(ReturnT.FAIL_CODE, "block strategy effect："+ExecutorBlockStrategyEnum.DISCARD_LATER.getTitle());
        }
    } else if (ExecutorBlockStrategyEnum.COVER_EARLY == blockStrategy) {
        // kill running jobThread
        if (jobThread.isRunningOrHasQueue()) {
            removeOldReason = "block strategy effect：" + ExecutorBlockStrategyEnum.COVER_EARLY.getTitle();

            jobThread = null;
        }
    } else {
        // just queue trigger
    }
}
單機串列

對當前線程不做任何處理，併在當前線程的隊列里增加一個執行任務

丟棄後續調度

如果當前線程阻塞，後續任務不再執行，直接返回失敗

覆蓋之前調度

創建一個移除原因，新建一個線程去執行後續任務

運行模式

ExecutorBizImpl.java->run();
BEAN

java里的bean對象

GLUE(Java)

利用java的反射機制，通過代碼字元串生成實體類

IJobHandler originJobHandler = GlueFactory.getInstance().loadNewInstance(triggerParam.getGlueSource());

GroovyClassLoader
GLUE(Shell Python PHP Nodejs PowerShell)

按照文件命名規則創建一個執行腳本文件和一個日誌輸出文件，通過腳本執行器執行

失敗重試次數

任務失敗後記錄到 xxl_job_log 中，由失敗監控線程查詢處理失敗的任務且失敗次數大於0，繼續執行

任務超時時間

把超時時間給 triggerParam 觸發參數，在調用執行器的任務時超時時間，有點類似HttpClient的超時時間

執行器（Exector）

  1. 註冊自己的機器地址

  2. 註冊項目中的 JobHandler

  3. 提供被調度中心調用的介面

    public interface ExecutorBiz {

    /**
     * 供調度中心檢測機器是否存活
     *
     * beat
     * @return
     */
    public ReturnT<String> beat();

    /**
     * 供調度中心檢測機器是否空閑
     *
     * @param jobId
     * @return
     */
    public ReturnT<String> idleBeat(int jobId);

    /**
     * kill
     * @param jobId
     * @return
     */
    public ReturnT<String> kill(int jobId);

    /**
     * log
     * @param logDateTim
     * @param logId
     * @param fromLineNum
     * @return
     */
    public ReturnT<LogResult> log(long logDateTim, long logId, int fromLineNum);

    /**
     * 執行觸發器
     * 
     * @param triggerParam
     * @return
     */
    public ReturnT<String> run(TriggerParam triggerParam);

}

總結

學到了什麼

  1. 演算法（LFU、LRU、輪詢等）
  2. JDK動態代理對象（詳細研究）
  3. 用到了Netty（詳細研究）
  4. FutureTask
  5. GroovyClassLoader

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

-Advertisement-
Play Games
更多相關文章
  • jquery的api以及用法總結-選擇器
    jQuery API及用法總結 選擇器 基本選擇器 1. \ 通用選擇器 2. .class 類選擇器，一個元素可以有多個類(chrome使用原生js函數getElementByClassName()實現) 利用類選擇器改變元素的樣式 3. element元素選擇器，DOM節點的標簽名(調用函數ge ...
  • 前端 js 頁面載入完成事件 - onload，五種寫法
    在js和jquery使用中，經常使用到頁面載入完成後執行某一方法。通過整理，大概是五種方式（其中有的只是書寫方式不一樣）。 1：使用jQuery的$(function){}; 2：使用jquery的$(document).ready(function(){}); 前兩者本質上沒有區別，第1種是第2種 ...
  • GitLab-使用SSH的方式拉取和推送項目
    場景 Docker Compose部署GitLab服務，搭建自己的代碼托管平臺(圖文教程)： https://blog.csdn.net/BADAO_LIUMANG_QIZHI/article/details/101039801 從零開始一步一步搭建Ubuntu Server伺服器、修改數據源、安裝 ...
  • GitLab-怎樣使用GitLab托管項目
    場景 Docker Compose部署GitLab服務，搭建自己的代碼托管平臺(圖文教程)： https://blog.csdn.net/BADAO_LIUMANG_QIZHI/article/details/101039801 從零開始一步一步搭建Ubuntu Server伺服器、修改數據源、安裝 ...
  • GitLab基本設置-新增用戶
    場景 Docker Compose部署GitLab服務，搭建自己的代碼托管平臺(圖文教程)： https://blog.csdn.net/BADAO_LIUMANG_QIZHI/article/details/101039801 從零開始一步一步搭建Ubuntu Server伺服器、修改數據源、安裝 ...
  • 高強度學習訓練第六天總結：Redis主從關係總結
    Redis主從複製機制 1、讀寫分離的好處 + 性能優化：主伺服器專註於寫操作，可以更適合寫入數據的模式工作；同樣，從伺服器專註於讀操作，可以用更適合讀取數據的模式工作。 + 強化數據安全，避免單點故障：由於同步機制的存在，各個伺服器之間的數據保持一致，所以其中某個伺服器宕機不會導致數據丟失或無法訪 ...
  • uml統一建模語言學習筆記(一)
    UML是一種統一建模語言，他是以面向對象的方式來實現對任何的系統進行描述的一種語言， 它包括9種圖形+包圖，分為靜態和動態兩種,也就是結構圖和行為圖 “靜態”圖有：用例圖、類圖、對象圖、部署圖、構件圖 “動態”圖有：序列圖、活動圖、狀態圖和協作圖。 1、用例圖： 用例圖是一種從用戶角度來描述系統功能 ...
  • 微服務之間的最佳調用方式
    微服務之間的調用有兩種方式，RPC和事件驅動。事件驅動是更好的方式，因為它是松耦合的。但如果業務邏輯是緊耦合的，RPC方式也是可行的（它的好處是代碼更簡單），而且你還可以通過選取合適的協議（Protobuf+gRPC）來降低這種緊耦合帶來的危害。由於事件溯源和事件通知的相似性，很多人把兩者弄混了，但... ...
一周排行
    -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.數據驗證 在伺服器端進行嚴格的數據驗證，確保接收到的數據符合預期格 ...
所有分類