import com.netflix.hystrix.HystrixCommand;
import com.netflix.hystrix.HystrixCommandGroupKey;

public class UserCommand extends HystrixCommand<User> {
    
    private final Long userId;
    private final UserServiceClient userServiceClient;
    
    public UserCommand(Long userId, UserServiceClient userServiceClient) {
        super(HystrixCommandGroupKey.Factory.asKey("UserGroup"));
        this.userId = userId;
        this.userServiceClient = userServiceClient;
    }
    
    @Override
    protected User run() throws Exception {
        // Logique principale - exécutée dans un thread séparé
        return userServiceClient.getUserById(userId);
    }
    
    @Override
    protected User getFallback() {
        // Logique de fallback - appelée en cas de défaillance
        return new User(userId, "Fallback User", "fallback@example.com");
    }
}

import com.netflix.hystrix.HystrixCommand;
import com.netflix.hystrix.HystrixCommandGroupKey;
import com.netflix.hystrix.HystrixCommandProperties;

public class CircuitBreakerUserCommand extends HystrixCommand<User> {
    
    public CircuitBreakerUserCommand() {
        super(Setter
            .withGroupKey(HystrixCommandGroupKey.Factory.asKey("UserGroup"))
            .andCommandPropertiesDefaults(HystrixCommandProperties.Setter()
                .withCircuitBreakerEnabled(true)                    // Activer le circuit breaker
                .withCircuitBreakerRequestVolumeThreshold(20)       // Seuil de requêtes
                .withCircuitBreakerErrorThresholdPercentage(50)     // Pourcentage d'erreurs
                .withCircuitBreakerSleepWindowInMilliseconds(5000)  // Temps d'attente en OPEN
                .withExecutionTimeoutInMilliseconds(3000)           // Timeout d'exécution
                .withExecutionIsolationStrategy(
                    HystrixCommandProperties.ExecutionIsolationStrategy.THREAD) // Isolation par thread
            )
        );
    }
    
    @Override
    protected User run() throws Exception {
        // Logique d'appel au service
        return userServiceClient.getUserById(userId);
    }
    
    @Override
    protected User getFallback() {
        // Fallback en cas de défaillance ou circuit breaker ouvert
        return new User(userId, "Fallback User", "fallback@example.com");
    }
}

public class ThreadIsolationCommand extends HystrixCommand<String> {
    
    public ThreadIsolationCommand() {
        super(Setter
            .withGroupKey(HystrixCommandGroupKey.Factory.asKey("ThreadGroup"))
            .andCommandPropertiesDefaults(HystrixCommandProperties.Setter()
                .withExecutionIsolationStrategy(
                    HystrixCommandProperties.ExecutionIsolationStrategy.THREAD)
                .withExecutionTimeoutInMilliseconds(5000)
            )
            .andThreadPoolPropertiesDefaults(HystrixThreadPoolProperties.Setter()
                .withCoreSize(10)                    // Taille du pool de threads
                .withMaximumSize(20)                 // Taille maximale
                .withMaxQueueSize(100)               // Taille maximale de la file d'attente
                .withQueueSizeRejectionThreshold(80) // Seuil de rejet
            )
        );
    }
    
    @Override
    protected String run() throws Exception {
        // Exécuté dans un thread séparé
        return "Résultat de l'opération";
    }
}

public class SemaphoreIsolationCommand extends HystrixCommand<String> {
    
    public SemaphoreIsolationCommand() {
        super(Setter
            .withGroupKey(HystrixCommandGroupKey.Factory.asKey("SemaphoreGroup"))
            .andCommandPropertiesDefaults(HystrixCommandProperties.Setter()
                .withExecutionIsolationStrategy(
                    HystrixCommandProperties.ExecutionIsolationStrategy.SEMAPHORE)
                .withExecutionTimeoutInMilliseconds(2000)
                .withExecutionIsolationSemaphoreMaxConcurrentRequests(10) // Max concurrents
            )
        );
    }
    
    @Override
    protected String run() throws Exception {
        // Exécuté dans le thread appelant
        return "Résultat de l'opération rapide";
    }
}

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-netflix-hystrix</artifactId>
</dependency>

<!-- Pour le dashboard Hystrix -->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-netflix-hystrix-dashboard</artifactId>
</dependency>

<!-- Pour Turbine (agrégation de métriques) -->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-netflix-turbine</artifactId>
</dependency>

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.circuitbreaker.EnableCircuitBreaker;
import org.springframework.cloud.netflix.hystrix.dashboard.EnableHystrixDashboard;

@SpringBootApplication
@EnableCircuitBreaker           // Active Hystrix
@EnableHystrixDashboard        // Active le dashboard (optionnel)
public class UserServiceApplication {
    public static void main(String[] args) {
        SpringApplication.run(UserServiceApplication.class, args);
    }
}

# Configuration globale de Hystrix
hystrix.command.default.execution.isolation.thread.timeoutInMilliseconds=3000
hystrix.command.default.circuitBreaker.requestVolumeThreshold=20
hystrix.command.default.circuitBreaker.errorThresholdPercentage=50
hystrix.command.default.circuitBreaker.sleepWindowInMilliseconds=5000

# Configuration des thread pools
hystrix.threadpool.default.coreSize=10
hystrix.threadpool.default.maximumSize=20
hystrix.threadpool.default.maxQueueSize=100
hystrix.threadpool.default.queueSizeRejectionThreshold=80

# Configuration du métriques
hystrix.metrics.rollingStats.timeInMilliseconds=10000
hystrix.metrics.rollingStats.numBuckets=10
hystrix.metrics.healthSnapshot.intervalInMilliseconds=500

# Activation du stream Hystrix pour le dashboard
management.endpoints.web.exposure.include=hystrix.stream,health,info

# Configuration spécifique pour le service utilisateur
hystrix.command.UserServiceCommand.execution.isolation.thread.timeoutInMilliseconds=5000
hystrix.command.UserServiceCommand.circuitBreaker.requestVolumeThreshold=10
hystrix.command.UserServiceCommand.circuitBreaker.errorThresholdPercentage=30

# Configuration spécifique du thread pool pour utilisateur
hystrix.threadpool.UserServicePool.coreSize=15
hystrix.threadpool.UserServicePool.maximumSize=30

import com.netflix.hystrix.contrib.javanica.annotation.HystrixCommand;
import org.springframework.stereotype.Service;
import org.springframework.web.client.RestTemplate;

@Service
public class UserService {
    
    private final RestTemplate restTemplate;
    
    public UserService(RestTemplate restTemplate) {
        this.restTemplate = restTemplate;
    }
    
    @HystrixCommand(fallbackMethod = "getUserFallback")
    public User getUser(Long userId) {
        // Appel HTTP qui peut échouer
        return restTemplate.getForObject(
            "http://user-service/users/" + userId, 
            User.class);
    }
    
    public User getUserFallback(Long userId) {
        // Méthode de fallback appelée en cas de défaillance
        return new User(userId, "Utilisateur par défaut", "default@example.com");
    }
}

import org.springframework.web.bind.annotation.*;

@RestController
@RequestMapping("/api/users")
public class UserController {
    
    private final UserService userService;
    
    public UserController(UserService userService) {
        this.userService = userService;
    }
    
    @GetMapping("/{id}")
    public User getUser(@PathVariable Long id) {
        // La méthode getUser utilisera Hystrix automatiquement
        return userService.getUser(id);
    }
}

@Service
public class OrderService {
    
    @HystrixCommand(fallbackMethod = "getDefaultOrders")
    public List<Order> getOrdersByUser(Long userId) {
        // Logique principale qui peut échouer
        return orderRepository.findByUserId(userId);
    }
    
    public List<Order> getDefaultOrders(Long userId) {
        // Fallback - données par défaut
        return Arrays.asList(new Order(0L, "Commande par défaut", userId));
    }
}

@HystrixCommand(
    fallbackMethod = "getOrdersFallback",
    commandProperties = {
        @HystrixProperty(name = "execution.isolation.thread.timeoutInMilliseconds", value = "3000"),
        @HystrixProperty(name = "circuitBreaker.requestVolumeThreshold", value = "10"),
        @HystrixProperty(name = "circuitBreaker.errorThresholdPercentage", value = "50"),
        @HystrixProperty(name = "circuitBreaker.sleepWindowInMilliseconds", value = "10000")
    }
)
public List<Order> getOrdersWithCustomConfig(Long userId) {
    return orderServiceClient.getOrders(userId);
}

public List<Order> getOrdersFallback(Long userId) {
    // Fallback avec logique personnalisée
    logger.warn("Fallback activé pour les commandes de l'utilisateur: " + userId);
    return Collections.emptyList();
}

@HystrixCommand(
    fallbackMethod = "getUserFallback",
    commandProperties = {
        @HystrixProperty(name = "execution.isolation.strategy", value = "THREAD"),
        @HystrixProperty(name = "execution.isolation.thread.timeoutInMilliseconds", value = "5000")
    },
    threadPoolProperties = {
        @HystrixProperty(name = "coreSize", value = "20"),
        @HystrixProperty(name = "maximumSize", value = "50"),
        @HystrixProperty(name = "maxQueueSize", value = "100"),
        @HystrixProperty(name = "queueSizeRejectionThreshold", value = "80")
    },
    threadPoolKey = "UserThreadPool"
)
public User getUserWithCustomThreadPool(Long userId) {
    return userServiceClient.getUser(userId);
}

// Première commande utilisant le même thread pool
@HystrixCommand(
    fallbackMethod = "getUserFallback",
    threadPoolKey = "SharedThreadPool"
)
public User getUser(Long userId) {
    return userServiceClient.getUser(userId);
}

// Deuxième commande utilisant le même thread pool
@HystrixCommand(
    fallbackMethod = "getProfileFallback",
    threadPoolKey = "SharedThreadPool",
    threadPoolProperties = {
        @HystrixProperty(name = "coreSize", value = "15"),
        @HystrixProperty(name = "maximumSize", value = "30")
    }
)
public UserProfile getUserProfile(Long userId) {
    return profileServiceClient.getProfile(userId);
}

@HystrixCommand(
    fallbackMethod = "getProductFallback",
    ignoreExceptions = {ProductNotFoundException.class}
)
public Product getProduct(Long productId) {
    Product product = productServiceClient.getProduct(productId);
    if (product == null) {
        throw new ProductNotFoundException("Produit non trouvé: " + productId);
    }
    return product;
}

// Cette méthode de fallback ne sera pas appelée pour ProductNotFoundException
public Product getProductFallback(Long productId) {
    logger.info("Fallback pour le produit: " + productId);
    return new Product(productId, "Produit par défaut", 0.0);
}

@HystrixCommand(
    fallbackMethod = "getDefaultResult",
    commandProperties = {
        @HystrixProperty(name = "fallback.isolation.semaphore.maxConcurrentRequests", value = "100")
    }
)
public ServiceResult performOperation(OperationRequest request) {
    return externalServiceClient.processRequest(request);
}

// Fallback général
public ServiceResult getDefaultResult(OperationRequest request) {
    return new ServiceResult("DEFAULT", "Service indisponible");
}

// Fallback pour des exceptions spécifiques (nécessite une logique personnalisée)
public ServiceResult handleTimeout(OperationRequest request, Throwable throwable) {
    if (throwable instanceof HystrixTimeoutException) {
        return new ServiceResult("TIMEOUT", "Service trop lent");
    }
    return getDefaultResult(request);
}

import com.netflix.hystrix.contrib.javanica.annotation.HystrixCollapser;
import com.netflix.hystrix.contrib.javanica.annotation.HystrixCommand;
import com.netflix.hystrix.contrib.javanica.command.AsyncResult;
import java.util.concurrent.Future;

@Service
public class UserService {
    
    @HystrixCollapser(
        batchMethod = "getUsersBatch",
        collapserProperties = {
            @HystrixProperty(name = "timerDelayInMilliseconds", value = "20"),
            @HystrixProperty(name = "maxRequestsInBatch", value = "10")
        }
    )
    public Future<User> getUser(Long userId) {
        // Cette méthode est automatiquement transformée en batch
        return null; // Retour ignoré - géré par Hystrix
    }
    
    @HystrixCommand
    public List<User> getUsersBatch(List<Long> userIds) {
        // Méthode batch - appelée avec plusieurs IDs
        return userServiceClient.getUsers(userIds);
    }
}

@RestController
public class UserController {
    
    @Autowired
    private UserService userService;
    
    @GetMapping("/users/{id}")
    public User getUser(@PathVariable Long id) throws Exception {
        // Les appels multiples dans un court laps de temps seront agrégés
        Future<User> userFuture = userService.getUser(id);
        return userFuture.get(); // Attend le résultat
    }
    
    @GetMapping("/users/batch")
    public List<User> getUsers(@RequestParam List<Long> ids) {
        // Appel batch direct
        return userService.getUsersBatch(ids);
    }
}

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-netflix-hystrix-dashboard</artifactId>
</dependency>

@SpringBootApplication
@EnableCircuitBreaker
@EnableHystrixDashboard
public class MonitoringApplication {
    public static void main(String[] args) {
        SpringApplication.run(MonitoringApplication.class, args);
    }
}

# Activer le stream Hystrix
management.endpoints.web.exposure.include=hystrix.stream,health,info

# Configuration du stream
management.endpoint.hystrix.stream.enabled=true

# Pour Turbine (agrégation multiple)
turbine.app-config=user-service,order-service,payment-service
turbine.cluster-name-expression=new String("default")
turbine.combine-host-port=true

@SpringBootApplication
@EnableTurbine
public class TurbineApplication {
    public static void main(String[] args) {
        SpringApplication.run(TurbineApplication.class, args);
    }
}

# Services à agréger
turbine.app-config=user-service,order-service,payment-service
turbine.cluster-name-expression=new String("default")
turbine.combine-host-port=true

# URLs des streams Hystrix
turbine.instanceUrlSuffix.default=hystrix.stream

# Configuration réseau
server.port=8989

# Configuration spécifique pour une commande
hystrix.command.GetUserCommand.execution.isolation.thread.timeoutInMilliseconds=2000
hystrix.command.GetUserCommand.circuitBreaker.requestVolumeThreshold=5
hystrix.command.GetUserCommand.circuitBreaker.errorThresholdPercentage=40
hystrix.command.GetUserCommand.circuitBreaker.sleepWindowInMilliseconds=15000
hystrix.command.GetUserCommand.circuitBreaker.forceOpen=false
hystrix.command.GetUserCommand.circuitBreaker.forceClosed=false
hystrix.command.GetUserCommand.execution.timeout.enabled=true

# Configuration du fallback
hystrix.command.GetUserCommand.fallback.isolation.semaphore.maxConcurrentRequests=20
hystrix.command.GetUserCommand.fallback.enabled=true

# Configuration des statistiques roulantes
hystrix.command.default.metrics.rollingStats.timeInMilliseconds=10000
hystrix.command.default.metrics.rollingStats.numBuckets=10
hystrix.command.default.metrics.rollingPercentile.enabled=true
hystrix.command.default.metrics.rollingPercentile.timeInMilliseconds=60000
hystrix.command.default.metrics.rollingPercentile.numBuckets=6
hystrix.command.default.metrics.rollingPercentile.bucketSize=100

# Configuration du snapshot de santé
hystrix.command.default.metrics.healthSnapshot.intervalInMilliseconds=500

# Configuration du cache de requêtes
hystrix.command.default.requestCache.enabled=true
hystrix.command.default.requestLog.enabled=true

# Configuration du pool par défaut
hystrix.threadpool.default.coreSize=10
hystrix.threadpool.default.maximumSize=20
hystrix.threadpool.default.maxQueueSize=100
hystrix.threadpool.default.queueSizeRejectionThreshold=80
hystrix.threadpool.default.keepAliveTimeMinutes=1
hystrix.threadpool.default.allowMaximumSizeToDivergeFromCoreSize=true

# Configuration d'un pool spécifique
hystrix.threadpool.UserServicePool.coreSize=15
hystrix.threadpool.UserServicePool.maximumSize=30
hystrix.threadpool.UserServicePool.maxQueueSize=200
hystrix.threadpool.UserServicePool.queueSizeRejectionThreshold=150

# Activer les métriques détaillées
management.endpoints.web.exposure.include=metrics,health,info,hystrix.stream
management.endpoint.metrics.enabled=true

# Métriques spécifiques Hystrix
management.metrics.enable.hystrix=true
management.metrics.distribution.percentiles-histogram.hystrix=true

import com.netflix.config.ConfigurationManager;
import com.netflix.hystrix.HystrixCommandKey;
import com.netflix.hystrix.HystrixCommandProperties;

@Component
public class HystrixConfigurator {
    
    @PostConstruct
    public void configureHystrix() {
        // Configuration programmatique
        ConfigurationManager.getConfigInstance().setProperty(
            "hystrix.command.GetUserCommand.execution.isolation.thread.timeoutInMilliseconds", 
            "3000"
        );
        
        ConfigurationManager.getConfigInstance().setProperty(
            "hystrix.threadpool.UserServicePool.coreSize", 
            "20"
        );
        
        // Configuration dynamique à l'exécution
        updateTimeoutDynamically("GetUserCommand", 5000);
    }
    
    public void updateTimeoutDynamically(String commandKey, int timeoutMs) {
        ConfigurationManager.getConfigInstance().setProperty(
            "hystrix.command." + commandKey + ".execution.isolation.thread.timeoutInMilliseconds", 
            String.valueOf(timeoutMs)
        );
    }
}

@Component
public class ConditionalHystrixConfig {
    
    @Value("${environment:prod}")
    private String environment;
    
    @PostConstruct
    public void setupEnvironmentSpecificConfig() {
        if ("dev".equals(environment)) {
            // Configuration pour développement
            ConfigurationManager.getConfigInstance().setProperty(
                "hystrix.command.default.circuitBreaker.enabled", "false"
            );
        } else if ("prod".equals(environment)) {
            // Configuration pour production
            ConfigurationManager.getConfigInstance().setProperty(
                "hystrix.command.default.circuitBreaker.enabled", "true"
            );
        }
    }
}

@HystrixCommand(fallbackMethod = "getDefaultUser")
public User getUser(Long userId) {
    return userServiceClient.getUser(userId);
}

public User getDefaultUser(Long userId) {
    // Données statiques de fallback
    return new User(userId, "Utilisateur temporairement indisponible", "unknown@example.com");
}

@HystrixCommand(fallbackMethod = "getCachedUser")
public User getUser(Long userId) {
    return userServiceClient.getUser(userId);
}

public User getCachedUser(Long userId) {
    // Fallback avec données du cache
    User cachedUser = cacheService.getUser(userId);
    if (cachedUser != null) {
        return cachedUser;
    }
    // Fallback de fallback
    return new User(userId, "Utilisateur par défaut", "default@example.com");
}

@HystrixCommand(fallbackMethod = "getDegradedUser")
public User getUserWithProfile(Long userId) {
    User user = userServiceClient.getUser(userId);
    UserProfile profile = profileServiceClient.getProfile(userId);
    user.setProfile(profile);
    return user;
}

public User getDegradedUser(Long userId) {
    // Service dégradé - données partielles
    logger.warn("Service dégradé pour l'utilisateur: " + userId);
    
    User user = new User(userId, "Utilisateur (service dégradé)", "degraded@example.com");
    user.setProfile(new UserProfile("Données de profil non disponibles"));
    
    // Notification de l'erreur
    alertService.sendAlert("Fallback activé pour utilisateur: " + userId);
    
    return user;
}

@HystrixCommand(
    fallbackMethod = "getCachedUser",
    commandProperties = {
        @HystrixProperty(name = "requestCache.enabled", value = "true")
    }
)
public User getUser(Long userId) {
    return userServiceClient.getUser(userId);
}

// Méthode de fallback utilisant le cache
public User getCachedUser(Long userId) {
    // Vérifier d'abord le cache Hystrix
    String cacheKey = "user-" + userId;
    User cachedUser = (User) HystrixRequestCache.getInstance(
        HystrixCommandKey.Factory.asKey("GetUserCommand"), 
        HystrixConcurrencyStrategyDefault.getInstance()
    ).get(cacheKey);
    
    if (cachedUser != null) {
        return cachedUser;
    }
    
    // Fallback par défaut
    return new User(userId, "Utilisateur par défaut", "default@example.com");
}

@Service
public class CachedUserService {
    
    private final HystrixRequestContext context;
    
    @PostConstruct
    public void initializeContext() {
        // Initialiser le contexte Hystrix pour le cache
        this.context = HystrixRequestContext.initializeContext();
    }
    
    @HystrixCommand(commandKey = "GetUserWithCache")
    public User getUser(Long userId) {
        return userServiceClient.getUser(userId);
    }
    
    public void clearCache() {
        // Nettoyer le cache à la fin de la requête
        if (context != null) {
            context.shutdown();
        }
    }
}

// Commandes pour le service utilisateur
@HystrixCommand(
    groupKey = "UserServiceGroup",
    threadPoolKey = "UserServicePool"
)
public User getUser(Long userId) {
    return userServiceClient.getUser(userId);
}

// Commandes pour le service commande
@HystrixCommand(
    groupKey = "OrderServiceGroup",
    threadPoolKey = "OrderServicePool"
)
public List<Order> getOrders(Long userId) {
    return orderServiceClient.getOrders(userId);
}

// Configuration des pools séparés
hystrix.threadpool.UserServicePool.coreSize=10
hystrix.threadpool.OrderServicePool.coreSize=15

@HystrixCommand(
    groupKey = "CriticalServiceGroup",
    threadPoolKey = "CriticalServicePool",
    threadPoolProperties = {
        @HystrixProperty(name = "coreSize", value = "50"),
        @HystrixProperty(name = "maximumSize", value = "100"),
        @HystrixProperty(name = "maxQueueSize", value = "50")
    }
)
public CriticalData getCriticalData(String id) {
    return criticalServiceClient.getData(id);
}

@HystrixCommand(
    groupKey = "NonCriticalServiceGroup",
    threadPoolKey = "NonCriticalServicePool",
    threadPoolProperties = {
        @HystrixProperty(name = "coreSize", value = "5"),
        @HystrixProperty(name = "maximumSize", value = "10"),
        @HystrixProperty(name = "maxQueueSize", value = "10")
    }
)
public NonCriticalData getNonCriticalData(String id) {
    return nonCriticalServiceClient.getData(id);
}

@HystrixCommand(
    fallbackMethod = "getTimeoutFallback",
    commandProperties = {
        @HystrixProperty(name = "execution.isolation.thread.timeoutInMilliseconds", value = "3000"),
        @HystrixProperty(name = "execution.timeout.enabled", value = "true")
    }
)
public ExpensiveOperation performExpensiveOperation(Data data) {
    return expensiveServiceClient.process(data);
}

public ExpensiveOperation getTimeoutFallback(Data data) {
    logger.warn("Timeout sur l'opération coûteuse");
    return new ExpensiveOperation("Opération annulée - timeout");
}

@HystrixCommand(
    fallbackMethod = "getAdaptiveFallback",
    commandProperties = {
        @HystrixProperty(name = "execution.isolation.thread.timeoutInMilliseconds", value = "5000")
    }
)
public ServiceResponse callService(ServiceRequest request) {
    // Timeout basé sur la complexité de la requête
    int timeout = calculateTimeout(request);
    return serviceClient.call(request, timeout);
}

private int calculateTimeout(ServiceRequest request) {
    // Logique adaptative de calcul du timeout
    if (request.isComplex()) {
        return 10000; // 10 secondes pour les requêtes complexes
    }
    return 3000; // 3 secondes pour les requêtes simples
}

public ServiceResponse getAdaptiveFallback(ServiceRequest request) {
    return new ServiceResponse("Service temporairement indisponible");
}

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-loadbalancer</artifactId>
</dependency>

# Activer Spring Cloud LoadBalancer (désactive Ribbon)
spring.cloud.loadbalancer.retry.enabled=true
spring.cloud.loadbalancer.ribbon.enabled=false

# Configuration des timeouts
spring.cloud.loadbalancer.retry.max-attempts=3
spring.cloud.loadbalancer.retry.backoff.enabled=true
spring.cloud.loadbalancer.retry.backoff.first-backoff=100ms
spring.cloud.loadbalancer.retry.backoff.max-backoff=1000ms

# Configuration du cache
spring.cloud.loadbalancer.cache.enabled=true
spring.cloud.loadbalancer.cache.ttl=30s
spring.cloud.loadbalancer.cache.capacity=1000

@Configuration
public class WebClientConfig {
    
    @Bean
    @LoadBalanced
    public WebClient.Builder loadBalancedWebClientBuilder() {
        return WebClient.builder();
    }
    
    @Bean
    public WebClient webClient(WebClient.Builder builder) {
        return builder.build();
    }
}

@Service
public class UserServiceClient {
    
    private final WebClient webClient;
    
    public UserServiceClient(@LoadBalanced WebClient.Builder webClientBuilder) {
        this.webClient = webClientBuilder.build();
    }
    
    public Mono<List<User>> getAllUsers() {
        return webClient
            .get()
            .uri("lb://user-service/users") // lb:// pour load balancing
            .retrieve()
            .bodyToFlux(User.class)
            .collectList();
    }
    
    public Mono<User> getUserById(Long id) {
        return webClient
            .get()
            .uri("lb://user-service/users/{id}", id)
            .retrieve()
            .bodyToMono(User.class);
    }
}

@Configuration
public class CustomLoadBalancerConfiguration {
    
    @Bean
    ReactorLoadBalancer<ServiceInstance> randomLoadBalancer(
            Environment environment,
            LoadBalancerClientFactory loadBalancerClientFactory) {
        
        String name = environment.getProperty(
            LoadBalancerClientFactory.PROPERTY_NAME);
            
        return new RandomLoadBalancer(
            loadBalancerClientFactory
                .getLazyProvider(name, ServiceInstanceListSupplier.class),
            name);
    }
}

@Configuration
@LoadBalancerClient(name = "user-service", 
                   configuration = CustomLoadBalancerConfiguration.class)
public class UserServiceLoadBalancerConfig {
    // Configuration spécifique à user-service
}

// Ou via properties
spring.cloud.loadbalancer.configurations[user-service]=com.example.config.CustomLoadBalancerConfiguration

# Configuration du cache des instances
spring.cloud.loadbalancer.cache.enabled=true
spring.cloud.loadbalancer.cache.ttl=30s
spring.cloud.loadbalancer.cache.capacity=1000
spring.cloud.loadbalancer.cache.refresh-instances=true

# Cache spécifique par service
spring.cloud.loadbalancer.cache.configurations[user-service].ttl=60s
spring.cloud.loadbalancer.cache.configurations[user-service].capacity=500

# Configuration du refresh du cache
spring.cloud.loadbalancer.cache.refresh.enabled=true
spring.cloud.loadbalancer.cache.refresh.initial-delay=0s
spring.cloud.loadbalancer.cache.refresh.fixed-delay=30s
spring.cloud.loadbalancer.cache.refresh.use-refresh-timer=true

# Gestion des événements
spring.cloud.loadbalancer.cache.refresh.on-instance-change=true
spring.cloud.loadbalancer.cache.refresh.on-health-change=true

# Filtres par défaut
spring.cloud.loadbalancer.configurations.default.filters=healthy,zone

# Filtres personnalisés
spring.cloud.loadbalancer.configurations[user-service].filters=healthy,zone,metadata
spring.cloud.loadbalancer.configurations[user-service].filter.metadata.key=version
spring.cloud.loadbalancer.configurations[user-service].filter.metadata.value=v2

# Configuration des zones
spring.cloud.loadbalancer.configurations[user-service].filter.zone.prefer-same-zone=true
spring.cloud.loadbalancer.configurations[user-service].filter.zone.zone=us-east-1

@Component
public class VersionFilter implements Supplier<ServiceInstanceListSupplier> {
    
    private final ServiceInstanceListSupplier delegate;
    
    public VersionFilter(ServiceInstanceListSupplier delegate) {
        this.delegate = delegate;
    }
    
    @Override
    public Flux<List<ServiceInstance>> get() {
        return delegate.get().map(this::filterByVersion);
    }
    
    private List<ServiceInstance> filterByVersion(List<ServiceInstance> instances) {
        return instances.stream()
            .filter(instance -> {
                Map<String, String> metadata = instance.getMetadata();
                return "v2".equals(metadata.get("version"));
            })
            .collect(Collectors.toList());
    }
}

# Timeouts globaux
spring.cloud.loadbalancer.retry.max-attempts=3
spring.cloud.loadbalancer.retry.backoff.enabled=true
spring.cloud.loadbalancer.retry.backoff.first-backoff=100ms
spring.cloud.loadbalancer.retry.backoff.max-backoff=1000ms
spring.cloud.loadbalancer.retry.backoff.multiplier=2.0

# Timeouts par service
spring.cloud.loadbalancer.configurations[user-service].timeout.connect=5000ms
spring.cloud.loadbalancer.configurations[user-service].timeout.read=15000ms
spring.cloud.loadbalancer.configurations[user-service].timeout.write=10000ms

# Configuration des retry par service
spring.cloud.loadbalancer.configurations[user-service].retry.max-attempts=5
spring.cloud.loadbalancer.configurations[user-service].retry.retryable-status-codes=503,504,408

# Retry avancé
spring.cloud.loadbalancer.retry.retry-on-connection-failure=true
spring.cloud.loadbalancer.retry.retry-on-all-operations=false
spring.cloud.loadbalancer.retry.retryable-exceptions=java.net.ConnectException,java.net.SocketTimeoutException
spring.cloud.loadbalancer.retry.not-retryable-exceptions=org.springframework.web.client.HttpClientErrorException

# Configuration des politiques de retry
spring.cloud.loadbalancer.retry.policy=exponential
spring.cloud.loadbalancer.retry.jitter.enabled=true
spring.cloud.loadbalancer.retry.jitter.range=50ms

<!-- Hystrix -->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-netflix-hystrix</artifactId>
</dependency>

<!-- Load Balancer -->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-loadbalancer</artifactId>
</dependency>

<!-- WebClient -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-webflux</artifactId>
</dependency>

# Activer Hystrix
feign.hystrix.enabled=true

# Configuration LoadBalancer
spring.cloud.loadbalancer.retry.enabled=true
spring.cloud.loadbalancer.ribbon.enabled=false

# Configuration Hystrix
hystrix.command.default.execution.isolation.thread.timeoutInMilliseconds=5000
hystrix.command.default.circuitBreaker.requestVolumeThreshold=10
hystrix.command.default.circuitBreaker.errorThresholdPercentage=50

# Actuator endpoints
management.endpoints.web.exposure.include=hystrix.stream,health,info,metrics

@Configuration
public class WebClientConfig {
    
    @Bean
    @LoadBalanced
    public WebClient.Builder loadBalancedWebClientBuilder() {
        return WebClient.builder();
    }
}

@Service
public class UserServiceClient {
    
    private final WebClient webClient;
    
    public UserServiceClient(@LoadBalanced WebClient.Builder webClientBuilder) {
        this.webClient = webClientBuilder.build();
    }
    
    @HystrixCommand(
        fallbackMethod = "getUserFallback",
        commandProperties = {
            @HystrixProperty(name = "execution.isolation.thread.timeoutInMilliseconds", value = "3000"),
            @HystrixProperty(name = "circuitBreaker.requestVolumeThreshold", value = "5"),
            @HystrixProperty(name = "circuitBreaker.errorThresholdPercentage", value = "40")
        }
    )
    public Mono<User> getUser(Long userId) {
        return webClient
            .get()
            .uri("lb://user-service/users/{id}", userId)
            .retrieve()
            .bodyToMono(User.class);
    }
    
    public Mono<User> getUserFallback(Long userId) {
        logger.warn("Fallback activé pour l'utilisateur: " + userId);
        User fallbackUser = new User(userId, "Utilisateur par défaut", "fallback@example.com");
        return Mono.just(fallbackUser);
    }
}

@FeignClient(
    name = "user-service",
    configuration = UserServiceFeignConfig.class,
    fallback = UserServiceFallback.class
)
public interface UserServiceClient {
    
    @GetMapping("/users/{id}")
    User getUser(@PathVariable("id") Long id);
    
    @GetMapping("/users")
    List<User> getAllUsers();
    
    @PostMapping("/users")
    User createUser(@RequestBody User user);
}

@Configuration
public class UserServiceFeignConfig {
    
    @Bean
    public Logger.Level feignLoggerLevel() {
        return Logger.Level.BASIC;
    }
    
    @Bean
    public Retryer retryer() {
        return new Retryer.Default(1000, 2000, 3);
    }
    
    @Bean
    public Request.Options options() {
        return new Request.Options(5000, 10000); // connectTimeout, readTimeout
    }
}

# Activer Hystrix pour Feign
feign.hystrix.enabled=true

# Configuration des timeouts
feign.client.config.default.connect-timeout=5000
feign.client.config.default.read-timeout=10000

# Retry configuration
feign.retryer.max-attempts=3

# LoadBalancer
spring.cloud.loadbalancer.ribbon.enabled=false
spring.cloud.loadbalancer.retry.enabled=true

@Service
public class ResilientUserService {
    
    @HystrixCommand(
        fallbackMethod = "handleUserError",
        ignoreExceptions = {UserNotFoundException.class},
        commandProperties = {
            @HystrixProperty(name = "execution.isolation.thread.timeoutInMilliseconds", value = "3000"),
            @HystrixProperty(name = "circuitBreaker.requestVolumeThreshold", value = "10"),
            @HystrixProperty(name = "circuitBreaker.errorThresholdPercentage", value = "50"),
            @HystrixProperty(name = "circuitBreaker.sleepWindowInMilliseconds", value = "10000")
        }
    )
    public User getUser(Long userId) {
        try {
            return userServiceClient.getUser(userId);
        } catch (UserNotFoundException e) {
            // Cette exception est ignorée par Hystrix
            throw e;
        } catch (Exception e) {
            // Les autres exceptions déclenchent le fallback
            throw new RuntimeException(e);
        }
    }
    
    public User handleUserError(Long userId) {
        logger.error("Erreur critique lors de la récupération de l'utilisateur: " + userId);
        
        // Notification d'alerte
        alertService.sendAlert("Erreur service utilisateur pour ID: " + userId);
        
        // Retourner un utilisateur par défaut
        return new User(userId, "Utilisateur temporairement indisponible", "error@example.com");
    }
}

@Service
public class SmartUserServiceClient {
    
    private final WebClient webClient;
    private final LoadBalancerClient loadBalancerClient;
    
    public SmartUserServiceClient(
            @LoadBalanced WebClient.Builder webClientBuilder,
            LoadBalancerClient loadBalancerClient) {
        this.webClient = webClientBuilder.build();
        this.loadBalancerClient = loadBalancerClient;
    }
    
    @HystrixCommand(fallbackMethod = "getUserFallback")
    public Mono<User> getUserWithRetry(Long userId) {
        return webClient
            .get()
            .uri("lb://user-service/users/{id}", userId)
            .retrieve()
            .onStatus(HttpStatus::is5xxServerError, response -> {
                // Retry sur erreurs 5xx
                return Mono.error(new ServiceUnavailableException("Service utilisateur indisponible"));
            })
            .bodyToMono(User.class)
            .retryWhen(Retry.backoff(3, Duration.ofMillis(100))
                .filter(throwable -> throwable instanceof ServiceUnavailableException));
    }
    
    public Mono<User> getUserFallback(Long userId) {
        return Mono.just(new User(userId, "Utilisateur par défaut", "fallback@example.com"));
    }
}

# Configuration des métriques
management.endpoints.web.exposure.include=metrics,health,info,prometheus,hystrix.stream
management.endpoint.metrics.enabled=true
management.endpoint.prometheus.enabled=true

# Métriques spécifiques Hystrix
management.metrics.enable.hystrix=true
management.metrics.enable.loadbalancer=true

# Configuration des tags
management.metrics.tags.application=${spring.application.name}
management.metrics.tags.environment=${spring.profiles.active:default}

# Dépendance Prometheus
<dependency>
    <groupId>io.micrometer</groupId>
    <artifactId>micrometer-registry-prometheus</artifactId>
</dependency>

# Endpoint Prometheus
management.endpoints.web.exposure.include=prometheus
management.endpoint.prometheus.enabled=true

# Configuration avancée
management.metrics.distribution.percentiles-histogram.hystrix=true
management.metrics.distribution.percentiles.hystrix.command=0.5,0.9,0.95,0.99
management.metrics.distribution.sla.hystrix.command=1ms,5ms,10ms,50ms

# Configuration des seuils d'alerte
spring.cloud.loadbalancer.alerting.enabled=true
spring.cloud.loadbalancer.alerting.health-threshold=0.9
spring.cloud.loadbalancer.alerting.retry-threshold=0.1
spring.cloud.loadbalancer.alerting.latency-threshold=1000ms

# Notifications
spring.cloud.loadbalancer.alerting.notifications.enabled=true
spring.cloud.loadbalancer.alerting.notifications.channels=slack,email
spring.cloud.loadbalancer.alerting.notifications.slack.webhook-url=https://hooks.slack.com/services/YOUR/SLACK/WEBHOOK
spring.cloud.loadbalancer.alerting.notifications.email.to=admin@example.com

@Component
public class ResilienceAlerting {
    
    private static final Logger logger = LoggerFactory.getLogger(ResilienceAlerting.class);
    
    @EventListener
    public void handleHystrixMetrics(HystrixMetricsEvent event) {
        HystrixCommandMetrics metrics = event.getMetrics();
        
        // Vérifier les seuils d'alerte
        if (metrics.getHealthCounts().getErrorPercentage() > 50) {
            sendAlert("High error rate in Hystrix command: " + 
                     metrics.getCommandKey().name() + 
                     " - Error percentage: " + metrics.getHealthCounts().getErrorPercentage() + "%");
        }
        
        if (metrics.getCircuitBreaker().isOpen()) {
            sendAlert("Circuit breaker OPEN for command: " + metrics.getCommandKey().name());
        }
    }
    
    @EventListener
    public void handleLoadBalancerStats(LoadBalancerStatsEvent event) {
        LoadBalancerStats stats = event.getStats();
        
        // Vérifier les seuils d'alerte
        if (stats.getRetryRate() > 0.1) {
            sendAlert("High retry rate detected: " + stats.getRetryRate());
        }
        
        if (stats.getAverageLatency() > 1000) {
            sendAlert("High latency detected: " + stats.getAverageLatency() + "ms");
        }
        
        if (stats.getHealthyInstancesRatio() < 0.8) {
            sendAlert("Low healthy instances ratio: " + stats.getHealthyInstancesRatio());
        }
    }
    
    private void sendAlert(String message) {
        logger.warn("RESILIENCE_ALERT: " + message);
        // Implémentation d'envoi d'alerte (email, Slack, etc.)
        notificationService.sendNotification(message);
    }
}

# Exemple de dashboard Grafana pour Hystrix et LoadBalancer
# Panel 1: Taux de requêtes par service
rate(hystrix_command_execution_total[5m])

# Panel 2: Pourcentage d'erreurs
rate(hystrix_command_execution_total{status="failure"}[5m]) / 
rate(hystrix_command_execution_total[5m]) * 100

# Panel 3: Latence 95th percentile
histogram_quantile(0.95, sum(rate(hystrix_command_latency_execute_seconds_bucket[5m])) by (le, command))

# Panel 4: État du circuit breaker
hystrix_circuitbreaker_open_total

# Panel 5: Taux de retry LoadBalancer
rate(loadbalancer_retry_requests_total[5m])

// Exemple de test de load balancing
@SpringBootTest
class LoadBalancerTest {
    
    @Autowired
    private UserServiceClient userServiceClient;
    
    @Test
    void testLoadBalancingDistribution() {
        Set<String> hosts = new HashSet<>();
        
        // Effectuer plusieurs appels
        for (int i = 0; i < 100; i++) {
            User user = userServiceClient.getUserById(1L);
            hosts.add(user.getHost()); // Supposons que l'host est retourné
        }
        
        // Vérifier que plusieurs instances ont été utilisées
        assertThat(hosts.size()).isGreaterThan(1);
    }
    
    @Test
    void testFailover() {
        // Simuler la panne d'une instance
        // Vérifier que les requêtes sont routées vers d'autres instances
    }
}

package com.example.eurekaserver;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.server.EnableEurekaServer;

@SpringBootApplication
@EnableEurekaServer
public class EurekaServerApplication {
    public static void main(String[] args) {
        SpringApplication.run(EurekaServerApplication.class, args);
    }
}

# Port du serveur Eureka
server.port=8761

# Ne pas s'enregistrer auprès d'un autre serveur Eureka
eureka.client.register-with-eureka=false
# Ne pas récupérer le registre d'autres serveurs
eureka.client.fetch-registry=false
# URL par défaut pour le service Eureka
eureka.client.service-url.defaultZone=http://localhost:8761/eureka/

# Durées de rafraîchissement (en millisecondes)
eureka.server.eviction-interval-timer-in-ms=30000
eureka.instance.lease-renewal-interval-in-seconds=30
eureka.instance.lease-expiration-duration-in-seconds=90

package com.example.userservice;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.EnableEurekaClient;

@SpringBootApplication
@EnableEurekaClient
public class UserServiceApplication {
    public static void main(String[] args) {
        SpringApplication.run(UserServiceApplication.class, args);
    }
}

# Port du service utilisateur
server.port=8080

# Nom du service (doit être unique dans Eureka)
spring.application.name=user-service

# URL du serveur Eureka
eureka.client.service-url.defaultZone=http://localhost:8761/eureka/

# Configuration de l'instance
eureka.instance.prefer-ip-address=true
eureka.instance.instance-id=${spring.application.name}:${server.port}

# Actuator endpoints
management.endpoints.web.exposure.include=health,info

package com.example.userservice.controller;

import org.springframework.web.bind.annotation.*;

import java.util.Arrays;
import java.util.List;

@RestController
@RequestMapping("/users")
public class UserController {
    
    @GetMapping
    public List<String> getAllUsers() {
        return Arrays.asList("Jean Dupont", "Marie Martin", "Pierre Durand");
    }
    
    @GetMapping("/{id}")
    public String getUserById(@PathVariable Long id) {
        return "Utilisateur avec ID: " + id;
    }
    
    @PostMapping
    public String createUser(@RequestBody String user) {
        return "Utilisateur créé: " + user;
    }
}

package com.example.orderservice;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.EnableEurekaClient;

@SpringBootApplication
@EnableEurekaClient
public class OrderServiceApplication {
    public static void main(String[] args) {
        SpringApplication.run(OrderServiceApplication.class, args);
    }
}

# Port du service commande
server.port=8081

# Nom du service
spring.application.name=order-service

# URL du serveur Eureka
eureka.client.service-url.defaultZone=http://localhost:8761/eureka/

# Configuration de l'instance
eureka.instance.prefer-ip-address=true
eureka.instance.instance-id=${spring.application.name}:${server.port}

# Actuator endpoints
management.endpoints.web.exposure.include=health,info

package com.example.orderservice.controller;

import org.springframework.web.bind.annotation.*;

import java.util.Arrays;
import java.util.List;

@RestController
@RequestMapping("/orders")
public class OrderController {
    
    @GetMapping
    public List<String> getAllOrders() {
        return Arrays.asList("Commande #123", "Commande #456", "Commande #789");
    }
    
    @GetMapping("/user/{userId}")
    public List<String> getOrdersByUser(@PathVariable Long userId) {
        return Arrays.asList("Commande #123 pour utilisateur " + userId);
    }
    
    @PostMapping
    public String createOrder(@RequestBody String order) {
        return "Commande créée: " + order;
    }
}

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-openfeign</artifactId>
</dependency>

package com.example.userservice;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.EnableEurekaClient;
import org.springframework.cloud.openfeign.EnableFeignClients;

@SpringBootApplication
@EnableEurekaClient
@EnableFeignClients
public class UserServiceApplication {
    public static void main(String[] args) {
        SpringApplication.run(UserServiceApplication.class, args);
    }
}

package com.example.userservice.client;

import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;

import java.util.List;

@FeignClient(name = "order-service")
public interface OrderServiceClient {
    
    @GetMapping("/orders/user/{userId}")
    List<String> getOrdersByUserId(@PathVariable("userId") Long userId);
    
    @GetMapping("/orders")
    List<String> getAllOrders();
}

package com.example.userservice.controller;

import com.example.userservice.client.OrderServiceClient;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.util.Arrays;
import java.util.List;

@RestController
@RequestMapping("/users")
public class UserController {
    
    @Autowired
    private OrderServiceClient orderServiceClient;
    
    @GetMapping
    public List<String> getAllUsers() {
        return Arrays.asList("Jean Dupont", "Marie Martin", "Pierre Durand");
    }
    
    @GetMapping("/{id}")
    public String getUserById(@PathVariable Long id) {
        return "Utilisateur avec ID: " + id;
    }
    
    @GetMapping("/{userId}/orders")
    public List<String> getUserOrders(@PathVariable Long userId) {
        // Appel au service de commandes via Feign
        return orderServiceClient.getOrdersByUserId(userId);
    }
    
    @GetMapping("/all-orders")
    public List<String> getAllOrders() {
        // Appel au service de commandes pour toutes les commandes
        return orderServiceClient.getAllOrders();
    }
    
    @PostMapping
    public String createUser(@RequestBody String user) {
        return "Utilisateur créé: " + user;
    }
}

# Configuration des timeouts pour OpenFeign
feign.client.config.default.connect-timeout=5000
feign.client.config.default.read-timeout=10000

# Activation de la compression
feign.compression.request.enabled=true
feign.compression.response.enabled=true

# Configuration du retry
ribbon.MaxAutoRetries=1
ribbon.MaxAutoRetriesNextServer=1
ribbon.ConnectTimeout=3000
ribbon.ReadTimeout=10000

# Variables pour différents environnements
export SERVER_PORT=8080
export EUREKA_SERVER_URL=http://eureka1:8761/eureka/,http://eureka2:8761/eureka/
export JAVA_OPTS="-Xmx512m -Xms256m"

#!/bin/bash
# start-services.sh
echo "Démarrage du serveur Eureka..."
nohup java -jar eureka-server.jar > eureka.log 2>&1 &
sleep 10

echo "Démarrage des microservices..."
nohup java -jar user-service.jar > user-service.log 2>&1 &
nohup java -jar order-service.jar > order-service.log 2>&1 &

echo "Tous les services sont démarrés"