What I have seen in many forums, and me myself was able to experience, was that if you are planning on use ICEfaces 2.0 you need JBoss 6.0. ICESoft has provided a NetBeans 6.9 community plugin that supports ICEfaces 2.0 and the problem is NetBeans 6.9 does not support JBoss 6.0.

Now you have to choose between wait until there is a NetBeans 7.0 available or build and manage your project manually. Since I didn’t want neither I decided to study NetBeans source code to see where it mentions JBoss 6.0.

I have found one of the many forums some tips about a patch that could be installed in order to make it start JBoss 6 correctly, not only it is really complicated to apply it, it is not a complete solution. This is because before starting JBoss 6 it must be correctly recognized by NetBeans 6.9 and that is the point. Using the information that is on the NetBeans bug list I found where the servers are installed, but now the problem was, what to do? That was when it occurred me that I could try checking NetBeans 7.0 source code to see what was different.

I’ve found out that I needed to change the server installation wizard and I used the “diff to” tool from NetBeans to find the files that were different the list is:

• src/org/netbeans/modules/j2ee/jboss4/ide/ui/JBPluginUtils.java
• src/org/netbeans/modules/j2ee/jboss4/ide/ui/JBInstantiantingIterator.java
• src/org/netbeans/modules/j2ee/jboss4/ide/JBLogWriter.java
• src/org/netbeans/modules/j2ee/jboss4/util/JBProperties.java

I was kind of naive to think that it would be enough however when installed I was able only to install JBoss 6 as a server but couldn’t create projects compatible with JEE6, only JEE5 was available.

Up until this point we are talking about 8 hours of stone breaking

The second part was a little more complicated because I didn’t know where to start, so I started searching the folders for any class that could contain a reference to JEE6 that is when I found that the class responsible for JBoss EE configurations was:

• src/org/netbeans/modules/j2ee/jboss4/ide/JBJ2eePlatformFactory.java

Cool! But, how could I get it to work? For the source code correction I went through the same process of “diffing” them, but the project simply stopped compiling!

What I found was that the whole NetBeans internal structured changed and this was complicated the figure out. I found that I would need to copy a new abstract class called:

• j2eeserver/src/org/netbeans/modules/j2ee/deployment/plugins/spi/J2eePlatformImpl2.java

and this wasn’t for the NetBeans JBoss support structure, this needed to be on the core libraries. But still no compilation, the project.xml needed to include a reference to the library, this was a minor problem

After the whole compilation process was through I thought it would be easier to simply copy the new jar files to my NetBeans 6.9.1 installation under the enterprise/modules folder and it worked fine!

The next step was to test everything both with and without ICEfaces 2.0, everything went fine using EJB injections, and even using the  debug feature when starting JBoss 6 under NetBeans.

And that were more 8 hours of broken stone carrying

So here is a zip file that contains the libraries ready for use. You are free to use it but I offer no warranties, so use it at your own risk. You have to unzip it under the NetBeans 6.9 or 6.9.1 folder and beware that when creating JSF/ICEfaces projects with JBoss 6 DO NOT include the jsf-api and jsf-impl into the war/ear file because it will conflict with the JBoss 6 provided libraries.

netbeans-6.9-JBoss6

If you think that all this work will help you please donate and help more solutions come to life!

Foi aí que esbarrei com o JFlex, é uma implementação em Java, baseada o JLex, sendo este último mais queixo duro. O JFlex tem uma interface gráfica bem simpática, mas que no final das contas você nem precisa usar

Uma das vantagens é que ele permite usar um modo de compatibilidade para ser usado junto com o CUP que vai analisar sintaticamente o seu programa. Assim você mata duas etapas do processo de compilação e depois pode escrever seu interpretador ou seu gerador de código!

Para facilitar a tarefa eu juntei as duas ferramentas em um “toolkit” já com 2 exemplos mastigados de como usar só o JFlex e dois de como usar a integração com o CUP. Como o pacote original do JFlex tem alguns exemplos interessantes eu deixei ele incluído no toolkit, mas já preparei os Makefiles dos projetos para referenciar a pasta lib que está no arquivo zip (baixe e descompacte no seu micro que esse parágrafo vai fazer mais sentido).

Então, para usar o JFlex é necessário entender para que ele serve antes de tudo. O objetivo dessa ferramenta gerar um programa que seja capaz de analisar uma entrada (normalmente de arquivo texto) que contém um “programa” escrito na linguagem definida e identificar se não contém algum caracter estranho ao que possa ser reconhecido. É só isso mesmo, mas escrever o analisador na mão é bem mais complicado, então por isso usamos esse tipo de ferramenta (pelo menos nos cursos de compiladores).

Para ajudar vou colocar uma figura aqui.

Temos duas areas nessa figura, uma acima do pontilhado, que é o processo de construção do analisador léxico, e a outra embaixo do pontilhado que é o uso do analisador já pronto. Neste exemplo estou trabalhando com uma linguagem fictícia chamada T1.

Uma saída comum do programa gerado pelo JFlex é uma tabela de símbolos com os valores que foram reconhecidos do programa analisado.

Para funcionar o JFlex recebe um arquivo em formato txt normalmente com a extensão .lex ou .flex, esse arquivo deve seguir um formato definido, com 3 seções separadas por %%:

1. Código do usuário – esta seção contém códigos que você precise para o seu analisador final, ela é copiada para o arquivo final
2. Definições e macros – nesta seção você define macros e seleciona as opções de configuração do JFlex
3. Regras – nesta última seção você vai definir as regras que indicam o que fazer, por exemplo retornar um símbolo, com os textos que vão sendo reconhecidos da entrada. Essas regras vão ser analisadas para gerar o autômato da linguagem que depois será codificado pelo JFlex.

É melhor colocar um exemplo bem simples aqui:

//secao do usuario, nao coloquei nada
%%
//nome da classe CalcLexer
%class CalcLexer
//ativa contagem de linhas
%line
//ativa contaagem de colunas
%column
//coloca em modo de debug que permite usar de forma isolada para testes
%debug
//macros sao escritas em expresoes regulares
LineTerminator = \r|\n|\r\n
WhiteSpace     = {LineTerminator} | [ \t\f]
dec_int_lit = 0 | [1-9][0-9]*
dec_int_id = [A-Za-z_][A-Za-z_0-9]*

%%
//regras
<YYINITIAL> {

 ";"   { return (new Yytoken(0,yytext(),yyline,yychar,yychar+1)); }
 "+"   { System.out.print(" + ");
         return (new Yytoken(0,yytext(),yyline,yychar,yychar+1)); }
 "-"   { System.out.print(" - ");
         return (new Yytoken(0,yytext(),yyline,yychar,yychar+1)); }
 "*"   { System.out.print(" * ");
         return (new Yytoken(0,yytext(),yyline,yychar,yychar+1)); }
 "/"   { System.out.print(" / ");
         return (new Yytoken(0,yytext(),yyline,yychar,yychar+1)); }
 "("   { System.out.print(" ( ");
         return (new Yytoken(0,yytext(),yyline,yychar,yychar+1)); }
 ")"   { System.out.print(" ) ");
         return (new Yytoken(0,yytext(),yyline,yychar,yychar+1)); }

 {dec_int_lit}      { System.out.print(yytext());
 return (new Yytoken(0,yytext(),yyline,yychar,yychar+1)); }

 {dec_int_id}       { System.out.print(yytext());
 return (new Yytoken(0,yytext(),yyline,yychar,yychar+1));}

 {WhiteSpace}       { /* pula, não faz nada */ }   
}
[^]      { throw new Error("Caracter inválido <"+yytext()+">"); }

Então com esse arquivo podemos gerar um analisador léxico capaz de reconhecer os caracteres necessários para escrever expressões aritméticas, mas ele não vai reconhecer se estão corretamente formadas, isso é papel do analisador sintático (que será o CUP).

Outra coisa importante desse exemplo, como estamos operando em modo debug, as regras estão retornando um objeto da classe Yytoken que deve ser fornecida (no toolkit esse exemplo está todo pronto). Quando integrarmos com o CUP o retorno será uma entrada na tabela de símbolos e por isso será do tipo inteiro.

Para encerrar, um breve comentário sobre uns métodos que aparecem na área de regras, temos:

• yytext() – retorna o texto atual reconhecido pelo lexer
• yyline – retorna o número da linha atual
• yychar – retorna o número do caracter atual

Para integrar com o CUP o uso do yytext() será muito importante, então no próximo texto veremos isso com mais detalhes.

De lá para cá muita coisa mudou, embora algunas daqueles livros continuem válidos. Resolvi então colocar aqui uma lista dos livros que um desevolvedor Java EE da atualidade deve ler para conseguir dominar esse ambiente, pelo menos são os livros básicos

1. Utilizando UML e Padrões do Craig – livro obrigatório porque discute o que é desenvolver sistemas, fala de padrões de projeto e de como fazer a análise
2. Java Persistence com Hibernate – detalha como funciona a API de persistência do Java, mas utiliza muitos detalhes relacionados ao Hibernate. O livro é muito bom porque discute em detalhes todos os problemas relacionados ao uso de bancos de dados relacionais com linguagens de programação orientadas a objetos.
3. Core Java Server Faces -  apresenta o framework da Sun para o desenvolvimento de aplicações web, desde que comecei a usar o JSF não quero mais saber de Struts não vou falar mal do Struts porque usei muito no passado, mas o JSF realmente é um modelo mais robusto e interessante. Este livro cobre todos os detalhes de como usar e como escrever uma aplicação completa.
4. EJB3 em Ação – Nenhuma aplicação Java EE está completa sem o uso de EJB, que é o modelo de componentes proposto pela Sun para a linguagem Java. Neste livro aprendemos como usar a especificação mais recente e como o uso de anotações facilita a vida do desenvolvedor que fica livre de muitos arquivos XML.
   
5. EJB3 Profissional: Java Persistence API – Um complemento ao livro de Hibernate, neste livro o leitor vai achar material relacionado apenas a especificação o que é muito bom porque, como costumo trabalhar, pode-se ficar totalmente independente da implementação de persitência.
6. Desenvolvendo Relatórios Profissionais Com iReport Para Netbeans IDE – Como toda aplicação precisa de relatórios para estar completa, nada como usar uma ferramenta poderosa e baseada em ambiente gráfico para escrever os seus. Neste livro, aprendemos a usar o plugin para Netbeans de forma gradual e bem detalhada.