[TIL] 221111 - SpringBoot Part2 : 트랜잭션과 AoP

SpringBoot Part2 (5)

 

AoP - 관점 지향 프로그래밍

기능,관심 지향적 프로그래밍

 

 

Cross Cutting Concern

CCC

https://www.codejava.net/frameworks/spring/understanding-spring-aop

 

: 중복코드를 일일히 사용하는 것이 아닌 행단으로 걸쳐서 적용해야하는 부가기능(Cross Cutting Concern)을 분리해서 방식

핵심로직에 부가기능을 쉽게 추가할수 있게한다.

 

class 계좌이체서비스 {
		method 이체() {
				AAAA
				비즈니스 로직
				BBBB
		}
		method 계좌확인() {
				AAAA
				비즈니스 로직
				BBBB
		}
}
class 대출승인서비스 {
		method 승인() {
				AAAA
				비즈니스 로직
				BBBB
		}
}

비지니스 메소드는 비지니스 핵심로직에만 집중하고, 부가 기능(AAA, BBB)은 별도로 빼서 부가기능을 담당하는 모듈에서 담당한다.

 

 

AoP 적용 방법

https://www.researchgate.net/figure/The-relationships-between-different-AOP-weaving-strategies_fig2_220888911

 

 

시점에 따라 크게 3가지 관점을 나뉜다.

• 컴파일 시점 → AoP 프레임워크가 소스파일을 컴파일하기전에 공통 구현 코드를 소스에 삽입하는 방식
• 클래스 로딩 시점
• 런타임 시점 → Spring에서 제공하는 AoP 방식, proxy를 이용하여 부가기능을 동작하게 하는 방식

 

 

Spring AoP - AoP Proxies

• JDK Proxy (interface based → 다이나믹 프록시)
• CGLib Proxy (class based)

 

Spring Proxies

JDK proxy 기법 → Spring AoP의 내부 동작

// 타겟 class
class CalculatorImpl implements Calculator {

    @Override
    public int add(int a, int b) {
        return a + b;
    }
}

interface Calculator {
    int add(int a,int b);
}

// invokation 핸들러 -> targat 객체를 호출
class LoggingInvocationHandler implements InvocationHandler{

    private static final Logger log = LoggerFactory.getLogger(LoggingInvocationHandler.class);
    private final Object target;

    LoggingInvocationHandler(Object target) {
        this.target = target;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        log.info("{} executed", method.getName());
        return method.invoke(target,args);
    }
}

public class JdkProxyTest {
    private static final Logger log = LoggerFactory.getLogger(JdkProxyTest.class);
    public static void main(String[] args) {
        Calculator calculator = new CalculatorImpl();
				// proxy 객체 만들기
        Calculator proxyInstance = (Calculator) Proxy.newProxyInstance( 
                LoggingInvocationHandler.class.getClassLoader(), //ClassLoader
                new Class[]{Calculator.class}, // target 인터페이스
                new LoggingInvocationHandler(calculator)); // target을 전달한 invoke 핸들러
        var res = proxyInstance.add(1,2);
        log.info("Add -> {} ",res);
    }
}

 

Spring AOP

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-aop</artifactId>
</dependency>

 

 

@AspectJ

: JDK proxy를 이용하여 런타임에 AoP 적용

 

주요용어

• 타겟(Target) - CustomerService
  • 핵심 기능을 담고 있는 모듈로서 부가기능을 부여할 대상
  • AoP를 적용할 대상
• 조인포인트(Join Point) - createCustmer, getCustmer,..
  • 어플리케이션을 부가기능을 적용할수 있는 지점 (AoP를 적용할 수 있는 위치)
  • 타겟 객체가 구현한 인터페이스의 모든 메서드
• 포인트 컷(Pointcut)
  • 어드바이스(부가기능)를 적용할 타겟의 메서드를 선별하는 정규표현식
  • 여러 조인트포인트 중에 어디 부가기능을 적용시킬지 나타낸다.
  • 포인트컷 표현식은 execution으로 시작하고 메서드의 Signature를 비교하는 방법을 주로 이용함
• 애스펙트(Aspect)
  • 관점, 기능, 부가 기능
  • 애스펙트 = 어드바이스 + 포인트컷 (부가기능 set)
  • Spring에서는 Aspect를 빈으로 등록해서 사용합니다.
• 어드바이스(Advice)
  • 어드바이스는 타겟의 특정 조인트포인트에 제공할 부가기능
  • Advice에는 @Before, @After, @Around, @AfterReturning, @AfterThrowing 등이 있습니다.

https://mossgreen.github.io/Spring-Certification-Spring-AOP/

• 위빙
  • 타켓의 조인 포인트에 어드바이즈가 적용되는 과정 (AoP를 적용하는 과정)

 

실습

// Aspect 정의
@Aspect
@Component
public class LoggingAspect {
    private static final Logger log = LoggerFactory.getLogger(LoggingAspect.class);

		// execution(접근지정자 리턴타입 패키지.메소드(arg))
    @Around("execution(public * org.prgrms.kdt..*.*(..))") // 포인트컷
    public Object log(ProceedingJoinPoint joinPoint) throws Throwable {
        log.info("Before method called. {}",joinPoint.getSignature().toString());
        var result = joinPoint.proceed();
        log.info("After method called with result => {}",result);
        return result;
    }
}

—

@Configuration
@ComponentScan(basePackages = {"org.prgrms.kdt.voucher","org.prgrms.kdt.aop"})
@EnableAspectJAutoProxy // AoP 적용 어노테이션
static  class Config{
				....
}

등록된 Bean에 의해서만 어드바이스가 가능

 

 

@Around() → 포인트 컷

• execution PCD

 

• 포인트컷 모듈화

public class CommonPointcut {
    @Pointcut("execution(public * org.prgrms.kdt..*.*(..))")
    public void servicePublicMethodPointcut(){};

    @Pointcut("execution(* org.prgrms.kdt..*Repository.*(..))")
    public void repositoryPublicMethodPointcut(){};
}

—

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

    @Around("org.prgrms.kdt.aop.CommonPointcut.repositoryPublicMethodPointcut()") // 포인트컷 풀class 명
    public Object log(ProceedingJoinPoint joinPoint) throws Throwable {
        log.info("Before method called. {}",joinPoint.getSignature().toString());
        var result = joinPoint.proceed();
        log.info("After method called with result => {}",result);
        return result;
    }
}

 

• 어노태이션을 이용한 포인트컷

// 사용자 어노테이션 만들기
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface TrackTime {
}

—

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

		// TrackTime 어노테이션을 사용한 class를 포인트컷으로 준다.
    @Around("@annotation(org.prgrms.kdt.aop.TrackTime)")
    public Object log(ProceedingJoinPoint joinPoint) throws Throwable {
        log.info("Before method called. {}",joinPoint.getSignature().toString());
        var startTime = System.nanoTime(); // 1 -> 1,000,000,000
        var result = joinPoint.proceed();
        var endTime = System.nanoTime() - startTime;
        log.info("After method called with result => {} and time taken {} nanoseconds",result,endTime);
        return result;
    }
}

—

// 어노테이션 적용
public class MemoryVoucherRepository {

	private  final Map<UUID, Voucher> storage = new ConcurrentHashMap<>();
  
	@Override
	@TrackTime
	public Voucher insert(Voucher voucher) {
	    storage.put(voucher.getVoucherId(),voucher);
	    return voucher;
	}

	....
}

 

실제 AoP를 직접 만들어 쓰는 경우도 종종있지만 거의 공통팀(프레임워크 팀)에서 어노테이션, aspect등을 만들어 주고 비지니스 로직에만 집중할 수 있도록 진행하게되는 경우가 많다.

 

---

트랜잭션

Spring 트랜잭션은 어노테이션 기반으로 트랜잭션 관리에 대한 Aspect를 제공해주는 동작이다.

@Configuration
@ComponentScan(basePackages = {"org.prgrms.kdt.voucher","org.prgrms.kdt.aop"})
@EnableAspectJAutoProxy // AoP 적용 어노테이션
static  class Config{
				....
}

 

PlatfoemTranactionManager

PlatfoemTranactionManager를 통해 트랜잭션 관리가 이루워진다.

DataTranactionManager 통해 직접 트랜잭션 등록

// Bean등록
@Bean
public PlatformTransactionManager platformTransactionManager(DataSource dataSource){
    return new DataSourceTransactionManager(dataSource);
}

—

public class CustomerJdbcRepository implements CustomerRepository {
	
		// 생성자를 통해 주입
		private final PlatformTransactionManager transactionManager;

		....

		public void testTransaction(Customer customer){
        var transaction = transactionManager.getTransaction(new DefaultTransactionDefinition()); //트랜잭션 생성
        try {
            jdbcTemplate.update("UPDATE customers SET name= :name  WHERE customer_id = UUID_TO_BIN(:customerId)",toParamMap(customer));
            jdbcTemplate.update("UPDATE customers SET email= :email WHERE customer_id = UUID_TO_BIN(:customerId)",toParamMap(customer));
            transactionManager.commit(transaction);
        }catch (DataAccessException e) {
            logger.info(e.getMessage());
            transactionManager.rollback(transaction);
        }
    }
}

 

 

tranaction template 사용

// Bean등록
@Bean
public PlatformTransactionManager platformTransactionManager(DataSource dataSource){
    return new DataSourceTransactionManager(dataSource);
}

@Bean
public TransactionTemplate transactionTemplate(PlatformTransactionManager platformTransactionManager){
    return new TransactionTemplate(platformTransactionManager);
}

—

public class CustomerJdbcRepository implements CustomerRepository {
	
		// 생성자를 통해 주입
		private final TransactionTemplate transactionTemplate;

		....

		public void testTransaction(Customer customer){
        transactionTemplate.execute(new TransactionCallbackWithoutResult() {
            @Override
            protected void doInTransactionWithoutResult(TransactionStatus status) {
                jdbcTemplate.update("UPDATE customers SET name= :name  WHERE customer_id = UUID_TO_BIN(:customerId)",toParamMap(customer));
                jdbcTemplate.update("UPDATE customers SET email= :email WHERE customer_id = UUID_TO_BIN(:customerId)",toParamMap(customer));
            }
        });
    }
}

 

@Transactional

spring에서 어노테이션을 이용해 트랜잭션을 제공한다.(선언전 트랜잭션 관리)

Aop proxy를 통해 동작한다.

: service단 에서 많이 사용하게된다. 일련의 동작들을 하나로 묶기위해

public class CustomerServiceImpl implements CustomerService {
    
    private final CustomerRepository customerRepository;

    public CustomerServiceImpl(CustomerRepository customerRepository) {
        this.customerRepository = customerRepository;
    }

    @Override
    @Transactional
    public void createCustomers(List<Customer> customers) {
        customers.forEach(customerRepository::insert);
    }
}

 

 

트랜잭션 전파

특정 메소드 A 내 트렌젹션이 처리되는 과정안에서 또 다른 메소드 B 트렌젝션이 처리되는 과정

// propagation 으로 값을 변경할 수 있다.
@Transactional(propagation = Propagation.REQUIRED) // defualt
public void createCustomers(List<Customer> customers) {
    customers.forEach(customerRepository::insert);
}

REQUIRED

: 현재 진행중인 트렌젝션(addCustomer)이 있다면 새로운 트렌젝션이 만들어 지지않고 해당 트렌젝션을 사용한다. 없다면 새로 만들어진다.

 

MANDATORY

: 이미 진행중인 메소드(상위 메소드)에 트렌젝션이 없다면 에러 발생. 호출전에 반드시 진행 중인 트렌젝션이 있어야한다.

 

REQURED_NEW

: 이미 진행중인 트렌젝션이 있어도 항상 새로운 트렌젝션(createCustomer, findOne)이 생겨난다. 진행 중이던 트렌젝션은 잠시 중단된다.

: 새로운 트렌젝션에서 문제가 생기면 해당 트렌젝션에서만 rollback이 되고 이전에 트렌젝션(addCustomer)에는 영향을 주지않는다.

 

SUPPORTES

: 현재 진행중인 트렌젝션(addCustomer)이 있다면 새로운 트렌젝션을 만들지않고 해당 트렌젝션을 사용하고 없다면 트렌젝션을 만들지않는다.

 

NOT_SUPPORTED

: 현재 진행중인 트렌젝션(addCustomer)이 있어도 새로운 트렌젝션이 만들지않고 잠시 멈춰있다가 종료가되면 다시 실행된다.

 

 

트랜잭션 격리

트렌젝션이 진행 중일때 하위 트렌젝션에서 자원을 변경할때, 개별 트렌젝션의 독립성의 단계를 나눈 것.

@Transactional(isolation = Isolation.DEFAULT) // 사용하는 DBMS의 default값을 사용하겠다.
public void createCustomers(List<Customer> customers) {
    customers.forEach(customerRepository::insert);
}

명령어를 통한 defualt값 확인

https://techannotation.wordpress.com/2014/12/04/5-minutes-with-spring-transaction-isolation-level/

 

dirty reads

: 아직 수정중인 데이터(commit 되지않은 데이터)를 다른 트렌젝션에서 읽을 수 있다. rollback이 발생했을 때 문제.

 

non-repeatable

: 한 트렌젝션 내에서 같은 쿼리를 두번 사용할때, 다른 트렌젝션이 그 사이 값을 수정하면 일관되지않은 결과가 나온다.

 

phantom reads

: 한 트랜잭션안에서 일정 범위의 레코드를 여러번 읽어올때, 첫번째 쿼리에서 없던 유령의 레코드가 두번째 쿼리에서 발생한다.

 

 

출처 - 해리 : SpringBoot Part1