Java SDK

The Connix Java SDK provides a robust, enterprise-ready interface for integrating Connix services into your Java applications.

Requirements

• Java 8 or later
• Maven 3.6+ or Gradle 6+

Installation

Maven

Add the following dependency to your pom.xml:

<dependency>
    <groupId>io.connix</groupId>
    <artifactId>connix-sdk</artifactId>
    <version>1.0.0</version>
</dependency>

Gradle

Add the following to your build.gradle:

implementation 'io.connix:connix-sdk:1.0.0'

Gradle (Kotlin DSL)

implementation("io.connix:connix-sdk:1.0.0")

Quick Start

import io.connix.sdk.ConnixClient;
import io.connix.sdk.model.Result;

public class ConnixExample {
    public static void main(String[] args) {
        // Initialize the client
        ConnixClient client = new ConnixClient("your-api-key");

        try {
            // Make a request
            Result result = client.someMethod("parameter");
            System.out.println("Result: " + result.getData());
        } catch (ConnixException e) {
            System.err.println("Error: " + e.getMessage());
        }
    }
}

Configuration

Configure the SDK with various options using the builder pattern:

import io.connix.sdk.ConnixClient;
import io.connix.sdk.ConnixClientConfig;
import java.time.Duration;

ConnixClientConfig config = ConnixClientConfig.builder()
    .timeout(Duration.ofSeconds(30))
    .maxRetries(3)
    .baseUrl("https://api.connix.io")
    .header("Custom-Header", "value")
    .build();

ConnixClient client = new ConnixClient("your-api-key", config);

Async Operations

The SDK supports both synchronous and asynchronous operations:

import java.util.concurrent.CompletableFuture;

// Synchronous
Result result = client.someMethod("parameter");

// Asynchronous
CompletableFuture<Result> future = client.someMethodAsync("parameter");
future.thenAccept(result -> {
    System.out.println("Async result: " + result.getData());
}).exceptionally(throwable -> {
    System.err.println("Error: " + throwable.getMessage());
    return null;
});

Error Handling

The SDK provides structured exception handling:

import io.connix.sdk.exception.ConnixException;
import io.connix.sdk.exception.ValidationException;
import io.connix.sdk.exception.NetworkException;

try {
    Result result = client.someMethod("parameter");
} catch (ValidationException e) {
    System.err.println("Validation error: " + e.getMessage());
    System.err.println("Details: " + e.getValidationErrors());
} catch (NetworkException e) {
    System.err.println("Network error: " + e.getMessage());
} catch (ConnixException e) {
    System.err.println("Connix error: " + e.getMessage() +
                      " (code: " + e.getErrorCode() + ")");
} catch (Exception e) {
    System.err.println("Unexpected error: " + e.getMessage());
}

Spring Boot Integration

The SDK includes Spring Boot auto-configuration:

Add Starter Dependency

<dependency>
    <groupId>io.connix</groupId>
    <artifactId>connix-spring-boot-starter</artifactId>
    <version>1.0.0</version>
</dependency>

Configuration Properties

connix:
  api-key: your-api-key
  timeout: 30s
  max-retries: 3
  base-url: https://api.connix.io

Inject and Use

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class MyService {

    @Autowired
    private ConnixClient connixClient;

    public void processData() {
        try {
            Result result = connixClient.getData();
            // Process result...
        } catch (ConnixException e) {
            // Handle error...
        }
    }
}

API Reference

ConnixClient

Constructor

public ConnixClient(String apiKey)
public ConnixClient(String apiKey, ConnixClientConfig config)

Methods

public Result someMethod(String param) throws ConnixException
public CompletableFuture<Result> someMethodAsync(String param)
public void close() // Closes underlying HTTP client

Configuration

ConnixClientConfig

public class ConnixClientConfig {
    private Duration timeout;
    private int maxRetries;
    private String baseUrl;
    private Map<String, String> headers;

    public static Builder builder() { ... }
}

Result

public class Result {
    private String id;
    private String data;
    private Instant timestamp;

    // Getters and setters...
}

Thread Safety

The ConnixClient is thread-safe and can be shared across multiple threads:

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

ConnixClient client = new ConnixClient("your-api-key");
ExecutorService executor = Executors.newFixedThreadPool(4);

for (int i = 0; i < 10; i++) {
    final int taskId = i;
    executor.submit(() -> {
        try {
            Result result = client.someMethod("task-" + taskId);
            System.out.println("Task " + taskId + " result: " + result.getData());
        } catch (ConnixException e) {
            System.err.println("Task " + taskId + " failed: " + e.getMessage());
        }
    });
}

executor.shutdown();

Examples

Basic Usage

import io.connix.sdk.ConnixClient;

public class BasicExample {
    public static void main(String[] args) {
        ConnixClient client = new ConnixClient("your-api-key");

        try {
            DataResponse response = client.getData();
            response.getItems().forEach(item -> {
                System.out.println("Item: " + item.getName());
            });
        } catch (ConnixException e) {
            System.err.println("Error: " + e.getMessage());
        } finally {
            client.close();
        }
    }
}

With Custom Configuration

import io.connix.sdk.ConnixClient;
import io.connix.sdk.ConnixClientConfig;
import java.time.Duration;

public class ConfigExample {
    public static void main(String[] args) {
        ConnixClientConfig config = ConnixClientConfig.builder()
            .timeout(Duration.ofMinutes(1))
            .maxRetries(5)
            .build();

        ConnixClient client = new ConnixClient("your-api-key", config);

        try {
            ProcessingResult result = client.processLargeData("large-dataset");
            System.out.println("Processing complete: " + result.getStatus());
        } catch (ConnixException e) {
            System.err.println("Error: " + e.getMessage());
        } finally {
            client.close();
        }
    }
}

Reactive Streams (Optional)

If you include the reactive dependency:

<dependency>
    <groupId>io.connix</groupId>
    <artifactId>connix-reactive</artifactId>
    <version>1.0.0</version>
</dependency>

import reactor.core.publisher.Mono;

public class ReactiveExample {
    public void processDataReactively() {
        ConnixReactiveClient client = new ConnixReactiveClient("your-api-key");

        Mono<Result> resultMono = client.someMethod("parameter");

        resultMono
            .doOnSuccess(result -> System.out.println("Success: " + result.getData()))
            .doOnError(error -> System.err.println("Error: " + error.getMessage()))
            .subscribe();
    }
}

Support

For support and questions, visit our GitHub repository or contact support.