学习一下ibaties_1

    *    < Previous   Next >

Sorry, your entry can't be deleted right now. Please try again later.
February 05
学习一下ibaties_1

学习一下ibaties

转自： http://www.blogjava.net/zhaijianhui/archive/2006/07/24/59724.html

to robbin
ibatis的网站
www.ibatis.com上面可以找到很好的文档，再加上有非常不错的例子，所以使用是相当的简单。
sourceforge上面的讨论
http://swik.net/DAOhttp://www.learntechnology.net/struts-ibatis.dohttp://www.nabble.com/iBATIS-f360.htmlhttp://www.cjsdn.net/post/page?bid=20&sty=3&tpg=2&s=73&age=0https://sourceforge.net/forum/forum.php?forum_id=206693http://www.cjsdn.net/post/view?bid=11&id=172565&sty=1&tpg=1&age=0Windows
环境下的tomcat + apache配置(绝对实践操作版)

ibatis大体上可以分为两个部分:SQL Maps + Data Access Objects
我现在的项目中都用到了，它提供的jpetstore就使用了db layer,可以参考它的实现方式。
不过我觉得jpetstore的db layer实现方式还不是太好，至少它的业务逻辑层和dao层没有明显区分，在实现比较

大的项目的时候造成了程序的混乱，如果没有一个良好的模式来实现db layer 的时候，确实会造成效率的低下，

有了良好的架构，速度确实很快（特别是SQL Maps + Data Access Objects 都使用的情况）
BO层的设计已经不是什么新鲜的了，但我觉得它确实可以很好的和DaoManager结合起来，通过DaoManager->SQL

map->jdbc
它的两个核心的配置文件：dao.xml+SqlMapConfig.xml
通过灵活的配置文件的组合可以实现数据库不同的访问组合
比如：一个dao.xml可以对应多个SqlMapConfig.xml
一个dao.xml可对应一个数据库，多个dao.xml就可以访问多个数据库了（它的petstore就提供了演示distributed

功能的样例是oracle+ms sql）
它的SqlMapConfig.xml中可配置sql-map resource，就是配置你具体的sql语句的xml文件。
它的sqlMap提供很多方法来访问数据库，直接返回你想要的结果

***************************
DAO中的一个供分页查询的方法
***************************
......

SqlMap sqlMap = getSqlMapFromLocalTransaction();//取到当前sqlmap对象
List list=sqlMap.executeQueryForList("你的MappedStatement文件中sql语句的名称", object("你可以通过这

个object传一些查询条件"),skipResults,maxResults);

...

有了良好的设计模式，它可以和struts完美结合在一起，无论是效率还是清晰型上，都非常令人满意的

public void saveUser(User user)
    {
        if (user.getId() == null)
        {
                Long id = (Long) getSqlMapClientTemplate().insert("addUser", user);
            logger.info("new User id set t " + id);
        } else {
            getSqlMapClientTemplate().update("updateUser", user);
        }
       
    }   

domain is the central business tier. service package is more like a web package, just a way to

expose these services remotely, so that users could use the web interfaces, or the webservice

interfaces(like amazon\'s webservices).


//TestA.javapublic class TestA{public static void main(String[] args){TestA a=new TestA

();System.out.println(a.getClass().getClassLoader());TestB b=new TestB();b.print

();}}//TestB.javapublic class TestB{public void print(){System.out.println(this.getClass

().getClassLoader());}}

DAO(data access objects)允许你去创建简单的组件，为你访问你的数据，而不用去实现具体的实现细节。使用

DAOS你能动态配置不同的持久层机制。
注意：DAO框架与sqlmaps框架是完全的分离开和互不依赖性，所以你可以单独使用，或一起来用都没有关系.

下面是一些重要的daos api
DaoManager(Facade模式):负责配置DAO框架实例（经过dao.xml),在其它api当中充当facade.
DaoTransaction(Marker Interface):通用的接口，为了去使用事物（连接），通用的实现将包装jdbc的连接对象

.
DaoException(RuntimeException运行期异常):所有的方法和类全部抛出dao api专有的异常。
Dao(Marker Interface):一个标记接口供所有的dao去实现，这个接口必须为所有的dao类去实现。这个接口没有

声名任何方法被实现，只是充当一个标记（例如：一些DaoFactory去辩别不同的类);
-----------------------------------
jdbc事务控制实现
sqlmap:通过sqlmaps框架和它的事物管理服务去实现，包括不同的DataSource和事物管理配置
hibernate:提供简单容易的和hibernate,它的事物工具（SessionFactory,Session,Transaction)整合
jdbc:通过jdbc api，使用它的基本的dataSource和Connction接口去管理事物
jta:管理分部式事物，需要被管理的datasource，这样子可以通过jndi访问.
external:允许事物被外部控制

dao.xml为配置文件(http://www.ibatis.com/dtd/dao-2.dtd)
DaoManager负责配置dao框架。DaoManager类可以为框架解析特定的xml文件，而提供出有用的信息供框架使用。

那么配置文件(xml文件)需要指定下面的内容:
1)dao的上下文
2)事物为每一个上下文件的实现
3)TransactionManager配置属性
4)Dao为每一个实现的dao接口
一个Dao上下文是一组相关的配置信息和Dao实现。通常一个上下文关联到一个数据源(datasource)或一个文件。
dao配置文件（通常被叫做dao.xml，但不是必须的),为下面的结构
<!DOCTYPE daoConfig
PUBLIC "-//iBATIS.com//DTD DAO Configuration 2.0//EN"
"http://www.ibatis.com/dtd/dao-2.dtd">
<
daoConfig>
<properties resource="com/domain/properties/MyProperties.properties"/>
<!-- Example JDBC DAO Configuration -->
<context>
<transactionManager type="JDBC">
<property name="DataSource" value="SIMPLE"/>
<property name="JDBC.Driver" value="${driver}"/>
<property name="JDBC.ConnectionURL" value="${url}"/>
<property name="JDBC.Username" value="${username}"/>
<property name="JDBC.Password" value="${password}"/>
<property name="JDBC.DefaultAutoCommit" value="true" />
<property name="Pool.MaximumActiveConnections" value="10"/>
<property name="Pool.MaximumIdleConnections" value="5"/>
<property name="Pool.MaximumCheckoutTime" value="120000"/>
</transactionManager>
<dao interface="com.domain.dao.OrderDao"
implementation="com.domain.dao.jdbc.JdbcOrderDao"/>
<dao interface="com.domain.dao.LineItemDao"
implementation="com.domain.dao.jdbc.JdbcLineItemDao"/>
<dao interface="com.domain.dao.CustomerDao"
implementation="com.domain.dao.jdbc.JdbcCustomerDao"/>
</context>
<!-- Example SQL Maps DAO Configuration -->
<context>
<transactionManager type="SQLMAP">
<property name="SqlMapConfigResource" value="com/domain/dao/sqlmap/SqlMapConfig.xml"/>
</transactionManager>
<dao interface="com.domain.dao.PersonDao"
implementation="com.domain.dao.sqlmap.SqlMapPersonDao"/>
<dao interface="com.domain.dao.BusinessDao"
implementation="com.domain.dao.sqlmap.SqlMapBusinessDao"/>
<dao interface="com.domain.dao.AccountDao"
implementation="com.domain.dao.sqlmap.SqlMapAccountDao"/>
</context>
</daoConfig>
一个dao.xml里可以有多个context,通常一个上下文指定一个特定的dataSource
为了去管理多样的配置（因为有不同的环境），你可以使用可选的元素<properties).
这个允许使用占用符，例如：
driver=org.postgresql.Driver
url=jdbc:postgresql://localhost:5432/test
这时你可以在dao.xml里用占用符取代具体的值，例如上面的可以改写成下面的
<property name="JDBC.Driver" value="${driver}"/>
<property name="JDBC.ConnectionURL" value="${url}"/>
在上下文当中，第一个context里同使用的是jdbc事物控制，所以在指定的property元素也要使用jdbc，不同的事

物管理实现会需要不同的properties,

事物管理实现(Transaction Manager Implementation and Configuration)是一个组件会管理pool（事物对象）

，一事物管理通常只是包装特定的DataSource，简单的事物通常包装一特定的实现类如jdbc连接实现

jdbc Transaction Manager:利用提供的datasource api提供连接池服务
有三种datasource是支持的(simple,dbcp,jndi),simple是实现了ibatis的SimpleDataSource。dbcp使用了

jakarta dbcp datasource，最后，jndi是实现了查找datasource是从jndi上去查
下面是不同的配置方法
<!-- Example iBATIS SimpleDataSource JDBC Transaction Manager -->
<transactionManager type="JDBC">
<property name="DataSource" value="SIMPLE"/>
<property name="JDBC.Driver" value="${driver}"/>
<property name="JDBC.ConnectionURL" value="${url}"/>
<property name="JDBC.Username" value="${username}"/>
<property name="JDBC.Password" value="${password}"/>
<property name="JDBC.DefaultAutoCommit" value="true" />
<!-- The following are optional -->
<property name="Pool.MaximumActiveConnections" value="10"/>
<property name="Pool.MaximumIdleConnections" value="5"/>
<property name="Pool.MaximumCheckoutTime" value="120000"/>
<property name="Pool.TimeToWait" value="10000"/>
<property name="Pool.PingQuery" value="select * from dual"/>
<property name="Pool.PingEnabled" value="false"/>
<property name="Pool.PingConnectionsOlderThan" value="0"/>
<property name="Pool.PingConnectionsNotUsedFor" value="0"/>
</transactionManager>

<!-- Example Jakarta DBCP JDBC Transaction Manager -->
<transactionManager type="JDBC">
<property name="DataSource" value="DBCP"/>
<property name="JDBC.Driver" value="${driver}"/>
<property name="JDBC.ConnectionURL" value="${url}"/>
<property name="JDBC.Username" value="${username}"/>
<property name="JDBC.Password" value="${password}"/>
<property name="JDBC.DefaultAutoCommit" value="true" />
<!-- The following are optional -->
<property name="Pool.MaximumActiveConnections" value="10"/>
<property name="Pool.MaximumIdleConnections" value="5"/>
<property name="Pool.MaximumWait" value="60000"/>
<!-- Use of the validation query can be problematic. If you have difficulty, try without it. -->
<property name="Pool.ValidationQuery" value="select 1 from ACCOUNT"/>
<property name="Pool.LogAbandoned" value="false"/>
<property name="Pool.RemoveAbandoned" value="false"/>
<property name="Pool.RemoveAbandonedTimeout" value="50000"/>
</transactionManager>


<!-- Example JNDI DataSource JDBC Transaction Manager -->
<transactionManager type="JDBC">
<property name="DataSource" value="JNDI"/>
<property name="DBJndiContext" value="java:comp/env/jdbc/MyDataSource"/>
</transactionManager>

jta管理事物：它使用的是jta api.实种实现总是需要通过jndi去获得datasource和一个UserTransaction实例也

是通过jndi访问的,因些需要在服务器配置一下，不过这使得配置dao框架十分简单了。下面是一个简单的配置
<transactionManager type="JTA">
<property name="DBJndiContext" value="java:comp/env/jdbc/MyDataSource"/>
<property name="UserTransaction" value="java:comp/env/UserTransaction"/>
</transactionManager>

sqlmap管理事物：通过dao框架包装sql maps事物服务，所有的你都要指定一个sql maps配置文件。下面是一个简

单的配置
<transactionManager type="SQLMAP">
<property name="SqlMapConfigResource" value="com/domain/dao/sqlmap/SqlMapConfig.xml"/>
</transactionManager>

hibernate管理事物:同样的,通过dao框架包装hibernate事物服务,基本上properties在配置文件当中和

hibernate.properties文件是一样的，另外，持久化类（你可能通过添加到hibernate配置文件当中去的）要

以"class."开头，下面是一个例子:
<transactionManager type="HIBERNATE">
<property name="hibernate.dialect" value="net.sf.hibernate.dialect.PostgreSQLDialect"/>
<property name="hibernate.connection.driver_class" value="${driver}"/>
<property name="hibernate.connection.url" value="${url}"/>
<property name="hibernate.connection.username" value="${username}"/>
<property name="hibernate.connection.password" value="${password}"/>
<property name="class.1" value="com.domain.Person"/>
<property name="class.2" value="com.domain.Business"/>
<property name="class.3" value="com.domain.Account"/>
</transactionManager>

external 管理事物:允许使用dao框架控制。这个执行基本是没有行为，因些不需要properties，如果你使用一个

flat file,你可以使用external事物管理,
<transactionManager type="EXTERNAL"/>

dao实现模板：你可能要问我怎么使用上面的事物，好了每一种事物类型都要相应的dao模板与之对应。例如：

jta,jdbc模板提供简单的访问jdbc连接对象。相似的sqlmap模板提供访问简单的SqlMapExecutor实例，而

hibernate template提供访问Session object.
使用dao template完全是可选的，但99%的时间里，是不可不选择的/

更多的模板请看下面的.
DaoManager编程：iBATIS　dao框架有许多的目的．第一个，它试图持久层的细节．这包括所有的接口，实现和异

常细节（在你的持久层解决方案当中）.
例如：如果你使用jdbc,dao框架将为你隐藏类如DataSource,Connection和SQLException.类似的，如果你使用

Hibernate orm,dao框架会为你隐藏类如Configuration,SessionFactory,Session和HibernateException.所有的

这些细节都会隐藏到了dao接口层．甚至在显示层的许多的datasource也会被隐藏.
第二个目的是:简化持久层编程模型,使在同一时间保持一致.不同的持久层解决方案有不同的编程语义和行为.
dao框架试图隐藏更多,允许在你的应用service和domain层,写出一致的风格.

DaoManager类负责dao框架的配置文件(通过dao.xml),另外,DaoManage扮演着中心门面的角色,它特殊之处是,还提

供方法允许你访问事物和dao实例.

读取配置文件:
使用DaoManagerBuilder类的静态方法buildDaoManager()方法读取dao.xml文件,buildDaoManager()方法需要一个

Reader实例作为参数.
例如:
Reader reader = new FileReader(C:/myapp/dao.xml);
DaoManager daoManager = DaoManagerBuilder.buildDaoManager(reader);

如在web应用环境当中(或其它),一般配置文件都会从classpath当中去加载的.我们可以使用

com.ibatis.common.resources.Resources类
Reader reader = Resources.getResourceAsReader(“com/domain/config/dao.xml”);
DaoManager daoManager = DaoManagerBuilder.buildDaoManager(reader);

Context和DaoManager
DaoManager实例是从dao.xml文件建立的.当你需要一个dao实例时,你可以通过DaoManager,和事物控制也会从它此

处提供的.因些不需直接访问context和事物管理..
你的dao知道它怎么去做.类似的,需要看你的daos怎么工作的,事物会恰当的开始和提交的.而且,事物仅在你的dao

被调用时才启动.

获取dao实例
一旦你得到了DaoManager实例,你就可以根据dao名字,利用DaoManager的getDao方法获取该dao实例了,如:
ProductDao productDao = (ProductDao) daoManager.getDao (ProductDao.class);

DaoManager提供了处理事务的方法.这些方法允许你划分事务,和避免传递事务对象(eg:jdbc Connction)到你的所

有的daos当中去.例如:
ProductDao productDao = (ProductDao) daoManager.getDao (ProductDao.class);
try {
daoManager.startTransaction();
Product product = productDao.getProduct (5);
product.setDescription (“New description.”);
productDao.updateProduct(product);
daoManager.commitTransaction();
} finally {
daoManager.endTransaction();
}
调用startTransaction()只是让DaoManager知道,你将要启动编程控制事务.
dao实例化时才启动事务的,甚至事务仅仅是contexts需要的时候.
commitTransaction()提交事务,endTransaction()需要在try{}catch(){}里面的,,
如果发现了异常,那么就会回滚.

自动提交事务
像jdbc的setAutoCommit(true)一样,不过也有不同之处,你可以使用多个update作为一个事务,你不需要指定提交

的行为方式,只要你不调用startTransaction()就行了
Product product = productDao.getProduct (5); // Transaction 1
product.setDescription (“New description.”);
productDao.updateProduct(product); // Transaction 2
product = productDao.getProduct (5); // Transaction 3
注意了,这里没有异常的事件发生的,如发生异常,就会回滚,和释放连接资源的.

实现自己的dao接口:
dao接口非常的简单,因为它没有声名任何的方法,只是一个marker interface,所以实现的只是你自己的接口罢了,

在你的接口当中没有限制你要定的任何方法,抛出的异常是运行期的DaoException类型的异常.
An example of a good Dao interface is:
public interface ProductDao extends Dao {
// Updates
public int updateProduct (Product product); // DAO Framework code may throw DaoException
public int insertProduct (Product product);
public int deleteProduct (int productId);
/
/ Queries
public Product getProduct (int productId);
public List getProductListByProductDescription (String description);
}