JPA 2.0: CRUD com EJB 3.1

Segundo a Oracle: 

"Enterprise JavaBeans (EJB) technology is the server-side component architecture for Java Platform, Enterprise Edition (Java EE). EJB technology enables rapid and simplified development of distributed, transactional, secure and portable applications based on Java technology."

Nessa postagem vamos criar um CRUD utilizando EJB como forma de injetar a conexão com o banco de dados. Atualmente está na versão 3.1, para ser utilizada com JEE 6. Eu já usei o EJB 3.0 com o JEE 5, e aquele era um "monstrinho" de pesado! Hoje nem chega ser perceptível o uso dele.

Bom... chega de teorias e vamos ao o que interessa,  crie um projeto com o nome CrudJPA, caso não saiba como iniciar o JPA no projeto, use esse projeto como base (siga os passos até criar o persistence.xml).
Em Pacotes de código-fonte crie os pacotes: model, controle e dao. Dentro do pacote model crie uma classe java com o nome de Cliente.java:

import java.io.Serializable;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.Table;

@Entity
@Table(name="cliente")
public class Cliente implements Serializable {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name="codigo")
    private Long codigo;

    @Column(length=100, name="nome")
    private String nome;

    public Long getCodigo() {
        return codigo;
    }

    public void setCodigo(Long codigo) {
        this.codigo = codigo;
    }

    public String getNome() {
        return nome;
    }

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

    @Override
    public int hashCode() {
        int hash = 0;
        hash += (codigo != null ? codigo.hashCode() : 0);
        return hash;
    }

    @Override
    public boolean equals(Object object) {
        if (!(object instanceof Cliente)) {
            return false;
        }
        Cliente other = (Cliente) object;
        if ((this.codigo == null && other.codigo != null) || (this.codigo != null && !this.codigo.equals(other.codigo))) {
            return false;
        }
        return true;
    }
}

Nosso modelo acima não tem nada de diferente, apenas as anotações do JPA que já foram faladas em postagens anteriores, antes que esqueçamos vamos mapear nossa entidade Cliente, dentro do persistence.xml, o mesmo deverá ficar assim:

<persistence version="2.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://java.sun.com/xml/ns/persistence" xsi:schemalocation="http://java.sun.com/xml/ns/persistence http://java.sun.com/xml/ns/persistence/persistence_2_0.xsd">
    <persistence-unit name="TesteJPAPU" transaction-type="JTA">
        <provider>org.eclipse.persistence.jpa.PersistenceProvider</provider>
        <jta-data-source>5tads</jta-data-source>
        <class>model.Cliente</class>
        <exclude-unlisted-classes>true</exclude-unlisted-classes>
        <properties>
            <property name="eclipselink.ddl-generation" value="create-tables" />
        </properties>
    </persistence-unit>
</persistence>

Agora dentro do pacote dao crie uma classe java com o nome de ClienteDAO.java, com o seguinte código:

package dao;

import java.util.List;
import javax.ejb.Stateless;
import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;
import javax.persistence.Query;
import model.Cliente;

/**
 *
 * @author andii
 */

@Stateless
public class ClienteDAO {

    @PersistenceContext(unitName="TesteJPAPU")
    private EntityManager em;

    public boolean gravar(Cliente cliente){
        boolean sucesso = false;
        try {
            em.merge(cliente);
            sucesso = true;
        } catch (Exception e) {
            e.printStackTrace();
        }

        return sucesso;
    }

    public Cliente selecionar(Long codigo){
        Cliente cliente = null;
        try {
            cliente = em.find(Cliente.class, codigo);
        } catch (Exception e) {
            e.printStackTrace();
        }

        return cliente;
    }

    public boolean remover(Cliente cliente){
        boolean sucesso = false;
        try {
            cliente = em.find(Cliente.class, cliente.getCodigo());
            em.remove(cliente);
            sucesso = true;
        } catch (Exception e) {
            e.printStackTrace();
        }

        return sucesso;
    }

    public List<Cliente> listar() {
        List<Cliente> clientes = null;
        try {
            Query query = em.createQuery("Select c from Cliente c");
            clientes = query.getResultList();
        } catch (Exception e) {
            e.printStackTrace();
        }
        
        return clientes;
    }
}

Agora vamos entender o que acontece no nosso ClienteDAO:
@Stateless: essa anotação define um bean de sessão sem estado, o que isso quer dizer? Que o nosso dao será criado toda vez que precisarmos dele. Caso precise que esse EJB se mantenha como um escopo de sessão mesmo, aí teria que usar @Stateful... mas não vem ao caso agora.
@PersistenceContext: este é usado para injetar o PU (persistence unit) em um EntityManager, veja que não é necessário instanciar um EntityManagerFactory. Lembre-se que esse TesteJPAPU é o mesmo que foi definido lá no meu persistence-unit do meu persistence.xml.
E quantos aos métodos, perceba nos códigos que não há mais a necessidade de abrir (usando em.getTransaction().begin()) e nem fechar (usando em.close()) a conexão com o banco de dados, ou seja, o EJB será o responsável por fazer isso (isso evita possíveis exception do tipo LazyInitializationException).
Apenas uma observação para o método gravar: veja que não tem o método alterar, isso pois o em.merge(cliente), funciona tanto para persistir um objeto como apenas para alterar, isso funciona assim: caso o JPA identifique que o objeto passado por parâmetro não está sendo gerenciado por ele, isso fará ele gravar um novo objeto, no caso aqui um novo cliente. Já quando você seleciona um cliente com um em.find(...) esse cliente está sendo gerenciado pelo JPA, e se mandar dar um em.merge(cliente) ele vai apenas alterar os dados, e não gravará um novo!

E agora vamos criar um bean dentro do pacote controle, para isso crie uma classe java com o nome de ClienteBean.java, dessa forma:

package controle;

import dao.ClienteDAO;
import java.io.Serializable;
import java.util.List;
import javax.ejb.EJB;
import javax.enterprise.context.SessionScoped;
import javax.faces.application.FacesMessage;
import javax.faces.context.FacesContext;
import javax.faces.event.ActionEvent;
import javax.inject.Named;
import model.Cliente;

/**
 *
 * @author andii
 */
@Named(value = "clienteBean")
@SessionScoped
public class ClienteBean implements Serializable {

    @EJB
    private ClienteDAO clienteDAO;
    private Cliente cliente = new Cliente();
    private List<Cliente> clientes;

    public void novo(){
        cliente = new Cliente();
    }

    public void gravar() {
        FacesContext context = FacesContext.getCurrentInstance();
        boolean resultado = clienteDAO.gravar(cliente);

        if (resultado) {
            cliente = new Cliente();
            context.addMessage(null, new FacesMessage("Cliente gravado com sucesso"));
        } else {
            context.addMessage(null, new FacesMessage("Falha ao gravar cliente!"));
        }
    }

    public void selecionar(ActionEvent evento) {
        Long codigo = (Long) evento.getComponent().getAttributes().get("codigo");
        cliente = clienteDAO.selecionar(codigo);
    }

    public void remover() {
        FacesContext context = FacesContext.getCurrentInstance();
        boolean resultado = clienteDAO.remover(cliente);

        if (resultado) {
            cliente = new Cliente();
            context.addMessage(null, new FacesMessage("Cliente removido com sucesso"));
        } else {
            context.addMessage(null, new FacesMessage("Falha ao remover cliente!"));
        }
    }

    //Getters e Setters
    public Cliente getCliente() {
        return cliente;
    }

    public void setCliente(Cliente cliente) {
        this.cliente = cliente;
    }

    public List<Cliente> getClientes() {
        clientes = clienteDAO.listar();
        return clientes;
    }

    public void setClientes(List<Cliente> clientes) {
        this.clientes = clientes;
    }
}

A unica diferença nesse bean é o fato do nosso ClienteDAO estar anotado com um @EJB.
@EJB: Essa anotação serve para fazermos a injeção de dependência do nosso EJB, que neste caso é o ClienteDAO, por ele estar sendo injetado, em nenhum momento será necessário instância-lo com um new ClienteDAO();

Agora para finalizar de vez o CRUD, vamos alterar a página index.xhtml(que é criada juntamente com o projeto) e para não ter que criar outras páginas, fiz o CRUD inteiro somente na página index, mas aí é só fazer como desejar, esta deverá ficar assim:

<?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>Facelet Title</title>
    </h:head>
    <h:body>
        <h:form id="dadosCliente">
            <fieldset style="width: 350px">
                <legend>Novo cliente</legend>
                <h:commandButton value="Novo" action="#{clienteBean.novo}" />
            </fieldset>
            <fieldset style="width: 350px">
                <legend>Dados do cliente</legend>
                <h:panelGrid columns="4">
                    <h:outputText value="Nome" />
                    <h:inputText value="#{clienteBean.cliente.nome}" />
                    <h:commandButton value="Gravar" action="#{clienteBean.gravar}" />
                    <h:commandButton value="Remover" action="#{clienteBean.remover}" rendered="#{clienteBean.cliente.codigo > 0}" />
                </h:panelGrid>
            </fieldset>
        </h:form>

        <h:form>
            <fieldset style="width: 350px">
                <legend>Clientes</legend>
                <h:dataTable value="#{clienteBean.clientes}" var="cliente" border="1">
                    <h:column>
                        <f:facet name="header"><h:outputText value="CODIGO" /></f:facet>
                        <h:outputText value="#{cliente.codigo}" />
                    </h:column>
                    <h:column>
                        <f:facet name="header"><h:outputText value="NOME" /></f:facet>
                        <h:outputText value="#{cliente.nome}" />
                    </h:column>
                    <h:column>
                        <h:commandButton value="Selecionar" actionListener="#{clienteBean.selecionar}">
                            <f:attribute name="codigo" value="#{cliente.codigo}" />
                            <f:ajax render=":dadosCliente" execute="@this" />
                        </h:commandButton>
                    </h:column>
                </h:dataTable>
            </fieldset>
        </h:form>
    </h:body>
</html>

Inicialmente essa seria a visualização da página index:

Ao clicar no botão Selecionar o cliente será selecionado, e será renderizado um botão de remover, enfim quando selecionado um cliente, a janela fica assim:

Mas como eu falei, essa é apenas uma opção de como pode ser feito nossa visualização, use sua criatividade para deixá-la como achar melhor!

Para mais informações veja a API do Java EE 6, para ver mais sobre o EJB, selecione o pacote javax.ejb. Aqui finalizamos mais uma postagem... fiz ela bem simples, para dar mais foco ao EJB 3.1 com o JPA 2.0. :)

JavaEE 6: CRUD em JSF 2.0

Inicialmente no banco de dados crie uma database chamada 4tads, e nela crie uma tabela cliente com o seguinte código:

CREATE TABLE `4tads`.`cliente` ( 
  `codigo` INTEGER(11)  NOT NULL AUTO_INCREMENT, 
  `nome` VARCHAR(255)  NOT NULL, 
  `telefone` VARCHAR(30) , 
  PRIMARY KEY (`codigo`) 
) 
ENGINE = InnoDB; 

Agora crie um projeto JEE 6 (Veja aqui), com o nome de crudJSF, teremos como estrutura final o seguinte projeto:

Antes de iniciar a codificação, vamos colocar no projeto o driver JDBC para acesso ao banco de dados, para isso clique com o botão direito em cima de Bibliotecas – Adicionar Biblioteca e selecione MySQL JDBC Driver:

Agora no Pacotes de código-fonte crie os seguintes pacotes: model, controller e dao.
Dentro do model crie uma classe java chamada Cliente.java, com os atributos codigo, nome e telefone, além dos getters e setters:

public class Cliente {

    private int codigo;
    private String nome;
    private String telefone;

    public int getCodigo() {
        return codigo;
    }

    public void setCodigo(int codigo) {
        this.codigo = codigo;
    }

    public String getNome() {
        return nome;
    }

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

    public String getTelefone() {
        return telefone;
    }

    public void setTelefone(String telefone) {
        this.telefone = telefone;
    }
}

Dentro do dao vamos criar uma classe java chamada Conexao.java, esta será responsável por fazer a conexão com o banco de dados:

import java.sql.DriverManager;
import java.sql.SQLException;
import com.mysql.jdbc.Connection;

public class Conexao {

    private String driver = "com.mysql.jdbc.Driver";
    private String URL = "jdbc:mysql://localhost/4tads";
    private String USER = "root";
    private String SENHA = "admin";
    private Connection conn;

    public Conexao() {
        try {
            Class.forName(driver);
            conn = (Connection) DriverManager.getConnection(URL, USER, SENHA);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public Connection getConn() {
        return conn;
    }

    public void fecharConexao() {
        try {
            conn.close();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}

Perceba que o atributo URL termina com 4tads, este está se referindo a nossa database criada no inicio do post que contém nossa tabela cliente. Os atributos USER e SENHA, se referem ao usuário e a senha do banco de dados.
Depois de ter criado nosso arquivo de conexão com o banco, vamos criar nossa classe ClienteDAO.java:

import com.mysql.jdbc.Statement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;
import model.Cliente;

/**
 *
 * @author andii
 */
public class ClienteDAO {

    private Conexao conexao;
    private Statement stmt;
    private boolean sucesso = false;

    public ClienteDAO() {
        conexao = new Conexao();
        try {
            stmt = (Statement) conexao.getConn().createStatement();
        } catch (SQLException ex) {
            ex.printStackTrace();
        }
    }

    public boolean inserir(Cliente cliente) {
        try {
            stmt.execute("INSERT INTO cliente (nome, telefone) VALUES ('" + cliente.getNome() + "','" + cliente.getTelefone() + "')");
            sucesso = true;
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            conexao.fecharConexao();
        }

        return sucesso;
    }

    public boolean alterar(Cliente cliente) {
        try {
            stmt.execute("UPDATE cliente SET nome = '" + cliente.getNome() + "', telefone = '" + cliente.getTelefone() + "' WHERE codigo = '" + cliente.getCodigo() + "'");
            sucesso = true;
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            conexao.fecharConexao();
        }

        return sucesso;
    }

    public boolean remover(Cliente cliente) {
        try {
            stmt.execute("DELETE FROM cliente WHERE codigo = '" + cliente.getCodigo() + "'");
            sucesso = true;
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            conexao.fecharConexao();
        }

        return sucesso;
    }

    public List<Cliente> listar() {
        List<Cliente> clientes = new ArrayList<Cliente>();
        try {
            ResultSet rs = stmt.executeQuery("SELECT * FROM cliente ORDER BY nome");
            while (rs.next()) {
                Cliente cliente = new Cliente();
                cliente.setCodigo(rs.getInt("codigo"));
                cliente.setNome(rs.getString("nome"));
                cliente.setTelefone(rs.getString("telefone"));

                clientes.add(cliente);
            }

        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            conexao.fecharConexao();
        }

        return clientes;
    }
}

Agora dentro do controller vamos criar nosso bean, para isso crie uma nova classe java com o nome de ClienteBean.java:

import dao.ClienteDAO;
import java.io.Serializable;
import java.util.List;
import javax.enterprise.context.SessionScoped;
import javax.faces.model.DataModel;
import javax.faces.model.ListDataModel;
import javax.inject.Named;
import model.Cliente;

/**
 *
 * @author andii
 */
@Named
@SessionScoped
public class ClienteBean implements Serializable{

    private ClienteDAO clienteDAO;
    private Cliente cliente = new Cliente();
    private DataModel<Cliente> clientes;

    public void novo(){
        cliente = new Cliente();
    }

    public String inserir(){
        String resultado = "falha";
        clienteDAO = new ClienteDAO();
        boolean retorno = clienteDAO.inserir(cliente);

        if(retorno){
            resultado = "clientes";
        }

        return resultado;
    }

    public void selecionar(){
        cliente = clientes.getRowData();
    }

    public String alterar(){
        String resultado = "falha";
        clienteDAO = new ClienteDAO();
        boolean retorno = clienteDAO.alterar(cliente);

        if(retorno){
            resultado = "clientes";
        }

        return resultado;
    }

    public String remover(){
        String resultado = "falha";
        clienteDAO = new ClienteDAO();
        boolean retorno = clienteDAO.remover(cliente);

        if(retorno){
            resultado = "clientes";
        }

        return resultado;
    }

    public Cliente getCliente() {
        return cliente;
    }

    public void setCliente(Cliente cliente) {
        this.cliente = cliente;
    }

    public DataModel<Cliente> getClientes() {
        clienteDAO = new ClienteDAO();
        List<Cliente> clienteList = clienteDAO.listar();
        clientes = new ListDataModel<Cliente>(clienteList);
        return clientes;
    }

    public void setClientes(DataModel<Cliente> clientes) {
        this.clientes = clientes;
    }

}

Para finalizar vamos criar nossas páginas JSF, com o botão direito em Páginas Web – Novo – Outro... selecione a categoria JavaServer Faces e o tipo de arquivo Página JSF e aí é só colocar o nome e finalizar. Faça esse procedimento para criar as seguintes páginas:
Obs.: apenas substitua o h:body de cada página criada pelos respectivos códigos abaixo.
novo.xhtml:

<h:body> 
        <h:form> 
            <h:panelGrid columns="2"> 
                <h:outputText value="Nome" /> 
                <h:inputText value="#{clienteBean.cliente.nome}" /> 
                <h:outputText value="Telefone" /> 
                <h:inputText value="#{clienteBean.cliente.telefone}" /> 
                <h:commandButton action="#{clienteBean.inserir}" value="Inserir" /> 
                <h:commandButton action="clientes" immediate="true" value="Cancelar" />
            </h:panelGrid> 
        </h:form> 
    </h:body>

Visualização:

alterar.xhtml:

<h:body> 
        <h:form> 
            <h:panelGrid columns="2"> 
                <h:outputText value="Nome" /> 
                <h:inputText value="#{clienteBean.cliente.nome}" /> 
                <h:outputText value="Telefone" /> 
                <h:inputText value="#{clienteBean.cliente.telefone}" /> 
                <h:commandButton action="#{clienteBean.alterar}" value="Alterar" /> 
                <h:commandButton action="clientes" immediate="true" value="Cancelar" />     
            </h:panelGrid> 
        </h:form> 
    </h:body>

Visualização:

remover.xhtml:

<h:body> 
        <h:form> 
            <h:outputText value="Deseja remover o cliente: #{clienteBean.cliente.nome} ?" /> 
            <h:panelGrid columns="2"> 
                <h:commandButton action="#{clienteBean.remover}" value="Remover" /> 
                <h:commandButton action="clientes" immediate="true" value="Cancelar" /> 
            </h:panelGrid> 
        </h:form> 
    </h:body>

Visualização:

clientes.xhtml:

<h:body> 
        <h:form> 
            <h:commandButton action="novo" actionlistener="#{clienteBean.novo}" value="Novo" /> 
            <h:dataTable value="#{clienteBean.clientes}" var="c"> 
                <h:column> 
                    <f:facet name="header"><h:outputText value="Nome" /></f:facet>
                    <h:outputText value="#{c.nome}" /> 
                </h:column> 
                <h:column> 
                    <f:facet name="header"><h:outputText value="Telefone" /></f:facet> 
                    <h:outputText value="#{c.telefone}" /> 
                </h:column> 
                <h:column> 
                    <f:facet name="header"><h:outputText value="Ações" /></f:facet> 
                    <h:commandButton action="alterar" actionListener="#{clienteBean.selecionar}" value="Alterar" /> 
                    <h:commandButton action="remover" actionListener="#{clienteBean.selecionar}" value="Remover" /> 
                </h:column> 
            </h:dataTable> 
        </h:form> 
    </h:body>

Visualização:

index.xhtml:

<h:body> 
        <h:form> 
            <h:commandButton action="clientes" value="Clientes" /> 
        </h:form> 
    </h:body>

Visualização:

erro.xhtml:

<h:body> 
        <h:form> 
            <h:outputText value="Ocorreu um erro, tente novamente:" /> 
            <h:commandButton action="index" value="Tentar novamente" /> 
        </h:form> 
    </h:body>

Visualização:

É isso aí... ;)

JavaEE 5: CRUD em JSF 1.2

Na postagem de hoje iremos fazer um CRUD - uma aplicação simples com as seguintes operações: Create(criar ou inserir), Retrieve(recuperar ou listar), Update(atualizar) e Delete(remover). Antes de começar vamos refrescar a memória: JavaServer Faces ...

Criando o projeto

No Eclipse crie um novo 'JSF Project' como no link acima e coloque o nome de ProjetoJsf. Segue a estrutura do projeto:

 

Nesse post não iremos implementar os pacotes model e dao, estes serão reutilizados das postagens anteriores: Parte I e Parte II, de acordo com esses links implemente as classes: Categoria.java, Conexao.java e Categoria_DAO.java, quanto a essa última classe, ela está implementada em partes nas duas postagens, então garanta que ela tenha os seguintes métodos: inserir, listar, selecionar, alterar e remover. 

Depois de feito isso, vamos criar nosso pacote  control onde guardamos nossos beans. Nesse caso teremos apenas um bean chamado CategoriaBean.java, a implentação desse bean é o seguinte:

public class CategoriaBean {
    //Atributos
    private Categoria categoria = new Categoria();
    private List<Categoria> categorias;

    //Métodos
    public String nova(){
        categoria = new Categoria();
        
        return "inserir";
    }
    
    public String inserir(){
        Categoria_DAO dao = new Categoria_DAO();
        return dao.inserir(categoria);
    }
    
    public void selecionar(int codigo){
        Categoria_DAO dao = new Categoria_DAO();
        categoria = dao.selecionar(codigo);
    }
    
    public String alterar(){
        Categoria_DAO dao = new Categoria_DAO();
        return dao.alterar(categoria);
    }
    
    public String remover(){
        Categoria_DAO dao = new Categoria_DAO();
        return dao.remover(categoria.getCodigo());
    }
    
    //Getters e Setters
    
    public Categoria getCategoria() {
        return categoria;
    }

    public void setCategoria(Categoria categoria) {
        this.categoria = categoria;
    }

    public List<Categoria> getCategorias() {
        Categoria_DAO dao = new Categoria_DAO();
        categorias = dao.listar();
        return categorias;
    }

    public void setCategorias(List<Categoria> categorias) {
        this.categorias = categorias;
    }
    
}

Alguns métodos são claros, criam uma Categoria_DAO e chamam suas operações correspondentes. Perceba que não há passagem do objeto Categoria por parâmetro nos métodos do bean, pois através dos getter's e setter's eles são teoricamente "injetados" dentro do bean ao dar um submit em um form de uma página JSF (talvez isso não tenha ficado muito claro, mas vou tentar esclarecer no decorrer da implementação).

Depois de implementar o bean, vamos mapeá-los no faces-config.xml com escopo de sessão:

<managed-bean>
  <managed-bean-name>categoriaBean</managed-bean-name>
  <managed-bean-class>control.CategoriaBean</managed-bean-class>
  <managed-bean-scope>session</managed-bean-scope>
 </managed-bean>

Dentro do WebContent crie as seguintes JSP's com o template de JSFBasePage:
* inserirCategoria.jsp
* categorias.jsp
* alterarCategoria.jsp
* removerCategoria.jsp
* falha.jsp

Por enquanto podem ser vazios mesmo, no faces-config.xml, faça o seguinte diagraḿa, onde alguns redirecionamentos dependem do que o bean retornar (explicado em sala de aula):

Segue agora apenas os códigos dos JSF's:
inserirCategoria.jsp

<%@ taglib uri="http://java.sun.com/jsf/html" prefix="h" %>
<%@ taglib uri="http://java.sun.com/jsf/core" prefix="f" %>
<html>
    <head>
        <title>Inserir Categoria</title>
    </head>
    <body>
        <f:view>
            <h:form>
            <h:panelGrid columns="3">
                <h:outputText value="Nome" />
                <h:inputText value="#{categoriaBean.categoria.nome}" required="true" requiredMessage="Informe o nome" id="nome" />
                <h:message for="nome" style="color: red;" />
                <h:commandButton value="Salvar" action="#{categoriaBean.inserir}" />
                <h:commandButton value="Cancelar" action="cancelar" immediate="true" />
            </h:panelGrid>    
            
            </h:form>
            
        </f:view>
    </body>    
</html>  

categorias.jsp

<%@ taglib uri="http://java.sun.com/jsf/html" prefix="h" %>
<%@ taglib uri="http://java.sun.com/jsf/core" prefix="f" %>
<html>
    <head>
        <title>Categorias</title>
    </head>
    <body>
        <f:view>
            <h:form>
                <h:commandButton value="Nova" action="#{categoriaBean.nova}" />
            </h:form>
            
            <h:dataTable value="#{categoriaBean.categorias}" var="c"  >
                <h:column>
                    <f:facet name="header"><h:outputText value="Codigo" /></f:facet>
                    <h:outputText value="#{c.codigo}" />
                </h:column>
                <h:column>
                    <f:facet name="header"><h:outputText value="Nome" /></f:facet>
                    <h:outputText value="#{c.nome}" />
                </h:column>
                <h:column>
                    <f:facet name="header"><h:outputText value="Ações" /></f:facet>
                    <h:form>
                        <h:commandButton value="Alterar" actionListener="#{categoriaBean.selecionar(c.codigo)}" action="alterar" />
                        <h:commandButton value="Remover" actionListener="#{categoriaBean.selecionar(c.codigo)}" action="remover" />
                    </h:form>
                </h:column>
            </h:dataTable>
            
        </f:view>
    </body>    
</html>  

alterarCategoria.jsp

<%@ taglib uri="http://java.sun.com/jsf/html" prefix="h" %>
<%@ taglib uri="http://java.sun.com/jsf/core" prefix="f" %>
<html>
    <head>
        <title>Alterar Categoria</title>
    </head>
    <body>
        <f:view>
            <h:form>
            <h:panelGrid columns="3">
                <h:outputText value="Nome" />
                <h:inputText value="#{categoriaBean.categoria.nome}" required="true" requiredMessage="Informe o nome" id="nome" />
                <h:message for="nome" style="color: red;" />
                <h:commandButton value="Salvar" action="#{categoriaBean.alterar}" />
                <h:commandButton value="Cancelar" action="cancelar" immediate="true" />
            </h:panelGrid>    
            </h:form>
        </f:view>
    </body>    
</html>  

removerCategoria.jsp

<%@ taglib uri="http://java.sun.com/jsf/html" prefix="h" %>
<%@ taglib uri="http://java.sun.com/jsf/core" prefix="f" %>
<html>
    <head>
        <title>Remover Categoria</title>
    </head>
    <body>
        <f:view>
            <h:outputText value="Confirma a remoção da categoria: #{categoriaBean.categoria.nome} ?" />
            <h:form> 
                <h:commandButton value="Sim" action="#{categoriaBean.remover}" />
                <h:commandButton value="Não" action="cancelar" immediate="true" />
            </h:form>
        </f:view>
    </body>    
</html>  

falha.jsp

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

<html>
    <head>
        <title></title>
    </head>
    <body>
        <f:view>
            <h:outputText value="Ocorreu um erro..." />
        </f:view>
    </body>    
</html>  

Até a próxima! =)

Baixar projeto

JavaEE 5: CRUD com JSP e Servlet - Parte II

Continuando a aula do dia 18/08/2010, vamos implementar o alterar e o remover de nossas categorias.

Altere a página index.jsp, para que ela fique com o seguinte código:

Depois de salvar as alterações o resultado é o seguinte:

Perceba que foram adicionados dois links: um para a página alterarCategoria.jsp e outro para a removerCategoria.jsp, ambos passando o código da categoria por parâmetro na própria URL. Porém essas páginas ainda não estão criadas, então vamos começar a criar e implementar as mesmas.

Implementando o alterar:

Inicialmente vamos alterar nossa classe Categoria_DAO.java, incluindo nela os métodos para selecionar a categoria pelo código da mesma, e o método de alterar a categoria:

Obs.: o método selecionar(int codigo), será reutilizado quando for implementado o remover.

Dentro do pacote control, crie um Servlet com o nome de AlterarCategoria.java, implemente o método doPost como a imagem abaixo:

Dentro do WebContent crie uma nova página JSP, com o nome de alterarCategoria.jsp, lembre-se que a action do form, é nosso servlet AlterarCategoria.java:

Ao clicar em Alterar no index.jsp, o resultado será este (perceba que o código da categoria sendo passado por parâmetro na URL):

Estando assim finalizado os passos para alterar nossa categoria.

Implementando o remover:

Novamente vamos começar alterando a classe Categoria_DAO.java, para incluir o método remover:

Dentro do pacote control, crie um Servlet com o nome de RemoverCategoria.java, implemente o método doPost como a imagem abaixo:

Dentro do WebContent crie uma nova página JSP, com o nome de removerCategoria.jsp, lembre-se que a action do form, é nosso servlet RemoverCategoria.java:

Ao clicar em Remover no index.jsp, o resultado será este (perceba que o código da categoria sendo passado por parâmetro na URL):

Estando assim finalizado os passos para remover nossa categoria.