19 – Exemples

Version : 4.0.0 Date : 2025-12-09

1. Application minimale

1.1 pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0
         https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>3.2.1</version>
    </parent>

    <groupId>com.example</groupId>
    <artifactId>my-socle-app</artifactId>
    <version>1.0.0</version>

    <properties>
        <java.version>21</java.version>
    </properties>

    <dependencies>
        <!-- Socle V4 -->
        <dependency>
            <groupId>eu.lmvi</groupId>
            <artifactId>socle-v004</artifactId>
            <version>4.0.0</version>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
</project>

1.2 Application.java

package com.example;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.ComponentScan;

@SpringBootApplication
@ComponentScan(basePackages = {"com.example", "eu.lmvi.socle"})
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

1.3 application.yml

socle:
  app_name: my-app
  env_name: ${ENV_NAME:DEV}
  region: ${REGION:local}

server:
  port: ${HTTP_PORT:8080}

logging:
  config: classpath:log4j2.xml

1.4 Worker simple

package com.example.worker;

import eu.lmvi.socle.worker.Worker;
import org.springframework.stereotype.Component;

@Component
public class HelloWorker implements Worker {

    @Override
    public String getName() {
        return "hello-worker";
    }

    @Override
    public void initialize() {
        System.out.println("Hello Worker initialized");
    }

    @Override
    public void start() {
        System.out.println("Hello Worker started");
    }

    @Override
    public void doWork() {
        System.out.println("Hello from worker!");
    }

    @Override
    public void stop() {
        System.out.println("Hello Worker stopped");
    }

    @Override
    public boolean isHealthy() {
        return true;
    }

    @Override
    public Map<String, Object> getStats() {
        return Map.of("status", "running");
    }
}

2. Worker Kafka Consumer

package com.example.worker;

import eu.lmvi.socle.worker.AbstractWorker;
import eu.lmvi.socle.techdb.TechDbManager;
import org.apache.kafka.clients.consumer.*;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Component
public class KafkaConsumerWorker extends AbstractWorker {

    @Autowired
    private TechDbManager techDb;

    private KafkaConsumer<String, String> consumer;
    private String topic = "my-topic";
    private long lastOffset = 0;

    @Override
    public String getName() {
        return "kafka-consumer";
    }

    @Override
    public int getStartPriority() {
        return 10;
    }

    @Override
    protected void doInitialize() {
        // Restaurer l'offset
        lastOffset = techDb.getOffset("kafka", topic + "-0").orElse(0L);
        log.info("Starting from offset: {}", lastOffset);

        // Créer le consumer
        Properties props = new Properties();
        props.put("bootstrap.servers", "localhost:9092");
        props.put("group.id", "my-group");
        props.put("key.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");
        props.put("value.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");
        props.put("enable.auto.commit", "false");

        consumer = new KafkaConsumer<>(props);
        consumer.subscribe(List.of(topic));
    }

    @Override
    protected void doProcess() {
        ConsumerRecords<String, String> records = consumer.poll(Duration.ofSeconds(1));

        for (ConsumerRecord<String, String> record : records) {
            processMessage(record);
            lastOffset = record.offset();
            incrementProcessed();
        }

        // Persister périodiquement
        if (processedCount.get() % 100 == 0) {
            techDb.saveOffset("kafka", topic + "-0", lastOffset, null);
        }
    }

    private void processMessage(ConsumerRecord<String, String> record) {
        log.debug("Processing: key={}, value={}", record.key(), record.value());
        // Traitement...
    }

    @Override
    protected void doStop() {
        // Sauvegarder l'offset final
        techDb.saveOffset("kafka", topic + "-0", lastOffset, null);

        if (consumer != null) {
            consumer.close();
        }
    }

    @Override
    public Map<String, Object> getStats() {
        Map<String, Object> stats = new HashMap<>(super.getStats());
        stats.put("lastOffset", lastOffset);
        return stats;
    }
}

3. Worker HTTP API

package com.example.worker;

import eu.lmvi.socle.worker.Worker;
import eu.lmvi.socle.kv.KvBus;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.web.bind.annotation.*;

@Component
@RestController
@RequestMapping("/api/orders")
public class OrderApiWorker implements Worker {

    @Autowired
    private KvBus kvBus;

    @Autowired
    private OrderService orderService;

    private volatile boolean running = false;

    @Override
    public String getName() {
        return "order-api";
    }

    @Override
    public boolean isPassive() {
        return true;  // Pas de doWork cyclique
    }

    @Override
    public void initialize() {}

    @Override
    public void start() {
        running = true;
    }

    @Override
    public void doWork() {
        // Passif - traitement via endpoints REST
    }

    @Override
    public void stop() {
        running = false;
    }

    @Override
    public boolean isHealthy() {
        return running;
    }

    @Override
    public Map<String, Object> getStats() {
        return Map.of("running", running);
    }

    // === REST Endpoints ===

    @PostMapping
    public ResponseEntity<Order> createOrder(@RequestBody CreateOrderRequest request) {
        Order order = orderService.create(request);

        // Cache l'order
        kvBus.putJson("order:" + order.getId(), order);
        kvBus.setTtl("order:" + order.getId(), Duration.ofHours(1));

        return ResponseEntity.status(HttpStatus.CREATED).body(order);
    }

    @GetMapping("/{id}")
    public ResponseEntity<Order> getOrder(@PathVariable String id) {
        // Vérifier le cache d'abord
        Optional<Order> cached = kvBus.getJson("order:" + id, Order.class);
        if (cached.isPresent()) {
            return ResponseEntity.ok(cached.get());
        }

        // Sinon charger depuis la DB
        return orderService.findById(id)
            .map(ResponseEntity::ok)
            .orElse(ResponseEntity.notFound().build());
    }
}

4. Worker Schedulé (Cron)

package com.example.worker;

import eu.lmvi.socle.worker.AbstractWorker;
import org.springframework.stereotype.Component;

@Component
public class DailyReportWorker extends AbstractWorker {

    @Override
    public String getName() {
        return "daily-report";
    }

    @Override
    public String getSchedule() {
        return "0 0 6 * * ?";  // Tous les jours à 6h
    }

    @Override
    public boolean isScheduled() {
        return true;
    }

    @Override
    protected void doProcess() {
        log.info("Generating daily report...");

        // Collecter les données
        ReportData data = collectReportData();

        // Générer le rapport
        Report report = generateReport(data);

        // Envoyer par email
        sendReportByEmail(report);

        log.info("Daily report sent successfully");
        incrementProcessed();
    }

    private ReportData collectReportData() {
        // ...
        return new ReportData();
    }

    private Report generateReport(ReportData data) {
        // ...
        return new Report();
    }

    private void sendReportByEmail(Report report) {
        // ...
    }
}

5. Pipeline de traitement

package com.example.pipeline;

import eu.lmvi.socle.pipeline.*;
import org.springframework.stereotype.Component;

@Component
public class OrderProcessingPipeline {

    @Autowired
    private PipelineEngine engine;

    @Autowired
    private OrderValidator validator;

    @Autowired
    private OrderEnricher enricher;

    @Autowired
    private PaymentProcessor paymentProcessor;

    @Autowired
    private NotificationService notificationService;

    public PipelineResult<ProcessedOrder> process(Order order) {
        Pipeline<Order, ProcessedOrder> pipeline = PipelineBuilder
            .<Order, ProcessedOrder>create("order-processing")
            .addStep(new ValidationStep(validator))
            .addStep(new EnrichmentStep(enricher))
            .addStep(new PaymentStep(paymentProcessor))
            .addStep(new NotificationStep(notificationService))
            .build();

        return engine.execute(pipeline, order);
    }
}

// Étape de validation
class ValidationStep implements PipelineStep<Order, ValidatedOrder> {

    private final OrderValidator validator;

    public ValidationStep(OrderValidator validator) {
        this.validator = validator;
    }

    @Override
    public String getName() {
        return "validation";
    }

    @Override
    public StepResult<ValidatedOrder> execute(Order input, PipelineContext context) {
        List<String> errors = validator.validate(input);
        if (!errors.isEmpty()) {
            return StepResult.failure(getName(),
                new ValidationException(errors), Duration.ZERO, 1);
        }
        return StepResult.success(getName(), new ValidatedOrder(input), Duration.ZERO);
    }

    @Override
    public boolean isRetryable() {
        return false;
    }
}

// Étape de notification (optionnelle)
class NotificationStep implements PipelineStep<ProcessedOrder, ProcessedOrder> {

    private final NotificationService notificationService;

    @Override
    public String getName() {
        return "notification";
    }

    @Override
    public StepResult<ProcessedOrder> execute(ProcessedOrder input, PipelineContext context) {
        try {
            notificationService.sendOrderConfirmation(input);
            return StepResult.success(getName(), input, Duration.ZERO);
        } catch (Exception e) {
            return StepResult.failure(getName(), e, Duration.ZERO, 1);
        }
    }

    @Override
    public boolean isOptional() {
        return true;  // Le pipeline continue même si la notif échoue
    }
}

6. Service avec résilience

package com.example.service;

import eu.lmvi.socle.resilience.*;
import org.springframework.stereotype.Service;

@Service
public class ExternalApiService {

    @Autowired
    private RetryTemplate retryTemplate;

    @Autowired
    private CircuitBreakerRegistry cbRegistry;

    @Autowired
    private KvBus kvBus;

    private final OkHttpClient httpClient;

    public Data fetchData(String id) {
        // Circuit breaker + Retry + Cache fallback
        CircuitBreaker cb = cbRegistry.getOrCreate("external-api");

        return cb.executeWithFallback(
            () -> retryTemplate.execute(() -> doFetchData(id)),
            () -> getCachedData(id)
        );
    }

    private Data doFetchData(String id) throws IOException {
        Request request = new Request.Builder()
            .url("https://api.example.com/data/" + id)
            .build();

        try (Response response = httpClient.newCall(request).execute()) {
            if (!response.isSuccessful()) {
                throw new IOException("API returned " + response.code());
            }

            Data data = parseResponse(response.body().string());

            // Mettre en cache
            kvBus.putJson("cache:data:" + id, data);
            kvBus.setTtl("cache:data:" + id, Duration.ofMinutes(5));

            return data;
        }
    }

    private Data getCachedData(String id) {
        return kvBus.getJson("cache:data:" + id, Data.class)
            .orElseThrow(() -> new RuntimeException("No cached data available"));
    }
}

7. Configuration multi-environnement

application.yml (base)

socle:
  app_name: ${APP_NAME:my-app}
  env_name: ${ENV_NAME:DEV}
  region: ${REGION:local}

spring:
  profiles:
    active: ${PROFILE:dev}

application-dev.yml

socle:
  kvbus:
    mode: in_memory
  techdb:
    console:
      enabled: true
  admin:
    auth:
      enabled: false

logging:
  level:
    eu.lmvi.socle: DEBUG

application-prod.yml

socle:
  kvbus:
    mode: redis
    redis:
      host: ${REDIS_HOST}
      password: ${REDIS_PASSWORD}
  techdb:
    console:
      enabled: false
  logging:
    forwarder:
      enabled: true
  auth:
    enabled: true
  admin:
    auth:
      enabled: true

logging:
  level:
    eu.lmvi.socle: INFO

8. Dockerfile complet

# Build stage
FROM eclipse-temurin:21-jdk-alpine AS build
WORKDIR /app
COPY pom.xml .
COPY src ./src
RUN apk add --no-cache maven && \
    mvn clean package -DskipTests

# Runtime stage
FROM eclipse-temurin:21-jre-alpine
WORKDIR /app

# Security
RUN addgroup -S app && adduser -S app -G app
USER app

# Copy artifact
COPY --from=build --chown=app:app /app/target/*.jar app.jar

# Config
ENV JAVA_OPTS="-XX:+UseContainerSupport -XX:MaxRAMPercentage=75.0 -Djava.security.egd=file:/dev/./urandom"

# Health check
HEALTHCHECK --interval=30s --timeout=10s --retries=3 \
    CMD wget -qO- http://localhost:8080/admin/health/live || exit 1

EXPOSE 8080

ENTRYPOINT ["sh", "-c", "java $JAVA_OPTS -jar app.jar"]

9. Kubernetes deployment complet

Voir 16-KUBERNETES pour l’exemple complet de déploiement K8s.

10. Références

• 03-QUICKSTART – Démarrage rapide
• 05-WORKERS – Workers
• 17-HOWTO – How-To Guides