iBATIS快速指南

iBATIS  概述

iBATIS 是一个持久性框架，在自动化的 Java，.NET 和 Ruby on Rails 的 SQL 数据库和对象之间进行映射。该映射通过包装 XML 配置文件中的 SQL 语句从应用程序逻辑分离。

iBATIS 是一个轻量级的框架和持久性 API 利于 POJO（普通Java对象）。

iBATIS 被称为一个数据映射和映射类属性以及数据库表的列之间的参数和结果的集合。

iBATIS 和其它持久性框架如 Hibernate 之间的显著不同的是，iBATIS 强调使用SQL，而其他框架通常使用自定义查询语言，具有 Hibernate 查询语言（HQL）或企业 JavaBeans 查询语言（EJB QL）。

iBATIS 的设计理念

iBatis 提供了以下设计理念 -

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

• 快速发展- iBATIS 尽一切努力让自己快速发展。

• 可移植性- iBATIS 可用于几乎任何语言或平台如 Java，Ruby 和 C＃。

• 独立接口- iBATIS 提供与数据库无关的接口和API，帮助应用程序与数据部分保持独立的持久性。

• 开源- iBATIS 的源码及软件是自由和开放。

iBATIS的优点

iBATIS的具有以下优点 -

• 支持存储过程- iBATIS 封装在 SQL 中，使业务逻辑保持了数据库特性，应用程序更易于部署和测试，更便于操作。

• 支持嵌入式SQL -无需预编译器，你可以完全访问所有的 SQL 的功能。

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

• 支持O / RM - iBATIS 支持许多功能，作为一个 O / RM 工具，如延迟加载，连接抓取，高速缓存，运行时代码生成和继承

iBATIS 利用了 JAVA 编程语言，开发数据库应用导向。在进一步讨论之前，请确保您了解程序和面向对象编程的基础知识 - 控制结构，数据结构和变量，类，对象，等等。

要了解 JAVA 详细你可以通过我们的 JAVA 教程 。

iBATIS的 - 环境

在实际开发前，你将不得不设立 iBATIS 的一个适当的环境。本章介绍如何设置为 SWF 工作环境。

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。

• JDBC 驱动程序 MySQL 是“com.mysql.jdbc.Driver”。

• 连接 UR L是为“jdbc：mysql：//本地主机：3306 / TESTDB”。

• 我们将分别使用用户名和密码的“根”和“根”。

• 我们对所有的操作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 对象（PO​​JO）对应的表类。本课程介绍对象，这将“模型”的数据库表行。

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

员工PO​​JO类

我们将在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映射语句中，我们将使用<插入>标记和这个标签定义中，我们可以定义将在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 -可能需要一个值作为字符串，整数，浮点，双 ，或根据需求任意类对象 。在这个例子中，我们将通过 Employee 对象作为参数，同时呼吁的SqlMap 类的插入方法。

如果数据库表使用 IDENTITY，AUTO_INCREMENT 或串行列或您已经定义了一个 SEQUENCE /发电机，可以使用 <selectKey元素> 元素在 <插入> 语句中使用或返回数据库生成的值。

IbatisInsert.java 文件

该文件将应用程序级别的逻辑插入在雇员表中的记录 -

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表操作。本章介绍如何使用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)

员工 PO​​JO 类

要执行读操作，我们将修改 Employee 类中 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 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 文件，这个标签定义标记内，我们将定义将在 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>

在这里，我们没有使用 WHERE 子句与 SQL SELECT 语句。我们将证明，在接下来的章节中，你怎么能与 WHERE SELECT 语句子句如何使用可以传递值到 WHERE 子句。

IbatisRead.java 文件

这个文件的应用程序级的逻辑读取雇员表中的记录 -

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 表执行读操作。本章介绍了如何更新使用 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)

员工 PO​​JO 类

要执行 UDPATE 操作，你就需要修改 Employee.java 文件内容如下 -

public class Employee {
   private int id;
   private String first_name; 
   private String last_name;   
   private int salary;  

   /* Define constructors for the Employee class. */
   public Employee() {}
  
   public Employee(String fname, String lname, int salary) {
      this.first_name = fname;
      this.last_name = lname;
      this.salary = salary;
   }

   /* Here are the required method definitions */
   public int getId() {
      return id;
   }
	
   public void setId(int id) {
      this.id = id;
   }
	
   public String getFirstName() {
      return first_name;
   }
	
   public void setFirstName(String fname) {
      this.first_name = fname;
   }
	
   public String getLastName() {
      return last_name;
   }
   public void setlastName(String lname) {
      this.last_name = lname;
   }
	
   public int getSalary() {
      return salary;
   }
	
   public void setSalary(int salary) {
      this.salary = salary;
   }

} /* End of Employee */

Employee.xml 文件

要定义使用 iBATIS SQL 映射语句中，我们将增加 <更新> 在 Employee.xml 这个标签定义标记内，我们将定义将在 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)

员工 PO​​JO 类

要执行删除操作，你并不需要修改 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 语句中的映射，我们会在 Employee.xml 添加<删除>标记和这个标签定义中，我们可以定义将在 IbatisDelete.java 文件可用于执行 SQL 删除数据库查询的“身份证”。

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE sqlMap PUBLIC "-//ibatis.apache.org//DTD SQL Map 2.0//EN" "http://ibatis.apache.org/dtd/sql-map-2.dtd">

<sqlMap namespace="Employee">

   <insert id="insert" parameterClass="Employee">
      INSERT INTO EMPLOYEE(first_name, last_name, salary)
      values (#first_name#, #last_name#, #salary#)

      <selectKey resultClass="int" keyProperty="id">
         select last_insert_id() as id
      </selectKey>
   </insert>

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

员工 PO​​JO 类

要使用 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的> 标记。这个标签本来这是需要我们的 <select> 标记的结果映射属性运行此结果映射的 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>

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

员工 PO​​JO 类

要使用存储过程，你并不需要修改 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 介绍<过程> </程序>和<parameterMap 的> </ parameterMap 的>标记。在这里，<过程> </程序>标签将有哪些，我们将在我们的应用程序使用调用存储过程的 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 record.....
ID:  1
First Name:  Zara
Last Name:  Ali
Salary:  5000
Record read 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 语句。想想，我们有以下 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)
);

让我们假设这个表只有一个记录如下 -

mysql> select * from EMPLOYEE;
+----+------------+-----------+--------+
| id | first_name | last_name | salary |
+----+------------+-----------+--------+
|  1 | Zara       | Ali       |   5000 |
+----+------------+-----------+--------+
1 row in set (0.00 sec)

员工 PO​​JO 类

要执行读操作，让我们有一个 Employee 类 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 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 这个标签定义标记内，我们将定义将在 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

由空传递的smc.queryForList（“Employee.findByID”，NULL）尝试上面的例子。

iBATIS OGNL 表达式

iBATIS 提供基于强大的 OGNL 表达式来消除其他元素。

• 如果声明
• 选择的时候，否则声明
• 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>

这种说法提供了功能一个可选的文本搜索类型。如果你没有冠军擦肩而过，那么所有激活的博客被返回。但是，如果你传递一个标题，它会寻找与给定的条件下像一个冠军。

您可以包括多个 if 条件如下-

<select id="findActiveBlogWithTitleLike" parameterType="Blog" resultType="Blog">
   SELECT * FROM BLOG
   WHERE state = 'ACTIVE.
	
   <if test="title != null">
      AND title like #{title}
   </if>
	
   <if test="author != null">
      AND author like #{author}
   </if>
	
</select>

在选择的时候，否则声明

iBATIS 提供了一个选择元素，它类似于 Java 的 switch 语句。它有助于只选择一个多选项中的情况下。

下面的例子将只按标题如果提供仅由作者如果提供搜索，然后。如果没有提供，它只返回精选的博客 -

<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 的记录（JCL）。
• Log4J 
• JDK 日志

您可以使用上述任何图书馆与 iBATIS 一起。

调试与 Log4J

假设你要使用 log4j 的日志记录。在开始之前，你需要交叉检查以下几点 -

• log4j 的 JAR 文件（log4j- {}版本的.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

你可以找到阿帕奇网站 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);

      /* 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 二进制运行程序。

你会得到以下结果。 A 记录将在 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 休眠

有 iBATIS 的和 Hibernate 之间的主要差异。这两种解决方案很好地工作，因为它们特定领域。 iBATIS 建议的情况如下 -

• 你想创建自己的 SQL 的，你是愿意维护。
• 你的环境是由关系数据模型驱动的。
• 你必须对现有的和复杂的模式工作。

使用 Hibernate 如果环境是由对象模型驱动的并需要自动生成SQL。

iBATIS 和 Hibernate 的区别

Hibernate 和 iBATIS 的是开源对象关系映射（ORM）工具，在同行业中可用。这些工具的用途取决于你使用它们的上下文。

下表重点介绍的 iBATIS 和 Hibernate 之间的差异 -

Hibernate 和 iBATIS 的接收来自 Spring 框架很好的支持，所以它不应该选择其中的一个问题。

iBATOR - 引言

iBATOR 是 iBATIS 的代码生成器。 iBATOR 内部检查的一个或多个数据库表和生成可用于访问表 iBATIS 的工件。

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

• SqlMap 的 XML 文件
• Java 类相匹配的表的主键和字段（多个）
• 使用上述对象 DAO 类（可选）

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

下载 iBATOR

如果您使用的不是其他的 Eclipse 的 IDE 下载独立 JAR。独立 JAR 包括一个 Ant 任务运行 iBATOR，也可以从 Java 代码在命令行运行 iBATOR。

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

• 你可以在网上查询资料- iBATOR 文档 。

生成配置文件

要运行 iBATOR，请按照下列步骤 -

步骤1

创建并填写相应的配置文件 ibatorConfig.xml。至少，你必须指定 -

• A <jdbcConnection>元素指定如何连接到目标数据库。

• A <javaModelGenerator>元素来指定目标包和生成的 Java 模型对象目标项目。

• A <sqlMapGenerator>元素来指定目标包和生成的 SQL 映射文件的目标项目。

• A <daoGenerator>元素指定生成的 DAO 接口和类目标包和目标的项目（可以省略<daoGenerator>元素，如果你不希望产生的 DAO）。

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

注-请参阅 XML 配置文件参考页面的 iBATOR 配置文件的一个例子。

第2步

将该文件保存在方便的位置，例如在： TEMP ibatorConfig.xml。

第3步

现在从命令行运行 iBATOR 如下 -

java -jar abator.jar -configfile 	empabatorConfig.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 映射文件必须列出。

例如，假设 iBATOR 已经生成一个名为 MyTable_SqlMap.xml 的 SQL 映射文件，该文件已被放置在你的项目的 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 映射文件（这是很常见的），则可以将文件与 <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 的需要。