Posts tagged Java

eclipse_debug.jpg

Usando breakpoint condicional no Eclipse

Jul 3rd

Posted by RicardoSEP in Programação

No comments

Quando estamos debugando uma aplicação Java pelo Eclipse, é muito comum querermos que a thread que se está executando seja suspensa de acordo com o valor de uma variável.

Por exemplo, nossa aplicação está apresentando um NullPointerException. Então desconfiamos que talvez uma variável está com valor null dentro de um loop. Ao invés de ficarmos percorrendo todo o loop até ver se a variável está nula, podemos colocar uma condição no breakpoint que vai dentro do loop que verifica se essa variável é nula. Se a expressão da condição for verdadeira, a thread é suspensa automaticamente no breakpoint.

Veja como usar o breakpoint condicional:

No Eclipse, adicione um breakpoint e depois de adicionado clique sobre esse mesmo breakpoint com o botão direito do mouse. Escolha a opção “Breakpoint Properties”. veja na imagem abaixo a opção:

eclipse_debug

Na tela que se abrir, marque a opção “Conditional” e digite logo abaixo a condição que você quer que seja verdadeira para que o breakpoint suspenda a thread em execução.

Eu usei um exemplo de comparação equals de uma String. Mas você pode usar qualquer expressão lógica. veja a imagem abaixo:

eclipse_debug_conditional

Pronto. Clique OK e seu breakpoint agora é condicional.

Note-se que usei o Eclipse Helios e Windows XP para o desenvolvimento desse mini-tutorial.

, , , , ,
new_project_eclipse.jpg

Integrando sua aplicação JAVA com Twitter usando twitter4j

Jul 2nd

Posted by RicardoSEP in Java

6 comments

Nos últimos anos o serviço web que tem crescido de forma extraordinária é o Twitter. É inegável o papel dele na web, nas mídias sociais e até na sociedade. Ele vem como uma ferramenta formadora de opinião fortíssima, abalando até a poderosa TV.

Por esse pequeno parágrafo escrito acima, é que nos leva a querer integrar nossas aplicações com esse serviço. Você já deve ter percebido a integração de vários portais e sistemas ao sistema de microblogging.

Nesse tutorial, explicarei como integrar o Twitter com uma aplicação JAVA utilizando a biblioteca twitter4j, que encapsula quase todas as funcionalidade que o twitter nos oferece através de sua API.

Antes de começar propriamente o tutorial, eu recomendo fortemente que você leia a wiki oficial da API do twitter. Existem informações importantíssimas sobre o funcionamento nu e cru da API do twitter. A wiki oficial da API do twitter pode ser acessada em: http://apiwiki.twitter.com/

Após a leitura, vamos ao tutorial em si.

Para esse tutorial, usei o seguinte ambiente de desenvolvimento:

  • Windows 7 64bits
  • Java 1.6 64bits
  • Eclipse 3.6 – Helios
  • Twitter4J – 2.1.3

Esse tutorial, também presume que você tenha um conhecimento básico prévio na linguagem Java e em orientação a objeto. Se sabe Java, mas nunca mexeu com o Eclipse, não se preocupe, a parte que se trata da configuração do projeto no Eclipse está bem detalhada.

O que é o Twitter4j?

O twitter4j é uma biblioteca Java que facilita o uso no Java da API do twitter. Ela NÃO é uma API oficial. Algumas features dela são:

  • 100% implementação em Java – Funciona em qualquer plataforma Java acima da versão 1.4.2;
  • Compatível com Android – A partir da versão 2.1.0 da twitter4j
  • Nenhuma dependência – Você não precisará adicionar nenhum outro JAR no seu classpath para fazer o Twitter4J funcionar!
  • Suporta autenticação OAuth! Mais informações sobre OAuth aqui!
  • Integração com Maven
  • …

BAIXANDO O TWITTER4J

Agora precisamos baixar o twitter 4j do site deles para usarmos na nossa aplicação. Para isso, acesse: http://twitter4j.org , no menu a esquerda clique em Download e baixe a última versão estável. Até o fechamento desse post, a versão era a 2.1.3.

Baixado o twitter4j, descompacte e abra a pasta. Você verá vários arquivos lá dentro, mas o que nos interessa é o twitter4j-core-2.1.3-SNAPSHOT.jar. Precisamos adicionar esse arquivo ao classpath do nosso projeto no eclipse. Já iremos fazer isso adiante.

CRIANDO O PROJETO NO ECLIPSE

Agora abra o Eclipse. Vamos criar um novo projeto no Eclipse para que possamos iniciar o uso do Twitter4J. Para isso, com o Eclipse aberto, vá em File – New – Other. Na tela que aparece, escolha a opção Java Project e clique em Next.

Veja as imagens abaixo sobre como criar um novo projeto Java no Eclipse.

new_project_eclipse

Em seguida:

java_project_eclipse

Na tela que aparecer, após você clicar em Next, você deverá escolher um nome para o projeto que estamos criando. Isso fica por sua conta. No meu exemplo, eu coloquei: MinhaAppTwitter.

Veja a imagem abaixo que é a tela de configuração do projeto Java no Eclipse:

eclipse_config_project

Pronto. Agora você pode clicar em Next e depois, na tela que aparecer, em Finish. Feito isso o projeto será criado na workspace e estará pronto para nós começarmos a codificar. Mas antes da codificação, temos que adicionar a biblioteca do Twitter4J que baixamos a pouco tempo, lembra? Vamos pegar aquele JAR e adicionar no classpath do nosso projeto através do Eclipse.

Para adicionarmos o JAR do twitter4j no classpath do nosso projeto, faça o seguinte: Botão Direito no Projeto na Workspace – Properties.

project_properties_eclipse

Na tela que aparecer, selecione no menu a esquerda a opção Java Build Path. A direita na tela, escolha a aba Libraries e depois clique no botão Add External JAR. Ache a biblioteca do twitter4j que descompactamos. Se você não mudou o nome, o nome da biblioteca deverá ser: twitter4j-core-2.1.3-SNAPSHOT.jar.

Veja na tela abaixo a tela de adição da biblioteca do twitter4j:

build_path_eclipse

Clique em OK para adicionar e depois em OK novamente para sair.

Pronto. Nosso projeto no Eclipse está configurado e com a biblioteca do twitter4j adicionada. Podemos começar o desenvolvimento em si.

USANDO O TWITTER4J

A primeira coisa que vamos fazer é criar um método que nos permite fazer uma busca no twitter de acordo com uma String que usaremos de parâmetro. Essa String pode ser uma palavra normal ou uma hashtag. Tanto faz. Nosso método receberá essa String como parâmetro e exibirá os tweets encontrados na busca.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

package com.meupost.tutorial.twitter4j;
 
import java.util.Iterator;
import java.util.List;
 
import twitter4j.Query;
import twitter4j.QueryResult;
import twitter4j.Tweet;
import twitter4j.Twitter;
import twitter4j.TwitterException;
import twitter4j.TwitterFactory;
 
public class MeuTwitter {
 
	public void buscaTwitter(String info) {
		TwitterFactory twitterFactory = new TwitterFactory();
		Twitter twitter = twitterFactory.getInstance();
 
		Query query = new Query(info);
 
		QueryResult resultadoBusca = null;
 
		try {
			resultadoBusca = twitter.search(query);
 
			List<tweet> listaTweets = resultadoBusca.getTweets();
 
			Iterator<tweet> itTweet = listaTweets.iterator();
 
			while (itTweet.hasNext()) {
				Tweet tweet = itTweet.next();
 
				System.out.println(tweet.getFromUser() + 
						" - " + 
						tweet.getText());
				System.out.println("--------------------------------");
			}
 
		} catch (TwitterException e) {
			e.printStackTrace();
		}
	}
}

Basta chamar o método de busca passando um parâmetro de busca. O método irá buscar no Twitter os últimos tweets de acordo com seu parâmetro e exibirá em console os tweets.

Repare que no trecho de código acima nós não fornecemos nenhum tipo de usuário ou senha. Isso que dizer que as buscas você pode fazer a vontade sem passar credenciais. Porém, para enviar um tweet para sua timeline, você irá precisar enviar suas credenciais (usuário e senha) e depois enviar seu tweet.

Veja o trecho abaixo de como enviar um tweet pelo twitter4j:

1
2
3
4
5
6
7
8
9
10
11
12
13
14

public void enviarTweet(String usuario, String senha, String tweet) {
	TwitterFactory twitterFactory = new TwitterFactory();
	Twitter twitter = twitterFactory.getInstance(usuario, senha);
 
	Status status = null;
 
	try {
		status = twitter.updateStatus(tweet);
		System.out.println("Enviado tweet: " + status.getText());
	} catch (TwitterException e) {
		e.printStackTrace();
	}
 
}

Muito simples, não? Repare que na hora de se obter o objeto pelo getInstace() da factory, agora nós passamos o usuário e senha do twitter. Nesse momento, logamos no Twitter e partir daí podemos manipular nossa conta programaticamente.

Esses são só um pequeno exemplo da capacidade do twitter4j. Você poderá fazer muito, mas muito mais com ele. Poderá integrar uma aplicação web. Uma aplicação J2EE. Poderá usar JRuby e integrar com scripts Ruby. O céu é o limite.

Recomendo muito que se você quiser se aprofundar no assunto do twitter4j, que leia a documentação oficial disponibilizada em http://twitter4j.org.

O JavaDoc pode ser encontrado aqui.

Se você quer experimentar outras bibliotecas do Java ou que seja de outra linguagem, na wiki do Twitter há uma lista de bibliotecas para diversas linguagens que facilitam sua vida ao mexer com a API do twitter. Veja aqui a lista de bibliotecas disponíveis: http://dev.twitter.com/pages/libraries

Agora é com você! O primeiro passo foi dado!

, , , , , ,

Dica rápida: Setando e obtendo dados do Clipboard com Java

Jun 26th

Posted by RicardoSEP in Java

No comments

Após algum tempo parado com o blog, devido ao trabalho, volto com uma dica rápida, mas muito útil na programação desktop para Java. Como obter ou setar uma String no clipboard do sistema operacional com Java.

Primeiramente, o que é o clipboard, em português, área de transferência? O clipboard é onde fica a informação que você copia utilizando a opção Editar – Copiar dos programas ou o mais comum o famoso CTRL + C.

Essa dica ensina a colocar programaticamente uma informação na clipboard para que você possa colar com o CTRL + V! Adicionalmente, ensinarei como obter algo no Java o que está na Clipboard.

Vamos lá.

Criei uma classe Útil onde há dois métodos. Um para setar uma String na clipboard e outro para obter a String da clipboard. Não há muito segredo nessa classe. De uma olhada.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

package com.meupost.util;
 
import java.awt.Toolkit;
import java.awt.datatransfer.DataFlavor;
import java.awt.datatransfer.StringSelection;
import java.awt.datatransfer.Transferable;
import java.awt.datatransfer.UnsupportedFlavorException;
import java.io.IOException;
 
public class Util {
 
	public static void setStringToClipboard(String str) {
	    StringSelection ss = new StringSelection(str);
	    Toolkit.getDefaultToolkit().getSystemClipboard().setContents(ss, null);
	}
 
	public static String getStringFromClipboard() {
		Transferable t = Toolkit.getDefaultToolkit().getSystemClipboard()
                                              .getContents(null);
 
		try {
			if (t != null && t.isDataFlavorSupported(DataFlavor.stringFlavor)) {
				String text = (String) t.getTransferData(DataFlavor.stringFlavor);
				return text;
			}
		} 
		catch (UnsupportedFlavorException e) {
			e.printStackTrace();
		} 
		catch (IOException e) {
			e.printStackTrace();
		}
 
		return null;
	}
 
}

Basta chamar os métodos!

Keep walking!

, ,

Verificando finais de semana em Java

Sep 8th

Posted by RicardoSEP in Java

No comments

Pessoal,

Seguem dois métodos simples que utiliza a API Calendar do JAVA para detectar os finais de semana de um determinado mês. Os dias dos mês que são finais de semana são colocados em uma List e retornados pelo método. Já me quebrou muitos galhos esses métodos.

Lembrando que em Calendar, o mês 01 (janeiro) começa com o valor 0.

O código abaixo está dividido em dois métodos. Há o isFinaDeSemana() que a partir de um dia, mês e ano, te devolve se é ou não um final de semana. O outro método getFinaisDeSemanaMes() te devolve uma list com todos os dias que são finais de semana em um mês.

  private List getFinaisDeSemanaMes(int ano, int mes)
  {
    Calendar calendar = new GregorianCalendar(ano, mes - 1, 1);
    int diasMaximos = calendar.getMaximum(Calendar.DAY_OF_MONTH);
    int dia = 1;
    List finaisDeSemana = new ArrayList();
 
    for (dia = 1; dia <= diasMaximos; dia++)
    {
      try
      {
        if (isFinalDeSemana(ano, mes, dia))
        {
          finaisDeSemana.add(new Long(dia));
        }
      }
      catch (Exception ex)
      {
        ex.printStackTrace();
        continue;
      }
    }
 
    return finaisDeSemana;
  }
 
  private boolean isFinalDeSemana(int ano, int mes, int dia) throws Exception
  {
    if ((mes < 1) || (mes > 12))
    {
      throw new Exception("Mês inválido");
    }
 
    boolean finalDeSemana;
    mes = mes - 1;
    Calendar data = new GregorianCalendar();
 
    data.set(ano, mes, 1);
    int diaMaximo = data.getActualMaximum(Calendar.DAY_OF_MONTH);
 
    if (diaMaximo < dia)
    {
      throw new Exception("Dia inválido");
    }
 
    data.set(ano, mes, dia);
    int diaDaSemana = data.get(Calendar.DAY_OF_WEEK);
 
    if ((diaDaSemana == Calendar.SATURDAY) || (diaDaSemana == Calendar.SUNDAY))
    {
      finalDeSemana = true;
    }
    else
    {
      finalDeSemana = false;
    }
 
    return finalDeSemana;
  }
, ,

Usando o XStream para serializar e desserializar objetos Java para XML

Mar 6th

Posted by RicardoSEP in Java

8 comments

O XStream é uma biblioteca simples e poderosa que facilita muito nossa vida quando precisamos serializar objetos Java para arquivos XML e também para fazer o processo inverso. A partir de JavaBeans podemos escrever os XML com poucas linhas de código.

Nesse artigo o uso básico e o intermediário do XStream. Veremos como serializar e desserializar objetos, o uso de aliases e list.

O ambiente que usei para criar esse artigo foi o seguinte:

  • Windows XP – SP3
  • JDK 6
  • Eclipse 3.4 – Ganymede
  • XStream 1.3.1

Para começar, precisamos baixar a biblioteca para ser usada. Acessem o site oficial do XStream (http://xstream.codehaus.org), cliquem em “Download” e baixem a última versão da versão binária (Binary Distribution).

Depois de baixado, descompacte o arquivo e você verá diversos arquivos JARs. Não precisamos de todos, porém se quiser pode adicionar todos no classpath do seu projeto ou aqueles que mais se encaixarem em suas necessidades. No site do XStream tem uma explicação sobre cada uma das dependências opcionais. Acesse: http://xstream.codehaus.org/download.html.

Depois de adicionar os JARs no classpath, estamos prontos para começar a codificar. Nosso primeiro exemplo será serializar um objeto simples (JavaBean) para XML. Vamos criar esse objeto:

 
package com.meupost.beans;
 
public class Agenda {
 
	private String nomePessoa;
	private int idade;
	private String email;
	private String telefone;
	private String fax;
 
	public String getNomePessoa() {
		return nomePessoa;
	}
 
	public void setNomePessoa(String nomePessoa) {
		this.nomePessoa = nomePessoa;
	}
 
	public int getIdade() {
		return idade;
	}
 
	public void setIdade(int idade) {
		this.idade = idade;
	}
 
	public String getEmail() {
		return email;
	}
 
	public void setEmail(String email) {
		this.email = email;
	}
 
	public String getTelefone() {
		return telefone;
	}
 
	public void setTelefone(String telefone) {
		this.telefone = telefone;
	}
 
	public String getFax() {
		return fax;
	}
 
	public void setFax(String fax) {
		this.fax = fax;
	}
}

Beleza! O objeto é esse. Vamos mandar ele para um XML. No nosso exemplo faço a serialização direto no void main(). Vejam:

package com.meupost.main;
 
import com.meupost.beans.Agenda;
import com.thoughtworks.xstream.XStream;
 
public class Main {
 
    public static void main(String args[]) {
 
         Agenda a1 = new Agenda();
 
         a1.setEmail("amigo1@email.com.br");
         a1.setFax("123-4567");
         a1.setIdade(55);
         a1.setNomePessoa("Fernando Pessoa");
         a1.setTelefone("654-3210");
         XStream x = new XStream();
 
         System.out.println(x.toXML(a1));
 
    }
}

A saída será assim:

<com.meupost.beans.Agenda>
  <nomePessoa>Fernando Pessoa</nomePessoa>
  <idade>55</idade>
  <email>amigo1@email.com.br</email>
  <telefone>654-3210</telefone>
  <fax>123-4567</fax>
</com.meupost.beans.Agenda>

Muito bom. Mas agora vamos complicar mais um pouco. Vamos criar mais um objeto chamado Endereco que vai conter onde nosso indivíduo mora. Esse objeto Endereco entrará como atributo do objeto Agenda. Vejam o exemplo abaixo de como fica e o resultado do XML.

Objeto Endereco:

 
package com.meupost.beans;
 
public class Endereco {
 
	private String rua;
	private int numero;
	private String cidade;
	private String estado;
 
	public String getRua() {
		return rua;
	}
 
	public void setRua(String rua) {
		this.rua = rua;
	}
 
	public int getNumero() {
		return numero;
	}
 
	public void setNumero(int numero) {
		this.numero = numero;
	}
 
	public String getCidade() {
		return cidade;
	}
 
	public void setCidade(String cidade) {
		this.cidade = cidade;
	}
 
	public String getEstado() {
		return estado;
	}
 
	public void setEstado(String estado) {
		this.estado = estado;
	}
}

Objeto Agenda. Reparem que adicionamos o atributo Endereco!

package com.meupost.beans;
 
public class Agenda {
 
	private String nomePessoa;
	private int idade;
	private String email;
	private String telefone;
	private String fax;
	private Endereco endereco;
 
	public String getNomePessoa() {
		return nomePessoa;
	}
 
	public void setNomePessoa(String nomePessoa) {
		this.nomePessoa = nomePessoa;
	}
 
	public int getIdade() {
		return idade;
	}
 
	public void setIdade(int idade) {
		this.idade = idade;
	}
 
	public String getEmail() {
		return email;
	}
 
	public void setEmail(String email) {
		this.email = email;
	}
 
	public String getTelefone() {
		return telefone;
	}
 
	public void setTelefone(String telefone) {
		this.telefone = telefone;
	}
 
	public String getFax() {
		return fax;
	}
 
	public void setFax(String fax) {
		this.fax = fax;
	}
 
	public Endereco getEndereco() {
		return endereco;
	}
 
	public void setEndereco(Endereco endereco) {
		this.endereco = endereco;
	}
}

E agora o teste e resultado:

package com.meupost.main;
 
import com.meupost.beans.Agenda;
import com.meupost.beans.Endereco;
import com.thoughtworks.xstream.XStream;
 
public class Main {
 
    public static void main(String args[]) {
 
        Agenda a1 = new Agenda();
 
        a1.setEmail("amigo1@email.com.br");
        a1.setFax("123-4567");
        a1.setIdade(55);
        a1.setNomePessoa("Fernando Pessoa");
        a1.setTelefone("654-3210");
 
        Endereco end = new Endereco();
        end.setRua("Rua Saldanha Marinho");
        end.setNumero(1234);
        end.setCidade("São José do Rio Preto");
        end.setEstado("São Paulo");
 
        a1.setEndereco(end);
        XStream x = new XStream();
 
        System.out.println(x.toXML(a1));
 
     }
}

Ótimo. E por fim o XML gerado:

<com.meupost.beans.Agenda>
  <nomePessoa>Fernando Pessoa</nomePessoa>
  <idade>55</idade>
  <email>amigo1@email.com.br</email>
  <telefone>654-3210</telefone>
  <fax>123-4567</fax>
  <endereco>
    <rua>Rua Saldanha Marinho</rua>
    <numero>1234</numero>
    <cidade>São José do Rio Preto</cidade>
    <estado>São Paulo</estado>
  </endereco>
</com.meupost.beans.Agenda>

Viram que dentro do nó endereco temos os atributos que definimos no nosso objeto? Pois bem, é assim que você pode relacionar os JavaBeans.

Vocês já devem ter percebido que o nome do nó raiz ta o mesmo nome do pacote. Isso com certeza é um incoveniente muito grande quando colocamos nosso sistema em produção. Para arrumarmos isso, podemos usar os Aliases que o XStream oferece. Basta uma linha de código. Vamos mudar nosso método void main() adicionando o alias e vamos gerar o XML novamente. Vejam:

package com.meupost.main;
 
import com.meupost.beans.Agenda;
import com.meupost.beans.Endereco;
import com.thoughtworks.xstream.XStream;
 
public class Main {
 
    public static void main(String args[]) {
 
        Agenda a1 = new Agenda();
 
        a1.setEmail("amigo1@email.com.br");
        a1.setFax("123-4567");
        a1.setIdade(55);
        a1.setNomePessoa("Fernando Pessoa");
        a1.setTelefone("654-3210");
 
        Endereco end = new Endereco();
        end.setRua("Rua Saldanha Marinho");
        end.setNumero(1234);
        end.setCidade("São José do Rio Preto");
        end.setEstado("São Paulo");
 
        a1.setEndereco(end);
 
       XStream x = new XStream();
       //Adicionei nova linha aqui!
       x.alias("agenda", Agenda.class);
 
       System.out.println(x.toXML(a1));
 
    }
}

E o resultado:

<agenda>
  <nomePessoa>Fernando Pessoa</nomePessoa>
  <idade>55</idade>
  <email>amigo1@email.com.br</email>
  <telefone>654-3210</telefone>
  <fax>123-4567</fax>
  <endereco>
    <rua>Rua Saldanha Marinho</rua>
    <numero>1234</numero>
    <cidade>São José do Rio Preto</cidade>
    <estado>São Paulo</estado>
  </endereco>
</agenda>

Agora, vamos fazer o processo inverso. Ao invés de escrevermos o XML, vamos ler e criar os objeto a partir do XML. Para facilitar, vamos usar nossos objetos já criados (Agenda e Endereco). Abaixo há um exemplo onde crio um objeto String com o XML a ser lido, passo a String ao XStream e o próprio se encarrega de criar nossos objetos JavaBean de volta sem esforço nenhum.

package com.meupost.main;
 
import com.meupost.beans.Agenda;
import com.meupost.beans.Endereco;
import com.thoughtworks.xstream.XStream;
 
public class Main {
 
    public static void main(String args[]) {
 
        String xml;
 
        xml = "<agenda>" +
        "<nomePessoa>Angelina Jolie</nomePessoa>" +
        "<idade>35</idade>" +
        "<email>angelina@jolie.com</email>" +
        "<telefone>1742-5236</telefone>" +
        "<fax>6541-222</fax>" +
        "<endereco>" +
             ="<rua>Rubião Júnior</rua>" +
            "<numero>2104</numero>" +
            "<cidade>São José do Rio Preto</cidade>" +
            "<estado>São Paulo</estado>" +
        "</endereco>" +
        "</agenda>";
 
        XStream x = new XStream();
 
        x.alias("agenda", Agenda.class);
        Agenda a = (Agenda) x.fromXML(xml);
 
        System.out.println(a.getNomePessoa());
    }
}

Vejam que no exemplo acima eu precisei indicar qual a classe que o nó raiz “agenda” fazia parte. Depois foi só passar o XML para o XStream e fazer o Cast para obter o objeto. Por fim exibimos em console o nome da Angelina!

Agora mais um problema tanto para leitura quanto para escrita do XML. E quando temos várias informações dentro de um nó? Por exemplo, temos um XML precido com esse abaixo:

<agenda>
  <pessoas>
    <pessoa>
      <nomePessoa>Fernando Pessoa</nomePessoa>
      <idade>55</idade>
      <email>amigo1@email.com.br</email>
      <telefone>124-6984</telefone>
      <fax>654-3210</fax>
      <endereco>
        <rua>Rua Saldanha Marinho</rua>
        <numero>5110</numero>
        <cidade>São José do Rio Preto</cidade>
        <estado>São Paulo</estado>
      </endereco>
    </pessoa>
    <pessoa>
      <nomePessoa>felipao@email.com.br</nomePessoa>
      <idade>60</idade>
      <email>amigo1@email.com.br</email>
      <telefone>2310-1110</telefone>
      <fax>211-4100</fax>
      <endereco>
        <rua>Rua Francisco Glicério</rua>
        <numero>210</numero>
        <cidade>Campinas</cidade>
        <estado>São Paulo</estado>
      </endereco>
    </pessoa>
    <pessoa>
      <nomePessoa>Raul Seixas</nomePessoa>
      <idade>78</idade>
      <email>raulzito@email.com.br</email>
      <telefone>222-2222</telefone>
      <fax>111-1111</fax>
      <endereco>
        <rua>Rua Mar Vermelho</rua>
        <numero>450</numero>
        <cidade>Babilônia</cidade>
        <estado>São Paulo</estado>
      </endereco>
    </pessoa>
  </pessoas>
</agenda>

Temos vários nós pessoa. Como se fosse uma lista de pessoas. E para tratarmos isso com o XStream? Temo como? Sim, lógico que tem. Primeiramente vamos criar o objeto (JavaBean) Pessoa contendo os mesmos atributos que havia no objeto Agenda, pois agora o objeto Agenda vai conter somente um atributo que é a lista de pessoas. Veja como fica o objeto Agenda e o objeto Pessoa:

Agenda:

package com.meupost.beans;
 
import java.util.ArrayList;
import java.util.List;
 
public class Agenda {
 
	private List<Pessoa> pessoas = new ArrayList<Pessoa>();
 
	public void add(Pessoa pessoa) {
		this.pessoas.add(pessoa);
	}
 
	public List<Pessoa> getContent() {
		return this.pessoas;
	}
}

Pessoa:

package com.meupost.beans;
 
public class Pessoa {
 
	private String nomePessoa;
	private int idade;
	private String email;
	private String telefone;
	private String fax;
	private Endereco endereco;
 
	public String getNomePessoa() {
		return nomePessoa;
	}
 
	public void setNomePessoa(String nomePessoa) {
		this.nomePessoa = nomePessoa;
	}
 
	public int getIdade() {
		return idade;
	}
 
	public void setIdade(int idade) {
		this.idade = idade;
	}
 
	public String getEmail() {
		return email;
	}
 
	public void setEmail(String email) {
		this.email = email;
	}
 
	public String getTelefone() {
		return telefone;
	}
 
	public void setTelefone(String telefone) {
		this.telefone = telefone;
	}
 
	public String getFax() {
		return fax;
	}
 
	public void setFax(String fax) {
		this.fax = fax;
	}
 
	public Endereco getEndereco() {
		return endereco;
	}
 
	public void setEndereco(Endereco endereco) {
		this.endereco = endereco;
	}
}

Viram a diferença? Agora o objeto agenda possui uma List onde podemos ir adicionando o objeto Pessoa. O XStream ficará responsável de ler essa List e colocar no XML. Abaixo veja o exemplo de preenchimento dos objetos e o resultado depois que o XStream transforma para XML:

package com.meupost.main;
 
import com.meupost.beans.Agenda;
import com.meupost.beans.Endereco;
import com.meupost.beans.Pessoa;
import com.thoughtworks.xstream.XStream;
 
 
public class Main {
 
     public static void main(String args[]) {
 
		Agenda a1 = new Agenda();
 
		Pessoa p1 = new Pessoa();
		p1.setEmail("amigo1@email.com.br");
		p1.setFax("654-3210");
		p1.setIdade(55);
		p1.setNomePessoa("Fernando Pesso");
		p1.setTelefone("124-6984");
		Endereco e1 = new Endereco();
		e1.setRua("Rua Saldanha Marinho");
		e1.setCidade("São José do Rio Preto");
		e1.setNumero(5110);
		e1.setEstado("São Paulo");
		p1.setEndereco(e1);
 
		Pessoa p2 = new Pessoa();
		p2.setEmail("amigo1@email.com.br");
		p2.setFax("211-4100");
		p2.setIdade(60);
		p2.setNomePessoa("felipao@email.com.br");
		p2.setTelefone("2310-1110");
		Endereco e2 = new Endereco();
		e2.setRua("Rua Francisco Glicério");
		e2.setCidade("Campinas");
		e2.setNumero(210);
		e2.setEstado("São Paulo");
		p2.setEndereco(e2);
 
		Pessoa p3 = new Pessoa();
		p3.setEmail("raulzito@email.com.br");
		p3.setFax("111-1111");
		p3.setIdade(78);
		p3.setNomePessoa("Raul Seixas");
		p3.setTelefone("222-2222");
		Endereco e3 = new Endereco();
		e3.setRua("Rua Mar Vermelho");
		e3.setCidade("Babilônia");
		e3.setNumero(450);
		e3.setEstado("São Paulo");
		p3.setEndereco(e3);
 
		a1.add(p1);
		a1.add(p2);
		a1.add(p3);
 
		XStream x = new XStream();
		x.alias("agenda", Agenda.class);
		x.alias("pessoa", Pessoa.class);
		String xml = x.toXML(a1);
 
		System.out.println(xml);
    }
}

E a nossa saída em XML:

<agenda>
  <pessoas>
    <pessoa>
      <nomePessoa>Fernando Pesso</nomePessoa>
      <idade>55</idade>
      <email>amigo1@email.com.br</email>
      <telefone>124-6984</telefone>
      <fax>654-3210</fax>
      <endereco>
        <rua>Rua Saldanha Marinho</rua>
        <numero>5110</numero>
        <cidade>São José do Rio Preto</cidade>
        <estado>São Paulo</estado>
      </endereco>
    </pessoa>
    <pessoa>
      <nomePessoa>felipao@email.com.br</nomePessoa>
      <idade>60</idade>
      <email>amigo1@email.com.br</email>
      <telefone>2310-1110</telefone>
      <fax>211-4100</fax>
      <endereco>
        <rua>Rua Francisco Glicério</rua>
        <numero>210</numero>
        <cidade>Campinas</cidade>
        <estado>São Paulo</estado>
      </endereco>
    </pessoa>
    <pessoa>
      <nomePessoa>Raul Seixas</nomePessoa>
      <idade>78</idade>
      <email>raulzito@email.com.br</email>
      <telefone>222-2222</telefone>
      <fax>111-1111</fax>
      <endereco>
        <rua>Rua Mar Vermelho</rua>
        <numero>450</numero>
        <cidade>Babilônia</cidade>
        <estado>São Paulo</estado>
      </endereco>
    </pessoa>
  </pessoas>
</agenda>

Bem, estamos chegando quase no fim do artigo. Mostrei como usar o XStream para escrever XML e como ler. Ainda há muito o que aprender sobre o XStream como os aliases de campo (aliasField) e atributos. Mas esse artigo não irá se aprofundar tanto. Espero que com o que foi mostrado e ensinado aqui seja o suficiente para um início. Há um pouco de material de estudo no site do XStream, mas também é básico. O melhor mesmo é ir no Google ou mexer no JavaDoc do XStream (http://xstream.codehaus.org/javadoc/index.html).

Para praticar você pode usar diversas APIs disponíveis como o do YouTube, Mercado Livre, Yahoo… Esses XMLs são mais complexos e são ótimos para estudo.

Até a próxima!

, , , , ,

Serialização de objeto no Java

Dec 3rd

Posted by RicardoSEP in Java

No comments

Quando estamos fazendo qualquer atividade no computador como um documento de texto, jogando um game ou até mesmo declarando o imposto de renda é quase que imperceptivel para nós a capacidade desses aplicativos salvarem informações no computador para que no futuro possamos continuar o trabalho de onde paramos. Mas o que isso tem haver com serialização de objetos no Java?

Bem, quando estamos codificando em Java, nossa aplicação também poderá salvar e recuperar informações no computador. Essas informações salvas, são salvas como objetos e essas mesmas informações salvas podem ser recuperadas para uso posterior pelo nosso programa.

Basicamente a serialização de objetos nos permite salvar em arquivo objetos para que no futuro nossa aplicação recupere esse objeto a partir do arquivo ou até mesmo uma outra aplicação poderá recuperar tal objeto. Diversas linguagens trabalham com serialização de objetos. Em um post futuro, tentarei explicar como funciona a serialização de objetos no Ruby.

A serialização de objetos no Java é simples e utiliza uma interface de marcação que é a java.io.Serializable. Essa interface não possui nenhum método. Ela só serve para marcar a classe que poderá ser serializada. Quando Java internamente olhar para essa classe e ver que ela implementa a java.io.Serializable, ele saberá que essa classe é certa para a serialização.

A serialização é boa para alguns casos e ruins para outros. Em classes onde há senhas, dados confidenciais ou qualquer tipo de informação que deva ser protegida a serialização pode ser perigosa pois ela “externa” essas informações. Portanto deverá haver muito cuidado na hora de se decidir o que deve ser serializado ou não.

Nesse post mostrarei de forma bem simples e organizada como serializar o objeto para arquivo, recuperar esse objeto e exibir em console os atributos do objeto que salvamos.

Primeiramente vamos criar um objeto que iremos salvar. Eu criei uma JavaBean que representa um carro.

package com.meupost.beans;
 
import java.io.Serializable;
 
public class Carro implements Serializable {
 
	private String cor;
	private String nome;
	private String marca;
	private float valor;
 
	public String getCor() {
		return cor;
	}
 
	public void setCor(String cor) {
		this.cor = cor;
	}
 
	public String getNome() {
		return nome;
	}
 
	public void setNome(String nome) {
		this.nome = nome;
	}
 
	public String getMarca() {
		return marca;
	}
 
	public void setMarca(String marca) {
		this.marca = marca;
	}
 
	public float getValor() {
		return valor;
	}
 
	public void setValor(float valor) {
		this.valor = valor;
	}
}

Feita a nossa classe que irá ser serializada, iremos criar outra classe que será responsável por serializar o objeto da classe acima. Essa classe que iremos criar agora é a classe fundamental na serialização de objetos no Java. Vejam:

package com.meupost.serial;
 
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
 
public class Serializar {
 
	/**
	* Esse método recebe um objeto arquivo e o objeto que será serializado. 
        * O método irá serializar o objeto passado no arquivo (referenciado pelo objeto file).
	*/
	public static void salvarObjeto(File file, Object objeto) throws FileNotFoundException,
 IOException {
 
		if (objeto == null) {
			throw new NullPointerException("Objeto passado é nulo");
		}
 
		FileOutputStream fileOut = null;
		ObjectOutputStream objOut = null;
 
		try {
			fileOut = new FileOutputStream(file);
			objOut = new ObjectOutputStream(fileOut);
			objOut.writeObject(objeto);
 
		} 
		catch (FileNotFoundException e) {
			throw new FileNotFoundException("O arquivo não pode ser encontrado");
		} 
		catch (IOException e) {
			throw new IOException("Erro de entrada e saída");
		}
		finally {
			if (fileOut != null) {
				fileOut.close();
			}
 
			if (objOut != null) {
				objOut.close();
			}
		}
 
	}
 
	/**
	* Para ler o objeto serializado, nós somente precisamos no arquivo onde 
        * esse objeto está salvado.
	* Sabendo o arquivo, nós conseguimos recuperar o objeto tranquilamente.
	*/
	public static Object recuperarObjeto(File file) throws FileNotFoundException, IOException,
ClassNotFoundException {
		Object obj = null;
 
		if (file == null) {
			throw new NullPointerException("Objeto FILE é Nulo.");
		}
 
		FileInputStream fileIn = null;
		ObjectInputStream objIn = null;
 
		try {
			fileIn = new FileInputStream(file);
			objIn = new ObjectInputStream(fileIn);
 
			obj = objIn.readObject();
		}
		catch (FileNotFoundException e) {
			throw new FileNotFoundException("Arquivo não encontrado");
		}
		catch (IOException e) {
			throw new IOException("Erro de entrada e saída");
		}
		catch (ClassNotFoundException e) {
			throw new ClassNotFoundException("Erro ao recuperar objeto do arquivo");
		}
		finally {
			if (fileIn != null) {
				fileIn.close();
			}
 
			if (objIn != null) {
				objIn.close();
			}
		}
 
		return obj;
	}
}

Com essa classe pronta, nós estamos apto a serializar o nosso objeto. Assim, vamos criar a classe Main para que nós possamos testar se nossa serialização irá funcionar o não. Na classe Main nós iremos instanciar alguns objetos Carro, colocaremos esses objetos em uma List e salvaremos essa List usando a nossa classe Serializar.

Depois de serializado, nós iremos recuperar essa List e iremos iremos percorrer essa lista mostrando os objetos que foram salvo. Eu criei um método que preenche a lista com objetos carro para ficar mais organizado.

package com.meupost.main;
 
import java.io.File;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
 
import com.meupost.beans.Carro;
import com.meupost.serial.Serializar;
 
public class Main {
 
	/**
	* Na classe Main iremos testar nossa serialização. Vamos serializar uma lista
	* de objetos Carro.
	*/
	public static void main(String[] args) {
		String path = "C:\Documents and Settings\ricardo\Desktop\objeto.ser";
		File file = new File(path);
 
		try {
			List<Carro> lstCarros = preencherLista();
 
			Serializar.salvarObjeto(file, lstCarros);
			System.out.println("Objetos salvos com Sucesso!");
 
			List<Carro> novaLista =  (List) Serializar.recuperarObjeto(file);
			System.out.println("Objetos Recuperados com sucesso");
 
			Iterator<Carro> it = novaLista.iterator();
 
			while (it.hasNext()) {
				Carro car = (Carro) it.next();
				System.out.println("Nome: " + car.getNome());
				System.out.println("Marca: " + car.getMarca());
				System.out.println("Cor: " + car.getCor());
				System.out.println("Valor: " + car.getValor());
				System.out.println("==================================");
			}
 
		} 
		catch (FileNotFoundException e) {
			e.printStackTrace();
		} 
		catch (IOException e) {
			e.printStackTrace();
		}
		catch (ClassNotFoundException e) {
			e.printStackTrace();
		}
		catch (Exception ex) {
			ex.printStackTrace();
		}
	}
 
	/**
	* Cria e seta nosso objeto carro. Colocaremos esse objeto em uma lista. Tal lista,
	* contendo os objetos carro, irá ser serializada.
	*/
	public static List<Carro> preencherLista() {
		List<Carro> listaCarros = null;
 
		Carro carro1 = new Carro();
		carro1.setCor("Preto");
		carro1.setMarca("Ford");
		carro1.setNome("F-250");
		carro1.setValor(80000.50F);
 
		Carro carro2 = new Carro();
		carro2.setCor("Prata");
		carro2.setMarca("Chevrolet");
		carro2.setNome("Celta");
		carro2.setValor(26451.44F);
 
		Carro carro3 = new Carro();
		carro3.setCor("Vermelho");
		carro3.setMarca("Chevrolet");
		carro3.setNome("Corsa");
		carro3.setValor(38478.40F);
 
		Carro carro4 = new Carro();
		carro4.setCor("Amarelo");
		carro4.setMarca("Volkswagen");
		carro4.setNome("Fusca");
		carro4.setValor(2411.14F);
 
		listaCarros = new ArrayList<Carro>();
 
		listaCarros.add(carro1);
		listaCarros.add(carro2);
		listaCarros.add(carro3);
		listaCarros.add(carro4);
 
		return listaCarros;
	}
}

Feita a classe Main e verificado que não há nenhum erro de compilação, nós podemos executar nosso pequeno programa. Executando da forma que está postada aqui, a saída para console ficará assim:

Objetos salvos com Sucesso!
Objetos Recuperados com sucesso
Nome: F-250
Marca: Ford
Cor: Preto
Valor: 80000.5
=======================================
Nome: Celta
Marca: Chevrolet
Cor: Prata
Valor: 26451.44
=======================================
Nome: Corsa
Marca: Chevrolet
Cor: Vermelho
Valor: 38478.4
=======================================
Nome: Fusca
Marca: Volkswagen
Cor: Amarelo
Valor: 2411.14
=======================================

E isso pessoal, espero que tenha sido útil o tutorial e que tenham gostado. Se quiserem saber mais sobre serialização de objetos utilizando o Java, você pode achar nesses links:

  • http://en.wikipedia.org/wiki/Serialization#Java
  • http://java.sun.com/developer/technicalArticles/Programming/serialization/
  • http://www.deitel.com/articles/java_tutorials/20050923/IntroductionToObjectSerialization.html
, , , , , , ,
123