refactor: 清理死代码函数以提升代码质量

移除了36个静态分析工具识别的未使用函数，减少代码体积534行：

核心模块：
- core/PluginAdapter.go: 移除7个未使用的插件适配器方法
- core/Registry.go: 移除5个未使用的注册器方法
- core/Scanner.go: 移除1个未使用的扫描方法
- core/WebDetection.go: 移除4个未使用的Web检测方法

通用模块：
- common/ConcurrencyMonitor.go: 移除3个未使用的并发监控方法
- common/common.go: 移除1个未使用的插件注册方法
- common/base/Plugin.go: 移除4个未使用的插件管理方法
- common/parsers/Simple.go: 移除1个未使用的端口解析方法
- common/utils/memmonitor.go: 移除9个未使用的内存监控方法
- common/utils/slicepool.go: 移除1个未使用的切片去重方法

插件模块：
- plugins/services/vnc/plugin.go: 移除1个未使用的服务识别方法

所有移除的函数均替换为中文注释标记，保持代码可读性。

Common/ConcurrencyMonitor.go

@@ -99,28 +99,7 @@ func (m *ConcurrencyMonitor) FinishConnection(pluginName, target string) {
 	}
 }
 
-// GetConnectionStats 获取所有插件连接统计
+// 已移除未使用的 GetConnectionStats 方法
-func (m *ConcurrencyMonitor) GetConnectionStats() map[string]*PluginConnectionInfo {
-	stats := make(map[string]*PluginConnectionInfo)
-	
-	m.pluginConnections.Range(func(key, value interface{}) bool {
-		keyStr := key.(string)
-		info := value.(*PluginConnectionInfo)
-		
-		// 只返回当前活跃的连接
-		if atomic.LoadInt64(&info.ActiveConnections) > 0 {
-			stats[keyStr] = &PluginConnectionInfo{
-				PluginName:        info.PluginName,
-				Target:            info.Target,
-				ActiveConnections: atomic.LoadInt64(&info.ActiveConnections),
-				TotalConnections:  atomic.LoadInt64(&info.TotalConnections),
-			}
-		}
-		return true
-	})
-	
-	return stats
-}
 
 // GetTotalActiveConnections 获取总活跃连接数
 func (m *ConcurrencyMonitor) GetTotalActiveConnections() int64 {
@@ -135,16 +114,7 @@ func (m *ConcurrencyMonitor) GetTotalActiveConnections() int64 {
 	return total
 }
 
-// Reset 重置监控器
+// 已移除未使用的 Reset 方法
-func (m *ConcurrencyMonitor) Reset() {
-	atomic.StoreInt64(&m.activePluginTasks, 0)
-	atomic.StoreInt64(&m.totalPluginTasks, 0)
-	
-	m.pluginConnections.Range(func(key, value interface{}) bool {
-		m.pluginConnections.Delete(key)
-		return true
-	})
-}
 
 // GetConcurrencyStatus 获取并发状态字符串
 func (m *ConcurrencyMonitor) GetConcurrencyStatus() string {
@@ -164,28 +134,4 @@ func (m *ConcurrencyMonitor) GetConcurrencyStatus() string {
 		i18n.GetText("concurrency_connection"), totalConnections)
 }
 
-// GetDetailedStatus 获取详细的并发状态
+// 已移除未使用的 GetDetailedStatus 方法
-func (m *ConcurrencyMonitor) GetDetailedStatus() string {
-	activePlugins, _ := m.GetPluginTaskStats()
-	connectionStats := m.GetConnectionStats()
-	
-	if activePlugins == 0 && len(connectionStats) == 0 {
-		return i18n.GetText("concurrency_no_active_tasks")
-	}
-	
-	status := fmt.Sprintf("%s: %d", i18n.GetText("concurrency_plugin_tasks"), activePlugins)
-	
-	if len(connectionStats) > 0 {
-		status += " | " + i18n.GetText("concurrency_connection_details") + ": "
-		first := true
-		for _, info := range connectionStats {
-			if !first {
-				status += ", "
-			}
-			status += fmt.Sprintf("%s@%s:%d", info.PluginName, info.Target, info.ActiveConnections)
-			first = false
-		}
-	}
-	
-	return status
-}

Common/base/Plugin.go

@@ -1,7 +1,6 @@
 package base
 
 import (
-	"fmt"
 	"sync"
 )
 
@@ -126,41 +125,7 @@ func (p *ScanPlugin) GetInfo() map[string]interface{} {
 // 插件管理器方法
 // =============================================================================
 
-// RegisterPlugin 注册插件
+// 已移除未使用的 RegisterPlugin 方法
-func (pm *PluginManager) RegisterPlugin(plugin *ScanPlugin) error {
-	if plugin == nil {
-		return fmt.Errorf("plugin cannot be nil")
-	}
-	if plugin.Name == "" {
-		return fmt.Errorf("plugin name cannot be empty")
-	}
-	if plugin.ScanFunc == nil {
-		return fmt.Errorf("plugin scan function cannot be nil")
-	}
-
-	pm.mu.Lock()
-	defer pm.mu.Unlock()
-
-	// 检查插件是否已存在
-	if _, exists := pm.plugins[plugin.Name]; exists {
-		return fmt.Errorf("plugin %s already registered", plugin.Name)
-	}
-
-	// 注册插件
-	pm.plugins[plugin.Name] = plugin
-
-	// 按类型索引
-	for _, pluginType := range plugin.Types {
-		pm.types[pluginType] = append(pm.types[pluginType], plugin)
-	}
-
-	// 按端口索引
-	for _, port := range plugin.Ports {
-		pm.ports[port] = append(pm.ports[port], plugin)
-	}
-
-	return nil
-}
 
 // ========================================================================================
 // 未使用的插件管理器方法已删除（死代码清理）
@@ -172,89 +137,11 @@ func (pm *PluginManager) RegisterPlugin(plugin *ScanPlugin) error {
 // 全局插件管理函数 (保持向后兼容)
 // =============================================================================
 
-// RegisterPlugin 注册插件到全局管理器
+// 已移除未使用的 RegisterPlugin 方法
-func RegisterPlugin(name string, plugin ScanPlugin) error {
-	// 转换为新的插件结构
-	newPlugin := &ScanPlugin{
-		Name:     name,
-		Ports:    plugin.Ports,
-		Types:    plugin.Types,
-		Enabled:  true,
-		ScanFunc: plugin.ScanFunc,
-	}
-	
-	// 注册到新的插件管理器
-	err := globalPluginManager.RegisterPlugin(newPlugin)
-	if err != nil {
-		return err
-	}
-	
-	// 同时更新Legacy管理器以保持向后兼容
-	LegacyPluginManager[name] = plugin
-	
-	return nil
-}
 
-// Clear 清理所有插件（防止内存泄漏）
+// 已移除未使用的 Clear 方法
-func (pm *PluginManager) Clear() {
-	pm.mu.Lock()
-	defer pm.mu.Unlock()
-	
-	// 清理插件实例
-	for name, plugin := range pm.plugins {
-		// ScanPlugin结构不包含Cleanup方法，直接删除即可
-		_ = plugin // 避免未使用变量警告
-		delete(pm.plugins, name)
-	}
-	
-	// 清理索引
-	for typeKey := range pm.types {
-		delete(pm.types, typeKey)
-	}
-	for portKey := range pm.ports {
-		delete(pm.ports, portKey)
-	}
-	
-	// 清理Legacy管理器
-	for k := range LegacyPluginManager {
-		delete(LegacyPluginManager, k)
-	}
-}
 
-// ClearPluginsByType 清理指定类型的插件
+// 已移除未使用的 ClearPluginsByType 方法
-func (pm *PluginManager) ClearPluginsByType(pluginType string) {
-	pm.mu.Lock()
-	defer pm.mu.Unlock()
-	
-	plugins := pm.types[pluginType]
-	for _, plugin := range plugins {
-		// ScanPlugin结构不包含Cleanup方法，直接删除即可
-		delete(pm.plugins, plugin.Name)
-	}
-	delete(pm.types, pluginType)
-	
-	// 同步清理端口索引
-	for port, portPlugins := range pm.ports {
-		filtered := make([]*ScanPlugin, 0)
-		for _, plugin := range portPlugins {
-			found := false
-			for _, typePlugin := range plugins {
-				if plugin == typePlugin {
-					found = true
-					break
-				}
-			}
-			if !found {
-				filtered = append(filtered, plugin)
-			}
-		}
-		if len(filtered) == 0 {
-			delete(pm.ports, port)
-		} else {
-			pm.ports[port] = filtered
-		}
-	}
-}
 
 // GetGlobalPluginManager 方法已删除（死代码清理）
 

Common/common.go

@@ -45,12 +45,7 @@ var PluginManager = base.LegacyPluginManager
 // 核心功能导出 - 直接调用对应模块
 // =============================================================================
 
-// 插件系统
+// 已移除未使用的 RegisterPlugin 方法
-func RegisterPlugin(name string, plugin ScanPlugin) {
-	if err := base.RegisterPlugin(name, plugin); err != nil {
-		LogError("Failed to register plugin " + name + ": " + err.Error())
-	}
-}
 
 // GetGlobalPluginManager 函数已删除（死代码清理）
 

Common/parsers/Simple.go

@@ -108,11 +108,7 @@ func ParsePort(ports string) []int {
 	return result
 }
 
-// ParsePortsFromString 从字符串解析端口列表
+// 已移除未使用的 ParsePortsFromString 方法
-// 保持与 ParsePortsFromString 的接口兼容性
-func ParsePortsFromString(portsStr string) []int {
-	return ParsePort(portsStr)
-}
 
 // =============================================================================
 // 辅助函数

Common/utils/memmonitor.go

@@ -1,8 +1,6 @@
 package utils
 
 import (
-	"log"
-	"runtime"
 	"time"
 )
 
@@ -25,102 +23,19 @@ func NewMemoryMonitor(maxHeapMB uint64, maxGoroutines int, checkInterval time.Du
 	}
 }
 
-// Start 启动内存监控
+// 已移除未使用的 Start 方法
-func (mm *MemoryMonitor) Start() {
-	if mm.running {
-		return
-	}
-	
-	mm.running = true
-	go mm.monitor()
-}
 
-// Stop 停止内存监控
+// 已移除未使用的 Stop 方法
-func (mm *MemoryMonitor) Stop() {
-	if !mm.running {
-		return
-	}
-	
-	mm.running = false
-	select {
-	case mm.stopChan <- true:
-	default:
-	}
-}
 
-// monitor 监控循环
+// 已移除未使用的 monitor 方法
-func (mm *MemoryMonitor) monitor() {
-	ticker := time.NewTicker(mm.checkInterval)
-	defer ticker.Stop()
-	
-	for {
-		select {
-		case <-ticker.C:
-			mm.checkMemory()
-		case <-mm.stopChan:
-			return
-		}
-	}
-}
 
-// checkMemory 检查内存使用情况
+// 已移除未使用的 checkMemory 方法
-func (mm *MemoryMonitor) checkMemory() {
-	var m runtime.MemStats
-	runtime.ReadMemStats(&m)
-	
-	heapMB := m.HeapInuse / 1024 / 1024
-	goroutineCount := runtime.NumGoroutine()
-	
-	// 检查堆内存使用
-	if heapMB > mm.maxHeapMB {
-		log.Printf("[WARN] 内存使用警告: 堆内存使用过高 %d MB (阈值: %d MB)", heapMB, mm.maxHeapMB)
-		
-		// 尝试触发GC
-		runtime.GC()
-		
-		// 再次检查
-		runtime.ReadMemStats(&m)
-		heapMBAfterGC := m.HeapInuse / 1024 / 1024
-		log.Printf("[INFO] GC后堆内存: %d MB", heapMBAfterGC)
-	}
-	
-	// 检查goroutine数量
-	if goroutineCount > mm.maxGoroutines {
-		log.Printf("[WARN] Goroutine数量警告: 当前数量 %d (阈值: %d)", goroutineCount, mm.maxGoroutines)
-	}
-}
 
-// GetMemoryStats 获取当前内存统计信息
+// 已移除未使用的 GetMemoryStats 方法
-func (mm *MemoryMonitor) GetMemoryStats() map[string]interface{} {
-	var m runtime.MemStats
-	runtime.ReadMemStats(&m)
-	
-	return map[string]interface{}{
-		"heap_inuse_mb":    m.HeapInuse / 1024 / 1024,
-		"heap_alloc_mb":    m.HeapAlloc / 1024 / 1024,
-		"sys_mb":           m.Sys / 1024 / 1024,
-		"num_gc":           m.NumGC,
-		"num_goroutines":   runtime.NumGoroutine(),
-		"last_gc_time":     time.Unix(0, int64(m.LastGC)),
-	}
-}
 
-// ForceGC 强制执行垃圾回收
+// 已移除未使用的 ForceGC 方法
-func (mm *MemoryMonitor) ForceGC() {
-	before := mm.getHeapSize()
-	runtime.GC()
-	after := mm.getHeapSize()
-	
-	// 使用log包直接输出，避免undefined common错误
-	log.Printf("[INFO] 强制GC: 释放内存 %d MB", (before-after)/1024/1024)
-}
 
-// getHeapSize 获取当前堆大小
+// 已移除未使用的 getHeapSize 方法
-func (mm *MemoryMonitor) getHeapSize() uint64 {
-	var m runtime.MemStats
-	runtime.ReadMemStats(&m)
-	return m.HeapInuse
-}
 
 // 默认内存监控器实例
 var DefaultMemMonitor = NewMemoryMonitor(
@@ -129,12 +44,6 @@ var DefaultMemMonitor = NewMemoryMonitor(
 	30*time.Second,  // 30秒检查一次
 )
 
-// StartDefaultMonitor 启动默认内存监控器
+// 已移除未使用的 StartDefaultMonitor 方法
-func StartDefaultMonitor() {
-	DefaultMemMonitor.Start()
-}
 
-// StopDefaultMonitor 停止默认内存监控器
+// 已移除未使用的 StopDefaultMonitor 方法
-func StopDefaultMonitor() {
-	DefaultMemMonitor.Stop()
-}

Common/utils/slicepool.go

@@ -2,25 +2,7 @@ package utils
 
 
 
-// DeduplicateStrings 高效字符串去重 - 简化版本
+// 已移除未使用的 DeduplicateStrings 方法
-func DeduplicateStrings(slice []string) []string {
-	if len(slice) <= 1 {
-		return slice
-	}
-	
-	// 使用最简单高效的实现
-	seen := make(map[string]struct{}, len(slice))
-	result := make([]string, 0, len(slice))
-	
-	for _, item := range slice {
-		if _, exists := seen[item]; !exists {
-			seen[item] = struct{}{}
-			result = append(result, item)
-		}
-	}
-	
-	return result
-}
 
 
 

core/PluginAdapter.go

@@ -34,45 +34,11 @@ func (pa *PluginAdapter) PluginExists(name string) bool {
 	return metadata != nil
 }
 
-// GetPluginPorts 获取插件支持的端口
+// 已移除未使用的 GetPluginPorts 方法
-func (pa *PluginAdapter) GetPluginPorts(name string) []int {
-	metadata := pa.registry.GetMetadata(name)
-	if metadata != nil {
-		return metadata.Ports
-	}
-	return []int{}
-}
 
-// GetPluginsByPort 根据端口获取支持的插件
+// 已移除未使用的 GetPluginsByPort 方法
-func (pa *PluginAdapter) GetPluginsByPort(port int) []string {
-	var plugins []string
-	for _, name := range pa.registry.GetAll() {
-		metadata := pa.registry.GetMetadata(name)
-		if metadata != nil {
-			for _, p := range metadata.Ports {
-				if p == port {
-					plugins = append(plugins, name)
-					break
-				}
-			}
-		}
-	}
-	return plugins
-}
 
-// GetPluginsByType 根据类型获取插件
+// 已移除未使用的 GetPluginsByType 方法
-func (pa *PluginAdapter) GetPluginsByType(pluginType string) []string {
-	var plugins []string
-	for _, name := range pa.registry.GetAll() {
-		metadata := pa.registry.GetMetadata(name)
-		if metadata != nil {
-			if metadata.Category == pluginType {
-				plugins = append(plugins, name)
-			}
-		}
-	}
-	return plugins
-}
 
 // ScanWithPlugin 使用插件进行扫描
 func (pa *PluginAdapter) ScanWithPlugin(pluginName string, info *common.HostInfo) error {
@@ -103,38 +69,10 @@ func (pa *PluginAdapter) ScanWithPlugin(pluginName string, info *common.HostInfo
 	return nil
 }
 
-// FilterPluginsByType 按类型过滤插件名称
+// 已移除未使用的 FilterPluginsByType 方法
-func FilterPluginsByType(pluginType string) func(name string) bool {
-	return func(name string) bool {
-		metadata := GlobalPluginAdapter.registry.GetMetadata(name)
-		if metadata == nil {
-			return false
-		}
-		
-		switch pluginType {
-		case common.PluginTypeService:
-			return metadata.Category == "service"
-		case common.PluginTypeWeb:
-			return metadata.Category == "web"
-		case common.PluginTypeLocal:
-			return metadata.Category == "local"
-		default:
-			return true
-		}
-	}
-}
 
-// GetServicePlugins 获取所有服务插件
+// 已移除未使用的 GetServicePlugins 方法
-func GetServicePlugins() []string {
-	return GlobalPluginAdapter.GetPluginsByType("service")
-}
 
-// GetWebPlugins 获取所有Web插件
+// 已移除未使用的 GetWebPlugins 方法
-func GetWebPlugins() []string {
-	return GlobalPluginAdapter.GetPluginsByType("web")
-}
 
-// GetLocalPlugins 获取所有本地插件
+// 已移除未使用的 GetLocalPlugins 方法
-func GetLocalPlugins() []string {
-	return GlobalPluginAdapter.GetPluginsByType("local")
-}

core/Registry.go

@@ -85,49 +85,15 @@ func InitializePluginSystem() error {
 	return nil
 }
 
-// GetAllPlugins 获取所有已注册插件名称
+// 已移除未使用的 GetAllPlugins 方法
-func GetAllPlugins() []string {
-	return base.GlobalPluginRegistry.GetAll()
-}
 
-// GetPluginMetadata 获取插件元数据
+// 已移除未使用的 GetPluginMetadata 方法
-func GetPluginMetadata(name string) *base.PluginMetadata {
-	return base.GlobalPluginRegistry.GetMetadata(name)
-}
 
-// CreatePlugin 创建插件实例
+// 已移除未使用的 CreatePlugin 方法
-func CreatePlugin(name string) (base.Plugin, error) {
-	return base.GlobalPluginRegistry.Create(name)
-}
 
-// GetPluginsByCategory 按类别获取插件
+// 已移除未使用的 GetPluginsByCategory 方法
-func GetPluginsByCategory(category string) []string {
-	var plugins []string
-	for _, name := range base.GlobalPluginRegistry.GetAll() {
-		if metadata := base.GlobalPluginRegistry.GetMetadata(name); metadata != nil {
-			if metadata.Category == category {
-				plugins = append(plugins, name)
-			}
-		}
-	}
-	return plugins
-}
 
-// GetPluginsByPort 按端口获取插件  
+// 已移除未使用的 GetPluginsByPort 方法
-func GetPluginsByPort(port int) []string {
-	var plugins []string
-	for _, name := range base.GlobalPluginRegistry.GetAll() {
-		if metadata := base.GlobalPluginRegistry.GetMetadata(name); metadata != nil {
-			for _, p := range metadata.Ports {
-				if p == port {
-					plugins = append(plugins, name)
-					break
-				}
-			}
-		}
-	}
-	return plugins
-}
 
 // init 自动初始化插件系统
 func init() {

core/Scanner.go

@@ -187,7 +187,4 @@ func executeScanTask(pluginName string, target common.HostInfo, ch *chan struct{
 }
 
 
-// Scan 入口函数，向后兼容旧的调用方式
+// 已移除未使用的 Scan 方法
-func Scan(info common.HostInfo) {
-	RunScan(info)
-}

core/WebDetection.go

@@ -1,10 +1,6 @@
 package core
 
 import (
-	"context"
-	"net"
-	"net/http"
-	"strings"
 	"time"
 )
 
@@ -48,98 +44,15 @@ func NewWebPortDetector() *WebPortDetector {
 	}
 }
 
-// IsWebService 检测指定主机端口是否为Web服务
+// 已移除未使用的 IsWebService 方法
-func (w *WebPortDetector) IsWebService(host string, port int) bool {
-	// 1. 首先检查是否为常见Web端口
-	if w.commonWebPorts[port] {
-		return true
-	}
-
-	// 2. 对于非常见端口，进行HTTP协议检测
-	return w.detectHTTPService(host, port)
-}
 
 // IsCommonWebPort 检查是否为常见Web端口
 func (w *WebPortDetector) IsCommonWebPort(port int) bool {
 	return w.commonWebPorts[port]
 }
 
-// detectHTTPService 检测HTTP服务（轻量级探测）
+// 已移除未使用的 detectHTTPService 方法
-func (w *WebPortDetector) detectHTTPService(host string, port int) bool {
-	// 创建检测上下文，避免长时间阻塞
-	ctx, cancel := context.WithTimeout(context.Background(), w.httpTimeout)
-	defer cancel()
 
-	// 尝试HTTP连接
+// 已移除未使用的 tryHTTPConnection 方法
-	if w.tryHTTPConnection(ctx, host, port, "http") {
-		return true
-	}
 
-	// 尝试HTTPS连接（对于高端口常见）
+// 已移除未使用的 GetCommonWebPorts 方法
-	if w.tryHTTPConnection(ctx, host, port, "https") {
-		return true
-	}
-
-	return false
-}
-
-// tryHTTPConnection 尝试HTTP连接
-func (w *WebPortDetector) tryHTTPConnection(ctx context.Context, host string, port int, protocol string) bool {
-	url := ""
-	if port == 80 && protocol == "http" {
-		url = "http://" + host
-	} else if port == 443 && protocol == "https" {
-		url = "https://" + host
-	} else {
-		url = protocol + "://" + host + ":" + string(rune(port))
-	}
-
-	// 创建HTTP客户端，快速检测
-	client := &http.Client{
-		Timeout: w.httpTimeout,
-		Transport: &http.Transport{
-			DialContext: (&net.Dialer{
-				Timeout: w.httpTimeout,
-			}).DialContext,
-			TLSHandshakeTimeout:   w.httpTimeout,
-			ResponseHeaderTimeout: w.httpTimeout,
-			DisableKeepAlives:     true,
-		},
-		CheckRedirect: func(req *http.Request, via []*http.Request) error {
-			return http.ErrUseLastResponse // 不跟随重定向，加快检测速度
-		},
-	}
-
-	// 发送HEAD请求，最小化网络开销
-	req, err := http.NewRequestWithContext(ctx, "HEAD", url, nil)
-	if err != nil {
-		return false
-	}
-
-	req.Header.Set("User-Agent", "fscan-web-detector/2.0")
-
-	resp, err := client.Do(req)
-	if err != nil {
-		// 检查错误类型，某些错误也表明是HTTP服务
-		errStr := strings.ToLower(err.Error())
-		if strings.Contains(errStr, "http") || 
-		   strings.Contains(errStr, "malformed http") ||
-		   strings.Contains(errStr, "server closed") {
-			return true
-		}
-		return false
-	}
-	defer resp.Body.Close()
-
-	// 任何HTTP响应都表明这是Web服务
-	return resp.StatusCode > 0
-}
-
-// GetCommonWebPorts 获取常见Web端口列表
-func (w *WebPortDetector) GetCommonWebPorts() []int {
-	ports := make([]int, 0, len(w.commonWebPorts))
-	for port := range w.commonWebPorts {
-		ports = append(ports, port)
-	}
-	return ports
-}

plugins/services/vnc/plugin.go

@@ -156,33 +156,7 @@ func (p *VNCPlugin) IsExploitSupported(method base.ExploitType) bool {
 	return p.exploiter.IsExploitSupported(method)
 }
 
-// performServiceIdentification 执行VNC服务识别（-nobr模式）
+// 已移除未使用的 performServiceIdentification 方法
-func (p *VNCPlugin) performServiceIdentification(ctx context.Context, info *common.HostInfo) (*base.ScanResult, error) {
-	// 尝试连接到VNC服务进行识别
-	conn, err := p.connector.Connect(ctx, info)
-	if err != nil {
-		return &base.ScanResult{
-			Success: false,
-			Service: "Unknown",
-			Banner:  "",
-			Error:   fmt.Errorf("服务不可访问"),
-		}, nil
-	}
-	
-	connectionInfo := conn.(map[string]interface{})
-	version := connectionInfo["version"].(string)
-	
-	return &base.ScanResult{
-		Success: true,
-		Service: "VNC",
-		Banner:  fmt.Sprintf("VNC服务 %s", version),
-		Extra: map[string]interface{}{
-			"version":    version,
-			"identified": true,
-			"protocol":   "VNC",
-		},
-	}, nil
-}
 
 // RegisterVNCPlugin 注册VNC插件
 func RegisterVNCPlugin() {