From Java Developer
to Microservices Architect

# Every microservice adds these lines to register itself
spring:
  application:
    name: order-service    # ← THIS is the name others use to find you
eureka:
  client:
    service-url:
      defaultZone: http://eureka-server:8761/eureka/
  instance:
    prefer-ip-address: true
    lease-renewal-interval-in-seconds: 30  # heartbeat frequency
    lease-expiration-duration-in-seconds: 90

# Maven dependency needed:
# spring-cloud-starter-netflix-eureka-client

// Feign = declarative HTTP. Zero boilerplate. Looks like a local call!
@FeignClient(name = "inventory-service")  // name = Eureka registration name
public interface InventoryClient {

  @GetMapping("/api/inventory/{skuCode}")
  Boolean isInStock(@PathVariable String skuCode);

  @PostMapping("/api/inventory/reserve")
  ReserveResponse reserve(@RequestBody ReserveRequest request);
}

// Usage in OrderService — no URL, no IP, no port, no RestTemplate!
@Service
public class OrderService {
  @Autowired private InventoryClient inventoryClient;

  public Order placeOrder(OrderRequest request) {
    if (!inventoryClient.isInStock(request.getSkuCode())) {
      throw new OutOfStockException("Item not available");
    }
    // ... save order
  }
}

// Enable Feign in main class:
@EnableFeignClients

@Component
public class AuthFilter implements GlobalFilter, Ordered {

  @Autowired private JwtUtil jwtUtil;

  @Override
  public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
    String path = exchange.getRequest().getPath().toString();

    // Skip auth for public endpoints
    if (path.startsWith("/api/public")) {
      return chain.filter(exchange);
    }

    String authHeader = exchange.getRequest().getHeaders().getFirst("Authorization");
    if (authHeader == null || !authHeader.startsWith("Bearer ")) {
      exchange.getResponse().setStatusCode(HttpStatus.UNAUTHORIZED);
      return exchange.getResponse().setComplete();
    }

    String token = authHeader.substring(7);
    if (!jwtUtil.isValid(token)) {
      exchange.getResponse().setStatusCode(HttpStatus.UNAUTHORIZED);
      return exchange.getResponse().setComplete();
    }
    // Optionally forward userId to downstream services
    ServerHttpRequest mutated = exchange.getRequest().mutate()
      .header("X-User-Id", jwtUtil.extractUserId(token))
      .build();
    return chain.filter(exchange.mutate().request(mutated).build());
  }

  @Override public int getOrder() { return -1; }  // run first
}

@RestController
public class FallbackController {

  @GetMapping("/fallback/orders")
  public ResponseEntity<?> ordersFallback() {
    return ResponseEntity
      .status(HttpStatus.SERVICE_UNAVAILABLE)
      .body(Map.of(
        "status", "degraded",
        "message", "Order service temporarily unavailable. Try again shortly.",
        "timestamp", Instant.now()
      ));
  }

  @GetMapping("/fallback/payments")
  public ResponseEntity<?> paymentsFallback() {
    return ResponseEntity.accepted()
      .body(Map.of("message", "Payment queued. You'll receive confirmation via email."));
  }
}

# Spring Boot 2.x needs bootstrap.yml
# Spring Boot 3.x uses spring.config.import
spring:
  config:
    import: optional:configserver:http://config-server:8888
  application:
    name: order-service      # Config Server fetches order-service.yml from Git
  profiles:
    active: dev              # fetches order-service-dev.yml

# URL pattern served by Config Server:
# /{application}/{profile}  →  order-service/dev  →  order-service-dev.yml
# /{application}/{profile}/{label}  (label = git branch)

// 1. Annotate beans that use config values with @RefreshScope
@RefreshScope   // ← re-creates this bean when config changes
@RestController
public class OrderController {

  @Value("${order.max-items:10}")     // default value = 10
  private int maxItemsPerOrder;

  @Value("${feature.express-delivery:false}")
  private boolean expressDeliveryEnabled;
}

// 2. Update the value in Git repo
// 3. Call this endpoint — NO restart needed:
//    POST http://order-service:8081/actuator/refresh
// 4. @RefreshScope beans are recreated with new values ✅

# Enable in application.yml:
management:
  endpoints:
    web:
      exposure:
        include: refresh, health, info, metrics

config-repo/
├── application.yml              # shared by ALL services
├── order-service/
│   ├── order-service.yml        # order service defaults
│   ├── order-service-dev.yml    # dev profile overrides
│   └── order-service-prod.yml   # prod profile overrides
├── payment-service/
│   ├── payment-service.yml
│   └── payment-service-prod.yml
└── inventory-service/
    └── inventory-service.yml

# Profile precedence (highest to lowest):
# order-service-prod.yml  →  order-service.yml  →  application.yml

resilience4j:
  circuitbreaker:
    instances:
      paymentService:
        sliding-window-size: 10           # evaluate last 10 calls
        failure-rate-threshold: 50        # open if ≥50% fail
        wait-duration-in-open-state: 10s   # stay open 10 seconds
        permitted-number-of-calls-in-half-open-state: 3
        slow-call-rate-threshold: 80      # also open if 80% are slow
        slow-call-duration-threshold: 2s

  retry:
    instances:
      paymentService:
        max-attempts: 3
        wait-duration: 500ms
        retry-exceptions:
          - java.io.IOException
          - java.util.concurrent.TimeoutException

  timelimiter:
    instances:
      paymentService:
        timeout-duration: 3s               # fail fast after 3 seconds
        cancel-running-future: true

// BULKHEAD ANALOGY: Ship compartments — if one floods, ship doesn't sink
// Without bulkhead: slow Payment hogs ALL threads → Inventory calls also fail
// With bulkhead: Payment has its OWN pool → Inventory pool unaffected

@Bulkhead(name = "paymentService", type = Bulkhead.Type.THREADPOOL)
@CircuitBreaker(name = "paymentService", fallbackMethod = "paymentFallback")
public CompletableFuture<String> processPayment(Order order) {
  return CompletableFuture.supplyAsync(() -> paymentClient.charge(order));
}

# application.yml
resilience4j:
  thread-pool-bulkhead:
    instances:
      paymentService:
        max-thread-pool-size: 10       # Payment gets max 10 threads
        core-thread-pool-size: 5
        queue-capacity: 20
      inventoryService:
        max-thread-pool-size: 15      # Inventory gets its own pool
        core-thread-pool-size: 8

@Service
public class NotificationService {

  @KafkaListener(topics = "order-placed-topic", groupId = "notification-group")
  public void handleOrderPlaced(OrderEvent event) {
    // ⚠️ CRITICAL: Kafka guarantees at-least-once delivery.
    // The SAME message may arrive TWICE (e.g., after a consumer crash).
    // Your consumer MUST be idempotent!

    if (processedEventRepo.exists(event.getOrderId())) {
      log.info("Duplicate event, skipping: {}", event.getOrderId());
      return;  // already processed — idempotent check!
    }

    emailService.sendConfirmation(event.getUserId(), event.getOrderId());
    processedEventRepo.markProcessed(event.getOrderId());
  }
}

// InventoryService also consumes the same event, independently:
@KafkaListener(topics = "order-placed-topic", groupId = "inventory-group")
public void reserveStock(OrderEvent event) {
  inventoryService.reserve(event.getSkuCode(), event.getQuantity());
}

// RabbitMQ: better for task queues, complex routing
// Kafka: better for event streaming, high throughput, replay

// Producer
@Autowired private RabbitTemplate rabbitTemplate;

rabbitTemplate.convertAndSend("order.exchange", "order.placed", event);

// Consumer
@RabbitListener(queues = "order.notification.queue")
public void handleOrder(OrderEvent event) {
  emailService.send(event);
}

// Config
@Bean
public Queue orderQueue() { return new Queue("order.notification.queue"); }

@Bean
public TopicExchange exchange() { return new TopicExchange("order.exchange"); }

@Bean
public Binding binding(Queue q, TopicExchange e) {
  return BindingBuilder.bind(q).to(e).with("order.#");
}

spring:
  kafka:
    bootstrap-servers: localhost:9092
    producer:
      key-serializer: org.apache.kafka.common.serialization.StringSerializer
      value-serializer: org.springframework.kafka.support.serializer.JsonSerializer
      acks: all              # wait for all replicas before success
      retries: 3
    consumer:
      group-id: notification-group
      auto-offset-reset: earliest
      key-deserializer: org.apache.kafka.common.serialization.StringDeserializer
      value-deserializer: org.springframework.kafka.support.serializer.JsonDeserializer
      properties:
        spring.json.trusted.packages: "*"
        max.poll.records: 50

@Configuration
public class SecurityConfig {

  @Bean
  SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
    http
      .csrf(csrf -> csrf.disable())
      .sessionManagement(s -> s.sessionCreationPolicy(
        SessionCreationPolicy.STATELESS))       // No sessions with JWT!
      .authorizeHttpRequests(auth -> auth
        .requestMatchers("/api/public/**").permitAll()
        .requestMatchers("/api/admin/**").hasRole("ADMIN")
        .anyRequest().authenticated())
      .oauth2ResourceServer(oauth2 ->
        oauth2.jwt(jwt ->
          jwt.jwtAuthenticationConverter(jwtAuthenticationConverter())));
    return http.build();
  }
}

# application.yml — points to Keycloak / your Auth Server JWKS
spring:
  security:
    oauth2:
      resourceserver:
        jwt:
          jwk-set-uri: http://keycloak:8080/realms/myapp/protocol/openid-connect/certs

// Service-to-service: use OAuth2 Client Credentials grant
// No user. Service authenticates AS ITSELF to get a token.
// Spring Security OAuth2 Client handles this automatically with WebClient

@Bean
public WebClient paymentWebClient(OAuth2AuthorizedClientManager clientManager) {
  ServletOAuth2AuthorizedClientExchangeFilterFunction oauth2 =
    new ServletOAuth2AuthorizedClientExchangeFilterFunction(clientManager);
  oauth2.setDefaultClientRegistrationId("payment-service");
  return WebClient.builder()
    .baseUrl("http://payment-service")
    .apply(oauth2.oauth2Configuration())
    .build();
}

# application.yml — register as OAuth2 client
spring:
  security:
    oauth2:
      client:
        registration:
          payment-service:
            authorization-grant-type: client_credentials
            client-id: order-service
            client-secret: ${ORDER_SERVICE_SECRET}
        provider:
          payment-service:
            token-uri: http://keycloak:8080/realms/myapp/protocol/openid-connect/token