Diferença entre colocar as notações do mapeamento nos métodos getters e colocar nos atributos privados - JSF

Quando você coloca as anotações da JPA nos atributos, o framework usará Reflection para acessar os valores. Em alguns casos, valores são carregados prematuramente, pois o framework não interceptará as chamadas nos métodos getters, por isso, ele carrega do banco de dados antes mesmo do momento necessário.

É aconselhado mapear sempre nos getters.
Nunca misture as duas formas de mapeamento, pois o comportamento pode ser inesperado.

Importância dos métodos hashCode e equals - JSF

Para que os objetos sejam diferenciados uns de outros, precisamos implementar o métodos equals().
No banco de dados, as chaves primárias diferenciam registros distintos. Quando mapeamos uma entidade de uma tabela, devemos criar o método equals(), levando em consideração a forma em que os registros são diferenciados no banco de dados.


public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + ((codigo == null) ? 0 : codigo.hashCode());
        return result;
    }

    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        Pessoa other = (Pessoa) obj;
        if (codigo == null) {
            if (other.codigo != null)
                return false;
        } else if (!codigo.equals(other.codigo))
            return false;
        return true;
    }

Veja que nesse exemplo, esse método é baseado no atributo "codigo", que representa a chave na tabela do banco de dados.

O método hashCode() ajuda a criar um critério para espalhar os diversos objetos dentro de uma tabela de espalhamento. Isso é importante para um determinado objeto ser encontrado mais rapidamente, melhorando a performance do software, pois evita muitas comparações desnecessárias durante uma busca em memória.

Associar atributos ao componente que usa o conversor - JSF

Deve-se colocar na página xhtml:

<h:inputText ....>
    <f:converter .... />
    <f:attribute name="nomeDoAtributo" value="#{.....}"/>
</h:inputText>

E no conversor pega o atributo da seguinte forma:

String valor = (String) component.getAttributes().get("nomeDoAtributo");

Páginas JSF sem extensão

Para tornar suas URLs amigáveis, você pode usar a biblioteca PrettyFaces (http://ocpsoft.org/prettyfaces/).

Baixe o JAR do PrettyFaces, importe em seu projeto, configure o arquivo web.xml e crie um novo chamado pretty-config.xml.

pretty-config.xml
<!-- Este arquivo deve ser colocado na pasta WEB-INF -->
<pretty-config xmlns="http://ocpsoft.com/prettyfaces/3.3.2"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://ocpsoft.com/prettyfaces/3.3.2 http://ocpsoft.com/xml/ns/prettyfaces/ocpsoft-pretty-faces-3.3.2.xsd">

<url-mapping id="cadastroLancamento">
<pattern value="/cadastro-lancamento" />
<view-id value="/CadastroLancamento.xhtml" />
</url-mapping>
<url-mapping id="consultaLancamento">
<pattern value="/consulta-lancamento" />
<view-id value="/ConsultaLancamento.xhtml" />
</url-mapping>

</pretty-config> 


web.xml
<!-- Incluir esse fragmento de código no arquivo web.xml -->
<filter>
<filter-name>Pretty Filter</filter-name>
<filter-class>com.ocpsoft.pretty.PrettyFilter</filter-class>
</filter>

<filter-mapping>
<filter-name>Pretty Filter</filter-name>
<url-pattern>/*</url-pattern>
<dispatcher>FORWARD</dispatcher>
<dispatcher>REQUEST</dispatcher>
<dispatcher>ERROR</dispatcher>
</filter-mapping>

Configurar extensão dos arquivos JSF

A configuração do mapeamento dos arquivos são feitas no arquivo web.xml.
Neste exemplo todos os arquivos .xhtml são mapeados:

<servlet-mapping>
    <servlet-name>facesServlet</servlet-name>
    <url-pattern>*.xhtml</url-pattern>
</servlet-mapping>

Um exemplo sem precisar utilizar a extensão do arquivo:

<servlet-mapping>
    <servlet-name>facesServlet</servlet-name>
    <url-pattern>/faces/*</url-pattern>
</servlet-mapping>

Neste segundo exemplo deve-se acessar o sistema da seguinte forma:

http://localhost:8080/SistemaTeste/faces/CadastroTeste

Definir o tempo da expiração da Sessão JSF 2

Para definir o tempo da expiração da sessão em um sistema JSF deve-se configurar o arquivo web.xml com o seguinte código:

 <session-config>
  <session-timeout>30</session-timeout>
</session-config>

O tempo é definido em minutos.



Podemos também criar cookies com JSF, utilizando o código abaixo no managed bean:


Cookie codigo = new Cookie("codigo", "1");
codigo.setMaxAge(3600);
((HttpServletResponse)facesContext.getExternalContext().getResponse())
.addCookie(codigo);

Observe que deve-se gerar o valor do código e não utilizar um valor fixo como neste exemplo.


Para recuperar os cookies, utiliza-se o código abaixo, assim é só procurar o cookie salvo previamente e autenticar o usuário:


FacesContext facesContext = FacesContext.getCurrentInstance();
Cookie cookies[] = ((HttpServletRequest)facesContext.getExternalContext()
.getRequest()).getCookies;

Diferenças entre EJB, Tomcat e GlassFish

Tomcat

EJB (Enterprise JavaBeans) é uma especificação que faz parte da Java EE. É um componente executado em um servidor de aplicação, que simplifica o desenvolvimento de componentes distribuídos, transacionais e seguros.

Você deve pensar em usar EJB caso tenha necessidade, por exemplo, de separar as classes negócio em um servidor e a interface com o usuário em outro servidor.

Apesar da possibilidade de chamada de componentes remotos, você não precisa desse requisito para usar EJB. Com essa tecnologia, o controle de transação e a segurança de sua aplicação são simplificados também.

Tomcat é apenas um Servlet Container, ou seja, ele implementa as especificações de Servlets e JSP (que fazem parte do Java EE). Tomcat não implementa EJB.

GlassFish

JBoss AS e Glassfish implementam todas as especificações do Java EE (incluindo Servlets, JSP, EJB, etc). A diferença entre Glassfish e JBoss AS é simplesmente o fornecedor. Os dois fazem a mesma coisa, de formas diferentes. Teoricamente, uma aplicação desenvolvida e testada no JBoss AS, deve funcionar no Glassfish.

Não acredite em pessoas que falam que Tomcat não é bom para produção, se os argumentos não forem baseados em testes. Só porque ele não implementa todas as especificações, não quer dizer que ele é pior.

Se o que você precisa é colocar em produção um sistema web, feito em JSF e JPA, por exemplo, Tomcat é mais do que suficiente. 

A única semelhança entre Enterprise JavaBeans (EJB) e JavaBeans são os nomes, por isso, não devem ser comparados.

EJB é a especificação que faz parte da Java EE.

JavaBeans são classes Java criadas seguindo uma convenção: os objetos devem ser serializáveis, com um construtor padrão e deve possuir métodos getters e setters para acessar os atributos de instância.