Técnicas de programação

Galera qual o melhor jeito de se programar usando: HTML, Bean, Jsp e Servlet?

Eu programo da seguinte forma:

Crio o formulário em HTML, pois é tudo estático e mais rápido para abrir.
Capturo os dados desse formulário utilizando Servlet.

Existe uma outra forma de fazer isso?
Tipo conceitos de MVC?????só que usando apenas as linguagens que citei a cima.

Eu pensei em usar Struts e JSF, mas o projeto que estou desenvolvendo é pra ontem.

Obrigado!!!!

somma,

Temos um projeto que é assim.
Como é que funciona...

Modelo:
O Bean é a classe modelo que é identica aos campos que tem no banco (Ex. UsuarioMd)
Temos ainda uma classe de persistencia com o banco de dados, nela é feita as operações com o banco. (Ex. UsuarioDb)

Controle:
O controle também é divido em duas classes:
A primeira é a classe de controle de tela (CT), é nela que fazemos as fazemos as atribuições dos campos, e as as validações necessárias.
A segundo é o Fluxo de Tela (Ft) que é o Servlet, que como ele proprio diz, controla o fluxo de tela. Diz para onde o usuário vai.

Visão:
Aqui utilizamos o JSP e o Javascript.

Espero ter ajudado.

Bom deixa eu ver se entendi:

Vc cria um bean e coloca como atributo as tuplas do banco.

Cria outro bean que faz a conexão e possíveis transações no BD.

Na Parte do controle.

Eu crio uma classe que irá capturar os atributos que estão no formulario (HTML) e que ja foram validados pelo javaScript

E este Servlet de controle utilizara este bean acima para capturar os dados e redimensionar para outra tela.

é isso!!!!! fsquadro

obrigado

É cara, pelo que você tá dizendo, eu recomendaria o Struts.
Ao contrário do que se diz por aí, não é um framework tão difícil de implementar, e oferece algumas otimizações em relação ao velho padrão de aplicações java web, e ainda te ajuda a entender o funcionamento do padrão MVC.

Caso opte pelo Struts, dedique-se a entender o funcionamento do struts-config.xml, dos beans, das tag-libs e do connection pool.
Não tem nada de assombroso nisto aí.

Dedique-se durante uma semana, e garanto que irá aprender.

Se desejar, de faça o seguinte tutorial, que me ajudou a aprender o Struts. E caso tenha alguma dúvida, posta aqui. Te aconselho a imprimir este tutorial.

http://portaljava.com/home/modules.php?name=Content&pa=showpage&pid=63

[]´s

Ta beleza então....

Vou imprimir este tutorial e aprender Struts

Muito obrigado e quando eu tiver dúvidas irei postas sim.

[]'s

Dê uma olhada no VRaptor e Mentawai:

http://www.vraptor.com.br/

http://www.mentaframework.org/

São super simples de utilizar, nem compara com o Struts.

Inclusive, Struts, só se for a versão nova, a versão antiga é muito engessada. Daí aumenta a dificuldade, pois pelo q ando vendo a galera tá usando pouco.

Somma,

Sim, funciona assim. Eu tenho um modelo, uma aplicação de exemplo se você quiser, me mande uma MP, com o seu email, que eu lhe envio.

Porém, eu também lhe aconselharia o VRaptor, ao inves do Struts, e se for usar o Struts, use o Struts 2.

Outra dica, te aconselho a usar também Hibernate Annotations.

Espero ter ajudado.

reveja este design antes de pensar em frameworks. Classes de negócio que representam tabelas caracterizam um sistema não Orientado a Objetos.

pcalcado,

O modelo, ele se baseia no banco, mas nao fica estritamente igual. Qual a metodologia que você utiliza, para a criação das classes de modelo?
O meu modelo é Bean.

Obrigado.

Oi,

Dê uma lida nos artigos e palestras:

http://fragmental.com.br/wiki/index.php?title=Main_Page

fsquadro wrote:
O meu modelo é Bean.

Como assim?

pcalcado,

As Classe de modelo (Md) correspondente a classe descrita em um diagrama conceitual de classes.

Os objetos de classes modelo (Md) são utilizados para a inserção, alteração e exclusão de registros no banco de dados.

Acredito que eu tenha me enrolado um pouco para explicar.

Olá,

Bom, geralmente ou se pensa em dados ou se pensa em objetos.

Seu domínio de objetos deve refletir os objetos do negócio, estes objetos com estado e comportamento 9e não apenas dados em um canto e funções em outro) mapeiam suas regras de negócio.

Mais detalhes na Mundo Java #15 e #17 ou nos artigos citados acima.

pcalcado,

Você viu a MP, eu lhe enviei as classes, para você dar uma olhada. Você acha que isto está digamos "fugindo" da POO?

Obrigado.

Oi,

Por favor cole as classes aqui no tópico

pcalcado,

Vou lhe mostrar aqui um exemplo de um modelo que eu falei, talvez com as palavras, eu não esteja conseguindo me expressar como quero, acho que este código vai ajudar.

UsuarioMd

/*
  * 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);
     }    
     
 }

UsuarioDb

/*
  * 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 */
 
 }

UsuarioCt

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();
     }
     
 }

UsuarioFt

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
     }
 }

E ai tem o JSP, que a camada de visão, juntamente com o Javascript.

Notícias, artigos e o maior fórum brasileiro sobre Java