Olá a todos,

Esta semana eu terminei de migrar o blog do WordPress para um domínio próprio chamado jamacedo.com. O motivo da migração foi basicamente as limitações impostas para os blogs hospedados no WordPress.com, entre elas: plugins e temas… todos os posts e comentários já estão disponíveis no novo domínio.

Se você está conhecendo agora ou deseja continuar acompanhando, peço que acesse jamacedo.com. Minha primeira meta para 2011 já será publicar com maior frequência !

Desejo a vocês um Feliz Natal e um 2011  cheio de realizações!

Abraços,

José Alexandre Macedo

Bom dia a todos,

Gostaria de compartilhar com vocês, com grande felicidade, que meu primeiro artigo na revista Java Magazine está nas bancas  neste mês de Novembro. Neste artigo apresento o funcionamento dos componentes customizados no JSF 2, além de uma aplicação utilizando esta e outras técnicas do JSF 2.

Quero agradecer o convite e a paciência do editor Eduardo Spínola e o apoio dos amigos e da professora Melise.

Também quero parabenizar o Eduardo e sua equipe pela iniciativa no desenvolvimento da nova revista Easy Java Magazine (disponível gratuitamente). Esta nova revista com certeza será de grande  importância para os desenvolvedores que estão iniciando com a linguagem Java.

Espero que este possa ser apenas o primeiro de outros artigos que eu venha a escrever para a revista. Não pretendo manter o foco exclusivamente no JSF, sendo que os assuntos serão abordados conforme as tecnologias e novidades que eu estiver trabalhando e aprendendo.

No mais agradeço também a você que visita o blog, estou sempre aberto para dúvidas, críticas e sugestões!

Abraço a todos,

José Alexandre Macedo

Este blog possui um novo domínio agora jamacedo.com, clique aqui para acessá-lo!

O site de hospedagem e compartilhamento de imagens Flickr disponibiliza para os desenvolvedores acesso as suas funcionalidades através de uma API de serviços REST. Com esta API o desenvolvedor pode soltar a imaginação e criar novos aplicativos, inclusive interagindo também com outros serviços disponíveis na web. Quem estiver interessado em conhecer os aplicativos criados utilizando a API do Flickr pode acessar o App Garden. Este site é uma iniciativa da própria empresa para reunir os aplicativos que utilizam o Flickr.

Mas por que eu precisaria do Netbeans para consumir os servicos do Flickr?

Não, você não precisa do Netbeans para utilizar os serviços. Entrentanto, a IDE disponibiliza um esquema de drag and drop que facilita muito algumas parte do trabalho. Nós veremos neste tutorial como utilizar este esquema para ter acesso a álbuns e fotos de forma simples e rápida.

Lembrando que o Netbeans auxilia no acesso à serviços de diversas outras APIs como por exemplo, Facebook, Google, Delicious, Twitter, Yahoo e muitas outras que não serão tratadas neste post. Porém a estratégia utilizada nas demais APIs é semelhante e você podera tomar como base este tutorial para trabalhar com outros serviços.

1º Passo

A primeira coisa a se fazer é criar uma conta no Yahoo(caso você já não tenha) para ter acesso ao Flickr. Ter acesso ao Flickr é importante porque você precisará registrar um aplicativo no App Garden.

2º Passo

Com acesso ao Flickr você deve ir a esta página para Criar um novo aplicativo. Precisamos desta etapa porque o Flickr só fornece permissão para uso dos serviços se a aplicação tiver uma chave e um segredo específicos para ela. O Flickr não cobra nada para registrar a aplicação e fornecer a chave. Nós utilizaremos esta chave e o segredo alguns passos a frente.

Ao acessar a página de criação de aplicativo você verá o seguinte:

Como nosso objetivo não é comercial escolha a opção SOLICITAR UMA CHAVE NÃO COMERCIAL.

3º Passo

Agora escolha um nome para sua aplicação, forneça uma pequena descrição, aceite os termos de compromisso e clique em ENVIAR. Após enviar você terá acesso a sua chave e seu segredo da mesma forma que a figura abaixo:

Anote a chave e o segredo em algum lugar para usarmos logo mais.

4º Passo

Vamos partir para o Netbeans agora.

Crie um Novo Projeto Java para desktop.

5º Passo

Agora crie uma classe com um método main.

Testaremos os serviços dentro deste método. Será nele que  iremos arrastar e soltar um método do serviço do Flickr.

6º Passo

Agora vá até a aba Serviços que fica ao lado das abas Arquivos e Projetos   e busque o seguinte nó da árvore Flickr –> Photo Service –> services –> rest –> photosets_getList e arraste e solte o método photosets_getList para dentro do método main da classe que você criou. Aparecerá a seguinte tela:

Apenas clique em OK pra que os códigos necessários terminem de ser gerados.

Após o OK será gerado o seguinte código para você:

import org.netbeans.saas.flickr.FlickrPhotoService;
import org.netbeans.saas.RestResponse;

public class Main {

    public static void main(String[] args) {

        // início do código que será gerado -------------------------
        try {
            String userId = null;

            RestResponse result = FlickrPhotoService.photosetsGetList(userId);
            if (result.getDataAsObject(flickr.photoservice.flickrresponse.Rsp.class) instanceof flickr.photoservice.flickrresponse.Rsp) {
                flickr.photoservice.flickrresponse.Rsp resultObj = result.getDataAsObject(flickr.photoservice.flickrresponse.Rsp.class);
            }
            //TODO - Uncomment the print Statement below to print result.
            //System.out.println("The SaasService returned: "+result.getDataAsString());
        } catch (Exception ex) {
            ex.printStackTrace();
        }
        // fim do código que será gerado -------------------------------
    }
}

O objeto resultObj é responsável, neste caso, por conter a lista de todos os álbuns de um usuário. É este objeto que iremos manipular.

Para termos acessos a lista dos álbuns, podemos utilizar este objeto da seguinte forma:

resultObj.getPhotosets().getPhotoset()

Este método retorna uma lista de álbuns.

Para testar, vamos listar na tela o id de todos os albuns do seu Flickr da seguinte forma:

import org.netbeans.saas.flickr.FlickrPhotoService;
import org.netbeans.saas.RestResponse;

public class Main {

    public static void main(String[] args) {

        // início do código que será gerado -------------------------
        try {
            String userId = null;

            RestResponse result = FlickrPhotoService.photosetsGetList(userId);
            if (result.getDataAsObject(flickr.photoservice.flickrresponse.Rsp.class) instanceof flickr.photoservice.flickrresponse.Rsp) {
                flickr.photoservice.flickrresponse.Rsp resultObj = result.getDataAsObject(flickr.photoservice.flickrresponse.Rsp.class);
                // listagem do id de todos os albuns
                for (int i = 0; i < resultObj.getPhotosets().getPhotoset().size(); i++) {
                    System.out.println("Album com id = " + resultObj.getPhotosets().getPhotoset().get(i).getId());
                }

            }
            //TODO - Uncomment the print Statement below to print result.
            //System.out.println("The SaasService returned: "+result.getDataAsString());
        } catch (Exception ex) {
            ex.printStackTrace();
        }
        // fim do código que será gerado -------------------------------
    }
}

Antes de executar é necessário configurar o arquivo .properties responsável pela autenticação, utilizando a chave e o segredo que você pegou no Flickr. Este arquivo foi gerado automaticamente e se encontra no pacote org.netbeans.saas.flickr com o nome flickrphotoserviceauthenticator.properties. Preencha este arquivo com a sua chave e seu segredo.

Pronto, agora ao executar a sua classe será exibida esta tela:

Antes de clicar em OK é necessário copiar o link e colar no navegador para que o site do Flickr dê a permissão para acessar seu serviço.

Ao executar o link no browser aparecerá a seguinte tela:

Escolha a opção OK, EU AUTORIZO e depois volte para a execução no Netbeans e clique em OK no JDialog de autorização.

Dessa forma seus álbuns serão listados no console do Netbeans.

Dicas

• O método photosets_getPhotos disponível no serviço é útil para buscar o id e título das fotos de um álbum, neste caso é necessário passar o id do album para conseguir utilizar o método.

A dica está na forma de acessar a lista de fotos. É necessário utilizar o objeto resultObj como é apresentado em seguida:

resultObj.getPhotoset().getPhoto().get(i).getId();

• O método photos_getInfo disponível no serviço encontra a descrição e o título de uma foto passando o id da foto. Para acessar essas informações você pode utilizar o objeto resultObj da seguinte forma:

resultObj.getPhoto().getDescription();
resultObj.getPhoto().getTitle();

• O método photos_getSizes disponível no serviço encontra as urls (uma para cada tamanho) de uma foto. O uso deste método precisa também do id da foto. Através dele você pode exibir as fotos na sua aplicação. O objeto resultObj deve ser utilizado da seguinte forma:

resultObj.getSizes().getSize().get(0).getSource();
resultObj.getSizes().getSize().get(1).getSource();
resultObj.getSizes().getSize().get(2).getSource();
resultObj.getSizes().getSize().get(3).getSource();
resultObj.getSizes().getSize().get(4).getSource();

Cada posição da lista retornada é um tamanho diferente da foto.

Conclusao

Este tutorial mostrou os passos necessários para acessarmos a API do Flickr.  Vimos como é simples consumir serviços com o auxilio do Netbeans. A partir deste tutorial você pode explorar outros serviços para construir diversos tipos de aplicações customizadas.

Depois de algum tempo sem postar nada devido a adaptação ao Rio e a empresa que comecei a trabalhar, Concrete Solutions, volto com muitas ideias novas e tecnologias diferentes para compartilhar aqui no blog. Continuarei escrevendo sobre desenvolvimento java para web mas tratarei também de assuntos como arquitetura orientada a serviço (SOA), projeto e análise de serviços, padrões de projeto empresariais, bibliotecas java script e assuntos referentes ao mercado de trabalho de tecnologia.

Vamos descrever neste artigo algumas mudanças no nosso CRUD JSF 2 para que ele passe a interagir com o usuário utilizando ajax, também vamos melhorar a interface do CRUD com a biblioteca de componentes JSF PrimeFaces. Esta biblioteca de componentes foi uma das primeiras a dar suporte a nova versão do JSF, além de estar sendo constantemente melhorada pelo seu autor Cagatay Civici. Uma das últimas mudanças foi a possibilidade da escolha de diversos skins para os componentes, assim como a possibilidade de utilização do suporte de criação de skin do jquery para gerar skins personalizados para os componentes do PrimeFaces através do ThemeRoller. Utilizaremos skin também neste post.

O CRUD passará a ter a seguinte interface:

Pré Requisitos:

• Este post é uma continuação do CRUD JSF 2.0 + Hibernate – Exemplo Gerenciando Livros, portanto é interessante que você acompanhe os passos inicias no CRUD para que entenda o que será alterado neste.
• Biblioteca de componentes PrimeFaces disponível aqui
• Os demais pré requisitos estão descritos na primeira parte do CRUD JSF 2

Avisos:

• O desenvolvimento dos códigos foi realizado no Netbeans 6.9, porém você pode utilizar a IDE de sua preferência para construir o CRUD. Os projeto disponíveis para download no fim do tutorial é executável no Netbeans.
• A versão do PrimeFaces utilizada foi a 2.2, utilize esta ou uma superior.

Adicionando e configurando a biblioteca PrimeFaces

Após  baixar a biblioteca PrimeFaces você deve adicioná-la ao projeto do CRUD de Livros. Caso não tenha ainda o projeto, baixe-o por aqui ou acompanhe a primeira paste do CRUD aqui.

A configuração necessária para que o PrimeFaces funcione é ZERO, isso mesmo, não é necessário nenhuma configuração xml para começar a utiliza-lo, apenas a sua declaração na página que o utilizar. No nosso caso a página index.xhtml deverá conter a seguinte declaração:

xmlns:p="http://primefaces.prime.com.tr/ui"

Para que possa ser utilizado um skin diferente na página, é necessário a inserção do seguinte código no arquivo web.xml

    <context-param>
        <param-name>primefaces.skin</param-name>
        <param-value>none</param-value>
    </context-param>

Esta configuração remove o skin padrão do PrimeFaces e permite que outros skins possam ser usados, sendo que, a especificação ocorre na página através da adição da tag <link>. Você deve clicar aqui para baixar o skin que é utilizado nas modificações deste CRUD. A pasta do skin deve ser colocada na pasta web do seu projeto. E as páginas que forem utilizar o skin devem conter a seguinte chamada dentro da tag <head>:

<link type="text/css" rel="stylesheet" href="dot-luv/skin.css" />

Porque utilizar ajax no nosso CRUD de Livros?

O ajax é a maneira que foi encontrada para que não fosse necessário recarregar toda uma página quando houvesse algumas mudanças apenas em parte dela. O objetivo do uso de ajax é tornar as páginas web mais próximas de softwares desktop e com isso poder ter uma aplicação que não depende de uma máquina específica e que pode ser acessada de qualquer lugar. Isso implica também em um novo modelo de negócio que começa a se difundir cada vez mais chamado Software as a Service (SaaS), ou, Software como um Serviço, este modelo se baseia em oferecer um serviço a diversos usuários pela web. Para o usuário a diferença está em não pagar um alto custo inicial pelo software como no modelo tradicional, além de poder acessar seu aplicativo de qualquer lugar. Para a empresa desenvolvedora a diferença está no lucro que não virá de uma vez como no modelo tardicional e também na facilidade de manutenção e updates para os usuários, pois, precisará realizadar apenas uma vez. Acho que comecei a me desviar um pouco do foco então vamos voltar. Em outro momento oportuno escreverei sobre SaaS.

Utilizando os componentes PrimeFaces no CRUD

Para melhorar a aparência do CRUD e adicionar a chamada assincrona por ajax aos métodos nós vamos adicionar alguns componentes da biblioteca PrimeFaces. Entre os componentes utilizados estão o layout, dataTable, commandLink, commandButton e o dialog.

Além de algumas mudanças nos códigos, nos descartaremos a página gerenciarLivro.xhtml e seu conteúdo irá para a página index.xhtml. Este conteúdo ficará dentro do componente dialog do primefaces e será chamado quando for necessário incluir ou alterar um livro.

Vamos ver como a página index.xhtml fica e depois vamos entender um poucos das mudanças realizadas.

<?xml version='1.0' encoding='UTF-8' ?>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
<html xmlns="http://www.w3.org/1999/xhtml"
      xmlns:h="http://java.sun.com/jsf/html"
      xmlns:f="http://java.sun.com/jsf/core"
      xmlns:p="http://primefaces.prime.com.tr/ui">
    <h:head>
        <title>Gerenciador de Livros</title>
        <link type="text/css" rel="stylesheet" href="dot-luv/skin.css" />
    </h:head>
    <h:body>
        <p:layout fullPage="true">
            <p:layoutUnit position="left" width="200" header="Atividades" resizable="true" closable="true" collapsible="true">
                <h:form prependId="false">
                    <p:commandLink value="Novo Livro" actionListener="#{livroController.prepararAdicionarLivro}" update="infosLivro" oncomplete="dialogGerLivro.show()"/>
                </h:form>
            </p:layoutUnit>
            <p:layoutUnit position="center">
                <h1>Gerenciador de Livros</h1>
                <br/>
                <h:form prependId="false">
                    <p:dataTable id="tabela" var="livro" value="#{livroController.listarLivros}">
                        <p:column>
                            <f:facet name="header">
                                <h:outputText value="Título"/>
                            </f:facet>
                            <h:outputText value="#{livro.titulo}" />
                        </p:column>
                        <p:column>
                            <f:facet name="header">
                                <h:outputText value="Autor"/>
                            </f:facet>
                            <h:outputText value="#{livro.autor}"/>
                        </p:column>
                        <p:column>
                            <f:facet name="header">
                                <h:outputText value="Páginas"/>
                            </f:facet>
                            <h:outputText value="#{livro.paginas}"/>
                        </p:column>
                        <p:column>
                            <f:facet name="header">
                                <h:outputText value="Editora"/>
                            </f:facet>
                            <h:outputText value="#{livro.editora}"/>
                        </p:column>
                        <p:column>
                            <f:facet name="header">
                                <h:outputText value="Isbn"/>
                            </f:facet>
                            <h:outputText value="#{livro.isbn}"/>
                        </p:column>
                        <p:column>
                            <f:facet name="header">
                                <h:outputText value="Avaliação"/>
                            </f:facet>
                            <h:outputText value="#{livro.avaliacao}"/>
                        </p:column>
                        <p:column>
                            <f:facet name="header">
                                <h:outputText value="Alterar"/>
                            </f:facet>
                            <p:commandButton actionListener="#{livroController.prepararAlterarLivro}" value="Alterar" update="infosLivro" oncomplete="dialogGerLivro.show()"/>
                        </p:column>
                        <p:column>
                            <f:facet name="header">
                                <h:outputText value="Excluir"/>
                            </f:facet>
                            <h:commandLink action="#{livroController.excluirLivro}" value="Excluir"/>
                        </p:column>
                    </p:dataTable>
                </h:form>
            </p:layoutUnit>
        </p:layout>

        <p:dialog header="Gerencia de Livro" widgetVar="dialogGerLivro"  resizable="false" modal="true" showEffect="slide" width="500">
            <h:form prependId="false">
                <h:panelGrid id="infosLivro" columns="2" style="margin-bottom:10px">

                    <h:outputLabel for="titulo" value="Título:" />
                    <h:inputText id="titulo" value="#{livroController.livro.titulo}"/>

                    <h:outputLabel for="autor" value="Autor:" />
                    <h:inputText id="autor" value="#{livroController.livro.autor}"/>

                    <h:outputLabel for="paginas" value="Páginas:" />
                    <h:inputText id="paginas" value="#{livroController.livro.paginas}"/>

                    <h:outputLabel for="editora" value="Editora:" />
                    <h:inputText id="editora" value="#{livroController.livro.editora}"/>

                    <h:outputLabel for="isbn" value="ISBN:" />
                    <h:inputText id="isbn" value="#{livroController.livro.isbn}"/>

                    <h:outputLabel for="avaliacao" value="Avaliação:" />
                    <h:selectOneMenu id="avaliacao" value="#{livroController.livro.avaliacao}">
                        <f:selectItem itemLabel="1" itemValue="1"/>
                        <f:selectItem itemLabel="2" itemValue="2"/>
                        <f:selectItem itemLabel="3" itemValue="3"/>
                        <f:selectItem itemLabel="4" itemValue="4"/>
                        <f:selectItem itemLabel="5" itemValue="5"/>
                    </h:selectOneMenu>

                    <p:commandButton update="tabela" oncomplete="dialogGerLivro.hide();" actionListener="#{livroController.adicionarLivro}" value="Inserir Livro"/>
                    <p:commandButton update="tabela" oncomplete="dialogGerLivro.hide();" actionListener="#{livroController.alterarLivro}" value="Alterar Livro"/>

                </h:panelGrid>
            </h:form>
        </p:dialog>

    </h:body>
</html>

O componente layout contém um subcomponente chamado layoutUnit. Nas configurações deste subcomponente nós informamos onde o código que estiver dentro dele vai se localizar na página. Por exemplo utilizando o position=”left” estamos falando que todo código dentro dete componente ficará do lado esquerdo da tela. Além disso, definimos a configuração fullPage do layout como true, o que faz o layout preencher toda a tela do browser.

A principal mudança do dataTable está na troca dos componentes padrões do jsf pelo dataTable do primefaces. Isso permite que a tabela seja renderizada e seja alterada com o uso do skin, além de muitas outras funcionalidades que não serão abordadas neste post. O dataTable passou a ter um id que serve para identifica-lo para que  fosse possível atualizar a tabela por ajax.

Os commandLinks e os commandButtons tiveram grandes alterações, pois é através deles que as chamadas ajax são realizadas. Vamos ver as principais mudanças:

• Troca do action pelo actionListener: esta troca é necessária porque não vamos mais carregar outra página após a execução de um método no servidor. Nós vamos executar os métodos no servidor e depois apenas atualizar os componentes que sofreram mudanças com a execução do método.
• O uso do atributo update informa quais componentes deverão ser renderizados novamente após a execução do actionListener, com isso o usuário passa a ter a sensação que está utilizando um programa desktop e não simplismente acessando um site.
• O atributo onComplete serve para ativar o dialog que apresenta as informações de um livro para alterações ou inclusões. A ativação do dialog só ocorre após a execução do método que estiver definido no actionListener e também após a renderização dos componentes que estão na variável update.

O componente dialog permite a criação de uma janela modal que pode ser arrastada pela tela e torna a aplicação mais próxima ainda de aplicações desktop, pelo fato das janelas serem comuns nas aplicações desktop. Uma variável importante deste componente é o widgetVar que serve para definir um nome para o dialog. Com este nome o dialog pode ser apresentado ou escondido na tela através das funções javascript nomeDoDialog.show() e nomeDoDialog.hide(), respectivamente.

Estas são as informações importantes para compreender as mudanças realizadas nas páginas xhtml. Agora vamos ver como a classe  LivroController.java deve ficar para que tudo funcione corretamente.

package Controller;

import Dao.LivroDao;
import Dao.LivroDaoImp;
import Model.Livro;
import java.util.List;
import javax.faces.bean.ManagedBean;
import javax.faces.bean.SessionScoped;
import javax.faces.event.ActionEvent;
import javax.faces.model.DataModel;
import javax.faces.model.ListDataModel;

/**
 * @author José Alexandre
 */
@ManagedBean
@SessionScoped
public class LivroController {

    private Livro livro;
    private DataModel listaLivros;

    public DataModel getListarLivros() {
        List<Livro> lista = new LivroDaoImp().list();
        listaLivros = new ListDataModel(lista);
        return listaLivros;
    }

    public Livro getLivro() {
        return livro;
    }

    public void setLivro(Livro livro) {
        this.livro = livro;
    }

    public void prepararAdicionarLivro(ActionEvent actionEvent){
        livro = new Livro();
    }

    public void prepararAlterarLivro(ActionEvent actionEvent){
        livro = (Livro)(listaLivros.getRowData());
    }

    public String excluirLivro(){

        Livro livroTemp = (Livro)(listaLivros.getRowData());
        LivroDao dao = new LivroDaoImp();
        dao.remove(livroTemp);
        return "index";

    }

    public void adicionarLivro(ActionEvent actionEvent){

        LivroDao dao = new LivroDaoImp();
        dao.save(livro);

    }

    public void alterarLivro(ActionEvent actionEvent){

        LivroDao dao = new LivroDaoImp();
        dao.update(livro);

    }

}

A mudança realizada nesta classe está nos métodos deixarem de retornar uma String com a página de destino. Eles passam a não retornar nada e também passam a receber como parâmetro um objeto ActionEvent. Isso acontece porque o objetivo agora é apenas realizar algumas mudanças no servidor e depois atualizar somente algumas partes da página através de ajax.

Essas foram as mudanças necessárias no CRUD para que ele passasse a utilizar ajax e alguns dos componentes da biblioteca primefaces.

Conclusão

Podemos notar que com poucas mudanças tivemos um ganho enorme com relação a usabilidade e aparência do CRUD. A partir deste CRUD o usuário pode começar a explorar os diversos outros componentes disponibilizados pelo primefaces, veja aqui os demos de todos eles, lembrando que existem também outras bibliotecas de componentes que o usuário pode conhecer e que podem atender melhor as necessidades de componentes de acordo com o caso.

Espero que tenham aproveitado e entendido o funcionamento do uso dos componentes primefaces e do ajax!

Por hoje é só e até a próxima! Qualquer dúvida estou a disposição!

Download

Para baixar o código fonte compatível com Netbeans clique aqui.

Depois de tanto trabalho a minha monografia finalmente foi finalizada, revisada e entregue ao BCC ( Bacharelado de Ciência da Computação) da Unifal.

Abaixo segue o resumo do trabalho:

O mercado de ações brasileiro, representado pela BOVESPA, é uma fonte de renda variável que está em crescimento no Brasil onde, com cautela e estratégias corretas, é possível obter bons lucros. Entretanto, sua natureza complexa e a falta de conhecimento podem gerar prejuízos irrecuperáveis. Com isso, estratégias que auxiliem as negociações realizando previsões dos preços das ações podem ajudar as pessoas que possuem dificuldade na análise de mercado, além de possibilitar lucros maiores com a utilização de algoritmos de Inteligência Artificial que usam dados passados do mercado acionário para predizer os preços futuros das ações. Esta monografia tem como objetivo verificar se a utilização de máquinas de comitê para a previsão do preço médio diário das ações, que combinam os resultados de diversos modelos de previsão, geram resultados melhores ou no mínimo tão bons quanto os resultados dos melhores previsores. Além disso, esta monografia define um sistema online para apoio à decisão ao investidor que pode ser utilizado com qualquer modelo ou técnica computacional de previsão para apresentar aos investidores sugestões de compra e venda diárias de ação e para tornar possível o acompanhamento dos lucros dos papéis que o investidor tenha em sua carteira.

O trabalho completo pode ser acessado no link abaixo.

Visualize aqui a Monografia

Agradeço mais uma vez a todos que tornaram possível a conclusão!

Abraços!

Estas últimas semanas foram de muita correria para finalizar a monografia e apresentá-la na última quinta (1/7/2010) para a banca examinadora. A banca foi composta por professores da Unifal, sendo dois doutores, um da Economia (prof. Marcelo Lacerda Rezende) e outro de otimização (prof. Marcos de Mendonça Passini), além do meu orientador prof. Humberto César Brandão de Oliveira.

A apresentação da monografia não é como qualquer outra apresentação, pois não é só uma apresentação, é uma defesa. E se é uma defesa logo se supõe que deve haver um ataque! O que acaba tornando tudo mais tenso. Mesmo treinando diversas vezes antes de apresentar, é difícil esconder totalmente o nervosismo.

No final ocorreu tudo bem e valeu a pena todo o esforço ao ouvir os  elogios da banca. Logicamente que foram definidas algumas correções para fechar o trabalho, coisa que se resolve em pouco tempo!

Em seguida segue a minha apresentação, após as correções, postarei a monografia também.

Agradeço mais uma vez ao meu orientador, à banca examinadora e a todos que ajudaram a tornar este trabalho possível!

A biblioteca de componentes RichFaces para JSF é a mais utilizada atualmente, entretanto sua versão estável mais recente, a 3.3.3,  não possui compatibilidade total com a nova versão do JSF. Apesar disso, é possível utilizar os dois juntos realizando algumas modificações e adicionando algumas bibliotecas a mais. Não sei até que ponto a utilização do RichFaces com JSF 2.0 vale a pena devido a não ter 100% de compatibilidade… mas para realização de testes e experimentos com certeza vale!

Então vamos lá!

As bibliotecas necessárias, além das bibliotecas do JSF 2.0, para utilizar o RichFaces 3.3.3 são:

- Biblioteca RichFaces 3.3.3 (download)

- Os 4 commons a seguir (download):

-commons-beanutils.jar

-commons-collections.jar

-commons-digester.jar

-commons-logging.jar

Um detalhe importante é que os facelets também não possuem total compatibilidade com o RichFaces 3.3.3, então é indicado a utilização de páginas jsp na camada de visão para que a adição do RichFaces 3.3.3 no JSF 2 funcione.

O arquivo web.xml deve ficar configurado de acordo com exemplo abaixo:

<?xml version="1.0" encoding="UTF-8"?>
<web-app version="2.5" xmlns="http://java.sun.com/xml/ns/javaee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd">
    <context-param>
        <param-name>javax.faces.PROJECT_STAGE</param-name>
        <param-value>Development</param-value>
    </context-param>
    <servlet>
        <servlet-name>Faces Servlet</servlet-name>
        <servlet-class>javax.faces.webapp.FacesServlet</servlet-class>
        <load-on-startup>1</load-on-startup>
    </servlet>
    <servlet-mapping>
        <servlet-name>Faces Servlet</servlet-name>
        <url-pattern>/faces/*</url-pattern>
    </servlet-mapping>
    <session-config>
        <session-timeout>
            30
        </session-timeout>
    </session-config>
    <welcome-file-list>
        <welcome-file>faces/index.jsp</welcome-file>
    </welcome-file-list>

    <context-param>
        <param-name>org.richfaces.SKIN</param-name>
        <param-value>blueSky</param-value>
    </context-param>
    <context-param>
        <param-name>org.richfaces.CONTROL_SKINNING</param-name>
        <param-value>enable</param-value>
    </context-param>
    <filter>
        <display-name>RichFaces Filter</display-name>
        <filter-name>richfaces</filter-name>
        <filter-class>org.ajax4jsf.Filter</filter-class>
    </filter>
    <filter-mapping>
        <filter-name>richfaces</filter-name>
        <servlet-name>Faces Servlet</servlet-name>
        <dispatcher>REQUEST</dispatcher>
        <dispatcher>FORWARD</dispatcher>
        <dispatcher>INCLUDE</dispatcher>
    </filter-mapping>
    <listener>
        <listener-class>com.sun.faces.config.ConfigureListener</listener-class>
    </listener>
</web-app>

As configurações para que o richfaces funcione são estas. Para testa-las vamos criar um exemplo simples onde será necessário a criação de uma página jsp e de um bean simples.

O bean será chamado User e  ira conter apenas um atributo name. No final sua classe deve ficar desta maneira:

User.java

import javax.faces.bean.ManagedBean;

@ManagedBean
public class User {

    String name;

    public User() {
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

}

A página jsp deve incluir as bibliotecas do richfaces e devem conter a execução de um exemplo. No final a página ficará assim:

index.jsp

<%@page contentType="text/html" pageEncoding="UTF-8"%>
<%@taglib prefix="f" uri="http://java.sun.com/jsf/core"%>
<%@taglib prefix="h" uri="http://java.sun.com/jsf/html"%>
<!-- Declaração das Tags da biblioteca RichFaces -->
<%@ taglib uri="http://richfaces.org/a4j" prefix="a4j"%>
<%@ taglib uri="http://richfaces.org/rich" prefix="rich"%>

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
    "http://www.w3.org/TR/html4/loose.dtd">

<html>
    <head>
        <meta http-equiv="Content-Type" content="text/html; charset=UTF-8"/>
        <title>Exemplo JSF 2.0 + RichFaces 3.3.3</title>
    </head>
    <body>
        <f:view>
            <h1><h:outputText value="Java Server Faces 2.0 + RichFaces 3.3.3"/></h1>

            <a4j:form>
                <rich:panel header="RichFaces 3.3.3 Exemplo" style="width: 315px">
                    <h:outputText value="Seu nome: " />
                    <h:inputText value="#{user.name}" >
                        <f:validateLength minimum="1" maximum="30" />
                    </h:inputText>
                    <a4j:commandButton value="Enviar" reRender="painelResposta" />
                    <br/>
                    <h:panelGroup id="painelResposta" >
                        <h:outputText value="Olá, " rendered="#{not empty user.name}" />
                        <h:outputText value="#{user.name}" />
                        <h:outputText value="!" rendered="#{not empty user.name}" />
                    </h:panelGroup>
                </rich:panel>
            </a4j:form>
        </f:view>
    </body>
</html>

Após a criação da classe e da página o projeto pode ser executado e deve mostrar no browser o seguinte:

Por hoje é só pessoal!

Enquanto não sai a versão 4.0 do richfaces surge a necessidade para quem deseja utilizar JSF 2 com RichFaces de adaptar a essas condições!

Abraços e qualquer coisa estamos ai!

Ontem lendo um post do Diego Pacheco na Imasters conheci uma técnica muito interessante de modelagem chamada UML em cores. Esta técnica utiliza 4 cores diferentes para identificar e definir as classes necessárias para um sistema. Em seguida vou descrever a técnica que pode ser muito útil durante o processo de modelagem do software.

As cores tornam os diagramas mais legíveis e passam mais informações referentes ao problema que está sendo modelado. Porem somente a definição de cores não é uma novidade, pois, diagramas de entidade e relacionamento já usavam antes da UML as cores para identificar áreas em comuns das tabelas. A novidade está em um padrão para definir estas cores de acordo com métodos e atributos adequados para cada uma.

Na maioria dos sistemas desenvolvidos diversos problemas sempre aparecem nas modelagens, como por exemplo, transações comerciais ou iterações de vendas, encomendas, aluguel, reserva, agendamento de eventos entre outros. As semelhanças entre todas as classes de uma destas categorias geralmente não são suficientemente para serem generalizadas em uma interface Java. No entanto, as semelhanças estão próximas o suficiente para poder ajudar a orientar a escolha e definição de classes em nossos desenhos.

Idealização…

Utilizado pela primeira vez em um grande projeto software em Singapura, em 1997, Peter Coad e seus colegas perceberam que as classes seguiam um padrão de relacionamento entre si, chamado de archetypes (arquétipos), então durante alguns anos eles pesquisaram e refinaram a técnica até lançarem em 1999 o livro Java Modeling in Color with UML.

Arquétipos…

Cada uma das cores definidas, rosa, amarelo, verde e azul, identificam um arquétipo como pode ser visto na Figura 1.

Figura 1 - Arquétipos definidos

Os quatro arquétipos são descritos abaixo:

• Moment-Interval (momento ou intervalo): Representado por atividades, eventos, serviços ou coisas que precisam ser registradas. Uma venda, um objeto que guarda outro temporariamente, como Sessão, são exemplos. Outros exemplos incluem venda, locação, ordem, viagem, vôo, reunião, reserva, sensor reading, etc.
• Role (papel): São os papéis. Exemplos do seu uso são: Funcionário, Fornecedor, Vendedor, Segurança, Atendente etc.
• Party,Place,Thing (pessoa, lugar, coisa ou objeto): São as classes do modelo que são tangíveis e unicamente identificáveis. Esse arquétipo atua em um evento, serviço ou momento. Exemplos seriam cadastros e relatórios.
• Description (descrição): Pode ser um catálogo ou um conjunto de rótulos de um objeto. São os dados de referências que utilizamos em combos, lookups e lists.

Para saber mais sobre os arquétipos leia este artigo de Sthefen Palmer.

Mais do que cores…

A UML em cores é mais do que colorir classes, ele propõe métodos e atributos que são comuns para cada arquétipo, como exemplo, o arquétipo Moment-Interval sempre terá um método para calcular valor ou calcular total. Um arquétipo Descripition pode fornecer um método que calcule a quantidade disponível de um item (estoque de um produto)

Com a experiência adquirida após algumas modelagens é mais fácil  notar essas recorrências. O que é recomendado é estar sempre anotando suas observações para que com o tempo você monte seu próprio diagrama com os padrões de ocorrência baseado nos arquétipos básicos definidos.

Conclusão

A técnica apesar de não ser tão nova pode ser muito útil para a modelagem de sistemas, pois de certa forma já existe um caminho para encaixar o problema que está sendo modelado, tornando mais intuitivo o desenvolvimento dos diagramas necessários. Além disso, os “papeis autocolantes” que são comumente encontrados em papelarias, possuem as mesmas cores utlizadas nesta técnica, o que facilita seu uso durante a modelagem inicial!

Referencias

http://edn.embarcadero.com/article/33737

http://knol.google.com/k/object-modelling-in-colour#

http://imasters.uol.com.br/artigo/17170

Espero que quem não conhecia a técnica tenha aprendido alguma coisa e que quando houver a necessidade ela seje útil, se tornando mais uma carta na manga para os analistas!

Abraços!

Bom dia a todos!

Hoje vou apresentar todos os passos necessários para a construção de um CRUD (Create, Read, Update and Delete) utilizando Java Server Faces 2.0 para facilitar a criação das páginas e a comunicação destas com as classes Java e Hibernate para realizar a persistência dos dados.

Para o desenvolvimento eu utilizei o Netbeans 6.8 que já conta com suporte ao JSF 2.0 e ao Hibernate 3 facilitando o trabalho de baixar os frameworks e coloca-los no projeto, porém, fica a cargo do desenvolvedor escolher a IDE de sua preferência para a criação!

O exemplo para a criação do CRUD será dado através da gerencia de livros, um exemplo simples mas capaz de mostrar como as operações básicas de um sistema podem ser efetuadas com JSF.

A segunda parte deste CRUD com utilização de ajax e da biblioteca de componentes PrimeFaces está disponível aqui!

Pré Requisitos

- Netbeans ou Eclipse

- JSF 2.0

- Hibernate 3

- MySQL

Estrutura do CRUD

O nosso CRUD segue o padrão MVC para programação Web, separando as classes em camadas de acordo com a responsabilidade de cada uma. Abaixo é apresentada a estrutura que criaremos onde Dao, Model, Controller e View serão pacotes do projeto.

Cada livro no CRUD terá as seguintes informações: título, autor, páginas, editora, isbn e avaliação que serão mantidas no banco de dados.

Criando o Banco de Dados…

O CRUD utilizará Banco de Dados MySQL, para isso, crie um squema e uma tabela no seu banco como está descrito abaixo.

Squema

CREATE DATABASE IF NOT EXISTS livraria;

Tabela

CREATE TABLE `livro` (
`id` bigint(20) NOT NULL AUTO_INCREMENT,
`autor` varchar(255) DEFAULT NULL,
`avaliacao` int(11) NOT NULL,
`editora` varchar(255) DEFAULT NULL,
`isbn` varchar(255) DEFAULT NULL,
`paginas` int(11) NOT NULL,
`titulo` varchar(255) DEFAULT NULL,
PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=4 DEFAULT CHARSET=latin1;

Criando as Camadas…

Model

O pacote Model do projeto deve conter uma classe chamada Livro que será um POJO (Plain Old Java Object) com as annotations do hibernate necessárias para utilização do framework. A classe deve ficar de acordo com esta:

package Model;

import java.io.Serializable;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;

/**
*
* @author José Alexandre
*/
@Entity
public class Livro implements Serializable {

@Id
@GeneratedValue
private long id;
private String titulo;
private String autor;
private int paginas;
private String editora;
private String isbn;
private int avaliacao;

public Livro() {
}

public Livro(long id, String titulo, String autor, int paginas, String editora, String isbn, int avaliacao) {
this.id = id;
this.titulo = titulo;
this.autor = autor;
this.paginas = paginas;
this.editora = editora;
this.isbn = isbn;
this.avaliacao = avaliacao;
}

public String getAutor() {
return autor;
}

public void setAutor(String autor) {
this.autor = autor;
}

public int getAvaliacao() {
return avaliacao;
}

public void setAvaliacao(int avaliacao) {
this.avaliacao = avaliacao;
}

public String getEditora() {
return editora;
}

public void setEditora(String editora) {
this.editora = editora;
}

public long getId() {
return id;
}

public void setId(long id) {
this.id = id;
}

public String getIsbn() {
return isbn;
}

public void setIsbn(String isbn) {
this.isbn = isbn;
}

public int getPaginas() {
return paginas;
}

public void setPaginas(int paginas) {
this.paginas = paginas;
}

public String getTitulo() {
return titulo;
}

public void setTitulo(String titulo) {
this.titulo = titulo;
}

}

Dao

O pacote Dao vai realizar a comunicação com o banco utilizando o hibernate para salvar, listar alterar e excluir livros. Dentro deste pacote, deve ser criada uma interface chamada LivroDao, uma classe chamada LivroDaoImp e uma classe chamada HibernateUtil (realizará a conexão com o banco) da mesma forma que estas:

Interface LivroDao

package Dao;

import Model.Livro;
import java.util.List;

/**
 *
 * @author José Alexandre
 */
public interface LivroDao {

    public void save(Livro livro);
    public Livro getLivro(long id);
    public List<Livro> list();
    public void remove(Livro livro);
    public void update(Livro livro);

}

Classe LivroDaoImp

package Dao;

import Model.Livro;
import java.util.List;
import org.hibernate.Session;
import org.hibernate.Transaction;

/**
 *
 * @author José Alexandre
 */
public class LivroDaoImp implements LivroDao {

    public void save(Livro livro) {
        Session session = HibernateUtil.getSessionFactory().openSession();
        Transaction t = session.beginTransaction();
        session.save(livro);
        t.commit();
    }
    public Livro getLivro(long id) {
        Session session = HibernateUtil.getSessionFactory().openSession();
        return (Livro) session.load(Livro.class, id);
    }
    public List<Livro> list() {
        Session session = HibernateUtil.getSessionFactory().openSession();
        Transaction t = session.beginTransaction();
        List lista = session.createQuery("from Livro").list();
        t.commit();
        return lista;
    }
    public void remove(Livro livro) {
        Session session = HibernateUtil.getSessionFactory().openSession();
        Transaction t = session.beginTransaction();
        session.delete(livro);
        t.commit();
    }
    public void update(Livro livro) {
        Session session = HibernateUtil.getSessionFactory().openSession();
        Transaction t = session.beginTransaction();
        session.update(livro);
        t.commit();
    }
}

Classe HibernateUtil

package Utils;

import Model.Livro;
import org.hibernate.cfg.AnnotationConfiguration;
import org.hibernate.SessionFactory;

/**
 * Hibernate Utility class with a convenient method to get Session Factory object.
 *
 * @author José Alexandre
 */
public class HibernateUtil {

    private static SessionFactory sessionFactory;

    private HibernateUtil() {
    }

    public static SessionFactory getSessionFactory() {
        if (sessionFactory == null) {
            try {
                // Create the SessionFactory from standard (hibernate.cfg.xml)
                // config file.
                AnnotationConfiguration ac = new AnnotationConfiguration();
                ac.addAnnotatedClass(Livro.class);
                sessionFactory = ac.configure().buildSessionFactory();
            } catch (Throwable ex) {
                // Log the exception.
                System.err.println("Initial SessionFactory creation failed." + ex);
                throw new ExceptionInInitializerError(ex);
            }
            return sessionFactory;
        } else {
            return sessionFactory;
        }
    }

Controller

O pacote Controller vai realizar a comunicação da Camada de Visão representada por nossas páginas JSF com o banco de dados sendo responsável por realizar as operações requisitadas nas páginas JSF e em seguida encaminhar o usuário para uma página. A classe a ser criada deve chamar LivroController e precisa ser escrita dessa forma:

package Controller;

import Dao.LivroDao;
import Dao.LivroDaoImp;
import Model.Livro;
import java.util.List;
import javax.faces.bean.ManagedBean;
import javax.faces.bean.SessionScoped;
import javax.faces.model.DataModel;
import javax.faces.model.ListDataModel;

/**
 *
 * @author José Alexandre
 */
@ManagedBean
@SessionScoped
public class LivroController {

    private Livro livro;
    private DataModel listaLivros;

    public DataModel getListarLivros() {
        List<Livro> lista = new LivroDaoImp().list();
        listaLivros = new ListDataModel(lista);
        return listaLivros;
    }
    public Livro getLivro() {
        return livro;
    }
    public void setLivro(Livro livro) {
        this.livro = livro;
    }
    public String prepararAdicionarLivro(){
        livro = new Livro();
        return "gerenciarLivro";
    }
    public String prepararAlterarLivro(){
        livro = (Livro)(listaLivros.getRowData());
        return "gerenciarLivro";
    }
    public String excluirLivro(){
        Livro livroTemp = (Livro)(listaLivros.getRowData());
        LivroDao dao = new LivroDaoImp();
        dao.remove(livroTemp);
        return "index";
    }
    public String adicionarLivro(){
        LivroDao dao = new LivroDaoImp();
        dao.save(livro);
        return "index";
    }
    public String alterarLivro(){
        LivroDao dao = new LivroDaoImp();
        dao.update(livro);
        return "index";
    }
}

View

O pacote View é composto por páginas JSF que irão executar o pedido de listagem, alteração, exclusão e adição de Livros, o nosso projeto precisará de duas páginas JSF uma chamada index.xhtml que listará os Livros do Usuário e permitirá excluí-los e acessar as páginas de alteração e inserção, a segunda página chamada gerenciarLivro.xhtml será criada para realizar a adição e alteração dos livros. As duas páginas se comunicam diretamente com os métodos e atributos da classe LivroController permitindo a interação de forma fácil com o banco de dados. Em seguida são apresentadas as páginas necessárias.

Página index.xhtml

<?xml version='1.0' encoding='UTF-8' ?>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml"
      xmlns:h="http://java.sun.com/jsf/html"
      xmlns:f="http://java.sun.com/jsf/core">
    <h:head>
        <title>Gerenciador de Livros</title>
    </h:head>
    <h:body>
        <h1>Gerenciador de Livros</h1>
        <h:dataTable var="livro" value="#{livroController.listarLivros}">
            <h:column>
                <f:facet name="header">
                    <h:outputText value="Título"/>
                </f:facet>
                <h:outputText value="#{livro.titulo}" />
            </h:column>
            <h:column>
                <f:facet name="header">
                    <h:outputText value="Autor"/>
                </f:facet>
                <h:outputText value="#{livro.autor}"/>
            </h:column>
            <h:column>
                <f:facet name="header">
                    <h:outputText value="Páginas"/>
                </f:facet>
                <h:outputText value="#{livro.paginas}"/>
            </h:column>
            <h:column>
                <f:facet name="header">
                    <h:outputText value="Editora"/>
                </f:facet>
                <h:outputText value="#{livro.editora}"/>
            </h:column>
            <h:column>
                <f:facet name="header">
                    <h:outputText value="Isbn"/>
                </f:facet>
                <h:outputText value="#{livro.isbn}"/>
            </h:column>
            <h:column>
                <f:facet name="header">
                    <h:outputText value="Avaliação"/>
                </f:facet>
                <h:outputText value="#{livro.avaliacao}"/>
            </h:column>
            <h:column>
                <f:facet name="header">
                    <h:outputText value="Alterar"/>
                </f:facet>
                <h:form>
                    <h:commandButton action="#{livroController.prepararAlterarLivro}" value="Alterar"/>
                    </h:form>
            </h:column>
            <h:column>
                <f:facet name="header">
                    <h:outputText value="Excluir"/>
                </f:facet>
                <h:form>
                    <h:commandButton action="#{livroController.excluirLivro}" value="Excluir"/>
                    </h:form>
            </h:column>
        </h:dataTable>
        <br/>
        <h:form>
            <h:commandLink value="Novo Livro" action="#{livroController.prepararAdicionarLivro}"/>
        </h:form>
    </h:body>
</html>

Página gerenciarLivro.xhtml

<?xml version='1.0' encoding='UTF-8' ?>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml"
      xmlns:h="http://java.sun.com/jsf/html"
      xmlns:f="http://java.sun.com/jsf/core">
    <h:head>
        <title>Gerenciador de Livros</title>
    </h:head>
    <h:body>
        <h1>Gerenciador de Livros</h1>
        <h:form>
            Título <h:inputText value="#{livroController.livro.titulo}"/><br/>
            Autor: <h:inputText value="#{livroController.livro.autor}"/><br/>
            Paginas: <h:inputText value="#{livroController.livro.paginas}"/><br/>
            Editora: <h:inputText value="#{livroController.livro.editora}"/><br/>
            ISBN: <h:inputText value="#{livroController.livro.isbn}"/><br/>
            Avaliação: <h:selectOneMenu value="#{livroController.livro.avaliacao}">
                <f:selectItem itemLabel="1" itemValue="1"/>
                <f:selectItem itemLabel="2" itemValue="2"/>
                <f:selectItem itemLabel="3" itemValue="3"/>
                <f:selectItem itemLabel="4" itemValue="4"/>
                <f:selectItem itemLabel="5" itemValue="5"/>
            </h:selectOneMenu><br/>
            <h:commandButton action="#{livroController.adicionarLivro}" value="Inserir Novo Livro"/>
            <h:commandButton action="#{livroController.alterarLivro}" value="Alterar Livro"/>
            <br/>
            <h:commandLink action="index" value="Voltar"/>
        </h:form>
    </h:body>
</html>

Configurações necessárias…

Arquivo web.xml

<?xml version="1.0" encoding="UTF-8"?>
<web-app version="2.5" xmlns="http://java.sun.com/xml/ns/javaee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd">
    <context-param>
        <param-name>javax.faces.PROJECT_STAGE</param-name>
        <param-value>Development</param-value>
    </context-param>
    <servlet>
        <servlet-name>Faces Servlet</servlet-name>
        <servlet-class>javax.faces.webapp.FacesServlet</servlet-class>
        <load-on-startup>1</load-on-startup>
    </servlet>
    <servlet-mapping>
        <servlet-name>Faces Servlet</servlet-name>
        <url-pattern>*.jsf</url-pattern>
    </servlet-mapping>
    <session-config>
        <session-timeout>
            30
        </session-timeout>
    </session-config>
    <welcome-file-list>
        <welcome-file>index.html</welcome-file>
    </welcome-file-list>
</web-app>

Arquivo hibernate.cfg.xml

Este arquivo configura o hibernate de acordo com seu banco de dados note que é preciso adicionar ainda o seu usuário no banco de dados, sua senha e caso seja necessário o ip e a porta do banco.

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-configuration PUBLIC "-//Hibernate/Hibernate Configuration DTD 3.0//EN" "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
  <session-factory>
    <property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>
    <property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
    <property name="hibernate.connection.url">jdbc:mysql://localhost:3306/livraria</property>
    <property name="hibernate.connection.username">seuUsuario</property>
    <property name="hibernate.connection.password">suaSenha</property>
  </session-factory>
</hibernate-configuration>

Essas são as informações necessárias para a criação de um CRUD básico para a gerencia de Livros utilizando JSF 2.0 e Hibernate, neste link segue o projeto criado no Netbeans para download.

Por hoje é só pessoal, qualquer dúvida estou a disposição!

A segunda parte deste CRUD com utilização de ajax e da biblioteca de componentes PrimeFaces está disponível aqui!

Abraços!

José Alexandre Macedo

Estou nos finalmentes pra entregar minha monografia (quando acabar vou postar aqui!), então nessa história de monografia tive um GRANDE problema pra realizar alguns experimentos que pegavam dados da web por causa do Proxy da Faculdade…. procurei, procurei, procurei na web e tava difícil de achar uns exemplos que eu pudesse autenticar meu usuário e que funcionasse! Então achei um que depois de algumas adaptações finalmente funcionou!

Acho que esse pode ser um problema comum e por isso vou postar aqui a solução mágica que deu certo!

O código abaixo só precisa ser executado uma vez no programa escrito em java, mesmo acessando várias vezes a web. Uma vez autenticado o problema está resolvido!

//alterar para o ip e a porta do seu proxy
System.setProperty("http.proxyHost", "ipDoSeuProxy");
System.setProperty("http.proxyPort", "portaDoSeuProxy");
//a danada da autenticação que só funcionou desta forma...
//no seuUsuario e suaSenha você coloca seu login e sua senha do proxy...
Authenticator.setDefault(new Authenticator() {
@Override
protected PasswordAuthentication getPasswordAuthentication() {
return new PasswordAuthentication("seuUsuario", "suaSenha".toCharArray());
}
});

Bom, por hoje é só….

Quando terminar minha monografia volto a postar com mais frequência!

Abraços a todos!

E qualquer coisa estamos ai!