Spring AOP로 로깅과 트랜잭션 관리를 쉽게 해보자! 🚀

안녕, 친구들! 오늘은 정말 재밌고 유용한 주제를 가지고 왔어. 바로 Spring AOP를 활용한 로깅과 트랜잭션 관리야. 이게 뭔 소리냐고? 걱정 마! 지금부터 차근차근 설명해줄게. 😉

우리가 프로그램을 개발할 때, 특히 Java를 사용해서 웹 애플리케이션을 만들 때 자주 마주치는 문제들이 있어. 그 중에서도 로깅(기록 남기기)이랑 트랜잭션 관리(데이터 처리 과정 관리)는 정말 중요하지만, 매번 코드에 일일이 넣기는 귀찮고 힘들지? 그래서 우리의 영웅 Spring AOP가 등장한 거야! 👏

잠깐! AOP가 뭐냐고? AOP는 'Aspect-Oriented Programming'의 약자로, 우리말로 하면 '관점 지향 프로그래밍'이야. 뭔가 어려워 보이지? 걱정 마, 곧 자세히 설명할 테니까!

이 글을 다 읽고 나면, 너도 Spring AOP를 사용해서 로깅이랑 트랜잭션 관리를 쉽게 할 수 있을 거야. 마치 재능넷에서 새로운 재능을 배우는 것처럼 말이야! 그럼 이제 본격적으로 시작해볼까? 🎉

1. AOP, 그게 뭐야? 🤔

자, 이제 AOP에 대해 자세히 알아볼 시간이야. AOP는 우리가 프로그램을 만들 때 자주 사용하는 기능들을 쉽게 관리할 수 있게 해주는 멋진 방법이야. 예를 들어, 로그를 남기는 것처럼 여러 곳에서 반복되는 코드를 한 곳에서 관리할 수 있게 해주지.

💡 AOP의 핵심 개념:

Aspect: 여러 곳에서 사용되는 기능을 모듈화한 것
Advice: 실제로 수행할 동작
Pointcut: Advice가 적용될 위치
Join Point: 프로그램 실행 중 Aspect가 적용될 수 있는 지점

이렇게 보면 좀 어려워 보이지? 걱정 마, 우리 함께 예시를 통해 이해해보자!

🌟 AOP 이해하기: 카페 주문 시스템

우리가 카페에서 음료를 주문하는 상황을 생각해보자. 주문 과정은 대략 이렇게 진행돼:

손님이 주문을 한다.
바리스타가 음료를 만든다.
손님에게 음료를 건넨다.

그런데 여기에 몇 가지 추가 작업이 필요해:

주문 내역을 기록한다. (로깅)
결제 처리를 한다. (트랜잭션)

이런 작업들은 모든 주문에 대해 똑같이 적용되어야 해. 그런데 매번 주문 처리 코드에 이런 내용을 넣으면 어떨까? 코드가 복잡해지고 관리하기 어려워질 거야.

여기서 AOP의 등장이야! AOP를 사용하면 이런 공통 작업들을 따로 모아서 관리할 수 있어. 마치 카페에서 주문 접수, 음료 제조, 결제를 각각 다른 직원이 담당하는 것처럼 말이야.

🎭 AOP 적용 예시:

Aspect: 주문 처리 (OrderProcessingAspect)
Advice: 로깅, 결제 처리
Pointcut: 주문 메소드 (order())
Join Point: 주문 메소드가 실행되는 시점

이렇게 AOP를 사용하면, 주문 처리 로직은 그대로 두고 로깅이나 결제 처리 같은 부가 기능을 쉽게 추가하거나 수정할 수 있어. 재능넷에서 새로운 재능을 쉽게 추가하고 관리하는 것처럼 말이야!

🤓 AOP의 장점

AOP를 사용하면 다음과 같은 멋진 장점들이 있어:

코드 중복 감소: 여러 곳에서 사용되는 기능을 한 곳에서 관리할 수 있어.
비즈니스 로직 집중: 핵심 기능에만 집중할 수 있어 코드가 깔끔해져.
유지보수 용이: 공통 기능을 변경할 때 한 곳만 수정하면 돼.
재사용성 증가: aspect를 여러 곳에서 재사용할 수 있어.

이제 AOP가 뭔지 조금은 이해가 됐지? 다음으로 Spring에서 어떻게 AOP를 사용하는지 알아보자!

2. Spring AOP: 마법같은 기능의 비밀 🎩✨

자, 이제 Spring AOP에 대해 자세히 알아볼 거야. Spring은 AOP를 정말 쉽고 강력하게 사용할 수 있게 해주는 프레임워크야. 마치 재능넷에서 다양한 재능을 쉽게 찾고 배울 수 있는 것처럼, Spring에서도 AOP를 쉽게 적용할 수 있어!

🌈 Spring AOP의 특징

Spring AOP는 다음과 같은 특징을 가지고 있어:

프록시 기반: Spring AOP는 프록시 패턴을 사용해. 이게 뭐냐고? 간단히 말하면, 원본 객체를 감싸는 새로운 객체를 만들어서 추가 기능을 제공하는 거야.
런타임 위빙: AOP의 적용이 프로그램이 실행될 때 이루어져. 이렇게 하면 성능에 약간의 영향이 있지만, 사용하기가 훨씬 간편해.
Spring 컨테이너와의 통합: Spring의 다른 기능들과 잘 어울려서 사용하기 편리해.

🎭 프록시 패턴이 뭐야?

프록시 패턴은 어떤 객체에 접근하기 전에 그 객체를 감싸는 새로운 객체를 통해 접근하는 방식이야. 마치 연예인의 매니저처럼, 직접 연예인을 만나기 전에 매니저를 통해 연락하는 것과 비슷해. 이렇게 하면 원래 객체의 동작을 변경하거나 추가 기능을 넣기 쉬워져.

🛠 Spring AOP 설정하기

Spring에서 AOP를 사용하려면 몇 가지 설정이 필요해. 하나씩 살펴볼까?

1. 의존성 추가

먼저 프로젝트에 Spring AOP 의존성을 추가해야 해. Maven을 사용한다면 pom.xml 파일에 다음 내용을 추가하면 돼:


<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-aop</artifactId>
    <version>5.3.9</version>
</dependency>
<dependency>
    <groupId>org.aspectj</groupId>
    <artifactId>aspectjweaver</artifactId>
    <version>1.9.7</version>
</dependency>

2. AOP 활성화

Spring 설정 파일(XML을 사용한다면) 또는 Java 설정 클래스에 AOP를 활성화하는 설정을 추가해야 해.

XML 설정의 경우:


<aop:aspectj-autoproxy/>

Java 설정의 경우:


@Configuration
@EnableAspectJAutoProxy
public class AppConfig {
    // 설정 내용
}

3. Aspect 클래스 생성

이제 실제로 AOP 기능을 구현할 Aspect 클래스를 만들어야 해. 이 클래스에는 @Aspect 어노테이션을 붙여줘:


import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.stereotype.Component;

@Aspect
@Component
public class LoggingAspect {

    @Before("execution(* com.example.service.*.*(..))")
    public void logBefore() {
        System.out.println("메소드 실행 전 로깅");
    }
}

이 예제에서는 @Before 어노테이션을 사용해서 특정 메소드 실행 전에 로그를 남기도록 했어. 'execution(* com.example.service.*.*(..))'는 포인트컷 표현식으로, com.example.service 패키지의 모든 클래스의 모든 메소드를 대상으로 한다는 뜻이야.

🎨 Spring AOP의 다양한 Advice 타입

Spring AOP는 다양한 Advice 타입을 제공해. 각각의 타입은 다른 시점에 실행돼:

@Before: 메소드 실행 전에 실행
@After: 메소드 실행 후에 실행 (예외 발생 여부와 관계없이)
@AfterReturning: 메소드가 정상적으로 결과를 반환한 후 실행
@AfterThrowing: 메소드에서 예외가 발생했을 때 실행
@Around: 메소드 실행 전후에 실행, 가장 강력한 Advice 타입

이런 다양한 Advice 타입을 사용하면 정말 세밀하게 AOP를 제어할 수 있어. 마치 재능넷에서 다양한 재능을 골라 배우는 것처럼, 상황에 맞는 Advice를 선택해서 사용하면 돼!

🎭 포인트컷 표현식 이해하기

포인트컷 표현식은 어떤 메소드에 Advice를 적용할지 결정하는 중요한 부분이야. 조금 더 자세히 알아볼까?

주요 포인트컷 표현식 패턴:

execution(* com.example.service.*.*(..)): com.example.service 패키지의 모든 클래스, 모든 메소드
execution(* com.example.service.UserService.*(..)): UserService 클래스의 모든 메소드
execution(* com.example.service.*.get*(..)): 패키지 내 모든 클래스의 get으로 시작하는 메소드
@annotation(com.example.annotation.LogExecutionTime): 특정 어노테이션이 붙은 메소드

이런 표현식을 잘 활용하면 정말 세밀하게 AOP를 적용할 수 있어. 예를 들어, 특정 패키지의 특정 메소드에만 로깅을 적용하거나, 특정 어노테이션이 붙은 메소드에만 트랜잭션을 적용하는 등의 작업이 가능해져.

🚀 Spring AOP의 활용 예시

자, 이제 Spring AOP를 어떻게 활용할 수 있는지 몇 가지 예시를 통해 살펴보자!

1. 메소드 실행 시간 측정


@Aspect
@Component
public class PerformanceAspect {

    @Around("execution(* com.example.service.*.*(..))")
    public Object measureExecutionTime(ProceedingJoinPoint joinPoint) throws Throwable {
        long start = System.currentTimeMillis();
        Object result = joinPoint.proceed();
        long executionTime = System.currentTimeMillis() - start;
        System.out.println(joinPoint.getSignature() + " executed in " + executionTime + "ms");
        return result;
    }
}

이 예제는 서비스 계층의 모든 메소드의 실행 시간을 측정해. @Around Advice를 사용해서 메소드 실행 전후의 시간을 비교하고 있어.

2. 예외 처리 및 로깅


@Aspect
@Component
public class ExceptionLoggingAspect {

    @AfterThrowing(pointcut = "execution(* com.example.service.*.*(..))", throwing = "ex")
    public void logException(JoinPoint joinPoint, Exception ex) {
        System.err.println("Exception in " + joinPoint.getSignature());
        System.err.println("Exception message: " + ex.getMessage());
    }
}

이 Aspect는 서비스 계층에서 발생하는 모든 예외를 로깅해. @AfterThrowing Advice를 사용해서 예외가 발생했을 때만 동작하도록 했어.

3. 메소드 파라미터 로깅


@Aspect
@Component
public class ParameterLoggingAspect {

    @Before("execution(* com.example.service.*.*(..))")
    public void logParameters(JoinPoint joinPoint) {
        Object[] args = joinPoint.getArgs();
        System.out.println("Method: " + joinPoint.getSignature().getName());
        System.out.println("Parameters: " + Arrays.toString(args));
    }
}

이 Aspect는 메소드 호출 시 전달되는 파라미터를 로깅해. 디버깅할 때 정말 유용할 거야!

이렇게 Spring AOP를 사용하면 코드의 여러 부분에 걸쳐 있는 공통 관심사를 깔끔하게 분리해서 관리할 수 있어. 마치 재능넷에서 다양한 재능을 체계적으로 분류하고 관리하는 것처럼 말이야! 😉

다음 섹션에서는 이런 Spring AOP를 실제로 로깅과 트랜잭션 관리에 어떻게 활용하는지 더 자세히 알아볼 거야. 기대되지 않아? 🎉

3. Spring AOP로 로깅 구현하기 📝

자, 이제 Spring AOP를 사용해서 로깅을 구현하는 방법을 알아볼 거야. 로깅은 프로그램의 실행 상태를 기록하는 중요한 작업이지. 디버깅할 때나 시스템 모니터링할 때 정말 유용하거든. 그런데 매번 코드에 로그를 남기는 부분을 직접 작성하려면 정말 귀찮고 시간도 많이 걸리지 않을까? 여기서 Spring AOP의 마법이 시작돼! 😎

🎯 로깅 AOP 구현 목표

우리가 만들 로깅 AOP는 다음과 같은 기능을 할 거야:

메소드 실행 전 로그 남기기
메소드 실행 후 로그 남기기
메소드 실행 시간 측정하기
예외 발생 시 로그 남기기

이렇게 하면 어떤 메소드가 언제 호출되었고, 얼마나 오래 실행되었는지, 그리고 어떤 문제가 있었는지 한눈에 파악할 수 있을 거야. 재능넷에서 사용자들의 활동을 추적하는 것처럼 말이야!

🛠 로깅 Aspect 구현하기

자, 이제 실제로 로깅 Aspect를 구현해보자. 다음 코드를 잘 봐봐:


import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

@Aspect
@Component
public class LoggingAspect {

    private static final Logger logger = LoggerFactory.getLogger(LoggingAspect.class);

    @Pointcut("execution(* com.example.service.*.*(..))")
    public void serviceMethods() {}

    @Before("serviceMethods()")
    public void logBefore(JoinPoint joinPoint) {
        logger.info("Before executing {}", joinPoint.getSignature().toShortString());
    }

    @AfterReturning(pointcut = "serviceMethods()", returning = "result")
    public void logAfterReturning(JoinPoint joinPoint, Object result) {
        logger.info("Method {} returned {}", joinPoint.getSignature().toShortString(), result);
    }

    @AfterThrowing(pointcut = "serviceMethods()", throwing = "e")
    public void logAfterThrowing(JoinPoint joinPoint, Throwable e) {
        logger.error("Exception in {}.{}() with cause = {}",
            joinPoint.getSignature().getDeclaringTypeName(),
            joinPoint.getSignature().getName(),
            e.getCause() != null ? e.getCause() : "NULL");
    }

    @Around("serviceMethods()")
    public Object logAround(ProceedingJoinPoint joinPoint) throws Throwable {
        long start = System.currentTimeMillis();
        
        try {
            Object result = joinPoint.proceed();
            long executionTime = System.currentTimeMillis() - start;
            logger.info("{} executed in {}ms", joinPoint.getSignature().toShortString(), executionTime);
            return result;
        } catch (IllegalArgumentException e) {
            logger.error("Illegal argument {} in {}", Arrays.toString(joinPoint.getArgs()),
                         joinPoint.getSignature().toShortString());
            throw e;
        }
    }
}

우와, 코드가 좀 길지? 하나씩 뜯어보자!

1. Pointcut 정의


@Pointcut("execution(* com.example.service.*.*(..))")
public void serviceMethods() {}

이 부분은 우리가 로깅을 적용할 메소드들을 지정하는 거야. 여기서는 com.example.service 패키지의 모든 클래스의 모든 메소드를 대상으로 하고 있어.

2. 메소드 실행 전 로깅


@Before("serviceMethods()")
public void logBefore(JoinPoint joinPoint) {
    logger.info("Before executing {}", joinPoint.getSignature().toShortString());
}

이 메소드는 지정된 메소드들이 실행되기 전에 로그를 남겨. 어떤 메소드가 실행될 건지 미리 알 수 있지.

3. 메소드 실행 후 로깅


@AfterReturning(pointcut = "serviceMethods()", returning = "result")
public void logAfterReturning(JoinPoint joinPoint, Object result) {
    logger.info("Method {} returned {}", joinPoint.getSignature().toShortString(), result);
}

이 메소드는 지정된 메소드들이 정상적으로 실행을 마치고 결과를 반환한 후에 로그를 남겨. 어떤 결과가 나왔는지 확인할 수 있어.

4. 예외 발생 시 로깅


@AfterThrowing(pointcut = "serviceMethods()", throwing = "e")
public void logAfterThrowing(JoinPoint joinPoint, Throwable e) {
    logger.error("Exception in {}.{}() with cause = {}",
        joinPoint.getSignature().getDeclaringTypeName(),
        joinPoint.getSignature().getName(),
        e.getCause() != null ? e.getCause() : "NULL");
}

이 메소드는 지정된 메소드들에서 예외가 발생했을 때 로그를 남겨. 어떤 예외가 어디서 발생했는지 자세히 알 수 있지.

5. 메소드 실행 시간 측정 및 로깅


@Around("serviceMethods()")
public Object logAround(ProceedingJoinPoint joinPoint  ) throws Throwable {
    long start = System.currentTimeMillis();
    
    try {
        Object result = joinPoint.proceed();
        long executionTime = System.currentTimeMillis() - start;
        logger.info("{} executed in {}ms", joinPoint.getSignature().toShortString(), executionTime);
        return result;
    } catch (IllegalArgumentException e) {
        logger.error("Illegal argument {} in {}", Arrays.toString(joinPoint.getArgs()),
                     joinPoint.getSignature().toShortString());
        throw e;
    }
}

이 메소드는 @Around Advice를 사용해서 메소드 실행 전후를 모두 처리해. 메소드의 실행 시간을 측정하고, 실행 중 발생한 예외도 로깅할 수 있어. 정말 강력하지?

🎨 로깅 Aspect 활용하기

이제 이 로깅 Aspect를 어떻게 활용할 수 있는지 살펴보자. 예를 들어, UserService라는 서비스 클래스가 있다고 가정해볼게:


@Service
public class UserService {
    public User createUser(String username, String email) {
        // 사용자 생성 로직
    }

    public User getUserById(Long id) {
        // 사용자 조회 로직
    }

    public void updateUser(User user) {
        // 사용자 정보 업데이트 로직
    }
}

이 UserService의 메소드들이 실행될 때마다 우리가 만든 LoggingAspect가 동작할 거야. 예를 들어:

createUser 메소드가 호출되기 전에 "Before executing UserService.createUser()" 로그가 남을 거야.
getUserById 메소드가 실행을 마치면 "Method UserService.getUserById() returned User@123456" 같은 로그가 남겠지.
updateUser 메소드에서 예외가 발생하면 상세한 예외 정보가 로그에 남을 거야.
모든 메소드의 실행 시간이 측정되어 로그에 남겠지.

이렇게 하면 UserService의 코드를 전혀 건드리지 않고도 상세한 로깅을 구현할 수 있어. 정말 편리하지 않아?

💡 로깅 Aspect 사용 시 주의사항

로깅 Aspect를 사용할 때 몇 가지 주의할 점이 있어:

성능 영향: 너무 많은 로그를 남기면 애플리케이션 성능에 영향을 줄 수 있어. 꼭 필요한 정보만 로깅하도록 해.
민감한 정보: 로그에 개인정보나 보안 관련 정보가 남지 않도록 주의해야 해.
로그 레벨: 적절한 로그 레벨(INFO, DEBUG, ERROR 등)을 사용해서 필요한 정보만 볼 수 있도록 해.
예외 처리: @AfterThrowing에서 예외를 처리할 때, 예외를 삼키지 말고 반드시 다시 throw해야 해.

이런 점들만 주의하면, Spring AOP를 사용한 로깅은 정말 강력하고 유용한 도구가 될 거야. 마치 재능넷에서 전문가의 조언을 받는 것처럼, 너의 애플리케이션도 전문가 수준의 로깅을 갖추게 될 거야! 😄

🚀 로깅 Aspect 확장하기

우리가 만든 기본적인 로깅 Aspect를 더 발전시킬 수 있는 방법들도 있어. 몇 가지 아이디어를 줄게:

MDC(Mapped Diagnostic Context) 활용: 각 요청마다 고유한 ID를 부여해서 로그를 추적하기 쉽게 만들 수 있어.
로그 포맷 커스터마이징: 로그 메시지의 형식을 프로젝트의 요구사항에 맞게 조정할 수 있어.
조건부 로깅: 특정 조건에서만 로그를 남기도록 설정할 수 있어.
로그 저장소 연동: 로그를 파일뿐만 아니라 데이터베이스나 외부 로그 관리 시스템에 저장할 수 있어.

이런 기능들을 추가하면 너의 로깅 시스템은 더욱 강력해질 거야. 마치 재능넷에서 기본 재능에 새로운 스킬을 추가하는 것처럼 말이야!

자, 이제 Spring AOP를 사용해서 로깅을 구현하는 방법을 배웠어. 다음 섹션에서는 트랜잭션 관리를 어떻게 AOP로 처리하는지 알아볼 거야. 기대되지 않아? 🎉

4. Spring AOP로 트랜잭션 관리하기 💼

자, 이제 Spring AOP를 사용해서 트랜잭션을 관리하는 방법을 알아볼 거야. 트랜잭션이 뭔지 모르겠다고? 걱정 마! 쉽게 설명해줄게. 🤓

🎭 트랜잭션이란?

트랜잭션은 데이터베이스의 상태를 변화시키는 하나의 논리적 기능을 수행하기 위한 작업의 단위야. 쉽게 말해, 여러 개의 데이터베이스 작업을 하나로 묶어서 '모두 성공하거나 모두 실패'하게 만드는 거지. 마치 재능넷에서 새로운 재능을 등록할 때, 정보 입력, 카테고리 설정, 가격 책정 등이 모두 성공해야 재능이 등록되는 것과 비슷해.

트랜잭션의 특성 (ACID):

원자성(Atomicity): 트랜잭션의 모든 연산이 완전히 수행되거나, 아니면 전혀 수행되지 않아야 함
일관성(Consistency): 트랜잭션 수행 전후의 데이터베이스 상태가 일관되어야 함
격리성(Isolation): 동시에 실행되는 트랜잭션들이 서로 영향을 미치지 않아야 함
지속성(Durability): 트랜잭션이 성공적으로 완료되면 그 결과가 영구적으로 반영되어야 함

🛠 Spring의 트랜잭션 관리

Spring은 트랜잭션 관리를 위한 강력한 추상화를 제공해. 이를 통해 다양한 트랜잭션 API(JDBC, JTA, Hibernate 등)를 일관된 방식으로 사용할 수 있지. 그리고 여기서 AOP가 등장해! Spring AOP를 사용하면 트랜잭션 관리 코드를 비즈니스 로직에서 완전히 분리할 수 있어.

🎨 @Transactional 어노테이션

Spring에서는 @Transactional 어노테이션을 사용해서 트랜잭션을 쉽게 관리할 수 있어. 이 어노테이션을 메소드나 클래스에 붙이면, Spring이 알아서 트랜잭션 처리를 해줘. 정말 편리하지?


@Service
public class UserService {
    @Transactional
    public void createUser(User user) {
        // 사용자 생성 로직
    }
}

이렇게 하면 createUser 메소드가 실행될 때 트랜잭션이 시작되고, 메소드가 정상적으로 종료되면 트랜잭션이 커밋돼. 만약 예외가 발생하면 트랜잭션이 롤백되지.

🚀 트랜잭션 설정하기

@Transactional 어노테이션은 다양한 속성을 제공해. 이를 통해 트랜잭션의 동작을 세밀하게 제어할 수 있어:

propagation: 트랜잭션 전파 방식을 설정
isolation: 트랜잭션 격리 수준을 설정
timeout: 트랜잭션 제한 시간을 설정
readOnly: 읽기 전용 트랜잭션 여부를 설정
rollbackFor: 특정 예외 발생 시 롤백하도록 설정

예를 들어, 다음과 같이 사용할 수 있어:


@Transactional(propagation = Propagation.REQUIRED, isolation = Isolation.READ_COMMITTED, 
               timeout = 30, readOnly = false, rollbackFor = Exception.class)
public void complexTransaction() {
    // 복잡한 트랜잭션 로직
}

💡 트랜잭션 AOP 동작 원리

Spring AOP는 @Transactional 어노테이션이 붙은 메소드나 클래스를 감지하고, 해당 메소드 실행 전후에 트랜잭션 관련 로직을 추가해. 대략 이런 식으로 동작해:

메소드 실행 전: 트랜잭션 시작
메소드 실행
예외 발생 여부 확인
예외가 없으면 트랜잭션 커밋, 예외가 있으면 롤백

이 모든 과정이 AOP에 의해 자동으로 처리되기 때문에, 개발자는 비즈니스 로직에만 집중할 수 있어. 정말 편리하지?

🎭 트랜잭션 관리 주의사항

트랜잭션을 사용할 때 주의해야 할 점들이 있어:

트랜잭션 범위: 트랜잭션의 범위를 적절히 설정해야 해. 너무 크면 성능이 저하될 수 있고, 너무 작으면 데이터 일관성을 보장하기 어려워.
예외 처리: 체크 예외와 언체크 예외에 대한 롤백 정책을 잘 이해하고 설정해야 해.
프록시 제한: @Transactional은 프록시를 통해 동작하기 때문에, 같은 클래스 내의 메소드 호출에는 적용되지 않아.
테스트: 트랜잭션이 의도한 대로 동작하는지 꼭 테스트해봐야 해.

🚀 트랜잭션 관리 예제

자, 이제 실제로 트랜잭션을 사용하는 예제를 볼까? 재능넷에서 새로운 재능을 등록하는 과정을 상상해보자:


@Service
public class TalentService {
    @Autowired
    private TalentRepository talentRepository;
    @Autowired
    private UserRepository userRepository;

    @Transactional
    public void registerNewTalent(Talent talent, Long userId) {
        User user = userRepository.findById(userId)
            .orElseThrow(() -> new UserNotFoundException("User not found"));
        
        talent.setUser(user);
        talentRepository.save(talent);
        
        user.incrementTalentCount();
        userRepository.save(user);
        
        if (talent.getPrice() < 0) {
            throw new InvalidPriceException("Talent price cannot be negative");
        }
    }
}

이 예제에서는 다음과 같은 작업들이 하나의 트랜잭션으로 처리돼:

사용자 조회
새로운 재능 저장
사용자의 재능 수 증가
가격 유효성 검사

만약 이 과정 중 어느 하나라도 실패하면(예를 들어, 가격이 음수라면), 모든 작업이 롤백되어 데이터의 일관성이 유지돼. 정말 멋지지 않아?

💡 트랜잭션 관리 발전시키기

기본적인 트랜잭션 관리를 넘어서, 더 발전된 기법들도 있어:

분산 트랜잭션: 여러 데이터베이스나 메시지 큐에 걸친 트랜잭션 관리
보상 트랜잭션: 긴 시간 동안 실행되는 트랜잭션을 관리하는 패턴
트랜잭션 로깅: 트랜잭션의 실행 과정을 상세히 로깅
트랜잭션 모니터링: 실시간으로 트랜잭션의 상태를 모니터링

이런 고급 기법들을 활용하면, 더욱 안정적이고 확장 가능한 시스템을 구축할 수 있어. 마치 재능넷에서 초보자 수준의 재능에서 시작해 전문가 수준의 재능으로 발전하는 것처럼 말이야! 😄

자, 이제 Spring AOP를 사용한 트랜잭션 관리에 대해 알아봤어. 이를 통해 비즈니스 로직과 트랜잭션 관리를 깔끔하게 분리하고, 더 안정적인 애플리케이션을 만들 수 있지. 멋지지 않아? 🎉

5. 실전 예제: 재능넷 서비스에 AOP 적용하기 🚀

자, 이제 우리가 배운 내용을 실제 서비스에 적용해볼 시간이야! 가상의 '재능넷' 서비스를 만들어보면서 Spring AOP를 활용한 로깅과 트랜잭션 관리를 구현해볼 거야. 준비됐니? 시작해보자! 😎

🎨 재능넷 서비스 구조

먼저 재능넷 서비스의 기본 구조를 살펴보자:


com.talentnet
  ├── controller
  │   └── TalentController.java
  ├── service
  │   └── TalentService.java
  ├── repository
  │   └── TalentRepository.java
  ├── model
  │   └── Talent.java
  ├── aspect
  │   ├── LoggingAspect.java
  │   └── TransactionAspect.java
  └── TalentNetApplication.java

🛠 로깅 Aspect 구현

먼저 로깅 Aspect를 구현해볼게:


@Aspect
@Component
public class LoggingAspect {
    private static final Logger logger = LoggerFactory.getLogger(LoggingAspect.class);

    @Pointcut("execution(* com.talentnet.service.*.*(..))")
    public void serviceLayer() {}

    @Before("serviceLayer()")
    public void logBefore(JoinPoint joinPoint) {
        logger.info("Entering method: {}", joinPoint.getSignature().getName());
    }

    @AfterReturning(pointcut = "serviceLayer()", returning = "result")
    public void logAfterReturning(JoinPoint joinPoint, Object result) {
        logger.info("Method {} returned: {}", joinPoint.getSignature().getName(), result);
    }

    @AfterThrowing(pointcut = "serviceLayer()", throwing = "error")
    public void logAfterThrowing(JoinPoint joinPoint, Throwable error) {
        logger.error("Exception in {}: {}", joinPoint.getSignature().getName(), error.getMessage());
    }
}

이 Aspect는 서비스 계층의 모든 메소드에 대해 로깅을 수행해. 메소드 진입, 반환, 예외 발생 시 각각 로그를 남기지.

💼 트랜잭션 관리

트랜잭션 관리는 @Transactional 어노테이션을 사용할 거야. 별도의 Aspect를 만들지 않고, 서비스 클래스에 직접 적용해보자:


@Service
public class TalentService {
    @Autowired
    private TalentRepository talentRepository;

    @Transactional
    public Talent createTalent(Talent talent) {
        // 재능 생성 로직
        return talentRepository.save(talent);
    }

    @Transactional(readOnly = true)
    public List<Talent> getAllTalents() {
        // 모든 재능 조회 로직
        return talentRepository.findAll();
    }

    @Transactional
    public Talent updateTalent(Long id, Talent talentDetails) {
        // 재능 업데이트 로직
        Talent talent = talentRepository.findById(id)
            .orElseThrow(() -> new ResourceNotFoundException("Talent not found"));
        talent.setName(talentDetails.getName());
        talent.setDescription(talentDetails.getDescription());
        talent.setPrice(talentDetails.getPrice());
        return talentRepository.save(talent);
    }

    @Transactional
    public void deleteTalent(Long id) {
        // 재능 삭제 로직
        Talent talent = talentRepository.findById(id)
            .orElseThrow(() -> new ResourceNotFoundException("Talent not found"));
        talentRepository.delete(talent);
    }
}

여기서 @Transactional 어노테이션은 각 메소드에 트랜잭션 경계를 설정해. getAllTalents() 메소드는 읽기 전용 트랜잭션으로 설정했어.

🎭 컨트롤러 구현

이제 컨트롤러를 구현해볼게:


@RestController
@RequestMapping("/api/talents")
public class TalentController {
    @Autowired
    private TalentService talentService;

    @PostMapping
    public ResponseEntity<Talent> createTalent(@RequestBody Talent talent) {
        Talent createdTalent = talentService.createTalent(talent);
        return new ResponseEntity<>(createdTalent, HttpStatus.CREATED);
    }

    @GetMapping
    public List<Talent> getAllTalents() {
        return talentService.getAllTalents();
    }

    @PutMapping("/{id}")
    public ResponseEntity<Talent> updateTalent(@PathVariable Long id, @RequestBody Talent talentDetails) {
        Talent updatedTalent = talentService.updateTalent(id, talentDetails);
        return ResponseEntity.ok(updatedTalent);
    }

    @DeleteMapping("/{id}")
    public ResponseEntity<?> deleteTalent(@PathVariable Long id) {
        talentService.deleteTalent(id);
        return ResponseEntity.ok().build();
    }
}

컨트롤러는 클라이언트의 요청을 받아 서비스 계층으로 전달하는 역할을 해.

🚀 애플리케이션 실행

마지막으로 메인 애플리케이션 클래스를 만들어보자:


@SpringBootApplication
@EnableAspectJAutoProxy
public class TalentNetApplication {
    public static void main(String[] args) {
        SpringApplication.run(TalentNetApplication.class, args);
    }
}

@EnableAspectJAutoProxy 어노테이션은 Spring AOP를 활성화해.

💡 실행 결과

이제 애플리케이션을 실행하면, 다음과 같은 일들이 일어날 거야:

재능을 생성, 조회, 수정, 삭제할 때마다 로그가 남을 거야.
각 작업은 트랜잭션 내에서 실행되어 데이터 일관성이 유지될 거야.
예외가 발생하면 로그에 기록되고 트랜잭션이 롤백될 거야.

예를 들어, 새로운 재능을 등록하면 이런 로그가 남을 수 있어:


INFO: Entering method: createTalent
INFO: Method createTalent returned: Talent{id=1, name='웹 개발', description='React와 Spring Boot로 웹 애플리케이션 개발', price=50000}