HTML CSS JAVASCRIPT PYTHON PYTHON2 JAVA C C++ C# SQL Excel Linux AI BOOTSTRAP PHP 教程库 参考手册 技术文章 测验 练习 HOWTO FAQ
❮ 上一节 下一节 ❯

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 文件为空，并在后续章节中介绍其内容。

<?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 - 创建操作

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

<?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。在此示例中，我们将在调用 SqlMap 类的 insert 方法时将 Employee 对象作为参数传递。

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

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 文件中添加 <select> 标记，并在此标记定义内定义一个"id"，该 id 将在 IbatisRead.java 文件中用于对数据库执行 SQL SELECT 查询。

<?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>

这里我们没有使用带有 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 <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 ");
   }
}

编译和运行

下面是编译和运行上述软件的步骤。在继续编译和执行之前，请确保已正确设置 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 中添加 <update> 标签，并在此标签定义中定义一个"id"，该 id 将在 IbatisUpdate.java 文件中用于对数据库执行 SQL UPDATE 查询。

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

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

编译和运行

以下是编译和运行上述软件的步骤。在继续编译和执行之前，请确保已正确设置 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 中添加 <delete> 标签，并在此标签定义中定义一个"id"，该 id 将在 IbatisDelete.java 文件中用于对数据库执行 SQL DELETE 查询。

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

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

编译和运行

下面是编译和运行上述软件的步骤。在继续编译和执行之前，请确保已正确设置 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 以引入 <resultMap></resultMap> 标签。此标签将具有一个 id，该 id 是在我们的 <select> 标签的 resultMap 属性中运行此 resultMap 所必需的。

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

此文件具有应用程序级逻辑，可使用 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 以引入 <procedure></procedure> 和 <parameterMap></parameterMap> 标签。这里的 <procedure></procedure> 标签将有一个 id，我们将在应用程序中使用它来调用存储过程。

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

此文件具有应用程序级逻辑，可使用 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 的所有记录。
<?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>

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

..................
<select id="findByID" resultClass="Employee">
   SELECT * FROM EMPLOYEE
	
   <dynamic prepend="WHERE ">
      <isNotEmpty property="id">
         id = #id#
      </isNotEmpty>
   </dynamic>
	
</select>
..................

如果您想要一个查询，我们可以选择一个员工的 ID 和/或名字，您的 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)

员工 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 中添加以下修改后的 <select> 标记，并在此标记定义内定义一个"id"，它将在 IbatisReadDy.java 中用于对数据库执行动态 SQL SELECT 查询。

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

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

编译和运行

下面是编译和运行上述软件的步骤。在继续编译和执行之前，请确保已正确设置 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 id="findActiveBlogWithTitleLike" parameterType="Blog" resultType="Blog">
   SELECT * FROM BLOG
   WHERE state = 'ACTIVE.
	
   <if test="title != null">
      AND title like #{title}
   </if>
	
</select>

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

您可以包含多个 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>

choose、when 和 else 语句

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

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

<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 开头，它知道将其删除。

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 - 调试

使用 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 <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 ");
   }
}

编译和运行

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

步骤 1

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

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

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

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

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

  • 至少一个数据库<table> 元素

注意 − 有关 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 文件应该包含这些条目 −

<?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 文件(这很常见)，则可以按任何顺序列出这些文件，并在 <transactionManager> 之后重复 <sqlMap> 元素。元素。

更新 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>

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

❮ 上一节 下一节 ❯