템플릿 메서드 패턴 - 백엔드 처리 골격을 강제하는 가장 오래되고 가장 위험한 패턴

public abstract class ExternalApiTemplate<REQ, RES> {
 
    private static final Logger log = LoggerFactory.getLogger(ExternalApiTemplate.class);
 
    private final RestClient restClient;
    private final MeterRegistry meterRegistry;
 
    protected ExternalApiTemplate(RestClient restClient, MeterRegistry meterRegistry) {
        this.restClient = restClient;
        this.meterRegistry = meterRegistry;
    }
 
    public final RES execute(REQ request) {
        validate(request);
        HttpHeaders headers = buildHeaders(request);
        Object payload = buildPayload(request);
 
        Timer.Sample sample = Timer.start(meterRegistry);
        try {
            String raw = restClient.post()
                    .uri(endpoint(request))
                    .headers(h -> h.addAll(headers))
                    .body(payload)
                    .retrieve()
                    .body(String.class);
 
            RES response = parseResponse(raw);
            verifyBusinessResult(response);
            return response;
        } catch (RestClientResponseException e) {
            throw translateHttpError(e);
        } catch (ExternalBusinessException e) {
            throw e;
        } catch (Exception e) {
            throw new ExternalCallFailedException(channelName(), e);
        } finally {
            sample.stop(meterRegistry.timer("external.api", "channel", channelName()));
        }
    }
 
    protected abstract String channelName();
    protected abstract String endpoint(REQ request);
    protected abstract HttpHeaders buildHeaders(REQ request);
    protected abstract Object buildPayload(REQ request);
    protected abstract RES parseResponse(String raw);
 
    protected void validate(REQ request) {
        if (request == null) {
            throw new IllegalArgumentException("request must not be null");
        }
    }
 
    protected void verifyBusinessResult(RES response) {
        // 기본은 통과. 채널마다 응답 코드 검증 다르므로 훅으로 둠
    }
 
    protected RuntimeException translateHttpError(RestClientResponseException e) {
        return new ExternalCallFailedException(channelName(), e);
    }
}

@Component
public class TossPaymentClient extends ExternalApiTemplate<PayRequest, PayResponse> {
 
    public TossPaymentClient(RestClient tossRestClient, MeterRegistry meterRegistry) {
        super(tossRestClient, meterRegistry);
    }
 
    @Override protected String channelName() { return "toss"; }
 
    @Override protected String endpoint(PayRequest request) {
        return "/v1/payments/" + request.paymentKey();
    }
 
    @Override protected HttpHeaders buildHeaders(PayRequest request) {
        HttpHeaders h = new HttpHeaders();
        h.setBasicAuth(request.secretKey(), "");
        h.setContentType(MediaType.APPLICATION_JSON);
        return h;
    }
 
    @Override protected Object buildPayload(PayRequest request) {
        return Map.of("orderId", request.orderId(), "amount", request.amount());
    }
 
    @Override protected PayResponse parseResponse(String raw) {
        return JsonUtils.read(raw, PayResponse.class);
    }
 
    @Override protected void verifyBusinessResult(PayResponse response) {
        if (!"DONE".equals(response.status())) {
            throw new ExternalBusinessException("toss", response.code(), response.message());
        }
    }
}

public abstract class BatchJobTemplate<ITEM> {
 
    private static final Logger log = LoggerFactory.getLogger(BatchJobTemplate.class);
 
    private final TransactionTemplate tx;
 
    protected BatchJobTemplate(TransactionTemplate tx) {
        this.tx = tx;
    }
 
    public final BatchResult run(BatchContext ctx) {
        beforeJob(ctx);
        int processed = 0;
        int failed = 0;
        try {
            int page = 0;
            while (true) {
                List<ITEM> chunk = readChunk(ctx, page);
                if (chunk.isEmpty()) break;
 
                for (ITEM item : chunk) {
                    try {
                        tx.executeWithoutResult(status -> {
                            ITEM processedItem = process(item);
                            write(processedItem);
                        });
                        processed++;
                    } catch (Exception e) {
                        failed++;
                        onItemFailed(item, e);
                        if (!continueOnError(e)) throw e;
                    }
                }
                page++;
            }
            return new BatchResult(processed, failed);
        } finally {
            afterJob(ctx, processed, failed);
        }
    }
 
    protected abstract List<ITEM> readChunk(BatchContext ctx, int page);
    protected abstract ITEM process(ITEM item);
    protected abstract void write(ITEM item);
 
    protected void beforeJob(BatchContext ctx) {}
    protected void afterJob(BatchContext ctx, int processed, int failed) {}
    protected void onItemFailed(ITEM item, Exception e) {
        log.warn("batch item failed", e);
    }
    protected boolean continueOnError(Exception e) {
        return e instanceof RecoverableBatchException;
    }
}

public abstract class OrderHandler {
    public Result handle(Command cmd) {
        validate(cmd);
        Result r = process(cmd);
        save(r);
        publish(r);
        return r;
    }
    protected abstract void validate(Command cmd);
    protected abstract Result process(Command cmd);
    protected abstract void save(Result r);
    protected abstract void publish(Result r);
}

public abstract class OrderHandler<C extends Command, R> {
 
    public final R handle(C cmd) {
        validate(cmd);
        R result = process(cmd);
        persist(result);
        if (shouldPublish(result)) {
            publish(result);
        }
        return result;
    }
 
    protected void validate(C cmd) {
        Objects.requireNonNull(cmd, "command");
    }
 
    protected abstract R process(C cmd);
    protected abstract void persist(R result);
 
    protected boolean shouldPublish(R result) { return true; }
    protected void publish(R result) {}
}

dependencies {
    testImplementation 'org.junit.jupiter:junit-jupiter:5.10.0'
    testImplementation 'org.assertj:assertj-core:3.24.2'
}

package lab;
 
import java.io.BufferedReader;
import java.io.IOException;
import java.io.Reader;
import java.util.ArrayList;
import java.util.List;
 
public abstract class LineBasedParser<T> {
 
    public final List<T> parse(Reader reader) {
        List<T> result = new ArrayList<>();
        try (BufferedReader br = new BufferedReader(reader)) {
            beforeParse();
            String line;
            int lineNo = 0;
            while ((line = br.readLine()) != null) {
                lineNo++;
                if (shouldSkip(line, lineNo)) continue;
                try {
                    T item = parseLine(line, lineNo);
                    if (item != null) result.add(item);
                } catch (Exception e) {
                    onParseError(line, lineNo, e);
                }
            }
            afterParse(result);
            return result;
        } catch (IOException e) {
            throw new ParseFailedException(e);
        }
    }
 
    protected abstract T parseLine(String line, int lineNo);
 
    protected boolean shouldSkip(String line, int lineNo) {
        return line.isBlank();
    }
 
    protected void beforeParse() {}
    protected void afterParse(List<T> items) {}
 
    protected void onParseError(String line, int lineNo, Exception e) {
        throw new ParseFailedException("line " + lineNo + ": " + line, e);
    }
 
    public static class ParseFailedException extends RuntimeException {
        public ParseFailedException(String msg, Throwable cause) { super(msg, cause); }
        public ParseFailedException(Throwable cause) { super(cause); }
    }
}

package lab;
 
public class CsvUserParser extends LineBasedParser<User> {
 
    private boolean headerSeen = false;
 
    @Override
    protected boolean shouldSkip(String line, int lineNo) {
        if (super.shouldSkip(line, lineNo)) return true;
        if (!headerSeen) { headerSeen = true; return true; }
        return false;
    }
 
    @Override
    protected User parseLine(String line, int lineNo) {
        String[] cols = line.split(",", -1);
        if (cols.length < 3) {
            throw new IllegalArgumentException("expected 3 cols, got " + cols.length);
        }
        return new User(Long.parseLong(cols[0].trim()), cols[1].trim(), cols[2].trim());
    }
}

package lab;
 
import org.junit.jupiter.api.Test;
 
import java.io.StringReader;
import java.util.List;
 
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatThrownBy;
 
class CsvUserParserTest {
 
    @Test
    void skipsHeaderAndBlankLines() {
        String csv = "id,name,email\n1,kim,kim@a.com\n\n2,lee,lee@b.com\n";
        List<User> users = new CsvUserParser().parse(new StringReader(csv));
        assertThat(users).extracting(User::name).containsExactly("kim", "lee");
    }
 
    @Test
    void invalidLineThrowsByDefault() {
        String csv = "id,name,email\nbroken-line\n";
        assertThatThrownBy(() -> new CsvUserParser().parse(new StringReader(csv)))
                .isInstanceOf(LineBasedParser.ParseFailedException.class);
    }
}