Java 做一个；“交易行为”；内部阶级

我有一个Spring+Hibernate+MySQL web应用程序，目前它只是一个hello world测试区域

我的一个服务类实现了此方法：

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;
    }

但这是一个内部类：如何从中传入和传出数据？我的意思是，我怎样才能从那个交易中得到结果“l”列表？您可以用多种方法来回答这个特定的案例，但我需要的是一个通用的TransactionAction或一个不同的解决方案，它允许我编写实际的数据库代码，而不必每次都编写相同的无聊代码

请不要回答“为什么不使用@Transactional annotations或AOP tx:advice配置？”因为我不能！

---

为什么？我在谷歌AppEngine上，而那些酷家伙并不那么酷：对javax.naming包的访问被禁用，以及一些声明性事务的伟大方式触及了它-\

您可以使用代理对象模拟基本的AOP机制。比如

这是一个嘲弄。但我真的怀疑它是否能与Spring或GAE配合得很好。请注意，您需要为代理使用接口

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;
    }
}

接口Dao{
列出getAllFoo（）；
}
公共类MyDao实现了Dao{
公共MyDao（）{
}
公共列表getAllFoo（）{
//…从数据库获取foo列表。无需使用事务
}
公共静态void main（字符串[]args）{
Dao=newmydao（）；
InvocationHandler=newTransactionProxyHandler（dao）；
Dao proxy=（Dao）proxy.newProxyInstance（MyDao.class.getClassLoader（），MyDao.class.getInterfaces（），handler）；
List all=proxy.getAllFoo（）；
}
}
类TransactionProxyHandler实现InvocationHandler{
受保护对象委托；
PlatformTransactionManager txm=新的PlatformTransactionManager（）；
公共事务ProxyHandler（对象委托）{
this.delegate=委托；
}
公共对象调用（对象代理、方法、对象[]参数）
扔掉的{
TransactionStatus status=txm.getTransaction（）；
对象res=null；
试一试{
res=method.invoke（委托，参数）；
提交（状态）；
}捕获（例外e）{
e、 printStackTrace（）；
txm.回滚（状态）；
}
返回res；
}
}

很有趣，但是。。。。你能用一点伪代码来编辑你的答案吗？只是为了了解我的情况。

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;
    }
}