Técnicas de programação

/*
  * Classe exemplo de modelo (Md) correspondente a classe descrita em 
  * um diagrama conceitual de classes
  *
  * para este exemplo, foi considerada a existencia de dois atributos:
  * código (inteiro) e nome (texto)
  * 
  * Os objetos de classes modelo (Md) são utilizados para a inserção, alteração e 
  * exclusão de registros no banco de dados (ver classe de persistencia (Db))
  *
  */
 
 package br.fotolog.padrao;
 
 import br.fotolog.agregacao.itensPadraoMd;
 import java.util.ArrayList;
 
 /**
  *
  * @author 
  */
 public class padraoMd {
     
     /** Cria uma nova instancia depadraoMd */
     public padraoMd() {
         this.nome = "joaquim";
         this.codigo = 15;
     }
 
     /**
      * Declaração da propriedade codigo.
      */
     private int codigo;
 
     /**
      * Método "Getter" da propriedade codigo.
      * @return Valor da propriedade codigo.
      */
     public int getCodigo() {
         return this.codigo;
     }
 
     /**
      * Método "Setter" da propriedade codigo.
      * @param codigo Novo valor da propriedade codigo.
      */
     public void setCodigo(int codigo) {
         this.codigo = codigo;
     }
 
     /**
      * Declaração da propriedade nome.
      */
     private String nome;
 
     /**
      * Método "Getter" da propriedade nome.
      * @return Valor da propriedade nome.
      */
     public String getNome() {
         return this.nome;
     }
 
     /**
      * Método "Setter" da propriedade nome.
      * @param nome Novo valor da propriedade nome.
      */
     public void setNome(String nome) {
         this.nome = nome;
     }
 
     /**
      * Holds value of property listaItens.
      */
     private ArrayList<itensPadraoMd> listaItens;
 
     /**
      * Getter for property listaItens.
      * @return Value of property listaItens.
      */
     public ArrayList<itensPadraoMd> getListaItens() {
         return this.listaItens;
     }
 
     /**
      * Setter for property listaItens.
      * @param listaItens New value of property listaItens.
      */
     public void setListaItens(ArrayList<itensPadraoMd> listaItens) {
         this.listaItens = listaItens;
     }
 
     /**
      * Getter for property listaItens.
      * @return Value of property listaItens.
      */
     public itensPadraoMd getListaItens(int index) {
         return this.listaItens.get(index);
     }
 
     /**
      * Setter for property listaItens.
      * @param listaItens New value of property listaItens.
      */
     public void setListaItens(itensPadraoMd itensPadrao) {
         this.listaItens.add(itensPadrao);
     }    
     
 }

/*
  * Classe padrão para a realização de persistencia de objeto no banco de dados
  * Possui métodos públicos que permitem a inserção, alteração e exclusão de registros 
  * no banco através da passagem de objetos de modelo. Permite também a consulta
  * dos registros existentes.
  *
  * As Classes de persistencia são implementadas utilizando o padrão de projetos
  * singleton (ver abaixo), ou seja, utiliza-se apenas uma instância de cada classe
  * de persistência.
  *
  * Cada classe do diagrama Conceitual de Classes (ex. fotolog, imagensfotolog, historico)
  * deve ter uma classe de persistencia (Db) e uma classe de modelo (Md).
  *
  * A lista de objetos existentes fica armazenada numa coleção, mais especificamente
  * a LinkedHashMap, pois esta garante a ordenação dos objetos (conforme a ordem que são
  * inseridos)
  *
  * As classes de persistência necessitam obter o objeto de conexão para realizar
  * as operações no banco. Neste caso, a classe GerenciadorBancoDados se encarrega
  * de retornar o objeto de conexão (somente um por aplicação).
  * 
  */
 
 package br.fotolog.padrao;
 
 import br.fotolog.agregacao.itensPadraoDb;
 import br.fotolog.conexao.GerenciadorBancoDados;
 import java.sql.Connection;
 import java.sql.PreparedStatement;
 import java.sql.ResultSet;
 import java.sql.SQLException;
 import java.util.ArrayList;
 import java.util.LinkedHashMap;
 
     
 public class padraoDb {
     
     /* Padrão singleton
      *
      * Na engenharia de software, o padrão de projetos singleton é utilizado para restringir
      * a instância de uma classe para um (ou poucos) objeto. Singleton é útil quando exatamente
      * um objeto é necessário para coordenar as ações entre sistemas ou camadas de um sistema.
      * Também é util para otimizar o uso de recursos de hardware (ex. memória). É considerado um anti-padrão se utilizado para simular variáveis globais.
      *
      * O padrão singleton é implementado através da criação de classes com um método que cria
      * uma nova instância do objeto, caso não exista nenhuma. Se uma instância já existe, ele
      * simplesmente retorna a referência ao objeto. Para termos certeza que o objeto não será
      * instanciado mais de uma vez, o construtor é declarado privado ou protegido. 
      */
     
     /* início da implementação do padrão singleton */
     
     /*
      *construtor privado
      *previne a instancia do objeto
      */
     private padraoDb(){} 
     
     /*
      *Metodo estático que deve ser chamado para instanciar um objeto da classe
      */
     public static padraoDb getInstance(){
         return padraoDb.unicaInstancia.instance;
     }   
     
     /*
      *classe interna (inner class), estática com o objeto que deverá ser usado
      */
     private static class unicaInstancia {
         private static padraoDb instance = new padraoDb();
     }  
     
     /* fim da implementação do padrão singleton */
     
     /* inicio da estrutura de persistencia */
     
     /* 
      * Lista ordenada dos objetos obtidos do banco de dados 
      */
     private LinkedHashMap listaObjetos = atualizaListaObjetos();
     
     /*
      * Método sincronizado (somente uma chamada por vez) utilizado para
      * realizar a atualização da lista de objetos
      */
     private synchronized LinkedHashMap atualizaListaObjetos(){
         LinkedHashMap retorno = new LinkedHashMap(); //instancia objeto de retorno
         try{
             Connection conexao = GerenciadorBancoDados.obterConexao(); //obtem o objeto de conexão
             ResultSet resultado; // declara variável que receberá o resultado da consulta
             String sql = "select codigo, nome from padrao order by codigo"; // monta string de consulta
             PreparedStatement ps = conexao.prepareStatement(sql); // prepara a consulta para execução
 
             resultado = ps.executeQuery(); // executa consulta e armazena resultado no objeto resultado
 
             // percorre os registros retornados
             while (resultado.next()){
                 padraoMd lPadrao = new padraoMd(); //instancia um objeto modelo
                 lPadrao.setCodigo(resultado.getInt("CODIGO")); //Atribui o valor do campo código retornado no sql para o atributo codigo do modelo
                 lPadrao.setNome(resultado.getString("NOME")); //Atribui o valor do campo nome retornado no sql para o atributo nome do modelo
                 lPadrao.setListaItens(itensPadraoDb.getInstance().obterLista(lPadrao.getCodigo(),true));
                 retorno.put(String.valueOf(lPadrao.getCodigo()),lPadrao); //insere objeto na lista de objetos (linkedhashmap), parâmetros: código e objeto
             }
             
         } catch (Exception e){
             System.out.println(e.getMessage());
         } finally{
             return retorno;
         }
     }
     
     /*
      * Método responsável por atualizar os dados da lista com os dados do banco
      */
     private void atualizarLista(){
         listaObjetos.clear();
         listaObjetos = atualizaListaObjetos();
     }
     
     /* fim da estrutura de persistencia */
     
     /* início dos metodos públicos para interação com a camada de controle */
     
     /*
      * Método responsável por inserir um objeto na lista de objetos existentes e 
      * executar a persistencia no banco
      * Parâmetros:
      * pObjeto: objeto de modelo com os dados que devem ser inseridos
      * Retorno:
      * true no caso de sucesso e false no caso de falha
      */
     public boolean salvarObjeto(padraoMd pObjeto){
         boolean retorno = false;
         try{
             Connection conexao = GerenciadorBancoDados.obterConexao(); //obtem objeto de conexao
             String sql = "insert into padrao (codigo, nome) values (?,?)";  //sql de inserção na tabela, no lugar dos valores utiliza-se "?", 
                                                                             //sendo que os valores serão passados depois
             PreparedStatement ps = conexao.prepareStatement(sql); //prepara o sql para execução
             ps.setInt(1,pObjeto.getCodigo()); //insere o valor do atributo código na posição 1
             ps.setString(2, pObjeto.getNome()); //insere o valor do atributo nome na posição 2
             itensPadraoDb.getInstance().atualizarListaObjetos(pObjeto.getListaItens());
             ps.execute(); // executa o sql, inserindo o registro na tabela
             listaObjetos.put(String.valueOf(pObjeto.getCodigo()),pObjeto); //insere o objeto na lista de objetos
             retorno = true;
         }catch(Exception e){
             System.out.println(e.getMessage());
             retorno = false;
         }finally{
             return retorno;
         }
     }
     
     /*
      * Método responsável por atualizar (alterar) um objeto na lista de objetos existentes e 
      * executar a persistencia no banco
      * Parâmetros:
      * pObjeto: objeto de modelo com os dados que devem ser inseridos
      * Retorno:
      * true no caso de sucesso e false no caso de falha
      */
     public boolean atualizarObjeto(padraoMd pObjeto){
         boolean retorno = false;
         try{
             Connection conexao = GerenciadorBancoDados.obterConexao();//obtem objeto de conexao
             String sql = "update padrao set nome = ? where codigo = ?"; //sql de alteração do registro, no lugar dos valores utiliza-se "?", 
                                                                         //sendo que os valores serão passados depois
             PreparedStatement ps = conexao.prepareStatement(sql);//prepara o sql para execução
             ps.setString(1, pObjeto.getNome());//insere o valor do atributo nome na posição 1
             ps.setInt(2,pObjeto.getCodigo());//insere o valor do atributo código na posição 2
             ps.execute();// executa o sql, alterando o registro na tabela
             itensPadraoDb.getInstance().atualizarListaObjetos(pObjeto.getListaItens());
             listaObjetos.put(String.valueOf(pObjeto.getCodigo()),pObjeto); //sobrepoe o objeto da lista de objetos com o objeto alterado
             retorno = true;
         }catch(Exception e){
             System.out.println(e.getMessage());
             retorno = false;
         }finally{
             return retorno;
         }
     }    
 
     /*
      * Método responsável por excluir um objeto na lista de objetos existentes e 
      * executar a persistencia no banco
      * Parâmetros:
      * pObjeto: objeto de modelo com os dados que devem ser inseridos
      * Retorno:
      * true no caso de sucesso e false no caso de falha
      */    
     public boolean excluirObjeto(padraoMd pObjeto){
         boolean retorno = false;
         try{
             Connection conexao = GerenciadorBancoDados.obterConexao();//obtem objeto de conexao
             String sql = "delete from padrao where codigo = ?"; //sql de exclusão do registro, no lugar dos valores utiliza-se "?", 
                                                                 //sendo que os valores serão passados depois
             PreparedStatement ps = conexao.prepareStatement(sql);//prepara o sql para execução
             ps.setInt(1,pObjeto.getCodigo());//insere o valor do atributo código na posição 1
             ps.execute();// executa o sql, excluindo o registro na tabela
             listaObjetos.remove(String.valueOf(pObjeto.getCodigo()));//remove o objeto da lista de objetos
             retorno = true;
         }catch(Exception e){
             System.out.println(e.getMessage());
             retorno = false;
         }finally{
             return retorno;
         }
     }    
 
     /*
      * Método responsável por retornar um objeto da lista de objetos existentes 
      * Parâmetros:
      * pCodigo: chave do objeto que deseja retornar
      * pAtualizar: indica se quer realizar a atualização da lista com os dados do banco antes de localizar um objeto
      * Retorno:
      * Objeto solicitado ou null caso não encontre
      */    
     public padraoMd procurarObjeto(int pCodigo, boolean pAtualizar){
         if (pAtualizar)
             atualizarLista();
         if (listaObjetos.containsKey(String.valueOf(pCodigo)))
             return (padraoMd) listaObjetos.get(String.valueOf(pCodigo));
         else
             return null;
     }
     
     /*
      * Método responsável por retornar a lista de objetos existentes
      * Parâmetros:
      * pAtualizar: indica se deve ser chamado o método que atualiza a lista com os dados do banco
      * Retorno:
      * ArrayList de objetos
      */
     public ArrayList obterLista(boolean pAtualizar){
         if (pAtualizar)
             atualizarLista();
         return new ArrayList(listaObjetos.values());
     }    
     
     /* fim dos metodos públicos para interação com a camada de controle */
 
 }

package br.fotolog.padrao;
 
 import br.fotolog.agregacao.itensPadraoDb;
 import br.fotolog.agregacao.itensPadraoMd;
 import br.fotolog.conexao.GerenciadorBancoDados;
 import java.util.ArrayList;
 import javax.servlet.http.HttpServletRequest;
 
 public class padraoCt {
 
     private padraoMd aModelo = new padraoMd();//objeto modelo
     private padraoDb aPersistencia = padraoDb.getInstance(); //objeto de persistencia   
     
     
     //obtem os valores passados pela requisição e armazena nos atributos
     //do modelo
     public boolean atribuirValores(HttpServletRequest req, boolean pNovo){
         boolean retorno = false;
         try{
           /*  if (pNovo)
                 aModelo.setCodigo(GerenciadorBancoDados.obterNovoCodigo("nome da sequence"));
             else */
             aModelo.setCodigo(Integer.parseInt(req.getParameter("codigo")));
             aModelo.setNome(req.getParameter("nome"));
             retorno = true;
         }catch(Exception e){
             retorno = false;
         }
         return retorno;
     }
     
     //chama o método da persistencia responsável por inserir um registro no banco
     public boolean salvar(){
         boolean retorno = false;
         if (this.aPersistencia.salvarObjeto(this.aModelo)) {
             this.limpar();
             retorno = true;
         }
         return retorno;
     }
     
     //chama o método da persistencia responsável retornar um registro (como objeto modelo) do banco
     public void localizar(HttpServletRequest req){
         this.aModelo = this.aPersistencia.procurarObjeto(Integer.parseInt(req.getParameter("codigo")),false);
     }    
     
     //chama o método da persistencia responsável por excluir um registro no banco
     public void excluir(HttpServletRequest req){
        this.aPersistencia.excluirObjeto(this.aPersistencia.procurarObjeto(Integer.parseInt(req.getParameter("codigo")),false));
     }
     
     //chama o método da persistencia responsável por alterar um registro no banco
     public boolean atualizar(){
         boolean retorno = false;
         if (this.aPersistencia.atualizarObjeto(this.aModelo)){
             this.limpar();
             retorno = true;
         }
         return retorno;
     }
     
     //retorna o modelo atual do controlador
     public padraoMd obterObjeto(){
         return this.aModelo;
     }
     
     //retorna uma coleção com os objetos modelo existentes
     public ArrayList obterLista(){
         return this.aPersistencia.obterLista(false);
     }   
 
     //inicia o objeto modelo
     public void limpar() {
         this.aModelo = new padraoMd();
     }
     
 }

package br.fotolog.padrao;
 
 import java.io.*;
 import java.net.*;
 
 import javax.servlet.*;
 import javax.servlet.http.*;
 
 public class padraoFt extends HttpServlet {
 
     //método que recebe uma requisição do usuário, independente de ser método GET ou POST
     public void service(HttpServletRequest req, HttpServletResponse res) throws ServletException, IOException {
         //direciona para o método que verifica a ação solicitada pelo usuário;
         //por padrão, o parâmetro utilizado para receber a ação é denominada pAcao
         this.verificarAcao(req, res, this.obterControle(req));
     }
     
     //método que retorna o objeto controlador armazenado em sessão, 
     //este mesmo objeto será utilizado pela camada de visão para acessar
     //o modelo
     private padraoCt obterControle(HttpServletRequest req){
         padraoCt lControlador = null;
         if (req.getSession().getAttribute("padraoCt") == null){ 
             //Se a sessão não contém o objeto, então é instanciado um novo objeto
             //e inserido na sessão
             lControlador = new padraoCt();
             req.getSession().setAttribute("padraoCt", lControlador);
         } else {
             //Caso contrário, obtem o objeto da sessão
             lControlador = (padraoCt) req.getSession().getAttribute("padraoCt");
         }
         return lControlador;
     }
 
     private void verificarAcao(HttpServletRequest req, HttpServletResponse res, padraoCt controlador) throws ServletException, IOException {
         if (req.getParameter("pAcao") != null){
             if (req.getParameter("pAcao").equals("listar")){
                 //direciona para a tela de listagem
                 //existem duas formas de redirecionar para a tela
                 //a primeira é através do sendRedirect, que redireciona para a 
                 //nova página (utilizando o parâmetro header "location" e o status
                 //SC_MOVED_TEMPORARILY;
                 //A segunda maneira, é utilizar o método getRequestDispatcher para
                 //repassar a requisição para uma página JSP através da opção forward()
                 //Primeira opção
                 //res.sendRedirect("padraoLst.jsp");                
                 //Segunda opção
                 RequestDispatcher rd = req.getRequestDispatcher("padraoLst.jsp");
                 rd.forward(req,res);
             } else
             if (req.getParameter("pAcao").equals("cadastrar")){
                 //inicia o objeto modelo e redireciona para a tela de cadastro
                 controlador.limpar();
                 RequestDispatcher rd = req.getRequestDispatcher("padraoCad.jsp");
                 rd.forward(req,res);
             } else
             if (req.getParameter("pAcao").equals("cancelar")){
                 //redireciona para a tela de cadastro                
                 RequestDispatcher rd = req.getRequestDispatcher("padraoLst.jsp");
                 rd.forward(req,res);
             }else
             if (req.getParameter("pAcao").equals("alterar")){
                //pede ao controlador para localizar o modelo que deseja alterar
                //e direciona para a tela de alteração
                 controlador.localizar(req);
                 RequestDispatcher rd = req.getRequestDispatcher("padraoCad.jsp");
                 rd.forward(req,res);
             } else
             if (req.getParameter("pAcao").equals("salvarCadastro")){
                //Obtem os dados da requisição, atribui os valores ao 
                //modelo e pede ao controlador realizar a persistencia no banco.
                //finalizando, retorna para a tela inicial 
                 controlador.atribuirValores(req, true);
                 controlador.salvar();
                 RequestDispatcher rd = req.getRequestDispatcher("padraoLst.jsp");
                 rd.forward(req,res);
             } else
             if (req.getParameter("pAcao").equals("salvarAlteracao")){
                //Obtem os dados da requisição, atribui os valores ao 
                //modelo e pede ao controlador realizar a persistencia no banco.
                //finalizando, retorna para a tela inicial 
                 controlador.atribuirValores(req, false);
                 controlador.atualizar();
                 RequestDispatcher rd = req.getRequestDispatcher("padraoLst.jsp");
                 rd.forward(req,res);
             } else
             if (req.getParameter("pAcao").equals("excluir")){
                //pede ao controlador para excluir o modelo no banco
                //e retornar para a tela inicial                 
                 controlador.excluir(req);
                 RequestDispatcher rd = req.getRequestDispatcher("padraoLst.jsp");
                 rd.forward(req,res);
             } else
                 res.sendError(res.SC_METHOD_NOT_ALLOWED); //envia código de erro 405
         } else
             res.sendError(res.SC_BAD_REQUEST); //envia código de erro 400
     }
 }

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;

@Entity
public class Produto implements Serializable {
    
    @Id
    @GeneratedValue(strategy=GenerationType.AUTO)
    private Long id;
    
    private String descricao;
    private Integer quantidade;
    
    /** Creates a new instance of Produto */
    public Produto() {
        
    }
    
    public Long getId() {
        return id;
    }
    
    public void setId(Long id) {
        this.id = id;
    }
    
    public String getDescricao() {
        return descricao;
    }
    
    public void setDescricao(String descricao) {
        this.descricao = descricao;
    }
    
    public Integer getQuantidade() {
        return quantidade;
    }
    
    public void setQuantidade(Integer quantidade) {
        this.quantidade = quantidade;
    }
}

ProdutoService{
save(){
transaction.begintransaction;
dao.save();
if(!transaction.getStatus().equals(transaction.ROLLBACK)){
 transaction.commit;
else{
 transaction.rollback;
 throw new appexception;
}