마시멜로

WebClient.create("https://user-service")
         .get()
         .uri("/users/{id}", userId)
         .retrieve()
         .bodyToMono(UserDto.class)
         .timeout(Duration.ofSeconds(3))
         .retry(2)
         .subscribe(user -> log.info("사용자 정보: {}", user));

implementation 'org.springframework.boot:spring-boot-starter-webflux'
implementation 'io.github.resilience4j:resilience4j-spring-boot3'

resilience4j:
  circuitbreaker:
    instances:
      exchangeApi:
        registerHealthIndicator: true
        slidingWindowSize: 10
        failureRateThreshold: 50
        waitDurationInOpenState: 5s

  retry:
    instances:
      exchangeApi:
        maxAttempts: 3
        waitDuration: 1s
        retryExceptions:
          - java.io.IOException
          - org.springframework.web.reactive.function.client.WebClientRequestException

@Configuration
public class WebClientConfig {
    @Bean
    public WebClient exchangeWebClient() {
        return WebClient.builder()
                .baseUrl("https://api.exchangerate-api.com/v4/latest")
                .defaultHeader(HttpHeaders.CONTENT_TYPE, MediaType.APPLICATION_JSON_VALUE)
                .build();
    }
}

@Service
@RequiredArgsConstructor
public class ExchangeWebClientService {

    private final WebClient exchangeWebClient;

    @Retry(name = "exchangeApi")
    @CircuitBreaker(name = "exchangeApi", fallbackMethod = "fallbackExchangeRate")
    public Mono<BigDecimal> getExchangeRate(String currencyCode) {
        return exchangeWebClient
                .get()
                .uri("/" + currencyCode) // ex: /USD
                .retrieve()
                .bodyToMono(ExchangeRateResponse.class)
                .map(res -> res.getRates().get("KRW"));
    }

    // fallback 메서드 (Throwable을 마지막 파라미터로 받아야 함)
    public Mono<BigDecimal> fallbackExchangeRate(String currencyCode, Throwable t) {
        log.warn("Fallback triggered for {} due to {}", currencyCode, t.getMessage());
        return Mono.just(BigDecimal.ZERO); // 기본값 반환
    }
}

@Data
public class ExchangeRateResponse {
    private String base;
    private Map<String, BigDecimal> rates;
}

@Component
@RequiredArgsConstructor
public class ApiTestRunner implements CommandLineRunner {

    private final ExchangeWebClientService service;

    @Override
    public void run(String... args) {
        service.getExchangeRate("USD")
               .doOnNext(rate -> log.info("USD → KRW 환율: {}", rate))
               .subscribe();
    }
}

public interface ExchangeApiClient {
    BigDecimal getExchangeRate(String currencyCode);
}

implementation 'org.springframework.retry:spring-retry'
implementation 'org.springframework.boot:spring-boot-starter-aop'

@Configuration
public class RetryConfig {

    @Bean
    public RetryTemplate retryTemplate() {
        return RetryTemplate.builder()
                .maxAttempts(3)
                .fixedBackoff(1000)  // 1초 대기 후 재시도
                .retryOn(ResourceAccessException.class)
                .retryOn(HttpServerErrorException.class)
                .build();
    }
}

@Service
@RequiredArgsConstructor
public class ExchangeApiService implements ExchangeApiClient {

    private final RestTemplate restTemplate;
    private final RetryTemplate retryTemplate;

    @Override
    public BigDecimal getExchangeRate(String currencyCode) {
        return retryTemplate.execute(context -> {
            ResponseEntity<ExchangeRateResponse> response =
                restTemplate.getForEntity("https://api.example.com/exchange?code=" + currencyCode,
                                          ExchangeRateResponse.class);
            return response.getBody().getRate();
        });
    }
}

implementation 'io.github.resilience4j:resilience4j-spring-boot3'

resilience4j:
  circuitbreaker:
    instances:
      exchangeApi:
        registerHealthIndicator: true
        slidingWindowSize: 10
        failureRateThreshold: 50
        waitDurationInOpenState: 10s

@Service
@RequiredArgsConstructor
public class ExchangeApiServiceWithCB implements ExchangeApiClient {

    private final RestTemplate restTemplate;

    @CircuitBreaker(name = "exchangeApi", fallbackMethod = "fallbackRate")
    public BigDecimal getExchangeRate(String currencyCode) {
        ResponseEntity<ExchangeRateResponse> response =
            restTemplate.getForEntity("https://api.example.com/exchange?code=" + currencyCode,
                                      ExchangeRateResponse.class);
        return response.getBody().getRate();
    }

    // 실패 시 실행되는 fallback
    public BigDecimal fallbackRate(String currencyCode, Throwable t) {
        log.warn("Fallback for currency {} due to {}", currencyCode, t.getMessage());
        return BigDecimal.ZERO;  // 기본값 또는 캐시 사용
    }
}

@Retry(name = "exchangeApi")
@CircuitBreaker(name = "exchangeApi", fallbackMethod = "fallbackRate")
public BigDecimal getExchangeRate(String currencyCode) { ... }

+---------------------------+
|          Heap            |
+---------------------------+
| Eden | Survivor | Old    |
|      | (S0/S1)  |        |
+---------------------------+

1. 객체 생성 → Eden
2. GC 발생 시 Eden → Survivor 이동
3. Survivor에서 살아남으면 → Old 영역으로 이동
4. Old 영역 가득 차면 → Mixed GC (Young + Old) 또는 Full GC

-XX:+UseG1GC \
-XX:MaxGCPauseMillis=200 \
-XX:G1HeapRegionSize=8m \
-XX:InitiatingHeapOccupancyPercent=45

// 예: 고객 주문 저장 로직
insertOrder();        // 주문 마스터
insertOrderItems();   // 주문 상세
updateStock();        // 재고 차감

try {
    insert();   // AutoCommit됨
    update();   // 여기서 실패
} catch (Exception e) {
    // rollback(); ← rollback 불가. 이미 insert는 반영됨
}

public interface UserRepository extends JpaRepository<User, Long> {

    @Transactional
    @Modifying
    @Query("DELETE FROM User u WHERE u.status = 'INACTIVE'")
    int deleteInactiveUsers();
}

public interface ItemRepositoryCustom {
    String saveItems(List<ITEM_Dto> list);
}

@Repository
@RequiredArgsConstructor
public class ItemRepositoryCustomImpl implements ItemRepositoryCustom {

    private final ProcedureCallService procedureCallService;
    private final Util util;

    @Override
    @Transactional
    public String saveItems(List<ITEM_Dto> list) {
        for (USP_IN_ITEM_ITEM_Dto dto : list) {
            procedureCallService.call_IN_ITEM_INS(
                dto.getCompanyId(),
                "Item",
                LocalDateTime.now(),
                dto.getInType(),
                dto.getAsAgentId(),
                dto.getItemId(),
                dto.getGoodQty(),
                dto.getRecycleQty(),
                dto.getBadQty(),
                0,
                dto.getDescription(),
                util.getLoginUserId(),
                "",
                0
            );
        }
        return "등록 완료";
    }
}

// greet.proto
syntax = "proto3";

package greet;

service GreeterService {
  rpc SayHello (HelloRequest) returns (HelloResponse);
}

message HelloRequest {
  string name = 1;
}

message HelloResponse {
  string message = 1;
}

@GRpcService
public class GreeterServiceImpl extends GreeterServiceGrpc.GreeterServiceImplBase {
    @Override
    public void sayHello(HelloRequest request, StreamObserver<HelloResponse> responseObserver) {
        HelloResponse response = HelloResponse.newBuilder()
                .setMessage("Hello, " + request.getName())
                .build();
        responseObserver.onNext(response);
        responseObserver.onCompleted();
    }
}

ManagedChannel channel = ManagedChannelBuilder.forAddress("localhost", 9090).usePlaintext().build();
GreeterServiceGrpc.GreeterServiceBlockingStub stub = GreeterServiceGrpc.newBlockingStub(channel);

HelloRequest request = HelloRequest.newBuilder().setName("World").build();
HelloResponse response = stub.sayHello(request);
System.out.println(response.getMessage());

class GreeterServiceImpl : GreeterServiceCoroutineImplBase() {
    override suspend fun sayHello(request: HelloRequest): HelloResponse {
        return HelloResponse.newBuilder()
            .setMessage("Hello, ${request.name}")
            .build()
    }
}

val channel = ManagedChannelBuilder.forAddress("localhost", 9090).usePlaintext().build()
val stub = GreeterServiceCoroutineStub(channel)

val response = stub.sayHello(HelloRequest.newBuilder().setName("Kotlin").build())
println(response.message)

@GrpcMethod('GreeterService', 'SayHello')
sayHello(data: { name: string }): { message: string } {
  return { message: `Hello, ${data.name}` };
}

ClientsModule.register([
  {
    name: 'GREETER_PACKAGE',
    transport: Transport.GRPC,
    options: {
      package: 'greet',
      protoPath: join(__dirname, './proto/greet.proto'),
    },
  },
])

@Injectable()
export class GreetService {
  constructor(@Inject('GREETER_PACKAGE') private client: ClientGrpc) {}

  private greeterService: any;

  onModuleInit() {
    this.greeterService = this.client.getService('GreeterService');
  }

  async greet(name: string) {
    const res = await lastValueFrom(this.greeterService.SayHello({ name }));
    return res.message;
  }
}

예시: NestJS CI

jobs:
  build:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v2
      - name: Install dependencies
        run: npm install
      - name: Run tests
        run: npm run test
      - name: Build
        run: npm run build

├── api-gateway
├── auth-service
├── user-service
├── product-service
├── config-server
├── discovery-server (Eureka)

├── apps/
│   ├── gateway
│   ├── auth
│   ├── user
│   └── payment
├── libs/
│   ├── common
│   └── interfaces

val consumer = KafkaConsumer<String, String>(props)
consumer.subscribe(listOf("topic"))

ClientsModule.register([
  {
    name: 'KAFKA_SERVICE',
    transport: Transport.KAFKA,
    options: {
      client: {
        brokers: ['localhost:9092'],
      },
    },
  },
])

@RestController
@RequestMapping("/api")
public class GreetController {
    @GetMapping("/greet")
    public String greet(@RequestParam String name) {
        return "Hello, " + name + "!";
    }
}

routing {
    get("/greet") {
        val name = call.parameters["name"] ?: "World"
        call.respondText("Hello, $name!")
    }
}

@Controller('api')
export class GreetController {
  @Get('greet')
  greet(@Query('name') name: string): string {
    return `Hello, ${name || 'World'}!`;
  }
}