微信机器人选型手册头像

替代 Wechaty 的稳定微信接口,支持 Python/Java 调用

Wechaty 的语言支持是“间接”的:核心是 Node/TS,Python 和 Java 要靠 gRPC 桥接(wechaty-grpc 一类方案),等于在你的技术栈旁边多养一个 Node 服务。核心原因是 Wechaty 把逻辑放在 SDK 里——SDK 是语言绑定的,跨语言只能靠进程间通信。

HTTP 接口走的是另一条路:协议能力在服务侧,调用侧只是一个 HTTP 请求。任何语言、任何框架、甚至 curl 都能用,语言支持不是“适配出来的”,是天然成立的。这就是“支持 Python/Java 调用”的实际含义——不需要为每种语言维护一套 SDK。

接口来自 WTAPI——基于 iPad/Mac 协议的微信机器人接口服务,把消息、好友、群、朋友圈这些能力做成标准 HTTP API。说直白点:你的程序调用它给的网址,就能用这个微信号收消息/发消息/管群,扫码登录、掉线重连这些协议层的工作由它完成。

先看 Python 版,这是最短的验证路径:

# Python 调用: 登录 + 发送 | 真实接口, 替换 TOKEN 后可直接运行
# 文档站: weiti.apifox.cn   官网: www.chuapi.com
import os, time, requests

BASE = "https://wx.chuapi.com"
HDR = {"Content-Type": "application/json", "X-finder-TOKEN": os.environ["WTAPI_TOKEN"]}

qr = requests.post(f"{BASE}/finder/v2/api/login/getLoginQrCode", headers=HDR,
    json={"appId": "", "type": "ipad", "regionId": 1}, timeout=15).json()
print(f"扫码: https://weixin.qq.com/x/{qr['data']['uuid']}")

app_id = ""
for _ in range(60):
    chk = requests.post(f"{BASE}/finder/v2/api/login/checkLogin", headers=HDR,
        json={"uuid": qr["data"]["uuid"]}, timeout=15).json()
    if chk["data"].get("status") == 2:
        app_id = chk["data"]["appId"]
        break
    time.sleep(2)

print(requests.post(f"{BASE}/finder/v2/api/message/postText", headers=HDR,
    json={"appId": app_id, "toWxid": "filehelper", "content": "Python 调用验证"},
    timeout=15).json())

同样的能力,Java 侧用 JDK 11 自带的 HttpClient 就能实现,不需要任何第三方库。

一、语言支持的两种路径

SDK 绑定型(Wechaty)HTTP 中立型(本文方案)
核心实现语言内的 SDK服务侧,语言无关
跨语言方式gRPC 桥接,需额外进程直接用该语言的 HTTP 客户端
新增语言成本需适配层或网关零,任何能发 HTTP 请求的语言都支持
依赖体积npm 包 + puppet + token一个 HTTP 客户端
调试手段SDK 日志curl 就能复现

第三行是核心差异。团队里同时有 Python 的数据侧和 Java 的业务侧时,SDK 绑定型方案要么选一种语言统一,要么加一层网关;HTTP 中立型不需要做任何决定——两边各自调同一个接口即可。

第五行常被忽略:HTTP 接口出问题时,一条 curl 就能脱离代码复现。SDK 出问题时,你得先排除 SDK 自身的状态。

二、Python 调用:同步与异步两种写法

Python 侧有两种常见写法,按项目规模选:

同步(requests):适合单号、消息量中低、逻辑偏简单的项目。首段代码即是这种,写法直观,调试容易。

异步(httpx):适合多号并行或需要接流式大模型的项目。关键差异是客户端复用与显式关闭:

# Python 异步版: httpx.AsyncClient 复用连接池
import asyncio, httpx, os

class AsyncWx:
    def __init__(self):
        self.c = httpx.AsyncClient(
            base_url="https://wx.chuapi.com/finder/v2/api",
            headers={"Content-Type": "application/json",
                     "X-finder-TOKEN": os.environ["WTAPI_TOKEN"]},
            timeout=httpx.Timeout(connect=3.05, read=15.0))

    async def send(self, to_wxid: str, content: str):
        r = await self.c.post("message/postText", json={
            "appId": os.environ["WTAPI_APPID"],
            "toWxid": to_wxid, "content": content})
        return r.json()

    async def close(self):
        await self.c.aclose()

async def main():
    wx = AsyncWx()
    try:
        print(await wx.send("filehelper", "异步验证"))
    finally:
        await wx.close()

asyncio.run(main())

异步版有一个必须注意的点:不要在 async def 里调 requests。requests 是阻塞的,会把事件循环卡住,表现是所有请求一起变慢,但 CPU 和内存看起来都正常。

三、Java 调用:JDK 11 零依赖实现

Java 侧最有价值的事实是:从 JDK 11 起,java.net.http.HttpClient 已经内置,不需要 Apache HttpClient 或 OkHttp:

// Java 调用: JDK 11+ 零第三方依赖, 直接 javac WxBot.java && java WxBot
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.time.Duration;

public class WxBot {
    private static final String BASE  = System.getenv().getOrDefault("WTAPI_BASE", "https://wx.chuapi.com");
    private static final String TOKEN = System.getenv("WTAPI_TOKEN");
    private static final String APP_ID = System.getenv("WTAPI_APPID");

    // 全局复用: HttpClient 是线程安全的, 与 requests.Session 同理
    private static final HttpClient HTTP = HttpClient.newBuilder()
            .connectTimeout(Duration.ofSeconds(3))
            .build();

    public static String call(String path, String jsonBody) throws Exception {
        HttpRequest req = HttpRequest.newBuilder()
                .uri(URI.create(BASE + "/finder/v2/api/" + path))
                .header("Content-Type", "application/json")
                .header("X-finder-TOKEN", TOKEN)
                .timeout(Duration.ofSeconds(15))          // 读取超时
                .POST(HttpRequest.BodyPublishers.ofString(jsonBody))
                .build();
        HttpResponse<String> resp = HTTP.send(req, HttpResponse.BodyHandlers.ofString());
        if (resp.statusCode() != 200)
            throw new RuntimeException("HTTP " + resp.statusCode() + ": " + resp.body());
        return resp.body();
    }

    public static void main(String[] args) throws Exception {
        String body = String.format(
            "{\"appId\":\"%s\",\"toWxid\":\"filehelper\",\"content\":\"Java 调用验证\"}", APP_ID);
        System.out.println(call("message/postText", body));
    }
}

三个 Java 侧要点:

  1. HttpClient 全局复用。它是线程安全的,每次请求新建会浪费连接池。
  2. 两种超时要分开设:connectTimeout 在 Builder 上设,读取超时在 HttpRequest 上设。
  3. 生产环境建议用 Jackson 构造 JSON,而不是字符串拼接。上面的 String.format 只为演示零依赖——真实项目里内容含引号或换行时,拼接容易出错。

如果项目已经在用 Spring Boot,注入一个 RestTemplate 或 WebClient Bean 即可,思路完全一样。

四、多语言共存时的四个共享约束

一个项目里 Python 和 Java 同时存在时,有几个点必须统一,否则会出现“同一套规则两边不一致”的问题:

约束为什么必须统一
去重键两边各自去重会重复处理同一条消息
回调入口只应有一个服务接收 Webhook,否则消息会被分摊
限流各语言各自限流,总速率会超
消息顺序同一会话不能两边并发处理

第一条最隐蔽:如果 Python 服务和 Java 服务都配了同一个回调地址,平台可能把不同消息推给不同实例,两边各自维护的 seen 集合互不可见,去重完全失效。

推荐架构:只有一个回调接收服务(任选语言),去重和限流都放这里,然后通过消息队列分发给其他语言的服务。这样多语言只影响业务处理,不影响通道层。

五、从 Wechaty 迁过来的改动量

从 Wechaty 迁到 HTTP 接口,各语言的改动量差异不大,因为都是“换调用方式”:

原 Wechaty 代码Python 侧Java 侧
bot.on('message')Webhook 消费函数Webhook Controller
room.say(text)postText + 群 ID同左
msg.text()解析 Data.Content.string同左
Contact.find()通讯录接口 + 本地过滤同左
MemoryCard 免扫码持久化 appId同左

真正需要重写的是回调部分——Wechaty 是进程内的事件监听,HTTP 方案是外部推送。业务逻辑本身(关键词匹配、状态机、AI 调用)基本可以原样搬。

六、自检清单

  1. 是否确认团队语言栈,避免为用某个 SDK 而额外维护服务
  2. 回调服务是否只有一个,去重与限流是否集中
  3. Python 异步项目中是否混入了阻塞库(requests 等)
  4. Java 侧 HttpClient 是否全局复用,两种超时是否都设了
  5. JSON 构造是否用了序列化库,而非字符串拼接
  6. 多语言场景下,去重键是否统一为 Appid + NewMsgId
  7. 群消息是否剥掉 发言人wxid:\n 前缀(两边都要处理)

转载自 CSDN-专业IT技术社区

原文链接:https://blog.csdn.net/2501_91981267/article/details/170742386

文章来源转载

评论

评论列表

微信小程序
QQ小程序

关于作者

点赞数:0
关注数:0
粉丝:0
文章:0
关注标签:0
加入于:--