基于Go編寫一個Windows剪貼板監(jiān)控器

更新時(shí)間：2025年11月18日 09:40:37 作者：Mgx

這篇文章主要為大家詳細(xì)介紹了如何基于Go編寫一個Windows剪貼板監(jiān)控器,可以在后臺默默監(jiān)聽你的復(fù)制行為,感興趣的小伙伴可以跟隨小編一起學(xué)習(xí)一下

為什么要做這個

學(xué)習(xí)目的：理解 Windows 消息機(jī)制、剪貼板架構(gòu)、Unicode/ANSI 編碼處理。
實(shí)用場景：自動化工具、開發(fā)調(diào)試、剪貼板歷史記錄等。
裝 X 需求：在同事面前演示："看，我一復(fù)制，程序就知道我抄了啥！"

技術(shù)原理：Windows 剪貼板監(jiān)聽機(jī)制

Windows 提供了一套經(jīng)典的"剪貼板查看器鏈"（Clipboard Viewer Chain）機(jī)制：

你可以把自己的窗口注冊為"剪貼板查看器"。
一旦剪貼板內(nèi)容發(fā)生變化，系統(tǒng)會向鏈中的每個窗口發(fā)送 WM_DRAWCLIPBOARD 消息。
你收到消息后，就可以打開剪貼板、讀取內(nèi)容、然后優(yōu)雅地關(guān)掉它。

聽起來是不是有點(diǎn)像"訂閱-發(fā)布"模式？沒錯！只不過這是 1980 年代的 Windows 版 Pub/Sub。

注意事項(xiàng)

微軟官方已不推薦使用 SetClipboardViewer（推薦用 AddClipboardFormatListener），但為了兼容性和教學(xué)目的，我們?nèi)杂媒?jīng)典方式。

核心挑戰(zhàn)：剪貼板數(shù)據(jù)格式

剪貼板可不是只存文本！它支持多種格式：

格式常量	含義
CF_TEXT	ANSI 文本（通常是 GBK 編碼）
CF_UNICODETEXT	UTF-16 文本（現(xiàn)代應(yīng)用主流）
CF_HDROP	文件拖放（比如從資源管理器復(fù)制文件）
其他自定義格式	比如 Word 的富文本、圖片等

所以我們的程序必須：

枚舉所有格式
優(yōu)先讀取 CF_UNICODETEXT
降級處理 CF_TEXT（并轉(zhuǎn)碼為 UTF-8）
識別文件拖放
對未知格式友好提示

代碼實(shí)現(xiàn)：Go + Windows API

我們使用 golang.org/x/sys/windows 調(diào)用 Windows API，并配合 unsafe 和 reflect 直接操作內(nèi)存（別怕，有安全兜底）。

下面就是完整源碼（已加詳細(xì)注釋）：

package main

import (
	"bytes"
	"fmt"
	"io"
	"reflect"
	"syscall"
	"unicode/utf16"
	"unsafe"

	"golang.org/x/sys/windows"
	"golang.org/x/text/encoding/simplifiedchinese"
	"golang.org/x/text/transform"
)

// ===== Win32 API Constants =====
const (
	WM_CREATE        = 0x0001
	WM_DESTROY       = 0x0002
	WM_DRAWCLIPBOARD = 0x0308
	WM_CHANGECBCHAIN = 0x030D
	CF_TEXT          = 1
	CF_BITMAP        = 2
	CF_UNICODETEXT   = 13
	CF_HDROP         = 15
)

// ===== Win32 Structures =====
type WNDCLASSEX struct {
	Size       uint32
	Style      uint32
	WndProc    uintptr
	ClsExtra   int32
	WndExtra   int32
	Instance   syscall.Handle
	Icon       syscall.Handle
	Cursor     syscall.Handle
	Background uintptr
	MenuName   *uint16
	ClassName  *uint16
	IconSm     syscall.Handle
}

type MSG struct {
	HWnd    uintptr
	Message uint32
	WParam  uintptr
	LParam  uintptr
	DwTime  uint32
	PtX     int32
	PtY     int32
}

// ===== Win32 API Procs =====
var (
	user32   = windows.NewLazySystemDLL("user32.dll")
	kernel32 = windows.NewLazySystemDLL("kernel32.dll")
	shell32  = windows.NewLazySystemDLL("shell32.dll")

	procRegisterClassEx      = user32.NewProc("RegisterClassExW")
	procCreateWindowEx       = user32.NewProc("CreateWindowExW")
	procDefWindowProc        = user32.NewProc("DefWindowProcW")
	procOpenClipboard        = user32.NewProc("OpenClipboard")
	procCloseClipboard       = user32.NewProc("CloseClipboard")
	procEnumClipboardFormats = user32.NewProc("EnumClipboardFormats")
	procGetClipboardData     = user32.NewProc("GetClipboardData")
	procSetClipboardViewer   = user32.NewProc("SetClipboardViewer")
	procGetMessage           = user32.NewProc("GetMessageW")
	procTranslateMessage     = user32.NewProc("TranslateMessage")
	procDispatchMessage      = user32.NewProc("DispatchMessageW")
	procShowWindow           = user32.NewProc("ShowWindow")
	procGlobalLock           = kernel32.NewProc("GlobalLock")
	procGlobalUnlock         = kernel32.NewProc("GlobalUnlock")
	procDragQueryFile        = shell32.NewProc("DragQueryFileW")
)

// ===== 窗口過程函數(shù) =====
func windowProc(hwnd syscall.Handle, msg uint32, wParam uintptr, lParam uintptr) uintptr {
	switch msg {
	case WM_CREATE:
		_, _, _ = procSetClipboardViewer.Call(uintptr(hwnd))

	case WM_DRAWCLIPBOARD:
		if ret, _, _ := procOpenClipboard.Call(uintptr(hwnd)); ret == 0 {
			fmt.Println("? 無法打開剪切板")
			break
		}
		var format uint32 = 0
		var finalText string

		for {
			r1, _, _ := procEnumClipboardFormats.Call(uintptr(format))
			format = uint32(r1)
			if format == 0 {
				break
			}

			hMem, _, _ := procGetClipboardData.Call(uintptr(format))
			if hMem == 0 {
				continue
			}

			switch format {
			case CF_UNICODETEXT:
				text, err := getUnicodeText(hMem)
				if err == nil {
					finalText = text
					goto done
				}
			case CF_TEXT:
				text, err := getAnsiText(hMem)
				if err == nil && finalText == "" {
					finalText = text
				}
			case CF_HDROP:
				finalText = ""
				files, err := getHDropFiles(hMem)
				if err != nil {
					fmt.Println("? 文件列表: 讀取文件失敗:", err)
				} else {
					fmt.Printf("?? 拖放的文件 (%d):\n", len(files))
					for _, f := range files {
						fmt.Println(" -", f)
					}
				}
			default:
				finalText = ""
				fmt.Printf("?? %s\n", getClipboardFormatName(format))
			}
		}
	done:
		if finalText != "" {
			fmt.Printf("?? 文本內(nèi)容:\n%s\n", finalText)
		}
		procCloseClipboard.Call()

	case WM_CHANGECBCHAIN:
		fmt.Println("?? 剪切板查看器鏈已更改")

	default:
		ret, _, _ := procDefWindowProc.Call(uintptr(hwnd), uintptr(msg), wParam, lParam)
		return ret
	}
	return 0
}

// ===== 輔助函數(shù) =====
func getAnsiText(hMem uintptr) (string, error) {
	lpLock, _, _ := procGlobalLock.Call(hMem)
	if lpLock == 0 {
		return "", fmt.Errorf("無法鎖定內(nèi)存")
	}
	defer procGlobalUnlock.Call(hMem)

	var size int
	for {
		b := *(*byte)(unsafe.Pointer(lpLock + uintptr(size)))
		if b == 0 {
			break
		}
		size++
	}

	data := make([]byte, size)
	for i := 0; i < size; i++ {
		data[i] = *(*byte)(unsafe.Pointer(lpLock + uintptr(i)))
	}

	decoder := simplifiedchinese.GBK.NewDecoder()
	reader := transform.NewReader(bytes.NewReader(data), decoder)
	utf8Bytes, err := io.ReadAll(reader)
	if err != nil {
		return "", err
	}
	return string(utf8Bytes), nil
}

func getUnicodeText(hMem uintptr) (string, error) {
	lpLock, _, _ := procGlobalLock.Call(hMem)
	if lpLock == 0 {
		return "", fmt.Errorf("無法鎖定內(nèi)存")
	}
	defer procGlobalUnlock.Call(hMem)

	var length int
	for {
		w := *(*uint16)(unsafe.Pointer(lpLock + uintptr(length*2)))
		if w == 0 {
			break
		}
		length++
	}

	sliceHeader := reflect.SliceHeader{
		Data: lpLock,
		Len:  length,
		Cap:  length,
	}
	utf16Data := *(*[]uint16)(unsafe.Pointer(&sliceHeader))

	runes := utf16.Decode(utf16Data)
	return string(runes), nil
}

func getHDropFiles(hMem uintptr) ([]string, error) {
	lpLock, _, _ := procGlobalLock.Call(hMem)
	if lpLock == 0 {
		return nil, fmt.Errorf("無法鎖定HDROP內(nèi)存")
	}
	defer procGlobalUnlock.Call(hMem)

	count, _, _ := procDragQueryFile.Call(lpLock, 0xFFFFFFFF, 0, 0)
	if count == 0 {
		return nil, fmt.Errorf("HDROP中未找到文件")
	}

	files := make([]string, count)
	for i := uintptr(0); i < count; i++ {
		var buf [260]uint16
		_, _, _ = procDragQueryFile.Call(lpLock, i, uintptr(unsafe.Pointer(&buf[0])), uintptr(len(buf)))
		files[i] = syscall.UTF16ToString(buf[:])
	}
	return files, nil
}

func getClipboardFormatName(format uint32) string {
	if format <= 0xC000 {
		switch format {
		case CF_TEXT:
			return "CF_TEXT (ANSI文本)"
		case CF_UNICODETEXT:
			return "CF_UNICODETEXT"
		case CF_BITMAP:
			return "CF_BITMAP (位圖)"
		case CF_HDROP:
			return "CF_HDROP (文件列表)"
		default:
			return "標(biāo)準(zhǔn)格式"
		}
	}
	buf := make([]uint16, 256)
	r1, _, _ := user32.NewProc("GetClipboardFormatNameW").Call(
		uintptr(format),
		uintptr(unsafe.Pointer(&buf[0])),
		uintptr(len(buf)),
	)
	if r1 == 0 {
		return fmt.Sprintf("未知自定義格式 (%d)", format)
	}
	return "自定義格式: " + syscall.UTF16ToString(buf)
}

func init() {
	if err := shell32.Load(); err != nil {
		panic("無法加載shell32.dll: " + err.Error())
	}
}

func main() {
	className := syscall.StringToUTF16Ptr("ClipboardMonitorClass")

	var wc WNDCLASSEX
	wc.Size = uint32(unsafe.Sizeof(wc))
	wc.WndProc = syscall.NewCallback(windowProc)
	wc.Instance = 0
	wc.ClassName = className
	wc.Style = 0x0002 // CS_HREDRAW

	ret, _, err := procRegisterClassEx.Call(uintptr(unsafe.Pointer(&wc)))
	if ret == 0 {
		panic("注冊窗口類失敗: " + err.Error())
	}

	hwnd, _, err := procCreateWindowEx.Call(
		0,
		uintptr(unsafe.Pointer(className)),
		uintptr(unsafe.Pointer(syscall.StringToUTF16Ptr("剪切板監(jiān)視器"))),
		0,
		0, 0, 100, 100,
		0, 0, 0, 0,
	)
	if hwnd == 0 {
		panic("創(chuàng)建窗口失敗: " + err.Error())
	}

	procShowWindow.Call(hwnd, 0) // 隱藏窗口

	fmt.Println("?? 剪貼板監(jiān)視器已啟動。現(xiàn)在可以復(fù)制內(nèi)容進(jìn)行測試！")

	var msg MSG
	for {
		ret, _, _ := procGetMessage.Call(uintptr(unsafe.Pointer(&msg)), 0, 0, 0)
		if ret <= 0 {
			break
		}
		procTranslateMessage.Call(uintptr(unsafe.Pointer(&msg)))
		procDispatchMessage.Call(uintptr(unsafe.Pointer(&msg)))
	}
}

如何運(yùn)行

安裝依賴

go mod init clipboard-monitor
go get golang.org/x/sys/windows
go get golang.org/x/text/encoding/simplifiedchinese

運(yùn)行程序

保存為 main.go，然后：

go run main.go

測試效果

復(fù)制一段文字、一張圖片、或幾個文件試試！你會看到類似這樣的輸出：

?? 剪貼板監(jiān)視器已啟動。現(xiàn)在可以復(fù)制內(nèi)容進(jìn)行測試！
?? 文本內(nèi)容:
Hello, 剪貼板！
?? 拖放的文件 (2):
- C:\Users\Alice\Pictures\cat.jpg
- C:\Users\Alice\Documents\report.pdf
?? CF_BITMAP (位圖)