Agent skill

java-ecosystem

Java 25 development patterns for the crypto-scout ecosystem including microservices, ActiveJ, and async I/O

View SKILL.md on GitHub Repository
Stars 163
Forks 31

Install this agent skill to your Project

npx add-skill https://github.com/majiayu000/claude-skill-registry/tree/main/skills/data/java-ecosystem

Metadata

Additional technical details for this skill

domain
microservices
version
25
language
java
framework
activej

SKILL.md

What I Do

Provide comprehensive guidance for Java 25 development across the crypto-scout ecosystem, covering microservice patterns, ActiveJ framework usage, and async I/O operations.

Core Architecture

Launcher Pattern (ActiveJ)

java
public final class Service extends Launcher {
    
    @Override
    protected Module getModule() {
        return combine(
            JmxModule.create(),
            ServiceGraphModule.create(),
            CoreModule.create(),
            ServiceModule.create(),
            WebModule.create()
        );
    }
    
    @Override
    protected void onStart() throws Exception {
        ConfigValidator.validate();
    }
    
    @Override
    protected void run() throws Exception {
        awaitShutdown();
    }
    
    public static void main(String[] args) throws Exception {
        new Service().launch(args);
    }
}

Module Structure

Module Purpose Location
CoreModule Reactor and virtual thread executor All services
WebModule HTTP server, clients, health routes All services
ClientModule AMQP publisher lifecycle crypto-scout-client
CollectorModule Repositories and services crypto-scout-collector
AnalystModule Analysis services crypto-scout-analyst

Reactive Service Pattern

java
public final class MyService extends AbstractReactive implements ReactiveService {
    private final Executor executor;
    private volatile Resource resource;
    
    public static MyService create(NioReactor reactor, Executor executor) {
        return new MyService(reactor, executor);
    }
    
    private MyService(NioReactor reactor, Executor executor) {
        super(reactor);
        this.executor = executor;
    }
    
    @Override
    public Promise<Void> start() {
        return Promise.ofBlocking(executor, () -> {
            // Initialize resources
            resource = createResource();
        });
    }
    
    @Override
    public Promise<Void> stop() {
        return Promise.ofBlocking(executor, () -> {
            // Cleanup resources
            closeResource(resource);
            resource = null;
        });
    }
}

Code Style Essentials

File Structure

1-23:   MIT License header
25:     Package declaration
26:     Blank line
27+:    Imports (java.* → third-party → static)
        Blank line
        Class declaration

Import Organization

java
import java.io.IOException;
import java.nio.file.Path;
import java.time.Duration;

import com.rabbitmq.stream.Environment;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import static com.github.akarazhev.cryptoscout.config.Constants.AmqpConfig.AMQP_RABBITMQ_HOST;

Naming Conventions

Element Convention Example
Classes PascalCase StreamService, AmqpPublisher
Methods camelCase with verb waitForDatabaseReady
Constants UPPER_SNAKE_CASE JDBC_URL, DB_USER
Locals final var final var timeout
Tests <Class>Test AmqpPublisherTest
Test methods should<Subject><Action> shouldPublishPayload

Error Handling

java
// Invalid state
if (resource == null) {
    throw new IllegalStateException("Resource not initialized: " + name);
}

// Try-with-resources
try (final var conn = dataSource.getConnection();
     final var stmt = conn.prepareStatement(sql)) {
    // Use resources
} catch (final SQLException e) {
    throw new IllegalStateException("Database error", e);
}

// Interrupt handling
try {
    Thread.sleep(duration.toMillis());
} catch (final InterruptedException e) {
    Thread.currentThread().interrupt();
}

Testing Patterns

JUnit 6 (Jupiter)

java
final class MyServiceTest {
    
    @BeforeAll
    static void setUp() {
        PodmanCompose.up();
    }
    
    @AfterAll
    static void tearDown() {
        PodmanCompose.down();
    }
    
    @Test
    void shouldServiceStartSuccessfully() throws Exception {
        final var service = createTestService();
        assertTrue(service.start().isResult());
    }
}

Mock Data Usage

java
// Load test fixtures
final var spotKlines = MockData.get(
    MockData.Source.BYBIT_SPOT, 
    MockData.Type.KLINE_1
);
final var fgi = MockData.get(
    MockData.Source.CRYPTO_SCOUT, 
    MockData.Type.FGI
);

Configuration Pattern

java
static final String VALUE = System.getProperty("property.key", "defaultValue");
static final int PORT = Integer.parseInt(System.getProperty("port.key", "5552"));
static final Duration TIMEOUT = Duration.ofMinutes(Long.getLong("timeout.key", 3L));

When to Use Me

Use this skill when:

  • Writing new Java classes or services
  • Understanding ActiveJ patterns and lifecycle
  • Implementing reactive services with Promise/async
  • Organizing imports and file structure
  • Following error handling and logging conventions
  • Writing JUnit 6 tests with proper lifecycle
  • Configuring services via system properties

Didn't find tool you were looking for?

Be as detailed as possible for better results