iBATIS - 快速指南
iBATIS - Overview
iBATIS是一个持久性框架,可以自动化SQL数据库与Java,.NET和Ruby on Rails中的对象之间的映射。 通过将SQL语句打包在XML配置文件中,映射与应用程序逻辑分离。
iBATIS是一个轻量级框架和持久性API,适用于持久化POJO(Plain Old Java Objects)。
iBATIS是所谓的数据映射器,负责在类属性和数据库表的列之间映射参数和结果。
iBATIS与其他持久性框架(如Hibernate)之间的显着差异在于iBATIS强调SQL的使用,而其他框架通常使用自定义查询语言,例如Hibernate查询语言(HQL)或Enterprise JavaBeans查询语言(EJB QL)。
iBATIS设计理念
iBATIS带有以下设计理念 -
Simplicity − iBATIS被广泛认为是当今最简单的持久性框架之一。
Fast Development − iBATIS尽其所能促进超快速开发。
Portability − iBATIS几乎可以用于任何语言或平台,例如Java,Ruby和C#for Microsoft .NET。
Independent Interfaces − iBATIS提供独立于数据库的接口和API,可帮助应用程序的其余部分独立于任何与持久性相关的资源。
Open source − iBATIS是免费的,是一个开源软件。
iBATIS的优点
iBATIS具有以下优势 -
Supports stored procedures − --iBATIS以存储过程的形式封装SQL,以便将业务逻辑保留在数据库之外,并且应用程序更易于部署和测试,并且更易于移植。
Supports inline SQL −不需要预编译器,您可以完全访问SQL的所有功能。
Supports dynamic SQL − iBATIS提供了基于参数动态构建SQL查询的功能。
Supports O/RM − iBATIS支持许多与O/RM工具相同的功能,例如延迟加载,连接提取,缓存,运行时代码生成和继承
iBATIS在开发面向数据库的应用程序时使用JAVA编程语言。 在继续之前,请确保您了解过程和面向对象编程的基础知识 - 控制结构,数据结构和变量,类,对象等。
要详细了解JAVA,您可以浏览我们的JAVA教程 。
iBATIS - Environment
在开始实际开发工作之前,您必须为iBATIS设置适当的环境。 本章介绍如何为iBATIS设置工作环境。
iBATIS安装
执行以下简单步骤在Linux机器上安装iBATIS -
$ unzip ibatis-2.3.4.726.zip
inflating: META-INF/MANIFEST.MF
creating: doc/
creating: lib/
creating: simple_example/
creating: simple_example/com/
creating: simple_example/com/mydomain/
creating: simple_example/com/mydomain/data/
creating: simple_example/com/mydomain/domain/
creating: src/
inflating: doc/dev-javadoc.zip
inflating: doc/user-javadoc.zip
inflating: jar-dependencies.txt
inflating: lib/ibatis-2.3.4.726.jar
inflating: license.txt
inflating: notice.txt
inflating: release.txt
$pwd
/var/home/ibatis
$set PATH=$PATH:/var/home/ibatis/
$set CLASSPATH=$CLASSPATH:/var/home/ibatis\
/lib/ibatis-2.3.4.726.jar
数据库设置
使用以下语法在任何MySQL数据库中创建EMPLOYEE表 -
mysql> CREATE TABLE EMPLOYEE (
id INT NOT NULL auto_increment,
first_name VARCHAR(20) default NULL,
last_name VARCHAR(20) default NULL,
salary INT default NULL,
PRIMARY KEY (id)
);
Create SqlMapConfig.xml
考虑以下 -
我们将使用JDBC访问数据库testdb 。
MySQL的JDBC驱动程序是“com.mysql.jdbc.Driver”。
连接URL是“jdbc:mysql:// localhost:3306/testdb”。
我们将分别使用用户名和密码作为“root”和“root”。
我们在所有操作中的sql语句映射将在“Employee.xml”中描述。
基于上述假设,我们必须创建一个名为SqlMapConfig.xml的XML配置文件, SqlMapConfig.xml包含以下内容。 这是您需要提供iBatis所需的所有配置的地方 -
重要的是,文件SqlMapConfig.xml和Employee.xml都应该存在于类路径中。 现在,我们将Employee.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>
<settings useStatementNamespaces="true"/>
<transactionManager type="JDBC">
<dataSource type="SIMPLE">
<property name="JDBC.Driver" value="com.mysql.jdbc.Driver"/>
<property name="JDBC.ConnectionURL" value="jdbc:mysql://localhost:3306/testdb"/>
<property name="JDBC.Username" value="root"/>
<property name="JDBC.Password" value="root"/>
</dataSource>
</transactionManager>
<sqlMap resource="Employee.xml"/>
</sqlMapConfig>
您也可以使用SqlMapConfig.xml文件设置以下可选属性 -
<property name="JDBC.AutoCommit" value="true"/>
<property name="Pool.MaximumActiveConnections" value="10"/>
<property name="Pool.MaximumIdleConnections" value="5"/>
<property name="Pool.MaximumCheckoutTime" value="150000"/>
<property name="Pool.MaximumTimeToWait" value="500"/>
<property name="Pool.PingQuery" value="select 1 from Employee"/>
<property name="Pool.PingEnabled" value="false"/>
iBATIS - Create Operation
要使用iBATIS执行任何创建,读取,更新和删除(CRUD)操作,您需要创建与该表对应的普通旧Java对象(POJO)类。 此类描述将“建模”数据库表行的对象。
POJO类将具有执行所需操作所需的所有方法的实现。
我们假设我们在MySQL中有以下EMPLOYEE表 -
CREATE TABLE EMPLOYEE (
id INT NOT NULL auto_increment,
first_name VARCHAR(20) default NULL,
last_name VARCHAR(20) default NULL,
salary INT default NULL,
PRIMARY KEY (id)
);
Employee POJO Class
我们将在Employee.java文件中创建一个Employee类,如下所示 -
public class Employee {
private int id;
private String first_name;
private String last_name;
private int salary;
/* Define constructors for the Employee class. */
public Employee() {}
public Employee(String fname, String lname, int salary) {
this.first_name = fname;
this.last_name = lname;
this.salary = salary;
}
} /* End of Employee */
您可以定义在表中设置单个字段的方法。 下一章将介绍如何获取各个字段的值。
Employee.xml File
要使用iBATIS定义SQL映射语句,我们将使用
<?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="Employee">
<insert id="insert" parameterClass="Employee">
insert into EMPLOYEE(first_name, last_name, salary)
values (#first_name#, #last_name#, #salary#)
<selectKey resultClass="int" keyProperty="id">
select last_insert_id() as id
</selectKey>
</insert>
</sqlMap>
这里的parameterClass −可以根据需要将值作为string, int, float, double或任何类object 。 在这个例子中,我们将调用Employee对象作为参数,同时调用SqlMap类的insert方法。
如果数据库表使用IDENTITY,AUTO_INCREMENT或SERIAL列,或者已定义SEQUENCE/GENERATOR,则可以使用
IbatisInsert.java File
此文件将具有应用程序级逻辑以在Employee表中插入记录 -
import com.ibatis.common.resources.Resources;
import com.ibatis.sqlmap.client.SqlMapClient;
import com.ibatis.sqlmap.client.SqlMapClientBuilder;
import java.io.*;
import java.sql.SQLException;
import java.util.*;
public class IbatisInsert{
public static void main(String[] args)throws IOException,SQLException{
Reader rd = Resources.getResourceAsReader("SqlMapConfig.xml");
SqlMapClient smc = SqlMapClientBuilder.buildSqlMapClient(rd);
/* This would insert one record in Employee table. */
System.out.println("Going to insert record.....");
Employee em = new Employee("Zara", "Ali", 5000);
smc.insert("Employee.insert", em);
System.out.println("Record Inserted Successfully ");
}
}
编译和运行 (Compilation and Run)
以下是编译和运行上述软件的步骤。 在继续编译和执行之前,请确保已正确设置PATH和CLASSPATH。
- 创建Employee.xml,如上所示。
- 如上所示创建Employee.java并编译它。
- 如上所示创建IbatisInsert.java并编译它。
- 执行IbatisInsert二进制文件以运行程序。
您将获得以下结果,并将在EMPLOYEE表中创建记录。
$java IbatisInsert
Going to insert record.....
Record Inserted Successfully
如果您检查EMPLOYEE表,它应显示以下结果 -
mysql> select * from EMPLOYEE;
+----+------------+-----------+--------+
| id | first_name | last_name | salary |
+----+------------+-----------+--------+
| 1 | Zara | Ali | 5000 |
+----+------------+-----------+--------+
1 row in set (0.00 sec)
iBATIS - Read Operation
在上一章中,我们讨论了如何使用iBATIS对表执行CREATE操作。 本章介绍如何使用iBATIS读取表。
我们在MySQL中有以下EMPLOYEE表 -
CREATE TABLE EMPLOYEE (
id INT NOT NULL auto_increment,
first_name VARCHAR(20) default NULL,
last_name VARCHAR(20) default NULL,
salary INT default NULL,
PRIMARY KEY (id)
);
该表只有一条记录如下 -
mysql> select * from EMPLOYEE;
+----+------------+-----------+--------+
| id | first_name | last_name | salary |
+----+------------+-----------+--------+
| 1 | Zara | Ali | 5000 |
+----+------------+-----------+--------+
1 row in set (0.00 sec)
Employee POJO Class
要执行读取操作,我们将修改Employee.java中的Employee类,如下所示 -
public class Employee {
private int id;
private String first_name;
private String last_name;
private int salary;
/* Define constructors for the Employee class. */
public Employee() {}
public Employee(String fname, String lname, int salary) {
this.first_name = fname;
this.last_name = lname;
this.salary = salary;
}
/* Here are the method definitions */
public int getId() {
return id;
}
public String getFirstName() {
return first_name;
}
public String getLastName() {
return last_name;
}
public int getSalary() {
return salary;
}
} /* End of Employee */
Employee.xml File
要使用iBATIS定义SQL映射语句,我们将在Employee.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="Employee">
<insert id="insert" parameterClass="Employee">
INSERT INTO EMPLOYEE(first_name, last_name, salary)
values (#first_name#, #last_name#, #salary#)
<selectKey resultClass="int" keyProperty="id">
select last_insert_id() as id
</selectKey>
</insert>
<select id="getAll" resultClass="Employee">
SELECT * FROM EMPLOYEE
</select>
</sqlMap>
这里我们没有将WHERE子句与SQL SELECT语句一起使用。 我们将在下一章中演示如何在SELECT语句中使用WHERE子句以及如何将值传递给该WHERE子句。
IbatisRead.java File
此文件具有应用程序级逻辑,用于从Employee表中读取记录 -
import com.ibatis.common.resources.Resources;
import com.ibatis.sqlmap.client.SqlMapClient;
import com.ibatis.sqlmap.client.SqlMapClientBuilder;
import java.io.*;
import java.sql.SQLException;
import java.util.*;
public class IbatisRead{
public static void main(String[] args)throws IOException,SQLException{
Reader rd = Resources.getResourceAsReader("SqlMapConfig.xml");
SqlMapClient smc = SqlMapClientBuilder.buildSqlMapClient(rd);
/* This would read all records from the Employee table. */
System.out.println("Going to read records.....");
List <Employee> ems = (List<Employee>)
smc.queryForList("Employee.getAll", null);
Employee em = null;
for (Employee e : ems) {
System.out.print(" " + e.getId());
System.out.print(" " + e.getFirstName());
System.out.print(" " + e.getLastName());
System.out.print(" " + e.getSalary());
em = e;
System.out.println("");
}
System.out.println("Records Read Successfully ");
}
}
编译和运行 (Compilation and Run)
以下是编译和运行上述软件的步骤。 在继续编译和执行之前,请确保已正确设置PATH和CLASSPATH。
- 创建Employee.xml,如上所示。
- 如上所示创建Employee.java并编译它。
- 如上所示创建IbatisRead.java并编译它。
- 执行IbatisRead二进制文件来运行程序。
您将获得以下结果,并且将从EMPLOYEE表中读取记录,如下所示 -
Going to read records.....
1 Zara Ali 5000
Record Reads Successfully
iBATIS - Update Operation
在上一章中,我们讨论了如何使用iBATIS对表执行READ操作。 本章介绍如何使用iBATIS更新表中的记录。
我们在MySQL中有以下EMPLOYEE表 -
CREATE TABLE EMPLOYEE (
id INT NOT NULL auto_increment,
first_name VARCHAR(20) default NULL,
last_name VARCHAR(20) default NULL,
salary INT default NULL,
PRIMARY KEY (id)
);
该表只有一条记录如下 -
mysql> select * from EMPLOYEE;
+----+------------+-----------+--------+
| id | first_name | last_name | salary |
+----+------------+-----------+--------+
| 1 | Zara | Ali | 5000 |
+----+------------+-----------+--------+
1 row in set (0.00 sec)
Employee POJO Class
要执行udpate操作,您需要修改Employee.java文件,如下所示 -
public class Employee {
private int id;
private String first_name;
private String last_name;
private int salary;
/* Define constructors for the Employee class. */
public Employee() {}
public Employee(String fname, String lname, int salary) {
this.first_name = fname;
this.last_name = lname;
this.salary = salary;
}
/* Here are the required method definitions */
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getFirstName() {
return first_name;
}
public void setFirstName(String fname) {
this.first_name = fname;
}
public String getLastName() {
return last_name;
}
public void setlastName(String lname) {
this.last_name = lname;
}
public int getSalary() {
return salary;
}
public void setSalary(int salary) {
this.salary = salary;
}
} /* End of Employee */
Employee.xml File
要使用iBATIS定义SQL映射语句,我们将在Employee.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="Employee">
<insert id="insert" parameterClass="Employee">
INSERT INTO EMPLOYEE(first_name, last_name, salary)
values (#first_name#, #last_name#, #salary#)
<selectKey resultClass="int" keyProperty="id">
select last_insert_id() as id
</selectKey>
</insert>
<select id="getAll" resultClass="Employee">
SELECT * FROM EMPLOYEE
</select>
<update id="update" parameterClass="Employee">
UPDATE EMPLOYEE
SET first_name = #first_name#
WHERE id = #id#
</update>
</sqlMap>
IbatisUpdate.java File
此文件具有应用程序级逻辑,用于将记录更新到Employee表中 -
import com.ibatis.common.resources.Resources;
import com.ibatis.sqlmap.client.SqlMapClient;
import com.ibatis.sqlmap.client.SqlMapClientBuilder;
import java.io.*;
import java.sql.SQLException;
import java.util.*;
public class IbatisUpdate{
public static void main(String[] args)
throws IOException,SQLException{
Reader rd = Resources.getResourceAsReader("SqlMapConfig.xml");
SqlMapClient smc = SqlMapClientBuilder.buildSqlMapClient(rd);
/* This would update one record in Employee table. */
System.out.println("Going to update record.....");
Employee rec = new Employee();
rec.setId(1);
rec.setFirstName( "Roma");
smc.update("Employee.update", rec );
System.out.println("Record updated Successfully ");
System.out.println("Going to read records.....");
List <Employee> ems = (List<Employee>)
smc.queryForList("Employee.getAll", null);
Employee em = null;
for (Employee e : ems) {
System.out.print(" " + e.getId());
System.out.print(" " + e.getFirstName());
System.out.print(" " + e.getLastName());
System.out.print(" " + e.getSalary());
em = e;
System.out.println("");
}
System.out.println("Records Read Successfully ");
}
}
编译和运行 (Compilation and Run)
以下是编译和运行上述软件的步骤。 在继续编译和执行之前,请确保已正确设置PATH和CLASSPATH。
- 创建Employee.xml,如上所示。
- 如上所示创建Employee.java并编译它。
- 如上所示创建IbatisUpdate.java并进行编译。
- 执行IbatisUpdate二进制文件来运行程序。
您将获得以下结果,并且将在EMPLOYEE表中更新记录,稍后,将从EMPLOYEE表中读取相同的记录。
Going to update record.....
Record updated Successfully
Going to read records.....
1 Roma Ali 5000
Records Read Successfully
iBATIS - Delete Operation
本章介绍如何使用iBATIS从表中删除记录。
我们在MySQL中有以下EMPLOYEE表 -
CREATE TABLE EMPLOYEE (
id INT NOT NULL auto_increment,
first_name VARCHAR(20) default NULL,
last_name VARCHAR(20) default NULL,
salary INT default NULL,
PRIMARY KEY (id)
);
假设此表有两条记录如下 -
mysql> select * from EMPLOYEE;
+----+------------+-----------+--------+
| id | first_name | last_name | salary |
+----+------------+-----------+--------+
| 1 | Zara | Ali | 5000 |
| 2 | Roma | Ali | 3000 |
+----+------------+-----------+--------+
2 row in set (0.00 sec)
Employee POJO Class
要执行删除操作,您无需修改Employee.java文件。 让我们保持原样在最后一章。
public class Employee {
private int id;
private String first_name;
private String last_name;
private int salary;
/* Define constructors for the Employee class. */
public Employee() {}
public Employee(String fname, String lname, int salary) {
this.first_name = fname;
this.last_name = lname;
this.salary = salary;
}
/* Here are the required method definitions */
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getFirstName() {
return first_name;
}
public void setFirstName(String fname) {
this.first_name = fname;
}
public String getLastName() {
return last_name;
}
public void setlastName(String lname) {
this.last_name = lname;
}
public int getSalary() {
return salary;
}
public void setSalary(int salary) {
this.salary = salary;
}
} /* End of Employee */
Employee.xml File
要使用iBATIS定义SQL映射语句,我们将在Employee.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="Employee">
<insert id="insert" parameterClass="Employee">
INSERT INTO EMPLOYEE(first_name, last_name, salary)
values (#first_name#, #last_name#, #salary#)
<selectKey resultClass="int" keyProperty="id">
select last_insert_id() as id
</selectKey>
</insert>
<select id="getAll" resultClass="Employee">
SELECT * FROM EMPLOYEE
</select>
<update id="update" parameterClass="Employee">
UPDATE EMPLOYEE
SET first_name = #first_name#
WHERE id = #id#
</update>
<delete id="delete" parameterClass="int">
DELETE FROM EMPLOYEE
WHERE id = #id#
</delete>
</sqlMap>
IbatisDelete.java File
此文件具有应用程序级逻辑,用于从Employee表中删除记录 -
import com.ibatis.common.resources.Resources;
import com.ibatis.sqlmap.client.SqlMapClient;
import com.ibatis.sqlmap.client.SqlMapClientBuilder;
import java.io.*;
import java.sql.SQLException;
import java.util.*;
public class IbatisDelete{
public static void main(String[] args)
throws IOException,SQLException{
Reader rd = Resources.getResourceAsReader("SqlMapConfig.xml");
SqlMapClient smc = SqlMapClientBuilder.buildSqlMapClient(rd);
/* This would delete one record in Employee table. */
System.out.println("Going to delete record.....");
int id = 1;
smc.delete("Employee.delete", id );
System.out.println("Record deleted Successfully ");
System.out.println("Going to read records.....");
List <Employee> ems = (List<Employee>)
smc.queryForList("Employee.getAll", null);
Employee em = null;
for (Employee e : ems) {
System.out.print(" " + e.getId());
System.out.print(" " + e.getFirstName());
System.out.print(" " + e.getLastName());
System.out.print(" " + e.getSalary());
em = e;
System.out.println("");
}
System.out.println("Records Read Successfully ");
}
}
编译和运行 (Compilation and Run)
以下是编译和运行上述软件的步骤。 在继续编译和执行之前,请确保已正确设置PATH和CLASSPATH。
- 创建Employee.xml,如上所示。
- 如上所示创建Employee.java并编译它。
- 如上所示创建IbatisDelete.java并编译它。
- 执行IbatisDelete二进制文件来运行程序。
您将获得以下结果,ID = 1的记录将从EMPLOYEE表中删除,其余记录将被读取。
Going to delete record.....
Record deleted Successfully
Going to read records.....
2 Roma Ali 3000
Records Read Successfully
iBATIS - Result Maps
resultMap元素是iBATIS中最重要和最强大的元素。 您可以使用iBATIS ResultMap减少高达90%的JDBC编码,在某些情况下,它允许您执行JDBC甚至不支持的操作。
ResultMaps的设计使得简单语句根本不需要显式结果映射,而更复杂的语句只需要描述关系的绝对必要。
本章仅提供iBATIS ResultMaps的简单介绍。
我们在MySQL中有以下EMPLOYEE表 -
CREATE TABLE EMPLOYEE (
id INT NOT NULL auto_increment,
first_name VARCHAR(20) default NULL,
last_name VARCHAR(20) default NULL,
salary INT default NULL,
PRIMARY KEY (id)
);
该表有两条记录如下 -
mysql> select * from EMPLOYEE;
+----+------------+-----------+--------+
| id | first_name | last_name | salary |
+----+------------+-----------+--------+
| 1 | Zara | Ali | 5000 |
| 2 | Roma | Ali | 3000 |
+----+------------+-----------+--------+
2 row in set (0.00 sec)
Employee POJO Class
要使用iBATIS ResultMap,您无需修改Employee.java文件。 让我们保持原样在最后一章。
public class Employee {
private int id;
private String first_name;
private String last_name;
private int salary;
/* Define constructors for the Employee class. */
public Employee() {}
public Employee(String fname, String lname, int salary) {
this.first_name = fname;
this.last_name = lname;
this.salary = salary;
}
/* Here are the required method definitions */
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getFirstName() {
return first_name;
}
public void setFirstName(String fname) {
this.first_name = fname;
}
public String getLastName() {
return last_name;
}
public void setlastName(String lname) {
this.last_name = lname;
}
public int getSalary() {
return salary;
}
public void setSalary(int salary) {
this.salary = salary;
}
} /* End of Employee */
Employee.xml File
在这里,我们将修改Employee.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="Employee">
<!-- Perform Insert Operation -->
<insert id="insert" parameterClass="Employee">
INSERT INTO EMPLOYEE(first_name, last_name, salary)
values (#first_name#, #last_name#, #salary#)
<selectKey resultClass="int" keyProperty="id">
select last_insert_id() as id
</selectKey>
</insert>
<!-- Perform Read Operation -->
<select id="getAll" resultClass="Employee">
SELECT * FROM EMPLOYEE
</select>
<!-- Perform Update Operation -->
<update id="update" parameterClass="Employee">
UPDATE EMPLOYEE
SET first_name = #first_name#
WHERE id = #id#
</update>
<!-- Perform Delete Operation -->
<delete id="delete" parameterClass="int">
DELETE FROM EMPLOYEE
WHERE id = #id#
</delete>
<!-- Using ResultMap -->
<resultMap id="result" class="Employee">
<result property="id" column="id"/>
<result property="first_name" column="first_name"/>
<result property="last_name" column="last_name"/>
<result property="salary" column="salary"/>
</resultMap>
<select id="useResultMap" resultMap="result">
SELECT * FROM EMPLOYEE
WHERE id=#id#
</select>
</sqlMap>
IbatisResultMap.java File
此文件具有应用程序级逻辑,可使用ResultMap从Employee表中读取记录 -
import com.ibatis.common.resources.Resources;
import com.ibatis.sqlmap.client.SqlMapClient;
import com.ibatis.sqlmap.client.SqlMapClientBuilder;
import java.io.*;
import java.sql.SQLException;
import java.util.*;
public class IbatisResultMap{
public static void main(String[] args)
throws IOException,SQLException{
Reader rd = Resources.getResourceAsReader("SqlMapConfig.xml");
SqlMapClient smc = SqlMapClientBuilder.buildSqlMapClient(rd);
int id = 1;
System.out.println("Going to read record.....");
Employee e = (Employee)smc.queryForObject ("Employee.useResultMap", id);
System.out.println("ID: " + e.getId());
System.out.println("First Name: " + e.getFirstName());
System.out.println("Last Name: " + e.getLastName());
System.out.println("Salary: " + e.getSalary());
System.out.println("Record read Successfully ");
}
}
编译和运行 (Compilation and Run)
以下是编译和运行上述软件的步骤。 在继续编译和执行之前,请确保已正确设置PATH和CLASSPATH。
- 创建Employee.xml,如上所示。
- 如上所示创建Employee.java并编译它。
- 如上所示创建IbatisResultMap.java并进行编译。
- 执行IbatisResultMap二进制文件来运行程序。
您将获得以下结果,这是EMPLOYEE表上的读取操作。
Going to read record.....
ID: 1
First Name: Zara
Last Name: Ali
Salary: 5000
Record read Successfully
iBATIS - Stored Procedures
您可以使用iBATIS配置调用存储过程。 首先,让我们了解如何在MySQL中创建存储过程。
我们在MySQL中有以下EMPLOYEE表 -
CREATE TABLE EMPLOYEE (
id INT NOT NULL auto_increment,
first_name VARCHAR(20) default NULL,
last_name VARCHAR(20) default NULL,
salary INT default NULL,
PRIMARY KEY (id)
);
让我们在MySQL数据库中创建以下存储过程 -
DELIMITER $$
DROP PROCEDURE IF EXISTS `testdb`.`getEmp` $$
CREATE PROCEDURE `testdb`.`getEmp`
(IN empid INT)
BEGIN
SELECT * FROM EMPLOYEE
WHERE ID = empid;
END $$
DELIMITER;
让我们考虑EMPLOYEE表有两条记录如下 -
mysql> select * from EMPLOYEE;
+----+------------+-----------+--------+
| id | first_name | last_name | salary |
+----+------------+-----------+--------+
| 1 | Zara | Ali | 5000 |
| 2 | Roma | Ali | 3000 |
+----+------------+-----------+--------+
2 row in set (0.00 sec)
Employee POJO Class
要使用存储过程,您不需要修改Employee.java文件。 让我们保持原样在最后一章。
public class Employee {
private int id;
private String first_name;
private String last_name;
private int salary;
/* Define constructors for the Employee class. */
public Employee() {}
public Employee(String fname, String lname, int salary) {
this.first_name = fname;
this.last_name = lname;
this.salary = salary;
}
/* Here are the required method definitions */
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getFirstName() {
return first_name;
}
public void setFirstName(String fname) {
this.first_name = fname;
}
public String getLastName() {
return last_name;
}
public void setlastName(String lname) {
this.last_name = lname;
}
public int getSalary() {
return salary;
}
public void setSalary(int salary) {
this.salary = salary;
}
} /* End of Employee */
Employee.xml File
在这里,我们将修改Employee.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="Employee">
<!-- Perform Insert Operation -->
<insert id="insert" parameterClass="Employee">
INSERT INTO EMPLOYEE(first_name, last_name, salary)
values (#first_name#, #last_name#, #salary#)
<selectKey resultClass="int" keyProperty="id">
select last_insert_id() as id
</selectKey>
</insert>
<!-- Perform Read Operation -->
<select id="getAll" resultClass="Employee">
SELECT * FROM EMPLOYEE
</select>
<!-- Perform Update Operation -->
<update id="update" parameterClass="Employee">
UPDATE EMPLOYEE
SET first_name = #first_name#
WHERE id = #id#
</update>
<!-- Perform Delete Operation -->
<delete id="delete" parameterClass="int">
DELETE FROM EMPLOYEE
WHERE id = #id#
</delete>
<!-- To call stored procedure. -->
<procedure id="getEmpInfo" resultClass="Employee" parameterMap="getEmpInfoCall">
{ call getEmp( #acctID# ) }
</procedure>
<parameterMap id="getEmpInfoCall" class="map">
<parameter property="acctID" jdbcType="INT" javaType="java.lang.Integer" mode="IN"/>
</parameterMap>
</sqlMap>
IbatisSP.java File
此文件具有应用程序级逻辑,可使用ResultMap从Employee表中读取员工的姓名 -
import com.ibatis.common.resources.Resources;
import com.ibatis.sqlmap.client.SqlMapClient;
import com.ibatis.sqlmap.client.SqlMapClientBuilder;
import java.io.*;
import java.sql.SQLException;
import java.util.*;
public class IbatisSP{
public static void main(String[] args)
throws IOException,SQLException{
Reader rd = Resources.getResourceAsReader("SqlMapConfig.xml");
SqlMapClient smc = SqlMapClientBuilder.buildSqlMapClient(rd);
int id = 1;
System.out.println("Going to read employee name.....");
Employee e = (Employee) smc.queryForObject ("Employee.getEmpInfo", id);
System.out.println("First Name: " + e.getFirstName());
System.out.println("Record name Successfully ");
}
}
编译和运行 (Compilation and Run)
以下是编译和运行上述软件的步骤。 在继续编译和执行之前,请确保已正确设置PATH和CLASSPATH。
- 创建Employee.xml,如上所示。
- 如上所示创建Employee.java并编译它。
- 如上所示创建IbatisSP.java并编译它。
- 执行IbatisSP二进制文件来运行程序。
您将得到以下结果:
Going to read record.....
ID: 1
First Name: Zara
Last Name: Ali
Salary: 5000
Record read Successfully
iBATIS - Dynamic SQL
动态SQL是iBATIS的一个非常强大的功能。 有时您必须根据参数对象的状态更改WHERE子句标准。 在这种情况下,iBATIS提供了一组动态SQL标记,可以在映射语句中使用,以增强SQL的可重用性和灵活性。
使用一些额外的标签将所有逻辑放入.XML文件中。 以下是SELECT语句以两种方式工作的示例 -
如果您传递了ID,那么它将返回与该ID相对应的所有记录。
否则,它将返回员工ID设置为NULL的所有记录。
<?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="Employee">
<select id="findByID" resultClass="Employee">
SELECT * FROM EMPLOYEE
<dynamic prepend="WHERE ">
<isNull property="id">
id IS NULL
</isNull>
<isNotNull property="id">
id = #id#
</isNotNull>
</dynamic>
</select>
</sqlMap>
您可以使用
..................
<select id="findByID" resultClass="Employee">
SELECT * FROM EMPLOYEE
<dynamic prepend="WHERE ">
<isNotEmpty property="id">
id = #id#
</isNotEmpty>
</dynamic>
</select>
..................
如果您想要一个查询,我们可以在其中选择一个ID和/或一个Employee的名字,您的SELECT语句将如下所示 -
..................
<select id="findByID" resultClass="Employee">
SELECT * FROM EMPLOYEE
<dynamic prepend="WHERE ">
<isNotEmpty prepend="AND" property="id">
id = #id#
</isNotEmpty>
<isNotEmpty prepend="OR" property="first_name">
first_name = #first_name#
</isNotEmpty>
</dynamic>
</select>
..................
动态SQL示例
以下示例说明如何使用动态SQL编写SELECT语句。 考虑一下,我们在MySQL中有以下EMPLOYEE表 -
CREATE TABLE EMPLOYEE (
id INT NOT NULL auto_increment,
first_name VARCHAR(20) default NULL,
last_name VARCHAR(20) default NULL,
salary INT default NULL,
PRIMARY KEY (id)
);
我们假设这个表只有一条记录如下 -
mysql> select * from EMPLOYEE;
+----+------------+-----------+--------+
| id | first_name | last_name | salary |
+----+------------+-----------+--------+
| 1 | Zara | Ali | 5000 |
+----+------------+-----------+--------+
1 row in set (0.00 sec)
Employee POJO Class
要执行读操作,让我们在Employee.java中有一个Employee类,如下所示 -
public class Employee {
private int id;
private String first_name;
private String last_name;
private int salary;
/* Define constructors for the Employee class. */
public Employee() {}
public Employee(String fname, String lname, int salary) {
this.first_name = fname;
this.last_name = lname;
this.salary = salary;
}
/* Here are the method definitions */
public int getId() {
return id;
}
public String getFirstName() {
return first_name;
}
public String getLastName() {
return last_name;
}
public int getSalary() {
return salary;
}
} /* End of Employee */
Employee.xml File
要使用iBATIS定义SQL映射语句,我们将在Employee.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="Employee">
<select id="findByID" resultClass="Employee">
SELECT * FROM EMPLOYEE
<dynamic prepend="WHERE ">
<isNotNull property="id">
id = #id#
</isNotNull>
</dynamic>
</select>
</sqlMap>
上面的SELECT语句有两种工作方式 -
如果传递ID,则返回与该ID对应的记录,否则返回所有记录。
IbatisReadDy.java File
此文件具有应用程序级逻辑,用于从Employee表中读取条件记录 -
import com.ibatis.common.resources.Resources;
import com.ibatis.sqlmap.client.SqlMapClient;
import com.ibatis.sqlmap.client.SqlMapClientBuilder;
import java.io.*;
import java.sql.SQLException;
import java.util.*;
public class IbatisReadDy{
public static void main(String[] args)
throws IOException,SQLException{
Reader rd=Resources.getResourceAsReader("SqlMapConfig.xml");
SqlMapClient smc=SqlMapClientBuilder.buildSqlMapClient(rd);
/* This would read all records from the Employee table.*/
System.out.println("Going to read records.....");
Employee rec = new Employee();
rec.setId(1);
List <Employee> ems = (List<Employee>)
smc.queryForList("Employee.findByID", rec);
Employee em = null;
for (Employee e : ems) {
System.out.print(" " + e.getId());
System.out.print(" " + e.getFirstName());
System.out.print(" " + e.getLastName());
System.out.print(" " + e.getSalary());
em = e;
System.out.println("");
}
System.out.println("Records Read Successfully ");
}
}
编译和运行 (Compilation and Run)
以下是编译和运行上述软件的步骤。 在继续编译和执行之前,请确保已正确设置PATH和CLASSPATH。
- 创建Employee.xml,如上所示。
- 如上所示创建Employee.java并编译它。
- 如上所示创建IbatisReadDy.java并编译它。
- 执行IbatisReadDy二进制文件来运行程序。
您将获得以下结果,并且将从EMPLOYEE表中读取记录。
Going to read records.....
1 Zara Ali 5000
Record Reads Successfully
通过将null作为smc.queryForList("Employee.findByID", null)传递来尝试上面的示例。
iBATIS OGNL表达式
iBATIS提供了强大的基于OGNL的表达式来消除大多数其他元素。
- if Statement
- choose, when, otherwise Statement
- where Statement
- foreach Statement
if 语句
动态SQL中最常见的事情是有条件地包含where子句的一部分。 例如 -
<select id="findActiveBlogWithTitleLike" parameterType="Blog" resultType="Blog">
SELECT * FROM BLOG
WHERE state = 'ACTIVE.
<if test="title != null">
AND title like #{title}
</if>
</select>
此语句提供可选的文本搜索类型的功能。 如果您没有传入标题,则返回所有活动的博客。 但是如果你确实传入一个标题,那么它将寻找具有给定条件的标题。
您可以包含多个if条件,如下所示 -
<select id="findActiveBlogWithTitleLike" parameterType="Blog" resultType="Blog">
SELECT * FROM BLOG
WHERE state = 'ACTIVE.
<if test="title != null">
AND title like #{title}
</if>
<if test="author != null">
AND author like #{author}
</if>
</select>
选择,何时以及其他陈述
iBATIS提供了一个类似于Java的switch语句的choose元素。 它有助于在众多选项中仅选择一个案例。
以下示例仅按标题搜索(如果提供了一个),然后仅提供作者(如果提供了一个)。 如果两者都没有提供,它只返回精选博客 -
<select id="findActiveBlogWithTitleLike" parameterType="Blog" resultType="Blog">
SELECT * FROM BLOG
WHERE state = 'ACTIVE.
<choose>
<when test="title != null">
AND title like #{title}
</when>
<when test="author != null and author.name != null">
AND author like #{author}
</when>
<otherwise>
AND featured = 1
</otherwise>
</choose>
</select>
where 语句
看看我们之前的示例,看看如果没有满足任何条件会发生什么。 你最终得到一个看起来像这样的SQL -
SELECT * FROM BLOG
WHERE
这会失败,但iBATIS有一个简单的解决方案,一个简单的改变,一切正常 -
<select id="findActiveBlogLike" parameterType="Blog" resultType="Blog">
SELECT * FROM BLOG
<where>
<if test="state != null">
state = #{state}
</if>
<if test="title != null">
AND title like #{title}
</if>
<if test="author != null>
AND author like #{author}
</if>
</where>
</select>
仅当包含的标记返回任何内容时, where元素才会插入WHERE 。 此外,如果该内容以AND或OR,开头OR,则它知道将其剥离。
foreach 语句
foreach元素允许您指定集合并声明可以在元素主体内使用的项和索引变量。
它还允许您指定开始和结束字符串,并添加一个分隔符以放置在迭代之间。 您可以按如下方式构建IN条件 -
<select id="selectPostIn" resultType="domain.blog.Post">
SELECT *
FROM POST P
WHERE ID in
<foreach item="item" index="index" collection="list"
open="(" separator="," close=")">
#{item}
</foreach>
</select>
iBATIS - Debugging
在使用iBATIS时,可以轻松调试程序。 iBATIS具有内置日志记录支持,它可与以下日志记录库一起使用,并按此顺序搜索它们。
- Jakarta Commons Logging(JCL)。
- Log4J
- JDK日志记录
您可以使用上面列出的任何库以及iBATIS。
使用Log4J进行调试
假设您要使用Log4J进行日志记录。 在继续之前,您需要交叉检查以下几点 -
- Log4J JAR文件(log4j- {version} .jar)应该在CLASSPATH中。
- 您在CLASSPATH中有log4j.properties。
以下是log4j.properties文件。 请注意,某些行已注释掉。 如果需要其他调试信息,可以取消注释它们。
# Global logging configuration
log4j.rootLogger = ERROR, stdout
log4j.logger.com.ibatis = DEBUG
# shows SQL of prepared statements
#log4j.logger.java.sql.Connection = DEBUG
# shows parameters inserted into prepared statements
#log4j.logger.java.sql.PreparedStatement = DEBUG
# shows query results
#log4j.logger.java.sql.ResultSet = DEBUG
#log4j.logger.java.sql.Statement = DEBUG
# Console output
log4j.appender.stdout = org.apache.log4j.ConsoleAppender
log4j.appender.stdout.layout = org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern = %5p [%t] − %m%n
您可以从Apaches站点 - Log4J文档中找到Log4J的完整文档。
iBATIS调试示例
以下Java类是一个非常简单的示例,它初始化然后将Log4J日志库用于Java应用程序。 我们将使用CLASSPATH中的上述属性文件。
import org.apache.log4j.Logger;
import com.ibatis.common.resources.Resources;
import com.ibatis.sqlmap.client.SqlMapClient;
import com.ibatis.sqlmap.client.SqlMapClientBuilder;
import java.io.*;
import java.sql.SQLException;
import java.util.*;
public class IbatisUpdate{
static Logger log = Logger.getLogger(IbatisUpdate.class.getName());
public static void main(String[] args)
throws IOException,SQLException{
Reader rd = Resources.getResourceAsReader("SqlMapConfig.xml");
SqlMapClient smc = SqlMapClientBuilder.buildSqlMapClient(rd);
/* This would insert one record in Employee table. */
log.info("Going to update record.....");
Employee rec = new Employee();
rec.setId(1);
rec.setFirstName( "Roma");
smc.update("Employee.update", rec );
log.info("Record updated Successfully ");
log.debug("Going to read records.....");
List <Employee> ems = (List<Employee>)
smc.queryForList("Employee.getAll", null);
Employee em = null;
for (Employee e : ems) {
System.out.print(" " + e.getId());
System.out.print(" " + e.getFirstName());
System.out.print(" " + e.getLastName());
System.out.print(" " + e.getSalary());
em = e;
System.out.println("");
}
log.debug("Records Read Successfully ");
}
}
编译和运行 (Compilation and Run)
首先,确保在继续编译和执行之前适当地设置了PATH和CLASSPATH。
- 创建Employee.xml,如上所示。
- 如上所示创建Employee.java并编译它。
- 如上所示创建IbatisUpdate.java并进行编译。
- 创建log4j.properties,如上所示。
- 执行IbatisUpdate二进制文件来运行程序。
你会得到以下结果。 记录将在EMPLOYEE表中更新,之后,将从EMPLOYEE表中读取相同的记录。
DEBUG [main] - Created connection 28405330.
DEBUG [main] - Returned connection 28405330 to pool.
DEBUG [main] - Checked out connection 28405330 from pool.
DEBUG [main] - Returned connection 28405330 to pool.
1 Roma Ali 5000
2 Zara Ali 5000
3 Zara Ali 5000
调试方法
在上面的示例中,我们仅使用了info()方法,但您可以根据自己的要求使用以下任何方法 -
public void trace(Object message);
public void debug(Object message);
public void info(Object message);
public void warn(Object message);
public void error(Object message);
public void fatal(Object message);
iBATIS - Hibernate
iBATIS和Hibernate之间存在重大差异。 鉴于其特定领域,这两种解决方案都运行良好。 建议使用iBATIS -
- 您想创建自己的SQL,并且愿意维护它们。
- 您的环境由关系数据模型驱动。
- 您必须处理现有的和复杂的模式。
如果环境由对象模型驱动并且需要自动生成SQL,请使用Hibernate。
iBATIS和Hibernate之间的区别
Hibernate和iBATIS都是业界可用的开源对象关系映射(ORM)工具。 使用这些工具取决于您使用它们的上下文。
下表突出显示了iBATIS和Hibernate之间的区别 -
iBATIS的 | 过冬 |
---|---|
iBATIS更简单。 它的封装尺寸要小得多。 | Hibernate为您生成SQL,这意味着您不必花时间生成SQL。 |
iBATIS非常灵活。 它提供更快的开发时间。 | Hibernate具有高度可扩展性。 它提供了更高级的缓存。 |
iBATIS使用可能依赖于数据库的SQL。 | Hibernate使用相对独立于数据库的HQL。 在Hibernate中更改db更容易。 |
iBatis将ResultSet从JDBC API映射到POJO Objets,因此您不必关心表结构。 | Hibernate将Java POJO对象映射到数据库表。 |
在iBATIS中使用存储过程非常容易。 | 在Hibernate中使用存储过程有点困难。 |
Hibernate和iBATIS都得到了SPRING框架的良好支持,因此选择其中一个不应该是一个问题。
iBATOR - Introduction
iBATOR是iBATIS的代码生成器。 iBATOR内省一个或多个数据库表并生成可用于访问表的iBATIS工件。
稍后您可以编写自定义SQL代码或存储过程以满足您的要求。 iBATOR生成以下工件 -
- SqlMap XML文件
- 用于匹配表的主键和字段的Java类
- DAO使用上述对象的类(可选)
iBATOR可以作为独立的JAR文件运行,也可以作为Ant任务运行,也可以作为Eclipse插件运行。 本教程描述了从命令行生成iBATIS配置文件的最简单方法。
下载iBATOR
如果您使用的是Eclipse以外的IDE,请下载独立的JAR。 独立JAR包含运行iBATOR的Ant任务,或者您可以从Java代码的命令行运行iBATOR。
您可以从Download iBATOR下载zip文件。
您可以查看在线文档 - iBATOR文档 。
生成配置文件
要运行iBATOR,请按照以下步骤操作 -
Step 1
适当地创建和填充配置文件ibatorConfig.xml。 至少,您必须指定 -
《jdbcConnection》元素,用于指定如何连接到目标数据库。
《javaModelGenerator》元素,用于为生成的Java模型对象指定目标包和目标项目。
一个《sqlMapGenerator》元素,用于为生成的SQL映射文件指定目标包和目标项目。
《daoGenerator》元素,用于为生成的DAO接口和类指定目标包和目标项目(如果不希望生成DAO,则可以省略“daoGenerator”元素)。
至少有一个数据库《table》元素
NOTE −有关iBATOR配置文件的示例,请参阅XML配置文件参考页面。
Step 2
将文件保存在方便的位置,例如:\temp\ibatorConfig.xml。
Step 3
现在从命令行运行iBATOR,如下所示 -
java -jar abator.jar -configfile \temp\abatorConfig.xml -overwrite
它将告诉iBATOR使用您的配置文件运行。 它还将告诉iBATOR覆盖任何具有相同名称的现有Java文件。 如果要保存任何现有Java文件,请省略−overwrite参数。
如果存在冲突,iBATOR会使用唯一名称保存新生成的文件。
运行iBATOR后,您需要创建或修改标准iBATIS配置文件以使用新生成的代码。 这将在下一节中解释。
运行iBATOR后的任务
运行iBATOR后,您需要创建或修改其他iBATIS配置工件。 主要任务如下 -
- 创建或修改SqlMapConfig.xml文件。
- 创建或修改dao.xml文件(仅当您使用的是iBATIS DAO框架时)。
每项任务详述如下 -
更新SqlMapConfig.xml文件
iBATIS使用XML文件(通常名为SqlMapConfig.xml)来指定iBATIS会话中使用的数据库连接,事务管理方案和SQL映射XML文件的信息。
iBATOR无法为您创建此文件,因为它对您的执行环境一无所知。 但是,此文件中的某些项目直接与iBATOR生成的项目相关。
配置文件中的iBATOR特定需求如下 -
- 必须启用语句名称空间。
- 必须列出iBATOR生成的SQL Map XML文件。
例如,假设iBATOR已生成名为MyTable_SqlMap.xml的SQL Map XML文件,并且该文件已放置在项目的test.xml包中。 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>
<!-- Statement namespaces are required for Abator -->
<settings useStatementNamespaces="true" />
<!-- Setup the transaction manager and data source that are
appropriate for your environment
-->
<transactionManager type="...">
<dataSource type="...">
</dataSource>
</transactionManager>
<!-- SQL Map XML files should be listed here -->
<sqlMap resource="test/xml/MyTable_SqlMap.xml" />
</sqlMapConfig>
如果有多个SQL Map XML文件(非常常见),那么可以在
更新dao.xml文件
iBATIS DAO框架由通常称为dao.xml的xml文件配置。
iBATIS DAO框架使用此文件来控制DAO的数据库连接信息,还列出DAO实现类和DAO接口。
在此文件中,您应指定SqlMapConfig.xml文件的路径,以及所有iBATOR生成的DAO接口和实现类。
例如,假设iBATOR已生成一个名为MyTableDAO的DAO接口和一个名为MyTableDAOImpl的实现类,并且这些文件已放置在项目的test.dao包中。
dao.xml文件应该包含以下条目 -
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE daoConfig PUBLIC "-//ibatis.apache.org//DTD DAO Configuration 2.0//EN" "http://ibatis.apache.org/dtd/dao-2.dtd">
<daoConfig>
<context>
<transactionManager type="SQLMAP">
<property name="SqlMapConfigResource" value="test/SqlMapConfig.xml"/>
</transactionManager>
<!-- DAO interfaces and implementations should be listed here -->
<dao interface="test.dao.MyTableDAO" implementation="test.dao.MyTableDAOImpl" />
</context>
</daoConfig>
NOTE −仅当您为iBATIS DAO框架生成DAO时,才需要执行此步骤。