Analyzing the GrowingIO SDK: Design Patterns, Async Processing, and High‑Performance Implementation

Downloading and Building the SDK

Clone the source repository from https://github.com/growingio/growingio-java-sdk.

Import the project into IntelliJ IDEA and build with Maven.

Run a simple test class; the console prints a log entry and the serialized event message array.

Event Message Construction

The GIOEventMessage class is a builder‑style data holder for a tracking event. Required fields are eventKey (business identifier) and loginUserId (user ID). Optional fields include eventTime (defaults to System.currentTimeMillis()) and arbitrary event variables.

// Build an event message
GIOEventMessage eventMessage = new GIOEventMessage.Builder()
    .eventTime(System.currentTimeMillis())            // optional, defaults to system time
    .eventKey("BuyProduct")                           // required event identifier
    .loginUserId("417abcabcabcbac")                   // required user ID
    .addEventVariable("product_name", "苹果")          // optional variable
    .addEventVariable("product_classify", "水果")      // optional variable
    .addEventVariable("product_price", 14)            // optional variable
    .build();

// Send the event to the server
GrowingAPI.send(eventMessage);

Core Classes and Workflow

GIOEventMessage

Uses compact HTTP parameter names for the request payload.

Maintains two Map<String, Object> structures: one for basic event parameters, another for variable‑level parameters.

Provides addEventVariable methods to insert or update variable data.

GrowingAPI

Validates server configuration (URL, project ID, queue size, timeout, etc.) and exposes the static send method. The method forwards the GIOEventMessage to the storage strategy via StoreStrategyClient.

StoreStrategyClient

Singleton entry point that returns the configured storage strategy. The default implementation is DefaultStoreStrategy.

DefaultStoreStrategy

Implements a producer‑consumer model:

A fixed thread pool processes messages.

Messages are placed in a BlockingQueue whose size, send interval, and batch size are configurable.

A scheduled task runs every sendInterval (default 100 ms), extracts messages from the queue, groups them by project ID, and triggers batch transmission.

static {
    sendMsgSchedule.scheduleWithFixedDelay(new Runnable() {
        @Override
        public void run() {
            while (!queue.isEmpty()) {
                if (currentBatchMsgSize() < sendMsgBatchSize) {
                    GIOMessage gioMessage = queue.poll();
                    if (gioMessage != null) {
                        String projectId = gioMessage.getProjectId();
                        if (batchMsgMap.containsKey(projectId)) {
                            List<GIOMessage> list = batchMsgMap.get(projectId);
                            list.add(gioMessage);
                        } else {
                            List<GIOMessage> list = new ArrayList<GIOMessage>();
                            list.add(gioMessage);
                            batchMsgMap.put(projectId, list);
                        }
                    }
                } else {
                    break;
                }
            }
            for (Map.Entry<String, List<GIOMessage>> entry : batchMsgMap.entrySet()) {
                if (entry.getValue() != null && !entry.getValue().isEmpty()) {
                    sender.sendMsg(entry.getKey(), entry.getValue());
                }
            }
            batchMsgMap.clear();
        }
    }, sendInterval, sendInterval, TimeUnit.MILLISECONDS);
}

Message Sender

The sender runs in an asynchronous thread pool and performs HTTP POST requests. It includes retry logic for network I/O errors, ensuring reliable delivery.

Design Patterns and Technical Highlights

Builder pattern – constructing GIOEventMessage.

Strategy pattern – interchangeable storage strategies via StoreStrategyClient.

Template method & Singleton – managing the default strategy instance.

Producer‑Consumer model – decoupling event production from asynchronous batch consumption.

Fixed thread pool and scheduled thread pool – handling high‑throughput, low‑latency reporting.

Reference Documentation

Official SDK usage guide: https://docs.growingio.com/v3/developer-manual/sdkintegrated/server-sdk/java-sdk