[Design Patterns] 09. 프록시 패턴의 다면성

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

// 현실적인 문제 상황
public class DocumentViewer {
    public void openDocument(String filename) {
        // 문제점들:
        // 1. 큰 파일은 로딩이 오래 걸림 (지연 로딩 필요)
        // 2. 원격 서버의 파일도 있음 (네트워크 투명성 필요)
        // 3. 민감한 문서는 권한 확인 필요 (보안 제어 필요)
        // 4. 자주 쓰는 문서는 캐싱하고 싶음 (성능 최적화 필요)
        
        Document doc = new RealDocument(filename);
        if (doc.isLarge()) {
            // 로딩이 오래 걸림... 😞
        }
        if (doc.isRemote()) {
            // 네트워크 에러 처리... 😰
        }
        if (doc.isConfidential()) {
            // 권한 확인... 🔐
        }
        doc.display();
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63

   // Subject 인터페이스
   interface Image {
       void display();
       String getInfo();
   }
   
   // RealSubject - 실제 이미지
   class RealImage implements Image {
       private String filename;
       private byte[] imageData;
       
       public RealImage(String filename) {
           this.filename = filename;
           loadFromDisk(); // 비용이 큰 작업
       }
       
       private void loadFromDisk() {
           System.out.println("Loading image: " + filename);
           // 실제로는 디스크에서 이미지 로딩
           try {
               Thread.sleep(1000); // 로딩 시뮬레이션
               imageData = new byte[1024 * 1024]; // 1MB 이미지
           } catch (InterruptedException e) {
               Thread.currentThread().interrupt();
           }
       }
       
       @Override
       public void display() {
           System.out.println("Displaying image: " + filename);
       }
       
       @Override
       public String getInfo() {
           return "Real image: " + filename + " (Size: " + imageData.length + " bytes)";
       }
   }
   
   // Virtual Proxy
   class ImageProxy implements Image {
       private String filename;
       private RealImage realImage;
       
       public ImageProxy(String filename) {
           this.filename = filename;
       }
       
       @Override
       public void display() {
           if (realImage == null) {
               realImage = new RealImage(filename); // 지연 로딩
           }
           realImage.display();
       }
       
       @Override
       public String getInfo() {
           if (realImage == null) {
               return "Proxy image: " + filename + " (Not loaded yet)";
           }
           return realImage.getInfo();
       }
   }

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78

   import java.math.BigDecimal;
   import java.net.URI;
   import java.net.http.HttpClient;
   import java.net.http.HttpRequest;
   import java.net.http.HttpResponse;

   // 원격 서비스 인터페이스
   interface BankService {
       BigDecimal getBalance(String accountId);
       boolean transfer(String fromAccount, String toAccount, BigDecimal amount);
   }
   
   // 실제 원격 서비스 (서버에 위치)
   class RealBankService implements BankService {
       @Override
       public BigDecimal getBalance(String accountId) {
           // 실제 데이터베이스 조회
           return new BigDecimal("1000.00");
       }
       
       @Override
       public boolean transfer(String fromAccount, String toAccount, BigDecimal amount) {
           // 실제 송금 처리
           return true;
       }
   }
   
   // Remote Proxy (클라이언트에 위치)
   class BankServiceProxy implements BankService {
       private String serverUrl;
       private HttpClient httpClient;
       
       public BankServiceProxy(String serverUrl) {
           this.serverUrl = serverUrl;
           this.httpClient = HttpClient.newHttpClient();
       }
       
       @Override
       public BigDecimal getBalance(String accountId) {
           try {
               HttpRequest request = HttpRequest.newBuilder()
                   .uri(URI.create(serverUrl + "/balance/" + accountId))
                   .GET()
                   .build();
               
               HttpResponse<String> response = httpClient.send(request, 
                   HttpResponse.BodyHandlers.ofString());
               
               return new BigDecimal(response.body());
           } catch (Exception e) {
               throw new RuntimeException("Remote call failed", e);
           }
       }
       
       @Override
       public boolean transfer(String fromAccount, String toAccount, BigDecimal amount) {
           // HTTP POST 요청으로 송금 요청
           try {
               String jsonBody = String.format(
                   "{\"from\":\"%s\",\"to\":\"%s\",\"amount\":%s}",
                   fromAccount, toAccount, amount
               );
               
               HttpRequest request = HttpRequest.newBuilder()
                   .uri(URI.create(serverUrl + "/transfer"))
                   .header("Content-Type", "application/json")
                   .POST(HttpRequest.BodyPublishers.ofString(jsonBody))
                   .build();
               
               HttpResponse<String> response = httpClient.send(request,
                   HttpResponse.BodyHandlers.ofString());
               
               return response.statusCode() == 200;
           } catch (Exception e) {
               throw new RuntimeException("Remote transfer failed", e);
           }
       }
   }

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87

   // 민감한 정보를 다루는 서비스
   interface SecureDocument {
       String getContent();
       void updateContent(String content);
       void delete();
   }
   
   class ConfidentialDocument implements SecureDocument {
       private String content;
       private String filename;
       
       public ConfidentialDocument(String filename, String content) {
           this.filename = filename;
           this.content = content;
       }
       
       @Override
       public String getContent() {
           return content;
       }
       
       @Override
       public void updateContent(String content) {
           this.content = content;
           System.out.println("Document updated: " + filename);
       }
       
       @Override
       public void delete() {
           System.out.println("Document deleted: " + filename);
       }
   }
   
   // Protection Proxy
   class SecureDocumentProxy implements SecureDocument {
       private ConfidentialDocument realDocument;
       private User currentUser;
       private AuditLogger auditLogger;
       
       public SecureDocumentProxy(ConfidentialDocument document, User user) {
           this.realDocument = document;
           this.currentUser = user;
           this.auditLogger = new AuditLogger();
       }
       
       @Override
       public String getContent() {
           if (!hasReadPermission()) {
               throw new SecurityException("Read access denied");
           }
           auditLogger.log("Document accessed by: " + currentUser.getName());
           return realDocument.getContent();
       }
       
       @Override
       public void updateContent(String content) {
           if (!hasWritePermission()) {
               throw new SecurityException("Write access denied");
           }
           auditLogger.log("Document modified by: " + currentUser.getName());
           realDocument.updateContent(content);
       }
       
       @Override
       public void delete() {
           if (!hasDeletePermission()) {
               throw new SecurityException("Delete access denied");
           }
           auditLogger.log("Document deleted by: " + currentUser.getName());
           realDocument.delete();
       }
       
       private boolean hasReadPermission() {
           return currentUser.hasRole("READER") || 
                  currentUser.hasRole("WRITER") || 
                  currentUser.hasRole("ADMIN");
       }
       
       private boolean hasWritePermission() {
           return currentUser.hasRole("WRITER") || 
                  currentUser.hasRole("ADMIN");
       }
       
       private boolean hasDeletePermission() {
           return currentUser.hasRole("ADMIN");
       }
   }

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59

import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.TimeUnit;

// Subject 인터페이스
interface DataService {
    String fetchData(String key);
}

// RealSubject - 비용이 큰 조회를 수행하는 실제 서비스
class RealDataService implements DataService {
    @Override
    public String fetchData(String key) {
        simulateSlowIO(); // 실제로는 DB/외부 API 호출
        return "data-for-" + key;
    }

    private void simulateSlowIO() {
        try {
            Thread.sleep(200); // 200ms I/O 지연 시뮬레이션
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }
}

// Cache Proxy - 동일 키 재요청 시 캐시된 값을 반환
class CachingDataServiceProxy implements DataService {
    private static final long TTL_MILLIS = TimeUnit.SECONDS.toMillis(30);

    private final DataService realService;
    private final Map<String, CacheEntry> cache = new ConcurrentHashMap<>();

    public CachingDataServiceProxy(DataService realService) {
        this.realService = realService;
    }

    @Override
    public String fetchData(String key) {
        CacheEntry entry = cache.get(key);
        long now = System.currentTimeMillis();
        if (entry != null && (now - entry.timestamp) < TTL_MILLIS) {
            return entry.value; // 캐시 적중: 실제 객체 호출 생략
        }
        String value = realService.fetchData(key); // 캐시 미스: 실제 객체 호출
        cache.put(key, new CacheEntry(value, now));
        return value;
    }

    private static class CacheEntry {
        final String value;
        final long timestamp;

        CacheEntry(String value, long timestamp) {
            this.value = value;
            this.timestamp = timestamp;
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71

   import org.springframework.beans.factory.annotation.Autowired;
   import org.springframework.cache.Cache;
   import org.springframework.cache.CacheManager;
   import org.springframework.cache.annotation.Cacheable;
   import org.springframework.stereotype.Service;
   import org.springframework.transaction.PlatformTransactionManager;
   import org.springframework.transaction.TransactionDefinition;
   import org.springframework.transaction.TransactionStatus;
   import org.springframework.transaction.annotation.Transactional;
   import org.springframework.transaction.support.DefaultTransactionDefinition;
   import org.slf4j.Logger;
   import org.slf4j.LoggerFactory;

   @Service
   @Transactional
   public class UserService {
       @Autowired
       private UserRepository userRepository;
       
       @Cacheable("users")
       @LogExecutionTime
       public User findById(Long id) {
           return userRepository.findById(id);
       }
   }
   
   // Spring이 생성하는 동적 프록시 (의사코드 — 실제로는 CGLIB가 바이트코드로 생성하며,
   // 아래는 그 프록시가 수행하는 위빙(weaving) 순서를 사람이 읽을 수 있게 풀어 쓴 것)
   class UserService$Proxy extends UserService {
       private UserService target;
       private PlatformTransactionManager txManager;
       private CacheManager cacheManager;
       private Logger logger = LoggerFactory.getLogger(UserService.class);
       
       @Override
       public User findById(Long id) {
           // 1. 캐시 확인
           Cache cache = cacheManager.getCache("users");
           Cache.ValueWrapper wrapper = cache.get(id);
           User cached = wrapper != null ? (User) wrapper.get() : null;
           if (cached != null) return cached;
           
           // 2. 트랜잭션 시작
           TransactionDefinition txDef = new DefaultTransactionDefinition();
           TransactionStatus tx = txManager.getTransaction(txDef);
           
           // 3. 실행 시간 측정 시작
           long startTime = System.currentTimeMillis();
           
           try {
               // 4. 실제 메서드 호출
               User result = target.findById(id);
               
               // 5. 결과 캐싱
               cache.put(id, result);
               
               // 6. 트랜잭션 커밋
               txManager.commit(tx);
               
               return result;
           } catch (Exception e) {
               // 7. 트랜잭션 롤백
               txManager.rollback(tx);
               throw e;
           } finally {
               // 8. 실행 시간 로깅
               long executionTime = System.currentTimeMillis() - startTime;
               logger.info("Method execution time: {}ms", executionTime);
           }
       }
   }

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

   import java.lang.reflect.InvocationHandler;
   import java.lang.reflect.InvocationTargetException;
   import java.lang.reflect.Method;
   import java.lang.reflect.Proxy;

   // JDK Dynamic Proxy 사용
   public class ProxyFactory {
       public static <T> T createProxy(T target, Class<T> interfaceType) {
           return (T) Proxy.newProxyInstance(
               interfaceType.getClassLoader(),
               new Class[]{interfaceType},
               new InvocationHandler() {
                   @Override
                   public Object invoke(Object proxy, Method method, Object[] args) 
                           throws Throwable {
                       // Before advice
                       System.out.println("Before: " + method.getName());
                       long startTime = System.nanoTime();
                       
                       try {
                           // 실제 메서드 호출
                           Object result = method.invoke(target, args);
                           
                           // After advice
                           long endTime = System.nanoTime();
                           System.out.println("After: " + method.getName() + 
                               " (" + (endTime - startTime) + "ns)");
                           
                           return result;
                       } catch (InvocationTargetException e) {
                           // Exception advice
                           System.out.println("Exception in: " + method.getName());
                           throw e.getCause();
                       }
                   }
               }
           );
       }
   }

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80

// 성능 측정 결과 (나노초/operation)
/*
작업 유형           | 직접 호출 | JDK Proxy | CGLIB  | 오버헤드
단순 메서드         |   1ns    |   15ns   |  12ns  | 1200-1500%
복잡한 메서드       |  100ns   |  115ns   | 112ns  |    12-15%
네트워크 호출       |  50ms    |  50.1ms  | 50.1ms |     0.2%
데이터베이스 조회   |  10ms    |  10.05ms |10.05ms |     0.5%

결론:
- 단순한 메서드: Proxy 오버헤드가 상당함
- 복잡한 작업: 오버헤드가 상대적으로 미미함
- I/O 작업: 오버헤드가 거의 무시할 수준
- 실무에서는 대부분 복잡한 작업이므로 큰 문제 없음

※ 위 수치는 특정 환경에서 관찰될 수 있는 예시 값이며, JVM 워밍업·JIT 최적화·하드웨어에 따라 실제 측정치는 달라질 수 있습니다. 절대값보다 "작업이 가벼울수록 상대적 오버헤드가 커진다"는 경향성에 주목하세요.
*/

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

// 최적화된 Proxy 구현
public class OptimizedProxyFactory {
    
    // 캐시를 통한 성능 최적화
    private static final Map<Class<?>, Method[]> METHOD_CACHE = new ConcurrentHashMap<>();
    private static final Map<String, Class<?>> PROXY_CLASS_CACHE = new ConcurrentHashMap<>();
    
    public static <T> T createOptimizedProxy(T target, Class<T> interfaceType, 
                                           ProxyInterceptor interceptor) {
        // 1. 프록시 클래스 캐싱
        String cacheKey = interfaceType.getName() + "_" + interceptor.getClass().getName();
        Class<?> proxyClass = PROXY_CLASS_CACHE.computeIfAbsent(cacheKey, k -> 
            Proxy.getProxyClass(interfaceType.getClassLoader(), interfaceType)
        );
        
        // 2. 메서드 정보 캐싱
        Method[] methods = METHOD_CACHE.computeIfAbsent(interfaceType, Class::getDeclaredMethods);
        
        // 3. 최적화된 InvocationHandler
        InvocationHandler handler = new OptimizedInvocationHandler(target, interceptor, methods);
        
        try {
            return (T) proxyClass.getConstructor(InvocationHandler.class).newInstance(handler);
        } catch (Exception e) {
            throw new RuntimeException("Failed to create optimized proxy", e);
        }
    }
    
    private static class OptimizedInvocationHandler implements InvocationHandler {
        private final Object target;
        private final ProxyInterceptor interceptor;
        private final Method[] cachedMethods;
        
        public OptimizedInvocationHandler(Object target, ProxyInterceptor interceptor, Method[] methods) {
            this.target = target;
            this.interceptor = interceptor;
            this.cachedMethods = methods;
        }
        
        @Override
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
            // Object 메서드는 별도 처리
            if (method.getDeclaringClass() == Object.class) {
                return method.invoke(target, args);
            }
            
            // 인터셉터 적용
            return interceptor.intercept(target, method, args);
        }
    }
}

// 프록시 인터셉터 인터페이스
@FunctionalInterface
public interface ProxyInterceptor {
    Object intercept(Object target, Method method, Object[] args) throws Throwable;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58

import java.time.Duration;
import com.github.benmanes.caffeine.cache.Cache;
import com.github.benmanes.caffeine.cache.Caffeine;
import io.github.resilience4j.circuitbreaker.CircuitBreaker;
import org.springframework.stereotype.Component;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;
import reactor.core.scheduler.Schedulers;

// Reactive Streams와 Proxy 패턴의 조합
// 주의: 이 UserService는 앞선 "Spring AOP" 절의 동기(blocking) UserService와는
// 별개의 반응형(reactive) 인터페이스로, findById/findAll이 Mono/Flux를 반환한다고 가정한다.
public class ReactiveServiceProxy implements UserService {
    private final UserService target;
    private final CircuitBreaker circuitBreaker;
    private final Cache<String, User> cache;
    
    public ReactiveServiceProxy(UserService target) {
        this.target = target;
        this.circuitBreaker = CircuitBreaker.ofDefaults("userService");
        this.cache = Caffeine.newBuilder()
            .maximumSize(1000)
            .expireAfterWrite(Duration.ofMinutes(10))
            .build();
    }
    
    @Override
    public Mono<User> findById(String userId) {
        return Mono.fromSupplier(() -> cache.getIfPresent(userId))
            .switchIfEmpty(
                // 캐시 미스 시 실제 서비스 호출
                Mono.fromSupplier(() -> circuitBreaker.executeSupplier(() -> {
                    User user = target.findById(userId).block();
                    cache.put(userId, user);
                    return user;
                }))
                .subscribeOn(Schedulers.boundedElastic())
                .timeout(Duration.ofSeconds(5))
                .retry(2)
                .onErrorResume(throwable -> {
                    // 폴백 처리
                    return Mono.just(User.defaultUser(userId));
                })
            );
    }
    
    @Override
    public Flux<User> findAll() {
        return Flux.defer(() -> 
            Flux.fromIterable(target.findAll().collectList().block())
        )
        .subscribeOn(Schedulers.boundedElastic())
        .timeout(Duration.ofSeconds(10))
        .onErrorResume(throwable -> 
            Flux.just(User.defaultUser("error"))
        );
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

// Service Mesh와 Proxy 패턴 (개념 코드 — 실제 타입은 프로젝트마다 다름)
@Component
public class ServiceMeshProxy implements OrderService {
    private final LoadBalancer loadBalancer;
    private final MetricsCollector metricsCollector;
    private final DistributedTracing tracing;
    
    @Override
    public Order createOrder(OrderRequest request) {
        // 1. 분산 추적 시작
        Span span = tracing.nextSpan().name("create-order");
        
        try (Tracer.SpanInScope ws = tracing.tracer().withSpanInScope(span)) {
            // 2. 로드 밸런싱
            ServiceInstance instance = loadBalancer.choose("order-service");
            
            // 3. 메트릭 수집 시작
            Timer.Sample sample = Timer.start(metricsCollector.registry());
            
            // 4. 실제 서비스 호출
            Order result = invokeService(instance, request);
            
            // 5. 메트릭 기록
            sample.stop(metricsCollector.timer("order.create"));
            
            // 6. 추적 정보 추가
            span.tag("order.id", result.getId());
            span.tag("success", "true");
            
            return result;
            
        } catch (Exception e) {
            span.tag("error", e.getMessage());
            throw e;
        } finally {
            span.end();
        }
    }
}