国产a久久精品一区二区三区,一区二区中文字,一本色道久久综合亚洲精品酒店

iBatis 新增时候主键的获取(MySql)

�C�物 — Mon, 12 Oct 2009 00:45:00 GMT

        insert into usersrcaccount
        (
            USER_ID,
            SOURCETYPE,
            ACCOUNT,
            PASSWORD
        )
        values
        (
            #userId#,
            #sourceType#,
            #account#,
            #password#
        )

            SELECT @@IDENTITY AS id

�C�物 2009-10-12 08:45 发表评论

ibatis中由SELECT语句自动生成COUNT语句

�C�物 — Fri, 02 May 2008 16:31:00 GMT

下面的内�Ҏ��Z��ibatis2.2�Q�以后的版本是否提供了类似功能不太清楚，甚至�q�个版本是否提供也没有细�IӞ��好像没有�Q��?br />
很多时候我们需要执行select语句对应的count语句�Q�例如分��|��询时要得到结果的记录敎ͼ�但在ibatis的映��文件中我们只想写一条select语句�Q�而count语句直接��p��条语句生成，�q�可以省��d��多不必要的语句关联，下面的代码可以实现这一炏V�?br />
CountStatementUtil.java

java 代码
package com.aladdin.dao.ibatis.ext;

import java.sql.Connection;
import java.sql.SQLException;
import java.util.List;

import com.aladdin.util.ReflectUtil;
import com.ibatis.common.jdbc.exception.NestedSQLException;
import com.ibatis.sqlmap.client.event.RowHandler;
import com.ibatis.sqlmap.engine.impl.ExtendedSqlMapClient;
import com.ibatis.sqlmap.engine.mapping.parameter.ParameterMap;
import com.ibatis.sqlmap.engine.mapping.result.AutoResultMap;
import com.ibatis.sqlmap.engine.mapping.result.BasicResultMap;
import com.ibatis.sqlmap.engine.mapping.result.ResultMap;
import com.ibatis.sqlmap.engine.mapping.sql.Sql;
import com.ibatis.sqlmap.engine.mapping.statement.ExecuteListener;
import com.ibatis.sqlmap.engine.mapping.statement.MappedStatement;
import com.ibatis.sqlmap.engine.mapping.statement.RowHandlerCallback;
import com.ibatis.sqlmap.engine.mapping.statement.SelectStatement;
import com.ibatis.sqlmap.engine.scope.ErrorContext;
import com.ibatis.sqlmap.engine.scope.RequestScope;

public class CountStatementUtil {

public static MappedStatement createCountStatement(MappedStatement selectStatement) {
return new CountStatement((SelectStatement) selectStatement);
}

public static String getCountStatementId(String selectStatementId) {
return "__" + selectStatementId + "Count__";
}

}

class CountStatement extends SelectStatement {

public CountStatement(SelectStatement selectStatement) {
super();
setId(CountStatementUtil.getCountStatementId(selectStatement
.getId()));
setResultSetType(selectStatement.getResultSetType());
setFetchSize(1);
setParameterMap(selectStatement.getParameterMap());
setParameterClass(selectStatement.getParameterClass());
setSql(selectStatement.getSql());
setResource(selectStatement.getResource());
setSqlMapClient(selectStatement.getSqlMapClient());
setTimeout(selectStatement.getTimeout());
List executeListeners = (List) ReflectUtil.getFieldValue(
selectStatement, "executeListeners", List.class);
if (executeListeners != null) {
for (Object listener : executeListeners) {
addExecuteListener((ExecuteListener) listener);
}
}
BasicResultMap resultMap = new AutoResultMap(
((ExtendedSqlMapClient) getSqlMapClient()).getDelegate(), false);
resultMap.setId(getId() + "-AutoResultMap");
resultMap.setResultClass(Long.class);
resultMap.setResource(getResource());
setResultMap(resultMap);

}

protected void executeQueryWithCallback(RequestScope request,
Connection conn, Object parameterObject, Object resultObject,
RowHandler rowHandler, int skipResults, int maxResults)
throws SQLException {
ErrorContext errorContext = request.getErrorContext();
errorContext
.setActivity("preparing the mapped statement for execution");
errorContext.setObjectId(this.getId());
errorContext.setResource(this.getResource());

try {
parameterObject = validateParameter(parameterObject);

Sql sql = getSql();

errorContext.setMoreInfo("Check the parameter map.");
ParameterMap parameterMap = sql.getParameterMap(request,
parameterObject);

errorContext.setMoreInfo("Check the result map.");
ResultMap resultMap = getResultMap(request, parameterObject, sql);

request.setResultMap(resultMap);
request.setParameterMap(parameterMap);

errorContext.setMoreInfo("Check the parameter map.");
Object[] parameters = parameterMap.getParameterObjectValues(
request, parameterObject);

errorContext.setMoreInfo("Check the SQL statement.");
String sqlString = getSqlString(request, parameterObject, sql);

errorContext.setActivity("executing mapped statement");
errorContext
.setMoreInfo("Check the SQL statement or the result map.");
RowHandlerCallback callback = new RowHandlerCallback(resultMap,
resultObject, rowHandler);
sqlExecuteQuery(request, conn, sqlString, parameters, skipResults,
maxResults, callback);

errorContext.setMoreInfo("Check the output parameters.");
if (parameterObject != null) {
postProcessParameterObject(request, parameterObject, parameters);
}

errorContext.reset();
sql.cleanup(request);
notifyListeners();
} catch (SQLException e) {
errorContext.setCause(e);
throw new NestedSQLException(errorContext.toString(), e
.getSQLState(), e.getErrorCode(), e);
} catch (Exception e) {
errorContext.setCause(e);
throw new NestedSQLException(errorContext.toString(), e);
}
}

private String getSqlString(RequestScope request, Object parameterObject,
Sql sql) {
String sqlString = sql.getSql(request, parameterObject);
int start = sqlString.toLowerCase().indexOf("from");
if (start >= 0) {
sqlString = "SELECT COUNT(*) AS c " + sqlString.substring(start);
}
return sqlString;
}

private ResultMap getResultMap(RequestScope request,
Object parameterObject, Sql sql) {
return getResultMap();
}

}

上面代码中的getSqlString�Ҏ��可以�Ҏ��自己�pȝ��select语句的复杂程度完善，�q�里�l�出的是最��单的实现�?br />
使用上面的类卛_��由select语句生成count语句�Q�下面是通过spring使用的代码：

BaseDaoiBatis.java

java 代码
//...
public abstract class BaseDaoiBatis extends SqlMapClientDaoSupport {

//...

protected long getObjectTotal(String selectQuery, Object parameterObject) {
prepareCountQuery(selectQuery);
//...
return (Long) getSqlMapClientTemplate().queryForObject(
CountStatementUtil.getCountStatementId(selectQuery),
parameterObject);
}

protected void prepareCountQuery(String selectQuery) {

String countQuery = CountStatementUtil.getCountStatementId(selectQuery);
if (logger.isDebugEnabled()) {
logger.debug("Convert " + selectQuery + " to " + countQuery);
}
SqlMapClient sqlMapClient = getSqlMapClientTemplate().getSqlMapClient();
if (sqlMapClient instanceof ExtendedSqlMapClient) {
SqlMapExecutorDelegate delegate = ((ExtendedSqlMapClient) sqlMapClient)
.getDelegate();
try {
delegate.getMappedStatement(countQuery);
} catch (SqlMapException e) {
delegate.addMappedStatement(CountStatementUtil
.createCountStatement(delegate
.getMappedStatement(selectQuery)));
}

}
}

//...
}

�C�物 2008-05-03 00:31 发表评论

对ibatis分页功能的改�q?

�C�物 — Sun, 13 Apr 2008 00:51:00 GMT

摘要: 今天无意间看��C��一��关于这斚w��的文章，觉得是网上改�q�ibatis分页斚w��比较好的文章�Q�这里�{摘一下，希望能让更多的�h用的刎ͼ�也希望别��把更好的解决�Ҏ��贡献出来�Q? function StorePage(){d=document;t=d.selection?(d.selection.type!='None'?d.selection.createRange().text:''):(d.g... 阅读全文

�C�物 2008-04-13 08:51 发表评论

��Z��struts+spring+ibatis�?J2EE 开�?2)

�C�物 — Wed, 05 Dec 2007 08:04:00 GMT

��此文章收藏到豌豆网

2.4. 代码剖析

下面��p��我们开始进一步分析JpetStore4.0的源代码�Q��ؓ下面的改造铺路。BeanAction.java是唯一一个Struts action�c�，位于com.ibatis.struts包下。正如上文所�a��Q�它是一个通用的控制类�Q�利用反��机�Ӟ��把控制�{�U�d��form bean的某个方法来处理。详�l�处理过�E�参考其源代码，��单明晰�?br />
Form bean�c�M��于com.ibatis.jpetstore.presentation包下�Q�命名规则�ؓ***Bean。Form bean�c�d��部��承于BaseBean�c�，而BaseBean�c�d��际��承于ActionForm�Q�因此，Form bean�c�d��是Struts�?ActionForm�Q�Form bean�cȝ��属性数据就由struts框架自动填充。而实际上�Q�JpetStore4.0扩展了struts中ActionForm的应用： Form bean�c�还��h��行�ؓ�Q�更像一个BO,其行为（�Ҏ��Q�由BeanAction�Ҏ��配置�Q�struts-config.xml�Q�的URL来调用。虽然如此，我们�q�是把Form bean�c�d��位于表现层。Struts-config.xml的配�|�里�?�U�映��方式，来告诉BeanAction把控制�{到哪个form bean对象的哪个方法来处理。以�q�个��h��q�接��Z��http://localhost/jpetstore4/shop/viewOrder.do

1. URL Pattern

此种方式表示�Q�控制将被�{发到"orderBean"�q�个form bean对象 �?viewOrder"�Ҏ��Q�行为）来处理。方法名�?path"参数的以"/"分隔的最后一部分�?

2. Method Parameter

此种方式表示�Q�控制将被�{发到"orderBean"�q�个form bean对象�?viewOrder"�Ҏ��Q�行为）来处理。配�|�中�?parameter"参数表示form bean�c�M��的方法�?parameter"参数优先�?path"参数�?

3. No Method call

此种方式表示�Q�form bean上没有�Q何方法被调用。如果存�?name"属性，则struts把表单参数等数据填充到form bean对象后，把控制�{发到"success"。否则，如果name为空�Q�则直接转发控制�?success"。这��q��当于struts内置的org.apache.struts.actions.ForwardAction的功�?

Service�c�M��于com.ibatis.jpetstore.service包下�Q�属于业务层。这些类��装了业务以及相应的事务控制。Service�cȝ��form bean�c�L��调用�?

com.ibatis.jpetstore.persistence.iface包下的类是DAO接口�Q�属于业务层�Q�其屏蔽了底层的数据库操作，供具体的Service�c�L��调用。DaoConfig�c�L��工具�c�（DAO工厂�c�）�Q�Service�c�通过DaoConfig�c�L��获得相应的DAO接口�Q�而不用关心底层的具体数据库操作，实现了如�?中{耦合2}的解耦�?

com.ibatis.jpetstore.persistence.sqlmapdao包下的类是对应DAO接口的具体实玎ͼ�在JpetStore4.0中采用了ibatis来实现ORM。这些实现类�l�承BaseSqlMapDao�c�，而BaseSqlMapDao�c�d��l�承ibatis DAO 框架中的SqlMapDaoTemplate�c�R��ibatis的配�|�文件存攑֜�com.ibatis.jpetstore.persistence.sqlmapdao.sql目录下。这些类和配�|�文件位于数据层

Domain�c�M��于com.ibatis.jpetstore.domain包下�Q�是普通的javabean。在�q�里用作数据传输对象�Q�DTO�Q�，贯穿视图层、业务层和数据层�Q�用于在不同层之间传输数据。剩下的部分��比较简单了�Q�请看具体的源代码，非常清晰�?

�C�物 2007-12-05 16:04 发表评论

��Z��struts+spring+ibatis�?J2EE 开�?3)

�C�物 — Wed, 05 Dec 2007 08:03:00 GMT

2.5. 需要改造的地方

JpetStore4.0的关键就在struts Action�c�d��form bean�c�M��Q�这也是其精华之一�Q�虽然该实现方式是试验性，待扩充和验证�Q�，在此�ơ改造中我们要保留下来，��x��制层一点不变，表现层获取相应业务类的方式变了（要加载spring环境�Q�，其它保持不变。要特别��x��的改动是业务层和持久层，�q�运的是JpetStore4.0设计非常好，需要改动的地方非常��，而且由模式可循，如下�Q?br />
1. 业务层和数据层用Spring BeanFactory机制��理�?br /> 2. 业务层的事务由spring 的aop通过声明来完成�?br /> 3. 表现层（form bean�Q�获取业务类的方法改��p��定义工厂�c�L��实现�Q�加载spring环境�Q��?br />
3. JPetStore的改�?br />
3.1. 攚w��后的架�?br />

其中�U�色部分是要增加的部分，蓝色部分是要修改的部分。下面就让我们逐一剖析�?br />
3.2. Spring Context的加�?br /> ��Z��在Struts中加载Spring Context�Q�一般会在struts-config.xml的最后添加如下部分：

Spring在设计时��充分考虑��C��与Struts的协同工作，通过内置的Struts Plug-in在两者之间提供了良好的结合点。但是，因�ؓ在这里我们一点也不改动JPetStore的控制层(�q�是JpetStore4.0的精华之一)�Q�所以本文不准备采用此方式来加蝲ApplicationContext。我们利用的是spring framework 的BeanFactory机制,采用自定义的工具�c�（bean工厂�c�）来加载spring的配�|�文�Ӟ��从中可以看出Spring有多灉|��Q�它提供了各�U�不同的方式来��用其不同的部�?层次�Q�您只需要用你想用的�Q�不需要的部分可以不用�?

具体的来��_��是在com.ibatis.spring包下创徏CustomBeanFactory�c�，spring的配�|�文件applicationContext.xml也放在这个目录下。以下就是该�cȝ��全部代码�Q�很��单：

public final class CustomBeanFactory {
            static XmlBeanFactory factory = null;
            static {
            Resource is = new
            InputStreamResource( CustomBeanFactory.class.getResourceAsStream("applicationContext.xml"));
            factory = new XmlBeanFactory(is);
            }
            public static Object getBean(String beanName){
            return factory.getBean(beanName);
            }
            }

实际上就是封装了Spring 的XMLBeanFactory而已�Q��ƈ且Spring的配�|�文件只需要加载一�ơ，以后��可以直接用CustomBeanFactory.getBean("someBean")来获得需要的对象�?例如someBean)�Q�而不需要知道具体的�c�R��CustomBeanFactory�cȝ��于{耦合1}的解耦。CustomBeanFactory�c�d��本文中只用于表现层的form bean对象获得service�cȝ��对象�Q�因为我们没有把form bean对象配置在applicationContext.xml中。但是，��Z��么不把表现层的form bean�c�M��配置��h��呢，�q�样��q��不着�q�CustomBeanFactory个类了，Spring会帮助我们创建需要的一切？问题的答案就在于form bean�c�L��struts的ActionForm�c�！如果大家熟悉struts�Q�就会知道ActionForm�c�L��struts自动创徏的：在一�ơ请求中�Q�struts判断�Q�如果ActionForm实例不存在，��创��Z��个ActionForm对象�Q�把客户提交的表单数据保存到ActionForm对象中。因此formbean�cȝ��对象��׃��能由spring来创建，但是service�c�M��及数据层的DAO�c�d��以，所以只有他们在spring中配�|�。所以，很自然的�Q�我们就创徏了CustomBeanFactory�c�，在表现层来衔接struts和spring。就�q�么��单，实现了另一�U�方式的{耦合一}的解耦�?

3.3. 表现�?

面分析到�Q�struts和spring是在表现层衔接�v来的�Q�那么表现层��p��做稍微的更改�Q�即所需要的service�cȝ��对象创徏上。以表现层的AccountBean�c�Mؓ例：原来的源代码如下

private static final AccountService accountService
            = AccountService.getInstance();
            private static final CatalogService catalogService
            = CatalogService.getInstance();

攚w��后的源代码如下

private static final AccountService accountService
            = (AccountService)CustomBeanFactory.getBean("AccountService");
            private static final CatalogService catalogService
            = (CatalogService)CustomBeanFactory.getBean("CatalogService");

其他的几个presentation�c�M��同样方式攚w��。这��P��表现层就完成了。关于表现层的其它部分如JSP�{�一概不动。也许您会说�Q�没有看��Z��么特别之处的好处啊？你还是额外实��C��一个工厂类。别着急，帷幕刚刚开启，spring是在表现层引入，但您发没发现�Q?

presentation�c�M��仅面向service�cȝ��接口�~�程�Q�具�?AccountService"是哪个实现类�Q�presentation�c�M��知道�Q�是在spring的配�|�文仉��配置。（本例中，��Z��最大限度的保持原来的代码不作变化，没有抽象出接口）。Spring鼓励面向接口�~�程�Q�因为是如此的方便和自然�Q�当然您也可以不�q�么做�?

CustomBeanFactory�q�个工厂�c�Mؓ什么会如此��单，因�ؓ其直接��用了Spring的BeanFactory。Spring从其核心而言�Q�是一个DI容器�Q�其设计哲学是提供一�U�无侵入式的高扩展性的框架。�ؓ了实现这个目标，Spring 大量引入了Java 的Reflection机制�Q�通过动态调用的方式避免��编码方式的�U�束�Q��ƈ在此基础上徏立了其核心组件BeanFactory�Q�以此作为其依赖注入机制的实现基��。org.springframework.beans包中包括了这些核心组件的实现�c�，核心中的核心为BeanWrapper和BeanFactory�c�R�?

�C�物 2007-12-05 16:03 发表评论

��Z��struts+spring+ibatis�?J2EE 开�?4)

�C�物 — Wed, 05 Dec 2007 08:02:00 GMT

3.4. 持久层在讨论业务层之前，我们先看一下持久层�Q�如下图所�C�：

在上文中�Q�我们把iface包下的DAO接口归�ؓ业务层，在这里不需要做修改。ibatis的sql配置文�g也不需要改。要改的是DAO实现�c�，�q�在spring的配�|�文件中配置��h��?br />
1、修改基�c?br />
所有的DAO实现�c�都�l�承于BaseSqlMapDao�c�R��修改BaseSqlMapDao�c�d��下：

public class BaseSqlMapDao extends SqlMapClientDaoSupport
            {
            protected static final int PAGE_SIZE = 4;
            protected SqlMapClientTemplate smcTemplate
            = this.getSqlMapClientTemplate();
            public BaseSqlMapDao()
            {
            }
            }

使BaseSqlMapDao�c�L��为��承于Spring提供的SqlMapClientDaoSupport�c�，�q�定义了一个保护属性smcTemplate�Q�其�c�d��为SqlMapClientTemplate�?

2、修改DAO实现�c?

所有的DAO实现�c�还是��承于BaseSqlMapDao�c�，实现相应的DAO接口�Q�但其相应的DAO操作委托SqlMapClientTemplate来执行，以AccountSqlMapDao�c�Mؓ例，部分代码如下�Q?

public List getUsernameList()
            {
            return smcTemplate.queryForList("getUsernameList", null);
            }
            public Account getAccount(String username, String password)
            {
            Account account = new Account();
            account.setUsername(username);
            account.setPassword(password);
            return (Account)
            smcTemplate.queryForObject
            ("getAccountByUsernameAndPassword", account);
            }
            public void insertAccount(Account account)
            {
            smcTemplate.update("insertAccount", account);
            smcTemplate.update("insertProfile", account);
            smcTemplate.update("insertSignon", account);
            }

��p��么简单，所有函数的�{�֐�都是一��L��Q�只需要查找替换就可以了！

�C�物 2007-12-05 16:02 发表评论

��Z��struts+spring+ibatis�?J2EE 开�?1)

�C�物 — Wed, 05 Dec 2007 08:02:00 GMT

1. 前言

Struts 是目前Java Web MVC框架中不争的王者。经�q�长达五�q�的发展�Q�Struts已经逐渐成长��Z��个稳定、成熟的框架�Q��ƈ且占有了MVC框架中最大的市场份额。但是Struts某些技术特性上已经落后于新兴的MVC框架。面对Spring MVC、Webwork2 �q�些设计更精密，扩展性更强的框架�Q�Struts受到了前所未有的挑战。但站在产品开发的角度而言�Q�Struts仍然是最�E�_��的选择。本文的原型例子JpetStore 4.0��是��Z��Struts开发的�Q�但是不拘惔于Struts的传�l�固定用法，例如只用了一个自定义Action�c�，�q�且在form bean�cȝ��定义上也是开创性的�Q��o��目一斎ͼ��E�后��具体剖析一下�?br />
Spring Framework 实际上是Expert One-on-One J2EE Design and Development 一书中所阐述的设计思想的具体实现。Spring Framework的功能非常多。包含AOP、ORM、DAO、Context、Web、MVC�{�几个部分组成。Web、MVC暂不用考虑�Q�JpetStore 4.0用的是更成熟的Struts和JSP�Q�DAO�׃��目前Hibernate、JDO、ibatis的流行，也不考虑�Q�JpetStore 4.0用的��是ibatis。因此最需要用的是AOP、ORM、Context。Context中，最重要的是Beanfactory�Q�它能将接口与实现分开�Q�非常强大。目前AOP应用最成熟的还是在事务��理上�?br />
ibatis 是一个功能强大实用的SQL Map工具�Q�不同于其他ORM工具�Q�如hibernate�Q�，它是��SQL语句映射成Java对象�Q�而对于ORM工具�Q�它的SQL语句是根据映��定义生成的。ibatis 以SQL开发的工作量和数据库移植性上的让步，为系�l�设计提供了更大的自��q��间。有ibatis代码生成的工��P��可以�Ҏ��DDL自动生成ibatis代码�Q�能减少很多工作量�?br />
2. JpetStore��q?br />
2.1. 背景

最初是Sun公司的J2EE petstore�Q�其最主要目的是用于学习J2EE�Q�但是其�~�点也很明显�Q�就是过度设计了。接着Oracle用J2EE petstore来比较各应用服务器的性能。微软推��Z��Z��.Net�q�_��?Pet shop�Q�用于竞争J2EE petstore。而JpetStore则是�l�过改良的基于struts的轻便框架J2EE web应用�E�序�Q�相比来��_��JpetStore设计和架构更优良�Q�各层定义清晎ͼ�使用了很多最佛_��践和模式�Q�避免了很多"反模�?�Q�如使用存储�q�程�Q�在java代码中嵌入SQL语句�Q�把HTML存储在数据库中等�{�。最新版本是JpetStore 4.0�?br />
2.2. JpetStore开发运行环境的建立

1、开发环�?br />
Java SDK 1.4.2
Apache Tomcat 4.1.31
Eclipse-SDK-3.0.1-win32
HSQLDB 1.7.2

2、Eclipse插�g

EMF SDK 2.0.1�Q�Eclipse建模框架�Q�lomboz插�g需要，可以使用runtime版本�?br /> lomboz 3.0�Q�J2EE插�g�Q�用来在Eclipse中开发J2EE应用�E�序
Spring IDE 1.0.3�Q�Spring Bean配置��理插�g
xmlbuddy_2.0.10�Q�编辑XML�Q�用免费版功能即�?br /> tomcatPluginV3�Q�tomcat��理插�g
Properties Editor�Q�编辑java的属性文�?�q�可以预览以及自动存盘�ؓUnicode格式。免��M��手工或者ANT调用native2ascii的麻烦�?br /> 2.3. 架构

�? JpetStore架构�?/center>

�? 是JPetStore架构图。参照这个架构图�Q�让我们�E�微剖析一下源代码�Q�得出JpetStore 4.0的具体实现图�Q�图2�Q�，思�\一下子��p��然开朗了。前�a�中提到的非传�l�的struts开发模式，关键��在struts Action�c�d��form bean�c�M��?br />
struts Action�c�d��有一个：BeanAction。没错，��实是一个！与传�l�的struts�~�程方式很不同。再仔细研究BeanAction�c�，发现它其实是一个通用�c�，利用反射原理�Q�根据URL来决定调用formbean的哪个方法。BeanAction大大��化了struts的编�E�模式，降低了对struts的依赖（与struts以及WEB容器有关的几个类都放在com.ibatis.struts包下�Q�其它的�c�都可以直接复用�Q�。利用这�U�模式，我们会很�Ҏ��的把它移植到新的框架如JSF�Q�spring�?br />
�q�样重心��p�{�U�d��form bean上了�Q�它已经不是普通意义上的form bean了。查看源代码�Q�可以看到它不仅仅有数据和校�?重置�Ҏ��Q�而且已经��h��了行为，从这个意义上来说�Q�它更像一个BO(Business Object)。这��是前文讲到的，BeanAction�c�d��用反��原理，�Ҏ��URL来决定调用form bean的哪个方法（行�ؓ�Q�。form bean的这些方法的�{�֐�很简单，例如�Q?br />

public String myActionMethod()
            {
            //..work
            return "success";
            }

�Ҏ��的返回值直接就是字�W�串�Q�对应的是forward的名�U�ͼ�而不再是ActionForward对象�Q�创建ActionForward对象的�Q务已�l�由BeanAction�c�M��劳了。另外，�E�序�q�提供了ActionContext工具�c�，该工��L��装了request 、response、form parameters、request attributes、session attributes�?application attributes中的数据存取操作�Q�简单而线�E�安全，form bean�c�M��用该工具�c�d��以进一步从表现层框架解耦。在�q�里需要特别指出的是，BeanAction�c�L��对struts扩展的一个有益尝试，虽然提供了非常好的应用开发模式，但是它还非常斎ͼ�一直在发展中�?

�? JpetStore 4.0具体实现

�C�物 2007-12-05 16:02 发表评论

��Z��struts+spring+ibatis�?J2EE 开�?5)

�C�物 — Wed, 05 Dec 2007 07:41:00 GMT

��此文章收藏到豌豆网

3、除��d��厂类以及相应的配�|�文�?br />
除去DaoConfig.java�q�个DAO工厂�c�d��相应的配�|�文件dao.xml�Q�因为DAO的获取现在要用spring来管理�?br />
4、DAO在Spring中的配置�Q�applicationContext.xml�Q?br />


                        
                        org.hsqldb.jdbcDriver
                        
                        
                        jdbc:hsqldb:hsql://localhost/xdb
                        
                        
                        sa
                        
                        
                        
                        
                        
                        
                        
                        
                        
                        classpath:com\ibatis\jpetstore\persistence\sqlmapdao\sql\sql-map-config.xml

1. 我们首先创徏一个数据源dataSource�Q�在�q�里配置的是hsqldb数据库。如果是ORACLE数据库，driverClassName的值是"oracle.jdbc.driver.OracleDriver"�Q�URL的值类��g��"jdbc:oracle:thin:@wugfMobile:1521:cdcf"。数据源现在由spring来管理，那么现在我们��可以去掉properties目录下database.properties�q�个配置文�g了；�q�有不要忘记修改sql-map-config.xml�Q�去�? 对它的引用�?

2. sqlMapClient节点。这个是针对ibatis SqlMap的SqlMapClientFactoryBean配置。实际上配置了一个sqlMapClient的创建工厂类。configLocation属性配�|�了ibatis映射文�g的名�U�。dataSource属性指向了使用的数据源�Q�这��h��有��用sqlMapClient的DAO都默认��用了该数据源�Q�除非在DAO的配�|�中另外昑ּ�指定�?

3. TransactionManager节点。定义了事务�Q��用的是DataSourceTransactionManager�?

4. 下面��可以定义DAO节点了，如AccountDao�Q�它的实现类是com.ibatis.jpetstore.persistence.sqlmapdao.AccountSqlMapDao�Q��用的SQL配置从sqlMapClient中读取，数据库连接没有特别列出，那么��是默认使用sqlMapClient配置的数据源datasource�?

�q�样�Q�我们就把持久层攚w��完了，其他的DAO配置�c�M��于AccountDao。怎么��P��单吧。这�ơ有接口了：�Q?AccountDao接口�Q?gt;AccountSqlMapDao实现�?

3.5. 业务�?

业务层的位置以及相关�c�，如下图所�C�：在这个例子中只有3个业务类�Q�我们以OrderService�c�Mؓ例来攚w��，�q�个�c�L��最复杂的，其中涉及了事务�?

1、在ApplicationContext配置文�g中增加bean的配�|�：


                        
                        
                        
                        
                        
                        
                        
                        
                        
                        
                        
                        
                        
                        
                        
                        
                        
                        
                        PROPAGATION_REQUIRED

定义了一个OrderService�Q�还是很�Ҏ��懂的。�ؓ了简单�v见，使用了嵌套bean�Q�其实现�c�L��com.ibatis.jpetstore.service.OrderService�Q�分别引用了ItemDao�Q�OrderDao�Q�SequenceDao。该bean的insert*实现了事务管�?AOP方式)。TransactionProxyFactoryBean自动创徏一个事务advisor�Q?该advisor包括一个基于事务属性的pointcut,因此只有事务性的�Ҏ��被拦截�?

2、业务类的修改，以OrderService��Z��Q?

public class OrderService {
                        /* Private Fields */
                        private ItemDao itemDao;
                        private OrderDao orderDao;
                        private SequenceDao sequenceDao;
                        /* Constructors */
                        public OrderService() {
                        }
                        /**
                        * @param itemDao 要设�|�的 itemDao�?
                        */
                        public final void setItemDao(ItemDao itemDao) {
                        this.itemDao = itemDao;
                        }
                        /**
                        * @param orderDao 要设�|�的 orderDao�?
                        */
                        public final void setOrderDao(OrderDao orderDao) {
                        this.orderDao = orderDao;
                        }
                        /**
                        * @param sequenceDao 要设�|�的 sequenceDao�?
                        */
                        public final void setSequenceDao(SequenceDao sequenceDao) {
                        this.sequenceDao = sequenceDao;
                        }
                        //剩下的部�?
                        …….
                        }

�U�色部分��Z��攚w��分。Spring采用的是Type2的设�|�依赖注入，所以我们只需要定义属性和相应的设值函数就可以了，ItemDao�Q�OrderDao�Q�SequenceDao的值由spring在运行期间注入。构造函数就可以为空了，另外也不需要自��q��写代码处理事务了�Q�事务在配置中声明）�Q�daoManager.startTransaction();�{�与事务相关的语句也可以��L��了。和原来的代码比较一下，是不是处理精��了很多！可以更关注业务的实现�?

4. �l�束�?

ibatis是一个功能强大实用的SQL Map工具�Q�可以直接控制SQL,为系�l�设计提供了更大的自��q��间。其提供的最新示例程序JpetStore 4.0,设计优雅�Q�应用了�q�今为止很多最佛_��践和设计模式�Q�非帔R��于学习以及在此基础上创��量��的J2EE WEB应用�E�序。JpetStore 4.0是基于struts的，本文在此基础上，最大程度保持了原有设计的精华以及最��的代码改动量，在业务层和持久化层引入了Spring。在您阅��M��本文以及攚w��后的源代码后，会深切的感受到Spring带来的种�U�好处：自然的面向接口的�~�程�Q�业务对象的依赖注入�Q�一致的数据存取框架和声明式的事务处理，�l�一的配�|�文�?#8230;更重要的是Spring既是全面的又是模块化的，Spring有分层的体系�l�构�Q�这意味着您能选择仅仅使用它�Q何一个独立的部分�Q�就像本文，而它的架构又是内部一致�?

�C�物 2007-12-05 15:41 发表评论

�C�物 — Wed, 05 Dec 2007 07:40:00 GMT

大多数IT �l�织都必��解决三个主要问题：1�Q�帮助组�l�减��成�?2�Q�增加�ƈ且保持客�?3�Q�加快业务效率。完成这些问题一般都需要实现对多个业务�pȝ��的数据和业务逻辑的无�~�访问，也就是说�Q�要实施�pȝ��集成工程�Q�以便联�l�业务流�E�、实现数据的讉K��与共享�?/blockquote>
JpetStore 4.0是ibatis的最新示例程序，��Z��Struts MVC框架�Q�注�Q�非传统Struts开发模式）�Q�以ibatis作�ؓ持久化层。该�C�Z��E�序设计优雅�Q�层�ơ清晎ͼ�可以学习以及作�ؓ一个高效率的编�E�模型参考。本文是在其基础上，采用Spring对其中间层（业务层）�q�行攚w��。��开发量�q�一步减��，同时又拥有了Spring的一些好�?#8230;

1. 前言

JpetStore 4.0是ibatis的最新示例程序。ibatis是开源的持久层��品，包含SQL Maps 2.0 �?Data Access Objects 2.0 框架。JpetStore�C�Z��E�序很好的展�C�Z��如何利用ibatis来开发一个典型的J2EE web应用�E�序。JpetStore有如下特点：

ibatis数据�?
POJO业务�?
POJO领域�c?
Struts MVC
JSP 表示�?

以下是本文用到的关键技术介�l�，本文假设您已�l�对Struts�Q�SpringFramewok�Q�ibatis有一定的了解�Q�如果不是，请首先查阅附录中的参考资料�?/p>

Struts 是目前Java Web MVC框架中不争的王者。经�q�长达五�q�的发展�Q�Struts已经逐渐成长��Z��个稳定、成熟的框架�Q��ƈ且占有了MVC框架中最大的市场份额。但是Struts某些技术特性上已经落后于新兴的MVC框架。面对Spring MVC、Webwork2 �q�些设计更精密，扩展性更强的框架�Q�Struts受到了前所未有的挑战。但站在产品开发的角度而言�Q�Struts仍然是最�E�_��的选择。本文的原型例子JpetStore 4.0��是��Z��Struts开发的�Q�但是不拘惔于Struts的传�l�固定用法，例如只用了一个自定义Action�c�，�q�且在form bean�cȝ��定义上也是开创性的�Q��o��目一斎ͼ��E�后��具体剖析一下�?
Spring Framework 实际上是Expert One-on-One J2EE Design and Development 一书中所阐述的设计思想的具体实现。Spring Framework的功能非常多。包含AOP、ORM、DAO、Context、Web、MVC�{�几个部分组成。Web、MVC暂不用考虑�Q�JpetStore 4.0用的是更成熟的Struts和JSP�Q�DAO�׃��目前Hibernate、JDO、ibatis的流行，也不考虑�Q�JpetStore 4.0用的��是ibatis。因此最需要用的是AOP、ORM、Context。Context中，最重要的是Beanfactory�Q�它能将接口与实现分开�Q�非常强大。目前AOP应用最成熟的还是在事务��理上�?
ibatis 是一个功能强大实用的SQL Map工具�Q�不同于其他ORM工具�Q�如hibernate�Q�，它是��SQL语句映射成Java对象�Q�而对于ORM工具�Q�它的SQL语句是根据映��定义生成的。ibatis 以SQL开发的工作量和数据库移植性上的让步，为系�l�设计提供了更大的自��q��间。有ibatis代码生成的工��P��可以�Ҏ��DDL自动生成ibatis代码�Q�能减少很多工作量�?

回页�?/strong>

2. JpetStore��q?/span>

2.1. 背景

最初是Sun公司的J2EE petstore�Q�其最主要目的是用于学习J2EE�Q�但是其�~�点也很明显�Q�就是过度设计了。接着Oracle用J2EE petstore来比较各应用服务器的性能。微软推��Z��Z��.Net�q�_��?Pet shop�Q�用于竞争J2EE petstore。而JpetStore则是�l�过改良的基于struts的轻便框架J2EE web应用�E�序�Q�相比来��_��JpetStore设计和架构更优良�Q�各层定义清晎ͼ�使用了很多最佛_��践和模式�Q�避免了很多"反模�?�Q�如使用存储�q�程�Q�在java代码中嵌入SQL语句�Q�把HTML存储在数据库中等�{�。最新版本是JpetStore 4.0�?/p>
2.2. JpetStore开发运行环境的建立

1、开发环�?/p>

Java SDK 1.4.2
Apache Tomcat 4.1.31
Eclipse-SDK-3.0.1-win32
HSQLDB 1.7.2

2、Eclipse插�g

EMF SDK 2.0.1�Q�Eclipse建模框架�Q�lomboz插�g需要，可以使用runtime版本�?
lomboz 3.0�Q�J2EE插�g�Q�用来在Eclipse中开发J2EE应用�E�序
Spring IDE 1.0.3�Q�Spring Bean配置��理插�g
xmlbuddy_2.0.10�Q�编辑XML�Q�用免费版功能即�?
tomcatPluginV3�Q�tomcat��理插�g
Properties Editor�Q�编辑java的属性文�?�q�可以预览以及自动存盘�ؓUnicode格式。免��M��手工或者ANT调用native2ascii的麻烦�?

3、示例源�E�序

ibatis�C�Z��E�序JpetStore 4.0 http://www.ibatis.com/jpetstore/jpetstore.html
攚w��后的源�E�序�Q?spring�Q�（源码链接�Q?

2.3. 架构

�? JpetStore架构�?/strong>

�? 是JPetStore架构图，更详�l�的内容请参见JPetStore的白皮书。参照这个架构图�Q�让我们�E�微剖析一下源代码�Q�得出JpetStore 4.0的具体实现图�Q�见�?�Q�，思�\一下子��p��然开朗了。前�a�中提到的非传�l�的struts开发模式，关键��在struts Action�c�d��form bean�c�M��?/p>
struts Action�c�d��有一个：BeanAction。没错，��实是一个！与传�l�的struts�~�程方式很不同。再仔细研究BeanAction�c�，发现它其实是一个通用�c�，利用反射原理�Q�根据URL来决定调用formbean的哪个方法。BeanAction大大��化了struts的编�E�模式，降低了对struts的依赖（与struts以及WEB容器有关的几个类都放在com.ibatis.struts包下�Q�其它的�c�都可以直接复用�Q�。利用这�U�模式，我们会很�Ҏ��的把它移植到新的框架如JSF�Q�spring�?/p>
�q�样重心��p�{�U�d��form bean上了�Q�它已经不是普通意义上的form bean了。查看源代码�Q�可以看到它不仅仅有数据和校�?重置�Ҏ��Q�而且已经��h��了行为，从这个意义上来说�Q�它更像一个BO(Business Object)。这��是前文讲到的，BeanAction�c�d��用反��原理，�Ҏ��URL来决定调用form bean的哪个方法（行�ؓ�Q�。form bean的这些方法的�{�֐�很简单，例如�Q?/p>

public String myActionMethod() { //..work return "success"; }

�Ҏ��的返回值直接就是字�W�串�Q�对应的是forward的名�U�ͼ�而不再是ActionForward对象�Q�创建ActionForward对象的�Q务已�l�由BeanAction�c�M��劳了�?/p>
另外�Q�程序还提供了ActionContext工具�c�，该工��L��装了request 、response、form parameters、request attributes、session attributes�?application attributes中的数据存取操作�Q�简单而线�E�安全，form bean�c�M��用该工具�c�d��以进一步从表现层框架解耦�?/p>
在这里需要特别指出的是，BeanAction�c�L��对struts扩展的一个有益尝试，虽然提供了非常好的应用开发模式，但是它还非常斎ͼ�一直在发展中�?/p>
�? JpetStore 4.0具体实现

2.4. 代码剖析

下面��p��我们开始进一步分析JpetStore4.0的源代码�Q��ؓ下面的改造铺路�?/p>

BeanAction.java是唯一一个Struts action�c�，位于com.ibatis.struts包下。正如上文所�a��Q�它是一个通用的控制类�Q�利用反��机�Ӟ��把控制�{�U�d��form bean的某个方法来处理。详�l�处理过�E�参考其源代码，��单明晰�?

Form bean�c�M��于com.ibatis.jpetstore.presentation包下�Q�命名规则�ؓ***Bean。Form bean�c�d��部��承于BaseBean�c�，而BaseBean�c�d��际��承于ActionForm�Q�因此，Form bean�c�d��是Struts�?ActionForm�Q�Form bean�cȝ��属性数据就由struts框架自动填充。而实际上�Q�JpetStore4.0扩展了struts中ActionForm的应用： Form bean�c�还��h��行�ؓ�Q�更像一个BO,其行为（�Ҏ��Q�由BeanAction�Ҏ��配置�Q�struts-config.xml�Q�的URL来调用。虽然如此，我们�q�是把Form bean�c�d��位于表现层�?/p>
Struts-config.xml的配�|�里�?�U�映��方式，来告诉BeanAction把控制�{到哪个form bean对象的哪个方法来处理�?/p>
以这个请求连接�ؓ例http://localhost/jpetstore4/shop/viewOrder.do

1. URL Pattern

此种方式表示�Q�控制将被�{发到"orderBean"�q�个form bean对象 �?viewOrder"�Ҏ��Q�行为）来处理。方法名�?path"参数的以"/"分隔的最后一部分�?/p>
2. Method Parameter

此种方式表示�Q�控制将被�{发到"orderBean"�q�个form bean对象�?viewOrder"�Ҏ��Q�行为）来处理。配�|�中�?parameter"参数表示form bean�c�M��的方法�?parameter"参数优先�?path"参数�?/p>
3. No Method call

此种方式表示�Q�form bean上没有�Q何方法被调用。如果存�?name"属性，则struts把表单参数等数据填充到form bean对象后，把控制�{发到"success"。否则，如果name为空�Q�则直接转发控制�?success"�?/p>
�q�就相当于struts内置的org.apache.struts.actions.ForwardAction的功�?/p>

Service�c�M��于com.ibatis.jpetstore.service包下�Q�属于业务层。这些类��装了业务以及相应的事务控制。Service�cȝ��form bean�c�L��调用�?
com.ibatis.jpetstore.persistence.iface包下的类是DAO接口�Q�属于业务层�Q�其屏蔽了底层的数据库操作，供具体的Service�c�L��调用。DaoConfig�c�L��工具�c�（DAO工厂�c�）�Q�Service�c�通过DaoConfig�c�L��获得相应的DAO接口�Q�而不用关心底层的具体数据库操作，实现了如�?中{耦合2}的解耦�?
com.ibatis.jpetstore.persistence.sqlmapdao包下的类是对应DAO接口的具体实玎ͼ�在JpetStore4.0中采用了ibatis来实现ORM。这些实现类�l�承BaseSqlMapDao�c�，而BaseSqlMapDao�c�d��l�承ibatis DAO 框架中的SqlMapDaoTemplate�c�R��ibatis的配�|�文件存攑֜�com.ibatis.jpetstore.persistence.sqlmapdao.sql目录下。这些类和配�|�文件位于数据层
Domain�c�M��于com.ibatis.jpetstore.domain包下�Q�是普通的javabean。在�q�里用作数据传输对象�Q�DTO�Q�，贯穿视图层、业务层和数据层�Q�用于在不同层之间传输数据�?/li>

剩下的部分就比较��单了�Q�请看具体的源代码，非常清晰�?/p>
2.5. 需要改造的地方

JpetStore4.0的关键就在struts Action�c�d��form bean�c�M��Q�这也是其精华之一�Q�虽然该实现方式是试验性，待扩充和验证�Q�，在此�ơ改造中我们要保留下来，��x��制层一点不变，表现层获取相应业务类的方式变了（要加载spring环境�Q�，其它保持不变。要特别��x��的改动是业务层和持久层，�q�运的是JpetStore4.0设计非常好，需要改动的地方非常��，而且由模式可循，如下�Q?/p>
1. 业务层和数据层用Spring BeanFactory机制��理�?/p>
2. 业务层的事务由spring 的aop通过声明来完成�?/p>
3. 表现层（form bean�Q�获取业务类的方法改��p��定义工厂�c�L��实现�Q�加载spring环境�Q��?/p>

回页�?/strong>

3. JPetStore的改�?/span>

3.1. 攚w��后的架�?/span>

其中�U�色部分是要增加的部分，蓝色部分是要修改的部分。下面就让我们逐一剖析�?/p>
3.2. Spring Context的加�?/span>

��Z��在Struts中加载Spring Context�Q�一般会在struts-config.xml的最后添加如下部分：

Spring在设计时��充分考虑��C��与Struts的协同工作，通过内置的Struts Plug-in在两者之间提供了良好的结合点。但是，因�ؓ在这里我们一点也不改动JPetStore的控制层(�q�是JpetStore4.0的精华之一)�Q�所以本文不准备采用此方式来加蝲ApplicationContext。我们利用的是spring framework 的BeanFactory机制,采用自定义的工具�c�（bean工厂�c�）来加载spring的配�|�文�Ӟ��从中可以看出Spring有多灉|��Q�它提供了各�U�不同的方式来��用其不同的部�?层次�Q�您只需要用你想用的�Q�不需要的部分可以不用�?/p>
具体的来��_��是在com.ibatis.spring包下创徏CustomBeanFactory�c�，spring的配�|�文件applicationContext.xml也放在这个目录下。以下就是该�cȝ��全部代码�Q�很��单：

public final class CustomBeanFactory { static XmlBeanFactory factory = null; static { Resource is = new InputStreamResource( CustomBeanFactory.class.getResourceAsStream("applicationContext.xml")); factory = new XmlBeanFactory(is); } public static Object getBean(String beanName){ return factory.getBean(beanName); } }

实际上就是封装了Spring 的XMLBeanFactory而已�Q��ƈ且Spring的配�|�文件只需要加载一�ơ，以后��可以直接用CustomBeanFactory.getBean("someBean")来获得需要的对象�?例如someBean)�Q�而不需要知道具体的�c�R��CustomBeanFactory�cȝ��于{耦合1}的解耦�?/p>
CustomBeanFactory�c�d��本文中只用于表现层的form bean对象获得service�cȝ��对象�Q�因为我们没有把form bean对象配置在applicationContext.xml中。但是，��Z��么不把表现层的form bean�c�M��配置��h��呢，�q�样��q��不着�q�CustomBeanFactory个类了，Spring会帮助我们创建需要的一切？问题的答案就在于form bean�c�L��struts的ActionForm�c�！如果大家熟悉struts�Q�就会知道ActionForm�c�L��struts自动创徏的：在一�ơ请求中�Q�struts判断�Q�如果ActionForm实例不存在，��创��Z��个ActionForm对象�Q�把客户提交的表单数据保存到ActionForm对象中。因此formbean�cȝ��对象��׃��能由spring来创建，但是service�c�M��及数据层的DAO�c�d��以，所以只有他们在spring中配�|��?/p>
所以，很自然的�Q�我们就创徏了CustomBeanFactory�c�，在表现层来衔接struts和spring。就�q�么��单，实现了另一�U�方式的{耦合一}的解耦�?/p>
3.3. 表现�?/span>
�?
面分析到�Q�struts和spring是在表现层衔接�v来的�Q�那么表现层��p��做稍微的更改�Q�即所需要的service�cȝ��对象创徏上。以表现层的AccountBean�c�Mؓ例：

原来的源代码如下

private static final AccountService accountService = AccountService.getInstance(); private static final CatalogService catalogService = CatalogService.getInstance();

攚w��后的源代码如下

private static final AccountService accountService = (AccountService)CustomBeanFactory.getBean("AccountService"); private static final CatalogService catalogService = (CatalogService)CustomBeanFactory.getBean("CatalogService");

其他的几个presentation�c�M��同样方式攚w��。这��P��表现层就完成了。关于表现层的其它部分如JSP�{�一概不动。也许您会说�Q�没有看��Z��么特别之处的好处啊？你还是额外实��C��一个工厂类。别着急，帷幕刚刚开启，spring是在表现层引入，但您发没发现�Q?/p>

presentation�c�M��仅面向service�cȝ��接口�~�程�Q�具�?AccountService"是哪个实现类�Q�presentation�c�M��知道�Q�是在spring的配�|�文仉��配置。（本例中，��Z��最大限度的保持原来的代码不作变化，没有抽象出接口）。Spring鼓励面向接口�~�程�Q�因为是如此的方便和自然�Q�当然您也可以不�q�么做�?
CustomBeanFactory�q�个工厂�c�Mؓ什么会如此��单，因�ؓ其直接��用了Spring的BeanFactory。Spring从其核心而言�Q�是一个DI容器�Q�其设计哲学是提供一�U�无侵入式的高扩展性的框架。�ؓ了实现这个目标，Spring 大量引入了Java 的Reflection机制�Q�通过动态调用的方式避免��编码方式的�U�束�Q��ƈ在此基础上徏立了其核心组件BeanFactory�Q�以此作为其依赖注入机制的实现基��。org.springframework.beans包中包括了这些核心组件的实现�c�，核心中的核心为BeanWrapper和BeanFactory�c�R�?

3.4. 持久�?/span>

在讨��Z��务层之前�Q�我们先看一下持久层�Q�如下图所�C�：

在上文中�Q�我们把iface包下的DAO接口归�ؓ业务层，在这里不需要做修改。ibatis的sql配置文�g也不需要改。要改的是DAO实现�c�，�q�在spring的配�|�文件中配置��h��?/p>
1、修改基�c?/p>
所有的DAO实现�c�都�l�承于BaseSqlMapDao�c�R��修改BaseSqlMapDao�c�d��下：

public class BaseSqlMapDao extends SqlMapClientDaoSupport { protected static final int PAGE_SIZE = 4; protected SqlMapClientTemplate smcTemplate = this.getSqlMapClientTemplate(); public BaseSqlMapDao() { } }

使BaseSqlMapDao�c�L��为��承于Spring提供的SqlMapClientDaoSupport�c�，�q�定义了一个保护属性smcTemplate�Q�其�c�d��为SqlMapClientTemplate。关于SqlMapClientTemplate�cȝ��详细说明请参照附录中�?Spring中文参考手�?

2、修改DAO实现�c?/p>
所有的DAO实现�c�还是��承于BaseSqlMapDao�c�，实现相应的DAO接口�Q�但其相应的DAO操作委托SqlMapClientTemplate来执行，以AccountSqlMapDao�c�Mؓ例，部分代码如下�Q?/p>

public List getUsernameList() { return smcTemplate.queryForList("getUsernameList", null); } public Account getAccount(String username, String password) { Account account = new Account(); account.setUsername(username); account.setPassword(password); return (Account) smcTemplate.queryForObject("getAccountByUsernameAndPassword", account); } public void insertAccount(Account account) { smcTemplate.update("insertAccount", account); smcTemplate.update("insertProfile", account); smcTemplate.update("insertSignon", account); }

��p��么简单，所有函数的�{�֐�都是一��L��Q�只需要查找替换就可以了！

3、除��d��厂类以及相应的配�|�文�?/p>
除去DaoConfig.java�q�个DAO工厂�c�d��相应的配�|�文件dao.xml�Q�因为DAO的获取现在要用spring来管理�?/p>
4、DAO在Spring中的配置�Q�applicationContext.xml�Q?/p>

org.hsqldb.jdbcDriver jdbc:hsqldb:hsql://localhost/xdb sa classpath:com\ibatis\jpetstore\persistence\sqlmapdao\sql\sql-map-config.xml

具体的语法请参照附录中的"Spring中文参考手�?。在�q�里只简单解释一下：

1. 我们首先创徏一个数据源dataSource�Q�在�q�里配置的是hsqldb数据库。如果是ORACLE数据库，driverClassName的值是"oracle.jdbc.driver.OracleDriver"�Q�URL的值类��g��"jdbc:oracle:thin:@wugfMobile:1521:cdcf"。数据源现在由spring来管理，那么现在我们��可以去掉properties目录下database.properties�q�个配置文�g了；�q�有不要忘记修改sql-map-config.xml�Q�去�?lt;properties resource="properties/database.properties"/>对它的引用�?/p>
2. sqlMapClient节点。这个是针对ibatis SqlMap的SqlMapClientFactoryBean配置。实际上配置了一个sqlMapClient的创建工厂类。configLocation属性配�|�了ibatis映射文�g的名�U�。dataSource属性指向了使用的数据源�Q�这��h��有��用sqlMapClient的DAO都默认��用了该数据源�Q�除非在DAO的配�|�中另外昑ּ�指定�?/p>
3. TransactionManager节点。定义了事务�Q��用的是DataSourceTransactionManager�?/p>
4. 下面��可以定义DAO节点了，如AccountDao�Q�它的实现类是com.ibatis.jpetstore.persistence.sqlmapdao.AccountSqlMapDao�Q��用的SQL配置从sqlMapClient中读取，数据库连接没有特别列出，那么��是默认使用sqlMapClient配置的数据源datasource�?/p>
�q�样�Q�我们就把持久层攚w��完了，其他的DAO配置�c�M��于AccountDao。怎么��P��单吧。这�ơ有接口了：�Q?AccountDao接口�Q?gt;AccountSqlMapDao实现�?/p>
3.5. 业务�?/span>

业务层的位置以及相关�c�，如下图所�C�：

在这个例子中只有3个业务类�Q�我们以OrderService�c�Mؓ例来攚w��，�q�个�c�L��最复杂的，其中涉及了事务�?/p>
1、在ApplicationContext配置文�g中增加bean的配�|�：

PROPAGATION_REQUIRED

定义了一个OrderService�Q�还是很�Ҏ��懂的。�ؓ了简单�v见，使用了嵌套bean�Q�其实现�c�L��com.ibatis.jpetstore.service.OrderService�Q�分别引用了ItemDao�Q�OrderDao�Q�SequenceDao。该bean的insert*实现了事务管�?AOP方式)。TransactionProxyFactoryBean自动创徏一个事务advisor�Q?该advisor包括一个基于事务属性的pointcut,因此只有事务性的�Ҏ��被拦截�?/p>
2、业务类的修�?/p>
以OrderService��Z��Q?/p>

public class OrderService { /* Private Fields */ private ItemDao itemDao; private OrderDao orderDao; private SequenceDao sequenceDao; /* Constructors */ public OrderService() { } /** * @param itemDao 要设�|�的 itemDao�? */ public final void setItemDao(ItemDao itemDao) { this.itemDao = itemDao; } /** * @param orderDao 要设�|�的 orderDao�? */ public final void setOrderDao(OrderDao orderDao) { this.orderDao = orderDao; } /** * @param sequenceDao 要设�|�的 sequenceDao�? */ public final void setSequenceDao(SequenceDao sequenceDao) { this.sequenceDao = sequenceDao; } //剩下的部�? ……. }

�U�色部分��Z��攚w��分。Spring采用的是Type2的设�|�依赖注入，所以我们只需要定义属性和相应的设值函数就可以了，ItemDao�Q�OrderDao�Q�SequenceDao的值由spring在运行期间注入。构造函数就可以为空了，另外也不需要自��q��写代码处理事务了�Q�事务在配置中声明）�Q�daoManager.startTransaction();�{�与事务相关的语句也可以��L��了。和原来的代码比较一下，是不是处理精��了很多！可以更关注业务的实现�?/p>

回页�?/strong>

4. �l�束�?/span>

ibatis是一个功能强大实用的SQL Map工具�Q�可以直接控制SQL,为系�l�设计提供了更大的自��q��间。其提供的最新示例程序JpetStore 4.0,设计优雅�Q�应用了�q�今为止很多最佛_��践和设计模式�Q�非帔R��于学习以及在此基础上创��量��的J2EE WEB应用�E�序。JpetStore 4.0是基于struts的，本文在此基础上，最大程度保持了原有设计的精华以及最��的代码改动量，在业务层和持久化层引入了Spring。在您阅��M��本文以及攚w��后的源代码后，会深切的感受到Spring带来的种�U�好处：自然的面向接口的�~�程�Q�业务对象的依赖注入�Q�一致的数据存取框架和声明式的事务处理，�l�一的配�|�文�?#8230;更重要的是Spring既是全面的又是模块化的，Spring有分层的体系�l�构�Q�这意味着您能选择仅仅使用它�Q何一个独立的部分�Q�就像本文，而它的架构又是内部一致�?/p>

参考资�?

jpetstore相关各种资料和源�E�序 http://www.ibatis.com/jpetstore/jpetstore.html

Spring中文参考手�?a >http://www.jactiongroup.net/reference/html/index.html

Spring 开发指�?夏昕

Struts http://struts.apache.org/

�C�物 2007-12-05 15:40 发表评论

�C�物 — Wed, 05 Dec 2007 07:39:00 GMT

10.3 Spring对IBatis的支�?nbsp;

http://book.csdn.net/ 2006-8-15 16:27:00

图书��D��

当前章节:10.3 Spring对IBatis的支�?/font>

·4.1 模式�Q�Pattern�Q�入�?/a>

·4.2 工厂模式�Q�Design Pattern�Q�Factory Method�Q�的�_�N��

·4.3 单例模式�Q�Design Pattern�Q�Singleton�Q?/a>

·10.4 Spring对Hibernate的支�?/a>

·10.5 ��结

·18.1 模仿对象

IT 游戏开发�h才专业招聘网�?/a>

每日上万个IT��历更�?快捷有效的招聘求�?

www.jobg.cn

非常4�Q?大学生实训计划，首付6800

4个月的全套Java技术体�pȝ��实训, 1个月的企业大型真实项目的实战开发�?

www.kettas.com.cn/

�q�距��L��触开源ERP

开源带来了哪些斚w��的好处？开源后的运营方向又是怎样�Q?

live.csdn.net

Spring�?/span>IBatis提供了完善的内徏支持。��?/span>Spring提供�?/span>IBatis辅助�c�，可以大大��化原有的IBatis讉K��代码。这些辅助类位于org.springframework.orm.ibatis包下�Q�目�?/span>Spring可同时支�?/span>IBatis1.3.x�?/span>2.0�?/span> 此外�Q�针�?/span>IBatis�Q?/span>Spring也提供了�?/span>JdbcTemplate一致的异常处理方式

10.3.1         标准JavaBean实体和映��?/span>

Spring宠物店非常典型的展现�?/span>Spring�?/span>IBatis的整合，下文��围�l�宠物店展开介绍�?/span>

首先来看宠物店中的一个领域对象（它是一个标准的JavaBean�Q�和它的映射文�g�Q�如代码10.13~10.14所�C��?/span>

代码10.13 Product.java

public class Product implements Serializable {

private String productId;

private String categoryId;

private String name;

private String description;

省略getter/setter...

}

代码10.14 Product.xml

...

class="org.springframework.samples.jpetstore.domain.Product">



    ...

    ...

10.3.2 衔接IBatis配置�?/span>DAO实现

接着�l�出IBatis的基本配�|�文�Ӟ��如代�?/span>10.15所�C��?/span>

代码10.15 sql-map-config.xml

...

...

在宠物店中，该文件仅包含了所有领域对象的映射文�g�Q�而挪��C��关于IBatis的事务和数据源配�|�（�?/span>IBatis配置文�g中的transactionManager元素和它的子元素dataSource�Q��?/span>

注意�Q?/span>在稍后将要给出的Spring配置文�g中接手了�q�些配置�Q�这是一个整合点�?/span>

在宠物店中，持久和数据访问都是通过DAO来实现的。对�?/span>Product�Q�存在一个与其对应的SqlMapProductDao�Q�如代码10.16所�C��?/span>

代码10.16 SqlMapProductDao.java

package org.springframework.samples.jpetstore.dao.ibatis;

import java.util.ArrayList;

import java.util.List;

import java.util.StringTokenizer;

import org.springframework.dao.DataAccessException;

import org.springframework.orm.ibatis.support.SqlMapClientDaoSupport;

import org.springframework.samples.jpetstore.dao.ProductDao;

import org.springframework.samples.jpetstore.domain.Product;

public class SqlMapProductDao

extends SqlMapClientDaoSupport

implements ProductDao {

public List getProductListByCategory(String categoryId)

    throws DataAccessException {

    return getSqlMapClientTemplate().queryForList("getProductListByCategory",

categoryId);

}

public Product getProduct(String productId)

    throws DataAccessException {

    return (Product) getSqlMapClientTemplate().queryForObject("getProduct", productId);

}

...

}

上述代码中出��C��Spring提供�?/span>IBatis DAO支持�c�d��获取SqlMapClientTemplate的父�c�L��板方法，�q�和JdbcDaoSupport�?/span>JdbcTemplate的��用具有一致的概念。�ƈ且，�q�些操作都统一的抛�?/span>Spring的通用数据讉K��异常DataAccessException�?/span>

注意�Q?/span>在早期的IBatis1.3.x版本�?/span>Dao支持�c�d��模板�c�d��别被命名�?/span>SqlMapDaoSupport�?/span>SqlMapTemplate�Q�在使用时不要�؜淆�?/span>

10.3.3 关键整合点：Spring配置文�g

有了以上�?/span>DAO�l��g后，来看一�?/span>Spring的配�|�，�q�是一个关键的整合点，如代�?/span>10.17所�C��?/span>

代码10.17 dataAccessContext-local.xml

"http://www.springframework.org/dtd/spring-beans.dtd">

class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">









class="org.springframework.jdbc.datasource.DataSourceTransactionManager">



class="org.springframework.orm.ibatis.SqlMapClientFactoryBean">





...

class="org.springframework.samples.jpetstore.dao.ibatis.SqlMapProductDao">



...

可以发现�Q?/span>Spring在上�q�文件中分别配置了数据源和事务管理的�{�略�Q�其中挪��M��原先�?/span>IBatis文�g中的配置�?/span>

说明�Q?/span>�q�样做的好处是可以通过Spring IoC容器�l�一的管理资源，在稍后还可以看到�Q?/span>Spring提供的声明性事务管理就是借助于统一的数据源和事务管理配�|��?/span>

SqlMapClientFactoryBean又是一个工�?/span>bean�Q�它暴露了两个关键属性用于注��?/span>IBatis配置文�g和相关的数据源。在工厂内部�Q�通过��d��IBatis配置文�g�Q?/span>Spring会创建出IBatis的核心组�?/span>SqlMapClient�Q��ƈ向相关的DAO�q�行注射�?/span>

SqlMapProductDao�l�承�?/span>SqlMapClientDaoSupport�Q�后者暴露出一�?/span>sqlMapClient属性，用于接受Spring的注��?/span>SqlMapClientDaoSupport会对其中��装�?/span>SqlMapClientTemplate做相应的讄��Q�所�?/span>DAO子类便可在取�?/span>SqlMapClientTemplate时正常地工作了�?/span>

10.3.4 ��d��声明式事务管�?/span>

以上�?/span>IBatis DAO可以很自方便地被注射到相应的业务对象�Q��ƈ参与�?/span>Spring提供的声明性事务中�Q�配�|�如代码10.18所�C��?/span>

代码10.18   applicationContext.xml

"http://www.springframework.org/dtd/spring-beans.dtd">

class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">





         ...

        WEB-INF/jdbc.properties





...

class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean"

abstract="true">







        PROPAGATION_REQUIRED

        PROPAGATION_REQUIRED

        PROPAGATION_REQUIRED,readOnly









       ...



        ...



��x��基本完成了Spring IoC�?/span>IBatis的整合了�Q�当然也可以通过�~�程的方式来使用Spring所提供的模板和支持�c�R�?/span>

�C�物 2007-12-05 15:39 发表评论

�C�物 — Wed, 05 Dec 2007 07:39:00 GMT
1�? Spring要结合Ibatis要在Spring的应用程序上下文中配�|�：

�E�序代码�Q?/td>

"dataSource"
class="org.apache.commons.dbcp.BasicDataSource"
destroy-method="close">
"driverClassName"
value="${jdbc.driverClassName}" />
"url" value="${jdbc.url}" />
"username" value="${jdbc.username}" />
"password" value="${jdbc.password}" />

"sqlMapClient"
class="org.springframework.orm.ibatis.SqlMapClientFactoryBean">
"configLocation"
value="classpath:resource/sqlmap-config.xml" />
"dataSource" ref="dataSource" />

数据源也可以在sqlmap-config中配�|��?br /> 2、如果DAO的实现类是实现SqlMapClientDaoSupport的，则在应用�E�序上下文中中配�|�如下：

�E�序代码�Q?/td>

"userInfoSqlMapDaoImpl"
class="com.sample.persistence.sqlmap.ibatis.UserInfoSqlMapDaoImpl">
"sqlMapClient" ref="sqlMapClient" />

如果实现�c�L��有其他的属性可以象上面的配�|�，如果�q�有其他的属性，则还要加其他的属性�?

�C�物 2007-12-05 15:39 发表评论