Baixar Apresentação

Propaganda

Programação para Internet II
Aulas 05 e 06
Fernando F. Costa
[email protected]
http://blog.fimes.edu.br/fernando
JavaBeans
Fundamentos básicos de JavaBeans
JavaBeans são componentes de softwares escritos em
Java que também são conhecidos como Beans.
A API JavaBeans foi lançada pela Sun em fevereiro de
1997, na versão 1.1 do JDK, sendo criada com a
cooperação da indústria.
Fundamentos básicos de JavaBeans
Qual é a diferença entre uma classe Java e um JavaBean?
Resposta:
“Um JavaBean normalmente é uma classe (poderia ser
mais
de
uma
classe),
mas
uma
classe
não
é
necessariamente um JavaBean.”
(TODD, 2003)
Fundamentos básicos de JavaBeans
Podemos definir um Bean como uma classe Java que
segue
um
conjunto
de convenções de design e
nomeação definidos pela especificação de JavaBeans do
J2SE. Ao contrário de outras tecnologias Java, os beans
não precisam obrigatoriamente estender uma classe ou
implementar uma interface. Entretanto é uma boa
prática a implementação da interface Serializable.
Fundamentos básicos de JavaBeans
Um bean tem como premissa a idéia de encapsulamento. Assim sendo
suas variáveis devem obrigatoriamente serem acessadas através de
métodos.
Outra importante regra refere-se ao construtor. Ele deve ser sem
parâmetros.
Em relação aos métodos, eles podem ser divididos em métodos de
leitura e de escrita.
Fundamentos básicos de JavaBeans
As convenções adotadas para dar nomes aos métodos de um Bean são:
●
public TipoDaPropriedade getNomeDaPropriedade()
●
public void setNomeDaPropriedade(TipoDaPropriedade varName)
Em relação as variáveis booleanas vale o mesmo conceito, com o uso da
palavra is ao invés do get.
●
public void setNomeDaPropriedade(Boolean varName)
●
public Boolean isNomeDaPropriedade()
Propriedades Beans
A manipulação de um Bean é feito através de suas
propriedades. Normalmente, estas propriedades são
descritas numa folha de propriedades, conforme
imagem abaixo:
Interagindo com um Bean
Para interagir com um Bean, primeiro dizemos à página onde encontrar o
Bean e atribuímos um nome a ele. Em seguida, fazendo uso deste nome
podemos acessar e alterar valores armazenados nas propriedades do
Bean. Tudo isso com as 3 tags a seguir:
●
<jsp:useBean>
●
<jsp:getProperty>
●
<jsp:setProperty>
Interagindo com um Bean
<jsp:useBean>
●
Serve para informar a página atual que um Bean será utilizado.
●
Permite escrever JSP´s que utilizam classes JavaBean.
Sintaxe:
<jsp:useBean id=”nome bean” class=”nome classe” />
ou
<jsp:useBean id=”nome bean” class=”nome classe”>
</jsp:useBean>
Interagindo com um Bean
<jsp:useBean> - Atributos
Interagindo com um Bean
<jsp:getProperty>
●
Permite recuperar o valor de uma propriedade em um JavaBean e
incorporá-lo a saída.
●
Não possui elemento de corpo
●
Espera 2 atributos: name e property
Sintaxe:
<jsp:getProperty name=”nome bean” property=”nome propriedade” />
Interagindo com um Bean
<jsp:setProperty>
●
Permite configurar o valor de uma propriedade em um JavaBean.
●
Não possui elemento de corpo
●
Espera 3 atributos: name, property e value
Sintaxe:
<jsp:setProperty name=”nome bean” property=”nome propriedade”
value=”valor”/>
Exemplo de um JavaBean para Fatorial
Fatorial.java
package unifimes;
public class Fatorial {
public Fatorial() { }
private String numero;
private Integer fatorial;
public void setNumero(String num) { this.numero = num; }
public String getNumero() { return numero; }
public String getFatorial() {
int valor = Integer.parseInt(getNumero());
fatorial = valor;
if (valor > 0) {
if (valor > 1)
for (int x = valor - 1; x > 1; x--)
fatorial = fatorial * x;
}
return fatorial.toString();
}
}
Exemplo de um JavaBean para Fatorial
index.html
<html>
<body>
<form name="fatorialbean" action="fatorialBean.jsp" method="POST">
<h1>Fatorial Bean</h1>
Valor:<input type="text" id="valor" name="valor" value="" />
<input type="submit" value="Calcular" name="calc" />
</form>
</body>
</html>
Exemplo de um JavaBean para Fatorial
fatorialBean.jsp
<html>
<body>
<jsp:useBean class="unifimes.Fatorial" id="fator" scope="session" />
<jsp:setProperty
name="fator"
property="numero"
value='<%=
request.getParameter("valor") %>' />
O Fatorial de
<jsp:getProperty name="fator" property="numero" />
usando a tag jsp:useBean &eacute;:
<jsp:getProperty name="fator" property="fatorial" />
</body>
</html>
Linguagens de Expressão
Linguagens de Expressão - EL
É uma Linguagem de script que permite o acesso à
componentes Java (JavaBeans) através de JSP. Desde o JSP
2.0, ela tem sido utilizada dentro de tags JSP para separar o
código Java do código JSP e para possibilitar o acesso mais
fácil aos componentes Java (e assim ao código Java).
EL – Acessando Propriedades
●
${varNome.propriedadeNome}: Indica que irá buscar uma
variável de um nome específico (varNome) e que irá
apresentar o valor de uma das propriedades dessa variável
(propriedadeNome). Ex:
${academico.matricula}
●
${varNome[indice ou parametro]}: Indica que ira localizar
uma variável de um nome específico e acessar o valor do
índice especificado ou do parametro informado. Ex:
${academicos[1]} ou $academico[“codigo”]}
EL – Operadores
(Relacionais, Lógicos e Aritméticos)
Outros operadores: * (multiplicação), / (divisão), - (subtração),
% (resto de divisão)
JSTL - JSP Standard Tag Library
Biblioteca Padrão de Tags JSP
JSTL – O que é?
JSTL consiste em uma coleção de bibliotecas, tendo cada
uma um propósito bem definido, que permitem escrever
páginas JSP´s sem código Java, aumentando assim a
legibilidade do código e a interação entre desenvolvedores e
web designers.
●
●
Uma página JSTL é uma página JSP contendo um
conjunto de tags JSTL´s.
Cada tag realiza um determinado tipo de processamento
(equivalente a código Java dentro de uma JSP).
●
Cada tag JSTL, faz parte de uma biblioteca JSTL.
●
Uma página JSTL pode utilizar várias bibliotecas JSTL´s.
JSTL – Para que serve?
●
●
●
Criar páginas dinâmicas bastante complexas sem escrever
código Java dentro delas;
Fornecer tags que tornem fáceis tarefas que exigiriam
várias linhas de código Java. Ex: Formatação de números
e datas seguindo configurações regionais do usuário;
Facilitar a
designers.
interação
entre
desenvolvedores
e
web
JSTL - Exemplo
<%@ taglib prefix="fmt" uri="http://java.sun.com/jsp/jstl/fmt" %>
<html>
<body bgcolor="#FFFFFF">
<jsp:useBean id="agora" class="java.util.Date"/>
<br>
Versão Curta: <fmt:formatDate value="${agora}" />
<br>
Versão Longa:
<fmt:formatDate value="${agora}" dateStyle="full"/>
</body>
</html>
Obs: Colocar os arquivos jstl.jar e standard.jar
na pasta WEB-INF/lib e no Path da aplicação
JSTL – Bibliotecas Padrão
●
Biblioteca Core (prefixo: c) - Controle de Fluxo, Manipulação de variáveis,
Gerenciamento de URL – Inclusão em JSP:
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
●
Biblioteca XML (prefixo: x) - Manipulação de arquivos XML, controle do fluxo dos
elementos de um documento e transformações – Inclusão em JSP:
<%@ taglib prefix="x" uri="http://java.sun.com/jsp/jstl/xml" %>
●
Biblioteca Internationalization (i18n) (prefixo: fmt) - Formatação de
mensagens, números e datas – Inclusão em JSP:
<%@ taglib prefix="fmt" uri="http://java.sun.com/jsp/jstl/fmt" %>
●
Biblioteca Database (prefixo: sql) - Gestão de consultas a Bancos de Dados Inclusão em JSP:
<%@ taglib prefix="sql" uri="http://java.sun.com/jsp/jstl/sql" %>
●
Biblioteca Functions (prefixo: fn) - Gestão de coleções, Manipulação de Strings
– Inclusão:
<%@ taglib prefix="fn" uri="http://java.sun.com/jsp/jstl/functions" %>
JSTL – Tags Básicas
(Biblioteca Core)
●
●
●
●
<c:forEach>: laços de repetição. Ex:
<c:forEach var="i" begin="2" end="5"> … </c:forEach>
<c:forTokens>: quebra string em substrings de acordo com o delimitador
indicado. Ex:
<c:forTokens var="i" delims="," items="2,3,4,5"> ... </c:forTokens >
<c:if>: teste condicional. Ex:
<c:if test="${i % 2 == 0}"> ... </c:if>
<c:choose>: múltiplos testes condicionais. Utilizada juntamente com as
tags <c:then> e <c:otherwise>. Ex:
<c:choose>
<c:when test="${i % 2 == 0}">${i} (par)</c:when>
<c:otherwise>${i} (impar)</c:otherwise>
</c:choose>
JSTL – Tags Básicas
(Biblioteca Core)
●
●
●
●
<c:import>: Permite importar páginas web do mesmo contexto web, de
contextos diferentes e até mesmo de máquinas diferentes. Ex:
<c:import var="headerText" url="header.jsp"/>
<c:set>: Permite a atribuir valores a variáveis em um determinado
escopo. Ex:
<c:set scope="request" var="title" value="Bem vindo a página"/>
<c:out>: Imprime uma saída para o usuário. Função semelhante as tags
de expressão do JSP. Ex:
<c:out value="${2 * 3}" />
<c:catch>: Tenta executar o que estiver dentro de seu corpo, e caso
ocorra alguma exceção, armazena na variável informada. Ex:
<c:catch var="ex">
JSTL – Uso do if
<%@ page language="java" contentType="text/html; charset=ISO-8859-1"
pageEncoding="ISO-8859-1"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
"http://www.w3.org/TR/html4/loose.dtd">
<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
<title>JSTL: Lógica com a Tag if</title>
</head>
<body>
<h3>JSTL: Lógica com a Tag <code>if</code></h3>
<ul>
<c:forEach var="i" begin="1" end="10">
<li><c:out value="${i}"/>
<c:if test="${i > 7}">
(maior que 7)
</c:if>
</li>
</c:forEach>
</ul>
</body>
</html>
JSTL – Tags de Formatação
●
<fmt:formatNumber>: Formatar um valor numérico como um número, um
valor monetário, uma porcentagem ou respeitando uma locale qualquer.
●
<fmt:parseNumber>: Realizar um parse em um número ou valor.
●
<fmt:formatDate>: Formatar uma data
●
<fmt:parseDate>: Realizar um parse em uma data.
●
<fmt:timeZone>: Recuperar uma timezone.
●
<fmt:setTimeZone>: Definir uma timezone.
●
<fmt:setLocale>: Define o local (a língua a ser usada) na aplicação.
Trabalhando com Datas e Números
<%@ page language="java" contentType="text/html; charset=ISO-8859-1"
pageEncoding="ISO-8859-1"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
"http://www.w3.org/TR/html4/loose.dtd">
<%@ taglib prefix="fmt" uri="http://java.sun.com/jsp/jstl/fmt" %>
<html>
<body>
<jsp:useBean id="now" class="java.util.Date" />
<h2>Internacionalização e Formatação de Datas</h2>
<ul>
<li>Formatando a data atual como "GMT":<br>
<fmt:timeZone value="GMT">
<fmt:formatDate value="${now}" type="both" dateStyle="full" timeStyle="full" />
</fmt:timeZone></li>
<li>Formatando a data atual como "GMT+1:00", e realizando um <i>parse</i> sobre ela:<br>
<fmt:timeZone value="GMT+1:00">
<fmt:formatDate value="${now}" type="both" dateStyle="full" timeStyle="full"
var="formatted" />
<fmt:parseDate value="${formatted}" type="both" dateStyle="full"
timeStyle="full" timeZone="PST" var="parsedDateTime" />
Trabalhando com Datas e Números
Data obtida via parse:
<fmt:formatDate value="${parsedDateTime}" type="date" dateStyle="full" /><br>
Tempo obtido via parse:
<fmt:formatDate value="${parsedDateTime}" type="time" timeStyle="full" />
</fmt:timeZone></li>
<li>Formatando a data atual no formato longo:<br>
<fmt:formatDate type="both" dateStyle="long" timeStyle="long" value="${now}" /></li>
<li>Formatando a data atual no formato médio:<br>
<fmt:formatDate type="both" dateStyle="medium" timeStyle="medium" value="${now}" /></li>
<li>Formatando a data atual no formato curto:<br>
<fmt:formatDate type="both" dateStyle="short" timeStyle="short" value="${now}" /></li>
<li>Formatando a data atual no formato yyyy-MM-dd:<br>
<fmt:formatDate pattern="yyyy-MM-dd" value="${now}" /></li>
<li>Formatando um número no formato moeda:<br>
<fmt:setLocale value="pt-BR" />
<fmt:formatNumber value="1000000" minFractionDigits="2" type="currency"/></li>
</ul>
</body>
</html>
Resultado Esperado
JSTL – Tags de Acesso ao BD
●
<sql:setDataSource>: Cria um dataSource, que proverá uma conexão ao
servidor de banco dados para qualquer página JSP participante do
mesmo escopo. Ex:
<sql:setDataSource var="ds"
driver="com.mysql.jdbc.Driver"
url="jdbc:mysql://localhost:3307/RegistroAcademico"
user="root"
password="123456"
scope="session"/>
●
<sql:transaction>: Cria uma transação com o banco dados, onde
podemos executar de forma mais protegida e sequencial, várias
atualizações ou inserções.
<sql:transaction dataSource="${ds}">
JSTL – Tags de Acesso ao BD
●
<sql:query>: Executa uma consulta sql. Ex:
<sql:query var="academicos" ...>
SELECT * FROM Academico
</sql:query>
●
<sql:update>: Executa uma atualização sql (inserção, atualização ou
exclusão). Ex:
<sql:update var="atualizaAcademico" ...>
INSERT INTO academico VALUES (2,'Fernando')
</sql:update>
●
<sql:param>: Determina valores para parâmetros de uma instrução em
tempo de execução. Ex:
<sql:update var="gravaAluno" ...>
insert into ALUNOS (MATRICULA,NOME) values(?,?)
<sql:param value="${param['edtMatricula']}"/>
<sql:param value="${param['edtNome']}"/>
</sql:update>
Exemplo
●
Para o nosso exemplo com JSTL, criem um banco de
dados e uma tabela com os campos (id, matricula, nome,
endereco, telefone).
create database academico;
create table aluno (
id integer not null auto_increment,
matricula integer not null,
nome varchar (50) not null,
endereco varchar(70),
telefone varchar(13),
primary key (id)
);
Listagem com JSTL
<%@page contentType="text/html"%>
<%@page pageEncoding="UTF-8"%>
<%@taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c"%>
<%@taglib uri="http://java.sun.com/jsp/jstl/fmt" prefix="fmt"%>
<%@taglib uri="http://java.sun.com/jsp/jstl/sql" prefix="sql"%>
<html>
<head>
<sql:setDataSource var="ds"
dataSource="jdbc:mysql://localhost:3306/academico, com.mysql.jdbc.Driver, admin, admin" />
<title>Exemplo JSTL </title>
</head>
<body>
<h1>Relação de Alunos</h1>
<hr>
<sql:query var="ResultadoAlunos" dataSource="${ds}">
select * from aluno
</sql:query>
Listagem com JSTL
<table border="1">
continuação...
<tr>
<th>Id</th>
<th>Matricula</th>
<th>Nome</th>
<th>Endereco</th>
<th>Telefone</th>
</tr>
<c:forEach var="listaAlunos" items="${ResultadoAlunos.rows}">
<tr>

<td><c:out value="${listaAlunos.id}"/></td>
<td><c:out value="${listaAlunos.matricula}"/></td>
<td><c:out value="${listaAlunos.nome}"/></td>
<td><c:out value="${listaAlunos.endereco}"/></td>
<td><c:out value="${listaAlunos.telefone}"/></td>
</tr>
</c:forEach>
</table>
</body>
</html>
Resultado Esperado
Exercício
●
Utilizando os conceitos apresentados sobre EL e JSTL, crie
uma página que mostre a data no formato dd/mm/yyyy e a
hora no formato HH:mm:ss. Além disso, com base na hora
exibida, deseje: Bom Dia (entre 07 e 13), Boa Tarde (entre 13
e 18) e Boa Noite.
Referências
●
JÚNIOR, José Celso Freire. Linguagem de Expressão 2.0 e JSP-Standard
Tag Library (JSTL).
●
MEDEIROS, Manoel Pimentel. JSTL – Exemplo de um cadastro web
●
VALENTIM, Ricardo. JSTL - JSP Standard Tag Library. 2007