Você está na página 1de 21

FACULDADE DE INFORMÁTICA E ADMINISTRAÇÃO PAULISTA - FIAP

PESQUISA SOBRE IBATIS – Disciplina de Persistência e JDBC

Nome: Fábio Henrique Gonçalves Damas


RM: 30530
Índice
1. Resumo ................................................................................................................................................ 2
2. O que é Ibatis ....................................................................................................................................... 3
3. Vantagens e desvantagens em relação do JPA .................................................................................... 4
4. Exemplos de utilização......................................................................................................................... 5
4.1. Configurações principais .............................................................................................................. 5
4.2. Inserção ........................................................................................................................................ 7
4.3. Listagem ..................................................................................................................................... 10
4.4. Alteração .................................................................................................................................... 12
4.5. Exclusão...................................................................................................................................... 15
5. Conclusão ........................................................................................................................................... 19
6. Bibliografia consultada ...................................................................................................................... 20

1
1. Resumo

Este artigo possui o objetivo de mostrar o uso do iBATIS. Suas principais vantagens e
desvantagens.
Para isso, o segundo capítulo terá uma explicação sobre o iBATIS, seu surgimento e o estado
atual de desenvolvimento.
O terceiro capítulo possui uma relação das desvantagens e vantagens em relação a JPA, tendo
como provider o HIBERNATE.
O quarto capítulo possui as configurações de ambiente para o uso do iBATIS, como também
um exemplo de uso das operações de inserção, listagem, alteração e exclusão usando iBATIS.
O quinto capítulo possui uma conclusão sobre o uso do iBATIS.
O sexto capítulo possui a bibliográfica consultada.

2
2. O que é Ibatis
O iBATIS é um data mapper de persistência, usado para automatizar o mapeamento entre
bancos de dados SQL e objetos feitos em JAVA, .NET e Ruby on Rails. Com ele, o mapeamento é
dissociado da lógica da aplicação, empacotando as instruções SQL em arquivos de configuração
XML.
Conforme GOOD (2010), “O iBATIS 3 é uma estrutura de persistência ORM que permite
mapear as propriedades em objetos Java para colunas de tabela em um banco de dados. O foco central
do mapeamento do iBATIS destaca o mapeamento de um modelo de objeto sólido com um design
sólido de banco de dados relacional”.
Frameworks de persistência, como o HIBERNATE, permitem criar um modelo de objeto
pelo usuário e depois criar e manter o banco de dados relacional automaticamente. Mas o iBATIS
tem um método inverso: O programador começa com um banco de dados SQL e o iBATIS
automatiza a criação dos objetos. Deviso a isso, o iBATIS é uma boa escolha quando o programador
não tem controle total sobre o esquema de banco de dados.
Esses tipos de data mappers, porém, são pouco usados. Um dos reflexos desta perda de
popularidade é que o iBatis parou sua evolução: Em 21/05/2010, a equipe de desenvolvimento criou
um ramo de desenvolvimento, chamando o projeto de MyBatis. Todas as novas atualizações são
realizadas nesse novo local. O projeto Apache iBatis ficou inativo desde então, sendo transferido
para o Apache Attic (Local onde projetos da Apache Software Foundation, que atingiram seu final
de ciclo de vida são colocados).

3
3. Vantagens e desvantagens em relação do JPA
Nessa comparação entre iBATIS e JPA, consideramos como provider de JPA o Hibernate,
pelo seu grande uso atualmente.

Vantagens
 Como o iBATIS é mais simples do que JPA, o tamanho do arquivo .jar é bem menor.
 A natureza do iBATIS é a inclusão de código SQL, tornando-o mais flexível. Dessa
forma o tempo de desenvolvimento pode ser mais rápido.
 Suporta procedimentos armazenados. Dessa forma, a lógica de negócio fica fora do
banco de dados, bem como a manutenção da aplicação torna-se mais fácil.
 É possível ter acesso a todas as funcionalidades do SQL.

Desvantagens
 O JPA é responsável por toda a geração do código SQL, enquanto no iBATIS deve-se
codificar o código SQL.
 Jpa é altamente escalável.
 O uso de HQL, faz com que o uso de JPA o torne independente de banco de dados.
 Em JPA, existe o mapeamento dos objetos Java POJO com as tabelas de banco de
dados.

4
4. Exemplos de utilização
Nesta parte, será detalhado um passo a passo da configuração e uso do iBATIS. Considera-
se no tutorial, que o computador esteja com o Mysql, Java e Eclipse instalados.

4.1. Configurações principais


1. Entre no site a seguir para efetuar o download do iBATIS:
http://www.java2s.com/Code/Jar/i/Downloadibatis234726jar.htm

2. Clique no link “ibatis/ibatis-2.3.4.726.jar.zip( 338 k)”

Figura 1 – Link para download

3. No arquivo compactado “ibatis-2.3.4.726.jar.zip” há o arquivo “ibatis-2.3.4.726.jar”. Nós


copiaremos nos passos a seguir esse arquivo para a pasta lib do projeto no Eclipse.

Figura 2 - O arquivo .jar é a biblioteca do iBatis

4. Copie o conector Mysql para java, do seguinte endereço:


https://dev.mysql.com/downloads/connector/j/.

5
Figura 3 – Arquivo para download

5. Em um computador com o eclipse instalado, crie um novo projeto “Java Project” chamado
“ibatis”. Crie uma pasta lib. Copie os arquivos .jar do mysql e do iBatis para a pasta lib:

Figura 4

6. Adicione os arquivos ao Build Path do projeto.


7. Com o Mysql Workbench, crie o banco de dados “iBatis”. Crie a tabela conforme o comando
SQL a seguir:

6
Figura 5

4.2. Inserção

1. Será criado a seguinte estrutura de pacotes e arquivos no projeto:

Figura 6 – Arquivos necessários para inclusão

2. A classe que conterá os campos da tabela é a Cliente.java:

7
Figura 7

3. A instrução para inserção dos dados ficará no arquivo Cliente.xml. Nesse arquivo é definido a
instrução sql INSERT parametrizada. O valor da chave primária da tabela é obtido pelo
comando sql last_insert_id().

Figura 8

4. No arquivo SqlMapConfig.xml são definidos os dados da conexão com o banco de dados


MySql. A linha 18, define a localização do arquivo Cliente.xml:

8
Figura 9

5. O arquivo ClienteInsert.java efetua a inclusão do Cliente. A chamada às configurações do


arquivo .xml ocorre na linha 14. Com o objeto SqlMapClient, realizamos a operação de insert,
primeiro instanciando o objeto SqlMapClient na linha 15 e na linha 22 chamando o insert.

Figura 10

6. Para verificar se os dados foram realmente gravados, executamos um comando SELECT no


Mysql Workbench:

9
Figura 11

4.3. Listagem

1. Insira os getters e setters no arquivo Cliente.java:

10
Figura 12

2. No arquivo Cliente.xml, adiciona-se a TAG <SELECT>. Nesta tag passa-se como parametro id
“getAll” e o endereço da classe Cliente. Dentro da TAG é definido o comando SQL.

Figura 13

3. Crie o arquivo ClienteSelect.java, que será responsável por exibir os clientes cadastrados. A
linha 18 é a responsável o commando SQL definido no arquivo Cliente.xml. Da linha 21, até a
linha 27, são realizados os comandos para a exibição dos registros.

11
Figura 14

4.4. Alteração

1. Será alterado o registro de código igual a 7. Para isso, verifica-se o valor do registro com o
MySql Workbench:

Figura 15 – Campo nome como “Helton” e email “helton@uol.com.br”

2. No arquivo Cliente.xml, adiciona-se a TAG update, com o comando SQL responsável pela
alteração:

12
Figura 16

3. Cria-se o arquivo ClienteUpdate.java, que fará a alteração no registro de id igual a 7:

13
Figura 17

4. Verificando o registro no Mysql Workbench, constatamos que o nome foi alterado para “Nome
alterado” e o email para “alterado@uol.com.br”:

14
Figura 18

4.5. Exclusão

1. Será excluido o registro de id igual a 7. Para isso, verifica-se a existência do registro no MySql
Workbench:

15
Figura 19

2. No arquivo Cliente.xml, adiciona-se a TAG delete, com o comando SQL responsável pela
exclusão:

16
Figura 20

3. O arquivo ClienteDelete.java é criado. Neste arquivo, na linha 20, temos o comando para a
exclusão. Chamando o método delete, passando como segundo parâmetro, o código do cliente
a ser excluído:

Figura 21

4. Ao checar os registros no MySql Workbench, o registro de código 7 não é mais exibido:

17
Figura 22

18
5. Conclusão
A grande diferença entre iBATIS e outros frameworks de persistência, como o Hibernate, é
que o iBATIS enfatiza o uso de SQL, enquanto que outros frameworks usam uma linguagem de
consulta personalizada, como por exemplo, o HQL (Hibernate Query Language) e o EJB QL
(Enterprise JavaBeans Query Language). Isso pode ser considerado uma vantagem ou desvantagem,
dependendo do projeto em que o iBATIS é empregado.
Recomenda-se o useo de iBATIS:
 Projetos em que o uso de comandos SQL é extremamente personalizado.
 Projetos onde a manipulação ao banco de dados é extremamente burocrática e controlada.
Dessa forma, o próprio administrador de banco de dados pode fornecer os comandos SQL
permitidos, nos arquivos .xml para o desenvolvedor.

19
6. Bibliografia consultada
GOOD, Nathan. O que há de novo no iBATIS 3, 2010. Disponível em:
https://www.ibm.com/developerworks/br/java/library/os-ibatis3. Acesso em: 05 de fev. 2017.
KELLER, Diego. Criando sua camada de persistência usando o iBATIS. Disponível em:
http://diegokeller.blogspot.com.br/2010/05/criando-sua-camada-de-persistencia.html. Acesso em: 05 de fev.
2017.

IBatis Tutorial. Disponível em http://www.w3ii.com/pt/ibatis/default.html. Acesso em: 05 de


fev. 2017.

20