Performance

// Votre code
@Singleton
@RequiredArgsConstructor
public class GetTrendsUseCase {
    private final TrendRepository repository;
}
 
// Code généré par Micronaut (simplifié)
public class $GetTrendsUseCase$Definition {
    public GetTrendsUseCase build(BeanContext context) {
        TrendRepository repository = context.getBean(TrendRepository.class);
        return new GetTrendsUseCase(repository);
    }
}

<!-- pom.xml -->
<plugin>
    <groupId>org.graalvm.buildtools</groupId>
    <artifactId>native-maven-plugin</artifactId>
</plugin>

# Compiler en natif
./mvnw package -Dpackaging=native-image
 
# Lancer le binaire
./target/myapp
 
# Démarrage en 15ms ! 🚀

// ❌ LENT : Crée une nouvelle instance à chaque injection
@Prototype
public class GetTrendsUseCase {
    private final TrendRepository repository;
}
 
// À chaque requête HTTP, une NOUVELLE instance est créée
@Controller
public class TrendController {
    private final GetTrendsUseCase useCase;  // ← Nouvelle instance
}

// ✅ RAPIDE : Une seule instance pour toute l'application
@Singleton
public class GetTrendsUseCase {
    private final TrendRepository repository;
}
 
// Réutilise toujours la MÊME instance
@Controller
public class TrendController {
    private final GetTrendsUseCase useCase;  // ← Même instance
}

// ❌ DANGER : État mutable partagé entre threads
@Singleton
public class TrendCache {
    private final List<TrendResult> cache = new ArrayList<>();  // ❌
 
    public void addTrend(TrendResult result) {
        cache.add(result);  // ❌ Race condition !
    }
 
    public List<TrendResult> getTrends() {
        return cache;  // ❌ Partagé entre threads
    }
}

// ✅ BON : Collection thread-safe
@Singleton
public class TrendCache {
    private final ConcurrentHashMap<String, TrendResult> cache =
        new ConcurrentHashMap<>();
 
    public void addTrend(String key, TrendResult result) {
        cache.put(key, result);  // ✅ Thread-safe
    }
 
    public Optional<TrendResult> getTrend(String key) {
        return Optional.ofNullable(cache.get(key));
    }
}

// ✅ MEILLEUR : Pas d'état mutable
@Singleton
public class TrendService {
    private final TrendRepository repository;
 
    public List<TrendResult> getTrends(TrendQuery query) {
        // Pas d'état partagé, retourne une nouvelle liste
        return repository.findAll(query);
    }
}

// ✅ OPTIMAL : Cache Redis ou Caffeine
@Singleton
public class TrendCacheAdapter {
    @Inject
    @Named("trends-cache")
    private Cache<String, TrendResult> cache;
 
    public void cache(String key, TrendResult result) {
        cache.put(key, result);
    }
}

// Par défaut, tous les @Singleton sont créés au démarrage
@Singleton
public class HeavyService {
    public HeavyService() {
        // Initialisation lourde (3 secondes)
        loadHugeDataset();
    }
}
 
// Résultat : Démarrage ralenti de 3 secondes

// ✅ Créé uniquement à la première utilisation
@Singleton(lazy = true)
public class HeavyService {
    public HeavyService() {
        loadHugeDataset();  // Exécuté à la première injection
    }
}

# application.yml (défaut)
micronaut:
  http:
    client:
      # Pas de timeout configuré = risque de blocage

# application.yml
micronaut:
  http:
    client:
      read-timeout: 5s           # ✅ Timeout lecture
      connect-timeout: 2s        # ✅ Timeout connexion
      pool:
        enabled: true            # ✅ Pool de connexions
        max-connections: 50      # ✅ Max 50 connexions
      follow-redirects: true     # ✅ Suivre redirections

@Singleton
@Requires(property = "api.trends.url")
public class TrendApiClientConfig {
 
    @Client("${api.trends.url}")
    @Retryable(
        attempts = "3",
        delay = "1s",
        multiplier = "2.0"
    )
    interface TrendApiClient {
        @Get("/trends?keyword={keyword}")
        String getTrends(String keyword);
    }
}

// ❌ MAUVAIS : Cache dans le domain
package org.smoka.domain.port.output;
 
public interface TrendRepository {
    @Cacheable("trends")  // ❌ Annotation technique dans le domain !
    Optional<TrendResult> getTrends(TrendQuery query);
}

// ✅ BON : Interface pure dans le domain
package org.smoka.domain.port.output;
 
public interface TrendRepository {
    Optional<TrendResult> getTrends(TrendQuery query);  // ✅ Pur
}
 
// ✅ Cache dans l'adapter (infrastructure)
package org.smoka.infrastructure.adapter;
 
@Singleton
public class CachedTrendRepositoryAdapter implements TrendRepository {
 
    private final TrendApiClient apiClient;
 
    @Cacheable(value = "trends", parameters = {"query.keyword", "query.region"})
    @Override
    public Optional<TrendResult> getTrends(TrendQuery query) {
        // Appel API mis en cache
        return apiClient.fetchTrends(query);
    }
}

# application.yml
micronaut:
  caches:
    trends:
      maximumSize: 1000
      expireAfterWrite: 10m

// ❌ LENT : 1 + N requêtes
@Singleton
public class GetTrendsWithDetailsUseCase {
    private final TrendRepository trendRepo;
    private final DetailRepository detailRepo;
 
    public List<TrendWithDetails> execute() {
        List<TrendResult> trends = trendRepo.findAll();  // 1 requête
 
        return trends.stream()
            .map(trend -> {
                // N requêtes (une par trend) !
                var details = detailRepo.findByKeyword(trend.keyword());
                return new TrendWithDetails(trend, details);
            })
            .toList();
    }
}

// ✅ RAPIDE : 2 requêtes au total
@Singleton
public class GetTrendsWithDetailsUseCase {
    private final TrendRepository trendRepo;
    private final DetailRepository detailRepo;
 
    public List<TrendWithDetails> execute() {
        List<TrendResult> trends = trendRepo.findAll();  // 1 requête
 
        // Récupérer TOUS les détails en une seule fois
        List<String> keywords = trends.stream()
            .map(TrendResult::keyword)
            .toList();
 
        Map<String, Detail> detailsByKeyword =
            detailRepo.findByKeywords(keywords)  // 1 seule requête !
                .stream()
                .collect(Collectors.toMap(Detail::keyword, d -> d));
 
        // Assembler en mémoire
        return trends.stream()
            .map(trend -> new TrendWithDetails(
                trend,
                detailsByKeyword.get(trend.keyword())
            ))
            .toList();
    }
}

public interface DetailRepository {
    // ✅ Méthode qui prend plusieurs keywords
    List<Detail> findByKeywords(List<String> keywords);
}