Exemplo de início de Loja virtual com movimentação.

PLoja, projeto da pós de JSP de Paranavaí 2010.

@Controller
public class CadastroPessoa extends MultiActionController {

    private CadastroServices cadastroServices;

    @Autowired(required = true)
    public void setCadastroServices(CadastroServices cadastroServices) {
        this.cadastroServices = cadastroServices;
    }

    public ModelAndView lista(HttpServletRequest request, HttpServletResponse response) {
        ModelAndView mv = new ModelAndView("paginaPessoa");
        mv.addObject("li", cadastroServices.listaPessoa());
        mv.addObject("lc", cadastroServices.listaCidadesBanco());
        return mv;
    }
 ...

Prefácio

Este livro é dividido em duas partes. A primeira parte trata do desenvolvimento de aplicações Web utilizando, principalmente, Servlets. A segunda parte aborda o paradigma de desenvolvimento de aplicações distribuídas utilizando a tecnologia Enterprise Java Beans.

A primeira parte do livro aborda de forma consistente e didática o conteúdo relacionado a Servlets. Nesta abordagem é definido um histórico do desenvolvimento de aplicações Web, passando por CGIs e linguagens de script. Além dos tópicos relacionados a Servlets são abordados tópicos relacionados tais como Java Server Pages (JSP), Java Beans, Taglibs, modelo MVC, instalação de configuração de um Web Container para desenvolvimento, além de tópicos avançados tais como controle de pooling de conexões com banco de dados.

A segunda parte do livro aborda o paradigma de desenvolvimento de aplicações distribuídas, destacando a evolução das técnicas de desenvolvimento desde a programação estrutura até o atual uso de sistemas distribuídos. A tecnologia utilizada para prover distribuição é a plataforma J2EE (Java 2 Enterprise Edition). São detalhados

os componentes e possibilidades que esta plataforma oferecem ao desenvolvedor. O livro foi dividido em partes para oferecer um conteúdo mais abrangente e completar. A primeira parte trata da construção de interfaces e controles para interação com os clientes de uma aplicação Web. A segunda parte aprofunda nos aspectos de distribuição de um sistema, permitindo que este execute em diversos computadores, dividindo sua carga e, conseqüentemente, aumentando seu desempenho.

O intituito de todo o livro é ser prático nos temas que apresenta. Todos os capítulos apresentam exemplos que simplificam o processo de entendimento dos temas.

InputStream is = this.getClass().getResourceAsStream("/relatorioslsitaDeEstados.jasper");
JasperRunManager.runReportToPdfStream(is, out, para, conn);
out.flush();

Existe uma situação onde você terá apenas o EntityMannager JPA e quer obter a conexão com o banco para gerar o relatório. Uma solução não muito elegante é:

    protected void processRequest(HttpServletRequest request, HttpServletResponse response)
    throws ServletException, IOException {
        response.setContentType("application/pdf");
        OutputStream out = response.getOutputStream();
        try {
            //Esta parte aqui não estaria aqui
            //Class.forName("com.mysql.jdbc.Driver");
            //Connection conn = DriverManager.getConnection("jdbc:mysql://127.0.0.1/gafanhoto", "root","senha");
            //
            EntityManager em=Persistencia.getInstancia().getEmf().createEntityManager();
            HibernateEntityManager hem=(HibernateEntityManager) em;
            Map para = new HashMap();

            String parte = request.getParameter("filt");
            if (parte != null) {
                para.put("filtro", parte + "%");
            }
            else{
                para.put("filtro", "%" );
            }
            InputStream is = this.getClass().getResourceAsStream("/relatorios/listaestados.jasper");
            JasperRunManager.runReportToPdfStream(is, out, para, hem.getSession().connection());
            out.flush();
        } catch (Exception ex) {
            ex.printStackTrace();
        }
        out.close();

Aqui está um video e um projeto básico de JSP, para quem está começando. Neste exemplo estão juntos código JAVA e HMTL em um mesmo arquivo. Esta não é uma boa prática mas é muito boa para fins didáticas.

  String caminho = request.getRequestURI();
  String pedacos[] = caminho.split("/");
  String nomeDaClasse = pedacos[pedacos.length - 1];
  String operacao = request.getParameter("operacao");
  nomeDaClasse = nomeDaClasse.substring(0, 1).toUpperCase() +  nomeDaClasse.substring(1);
  Class classe = Class.forName("entidades." + nomeDaClasse);

Material

 String proximaPagina = "consultacidade.jsp";
        EntityManager em = Persistencia.getInstancia().getEmf().createEntityManager();
        try {
            em.getTransaction().begin();
            String acao = request.getParameter("ac");
            if (acao == null) {
                acao = "consultar";
            }
            if (acao.equals("incluir")) {
                Cidade cid = new Cidade();
                JspRuntimeLibrary.introspect(cid, request);
                request.setAttribute("cid", cid);
                CadastrosBusiness.getInstancia().gravaCidade(em, cid);
            }
            if (acao.equals("excluir")) {
                Cidade cid = new Cidade();
                JspRuntimeLibrary.introspect(cid, request);
                CadastrosBusiness.getInstancia().excluir(em, cid);

            }
            if (acao.equals("alterar")) {
                Cidade cid = new Cidade();
                JspRuntimeLibrary.introspect(cid, request);
                cid = CadastrosBusiness.getInstancia().recuperaCidade(em, cid);
                request.setAttribute("cid", cid);
                if (cid != null) {
                    proximaPagina = "alteraCidade.jsp";
                } else {
                    //colocar mensagem quando não encontrar a cidade
                }

            }
            if (acao.equals("gravar")) {
                Cidade cid = new Cidade();
                JspRuntimeLibrary.introspect(cid, request);
                CadastrosBusiness.getInstancia().gravar(em, cid);
            }

            if (proximaPagina.equals("consultacidade.jsp")) {
                request.setAttribute("cidades", CadastrosBusiness.getInstancia().listaCidades(em));
            }

            request.getRequestDispatcher(proximaPagina).forward(request, response);
            em.getTransaction().commit();
        } catch(JasperException ex){
            em.getTransaction().rollback();
            request.setAttribute("msg", "Formato de número inválido");
            request.getRequestDispatcher(proximaPagina).forward(request, response);
        }
        catch (BusinessException be) {
            em.getTransaction().rollback();
            request.setAttribute("msg", be.getMessage());
            request.getRequestDispatcher(proximaPagina).forward(request, response);

        } catch (Exception ex) {
            ex.printStackTrace();
            em.getTransaction().rollback();
            request.getRequestDispatcher("paginaerro.jsp").forward(request, response);
        }

Nas aulas de JSP os alunos criaram uma sala para conversar. Esta sala está disponível em http://munif.com.br/sala.

Por favor, façam um teste e usem quando quiser.

O código fonte está disponível aqui no site.

Aqui estão os exemplos da primeira aula de JSP.

public class Venda implements Serializable{

    private Integer codigo;
    private String cliente;
    private Date dataVenda;

    private Set itens;

...
}

  public void doTag() throws JspException {
        JspWriter out = getJspContext().getOut();
        try {
            Class classe = entidade.getClass();
            Field atributos[] = classe.getDeclaredFields();
            for (Field at : atributos) {
            ...

O Spring Framework é muito bom para adotar boas práticas de progamação e padrões de projeto sem a necessidade de implementar muito código.

Uma das funcionalidades mais interessantes é a inversão de controle. Para utilizar o Spring o programador informa quais são os componentes (Beans na terminologia do Spring) da sua aplicação e como estes se relacionam. O Spring então se encarrega de criar instâncias, associá-las, mantê-las e finalizá-las.

Além disso, o Spring possui várias outras funcionalidades como implementação de MVC, validadores, segurança e internacionalização.

Atualmente este framework oferece a possibilidade de especificação através de annotations além do "agradável" XML. O exemplo em anexo utiliza algumas configurações genéricas em XML que servem para qualquer projeto, exceto, é claro, a configuração do banco de dados. As configurações específicas estão todas em anotações, diretamente nas classes.

Exemplo de cadastro com Spring Hibernate através de anotações.

Aqui estão alguns exemplos de cadastro MVC.

JavaServer Pages (JSP) é uma tecnologia utilizada no desenvolvimento de aplicações para Web, similar às tecnologias Active Server Pages (ASP) da Microsoft ou PHP. Por ser baseada na linguagem de programação Java, tem a vantagem da portabilidade de plataforma, que permite a sua execução em diversos sistemas operacionais, como o Windows da Microsoft, Unix e Linux. Esta tecnologia permite ao desenvolvedor de páginas para Internet produzir aplicações que acessem o banco de dados, manipulem arquivos no formato texto, capturem informações a partir de formulários e captem informações sobre o visitante e sobre o servidor.

Uma página criada com a tecnologia JSP, após instalada em um servidor de aplicação compatível com a tecnologia Java EE, é transformada em um Servlet.São exemplos de servidor compatível com a tecnologia JSP o Tomcat e o Glassfish.

(Retirado de http://pt.wikipedia.org/wiki/JavaServer_Pages)

Este site está sendo desenvolvido em JSP utilizando o modelo MVC e seu código fonte pode ser obitido aqui, bem como as bibliotecas utilizadas. Sugestões e contribuições são bem vindas.