Demoiselle e Partenon no I BootCamp Xanxerê

Este final de semana aconteceu o I BootCamp na cidade de Xanxerê organizado pela UNOESC XXE e o grupo OeSC Livre. Eu estive presente apresentando sobre o Framework Demoiselle e o Partenon, este último sendo meu projeto de TCC em conjunto com o Luiz Felipe Bartz e o Professor Orientador Roberson J. F. Alves.

As palestras estavam muito interessantes e o evento foi um sucesso.

Para quem quiser visualizar a apresentação segue o link no slideshare: http://goo.gl/O350l.

Padrões de Projeto: Bala de Prata?

Para quem não entendeu o título, fique tranquilo vou explicar o que significa. O que quero levantar é o seguinte: Será que padrões de projeto são sempre a melhor solução para tudo, todos os problemas de OO, etc?

Os Padrões de Projeto foram criados para solucionar problemas comuns no desenvolvimento de software. Eles já foram usados, testados e aprovados. Quanto a isso não há dúvida, mas o que devemos prezar é: o código deve ser simples de ler, entender e manter. De que adianta matar uma formiga com um canhão?

Um dos princípios do movimento ágil é: não antecipe o problema, apenas resolva o problema que você tem no momento. Há muitas pessoas por aí procurando lugar no código para aplicar um padrão. Em primeiro lugar, os padrões nasceram de uma necessidade, então você deve sentir esta necessidade para tentar resolver o problema usando padrões de projeto.

Na minha humilde opinião os padrões auxiliam e muito, quando há necessidade de implementá-los, não saia por aí caçando oportunidades para implementar padrões no seu projeto e dizer “Eu uso padrões de projeto, sou o cara”.

Criando Web Service em Java com JAX-WS

JAX-WS é a nova especificação para web services na plataforma Java, você pode saber mais procurando pela JSR-224.

Com base na JSR-224 o projeto Glassfish desenvolveu uma implementação de referência chamada RI JAX-WS. Que mais tarde foi fundido com o projeto Glassfish WSIT que visava dar o RI JAX-WS maior interoperabilidade.

Desta junção originou-se o Glassfish Metro que hoje é a implementação que possibilita a maior compatibilidade com diferentes plataformas e tipos de web services, como os RPC-Style.

Agora que conhecemos um pouco o que será utilizado, vamos por a mão na massa!

Crie um projeto WEB na IDE de sua preferência. Eu utilizei o Netbeans 7.0 juntamente com o o Tomcat 7.0.

Após ter o projeto criado vamos fazer o download do metro. Para este projeto baixei o arquivo:  metro-standalone-2.1.1.zip.. Após finalizar o download descompacte o arquivo e copie o conteúdo da pasta lib para o classpath do seu projeto.

Depois de copiar o metro podemos iniciar nosso web Service, que terá como função: Receber um objeto Pessoa e retornar uma string saudando a Pessoa pelo seu nome.

Segue a implementação da classe Pessoa:

public class Pessoa {

    private String nome;
    private String email;
    private String telefone;

    //Getters e Setter omitidos
}

A seguir crie a classe HelloService, que será a implementação do WebService:

@WebService
public class HelloService {

    @WebMethod(operationName="sayHello")
    public String sayHello(@WebParam(name="pessoa") Pessoa p){
        return "Hello " + p.getNome();
    }
}

Podemos notar a simplicidade em definir o WebService. Veja a anotação @WebService é ela que diz que esta classe é um WebService. Após a definição da classe podemos observar o método público criado, este método processará a chamada, recebendo um parâmetro com um objeto Pessoa.

O método sayHello também está anotado, porém com @WebMethod, esta anotação informa que o método será publicado, o mesmo acontece com o parametro, que está anotado com @WebParam.

OBS: As anotações no método e atributos não são obrigatórias, possibilitando a criação do webservice sem elas. Porém é altamente recomendado que sejam utilizadas as anotações para não termos problemas posteriores.

Após a criação das classes é necessário configurar o arquivo web.xml. Vamos adicionar um servlet que receberá as requisições para o web service criado, e um listener que fará a leitura do arquivo sun-jaxws.xml que contém a implementação do serviço.

O arquivo sun-jaxws.xml ainda não existe, portanto crie-o dentro da pasta WEB-INF com o seguinte conteúdo:

<?xml version="1.0" encoding="UTF-8"?>
<endpoints version="2.0" xmlns="http://java.sun.com/xml/ns/jax-ws/ri/runtime">
  <endpoint implementation="seupacote.HelloService" name="HelloService" url-pattern="/HelloService"/>
</endpoints>

Altere o arquivo web.xml adicionando o seguinte conteúdo:

<listener>
    <listener-class>com.sun.xml.ws.transport.http.servlet.WSServletContextListener</listener-class>
</listener>
<servlet>
    <servlet-name>HelloService</servlet-name>
    <servlet-class>com.sun.xml.ws.transport.http.servlet.WSServlet</servlet-class>
    <load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
    <servlet-name>HelloService</servlet-name>
    <url-pattern>/HelloService</url-pattern>
</servlet-mapping>

Após terminar estas configurações seu WebService esta pronto para ser executado. Você pode visualizar o WSDL gerado acessando http://seuhost:suaporta/SuaApp/HelloService?wsdl.

Bons estudos.

Usando Demoiselle Framework com Netbeans e Tomcat.

O Demoiselle Framework é construído a partir do conceito de framework integrador, integrando diversas ferramentas utilizadas no mercado Java. Tem como objetivo facilitar o desenvolvimento de aplicações, privando o desenvolvedor de perder tempo escolhendo os frameworks especialistas que serão usados no seu projeto, resultando grande aumento da produtividade, e facilita a manutenção dos sistemas. Possui mecanismos facilitadores voltados à resolução dos problemas mais comum em uma aplicação, entre eles estão arquitetura, segurança e configuração.

O framework contém uma estrutura não monolítica, ou seja, as funcionalidades estão separadas do núcleo principal, esta forma de organização permite que aplicações específicas não necessitem compor dependências que não serão usadas.

A estrutura do Demoiselle é dividida em Core, que contém as funcionalidades que são comuns a todas aplicações, é a base, o núcleo propriamente dito. Extensões por sua vez são funcionalidades extras extremamente ligadas ao núcleo, porém específicas a um domínio, como é o caso de JPA e JSF, pois algumas aplicações não fazem uso de persistência, não fazendo sentido estar no núcleo. Por fim os Componentes, que são artefatos independentes do núcleo, não precisam estender as funcionalidades do core, têm ciclo de vida próprio, não precisa necessariamente fazer uso do Demoiselle.

(Os parágrafos acima foram retirados do meu Projeto de TCC, no qual estou usando Demoiselle. )

Para o gerenciar o projeto é utilizado o Apache Maven, não estando preso a este. Porém uma das vantagens de usar o Maven é a possibilidade de usar os arquétipos, que são modelos de aplicações.

A execução do projeto foi feita utilizando a IDE Netbeans 7.0, justamente pelo maior suporte ao Maven, que nas versões anteriores não é tão completo. Pode ser que funcione com versões anteriores, mas os recursos do maven serão mais precários.

Nosso projeto usará um arquetipo de uma aplicação JSF com JPA. Este arquétipo contém uma aplicação simples de bookmark (links favoritos). A partir desta simples aplicação é possível entender os principais conceitos do Demoiselle.

Agora vamos ao que interessa!!! No Netbeans clique em Novo Projeto, na Categoria Maven selecione Projeto do Arquetipo.  Clicando em próximo você visualizará uma tela com vários arquetipos que estão disponíveis nos repositórios do Maven. o Arquetipo do demoiselle não está nestes repositórios. Clique em Adicionar para inserir um arquetipo externo. Os arquétipos disponibilizados pela aquipe do demoiselle estão disponíveis aqui. Os dados abaixo são referentes ao arquetipo demoiselle-jsf-jpa.

groupId: br.gov.frameworkdemoiselle.archetypes
artifactId: demoiselle-jsf-jpa
version: 2.1.2
repository: http://demoiselle.sourceforge.net/repository/release

Selecione o arquétipo criado e clique em próximo. Após informar os dados do projeto clique em Finalizar. Nesta etapa o maven irá indexar os repositórios e baixará as dependências necessárias para o projeto. Pegue um café, pois este processo demora certo tempo.

Após criar o projeto e baixar as dependências, são necessárias algumas configurações para que seja possível rodar o projeto no Tomcat. Para este tutorial foi usado o Tomcat 7 pois é a versão mais nova e que atende maior quantidade de recursos do JEE 6. Podendo não funcionar em versões anteriores.

Primeiramente devemos escolher a configuração do Maven Profile do projeto, no netbeans esta configuração é feita no combobox que está localizado próximo ao botão executar na barra de ferramentas, selecione tomcat7.

Após isso habilitaremos o listener do Weld (framework para CDI) no arquivo web.xml, devendo ser adicionado o seguinte conteúdo:

<listener>
    <listener-class>org.jboss.weld.environment.servlet.Listener</listener-class>
</listener>

Provavelmente este trecho apenas estará comentado, bastando apenas remover os comentários.

O próximo arquivo a ser alterado é o persistence.xml, que está localizado na pasta Outros códigos-fonte, em META-INF. Novamente nossa Persistence Unit (Unidade de persistência JPA) estará comentada, descomente a Persistence unit que está localizada abaixo do seguinte comentário: <!–If you are using tomcat6/tomcat7 then use this persistence-unit–>. Esta é a única persistence unit que deve estar neste arquivo.

O arquivo deve ficar com o seguinte conteúdo:

<persistence-unit name="bookmark-ds" transaction-type="RESOURCE_LOCAL">

    <class>com.mycompany.teste.domain.Bookmark</class>

    <properties>
        <property name="javax.persistence.jdbc.driver" value="org.hsqldb.jdbcDriver" />
        <property name="javax.persistence.jdbc.user" value="sa" />
        <property name="javax.persistence.jdbc.password" value="" />
        <property name="javax.persistence.jdbc.url" value="jdbc:hsqldb:hsql:." />

        <property name="eclipselink.logging.level" value="FINE" />
        <property name="eclipselink.ddl-generation" value="create-tables" />
        <property name="eclipselink.ddl-generation.output-mode" value="database" />
    </properties>
</persistence-unit>

Na mesma pasta devemos alterar o arquivo beans.xml, para ativar a estratégia de transação JPA do Demoiselle. Deixe apenas uma linha contendo a seguinte entrada:

<alternatives>
    <class>br.gov.frameworkdemoiselle.transaction.JPATransaction</class>
</alternatives>

Após estas configurações o projeto estará apto a rodar, o arquétipo vem configurado com uma base de dados padrão que é iniciada com o projeto.  O banco de dados utilizado é o HSQLDB.

Para compilar o projeto execute Shift+F11 ou Limpar e Construir, após finalizado este processo você verá no final do console a saída ‘BUILD SUCCESS’. Agora você pode executar seu projeto usando F6 ou Executar. Quando for clicado em executar aparecerá uma mensagem pedindo o servidor onde será executado o projeto. Selecione o Tomcat 7, e marque em lembrar permanentemente.

Sempre que você executar o projeto é indicado que você pare o servidor Tomcat. Pois quando o projeto é compilado, o maven altera alguns arquivos que estão em uso pelo servidor. Gerando um erro de compilação.

Para alterar a base de dados é possível alterar o persistence.xml com as configurações que desejadas e adicionar a dependência do driver JDBC que você quer usar.

Finalizo aqui este post sobre o Demoiselle, o primeiro de uma série de muitos, espero. Caso tiver dúvidas eu sugestões deixe um comentário.

Caso haja interesse de interagir com a comunidade demoiselle, acesse o site, onde você pode se inscrever na lista de discussão, o pessoal do demoiselle está sempre ajudando os iniciantes através deste meio. O Demoiselle e sua comunidade estão de parabéns.

Fontes:
Framework Demoiselle 2.0: Guia de Referência: <http://demoiselle.sourceforge.net/docs/reference/2.0-v6/pdf/demoiselle-reference.pdf>

XML com XMLBeans

O que é, o que faz o XmlBeans?
Segundo a descrição do site, XMLBeans é uma tecnologia para acessar Xml e fazer binding a tipos Java. XMLBeans provê várias formas de acesso a XML, incluindo:

• Através de XML Schemas que foram compilados para gerar tipos Java que representam tipos de Schema, Desta forma, você pode acessar instâncias do schema através de JavaBeans no estilo “getFoo” e “setFoo”.
• A API XMLBeans também permite refletir o Schema para um modelo de Objeto XML Schema.
• Modelo de Cursor pelo qual você pode percorrer o XML inteiro.
• Suporte a DOM XML.

Então no meu caso usei o XMLBeans para gerar os beans de acesso ao xml,  para isso devo ter em mãos o Schema para validação do XML.

Primeiramente devemos baixar o XMLBeans, o site é : http://xmlbeans.apache.org, selecione download e binary releases. Eu usei o mirror recomendado por eles e baixei a versão xmlbeans-2.5.0.zip.

Extraia o arquivo e coloque na raiz do Sistema, no meu caso: C:xmlbeans, e crie uma variável de ambiente com o nome XMLBEANS_HOME e como valor coloque a raiz do XMLBeans (C:xmlbeans), e adicione a variável de ambiente path a pasta bin do XMLBeans: %XMLBEANS_HOME%bin.

Eu tive problemas com as minhas variáveis de ambiente Java, por isso tive que rodar os comandos direto da pasta bin do meu JDK.

No meu caso o XMLBeans irá gerar um jar com os beans de acesso a partir de um schema que eu tenho.

O comando que usei foi o seguinte:

cd %JAVA_HOME%bin
scomp -out c:beans.jar c:schemasmySchema.xsd

Sendo que beans.jar é o jar com as classes para acessar o XML, e mySchema.xsd é o schema do XML.

É necessário adicionar o arquivo beans.jar e as bibliotecas que estão em %XMLBEANS_HOME%lib no diretório das libs do seu projeto.

Segue exemplo de uso em Java, neste exemplo eu li o Xml da NFe.

try {
    // O construtor pode ser chamando de várias formas mas as que eu usei foram
    // passar um File e uma string contendo o xml
    //NfeProcDocument doc = NfeProcDocument.Factory.parse( xmlString );
    NfeProcDocument doc = NfeProcDocument.Factory.parse(new File("c://arquivo.xml"));

    //todos os nodos do xml pode ser acessados via get e set
    System.out.println(doc.getNfeProc().getNFe().getInfNFe().getId());
}catch (Exception e) {
    e.printStackTrace();
}

Existem outros comandos que podem ser usados, aqui está uma lista deles: http://xmlbeans.apache.org/docs/2.0.0/guide/tools.html.
E aqui está o tutorial de primeiros passos: http://xmlbeans.apache.org/docs/2.0.0/guide/conGettingStartedwithXMLBeans.html