tessl/maven-org-apache-activemq--artemis-commons

Common utilities, API classes, and shared functionality for Apache ActiveMQ Artemis message broker

—

Pending

Overview

Eval results

Files

JSON Processing

Name: tessl/maven-org-apache-activemq--artemis-commons
Author: tessl

Apache ActiveMQ Artemis Commons provides a complete JSON API implementation through shaded Jakarta JSON and Apache Johnzon dependencies. The API provides full JSON processing capabilities including parsing, building, and manipulation of JSON objects and arrays.

Core JSON Interfaces

JsonValue

Base interface for all JSON values.

interface JsonValue {
    // JSON value types
    enum ValueType {
        ARRAY, OBJECT, STRING, NUMBER, TRUE, FALSE, NULL
    }
    
    // Constants for common values
    JsonValue TRUE = /* ... */;
    JsonValue FALSE = /* ... */;
    JsonValue NULL = /* ... */;
    
    // Core methods
    ValueType getValueType();
    String toString();
}

JsonObject

JSON object representation with Map-like interface.

interface JsonObject extends JsonValue, Map<String, JsonValue> {
    // Type-safe getters for nested JSON values
    JsonObject getJsonObject(String name);
    JsonArray getJsonArray(String name);
    JsonNumber getJsonNumber(String name);
    JsonString getJsonString(String name);
    
    // Native type getters
    String getString(String name);
    String getString(String name, String defaultValue);
    int getInt(String name);
    int getInt(String name, int defaultValue);
    boolean getBoolean(String name);
    boolean getBoolean(String name, boolean defaultValue);
    
    // Utility methods
    boolean isNull(String name);
    boolean containsKey(String name);
}

JsonArray

JSON array representation with List-like interface.

interface JsonArray extends JsonValue, List<JsonValue> {
    // Type-safe getters by index
    JsonObject getJsonObject(int index);
    JsonArray getJsonArray(int index);
    JsonNumber getJsonNumber(int index);
    JsonString getJsonString(int index);
    
    // Native type getters by index
    String getString(int index);
    String getString(int index, String defaultValue);
    int getInt(int index);
    int getInt(int index, int defaultValue);
    boolean getBoolean(int index);
    boolean getBoolean(int index, boolean defaultValue);
    
    // Utility methods
    boolean isNull(int index);
    <T> List<T> getValuesAs(Class<T> clazz);
    <T, K extends JsonValue> List<T> getValuesAs(Function<K, T> func);
}

JsonString and JsonNumber

interface JsonString extends JsonValue {
    String getString();
}

interface JsonNumber extends JsonValue {
    boolean isIntegral();
    int intValue();
    long longValue();
    BigInteger bigIntegerValue();
    double doubleValue();
    BigDecimal bigDecimalValue();
}

JSON Builders

JsonObjectBuilder

Builder for creating JSON objects.

interface JsonObjectBuilder {
    // Add methods for different value types
    JsonObjectBuilder add(String name, JsonValue value);
    JsonObjectBuilder add(String name, String value);
    JsonObjectBuilder add(String name, BigInteger value);
    JsonObjectBuilder add(String name, BigDecimal value);
    JsonObjectBuilder add(String name, int value);
    JsonObjectBuilder add(String name, long value);
    JsonObjectBuilder add(String name, double value);
    JsonObjectBuilder add(String name, boolean value);
    
    // Add nested builders
    JsonObjectBuilder add(String name, JsonObjectBuilder builder);
    JsonObjectBuilder add(String name, JsonArrayBuilder builder);
    
    // Null value and manipulation
    JsonObjectBuilder addNull(String name);
    JsonObjectBuilder addAll(JsonObjectBuilder builder);
    JsonObjectBuilder remove(String name);
    
    // Build final object
    JsonObject build();
}

JsonArrayBuilder

Builder for creating JSON arrays.

interface JsonArrayBuilder {
    // Add methods for different value types
    JsonArrayBuilder add(JsonValue value);
    JsonArrayBuilder add(String value);
    JsonArrayBuilder add(BigInteger value);
    JsonArrayBuilder add(BigDecimal value);
    JsonArrayBuilder add(int value);
    JsonArrayBuilder add(long value);
    JsonArrayBuilder add(double value);
    JsonArrayBuilder add(boolean value);
    
    // Add nested builders
    JsonArrayBuilder add(JsonObjectBuilder builder);
    JsonArrayBuilder add(JsonArrayBuilder builder);
    
    // Null value and manipulation
    JsonArrayBuilder addNull();
    JsonArrayBuilder addAll(JsonArrayBuilder builder);
    JsonArrayBuilder add(int index, JsonValue value);
    JsonArrayBuilder set(int index, JsonValue value);
    JsonArrayBuilder remove(int index);
    
    // Build final array
    JsonArray build();
}

JSON Factory and Utilities

JsonLoader

Factory class for creating JSON objects, arrays, and builders.

class JsonLoader {
    // Reading JSON from sources
    static JsonObject readObject(Reader reader);
    static JsonArray readArray(Reader reader);
    static JsonObject readObject(InputStream stream);
    static JsonArray readArray(InputStream stream);
    static JsonObject readObject(String jsonString);
    static JsonArray readArray(String jsonString);
    
    // Creating builders
    static JsonObjectBuilder createObjectBuilder();
    static JsonArrayBuilder createArrayBuilder();
    static JsonObjectBuilder createObjectBuilder(JsonObject object);
    static JsonArrayBuilder createArrayBuilder(JsonArray array);
}

Usage Examples

Creating JSON Objects

import org.apache.activemq.artemis.utils.JsonLoader;
import org.apache.activemq.artemis.json.*;

// Create JSON object using builder
JsonObject config = JsonLoader.createObjectBuilder()
    .add("name", "messageQueue")
    .add("durable", true)
    .add("maxConsumers", 10)
    .add("address", "orders.processing")
    .add("properties", JsonLoader.createObjectBuilder()
        .add("priority", 5)
        .add("timeout", 30000)
        .addNull("description"))
    .build();

// Convert to string
String jsonString = config.toString();

Creating JSON Arrays

// Create JSON array of queue configurations
JsonArray queues = JsonLoader.createArrayBuilder()
    .add(JsonLoader.createObjectBuilder()
        .add("name", "highPriority")
        .add("maxConsumers", 5)
        .add("ringSize", 1000))
    .add(JsonLoader.createObjectBuilder()
        .add("name", "lowPriority")
        .add("maxConsumers", 2)
        .add("ringSize", 500))
    .addNull()  // placeholder
    .add("simpleQueueName")
    .build();

// Process array elements
for (int i = 0; i < queues.size(); i++) {
    if (!queues.isNull(i)) {
        JsonValue value = queues.get(i);
        if (value.getValueType() == JsonValue.ValueType.OBJECT) {
            JsonObject queueConfig = queues.getJsonObject(i);
            String name = queueConfig.getString("name");
            int maxConsumers = queueConfig.getInt("maxConsumers", 1);
            // Process queue configuration
        }
    }
}

Reading JSON from Strings

// Parse JSON string
String jsonData = """
{
    "server": {
        "host": "localhost",
        "port": 61616,
        "ssl": false
    },
    "queues": [
        {"name": "orders", "durable": true},
        {"name": "notifications", "durable": false}
    ],
    "maxConnections": 100
}
""";

JsonObject serverConfig = JsonLoader.readObject(jsonData);

// Extract nested values
JsonObject server = serverConfig.getJsonObject("server");
String host = server.getString("host");
int port = server.getInt("port");
boolean ssl = server.getBoolean("ssl");

JsonArray queues = serverConfig.getJsonArray("queues");
int maxConnections = serverConfig.getInt("maxConnections");

// Process queues
for (JsonObject queue : queues.getValuesAs(JsonObject.class)) {
    String queueName = queue.getString("name");
    boolean durable = queue.getBoolean("durable");
    // Configure queue
}

Reading JSON from Streams

import java.io.*;

// Read from file
try (FileReader reader = new FileReader("config.json")) {
    JsonObject config = JsonLoader.readObject(reader);
    // Process configuration
}

// Read from input stream
try (InputStream stream = getClass().getResourceAsStream("/default-config.json")) {
    JsonObject defaultConfig = JsonLoader.readObject(stream);
    // Process default configuration
}

Modifying Existing JSON

// Start with existing JSON object
JsonObject original = JsonLoader.readObject(existingJsonString);

// Create modified version using builder
JsonObject modified = JsonLoader.createObjectBuilder(original)
    .add("lastModified", System.currentTimeMillis())
    .add("version", "2.0")
    .remove("deprecated")
    .build();

// Merge with additional properties
JsonObject extended = JsonLoader.createObjectBuilder(modified)
    .addAll(JsonLoader.createObjectBuilder()
        .add("newFeature", true)
        .add("migrationRequired", false))
    .build();

Type-Safe Value Extraction

JsonObject data = JsonLoader.readObject(jsonString);

// Safe extraction with defaults
String name = data.getString("name", "defaultQueue");
int priority = data.getInt("priority", 0);
boolean enabled = data.getBoolean("enabled", true);

// Check for null values
if (!data.isNull("description")) {
    String description = data.getString("description");
    // Use description
}

// Safe nested access
if (data.containsKey("metadata")) {
    JsonObject metadata = data.getJsonObject("metadata");
    if (metadata.containsKey("tags")) {
        JsonArray tags = metadata.getJsonArray("tags");
        List<String> tagList = tags.getValuesAs(JsonString.class)
            .stream()
            .map(JsonString::getString)
            .collect(Collectors.toList());
    }
}

Complex JSON Construction

// Build complex nested JSON structure
JsonObject complexConfig = JsonLoader.createObjectBuilder()
    .add("version", "1.0")
    .add("timestamp", System.currentTimeMillis())
    .add("server", JsonLoader.createObjectBuilder()
        .add("host", "broker.example.com")
        .add("ports", JsonLoader.createArrayBuilder()
            .add(61616)
            .add(61617)
            .add(5445))
        .add("security", JsonLoader.createObjectBuilder()
            .add("enabled", true)
            .add("protocols", JsonLoader.createArrayBuilder()
                .add("TLS")
                .add("SASL"))))
    .add("queues", JsonLoader.createArrayBuilder()
        .add(JsonLoader.createObjectBuilder()
            .add("name", "orders")
            .add("address", "orders.processing")
            .add("durable", true)
            .add("consumers", JsonLoader.createObjectBuilder()
                .add("max", 10)
                .add("exclusive", false)))
        .add(JsonLoader.createObjectBuilder()
            .add("name", "notifications")
            .add("address", "notifications.email")
            .add("durable", false)
            .add("consumers", JsonLoader.createObjectBuilder()
                .add("max", 1)
                .add("exclusive", true))))
    .build();

// Serialize to formatted JSON
String prettyJson = complexConfig.toString();

Integration with ActiveMQ Configuration

QueueConfiguration JSON Integration

import org.apache.activemq.artemis.api.core.QueueConfiguration;

// QueueConfiguration can be serialized to/from JSON
QueueConfiguration queue = QueueConfiguration.of("myQueue")
    .setDurable(true)
    .setMaxConsumers(5);

// Convert to JSON using built-in method
String queueJson = queue.toJSON();

// Parse back from JSON
QueueConfiguration restored = QueueConfiguration.fromJSON(queueJson);

// The JSON uses the same structure as the JSON API
JsonObject queueJsonObj = JsonLoader.readObject(queueJson);
String queueName = queueJsonObj.getString("name");
boolean durable = queueJsonObj.getBoolean("durable");

Configuration File Processing

// Process configuration files with multiple queue definitions
JsonObject config = JsonLoader.readObject(configFileReader);
JsonArray queues = config.getJsonArray("queues");

List<QueueConfiguration> queueConfigs = new ArrayList<>();
for (JsonObject queueJson : queues.getValuesAs(JsonObject.class)) {
    // Convert JSON to QueueConfiguration
    QueueConfiguration queueConfig = QueueConfiguration.fromJSON(queueJson.toString());
    queueConfigs.add(queueConfig);
}

// Use configurations
for (QueueConfiguration config : queueConfigs) {
    createQueue(config);
}

Error Handling

JSON Processing Exceptions

try {
    JsonObject obj = JsonLoader.readObject(malformedJson);
} catch (JsonException e) {
    // Handle malformed JSON
    logger.error("Invalid JSON format", e);
} catch (ClassCastException e) {
    // Handle type mismatches
    logger.error("JSON type mismatch", e);
}

// Safe value extraction
JsonObject data = JsonLoader.readObject(jsonString);
try {
    int value = data.getInt("numericField");
} catch (ClassCastException e) {
    // Field is not numeric, use default
    int value = 0;
} catch (NullPointerException e) {
    // Field doesn't exist, use default
    int value = 0;
}

Performance Considerations

Reusing Builders

// Reuse builders for better performance
JsonObjectBuilder reusableBuilder = JsonLoader.createObjectBuilder();

for (DataItem item : items) {
    JsonObject itemJson = reusableBuilder
        .add("id", item.getId())
        .add("name", item.getName())
        .add("timestamp", item.getTimestamp())
        .build();
    
    processItem(itemJson);
    
    // Builder is reset after build(), ready for reuse
}

Streaming for Large Data

// For large JSON data, consider streaming approaches
try (JsonParser parser = Json.createParser(largeJsonStream)) {
    while (parser.hasNext()) {
        JsonParser.Event event = parser.next();
        switch (event) {
            case START_OBJECT:
                // Process object start
                break;
            case KEY_NAME:
                String key = parser.getString();
                break;
            case VALUE_STRING:
                String value = parser.getString();
                break;
            // Handle other events
        }
    }
}

Install with Tessl CLI

npx tessl i tessl/maven-org-apache-activemq--artemis-commons

docs