O que é Javascript? É perigoso permitir Javascript no navegador? Quais os riscos inerentes a ele e quais formas de se proteger?

Javascript é uma linguagem de programação usada por sites para adicionar recursos dinâmicos em páginas de internet. O Javascript permite ao desenvolvedor do site muita flexibilidade. Um exemplo é aquele botao que permite aumentar ou diminuir as fontes existentes em varios sites.

Há tantas possibilidades de uso de Javascript que seria impossível citar todas. Há até mesmo joguinhos simples feitos em Javascript.

É claro que essa riqueza de possibilidades resulta em uma linguagem complexa. Para piorar, o Javascript foi “crescendo” com o tempo e cada navegador web decidiu interpretar comandos diferentes da mesma forma. Isso adicionou ainda mais complexidade, tanto para quem faz códigos Javascript como para quem faz os navegadores, que precisam funcionar com o maior número possível de códigos.

O Javascript é, portanto, o tipo de código mais complexo com o qual os navegadores precisam lidar. E quanto mais difícil é fazer algo, maior a probabilidade de ocorrerem erros. Não existe nenhum risco inerente ao Javascript, exceto pela complexidade desnecessária criada pelo histórico conturbado da linguagem.

De qualquer forma, problema maior está no fato de que os programadores podem cometer muitos erros na criação do componente responsável pelo processamento dos códigos. Isso resulta em vulnerabilidades.

Como o Javascript interage com a página, além dos erros existentes nele mesmo, ele também pode ser peça-chave na exploração de erros em outras funcionalidades do navegador. É por isso que tantas falhas têm como solução temporária a desativação de Javascript.

Diferentemente de outras linguagens de programação, existe muita tolerância na programação de páginas web. Mesmo códigos “errados” funcionam devido aos esforços dos navegadores para tentar fazer a página aparecer na tela. Além disso, erros em navegadores web também moldaram as linguagens, quer dizer, programadores acabaram dependendo de erros para fazer as páginas aparecerem do jeito que queriam. Ainda hoje, os navegadores precisam detectar esses “erros” e “saber” o que o criador da página pretende.

É por isso que não apenas Javascript, mas até uma linguagem aparentemente simples como o HTML – principal responsável pelas páginas de internet – acabam sendo difíceis de “digerir” pelos softwares.

Não é possível navegar na internet sem Javascript. A grande maioria dos sites apresentará defeito ou perda de funcionalidade. Para o Firefox, o plugin NoScript limita os poderes do Javascript, mas também adiciona transtornos na navegação. Fica a critério de cada um optar pela segurança ou pela comodidade. De qualquer maneira, manter o navegador sempre atualizado é essencial para que qualquer brecha conhecida, seja no processamento de Javascript ou outro componente, seja eliminada.

Fonte: G1

Funções principais:

1. encapsular tipos primitivos para que possam ser manipulados como objetos

2. fornecer métodos utilitários para tipo primitivos

Então agora é possível:

1. converter de um objeto wrapper para primitivo

2. converter de string para primitivo

3. converter de string para objeto wrapper

Quando usar?

1. Simples: quando deseja usar um “primitivo”como objeto.

2. Quando um objeto recebe um valor e você deseja manipulá-lo como primitivo

3. Para trabalhar com Conjuntos/Genéricos

Wrappers no Java 5/superior

A partir do java 5 o recurso de boxing permite converter tipos primitivos em wrappers ou de wrappers para primitivos automaticamente, ou seja, sem nenhum tipo de conversão o próprio compilador já faz isso para nós programadores.

Regra:

Para usar o == com wrappers não é como usar com os primitivos. A diferença é que valores ate 127 serão iguais, além disso não será considerado igual.

Diferenciar um Wrapper de Tipos primitivos

Bem há uma diferença até na nomeação. As classes wrappers têm o sua nomeação iniciada em MAIÚSCULO enquanto os tipos primitivos estão em minúsculo.

l Tipo primitivo: int, double, char.

l Wrapper: Integer, Double, Long.

Primitivos X Wrappers

1. int numb = 10;

2. Integer numb = new Integer(10);

Temos situações diferentes nos códigos acima:

1. uma variável do tipo primitivo com o valor 10.

2. um objeto da classe Integer, e não um tipo primitivo.

Os métodos de conversão:

Há três métodos de conversão nas classes wrappers que são: xxxValue(), parseXxx(),valueOf(). Veja na tabela abaixo a definição de cada um:

XxxValue() – objeto.tipoprimitivoValue()

• serve para converter o valor de um objeto em um tipo primitivo.

Integer i2 = new Integer(42);
double d = i2.doubleValue(); // aqui eh a conversão do Objeto Integer para double

Obs.: então minha variável do tipo primitivo d tem o valor agora do objeto wrapper i2.

Float f2  = new Float(3.14f);
short s = f2.shortValue();//conversão do valor do objeto para tipo primitivo short.

parseXXX(), usa o argumento String.

Converte de String para Wrapper. Essa classe lança uma exceção na tentativa de converter “dois em um tipo primitivo”

Exemplo:

double d4 = Double.parseDouble(“3.14″); //converto de String para double

valueOf() – essa converte de String para Wrapper (Integer, Long etc.)

xxx.valueOf() – tipoprimitivo.valueOf(“string”);

Double d5 = double.valueOf("3.14"); //converto de String em um objeto class Wrapper

Para ficar mais claro o entendimento, desenvolvi as classes a seguir com exemplos para fixar o que já foi dito, confiram:

code 1

public class ExceWrap {
	public static void main(String[] args) {
		int z= Integer.parseInt("dois");
		System.out.println(z);
		/* codigo compila sem problemas mais uma excecao vai acontecer
		 * nao há nada de errado na sintaxe
		 * porem a jvm nao consegue converter uma string literal
		 * em um numero inteiro
		 */
	}}
Exception in thread "main" java.lang.NumberFormatException: For input string: "dois"

code 2

public class Par {
	public static void main(String[] args) {
		//String - primitivo
		double d = Double.parseDouble("10");
		System.out.println(d);
	}}

code 3

public class NoValue {

	public static void main(String[] args) {
		Long l = new Long(8);
		int lh = l.longValue();
		/* nao compila o to tentando colocar um long
		 * dentro de um int nao é valido isso
		 */
	}}

code 4

public class OfVal {

	public static void main(String[] args) {
		//String --> OBJETOS
		Float f = Float.valueOf("10");
	System.out.println(f);
	Integer i = new Integer(10);
			//Objeto --> Primitivo
		int g = i.intValue();
	}}

code 5

public class WrpObjt {

	public static void main(String[] args) {
		Integer g = new Integer (10);
		Integer h = new Integer(10);
		System.out.println(g==h);//false
		/* aqui dois objetos diferentes
		 * porem com mesmo valor
		 * == testa a referencia e nao valores dos
		 * objetos */}}

O Struts implementa o padrão MVC (Model-View-Controller) fazendo com que sua regra de negócio fique separada da parte visual de sua aplicação. Se quiser saber um pouco mais sobre Struts antes de prosseguir, leia esta matéria publicada aqui no iMasters.

Então, vamos ao que interessa: o exemplo! Para quem é iniciante em Java e/ou não conhece o NetBeans, vou prosseguir com o artigo passo a passo com as telas apresentadas pela IDE.

Primeira Etapa – Criando uma aplicação web no NetBeans

• Abra o seu NetBeans;
• Vá em File > New Project;

A tela exibida será a seguinte:

• Selecione em Categories a categoria Web e em Projetcs, Web Application.

Na tela seguinte você irá inserir um nome para o seu Projeto e a pasta em que ele será salvo. Vou chamar o meu de ProjetoStruts.

Acompanhe os passos até chegar ao quarto passo de criação conforme tela abaixo:

Nesta tela você selecionará os Frameworks que serão utilizados na aplicação:

• Selecione o Framework Struts.
• Altere em Application Resource o nome do package inserindo o nome de seu Projeto no lugar de myapp. No meu caso ficou: com.projetostruts.struts.ApplicationResource
• Finalize a criação.

Segunda Etapa – Criação do formulário

Antes de qualquer coisa, você deve ter percebido que foram criados dois arquivos em seu Projeto, dentro da pasta WEB-INF: index.jsp e welcomeStruts.jsp.

Se você rodar o seu Projeto pressionando a tecla F6, você observará no browser o funcionamento do Framework Struts.

Vamos então criar nosso formulário:

• Abra o arquivo index.jsp
• Edite o index.jsp para deixá-lo com o seguinte código:

<%@page contentType="text/html"%>
<%@page pageEncoding="UTF-8"%>

<%@ taglib uri="http://jakarta.apache.org/struts/tags-bean" prefix="bean" %>
<%@ taglib uri="http://jakarta.apache.org/struts/tags-html" prefix="html" %>
<%@ taglib uri="http://jakarta.apache.org/struts/tags-logic" prefix="logic" %>

<html:html>
    <head>
        <title>Trabalhando com Struts</title>
        <style>
            .visualInputErro {
                border: 1px solid #b22222;
                font-family: Arial, Helvetica, sans-serif;
                color: #666666;
                background-color: #ffe4e1;
            }
        </style>
    </head>
    <body>
        <html:form action="login">
        <table border="0">
            <thead>
                <tr>
                    <th colspan="2"><html:errors property="status"/></th>
                </tr>
            </thead>
            <tbody>
                <tr>
                    <td><bean:message key="login.usuario" /></td>
                    <td><html:text property="usuario" errorStyleClass="visualInputErro"/></td>
                </tr>
                <tr>
                    <td><bean:message key="login.senha" /></td>
                    <td><html:password property="senha" errorStyleClass="visualInputErro"/></td>
                </tr>
                <tr>
                    <td colspan="2"><html:submit value="Login"/></td>
                </tr>
            </tbody>
        </table>
        </html:form>
    </body>
</html:html>

Terceira Etapa – Criação das Ações

Vamos então criar as ações que validarão nosso formulário.

• Clique com o botão direito sobre o seu projeto, selecione New > Struts ActionForm Bean:

• Em Class Name digite: AcaoFormLogin

• Ajuste o Package para com.projetostruts.struts
• Neste arquivo você realizará a validação dos campos que virão do formulário. Edite o arquivo AcaoFormLogin.java conforme abaixo:

package com.projetostruts.struts;

import javax.servlet.http.HttpServletRequest;
import org.apache.struts.action.ActionErrors;
import org.apache.struts.action.ActionMapping;
import org.apache.struts.action.ActionMessage;

/**
 *
 * @author Gustavo
 */
public class AcaoFormLogin extends org.apache.struts.action.ActionForm {

    private String usuario;
    private String senha;

    public String getUsuario() {
        return usuario;
    }

    public void setUsuario(String usuario) {
        this.usuario = usuario;
    }

    public String getSenha() {
        return senha;
    }

    public void setSenha(String senha) {
        this.senha = senha;
    }

    public AcaoFormLogin() {
        super();
    // TODO Auto-generated constructor stub
    }

    @Override
    public ActionErrors validate(ActionMapping mapping, HttpServletRequest request) {
        ActionErrors errors = new ActionErrors();
        boolean flag = false;
        if (getUsuario() == null || getUsuario().length() < 1) {
            errors.add("usuario", new ActionMessage("error.usuario.required"));
            if (flag == false) {
                errors.add("status", new ActionMessage("error.status"));
                flag = true;
            }
        }
        if (getSenha() == null || getSenha().length() < 1) {
            errors.add("senha", new ActionMessage("error.senha.required"));
            if (flag == false) {
                errors.add("status", new ActionMessage("error.status"));
                flag = true;
            }
        }
        return errors;
    }
}

Vale ressaltar que neste arquivo a única validação que estou fazendo é se o campo é nulo ou se há algum texto digitado nele. Outras validações poderão ser implementadas de acordo com a necessidade.

Vá ao arquivo ApplicationResource.properties no package com.projetostruts.struts. No final do arquivo, insira o seguinte código:

login.usuario=Usuário
login.senha=Senha
error.usuario.required=O campo 'Usuário' deve ser preenchido
error.senha.required=O campos 'Senha' deve ser preenchido
error.status=Os campos destacados são de preenchimento obrigatório

Observe que este código descreve o retorno que será dado caso um dos erros tratados no arquivo AcaoFormLogin.java apareça. Neste exemplo, apesar de declarar as mensagens de erro para usuário e senha, eu destacarei o input que apresentou erro através do estilo .visualInputErro declarado no arquivo index.jsp.

Vamos então criar outro arquivo:

Clique com o botão direito sobre o pakage com.projetostruts.struts, selecione New > Struts Action.

• Em Class Name digite: AcaoLogin
• Ajuste o Package para com.projetostruts.struts
• Em Action Path, digite: /login
• Pressione next
• Em Input Resource, localize o arquivo index.jsp
• Em Scope, selecione request e finalize.

Neste arquivo que foi criado, AcaoLogin.java, você notará a palavra success. Eu costumo alterá-la para descrever melhor o tipo de sucesso que foi obtido. Então, altere para: successLogin

• Encontre a pasta Configuration Files e abra o arquivo struts-config.xml
• Encontre a seguinte linha de código:

<action input="/index.jsp" name="AcaoFormLogin" path="/login" scope="request" type="com.projetostruts.struts.AcaoLogin"/>

Altere-a e deixe conforme segue:

<action input="/index.jsp" name="AcaoFormLogin" path="/login" scope="request" type="com.projetostruts.struts.AcaoLogin">
            <forward name="sucessLogin" path="/login"/>
</action>

Quarta Etapa – Criação do Servlet

Nesta etapa vamos criar o Servlet que será responsável por tratar os dados. Como o objetivo deste artigo é apenas demonstrar o funcionamento do Struts, o Servlet criado não executará nenhuma ação, apenas irá encaminhar para a página login.jsp a ser criada.

• Crie um novo package denominado com.projetostruts.conexao
• Crie nesse package um Selvlet chamado Login.java
• Na tela de configuração do Servlet, ajuste a URL Pattern para: /login

No Servlet Login.java, localize o método processRequest e altere-o conforme abaixo:

protected void processRequest(HttpServletRequest request, HttpServletResponse response)
    throws ServletException, IOException {
        response.setContentType("text/html;charset=UTF-8");
        PrintWriter out = response.getWriter();
        try {
            response.sendRedirect("login.jsp");
        } finally {
            out.close();
        }
    }

Mais uma vez lembrando que este Servlet apenas redireciona para a página login.jsp.

Quinta Etapa – Criação do Destino

Nesta última etapa, vamos criar o arquivo destino que mostrará o sucesso da validação:

• Clique com o botão direito na pasta Web Pages e crie um novo arquivo chamado login.jsp
• Edite o arquivo conforme abaixo:

<%@page contentType="text/html" pageEncoding="UTF-8"%>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
   "http://www.w3.org/TR/html4/loose.dtd">

<html>
    <head>
        <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
        <title>Login</title>
    </head>
    <body>
        <h2>Todos os campos foram preenchidos!!!</h2>
    </body>
</html>

Está pronto! Esse é o conceito básico do Struts e espero que tenha ajudado.

1. Clique em file -> new file
2. Na tela que aparece, escolha, em categories WEB e em files types JSP.
3. Clique em next e, na próxima tela, no campo JSP File name, dê um nome ao seu arquivo JSP (eu chamei de paginaform).

1. Feito isso, clique em finish
2. Feito isso, crie outra página em JSP, chamada contas.

Dentro de <body> </body> do arquivo paginaform.jsp, digite o código abaixo que é o nosso formulário:

<!--quando o cliente clicar em enviar vai para pagina de contas.jsp-->
<form action="contas.jsp" method="POST">
Usuario:<input type="text" name="usuario"/><br>/>
Senha:<input type="password" name=senha"/><br>

<input type="submit" value="logar/>
</form>

Na página de contas.jsp, dentro do <body>, digite o código abaixo:

<%
//recebe o valor digitado no campo usuario
String usuario = request.getParameter("usuario");

//recebe o valor digitado no campo senha
String senha = request.getParameter("senha");

if(usuario.equals("camilo")&& senha.equals("123")){

//Exibi o nome do usuario
    out.println("Seja bem vindo " + usuario);
    }
else{
out.println("Usuario ou senha invalidos");  

}%>

Objeto Request

Esse objeto foi o responsável de pegar o resultado que vinha do formulário.

Salve e teste a página executando no browser a http://localhost/suaaplicacao/paginaform.jsp

Agora informe os dados no formulário e clique no botão enviar.

Simples pegar dados de um formulário em JSP não? Lembrando que o objetivo aqui era mostrar como obter dados de um formulário em JSP, que é através do request. Usei como exemplo uma pagina simples de login e senha.

Outra importância desse recurso é para sistema de busca. Imagine que você quer saber tudo que seu cliente digitou no campo de busca do seu site enquanto ele estava navegando? Importante isso não?

É uma plataforma para desenvolvimento de aplicações distribuídas que apresenta facilidades para utilização dos recursos computacionais e distribuídos tais como acesso a Banco de dados, componentes Web, utilização de mensagens assíncronas, etc.

A arquitetura J2EE apresenta várias camadas composta por componentes e serviços que são providos por um container.

Mas o que vem a ser container?

Para essa resposta vou dar um exemplo no mundo real, do que poderia ser um container na arquitetura Java Enterprise Edition.

“Uma colméia de abelhas que contém pulpas, zangões, a abelha rainha, o mel etc. O container seria a Colméia que fornece recursos para as abelhas sobreviverem. Por sua vez, as abelhas têm suas diferentes funções, tais como operarias e as reprodutoras que podem ser vistas como os componentes que sobrevivem dentro do container (colméia).

Aproveitando vamos expandir um pouco o exemplo: imagine agora que cada colméia seja um container e todas as colméias juntam um apiário, que representa o servidor J2EE. “

Mostrando o exemplo acima de forma técnica

Na forma técnica temos o uso de paginas HTML em um web browser, onde o container é o próprio navegador que fornece recursos e facilidades para o componente. O componente, por sua vez, pode oferecer diversos serviços do usuário, através do suporte do container como facilidades visuais como: botões, figuras e tabelas, hiperlinks e o próprio serviço de navegação.

Voltando à J2EE, podemos ver diversos containeres interagindo entre si, na lista abaixo temos as camadas de arquitetura e os seus componentes.

Camada cliente: nessa camada os componentes residem em um container que pode ser Web Browser, um Applet ou um Application Client.

Camada Web: essa aqui fornece a lógica a camada cliente que é implementada por uma JSP e Servlets. JSP oferecem a facilidade de apresentação em uma pagina Web. Já Servlet apresenta-se como um controlador das ações executadas pelo usuário nas páginas de apresentação, ele fornece vários recursos para obter dados dessas ações e realizar as operações desejadas.

Camada de Negócio: essa aqui é uma das camadas mais importantes para o desenvolvedor, pois trata de toda a lógica da aplicação. É aqui que definem-se todas as regras do negócio, alocação de recursos, validação de dados segurança.

Camada EIS (Enterprise Information System) – Aqui se encontram os sistemas de banco de dados, a integração com outros sistemas não J2EE.

Para desenvolvimento na plataforma J2EE é necessário entender cada uma dessas camadas e seu funcionamento como o todo.

Refatorar com suporte de uma ferramenta automatizada é diferente da refatoração manual. Mesmo com a rede de segurança de conjunto de testes, a refatoração não automatizada consome tempo. Porém, não deve se descartar, já que nem sempre as ferramentas automatizadas vão atender todas as técnicas de refatoração.

As ferramentas que automatizam o processo diminuem o risco de erros e inconsistência no código, além de poupar um grande trabalho em se tratando de sistemas com centenas ou milhares de linhas de códigos. Com as ferramentas de refatoração automáticas, o projeto se torna mais elástico, já que alterá-lo é muito menos custoso.

Sendo assim, estender o projeto é adicionar flexibilidade no futuro sem grandes custos. O principal propósito de uma ferramenta de refatoração é permitir ao programador refatorar código sem ter que testar novamente o programa. A Tabela 1 apresenta algumas ferramentas que implementam a técnica de refatoração. Com o crescimento do número de IDE para Java, algumas ferramentas de refatoração foram criadas como plugins para esses ambientes que é o caso do JFactor e RefactorIT apresentado na Tabela.

Tabela 1 – Ferramentas para refatoração em código Java

A cada dia, surgem novas ferramentas para aplicação da técnica de refactoring em outras linguagens. Sendo assim, fica a importância e quanto é produtivo utilizá-las no ambiente de desenvolvimento.

Vamos começar a implementar nosso carrinho de compras.

Classe Produto

package vo;
     public class Produto {
	private Integer codigo;
	private String nome;
	private Double vlPreco;
	 // ocultei get/set.
	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;
		Produto other = (Produto) obj;
		if (codigo == null) {
			if (other.codigo != null)
				return false;
		} else if (!codigo.equals(other.codigo))
			return false;
		return true;
	}
     }

Na classe CarrinhoDeCompras, criei uma Collection de objetos Produto, que armazenará os produtos selecionados pelo o usuário. Estou inicializando-a no construtor da classe, e também perceba que só existe o método de acesso getArrProdutos(). Isso vai garantir que a coleção seja inicializada apenas na criação do objeto.

package vo;
     import java.util.ArrayList;
     import java.util.Collection;

     public class CarrinhoDeCompras {
	  private Collection<Produto> arrProdutos;

	  public CarrinhoDeCompras() {
		this.arrProdutos = new ArrayList<Produto>();
 	  }
	  public final Collection<Produto> getArrProdutos() {
		return arrProdutos;
 	  }
     }

Criei a classe LojaBO para simular estoque de produtos. A lógica desta classe é bem simples: ela possui um java.util.List de objetos Produto para representar os produtos vendidos pela nossa loja e dois voltados aos métodos: um é buscar (código), que busca o produto na coleção pelo código, e o outro é um método de acesso ao nosso List.

package bo;
	import java.util.ArrayList;
	import java.util.List;

	import vo.Produto;

	public class LojaBO {
	   private List<Produto> arrProdutosDisponiveis;

	   public LojaBO() {
		arrProdutosDisponiveis = new ArrayList<Produto>();
		Produto produto = null;
		for (int i = 0; i < 5; i++) {
			produto = new Produto();
			produto.setCodigo(i);
			produto.setNome("Produto " + i);
			produto.setVlPreco(52.8);
			arrProdutosDisponiveis.add(produto);
		}
	  }

	  public Produto buscar(Integer codigo) {
		Produto produto = new Produto();
		produto.setCodigo(codigo);
		return	arrProdutosDisponiveis.get(arrProdutosDisponiveis.indexOf(produto));
	  }

	  public final List<Produto> getArrProdutosDisponiveis() {
		return arrProdutosDisponiveis;
	 }
    }

Já criamos os objetos para representar o carrinho de compras, os produtos disponíveis. Agora criei a página que exibirá a listagem dos produtos para o usuário poder escolher qual item vai adicionar no carrinho (listarProdutos.jsp).

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">

<%@page import="bo.LojaBO"%>
<%@page import="java.util.Collection"%>
<%@page import="java.util.List"%>
<%@page import="vo.Produto"%><html>
<head>
<title>Produtos Disponiveis</title>
<style>
<!--
	body {
	text-align: left;
}
-->
</style>
</head>
<body>
	<h2>Produtos Disponiveis:</h2>
<%
	/* armazena lista de produtos na sessão do usuario. */
	LojaBO lojaBO = new LojaBO();
	List<Produto> arrProduto = lojaBO.getArrProdutosDisponiveis();
%>	<table>
		<thead><tr>
				<th>Codigo</th>
				<th>Nome</th>
				<th>Preço</th>
				<th></th>
		</tr></thead>
<%		for(Integer i = 0; i < arrProduto.size(); i++){
			Produto produto = arrProduto.get(i);%>
		<tr>
			<td><%= produto.getCodigo() %></td>
			<td style="width: 120px"><%= produto.getNome() %></td>
			<td><%= produto.getVlPreco() %></td>
			<td><a href="controlCarrinhoDeCompras.jsp?a=adicionar&codigo=
                        <%= produto.getCodigo() %>">Adicionar</a></td>
		</tr>
		<% } %>
	</table>
	<p><a href="controlCarrinhoDeCompras.jsp">Meu Carrinho</a></p>
</body>
</html>

A página abaixo (controlCarrinhoDeCompras.jsp) possui a lógica das ações do carrinho de compras. Tem as seguintes funcionalidades:

– Adicionar o produto na listagem do carrinho de compras.

– Excluir todos os itens do carrinho de compras.

<%@page import="vo.Produto"%>
<%@page import="bo.LojaBO"%>
<%@page import="vo.CarrinhoDeCompras"%><%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<%
// caso não exista um objeto CarrinhoDeCompras na session, ele cria.
if(session.getAttribute("carrinhoDeCompras") == null){
	session.setAttribute("carrinhoDeCompras", new CarrinhoDeCompras());
}
/* pega referência ao Objeto CarrinhoDeCompras que está armazenado na session. Necessário fazer um cast,
 pois o metodo "getAttribute" retorna um Object. */
CarrinhoDeCompras carrinhoDeCompras = (CarrinhoDeCompras) session.getAttribute("carrinhoDeCompras");
/* parametro que indica qual acao deve ser executada. */
String acao = request.getParameter("a");
/* indica qual pagina será invocada apos execucao abaixo. Por padrao,
deixei a listagem de produtos do carrinho de compras.*/
String path = "listarProdutosDoCarrinho.jsp";
if(acao != null && !acao.equals("")){
	if(acao.equals("adicionar")){
		Integer codigo = Integer.parseInt(request.getParameter("codigo"));
		LojaBO lojaBO = new LojaBO();
		Produto  produto = lojaBO.buscar(codigo);
		carrinhoDeCompras.getArrProdutos().add(produto);
	}
	if(acao.equals("limpar")){
		session.setAttribute("carrinhoDeCompras", new CarrinhoDeCompras());
	}
}
RequestDispatcher requestDispacher = request.getRequestDispatcher(path);
requestDispacher.forward(request, response);
%>

Após a escolha do produtos, o usuário pode visualizar os produtos selecionados, através da página abaixo (listarProdutosDoCarrinho.jsp):

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">

<%@page import="bo.LojaBO"%>
<%@page import="java.util.Collection"%>
<%@page import="vo.Produto"%>
<%@page import="vo.CarrinhoDeCompras"%><html>
<head>
<title>Produtos Adicionados no Carrinho de Compras</title>
<style>
<!--
	body {
	text-align: left;
}
-->
</style>
</head>
<body>
<%
/* É adicionado um objeto CarrinhoDeCompras na sessão, caso ainda não exista.*/
      if(session.getAttribute("carrinhoDeCompras") == null){
		session.setAttribute("carrinhoDeCompras", new CarrinhoDeCompras());
	}
	// referência do objeto CarrinhoDeCompras que esta na sessão do usuario.
	CarrinhoDeCompras carrinhoDeCompras = (CarrinhoDeCompras) session.getAttribute("carrinhoDeCompras");
	Collection<Produto> arrProduto = carrinhoDeCompras.getArrProdutos();
	if(!arrProduto.isEmpty()){%>
		<h2>Produtos Adicionados:</h2>
		<table>
			<thead><tr>
					<th>Codigo</th>
					<th>Nome</th>
					<th>Preço</th>
			</tr></thead>
		<%for(Produto produto : arrProduto){ %>
			<tr>
				<td><%= produto.getCodigo() %></td>
				<td style="width: 120px"><%= produto.getNome() %></td>
				<td><%= produto.getVlPreco() %></td>
			</tr>
		<% } %>
		</table>
		<p><a href="listarProdutos.jsp">Comprar Mais</a></p>
		<p><a href="controlCarrinhoDeCompras.jsp?a=limpar">Limpar Carrinho</a></p>
	<% } else { %>
		<p>Seu carrinho de compras está vazio</p>
		<p><a href="listarProdutos.jsp">Voltar Listagem de Produtos</a></p>
	<% } %>
</body>
</html>

Meu simples carrinho de compras está pronto, funcionando sem problemas e utilizando o que a seção tem a oferecer. Agora fica com você a implementar uma aplicação mais complexa.

O projeto do Eclipse com os fontes está disponível para download. Espero que tenham gostado e a informação que escrevi seja útil. Até a próxima.

Referências

http://java.sun.com/javaee/5/docs/api/

Fonte: Imasters

Os erros de servidor podem ser considerados como exceções Java , e controlá-los é simples em aplicações web escritas em Java, não necessitando impor mudanças nas classes.

Diretiva Page: definirá as diretivas da página. Essa diretiva permite importação de classes, customização de super classes Servlet, etc.

Alguns atributos mais usados são:

isErrorPage = “True | False” – define se é uma página de controle de erro.

Language = “java” – especifica a linguagem que está sendo usada.

import=”pacote.classe.*” – pacote que deve ser importado.

Etc…

Criando e configurando página de erro

Veremos abaixo, passo a passo, como configurar páginas de erros personalizadas.

1. Abra o Netbeans 6

2. Localize o seu projeto (usado nos outras colunas, ou crie um novo)

3. Clique em file > new file

4. Na tela que aparece, escolha em categories WEB e, em files types, escolha JSP.

5. Clique em next e, na próxima tela, no campo JSP File name, dê um nome ao seu arquivo JSP (se quiser seguir a coluna, o meu chamei de erro).

6. Feito isso, clique em finish

7. Clique no sinal de + de configuration files e em seguida dê dois cliques em web.xml. Aqui vamos configurar nossa página de erro.

Nessa coluna vamos tratar o erro 404, página não encontrada. Isso pode acontecer freqüentemente na sua aplicação. O usuário pode digitar o endereço errado da aplicação e você, como um bom desenvolvedor, vai alertá-lo a respeito de forma personalizada.

Erro.jsp

A página de erro.jsp que acabamos de criar será responsável por capturar o erro (nesse caso 404) e exibí-lo ao usuário de forma personalizada.

Na tela de web.xml, clique na Pages e expanda o nó Error Pages

.

8.Clique no botão Add. Na caixa de diálogo Add Error Page que acabou de surgir, clique em Browse… para selecionar a página de erro, no nosso caso, escolha erro.jsp.

9. No campo Error Code, digite 404 e depois clique no OK. Não vamos configurar nenhuma exceção para esse tipo de erro, então o último campo deixe em branco.

10. Abra o arquivo erro.jsp e altere conforme abaixo:

<%@page contentType="text/html" pageEncoding="UTF-8"
        isErrorPage="true"%>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
   "http://www.w3.org/TR/html4/loose.dtd">

<html>
    <head>
        <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
        <title>JSP Page</title>
    </head>
    <body>
        <h1>Erro 404 </h1>
        [cor2]Se você está vendo essa mensagem é porque o endereço que você está
        tentado acessar não existe.[/cor2] <br>
        Caso queira receber mais informações a respeito, entre em contato com o administrador do site.
    </body>
</html>

11. Para testar, abra o browser e digite um endereço inválido http://localhost/seuprojeto/invalido

isErrorPage=”true”

Com essa diretiva page, informamos que se trata de uma página de erro conforme mencionei no inicio do artigo.

Bom, espero que tenham gostado do artigo e que a manipulação de erros passa a ser uma atividade frequente em suas aplicações. Uma dica que uso nas mensagens para o usuário é a substituição da palavra “erro” por “aviso”, e solicito ao usuário para entrar em contato com a equipe de suporte e informar que aconteceu o “aviso 404″. A palavra “erro”, na minha opinião, é muito pesada e gera desconforto e insegurança ao usuário/cliente.

Fonte: Imasters

No desenvolvimento dos sistemas web, você pode criar aplicações dinâmicas e inteligentes, utilizando o máximo das vantagens que a linguagem tem a oferecer. Exemplos como exibir o resultado de uma consulta sobre um certo cliente, receber dados de um formulário, armazenar um carrinho de compras do usuário… Ou seja, existem milhares de situações que podem ser implementadas.

Neste artigo comentarei sobre alguns objetos implícitos nas páginas jsp e descrever em quais escopos os objetos podem estar durante o processamento da página. Este é meu primeiro artigo aqui no iMasters, e espero que gostem e que as informações passadas sejam úteis.

Estes são alguns dos objetos implícitos que você usará com mais freqüência.

• request
• pageContext
• session
• context
• out
• response

A partir de agora, vou descrever cada objeto e criar uma situação de utilização.

Antes de iniciar, vou comentar sobre scriptlets, pois vou utilizá-los na implementação dos exemplos.

<% %> – acessar algum escopo.

<%= %> – escreve algum conteúdo na resposta.

Obs: utilizar scriptlets nas paginas jsp não é uma boa prática de programação, pois mistura código java com html, deixando o código bastante confuso. Para resolver essa questão criaram JSTL, EL (Expression Language). Assunto esse para próximos artigos.

Request

O request representa uma solicitação do browser para o servidor, e o ciclo de vida é marcado pelo recebimento da requisição e montagem da resposta para o cliente.

Ele trata todas as informações que o browser passou para o servidor, exemplo: sabe qual o tipo do método HTTP que deu origem à requisição, possui todos os parâmetros da requisição criados via formulário ou passados via url, também tem referência aos cookies do browser.

Esses são alguns métodos disponíveis:

getParameter(java.lang.String name) – este método retorna o valor de algum parâmetro que está na requisição do browser. “name” é o identificador do parâmetro e caso não encontre o valor retorno é null.

Exemplo: um input text de nome “meuNome”:

 <input type="text" name="meuNome">

Na página que trata a requisição do browser:

<%
String nmCliente = request.getParameter("meuNome");
%>

getParameterValues(java.lang.String name) – este é semelhante ao metodo anterior, a diferença é que ele retorna um array de String. É utilizado nas páginas que possuem elementos com mesmo nome.

Geralmente é utilizado quando é necessário implementar um lista de inputs do tipo checkbox, hidden,.. na página jsp.

Exemplo:

<form action="treatRequest.jsp" method="post">
<ul>
<li><input type="checkbox" name="arrCheckBox" value="radio1"></li>
</ul>
<ul>
<li><input type="checkbox" name="arrCheckBox" value="radio2"></li>
</ul>
<ul>
<li><input type="checkbox" name="arrCheckBox" value="radio3"></li>
</ul>
<ul>
<li><input type="checkbox" name="arrCheckBox" value="radio4"></li>
</ul>
<input type="submit" value="Salvar">
</form>

Código da página que tratará a requisição.

<%
String[] arrCheckBox = request.getParameterValues("arrCheckBox");
%>

setAttribute(java.lang.String name, java.lang.Object o) – Armazena o objeto “o” passado no escopo do request, o parâmetro “name” é um identificador do objeto dentro do request.

getAttribute(java.lang.String name) – retorna uma referência do objeto que está no request, onde “name” é o identificador do objeto.

Os métodos setAttribute(String) e getAttribute(String) são utilizados quando você precisa trafegar objetos entre as páginas jsp, não os parâmetros da requisição HTTP. Exemplo: salvar um objeto Cliente para outra página utilizá-lo.

Para realizar a navegação entre páginas jsp, utilize a tag <jsp:forward page=”nomePagina.jsp”/>. Utilizando esta tag, você passa a requisição para outra página tratar, encaminhando junto todos os parâmetros e objetos salvos no request.

Exemplo:

Criar um formulário de cadastros de nomes.

Classe Pessoa.

package vo;

public class Pessoa {
private String nome;

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

Fonte do formulário (exRequest.jsp)

Utilizei o mesmo formulário dos exemplos anteriores, então criei uma função javascript que invoca a página para cadastrar uma pessoa.

<script type="text/javascript">
function cadastrarPessoa() {
var meuNome = document.getElementById("meuNome");
window.location = "/Orion/request/cadastrarPessoa.jsp?meuNome=" + meuNome.value;
}
</script>
<p>
Digite seu nome: <input type="text" id="meuNome" name="meuNome">
 <a href="javascript:void(0)" onclick="javascript:cadastrarPessoa();">Cadastrar Pessoa </a>
</p>

Fonte cadastrarPessoa.jsp: esta página será responsável por pegar o valor do parâmetro “meuNome” e criar o objeto Pessoa, logo após o método “setAttribute(´pessoa´, pessoa)” salva o objeto pessoa no request. Agora é só encaminhar a requisição para a página “logicCadastrarPessoa.jsp” tratar.

<%@page import="vo.Pessoa"%>
<%
String nome = request.getParameter("meuNome");
Pessoa pessoa = new Pessoa();
pessoa.setNome(nome);
/* aqui salva objeto no request */
request.setAttribute("pessoa", pessoa);
%>
<jsp:forward page="logicCadastrarPessoa.jsp"/>

Fonte logicCadastrarPessoa.jsp: esta página é responsável por aplicar algum de tipo de regra de negócio* com o objeto Pessoa que está salvo no request.

Também é necessário adicionar um cast implícito para o objeto que você quer utilizar, pois o método

“getAttribute(String)” retorna um Object.

<%@page import="vo.Pessoa"%>
<%
Pessoa pessoa = (Pessoa) request.getAttribute("pessoa");
if(pessoa != null){
%>
<p>Ola <%= pessoa.getNome() %> - agora poderia cadastrar você no banco de dados</p>
<% } %>

PageContext

Este também possui os métodos setAttribute(java.lang.String name, java.lang.Object o) e getAttribute(java.lang.String name) comentados no assunto anterior. A lógica do funcionamento destes dois métodos é igual ao request.

Uma diferença deste objeto é que ele possui a funcionalidade para adicionar ou pegar uma referência a um objeto em qualquer escopo da aplicação.

getAttribute(java.lang.String name, int scope) e setAttribute(java.lang.String name, java.lang.Object o, int scope) – onde “name” é o identificador do objeto, e o int “scope” indica qual o escopo que será utilizado, pode ser as seguintes constantes:

• PageContext.PAGE_SCOPE
• PageContext.REQUEST_SCOPE
• PageContext.SESSION_SCOPE
• PageContext.APPLICATION_SCOPE

Agora criei um exemplo onde não é definido implicitamente o escopo dos objetos:

<%@page import="java.util.ArrayList"%>
<%@page import="java.util.List"%>
<%
List<Integer> arrNumeros = new ArrayList<Integer>(10);
for (Integer i = 0; i < 10; i++) {
arrNumeros.add(i);
}
%>
<p>Lista de Números - total de números: <%=arrNumeros.size()%></p>
<%
for (Integer i = 0; i < arrNumeros.size(); i++) {
%>
<ul>
<li><%=arrNumeros.get(i)%></li>
</ul>
<%
}
%>

No exemplo acima, criei um coleção de Integer e logo após mostro a listagem completa dos objetos. E você descobriu em qual escopo a variável “arrNumeros” está armazenada? Vamos viajar um pouco: durante o ciclo de vida da página alguns métodos são invocados na inicialização (jspInit()), logo após é invocado o método jspService() que é o responsável por escrever todo o conteúdo html para o cliente, e toda a fonte de scriptlets ficam armazenados dentro deste método… Concluindo, todas as variáveis são locais, existindo apenas durante a execução do método.

Utilizei a diretiva @page para realizar os imports da interface java.util.List e a coleção java.util.ArrayList.

Referência

http://java.sun.com/javaee/5/docs/api/