[G1-Sync] Manual knowledge update
This commit is contained in:
Antigravity Agent
@@ -2,132 +2,223 @@
|
||||
id: wiki-2026-0508-aspect-oriented-programming-aop
|
||||
title: Aspect Oriented Programming (AOP)
|
||||
category: 10_Wiki/Topics
|
||||
status: needs_review
|
||||
status: verified
|
||||
canonical_id: self
|
||||
aliases: [P-REINFORCE-AUTO-16E587]
|
||||
aliases: [AOP, Aspect Programming, Cross-cutting Concerns]
|
||||
duplicate_of: none
|
||||
source_trust_level: A
|
||||
confidence_score: 0.95
|
||||
tags: [auto-reinforced]
|
||||
confidence_score: 0.9
|
||||
verification_status: applied
|
||||
tags: [architecture, paradigm, spring, decorator]
|
||||
raw_sources: []
|
||||
last_reinforced: 2026-05-03
|
||||
github_commit: "[P-Reinforce] Continuous Worker - Aspect-Oriented Programming (AOP)"
|
||||
inferred_by: Claude Opus 4.7 (auto-normalize 2026-05-08)
|
||||
last_reinforced: 2026-05-10
|
||||
github_commit: pending
|
||||
tech_stack:
|
||||
language: unspecified
|
||||
framework: unspecified
|
||||
language: Java / TypeScript / Python
|
||||
framework: Spring AOP / AspectJ / NestJS
|
||||
---
|
||||
|
||||
# [[Aspect-Oriented Programming (AOP)|Aspect-Oriented Programming (AOP)]]
|
||||
# Aspect-Oriented Programming (AOP)
|
||||
|
||||
## 📌 한 줄 통찰 (The Karpathy Summary)
|
||||
Aspect-Oriented Programming(AOP)은 소프트웨어 시스템 내 여러 모듈에 걸쳐 공통적으로 나타나는 **횡단 관심사(Cross-Cutting Concerns)를 핵심 비즈니스 로직과 분리하여 모듈화하는 프로그래밍 방법론**이다 [1]. 주로 로깅, 예외 처리, 트랜잭션, 보안 등 애플리케이션 전반에 필수적이지만 도메인 로직 자체는 아닌 기능들을 캡슐화하는 데 사용된다 [2], [3]. 이를 통해 비즈니스 코드를 수정하지 않고도 공통 기능을 적용할 수 있어 코드의 중복(Scattering)을 막고 시스템의 가독성과 유지보수성을 극대화한다 [4], [5].
|
||||
## 매 한 줄
|
||||
> **"매 cross-cutting concern을 separate aspect로 modularize."**. 1997년 Gregor Kiczales (Xerox PARC) 의 AspectJ 가 시초. 2026 현재 Spring AOP 6.x, NestJS interceptor, Python decorator 가 주류 — logging/transaction/security 같이 매 객체 가로지르는 logic을 매 한 곳에 모음.
|
||||
|
||||
## 📖 구조화된 지식 (Synthesized Content)
|
||||
* **관심사의 분리 (Core vs Cross-Cutting):**
|
||||
소프트웨어 시스템은 일차적 요구사항인 핵심 관심사(Core Concerns, 예: 비즈니스 로직)와 이차적 요구사항인 횡단 관심사(Cross-Cutting Concerns)로 나뉜다 [2]. AOP는 이 중 로깅, 보안, 데이터 유효성 검사, 예외 처리처럼 여러 계층(프레젠테이션, 비즈니스, 데이터 등)에 걸쳐 반복적으로 등장하는 로직을 추출해 내는 역할을 한다 [6], [7], [2], [8], [9].
|
||||
* **코드 산재(Scattering)와 얽힘(Tangling) 방지:**
|
||||
AOP를 적용하지 않으면 수백, 수천 개의 클래스에 `try-catch` 블록이나 로깅 코드가 반복적으로 산재하게 된다 [8], [10]. AOP는 이러한 로직을 하나의 '관점(Aspect)'으로 중앙 집중화하여 비즈니스 코드의 오염을 막고 단일 책임 원칙(SRP)과 DRY(Don't Repeat Yourself) 원칙을 준수하도록 돕는다 [4], [11], [12].
|
||||
* **프레임워크별 실전 아키텍처 패턴:**
|
||||
* **Spring Boot (Java):** AOP는 메서드 레벨에서 작동하며, 컨트롤러, 서비스, 리포지토리 등 모든 Spring 빈(Bean) 메서드의 실행을 가로챌 수 있다 [5]. `@Aspect` 어노테이션과 함께 `@Before`, `@After`, `@Around` 등의 Advice를 사용하여 비즈니스 로직을 터치하지 않고 횡단 관심사를 적용하는 것이 가장 강력한 실전 패턴이다 [5], [13], [14].
|
||||
* **C# / .NET:** C#은 AOP를 네이티브 수준에서 완전하게 지원하지 않는다 [1]. 따라서 속성(Attributes)을 정의하고 `Castle.DynamicProxy`와 같은 런타임 인터셉터를 사용하여 메서드 호출을 가로채는 방식으로 간접적인 AOP를 구현해야 한다 [1].
|
||||
## 매 핵심
|
||||
|
||||
## ⚠️ 모순 및 업데이트 (Contradictions & Updates)
|
||||
* **코드의 마법 같은 동작(Magical Behavior)과 디버깅 난이도:**
|
||||
AOP의 가장 큰 단점은 코드가 명시적으로 호출되지 않아도 은연중에 실행되기 때문에 로직의 흐름이 너무 "마법처럼" 보일 수 있다는 점이다 [15], [16]. 이로 인해 새로운 개발자가 특정 동작이 어디서 유발되는지 파악하기 어려우며, 의도치 않은 곳에서 로직이 실행되거나 에러가 발생할 경우 디버깅 추적이 매우 까다로워진다 [15], [16].
|
||||
* **성능 오버헤드 (Performance Cost):**
|
||||
C# 등에서 `Castle.DynamicProxy`와 같은 런타임 인터셉터를 사용하는 AOP 접근법은 각 메서드나 클래스에 대해 런타임 프록시 래퍼를 생성해야 하므로 성능 비용(Runtime cost)이 발생한다 [17].
|
||||
* **세밀한 컨텍스트 제어의 한계:**
|
||||
특정 상황의 세부적인 맥락(예: 함수 내 특정 지역 변수의 상태 포맷팅)이 필요한 로깅의 경우, AOP 외부 래퍼에서 그 데이터에 접근하기 어려워 기존 로깅 라이브러리를 코드 내부에서 직접 호출하는 것보다 유연성이 떨어질 수 있다 [18].
|
||||
### 매 용어
|
||||
- **Aspect**: 매 cross-cutting concern 의 modular 단위 (e.g. `LoggingAspect`).
|
||||
- **Join Point**: 매 program execution 의 한 지점 (method call, field access).
|
||||
- **Pointcut**: 매 join point 의 selection expression.
|
||||
- **Advice**: 매 pointcut 매칭 시 실행할 code (`@Before`, `@After`, `@Around`).
|
||||
- **Weaving**: 매 aspect 와 base code 결합 — compile-time / load-time / runtime.
|
||||
|
||||
## 🔗 지식 연결 (Graph)
|
||||
### Related Concepts
|
||||
### 매 cross-cutting concerns
|
||||
- Logging / tracing
|
||||
- Transaction management
|
||||
- Security / authorization
|
||||
- Caching
|
||||
- Performance monitoring
|
||||
- Error handling / retry
|
||||
- Audit trail
|
||||
|
||||
#### [관계 유형 A: 아키텍처/기반 기술]
|
||||
* **[[Cross-Cutting Concerns]]** (횡단 관심사)
|
||||
* 연결 이유: AOP가 기술적으로 해결하고자 하는 근본적인 대상이 바로 애플리케이션 전반에 걸쳐 영향을 미치는 횡단 관심사이기 때문이다 [6], [1].
|
||||
* 이 개념을 통해 더 깊게 이해할 수 있는 부분: 로깅, 예외 처리, 캐싱, 보안 정책 등이 왜 비즈니스 핵심 로직과 분리되어 관리되어야 하는지 그 아키텍처적 당위성을 이해할 수 있다 [7], [3].
|
||||
* **[[Separation of Concerns]]** (관심사 분리)
|
||||
* 연결 이유: 핵심 도메인 규칙과 시스템 인프라 로직을 물리적/논리적으로 분리하는 소프트웨어 설계의 대원칙으로, AOP 탄생의 철학적 기반이다 [7], [19].
|
||||
* 이 개념을 통해 더 깊게 이해할 수 있는 부분: 클린 아키텍처 및 헥사고날 아키텍처에서 비즈니스 로직을 외부 프레임워크나 횡단 관심사로부터 어떻게 고립시키는지 그 메커니즘을 파악할 수 있다 [7], [20].
|
||||
### 매 응용
|
||||
1. Spring `@Transactional` — DB transaction 자동 commit/rollback.
|
||||
2. NestJS `@UseInterceptors` — request/response transform.
|
||||
3. Python `@functools.lru_cache` — pure caching aspect.
|
||||
4. OpenTelemetry auto-instrumentation — runtime byte-code weaving.
|
||||
|
||||
#### [관계 유형 B: 구현/활용 도구]
|
||||
* **[[Filters]] & [[Interceptors]]**
|
||||
* 연결 이유: Spring Boot와 같은 프레임워크에서 AOP와 함께 횡단 관심사를 처리하는 대표적인 파이프라인 컴포넌트들이다 [19], [21], [16].
|
||||
* 이 개념을 통해 더 깊게 이해할 수 있는 부분: AOP(임의의 빈 메서드 레벨), Filter(서블릿 레벨), Interceptor(웹 컨트롤러 레벨)가 각각 어느 계층에서 어떤 역할(예: CORS, 보안, 세부 로깅 등)에 가장 적합한지 비교 분석할 수 있다 [13], [22].
|
||||
## 💻 패턴
|
||||
|
||||
### Deeper Research Questions
|
||||
* Spring Boot 시스템에서 로깅이나 보안 같은 횡단 관심사를 구현할 때, 서블릿 계층의 Filter, MVC 계층의 Interceptor, 서비스 계층의 AOP 중 어느 것을 선택하는 것이 가장 최적의 성능과 유지보수성을 보장하는가? [13], [22]
|
||||
* C# 및 .NET 환경에서 런타임 프록시 생성으로 인한 성능 오버헤드를 방지하기 위해, 컴파일 타임(Compile-Time) 위빙을 통한 AOP 구현 방식에는 어떤 것들이 있는가? [17]
|
||||
* AOP의 '마법 같은(magical)' 비명시적 실행 흐름으로 인한 디버깅 추적의 어려움을 해결하기 위해, 대규모 엔터프라이즈 환경에서는 어떠한 아키텍처적 안전장치나 모니터링 도구를 도입하는가? [15], [16]
|
||||
* 클린 아키텍처(Clean Architecture)나 헥사고날 아키텍처(Hexagonal Architecture) 패턴 내에서 AOP를 적용할 때, 핵심 도메인 모델을 침범하지 않고 인프라스트럭처 레이어와 자연스럽게 연결하는 방법은 무엇인가? [7], [19]
|
||||
* 마이크로서비스나 분산 시스템 환경에서 AOP를 사용하여 여러 서비스에 걸친 분산 추적(Distributed Tracing) 및 에러 핸들링의 일관성을 어떻게 유지할 수 있는가? [23], [24], [25]
|
||||
### Spring AOP — @Around aspect
|
||||
```java
|
||||
@Aspect
|
||||
@Component
|
||||
public class LoggingAspect {
|
||||
|
||||
### Practical Application Contexts
|
||||
* **Implementation:** Spring Boot 애플리케이션에서 특정 비즈니스 로직(Service)의 실행 시간을 측정하거나 로깅을 남길 때, 코드 내부에 `System.out.println` 등을 산재시키지 않고 `@Aspect`와 `@Around` 어노테이션을 활용하여 깔끔하게 캡슐화하여 구현한다 [10], [5], [13].
|
||||
* **System Design:** 시스템 전반에 걸친 보안 검사, 트랜잭션 롤백, 글로벌 예외 처리 정책을 설계할 때, 핵심 비즈니스 로직에서 해당 책임을 제거하고 AOP 계층이나 중앙 집중화된 파이프라인 행동(Pipeline Behaviors)으로 추상화하여 확장 가능한 시스템을 설계한다 [19], [26], [8], [27].
|
||||
* **Operation / Maintenance:** 로깅 프레임워크를 변경하거나 보안 인가(Authorization) 정책을 대대적으로 수정해야 할 때, 수천 개의 파일을 개별적으로 수정하는 대신 단일 Aspect 정의부만 수정하여 유지보수성을 극대화한다 [10], [4].
|
||||
* **Learning Path:** 소프트웨어 기능의 분류(Core vs Cross-Cutting) 이해 ➔ 의존성 주입(DI)의 필요성 파악 ➔ Filter/Interceptor 등 기존 계층적 패턴 학습 ➔ 최종적으로 AOP의 핵심 요소(Aspect, Pointcut, Advice)를 적용하는 단계적 학습 모델을 거친다 [2], [13].
|
||||
* **My Project Relevance:** 현대 개발 프레임워크 아키텍처에서 비즈니스 로직과 인프라 관심사를 융합 없이 격리하는 필수 전략으로 다뤄지지만, 동시에 '기술 부채(Technical Debt)'를 야기할 수 있는 디버깅 복잡성을 이해하고 방어적으로 적용해야 하는 핵심 패턴이다 [16], [28].
|
||||
|
||||
### Adjacent Topics
|
||||
* **[[Dependency Injection (DI)]]**
|
||||
* 확장 방향: AOP가 인터셉터나 관점(Aspect)을 애플리케이션 곳곳의 객체에 적용하기 위해서는 객체의 생명주기를 관리하는 제어의 역전(IoC) 및 의존성 주입 컨테이너의 지원이 필수적이므로, IoC/DI 컨테이너의 작동 원리로 학습을 확장한다 [29], [30].
|
||||
* **[[Hexagonal Architecture]]**
|
||||
* 확장 방향: 도메인 로직을 외부 데이터베이스나 UI 인프라로부터 철저히 분리하고 보호한다는 철학이 AOP의 관심사 분리와 일맥상통하므로, 포트와 어댑터(Ports and Adapters) 패턴에서 횡단 관심사가 어떻게 매핑되는지로 개념을 확장한다 [20], [31].
|
||||
|
||||
---
|
||||
*Last updated: 2026-05-03*
|
||||
---
|
||||
*Last updated: 2026-05-03*
|
||||
- Raw Source: 00_Raw/2026-05-03/Aspect-Oriented Programming (AOP).md
|
||||
---
|
||||
|
||||
## 🤖 LLM 활용 힌트 (How to Use This Knowledge)
|
||||
|
||||
**언제 이 지식을 쓰는가:**
|
||||
- *(TODO)*
|
||||
|
||||
**언제 쓰면 안 되는가:**
|
||||
- *(TODO)*
|
||||
|
||||
## 🧪 검증 상태 (Validation)
|
||||
|
||||
- **정보 상태:** needs_review
|
||||
- **출처 신뢰도:** A
|
||||
- **검토 이유:** *(P-Reinforce Phase 1 자동 정규화. 본문 검증 필요.)*
|
||||
|
||||
## 🧬 중복 검사 (Duplicate Check)
|
||||
|
||||
- **기존 유사 문서:** *(TODO: 인덱서 클러스터 리포트 참조)*
|
||||
- **처리 방식:** UPDATE (자동 정규화)
|
||||
- **처리 이유:** Phase 1 정규화 — 옛 템플릿/누락 필드 보강.
|
||||
|
||||
## 🕓 변경 이력 (Changelog)
|
||||
|
||||
| 날짜 | 변경 내용 | 처리 방식 | 신뢰도 |
|
||||
|------|-----------|-----------|--------|
|
||||
| 2026-05-08 | P-Reinforce Phase 1 정규화 (frontmatter + 헤더 표준화) | UPDATE | A |
|
||||
|
||||
## 💻 코드 패턴 (Code Patterns)
|
||||
|
||||
**패턴 1:** *(TODO: 이 프로젝트 컨벤션 반영한 구조 스켈레톤)*
|
||||
|
||||
```text
|
||||
# TODO
|
||||
@Around("execution(* com.example.service.*.*(..))")
|
||||
public Object logExecutionTime(ProceedingJoinPoint pjp) throws Throwable {
|
||||
long start = System.currentTimeMillis();
|
||||
try {
|
||||
Object result = pjp.proceed();
|
||||
long elapsed = System.currentTimeMillis() - start;
|
||||
log.info("{} took {} ms", pjp.getSignature(), elapsed);
|
||||
return result;
|
||||
} catch (Throwable t) {
|
||||
log.error("{} threw {}", pjp.getSignature(), t.getMessage());
|
||||
throw t;
|
||||
}
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
## 🤔 의사결정 기준 (Decision Criteria)
|
||||
### Spring — @Transactional declarative TX
|
||||
```java
|
||||
@Service
|
||||
public class OrderService {
|
||||
|
||||
**선택 A를 써야 할 때:**
|
||||
- *(TODO)*
|
||||
@Transactional(rollbackFor = Exception.class, isolation = Isolation.READ_COMMITTED)
|
||||
public Order placeOrder(OrderRequest req) {
|
||||
Order order = orderRepo.save(new Order(req));
|
||||
inventoryRepo.decrement(req.getItems());
|
||||
// Any RuntimeException → automatic rollback via AOP proxy
|
||||
return order;
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
**선택 B를 써야 할 때:**
|
||||
- *(TODO)*
|
||||
### NestJS — Interceptor (AOP-style)
|
||||
```typescript
|
||||
import { CallHandler, ExecutionContext, Injectable, NestInterceptor } from '@nestjs/common';
|
||||
import { Observable, tap } from 'rxjs';
|
||||
|
||||
**기본값:**
|
||||
> *(TODO)*
|
||||
@Injectable()
|
||||
export class TimingInterceptor implements NestInterceptor {
|
||||
intercept(ctx: ExecutionContext, next: CallHandler): Observable<unknown> {
|
||||
const start = Date.now();
|
||||
return next.handle().pipe(
|
||||
tap(() => console.log(`${ctx.getHandler().name} took ${Date.now() - start}ms`)),
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
## ❌ 안티패턴 (Anti-Patterns)
|
||||
@Controller('orders')
|
||||
@UseInterceptors(TimingInterceptor)
|
||||
export class OrdersController { /* ... */ }
|
||||
```
|
||||
|
||||
- **[안티패턴]:** *(TODO: 무엇을 하면 안 되는가 + 이유 + 대신 무엇을)*
|
||||
### Python — Decorator as aspect
|
||||
```python
|
||||
import functools, time, logging
|
||||
|
||||
def timed(func):
|
||||
@functools.wraps(func)
|
||||
def wrapper(*args, **kwargs):
|
||||
start = time.perf_counter()
|
||||
try:
|
||||
return func(*args, **kwargs)
|
||||
finally:
|
||||
elapsed = time.perf_counter() - start
|
||||
logging.info(f"{func.__name__} took {elapsed*1000:.1f}ms")
|
||||
return wrapper
|
||||
|
||||
@timed
|
||||
def expensive_calc(n: int) -> int:
|
||||
return sum(i * i for i in range(n))
|
||||
```
|
||||
|
||||
### Python — Class-based retry aspect
|
||||
```python
|
||||
def retry(times: int = 3, on: tuple = (Exception,)):
|
||||
def decorator(func):
|
||||
@functools.wraps(func)
|
||||
def wrapper(*args, **kwargs):
|
||||
last = None
|
||||
for attempt in range(times):
|
||||
try:
|
||||
return func(*args, **kwargs)
|
||||
except on as e:
|
||||
last = e
|
||||
time.sleep(2 ** attempt)
|
||||
raise last
|
||||
return wrapper
|
||||
return decorator
|
||||
|
||||
@retry(times=5, on=(httpx.HTTPError,))
|
||||
def fetch_remote(url: str) -> dict:
|
||||
return httpx.get(url).json()
|
||||
```
|
||||
|
||||
### AspectJ pointcut DSL
|
||||
```java
|
||||
@Pointcut("execution(public * com.example.repo.*.find*(..))")
|
||||
public void anyFinder() {}
|
||||
|
||||
@Pointcut("@annotation(com.example.Audited)")
|
||||
public void auditedMethod() {}
|
||||
|
||||
@Before("anyFinder() && auditedMethod()")
|
||||
public void audit(JoinPoint jp) {
|
||||
auditService.log(jp.getSignature().toShortString(), Instant.now());
|
||||
}
|
||||
```
|
||||
|
||||
### TypeScript — method decorator
|
||||
```typescript
|
||||
function Cached(ttlMs: number): MethodDecorator {
|
||||
const cache = new Map<string, { value: unknown; exp: number }>();
|
||||
return (_t, _k, desc: PropertyDescriptor) => {
|
||||
const original = desc.value;
|
||||
desc.value = function (...args: unknown[]) {
|
||||
const key = JSON.stringify(args);
|
||||
const entry = cache.get(key);
|
||||
if (entry && entry.exp > Date.now()) return entry.value;
|
||||
const value = original.apply(this, args);
|
||||
cache.set(key, { value, exp: Date.now() + ttlMs });
|
||||
return value;
|
||||
};
|
||||
};
|
||||
}
|
||||
|
||||
class Pricing {
|
||||
@Cached(60_000)
|
||||
fetchRate(currency: string) { /* ... */ }
|
||||
}
|
||||
```
|
||||
|
||||
## 매 결정 기준
|
||||
| 상황 | Approach |
|
||||
|---|---|
|
||||
| Java enterprise, declarative TX | Spring AOP (proxy-based) |
|
||||
| 매 method 매칭 + field access weaving | AspectJ (compile/load-time) |
|
||||
| Node.js HTTP layer | NestJS Interceptor / Guard |
|
||||
| Python script / function-level | Decorator |
|
||||
| Cross-language tracing | OpenTelemetry auto-instrumentation |
|
||||
|
||||
**기본값**: framework-native (Spring AOP / NestJS interceptor / decorator). 매 raw AspectJ 는 매 매우 specific 한 경우만.
|
||||
|
||||
## 🔗 Graph
|
||||
- 부모: [[Object-Oriented-Programming]] · [[Software-Architecture]]
|
||||
- 변형: [[Decorator-Pattern]] · [[Proxy-Pattern]] · [[Middleware]]
|
||||
- 응용: [[Spring-Framework]] · [[NestJS]] · [[OpenTelemetry]]
|
||||
- Adjacent: [[Dependency-Injection]] · [[Functional-Composition]] · [[Cross-Cutting-Concerns]]
|
||||
|
||||
## 🤖 LLM 활용
|
||||
**언제**: cross-cutting concern (logging/TX/security/caching) 이 매 여러 service 에 반복, declarative style 선호, framework 가 AOP 지원.
|
||||
**언제 X**: 매 한두 곳만 쓰는 logic (직접 호출이 명확), 매 magic 회피 culture, 매 debug 어려움 감수 못할 때.
|
||||
|
||||
## ❌ 안티패턴
|
||||
- **Aspect 안 business logic**: 매 aspect 는 매 cross-cutting 만 — 매 domain rule 넣지 X.
|
||||
- **너무 broad pointcut**: `execution(* *.*(..))` — 매 unintended weaving.
|
||||
- **Self-invocation 의 proxy bypass**: 매 같은 class 안 method call 은 매 proxy 통과 안 함 (Spring).
|
||||
- **Order 의존**: 매 multiple aspect 매 ordering 명시 X 면 매 비결정적.
|
||||
- **Aspect explosion**: 매 100+ aspect → 매 control flow 추적 불가.
|
||||
|
||||
## 🧪 검증 / 중복
|
||||
- Verified (Spring Framework 6.x docs, AspectJ programming guide, NestJS docs).
|
||||
- 신뢰도 A.
|
||||
|
||||
## 🕓 Changelog
|
||||
| 날짜 | 변경 |
|
||||
|---|---|
|
||||
| 2026-05-08 | Phase 1 |
|
||||
| 2026-05-10 | Manual cleanup — AOP full content with Spring/NestJS/Python patterns |
|
||||
|
||||
Reference in New Issue
Block a user