iBATIS - 快速指南

上一页
下一页

iBATIS - 概述

iBATIS是一个持久化框架，它自动映射Java、.NET和Ruby on Rails中的SQL数据库和对象。通过将SQL语句打包在XML配置文件中，映射与应用程序逻辑解耦。

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

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

iBATIS与其他持久化框架（如Hibernate）的一个显著区别在于，iBATIS强调使用SQL，而其他框架通常使用自定义查询语言，如Hibernate查询语言（HQL）或Enterprise JavaBeans查询语言（EJB QL）。

iBATIS设计理念

iBATIS带有以下设计理念：

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

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

  • 可移植性 - iBATIS可以应用于几乎任何语言或平台，例如Java、Ruby和C# for Microsoft .NET。

  • 独立接口 - 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文件(s)上适当地设置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://127.0.0.1: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://127.0.0.1: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)
);

Employee POJO类

我们将如下在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文件

要使用iBATIS定义SQL映射语句，我们将使用<insert>标签，并在该标签定义内，我们将定义一个“id”，该“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 -可以根据需要取值为字符串、int、float、double或任何类对象。在本例中，我们在调用SqlMap类的insert方法时将传递Employee对象作为参数。

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

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

      /* 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 ");
   }
}

编译和运行

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

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

要使用iBATIS定义SQL映射语句，我们将添加<select>标签到Employee.xml文件中，并在该标签定义内，我们将定义一个“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);

      /* 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 ");
   }
}

编译和运行

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

  • 如上所示创建Employee.xml。
  • 如上所示创建Employee.java并编译它。
  • 如上所示创建IbatisRead.java并编译它。
  • 执行IbatisRead二进制文件以运行程序。

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

Going to read records.....
   1  Zara  Ali  5000
Record Reads Successfully

iBATIS - 更新操作

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

要执行更新操作，您需要如下修改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文件

要使用iBATIS定义SQL映射语句，我们将添加<update>标签到Employee.xml中，并在该标签定义内，我们将定义一个“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);

      /* 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 ");
   }
}

编译和运行

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

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

要使用iBATIS定义SQL映射语句，我们将添加<delete>标签到Employee.xml中，并在该标签定义内，我们将定义一个“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);

      /* 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 ");
   }
}

编译和运行

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

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

在这里，我们将修改 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)

Employee POJO类

要使用存储过程，您无需修改 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文件

在这里，我们将修改 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)

Employee POJO类

要执行读取操作，让我们在 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文件

要使用 iBATIS 定义 SQL 映射语句，我们将添加以下修改后的 <select> 标签到 Employee.xml 中，并在该标签定义内，我们将定义一个 "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);

      /* 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 ");
   }
}

编译和运行

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

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 日志记录

您可以将上述任何库与 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

您可以从 Apache 网站找到 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 ");
   }
}

编译和运行

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

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

步骤 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 映射 XML 文件。

例如，假设 iBATOR 生成了一个名为 MyTable_SqlMap.xml 的 SQL 映射 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 映射 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 时，才需要执行此步骤。

打印页面
上一页
下一页
广告