[Spring DB] 트랜잭션 AOP

4-7. 트랜잭션 문제 해결 - 트랜잭션 AOP 이해

• 서비스 계층에 순수한 비즈니스 로직만 남기기 위해 스프링 AOP를 통해 프록시를 도입한다.

프록시 도입 전

• 프록시를 도입하기 전에는 기존처럼 서비스의 로직에서 트랜잭션을 직접 시작한다.

프록시 도입 후

• 프록시를 사용하면 트랜잭션을 처리하는 객체와 비즈니스 로직을 처리하는 서비스 객체를 명확하게 분리할 수 있다.

트랜잭션 프록시 코드 예시

public class TransactionProxy {
      private MemberService target;
      
      
public void logic() { //트랜잭션 시작
       TransactionStatus status = transactionManager.getTransaction(..);
       try {
      //실제 대상 호출
        target.logic();
        transactionManager.commit(status); //성공시 커밋 
      } catch (Exception e) {
      	transactionManager.rollback(status); //실패시 롤백
        throw new IllegalStateException(e);
      }
   }
} 

트랜잭션 프록시 적용 후 서비스 코드 예시

public class Service {
      public void logic() {
		  //트랜잭션 관련 코드 제거, 순수 비즈니스 로직만 남음
          bizLogic(fromId, toId, money);
      }
}

• 프록시를 도입하면서 트랜잭션 처리 로직을 모두 가져갔다. 그리고 트랜잭션을 시작한 후에 실제 서비스를 대신 호출한다. 트랜잭션 프록시 덕분에 서비스 계층에는 순수한 비즈니즈 로직만 남길 수 있다.

스프링이 제공하는 트랜잭션 AOP

• 스프링이 제공하는 AOP 기능을 사용하면 프록시를 매우 편리하게 적용할 수 있다. 스프링 핵심 원리 - 고급편을 통해 AOP를 열심히 공부하신 분이라면 아마도 @Aspect , @Advice , @Pointcut 를 사용해서 트랜잭션 처리용 AOP를 어떻게 만들지 머리속으로 그림이 그려질 것이다.
• 물론 스프링 AOP를 직접 사용해서 트랜잭션을 처리해도 되지만, 트랜잭션은 매우 중요한 기능이고, 전세계 누구나 다 사용하는 기능이다. 스프링은 트랜잭션 AOP를 처리하기 위한 모든 기능을 제공한다. 스프링 부트를 사용하면 트랜잭션 AOP를 처리하기 위해 필요한 스프링 빈들도 자동으로 등록해준다.
• 개발자는 트랜잭션 처리가 필요한 곳에 @Transactional 애노테이션만 붙여주면 된다. 스프링의 트랜잭션 AOP는 이 애노테이션을 인식해서 트랜잭션 프록시를 적용해준다.

@Transactional

  org.springframework.transaction.annotation.Transactional

• 스프링 AOP를 적용하려면 어드바이저, 포인트컷, 어드바이스가 필요하다. 스프링은 트랜잭션 AOP 처리를 위해 다음 클래스를 제공한다. 스프링 부트를 사용하면 해당 빈들은 스프링 컨테이너에 자동으로 등록된다.

  어드바이저: BeanFactoryTransactionAttributeSourceAdvisor
  포인트컷: TransactionAttributeSourcePointcut
  어드바이스: TransactionInterceptor

4-8. 트랜잭션 문제 해결 - 트랜잭션 AOP 적용

MemberServiceV3_3

package hello.jbdc.service

import hello.jbdc.Log
import hello.jbdc.domain.Member
import hello.jbdc.repository.MemberRepositoryV3
import org.springframework.transaction.annotation.Transactional
import java.sql.SQLException
import kotlin.jvm.Throws

/*
  트랜잭션 - 트랜잭션 매니저
 */
@Transactional
class MemberServiceV3_3(
  private val memberRepository: MemberRepositoryV3
) :Log{

  @Throws(SQLException::class)
  fun accountTransfer(fromId: String, toId: String, money: Int){
    bizLogic(fromId, toId, money)
  }

  @Throws(SQLException::class)
  private fun bizLogic(fromId: String, toId: String, money: Int){
    val fromMember = memberRepository.findById(fromId)
    val toMember = memberRepository.findById(toId)

    memberRepository.update(fromId, fromMember.money - money)
    validation(toMember)
    memberRepository.update(toId, fromMember.money + money)
  }

  private fun validation(toMember: Member){
    if (toMember.memberId.equals("ex")){
      throw IllegalStateException("이체 중 예외 발생")
    }
  }
}

• 기존 트랜잭션 처리 로직을 @Transactional 어노테이션으로 대체했다.

package hello.jbdc.service

import hello.jbdc.Log
import hello.jbdc.connection.ConnectionConst
import hello.jbdc.domain.Member
import hello.jbdc.repository.MemberRepositoryV3
import org.assertj.core.api.Assertions.assertThat
import org.assertj.core.api.Assertions.assertThatThrownBy
import org.junit.jupiter.api.AfterEach
import org.junit.jupiter.api.DisplayName
import org.junit.jupiter.api.Test
import org.springframework.beans.factory.annotation.Autowired
import org.springframework.boot.test.context.SpringBootTest
import org.springframework.boot.test.context.TestConfiguration
import org.springframework.context.annotation.Bean
import org.springframework.jdbc.datasource.DataSourceTransactionManager
import org.springframework.jdbc.datasource.DriverManagerDataSource
import java.sql.SQLException


@SpringBootTest
internal class MemberServiceV3_3Test: Log{

  val MEMBER_A = "memberA"
  val MEMBER_B = "memberB"
  val MEMBER_EX = "ex"

  @Autowired
  lateinit var memberRepository: MemberRepositoryV3

  @Autowired
  lateinit var memberService: MemberServiceV3_3


  @AfterEach
  @Throws(SQLException::class)
  fun after(){
    memberRepository.delete(MEMBER_A);
    memberRepository.delete(MEMBER_B);
    memberRepository.delete(MEMBER_EX);
  }

  @TestConfiguration
   class TestConfig{
    @Bean
    fun dataSource() = DriverManagerDataSource(ConnectionConst.URL, ConnectionConst.USERNAME, ConnectionConst.PASSWORD)

    @Bean
    fun transactionManager() = DataSourceTransactionManager(dataSource())

    @Bean
    fun memberRepositoryV3() = MemberRepositoryV3(dataSource())

    @Bean
    fun memberServiceV3_3() = MemberServiceV3_3(memberRepositoryV3())
  }
  
  @Test
  fun AopCheck() {
    logger.info("memberService class={}", memberService.javaClass)
    logger.info("memberRepository class={}", memberRepository.javaClass)
    Assertions.assertThat(AopUtils.isAopProxy(memberService)).isTrue()
    Assertions.assertThat(AopUtils.isAopProxy(memberRepository)).isFalse()
  }
  
  @Test
  @DisplayName("정상 이체")
  @Throws(SQLException::class)
  fun accountTransfer() {
    //given
    val memberA = Member(MEMBER_A, 10000)
    val memberB = Member(MEMBER_B, 10000)
    memberRepository.save(memberA)
    memberRepository.save(memberB)
    //when
    memberService.accountTransfer(memberA.memberId,
      memberB.memberId, 2000)
//    //then
    val findMemberA: Member = memberRepository.findById(memberA.memberId)
    val findMemberB: Member = memberRepository.findById(memberB.memberId)
    assertThat(findMemberA.money).isEqualTo(8000)
    assertThat(findMemberB.money).isEqualTo(12000)
  }

  @Test
  @DisplayName("이체 중 예외 발생")
  fun accountTransferEx(){
    //given
    val memberA = Member(MEMBER_A, 10000)
    val memberEx = Member(MEMBER_EX, 10000)
    memberRepository.save(memberA)
    memberRepository.save(memberEx)
    // when

    assertThatThrownBy {
      memberService.accountTransfer(memberA.memberId, memberEx.memberId,
        2000)
    }
      .isInstanceOf(IllegalStateException::class.java)

    // then
    val findMemberA = memberRepository.findById(memberA.memberId)
    val findMemberEx = memberRepository.findById(memberEx.memberId)

    assertThat(findMemberA.money).isEqualTo(10000)
    assertThat(findMemberEx.money).isEqualTo(10000)

  }
}

• @SpringBootTest: 스프링 AOP를 적용하려면 스프링 컨테이너가 필요하다. 이 애노테이션이 있으면 테스트시 스프링 부트를 통해 스프링 컨테이너를 생성한다. 그리고 테스트에서 @Autowired 등을 통해 스프링 컨테이너가 관리하는 빈들을 사용할 수 있다.
• @TestConfiguration: 테스트 안에서 내부 설정 클래스를 만들어서 사용하면서 이 에노테이션을 붙이면, 스프링 부트가 자동으로 만들어주는 빈들에 추가로 필요한 스프링 빈들을 등록하고 테스트를 수행할 수 있다.
• TestConfig
  • DataSource 스프링에서 기본으로 사용할 데이터 소스를 스프링 빈으로 등록한다. 추가로 트랜잭션 매니저에서도 사용한다.
  • DataSourceTransactionManager 트랜잭션 매니저를 스프링 빈으로 등록한다.
    • 스프링이 제공하는 트랜잭션 AOP는 스프링 빈에 등록된 트랜잭션 매니저를 찾아서 사용하기 때문에 트랜잭션 매니저를 스프링 빈으로 등록해두어야 한다.
• 코틀린으로 테스트를 돌렸는데, @Transactional 어노테이션을 메서드 위에 정의할 때 오류가 났다.. 코틀린의 기본 클래스가 final 형이라 CGLIB 프록시가 상속을 못 받는 것 같은데, 그냥 클래스 위에 선언하니 잘 돌아갔다. (원인 아시는 분 댓글 달아주시면 감사하겠습니다!)

AOP 프록시 적용 확인

  @Test
  fun AopCheck() {
    logger.info("memberService class={}", memberService.javaClass)
    logger.info("memberRepository class={}", memberRepository.javaClass)
    Assertions.assertThat(AopUtils.isAopProxy(memberService)).isTrue()
    Assertions.assertThat(AopUtils.isAopProxy(memberRepository)).isFalse()
  }

memberService class=class hello.jdbc.service.MemberServiceV3_3$
 $EnhancerBySpringCGLIB$$...
 memberRepository class=class hello.jdbc.repository.MemberRepositoryV3

• 먼저 AOP 프록시가 적용되었는지 확인해보자. AopCheck() 의 실행 결과를 보면 memberService 에 EnhancerBySpringCGLIB.. 라는 부분을 통해 프록시(CGLIB)가 적용된 것을 확인할 수 있다. memberRepository 에는 AOP를 적용하지 않았기 때문에 프록시가 적용되지 않는다.
• 나머지 테스트 코드들을 실행해보면 트랜잭션이 정상 수행되고, 실패시 정상 롤백된 것을 확인할 수 있다.

4-9. 트랜잭션 문제 해결 - 트랜잭션 AOP 정리

• 선언적 트랜잭션 관리(Declarative Transaction Management)
  • @Transactional 애노테이션 하나만 선언해서 매우 편리하게 트랜잭션을 적용하는 것을 선언적 트랜잭션 관리라 한다.
  • 선언적 트랜잭션 관리는 과거 XML에 설정하기도 했다. 이름 그대로 해당 로직에 트랜잭션을 적용하겠다 라고 어딘가에 선언하기만 하면 트랜잭션이 적용되는 방식이다.
• 프로그래밍 방식의 트랜잭션 관리(programmatic transaction management)
  • 트랜잭션 매니저 또는 트랜잭션 템플릿 등을 사용해서 트랜잭션 관련 코드를 직접 작성하는 것을 프로그래밍 방식의 트랜잭션 관리라 한다.
• 선언적 트랜잭션 관리가 프로그래밍 방식에 비해서 훨씬 간편하고 실용적이기 때문에 실무에서는 대부분 선언적 트랜잭션 관리를 사용한다.
• 프로그래밍 방식의 트랜잭션 관리는 스프링 컨테이너나 스프링 AOP 기술 없이 간단히 사용할 수 있지만 실무에서는 대부분 스프링 컨테이너와 스프링 AOP를 사용하기 때문에 거의 사용되지 않는다. 프로그래밍 방식 트랜잭션 관리는 테스트 시에 가끔 사용될 때는 있다.

정리

• 스프링이 제공하는 선언적 트랜잭션 관리 덕분에 드디어 트랜잭션 관련 코드를 순수한 비즈니스 로직에서 제거할 수 있었다.
• 개발자는 트랜잭션이 필요한 곳에 @Transactional 애노테이션 하나만 추가하면 된다. 나머지는 스프링 트랜잭션 AOP가 자동으로 처리해준다.