Tecnologias paraDesenvolvimento    de Software
Licença    Esta obra está licenciada sob uma       Licença Creative Commonshttp://creativecommons.org/licenses/by-nc-sa/2....
Instrutor●   Rafael Benevides●   Trabalha com Java desde 2001●   Possui as certificações Java: SCJA, SCJP,    SCWCD, SCBCD...
Objetivo●   Visão geral das diversas tecnologias para    desenvolvimento de software corporativo
Agenda●   31/07 – Servlets, JSP e JSF●   01/08 – JNDI, JMS, JAAS, JCA e JTA●   02/08 – Hibernate e JPA●   Livres por algun...
Apresentação da equipe●   Seu nome●   Atividade que executa●   Experiência–    Orientação a objetos–    Programação Java– ...
JCP e as Especificações Java●   O que é uma especificação?●   Como nascem as especificações ?●   JCP - Java Community Proc...
Programação por contratos●   Interoperabilidade                         ?
Contrato entre componentes●   Interoperabilidade só é atingida com:    ●   Padronização
Uma interface é um contrato entre             partes
Interface não é implementação          ≠
Interfaces●   Elementos legais    –   Contrato                         –   Contratado          –   Contratante            ...
Interfaces
Uma Interface com várias   implementações
Interfaces Java    ●   Javapublic interface DataAccesLayer {         public String [] read(int recNo);          public voi...
Implementação da Interface    ●   Javapublic class ArquivoBinario implements DataAccessLayer {         public String [] re...
Frameworks●   Exemplo    –   Auto atendimento do BRB    –   Auto atendimento do BB    –   Auto atendimento do Banco REAL
Frameworks●   Exemplo    –   Auto atendimento do BRB    –   Auto atendimento do BB    –   Auto atendimento do Banco REAL  ...
Framework genérico●   Aplicativo genérico    –   Auto atendimento bancário    –   Framework de auto atendimento bancário
Frameworks●   Esqueleto de uma aplicação●   Extensível●   Parametrizável●   Exemplos: Applet, Servlet, MIDlet, EJB, etc
Applet
Servlet
Midlet
EJB 2.1 – Session Bean
Servlets
Assuntos●   Servlets e o Web Container●   Escrevendo texto●   Escrevendo binário●   SendError e sendRedirect●   Parametros...
Como nasceu o servlet●   Era uma vez o CGI...●   Mas o CGI não suporta Threads●   O CGI é dependente de plataforma●   E nã...
Nasceu o Servlet●   Foi pensado para aplicações do tipo Requisição e Resposta    (Request e Response)●   Precisa de um Con...
Vantagem do Servlet sobre CGI●   Eficiente: Nova Thread em vez de um novo Processo●   Conveniente: É Java!!! Não é necessá...
Ciclo de vida - Métodos●   Interface Servlet possui 3 métodos principais:    –   init()    –   service()    –   destroy()●...
Método service()●   A classe HttpServlet implementa o service()    para tratar uma requisição HTTP em um dos    métodos es...
Ciclo de vida de um Servlet
Estrutura básica de um Servletpublic class AlgumServlet extends HttpServlet {      public void doGet(HttpServletRequest re...
Hello World em Servletpublic class HelloWorld extends HttpServlet {       public void doGet(HttpServletRequest request,   ...
Servlets – Conteúdo bináriopublic class ImageServlet extends HttpServlet {        public void doGet(HttpServletRequest req...
Servlets e Http Response code  response.sendError(HttpServletResponse.SC_NOT_FOUND)    CódigoTipo    1XX   Informação    2...
Redirect vs Request DispatcherResquestDispatcher rd = request.getResquestDispatcher("Servlet2");rd.forward(request, respon...
Lendo Parâmetrospublic class LerParametros extends HttpServlet {        public void doGet(HttpServletRequest request,     ...
Lendo Parâmetros
Lendo Atributos●   Como o HTTP não mantém estado de sessão, são as    aplicações Web que precisam cuidar de mantê-lo    qu...
Lendo atributos da sessão   ●   Sessões são representados por objetos HttpSession e são obtidas       a partir de uma requ...
Configurando um Servlet●   javax.servlet.ServletConfig●   O ServletConfig pode ser obtido nos métodos:     –   init(Servle...
Mapeando um Servlet<servlet>    <description></description>    <display-name>HelloWorld</display-name>    <servlet-name>He...
Filtros●   Um filtro é um componente Web que reside    no servidor    –   Intercepta as requisições e respostas no seu cam...
Criando um Filtro●   Implementar a interface Filter●   Cadastrar o filtro no web.xml●   Sintaxe lembra mapeamento do Servl...
Filtro simples que substitui um             servlet public class HelloFilter implements Filter {          public void doFi...
JSP
Assuntos●   JSP e Ciclo de vida●   Variáveis implícitas●   Diretivas (page, taglib, include)●   Scriptlets <% %>●   Expres...
JSP●   Um JSP é um servlet durante a execução●   Em um servidor que suporta JSP, processamento de JSP    passa por uma cam...
Por que JSP ?●   Servlets forçam o programador a embutir    código HTML dentro de código Java    –   Desvantagem se a maio...
JSP●   Solução do problema anterior usando    templates JSP    <body>    <p>A data de hoje é <%=new Date() %>.</p>    <bod...
Criando uma JSP facilmente●   Mudar a extensão de um arquivo HTML    para .jsp●   Colocar o documento em um servidor que  ...
Criando uma JSP facilmente●   Transformado em um JSP, um arquivo HTML    pode conter blocos de código (scriptlets): <    %...
Sintaxe do JSP●   Podem ser usados em documentos de texto    (geralmente HTML ou XML)●   Todos são interpretados no servid...
Diretivas JSP●   Contém informações necessárias ao processamento da classe do servlet    que gera a página JSP●   Sintaxe ...
Declarações●    Dão acesso ao corpo da classe do servlet. Permitem a declaração de     variáveis e métodos em uma página● ...
Expressões●   Expressões: Quando processadas, retornam um valor que é    inserido na página no lugar da expressão●   Sinta...
Scriptlets●   Scriptlets: Blocos de código que são executados sempre que uma página    JSP é processada●   Correspondem a ...
Objetos implícitos●   Objetos do Servlet     –   page     –   config●   Objetos Contextuais     –   session     –   applic...
Exemplo de objetos implicitoshttp://servidor/programa.jsp?nome=Fulano&id=5<% String nome = request.getParameter("nome"); S...
Taglibs e JSTL ●   Designers não se dão bem com scriptlets ●   Para isto a JSP suporta TaglibsTaglibs são declaradas no in...
JSTL – Java Standard Tag Library●   Esforço de padronização do JCP: JSR-152●   Oferece dois recursos:    –   Conjunto padr...
JSTL – 4 bibliotecas●   Core – loops, condições, url, etc     –   <%@ taglib uri="http://java.sun.com/jstl/ea/core" prefix...
EL – Expression Language●   Permite embutir em atributos expressões dentro de delimitadores $    {...}●   Em vez de reques...
Principais ações●    Suporte à impressão da linguagem     expressões    <c:out value="${pessoa.nome}" />      – Expressões...
Principais ações    ●    Iteração    <c:forEach items="${pessoas}" var="p" varStatus="s">           <c:out value="${s.coun...
JSF
Assuntos●   Por quê JSF ?●   Managed Beans●   Navegação●   Tags●   Tabela●   Conversão e Validação
O que é JSF●   Mais que um framework para desenvolver    aplicações web de forma ágil, JSF foi    incorporado ao especific...
Managed Beans   ●   São classes simples, não herdam de ninguém nem são obrigados       a implementar nenhuma interface   ●...
Navegação ●   Navegação fácil (faces-config.xml)<navigation-rule>       <from-view-id>/greeting.jsp</from-view-id>       <...
Tags●   Dois tipos:●   H (html) e F (faces)<%@ taglib uri="http://java.sun.com/jsf/html" prefix="h" %><%@ taglib uri="http...
Tags HTML●   <h:form> - É a declaração de um formulário comum, o detalhe é que ele é    declarado aqui sem nenhuma ação, i...
Tags HTML●   <h:inputSecret id="senha" value="#{cadastroBean.senha}"    required="true"/> <h:message for="senha"/> - Input...
Tags faces●   <f:view> - É o nodo inicial, uma espécie de saco que vai    guardar todos os componentes, validadores, conve...
Tabelas●   Usa-se o componente <h:dataTable>●   O Backing bean deve retornar um DataModel●   Existem algumas implementaçõe...
Tabelas<h:dataTable var="usuario"       value="#{cadastroBean.usuariosCadastrados}" border="1">      <h:column>           ...
Conversores●    JSF tem seus alguns conversores implementados, mas é possível criar    seus próprios conversores     –   B...
Conversor não padrão●   Implementar a interface Converter●   Cadastrar no faces-config.xml●   Usar em conjunto com a tag  ...
Validadores●   JSF tem seus alguns validadores implementados, mas é possível criar    seus próprios conversores     –   Va...
JNDI
Assuntos●   Introdução ao JNDI     –   Conceitos básicos sobre nomes e diretórios     –   Classes e pacotes da API JNDI●  ...
Conceitos fundamentais●   Conceitos relativos a sistema de nomes     –   Serviço de nomes     –   Ligação (binding)     – ...
Serviço de Nomes●   A principal função de um serviço de nomes é permitir a associação    de um nome (ou uma outra represen...
Ligação ou Binding●   É a associação de um nome com um objeto    (ou com um localizador do objeto)●   Exemplos:    –   Nom...
Convenções de nomeclatura●   Todo sistema de nomes obedece a uma    determinada convenção que determina sua    sintaxe●   ...
Contextos e subcontextos●   Um contexto é um conjunto de ligações nome-objeto●   Se o objeto (referência) contido no conte...
Serviço de diretórios●   Um serviço de diretório é oferece operações para criar, remover,    modificar e principalmente pe...
Atributos●   Descrevem objeto associado a um objeto de diretório●   Um atributo possui     –   Um identificador de atribut...
LDAP●   Lightweight Directory Access Protocol●   Protocolo leve para acesso a diretórios (padrão aberto)●   Armazena objet...
LDAP
JNDI●   Java Naming and Directory Interface é uma ponte sobre os    diversos serviços de nomes e diretórios diferentes●   ...
Arquitetura JNDI
Uso do JNDI●   Para usar JNDI é preciso ter     –   As classes e interfaces do JNDI (pacotes javax.naming.*)     –   Pelo ...
Exemplo 1 – Sistemas de nomes1:import javax.naming.Context;2:import javax.naming.InitialContext;3:import javax.naming.Nami...
Contexto inicial    Precisa ser obtido antes de qualquer operação. Passos:    ●   1: selecionar o provedor de serviços    ...
Recuperação de objeto (lookup)●   Para obter a referência para um objeto de um contexto usa-se o    método lookup()●   Par...
Exemplo de lookup●    O método lookup() usando com o provedor de serviço fscontext     retorna um java.io.File pelo nome d...
Modificando o Bind                                     ●   Substituindo ligações       ●   Adicionando ligações      Fruit...
Conclusões●   Sistemas de nomes e diretórios abstraem conceitos específicos a    um domínio de problema     –   Maior faci...
JMS
Assuntos●   Mensagem assíncrona●   Point-to-Point (Queue)●   Publish-Subscriber (Topic)●   Modelo de programação●   Exemplos
O que é Messaging●   Método de comunicação entre componentes ou aplicações●   Arquitetura peer-to-peer com serviço central...
Messaging vs RPC vs e-Mail●   Messaging    –   Mensagens são representadas como eventos (que causam        numero limitado...
Messaging vs RPC vs e-Mail●   RMI/RPC (Corba, Java RMI, etc.)    –   Mensagens são representadas como chamadas para método...
Messaging vs RPC vs e-Mail
Messaging vs RPC vs e-Mail●   E-mail    –   Uma ou ambas as partes podem ser usuários        humanos●   Messaging é sempre...
Desvantagens dos MOMs●   Camada adicional para repasse de mensagens●   Centralização em único ponto introduz risco de falh...
Desvantagens genéricas dos MOMs ●   Muito genérica: aplicações precisam decifrar as mensagens para     que possam operar; ...
Vantagens dos MOMs (1)●   Escalabilidade    –   Para aumentar a capacidade servidora, basta        acrescentar mais servid...
Vantagens dos MOMs (2)●   Comunicação assíncrona    –   Componentes podem realizar outras tarefas        enquanto não estã...
Vantagens dos MOMs (3)●   Desacoplamento    –   Maior modularidade, maior reuso        (substituibilidade), maior simplici...
Vantagens dos MOMs (4)●   Flexibilidade    –   API definida pelo tipo das mensagens (e não por        interfaces)    –   M...
E quando usar MOM em vez de                RPC●   ... ou, quando decidir por acoplamento mais fraco?     –   Quando a comu...
JMS●   Interface Java única para unir as MOMs    incompatíveis●   API que permite que aplicações criem,    enviem, recebam...
Metas do JMS●   Oferecer uma API simples, unificada e    compatível com aplicações existentes (não-    JMS)●   Suportar ap...
Principais características●   Modelo flexível de desenvolvimento baseado em dois domínios:    ponto-a-ponto e publish/subs...
Arquitetura JMS
Domínio PTP-Point-to-Point●   Baseado no conceito de filas, remetentes e destinatários●   Um para um: cada mensagem é envi...
Domínio pub-sub (publica/inscreve)●   Baseado em canais (tópicos)●   Muitos para muitos: mensagens são enviadas    a um ca...
Consumo de mensagens●   Sistemas de messaging são sempre assíncronos no sentido de    que não há dependência quanto ao tem...
Escrevendo aplicações JMS●   Obter um destino e uma fábrica de conexões via JNDI●   Usar a fábrica para obter uma conexão●...
Escrevendo aplicações JMS
Há dois tipos de destino JMS    ●       Filas (Queue)             –   Retêm todas as mensagens que recebem até que sejam r...
Fábricas de conexão●   Antes que se possa     –   enviar uma mensagem para uma fila,     –   publicar uma mensagem em um c...
Fábricas de conexão●   É preciso conhecer o nome JNDIString nomeJRI = "TopicConnectionFactory"; //default J2EE-RIString no...
Conexões ●   Encapsulam uma conexão virtual com o     provedor JMS     –   Suportam multiplas sessões (threads) ●   Uma ve...
Sessões    ●   Contexto onde se produz e se consome        mensagens        –   Criam produtores, consumidores e mensagens...
Produtores de mensagens    ●   Objeto criado pela sessão e usado para enviar mensagens para        um destino         –   ...
Consumidores de mensagens    ●   Objeto criado pela sessão e usado para receber mensagens         –   QueueReceiver: domín...
MessageListener  ●   Event handler que detecta o recebimento de mensagens  ●   Para usar, implemente MessageListener e seu...
MessageListener●   Para que objeto seja notificado, é preciso    registrá-lo em um QueueReceiver ou    TopicSubscriber    ...
Seis tipos de mensagens●   Message - Mensagem genérica sem corpo (contendo apenas    cabeçalho e possíveis propriedades)● ...
Criação de Mensagem    ●    Para cada tipo de mensagem, Session fornece método create():         createMessage(), createTe...
JAAS
Assuntos●   API do JAAS●   Conceito de autenticação e autorização●   O Login Module●   Exemplo●   O JAAS no Servidor de ap...
JAAS●   Java Authentication and Authorization Service●   Implementação Java do PAM (Pluggable Authentication Module)
Arquitetura do JAAS
APIS do JAAS●   Classes Comuns     –   Subject, Principal, Credential●   Classes e interfaces de autenticação     –   Logi...
Subject●   Para autorizar acesso a um recurso, as aplicações primeiramente    devem identificar a origem da requisição●   ...
Principals●   Principals são associados a um Subject quando são autenticados    com sucesso.●   Representam a identidade d...
Credentials●   São atributos de segurança que são plugáveis ao Subject●   Qualquer classe Java pode ser usada como uma Cre...
Classes de Autênticação●   LoginContext●   LoginModule●   CallBack●   CallBackHandler
LoginContext●   Contexto (Senha do cartão e senha do    bankline)●   Consulta uma configuração para determinar    quais Lo...
LoginModule    ●   É a interface (contrato) que dá ao desenvolvedor a possibilidade        de implementar diferentes mecan...
LoginModule●   Ciclo de Vida    –   void initialize(Subject subject, CallbackHandler callbackHandler, Map        sharedSta...
CallbackHandler●   Classe Responsável por receber os CallBacks e processa-los●   É quem faz a comunicação com o Usuário●  ...
Callback   ●   A Interface Callback possui várias implementações   ●   Cada implementação é responsável por obter uma info...
Revendo Arquitetura do JAAS
Classes de Autorização●   As classes de autorização não serão vistas●   Autorização em ambiente corporativo deve    ser fe...
Pegando Autenticação na WEB
Formulário de Autenticação<html>  <head>    <title>Jaas - Testes</title>  </head>  <body>    <center><h2>Jaas Login</h2></...
Resgatando informações do JAAS HttpServletRequest.getUserPrincipal(); // retorna o User HttpServletRequest.isUserInRole("A...
JCA
Assuntos●   EAI●   Resource Adapter Overview●   Contratos●   Interfaces●   Ciclo de Vida●   Deployment descriptor●   Códig...
EIS●   Enterprise Information Systems (EIS)●   Informações espalhadas em Banco de Dados,    ERPs, Mainframe, etc●   Mesmo ...
JCA●   J2EE Connector Architecture (JCA) define    uma arquitetura padrão para conectar    aplicações J2EE a sistemas hete...
O que são Resource Adapters ?●   Camada de conexão entre aplicações    corporativas ou servidores de aplicação e o    EIS●...
Exemplos de Resource Adapters●   Um driver JDBC que se conecta a um Banco    de Dados●   Um Resource Adapter que se conect...
Contratos JCA●   Contrato entre o cliente e o Resource Adapter●   Contratos de Sistema    –   Pool de Conexões    –   Tran...
Contratos de Sistema
Interfaces JCA●   ConnectionFactory: Repositório de conexões.    Implementado pelo resource adapter.●   ConnectionManager:...
Ciclo de vida do JCA●   Cliente faz lookup de um CF via JNDI●   Cliente chama método getConnection no CF●   CF repassa a r...
Ciclo de Vida do JCA
●   ra.xml       Deployment descriptor●   Informações genéricas do adaptador     –   Nome     –   Tipo do EIS     –   Nome...
Exemplo de código JCA//ConnectionFactory interface javax.sql.DataSource;//Connection Interface java.sql.ConnectionContext ...
Exemplo para “meu” JCA//ConnectionFactory interface com.digitel.SomeConnectionFactory;//Connection Interface com.digitel.M...
JTA
Assuntos●   Transação●   Transação distribuída (XA)●   BMT, CMT e UserTransaction●   Políticas para transações CMT●   Dest...
Motivação para o uso de transações ●   Operações Atômicas.     –   Exemplo: aplicação bancária. ●   Falha na rede. ●   Ace...
Benefícios do uso de transações●   Uma transação é um conjunto de operações que executam de    forma atômica.●   Uma trans...
Transações são Ácidas!!!●   ACID - características essenciais : Atômica, Consistente, Isolada e Durável●   Atômica     –  ...
Modelos Transacionais●   Flat Transactions●   Nested Transactions
Flat Transactions●   Modelo commit/rollback.
Nested Transactions●   Transações aninhadas podem ser vistas como uma árvore,    permitindo inserir grupos de operações at...
Transações distribuídas●   Problema: e se conta1 e conta2 pertencerem a 2 bancos    diferentes?●   Solução: transações dis...
JTA●   Abreviação para Java Transaction API●   Especificação de Interfaces para o sistema de    transação●   Permite demar...
Usando o JTA●   Quem pode usar o JTA?    –   Código cliente    –   EJB (de duas maneiras)         ●   Declarativa         ...
Interface UserTransaction      Método                               Descrição                              Inicia uma nova...
JTA com EJB - BMT●   Bean Managed Transaction●   A API JTA é utilizada no controle    programático das transações.    –   ...
Transações no EJBpublic void withdrawCash(double amount) {         UserTransaction ut = sessionCtx.getUserTransaction();  ...
Transações iniciadas pelo Cliente●   O cliente pode iniciar transações usando as APIs JDBC e JMS●   Cliente pode ser stand...
Transações declarativas - CMT●   Container Managed Transaction●   Controle de transações totalmente gerenciado pelo contai...
Propagação de transação●   Facilmente resolvida com BMT●   E no CMT ?
Políticas Transacionais●   Define como a transação irá reagir quando o    seu método for chamado por um cliente    dentro ...
Required●   Indica que o método tem que ser chamado    dentro do escopo de uma transação
Supports●   Indica que o método suporta transações
RequiresNew●   Indica que uma nova transação, iniciada no    escopo do bean, é sempre criada
NotSupported●   Indica que o método não suporta transações
Mandatory●   Indica que o método só pode ser chamado no    escopo de uma transação do cliente
Never●   Indica que o método nunca pode ser    chamado no escopo de uma transação    –   Se o cliente que chama o método f...
Destino de uma transação●   Apenas exceções do sistema (Runtime, Remote, EJBException)    provocam automaticamente o rollb...
Qual estilo de demarcação usar?●   Vantagens da demarcação explícita (BMT)     –   Maior controle: é possível extrapolar o...
Problemas de falta de isolamento●   Dirty read     –   É o mais grave dos problemas de isolamento. Ocorre quanto         u...
Niveis de isolamento●   Read Uncommitted:    –   Não oferece garantia de isolamento (aceita dirty        reads - cliente p...
Níveis de isolamento●   Repeatable Read    –   Bloqueia o acesso aos dados utilizados durante a        consulta impedindo ...
Como definir o nível de isolamento●   Use as ferramentas do seu servidor ou banco de dados     –   Não há como especificar...
Hibernate
Assuntos●   Conceitos de ORM●   Bootstraping e configuração●   Mapeamento via XML●   Operações da Session●   Queries e HQL...
Hibernate Uma solução não invasiva para persistência de dados em  aplicações Java    Não é preciso aderir a padrões de d...
ORM Object-Relational Mapping    Mapeamento Objeto-Relacional A solução mais bem-sucedida de persistência para objetos...
Banco de Dados relacionais   Sistemas de gerenciamento de bancos de dados relacionais têm interfaces    de programação ba...
Como funciona o ORM Classes são mapeadas em tabelas (schemas) Instâncias (objetos) são (automaticamente) mapeados em reg...
Incompatibilidade do Paradigma Há vários pontos onde o modelo relacional é  incompatível com o modelo de objetos   Granu...
Exemplo simples O exemplo abaixo não apresenta problemas de  descasamento de paradigma: é simples   User: representa o u...
Classes e Tabelas   Neste exemplo, o descasamento entre o paradigma    objeto e relacional não aparecepublic class User {...
Hibernate●   Voltando ao hibernate...●   Hello World Esta aplicação simples consiste de     uma classe     um arquivo d...
O Objetopackage hello;public class Message {            private Long id;            private String text;            privat...
Nada mais é que um simples              objeto... Possui:    Identificador da mensagem (id),    Texto da mensagem (text...
Arquitetura do Hibernate          • O Hibernate persiste objetos java comuns          (POJO)          • Usa reflexão para ...
Interfaces do Hibernate Cinco interfaces fundamentais são usadas em quase qualquer aplicação Servem para armazenar, remo...
Session Principal interface usada em aplicações  Hibernate   Todas as operações explícitas de persistência são    realiz...
SessionFactory Uma aplicação obtém uma Session a partir de  uma SessionFactory   Objeto pesado; lento para inicializar e...
Configuration É o ponto de partida para iniciar o Hibernate Inicializado com propriedades de configuração  do sistema  ...
Transaction Abstração da implementação de transações  usada no código   A implementação real pode ser uma transação    J...
Query e Criteria Permite a realização de consultas ao banco Consultas Query são escritas em HQL (Hibernate Query  Langua...
3 passos para usar o Hibernate   1) Primeiro é preciso obter um objeto de sessão Session.     Session session = ...;     ...
HBM - Mapeamento As informações sobre o mapeamento entre a tabela e a classe Message ficam em um arquivo  XML   • Guarde-...
Manipulação do Objeto Leitura de uma mensagem específica   Message message = (Message) session.load(Message.class, new Lo...
Propriedades                            Propriedades para Conexões JDBC    ●    hibernate.connection.driver_class = org.po...
Configuração via XMLpackage util;import org.hibernate.*;import org.hibernate.cfg.*;public class HibernateUtil {    private...
Configuração programáticaConfiguration cfg = new Configuration()   .addClass(org.hibernate.auction.Item.class)   .addClass...
Persistindo Objetos       Session session =HibernateUtil.getSessionFactory().getCurrentSession();        session.beginTran...
Operações da SessionDomesticCat cat = (DomesticCat) sess.load( Cat.class, new Long(69) );cat.setName("PK");sess.flush(); /...
Carregando objetos persistidos   ●   Via load long id = 1234; DomesticCat pk = (DomesticCat) sess.load( DomesticCat.class,...
Query – Parâmetros//Parâmetro nomeado (preferido)Query q = sess.createQuery("from DomesticCat cat where cat.name = :name")...
Query - PaginaçãoString hql = "from DomesticCat cat";Query q = sess.createQuery(hql);q.setFirstResult(20);q.setMaxResults(...
CriteriaCriteria crit = sess.createCriteria(Cat.class);crit.setMaxResults(50);List cats = crit.list();    List cats = sess...
JPA
Assuntos●   Anotações●   Facilidades●   Bootstraping J2SE e J2EE●   EntityManager●   JPQL
JPA●   JPA (Java Persistence API) é a especificação padrão para o    gerenciamento de persistência e mapeamento objeto rel...
Provedor JPA●   Existem diversas implementações de diversos    fabricantes●   Oracle Toplink●   Hibernate EntityManager●  ...
Entidade●   Principal conceito do JPA●   É um objeto que pode ser persistido no Banco    de Dados●   Nada mais é que um PO...
Ciclo de vida da Entidade●   Objetos podem existir sem o Banco de Dados●   Entra em cena o estado do objeto
Como é realizado o mapeamento ?●   Anotações são “metadados” das classes       –   @Entity       –   @Table(“tabela”)     ...
Como funciona o EntityManager
Criando o EntityManager
Exemplo Simples – Criando uma          Entidade    import javax.persistence.*;    @Entity    @Table (name=”aluno”)    publ...
Persistence.xml<persistence>         <persistence-unit name="exemplo" transaction-type="RESOURCE_LOCAL">                <p...
public class Principal {   Testando          public static void main(String[] args){                //Cria objeto que gere...
Facilidades com EJB3●    JPA - Sempre é preciso ter uma transação ativa●    EJB é automático (Required)●    EntityManager ...
Relacionamentos●   @OneToMany     –   Pessoa tem vários telefones     –   List<Telefone> telefones = new ArrayList<Telefon...
Queries●   Não existe Criteria – previsto para JPA 2.0●   JPQL – Java Persistence Query Language●   Um único método:    – ...
Exemplos de Queriesfinal List<Pessoa> list = em.createQuery("fromPessoa where p.nome = ?1")        .setParameter(1, "Rafae...
Apostilava Java EE 5 - 2007
Apostilava Java EE 5 - 2007
Apostilava Java EE 5 - 2007
Apostilava Java EE 5 - 2007
Apostilava Java EE 5 - 2007
Apostilava Java EE 5 - 2007
Apostilava Java EE 5 - 2007
Apostilava Java EE 5 - 2007
Apostilava Java EE 5 - 2007
Apostilava Java EE 5 - 2007
Apostilava Java EE 5 - 2007
Apostilava Java EE 5 - 2007
Apostilava Java EE 5 - 2007
Apostilava Java EE 5 - 2007
Apostilava Java EE 5 - 2007
Apostilava Java EE 5 - 2007
Apostilava Java EE 5 - 2007
Apostilava Java EE 5 - 2007
Apostilava Java EE 5 - 2007
Apostilava Java EE 5 - 2007
Apostilava Java EE 5 - 2007
Apostilava Java EE 5 - 2007
Apostilava Java EE 5 - 2007
Apostilava Java EE 5 - 2007
Apostilava Java EE 5 - 2007
Apostilava Java EE 5 - 2007
Apostilava Java EE 5 - 2007
Apostilava Java EE 5 - 2007
Apostilava Java EE 5 - 2007
Apostilava Java EE 5 - 2007
Apostilava Java EE 5 - 2007
Apostilava Java EE 5 - 2007
Apostilava Java EE 5 - 2007
Apostilava Java EE 5 - 2007
Apostilava Java EE 5 - 2007
Apostilava Java EE 5 - 2007
Apostilava Java EE 5 - 2007
Apostilava Java EE 5 - 2007
Apostilava Java EE 5 - 2007
Apostilava Java EE 5 - 2007
Apostilava Java EE 5 - 2007
Apostilava Java EE 5 - 2007
Apostilava Java EE 5 - 2007
Apostilava Java EE 5 - 2007
Apostilava Java EE 5 - 2007
Apostilava Java EE 5 - 2007
Apostilava Java EE 5 - 2007
Apostilava Java EE 5 - 2007
Apostilava Java EE 5 - 2007
Apostilava Java EE 5 - 2007
Apostilava Java EE 5 - 2007
Apostilava Java EE 5 - 2007
Apostilava Java EE 5 - 2007
Apostilava Java EE 5 - 2007
Apostilava Java EE 5 - 2007
Apostilava Java EE 5 - 2007
Apostilava Java EE 5 - 2007
Apostilava Java EE 5 - 2007
Apostilava Java EE 5 - 2007
Apostilava Java EE 5 - 2007
Apostilava Java EE 5 - 2007
Apostilava Java EE 5 - 2007
Apostilava Java EE 5 - 2007
Apostilava Java EE 5 - 2007
Apostilava Java EE 5 - 2007
Apostilava Java EE 5 - 2007
Apostilava Java EE 5 - 2007
Apostilava Java EE 5 - 2007
Apostilava Java EE 5 - 2007
Apostilava Java EE 5 - 2007
Apostilava Java EE 5 - 2007
Apostilava Java EE 5 - 2007
Apostilava Java EE 5 - 2007
Apostilava Java EE 5 - 2007
Apostilava Java EE 5 - 2007
Apostilava Java EE 5 - 2007
Apostilava Java EE 5 - 2007
Apostilava Java EE 5 - 2007
Apostilava Java EE 5 - 2007
Apostilava Java EE 5 - 2007
Apostilava Java EE 5 - 2007
Apostilava Java EE 5 - 2007
Apostilava Java EE 5 - 2007
Apostilava Java EE 5 - 2007
Apostilava Java EE 5 - 2007
Apostilava Java EE 5 - 2007
Apostilava Java EE 5 - 2007
Apostilava Java EE 5 - 2007
Apostilava Java EE 5 - 2007
Apostilava Java EE 5 - 2007
Apostilava Java EE 5 - 2007
Apostilava Java EE 5 - 2007
Apostilava Java EE 5 - 2007
Apostilava Java EE 5 - 2007
Apostilava Java EE 5 - 2007
Apostilava Java EE 5 - 2007
Apostilava Java EE 5 - 2007
Apostilava Java EE 5 - 2007
Apostilava Java EE 5 - 2007
Apostilava Java EE 5 - 2007
Apostilava Java EE 5 - 2007
Apostilava Java EE 5 - 2007
Apostilava Java EE 5 - 2007
Apostilava Java EE 5 - 2007
Apostilava Java EE 5 - 2007
Apostilava Java EE 5 - 2007
Apostilava Java EE 5 - 2007
Apostilava Java EE 5 - 2007
Apostilava Java EE 5 - 2007
Apostilava Java EE 5 - 2007
Apostilava Java EE 5 - 2007
Apostilava Java EE 5 - 2007
Apostilava Java EE 5 - 2007
Apostilava Java EE 5 - 2007
Apostilava Java EE 5 - 2007
Apostilava Java EE 5 - 2007
Apostilava Java EE 5 - 2007
Apostilava Java EE 5 - 2007
Apostilava Java EE 5 - 2007
Apostilava Java EE 5 - 2007
Apostilava Java EE 5 - 2007
Apostilava Java EE 5 - 2007
Apostilava Java EE 5 - 2007
Apostilava Java EE 5 - 2007
Apostilava Java EE 5 - 2007
Apostilava Java EE 5 - 2007
Apostilava Java EE 5 - 2007
Apostilava Java EE 5 - 2007
Apostilava Java EE 5 - 2007
Apostilava Java EE 5 - 2007
Apostilava Java EE 5 - 2007
Apostilava Java EE 5 - 2007
Apostilava Java EE 5 - 2007
Apostilava Java EE 5 - 2007
Apostilava Java EE 5 - 2007
Apostilava Java EE 5 - 2007
Apostilava Java EE 5 - 2007
Apostilava Java EE 5 - 2007
Apostilava Java EE 5 - 2007
Apostilava Java EE 5 - 2007
Apostilava Java EE 5 - 2007
Apostilava Java EE 5 - 2007
Apostilava Java EE 5 - 2007
Apostilava Java EE 5 - 2007
Apostilava Java EE 5 - 2007
Apostilava Java EE 5 - 2007
Apostilava Java EE 5 - 2007
Apostilava Java EE 5 - 2007
Apostilava Java EE 5 - 2007
Apostilava Java EE 5 - 2007
Apostilava Java EE 5 - 2007
Apostilava Java EE 5 - 2007
Apostilava Java EE 5 - 2007
Apostilava Java EE 5 - 2007
Upcoming SlideShare
Loading in...5
×

Apostilava Java EE 5 - 2007

2,339

Published on

Apostila de 2007 com diversas tecnologias da Spec Java EE 5

Published in: Technology
0 Comments
1 Like
Statistics
Notes
  • Be the first to comment

No Downloads
Views
Total Views
2,339
On Slideshare
0
From Embeds
0
Number of Embeds
0
Actions
Shares
0
Downloads
69
Comments
0
Likes
1
Embeds 0
No embeds

No notes for slide

Apostilava Java EE 5 - 2007

  1. 1. Tecnologias paraDesenvolvimento de Software
  2. 2. Licença Esta obra está licenciada sob uma Licença Creative Commonshttp://creativecommons.org/licenses/by-nc-sa/2.0/br/
  3. 3. Instrutor● Rafael Benevides● Trabalha com Java desde 2001● Possui as certificações Java: SCJA, SCJP, SCWCD, SCBCD e SCEA.● E não Java: SAP Netweaver e ITIL● Atualmente desenvolve aplicações para o Governo Federal usando as tecnologias que serão apresentadas
  4. 4. Objetivo● Visão geral das diversas tecnologias para desenvolvimento de software corporativo
  5. 5. Agenda● 31/07 – Servlets, JSP e JSF● 01/08 – JNDI, JMS, JAAS, JCA e JTA● 02/08 – Hibernate e JPA● Livres por alguns dias ;)● 07/08 – JBoss AS, EJB2.1, EJB3 e Webservices● 08/08 – Maven, JMX, Spring e JWS● 09/09 – JBoss Seam
  6. 6. Apresentação da equipe● Seu nome● Atividade que executa● Experiência– Orientação a objetos– Programação Java– Modelagem/Projeto de Classes Expectativas sobre o curso
  7. 7. JCP e as Especificações Java● O que é uma especificação?● Como nascem as especificações ?● JCP - Java Community Proccess● Quem participa: Apache, BEA, CA, Ebay, Eclipse, Google, HP, IBM, LG, Mitsubishi, Motorola, Nokia, Novell, Oracle, Panasonic, Philips, Red Hat, SAP, Siemens, Sony,● A própria Sun● E também: faculdades, comunidades (Soujava, etc) e pessoas
  8. 8. Programação por contratos● Interoperabilidade ?
  9. 9. Contrato entre componentes● Interoperabilidade só é atingida com: ● Padronização
  10. 10. Uma interface é um contrato entre partes
  11. 11. Interface não é implementação ≠
  12. 12. Interfaces● Elementos legais – Contrato – Contratado – Contratante ● Quem ● Quem usa a ● Interface implementa a interface interface
  13. 13. Interfaces
  14. 14. Uma Interface com várias implementações
  15. 15. Interfaces Java ● Javapublic interface DataAccesLayer { public String [] read(int recNo); public void update(int recNo, String [] data); public void delete(int recNo);}
  16. 16. Implementação da Interface ● Javapublic class ArquivoBinario implements DataAccessLayer { public String [] read(int recNo) { //Codigo.... } public void update(int recNo, String[] data) { //Codigo.... } public void delete(int recNo) { //Codigo.... }}
  17. 17. Frameworks● Exemplo – Auto atendimento do BRB – Auto atendimento do BB – Auto atendimento do Banco REAL
  18. 18. Frameworks● Exemplo – Auto atendimento do BRB – Auto atendimento do BB – Auto atendimento do Banco REAL – Auto atendimento genérico
  19. 19. Framework genérico● Aplicativo genérico – Auto atendimento bancário – Framework de auto atendimento bancário
  20. 20. Frameworks● Esqueleto de uma aplicação● Extensível● Parametrizável● Exemplos: Applet, Servlet, MIDlet, EJB, etc
  21. 21. Applet
  22. 22. Servlet
  23. 23. Midlet
  24. 24. EJB 2.1 – Session Bean
  25. 25. Servlets
  26. 26. Assuntos● Servlets e o Web Container● Escrevendo texto● Escrevendo binário● SendError e sendRedirect● Parametros● Contextos● Sessão● Servlet Config● Mapeamento dos Servlets● Filtros
  27. 27. Como nasceu o servlet● Era uma vez o CGI...● Mas o CGI não suporta Threads● O CGI é dependente de plataforma● E não escala!● Mesmo assim as pessoas querem desenvolver para Web● Assim...
  28. 28. Nasceu o Servlet● Foi pensado para aplicações do tipo Requisição e Resposta (Request e Response)● Precisa de um Container● Para aplicações Web, foi definido classes específicas para lidar com HTTP.
  29. 29. Vantagem do Servlet sobre CGI● Eficiente: Nova Thread em vez de um novo Processo● Conveniente: É Java!!! Não é necessário aprender Perl ou outras linguagens● Poderoso: De novo, é Java e possui todos seus benefícios, além do benefício do Contêiner● Portável: – Entre Sistemas Operacionais - É Java – Servidores: Faz parte de uma JSR● É barato: Varias opções livres, incluindo o famoso e poderoso Apache.
  30. 30. Ciclo de vida - Métodos● Interface Servlet possui 3 métodos principais: – init() – service() – destroy()● Mais métodos auxiliares: – getServletConfig() – getServletInfo() – GetServletContext() – etc
  31. 31. Método service()● A classe HttpServlet implementa o service() para tratar uma requisição HTTP em um dos métodos específicos: – doGet() – doHead() – doDelete() – doOptions() – doPost() – doTrace()
  32. 32. Ciclo de vida de um Servlet
  33. 33. Estrutura básica de um Servletpublic class AlgumServlet extends HttpServlet { public void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException { Use o “request para ler os cabeçalhos-HTTP (ex.: cookies) e dados de formulários (ex.: dados preenchidos pelo usuários e enviados) Use o “response” para especificar respostas HTTP (ex.: especificar tipo de conteúdo, criar cookies, etc) PrintWriter out = response.getWriter(); // Use "out" para enviar conteúdo escrito (Writer) para o cliente }}
  34. 34. Hello World em Servletpublic class HelloWorld extends HttpServlet { public void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException { PrintWriter out = response.getWriter(); out.println("Hello World"); }}
  35. 35. Servlets – Conteúdo bináriopublic class ImageServlet extends HttpServlet { public void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException { response.setContentType("image/jpeg"); File file = new File("C:/algumaImagen.gif"); // Abrir os Streams FileInputStream in = new FileInputStream(file); OutputStream out = response.getOutputStream(); // Copiar do Arquivo para o Response byte[] buf = new byte[1024]; int count = 0; while ((count = in.read(buf)) >= 0) { out.write(buf, 0, count); } in.close(); out.close(); }}
  36. 36. Servlets e Http Response code response.sendError(HttpServletResponse.SC_NOT_FOUND) CódigoTipo 1XX Informação 2XX Sucesso 3XX Redirecionamento 4XX Erro Cliente 5XX Erro ServidorMnemonic Code MessageSC_OK 200 OKSC_NO_CONTENT 204 No ContentSC_MOVED_PERMANENTLY 301 Moved PermanentlySC_MOVED_ TEMPORARILY 302 Moved TemporarilySC_ UNAUTHORIZED 401 UnauthorizedSC_NOT_FOUND 404 Not FoundSC_SERVICE_UNAVAILABLE 503 Service Unavailable
  37. 37. Redirect vs Request DispatcherResquestDispatcher rd = request.getResquestDispatcher("Servlet2");rd.forward(request, response); response.sendRedirect(“Servlet2);
  38. 38. Lendo Parâmetrospublic class LerParametros extends HttpServlet { public void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException { response.setContentType("text/html"); PrintWriter out = response.getWriter(); out.println("<BODY>n" + "<UL>n"+ " <LI>param1: " + request.getParameter("param1") + "n"+ " <LI>param2: " + request.getParameter("param2") + "n"+ " <LI>param3: " + request.getParameter("param3") + "n" + "</UL>n" + "</BODY></HTML>"); }}
  39. 39. Lendo Parâmetros
  40. 40. Lendo Atributos● Como o HTTP não mantém estado de sessão, são as aplicações Web que precisam cuidar de mantê-lo quando necessário● Atributos != parâmetros● Parâmetros estão na URL e Atributos estão na container● Atributos podem estar em um dos 3 contextos: – Aplicação – javax.servlet.ServletContext – Session – javax.servlet.http.HttpSession – Request – javax.servlet.HttpServletRequest
  41. 41. Lendo atributos da sessão ● Sessões são representados por objetos HttpSession e são obtidas a partir de uma requisição ● Dois métodos podem ser usados – HttpSession session = request.getSession(false); – HttpSession session = request.getSession();Requisição 1String[] vetor = {"um", "dois", "tres"};HttpSession session = request.getSession();session.setAttribute("dados", vetor);Requisição 2HttpSession session = request.getSession();String[] dados = (String[])session.getAttribute("dados");
  42. 42. Configurando um Servlet● javax.servlet.ServletConfig● O ServletConfig pode ser obtido nos métodos: – init(ServletConfig) – getServletConfig()● O método getInitParameter(“senhaBanco”) retorna o valor do web.xml <servlet> <servlet-name>HelloWorld</servlet-name> <servlet-class>com.digitel.servlet.HelloWorld</servlet-class> <init-param> <param-name>senhaBanco</param-name> <param-value>123</param-value> </init-param> </servlet>
  43. 43. Mapeando um Servlet<servlet> <description></description> <display-name>HelloWorld</display-name> <servlet-name>HelloWorld</servlet-name> <servlet-class>com.digitel.servlet.HelloWorld</servlet-class> <init-param> <param-name>senhaBanco</param-name> <param-value>123</param-value> </init-param> </servlet> <servlet-mapping> <servlet-name>HelloWorld</servlet-name> <url-pattern>/HelloWorld</url-pattern> </servlet-mapping><servlet>
  44. 44. Filtros● Um filtro é um componente Web que reside no servidor – Intercepta as requisições e respostas no seu caminho até o servlet e de volta ao cliente – Sua existência é ignorada por ambos. É totalmente transparente tanto para o cliente quanto para o servlet – Suportado desde a versão 2.3 da especificação de Servlets – Filtros permitem tomadas de decisões: Geralmente usados para autêncicação
  45. 45. Criando um Filtro● Implementar a interface Filter● Cadastrar o filtro no web.xml● Sintaxe lembra mapeamento do Servlet<filter> <filter-name>umFiltro</filter-name> <filter-class>com.digetel.HelloFilter</filter-class></filter><filter-mapping> <filter-name>umFiltro</filter-name> <url-pattern>/filtro</url-pattern></filter-mapping>
  46. 46. Filtro simples que substitui um servlet public class HelloFilter implements Filter { public void doFilter(ServletRequest request, ServletResponse response, FilterChain filterChain) throws ServletException, IOException { PrintWriter out = response.getWriter(); out.println("<HTML><HEAD>[etc].."); out.println("</TITLE></HEAD><BODY>"); out.println("<H1>Filter Response</H1>"); out.println("<P>" + texto); out.println("</BODY></HTML>"); out.close(); } public void destroy() {} }
  47. 47. JSP
  48. 48. Assuntos● JSP e Ciclo de vida● Variáveis implícitas● Diretivas (page, taglib, include)● Scriptlets <% %>● Expressão <%= %>● Declaração <%! %>● Comentário <%-- --%>● Objetos implícitos● Taglibs e JSTL● EL
  49. 49. JSP● Um JSP é um servlet durante a execução● Em um servidor que suporta JSP, processamento de JSP passa por uma camada adicional onde a página é transformada (compilada) em um servlet● Um JSP, depois de carregado, é tão veloz quando um servlet● Acesso via URL usa como localizador a própria página● É mais fácil escrever e implantar, mas é mais difícil depurar
  50. 50. Por que JSP ?● Servlets forçam o programador a embutir código HTML dentro de código Java – Desvantagem se a maior parte do que tem que ser gerado é texto ou código HTML estático – Mistura as coisas: programador tem que ser bom Web Designer e se virar sem ferramentas de Web Design HojeServlet.java Date hoje = new Date(); out.println("<body>"); out.println("<p>A data de hoje é "+hoje+".</p>"); out.println("<body>");
  51. 51. JSP● Solução do problema anterior usando templates JSP <body> <p>A data de hoje é <%=new Date() %>.</p> <body> hoje.jsp● Em um servidor que suporta JSP, processamento de JSP passa por uma camada adicional onde a página é transformada (compilada) em um servlet● Acesso via URL usa como localizador a própria página
  52. 52. Criando uma JSP facilmente● Mudar a extensão de um arquivo HTML para .jsp● Colocar o documento em um servidor que suporte JSP● Fazendo isto, a página será transformada em um servlet – A compilação é feita no primeiro acesso – Nos acessos subseqüentes, a requisição é redirecionada ao servlet que foi gerado a partir da página
  53. 53. Criando uma JSP facilmente● Transformado em um JSP, um arquivo HTML pode conter blocos de código (scriptlets): < % ... %> e expressões <%= ... %> que são os elementos mais frequentemente usados <p>Texto repetido: <% for (int i = 0; i < 10; i++) { %> <p>Esta é a linha <%=i %> <% }%>
  54. 54. Sintaxe do JSP● Podem ser usados em documentos de texto (geralmente HTML ou XML)● Todos são interpretados no servidor (jamais chegam ao browser) – diretivas: <%@ ... %> – declarações: <%! ... %> – expressões: <%= ... %> – scriptlets: <% ... %> – comentários: <%-- ... --%> – ações: <jsp:ação ... /> – custom tags: <prefixo:elemento ... />
  55. 55. Diretivas JSP● Contém informações necessárias ao processamento da classe do servlet que gera a página JSP● Sintaxe : <%@ diretiva atrib1 atrib2 ... %>● Principais diretivas: – page: atributos relacionados à página – include: inclui outros arquivos na página – taglib: declara biblioteca de custom tags usada no documentoExemplos:<%@ page import="java.net.*, java.io.*"session="false" errorPage="/erro.jsp" %><%@ include file="navbar.jsp" %>
  56. 56. Declarações● Dão acesso ao corpo da classe do servlet. Permitem a declaração de variáveis e métodos em uma página● Úteis para declarar: – Variáveis e métodos de instância (pertencentes ao servlet) – Variáveis e métodos estáticos (pertencentes à classe do servlet) – Classes internas (estáticas e de instância), blocos static, etc.● Sintaxe: <%! declaração %> Exemplo: <%! public final static String[] meses = {"jan", "fev", "mar", "abr", "mai", "jun"}; public static String getMes() { Calendar cal = new GregorianCalendar(); return meses[cal.get(Calendar.MONTH)]; } %>
  57. 57. Expressões● Expressões: Quando processadas, retornam um valor que é inserido na página no lugar da expressão● Sintaxe: <%= expressão %>● Equivale a out.print(expressão), portanto, não pode terminar em ponto-e-vírgula● Todos os valores resultantes das expressões são convertidos em String antes de serem redirecionados à saída padrão
  58. 58. Scriptlets● Scriptlets: Blocos de código que são executados sempre que uma página JSP é processada● Correspondem a inserção de seqüências de instruções no método _jspService() do servlet gerado● Sintaxe: <% instruções Java; %> <HTML> <BODY> <%     // Este scriptlet declara e inicializa "date"     System.out.println( "Pegando a data do sistema" );     java.util.Date date = new java.util.Date(); %> Hello!  A data/hora agora é <%     out.println( date );     out.println( "<BR>Seu IP é " );     out.println( request.getRemoteHost()); %> </BODY> </HTML>
  59. 59. Objetos implícitos● Objetos do Servlet – page – config● Objetos Contextuais – session – application – pageContext● Entrada e saída – request – response – out● Controle de Exceção – exception
  60. 60. Exemplo de objetos implicitoshttp://servidor/programa.jsp?nome=Fulano&id=5<% String nome = request.getParameter("nome"); String idStr = request.getParameter("id"); int id = Integer.parseInt(idStr);%><p>Bom dia <%=nome %>! (cod: <%=id %>
  61. 61. Taglibs e JSTL ● Designers não se dão bem com scriptlets ● Para isto a JSP suporta TaglibsTaglibs são declaradas no início de cada página<%@taglib uri="http://abc.com/ex" prefix="exemplo"%> ... e usadas em qualquer lugar <exemplo:dataHoje /> produz → Thursday, Agosto 31, 2008 13:13:13 GMT-03
  62. 62. JSTL – Java Standard Tag Library● Esforço de padronização do JCP: JSR-152● Oferece dois recursos: – Conjunto padrão de tags básicos (Core, XML, banco de dados e internacionalização) – Linguagem de expressões do JSP 1.3● Oferece mais controle ao autor de páginas sem necessariamente aumentar a complexidade – Controle sobre dados sem precisar escrever scripts – Estimula a separação da apresentação e lógica – Estimula o investimento em soluções MVC
  63. 63. JSTL – 4 bibliotecas● Core – loops, condições, url, etc – <%@ taglib uri="http://java.sun.com/jstl/ea/core" prefix="c" /> – Exemplo: <c:if test="...">...</c:if>● XML – processamento de XML – <%@ taglib uri="http://java.sun.com/jstl/ea/xml" prefix="x" /> – Exemplo: <x:parse>...</x:parse>● I18n – Internacionalização – <%@ taglib uri="http://java.sun.com/jstl/ea/fmt" prefix="fmt" /> – Exemplo: <fmt:message key="..." />● SQL – Manipulação de Banco de Dados – <%@ taglib uri="http://java.sun.com/jstl/ea/sql" prefix="sql" /> – Exemplo: <sql:update>...</sql:update>
  64. 64. EL – Expression Language● Permite embutir em atributos expressões dentro de delimitadores $ {...}● Em vez de request.getAttribute("nome"):${nome}● Em vez de bean.getPessoa().getNome():${bean.pessoa.nome}● Suporta operadores aritméticos, relacionais e binários: and, or, eq, not eq, not empty, le, ge, lt, le
  65. 65. Principais ações● Suporte à impressão da linguagem expressões <c:out value="${pessoa.nome}" /> – Expressões condicionais<c:if test="${pessoa.idade &gt;= 18}"> <a href="adultos.html">Entrar</a></c:if><c:choose> <c:when test="${dia.hora == 13}"> <c:out value="${mensagemEspecial}" /> </c:when> <c:otherwise> <c:out value="${mensagemPadrao}" /> </c:otherwise></c:choose>
  66. 66. Principais ações ● Iteração <c:forEach items="${pessoas}" var="p" varStatus="s"> <c:out value="${s.count}"/>. <c:out value="${p}"/> </c:forEach>● Operação com Banco de Dados <sql:query dataSource="${dsn}">SELECT...</sql:query> <sql:transaction>, <sql:update>, etc.
  67. 67. JSF
  68. 68. Assuntos● Por quê JSF ?● Managed Beans● Navegação● Tags● Tabela● Conversão e Validação
  69. 69. O que é JSF● Mais que um framework para desenvolver aplicações web de forma ágil, JSF foi incorporado ao especificação J2EE● O que JSF trás de bom? – MVC para aplicações web – "fácil" de usar – Boa demanda do mecado e conseqüentemente dos desenvolvedores
  70. 70. Managed Beans ● São classes simples, não herdam de ninguém nem são obrigados a implementar nenhuma interface ● Possuem nossos famosos getter e setters seguindo a convenção JavaBean<h:inputText id="nome" value="#{meuBean.nome}" size="25" maxlength="125" />Devem ser cadastrados no faces-config.xml<managed-bean> <managed-bean-name>meuBean</managed-bean-name> <managed-bean-class>br.com.digitel.MeuBean</managed-bean-class> <managed-bean-scope>session</managed-bean-scope></managed-bean>
  71. 71. Navegação ● Navegação fácil (faces-config.xml)<navigation-rule> <from-view-id>/greeting.jsp</from-view-id> <navigation-case> <from-outcome>success</from-outcome> <to-view-id>/response.jsp</to-view-id> </navigation-case> <navigation-case> <from-outcome>fail</from-outcome> <to-view-id>/fail.jsp</to-view-id> </navigation-case></navigation-rule>
  72. 72. Tags● Dois tipos:● H (html) e F (faces)<%@ taglib uri="http://java.sun.com/jsf/html" prefix="h" %><%@ taglib uri="http://java.sun.com/jsf/core" prefix="f" %>
  73. 73. Tags HTML● <h:form> - É a declaração de um formulário comum, o detalhe é que ele é declarado aqui sem nenhuma ação, isso vai ser feito mais na frente no botão de submissão● <h:outputText value="Login"/> - Tag que imprime na tela um valor fixo, como o caso acima, mas pode imprimir valores de JavaBeans ou de um arquivo de bundle por exemplo.● <h:inputText id="login" binding="#{cadastroBean.loginComponente}" required="true"/> <h:message for="login"/> - Nessa tag temos uma input comum, o detalhe é que ela está "amarrada" a propriedade que está no meu bean
  74. 74. Tags HTML● <h:inputSecret id="senha" value="#{cadastroBean.senha}" required="true"/> <h:message for="senha"/> - Input como a explicada acima com a entrada escondida● <h:commandButton action="#{cadastroBean.cadastraUsuarioAction}" value="Enviar Dados"/> - Aqui vai acontecer a submissão do formulário, no atributo action diz que ação tomar quando o formulário for submetido
  75. 75. Tags faces● <f:view> - É o nodo inicial, uma espécie de saco que vai guardar todos os componentes, validadores, conversores etc● <f:convertXXXX> - Para usar conversores – Converte entre String e Objetos● <f:validateXXX> - Para usar validadores – Valida se os dados são válidos● <f:facet > - Adiciona um “facet” (ou atributo) para um componente.● <f:seletItem(s) > - Para valores de combos
  76. 76. Tabelas● Usa-se o componente <h:dataTable>● O Backing bean deve retornar um DataModel● Existem algumas implementações de DataModel: ArrayDataModel, ListDataModel, ResultDataModel, ResultSetDataModel, ScalarDataModel
  77. 77. Tabelas<h:dataTable var="usuario" value="#{cadastroBean.usuariosCadastrados}" border="1"> <h:column> <f:facet name="header"> <h:outputText value="Login"/> </f:facet> <h:outputText value="#{usuario.login}" /> <f:facet name="footer"> <h:outputText value="Login"/> </f:facet> </h:column></h:dataTable>
  78. 78. Conversores● JSF tem seus alguns conversores implementados, mas é possível criar seus próprios conversores – BigDecimalConverter – BigIntegerConverter – BooleanConverter – ByteConverter – CharacterConverter – DateTimeConverter – DoubleConverter – FloatConverter – IntegerConverter – LongConverter – NumberConverter – ShortConverter
  79. 79. Conversor não padrão● Implementar a interface Converter● Cadastrar no faces-config.xml● Usar em conjunto com a tag – <f:converter id=”meuConverter” />
  80. 80. Validadores● JSF tem seus alguns validadores implementados, mas é possível criar seus próprios conversores – ValidateLenght – ValidateLongRange – ValidateDoubleRange● Para criar seu próprio validador – Implementar a interface Validator – Cadastrar no faces-config.xml – Usar em conjunto com a tag ● <f:validator id=”meuValidador” />
  81. 81. JNDI
  82. 82. Assuntos● Introdução ao JNDI – Conceitos básicos sobre nomes e diretórios – Classes e pacotes da API JNDI● Operações com nomes – Contexto inicial – Localização (lookup) de objetos – Contextos – Ligações (bindings)● Operações com diretórios – Atributos – Pesquisas● Registro de objetos
  83. 83. Conceitos fundamentais● Conceitos relativos a sistema de nomes – Serviço de nomes – Ligação (binding) – Convenções de nomenclatura – Contextos e subcontextos● Conceitos relativos a sistemas de diretórios – Diretórios e serviços de diretórios – Atributos – Pesquisas e filtros – LDAP
  84. 84. Serviço de Nomes● A principal função de um serviço de nomes é permitir a associação de um nome (ou uma outra representação alternativa mais simples) a recursos computacionais como – endereços de memória, de rede, de serviços – objetos e referências – códigos em geral● Exemplos: – Sistema de arquivos: liga caminho a bloco(s) de memória: c:tempdados.txt → 16A0:0C00 – Sistema DNS: liga nome de domínio a endereço IP: www.digitel.com.br → 200.198.105.35
  85. 85. Ligação ou Binding● É a associação de um nome com um objeto (ou com um localizador do objeto)● Exemplos: – Nome de arquivo no DOS está ligado a um bloco de memória – Nome de máquina na internet está ligado a endereço IP – Nome de objeto em ORB está ligado a uma instância remota do objeto – UmNome → Objeto
  86. 86. Convenções de nomeclatura● Todo sistema de nomes obedece a uma determinada convenção que determina sua sintaxe● Exemplos: – DOS: C:Windows – Linux: /home/rafael/Documentos – DNS: www.digitel.com.br – LDAP: tel=61-133, uf=RS, pais=55
  87. 87. Contextos e subcontextos● Um contexto é um conjunto de ligações nome-objeto● Se o objeto (referência) contido no contexto for também um contexto ele é um subcontexto● Exemplos de contextos e subcontextos:● /usr/bin/java/ → usr é o contexto; bin é subcontexto de usr, ...● www.abc.com.br → br é o contexto, com é subcontexto de br, ...
  88. 88. Serviço de diretórios● Um serviço de diretório é oferece operações para criar, remover, modificar e principalmente pesquisar atributos associados a objetos em um diretório● Diretório = tipo de banco de dados acessível via rede● Projetado para ser mais eficientes na recuperação de dados que na gravação ou alteração● Atualizações são simples, sem transações e envolvendo pequena quantidade de dados
  89. 89. Atributos● Descrevem objeto associado a um objeto de diretório● Um atributo possui – Um identificador de atributo: permite que o atributo seja localizado e utilizado – Conjunto de valores de atributo: as informações (dados) que estão associadas com o atributo – Um tipo: restringe os dados que um atributo pode receber● Atributos fazem parte do contexto do objeto
  90. 90. LDAP● Lightweight Directory Access Protocol● Protocolo leve para acesso a diretórios (padrão aberto)● Armazena objetos em uma árvore● Define vários atributos, tipos e sintaxes padrão baseados no X.500● Extensível (pode-se criar novos tipos, atributos, etc.)● Diretórios baseados em LDAP suportam: – qualquer tipo de dados – várias formas de segurança (criptografia, autenticação, integridade)
  91. 91. LDAP
  92. 92. JNDI● Java Naming and Directory Interface é uma ponte sobre os diversos serviços de nomes e diretórios diferentes● Vantagens – Só é preciso aprender uma única API para acessar vários tipos de informação de serviços de diretório – Isola a aplicação dos detalhes específicos do protocolo – Pode ser usada para ler objetos Java (serializados) que estejam armazenados em um diretório
  93. 93. Arquitetura JNDI
  94. 94. Uso do JNDI● Para usar JNDI é preciso ter – As classes e interfaces do JNDI (pacotes javax.naming.*) – Pelo menos um provedor de serviços JNDI (driver)● O Java 2 SDK inclui provedores de serviço (SPs) para – LDAP - Lightweight Directory Access Protocol – CORBA - Common ORB Architecture e COS name service – Java RMI Registry
  95. 95. Exemplo 1 – Sistemas de nomes1:import javax.naming.Context;2:import javax.naming.InitialContext;3:import javax.naming.NamingException;4:import java.util.Properties;5:6:class Lookup {7: public static void main(String[] args) {8: Properties env = System.getProperties();9: env.put(Context.INITIAL_CONTEXT_FACTORY,10: "com.sun.jndi.fscontext.RefFSContextFactory");11: try {12: Context ctx = new InitialContext(env);13: Object obj = ctx.lookup(args[0]);14: System.out.println(args[0]+" esta ligado a: " + obj);15: ctx.close();16: } catch (NamingException e) {17: System.err.println("Não achei "+args[0]+": "+e);18: }19: }20:}
  96. 96. Contexto inicial Precisa ser obtido antes de qualquer operação. Passos: ● 1: selecionar o provedor de serviços Properties env = new Properties(); env.put(Context.INITIAL_CONTEXT_FACTORY, "classe.do.ProvedorDeServicos");● 2: Configurar o acesso ao serviço env.put(Context.PROVIDER_URL, "ldap://xyz.com:389"); env.put(Context.OUTRA_PROPRIEDADE, "valor"); (...)● 3: criar um objeto para representar o contexto Context ctx = new InitialContext(env);
  97. 97. Recuperação de objeto (lookup)● Para obter a referência para um objeto de um contexto usa-se o método lookup()● Para usar o objeto retornado é preciso conhecer o seu tipo e fazer o cast (ou narrow, se objeto remoto) para promover a referência● Se o objeto for um contexto, lookup() age como um método para mudar de contexto (como o chdir, em Unix)
  98. 98. Exemplo de lookup● O método lookup() usando com o provedor de serviço fscontext retorna um java.io.File pelo nome de arquivo env.put(Context.INITIAL_CONTEXT_FACTORY, "com.sun.jndi.fscontext.RefFSContextFactory"); env.put(Context.PROVIDER_URL, "file:/cap02/lab/filesys"); Context ctx = new InitialContext(env); File f = (File)ctx.lookup("report.txt");
  99. 99. Modificando o Bind ● Substituindo ligações ● Adicionando ligações Fruit fruit = new Fruit("lemon"); ctx.rebind("favorite", fruit);Fruit fruit = new Fruit("orange");ctx.bind("favorite", fruit);● Removendo ● Renomeando ligações objetos ctx.unbind("favorite"); ctx.rename("report.txt", "old_report.txt");● Criando novos contextos ● Destruindo contextos Context result = ctx.destroySubcontext("new"); ctx.createSubcontext("new");
  100. 100. Conclusões● Sistemas de nomes e diretórios abstraem conceitos específicos a um domínio de problema – Maior facilidade do uso de recursos – Maior desacoplamento● JNDI fornece uma interface genérica para diversos sistemas de nomes e diretórios diferentes – Permite que recursos compartilhados, localizados através de diferentes sistemas de nomes e diretórios possam ser armazenados e localizados usando uma interface uniforme – A mesma interface pode ser usada para interagir com sistemas de arquivos, LDAP, registro do Windows, DNS, ORBs, RMI Registry e outros repositórios de objetos, etc.
  101. 101. JMS
  102. 102. Assuntos● Mensagem assíncrona● Point-to-Point (Queue)● Publish-Subscriber (Topic)● Modelo de programação● Exemplos
  103. 103. O que é Messaging● Método de comunicação entre componentes ou aplicações● Arquitetura peer-to-peer com serviço centralizado para repasse de mensagens recebidas e enviadas● Clientes e servidores enviam e recebem mensagens para canais administrados por serviço central de mensagens (MOM)
  104. 104. Messaging vs RPC vs e-Mail● Messaging – Mensagens são representadas como eventos (que causam numero limitado de ações por parte do MOM) – Interface genérica (pode ser reutilizada para aplicações diferentes) – Arquitetura centralizada (tudo passa pelo MOM) – Serviços de diretórios localizam canais de comunicação (destinos)
  105. 105. Messaging vs RPC vs e-Mail● RMI/RPC (Corba, Java RMI, etc.) – Mensagens são representadas como chamadas para métodos remotos (numero ilimitado de ações) – Cada aplicação se comunica através de uma interface definida – Pode ser descentralizado (rede de ORBs ligados por IIOP) – Serviços de diretórios localizam objetos
  106. 106. Messaging vs RPC vs e-Mail
  107. 107. Messaging vs RPC vs e-Mail● E-mail – Uma ou ambas as partes podem ser usuários humanos● Messaging é sempre comunicação 100% B2B
  108. 108. Desvantagens dos MOMs● Camada adicional para repasse de mensagens● Centralização em único ponto introduz risco de falha de todo o sistema caso o serviço de mensagens falhe – Solução: replicação, clustering
  109. 109. Desvantagens genéricas dos MOMs ● Muito genérica: aplicações precisam decifrar as mensagens para que possam operar; esconde a interface de programação remota dentro das mensagens ● Comunicação assíncrona (geralmente): dificulta a criação de aplicações que necessitam de comunicação síncrona. ● Não faz tratamento de representação de dados (data marshalling) - MOM é apenas meio de transporte
  110. 110. Vantagens dos MOMs (1)● Escalabilidade – Para aumentar a capacidade servidora, basta acrescentar mais servidores (não é preciso mexer nos componentes) – Novos clientes podem se conectar para usar mensagens em outras aplicações – Infraestrutura é reutilizada para novas aplicações
  111. 111. Vantagens dos MOMs (2)● Comunicação assíncrona – Componentes podem realizar outras tarefas enquanto não estão ocupados lidando com requisições – Podem sondar o servidor em busca de novas mensagens quando estiverem livres (PTP) – Podem se cadastrar para, quando houver mensagens novas, receber notificação (pub/sub)
  112. 112. Vantagens dos MOMs (3)● Desacoplamento – Maior modularidade, maior reuso (substituibilidade), maior simplicidade, maior robustez (falhas localizadas) – Papéis bem definidos simplificam o desenvolvimento: produtor, consumidor e serviço tem unica interface, independente da aplicação – Servidor de messaging é responsável pela qualidade do serviço (não é preocupação dos componentes)
  113. 113. Vantagens dos MOMs (4)● Flexibilidade – API definida pelo tipo das mensagens (e não por interfaces) – Meio comum é a mensagem: se componentes a entendem, o resto (linguagens, plataformas, etc.) não importa!
  114. 114. E quando usar MOM em vez de RPC● ... ou, quando decidir por acoplamento mais fraco? – Quando a comunicação se baseia mais no formato de mensagens que em interfaces rígidas (componentes não dependem da interface de outros componentes) – Quando a disponibilidade dos componentes é imprevisível, mas sua aplicação precisa rodar mesmo que componentes não estejam todos acessíveis – Quando for preciso suportar comunicação assíncrona: componente pode enviar informações para outro e continuar a operar mesmo sem receber resposta imediataCenário comum em muitas aplicações B2B!
  115. 115. JMS● Interface Java única para unir as MOMs incompatíveis● API que permite que aplicações criem, enviem, recebam e leiam mensagens através de um MOM● API consiste principalmente de interfaces (implementadas pelo fabricante do MOM)● Parte integral da plataforma J2EE (acrescenta possibilidade de comunicação assíncrona a EJBs)
  116. 116. Metas do JMS● Oferecer uma API simples, unificada e compatível com aplicações existentes (não- JMS)● Suportar aplicações heterogêneas em diferentes Sos, plataformas, arquiteturas e linguagens● Suportar mensagens contendo objetos serializados Java e páginas XML
  117. 117. Principais características● Modelo flexível de desenvolvimento baseado em dois domínios: ponto-a-ponto e publish/subscribe● Controle de persistência, tempo de vida, prioridades e durabilidade associados a serviços e mensagens● Suporte à comunicação síncrona e assíncrona● Suporte a transações no envio e recebimento de mensagens● Suportado por todos os servidores de aplicação J2EE (implementam os dois domínios: PTP e pub/sub)
  118. 118. Arquitetura JMS
  119. 119. Domínio PTP-Point-to-Point● Baseado no conceito de filas, remetentes e destinatários● Um para um: cada mensagem é enviada para uma fila específica e é consumida por um destinatário (que pode ou não estar disponível no momento)● Destinatário confirma que a mensagem foi recebida e processada corretamente (acknowledgement)● Filas retém mensagens até que sejam consumidas (ou expirem)
  120. 120. Domínio pub-sub (publica/inscreve)● Baseado em canais (tópicos)● Muitos para muitos: mensagens são enviadas a um canal onde todos os assinantes do canal podem retirá-la● Assinantes recebem notificação
  121. 121. Consumo de mensagens● Sistemas de messaging são sempre assíncronos no sentido de que não há dependência quanto ao tempo de envio e recebimento das mensagens● JMS porém permite um tipo de sincronismo: Pode-se bloquear as operações em um destinatário até que uma determinada mensagem chegue● A especificação JMS, portanto, define que mensagens podem ser consumidas de duas formas: – Síncrona: quando o destinatário envia uma chamada receive() e fica a esperar pelo recebimento de mensagens – Assíncrona: o cliente registra-se como ouvinte de mensagens e é notificado quando elas chegam
  122. 122. Escrevendo aplicações JMS● Obter um destino e uma fábrica de conexões via JNDI● Usar a fábrica para obter uma conexão● Usar a conexão para obter uma ou mais sessões● Usar a sessão para criar uma mensagem● Iniciar a sessão● Com a sessão, pode-se: – Enviar mensagens – Receber mensagens – Cadastrar ouvintes para receber mensagens automaticamente
  123. 123. Escrevendo aplicações JMS
  124. 124. Há dois tipos de destino JMS ● Filas (Queue) – Retêm todas as mensagens que recebem até que sejam retiradas ou expirem – Para cada mensagem enviada, apenas um cliente pode retirá-la Queue fila = (Queue) ctx.lookup("jms/Queue");● Canais (Topic) – Cada canal pode ter vários clientes assinantes – Cada assinante recebe uma cópia das mensagens enviadas – Para receber uma mensagem publicada em um canal, clientes precisam já ser assinantes dele antes do envio. Topic canal = (Topic) ctx.lookup("jms/Topic");
  125. 125. Fábricas de conexão● Antes que se possa – enviar uma mensagem para uma fila, – publicar uma mensagem em um canal, – consumir uma mensagem de uma fila ou – fazer uma assinatura de um canal● é preciso obter uma conexão ao provedor JMS● Isto é feito através de uma fábrica de conexões. Há duas: – TopicConnectionFactory - para conexões no domínio Topic – QueueConnectionFactory - para conexões no domínio Queue
  126. 126. Fábricas de conexão● É preciso conhecer o nome JNDIString nomeJRI = "TopicConnectionFactory"; //default J2EE-RIString nomeJBoss = "ConnectionFactory"; // JbossMQContext ctx = new InitialContext();TopicConnectionFactory factory =(TopicConnectionFactory) ctx.lookup(nomeJBoss);
  127. 127. Conexões ● Encapsulam uma conexão virtual com o provedor JMS – Suportam multiplas sessões (threads) ● Uma vez obtida uma fábrica de conexões, pode-se obter uma conexãoQueueConnection queueCon =queueConnectionFactory.createQueueConnection();TopicConnection topicCon =topicConnectionFactory.createTopicConnection();
  128. 128. Sessões ● Contexto onde se produz e se consome mensagens – Criam produtores, consumidores e mensagens – Processam a execução de ouvintes – Single-threaded – Podem ser configuradas para definir: forma de acknowledgement ,uso ou não de transaçõesTopicSession topicSession =topicCon.createTopicSession(false, Session.AUTO_ACKNOWLEDGE);QueueSession queueSession = queueCon.createQueueSession(true, 0);
  129. 129. Produtores de mensagens ● Objeto criado pela sessão e usado para enviar mensagens para um destino – QueueSender: domínio ponto-a-ponto – TopicPublisher: domínio pub/sub QueueSender sender = queueSession.createSender(fila); TopicPublisher publisher = topicSession.createPublisher(canal);● Uma vez criado o produtor, ele pode ser usado para enviar mensagens sender.send( message ); publisher.publish( message );
  130. 130. Consumidores de mensagens ● Objeto criado pela sessão e usado para receber mensagens – QueueReceiver: domínio ponto-a-ponto – TopicSubscriber: domínio pub/subQueueReceiver receiver = queueSession.createReceiver(fila);TopicSubscriber subscriber = topicSession.createSubscriber(canal);● Depois, pode consumir mensagens de forma síncrona (método é o mesmo para domínios PTP e pub/sub Message queueMsg = receiver.receive(); Message topicMsg = subscriber.receive(1000);● Para consumir mensagens de forma assíncrona é preciso criar um MessageListener
  131. 131. MessageListener ● Event handler que detecta o recebimento de mensagens ● Para usar, implemente MessageListener e seu método onMessage(): ● Método onMessage() não deve deixar escapar exceções (entre try- catch)public class MyListener implements MessageListener { public void onMessage(Message msg) { TextMessage txtMsg = (TextMessage) msg; System.out.println( "Mensagem recebida: " + txtMsg.getText() ) }}
  132. 132. MessageListener● Para que objeto seja notificado, é preciso registrá-lo em um QueueReceiver ou TopicSubscriber subscriber.setMessageListener( new MyListener() );
  133. 133. Seis tipos de mensagens● Message - Mensagem genérica sem corpo (contendo apenas cabeçalho e possíveis propriedades)● TextMessage - Objeto do tipo String (ex: conteúdo XML)● MapMessage - Conjunto de pares nome/valor onde nomes são Strings e valores são tipos primitivos● BytesMessage - Stream de bytes não interpretados● StreamMessage - Seqüência de tipos primitivos Java● ObjectMessage - Objeto Java serializado
  134. 134. Criação de Mensagem ● Para cada tipo de mensagem, Session fornece método create(): createMessage(), createTextMessage(), createBytesMessage(), createObjectMessage(), createMapMessage(), createStreamMessage() TextMessage message = queueSession.createTextMessage(); message.setText(msg_text); // msg_text é String sender.send(message);● Após receber uma mensagem, via receive() ou onMessage(), é preciso fazer o cast para ter acesso aos métodos específicos de cada tipo de mensagem Message m = receiver.receive(); if (m instanceof TextMessage) { TextMessage message = (TextMessage) m; System.out.println("Recebido: " + message.getText()); }
  135. 135. JAAS
  136. 136. Assuntos● API do JAAS● Conceito de autenticação e autorização● O Login Module● Exemplo● O JAAS no Servidor de aplicação● Login Module do fornecedor● Escrevendo seu Login Module.
  137. 137. JAAS● Java Authentication and Authorization Service● Implementação Java do PAM (Pluggable Authentication Module)
  138. 138. Arquitetura do JAAS
  139. 139. APIS do JAAS● Classes Comuns – Subject, Principal, Credential● Classes e interfaces de autenticação – LoginContext, LoginModule, CallbackHandler, Callback● Classes de autorização (J2SE) – Policy, AuthPermission, PrivateCredentialPermission
  140. 140. Subject● Para autorizar acesso a um recurso, as aplicações primeiramente devem identificar a origem da requisição● O termo Subject representa a origem da requisição● Um Subject pode ser uma pessoa ou serviço● Uma vez que o Subject autenticado é populado com vários Principals e(ou) Credentials● Um Subject pode ter vários principals: RG 1234 CPF 111,111,111- 11
  141. 141. Principals● Principals são associados a um Subject quando são autenticados com sucesso.● Representam a identidade do Subject● Devem implementar as interfaces: – java.security.Principal and java.io.Serializable
  142. 142. Credentials● São atributos de segurança que são plugáveis ao Subject● Qualquer classe Java pode ser usada como uma Credential● Exemplo: Senha, Certificado Digital, etc
  143. 143. Classes de Autênticação● LoginContext● LoginModule● CallBack● CallBackHandler
  144. 144. LoginContext● Contexto (Senha do cartão e senha do bankline)● Consulta uma configuração para determinar quais LoginsModules serão usados● Obrigatoriamente precisa de um nome● Cada LoginModule pode ser: – Required, Requisite, Sufficient ou Optional
  145. 145. LoginModule ● É a interface (contrato) que dá ao desenvolvedor a possibilidade de implementar diferentes mecanismos de autenticação ● O CallbackHandler é informado no initialize e deve ser chamado para pegar os usuários e senhaCallback[] callbacks = new Callback[2];callbacks[0] = new NameCallback("Login");callbacks[1] = new PasswordCallback("Senha", false);callbackHandler.handle(callbacks);loginInformado = ((NameCallback) callbacks[0]).getName();char[] tmpPassword = ((PasswordCallback) callbacks[1]).getPassword();
  146. 146. LoginModule● Ciclo de Vida – void initialize(Subject subject, CallbackHandler callbackHandler, Map sharedState, Map options) – boolean login() - Fase 1 – boolean commit() ou boolean abort() - Fase 2 – boolean logout
  147. 147. CallbackHandler● Classe Responsável por receber os CallBacks e processa-los● É quem faz a comunicação com o Usuário● Não precisa ser criado em aplicações corporativos pois será usado o CallBackHandler do servidor
  148. 148. Callback ● A Interface Callback possui várias implementações ● Cada implementação é responsável por obter uma informação específica ● Algumas Implementações: – ChoiceCallback – ConfirmationCallback – LanguageCallback – NameCallback – PasswordCallbackString loginInformado = ((NameCallback) callbacks[0]).getName();char[] tmpPassword = ((PasswordCallback) callbacks[1]).getPassword();
  149. 149. Revendo Arquitetura do JAAS
  150. 150. Classes de Autorização● As classes de autorização não serão vistas● Autorização em ambiente corporativo deve ser feito pelo Container
  151. 151. Pegando Autenticação na WEB
  152. 152. Formulário de Autenticação<html> <head> <title>Jaas - Testes</title> </head> <body> <center><h2>Jaas Login</h2></center> <br /> Por favor, entre com sua senha <br /> <form method="POST" action="j_security_check"> Usuário: <input type="text" name="j_username"/> <br /> Senha: <input type="password" name="j_password"/> <br /> <input type="submit" value="Entrar"/> </form> </body></html>
  153. 153. Resgatando informações do JAAS HttpServletRequest.getUserPrincipal(); // retorna o User HttpServletRequest.isUserInRole("ADM"); // retorna se o usuario possui a role informada User user = (User) HttpServletRequest.getUserPrincipal(); user.getRoles(); // roles do usuario
  154. 154. JCA
  155. 155. Assuntos● EAI● Resource Adapter Overview● Contratos● Interfaces● Ciclo de Vida● Deployment descriptor● Código de exemplo
  156. 156. EIS● Enterprise Information Systems (EIS)● Informações espalhadas em Banco de Dados, ERPs, Mainframe, etc● Mesmo assim a integração é cada vez mais necessária● Cada produto possui conectividade diferenciada● O que fazer ?
  157. 157. JCA● J2EE Connector Architecture (JCA) define uma arquitetura padrão para conectar aplicações J2EE a sistemas heterogêneos● Esta arquitetura pode ser usada para criar Resource Adapters (Adaptadore de Recursos) – Componentes J2EE que implementam JCA para EIS específico.
  158. 158. O que são Resource Adapters ?● Camada de conexão entre aplicações corporativas ou servidores de aplicação e o EIS● Pode ser considerado um “Driver” a nível de sistema para se conectar a um EIS● Específico para um EIS● Também chamado de Connector
  159. 159. Exemplos de Resource Adapters● Um driver JDBC que se conecta a um Banco de Dados● Um Resource Adapter que se conecta a um ERP● Um Resource Adapter que se conecta a um sistema de processamento de transações● Um Resource Adapter que se conecta a um Mainframe
  160. 160. Contratos JCA● Contrato entre o cliente e o Resource Adapter● Contratos de Sistema – Pool de Conexões – Transação – Segurança● Contratos de sistemas são gerenciados pelo Servidor J2EE
  161. 161. Contratos de Sistema
  162. 162. Interfaces JCA● ConnectionFactory: Repositório de conexões. Implementado pelo resource adapter.● ConnectionManager: Implementado pelo servidor de aplicações para gerenciar as conexões.● ManagedConnectionFactory: Implementado pelo resource adapter e usado para decidir a conexão mais apropriada ao cliente.● Connection: Implementado pelo resource adapter, esta é a interface de acesso ao EIS.
  163. 163. Ciclo de vida do JCA● Cliente faz lookup de um CF via JNDI● Cliente chama método getConnection no CF● CF repassa a requisição para o CM● CM repassa a requisição para o MCF● MCF verifica as conexões existentes no pool (qual atende o cliente ?)● Se não existe, uma nova conexão é criada e colocada no pool.● MCF retorna a conexão via CF
  164. 164. Ciclo de Vida do JCA
  165. 165. ● ra.xml Deployment descriptor● Informações genéricas do adaptador – Nome – Tipo do EIS – Nome do Fabricante● Detalhes do ConnectionFactory – Interface do ConnectionFactory – Implementação do ConnectionFactory – Interface da Connection – Implementação da Connection● Propriedades de Configuração – Nome – Tipo – Valor● Informações de Autenticação
  166. 166. Exemplo de código JCA//ConnectionFactory interface javax.sql.DataSource;//Connection Interface java.sql.ConnectionContext ic = new InitialContext();javax.sql.DataSource ds = (javax.resource.DataSource)ic.lookup("myconnfact");java.sql.Connection con = ds.getConnection();con.doSomething();//Finalmente fecha a conexão (volta para o pool)con.close();
  167. 167. Exemplo para “meu” JCA//ConnectionFactory interface com.digitel.SomeConnectionFactory;//Connection Interface com.digitel.MyConnectioncom.digitel.SomeConnectionFactory cf = (com.digitel.SomeConnectionFactory) ic.lookup("myconnfact");com.digitel.MyConnection myCon = cf.getConnection();//Use o objeto Connection para acessar dados usando a API da interface ConnectionmyCon.doSomething();//Finalmente feche a conexão (retorna para o pool)
  168. 168. JTA
  169. 169. Assuntos● Transação● Transação distribuída (XA)● BMT, CMT e UserTransaction● Políticas para transações CMT● Destino de uma Transação● Níveis de isolamento
  170. 170. Motivação para o uso de transações ● Operações Atômicas. – Exemplo: aplicação bancária. ● Falha na rede. ● Acesso/modificação concorrente de dados.
  171. 171. Benefícios do uso de transações● Uma transação é um conjunto de operações que executam de forma atômica.● Uma transação garante que todas as operações serão realizadas ou que nenhuma delas será realizada.● Propriedades ACID – Atomicidade – Consistência – Isolamento – Durabilidade
  172. 172. Transações são Ácidas!!!● ACID - características essenciais : Atômica, Consistente, Isolada e Durável● Atômica – Garante que todas as operações sejam tratadas como uma unica unidade de trabalho. Todas as tarefas de uma unidade transacional devem funcionar sem erros ou todo o processo é revertido.● Consistente – O estado do sistema após uma transação deve manter-se consistente (transações devem englobar processos de negócio completos)● Isolada – Transação deve poder executar sem interferência de outros processos. Isto é possível utilizando sincronização.● Durável – Dados alterados durante a transações devem ser guardados em meio persistente até que a transação complete com sucesso
  173. 173. Modelos Transacionais● Flat Transactions● Nested Transactions
  174. 174. Flat Transactions● Modelo commit/rollback.
  175. 175. Nested Transactions● Transações aninhadas podem ser vistas como uma árvore, permitindo inserir grupos de operações atômicas dentro de outros grupos.
  176. 176. Transações distribuídas● Problema: e se conta1 e conta2 pertencerem a 2 bancos diferentes?● Solução: transações distribuídas – transação T1 no BD do banco1 para sacar conta1 – transação T2 no BD do banco2 para depositar conta2 – coordenador de transações ●garante que ambas falham ou ambas sucedem● Ou ainda: – 1 transação global (TG) – 2 transações locais (TL1 e TL2)
  177. 177. JTA● Abreviação para Java Transaction API● Especificação de Interfaces para o sistema de transação● Permite demarcar transações independente da implementação do coordenador de transação● É controlada obrigatoriamente pelo Servidor de aplicações● Não suporta Nested Transactions
  178. 178. Usando o JTA● Quem pode usar o JTA? – Código cliente – EJB (de duas maneiras) ● Declarativa ● Programática● Exceto pela forma declarativa, a única interface conhecida é: – javax.transaction.UserTransaction
  179. 179. Interface UserTransaction Método Descrição Inicia uma nova transação, que se associa ao thread begin() atual. Executa o protocolo de confirmação de duas fases em uma transação existente associada ao thread atual. commit() Cada gerenciador de recursos tornará suas atualizações duráveis Recupera o status de transação associada a esse getStatus() thread Força uma reversão da transação associada ao thread Rollback() atual Chame-o para forçar a transação atual a reverter. Por setRollbackOnly() fim, forçará a transação a abortar. O tempo limite da transação é o tempo máximo que uma transação pode executar antes de seu aborto.setTransactionTimeout (int) Isso é útil para evitar situações de impasse, em que recursos preciosos são retidos por uma transação que está sendo executada atualmente.
  180. 180. JTA com EJB - BMT● Bean Managed Transaction● A API JTA é utilizada no controle programático das transações. – Inicia transação em um Bean. – Chama outro Bean também envolvido em transações. – Controla commits e rollbacks.
  181. 181. Transações no EJBpublic void withdrawCash(double amount) { UserTransaction ut = sessionCtx.getUserTransaction(); try { double mbState = machineBalance; ut.begin(); machineBalance -= amount; insertMachine(machineBalance); ut.commit(); } catch (Exception ex) { try { ut.rollback(); } catch (SystemException syex) { throw new EJBException ("Rollback failed: " + syex.getMessage()); } throw new EJBException ("Transaction failed: " + ex.getMessage()); }}
  182. 182. Transações iniciadas pelo Cliente● O cliente pode iniciar transações usando as APIs JDBC e JMS● Cliente pode ser standalone, servlet, outro bean (não EJB), etc.● É necessário obter uma instância da classe UserTransaction através de JNDI● O container deve disponibilizar o JTA na localidade java:comp/UserTransaction Context ctx = new InitialContext(); UserTransaction ut = (javax.transaction.UserTransaction) ctx.lookup("java:comp/UserTransaction"); ut.begin(); // realizar operações ut.commit();
  183. 183. Transações declarativas - CMT● Container Managed Transaction● Controle de transações totalmente gerenciado pelo container● Não permite o uso de métodos commit() e rollback() de java.sql.Connection ou javax.jms.Session dentro do código● No deployment descriptor, especifique o uso de CMT <transaction-type>Container</transaction-type>
  184. 184. Propagação de transação● Facilmente resolvida com BMT● E no CMT ?
  185. 185. Políticas Transacionais● Define como a transação irá reagir quando o seu método for chamado por um cliente dentro ou fora do contexto de uma transação● Os valores suportados para este elemento: – NotSupported – Supports – Required – RequiresNew – Mandatory – Never
  186. 186. Required● Indica que o método tem que ser chamado dentro do escopo de uma transação
  187. 187. Supports● Indica que o método suporta transações
  188. 188. RequiresNew● Indica que uma nova transação, iniciada no escopo do bean, é sempre criada
  189. 189. NotSupported● Indica que o método não suporta transações
  190. 190. Mandatory● Indica que o método só pode ser chamado no escopo de uma transação do cliente
  191. 191. Never● Indica que o método nunca pode ser chamado no escopo de uma transação – Se o cliente que chama o método for parte de uma transação, o bean irá provocar um RemoteException (ou EJBException em clientes locais)
  192. 192. Destino de uma transação● Apenas exceções do sistema (Runtime, Remote, EJBException) provocam automaticamente o rollback de uma transação – O container não tem como adivinhar que outras exceções sejam graves o suficiente para causar rollback● Pode-se condenar (doom) uma transação CMT usando o método setRollbackOnly() – O método aciona uma flag usado pelo container para monitorar o estado de uma transação – Pode-se saber o estado de uma transação usando getRollbackOnly()
  193. 193. Qual estilo de demarcação usar?● Vantagens da demarcação explícita (BMT) – Maior controle: é possível extrapolar os limites dos métodos (em Stateful Session Beans) ou agrupar conjuntos de instruções menores no interior dos métodos● Vantagens da demarcação implícita (CMT) – Muito mais simples – Mais seguro: evita a introdução de código que pode provocar deadlock e outros problemas similares – Controle fica com o bean assembler / deployer – Mais eficiente: container gerencia melhor os recursos● Transações iniciadas pelo cliente – Vantagem: controle em relação a falhas de rede – Desvantagem: transação muito longa - ineficiente
  194. 194. Problemas de falta de isolamento● Dirty read – É o mais grave dos problemas de isolamento. Ocorre quanto uma transação lê valores não cometidos, gravados no banco por uma transação que ainda não terminou. Se a primeira transação falhar, a segunda estará com dados incorretos.● Unrepeatable read – Ocorre quando duas leituras consecutivas do mesmo registro retorna valores diferentes, devido à alteração de dados por outra transação.● Phantom read – Ocorre quando duas leituras consecutivas da mesma tabela retorna valores diferentes, devido à inserção de dados por outra transação.
  195. 195. Niveis de isolamento● Read Uncommitted: – Não oferece garantia de isolamento (aceita dirty reads - cliente pode ler dados ainda não cometidos) mas oferece a maior performance.● Read Committed – Resolve o os dirty reads mas não garante que leituras consecutivas retornem os mesmos resultados (aceita unrepeatable reads)
  196. 196. Níveis de isolamento● Repeatable Read – Bloqueia o acesso aos dados utilizados durante a consulta impedindo unrepeatable reads, mas não impede que novos dados apareçam no banco durante a operação (aceita phantom reads)● Serializable – Bloqueia o acesso concorrente aos dados (transações ocorrem em série) durante o uso mas baixa a performance significativamente.
  197. 197. Como definir o nível de isolamento● Use as ferramentas do seu servidor ou banco de dados – Não há como especificar níveis de isolamento no DD● No JBoss, o nível de isolamento default pode ser configurado no arquivo *-ds.xml de cada data source instalada. – Esse recurso depende de suporte por parte do gerenciador de banco de dados e a sintaxe varia. Exemplo: <transaction-isolation> TRANSACTION_COMMITTED </transaction-isolation>
  198. 198. Hibernate
  199. 199. Assuntos● Conceitos de ORM● Bootstraping e configuração● Mapeamento via XML● Operações da Session● Queries e HQL● Criteria
  200. 200. Hibernate Uma solução não invasiva para persistência de dados em aplicações Java  Não é preciso aderir a padrões de design específicos (como em EJB) para que uma aplicação tenha os benefícios da persistência  Torna fácil adicionar persistência a objetos comuns de aplicações existentes Uma das mais completas soluções de ORM Open-source
  201. 201. ORM Object-Relational Mapping  Mapeamento Objeto-Relacional A solução mais bem-sucedida de persistência para objetos Tem como objetivo:  Preservar as vantagens do paradigma relacional (robustez, maturidade, facilidade de pesquisa, etc.) para a camada de persistência  Preservar as vantagens do paradigma orientado a objetos (reuso, modularidade, herança, polimorfismo, etc.) para a camada de negócios
  202. 202. Banco de Dados relacionais Sistemas de gerenciamento de bancos de dados relacionais têm interfaces de programação baseadas em SQL  SQL serve como linguagem de definição de dados (DDL) para criar e alterar esquemas de dados (create table, etc.)  Também funciona como linguagem de manipulação de dados (DML) para interagir com os dados (select, insert. etc.) Para usar Hibernate eficientemente, SQL é um pré-requisito  Hibernate gera código SQL e automatiza processos trabalhosos  Para otimizar e mesmo para compreender bem o funcionamento do Hibernate é preciso conhecer SQL  HQL, linguagem de recuperação de dados, assemelha-se a SQL
  203. 203. Como funciona o ORM Classes são mapeadas em tabelas (schemas) Instâncias (objetos) são (automaticamente) mapeados em registros String codigo String nome double saldo conta correntista saldo 1 Gargantua 1370 instância:Conta 2 Pantagruel 3450 codigo="4" 3 Gargamel 800 nome="Morticia" saldo=8200 4 Morticia 8200
  204. 204. Incompatibilidade do Paradigma Há vários pontos onde o modelo relacional é incompatível com o modelo de objetos  Granularidade  Herança e polimorfismo  Identidade  Associações  Navegação em grafos Uma boa solução ORM precisa lidar com esses problemas eficientemente
  205. 205. Exemplo simples O exemplo abaixo não apresenta problemas de descasamento de paradigma: é simples  User: representa o usuário  BillingDetails: representa detalhes da cobrança
  206. 206. Classes e Tabelas  Neste exemplo, o descasamento entre o paradigma objeto e relacional não aparecepublic class User { public class BillingDetails { private String userName; private String accountNumber; private String name; private String accountName; private String address; private String accountType; private Set billingDetails; private User user; // (get/set pairs), etc. ... //methods, get/set pairs...} }create table USER ( USERNAME VARCHAR(15) NOT NULL PRIMARY KEY, Foreign key USERNAME NAME VARCHAR(50) NOT NULL, realiza o ADDRESS VARCHAR(100)) relacionamento create table BILLING_DETAILS ( ACCOUNT_NUMBER VARCHAR(10) NOT NULL PRIMARY Key, ACCOUNT_NAME VARCHAR(50) NOT NULL, ACCOUNT_TYPE VARCHAR(2) NOT NULL, USERNAME VARCHAR(15) FOREIGN KEY REFERENCES USER )
  207. 207. Hibernate● Voltando ao hibernate...● Hello World Esta aplicação simples consiste de  uma classe  um arquivo de mapeamento  uma tabela de banco de dados O objetivo é armazenar mensagens em um banco de dados e recuperá-las. Usaremos um ambiente standalone
  208. 208. O Objetopackage hello;public class Message { private Long id; private String text; private Message nextMessage; public String getText() { return text; } public void setText(String text) { this.text = text; } // getters e setters e outros construtores}
  209. 209. Nada mais é que um simples objeto... Possui:  Identificador da mensagem (id),  Texto da mensagem (text)  Referência para próxima mensagem (nextMessage) É um POJO  Plain Old Java Object Não tem nada a ver com o Hibernate  Pode ser usado em qualquer aplicação Java.  Segue as convenções usadas em JavaBeans
  210. 210. Arquitetura do Hibernate • O Hibernate persiste objetos java comuns (POJO) • Usa reflexão para acessar as propriedades persistentes de um objeto • As classes persistentes são definidades (descritas) em documentos de mapeamento • Arquivos XML são usados para descrever os campos, associações e subclasses persistentes • Os Mapeamentos são "compilados" na inicialização da aplicação
  211. 211. Interfaces do Hibernate Cinco interfaces fundamentais são usadas em quase qualquer aplicação Servem para armazenar, remover, atualizar e recuperar objetos persistentes e lidar com transações Estão listados abaixo na ordem em que (geralmente) são usadas • Configuration: carrega dados de configuração • SessionFactory: obtida de uma Configuration; permite criar sessões de interação com a camada de persistência • Session: principal objeto usado para ler, gravar, atualizar, etc. • Transaction: camada sobre sistemas de transações nativo • Query ou Criteria: realizam pesquisa no modelo de objetos
  212. 212. Session Principal interface usada em aplicações Hibernate  Todas as operações explícitas de persistência são realizadas através de um objeto Session Objeto leve  Fácil de criar  Fácil de destruir Objetos Session não são threadsafe  Devem ser usados em uma unica thread  Para threads adicionais, crie sessions adicionais
  213. 213. SessionFactory Uma aplicação obtém uma Session a partir de uma SessionFactory  Objeto pesado; lento para inicializar e destruir  Geralmente tem-se uma apenas para toda a aplicação  Deve-se ter uma SessionFactory para cada banco de dados utilizado Realiza cache de comandos SQL e dados e metadados usados em tempo de execução
  214. 214. Configuration É o ponto de partida para iniciar o Hibernate Inicializado com propriedades de configuração do sistema  Especifica a localização de dados e arquivos de mapeamento, objetos, configuração do banco de dados, pool de conexões, dialeto do SQL do banco, etc.  Geralmente obtém a configuração via arquivos .properties, XML ou propriedades dinâmicas Cria a SessionFactory
  215. 215. Transaction Abstração da implementação de transações usada no código  A implementação real pode ser uma transação JTA, JDBC, etc. Essencial para garantir a portabilidade de aplicação entre diferentes ambientes e containers  Encapsula o objeto de transação nativo em servidores de aplicação ou outros ambientes controlados
  216. 216. Query e Criteria Permite a realização de consultas ao banco Consultas Query são escritas em HQL (Hibernate Query Language) ou no SQL nativo do banco. Objetos Query são usados para  Passar parâmetros para a consulta em HQL  Filtrar resultados  Executar os comandos da consulta Criteria é uma alternativa que faz a mesma coisa usando métodos da API (em Java, em vez de HQL) Uma Query só pode ser usada dentro de sua sessão
  217. 217. 3 passos para usar o Hibernate 1) Primeiro é preciso obter um objeto de sessão Session. Session session = ...;  Através desse objeto é possível realizar operações de leitura e gravação (mais sobre como obtê-lo adiante) 2) Para gravar, crie um objeto da maneira usual e grave na sessão usando save() Message message = new Message(); message.setText(“Hello World!”); session.save(message); 3) Para ler todas as mensagens, envie um query via find() List messages = session.find(“from Message”);
  218. 218. HBM - Mapeamento As informações sobre o mapeamento entre a tabela e a classe Message ficam em um arquivo XML • Guarde-o no mesmo pacote que a classe • Chame-o de Message.hbm.xml No código abaixo, em vermelho as propriedades do objeto, em azul as colunas da tabela mapeadas<hibernate-mapping> <class name="hello.Message" table="MESSAGE"> <id name="id" column="MESSAGE_ID"> <generator class="increment" /> </id> <property name="text" column="MESSAGE_TEXT" /> <many-to-one name="nextMessage" cascade="all“ column="NEXT_MESSAGE_ID" /> </class></hibernate-mapping>
  219. 219. Manipulação do Objeto Leitura de uma mensagem específica Message message = (Message) session.load(Message.class, new Long(1)); Alteração da mensagem acima (sem usar Session) message.setText("Greetings Earthling"); Message nextMessage = new Message("Take me to your leader (please)"); message.setNextMessage( nextMessage ); Leitura de várias mensagens do bancoSession newSession = getSessionFactory().openSession();List messages = newSession .find("from Message");System.out.println( messages.size() + " message(s) found:" );for ( Iterator iter = messages.iterator(); iter.hasNext(); ) { Message message = (Message) iter.next(); System.out.println( message.getText() );}newSession.close();
  220. 220. Propriedades Propriedades para Conexões JDBC ● hibernate.connection.driver_class = org.postgresql.Driver ● hibernate.connection.url = jdbc:postgresql://localhost/mydatabase ● hibernate.connection.username = myuser ● hibernate.connection.password = secret ● hibernate.c3p0.min_size=5 ● hibernate.c3p0.max_size=20 ● hibernate.c3p0.timeout=1800 ● hibernate.c3p0.max_statements=50 ● hibernate.dialect = org.hibernate.dialect.PostgreSQLDialect Propriedades para Datasources JNDI● hibernate.connection.datasource = java:/comp/env/jdbc/test● hibernate.transaction.factory_class = org.hibernate.transaction.JTATransactionFactory● hibernate.transaction.manager_lookup_class = org.hibernate.transaction.JBossTransactionManagerLookup● hibernate.dialect = org.hibernate.dialect.PostgreSQLDialect
  221. 221. Configuração via XMLpackage util;import org.hibernate.*;import org.hibernate.cfg.*;public class HibernateUtil { private static final SessionFactory sessionFactory; static { try { // Create the SessionFactory from hibernate.cfg.xml sessionFactory = new Configuration().configure().buildSessionFactory(); } catch (Throwable ex) { System.err.println("Initial SessionFactory creation failed." + ex); throw new ExceptionInInitializerError(ex); } } public static SessionFactory getSessionFactory() { return sessionFactory; }}
  222. 222. Configuração programáticaConfiguration cfg = new Configuration() .addClass(org.hibernate.auction.Item.class) .addClass(org.hibernate.auction.Bid.class) .setProperty("hibernate.dialect","org.hibernate.dialect.MySQLInnoDBDialect") .setProperty("hibernate.connection.datasource","java:comp/env/jdbc/test") .setProperty("hibernate.order_updates", "true");
  223. 223. Persistindo Objetos Session session =HibernateUtil.getSessionFactory().getCurrentSession(); session.beginTransaction(); Event theEvent = new Event(); theEvent.setTitle(title); theEvent.setDate(theDate); session.save(theEvent); session.getTransaction().commit();
  224. 224. Operações da SessionDomesticCat cat = (DomesticCat) sess.load( Cat.class, new Long(69) );cat.setName("PK");sess.flush(); // Mudanças são automaticamente persistidas● Objetos persistentes
  225. 225. Carregando objetos persistidos ● Via load long id = 1234; DomesticCat pk = (DomesticCat) sess.load( DomesticCat.class, new Long(id) ); ● Via QueryList cats = session.createQuery( "from Cat as cat where cat.birthdate < ?") .setDate(0, date) .list();List mothers = session.createQuery( "select mother from Cat as cat join cat.mother as mother wherecat.name = ?") .setString(0, name) .list();
  226. 226. Query – Parâmetros//Parâmetro nomeado (preferido)Query q = sess.createQuery("from DomesticCat cat where cat.name = :name");q.setString("name", "Fritz");//Parâmetro posicionalQuery q = sess.createQuery("from DomesticCat cat where cat.name = ?");q.setString(0, "Izi");//Lista de parâmetrosList names = new ArrayList();names.add("Izi");names.add("Fritz");String hql = "from DomesticCat cat where cat.name in (:namesList)";Query q = sess.createQuery(hql);q.setParameterList("namesList", names);
  227. 227. Query - PaginaçãoString hql = "from DomesticCat cat";Query q = sess.createQuery(hql);q.setFirstResult(20);q.setMaxResults(10);List cats = q.list();
  228. 228. CriteriaCriteria crit = sess.createCriteria(Cat.class);crit.setMaxResults(50);List cats = crit.list(); List cats = sess.createCriteria(Cat.class) .add( Restrictions.like("name", "Fritz%") ) .add( Restrictions.between("weight", minWeight, maxWeight) ) .list(); List cats = sess.createCriteria(Cat.class) .add( Restrictions.like("name", "Fritz%") ) .add( Restrictions.or( Restrictions.eq( "age", new Integer(0) ), Restrictions.isNull("age") ) ) .list();
  229. 229. JPA
  230. 230. Assuntos● Anotações● Facilidades● Bootstraping J2SE e J2EE● EntityManager● JPQL
  231. 231. JPA● JPA (Java Persistence API) é a especificação padrão para o gerenciamento de persistência e mapeamento objeto relacional, surgida na plataforma Java EE 5.0● Introduzida no intuito de substituir os Entity Beans (que foram descontinuados) e simplificar o desenvolvimento de aplicações Java EE● Pode ser usada com Java SE● Configuração por anotações● Baseada no Hibernate
  232. 232. Provedor JPA● Existem diversas implementações de diversos fabricantes● Oracle Toplink● Hibernate EntityManager● Bea Kodo● Apache JPA
  233. 233. Entidade● Principal conceito do JPA● É um objeto que pode ser persistido no Banco de Dados● Nada mais é que um POJO● Possui um ciclo de vida gerenciado pelo JPA● Basta possuir a anotação @Entity, ter um construtor padrão, e uma chave primária
  234. 234. Ciclo de vida da Entidade● Objetos podem existir sem o Banco de Dados● Entra em cena o estado do objeto
  235. 235. Como é realizado o mapeamento ?● Anotações são “metadados” das classes – @Entity – @Table(“tabela”) – @Column(“coluna”) – @Id – @GeneratedValue – @Transient – @NamedQuery – @Temporal – @Enumeration
  236. 236. Como funciona o EntityManager
  237. 237. Criando o EntityManager
  238. 238. Exemplo Simples – Criando uma Entidade import javax.persistence.*; @Entity @Table (name=”aluno”) public class Aluno { @Id @GeneratedValue private int id; private int matricula; private String nome; //Getters e Setters }
  239. 239. Persistence.xml<persistence> <persistence-unit name="exemplo" transaction-type="RESOURCE_LOCAL"> <properties> <property name="hibernate.connection.driver_class" value="org.hsqldb.jdbcDriver"/> <property name="hibernate.connection.username" value="sa"/> <property name="hibernate.connection.password" value=""/> <property name="hibernate.connection.url" value="jdbc:hsqldb:hsql://localhost"/> <property name="hibernate.dialect" value="org.hibernate.dialect.HSQLDialect"/> </properties> </persistence-unit></persistence>
  240. 240. public class Principal { Testando public static void main(String[] args){ //Cria objeto que gerenciará persistência EntityManagerFactory fabrica = Persistence.createEntityManagerFactory("exemplo"); EntityManager em = fabrica.createEntityManager(); try { EntityTransaction tx = gerenciador.getTransaction(); tx.begin(); //Inicia transação Aluno a1 = new Aluno(); a1.setNome(“Pedro”); a1.setMatricula(20009387); em.persist(a1); //Persiste primeiro aluno Aluno a2 = new Aluno(); a2.setNome(“Maria Eduarda”); a2.setMatricula(20052347); em.persist(a2); //Persiste segundo aluno tx.commit(); //Finaliza transação } catch (Exception ex) { tx.rollback(); //Desfaz operações em caso de erro } finally { //Libera recursos em.close(); fabrica.close(); } }}
  241. 241. Facilidades com EJB3● JPA - Sempre é preciso ter uma transação ativa● EJB é automático (Required)● EntityManager pode ser injetado via anotação: @PersistenceContext @PersistenceContext EntityManager em; public void enterOrder(int custID, Order newOrder) { Customer cust = em.find(Customer.class, custID); cust.getOrders().add(newOrder); newOrder.setCustomer(cust); }
  242. 242. Relacionamentos● @OneToMany – Pessoa tem vários telefones – List<Telefone> telefones = new ArrayList<Telefone>()● @ManyToOne – Telefone pertence a uma pessoa – Pessoa pessoa;● @OneToOne – Pessoa possui uma Casa – Casa casa;● @ManyToMany – Professor possui várias turmas e vice-versa – List<Turma> turmas = new ArrayList<Turma>();
  243. 243. Queries● Não existe Criteria – previsto para JPA 2.0● JPQL – Java Persistence Query Language● Um único método: – createQuery(jpql);● Dois retornos: – getSingleResult(); – getResultList();
  244. 244. Exemplos de Queriesfinal List<Pessoa> list = em.createQuery("fromPessoa where p.nome = ?1") .setParameter(1, "Rafael").getResultList();final Person pByWhere = (Person) em.createQuery( "SELECT p from Person p wherefirstName=Brett") .getSingleResult();
  1. A particular slide catching your eye?

    Clipping is a handy way to collect important slides you want to go back to later.

×