具有异步方法调用的Java服务

Question

Given a FooService with read and write operations backed by a repository , I want to provide an asynchronous variant of it to be used in a Spring REST web service (potentially using Akka as it's already a candidate for other problems...).

So far I have the verbose and somewhat clunky variant

class AsyncFooService extends FooService {

    private final ExecutorService executor = Executors.newCachedThreadPool();
    private final FooService delegate = ...

    @Override
    public void writeSomeThing(Obj o) {
        executor.submit(new Runnable() {
           @Override
           public void run() {
               delegate.writeSomeThing(o);
           }
        });
    }

    // repeat same override & executor semantics for all write* routines
}

What other good variants are there in achieveing asynchronous operations to the service?

To limit the scope, let's not directly consider Proxies as they don't provide a solution in themselves.

Answer 1

As there is some Spring involved I would just use an AOP advice to automate your "clunky" approach a bit. The advice class:

public class AsyncAdvice implements MethodInterceptor {

    @Inject
    private ExecutorService executorService;

    @Override
    public Object invoke(final MethodInvocation invocation) throws Throwable {
        executor.submit(new Runnable() {
            @Override
            public void run() {
                invocation.proceed();
            }
        });
    }
}

and in applicationContext.xml:

<!-- Synchronous instance -->
<bean id="fooService" class="FooService" scope="singleton">
    <!-- Whatever -->
</bean>

<!-- Asynchronous instance -->
<bean id="asyncFooService" parent="fooService" scope="singleton"/>

<bean id="asyncAdvice" class="AsyncAdvice" scope="singleton">
    <property name="executorService" ref="..."/>
</bean>

<aop:config>
    <aop:advice pointcut="bean(asyncFooService)" and execution=(* FooService.write*(..))"
                advice="asyncAdvice"/>
</aop:config>

This is a pretty lightweight solution. Anyway, your last paragraph makes me think that yoou want a more automated solution.

Answer 2

First off I think there is a typo in your code - you're calling the same writeSomeThing() method from within the run() creating infinite loop?

Aside from this, I think this is pretty much how would you do it in plain Java - using Executors. More verbose for sure, but you could move this code to the proxy/interceptor to your sync implementation, which would submit task to executor and return control to the caller, therefore leaving sync implementation free of this non functional logic. Then you could either call sync implementation directly to get sync behavior or call proxy to get async, or perhaps proxy cold handle both depending on the parameters etc.

If you want less coding to do and having enough flexibility there are certainly options available - beside Akka, which you already mentioned, you could look at Apache Camel's SEDA queues or to any lightweight messaging solution which would let you to post tasks to the work queues for processing outside of your main thread.

Answer 3

You could build a single function using a list of methods and class.invoke.

If it is one-off, Eclipse provides code generation by template or,even better, you can write java code which read a list of function and generate the wrappers for you.