使用Annotation设计持久层

这篇文章的想法来自于过去的两篇文章：《设计自己的mvc框架》《设计模式之事务处理》

链接：

http://www.javaresearch.org/article/59935.htm

http://www.javaresearch.org/article/59043.htm

代码下载同样在www.126.com的邮箱里，用户名 sharesources 密码 javafans

    本文只是学习性质的文章，我一开始的想法就是修改《设计模式之事务处理》，提供annotation来提供事务支持，支持到方法级别。通过引入一个 @transaction标注，如果被此标注的方法将自动享受事务处理。目的是学习下annotation和加深下对声明式事务处理的理解。

    annotation是jdk5引入的新特性，现在越来越多的框架采用此特性来代替烦琐的xml配置文件，比如hibernate,ejb3, spring等。对annotation不了解，请阅读ibm网站上的文章，还有推荐javaeye的annotation专栏：http: //www.javaeye.com/subject/annotation

    代码的示例是一个简单的用户管理例子。

    首先，环境是mysql+jdk5+myeclipse5+tomcat5，在mysql中建立一张表adminusers:

    create table adminusers(id int(10) auto_increment not null primary key,

     name varchar(10) not null,

     password varchar(10) not null,

     user_type varchar(10));

    然后在tomcat下建立一个数据源，把代码中的strutslet.xml拷贝到tomcat安装目录下的 /conf/catalina/localhost目录里，请自行修改文件中的数据库用户名和密码，以及数据库名称。另外，把mysql的 jdbc驱动拷贝到tomcat安装目录下的common/lib目录。这样数据源就建好了。在web.xml中引用：

   <resource-ref>

        <description>db connection</description>

        <res-ref-name>jdbc/test</res-ref-name>

        <res-type>javax.sql.datasource</res-type>

        <res-auth>container</res-auth>

    </resource-ref>

    我的例子只是在《设计模式之事务处理》的基础上改造的，在那篇文章里，我讲解了自己对声明式事务处理的理解，并利用动态代理实现了一个 transactionwrapper(事务包装器)，通过业务代理工厂提供两种版本的业务对象：经过事务包装的和未经过事务包装的。我们在默认情况下包装业务对象中的所有方法，但实际情况是，业务对象中的很多方法不用跟数据库打交道，它们根本不需要包装在一个事务上下文中，这就引出了，我们为什么不提供一种方式来配置哪些方法需要事务控制而哪些并不需要？甚至提供事务隔离级别的声明？很自然的想法就是提供一个配置文件，类似spring式的事务声明。既然jdk5已经引入annotation，相比于配置文件的烦琐和容易出错，我们定义一个@transaction的annotation来提供此功能。

    看下transaction.java的代码：

    package com.strutslet.db;

    import java.lang.annotation.documented;

    import java.lang.annotation.elementtype;

    import java.lang.annotation.retention;

    import java.lang.annotation.retentionpolicy;

    import java.lang.annotation.target;

    import java.sql.connection;

    @target(elementtype.method)

    @retention(retentionpolicy.runtime)

    @documented

    public @interface transaction {

       //事务隔离级别，默认为read_committed

       public int level() default connection.transaction_read_committed    ;

    }

@transaction 标注只有一个属性level，level表示事务的隔离级别，默认为read_committed（也是一般jdbc驱动的默认级别，jdbc驱动默认级别一般于数据库的隔离级别一致）。 @target(elementtype.method)表示此标注作用于方法级别， @retention(retentionpolicy.runtime)表示在运行时，此标注的信息将被加载进jvm并可以通过annotation的 api读取。我们在运行时读取annotation的信息，根据隔离级别和被标注的方法名决定是否将业务对象的方法加进事务控制。我们只要稍微修改下 transactionwrapper:

//transactionwrapper.java

package com.strutslet.db;

import java.lang.annotation.annotation;

import java.lang.reflect.invocationhandler;

import java.lang.reflect.method;

import java.lang.reflect.proxy;

import java.sql.connection;

import java.sql.sqlexception;

import com.strutslet.exception.systemexception;

public class transactionwrapper {

    public static object decorate(object delegate) {

        return proxy.newproxyinstance(delegate.getclass().getclassloader(),

                delegate.getclass().getinterfaces(), new xawrapperhandler(

                        delegate));

    static final class xawrapperhandler implements invocationhandler {

        private final object delegate;

        xawrapperhandler(object delegate) {

            // cache the wrapped delegate, so we can pass method invocations

            // to it.

            this.delegate = delegate;

        }

        public object invoke(object proxy, method method, object[] args)

                throws throwable {

            object result = null;

            connection con = connectionmanager.getconnection();

            //得到transaction标注 

            transaction transaction = method.getannotation(transaction.class);

            //如果不为空，说明代理对象调用的方法需要事务控制。

            if (transaction != null) {

                // system.out.println("transaction.." + con.tostring());

                // 得到事务隔离级别信息

                int level = transaction.level();

                try {

                    if (con.getautocommit())

                        con.setautocommit(false);

                    //设置事务隔离级别

                    con.settransactionisolation(level);

                    //调用原始对象的业务方法

                    result = method.invoke(delegate, args);

                    con.commit();

                    con.setautocommit(true);

                } catch (sqlexception se) {

                    // rollback exception will be thrown by the invoke method

                    con.rollback();

                    throw new systemexception(se);

                } catch (exception e) {

                    throw new systemexception(e);

                }

            } else {

                result = method.invoke(delegate, args);

            }

            return result;

}

现在，看下我们的usermanager业务接口，请注意，我们是使用动态代理，只能代理接口，所以要把@transaction标注是接口中的业务方法（与ejb3中的remote,local接口类似的道理）:

package com.strutslet.demo.service;

import com.strutslet.db.transaction;

import com.strutslet.demo.domain.adminuser;

public interface usermanager {

    //查询，不需要事务控制

    public boolean checkuser(string name, string password) throws sqlexception;

    //新增一个用户，需要事务控制，默认级别

    @transaction

    public boolean adduser(adminuser user) throws sqlexception;

要把adduser改成其他事务隔离级别（比如oracle的serializable级别），稍微修改下：@transaction(level=connection.transaction_serializable)

public boolean adduser(adminuser user) throws sqlexception;

不准备详细解释例子的业务流程，不过是登录和增加用户两个业务方法，看下就明白。阅读本文前最好已经读过开头提过的两篇文章。我相信代码是最好的解释：）

文章转自庄周梦蝶  ，原文发布5.16