iBATIS - 快速指南

❮ 上一节

下一节 ❯

iBATIS - 快速指南

iBATIS - 概述

iBATIS 是一个持久性框架，可自动完成 SQL 数据库与 Java、.NET 和 Ruby on Rails 中的对象之间的映射。通过将 SQL 语句打包到 XML 配置文件中，映射与应用程序逻辑分离。

iBATIS 是一个轻量级框架和持久性 API，适用于持久化 POJO(普通旧 Java 对象)。

iBATIS 就是所谓的数据映射器，负责在类属性和数据库表的列之间映射参数和结果。

iBATIS 与其他持久性框架(如 Hibernate)之间的一个显著区别是，iBATIS 强调使用 SQL，而其他框架通常使用自定义查询语言，如 Hibernate 查询语言 (HQL) 或 Enterprise JavaBeans 查询语言 (EJB QL)。

iBATIS 设计理念

iBATIS 具有以下设计理念 −

简单 − iBATIS 被广泛认为是当今最简单的持久性框架之一。

快速开发 − iBATIS 尽其所能促进超快速开发。

可移植性 − iBATIS 几乎可以在任何语言或平台上实现，例如 Java、Ruby 和适用于 Microsoft .NET 的 C#。

独立接口 − iBATIS 提供独立于数据库的接口和 API，可帮助应用程序的其余部分保持独立于任何与持久性相关的资源。

开源 − iBATIS 是免费的开源软件。

iBATIS 的优势

iBATIS 提供以下优势 −

支持存储过程 − iBATIS 以存储过程的形式封装 SQL，这样业务逻辑就被排除在数据库之外，应用程序更易于部署和测试，并且更易于移植。

支持内联 SQL − 无需预编译器，您可以完全访问 SQL 的所有功能。

支持动态 SQL − iBATIS 提供基于参数动态构建 SQL 查询的功能。

支持 O/RM − iBATIS 支持许多与 O/RM 工具相同的功能，例如延迟加载、连接获取、缓存、运行时代码生成和继承

iBATIS 在开发时使用 JAVA 编程语言面向数据库的应用程序。在继续之前，请确保您了解过程和面向对象编程的基础知识＆减去控制结构，数据结构和变量，类，对象等。

要详细了解 JAVA，您可以阅读我们的JAVA 教程。

iBATIS - 环境

在开始实际开发工作之前，您必须为 iBATIS 设置适当的环境。本章介绍如何为 iBATIS 设置工作环境。

iBATIS 安装

执行以下简单步骤在您的 Linux 机器上安装 iBATIS −

从下载 iBATIS下载最新版本的 iBATIS。

解压下载的文件以从包中提取 .jar 文件并将其保存在适当的 lib 目录中。

在提取的 .jar 文件中适当设置 PATH 和 CLASSPATH 变量。

$ 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)

);

创建 SqlMapConfig.xml

考虑以下 −

我们将使用 JDBC 访问数据库 testdb。

MySQL 的 JDBC 驱动程序是"com.mysql.jdbc.Driver"。

连接 URL 是"jdbc:mysql://localhost:3306/testdb"。

我们将分别使用用户名和密码作为"root"和"root"。

所有操作的 sql 语句映射将在"Employee.xml"中描述。

基于上述假设，我们必须创建一个名为 SqlMapConfig.xml 的 XML 配置文件，内容如下。您需要在此处提供 iBatis 所需的所有配置 −

SqlMapConfig.xml 和 Employee.xml 文件必须位于类路径中。目前，我们将保留 Employee.xml 文件为空，并在后续章节中介绍其内容。

您还可以使用 SqlMapConfig.xml 文件设置以下可选属性 −

iBATIS - 创建操作

要使用 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)

);

员工 POJO 类

我们将在 Employee.java 文件中创建一个 Employee 类，如下所示 −

public class Employee {

private int id;

private String first_name;

private String last_name;

private int salary;

/* 为 Employee 类定义构造函数。 */

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 文件

要使用 iBATIS 定义 SQL 映射语句，我们将使用 标记，并且在此标记定义中，我们将定义一个"id"，它将在 IbatisInsert.java 文件中用于对数据库执行 SQL INSERT 查询。

insert into EMPLOYEE(first_name, last_name, salary)

values (#first_name#, #last_name#, #salary#)

select last_insert_id() as id

此处 parameterClass − 可以根据需求将值作为 string、int、float、double 或任何类 object。在此示例中，我们将在调用 SqlMap 类的 insert 方法时将 Employee 对象作为参数传递。

如果您的数据库表使用 IDENTITY、AUTO_INCREMENT 或 SERIAL 列，或者您已定义 SEQUENCE/GENERATOR，则可以使用 语句中的元素来使用或返回该数据库生成的值。

IbatisInsert.java 文件

此文件将具有应用程序级逻辑，用于在 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);

/* 这将在 Employee 表中插入一条记录。 */

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 ");

}

}

编译和运行

下面是编译和运行上述软件的步骤。在继续编译和执行之前，请确保已正确设置 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 - 读取操作

在上一章中，我们讨论了如何使用 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 类

要执行读取操作，我们将修改 Employee.java 中的 Employee 类，如下所示 −

public class Employee {

private int id;

private String first_name;

private String last_name;

private int salary;

/* 为 Employee 类定义构造函数。 */

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 文件

要使用 iBATIS 定义 SQL 映射语句，我们需要在 Employee.xml 文件中添加 标记，并在此标记定义内定义一个"id"，该 id 将在 IbatisRead.java 文件中用于对数据库执行 SQL SELECT 查询。

INSERT INTO EMPLOYEE(first_name, last_name, salary)

values (#first_name#, #last_name#, #salary#)

select last_insert_id() as id

SELECT * FROM EMPLOYEE

这里我们没有使用带有 SQL SELECT 语句的 WHERE 子句。我们将在下一章中演示如何将 WHERE 子句与 SELECT 语句一起使用以及如何将值传递给该 WHERE 子句。

IbatisRead.java 文件

此文件具有应用程序级逻辑，用于从 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);

/* 这将从 Employee 表读取所有记录。 */

System.out.println("Going to read records.....");

List ems = (List)

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 ");

}

}

编译和运行

下面是编译和运行上述软件的步骤。在继续编译和执行之前，请确保已正确设置 PATH 和 CLASSPATH。

如上所示创建 Employee.xml。

如上所示创建 Employee.java 并对其进行编译。

如上所示创建 IbatisRead.java 并对其进行编译。

执行 IbatisRead 二进制文件以运行该程序。

您将获得以下结果，并且将从 EMPLOYEE 表中读取一条记录，如下所示 −

Going to read records.....

1 Zara Ali 5000

Record Reads Successfully

iBATIS - 更新操作

在上一章中，我们讨论了如何使用 iBATIS 对表执行读取操作。本章介绍如何使用 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)

员工 POJO 类

要执行更新操作，您需要按如下方式修改 Employee.java 文件 −

public class Employee {

private int id;

private String first_name;

private String last_name;

private int salary;

/* 为 Employee 类定义构造函数。 */

public Employee() {}

public Employee(String fname, String lname, int salary) {

this.first_name = fname;

this.last_name = lname;

this.salary = salary;

}

/* 以下是所需的方法定义 */

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 文件

要使用 iBATIS 定义 SQL 映射语句，我们需要在 Employee.xml 中添加 标签，并在此标签定义中定义一个"id"，该 id 将在 IbatisUpdate.java 文件中用于对数据库执行 SQL UPDATE 查询。

INSERT INTO EMPLOYEE(first_name, last_name, salary)

values (#first_name#, #last_name#, #salary#)

select last_insert_id() as id

SELECT * FROM EMPLOYEE

UPDATE EMPLOYEE

SET first_name = #first_name#

WHERE id = #id#

IbatisUpdate.java 文件

此文件具有应用程序级逻辑，用于将记录更新到 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);

/*这将更新员工表中的一条记录。*/

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 ems = (List)

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 ");

}

}

编译和运行

以下是编译和运行上述软件的步骤。在继续编译和执行之前，请确保已正确设置 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 - 删除操作

本章介绍如何使用 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 类

要执行删除操作，您无需修改​​ Employee.java 文件。让我们将其保留为上一章中的原样。

public class Employee {

private int id;

private String first_name;

private String last_name;

private int salary;

/* 为 Employee 类定义构造函数。 */

public Employee() {}

public Employee(String fname, String lname, int salary) {

this.first_name = fname;

this.last_name = lname;

this.salary = salary;

}

/* 以下是所需的方法定义 */

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 文件

要使用 iBATIS 定义 SQL 映射语句，我们需要在 Employee.xml 中添加 标签，并在此标签定义中定义一个"id"，该 id 将在 IbatisDelete.java 文件中用于对数据库执行 SQL DELETE 查询。

INSERT INTO EMPLOYEE(first_name, last_name, salary)

values (#first_name#, #last_name#, #salary#)

select last_insert_id() as id

SELECT * FROM EMPLOYEE

UPDATE EMPLOYEE

SET first_name = #first_name#

WHERE id = #id#

DELETE FROM EMPLOYEE

WHERE id = #id#

IbatisDelete.java 文件

此文件具有应用程序级逻辑，用于从 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);

/*这将删除 Employee 表中的一个记录。*/

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 ems = (List)

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 ");

}

}

编译和运行

下面是编译和运行上述软件的步骤。在继续编译和执行之前，请确保已正确设置 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 - 结果映射

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 类

要使用 iBATIS ResultMap，您无​​需修改​​ Employee.java 文件。让我们将其保留为上一章中的原样。

public class Employee {

private int id;

private String first_name;

private String last_name;

private int salary;

/* 为 Employee 类定义构造函数。 */

public Employee() {}

public Employee(String fname, String lname, int salary) {

this.first_name = fname;

this.last_name = lname;

this.salary = salary;

}

/* 以下是所需的方法定义 */

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 文件

在这里，我们将修改 Employee.xml 以引入 标签。此标签将具有一个 id，该 id 是在我们的 标签的 resultMap 属性中运行此 resultMap 所必需的。

INSERT INTO EMPLOYEE(first_name, last_name, salary)

values (#first_name#, #last_name#, #salary#)

select last_insert_id() as id

SELECT * FROM EMPLOYEE

UPDATE EMPLOYEE

SET first_name = #first_name#

WHERE id = #id#

DELETE FROM EMPLOYEE

WHERE id = #id#

SELECT * FROM EMPLOYEE

WHERE id=#id#

IbatisResultMap.java 文件

此文件具有应用程序级逻辑，可使用 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 ");

}

}

编译和运行

下面是编译和运行上述软件的步骤。在继续编译和执行之前，请确保已正确设置了 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 - 存储过程

您可以使用 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)

员工 POJO 类

要使用存储过程，您无需修改​​ Employee.java 文件。让我们将其保留为上一章中的原样。

public class Employee {

private int id;

private String first_name;

private String last_name;

private int salary;

/* 为 Employee 类定义构造函数。 */

public Employee() {}

public Employee(String fname, String lname, int salary) {

this.first_name = fname;

this.last_name = lname;

this.salary = salary;

}

/* 以下是所需的方法定义 */

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 文件

在这里，我们将修改 Employee.xml 以引入 和 标签。这里的 标签将有一个 id，我们将在应用程序中使用它来调用存储过程。

INSERT INTO EMPLOYEE(first_name, last_name, salary)

values (#first_name#, #last_name#, #salary#)

select last_insert_id() as id

SELECT * FROM EMPLOYEE

UPDATE EMPLOYEE

SET first_name = #first_name#

WHERE id = #id#

DELETE FROM EMPLOYEE

WHERE id = #id#

{ call getEmp( #acctID# ) }

IbatisSP.java 文件

此文件具有应用程序级逻辑，可使用 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 ");

}

}

编译和运行

下面是编译和运行上述软件的步骤。在继续编译和执行之前，请确保已正确设置 PATH 和 CLASSPATH。

如上所示创建 Employee.xml。

如上所示创建 Employee.java 并对其进行编译。

如上所示创建 IbatisSP.java 并对其进行编译。

执行 IbatisSP 二进制文件以运行该程序。

您将获得以下结果 −

Going to read employee name.....

First Name: Zara

Record name Successfully

iBATIS - 动态 SQL

动态 SQL 是 iBATIS 的一个非常强大的功能。有时您必须根据参数对象的状态更改 WHERE 子句条件。在这种情况下，iBATIS 提供了一组动态 SQL 标记，可在映射语句中使用，以增强 SQL 的可重用性和灵活性。

所有逻辑都使用一些附加标记放在 .XML 文件中。以下是 SELECT 语句以两种方式工作的示例 −

如果您传递一个 ID，那么它将返回与该 ID 对应的所有记录。

否则，它将返回员工 ID 设置为 NULL 的所有记录。

SELECT * FROM EMPLOYEE

id IS NULL

id = #id#

您可以使用 标签检查条件，如下所示。仅当传递的属性不为空时才会添加条件。

..................

SELECT * FROM EMPLOYEE

id = #id#

..................

如果您想要一个查询，我们可以选择一个员工的 ID 和/或名字，您的 SELECT 语句将如下所示 −

..................

SELECT * FROM EMPLOYEE

id = #id#

first_name = #first_name#

..................

动态 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)

员工 POJO 类

要执行读取操作，让我们在 Employee.java 中创建一个员工类，如下所示 −

public class Employee {

private int id;

private String first_name;

private String last_name;

private int salary;

/* 为 Employee 类定义构造函数。 */

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 文件

要使用 iBATIS 定义 SQL 映射语句，我们将在 Employee.xml 中添加以下修改后的 标记，并在此标记定义内定义一个"id"，它将在 IbatisReadDy.java 中用于对数据库执行动态 SQL SELECT 查询。

SELECT * FROM EMPLOYEE

id = #id#

上述 SELECT 语句有两种工作方式 −

如果您传递一个 ID，则它会返回与该 ID 对应的记录;否则，它会返回所有记录。

IbatisReadDy.java 文件

此文件具有应用程序级逻辑，用于从 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);

/* 这将从 Employee 表读取所有记录。*/

System.out.println("Going to read records.....");

Employee rec = new Employee();

rec.setId(1);

List ems = (List)

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 ");

}

}

编译和运行

下面是编译和运行上述软件的步骤。在继续编译和执行之前，请确保已正确设置 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 语句

choose、when、otherwise 语句

where 语句

foreach 语句

if 语句

动态 SQL 中最常见的操作是有条件地包含 where 子句的一部分。例如 −

SELECT * FROM BLOG

WHERE state = 'ACTIVE.

AND title like #{title}

此语句提供可选的文本搜索类型的功能。如果您不传入任何标题，则将返回所有活跃博客。但如果您传入了标题，它将查找具有给定 like 条件的标题。

您可以包含多个 if 条件，如下所示 −

SELECT * FROM BLOG

WHERE state = 'ACTIVE.

AND title like #{title}

AND author like #{author}

choose、when 和 else 语句

iBATIS 提供了一个 choose 元素，它类似于 Java 的 switch 语句。它有助于在众多选项中仅选择一个案例。

以下示例将仅按标题(如果提供了标题)进行搜索，然后仅按作者(如果提供了作者)进行搜索。如果两者都未提供，则仅返回精选博客 −

SELECT * FROM BLOG

WHERE state = 'ACTIVE.

AND title like #{title}

AND author like #{author}

AND featured = 1

where 语句

查看我们之前的示例，看看如果所有条件都不满足会发生什么。您最终会得到类似这样的 SQL −

SELECT * FROM BLOG

WHERE

这会失败，但 iBATIS 有一个简单的解决方案，只需进行一次简单的更改，一切就会正常 −

SELECT * FROM BLOG

state = #{state}

AND title like #{title}

SELECT *

FROM POST P

WHERE ID in

open="(" separator="," close=")">

#{item}

iBATIS - 调试

使用 iBATIS 时，调试程序非常容易。iBATIS 具有内置日志支持，可与以下日志库配合使用并按此顺序搜索它们。

Jakarta Commons Logging (JCL)。

Log4J

JDK logging

您可以将上面列出的任何库与 iBATIS 一起使用。

使用 Log4J 进行调试

假设您将使用 Log4J 进行日志记录。继续操作之前，您需要交叉检查以下几点 −

Log4J JAR 文件 (log4j-{version}.jar) 应位于 CLASSPATH 中。

您在 CLASSPATH 中拥有 log4j.properties。

以下是 log4j.properties 文件。请注意，有些行已被注释掉。如果您需要额外的调试信息，可以取消注释它们。

# 全局日志配置

log4j.rootLogger = ERROR, stdout

log4j.logger.com.ibatis = DEBUG

# 显示准备好的语句的 SQL

#log4j.logger.java.sql.Connection = DEBUG

# 显示插入到准备好的语句中的参数

#log4j.logger.java.sql.PreparedStatement = DEBUG

# 显示查询结果

#log4j.logger.java.sql.ResultSet = DEBUG

#log4j.logger.java.sql.Statement = DEBUG

# 控制台输出

log4j.appender.stdout = org.apache.log4j.ConsoleAppender

log4j.appender.stdout.layout = org.apache.log4j.PatternLayout

log4j.appender.stdout.layout.ConversionPattern = %5p [%t] − %m%n

您可以从 Apache 网站 − Log4J 文档 找到 Log4J 的完整文档。

iBATIS 调试示例

以下 Java 类是一个非常简单的示例，它初始化然后使用 Java 应用程序的 Log4J 日志库。我们将使用位于 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);

/* 这将在 Employee 表中插入一条记录。 */

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 ems = (List)

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 ");

}

}

编译和运行

首先，请确保在继续编译和执行之前已正确设置了 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

Hibernate

iBATIS 更简单。它的包大小要小得多。

Hibernate 为您生成 SQL，这意味着您不必花时间生成 SQL。

iBATIS 很灵活。它提供更快的开发时间。

Hibernate 具有高度可扩展性。它提供了更高级的缓存。

iBATIS 使用可能依赖于数据库的 SQL。

Hibernate 使用相对独立于数据库的 HQL。在 Hibernate 中更改数据库更加容易。

iBatis 将 JDBC API 中的 ResultSet 映射到您的 POJO 对象，因此您不必关心表结构。

Hibernate 将 Java POJO 对象映射到数据库表。

在 iBATIS 中使用存储过程非常容易。

在 Hibernate 中使用存储过程有点困难。

Hibernate 和 iBATIS 都得到了 SPRING 框架的良好支持，因此选择其中之一应该不成问题。

iBATOR - 简介

iBATOR 是 iBATIS 的代码生成器。iBATOR 会检查一个或多个数据库表，并生成可用于访问这些表的 iBATIS 工件。

稍后，您可以编写自定义 SQL 代码或存储过程来满足您的要求。iBATOR 会生成以下工件 −

SqlMap XML 文件

用于匹配表的主键和字段的 Java 类

使用上述对象的 DAO 类(可选)

iBATOR 可以作为独立 JAR 文件、Ant 任务或 Eclipse 插件运行。本教程介绍了从命令行生成 iBATIS 配置文件的最简单方法。

下载 iBATOR

如果您使用的是 Eclipse 以外的 IDE，请下载独立 JAR。独立 JAR 包含一个用于运行 iBATOR 的 Ant 任务，或者您可以从 Java 代码的命令行运行 iBATOR。

您可以从下载 iBATOR下载 zip 文件。

您可以查看在线文档 − iBATOR 文档。

生成配置文件

要运行 iBATOR，请按照以下步骤 −

步骤 1

创建并适当填写配置文件 ibatorConfig.xml。至少，您必须指定 −

一个 元素，用于指定如何连接到目标数据库。

一个 元素，用于指定生成的 Java 模型对象的目标包和目标项目。

一个 元素，用于指定生成的 SQL 映射文件的目标包和目标项目。

一个 元素，用于指定生成的 DAO 接口和类的目标包和目标项目(如果您不想生成 DAO，可以省略 元素)。

至少一个数据库

元素

注意 − 有关 iBATOR 配置文件示例，请参阅 XML 配置文件参考 页面。

步骤 2

将文件保存到方便的位置，例如:emp\ibatorConfig.xml。

步骤 3

现在从命令行运行 iBATOR，如下所示 −

java -jar abator.jar -configfile emp\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 文件应该包含这些条目 −

如果有多个 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 文件应该包含这些条目 −

注意 − 仅当您为 iBATIS DAO 框架生成 DAO 时才需要此步骤。

❮ 上一节

下一节 ❯