Question

I’ve got a Spring + Hibernate + MySQL web application, which is just a hello-world-test-area for now.

One of my Service classes implements this method:

public List<Offerta> tutte() {
        List<Offerta> tutte = null;
        TransactionStatus status = txm.getTransaction( new DefaultTransactionDefinition() );
        try {
            tutte = dao.getAll(Offerta.class);
            txm.commit(status);
        } catch (Exception e) {
            e.printStackTrace();
            txm.rollback(status);
        }
        return tutte;
    }

‘txm’ is an injected PlatformTransactionManager.

What I want now, is to avoid duplicating the “wrapping” transaction code in all my service’s methods!

I would like something like this:

someHelperTransactionClass.doThisInTransaction(new TransactionAction() {
  List l = dao.queryForSomething();
});

But that’s a inner class: how can I pass in and out data from it? I mean, how can I get the resulting “l” list from that TransactionAction? You could answer in a number of ways to this specific case, but what I need is a generic TransactionAction or a different solution which let me write the actual database code, without having to write each time the same boring code.

Please do not answer “Why don’t you use @Transactional annotations or AOP tx:advice configuration?” because I CAN’T!
Why? I am on Google AppEngine, and that cool guys are not so cool: the disabled access to the javax.naming package, and something in those great ways to declarative transactions touches it. :-\

Answer 1

You can imitate basic AOP mechanism using Proxy objects. Such as http://www.devx.com/Java/Article/21463/1954

This is a mock. But I really doubt it plays well with Spring or GAE. PLease note that you need to use interfaces for Proxies.

interface Dao {
    List<Foo> getAllFoo();
}

public class MyDao implements Dao {

    public MyDao() {
    }

    public List<Foo> getAllFoo() {
        //.. get list of foo from database. No need to use transactions
    }

    public static void main(String[] args) {
        Dao dao = new MyDao();
        InvocationHandler handler = new TransactionProxyHandler(dao);
        Dao proxy = (Dao) Proxy.newProxyInstance(MyDao.class.getClassLoader(), MyDao.class.getInterfaces(), handler);
        List<Foo> all = proxy.getAllFoo();
    }
}


class TransactionProxyHandler implements InvocationHandler {

    protected Object delegate;
    PlatformTransactionManager txm = new PlatformTransactionManager();

    public TransactionProxyHandler(Object delegate) {
        this.delegate = delegate;
    }

    public Object invoke(Object proxy, Method method, Object[] args)
            throws Throwable {
        TransactionStatus status = txm.getTransaction();
        Object res = null;
        try {
            res = method.invoke(delegate, args);
            txm.commit(status);
        } catch (Exception e) {
            e.printStackTrace();
            txm.rollback(status);
        }
        return res;
    }
}