Refactor/#34 주차장 데이터 삽입 성능개선 및 외부 api 장애 발생시 처리 로직 추가

app-scheduler/src/main/java/com/parkingcomestrue/external/api/ApiCounter.java

@@ -0,0 +1,59 @@
+package com.parkingcomestrue.external.api;
+
+public class ApiCounter {
+
+    private final double MIN_TOTAL_COUNT;
+
+    private double totalCount;
+    private double errorCount;
+    private boolean isClosed;
+
+    public ApiCounter() {
+        this.MIN_TOTAL_COUNT = 10;
+        this.totalCount = 0;
+        this.errorCount = 0;
+        this.isClosed = false;
+    }
+
+    public ApiCounter(double minTotalCount) {
+        this.MIN_TOTAL_COUNT = minTotalCount;
+        this.totalCount = 0;
+        this.errorCount = 0;
+        this.isClosed = false;
+    }
+
+    public synchronized void countUp() {
+        totalCount++;
+    }
+
+    public synchronized void errorCountUp() {
+        totalCount++;
+        errorCount++;
+    }
+
+    public void reset() {
+        totalCount = 0;
+        errorCount = 0;
+        isClosed = false;
+    }
+
+    public boolean isClosed() {
+        return isClosed;
+    }
+
+    public void close() {
+        isClosed = true;
+    }
+
+    public boolean isErrorRateOverThan(double errorRate) {
+        if (totalCount < MIN_TOTAL_COUNT) {
+            return false;
+        }
+        double currentErrorRate = errorCount / totalCount;
+        return currentErrorRate >= errorRate;
+    }
+
+    public double getTotalCount() {
+        return totalCount;
+    }
+}

app-scheduler/src/main/java/com/parkingcomestrue/external/api/CircuitBreaker.java

@@ -0,0 +1,17 @@
+package com.parkingcomestrue.external.api;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+import java.util.concurrent.TimeUnit;
+
+@Retention(RetentionPolicy.RUNTIME)
+@Target(ElementType.METHOD)
+public @interface CircuitBreaker {
+
+    int minTotalCount() default 10;
+    double errorRate() default 0.2;
+    long resetTime() default 30;
+    TimeUnit timeUnit() default TimeUnit.MINUTES;
+}

app-scheduler/src/main/java/com/parkingcomestrue/external/api/CircuitBreakerAspect.java

@@ -0,0 +1,53 @@
+package com.parkingcomestrue.external.api;
+
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.Executors;
+import java.util.concurrent.ScheduledExecutorService;
+import lombok.extern.slf4j.Slf4j;
+import org.aspectj.lang.ProceedingJoinPoint;
+import org.aspectj.lang.annotation.Around;
+import org.aspectj.lang.annotation.Aspect;
+import org.springframework.stereotype.Component;
+
+@Slf4j
+@Aspect
+@Component
+public class CircuitBreakerAspect {
+
+    private final ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(10);
+    private final Map<Object, ApiCounter> map = new ConcurrentHashMap<>();
+
+    @Around("@annotation(annotation)")
+    public Object around(ProceedingJoinPoint proceedingJoinPoint, CircuitBreaker annotation) {
+        ApiCounter apiCounter = getApiCounter(proceedingJoinPoint, annotation.minTotalCount());
+        if (apiCounter.isClosed()) {
+            log.warn("현재 해당 {} API는 오류로 인해 중지되었습니다.", proceedingJoinPoint.getTarget());
+            return null;
+        }
+        try {
+            Object result = proceedingJoinPoint.proceed();
+            apiCounter.countUp();
+            return result;
+        } catch (Throwable e) {
+            handleError(annotation, apiCounter);
+            return null;
+        }
+    }
+
+    private ApiCounter getApiCounter(ProceedingJoinPoint proceedingJoinPoint, int minTotalCount) {
+        Object target = proceedingJoinPoint.getTarget();
+        if (!map.containsKey(target)) {
+            map.put(target, new ApiCounter(minTotalCount));
+        }
+        return map.get(target);
+    }
+
+    private void handleError(CircuitBreaker annotation, ApiCounter apiCounter) {
+        apiCounter.errorCountUp();
+        if (apiCounter.isErrorRateOverThan(annotation.errorRate())) {
+            apiCounter.close();
+            scheduler.schedule(apiCounter::reset, annotation.resetTime(), annotation.timeUnit());
+        }
+    }
+}

app-scheduler/src/test/java/com/parkingcomestrue/external/api/ApiCounterTest.java

@@ -0,0 +1,91 @@
+package com.parkingcomestrue.external.api;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import org.junit.jupiter.api.Test;
+
+class ApiCounterTest {
+
+    @Test
+    void 전체_요청이_최소_횟수를_넘고_예외가_특정_지수를_넘어가면_true를_반환한다() {
+        //given
+        ApiCounter apiCounter = new ApiCounter();
+
+        for (int i = 0; i < 8; i++) {
+            apiCounter.countUp();
+        }
+        for (int i = 0; i < 2; i++) {
+            apiCounter.errorCountUp();
+        }
+
+        //when
+        boolean actual = apiCounter.isErrorRateOverThan(0.2);
+
+        //then
+        assertThat(actual).isTrue();
+    }
+
+    @Test
+    void 여러_스레드에서도_전체_요청이_최소_횟수를_넘고_예외가_특정_지수를_넘어가면_true를_반환한다() throws InterruptedException {
+        //given
+        ExecutorService executorService = Executors.newFixedThreadPool(30);
+        ApiCounter apiCounter = new ApiCounter();
+        int threadCount = 1000;
+        CountDownLatch latch = new CountDownLatch(threadCount);
+
+        //when
+        for (int i = 0; i < threadCount; i++) {
+            if (i % 10 == 0 || i % 10 == 1) {
+                executorService.submit(() -> {
+                    try {
+                        apiCounter.errorCountUp();
+                    } finally {
+                        latch.countDown();
+                    }
+                });
+                continue;
+            }
+            executorService.submit(() -> {
+                try {
+                    apiCounter.countUp();
+                } finally {
+                    latch.countDown();
+                }
+            });
+        }
+
+        latch.await();
+        boolean actual = apiCounter.isErrorRateOverThan(0.2);
+
+        //then
+        assertThat(actual).isTrue();
+    }
+
+    @Test
+    void 여러_스레드에서_카운트를_증가시킬수있다() throws InterruptedException {
+        //given
+        ExecutorService executorService = Executors.newFixedThreadPool(30);
+        ApiCounter apiCounter = new ApiCounter();
+        int threadCount = 1000;
+        CountDownLatch latch = new CountDownLatch(threadCount);
+
+        //when
+        for (int i = 0; i < threadCount; i++) {
+            executorService.submit(() -> {
+                try {
+                    apiCounter.countUp();
+                } finally {
+                    latch.countDown();
+                }
+            });
+        }
+
+        latch.await();
+
+        //then
+        assertThat(apiCounter.getTotalCount()).isEqualTo(threadCount);
+    }
+}

app-scheduler/src/test/java/com/parkingcomestrue/external/api/CircuitBreakerAspectTest.java

@@ -0,0 +1,56 @@
+package com.parkingcomestrue.external.api;
+
+import com.parkingcomestrue.fake.CircuitBreakerTestService;
+import org.assertj.core.api.Assertions;
+import org.junit.jupiter.api.Test;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.context.SpringBootTest;
+
+@SpringBootTest
+class CircuitBreakerAspectTest {
+
+    /**
+     * 요청 중 20%의 예외가 발생하면 api 요청 잠김
+     * 잠긴 후, 2초 후에 다시 요청보내지도록 reset
+     */
+    @Autowired
+    private CircuitBreakerTestService service;
+
+    private boolean[] isExecuted = {false, false};
+    private final long SECOND = 1000;
+
+    @Test
+    void 서비스에_에러가_특정_지수를_넘으면_요청이_잠긴다() {
+        //given
+        for (int i = 0; i < 8; i++) {
+            service.call(() -> {});
+        }
+        for (int i = 0; i < 2; i++) {
+            service.call(() -> {throw new RuntimeException();});
+        }
+
+        //when
+        service.call(() -> {isExecuted[0] = true;});
+
+        //then
+        Assertions.assertThat(isExecuted[0]).isFalse();
+    }
+
+    @Test
+    void 서비스가_잠긴후_특정시간이_지나면_다시_요청을_보낼수있다() throws InterruptedException {
+        //given
+        for (int i = 0; i < 8; i++) {
+            service.call(() -> {});
+        }
+        for (int i = 0; i < 2; i++) {
+            service.call(() -> {throw new RuntimeException();});
+        }
+        Thread.sleep(2 * SECOND);
+
+        //when
+        service.call(() -> {isExecuted[1] = true;});
+
+        //then
+        Assertions.assertThat(isExecuted[1]).isTrue();
+    }
+}

app-scheduler/src/test/java/com/parkingcomestrue/fake/CircuitBreakerTestService.java

@@ -0,0 +1,14 @@
+package com.parkingcomestrue.fake;
+
+import com.parkingcomestrue.external.api.CircuitBreaker;
+import java.util.concurrent.TimeUnit;
+import org.springframework.stereotype.Service;
+
+@Service
+public class CircuitBreakerTestService {
+
+    @CircuitBreaker(resetTime = 2, timeUnit = TimeUnit.SECONDS)
+    public void call(Runnable runnable) {
+        runnable.run();
+    }
+}