<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-actuator</artifactId>
</dependency>
<dependency>
    <groupId>io.micrometer</groupId>
    <artifactId>micrometer-registry-prometheus</artifactId>
</dependency>

management:
  endpoints:
    web:
      exposure:
        include: '*'
    enabled-by-default: true
  metrics:
    export:
      prometheus:
        enabled: true

public class SecurityConfig extends WebSecurityConfigurerAdapter{
    @Override
    protected void configure(HttpSecurity httpSecurity) throws Exception{
        httpSecurity
                // 配置要放開的接口
                .antMatchers("/actuator/**").permitAll()
                .antMatchers("/metrics/**").permitAll()
                .antMatchers("/trace").permitAll()
                .antMatchers("/heapdump").permitAll()
                // ...
    }
}

params:
 - field: host
   # name-param field display i18n name
   name:
     zh-CN: 目標 Host
     en-US: Target Host
   # type-param field type(most mapping the html input type)
   type: text
   # required-true or false
   required: true
# field-param field key
 - field: port
   # name-param field display i18n name
   name:
     zh-CN: 端口
     en-US: Port
   # type-param field type(most mapping the html input type)
   type: number
   # when type is number, range is required
   range: '[0,65535]'

@Override
 public void execute(Alert alert, PluginContext pluginContext) {
     log.info("param host:{}",pluginContext.getString("host"));
     log.info("param port:{}",pluginContext.getInteger("port"));
 }

//初始化桶大小為512 -1，用于取模
        int mask = 511;
        // 初始化起始時間
        startTime = System.nanoTime();
        do {
            // 獲取下一個時間指針
            long deadline = waitForNextTick();
            if (deadline > 0) {
                // 計算當前桶索引（取模）
                int idx = (int) (tick & mask);
                // 清理已取消任務(wù)
                processCancelledTasks();
                // 獲取當前桶
                HashedWheelBucket bucket = wheel[idx];
                // 將新任務(wù)添加到桶桶
                transferTimeoutsToBuckets();
                // 執(zhí)行到期任務(wù)
                bucket.expireTimeouts(deadline);
                // 推進時間+1
                tick++;
            }
        } while (isRunning());

private long waitForNextTick() {
    // 計算下一個tick的絕對時間點（單位：納秒）
    // tickDuration：每個tick的時間長度（默認1秒=1e9納秒）
    // tick：當前已執(zhí)行的tick計數(shù)
    long deadline = tickDuration * (tick + 1);

    // 自旋等待直到達到下一個tick時間點
    for (; ; ) {
        // 計算當前已過去的時間（納秒）
        final long currentTime = System.nanoTime() - startTime;
        
        // 計算需要休眠的時間（毫秒）
        // +999999：實現(xiàn)納秒到毫秒的向上取整轉(zhuǎn)換（避免精度丟失）
        long sleepTimeMs = (deadline - currentTime + 999999) / 1000000;

        // 檢查是否已達到或超過deadline
        if (sleepTimeMs <= 0) {
            // 處理極端邊界情況
            if (currentTime == Long.MIN_VALUE) {
                return -Long.MAX_VALUE;  // 異常返回值
            } else {
                return currentTime;  // 返回實際經(jīng)過的時間
            }
        }
        
        // Windows平臺特殊處理：調(diào)整休眠精度
        // 原因：Windows默認系統(tǒng)定時器精度約15ms，調(diào)整為10ms倍數(shù)可減少無效喚醒
        if (NetworkUtil.isWindowsPlatform()) {
            sleepTimeMs = sleepTimeMs / 10 * 10;  // 向下對齊到10ms
        }

        try {
            // 精確休眠直到下一個tick
            Thread.sleep(sleepTimeMs);
        } catch (InterruptedException ignored) {
            // 被中斷時檢查是否處于關(guān)閉狀態(tài)
            if (WORKER_STATE_UPDATER.get(HashedWheelTimer.this) == WORKER_STATE_SHUTDOWN) {
                return Long.MIN_VALUE;  // 返回關(guān)閉標識
            }
            // 否則忽略中斷繼續(xù)等待
        }
    }
}

private void processCancelledTasks() {
            for (; ; ) {
                // 從取消任務(wù)隊列獲取取消任務(wù)
                HashedWheelTimeout timeout = cancelledTimeouts.poll();
                if (timeout == null) {
                    // all processed
                    break;
                }
                try {
                    // timeout實現(xiàn)的從雙向鏈表中刪除當前節(jié)點
                    timeout.remove();
                } catch (Throwable t) {
                    if (logger.isWarnEnabled()) {
                        logger.warn("An exception was thrown while process a cancellation task", t);
                    }
                }
            }
        }

private void transferTimeoutsToBuckets() {
    // 每次tick最多轉(zhuǎn)移100,000個任務(wù)，防止添加任務(wù)的線程循環(huán)添加導(dǎo)致工作線程阻塞
    for (int i = 0; i < 100000; i++) {
        // 從任務(wù)隊列取出任務(wù)
        HashedWheelTimeout timeout = timeouts.poll();
        // 隊列為空時結(jié)束轉(zhuǎn)移
        if (timeout == null) {
            break;
        }
        // 跳過已取消的任務(wù)
        if (timeout.state() == HashedWheelTimeout.ST_CANCELLED) {
            continue;
        }
        // 計算任務(wù)的理論觸發(fā)時間槽（單位：tick）
        long calculated = timeout.deadline / tickDuration;
        // 計算任務(wù)需要經(jīng)歷的完整輪數(shù)
        timeout.remainingRounds = (calculated - tick) / wheel.length;
        // 確保任務(wù)不會分配到過去的時間槽：
        // 如果計算的時間槽小于當前tick，則使用當前tick
        final long ticks = Math.max(calculated, tick);
        // 計算桶索引（通過位運算替代取模，要求wheel.length是2的冪）
        int stopIndex = (int) (ticks & mask);
        // 將任務(wù)添加到對應(yīng)桶中
        HashedWheelBucket bucket = wheel[stopIndex];
        bucket.addTimeout(timeout);
    }
}

void expireTimeouts(long deadline) {
            HashedWheelTimeout timeout = head;
            // 遍歷桶中任務(wù)鏈表
            while (timeout != null) {
                HashedWheelTimeout next = timeout.next;
                // 剩余輪數(shù)為 0
                if (timeout.remainingRounds <= 0) {
                    // 從鏈表移除
                    remove(timeout);
                    if (timeout.deadline <= deadline) {
                        // 執(zhí)行任務(wù)
                        timeout.expire();
                    }
                } elseif (timeout.isCancelled()) {
                    // 移除已取消任務(wù)
                    remove(timeout);
                } else {
                    // 減少剩余輪數(shù)
                    timeout.remainingRounds--;
                }
                // 指針next
                timeout = next;
            }
        }

// 1. 添加物理節(jié)點
public void addNode(Node newNode) {
    if (!isPrivateMode(newNode)) {
        int vnodes = getVirtualNodeCount(newNode);
        for (int i = 0; i < vnodes; i++) {
            addVirtualNode(newNode, newNode.id + i);
        }
    }
    nodeMap.put(newNode.id, newNode);
    rebalanceJobs();
}

// 2. 添加虛擬節(jié)點（核心遷移邏輯）
public synchronized void addVirtualNode(Node node, String vnodeId) {
    int vHash = hash(vnodeId);
    hashRing.put(vHash, node);  // 加入哈希環(huán)
    
    // 初始化虛擬節(jié)點任務(wù)集
    node.initVirtualNode(vHash);  
    
    // 獲取順時針后繼節(jié)點
    Node nextNode = getNextNode(vHash);
    
    // 遷移任務(wù)：從后繼節(jié)點獲取任務(wù)集合
    Set<Long[]> jobs = nextNode.getJobsForMigration(vHash);
    
    if (!jobs.isEmpty()) {
        // 拆分任務(wù)：需要遷移的部分
        Set<Long[]> migrateJobs = extractJobsToMigrate(jobs, vHash);
        
        // 更新節(jié)點任務(wù)映射
        nextNode.updateJobs(jobs);          // 更新原節(jié)點
        node.addJobsToVirtualNode(vHash, migrateJobs); // 添加到新節(jié)點
        
        // 更新物理節(jié)點狀態(tài)
        if (node != nextNode) {
            migrateJobStatus(nextNode, node, migrateJobs);
        }
    }
}

// 3. 管理虛擬節(jié)點任務(wù)
private void addVirtualNodeJobs(int vHash, Set<Long[]> jobs) {
    if (vNodeJobs == null) vNodeJobs = new ConcurrentHashMap<>();
    
    // 合并或創(chuàng)建任務(wù)集
    if (vNodeJobs.containsKey(vHash)) {
        vNodeJobs.get(vHash).addAll(jobs);
    } else {
        vNodeJobs.put(vHash, jobs);
    }
}

public Node dispatchJob(Integer dispatchHash, Long jobId, boolean isFlushed) {
        if (dispatchHash == null || hashCircle == null || hashCircle.isEmpty()) {
            log.warn("There is no available collector registered. Cache the job {}.", jobId);
            dispatchJobCache.add(new DispatchJob(dispatchHash, jobId));
            return null;
        }
        // 獲取哈希環(huán)中第一個大于等于dispatchHash的節(jié)點
        Map.Entry<Integer, Node> ceilEntry = hashCircle.ceilingOrFirstEntry(dispatchHash);
        int virtualKey = ceilEntry.getKey();
        Node curNode = ceilEntry.getValue();

        curNode.addJob(virtualKey, dispatchHash, jobId, isFlushed);
        return curNode;
    }

public void collectorGoOffline(String identity) {
    // ... 更新數(shù)據(jù)庫狀態(tài)
    
    // 關(guān)鍵步驟：從一致性哈希環(huán)移除
    consistentHash.removeNode(identity);
    
    // 關(guān)鍵步驟：重新平衡任務(wù)分配
    reBalanceCollectorAssignJobs();
}

public void savePlugin(PluginUpload pluginUpload) {
        // 1. 保存JAR文件到plugin-lib目錄
        String jarPath = new File(this.getClass().getProtectionDomain().getCodeSource().getLocation().getPath()).getAbsolutePath();
        Path extLibPath = Paths.get(new File(jarPath).getParent(), "plugin-lib");
        File extLibDir = extLibPath.toFile();
        String fileName = UUID.randomUUID().toString().replace("-", "") + "_" + fileName;
        File destFile = new File(extLibDir, fileName);

        // 2. 驗證JAR文件內(nèi)容
        PluginMetadata parsed = validateJarFile(destFile);

        // 3. 保存插件元數(shù)據(jù)到數(shù)據(jù)庫
        metadataDao.save(pluginMetadata);
        itemDao.saveAll(pluginItems);

        // 4. 重新加載類加載器
        loadJarToClassLoader();

        // 5. 同步插件狀態(tài)
        syncPluginStatus();
    }

@PostConstruct
private void loadJarToClassLoader() {
    // 1. 關(guān)閉舊的類加載器
    for (URLClassLoader pluginClassLoader : pluginClassLoaders) {
        if (pluginClassLoader != null) {
            pluginClassLoader.close();
        }
    }
    
    // 2. 清理內(nèi)存
    if (!pluginClassLoaders.isEmpty()) {
        pluginClassLoaders.clear();
        System.gc();
    }
    
    // 3. 重新加載所有啟用的插件
    List<PluginMetadata> plugins = metadataDao.findPluginMetadataByEnableStatusTrue();
    for (PluginMetadata metadata : plugins) {
        List<URL> urls = loadLibInPlugin(metadata.getJarFilePath(), metadata.getId());
        urls.add(new File(metadata.getJarFilePath()).toURI().toURL());
        pluginClassLoaders.add(new URLClassLoader(urls.toArray(new URL[0]), Plugin.class.getClassLoader()));
    }
}

@Override
public <T> void pluginExecute(Class<T> clazz, Consumer<T> execute) {
    for (URLClassLoader pluginClassLoader : pluginClassLoaders) {
        // 使用ServiceLoader發(fā)現(xiàn)插件實現(xiàn)
        ServiceLoader<T> load = ServiceLoader.load(clazz, pluginClassLoader);
        for (T t : load) {
            if (pluginIsEnable(t.getClass())) {
                execute.accept(t);
            }
        }
    }
}