Jair Rillo Junior’s Website

Esse post é uma dica rápida para quem, como eu, precisa que a partição Windows seja montada na inicialização do Ubuntu.

A primeira coisa a fazer é abrir a shell e digitar o seguinte:

sudo gedit /etc/hal/fdi/policy/preferences.fdi

Dentro desse arquivo, haverá a seguinte entrada de código:

  <device>
    <match key="storage.hotpluggable" bool="false">
      <match key="storage.removable" bool="false">
        <merge key="storage.automount_enabled_hint" type="bool">false</merge>
      </match>
    </match>
  </device>

Mude o valor false da key storage.automount_enabled_hint para true. A nova linha deve ficar assim:

        <merge key="storage.automount_enabled_hint" type="bool">false</merge>

Agora salve o arquivo e reinicie o Ubuntu. No próximo login, sua partição Windows estará montada automaticamente.

Essa dica foi retirada do site UbuntuForunm: http://ubuntuforum-br.org/index.php?topic=48578.0

[english]
In this topic, we’re going to talk an interesting subject: How to create a project using Maven, JSF 1.2 RI, Richfaces, Tomahawk and Hibernate all together. Maybe in the first time, it’ll take long time to download the required JARs files, but believe me, after that you’ll be able to create a new project in less than 5 minutes.
You can read the full post here.
[/english]
[portuguese]
Esse artigo ensina como criar e configurar um projeto que usa Maven + JSF + RichFaces + Facelets + Tomahawk + Hibernate.
Geralmente a criação e, principalmente, a configuração de um projeto com muitos frameworks é bastante chata e demorada, porém, nesse artigo eu descrevo passo-à-passo de como fazer essa configuração sem problemas. Você pode ler o artigo aqui
[/portugese]

<english>
he next Java EE release, version 6, is going to bring us many news. Among them, EJB 3.1 seems the most interesting, in my opinion.

Although it’s a draft yet, we can make some testing using Glassfish V3. To get started, we’re going to show up how to create a single Stateless Session Bean (without interface) and package it in a WAR file… you can read the full post here.
</english>

Esse não será um post explicativo, passo à passo ou um mini-tutorial, pelo contrário, esse será um post para lembrar que Listeners podem ser um grande aliado no desenvolvimento de software em Java.

A inspiração nele surgiu recentemente quando eu precisava carregar algumas coisas quando a aplicação fosse iniciada (J2EE). Na hora eu pensei em várias alternativas, tais como: criar um Servlet e carregá-lo usando a tag <load-on-startup>1, chamar os recursos quando a primeira Action fosse executada e até mesmo extender o Listener do Struts para que meus recursos fossem iniciados junto com o mesmo. No entanto eu esqueci do óbvio: Porque eu mesmo não posso criar um Listener?

Embora a idéia seja óbvia, ela foi a última alternativa que eu pensei, mas porque? Talvez pelo fato de usarmos pouco os Listeners, ou seja, geralmente a gente cria eles uma vez e esquecemos ele rodando, já que sua manutenção é quase sempre nula. Por isso mesmo, esse post vem lembrar a todos que Listeners são elegantes e devem ser usados.

No caso do Ambiente Java EE (ou J2EE), nós temos vários Listeners: ServletContextListener, HTTPSessionListener, ServletRequestListener e por ai vai. Em JavaSE também temos listeners, principalmente aqueles agregados com Swing.

Onde usar Listeners em uma aplicação real J2EE/JEE

Um exemplo clássico de um Listener é a inicialização do objeto SessionFactory do Hibernate em um ambiente JEE. Como você deve saber, o SessionFactory deve ser criado apenas uma vez e compartilhado por toda a aplicação. Uma maneira elegante de iniciar ele é quando a aplicação é iniciada. Para isso, podemos criar um SerlvetContextListener.

Exemplo de um ServletContextListener

Para não deixarmos o post sem nenhum código, vamos dar o exemplo de um ServletContextListener. Quando a aplicação for iniciada, queremos que ela “imprima” uma mensagem no console. O exemplo é bem simples, porém o suficiente para mostrarmos o conceito e funcionamento do Listener.

Antes de montarmos o código fonte, devemos saber que para a criação de um Listener nós precisamos basicamente de duas coisas:

1. Uma classe que implementa um Listener, no nosso caso a interface javax.servlet.ServletContextListener
2. Registrar o Listener dentro do web.xml

A partir do momento que nossa classe implementa o javax.servlet.ServletContextListener, somos obrigados a implementar dois métodos:

• contextInitialized
• contextDestroyed

Como o nome diz, o contextInitialized é o método que será executado quando o servidor rodar. Portanto, podemos implementar essa classe com o código abaixo:

package com.jairrillo.listeners;
 
import javax.servlet.ServletContextEvent;
import javax.servlet.ServletContextListener;
 
/**
 * 
 * @author Jair Rillo Junior
 * email: <mailto:jrjuniorsp@yahoo.com.br>
 * gtalk: jairrillo@gmail.com
 *
 */
public class TestInitialListener implements ServletContextListener {
 
 
	/**
     * @see ServletContextListener#contextInitialized(ServletContextEvent)
     */
    public void contextInitialized(ServletContextEvent event) {
    	System.out.println("ServletContextListener acabou de ser executado....");
    }
 
	/**
     * @see ServletContextListener#contextDestroyed(ServletContextEvent)
     */
    public void contextDestroyed(ServletContextEvent event) {
        // TODO Auto-generated method stub
    }
 
}

Além disso, devemos editar o web.xml e adicionar a segiunte tag:

  <listener>
  	<listener-class>com.jairrillo.listeners.TestInitialListener</listener-class>
  </listener>

Pronto, nosso Listener já está criado e pronto para ser executado, bastante simples, certo? O procedimento acima pode ser feito para outros Listeners também, portanto, não se esqueçam de usar nossos amigos Listeners.

Deixe seu comentário abaixo caso tenha alguma dúvida ou feedback sobre esse post.

<english>Searching in the internet, I didn’t find an useful page explaining how to add hibernate depency into Maven. Although it seems an easy setup, I faced some problems that I’ll describe below. You can read the full post here.
</english>

Esse post irá tratar sobre um assunto útil mas que poucas pessoas conhecem, disjunction. O Disjunction é usado em conjunto com a API de Criteria e basicamente serve para fazer um conjunto de OR na query.

Quando estamos usando Hibernte Criteria, uma maneira de fazer OR é através do Restrictions.or, como na sintaxe abaixo:

List cats = sess.createCriteria(Cat.class)
    .add( Restrictions.like("name", "Fritz%") )
    .add( Restrictions.or(
        Restrictions.eq( "age", new Integer(0) ),
        Restrictions.isNull("age")
    ) )
    .list();

Como você pode ver no exemplo acima, criamos uma query onde existe um OR com 2 registros, porém, como poderíamos criar uma query com vários “OR”s?

Usando o Disjunction

De modo geral, o Disjunction é usado quando queremos usar um conjunto de “OR”s em uma query. Supondo que no mesmo exemplo acima, iremos adicionar mais algumas cláusulas para o campo “age”, como por exemplo. age = 1 or age = 2 or age = 3 or age = 4…Usando o Restrictions.or iria ser bastante complicado, portanto nesse caso, podemos usar o Disjunction assim:

Disjunction disjunction = Restrictions.disjunction(); 
disjunction.add(Restrictions.eq( "age", new Integer(0));
disjunction.add(Restrictions.eq( "age", new Integer(1));
disjunction.add(Restrictions.eq( "age", new Integer(2));
disjunction.add(Restrictions.eq( "age", new Integer(3));
disjunction.add(Restrictions.eq( "age", new Integer(4));
disjunction.add(Restrictions.isNull("age"));
 
List cats = sess.createCriteria(Cat.class)
    .add( Restrictions.like("name", "Fritz%") )
    .add(disjunction))    
    .list();

Como podemos ver acima, usando Disjunction o código fica bem mais claro para leitura e simples para manutenção.

Conclusão

Embora seja simples, o uso do Disjunction ainda não é muito utilizado. Eu tenho visto muito código que com o Disjunction seria mais simples. Esse post mostrou como usá-lo de uma forma rápida e prática.

Espero que esse post seja útil para alguém. Deixe seu comentário ou dúvida abaixo.

<english>Criteria, in my opinion, is the most fantastic mechanism for querying ever created….. You can read this full topic here.</english>

<pt-BR>

Como usar LEF-JOIN no Hibernate Criteria API

Criteria, na minha opinião é um dos mecanismos mais fantástico para query já criado. Hibernate possuí uma excelente API para Criteria. Porém por padrão, Hibernate criteria usa INNER JOIN internamente e dependendo da situação, ela não funciona como esperado.

Você deve saber que INNER and LEFT join são totalmente diferentes. Basicamente, INNER JOIN é usado quando ambos os lados da associação existe, enquanto o LEFT JOIN é usado quando apenas um lado (esquerdo) da associação existe. Vamos olhar um exemplo real.

Supondo que tenhamos o seguinte diagrama de classe:

Como você pode ver acima, existe um relacionamento One-to_Many entre Person e Children. Como usual, uma Person pode ter nenhum or muitos filhos, assim como um filho pode ter apenas um pai (pelo menos biológico).

Agora queremos uma lista de todas as pessoas. Se ele/ela tem filhos, mostre o nome deles, senão, mostre apenas o nome da pessoa. Para fazer isso, nós podemos criar uma HQL assim:

Query query = getSession().createQuery("SELECT p FROM Person p LEFT JOIN p.listChildren children");

Nota: Nós usamos LEFT JOIN, mas porque? Porque se a person não tem relacionamento (sem filhos), a query deve trazer os valores também. Se a query fosse como abaixo:

Query query = getSession().createQuery("SELECT p FROM Person p INNER JOIN p.listChildren children");

A pessoa sem relacionamento (sem filhos) não serão recuperadas pela query. O INNER JOIN compara os valores em amobos os lado do relacionamento. Ele não é correto para o requesito acima.

Construindo a mesma query usando Criteria

Supondo que nós vamos criar a mesma HQL acima mas usando o Criteria. A sintaxe poderia ser:

Criteria criteria = getSession().createCriteria(Person.class);
criteria.addAlias("listChildren","children");
criteria.list();

Hibernate vai ler o código acima e transformá-lo em HQL que usa INNER JOIN. O problema é que a Pessoal sem crianças não serão recuperadas do banco de dados. A pergunta é: Como mudar o comportamento padrão do Hibernate Criteria?

Usando LEFT JOIN no Hibernate Criteria

Felizmente, existe uma maneira simples de mudar o comportamento padrão do hibernate. Simplesmente adicione o argumento “CriteriaSpecification.LEFT_JOIN”. Portanto, A Criteria acima ficaria assim:

Criteria criteria = getSession().createCriteria(Person.class);
criteria.addAlias("listChildren","children",CriteriaSpecification.LEFT_JOIN);
criteria.list();

Conclusão

A API Criteria é um mecanismo muito poderoso para Query no Hibernate. Ela pode ser usada para simples e queries avançadas. Como você viu nesse post, a API de Criteria é também flexível. Aconselho a usar a API de Criteria para queries com parametros dinâmicos. Não se preocupe mais com SQL, HQL or alguma coisa a mais sem ser Objetos :).

Espero que esse tópico tenha sido útil. Pode deixar sua questão ou comentário abaixo.

<english>Java 1.5 brought an interesting feature: Annotations. Boring things, like mapping, can do now through Annotations……..You can read the full post here.</english>

Uma das regras dos testes unitários é isolar a unidade dos recursos externos, tais como: banco de dados, servidor de aplicação, arquivo xml, txt, csv, etc. Ao invés de usarmos esses recursos, o ideal é criar uma interface/classe que interage com esses recursos e, nos testes unitários, usar Mock Objects para simular o seu funcionamento. Em outros casos, podemos simular diretamente o recurso ao invés da interface/classe que interage com ela. Nesse tópico iremos aprender como simular um recurso, no caso, um arquivo .csv.

Criando a classe que interage com um arquivo .CSV

Vamos utilizar um exemplo bem simples. Uma classe (ProcessCSV) que possuí um método (getItensFromCSV) onde recebe um InputStream (o arquivo .csv) e retorna uma lista de arrays de string (List). A implementação do método poderia ser algo do tipo:

package com.jairrillo;
 
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.LinkedList;
import java.util.List;
 
public class ProcessCSV {
 
	public List<String[]> getItensFromCSV(InputStream input) throws IOException {
		//List that will be returned
		List<String[]> listItens = new LinkedList<String[]>();
		//Starting buffered reader
		BufferedReader reader = new BufferedReader(new InputStreamReader(input));
		String line;
		//going through all values from InputStream
		while ((line = reader.readLine()) != null) {
			//Split them into an array
			String values[] = line.split(";");
			//Add the array to the list
			listItens.add(values);
		}
		//Return the List
		return listItens;
	}
}

Nada muito especial na classe acima. Recebemos um InputStream como parametro, percorremos todas as linhas do arquivo, quebramos em atributos e jogamos na array de String.

A pergunta agora é: Como podemos criar uma classe do JUnit que testa esse método?

Criando a classe do JUnit

A resposta para a pergunta acima está no código abaixo:

package com.jairrillo;
 
import java.io.ByteArrayInputStream;
import java.util.List;
 
import static junit.framework.Assert.*;
 
import org.junit.Test;
 
 
public class TestProcessCSV {
 
	private static final String csvContent = 
		"line1;test;1 \n" +
		"line2;test two;10 \n" +
		"line3;test foo;12 \n" +
		"line4;test bar;21 \n";
 
	@Test
	public void testGetItensFromCSV() throws Exception {
		ProcessCSV processCSV = new ProcessCSV();
		List<String[]> listItens = processCSV.getItensFromCSV(new ByteArrayInputStream(csvContent.getBytes()));
		//Asserts
		assertEquals(4, listItens.size());
		assertEquals("line1", listItens.get(0)[0]);
		assertEquals("line3", listItens.get(2)[0]);		
	}
 
}

A classe acima é uma classe do JUnit normal. Em uma aplicação real, certamente teríamos que criar mais métodos para teste.
Analisando a classe de teste acima, existem 2 detalhes importantes:

1. O atributo csvContent simula o conteúdo de um arquivo CSV
2. A forma como esse conteúdo é passado, new ByteArrayInputStream(csvContent.getBytes()), também é importante

Dessa forma simples, podemos testar um método que lê um arquivo .CSV. A mesma técnica pode ser usada para arquivos textos, xml, properties, etc.
Antes que me perguntem, no caso de banco de dados a situação é diferente. Para esse caso aconselho sempre simular o Repositório/DAO e depois criar um teste de integração, específico na classe concreta do DAO (integrando a aplicação com o banco de dados local).

Espero que esse tópico simples, seja útil para alguém. Fiquem à vontade para deixar sua dúvida ou comentário abaixo. Você pode também fazer o download do projeto exemplo aqui.