目录

iBATIS - 快速指南

iBATIS - Overview

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

iBATIS是一个轻量级框架和持久性API,适用于持久化POJO(Plain Old Java Objects)。

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

iBATIS与其他持久性框架(如Hibernate)之间的显着差异在于iBATIS强调SQL的使用,而其他框架通常使用自定义查询语言,例如Hibernate查询语言(HQL)或Enterprise JavaBeans查询语言(EJB QL)。

iBATIS设计理念

iBATIS带有以下设计理念 -

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

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

  • Portability − iBATIS几乎可以用于任何语言或平台,例如Java,Ruby和C#for Microsoft .NET。

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

  • Open source − iBATIS是免费的,是一个开源软件。

iBATIS的优点

iBATIS具有以下优势 -

  • Supports stored procedures − --iBATIS以存储过程的形式封装SQL,以便将业务逻辑保留在数据库之外,并且应用程序更易于部署和测试,并且更易于移植。

  • Supports inline SQL −不需要预编译器,您可以完全访问SQL的所有功能。

  • Supports dynamic SQL − iBATIS提供了基于参数动态构建SQL查询的功能。

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

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

要详细了解JAVA,您可以浏览我们的JAVA教程

iBATIS - Environment

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

iBATIS安装

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

  • 下载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)
);

Create SqlMapConfig.xml

考虑以下 -

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

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

  • 连接URL是“jdbc:mysql:// localhost:3306/testdb”。

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

  • 我们在所有操作中的sql语句映射将在“Employee.xml”中描述。

基于上述假设,我们必须创建一个名为SqlMapConfig.xml的XML配置文件, SqlMapConfig.xml包含以下内容。 这是您需要提供iBatis所需的所有配置的地方 -

重要的是,文件SqlMapConfig.xml和Employee.xml都应该存在于类路径中。 现在,我们将Employee.xml文件保留为空,我们将在后续章节中介绍其内容。

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE sqlMapConfig PUBLIC "-//ibatis.apache.org//DTD SQL Map Config 2.0//EN" "http://ibatis.apache.org/dtd/sql-map-config-2.dtd">
<sqlMapConfig>
   <settings useStatementNamespaces="true"/>
   <transactionManager type="JDBC">
      <dataSource type="SIMPLE">
         <property name="JDBC.Driver" value="com.mysql.jdbc.Driver"/>
         <property name="JDBC.ConnectionURL" value="jdbc:mysql://localhost:3306/testdb"/>
         <property name="JDBC.Username" value="root"/>
         <property name="JDBC.Password" value="root"/>
      </dataSource>
   </transactionManager>
   <sqlMap resource="Employee.xml"/> 
</sqlMapConfig>

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

<property name="JDBC.AutoCommit" value="true"/>
<property name="Pool.MaximumActiveConnections" value="10"/>
<property name="Pool.MaximumIdleConnections" value="5"/>
<property name="Pool.MaximumCheckoutTime" value="150000"/> 
<property name="Pool.MaximumTimeToWait" value="500"/> 
<property name="Pool.PingQuery" value="select 1 from Employee"/> 
<property name="Pool.PingEnabled" value="false"/>

iBATIS - Create Operation

要使用iBATIS执行任何创建,读取,更新和删除(CRUD)操作,您需要创建与该表对应的普通旧Java对象(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)
);

Employee POJO Class

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

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

您可以定义在表中设置单个字段的方法。 下一章将介绍如何获取各个字段的值。

Employee.xml File

要使用iBATIS定义SQL映射语句,我们将使用标记,在此标记定义中,我们将定义一个“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 。 在这个例子中,我们将调用Employee对象作为参数,同时调用SqlMap类的insert方法。

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

IbatisInsert.java File

此文件将具有应用程序级逻辑以在Employee表中插入记录 -

import com.ibatis.common.resources.Resources;
import com.ibatis.sqlmap.client.SqlMapClient;
import com.ibatis.sqlmap.client.SqlMapClientBuilder;
import java.io.*;
import java.sql.SQLException;
import java.util.*;
public class IbatisInsert{
   public static void main(String[] args)throws IOException,SQLException{
      Reader rd = Resources.getResourceAsReader("SqlMapConfig.xml");
      SqlMapClient smc = SqlMapClientBuilder.buildSqlMapClient(rd);
      /* This would insert one record in Employee table. */
      System.out.println("Going to insert record.....");
      Employee em = new Employee("Zara", "Ali", 5000);
      smc.insert("Employee.insert", em);
      System.out.println("Record Inserted Successfully ");
   }
} 

编译和运行 (Compilation and Run)

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

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

您将获得以下结果,并将在EMPLOYEE表中创建记录。

$java IbatisInsert
Going to insert record.....
Record Inserted Successfully

如果您检查EMPLOYEE表,它应显示以下结果 -

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

iBATIS - Read Operation

在上一章中,我们讨论了如何使用iBATIS对表执行CREATE操作。 本章介绍如何使用iBATIS读取表。

我们在MySQL中有以下EMPLOYEE表 -

CREATE TABLE EMPLOYEE (
   id INT NOT NULL auto_increment,
   first_name VARCHAR(20) default NULL,
   last_name  VARCHAR(20) default NULL,
   salary     INT  default NULL,
   PRIMARY KEY (id)
);

该表只有一条记录如下 -

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

Employee POJO Class

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

public class Employee {
   private int id;
   private String first_name; 
   private String last_name;   
   private int salary;  
   /* Define constructors for the Employee class. */
   public Employee() {}
   public Employee(String fname, String lname, int salary) {
      this.first_name = fname;
      this.last_name = lname;
      this.salary = salary;
   }
   /* Here are the method definitions */
   public int getId() {
      return id;
   }
   public String getFirstName() {
      return first_name;
   }
   public String getLastName() {
      return last_name;
   }
   public int getSalary() {
      return salary;
   }
} /* End of Employee */

Employee.xml File

要使用iBATIS定义SQL映射语句,我们将在Employee.xml文件中添加

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE sqlMap PUBLIC "-//ibatis.apache.org//DTD SQL Map 2.0//EN" "http://ibatis.apache.org/dtd/sql-map-2.dtd">
<sqlMap namespace="Employee">
   <insert id="insert" parameterClass="Employee">
      INSERT INTO EMPLOYEE(first_name, last_name, salary)
      values (#first_name#, #last_name#, #salary#)
      <selectKey resultClass="int" keyProperty="id">
         select last_insert_id() as id
      </selectKey>
   </insert>
   <select id="getAll" resultClass="Employee">
      SELECT * FROM EMPLOYEE
   </select>
</sqlMap>

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

IbatisRead.java File

此文件具有应用程序级逻辑,用于从Employee表中读取记录 -

import com.ibatis.common.resources.Resources;
import com.ibatis.sqlmap.client.SqlMapClient;
import com.ibatis.sqlmap.client.SqlMapClientBuilder;
import java.io.*;
import java.sql.SQLException;
import java.util.*;
public class IbatisRead{
   public static void main(String[] args)throws IOException,SQLException{
      Reader rd = Resources.getResourceAsReader("SqlMapConfig.xml");
      SqlMapClient smc = SqlMapClientBuilder.buildSqlMapClient(rd);
      /* This would read all records from the Employee table. */
      System.out.println("Going to read records.....");
      List <Employee> ems = (List<Employee>)
         smc.queryForList("Employee.getAll", null);
      Employee em = null;
      for (Employee e : ems) {
         System.out.print("  " + e.getId());
         System.out.print("  " + e.getFirstName());
         System.out.print("  " + e.getLastName());
         System.out.print("  " + e.getSalary());
         em = e; 
         System.out.println("");
      }    
      System.out.println("Records Read Successfully ");
   }
} 

编译和运行 (Compilation and Run)

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

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

您将获得以下结果,并且将从EMPLOYEE表中读取记录,如下所示 -

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

iBATIS - Update Operation

在上一章中,我们讨论了如何使用iBATIS对表执行READ操作。 本章介绍如何使用iBATIS更新表中的记录。

我们在MySQL中有以下EMPLOYEE表 -

CREATE TABLE EMPLOYEE (
   id INT NOT NULL auto_increment,
   first_name VARCHAR(20) default NULL,
   last_name  VARCHAR(20) default NULL,
   salary     INT  default NULL,
   PRIMARY KEY (id)
);

该表只有一条记录如下 -

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

Employee POJO Class

要执行udpate操作,您需要修改Employee.java文件,如下所示 -

public class Employee {
   private int id;
   private String first_name; 
   private String last_name;   
   private int salary;  
   /* Define constructors for the Employee class. */
   public Employee() {}
   public Employee(String fname, String lname, int salary) {
      this.first_name = fname;
      this.last_name = lname;
      this.salary = salary;
   }
   /* Here are the required method definitions */
   public int getId() {
      return id;
   }
   public void setId(int id) {
      this.id = id;
   }
   public String getFirstName() {
      return first_name;
   }
   public void setFirstName(String fname) {
      this.first_name = fname;
   }
   public String getLastName() {
      return last_name;
   }
   public void setlastName(String lname) {
      this.last_name = lname;
   }
   public int getSalary() {
      return salary;
   }
   public void setSalary(int salary) {
      this.salary = salary;
   }
} /* End of Employee */

Employee.xml File

要使用iBATIS定义SQL映射语句,我们将在Employee.xml中添加标记,在此标记定义中,我们将定义一个“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 File

此文件具有应用程序级逻辑,用于将记录更新到Employee表中 -

import com.ibatis.common.resources.Resources;
import com.ibatis.sqlmap.client.SqlMapClient;
import com.ibatis.sqlmap.client.SqlMapClientBuilder;
import java.io.*;
import java.sql.SQLException;
import java.util.*;
public class IbatisUpdate{
   public static void main(String[] args)
   throws IOException,SQLException{
      Reader rd = Resources.getResourceAsReader("SqlMapConfig.xml");
      SqlMapClient smc = SqlMapClientBuilder.buildSqlMapClient(rd);
      /* This would update one record in Employee table. */
      System.out.println("Going to update record.....");
      Employee rec = new Employee();
      rec.setId(1);
      rec.setFirstName( "Roma");
      smc.update("Employee.update", rec );
      System.out.println("Record updated Successfully ");
      System.out.println("Going to read records.....");
      List <Employee> ems = (List<Employee>)
         smc.queryForList("Employee.getAll", null);
      Employee em = null;
      for (Employee e : ems) {
         System.out.print("  " + e.getId());
         System.out.print("  " + e.getFirstName());
         System.out.print("  " + e.getLastName());
         System.out.print("  " + e.getSalary());
         em = e; 
         System.out.println("");
      }    
      System.out.println("Records Read Successfully ");
   }
} 

编译和运行 (Compilation and Run)

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

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

您将获得以下结果,并且将在EMPLOYEE表中更新记录,稍后,将从EMPLOYEE表中读取相同的记录。

Going to update record.....
Record updated Successfully
Going to read records.....
   1  Roma  Ali  5000
Records Read Successfully

iBATIS - Delete Operation

本章介绍如何使用iBATIS从表中删除记录。

我们在MySQL中有以下EMPLOYEE表 -

CREATE TABLE EMPLOYEE (
   id INT NOT NULL auto_increment,
   first_name VARCHAR(20) default NULL,
   last_name  VARCHAR(20) default NULL,
   salary     INT  default NULL,
   PRIMARY KEY (id)
);

假设此表有两条记录如下 -

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

Employee POJO Class

要执行删除操作,您无需修改​​Employee.java文件。 让我们保持原样在最后一章。

public class Employee {
   private int id;
   private String first_name; 
   private String last_name;   
   private int salary;  
   /* Define constructors for the Employee class. */
   public Employee() {}
   public Employee(String fname, String lname, int salary) {
      this.first_name = fname;
      this.last_name = lname;
      this.salary = salary;
   }
   /* Here are the required method definitions */
   public int getId() {
      return id;
   }
   public void setId(int id) {
      this.id = id;
   }
   public String getFirstName() {
      return first_name;
   }
   public void setFirstName(String fname) {
      this.first_name = fname;
   }
   public String getLastName() {
      return last_name;
   }
   public void setlastName(String lname) {
      this.last_name = lname;
   }
   public int getSalary() {
      return salary;
   }
   public void setSalary(int salary) {
      this.salary = salary;
   }
} /* End of Employee */

Employee.xml File

要使用iBATIS定义SQL映射语句,我们将在Employee.xml中添加标记,在此标记定义中,我们将定义一个“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 File

此文件具有应用程序级逻辑,用于从Employee表中删除记录 -

import com.ibatis.common.resources.Resources;
import com.ibatis.sqlmap.client.SqlMapClient;
import com.ibatis.sqlmap.client.SqlMapClientBuilder;
import java.io.*;
import java.sql.SQLException;
import java.util.*;
public class IbatisDelete{
   public static void main(String[] args)
   throws IOException,SQLException{
      Reader rd = Resources.getResourceAsReader("SqlMapConfig.xml");
      SqlMapClient smc = SqlMapClientBuilder.buildSqlMapClient(rd);
      /* This would delete one record in Employee table. */
      System.out.println("Going to delete record.....");
      int id = 1;
      smc.delete("Employee.delete", id );
      System.out.println("Record deleted Successfully ");
      System.out.println("Going to read records.....");
      List <Employee> ems = (List<Employee>)
         smc.queryForList("Employee.getAll", null);
      Employee em = null;
      for (Employee e : ems) {
         System.out.print("  " + e.getId());
         System.out.print("  " + e.getFirstName());
         System.out.print("  " + e.getLastName());
         System.out.print("  " + e.getSalary());
         em = e; 
         System.out.println("");
      }    
      System.out.println("Records Read Successfully ");
   }
} 

编译和运行 (Compilation and Run)

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

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

您将获得以下结果,ID = 1的记录将从EMPLOYEE表中删除,其余记录将被读取。

Going to delete record.....
Record deleted Successfully
Going to read records.....
   2  Roma  Ali  3000
Records Read Successfully

iBATIS - Result Maps

resultMap元素是iBATIS中最重要和最强大的元素。 您可以使用iBATIS ResultMap减少高达90%的JDBC编码,在某些情况下,它允许您执行JDBC甚至不支持的操作。

ResultMaps的设计使得简单语句根本不需要显式结果映射,而更复杂的语句只需要描述关系的绝对必要。

本章仅提供iBATIS ResultMaps的简单介绍。

我们在MySQL中有以下EMPLOYEE表 -

CREATE TABLE EMPLOYEE (
   id INT NOT NULL auto_increment,
   first_name VARCHAR(20) default NULL,
   last_name  VARCHAR(20) default NULL,
   salary     INT  default NULL,
   PRIMARY KEY (id)
);

该表有两条记录如下 -

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

Employee POJO Class

要使用iBATIS ResultMap,您无​​需修改​​Employee.java文件。 让我们保持原样在最后一章。

public class Employee {
   private int id;
   private String first_name; 
   private String last_name;   
   private int salary;  
   /* Define constructors for the Employee class. */
   public Employee() {}
   public Employee(String fname, String lname, int salary) {
      this.first_name = fname;
      this.last_name = lname;
      this.salary = salary;
   }
   /* Here are the required method definitions */
   public int getId() {
      return id;
   }
   public void setId(int id) {
      this.id = id;
   }
   public String getFirstName() {
      return first_name;
   }
   public void setFirstName(String fname) {
      this.first_name = fname;
   }
   public String getLastName() {
      return last_name;
   }
   public void setlastName(String lname) {
      this.last_name = lname;
   }
   public int getSalary() {
      return salary;
   }
   public void setSalary(int salary) {
      this.salary = salary;
   }
} /* End of Employee */

Employee.xml File

在这里,我们将修改Employee.xml以引入 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 File

此文件具有应用程序级逻辑,可使用ResultMap从Employee表中读取记录 -

import com.ibatis.common.resources.Resources;
import com.ibatis.sqlmap.client.SqlMapClient;
import com.ibatis.sqlmap.client.SqlMapClientBuilder;
import java.io.*;
import java.sql.SQLException;
import java.util.*;
public class IbatisResultMap{
   public static void main(String[] args)
   throws IOException,SQLException{
      Reader rd = Resources.getResourceAsReader("SqlMapConfig.xml");
      SqlMapClient smc = SqlMapClientBuilder.buildSqlMapClient(rd);
      int id = 1;
      System.out.println("Going to read record.....");
      Employee e = (Employee)smc.queryForObject ("Employee.useResultMap", id);
      System.out.println("ID:  " + e.getId());
      System.out.println("First Name:  " + e.getFirstName());
      System.out.println("Last Name:  " + e.getLastName());
      System.out.println("Salary:  " + e.getSalary());
      System.out.println("Record read Successfully ");
   }
} 

编译和运行 (Compilation and Run)

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

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

您将获得以下结果,这是EMPLOYEE表上的读取操作。

Going to read record.....
ID:  1
First Name:  Zara
Last Name:  Ali
Salary:  5000
Record read Successfully

iBATIS - Stored Procedures

您可以使用iBATIS配置调用存储过程。 首先,让我们了解如何在MySQL中创建存储过程。

我们在MySQL中有以下EMPLOYEE表 -

CREATE TABLE EMPLOYEE (
   id INT NOT NULL auto_increment,
   first_name VARCHAR(20) default NULL,
   last_name  VARCHAR(20) default NULL,
   salary     INT  default NULL,
   PRIMARY KEY (id)
);

让我们在MySQL数据库中创建以下存储过程 -

DELIMITER $$
   DROP PROCEDURE IF EXISTS `testdb`.`getEmp` $$
   CREATE PROCEDURE `testdb`.`getEmp` 
   (IN empid INT)
   BEGIN
      SELECT * FROM EMPLOYEE
      WHERE ID = empid;
   END $$
DELIMITER;

让我们考虑EMPLOYEE表有两条记录如下 -

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

Employee POJO Class

要使用存储过程,您不需要修改Employee.java文件。 让我们保持原样在最后一章。

public class Employee {
   private int id;
   private String first_name; 
   private String last_name;   
   private int salary;  
   /* Define constructors for the Employee class. */
   public Employee() {}
   public Employee(String fname, String lname, int salary) {
      this.first_name = fname;
      this.last_name = lname;
      this.salary = salary;
   }
   /* Here are the required method definitions */
   public int getId() {
      return id;
   }
   public void setId(int id) {
      this.id = id;
   }
   public String getFirstName() {
      return first_name;
   }
   public void setFirstName(String fname) {
      this.first_name = fname;
   }
   public String getLastName() {
      return last_name;
   }
   public void setlastName(String lname) {
      this.last_name = lname;
   }
   public int getSalary() {
      return salary;
   }
   public void setSalary(int salary) {
      this.salary = salary;
   }
} /* End of Employee */

Employee.xml File

在这里,我们将修改Employee.xml以引入 procedure>和 parameterMap>标记。 这里 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 File

此文件具有应用程序级逻辑,可使用ResultMap从Employee表中读取员工的姓名 -

import com.ibatis.common.resources.Resources;
import com.ibatis.sqlmap.client.SqlMapClient;
import com.ibatis.sqlmap.client.SqlMapClientBuilder;
import java.io.*;
import java.sql.SQLException;
import java.util.*;
public class IbatisSP{
   public static void main(String[] args)
   throws IOException,SQLException{
      Reader rd = Resources.getResourceAsReader("SqlMapConfig.xml");
      SqlMapClient smc = SqlMapClientBuilder.buildSqlMapClient(rd);
      int id = 1;
      System.out.println("Going to read employee name.....");
      Employee e = (Employee) smc.queryForObject ("Employee.getEmpInfo", id);
      System.out.println("First Name:  " + e.getFirstName());
      System.out.println("Record name Successfully ");
   }
} 

编译和运行 (Compilation and Run)

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

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

您将得到以下结果:

Going to read record.....
ID:  1
First Name:  Zara
Last Name:  Ali
Salary:  5000
Record read Successfully

iBATIS - Dynamic SQL

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

使用一些额外的标签将所有逻辑放入.XML文件中。 以下是SELECT语句以两种方式工作的示例 -

如果您传递了ID,那么它将返回与该ID相对应的所有记录。

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

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE sqlMap PUBLIC "-//ibatis.apache.org//DTD SQL Map 2.0//EN" "http://ibatis.apache.org/dtd/sql-map-2.dtd">
<sqlMap namespace="Employee">
   <select id="findByID" resultClass="Employee">
      SELECT * FROM EMPLOYEE
      <dynamic prepend="WHERE ">
         <isNull property="id">
            id IS NULL
         </isNull>
         <isNotNull property="id">
            id = #id#
         </isNotNull>
      </dynamic>
   </select>
</sqlMap>

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

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

如果您想要一个查询,我们可以在其中选择一个ID和/或一个Employee的名字,您的SELECT语句将如下所示 -

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

动态SQL示例

以下示例说明如何使用动态SQL编写SELECT语句。 考虑一下,我们在MySQL中有以下EMPLOYEE表 -

CREATE TABLE EMPLOYEE (
   id INT NOT NULL auto_increment,
   first_name VARCHAR(20) default NULL,
   last_name  VARCHAR(20) default NULL,
   salary     INT  default NULL,
   PRIMARY KEY (id)
);

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

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

Employee POJO Class

要执行读操作,让我们在Employee.java中有一个Employee类,如下所示 -

public class Employee {
   private int id;
   private String first_name; 
   private String last_name;   
   private int salary;  
   /* Define constructors for the Employee class. */
   public Employee() {}
   public Employee(String fname, String lname, int salary) {
      this.first_name = fname;
      this.last_name = lname;
      this.salary = salary;
   }
   /* Here are the method definitions */
   public int getId() {
      return id;
   }
   public String getFirstName() {
      return first_name;
   }
   public String getLastName() {
      return last_name;
   }
   public int getSalary() {
      return salary;
   }
} /* End of Employee */

Employee.xml File

要使用iBATIS定义SQL映射语句,我们将在Employee.xml中添加以下修改后的

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE sqlMap PUBLIC "-//ibatis.apache.org//DTD SQL Map 2.0//EN" "http://ibatis.apache.org/dtd/sql-map-2.dtd">
<sqlMap namespace="Employee">
   <select id="findByID" resultClass="Employee">
      SELECT * FROM EMPLOYEE
      <dynamic prepend="WHERE ">
         <isNotNull property="id">
            id = #id#
         </isNotNull>
      </dynamic>
   </select>
</sqlMap>

上面的SELECT语句有两种工作方式 -

  • 如果传递ID,则返回与该ID对应的记录,否则返回所有记录。

IbatisReadDy.java File

此文件具有应用程序级逻辑,用于从Employee表中读取条件记录 -

import com.ibatis.common.resources.Resources;
import com.ibatis.sqlmap.client.SqlMapClient;
import com.ibatis.sqlmap.client.SqlMapClientBuilder;
import java.io.*;
import java.sql.SQLException;
import java.util.*;
public class IbatisReadDy{
   public static void main(String[] args)
   throws IOException,SQLException{
      Reader rd=Resources.getResourceAsReader("SqlMapConfig.xml");
      SqlMapClient smc=SqlMapClientBuilder.buildSqlMapClient(rd);
      /* This would read all records from the Employee table.*/
      System.out.println("Going to read records.....");
      Employee rec = new Employee();
      rec.setId(1);
      List <Employee> ems = (List<Employee>)  
         smc.queryForList("Employee.findByID", rec);
      Employee em = null;
      for (Employee e : ems) {
         System.out.print("  " + e.getId());
         System.out.print("  " + e.getFirstName());
         System.out.print("  " + e.getLastName());
         System.out.print("  " + e.getSalary());
         em = e; 
         System.out.println("");
      }    
      System.out.println("Records Read Successfully ");
   }
} 

编译和运行 (Compilation and Run)

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

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

您将获得以下结果,并且将从EMPLOYEE表中读取记录。

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

通过将null作为smc.queryForList("Employee.findByID", null)传递来尝试上面的示例。

iBATIS OGNL表达式

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

  • if Statement
  • choose, when, otherwise Statement
  • where Statement
  • foreach Statement

if 语句

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

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

此语句提供可选的文本搜索类型的功能。 如果您没有传入标题,则返回所有活动的博客。 但是如果你确实传入一个标题,那么它将寻找具有给定条件的标题。

您可以包含多个if条件,如下所示 -

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

选择,何时以及其他陈述

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

以下示例仅按标题搜索(如果提供了一个),然后仅提供作者(如果提供了一个)。 如果两者都没有提供,它只返回精选博客 -

<select id="findActiveBlogWithTitleLike" parameterType="Blog" resultType="Blog">
   SELECT * FROM BLOG
   WHERE state = 'ACTIVE.
   <choose>
      <when test="title != null">
         AND title like #{title}
      </when>
      <when test="author != null and author.name != null">
         AND author like #{author}
      </when>
      <otherwise>
         AND featured = 1
      </otherwise>
   </choose>
</select>

where 语句

看看我们之前的示例,看看如果没有满足任何条件会发生什么。 你最终得到一个看起来像这样的SQL -

SELECT * FROM BLOG
WHERE

这会失败,但iBATIS有一个简单的解决方案,一个简单的改变,一切正常 -

<select id="findActiveBlogLike" parameterType="Blog" resultType="Blog">
   SELECT * FROM BLOG
   <where>
      <if test="state != null">
         state = #{state}
      </if>
      <if test="title != null">
         AND title like #{title}
      </if>
      <if test="author != null>
         AND author like #{author}
      </if>
   </where>
</select>

仅当包含的标记返回任何内容时, where元素才会插入WHERE 。 此外,如果该内容以ANDOR,开头OR,则它知道将其剥离。

foreach 语句

foreach元素允许您指定集合并声明可以在元素主体内使用的项和索引变量。

它还允许您指定开始和结束字符串,并添加一个分隔符以放置在迭代之间。 您可以按如下方式构建IN条件 -

<select id="selectPostIn" resultType="domain.blog.Post">
   SELECT *
   FROM POST P
   WHERE ID in
   <foreach item="item" index="index" collection="list"
      open="(" separator="," close=")">
      #{item}
   </foreach>
</select>

iBATIS - Debugging

在使用iBATIS时,可以轻松调试程序。 iBATIS具有内置日志记录支持,它可与以下日志记录库一起使用,并按此顺序搜索它们。

  • Jakarta Commons Logging(JCL)。
  • Log4J
  • JDK日志记录

您可以使用上面列出的任何库以及iBATIS。

使用Log4J进行调试

假设您要使用Log4J进行日志记录。 在继续之前,您需要交叉检查以下几点 -

  • Log4J JAR文件(log4j- {version} .jar)应该在CLASSPATH中。
  • 您在CLASSPATH中有log4j.properties。

以下是log4j.properties文件。 请注意,某些行已注释掉。 如果需要其他调试信息,可以取消注释它们。

# Global logging configuration
log4j.rootLogger = ERROR, stdout
log4j.logger.com.ibatis = DEBUG
# shows SQL of prepared statements
#log4j.logger.java.sql.Connection = DEBUG
# shows parameters inserted into prepared statements
#log4j.logger.java.sql.PreparedStatement = DEBUG
# shows query results
#log4j.logger.java.sql.ResultSet = DEBUG
#log4j.logger.java.sql.Statement = DEBUG
# Console output
log4j.appender.stdout = org.apache.log4j.ConsoleAppender
log4j.appender.stdout.layout = org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern = %5p [%t] − %m%n

您可以从Apaches站点 - Log4J文档中找到Log4J的完整文档。

iBATIS调试示例

以下Java类是一个非常简单的示例,它初始化然后将Log4J日志库用于Java应用程序。 我们将使用CLASSPATH中的上述属性文件。

import org.apache.log4j.Logger;
import com.ibatis.common.resources.Resources;
import com.ibatis.sqlmap.client.SqlMapClient;
import com.ibatis.sqlmap.client.SqlMapClientBuilder;
import java.io.*;
import java.sql.SQLException;
import java.util.*;
public class IbatisUpdate{
   static Logger log = Logger.getLogger(IbatisUpdate.class.getName());
   public static void main(String[] args)
   throws IOException,SQLException{
      Reader rd = Resources.getResourceAsReader("SqlMapConfig.xml");
      SqlMapClient smc = SqlMapClientBuilder.buildSqlMapClient(rd);
      /* This would insert one record in Employee table. */
      log.info("Going to update record.....");
      Employee rec = new Employee();
      rec.setId(1);
      rec.setFirstName( "Roma");
      smc.update("Employee.update", rec );
      log.info("Record updated Successfully ");
      log.debug("Going to read records.....");
      List <Employee> ems = (List<Employee>) 
         smc.queryForList("Employee.getAll", null);
      Employee em = null;
      for (Employee e : ems) {
         System.out.print("  " + e.getId());
         System.out.print("  " + e.getFirstName());
         System.out.print("  " + e.getLastName());
         System.out.print("  " + e.getSalary());
         em = e;
         System.out.println("");
      }
      log.debug("Records Read Successfully ");
   }
}

编译和运行 (Compilation and Run)

首先,确保在继续编译和执行之前适当地设置了PATH和CLASSPATH。

  • 创建Employee.xml,如上所示。
  • 如上所示创建Employee.java并编译它。
  • 如上所示创建IbatisUpdate.java并进行编译。
  • 创建log4j.properties,如上所示。
  • 执行IbatisUpdate二进制文件来运行程序。

你会得到以下结果。 记录将在EMPLOYEE表中更新,之后,将从EMPLOYEE表中读取相同的记录。

DEBUG [main] - Created connection 28405330.
DEBUG [main] - Returned connection 28405330 to pool.
DEBUG [main] - Checked out connection 28405330 from pool.
DEBUG [main] - Returned connection 28405330 to pool.
   1  Roma  Ali  5000
   2  Zara  Ali  5000
   3  Zara  Ali  5000

调试方法

在上面的示例中,我们仅使用了info()方法,但您可以根据自己的要求使用以下任何方法 -

public void trace(Object message);
public void debug(Object message);
public void info(Object message);
public void warn(Object message);
public void error(Object message);
public void fatal(Object message);

iBATIS - Hibernate

iBATIS和Hibernate之间存在重大差异。 鉴于其特定领域,这两种解决方案都运行良好。 建议使用iBATIS -

  • 您想创建自己的SQL,并且愿意维护它们。
  • 您的环境由关系数据模型驱动。
  • 您必须处理现有的和复杂的模式。

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

iBATIS和Hibernate之间的区别

Hibernate和iBATIS都是业界可用的开源对象关系映射(ORM)工具。 使用这些工具取决于您使用它们的上下文。

下表突出显示了iBATIS和Hibernate之间的区别 -

iBATIS的 过冬
iBATIS更简单。 它的封装尺寸要小得多。 Hibernate为您生成SQL,这意味着您不必花时间生成SQL。
iBATIS非常灵活。 它提供更快的开发时间。 Hibernate具有高度可扩展性。 它提供了更高级的缓存。
iBATIS使用可能依赖于数据库的SQL。 Hibernate使用相对独立于数据库的HQL。 在Hibernate中更改db更容易。
iBatis将ResultSet从JDBC API映射到POJO Objets,因此您不必关心表结构。 Hibernate将Java POJO对象映射到数据库表。
在iBATIS中使用存储过程非常容易。 在Hibernate中使用存储过程有点困难。

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

iBATOR - Introduction

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

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

  • SqlMap XML文件
  • 用于匹配表的主键和字段的Java类
  • DAO使用上述对象的类(可选)

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

下载iBATOR

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

生成配置文件

要运行iBATOR,请按照以下步骤操作 -

Step 1

适当地创建和填充配置文件ibatorConfig.xml。 至少,您必须指定 -

  • 《jdbcConnection》元素,用于指定如何连接到目标数据库。

  • 《javaModelGenerator》元素,用于为生成的Java模型对象指定目标包和目标项目。

  • 一个《sqlMapGenerator》元素,用于为生成的SQL映射文件指定目标包和目标项目。

  • 《daoGenerator》元素,用于为生成的DAO接口和类指定目标包和目标项目(如果不希望生成DAO,则可以省略“daoGenerator”元素)。

  • 至少有一个数据库《table》元素

NOTE −有关iBATOR配置文件的示例,请参阅XML配置文件参考页面。

Step 2

将文件保存在方便的位置,例如:\temp\ibatorConfig.xml。

Step 3

现在从命令行运行iBATOR,如下所示 -

java -jar abator.jar -configfile \temp\abatorConfig.xml -overwrite

它将告诉iBATOR使用您的配置文件运行。 它还将告诉iBATOR覆盖任何具有相同名称的现有Java文件。 如果要保存任何现有Java文件,请省略−overwrite参数。

如果存在冲突,iBATOR会使用唯一名称保存新生成的文件。

运行iBATOR后,您需要创建或修改标准iBATIS配置文件以使用新生成的代码。 这将在下一节中解释。

运行iBATOR后的任务

运行iBATOR后,您需要创建或修改其他iBATIS配置工件。 主要任务如下 -

  • 创建或修改SqlMapConfig.xml文件。
  • 创建或修改dao.xml文件(仅当您使用的是iBATIS DAO框架时)。

每项任务详述如下 -

更新SqlMapConfig.xml文件

iBATIS使用XML文件(通常名为SqlMapConfig.xml)来指定iBATIS会话中使用的数据库连接,事务管理方案和SQL映射XML文件的信息。

iBATOR无法为您创建此文件,因为它对您的执行环境一无所知。 但是,此文件中的某些项目直接与iBATOR生成的项目相关。

配置文件中的iBATOR特定需求如下 -

  • 必须启用语句名称空间。
  • 必须列出iBATOR生成的SQL Map XML文件。

例如,假设iBATOR已生成名为MyTable_SqlMap.xml的SQL Map XML文件,并且该文件已放置在项目的test.xml包中。 SqlMapConfig.xml文件应该包含以下条目 -

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE sqlMapConfig PUBLIC "-//ibatis.apache.org//DTD SQL Map Config 2.0//EN" "http://ibatis.apache.org/dtd/sql-map-config-2.dtd">
<sqlMapConfig>
   <!-- Statement namespaces are required for Abator -->
   <settings useStatementNamespaces="true" />
   <!-- Setup the transaction manager and data source that are
   appropriate for your environment
   -->
   <transactionManager type="...">
      <dataSource type="...">
      </dataSource>
   </transactionManager>
   <!-- SQL Map XML files should be listed here -->
   <sqlMap resource="test/xml/MyTable_SqlMap.xml" />
</sqlMapConfig>

如果有多个SQL Map XML文件(非常常见),那么可以在元素之后使用重复的元素以任何顺序列出文件。

更新dao.xml文件

iBATIS DAO框架由通常称为dao.xml的xml文件配置。

iBATIS DAO框架使用此文件来控制DAO的数据库连接信息,还列出DAO实现类和DAO接口。

在此文件中,您应指定SqlMapConfig.xml文件的路径,以及所有iBATOR生成的DAO接口和实现类。

例如,假设iBATOR已生成一个名为MyTableDAO的DAO接口和一个名为MyTableDAOImpl的实现类,并且这些文件已放置在项目的test.dao包中。

dao.xml文件应该包含以下条目 -

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE daoConfig PUBLIC "-//ibatis.apache.org//DTD DAO Configuration 2.0//EN" "http://ibatis.apache.org/dtd/dao-2.dtd">
<daoConfig>
   <context>
      <transactionManager type="SQLMAP">
         <property name="SqlMapConfigResource" value="test/SqlMapConfig.xml"/>
      </transactionManager>
      <!-- DAO interfaces and implementations should be listed here -->
      <dao interface="test.dao.MyTableDAO" implementation="test.dao.MyTableDAOImpl" />
   </context>
</daoConfig>

NOTE −仅当您为iBATIS DAO框架生成DAO时,才需要执行此步骤。

↑回到顶部↑
WIKI教程 @2018