- 浏览: 565223 次
- 性别:
- 来自: 北京
文章分类
- 全部博客 (267)
- 随笔 (4)
- Spring (13)
- Java (61)
- HTTP (3)
- Windows (1)
- CI(Continuous Integration) (3)
- Dozer (1)
- Apache (11)
- DB (7)
- Architecture (41)
- Design Patterns (11)
- Test (5)
- Agile (1)
- ORM (3)
- PMP (2)
- ESB (2)
- Maven (5)
- IDE (1)
- Camel (1)
- Webservice (3)
- MySQL (6)
- CentOS (14)
- Linux (19)
- BI (3)
- RPC (2)
- Cluster (9)
- NoSQL (7)
- Oracle (25)
- Loadbalance (7)
- Web (5)
- tomcat (1)
- freemarker (1)
- 制造 (0)
最新评论
-
panamera:
如果设置了连接需要密码,Dynamic Broker-Clus ...
ActiveMQ 集群配置 -
panamera:
请问你的最后一种模式Broker-C节点是不是应该也要修改持久 ...
ActiveMQ 集群配置 -
maosheng:
longshao_feng 写道楼主使用 文件共享 模式的ma ...
ActiveMQ 集群配置 -
longshao_feng:
楼主使用 文件共享 模式的master-slave,produ ...
ActiveMQ 集群配置 -
tanglanwen:
感触很深,必定谨记!
少走弯路的十条忠告
简介:
iBATIS 通过 SQL Map 将 Java 对象映射成 SQL 语句和将结果集再转化成 Java 对象,与其他 ORM 框架相比,既解决了 Java 对象与输入参数和结果集的映射,又能够让用户方便的手写使用 SQL 语句。
本文主要介绍了 iBATIS 框架的体系结构和运行流程,以及 iBATIS 如何完成 SQL 语句的解析与 Java 对象与数据字段映射关系的建立,最后用一个实例说明了 iBATIS 是如何帮我们完成工作的。
iBATIS 框架主要的类层次结构:
总体来说 iBATIS 的系统结构还是比较简单的,它主要完成两件事情:
1.根据 JDBC 规范建立与数据库的连接;
2.通过反射打通 Java 对象与数据库参数交互之间相互转化关系。
iBATIS 的框架结构也是按照这种思想来组织类层次结构的,其实它是一种典型的交互式框架。先期准备好交互的必要条件,然后构建一个交互的环境,交互环境中还划分成会话,每次的会话也有一个环境。当这些环境都准备好了以后,剩下的就是交换数据了。其实涉及到网络通信,一般都会是类似的处理方式。
图 1 是 iBATIS 框架的主要的类层次结构图:
上面的类图中左边 SqlMapClient 接口主要定义了客户端的操作行为包括 select、insert、update、delete。而右边主要是定义了当前客户端在当前线程的执行环境。SqlMapSession 可以共享使用,也可以自己创建,如果是自己创建在结束时必须要调用关闭接口关闭。
当使用者持有了 SqlMapClientImpl 对象就可以使用 iBATIS 来工作了。这里还要提到另外一个类 SqlMapExecutorDelegate 这个类从名字就可以看出他是执行代理类。这个类非常重要,重要是因为他耦合了用户端的执行操作行为和执行的环境,他持有执行操作的所需要的数据,同时提供管理着执行操作依赖的环境。所以他是一个强耦合的类,也可以看做是个工具类。
iBATIS 框架的设计策略:
iBATIS 主要的设计目的还是为了让我们执行 SQL 时对输入输出的数据管理更加方便,所以如何方便的让我们写出 SQL 和方便的获取 SQL 的执行结果才是 iBATIS 的核心竞争力。那么 iBATIS 是怎么实现它的核心竞争力的呢?
iBATIS 框架的一个重要组成部分就是其 SqlMap 配置文件,SqlMap 配置文件的核心是 Statement 语句包括 CIUD。 iBATIS 通过解析 SqlMap 配置文件得到所有的 Statement 执行语句,同时会形成 ParameterMap、ResultMap 两个对象用于处理参数和经过解析后交给数据库处理的 Sql 对象。这样除去数据库的连接,一条 SQL 的执行条件已经具备了。
图 2 描述了 Statement 有关的类结构图:
图 2 给出了围绕 SQL 执行的基本的结构关系,但是还有一个关键的部分就是,如何定义 SQL 语句中的参数与 Java 对象之间的关系,这其中还涉及到 Java 类型到数据库类型的转换等一系列问题。
数据的映射大体的过程是这样的:根据 Statement 中定义的 SQL 语句,解析出其中的参数,按照其出现的顺序保存在 Map 集合中,并按照 Statement 中定义的 ParameterMap 对象类型解析出参数的 Java 数据类型。并根据其数据类型构建 TypeHandler 对象,参数值的复制是通过 DataExchange 对象完成的。
图 3 是参数映射相关的类结构图:
图 3 是输入参数的映射结构情况,返回结果 ResultMap 的映射情况也是类似的。主要就是要解决 SQL 语句中的参数与返回结果的列名与 Statement 中定义的 parameterClass 和 resultClass 中属性的对应关系。
iBATIS 框架的运行原理:
前面大体分析了 iBATIS 框架的主要类的结构,这里主要看一下这些类是如何串联起来、如何工作的。
图 4 描述了整个过程的主要执行步骤。
上图中描述的 SqlMapSession 对象的创建和释放根据不同情况会有不同,因为 SqlMapSession 负责创建数据库的连接,包括对事务的管理,iBATIS 对管理事务既可以自己管理也可以由外部管理,iBATIS 自己管理是通过共享 SqlMapSession 对象实现的,多个 Statement 的执行时共享一个 SqlMapSession 实例,而且都是线程安全的。如果是外部程序管理就要自己控制 SqlMapSession 对象的生命周期。
代码示例:
下面我们将根据一个具体的实例解析一个 Statement 如何完成映射的,我们用一个典型的查询语句看看 Java 对象中的数据时如何赋给 SQL 中的参数的,再看看 SQL 的查询结果是如何转成 Java 对象的。
Spring 的 applicationContext 配置文件(applicationContext.xml):
<?xml version="1.0" encoding="GBK"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd">
<beans>
<bean id="sqlMapTransactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<property name="dataSource" ref="dataSource"/>
</bean>
<bean id="sqlMapTransactionTemplate" class="org.springframework.transaction.support.TransactionTemplate">
<property name="transactionManager" ref="sqlMapTransactionManager"/>
</bean>
<!--sql map -->
<bean id="sqlMapClient" class="org.springframework.orm.ibatis.SqlMapClientFactoryBean">
<property name="configLocation" value="com/mydomain/data/SqlMapConfig.xml"/>
<property name="dataSource" ref="dataSource"/>
</bean>
<bean id="dataSource" name="dataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">
<property name="driverClassName" value="oracle.jdbc.driver.OracleDriver"/>
<property name="url" value="jdbc:oracle:thin:@10.1.5.11:1521:XE"/>
<property name="username" value="junshan"/>
<property name="password" value="junshan"/>
<property name="maxActive" value="20"/>
</bean>
<bean id="accountDAO" class="com.mydomain.DAO.AccountDAO">
<property name="sqlMapClient" ref="sqlMapClient"/>
<property name="sqlMapTransactionTemplate" ref="sqlMapTransactionTemplate"/>
</bean>
</beans>
iBatis的SqlMapConfig配置文件(SqlMapConfig.xml)
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE sqlMapConfig
PUBLIC "-//ibatis.apache.org//DTD SQL Map Config 2.0//EN"
"http://ibatis.apache.org/dtd/sql-map-config-2.dtd">
<sqlMapConfig>
<!-- Configure a built-in transaction manager. If you're using an
app server, you probably want to use its transaction manager
and a managed datasource -->
<!-- -->
<transactionManager type="JDBC" commitRequired="false">
<dataSource type="SIMPLE">
<property name="JDBC.Driver" value="oracle.jdbc.driver.OracleDriver"/>
<property name="JDBC.ConnectionURL" value="jdbc:oracle:thin:@10.1.5.11:1521:XE"/>
<property name="JDBC.Username" value="junshan"/>
<property name="JDBC.Password" value="junshan"/>
<property name="JDBC.DefaultAutoCommit" value="true"></property>
</dataSource>
</transactionManager>
<!-- List the SQL Map XML files. They can be loaded from the
classpath, as they are here (com.domain.data...) -->
<sqlMap resource="com/mydomain/data/Account.xml"/>
<!-- List more here...
<sqlMap resource="com/mydomain/data/Order.xml"/>
<sqlMap resource="com/mydomain/data/Documents.xml"/>
-->
</sqlMapConfig>
Account.xml配置文件
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE sqlMap
PUBLIC "-//ibatis.apache.org//DTD SQL Map 2.0//EN"
"http://ibatis.apache.org/dtd/sql-map-2.dtd">
<sqlMap namespace="Account">
<!-- Use type aliases to avoid typing the full classname every time. -->
<typeAlias alias="Account" type="com.mydomain.domain.Account"/>
<!-- Result maps describe the mapping between the columns returned
from a query, and the class properties. A result map isn't
necessary if the columns (or aliases) match to the properties
exactly. -->
<resultMap id="AccountResult" class="Account">
<result property="id" column="ACC_ID" nullValue="0"/>
<result property="firstName" column="ACC_FIRST_NAME"/>
<result property="lastName" column="ACC_LAST_NAME"/>
<result property="emailAddress" column="ACC_EMAIL"/>
<result property="date" column="ACC_DATE"/>
</resultMap>
<!-- Select with no parameters using the result map for Account class. -->
<select id="selectAllAccounts" resultMap="AccountResult">
select * from ACCOUNT
</select>
<!-- A simpler select example without the result map. Note the
aliases to match the properties of the target result class. -->
<select id="selectAccount" parameterClass="Account" resultClass="Account">
select
ACC_ID,
ACC_FIRST_NAME as firstName,
ACC_LAST_NAME as lastName,
ACC_EMAIL as emailAddress,
ACC_DATE
from ACCOUNT
where ACC_ID = #id:INTEGER# and ACC_FIRST_NAME = #firstName#
</select>
<select id="selectAccountById" parameterClass="int" resultClass="Account">
select
ACC_ID as id,
ACC_FIRST_NAME as firstName,
ACC_LAST_NAME as lastName,
ACC_EMAIL as emailAddress,
ACC_DATE as date
from ACCOUNT
where ACC_ID = #id:INTEGER# and ACC_FIRST_NAME = #firstName#
</select>
<!-- Insert example, using the Account parameter class -->
<insert id="insertAccount" parameterClass="Account">
insert into ACCOUNT (
ACC_FIRST_NAME,
ACC_LAST_NAME,
ACC_EMAIL,
ACC_ID,
ACC_DATE)
values (
#firstName#, #lastName:VARCHAR#, #emailAddress#, #id#, #date:DATE#
)
</insert>
<!-- Update example, using the Account parameter class -->
<update id="updateAccount" parameterClass="Account">
update ACCOUNT set
ACC_FIRST_NAME = #firstName#,
ACC_LAST_NAME = #lastName#,
ACC_EMAIL = #emailAddress#
where
ACC_ID = #id#
</update>
<!-- Delete example, using an integer as the parameter class -->
<delete id="deleteAccountById" parameterClass="int">
delete from ACCOUNT where ACC_ID = #id#
</delete>
</sqlMap>
Java 测试类:
package com.mydomain.domain;
import java.util.Date;
public class Account {
private int id;
private String firstName;
private String lastName;
private String emailAddress;
private Date date;
public Date getDate() {
return date;
}
public void setDate(Date date) {
this.date = date;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getFirstName() {
return firstName;
}
public void setFirstName(String firstName) {
this.firstName = firstName;
}
public String getLastName() {
return lastName;
}
public void setLastName(String lastName) {
this.lastName = lastName;
}
public String getEmailAddress() {
return emailAddress;
}
public void setEmailAddress(String emailAddress) {
this.emailAddress = emailAddress;
}
@Override
public String toString() {
return "Account{" +
"id=" + id +
", firstName='" + firstName + '\'' +
", lastName='" + lastName + '\'' +
", emailAddress='" + emailAddress + '\'' +
'}';
}
}
package com.mydomain.dao;
import com.mydomain.domain.Account;
import org.springframework.orm.ibatis.support.SqlMapClientDaoSupport;
import org.springframework.transaction.support.TransactionTemplate;
import java.sql.SQLException;
import java.util.List;
/**
*
* To change this template use File | Settings | File Templates.
*/
public class AccountDAO extends SqlMapClientDaoSupport {
/**
* 数据库的事务模板
*/
protected TransactionTemplate sqlMapTransactionTemplate;
public TransactionTemplate getSqlMapTransactionTemplate() {
return sqlMapTransactionTemplate;
}
public void setSqlMapTransactionTemplate(TransactionTemplate sqlMapTransactionTemplate) {
this.sqlMapTransactionTemplate = sqlMapTransactionTemplate;
}
public List selectAll(){
return getSqlMapClientTemplate().queryForList("selectAllAccounts");
}
public Account selectAccountById (int id) throws SQLException {
return (Account) getSqlMapClientTemplate().queryForObject("selectAccountById", id);
}
public Account selectAccount (Account account) throws SQLException {
return (Account) getSqlMapClientTemplate().queryForObject("selectAccount", account);
}
public void insertAccount (Account account) throws SQLException {
getSqlMapClientTemplate().insert("insertAccount", account);
}
public void updateAccount (Account account) throws SQLException {
getSqlMapClientTemplate().update("updateAccount", account);
}
public void deleteAccount (int id) throws SQLException {
getSqlMapClientTemplate().delete("deleteAccountById", id);
}
}
package com.mydomain.test;
import com.ibatis.sqlmap.client.SqlMapClient;
import com.ibatis.sqlmap.client.SqlMapClientBuilder;
import com.ibatis.common.resources.Resources;
import com.mydomain.domain.Account;
import java.io.Reader;
import java.io.IOException;
import java.util.List;
import java.sql.SQLException;
/**
* This is not a best practices class. It's just an example
* to give you an idea of how iBATIS works. For a more complete
* example, see JPetStore 5.0 at http://www.ibatis.com.
*/
public class SimpleExample {
/**
* SqlMapClient instances are thread safe, so you only need one.
* In this case, we'll use a static singleton. So sue me. ;-)
*/
private static SqlMapClient sqlMapper;
/**
* It's not a good idea to put code that can fail in a class initializer,
* but for sake of argument, here's how you configure an SQL Map.
*/
static {
try {
Reader reader = Resources.getResourceAsReader("com/mydomain/data/SqlMapConfig.xml");
sqlMapper = SqlMapClientBuilder.buildSqlMapClient(reader);
reader.close();
} catch (IOException e) {
// Fail fast.
throw new RuntimeException("Something bad happened while building the SqlMapClient instance." + e, e);
}
}
public static List selectAllAccounts () throws SQLException {
return sqlMapper.queryForList("selectAllAccounts");
}
public static Account selectAccountById (int id) throws SQLException {
return (Account) sqlMapper.queryForObject("selectAccountById", id);
}
public static Account selectAccount (Account account) throws SQLException {
return (Account) sqlMapper.queryForObject("selectAccount", account);
}
public static void insertAccount (Account account) throws SQLException {
sqlMapper.insert("insertAccount", account);
}
public static void updateAccount (Account account) throws SQLException {
sqlMapper.update("updateAccount", account);
}
public static void deleteAccount (int id) throws SQLException {
sqlMapper.delete("deleteAccountById", id);
}
public SqlMapClient getSqlMapClient(){
return sqlMapper;
}
public static void main(String[] args) throws Exception{
SimpleExample accountDAO = new SimpleExample();
Account account = new Account();
account.setId(1);
account.setFirstName("tao");
account.setLastName("bao");
//account.setEmailAddress("junshan@taobao.com");
try {
SqlMapClient sqlMapper = accountDAO.getSqlMapClient();
//sqlMapper.startTransaction();
//accountDAO.deleteAccount(account.getId());
accountDAO.insertAccount(account);
account = accountDAO.selectAccount(account);
System.out.println(account);
account.setFirstName("bobo");
accountDAO.updateAccount(account);
System.out.println(account);
//accountDAO.insertAccount(account);
//sqlMapper.commitTransaction();
List as = accountDAO.selectAllAccounts();
} catch (SQLException e) {
e.printStackTrace();
}
}
}
package com.mydomain.test;
import java.util.Date;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.transaction.TransactionStatus;
import org.springframework.transaction.support.TransactionCallback;
import com.mydomain.DAO.AccountDAO;
import com.mydomain.domain.Account;
public class SimpleTest {
public static void main(String[] args) {
ApplicationContext factory = new ClassPathXmlApplicationContext("/com/mydomain/data/applicationContext.xml");
final AccountDAO accountDAO = (AccountDAO) factory.getBean("accountDAO");
final Account account = new Account();
account.setId(1);
account.setFirstName("tao");
account.setLastName("bao");
account.setEmailAddress("junshan@taobao.com");
account.setDate(new Date());
try {
accountDAO.getSqlMapTransactionTemplate().execute(new TransactionCallback(){
public Object doInTransaction(TransactionStatus status){
try{
accountDAO.deleteAccount(account.getId());
accountDAO.insertAccount(account);
account.setLastName("bobo");
accountDAO.updateAccount(account);
Account result = accountDAO.selectAccount(account);
System.out.println(result);
return null;
} catch (Exception e) {
status.setRollbackOnly();
return false;
}
}
});
//accountDAO.getSqlMapClient().commitTransaction();
} catch (Exception e) {
e.printStackTrace();
}
}
}
当我们执行:
accountDAO.selectAccount(account);
解析后的 SQL:
select
ACC_ID,
ACC_FIRST_NAME as firstName,
ACC_LAST_NAME as lastName,
ACC_EMAIL as emailAddress,
ACC_DATE
from ACCOUNT
where ACC_ID = ? and ACC_FIRST_NAME = ?
iBATIS 将会选择Account.xml中这条 Statement 来解析,最终会把它解析成一个标准的 SQL 提交给数据库执行,并且会设置两个选择条件参数。
iBATIS 会把 SqlMap 配置文件解析成一个个 Statement,其中包括 ParameterMap、ResultMap,以及解析后的 SQL。当 iBATIS 构建好 RequestScope 执行环境后,要做的工作就是把传过来的对象数据结合 ParameterMap 中信息提取出一个参数数组,这个数组的顺序就是对应于 SQL 中参数的顺序,然后会调用 preparedStatement.setXXX(i, parameter) 提交参数。
#id# 将被解析成 Account 对象的 id 属性。#firstName# 同样被解析成 Account 对象的 firstName 属性,而 parameterClass="Account"指明了 Account 的类类型。接着 iBATIS 会根据这些变量和 parameterClass 指定的类型创建合适的 dataExchange 和 parameterPlan 对象。parameterPlan 对象中按照前面的顺序保存了变量的setter 和 getter 方法列表。
映射参数值到数据库过程时序图
映射返回对象时序图
配置文件与相应代码对应关系图
iBATIS 要达到目的就是把用户关心的和容易变化的数据放到配置文件中配置,方便用户管理。而把流程性的、固定不变的交给 iBATIS 来实现。这样是用户操作数据库简单、方便,这也是 iBATIS 的价值所在。
iBATIS 通过 SQL Map 将 Java 对象映射成 SQL 语句和将结果集再转化成 Java 对象,与其他 ORM 框架相比,既解决了 Java 对象与输入参数和结果集的映射,又能够让用户方便的手写使用 SQL 语句。
本文主要介绍了 iBATIS 框架的体系结构和运行流程,以及 iBATIS 如何完成 SQL 语句的解析与 Java 对象与数据字段映射关系的建立,最后用一个实例说明了 iBATIS 是如何帮我们完成工作的。
iBATIS 框架主要的类层次结构:
总体来说 iBATIS 的系统结构还是比较简单的,它主要完成两件事情:
1.根据 JDBC 规范建立与数据库的连接;
2.通过反射打通 Java 对象与数据库参数交互之间相互转化关系。
iBATIS 的框架结构也是按照这种思想来组织类层次结构的,其实它是一种典型的交互式框架。先期准备好交互的必要条件,然后构建一个交互的环境,交互环境中还划分成会话,每次的会话也有一个环境。当这些环境都准备好了以后,剩下的就是交换数据了。其实涉及到网络通信,一般都会是类似的处理方式。
图 1 是 iBATIS 框架的主要的类层次结构图:
上面的类图中左边 SqlMapClient 接口主要定义了客户端的操作行为包括 select、insert、update、delete。而右边主要是定义了当前客户端在当前线程的执行环境。SqlMapSession 可以共享使用,也可以自己创建,如果是自己创建在结束时必须要调用关闭接口关闭。
当使用者持有了 SqlMapClientImpl 对象就可以使用 iBATIS 来工作了。这里还要提到另外一个类 SqlMapExecutorDelegate 这个类从名字就可以看出他是执行代理类。这个类非常重要,重要是因为他耦合了用户端的执行操作行为和执行的环境,他持有执行操作的所需要的数据,同时提供管理着执行操作依赖的环境。所以他是一个强耦合的类,也可以看做是个工具类。
iBATIS 框架的设计策略:
iBATIS 主要的设计目的还是为了让我们执行 SQL 时对输入输出的数据管理更加方便,所以如何方便的让我们写出 SQL 和方便的获取 SQL 的执行结果才是 iBATIS 的核心竞争力。那么 iBATIS 是怎么实现它的核心竞争力的呢?
iBATIS 框架的一个重要组成部分就是其 SqlMap 配置文件,SqlMap 配置文件的核心是 Statement 语句包括 CIUD。 iBATIS 通过解析 SqlMap 配置文件得到所有的 Statement 执行语句,同时会形成 ParameterMap、ResultMap 两个对象用于处理参数和经过解析后交给数据库处理的 Sql 对象。这样除去数据库的连接,一条 SQL 的执行条件已经具备了。
图 2 描述了 Statement 有关的类结构图:
图 2 给出了围绕 SQL 执行的基本的结构关系,但是还有一个关键的部分就是,如何定义 SQL 语句中的参数与 Java 对象之间的关系,这其中还涉及到 Java 类型到数据库类型的转换等一系列问题。
数据的映射大体的过程是这样的:根据 Statement 中定义的 SQL 语句,解析出其中的参数,按照其出现的顺序保存在 Map 集合中,并按照 Statement 中定义的 ParameterMap 对象类型解析出参数的 Java 数据类型。并根据其数据类型构建 TypeHandler 对象,参数值的复制是通过 DataExchange 对象完成的。
图 3 是参数映射相关的类结构图:
图 3 是输入参数的映射结构情况,返回结果 ResultMap 的映射情况也是类似的。主要就是要解决 SQL 语句中的参数与返回结果的列名与 Statement 中定义的 parameterClass 和 resultClass 中属性的对应关系。
iBATIS 框架的运行原理:
前面大体分析了 iBATIS 框架的主要类的结构,这里主要看一下这些类是如何串联起来、如何工作的。
图 4 描述了整个过程的主要执行步骤。
上图中描述的 SqlMapSession 对象的创建和释放根据不同情况会有不同,因为 SqlMapSession 负责创建数据库的连接,包括对事务的管理,iBATIS 对管理事务既可以自己管理也可以由外部管理,iBATIS 自己管理是通过共享 SqlMapSession 对象实现的,多个 Statement 的执行时共享一个 SqlMapSession 实例,而且都是线程安全的。如果是外部程序管理就要自己控制 SqlMapSession 对象的生命周期。
代码示例:
下面我们将根据一个具体的实例解析一个 Statement 如何完成映射的,我们用一个典型的查询语句看看 Java 对象中的数据时如何赋给 SQL 中的参数的,再看看 SQL 的查询结果是如何转成 Java 对象的。
Spring 的 applicationContext 配置文件(applicationContext.xml):
<?xml version="1.0" encoding="GBK"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd">
<beans>
<bean id="sqlMapTransactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<property name="dataSource" ref="dataSource"/>
</bean>
<bean id="sqlMapTransactionTemplate" class="org.springframework.transaction.support.TransactionTemplate">
<property name="transactionManager" ref="sqlMapTransactionManager"/>
</bean>
<!--sql map -->
<bean id="sqlMapClient" class="org.springframework.orm.ibatis.SqlMapClientFactoryBean">
<property name="configLocation" value="com/mydomain/data/SqlMapConfig.xml"/>
<property name="dataSource" ref="dataSource"/>
</bean>
<bean id="dataSource" name="dataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">
<property name="driverClassName" value="oracle.jdbc.driver.OracleDriver"/>
<property name="url" value="jdbc:oracle:thin:@10.1.5.11:1521:XE"/>
<property name="username" value="junshan"/>
<property name="password" value="junshan"/>
<property name="maxActive" value="20"/>
</bean>
<bean id="accountDAO" class="com.mydomain.DAO.AccountDAO">
<property name="sqlMapClient" ref="sqlMapClient"/>
<property name="sqlMapTransactionTemplate" ref="sqlMapTransactionTemplate"/>
</bean>
</beans>
iBatis的SqlMapConfig配置文件(SqlMapConfig.xml)
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE sqlMapConfig
PUBLIC "-//ibatis.apache.org//DTD SQL Map Config 2.0//EN"
"http://ibatis.apache.org/dtd/sql-map-config-2.dtd">
<sqlMapConfig>
<!-- Configure a built-in transaction manager. If you're using an
app server, you probably want to use its transaction manager
and a managed datasource -->
<!-- -->
<transactionManager type="JDBC" commitRequired="false">
<dataSource type="SIMPLE">
<property name="JDBC.Driver" value="oracle.jdbc.driver.OracleDriver"/>
<property name="JDBC.ConnectionURL" value="jdbc:oracle:thin:@10.1.5.11:1521:XE"/>
<property name="JDBC.Username" value="junshan"/>
<property name="JDBC.Password" value="junshan"/>
<property name="JDBC.DefaultAutoCommit" value="true"></property>
</dataSource>
</transactionManager>
<!-- List the SQL Map XML files. They can be loaded from the
classpath, as they are here (com.domain.data...) -->
<sqlMap resource="com/mydomain/data/Account.xml"/>
<!-- List more here...
<sqlMap resource="com/mydomain/data/Order.xml"/>
<sqlMap resource="com/mydomain/data/Documents.xml"/>
-->
</sqlMapConfig>
Account.xml配置文件
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE sqlMap
PUBLIC "-//ibatis.apache.org//DTD SQL Map 2.0//EN"
"http://ibatis.apache.org/dtd/sql-map-2.dtd">
<sqlMap namespace="Account">
<!-- Use type aliases to avoid typing the full classname every time. -->
<typeAlias alias="Account" type="com.mydomain.domain.Account"/>
<!-- Result maps describe the mapping between the columns returned
from a query, and the class properties. A result map isn't
necessary if the columns (or aliases) match to the properties
exactly. -->
<resultMap id="AccountResult" class="Account">
<result property="id" column="ACC_ID" nullValue="0"/>
<result property="firstName" column="ACC_FIRST_NAME"/>
<result property="lastName" column="ACC_LAST_NAME"/>
<result property="emailAddress" column="ACC_EMAIL"/>
<result property="date" column="ACC_DATE"/>
</resultMap>
<!-- Select with no parameters using the result map for Account class. -->
<select id="selectAllAccounts" resultMap="AccountResult">
select * from ACCOUNT
</select>
<!-- A simpler select example without the result map. Note the
aliases to match the properties of the target result class. -->
<select id="selectAccount" parameterClass="Account" resultClass="Account">
select
ACC_ID,
ACC_FIRST_NAME as firstName,
ACC_LAST_NAME as lastName,
ACC_EMAIL as emailAddress,
ACC_DATE
from ACCOUNT
where ACC_ID = #id:INTEGER# and ACC_FIRST_NAME = #firstName#
</select>
<select id="selectAccountById" parameterClass="int" resultClass="Account">
select
ACC_ID as id,
ACC_FIRST_NAME as firstName,
ACC_LAST_NAME as lastName,
ACC_EMAIL as emailAddress,
ACC_DATE as date
from ACCOUNT
where ACC_ID = #id:INTEGER# and ACC_FIRST_NAME = #firstName#
</select>
<!-- Insert example, using the Account parameter class -->
<insert id="insertAccount" parameterClass="Account">
insert into ACCOUNT (
ACC_FIRST_NAME,
ACC_LAST_NAME,
ACC_EMAIL,
ACC_ID,
ACC_DATE)
values (
#firstName#, #lastName:VARCHAR#, #emailAddress#, #id#, #date:DATE#
)
</insert>
<!-- Update example, using the Account parameter class -->
<update id="updateAccount" parameterClass="Account">
update ACCOUNT set
ACC_FIRST_NAME = #firstName#,
ACC_LAST_NAME = #lastName#,
ACC_EMAIL = #emailAddress#
where
ACC_ID = #id#
</update>
<!-- Delete example, using an integer as the parameter class -->
<delete id="deleteAccountById" parameterClass="int">
delete from ACCOUNT where ACC_ID = #id#
</delete>
</sqlMap>
Java 测试类:
package com.mydomain.domain;
import java.util.Date;
public class Account {
private int id;
private String firstName;
private String lastName;
private String emailAddress;
private Date date;
public Date getDate() {
return date;
}
public void setDate(Date date) {
this.date = date;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getFirstName() {
return firstName;
}
public void setFirstName(String firstName) {
this.firstName = firstName;
}
public String getLastName() {
return lastName;
}
public void setLastName(String lastName) {
this.lastName = lastName;
}
public String getEmailAddress() {
return emailAddress;
}
public void setEmailAddress(String emailAddress) {
this.emailAddress = emailAddress;
}
@Override
public String toString() {
return "Account{" +
"id=" + id +
", firstName='" + firstName + '\'' +
", lastName='" + lastName + '\'' +
", emailAddress='" + emailAddress + '\'' +
'}';
}
}
package com.mydomain.dao;
import com.mydomain.domain.Account;
import org.springframework.orm.ibatis.support.SqlMapClientDaoSupport;
import org.springframework.transaction.support.TransactionTemplate;
import java.sql.SQLException;
import java.util.List;
/**
*
* To change this template use File | Settings | File Templates.
*/
public class AccountDAO extends SqlMapClientDaoSupport {
/**
* 数据库的事务模板
*/
protected TransactionTemplate sqlMapTransactionTemplate;
public TransactionTemplate getSqlMapTransactionTemplate() {
return sqlMapTransactionTemplate;
}
public void setSqlMapTransactionTemplate(TransactionTemplate sqlMapTransactionTemplate) {
this.sqlMapTransactionTemplate = sqlMapTransactionTemplate;
}
public List selectAll(){
return getSqlMapClientTemplate().queryForList("selectAllAccounts");
}
public Account selectAccountById (int id) throws SQLException {
return (Account) getSqlMapClientTemplate().queryForObject("selectAccountById", id);
}
public Account selectAccount (Account account) throws SQLException {
return (Account) getSqlMapClientTemplate().queryForObject("selectAccount", account);
}
public void insertAccount (Account account) throws SQLException {
getSqlMapClientTemplate().insert("insertAccount", account);
}
public void updateAccount (Account account) throws SQLException {
getSqlMapClientTemplate().update("updateAccount", account);
}
public void deleteAccount (int id) throws SQLException {
getSqlMapClientTemplate().delete("deleteAccountById", id);
}
}
package com.mydomain.test;
import com.ibatis.sqlmap.client.SqlMapClient;
import com.ibatis.sqlmap.client.SqlMapClientBuilder;
import com.ibatis.common.resources.Resources;
import com.mydomain.domain.Account;
import java.io.Reader;
import java.io.IOException;
import java.util.List;
import java.sql.SQLException;
/**
* This is not a best practices class. It's just an example
* to give you an idea of how iBATIS works. For a more complete
* example, see JPetStore 5.0 at http://www.ibatis.com.
*/
public class SimpleExample {
/**
* SqlMapClient instances are thread safe, so you only need one.
* In this case, we'll use a static singleton. So sue me. ;-)
*/
private static SqlMapClient sqlMapper;
/**
* It's not a good idea to put code that can fail in a class initializer,
* but for sake of argument, here's how you configure an SQL Map.
*/
static {
try {
Reader reader = Resources.getResourceAsReader("com/mydomain/data/SqlMapConfig.xml");
sqlMapper = SqlMapClientBuilder.buildSqlMapClient(reader);
reader.close();
} catch (IOException e) {
// Fail fast.
throw new RuntimeException("Something bad happened while building the SqlMapClient instance." + e, e);
}
}
public static List selectAllAccounts () throws SQLException {
return sqlMapper.queryForList("selectAllAccounts");
}
public static Account selectAccountById (int id) throws SQLException {
return (Account) sqlMapper.queryForObject("selectAccountById", id);
}
public static Account selectAccount (Account account) throws SQLException {
return (Account) sqlMapper.queryForObject("selectAccount", account);
}
public static void insertAccount (Account account) throws SQLException {
sqlMapper.insert("insertAccount", account);
}
public static void updateAccount (Account account) throws SQLException {
sqlMapper.update("updateAccount", account);
}
public static void deleteAccount (int id) throws SQLException {
sqlMapper.delete("deleteAccountById", id);
}
public SqlMapClient getSqlMapClient(){
return sqlMapper;
}
public static void main(String[] args) throws Exception{
SimpleExample accountDAO = new SimpleExample();
Account account = new Account();
account.setId(1);
account.setFirstName("tao");
account.setLastName("bao");
//account.setEmailAddress("junshan@taobao.com");
try {
SqlMapClient sqlMapper = accountDAO.getSqlMapClient();
//sqlMapper.startTransaction();
//accountDAO.deleteAccount(account.getId());
accountDAO.insertAccount(account);
account = accountDAO.selectAccount(account);
System.out.println(account);
account.setFirstName("bobo");
accountDAO.updateAccount(account);
System.out.println(account);
//accountDAO.insertAccount(account);
//sqlMapper.commitTransaction();
List as = accountDAO.selectAllAccounts();
} catch (SQLException e) {
e.printStackTrace();
}
}
}
package com.mydomain.test;
import java.util.Date;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.transaction.TransactionStatus;
import org.springframework.transaction.support.TransactionCallback;
import com.mydomain.DAO.AccountDAO;
import com.mydomain.domain.Account;
public class SimpleTest {
public static void main(String[] args) {
ApplicationContext factory = new ClassPathXmlApplicationContext("/com/mydomain/data/applicationContext.xml");
final AccountDAO accountDAO = (AccountDAO) factory.getBean("accountDAO");
final Account account = new Account();
account.setId(1);
account.setFirstName("tao");
account.setLastName("bao");
account.setEmailAddress("junshan@taobao.com");
account.setDate(new Date());
try {
accountDAO.getSqlMapTransactionTemplate().execute(new TransactionCallback(){
public Object doInTransaction(TransactionStatus status){
try{
accountDAO.deleteAccount(account.getId());
accountDAO.insertAccount(account);
account.setLastName("bobo");
accountDAO.updateAccount(account);
Account result = accountDAO.selectAccount(account);
System.out.println(result);
return null;
} catch (Exception e) {
status.setRollbackOnly();
return false;
}
}
});
//accountDAO.getSqlMapClient().commitTransaction();
} catch (Exception e) {
e.printStackTrace();
}
}
}
当我们执行:
accountDAO.selectAccount(account);
解析后的 SQL:
select
ACC_ID,
ACC_FIRST_NAME as firstName,
ACC_LAST_NAME as lastName,
ACC_EMAIL as emailAddress,
ACC_DATE
from ACCOUNT
where ACC_ID = ? and ACC_FIRST_NAME = ?
iBATIS 将会选择Account.xml中这条 Statement 来解析,最终会把它解析成一个标准的 SQL 提交给数据库执行,并且会设置两个选择条件参数。
iBATIS 会把 SqlMap 配置文件解析成一个个 Statement,其中包括 ParameterMap、ResultMap,以及解析后的 SQL。当 iBATIS 构建好 RequestScope 执行环境后,要做的工作就是把传过来的对象数据结合 ParameterMap 中信息提取出一个参数数组,这个数组的顺序就是对应于 SQL 中参数的顺序,然后会调用 preparedStatement.setXXX(i, parameter) 提交参数。
#id# 将被解析成 Account 对象的 id 属性。#firstName# 同样被解析成 Account 对象的 firstName 属性,而 parameterClass="Account"指明了 Account 的类类型。接着 iBATIS 会根据这些变量和 parameterClass 指定的类型创建合适的 dataExchange 和 parameterPlan 对象。parameterPlan 对象中按照前面的顺序保存了变量的setter 和 getter 方法列表。
映射参数值到数据库过程时序图
映射返回对象时序图
配置文件与相应代码对应关系图
iBATIS 要达到目的就是把用户关心的和容易变化的数据放到配置文件中配置,方便用户管理。而把流程性的、固定不变的交给 iBATIS 来实现。这样是用户操作数据库简单、方便,这也是 iBATIS 的价值所在。
相关推荐
**深入分析 iBATIS 框架之系统架构与映射原理** iBATIS 是一个优秀的持久层框架,它允许开发者将 SQL 语句与 Java 代码分离,从而简化了数据库访问层的开发工作。本篇文章将深入探讨 iBATIS 的核心系统架构以及其...
这个自己编写的Ibatis框架实现,虽然可能在功能上与官方版本有所差异,但基本原理和核心思想是一致的,即通过XML配置文件解耦SQL和Java代码,提供灵活的SQL映射和参数映射,以及方便的结果集映射,以此简化数据库...
SqlMapConfig.xml是整个iBATIS框架的全局配置文件,它包含了数据源、事务管理器等核心组件的配置信息。在这个文件中,你可以定义数据源(DataSource),这是连接到数据库的入口;设置事务管理器(TransactionManager...
在"iBATIS框架源码剖析pdf第二部分"中,我们将深入探讨iBATIS的核心组件、工作原理以及其实现细节。 首先,我们来了解一下iBATIS的基本架构。iBATIS由四大核心部分组成:SqlMapConfig.xml配置文件、SqlMap接口、SQL...
SSH2+IBATIS框架是Java开发中常用的一套企业级应用开发框架组合,它将Spring、Hibernate、Struts2和iBatis等组件融合在一起,以提高开发效率和实现松耦合。以下是对这些框架及其整合方式的详细说明: **Spring框架*...
SpringMvc作为Spring框架的一部分,主要用于处理HTTP请求和视图的渲染,而iBatis则是一个轻量级的数据访问层框架,它将SQL与Java代码分离,提高了数据库操作的灵活性和可维护性。接下来,我们将深入探讨这两个框架的...
总的来说,ibatis框架源码的学习不仅可以帮助我们理解其工作原理,提升开发效率,还能为我们提供一种思考问题的角度,理解数据访问层的设计模式。通过对源码的深入剖析,我们可以更好地解决实际项目中的问题,进行...
Ibatis框架是一个轻量级的Java持久层框架,它提供了SQL映射功能,将复杂的SQL语句与Java代码分离,使开发更为灵活高效。在这个"Ibatis框架三层架构项目"中,我们可以看到它按照标准的软件工程设计模式进行了分层,...
【Ibatis框架三层架构项目源码】是一个基于Asp.Net技术的项目,它利用了流行的持久层框架Ibatis来实现数据库交互。Ibatis是Java语言中的一个SQL映射框架,但在.NET环境中,MyBatis-.NET是其对应版本,虽然这里标签...
Spring MVC 是 Spring 框架的一部分,主要用于构建 MVC(Model-View-Controller)架构的 Web 应用程序,而 iBatis 是一个轻量级的持久层框架,它提供了一种将 SQL 查询与 Java 代码解耦合的方式。 **Spring MVC ...
- **SQL映射**:iBatis 提供了一个SQL映射框架,将SQL语句与Java代码分离,通过XML或注解方式定义SQL语句,降低了DAO层的复杂性。 - **动态SQL**:iBatis 支持动态SQL,可以在XML映射文件中编写条件语句,根据传入...
iBatis框架则提供了一种将SQL语句与Java代码分离的方式,通过XML配置文件或注解来定义SQL语句,使得数据库操作更易于维护和扩展。它的核心概念有SqlSessionFactory、SqlSession和Mapper。SqlSessionFactory创建...
标题 "ibatis 的关系映射" 指的是在使用 iBATIS(一款优秀的Java持久层框架)时,如何处理数据库中的对象关系映射(ORM)问题。在Java应用程序中,iBATIS 提供了一种方便的方式来将数据库操作与业务逻辑解耦,使得...
《Java Web核心框架之iBATIS详解》 在Java Web开发中,ORM(Object-Relational Mapping,对象关系映射)框架扮演着至关重要的角色,它们简化了数据库操作,使得开发者可以专注于业务逻辑而不是底层的SQL。iBATIS,...
1. Struts1的MVC架构和ActionServlet的工作原理。 2. iBatis的SQL映射机制和动态SQL功能。 3. 如何在Struts1的Action中调用iBatis执行数据库操作。 4. ActionForm在请求数据传递中的作用。 5. 整合后的项目结构,...
本书籍“iBATIS 框架源码剖析”提供了对iBATIS框架深入理解的机会,通过源代码分析,帮助读者掌握其内部工作原理。源代码带有详尽的注释,使得学习过程更为直观和高效。 iBATIS的核心概念主要有以下几个方面: 1. ...
【Ibatis框架三层架构项目源码 v1.0.rar】是一个基于Ibatis的.NET项目,展示了如何使用Ibatis实现一个标准的三层架构。这个项目包含了数据库设计和完整的源代码,可以直接运行,便于学习和理解Ibatis在实际项目中的...
Mvc Ibatis框架的结合,使得开发者能够在享受MVC模式带来的清晰架构的同时,利用Ibatis的强大SQL处理能力,提高开发效率和代码质量。通过深入理解和实践这两种框架,可以更好地构建健壮、高效的Java Web应用程序。在...