Arquivo da tag: java

Instalando JBoss Tools no Eclipse

O JBoss Tools é um plugin do Eclipse para utilização de tecnologias ligadas à JBoss, como: JBoss AS, Hibernate, JPA, Drools, jBPM, JavaServer Faces, (X)HTML, JBoss Seam, Smooks, JBoss ESB, JBoss Portal e outros.

A versão do JBoss Tools a ser instalada deve ser compatível com a versão do Eclipse utilizado, baseando-se na página de download. Dê preferência pelas “Stable Releases”, só escolha uma versão “Development Milestones” se houver necessidade. Por exemplo, no momento em que escrevo este post, a última versão do Eclipse lançada é a Helios e não há uma versão estável do JBoss Tools compatível com este, então precisarei utilizar o JBoss Tools 3.6.0 ainda em desenvolvimento.

Então, vamos ao passo-a-passo:

1- Abra o Eclipse

2- Vá ao menu “Help” e clique em “Install New Software”

3- Clique no botão “Add” ao lado do campo “Work with”

4- Preencha o campo “Name” com “JBoss Tools 3.6.0” (sem aspas)

5- Preencha o campo “Location” com o endereço encontrado na página de download. No meu caso é “http://download.jboss.org/jbosstools/updates/development/” (novamente, sem aspas)

6- Clique em “OK”

7- Marque os componentes desejados (ou todos, se preferir). Por exemplo, alguns bastante utilizados são: Hibernate Tools, JBossAS Tools e JBoss Tools RichFaces.

8- Clique em “Next”

9- Clique novamente em “Next”

10- Marque a opção “I accept the terms of the license agreements”

11- Clique no botão “Finish”

12- Aguarde o processo de instalação, aparecerá uma janela com título “Security Warning”, clique em “OK”

13- Aguarde novamente e clique em “Restart Now” na janela que aparecerá

Pronto! Seu Eclipse já está com JBoss Tools instalado.

Hello World em JSF

Diante da dificuldade de um amigo em encontrar na internet um tutorial que explicasse corretamente como desenvolver um simples “Hello World” utilizando JSF, ele resolveu me enviar o exemplo dele para que fosse publicado aqui. Obrigado Sérgio!

Nesse artigo, focarei no desenvolvimento do exemplo e não me aprofundarei em explicações sobre a utilização do JSF, para isso aconselho a leitura do capítulo sobre JSF do tutorial Java EE da Sun.

O JSF é um framework que roda no lado servidor da aplicação web e disponibiliza mecanismos ao desenvolvedor para facilitar, entre outros, o tratamento de eventos, validações no servidor, conversão de dados, navegação entre páginas e internacionalização da aplicação.

O funcionamento mais simples a ser entendido do JSF é que ele vincula os componentes de tela aos dados no lado servidor. De forma que ao ser digitado um texto numa caixa da tela, aquele texto será “automaticamente” copiado para um atributo da sua classe controladora, chamada de backing bean. Assim como os itens de um elemento select do html podem ser gerados com base em uma lista que está armazenada no seu backing bean. Para possibilitar esse funcionamento precisamos utilizar as tags JSF no lugar das tags HTML em nossas páginas, o que não traz grandes dificuldades já que existe claramente uma relação de um-para-um entre elas.

Vou parar as explicações por aqui para irmos para o lado prático. Antes de mais nada, é necessário criar um projeto JSF para utilizarmos. Além disso, criaremos algumas páginas JSP, um backing bean para controlar nossa tela, regras de navegação e um arquivo de propriedades com os textos utilizados. Segue o passo-a-passo para desenvolver o Hello World em JSF:

1- Criar um arquivo “index.jsp” na pasta “WebContent” com o conteúdo abaixo. Toda aplicação JSF precisa de um página inicial que redirecione para uma url do jsf.

<html>
<body>
    <jsp:forward page="/formulario.jsf" />
</body>
</html>

2- Criar a classe “PessoaBean” abaixo no pacote “helloworld”. Essa classe será o nosso backing bean.

package helloworld;

public class PessoaBean {

    private String nome = "";

    public String getNome() {
        return nome;
    }

    public void setNome(String nome) {
        this.nome = nome;
    }
}

3- Acrescentar no arquivo “faces-config.xml” o seguinte elemento. Essa é a declaração do nosso backing bean. Nas telas faremos referência a ele utilizando o nome “pessoaBean” que demos ao mesmo. Também definimos que o escopo dele será de requisição.

<managed-bean>
    <managed-bean-name>pessoaBean</managed-bean-name>
    <managed-bean-class>helloworld.PessoaBean</managed-bean-class>
    <managed-bean-scope>request</managed-bean-scope>
</managed-bean>

4- Criar a página “formulario.jsp” na pasta “WebContent” com o conteúdo abaixo. Nela utilizamos a tag loadBundle para carregar um arquivo de propriedades com as mensagens a serem exibidas ao usuário e utilizamos a variável “msg” para referenciar tal arquivo no conteúdo da página. As outras tags utilizadas servem para exibir texto, criar uma caixa de entrada de texto e criar um botão.

<%@ taglib uri="http://java.sun.com/jsf/html" prefix="h"%>
<%@ taglib uri="http://java.sun.com/jsf/core" prefix="f"%>

<f:loadBundle basename="helloworld.mensagens" var="msg" />

<html>
<head>
    <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
    <title>rodrigoaguas.com</title>
</head>
<body>
<f:view>

    <h1><h:outputText value="#{msg.titulo}" /></h1>

    <h:form>
        <h:outputText value="#{msg.pergunta}" />
        <h:inputText value="#{pessoaBean.nome}" />
        <h:commandButton action="bemvindo" value="#{msg.botao}" />
    </h:form>
   
</f:view>
</body>
</html>

5- Criar o arquivo “mensagens.properties” no pacote “helloworld” com o seguinte conteúdo:

pergunta = Qual é o seu nome?
botao = Fale Comigo
titulo = Olá Mundo!
boasvindas = Seja bem vindo ao jsf

6- Para fazermos o usuário ser encaminhado para outra página quando apertar o botão, precisamos acrescentar a regra de navegação abaixo no “faces-config.xml”.

<navigation-rule>
    <from-view-id>/formulario.jsp</from-view-id>
    <navigation-case>
        <from-outcome>bemvindo</from-outcome>
        <to-view-id>/saudacoes.jsp</to-view-id>
    </navigation-case>
</navigation-rule>

Assim, nosso arquivo “faces-config.xml” completo fica da seguinte forma:

<?xml version="1.0" encoding="UTF-8"?>
<faces-config version="1.2" xmlns="http://java.sun.com/xml/ns/javaee"
    xmlns:xi="http://www.w3.org/2001/XInclude" 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-facesconfig_1_2.xsd">

    <managed-bean>
        <managed-bean-name>pessoaBean</managed-bean-name>
        <managed-bean-class>helloworld.PessoaBean</managed-bean-class>
        <managed-bean-scope>request</managed-bean-scope>
    </managed-bean>

    <navigation-rule>
        <from-view-id>/formulario.jsp</from-view-id>
        <navigation-case>
            <from-outcome>bemvindo</from-outcome>
            <to-view-id>/saudacoes.jsp</to-view-id>
        </navigation-case>
    </navigation-rule>

</faces-config>

7- Nosso último passo é criar a página “saudacoes.jsp” na pasta “WebContent”. Essa página será exibida após o visitante ter digitado o nome e apertado o botão no formulário da outra página.

<%@ taglib uri="http://java.sun.com/jsf/html" prefix="h"%>
<%@ taglib uri="http://java.sun.com/jsf/core" prefix="f"%>

<f:loadBundle basename="helloworld.mensagens" var="msg" />

<html>
<head>
    <title>rodrigoaguas.com</title>
</head>
<body>
<f:view>
   
    <h3>
        <h:outputText value="#{msg.boasvindas}" />,
        <h:outputText value="#{pessoaBean.nome}" />!
    </h3>
   
</f:view>
</body>
</html>

Pronto! Agora basta dar deploy em um servidor. Lembrando que o eclipse tem integração com o Tomcat e o JBoss, bastando para dar deploy neles clicar com o botão direito do mouse na pasta do projeto, depois ir em “Run As”, depois “Run on Server”, selecionar o servidor e clicar em “Finish”.

Depois de feito o deploy, acesse http://localhost:8080/hello/ para ver sua aplicação funcionando.

Configurando Facelets em projeto JSF no eclipse

Após termos nosso projeto JavaServer Faces criado no eclipse, iremos configurar o facelets no mesmo. O facelets é um framework de templating feito específicamente para projetos JSF. Ele se integra de tal forma com o ciclo de vida do jsf que resulta numa melhora da performance significativa em comparação ao uso de JSP. Além disso, o facelets funciona em todos os web containers amplamente conhecidos, não impondo restrição alguma ao projeto.

1- Faça o download do facelets na versão 1.1.15, pois a versão 1.2 não é estável (e parece que não ficará tão cedo);

2- Extraia o arquivo “jsf-facelets.jar” para dentro da pasta “WebContent\WEB-INF\lib” do seu projeto JSF. Como estamos utilizando o JBoss nesse exemplo, não é necessário extrair também os outros arquivos JAR da pasta lib do facelets, pois são dependências de bibliotecas que já existem no JBoss;

3- Não basta apenas acrescentarmos a biblioteca do facelets em nosso projeto, devemos configurar algumas outras coisas para que o JSF se integre ao facelets. Acrescente as seguintes linhas ao arquivo faces-config.xml (encontrado em “WebContent\WEB-INF”):

<application>
    <view-handler>com.sun.facelets.FaceletViewHandler</view-handler>
</application>

4- E no mesmo local devemos incluir as seguintes linhas ao arquivo Web.xml:

<context-param>
    <param-name>javax.faces.DEFAULT_SUFFIX</param-name>
    <param-value>.htm</param-value>
</context-param>

<context-param>
    <param-name>facelets.DEVELOPMENT</param-name>
    <param-value>true</param-value>
</context-param>

<context-param>
    <param-name>facelets.SKIP_COMMENTS</param-name>
    <param-value>true</param-value>
</context-param>

<context-param>
    <param-name>com.sun.faces.validateXml</param-name>
    <param-value>true</param-value>
</context-param>

No primeiro parâmetro, indicamos que os arquivos físicos que utilizaremos para a apresentação tem extensão .htm.
Dessa forma, quando o facelets receber uma requisição ao endereço “bemvindo.jsf” buscará pelo arquivo “bemvindo.htm”.
Na prática, não importa a extensão escolhida, costuma-se deixar htm ou html apenas por questões históricas.

O segundo parâmetro indica ao facelets que estamos em ambiente de desenvolvimento, dessa forma ele exibe possíveis erros em uma tela amigável ao desenvolvedor, mas que não deve ser exibida futuramente ao usuário final.

O terceiro parâmetro determina ao facelets que os comentários nos códigos HTML devem ser tratados como comentários. Pois o facelets por padrão não ignora comentários () nos arquivos de apresentação.

O quarto parâmetro faz com que o facelets valide o código html das telas, só permitindo que seja utilizado XHTML.

Pronto! Dessa forma o facelets já está pronto para ser executado em seu projeto.