org.springframework.aop.framework.ProxyFactory

private void testAdvice(Advisor advisor, LogUserAdvice logAdvice, TestService target, String message, boolean proxyTargetClreplaced) throws Exception {
    logAdvice.reset();
    ProxyFactory factory = new ProxyFactory(target);
    factory.setProxyTargetClreplaced(proxyTargetClreplaced);
    factory.addAdvisor(advisor);
    TestService bean = (TestService) factory.getProxy();
    replacedertEquals(0, logAdvice.getCountThrows());
    try {
        bean.sayHello();
        fail("Expected exception");
    } catch (TestException ex) {
        replacedertEquals(message, ex.getMessage());
    }
    replacedertEquals(1, logAdvice.getCountThrows());
}

private void testException(Exception expected) throws Exception {
    LocalInterfaceWithBusinessMethods ejb = mock(LocalInterfaceWithBusinessMethods.clreplaced);
    given(ejb.targetMethod()).willThrow(expected);
    String jndiName = "foobar";
    Context mockContext = mockContext(jndiName, ejb);
    LocalSlsbInvokerInterceptor si = configuredInterceptor(mockContext, jndiName);
    ProxyFactory pf = new ProxyFactory(new Clreplaced<?>[] { LocalInterfaceWithBusinessMethods.clreplaced });
    pf.addAdvice(si);
    LocalInterfaceWithBusinessMethods target = (LocalInterfaceWithBusinessMethods) pf.getProxy();
    try {
        target.targetMethod();
        fail("Should have thrown exception");
    } catch (Exception thrown) {
        replacedertTrue(thrown == expected);
    }
    verify(mockContext).close();
}

/**
 * Subclreplacedes may choose to implement this: for example,
 * to change the interfaces exposed.
 * <p>The default implementation is empty.
 * @param proxyFactory a ProxyFactory that is already configured with
 * TargetSource and interfaces and will be used to create the proxy
 * immediately after this method returns
 */
protected void customizeProxyFactory(ProxyFactory proxyFactory) {
}

private void testAdvice(Advisor advisor, LogUserAdvice logAdvice, TestService target, String message, boolean proxyTargetClreplaced) throws Exception {
    logAdvice.reset();
    ProxyFactory factory = new ProxyFactory(target);
    factory.setProxyTargetClreplaced(proxyTargetClreplaced);
    factory.addAdvisor(advisor);
    TestService bean = (TestService) factory.getProxy();
    replacedertThat(logAdvice.getCountThrows()).isEqualTo(0);
    replacedertThatExceptionOfType(TestException.clreplaced).isThrownBy(bean::sayHello).withMessage(message);
    replacedertThat(logAdvice.getCountThrows()).isEqualTo(1);
}

private void testException(Exception expected) throws Exception {
    LocalInterfaceWithBusinessMethods ejb = mock(LocalInterfaceWithBusinessMethods.clreplaced);
    given(ejb.targetMethod()).willThrow(expected);
    String jndiName = "foobar";
    Context mockContext = mockContext(jndiName, ejb);
    LocalSlsbInvokerInterceptor si = configuredInterceptor(mockContext, jndiName);
    ProxyFactory pf = new ProxyFactory(new Clreplaced<?>[] { LocalInterfaceWithBusinessMethods.clreplaced });
    pf.addAdvice(si);
    LocalInterfaceWithBusinessMethods target = (LocalInterfaceWithBusinessMethods) pf.getProxy();
    replacedertThatExceptionOfType(Exception.clreplaced).isThrownBy(target::targetMethod).satisfies(ex -> replacedertThat(ex).isSameAs(expected));
    verify(mockContext).close();
}

private void testAdvice(Advisor advisor, LogUserAdvice logAdvice, TestService target, String message, boolean proxyTargetClreplaced) throws Exception {
    logAdvice.reset();
    ProxyFactory factory = new ProxyFactory(target);
    factory.setProxyTargetClreplaced(proxyTargetClreplaced);
    factory.addAdvisor(advisor);
    TestService bean = (TestService) factory.getProxy();
    replacedertThat(logAdvice.getCountThrows()).isEqualTo(0);
    replacedertThatExceptionOfType(TestException.clreplaced).isThrownBy(bean::sayHello).withMessageContaining(message);
    replacedertThat(logAdvice.getCountThrows()).isEqualTo(1);
}

/**
 * Subclreplacedes may choose to implement this: for example, to change the interfaces exposed.
 * <p>The default implementation is empty.
 *
 * @param proxyFactory a ProxyFactory that is already configured with TargetSource and
 *                     interfaces and will be used to create the proxy immediately after this
 *                     method returns
 */
protected void customizeProxyFactory(ProxyFactory proxyFactory) {
}

void configure(ProxyFactory proxyFactory, RestClientInterceptor restClientInterceptor) {
    proxyFactory.addAdvice(retryOperationsInterceptor);
    restClientInterceptor.setRetryEnabled(true);
}

public static void main(String[] args) throws Exception {
    ThrowsAdviceDemo instance = new ThrowsAdviceDemo();
    ProxyFactory proxyFactory = new ProxyFactory(instance);
    proxyFactory.addAdvice(new MyThrowsAdvice());
    ThrowsAdviceDemo proxy = (ThrowsAdviceDemo) proxyFactory.getProxy();
    proxy.execute();
    proxy.execute();
}

public static void main(String[] args) {
    DefaultEchoService defaultEchoService = new DefaultEchoService();
    // 注入目标对象（被代理）
    ProxyFactory proxyFactory = new ProxyFactory(defaultEchoService);
    proxyFactory.setTargetClreplaced(DefaultEchoService.clreplaced);
    // 添加 Advice 实现 MethodInterceptor < Interceptor < Advice
    proxyFactory.addAdvice(new EchoServiceMethodInterceptor());
    // 获取代理对象
    EchoService echoService = (EchoService) proxyFactory.getProxy();
    System.out.println(echoService.echo("Hello,World"));
}

private void testAdvice(Advisor advisor, LogUserAdvice logAdvice, TestService target, String message, boolean proxyTargetClreplaced) throws Exception {
    logAdvice.reset();
    ProxyFactory factory = new ProxyFactory(target);
    factory.setProxyTargetClreplaced(proxyTargetClreplaced);
    factory.addAdvisor(advisor);
    TestService bean = (TestService) factory.getProxy();
    replacedertEquals(0, logAdvice.getCountThrows());
    try {
        bean.sayHello();
        fail("Expected exception");
    } catch (TestException e) {
        replacedertEquals(message, e.getMessage());
    }
    replacedertEquals(1, logAdvice.getCountThrows());
}

/**
 * Subclreplacedes may choose to implement this: for example,
 * to change the interfaces exposed.
 * <p>The default implementation is empty.
 * @param proxyFactory ProxyFactory that is already configured with
 * TargetSource and interfaces and will be used to create the proxy
 * immediately after this method returns
 */
protected void customizeProxyFactory(ProxyFactory proxyFactory) {
}

@Override
public void postProcess(ProxyFactory factory, RepositoryInformation repositoryInformation) {
    factory.addAdvice(new JpaEnreplacedyGraphMethodInterceptor(enreplacedyManager, repositoryInformation.getDomainType()));
}

static JPQLQuery<?> proxy(JPQLQuery<?> countQuery) {
    ProxyFactory proxyFactory = new ProxyFactory(countQuery);
    proxyFactory.addAdvice(INSTANCE);
    return (JPQLQuery<?>) proxyFactory.getProxy();
}

@Override
public void afterPropertiesSet() {
    super.afterPropertiesSet();
    Clreplaced<?> ifc = getServiceInterface();
    replacedert.notNull(ifc, "Property 'serviceInterface' is required");
    // Build a proxy that also exposes the JAX-WS BindingProvider interface.
    ProxyFactory pf = new ProxyFactory();
    pf.addInterface(ifc);
    pf.addInterface(BindingProvider.clreplaced);
    pf.addAdvice(this);
    this.serviceProxy = pf.getProxy(getBeanClreplacedLoader());
}

protected void addPersistenceExceptionTranslation(ProxyFactory pf, PersistenceExceptionTranslator pet) {
    pf.addAdvisor(new PersistenceExceptionTranslationAdvisor(pet, Repository.clreplaced));
}

/**
 * As of 4.2, this method adds {@link TransactionalProxy} to the set of
 * proxy interfaces in order to avoid re-processing of transaction metadata.
 */
@Override
protected void postProcessProxyFactory(ProxyFactory proxyFactory) {
    proxyFactory.addInterface(TransactionalProxy.clreplaced);
}

private Foo cglibProxy(Foo foo) {
    ProxyFactory pf = new ProxyFactory();
    pf.setTarget(foo);
    pf.setProxyTargetClreplaced(true);
    Foo proxy = (Foo) pf.getProxy();
    replacedertTrue("Proxy is a CGLIB proxy", AopUtils.isCglibProxy(proxy));
    replacedertThat(proxy, instanceOf(FooImpl.clreplaced));
    return proxy;
}

private Foo jdkProxy(Foo foo) {
    ProxyFactory pf = new ProxyFactory();
    pf.setTarget(foo);
    pf.addInterface(Foo.clreplaced);
    Foo proxy = (Foo) pf.getProxy();
    replacedertTrue("Proxy is a JDK dynamic proxy", AopUtils.isJdkDynamicProxy(proxy));
    replacedertThat(proxy, instanceOf(Foo.clreplaced));
    return proxy;
}

@Test
public void testMethodValidationInterceptor() {
    MyValidBean bean = new MyValidBean();
    ProxyFactory proxyFactory = new ProxyFactory(bean);
    proxyFactory.addAdvice(new MethodValidationInterceptor());
    proxyFactory.addAdvisor(new AsyncAnnotationAdvisor());
    doTestProxyValidation((MyValidInterface) proxyFactory.getProxy());
}

protected Object configuredProxy(SimpleRemoteSlsbInvokerInterceptor si, Clreplaced<?> ifc) throws NamingException {
    si.afterPropertiesSet();
    ProxyFactory pf = new ProxyFactory(new Clreplaced<?>[] { ifc });
    pf.addAdvice(si);
    return pf.getProxy();
}

@Test
public void testInvokesMethodOnEjbInstanceWithSeparateBusinessMethods() throws Exception {
    Object retVal = new Object();
    LocalInterface ejb = mock(LocalInterface.clreplaced);
    given(ejb.targetMethod()).willReturn(retVal);
    String jndiName = "foobar";
    Context mockContext = mockContext(jndiName, ejb);
    LocalSlsbInvokerInterceptor si = configuredInterceptor(mockContext, jndiName);
    ProxyFactory pf = new ProxyFactory(new Clreplaced<?>[] { BusinessMethods.clreplaced });
    pf.addAdvice(si);
    BusinessMethods target = (BusinessMethods) pf.getProxy();
    replacedertTrue(target.targetMethod() == retVal);
    verify(mockContext).close();
    verify(ejb).remove();
}

@Test
public void testInvokesMethodOnEjbInstance() throws Exception {
    Object retVal = new Object();
    LocalInterfaceWithBusinessMethods ejb = mock(LocalInterfaceWithBusinessMethods.clreplaced);
    given(ejb.targetMethod()).willReturn(retVal);
    String jndiName = "foobar";
    Context mockContext = mockContext(jndiName, ejb);
    LocalSlsbInvokerInterceptor si = configuredInterceptor(mockContext, jndiName);
    ProxyFactory pf = new ProxyFactory(new Clreplaced<?>[] { BusinessMethods.clreplaced });
    pf.addAdvice(si);
    BusinessMethods target = (BusinessMethods) pf.getProxy();
    replacedertTrue(target.targetMethod() == retVal);
    verify(mockContext).close();
    verify(ejb).remove();
}

/**
 * Create an empty pointcut, populating instance variables.
 */
@Before
public void setup() {
    ProxyFactory pf = new ProxyFactory(new SerializablePerson());
    nop = new SerializableNopInterceptor();
    pc = new NameMatchMethodPointcut();
    pf.addAdvisor(new DefaultPointcutAdvisor(pc, nop));
    proxied = (Person) pf.getProxy();
}

@Test
public void testAnnotationOnDynamicProxyMethod() throws Exception {
    String expression = "@annotation(test.annotation.transaction.Tx)";
    AspectJExpressionPointcut ajexp = new AspectJExpressionPointcut();
    ajexp.setExpression(expression);
    ProxyFactory factory = new ProxyFactory(new BeanA());
    factory.setProxyTargetClreplaced(false);
    IBeanA proxy = (IBeanA) factory.getProxy();
    replacedertTrue(ajexp.matches(IBeanA.clreplaced.getMethod("getAge"), proxy.getClreplaced()));
}

@Test
public void testAnnotationOnCglibProxyMethod() throws Exception {
    String expression = "@annotation(test.annotation.transaction.Tx)";
    AspectJExpressionPointcut ajexp = new AspectJExpressionPointcut();
    ajexp.setExpression(expression);
    ProxyFactory factory = new ProxyFactory(new BeanA());
    factory.setProxyTargetClreplaced(true);
    BeanA proxy = (BeanA) factory.getProxy();
    replacedertTrue(ajexp.matches(BeanA.clreplaced.getMethod("getAge"), proxy.getClreplaced()));
}

@Override
protected ProxyFactory prepareProxyFactory(Object bean, String beanName) {
    if (this.beanFactory != null) {
        AutoProxyUtils.exposeTargetClreplaced(this.beanFactory, beanName, bean.getClreplaced());
    }
    ProxyFactory proxyFactory = super.prepareProxyFactory(bean, beanName);
    if (!proxyFactory.isProxyTargetClreplaced() && this.beanFactory != null && AutoProxyUtils.shouldProxyTargetClreplaced(this.beanFactory, beanName)) {
        proxyFactory.setProxyTargetClreplaced(true);
    }
    return proxyFactory;
}

@Override
protected void customizeProxyFactory(ProxyFactory proxyFactory) {
    proxyFactory.setProxyTargetClreplaced(true);
}

private Foo cglibProxy(Foo foo) {
    ProxyFactory pf = new ProxyFactory();
    pf.setTarget(foo);
    pf.setProxyTargetClreplaced(true);
    Foo proxy = (Foo) pf.getProxy();
    replacedertThat(AopUtils.isCglibProxy(proxy)).as("Proxy is a CGLIB proxy").isTrue();
    replacedertThat(proxy).isInstanceOf(FooImpl.clreplaced);
    return proxy;
}

private Foo jdkProxy(Foo foo) {
    ProxyFactory pf = new ProxyFactory();
    pf.setTarget(foo);
    pf.addInterface(Foo.clreplaced);
    Foo proxy = (Foo) pf.getProxy();
    replacedertThat(AopUtils.isJdkDynamicProxy(proxy)).as("Proxy is a JDK dynamic proxy").isTrue();
    replacedertThat(proxy).isInstanceOf(Foo.clreplaced);
    return proxy;
}

@Test
public void testMethodValidationInterceptor() {
    MyValidBean bean = new MyValidBean();
    ProxyFactory proxyFactory = new ProxyFactory(bean);
    proxyFactory.addAdvice(new MethodValidationInterceptor());
    proxyFactory.addAdvisor(new AsyncAnnotationAdvisor());
    doTestProxyValidation((MyValidInterface<?>) proxyFactory.getProxy());
}

@Test
public void testInvokesMethodOnEjbInstanceWithSeparateBusinessMethods() throws Exception {
    Object retVal = new Object();
    LocalInterface ejb = mock(LocalInterface.clreplaced);
    given(ejb.targetMethod()).willReturn(retVal);
    String jndiName = "foobar";
    Context mockContext = mockContext(jndiName, ejb);
    LocalSlsbInvokerInterceptor si = configuredInterceptor(mockContext, jndiName);
    ProxyFactory pf = new ProxyFactory(new Clreplaced<?>[] { BusinessMethods.clreplaced });
    pf.addAdvice(si);
    BusinessMethods target = (BusinessMethods) pf.getProxy();
    replacedertThat(target.targetMethod() == retVal).isTrue();
    verify(mockContext).close();
    verify(ejb).remove();
}

@Test
public void testInvokesMethodOnEjbInstance() throws Exception {
    Object retVal = new Object();
    LocalInterfaceWithBusinessMethods ejb = mock(LocalInterfaceWithBusinessMethods.clreplaced);
    given(ejb.targetMethod()).willReturn(retVal);
    String jndiName = "foobar";
    Context mockContext = mockContext(jndiName, ejb);
    LocalSlsbInvokerInterceptor si = configuredInterceptor(mockContext, jndiName);
    ProxyFactory pf = new ProxyFactory(new Clreplaced<?>[] { BusinessMethods.clreplaced });
    pf.addAdvice(si);
    BusinessMethods target = (BusinessMethods) pf.getProxy();
    replacedertThat(target.targetMethod() == retVal).isTrue();
    verify(mockContext).close();
    verify(ejb).remove();
}

/**
 * Create an empty pointcut, populating instance variables.
 */
@BeforeEach
public void setup() {
    ProxyFactory pf = new ProxyFactory(new SerializablePerson());
    nop = new SerializableNopInterceptor();
    pc = new NameMatchMethodPointcut();
    pf.addAdvisor(new DefaultPointcutAdvisor(pc, nop));
    proxied = (Person) pf.getProxy();
}

@Test
public void testAnnotationOnDynamicProxyMethod() throws Exception {
    String expression = "@annotation(test.annotation.transaction.Tx)";
    AspectJExpressionPointcut ajexp = new AspectJExpressionPointcut();
    ajexp.setExpression(expression);
    ProxyFactory factory = new ProxyFactory(new BeanA());
    factory.setProxyTargetClreplaced(false);
    IBeanA proxy = (IBeanA) factory.getProxy();
    replacedertThat(ajexp.matches(IBeanA.clreplaced.getMethod("getAge"), proxy.getClreplaced())).isTrue();
}

@Test
public void testAnnotationOnCglibProxyMethod() throws Exception {
    String expression = "@annotation(test.annotation.transaction.Tx)";
    AspectJExpressionPointcut ajexp = new AspectJExpressionPointcut();
    ajexp.setExpression(expression);
    ProxyFactory factory = new ProxyFactory(new BeanA());
    factory.setProxyTargetClreplaced(true);
    BeanA proxy = (BeanA) factory.getProxy();
    replacedertThat(ajexp.matches(BeanA.clreplaced.getMethod("getAge"), proxy.getClreplaced())).isTrue();
}

public static void main(String[] args) {
    DefaultEchoService defaultEchoService = new DefaultEchoService();
    // 注入目标对象（被代理）
    ProxyFactory proxyFactory = new ProxyFactory(defaultEchoService);
    proxyFactory.setTargetClreplaced(DefaultEchoService.clreplaced);
    // 添加 Advice 实现 MethodInterceptor < Interceptor < Advice
    proxyFactory.addAdvice(new EchoServiceMethodInterceptor());
    proxyFactory.addListener(new AdvisedSupportListener() {

        @Override
        public void activated(AdvisedSupport advised) {
            System.out.println("AOP 配置对象：" + advised + " 已激活");
        }

        @Override
        public void adviceChanged(AdvisedSupport advised) {
            System.out.println("AOP 配置对象：" + advised + " 已变化");
        }
    });
    // 获取代理对象
    // 激活事件触发 createAopProxy() <- getProxy()
    EchoService echoService = (EchoService) proxyFactory.getProxy();
    proxyFactory.addAdvice(new Advice() {
    });
}

@Override
public void afterPropertiesSet() {
    super.afterPropertiesSet();
    // Build a proxy that also exposes the JAX-WS BindingProvider interface.
    ProxyFactory pf = new ProxyFactory();
    pf.addInterface(getServiceInterface());
    pf.addInterface(BindingProvider.clreplaced);
    pf.addAdvice(this);
    this.serviceProxy = pf.getProxy(getBeanClreplacedLoader());
}

/**
 * Create an empty pointcut, populating instance variables.
 */
@Before
public void setUp() {
    ProxyFactory pf = new ProxyFactory(new SerializablePerson());
    nop = new SerializableNopInterceptor();
    pc = new NameMatchMethodPointcut();
    pf.addAdvisor(new DefaultPointcutAdvisor(pc, nop));
    proxied = (Person) pf.getProxy();
}

@Test
public void callOnProxy() {
    ProxyFactory factory = new ProxyFactory(new Foo());
    // factory.addInterface(FooInterface.clreplaced);
    // factory.addAdvisor(new LoggingAspect());
    Foo pojo = (Foo) factory.getProxy();
    String s = pojo.fooBar();
    replacedertThat(s).isEqualTo("foobar");
}

/**
 * Builds a proxy on enreplacedy manager which is aware of methods that can make use of query hints.
 *
 * @param enreplacedyManager The enreplacedy manager to proxy
 * @return The proxied enreplacedy manager
 */
static EnreplacedyManager proxy(EnreplacedyManager enreplacedyManager) {
    ProxyFactory proxyFactory = new ProxyFactory(enreplacedyManager);
    proxyFactory.addAdvice(new RepositoryEnreplacedyManagerEnreplacedyGraphInjector());
    return (EnreplacedyManager) proxyFactory.getProxy();
}

private ServletContext getToolboxConfigFileAwareServletContext() {
    ProxyFactory factory = new ProxyFactory();
    factory.setTarget(getServletContext());
    factory.addAdvice(new GetResourceMethodInterceptor(getToolboxConfigLocation()));
    return (ServletContext) factory.getProxy(getClreplaced().getClreplacedLoader());
}

public static EnreplacedyManager createProxy(EnreplacedyManager target, StateListener stateListener, Identifier identifier) {
    ProxyFactory proxyFactory = new ProxyFactory(target);
    proxyFactory.addAdvice(new EnreplacedyManagerMethodInterceptor(stateListener, identifier));
    // TODO: switch to use cglib proxy via setTargetClreplaced/setProxyTargetClreplaced
    return (EnreplacedyManager) proxyFactory.getProxy();
}

/**
 * Apply a lock (preferably a read lock allowing multiple concurrent access) to the bean. Callers should replace the
 * bean input with the output.
 *
 * @param bean the bean to lock
 * @param lock the lock to apply
 * @return a proxy that locks while its methods are executed
 */
private Object getDisposalLockProxy(Object bean, final Lock lock) {
    ProxyFactory factory = new ProxyFactory(bean);
    factory.setProxyTargetClreplaced(proxyTargetClreplaced);
    factory.addAdvice(new MethodInterceptor() {

        public Object invoke(MethodInvocation invocation) throws Throwable {
            lock.lock();
            try {
                return invocation.proceed();
            } finally {
                lock.unlock();
            }
        }
    });
    return factory.getProxy();
}

@Override
protected Object advised(Object target, ReactiveTransactionManager ptm, TransactionAttributeSource[] tas) {
    TransactionInterceptor ti = new TransactionInterceptor();
    ti.setTransactionManager(ptm);
    ti.setTransactionAttributeSources(tas);
    ProxyFactory pf = new ProxyFactory(target);
    pf.addAdvice(0, ti);
    return pf.getProxy();
}

/**
 * Template method to create an advised object given the
 * target object and transaction setup.
 * Creates a TransactionInterceptor and applies it.
 */
@Override
protected Object advised(Object target, ReactiveTransactionManager ptm, TransactionAttributeSource tas) {
    TransactionInterceptor ti = new TransactionInterceptor();
    ti.setTransactionManager(ptm);
    replacedertThat(ti.getTransactionManager()).isEqualTo(ptm);
    ti.setTransactionAttributeSource(tas);
    replacedertThat(ti.getTransactionAttributeSource()).isEqualTo(tas);
    ProxyFactory pf = new ProxyFactory(target);
    pf.addAdvice(0, ti);
    return pf.getProxy();
}

@Test
public void clreplacedLevelOnly() {
    ProxyFactory proxyFactory = new ProxyFactory();
    proxyFactory.setTarget(new TestClreplacedLevelOnly());
    proxyFactory.addAdvice(this.ti);
    TestClreplacedLevelOnly proxy = (TestClreplacedLevelOnly) proxyFactory.getProxy();
    proxy.doSomething();
    replacedertGetTransactionAndCommitCount(1);
    proxy.doSomethingElse();
    replacedertGetTransactionAndCommitCount(2);
    proxy.doSomething();
    replacedertGetTransactionAndCommitCount(3);
    proxy.doSomethingElse();
    replacedertGetTransactionAndCommitCount(4);
}

@Test
public void withCommitOnCheckedException() {
    ProxyFactory proxyFactory = new ProxyFactory();
    proxyFactory.setTarget(new TestWithExceptions());
    proxyFactory.addAdvice(this.ti);
    TestWithExceptions proxy = (TestWithExceptions) proxyFactory.getProxy();
    try {
        proxy.doSomethingElseWithCheckedException();
        fail("Should throw Exception");
    } catch (Exception ex) {
        replacedertGetTransactionAndCommitCount(1);
    }
}

@Test
public void crossClreplacedInterfaceOnJdkProxy() {
    ProxyFactory proxyFactory = new ProxyFactory();
    proxyFactory.setTarget(new OtherServiceImpl());
    proxyFactory.addInterface(OtherService.clreplaced);
    proxyFactory.addAdvice(this.ti);
    OtherService otherService = (OtherService) proxyFactory.getProxy();
    otherService.foo();
    replacedertGetTransactionAndCommitCount(1);
}

@Test
public void withVavrTryCheckedExceptionAndRollbackRule() {
    ProxyFactory proxyFactory = new ProxyFactory();
    proxyFactory.setTarget(new TestWithVavrTry());
    proxyFactory.addAdvice(this.ti);
    TestWithVavrTry proxy = (TestWithVavrTry) proxyFactory.getProxy();
    proxy.doSomethingErroneousWithCheckedExceptionAndRollbackRule();
    replacedertGetTransactionAndRollbackCount(1);
}

See More Examples