Spring - @Transactional 살펴보기 (1) - AOP Proxy

@Service
@RequiredArgsConstructor
public class UserService {

    private final UserRepository userRepository;
    private final UserHistoryRepository userHistoryRepository;

    public List<User> getAllUsers() {
        return userRepository.findAll();
    }

    @Transactional
    public User create(User user) {
        userRepository.save(user);
        userHistoryRepository.save(UserHistory.from(user));

        return user;
    }

}

// org.springframework.aop.framework.CglibAopProxy#buildProxy
private Object buildProxy(@Nullable ClassLoader classLoader, boolean classOnly) {
  if (logger.isTraceEnabled()) {
    logger.trace("Creating CGLIB proxy: " + String.valueOf(this.advised.getTargetSource()));
  }

  try {
    ...

    this.validateClassIfNecessary(proxySuperClass, classLoader);
    Enhancer enhancer = this.createEnhancer();

    ...

    enhancer.setSuperclass(proxySuperClass);
    enhancer.setInterfaces(AopProxyUtils.completeProxiedInterfaces(this.advised));
    enhancer.setNamingPolicy(SpringNamingPolicy.INSTANCE);
    enhancer.setAttemptLoad(true);
    enhancer.setStrategy(KotlinDetector.isKotlinType(proxySuperClass) ? new ClassLoaderAwareGeneratorStrategy(classLoader) : new ClassLoaderAwareGeneratorStrategy(classLoader, undeclaredThrowableStrategy));
    Callback[] callbacks = this.getCallbacks(rootClass);
    Class<?>[] types = new Class[callbacks.length];

    for(x = 0; x < types.length; ++x) {
      types[x] = callbacks[x].getClass();
    }

    ProxyCallbackFilter filter = new ProxyCallbackFilter(this.advised.getConfigurationOnlyCopy(), this.fixedInterceptorMap, this.fixedInterceptorOffset);
    enhancer.setCallbackFilter(filter);
    enhancer.setCallbackTypes(types);

    Object var22;
    try {
      var22 = classOnly ? this.createProxyClass(enhancer) : this.createProxyClassAndInstance(enhancer, callbacks);
    } finally {
      filter.advised.reduceToAdvisorKey();
    }

    return var22;
  }

  ...
}

// org.springframework.cglib.proxy.Enhancer
public void setCallback(final Callback callback) {
    this.setCallbacks(new Callback[]{callback});
}

public void setCallbacks(Callback[] callbacks) {
    if (callbacks != null && callbacks.length == 0) {
        throw new IllegalArgumentException("Array cannot be empty");
    } else {
        this.callbacks = callbacks;
    }
}

// org.springframework.cglib.proxy.MethodInterceptor
public interface MethodInterceptor extends Callback {
    Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable;
}

public class TempInterceptor implements MethodInterceptor {

    @Override
    public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
        System.out.println("Before method: " + method.getName());
        Object result = proxy.invokeSuper(obj, args); // 원본 메서드 호출
        System.out.println("After method: " + method.getName());
        return result;
    }

}

import org.springframework.cglib.proxy.Enhancer;

public class Main {

    public static void main(String[] args) {
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(TempService.class); // 원본 클래스 지정
        enhancer.setCallback(new TempInterceptor()); // 인터셉터 지정

        // 프록시 인스턴스 생성
        TempService proxy = (TempService) enhancer.create(); // TempService$$EnhancerByCGLIB$$

        // 프록시 메서드 호출 (intercept → invokeSuper → 원본 호출)
        proxy.hello("CGLIB");
    }

}

// org.springframework.transaction.interceptor.TransactionInterceptor
public class TransactionInterceptor extends TransactionAspectSupport implements MethodInterceptor, Serializable {
  public TransactionInterceptor() {
  }

  public TransactionInterceptor(TransactionManager ptm, TransactionAttributeSource tas) {
    this.setTransactionManager(ptm);
    this.setTransactionAttributeSource(tas);
  }

  ...

  @Nullable
  public Object invoke(MethodInvocation invocation) throws Throwable {
    Class<?> targetClass = invocation.getThis() != null ? AopUtils.getTargetClass(invocation.getThis()) : null;
    Method var10001 = invocation.getMethod();
    Objects.requireNonNull(invocation);
    return this.invokeWithinTransaction(var10001, targetClass, invocation::proceed);
  }

  ...

}

// org.springframework.transaction.interceptor.TransactionAspectSupport#invokeWithinTransaction
@Nullable
protected Object invokeWithinTransaction(Method method, @Nullable Class<?> targetClass, final InvocationCallback invocation) throws Throwable {
  TransactionAttributeSource tas = this.getTransactionAttributeSource();
  TransactionAttribute txAttr = tas != null ? tas.getTransactionAttribute(method, targetClass) : null;
  TransactionManager tm = this.determineTransactionManager(txAttr, targetClass);
  if (this.reactiveAdapterRegistry != null && tm instanceof ReactiveTransactionManager rtm) {
    ...
  } else {
    PlatformTransactionManager ptm = this.asPlatformTransactionManager(tm);
    String joinpointIdentification = this.methodIdentification(method, targetClass, txAttr);
    if (txAttr != null && ptm instanceof CallbackPreferringPlatformTransactionManager cpptm) {
      ...
    } else {
      TransactionInfo txInfo = this.createTransactionIfNecessary(ptm, txAttr, joinpointIdentification);

      Object retVal;
      try {
        retVal = invocation.proceedWithInvocation();
      } catch (Throwable var23) {
        this.completeTransactionAfterThrowing(txInfo, var23);
        throw var23;
      } finally {
        this.cleanupTransactionInfo(txInfo);
      }

      if (retVal != null && txAttr != null) {
        TransactionStatus status = txInfo.getTransactionStatus();
        if (status != null) {
          ...
        }
      }

      this.commitTransactionAfterReturning(txInfo);
      return retVal;
    }
  }
}