Gaia Framework - utilizando API do Ant para gerar Jar

Como primeiro post técnico sobre o Gaia Framework escolhi a integração feita com a API do Ant. Mais especificamente a task que fazia a compactação dos arquivos e criar um Jar bacana. Basicamente o XML visto a baixo:

<project default="createJar">
   <target name="createJar" >
     <jar destfile="gaia-dynamic-entity-2.0.jar" basedir="." />
   </target>
</project>

O foda é fazer esse XML virar código Java. Depois de muito procurar no Google eu descobri que não sei procurar ahhahhahaha. Por isso parti pro velho e sábio método milenar da "Tentativa e Erro" ... basicamente é simples ... adicionamos o jar do Ant no projeto e vamos chutando as classes a serem usadas. Não deve ser muito difícil né? eheheheheheh

Bom para inlcuir o Jar do Ant no projeto basta que seja importada a seguinte dependência:

<dependency>
   <groupId>org.apache.ant</groupId>
   <artifactId>ant</artifactId>
   <version>1.8.2</version>
</dependency>

Segundo passo é decobrir as classes que tinha que usar, mas até que foi simples. O nome delas é igual ao das tags, veja o código Java:

package net.sf.gaia.util;

import java.io.File;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.apache.tools.ant.Project;
import org.apache.tools.ant.Target;
import org.apache.tools.ant.taskdefs.Jar;

public abstract class GaiaUtils {

  private static final Log logger = LogFactory.getLog(GaiaUtils.class);

  public final static String getGaiaPath() {
    String path = System.getProperty("gaia.dir");
    if (path == null) {
       path = System.getProperty("user.dir");
    }
    return path;
  }

  public final static String getGaiaTempPath() {
    return getGaiaPath() + File.separator + "temp";
  }

  public final static String getGaiaServicePath() {
    String path = System.getProperty("gaia.service.dir");
    if (path == null) {
       path = System.getProperty("user.dir");
    }
    return path;
  }
  public final static void createJarFile(String jarName, String classPath) {
    try {
       if (classPath == null) {
          classPath = getGaiaTempPath() + File.separator + "classes";
       }
       
       logger.info("Creating pack classes from: " + classPath + " ...");
       long l = System.currentTimeMillis();

       if (!jarName.endsWith(".jar")) {
          jarName += ".jar";
       }
       
       File jarDir = new File(getGaiaServicePath());
       if (!jarDir.exists()) {
          jarDir.mkdir();
       }
       
       File jarTempDir = new File(classPath);
       if (!jarTempDir.exists()) {
          jarTempDir.mkdir();
       }

       Project proj = new Project();
       Target target = new Target();
       Jar jar = new Jar();
       jar.setBasedir(jarTempDir);
       
       File fileJar = new File(jarDir, jarName);
       // Delete the jar file if it already exists
       if (fileJar.exists() == true) {
          fileJar.delete();
       }
       
       jar.setDestFile(fileJar);

       jar.setProject(proj);
       
       target.addTask(jar);
       target.setName("createJar");
       target.setProject(proj);
       
       proj.addTarget(target);
       proj.setDefault("createJar");
       
       jar.execute();
       logger.info("Created jar file: " + jarName + " ... " + (System.currentTimeMillis() - l) + " ms");
    } catch (Exception e) {
       logger.error("Can't create " + jarName, e);
    }
  }
}

Hibernate - Visão básica das annotation

Bom é isso vamos a mais um post e desta vez vamos falar as anotações usando o Hibernate.

Antes de mais nada vale ressaltar que para você configurar o Hibernate na sua aplicação não necessariamente você precisa usar JPA, isto é, annotation ou anotações. As configurações do banco poderiam muito bem serem feitas usando os arquivos hbm.xml, mas como isso (no meu caso) é muito chato de fazer vamos para as annotation.

Para quem tiver o interesse ou já usa mas não sabe, o Hibernate oferece uma API que serve para eliminar de vez o uso dos complexos arquivos hbm.xml para simplificar o desenvolvimento das aplicações e facilitar a manutenção. Isso graças a vantagem de que toda essa configuração fica na classe e não em arquivos separados que em muitos caso não é de fácil entendimento.

1. @Id : é a anotação de atributo que o identifica como uma chave primaria.

2. @GeneratedValue  : é a anotação de atributo que faz com que a chave primaria tenha seu valor gerado automaticamente. em geral essa anotação vem acompanhada por @Id.

3. @Entity : é uma anotação de classe que diz que o objeto em questão possui uma tabela associada no banco de dados.

4. @Table (name="table") : anotação de classe que diz o nome da tabela a qual o objeto está mapeado. Ela não é obrigatória e por tanto se não for declara a tabela terá p mesmo nome do objeto.

5. @Column (name="column", nullable=false, length=32) : anotação de atributo que o relaciona a uma coluna da tabela atribuindo as características da coluna não poder conter um valor nulo e o seu tamanho não pode passar de 32 bytes. Essa anotação não é obrigatória e por tanto se não for declara a coluna terá o mesmo nome do atributo, podendo conter valor nulo de tamanho definido no banco.

6. @Lob : anotação de atributo que identifica que ele é um tipo Clob ou Blob.

7. @OneToMany (mappedBy="order", cascade=CascadeType.ALL, fech=FetchType.LAZY)
    @OrderBy (value="id ASC")
      - anotações de atributo que declaram que é uma relação de 1-N. A anotação @OrderBy não é obrigatória.

    @ManyToOne (cascade=CascadeType.REFRESH, optional=false)
    @JoinColumn (name="order_id")
       - anotação de atributo que declara que é uma relação de N-1. A anotação @JoinColumn só é necessário quando não houver explicitamente um campo que una as duas tabelas.

8. @Temporal (value=TemporalType.DATE) : anotação de atributo que descreve a precisão esperada no banco de dados.

9. @OneToOne (optional=true, cascade=CascadeType.ALL, mappedBy="person") : anotação de atributo que o associa a um objeto também mapeado por @Entity. Há casos em que é necessário utilizar a anotação @JoinColumn para dizer explicitamente a associação, exemplo:
   @OneToOne (optional=false, cascade=CascadeType.ALL, mappedBy="person")
   @JoinColumn (name="Person_ID", referencedColumnName="personid", unique=true)
    - anotação de atributo 1-1.

10. @ManyToMany (mappedBy="students") : anotação de atributo que declara que é uma relação de N-N. Há casos em que é necessário utilizar o @JoinColumn para dizer explicitamente a associação, exemplo:
     @ManyToMany (cascade=CascadeType.PERSIST, fetch=FeatchType.LAZY)
     @JoinColumn (name="Teacher_Student",
             joinColumns = (@JoinColumn (name="Teacher_ID", referencedColumnName="teacherid")),
             inverseJoinColumns = (@JoinColumn (name="Student_ID", referencedColumnName="Studentid")))

11. @Transient : anotação de atributo que que indica que ela não está mapeada na tabela e deve ser ignorada.

12. @Cache (usage=CacheConcurrencyStrategy.READ_WRITE) : anotação de classe que indica que para essa aplicação o objeto em questão usa cache.

Pivot - Hello World com Maven

Saudações Rangos!

Esse post vai tratar de ajudar a fazer seu primeiro "hello world!" no Apache Pivot. Deve estar se perguntando o porque disso? Bom é simples. O tutorial que tem no site oficial está errado! E também vou aproveitar para dar uma desenferrujada e digitar um pouco ... eheheheh.

Bom para inicio de conversa eu estruturei meu exemplo no Maven. Porque? Porque eu gosto da maneira que o Maven gerencia minhas dependências de outros jars, segue o meu POM:

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>net.sf.gaia.test</groupId>
    <artifactId>pivot-tutorial</artifactId>
    <name>Pivot Maven Tutorial</name>
    <version>1.0-SNAPSHOT</version>

    <dependencies>
        <dependency>
            <groupId>org.apache.pivot</groupId>
            <artifactId>pivot-core</artifactId>
            <version>1.4</version>
        </dependency>
        <dependency>
            <groupId>org.apache.pivot</groupId>
            <artifactId>pivot-wtk</artifactId>
            <version>1.4</version>
        </dependency>
        <dependency>
            <groupId>org.apache.pivot</groupId>
            <artifactId>pivot-web</artifactId>
            <version>1.4</version>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>2.0.2</version>
                <inherited>true</inherited>
                <configuration>
                    <source>1.6</source>
                    <target>1.6</target>
                    <encoding>UTF-8</encoding>
                </configuration>
            </plugin>
    </build>
</project>

Basicamente no POM eu adicionei as dependências utilizada no tutorial para compilar a classe. E também adicionei o pluging para compilar utilizando o Java 6 com codificação de texto UTF-8.

A classe de exemplo eu usei a mesma que está no site oficial Apache Pivot - Hello World, mas segue ele ai:

package org.apache.pivot.tutorials;

import java.awt.Color;
import java.awt.Font;

import org.apache.pivot.collections.Map;
import org.apache.pivot.wtk.Application;
import org.apache.pivot.wtk.DesktopApplicationContext;
import org.apache.pivot.wtk.Display;
import org.apache.pivot.wtk.HorizontalAlignment;
import org.apache.pivot.wtk.Label;
import org.apache.pivot.wtk.VerticalAlignment;
import org.apache.pivot.wtk.Window;

public class HelloJava implements Application {
    private Window window = null;
 
    @Override
    public void startup(Display display, Map<String, String> properties) {
        Label label = new Label();
        label.setText("Hello World!");
        label.getStyles().put("font", new Font("Arial", Font.BOLD, 24));
        label.getStyles().put("color", Color.RED);
        label.getStyles().put("horizontalAlignment", HorizontalAlignment.CENTER);
        label.getStyles().put("verticalAlignment", VerticalAlignment.CENTER);
 
        window = new Window();
        window.setContent(label);
        window.setTitle("Hello World!");
        window.setMaximized(true);
        window.open(display);
    }
 
    @Override
    public boolean shutdown(boolean optional) {
        if (window != null) {
            window.close();
        }
 
        return false;
    }
 
    @Override
    public void suspend() {
    }
 
    @Override
    public void resume() {
    }
 
    public static void main(String[] args) {
        DesktopApplicationContext.main(HelloJava.class, args);
    }
}

O que mais incomodo não foram nem o Maven e nem o classe. O que estava errado mesmo era o código HTML para adicionar a Applet e ver o exemplo funcionando. Tudo por causa de um que no tutorial era dito para usar o parâmetro "applicationClassName" quando na verdade era para ser usado "application_class_name". Esse simples troca já da uma dor de cabeça, segue como ficou:

<applet code="org.apache.pivot.wtk.BrowserApplicationContext$HostApplet" archive="lib/pivot-core-1.4.jar,lib/pivot-wtk-1.4.jar,lib/pivot-wtk-terra-1.4.jar,lib/pivot-tutorial-1.0-SNASHOT.jar" width="400" height="200" >
     <param name="application_class_name" value="org.apache.pivot.tutorials.HelloJava" >
</applet>

Java - Manipulação de String

E ai pessoal, passei na SCJP e finalmente consegui tempo para terminar esse post ehehe :D ... Valeu ai a toda ajuda, mas agora voltando aos post queria falar um pouco sobre algo que me chamou muita atenção no estudo de Java - Manipulação de String. Parece simples né? Na verdade não é bem assim, vou justificar.

Todo mundo sabe que em Java você tem dois tipo de variáveis de referência, uma para tipos primitivos: int, float, double, boolean, char, shot e long(não sei se esqueci de algum) e outra que são referências aos objetos, isto é, as classes em si que você utiliza no seu dia a dia.

Essas classes em especial por padrão estendem a classe Object, isso é, todas os objetos no Java são derivados da classe Object (menos a propia Object ... obvio né ehehehe).

Mas tá e porque escrever um post sobre a classe String? Que que ela tem de diferente? Bom é que diferente dos outros objetos a uma String só pode ser criada uma vez, ela nunca poderá ser modificada. Então o que acontece quando um objeto String parece estar se modificando? Vamos ao exemplo:

String ola = "Ola!";

Vejamos, o que temos é uma variável de nome ola que serve se referência para um objeto String com valor "Ola!", até ai tudo bem né? Mas se continuarmos:

String olaAux = ola;
ola = ola.concat(" Como vai?");
if (ola.equals(olaAux))
      System.out.print("Igual");
else
      System.out.print("Diferente");

Uh que código mais tosco deve estar pensando hehehe ... Mas e ai, o que vai aparecer na saída? Resposta: "Diferente". Pode testar se não acreditar.

Intrigado? Bem isso é normal, mas lembre-se que comentei que uma variável String nunca pode ser modificada, então o que aconteceu? Simples, Quando criamos a variável se referência olaAux a atribuímos o valor de ola. Depois quando usamos o método concat adicionamos no final da String o valor " Como vai?", mas como String não pode ser mudada a JVM cria uma nova instância de String somando os dois valores "Ola!" e " Como vai!". Assim a variável ola passa a apontar para uma nova instância se String com valor "Ola! Como vai?", enquanto que olaAux continua apontando para "Ola!".

Vale destacar que a JVM cria uma lista da memória de todas as Strings que são criadas, isso quer dizer que no nosso exemplo foram criadas cinco Strings nessa lista. Cinco? Sim! Cada String criada no texto é adiciona na lista, são elas: "Ola!", " Como vai?", "Ola! Como vai?", "Igual" e "Diferente".

A JVM cria essa lista como uma forma de otimizar a utilização de memória, assim se diversas variáveis de String precisarem utilizar o mesmo conteúdo elas irão apontar para a mesma referência e não ficar criando novas instâncias todas as vezes que precisar.

Bom esse foi só um breve resumo, se quiserem mais detalhes o livro do SCJP tem um capitulo inteiro sobre Strings. Até mais!

jQuery - Boas práticas com FreeMarker/Velocity

Primeiramente é bom estar escrevendo novamente hehehe. Faz tempo que queria postar algo mas sempre (por algum inconveniente ou destino) ficava sem tempo. Bom vamos lá ...
Antes de tudo tu já deves ou pelo menos tem uma noção de para que utilizamos ferramentas como Freemarker ou mesmo o Velocity? Não?? ... Eu gosto de falar deles com geradores de código HTML em tempo de execução, isto é, essas ferramentas me possibilitam criar componentes em código HTML a partir de um modelo pré-definido. Conseguiu entender agora? Se a reposta ainda é não fique tranquilo, isso é mais fácil do que parece.
Bom, nada melhor do que um exemplo não é? Então supondo que o modelo gere um código HTML onde eu tenho um Label (contendo a tescrição do item) e um Input (que receberá valores passados pelo usuário), algo mais ou menos assim:

Descrição do Item:

O código Java por sua vez irá passar alguns váriáveis para o modelo. Neste exmplo vou usar o Velocity, segue:

VelocityContext context = new VelocityContext();
context.put("id", "my_velocity_id"); //id padrão
context.put("isEditable", true); //se o Input pode ser editado

context.put("text", "Descrição do Item"); //adicionado a Label
context.put("value", "Valor do Item"); //adicionado ao Input

StringWriter w = new StringWriter();
Velocity.mergeTemplate("myTemplate.vm", "UTF-8", context, w);

E por sua vez temos o código do arquivo myTemplate.vm:
<center>
     <div style="border:1px solid black; padding: 2px 2px 2px 2px">
        <label id="${id}_label_">${text}</label> <input id="${id}_input_" value="${value}" />
     </div>
</center>

Espero que você que estava meio em dúvida se tinha entendido ou não tenha compreendido como isso funciona. Senão não adianta continuar hahaha ... brincadeira.
Exemplinho até agora foi bonito mas não falamos nada de jQuery, bom se você prestou atenção viu que meu código Java está passando um parâmetro que não está sendo utilizado no Velocity. Consegue descobrir? ... hehehe ... se olhar bem verá que tem o parâmtro isEditable não é usado de modo algum no myTemplate.vm. Mas então para que serve? Bom se você lembra o assunto do tópico verá que queremos usar jQuery no nosso Velocity, para isso vamos usar o parâmetro isEditable para gerar um código JavaScript e modificar o nosso Input, tudo isso usando uma linha do jQuery :D ... segue o novo myTemplate.vm:
<center>
     <div style="border:1px solid black; padding: 2px 2px 2px 2px">
        <label id="${id}_label_">${text}</label> <input id="${id}_input_" value="${value}" />
     </div>
</center>
## Se isEditable for false
#if (!${isEditable})
  <script type="text/javascript">
     ## modo normal de utilizar no Velocity -- funciona!
     $("#"+"${id}_input_").attr("readonly","readonly");
  </script>
#end

Repare que em vez de eu usar o seletor do jQuery como uma só string acabei separando em duas: "#" e "${id}_input_". Isso porque se o # ficar ao lado do $ a API não irá gerar corretamente a tag, causando um transtorno e que sem dúvida o fará perder muito tempo.
Note que # e $ são palavras a ferramenta também utiliza internamente. Por isso alguns sites aconselham que em vez de usar: $(seletor), utilizar a forma extença jQuery(seletor).

Java - Pré-Processadores

Bom antes de tudo o que é um pré-processador? Bem, eu vejo ele como um "if else" do compilador, como assim? Tipo se o argumento que eu passar estiver definido na VM então aquele trecho de código é carregado senão carrega outro ou no para ser mais extremo não carrega nada.

Pré-processadores não são usados no J2SE, pelo menos eu nunca vi! Mas no J2ME não é muito difícil de ver implementações de código que não possuam um ou mais instruções de um pré-processador, ainda mais quando a aplicação é feita para rodar em aparelhos diferentes com APIs nada parecidas.

Para declarar o uso de pré-processador basta iniciar a linha com //# e em seguida escrever o argumento. Como um exemplo sempre é bom e facilita as coisas, segue:

//#ifdef XMOBILE
public class MyApp extends MyCanvas {
//#else
public class MyApp extends Canvas {
//#endif

Veja que esse exemplo é uma quebra em quem está acostumado basicamente com o puro Java. Nesse exemplo acima vemos que se XMOBILE não estiver definido a classe MyApp estenderá Canvas ao invés de MyCanvas, isso muda ela completamente, consegue ver?

Veja que se eu quisesse ser mais radial poderia escolher qual os pacotes que eu vou incluir e quais eu não vou:

//#define MIDP2
//#ifdef MIDP2
import javax.microedition.media.*;
import javax.microedition.media.control.*;
import javax.microedition.media.control.ToneControl;
//#endif
//#ifdef NOKIAUI
import com.nokia.mid.sound.*;
import com.nokia.mid.ui.*;
//#endif
//#ifdef MOTOROLA
import com.motorola.multimedia.*;
//#endif
import javax.microedition.lcdui.*;
import java.io.*;

Veja que agora eu primeiramente defino o que vou usar e depois testo. Isso é só para salientar e melhorar o entendimento sobre o funcionamento. Também não deve se limitar em achar que o //#define MIDP2 deve ser inserido sempre antes do teste, isto é, na mesma classe. Não! Ele pode ser definido a qualquer momento da execução. Uma boa prática é inseri-los na classe que é carregada primeiro pelo MIDlet.

Jad - Decompilador Java

Quem nunca ficou curioso quando após compilar uma classe Java, olhar para o .class gerado e se perguntar: "será que tem como voltar?" Bom meus amigos tem!

Um exemplo é o Jad (JAva Decompiler). Eles é um programa que faz o serviço sujo de decompilar um .class para um .jad (que na verdade é o .java "diferente" ehehe).

Você pode simplesmente baixar o Jad e executa-lo pela linha de comando:
      joppi@joppi:~$ jad MyTest.class

Vai ver que no mesmo diretório apareceu um MyTest.jad, se quiser pode renomear para MyTest.java que não vai ter problema. Esse arquivo já é um arquivo Java semelhante ao original. Sim semelhante!

O Jad também conta com uma interface gráfica, o JadClipse. Sim é um plugin do eclipse! Qualquer dúvida clique aqui ou se preferir ir direto pode usar o update do Eclipse: http://jadclipse.sf.net/update ou baixar o jar no site: http://sourceforge.net/projects/jadclipse.