iBATIS - Guia rápido

iBATIS é uma estrutura de persistência que automatiza o mapeamento entre bancos de dados SQL e objetos em Java, .NET e Ruby on Rails. Os mapeamentos são desacoplados da lógica do aplicativo, empacotando as instruções SQL em arquivos de configuração XML.

iBATIS é uma estrutura leve e API de persistência boa para POJOs persistentes (Plain Old Java Objects).

O iBATIS é conhecido como mapeador de dados e se encarrega de mapear os parâmetros e resultados entre as propriedades da classe e as colunas da tabela do banco de dados.

Uma diferença significativa entre o iBATIS e outros frameworks de persistência, como o Hibernate, é que o iBATIS enfatiza o uso de SQL, enquanto outros frameworks normalmente usam uma linguagem de consulta personalizada, como a Hibernate Query Language (HQL) ou Enterprise JavaBeans Query Language (EJB QL).

Filosofias de design iBATIS

O iBATIS vem com as seguintes filosofias de design -

  • Simplicity − O iBATIS é amplamente considerado um dos frameworks de persistência mais simples disponíveis atualmente.

  • Fast Development − O iBATIS faz tudo o que pode para facilitar o desenvolvimento hiper-rápido.

  • Portability − O iBATIS pode ser implementado para quase qualquer linguagem ou plataforma, como Java, Ruby e C # para Microsoft .NET.

  • Independent Interfaces − O iBATIS fornece interfaces independentes de banco de dados e APIs que ajudam o restante do aplicativo a permanecer independente de quaisquer recursos relacionados à persistência.

  • Open source − O iBATIS é gratuito e um software de código aberto.

Vantagens do iBATIS

iBATIS oferece as seguintes vantagens -

  • Supports stored procedures − O iBATIS encapsula SQL na forma de procedimentos armazenados para que a lógica de negócios seja mantida fora do banco de dados e o aplicativo seja mais fácil de implantar e testar, além de ser mais portátil.

  • Supports inline SQL − Nenhum pré-compilador é necessário e você tem acesso total a todos os recursos do SQL.

  • Supports dynamic SQL − O iBATIS fornece recursos para construir consultas SQL dinamicamente com base em parâmetros.

  • Supports O/RM − O iBATIS suporta muitos dos mesmos recursos de uma ferramenta O / RM, como carregamento lento, busca de junção, armazenamento em cache, geração de código em tempo de execução e herança

O iBATIS faz uso da linguagem de programação JAVA durante o desenvolvimento de aplicativos orientados a banco de dados. Antes de prosseguir, certifique-se de compreender os fundamentos da programação procedural e orientada a objetos - estruturas de controle, estruturas de dados e variáveis, classes, objetos, etc.

Para entender JAVA em detalhes, você pode consultar nosso Tutorial JAVA .

Você teria que configurar um ambiente adequado para iBATIS antes de iniciar o trabalho de desenvolvimento real. Este capítulo explica como configurar um ambiente de trabalho para iBATIS.

Instalação iBATIS

Execute as seguintes etapas simples para instalar o iBATIS em sua máquina Linux -

  • Baixe a versão mais recente do iBATIS em Baixar iBATIS .

  • Descompacte o arquivo baixado para extrair o arquivo .jar do pacote e mantê-lo no diretório lib apropriado.

  • Defina as variáveis ​​PATH e CLASSPATH no (s) arquivo (s) .jar extraído (s) apropriadamente.

$ 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

Configuração de banco de dados

Crie uma tabela EMPLOYEE em qualquer banco de dados MySQL usando a seguinte sintaxe -

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

Crie SqlMapConfig.xml

Considere o seguinte -

  • Vamos usar JDBC para acessar o banco de dados testdb.

  • O driver JDBC para MySQL é "com.mysql.jdbc.Driver".

  • O URL de conexão é "jdbc: mysql: // localhost: 3306 / testdb".

  • Usaríamos nome de usuário e senha como "root" e "root" respectivamente.

  • Nossos mapeamentos de instrução sql para todas as operações seriam descritos em "Employee.xml".

Com base nas suposições acima, temos que criar um arquivo de configuração XML com o nome SqlMapConfig.xmlcom o seguinte conteúdo. É aqui que você precisa fornecer todas as configurações necessárias para iBatis -

É importante que os arquivos SqlMapConfig.xml e Employee.xml estejam presentes no caminho da classe. Por enquanto, manteríamos o arquivo Employee.xml vazio e cobriríamos seu conteúdo nos capítulos subsequentes.

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

Você também pode definir as seguintes propriedades opcionais usando o arquivo 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"/>

Para executar qualquer operação Criar, Ler, Atualizar e Excluir (CRUD) usando iBATIS, você precisaria criar uma classe Plain Old Java Objects (POJO) correspondente à tabela. Esta classe descreve os objetos que "modelarão" as linhas da tabela do banco de dados.

A classe POJO teria implementação para todos os métodos necessários para executar as operações desejadas.

Vamos supor que temos a seguinte tabela EMPLOYEE no 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)
);

Classe POJO do funcionário

Criaríamos uma classe Employee no arquivo Employee.java da seguinte maneira -

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

Você pode definir métodos para definir campos individuais na tabela. O próximo capítulo explica como obter os valores de campos individuais.

Arquivo Employee.xml

Para definir a instrução de mapeamento SQL usando iBATIS, usaríamos a tag <inserir> e dentro dessa definição de tag, definiríamos um "id" que será usado no arquivo IbatisInsert.java para executar a consulta SQL INSERT no banco de dados.

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

Aqui parameterClass −pode receber um valor como string, int, float, double ou qualquer objeto de classe com base no requisito. Neste exemplo, passaríamos o objeto Employee como um parâmetro ao chamar o método de inserção da classe SqlMap.

Se a sua tabela de banco de dados usa uma coluna IDENTITY, AUTO_INCREMENT ou SERIAL ou você definiu um SEQUENCE / GENERATOR, você pode usar o elemento <selectKey> em uma instrução <inserir> para usar ou retornar aquele valor gerado pelo banco de dados.

Arquivo IbatisInsert.java

Este arquivo teria lógica de nível de aplicativo para inserir registros na tabela 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 ");
   }
}

Compilação e execução

Aqui estão as etapas para compilar e executar o software mencionado acima. Certifique-se de ter definido PATH e CLASSPATH apropriadamente antes de prosseguir com a compilação e execução.

  • Crie Employee.xml conforme mostrado acima.
  • Crie Employee.java conforme mostrado acima e compile-o.
  • Crie IbatisInsert.java conforme mostrado acima e compile-o.
  • Execute o binário IbatisInsert para executar o programa.

Você obteria o seguinte resultado e um registro seria criado na tabela EMPLOYEE.

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

Se você verificar a tabela EMPLOYEE, ela deve exibir o seguinte resultado -

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

Discutimos, no último capítulo, como realizar a operação CREATE em uma tabela usando iBATIS. Este capítulo explica como ler uma tabela usando iBATIS.

Temos a seguinte tabela EMPLOYEE no 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)
);

Esta tabela possui apenas um registro da seguinte forma -

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

Classe POJO do funcionário

Para realizar a operação de leitura, modificaríamos a classe Employee em Employee.java da seguinte maneira -

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

Arquivo Employee.xml

Para definir a instrução de mapeamento SQL usando iBATIS, adicionaríamos a tag <select> no arquivo Employee.xml e dentro dessa definição de tag, definiríamos um "id" que será usado no arquivo IbatisRead.java para executar a consulta SQL SELECT no banco de dados.

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

Aqui não usamos a cláusula WHERE com a instrução SQL SELECT. Demonstraríamos, no próximo capítulo, como você pode usar a cláusula WHERE com a instrução SELECT e como você pode passar valores para essa cláusula WHERE.

Arquivo IbatisRead.java

Este arquivo tem lógica de nível de aplicativo para ler registros da tabela de funcionários -

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

Compilação e execução

Aqui estão as etapas para compilar e executar o software mencionado acima. Certifique-se de ter definido PATH e CLASSPATH apropriadamente antes de prosseguir com a compilação e execução.

  • Crie Employee.xml conforme mostrado acima.
  • Crie Employee.java conforme mostrado acima e compile-o.
  • Crie IbatisRead.java conforme mostrado acima e compile-o.
  • Execute o binário IbatisRead para executar o programa.

Você obteria o seguinte resultado, e um registro seria lido da tabela EMPLOYEE da seguinte forma -

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

Discutimos, no último capítulo, como realizar a operação READ em uma tabela usando iBATIS. Este capítulo explica como você pode atualizar registros em uma tabela usando iBATIS.

Temos a seguinte tabela EMPLOYEE no 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)
);

Esta tabela possui apenas um registro da seguinte forma -

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

Classe POJO do funcionário

Para realizar a operação udpate, você precisa modificar o arquivo Employee.java da seguinte forma -

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

Arquivo Employee.xml

Para definir a instrução de mapeamento SQL usando iBATIS, adicionaríamos a tag <update> em Employee.xml e dentro dessa definição de tag, definiríamos um "id" que será usado no arquivo IbatisUpdate.java para executar a consulta SQL UPDATE no banco de dados.

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

Arquivo IbatisUpdate.java

Este arquivo tem lógica de nível de aplicativo para atualizar registros na tabela Funcionário -

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

Compilação e execução

Aqui estão as etapas para compilar e executar o software mencionado acima. Certifique-se de ter definido PATH e CLASSPATH apropriadamente antes de prosseguir com a compilação e execução.

  • Crie Employee.xml conforme mostrado acima.
  • Crie Employee.java conforme mostrado acima e compile-o.
  • Crie IbatisUpdate.java conforme mostrado acima e compile-o.
  • Execute o binário IbatisUpdate para executar o programa.

Você obteria o seguinte resultado e um registro seria atualizado na tabela EMPLOYEE e, posteriormente, o mesmo registro seria lido na tabela EMPLOYEE.

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

Este capítulo descreve como excluir registros de uma tabela usando iBATIS.

Temos a seguinte tabela EMPLOYEE no 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)
);

Suponha que esta tabela tenha dois registros, como segue -

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)

Classe POJO do funcionário

Para executar a operação de exclusão, você não precisa modificar o arquivo Employee.java. Vamos manter como estava no capítulo anterior.

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

Arquivo Employee.xml

Para definir a instrução de mapeamento SQL usando iBATIS, adicionaríamos a tag <delete> em Employee.xml e dentro desta definição de tag, definiríamos um "id" que será usado no arquivo IbatisDelete.java para executar a consulta SQL DELETE no banco de dados.

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

Arquivo IbatisDelete.java

Este arquivo tem lógica de nível de aplicativo para excluir registros da tabela de funcionários -

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

Compilação e execução

Aqui estão as etapas para compilar e executar o software mencionado acima. Certifique-se de ter definido PATH e CLASSPATH apropriadamente antes de prosseguir com a compilação e execução.

  • Crie Employee.xml conforme mostrado acima.
  • Crie Employee.java conforme mostrado acima e compile-o.
  • Crie IbatisDelete.java conforme mostrado acima e compile-o.
  • Execute o binário IbatisDelete para executar o programa.

Você obteria o seguinte resultado e um registro com ID = 1 seria excluído da tabela EMPLOYEE e o restante dos registros seria lido.

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

O elemento resultMap é o elemento mais importante e poderoso no iBATIS. Você pode reduzir em até 90% a codificação JDBC usando iBATIS ResultMap e, em alguns casos, permite que você faça coisas que o JDBC nem mesmo suporta.

O design de ResultMaps é tal que instruções simples não requerem mapeamentos explícitos de resultados, e instruções mais complexas não requerem mais do que o absolutamente necessário para descrever os relacionamentos.

Este capítulo fornece apenas uma introdução simples aos ResultMaps do iBATIS.

Temos a seguinte tabela EMPLOYEE no 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)
);

Esta tabela possui dois registros, como segue -

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)

Classe POJO do funcionário

Para usar o iBATIS ResultMap, você não precisa modificar o arquivo Employee.java. Vamos manter como estava no capítulo anterior.

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

Arquivo Employee.xml

Aqui, modificaríamos Employee.xml para introduzir a tag <resultMap> </resultMap>. Esta tag teria um id que é necessário para executar este resultMap no atributo resultMap de nossa tag <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">

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

Arquivo IbatisResultMap.java

Este arquivo tem lógica de nível de aplicativo para ler registros da tabela Employee usando ResultMap -

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

Compilação e execução

Aqui estão as etapas para compilar e executar o software mencionado acima. Certifique-se de ter definido PATH e CLASSPATH apropriadamente antes de prosseguir com a compilação e execução.

  • Crie Employee.xml conforme mostrado acima.
  • Crie Employee.java conforme mostrado acima e compile-o.
  • Crie IbatisResultMap.java conforme mostrado acima e compile-o.
  • Execute o binário IbatisResultMap para executar o programa.

Você obteria o seguinte resultado, que é uma operação de leitura na tabela EMPLOYEE.

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

Você pode chamar um procedimento armazenado usando a configuração iBATIS. Em primeiro lugar, vamos entender como criar um procedimento armazenado no MySQL.

Temos a seguinte tabela EMPLOYEE no 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)
);

Vamos criar o seguinte procedimento armazenado no banco de dados MySQL -

DELIMITER $$

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

DELIMITER;

Vamos considerar que a tabela EMPLOYEE tem dois registros da seguinte maneira -

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)

Classe POJO do funcionário

Para usar o procedimento armazenado, você não precisa modificar o arquivo Employee.java. Vamos manter como estava no capítulo anterior.

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

Arquivo Employee.xml

Aqui, modificaríamos Employee.xml para introduzir as tags <procedure> </procedure> e <parameterMap> </parameterMap>. Aqui, a tag <procedure> </procedure> teria um id que usaríamos em nosso aplicativo para chamar o procedimento armazenado.

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

Arquivo IbatisSP.java

Este arquivo tem lógica de nível de aplicativo para ler os nomes dos funcionários da tabela Employee usando ResultMap -

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

Compilação e execução

Aqui estão as etapas para compilar e executar o software mencionado acima. Certifique-se de ter definido PATH e CLASSPATH apropriadamente antes de prosseguir com a compilação e execução.

  • Crie Employee.xml conforme mostrado acima.
  • Crie Employee.java conforme mostrado acima e compile-o.
  • Crie IbatisSP.java conforme mostrado acima e compile-o.
  • Execute o binário do IbatisSP para executar o programa.

Você obteria o seguinte resultado:

Going to read employee name.....
First Name:  Zara
Record name Successfully

SQL dinâmico é um recurso muito poderoso do iBATIS. Às vezes, você precisa alterar o critério da cláusula WHERE com base no estado do seu objeto de parâmetro. Em tais situações, o iBATIS fornece um conjunto de tags SQL dinâmicas que podem ser usadas em instruções mapeadas para aprimorar a capacidade de reutilização e flexibilidade do SQL.

Toda a lógica é colocada em um arquivo .XML usando algumas tags adicionais. A seguir está um exemplo em que a instrução SELECT funcionaria de duas maneiras -

Se você passar um ID, ele retornará todos os registros correspondentes a esse ID.

Caso contrário, ele retornaria todos os registros onde o ID do funcionário está definido como 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>

Você pode verificar uma condição usando a tag <isNotEmpty> da seguinte maneira. Aqui, uma condição seria adicionada apenas quando uma propriedade passada não estivesse vazia.

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

Se você quiser uma consulta em que possamos selecionar um id e / ou o primeiro nome de um funcionário, sua instrução SELECT seria a seguinte -

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

Exemplo de SQL Dinâmico

O exemplo a seguir mostra como você pode escrever uma instrução SELECT com SQL dinâmica. Considere, temos a seguinte tabela EMPLOYEE no 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)
);

Vamos supor que esta tabela tenha apenas um registro da seguinte forma -

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

Classe POJO do funcionário

Para realizar a operação de leitura, vamos ter uma classe Employee em Employee.java da seguinte maneira -

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

Arquivo Employee.xml

Para definir a instrução de mapeamento SQL usando iBATIS, adicionaríamos a seguinte tag <select> modificada em Employee.xml e dentro dessa definição de tag, definiríamos um "id" que será usado em IbatisReadDy.java para executar a consulta SQL SELECT dinâmica em base de dados.

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

A instrução SELECT acima funcionaria de duas maneiras -

  • Se você passar um ID, ele retorna os registros correspondentes a esse ID. Caso contrário, ele retorna todos os registros.

Arquivo IbatisReadDy.java

Este arquivo tem lógica de nível de aplicativo para ler registros condicionais da tabela 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 ");
   }
}

Compilação e execução

Aqui estão as etapas para compilar e executar o software mencionado acima. Certifique-se de ter definido PATH e CLASSPATH apropriadamente antes de prosseguir com a compilação e execução.

  • Crie Employee.xml conforme mostrado acima.
  • Crie Employee.java conforme mostrado acima e compile-o.
  • Crie IbatisReadDy.java conforme mostrado acima e compile-o.
  • Execute o binário IbatisReadDy para executar o programa.

Você obteria o seguinte resultado e um registro seria lido da tabela EMPLOYEE.

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

Experimente o exemplo acima passando nullcomo smc.queryForList ("Employee.findByID", null) .

Expressões iBATIS OGNL

O iBATIS fornece expressões baseadas em OGNL poderosas para eliminar a maioria dos outros elementos.

  • declaração if
  • escolher, quando, de outra forma Declaração
  • onde declaração
  • declaração foreach

A declaração if

A coisa mais comum a se fazer em SQL dinâmico é incluir condicionalmente uma parte de uma cláusula where. Por exemplo -

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

Esta declaração fornece um tipo de funcionalidade de pesquisa de texto opcional. Se você não transmitir nenhum título, todos os blogs ativos serão retornados. Mas se você passar em um título, ele irá procurar um título com o dadolike doença.

Você pode incluir vários if condições como segue -

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

A escolha, quando e outras declarações

iBATIS oferece um chooseelemento que é semelhante à instrução switch do Java. Ajuda a escolher apenas um caso entre muitas opções.

O exemplo a seguir pesquisaria apenas por título, se fornecido, e apenas por autor, se fornecido. Se nenhum dos dois for fornecido, ele retornará apenas blogs em destaque -

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

A declaração onde

Dê uma olhada em nossos exemplos anteriores para ver o que acontece se nenhuma das condições for atendida. Você acabaria com um SQL parecido com este -

SELECT * FROM BLOG
WHERE

Isso iria falhar, mas o iBATIS tem uma solução simples com uma mudança simples, tudo funciona bem -

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

o whereelemento insere um WHERE somente quando as tags que o contêm retornam qualquer conteúdo. Além disso, se esse conteúdo começar com AND ou OR, ele sabe como removê-lo.

A declaração foreach

O elemento foreach permite que você especifique uma coleção e declare as variáveis ​​de item e índice que podem ser usadas dentro do corpo do elemento.

Ele também permite que você especifique strings de abertura e fechamento e adicione um separador para colocar entre as iterações. Você pode construir umIN condição da seguinte forma -

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

É fácil depurar seu programa enquanto trabalha com o iBATIS. O iBATIS tem suporte de registro embutido e funciona com as seguintes bibliotecas de registro e as procura nesta ordem.

  • Jakarta Commons Logging (JCL).
  • Log4J
  • Registro JDK

Você pode usar qualquer uma das bibliotecas listadas acima junto com o iBATIS.

Depurando com Log4J

Supondo que você usará Log4J para registro. Antes de prosseguir, você precisa verificar os seguintes pontos -

  • O arquivo Log4J JAR (log4j- {versão} .jar) deve estar no CLASSPATH.
  • Você tem log4j.properties disponível no CLASSPATH.

A seguir está o arquivo log4j.properties. Observe que algumas das linhas estão comentadas. Você pode removê-los se precisar de informações adicionais de depuração.

# 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

Você pode encontrar a documentação completa do Log4J no site da Apaches - Log4J Documentation .

Exemplo de depuração iBATIS

A seguinte classe Java é um exemplo muito simples que inicializa e, em seguida, usa a biblioteca de registro Log4J para aplicativos Java. Usaríamos o arquivo de propriedades mencionado acima, que se encontra em 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 ");
   }
}

Compilação e execução

Em primeiro lugar, certifique-se de definir PATH e CLASSPATH apropriadamente antes de prosseguir com a compilação e execução.

  • Crie Employee.xml conforme mostrado acima.
  • Crie Employee.java conforme mostrado acima e compile-o.
  • Crie IbatisUpdate.java conforme mostrado acima e compile-o.
  • Crie log4j.properties conforme mostrado acima.
  • Execute o binário IbatisUpdate para executar o programa.

Você obteria o seguinte resultado. Um registro seria atualizado na tabela EMPLOYEE e posteriormente, o mesmo registro seria lido da tabela 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

Métodos de depuração

No exemplo acima, usamos apenas info() método, no entanto, você pode usar qualquer um dos seguintes métodos de acordo com seus requisitos -

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

Existem grandes diferenças entre o iBATIS e o Hibernate. Ambas as soluções funcionam bem, dado seu domínio específico. iBATIS é sugerido no caso -

  • Você deseja criar seus próprios SQL e está disposto a mantê-los.
  • Seu ambiente é orientado por um modelo de dados relacional.
  • Você tem que trabalhar em esquemas existentes e complexos.

Use o Hibernate se o ambiente for orientado por modelo de objeto e precisar gerar SQL automaticamente.

Diferença entre iBATIS e Hibernate

Tanto o Hibernate quanto o iBATIS são ferramentas de Mapeamento Relacional de Objetos (ORM) de código aberto disponíveis na indústria. O uso de cada uma dessas ferramentas depende do contexto em que você as está usando.

A tabela a seguir destaca as diferenças entre iBATIS e Hibernate -

iBATIS Hibernar
iBATIS é mais simples. Ele vem em um tamanho de pacote muito menor. O Hibernate gera SQL para você, o que significa que você não precisa perder tempo gerando SQL.
O iBATIS é flexível. Ele oferece um tempo de desenvolvimento mais rápido. O Hibernate é altamente escalonável. Ele fornece um cache muito mais avançado.
O iBATIS usa SQL que pode ser dependente do banco de dados. O Hibernate usa HQL, que é relativamente independente de bancos de dados. É mais fácil alterar o banco de dados no Hibernate.
iBatis mapeia o ResultSet da API JDBC para seus objetos POJO, então você não precisa se preocupar com as estruturas da tabela. O Hibernate mapeia seus objetos Java POJO para as tabelas do banco de dados.
É muito fácil usar o procedimento armazenado no iBATIS. O uso de stored procedures é um pouco difícil no Hibernate.

Tanto o Hibernate quanto o iBATIS recebem um bom suporte do framework SPRING, então não deve ser um problema escolher um deles.

iBATOR é um gerador de código para iBATIS. O iBATOR examina uma ou mais tabelas do banco de dados e gera artefatos iBATIS que podem ser usados ​​para acessar as tabelas.

Posteriormente, você pode escrever seu código SQL personalizado ou procedimento armazenado para atender aos seus requisitos. O iBATOR gera os seguintes artefatos -

  • Arquivos XML SqlMap
  • Classes Java para corresponder à chave primária e aos campos da (s) tabela (s)
  • Classes DAO que usam os objetos acima (opcional)

O iBATOR pode ser executado como um arquivo JAR autônomo, ou como uma tarefa Ant, ou como um plugin do Eclipse. Este tutorial descreve a maneira mais simples de gerar arquivos de configuração iBATIS a partir da linha de comando.

Baixar iBATOR

Baixe o JAR independente se estiver usando um IDE diferente do Eclipse. O JAR autônomo inclui uma tarefa Ant para executar o iBATOR ou você pode executar o iBATOR a partir da linha de comando do código Java.

  • Você pode baixar o arquivo zip em Baixar iBATOR .

  • Você pode verificar a documentação online - Documentação iBATOR .

Gerando arquivo de configuração

Para executar o iBATOR, siga estas etapas -

Passo 1

Crie e preencha um arquivo de configuração ibatorConfig.xml apropriadamente. No mínimo, você deve especificar -

  • UMA <jdbcConnection> elemento para especificar como se conectar ao banco de dados de destino.

  • UMA <javaModelGenerator> elemento para especificar o pacote de destino e o projeto de destino para os objetos de modelo Java gerados.

  • UMA <sqlMapGenerator> elemento para especificar o pacote de destino e o projeto de destino para os arquivos de mapa SQL gerados.

  • UMA <daoGenerator> elemento para especificar o pacote de destino e o projeto de destino para as interfaces e classes DAO geradas (você pode omitir o elemento <daoGenerator> se não desejar gerar DAOs).

  • Pelo menos um banco de dados <table> elemento

NOTE −Consulte a página XML Configuration File Reference para obter um exemplo de arquivo de configuração iBATOR.

Passo 2

Salve o arquivo em um local conveniente, por exemplo, em: \ temp \ ibatorConfig.xml.

etapa 3

Agora execute o iBATOR a partir da linha de comando da seguinte maneira -

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

Ele dirá ao iBATOR para rodar usando seu arquivo de configuração. Também dirá ao iBATOR para sobrescrever todos os arquivos Java existentes com o mesmo nome. Se você deseja salvar qualquer arquivo Java existente, omita o−overwrite parâmetro.

Se houver um conflito, o iBATOR salva o arquivo recém-gerado com um nome exclusivo.

Depois de executar o iBATOR, você precisa criar ou modificar os arquivos de configuração iBATIS padrão para usar o código recém-gerado. Isso é explicado na próxima sessão.

Tarefas após executar o iBATOR

Depois de executar o iBATOR, você precisa criar ou modificar outros artefatos de configuração do iBATIS. As principais tarefas são as seguintes -

  • Crie ou modifique o arquivo SqlMapConfig.xml.
  • Crie ou modifique o arquivo dao.xml (somente se você estiver usando o iBATIS DAO Framework).

Cada tarefa é descrita em detalhes abaixo -

Atualizando o arquivo SqlMapConfig.xml

O iBATIS usa um arquivo XML, comumente denominado SqlMapConfig.xml, para especificar informações para uma conexão de banco de dados, um esquema de gerenciamento de transações e arquivos XML de mapa SQL que são usados ​​em uma sessão iBATIS.

O iBATOR não pode criar este arquivo para você porque ele não sabe nada sobre o seu ambiente de execução. No entanto, alguns dos itens neste arquivo estão diretamente relacionados aos itens gerados pelo iBATOR.

As necessidades específicas do iBATOR no arquivo de configuração são as seguintes -

  • Os namespaces de instrução devem ser ativados.
  • Os arquivos XML de mapas SQL gerados pelo iBATOR devem ser listados.

Por exemplo, suponha que o iBATOR tenha gerado um arquivo XML de Mapa SQL chamado MyTable_SqlMap.xml e que o arquivo foi colocado no pacote test.xml do seu projeto. O arquivo SqlMapConfig.xml deve ter essas entradas -

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

Se houver mais de um arquivo XML de Mapa SQL (como é bastante comum), os arquivos podem ser listados em qualquer ordem com elementos <sqlMap> repetidos após o elemento <transactionManager>.

Atualizando o arquivo dao.xml

A estrutura iBATIS DAO é configurada por um arquivo xml comumente chamado dao.xml.

A estrutura iBATIS DAO usa esse arquivo para controlar as informações de conexão do banco de dados para DAOs e também para listar as classes de implementação DAO e as interfaces DAO.

Nesse arquivo, você deve especificar o caminho para o arquivo SqlMapConfig.xml e todas as interfaces DAO geradas pelo iBATOR e classes de implementação.

Por exemplo, suponha que o iBATOR tenha gerado uma interface DAO chamada MyTableDAO e uma classe de implementação chamada MyTableDAOImpl, e que os arquivos foram colocados no pacote test.dao do seu projeto.

O arquivo dao.xml deve ter essas entradas -

<?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 − Esta etapa é necessária apenas se você gerou DAOs para a estrutura iBATIS DAO.

ja/tutorial
es/tutorial
de/tutorial
fr/tutorial
th/tutorial
pt/tutorial
ru/tutorial
vi/tutorial
it/tutorial
ko/tutorial
tr/tutorial
id/tutorial
pl/tutorial
hi/tutorial
japost
espost
depost
frpost
thpost
ptpost
rupost
vipost
itpost
kopost
trpost
idpost
plpost
hipost

© Copyright 2021 - 2024 | All Rights Reserved