Exploring wxjava: A Deep Dive into the Open‑Source WeChat SDK Design Process

The article shares the source‑code design of the open‑source wxjava project—a Java SDK for WeChat services such as payment, public accounts, mini‑programs, and enterprise WeChat—to help readers improve their own SDK design skills.

Starter Pattern Recap

Building on the previous lesson, the author highlights the lightweight Spring Boot starter used in wxjava, noting its minimal class count and consistent structure, which serves as a reusable template for creating custom SDKs.

Core Workflow Overview

The SDK abstracts a Config object that can be stored in memory or Redis. A Properties class supplies application ID and secret information. The central service class ( WxMpService) provides two main responsibilities: exposing API methods to external callers and offering core utilities such as HTTP request execution and response parsing.

Entry Point: User‑Tag Service Test

The author traces the flow using the unit‑test class WxMpUserTagServiceImplTest, which exercises the user‑tag creation API. The test reveals how the service is instantiated via the starter and how the WxMpService object orchestrates the request.

Tag Creation Method

The method defines request parameters, parses the response into a Java object, and hides the underlying HTTP details from the caller. Each sub‑module (e.g., public‑account, mini‑program) defines its own request and result models, while simple APIs may use a shared model.

POST Method Overloads

Three overloaded post methods illustrate the request pipeline:

Construct the URL from the current Config and pass the request payload.

Create an HTTP request executor (strategy pattern) to handle the actual network call.

Execute the request with built‑in retry logic and error handling.

The three automatic steps are:

Extract configuration and build the URL.

Define the HTTP request handler.

Retry on request errors.

Configuration Retrieval

Configuration objects are stored in a Map and accessed via a Holder that selects the appropriate environment configuration at runtime.

URL Maintenance

API endpoints are maintained using an enum that maps each operation to its URL, simplifying updates and extensions.

Request Executor Implementation

The executor follows a classic strategy and template pattern. The SimplePostRequestExecutor and its OkHttpSimplePostRequestExecutor subclass demonstrate how different HTTP libraries can be swapped without changing higher‑level code.

executeInternal – Token Handling

The core executeInternal method obtains an access token, appends it to the URL, invokes the executor, and returns a generic result type T. It also handles token expiration by checking the in‑memory cache, acquiring a lock, and requesting a new token when needed.

Custom @Required Annotation

To enforce mandatory fields, wxjava defines a @Required annotation. A reflective utility method checkRequiredFields scans bean fields, collects missing required fields, and throws a WxErrorException if any are absent.

Abstract Request Model

The SDK provides an abstract base class BaseWxPayRequest that implements common fields (e.g., appid, mch_id, nonce_str, sign) and a template method checkFields. Subclasses implement checkConstraints for additional validation and storeMap to assemble parameters for signing and XML generation.

Message Duplicate Checker

Two implementations illustrate different strategies: WxMessageInMemoryDuplicateCheckerSingleton uses a ConcurrentHashMap with a scheduled task to purge entries after 15 seconds. WxMessageInRedisDuplicateChecker leverages Redisson to store a temporary key with a configurable expiration.

Design Patterns Observed

The author points out several classic patterns applied in wxjava:

Singleton (in‑memory duplicate checker).

Template Method + Strategy (request executor hierarchy).

Dependency Inversion (executors depend on abstract RequestHttp rather than concrete implementations).

Open/Closed Principle (new API features can be added by extending classes without modifying existing code).

Conclusion

By following the demonstrated steps—starting with a starter component, defining configuration, abstracting request/response models, handling tokens, applying custom annotations, and employing proven design patterns—developers can design robust, extensible SDKs for Open API integrations.