O que há de novo no iBATIS 3

Usando o iBATIS como uma estrutura de persistência em seu aplicativo

O iBATIS é um projeto usado principalmente para data access object (DAO) e object-relational mapping (ORM). É possível usá-lo para trabalhar facilmente com™ objetos e bancos de dados Java. A atualização do iBATIS 3 beta 9 foi postada em 23 de janeiro de 2010. O iBATIS 3 é uma versão completamente regravada do iBATIS e inclui algumas atualizações significativas. Este artigo apresenta algumas das novidades do iBATIS 3.

Nathan A. Good, Author and Software Engineer, Alliance of Computer Professionals

Nathan A. Good mora na área Twin Cities em Minnesota. Profissionalmente, ele realiza desenvolvimento de software, arquitetura de software e administração de sistemas. Quando ele não está desenvolvendo software, ele gosta de montar PCs e servidores, ler sobre e trabalhar com novas tecnologias e tentar convencer seus amigos de começarem a usar software livre. Ele escreveu e coescreveu muitos livros e artigos, incluindo Professional Red Hat Enterprise Linux 3, Regular Expression Recipes: A Problem-Solution Approach, Regular Expression Recipes for Windows Developers: A Problem-Solution Approach, PHP 5 Recipes: A Problem-Solution Approach e Foundations of PEAR: Rapid PHP Development.


nível de autor Contribuidor do
        developerWorks

30/Mar/2010

Dependendo de quanto tempo você vem gravando código Java, você deve se lembrar de quando gravou muitas classes com lógica dentro de métodos que mapearam dados em objetos Java para e dos dados em um relational database management system (RDBMS). Para a maioria, essa intervenção manual agora é amplamente desencorajada, em favor do uso de ferramentas ORM como melhor prática.

As ferramentas ORM permitem que você configure o mapeamento entre elementos de dados em um banco de dados relacional com propriedades de objeto Java. Quando configuradas, essas ferramentas permitem que você use seus objetos Java sem se preocupar com detalhes de como os dados nas propriedades das classes Java são guardados ou recuperados, deixando-o livre para gravar, depurar e manipular erros em uma série de códigos repetitivos.

Este artigo apresenta os novos recursos no iBATIS 3, uma ferramenta ORM da Apache Foundation que você pode usar para construir aplicativos Java que se conectam a bancos de dados. Para aproveitar este artigo ao máximo, você deve ter o Java Development Kit (JDK) V5 ou mais recente e o Eclipse V3.4 ou mais recente. Este artigo usa o iBATIS 3 beta 9. O site do iBATIS indica que a beta 9 está perto de se tornar general availability (GA), de modo que os exemplos neste artigo também devem se aplicar à versão GA quando ela estiver disponível.

Como o objetivo do iBATIS é fazer mapeamento para um RDBMS, um banco de dados também é necessário para obter um quadro completo dos exemplos. Os exemplos neste artigo usam o Apache Derby como banco de dados escolhido. É importante observar que, além de livrá-lo de gravar códigos Java repetitivos que usam Java Database Connectivity (JDBC), as ferramentas ORM fornecem a vantagem de oferecer uma melhor abstração da camada de dados. Com algumas mudanças na configuração do iBATIS e referências para as bibliotecas JDBC corretas, você deve ser capaz de usar os exemplos neste artigo com outros bancos de dados.

Visão geral do iBATIS

O iBATIS 3 é uma estrutura de persistência que permite configurar mapeamentos entre as propriedades em suas classes Java e colunas de tabela em um RDBMS. Quando configurada, a estrutura manipula a conexão JDBC e atribuições para você. É possível configurar o iBATIS 3 usando arquivos XML. É possível fazer o download da estrutura iBATIS como archive de arquivo comprimido (ZIP) do site do iBATIS (consulte Recursos). No archive está um arquivo Java Archive (JAR) que você pode incluir em seu projeto Java para fornecer as classes que usa.

A Listagem 1 contém um exemplo de uma classe Java usada pelo aplicativo de exemplo.

Listagem 1. A classe Automobile usada no aplicativo de exemplo
package com.ibm.developerWorks.examples.ibatis.model;

public class Automobile {

    private int id;
    private String make;
    private String model;
    private int year;

    public Automobile() {
        super();
    }

    public Automobile(final int id, final String make, final String model, 
        final int year) {

        super();
        this.id = id;
        this.make = make;
        this.model = model;
        this.year = year;
    }

    public int getId() {
        return id;
    }

    public String getMake() {
        return make;
    }

    public String getModel() {
        return model;
    }

    public int getYear() {
        return year;
    }

    public void setId(final int id) {
        this.id = id;
    }

    public void setMake(final String make) {
        this.make = make;
    }

    public void setModel(final String model) {
        this.model = model;
    }

    public void setYear(final int year) {
        this.year = year;
    }

    @Override
    public String toString() {
        return "Automobile [id=" + id + ", make=" + make + ", model=" + model + ", 
				    year=" + year + "]";
    }
}

Essa classe Automobile é um plain old Java object (POJO) simples que contém dados usados pelo aplicativo. A estrutura do iBATIS, quando configurada, é capaz de transportar esse objeto para o banco de dados ou retorná-lo em resultado de um método que o selecione no banco de dados.

A Listagem 2 mostra um script SQL que cria a tabela de banco de dados de exemplo.

Listagem 2. O script SQL para a criação da tabela automobiles
CREATE TABLE automobiles (
    id INT NOT NULL,
    make VARCHAR(255) NOT NULL,
    model VARCHAR(255) NOT NULL,
    model_year INT NOT NULL
);

Execute esse script de banco de dados para criar a tabela em seu banco de dados. Se estiver usando o Derby como banco de dados, execute esse script usando o utilitário de linha de comando que vem com o Derby na pasta bin (consulte a Listagem 3). Antes de executar o exemplo, certifique-se de atribuir a variável DERBY_HOME para todo o caminho para o diretório no qual o Derby está instalado e de salvar o script SQL em um arquivo chamado create.sql.

Listagem 3. Usando a ferramenta ij de linha de comando do Derby para executar create.sql
$ cd $DERBY_HOME/bin
$ ./ij
> connect 'jdbc:derby:/tmp/MyDB';
> run create.sql

A Listagem 4 mostra o arquivo de mapeamento XML que permite mapear as propriedades na classe Java para as colunas de dados na tabela de dados.

Listagem 4. O arquivo de mapeamento XML (automobile-mapper.xml)
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
    PUBLIC "-//ibatis.apache.org//DTD Mapper 3.0//EN"
    "http://ibatis.apache.org/dtd/ibatis-3-mapper.dtd">
<mapper namespace="com.ibm.developerWorks.examples.ibatis.model.Automobile">
    <resultMap type="Automobile" id="automobileResult">
        <result column="id" property="id" />
        <result column="make" property="make" />
        <result column="model" property="model" />
        <result column="model_year" property="year" />
    </resultMap>
    <select id="select" parameterType="int" resultType="Automobile"
        resultMap="automobileResult">
        select * from
        automobiles where id = #{id}
  </select>
    <insert id="insert" parameterType="Automobile">
        insert into automobiles (id,
        model, make, model_year)
        values (#{id}, #{model}, #{make}, #{year})
    </insert>
    <delete id="delete" parameterType="int">
        delete from automobiles where
        id = #{id}
  </delete>
    <delete id="deleteAll">
        delete from automobiles
  </delete>
</mapper>

O arquivo de mapeamento XML contém os elementos <select>, <insert> e <delete> com código dentro deles que parecem ANSI SQL normais. Os nomes dos elementos XML correspondem ao tipo de instrução SQL esperada — os elementos <insert> correspondem às instruções INSERT SQL e assim por diante. Os parâmetros são definidos no código SQL pela notação #{parameter}, em que parâmetro é o nome do campo na sua classe Java. Por exemplo, o objeto Automobile possui um campo chamado make, de modo que você pode passar o valor armazenado nesse campo para a instrução SQL usando #{make}.

Um novo recurso do iBATIS 3 é a capacidade de realizar essa mesma configuração usando anotações em uma interface Java. Explicarei como usar anotações Java 5 em vez de arquivos de configuração XML mais adiante (consulte Recursos do Java 5).

Finalmente, a Listagem 5 demonstra o arquivo de configuração XML para iBATIS 3, que especifica o nome do banco de dados, o tipo de driver a ser usado e outras propriedades de banco de dados, como credenciais. Os nomes dos arquivos de mapeamento, como o mostrado na Listagem 4, estão listados no elemento <mappers> do arquivo de configuração.

Listagem 5. O arquivo de configuração XML (ibatis-config.xml)
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
  PUBLIC "-//ibatis.apache.org//DTD Config 3.0//EN"
  "http://ibatis.apache.org/dtd/ibatis-3-config.dtd">
<configuration>
    <typeAliases>
        <typeAlias type="com.ibm.developerWorks.examples.ibatis.model.Automobile"
            alias="Automobile" />
    </typeAliases>
    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC" />
            <dataSource type="POOLED">
                <property name="driver" 
                    value="org.apache.derby.jdbc.EmbeddedDriver" />
                <property name="url" value="jdbc:derby:/tmp/MyDB" />
            </dataSource>
        </environment>
    </environments>
    <mappers>
        <mapper resource="automobile-mapper.xml" />
    </mappers>
</configuration>

Se usar o método de anotações de Java para definição de mapeamento entre os objetos e o banco de dados, você não precisa desse arquivo de configuração, já que o iBATIS 3 fornece uma application program interface (API) Java que permite que você realize essa configuração de forma programática.


Vantagens de usar o iBATIS

Uma vantagem de usar o iBATIS é que a configuração XML o ativa para ser uma boa estrutura ORM para mapeamento de objetos para bancos de dados relacionais existentes. Com as classes Mapper e os arquivos de mapeamento, o destaque fica para os objetos de mapeamento para estruturas de dados existentes, em vez de adequar uma estrutura de dados à estrutura de objeto. Apesar de o custo no momento da configuração ser maior do que o custo de usar uma estrutura que distancie mais os desenvolvedores da estrutura de dados, projetar um banco de dados e modelos de objeto de forma independente tem suas vantagens. Bons profissionais de bancos de dados relacionais e designers de modelo de objeto podem ter objetivos conflitantes que tornam suas respectivas implementações bem diferentes umas das outras.

No passado, usei o iBATIS de forma intensiva em projetos em que o banco de dados usa uma estrutura relacional e procedimentos armazenados, e nos quais desenvolvedores tinham muito menos controle sobre o design do banco de dados.


Criando o projeto Java de exemplo

Para testar os exemplos neste artigo, você precisa criar um projeto Java vazio. No novo projeto Java, crie uma classe que inclua um método main(), como mostrado na Listagem 6.

Listagem 6. A classe Main
package com.ibm.developerWorks.examples.ibatis;

import java.io.IOException;

import javax.sql.DataSource;

import org.apache.commons.cli.CommandLine;
import org.apache.commons.cli.GnuParser;
import org.apache.commons.cli.OptionBuilder;
import org.apache.commons.cli.Options;
import org.apache.derby.jdbc.EmbeddedDataSource;
import org.apache.ibatis.mapping.Environment;
import org.apache.ibatis.session.Configuration;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
import org.apache.ibatis.transaction.TransactionFactory;
import org.apache.ibatis.transaction.jdbc.JdbcTransactionFactory;

import com.ibm.developerWorks.examples.ibatis.data.AutomobileMapper;
import com.ibm.developerWorks.examples.ibatis.model.Automobile;

public class Main {

    private static final String CREATE = "create";
    private static final String DELETE = "delete";
    private static final String IBATIS_CONFIG = "ibatis-config.xml";
    private static final String SHOW = "show";

    @SuppressWarnings("static-access")
    private static Options createOptions() {
        Options options = new Options();
        options.addOption(CREATE, false, "creates the objects in the database");
        options.addOption(OptionBuilder.withArgName(SHOW).hasArg().withDescription(
                "shows the specified automobile").withLongOpt(SHOW).create());
        options.addOption(DELETE, false, "deletes all of the objects in database");
        return options;
    }

    private static SqlSessionFactory createSqlMapper() throws IOException {
        Reader reader = Resources.getResourceAsReader(IBATIS_CONFIG);
        return new SqlSessionFactoryBuilder().build(reader);
    }

    public static void main(final String[] args) {
        Options options = createOptions();
        try {
            CommandLine cmd = new GnuParser().parse(options, args);

            SqlSession session = createSqlMapper().openSession();
            
            try {
                if (cmd.hasOption(CREATE)) {
                    System.out.println("Creating the objects in the database...");
                    // Create the automobiles
                    session.insert(Automobile.class.getName() + ".insert", new
                        Automobile(1, "Toyota", "Tercel", 1993));
                    session.insert(Automobile.class.getName() + ".insert", new
                        Automobile(2, "Honda", "CR-V", 2000));
                    session.insert(Automobile.class.getName() + ".insert", new
                        Automobile(3, "Chevrolet", "Impala", 1964));
                    session.insert(Automobile.class.getName() + ".insert", new
                        Automobile(4, "Dodge", "Pickup", 1946));

                    session.commit();

                } else if (cmd.hasOption(SHOW)) {

                    Automobile auto = (Automobile) session.selectOne(
                        Automobile.class.getName() + ".select", cmd.getOptionValue(SHOW));
                    
                    if (auto == null) {
                        System.out.println("No matching results found!");
                    } else {
                        System.out.println(auto);
                    }

                } else if (cmd.hasOption(DELETE)) {

                    session.delete(Automobile.class.getName() + ".deleteAll");
                    session.commit();

                } else {
                    System.out.println("Doing nothing.");
                }

            } finally {
                session.close();
            }

        } catch (Exception e) {
            e.printStackTrace();
        }
    }

}

Para evitar linhas de código de análise de argumento arbitrário, esse método main usa o projeto Apache Commons CLI para analisar os argumentos enviados a ele da linha de comando. O uso do projeto Apache Commons CLI ativa o exemplo para responder a diferentes argumentos de linha de comando, como --create, --delete ou --show. Para obter mais informações sobre o projeto Apache Commons CLI, consulte Recursos. O suporte desse argumento permite que o método main() realize algumas operações de exemplo com os objetos e o iBATIS.

Esse exemplo usa a classe Resources do iBATIS para carregar a configuração de um arquivo XML. A classe Resources carrega o arquivo como Reader e o passo para o SqlSessionFactoryBuilder. O SqlSessionFactoryBuilder é capaz de construir um SqlSessionFactory, que, é usado em fila para criar os objetos SqlSession que permitem que seu código interaja com o banco de dados através de métodos definidos nas classes de mapeamento.

Antes que possa compilar e executar o código de exemplo, você precisa importar os arquivos JAR do iBATIS 3, Apache Commons CLI e Apache Derby (ibatis-3-core-x.jar, commons-cli-1.2.jar e derby.jar).


Executando o exemplo

Você pode executar esse exemplo executando a classe principal do Eclipse. Se quiser adicionar argumentos à chamada Java, abra Run > Run Configurations e encontre a configuração de execução de Java Application/Main. Na guia Arguments, especifique os argumentos que deseja fornecer nos Argumentos do Programa (demonstrados na Figura 1).

Figura 1. Adicionando argumentos à configuração de execução
Adicionando argumentos à configuração de execução

Ou chame o aplicativo Java da linha de comando, lembrando-se de definir o caminho da classe para incluir os arquivos JAR do iBATIS 3, Apache Commons CLI e Apache Derby. Consulte a Listagem 7 para obter um exemplo de como chamar o aplicativo.

Listagem 7. Executando o aplicativo da linha de comando
$ java -classpath {jars} com.ibm.developerWorks.examples.ibatis.Main --create
Creating the objects in the database...

Ao executar o aplicativo Java, você verá que --create cria quatro novos objetos Automobile e os adiciona ao banco de dados na tabela automobiles. O uso do argumento --delete excluir os objetos do banco de dados. O uso de --show com um ID executa o script SQL para obter o registro de correspondência do banco de dados, cria um objeto Automobile que possui os dados e exibe os resultados no console.

Depois que os exemplos de configuração XML estiverem funcionando, você estará pronto para ver um dos novos recursos principais do iBATIS 3: Suporte a anotação de Java.


Recursos do Java 5

O iBATIS 3 oferece novas mudanças que permitem que você aproveite as anotações do Java 5. Usando anotações, você pode criar interfaces mapeadoras que permitem que você faça todo o mapeamento de objetos para o banco de dados em código Java. Vejamos o código mostrado na Listagem 8, que mostra a interface AutomobileMapper usada para configuração, em vez da configuração XML.

Listagem 8. A interface AutomobileMapper
package com.ibm.developerWorks.examples.ibatis.data;

import org.apache.ibatis.annotations.Delete;
import org.apache.ibatis.annotations.Insert;
import org.apache.ibatis.annotations.Select;

import com.ibm.developerWorks.examples.ibatis.model.Automobile;

public interface AutomobileMapper {

	@Select("select id, make, model, model_year as \"year\" from automobiles 
	    where id = #{id}")
	Automobile selectAutomobile(final int id);
	
	@Insert("insert into automobiles(id,make,model,model_year) 
	    values (#{id}, #{make}, #{model}, #{year})")
	void insertAutomobile(final Automobile arg);
	
	@Delete("delete from automobiles")
	void deleteAll();
	
}

Na configuração XML para o mapeador Automobile, o elemento resultMap é usado para mapear a coluna do banco de dados model_year com o campo year no objeto Automobile. Esse é um mapeamento bastante fácil que você pode fazer em anotações simplesmente usando o recurso SQL de alias para a coluna, que é feito no SQL definido na anotação @Select.

A anotação Select na interface AutomobileMapper mapeia o método selectAutomobile para o SQL, que pode ser usado para selecionar um registro da tabela automobiles com um dado valor. O valor é especificado como o parâmetro id para o argumento e está incluído na instrução SQL como #{id}, exatamente como na configuração XML. Uma grande vantagem de usar interfaces Java para mapear os métodos SQL é o feedback disponível no editor Java na forma de erros de tempo de compilação. Você pode ter certeza de que os métodos estão aguardando e retornando os tipos corretos, enquanto que a configuração XML normalmente requer que você execute o código antes de encontrar erros.

Além disso, o iBATIS 3 agora suporta herança de interface, que permite que você refine suas interfaces Java para reduzir duplicação de código.

A documentação do iBATIS alerta que as anotações podem ser bem mais simples e fáceis de ler em projetos menores e mais simples. No entanto, as anotações são limitadas se comparadas à configuração XML. Se seu projeto inclui objetos complexos ou uma estrutura de banco de dados complexa, pense em usar a configuração XML em vez das anotações Java.


Outras mudanças de API

A configuração baseada em anotações do iBATIS requer uma instanciação ligeiramente diferente. Em vez de usar uma classe Reader que lê uma configuração XML, você pode adicionar os mapeadores ao objeto Configuration, como mostrado na Listagem 9.

Listagem 9. O novo código Java usando configuração de anotação
package com.ibm.developerWorks.examples.ibatis;

// snipped imports

public class Main {

    // snipped constants declarations--didn't change

    // new method for creating data source 
private static DataSource createDataSource()
{ EmbeddedDataSource dataSource =
 new org.apache.derby.jdbc.EmbeddedDataSource(); 
	dataSource.setDatabaseName
	("/tmp/MyDB"); 
	return dataSource; }

    @SuppressWarnings("static-access")
    private static Options createOptions() 
	{
		// snipped... no changes
    }

    private static SqlSessionFactory createSqlMapper() 
	throws IOException 
	{ DataSource datasource = 
	createDataSource(); 
	 TransactionFactory transaction = 
	new JdbcTransactionFactory(); 
	 Configuration configuration = 
	new Configuration(new Environment
	 ("development", transaction, datasource)); 
	configuration.addMapper
	(AutomobileMapper.class);
return new SqlSessionFactoryBuilder().build
		(configuration);
    }

    public static void main(final String[] args) {
        Options options = createOptions();
        try {
            CommandLine cmd = new GnuParser().parse(options, args);

            SqlSession session =
			 createSqlMapper().openSession();
			  AutomobileMapper mapper = 
 session.getMapper(AutomobileMapper.class);
            
            try {
                if (cmd.hasOption(CREATE)) {
                    System.out.println
	("Creating the objects in the database...");
                    // Create the automobiles mapper.insertAutomobile(new Automobile
	(1, "Toyota", "Tercel", 1993));
	mapper.insertAutomobile(new Automobile(
	2, "Honda", "CR-V", 2000));
	mapper.insertAutomobile( new Automobile
	(3, "Chevrolet", "Impala", 1964));
	mapper.insertAutomobile(new Automobile
	(4, "Dodge", "Pickup", 1946));

        session.commit();

            } else if (cmd.hasOption(SHOW)) 
			{
 Automobile auto = mapper.selectAutomobile
( Integer.parseInt(cmd.getOptionValue(SHOW)));

                    if (auto == null){
                    System.out.println(
					"No matching results found!");
                    } else {
                System.out.println(auto);
                    }

                } 
		else if (cmd.hasOption(DELETE)) {

                    mapper.deleteAll();
                    session.commit();

                } else {
            System.out.println("Doing nothing.");
                }

            } finally {
                session.close();
            }

        } catch (Exception e) {
            e.printStackTrace();
        }
    }

}

O AutomobileMapper fornecido ao método addMapper() é a mesma interface Java mostrada na Listagem 8.

O objeto Configuration também precisa de uma implementação DataSource. Neste exemplo, a implementação DataSource é criada bem facilmente no método estático createDataSource(). No entanto, em um aplicativo de produção, você deve modificar isso para tornar as informações de origem de dados, — como o nome do banco de dados, — mais dinâmicas. Se está construindo um aplicativo dentro de um servidor de aplicativo ou servidor da Web que gerencia persistência, você pode usar o Java Naming and Directory Interface (JNDI) para obter o DataSource.


Mudanças de configuração XML

Se decidir usar a configuração XML em vez de anotações Java para o iBATIS enquanto estiver fazendo a atualização de uma versão anterior do iBATIS, você perceberá que há algumas diferenças essenciais no XML entre a versão antiga e a nova.

As versões anteriores do iBATIS usam um parameterMap, que é semelhante a um resultMap, para mapear os parâmetros dos métodos. No entanto, o elemento parameterMap tornou-se obsoleto e não deve mais ser usado. Em vez disso, inclua o tipo do objeto no parameterType e acesse as propriedades no tipo usando a notação padrão (por exemplo, #{id} para o campo id em um objeto Java).

Os elementos raiz de arquivos mapeadores e de configuração são atualizados para incluir novas declarações Document Type Definition (DTD) e alguns dos elementos que foram movidos para oferecer uma melhor organização.

Para obter mais informações sobre as mudanças de configuração XML no iBATIS, consulte Recursos. Esteja ciente de que, a partir da versão beta 9 do iBATIS, a documentação para adaptação de versões mais antigas do XML para versões mais recentes ainda está em andamento.


iBATIS Migrations

O projeto iBATIS Schema Migrations System (iBATIS Migrations) não é um projeto de migração de esquemas mais antigos de configuração XML para esquemas mais novos. Ele é um projeto destinado a tornar mais fácil a migração de mudanças no banco de dados em desenvolvimento de uma versão do banco de dados para outra, conforme o banco de dados se desenvolve. É possível usar a ferramenta para gerar scripts SQL que permitem aplicar mudanças automaticamente, o que pode reduzir muito os erros.

Para obter mais informações sobre o projeto iBATIS Migrations, consulte Recursos.


Resumo

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.

A novidade no iBATIS 3 é o uso de anotações Java para mapeamento, que pode introduzir um mapeamento mais limpo e direto, que é acessível no código de origem Java para muitos projetos. O iBATIS 3 ainda oferece a capacidade de mapear objetos usando arquivos de configuração XML. Os métodos de configuração dupla permitem configurar o iBATIS usando o método mais fácil para o seu projeto.

Recursos

Aprender

Obter produtos e tecnologias

Discutir

Comentários

developerWorks: Conecte-se

Los campos obligatorios están marcados con un asterisco (*).


Precisa de um ID IBM?
Esqueceu seu ID IBM?


Esqueceu sua senha?
Alterar sua senha

Ao clicar em Enviar, você concorda com os termos e condições do developerWorks.

 


A primeira vez que você entrar no developerWorks, um perfil é criado para você. Informações no seu perfil (seu nome, país / região, e nome da empresa) é apresentado ao público e vai acompanhar qualquer conteúdo que você postar, a menos que você opte por esconder o nome da empresa. Você pode atualizar sua conta IBM a qualquer momento.

Todas as informações enviadas são seguras.

Elija su nombre para mostrar



Ao se conectar ao developerWorks pela primeira vez, é criado um perfil para você e é necessário selecionar um nome de exibição. O nome de exibição acompanhará o conteúdo que você postar no developerWorks.

Escolha um nome de exibição de 3 - 31 caracteres. Seu nome de exibição deve ser exclusivo na comunidade do developerWorks e não deve ser o seu endereço de email por motivo de privacidade.

Los campos obligatorios están marcados con un asterisco (*).

(Escolha um nome de exibição de 3 - 31 caracteres.)

Ao clicar em Enviar, você concorda com os termos e condições do developerWorks.

 


Todas as informações enviadas são seguras.


static.content.url=http://www.ibm.com/developerworks/js/artrating/
SITE_ID=80
Zone=Tecnologia Java, Software livre
ArticleID=478558
ArticleTitle=O que há de novo no iBATIS 3
publish-date=03302010