construindo portlets para ibm websphere portal – parte 2

© 2013 IBM Corporation

Construindo Portlets para IBM WebSphere Portal – Parte 2+ Melhores Práticas

Rodrigo Reis IT Specialist & Application ArchitectIBM Collaboration Solutions

© 2013 IBM Corporation2

Agenda

Introdução

Parte 1: Revisando conceitos de Portal e Portlets

Parte 2: IBM WebSphere Portal API (Model SPI, REST, WebDAV)

Parte 3: Criando Portlets com JSF

Parte 4: Melhores Práticas


Introdução

● Este workshop não é de introdução a Java ou IBM WebSphere Portal

● Necessário conhecimento básico de Programação Java para Web (JSP, HTML, XML, JavaScript, Frameworks) e Portlets

● O objetivo do workshop é apresentar tópicos avançados no desenvolvimento de portlets e explorar as melhores práticas

4 © 2013 IBM Corporation

1878A

Parte 1: Revisando conceitos de Portal e Portlets


Portal e Portlets

● Um Portlet Java é: um componente Web, gerenciado por um portlet container, que processa requests e gera conteúdo dinâmico

● Portlet container possui grande número de implementações comerciais (IBM, Oracle, OpenText (Vignette), SAP, JBoss, ...) e open source (Apache Jetspeed-2, Liferay, uPortal, ...)

Portlet A

Portlet B

Portlet C

Portlet DPortlet Container

Portal Server

A

B

D

C


Portal e Portlets

● O Java Portlet Specification (JSR168, JSR286) padroniza os portlets, permitindo a interoperabilidade de portlets entre diferentes portais.

- Java Portlet Specification 3.0 (JSR 362) atualmente em desenvolvimento

● Web Services for Remote Portlets (WSRP) é um protocolo de rede padrão desenvolvido para comunicação remota de portlets


Portlet Modes & States

● Um portlet pode conter 3 modos de operação:

● View – Modo de exibição padrão

● Edit – Usuário personaliza o portlet

● Help – Exibe janela de ajuda

● Diferente de aplicações web tradicionais, portlets utilizam apenas uma fração da página. Os seguintes estados de janela estão disponiveis:

● Minimize – exibe apenas o titulo da janela

● Maximize – exibe apenas o portlet na janela

● Restore – exibe o portlet no modo padrão


Criando um Portlet

Desenvolvendo● Parte 1: Código do Portlet

● Part 2: Portlet descriptor

Empacotando & Publicando

public class HelloWorld extends GenericPortlet {

public void init (PortletConfig portletConfig) throws UnavailableException, PortletException {

super.init(portletConfig);

}

public void doView(RenderRequest request, RenderResponse response) throws PortletException, IOException {

response.setContentType("text/html");

response.getWriter().println("Hello Portal World!</p>");

}

}

<?xml version="1.0" encoding="UTF-8"?>

<portlet-app ...>

<portlet>

<portlet-name>HelloWorld portlet name</portlet-name>

<display-name>Hello World portlet (JSR)</display-name>

<display-name xml:lang="en">Hello World portlet (JSR)</display-name>

<portlet-class>HelloWorld</portlet-class>

<supports>

<mime-type>text/html</mime-type>

<portlet-mode>view</portlet-mode>

</supports>

<supported-locale>en</supported-locale>

</portlet>

</portlet-app>

+

WAR


Checkpoint

NÃO é um dos propósitos da especificação JSR168:

A – Definir um pacote de portlets para permitir uma implantação fácil

B – Permitir a portabilidade entre os portlets do portal

C – Definir o modelo de segurança do portlet container

D – Definir a API entre o portlet container e portlets

E – Definir o ambiente de execução, ou portlet container, para portlets


1878A

Parte 2: IBM WebSphere Portal API (Model SPI, REST, WebDAV)


Visão GeralBrowser / Systems

Model SPI

REST SPI

WebDAV SPI

Custom Development(Server Side – Theme, Extensions)

Web Experience Suite

Client Engine

Custom Development(Client Side)

Third Party

Custom Portlets

Markup (HTML)

Data (ATOM,binary…)

Theme / Portlets

IBM products

Out of the box features


Model System Programming Interface (SPI)

O Model SPI encapsula a camada de operação do banco de dados e fornece uma interface de programação para clientes, fornecedores e desenvolvedores do portal

Model SPIModel SPI

Navigation ModelNavigation Model

Content ModelContent Model

Theme ModelTheme Model

Skin ModelSkin Model

Layout ModelLayout Model

Client ModelClient Model

Language ModelLanguage ModelPortlet ModelPortlet Model

Markup ModelMarkup ModelWire ModelWire Model

Virtual Portal ModelVirtual Portal Model

Navigation Selection ModelNavigation Selection Model

Resource ModelResource Model

Tag ModelTag Model

Rating ModelRating Model

Models disponiveis no Portal 8


Relacionamento entre modelos chaves

Navigation Model Content Model Layout Model

Portlet Model

PortletWin

PortletEnt

PortletDef

Portlet

WebApp

Wire Model

Theme Model Skin Model


Usando o Model SPI – Operação de Leitura

Passo 1: JNDI busca uma instância que implementa a interface Model Home

Passo 2: Retorna provedor Model Provider da interface Model Home

Passo 3: Retorna argumentos de contexto, dependendo do modelo do provedor de modelo

Passo 4: Recuperar um nó do modelo a partir da localização (Locator) ou iterar sobre todos os nós do modelo

Melhores Práticas: Guardar a instância de Home para reutilização, elimina a necessidade de invocar repetidamente o lookup JNDI, potencialmente caro.

Model Home

Model Provider

Model

ModelnodeModelnode

Modelnode

Locator


Usando o Model SPI – Operação de Leitura

Exemplo de como obter o Theme Model:

final Context ctx = new InitialContext();

ThemeListHome home = (ThemeListHome)ctx.lookup(ThemeListHome.JNDI_NAME);

ThemeListProvider provider = home.getThemeListProvider();

ThemeList<Theme> model = provider.getThemeList(aRequest);

Iterator<Theme> it = model.iterator();

Locator<Theme> locator = model.getLocator();

Theme theme = locator.findByID(anObjectID);

1

2

3

4

ThemeListHome

ThemeListProvider

ThemeList

ThemeTheme

Theme

Locator


Usando o Model SPI – Operação de Escrita

Passo 1: JNDI busca uma instância que implementa a interface ControllerHome

Passo 2: Retorna instância do provedor ControllerProvider da interface ControllerHome

Passo 3: Cria um modelo com o provedor ControllerProvider

Passo 4: Recuperar um nó do modelo a partir do Controller usando localização (Locator) ou iterando sobre todos os nós do modelo

Passo 5: Gerenciamento de operações no Controller e nós modificáveis, e a operação de commit (apenas um commit!)

Atenção: Liberar o Controller apenas uma vez.

ControllerHome

ControllerProvider

Controller

Mod.Modelnode

Locator

Mod.ModelnodeMod.Modelnode

Model


Usando o Model SPI – Operação de Escrita

Exemplo usando o ThemeList controller:

final Context ctx = new InitialContext();

ThemeListControllerHome home = (ThemeListControllerHome)

ctx.lookup(ThemeListControllerHome.JNDI_NAME);

ThemeListControllerProvider provider =home.getThemeListControllerProvider();

ThemeListController<Theme> controller =provider.createThemeListController(aThemeList);

CreationContextBuilderFactory creationFct = CreationContextBuilderFactory.getInstance();

CreationContext cContext = creationFct.newDecorationCreationContext("resourceRoot","contextRoot");

ModifiableTheme modTheme = controller.create(Theme.class,cContext);

controller.insert(modTheme);

controller.commit();controller.dispose();

1

2

3

5

ThemeListControllerHome

ThemeListControllerProvider

ThemeListController

Mod.Theme

Locator

Mod.ThemeMod.Theme

ThemeList


Model SPI – Exemplo usando Navigation

Root

Home

Getting Started Features

Administration Applications Search Center Tag Center

CTF Test Page CTF Legacy Test Page

Navigation Model

final Context ctx = new InitialContext();NavigationModelHome navHome =

(NavigationModelHome)ctx.lookup(NavigationModelHome.JNDI_NAME);NavigationModelProvider navProvider = navHome.getNavigationModelProvider();NavigationModel<NavigationNode> navModel =

navProvider.getNavigationModel(request, response);NavigationNode aNode = navModel.getRoot();. . .while(navModel.hasChildren(aNode)){

for (Iterator<NavigationNode> it = navModel.getChildren(aNode); it.hasNext();){NavigationNode child = it.next();final String title = child.getTitle(aLocale);. . .

}}

Interface com usuário

Modelo

Implementação


Checkpoint

O modelo a seguir NÃO pertence a Model SPI:

A – Resource Center Model

B – Portlet Model

C – Navigation Selection Model

D – Markup Model

E – Wire Model


Laboratório 4: Trabalhando com Model SPI

● Implementar um portlet usando Model SPI


REST Programming Model

REST é a base da Web

● Recursos são identificados de forma exclusiva via URI

● HTTP GET representa operações idempotentes

● HTTP POST / PUT / DELETE representam modificações

Por que eu deveria seguir o padrão REST?

● Performance: infra-estrutura de cache HTTP assume REST

● Funcionalidade: comportamento consistente do botão de voltar

● Bookmarkability e crawlability


REST Programming Model

WebSphere Portal faz com que seja fácil de seguir o padrão REST

● JSR168/286 é costurado em torno de REST

– Render phase mapea o HTTP GET

– Action/event phase mapea o HTTP POST

– Render parameters mapeam HTTP URLs

● Portal Services são fornecidos como REST feeds

– Model feeds

– User feeds

– ...

Cliente

AJA

X

ServiçosREST

Serviçosdo Portal


Serviços REST disponíveis no Portal 8

REST SPIREST SPI

(R/W) Navigation Model(R/W) Navigation Model

(R/W) Content Model(R/W) Content Model

Theme Model (R/W)Theme Model (R/W)

Skin Model (R/W)Skin Model (R/W)

(R/W) Layout Model(R/W) Layout Model

Client Model (R)Client Model (R)

Language Model (R)Language Model (R)

(R/W) Portlet Model(R/W) Portlet Model

(R/W) Wire Model(R/W) Wire Model

sl

ll

cl

cm

nm

lm

wm

pm

tl

tm Tagging Model (R/W)Tagging Model (R/W)

wcm

WCM content modelWCM content model

rm Rating Model (R/W) Rating Model (R/W)

ContentMapping (R/W)ContentMapping (R/W)

contentmapping


Exemplo: ATOM feed – Portal Navigation Model

/wps/mycontenthandler/!ut/p/nm/oid:wps.portal.root? mode=download&digest=Ijd6SHFqhrFcnWe3Pts88A!!

Suporte a cache

Compressão(se solicitada)

(Status-Line) HTTP/1.1 200 OKServer WebSphere Application Server/6.1Date Thu, 03 Oct 2011 11:54:16 GMTExpires Fri, 04 Oct 2011 11:54:16 GMTCache-Control private, max-age=86400Last-Modified Thu, 01 Jan 2011 00:00:00 GMTContent-Location http://wps60.boeblinge...88A!!Content-Type application/atom+xmlContent-Encoding gzipContent-Language de-DEContent-Length 523Accept-Ranges bytesX-Request-Digest Ijd6SHFqhrFcnWe3Pts88A!!


Exemplo: ATOM feed – Portal Navigation Model


Checkpoint

Qual dos modelos a seguir é acessível por REST apenas para leitura?

A – Content Model

B – Wire Model

C – Client Model

D – Theme Model

E – Layout Model


Resource Addressability Framework – URL, URI e Recursos

● Antigamente no WebSphere Portal as URLs especificavam a localização exata dos recursos

● Um mesmo conteúdo (documentos), por exemplo, pode estar localizado em diferentes páginas e portanto endereçável por URLs diferentes

● Em alguns casos, no entanto, é desejável poder tratar conteúdos independente da sua localização

Conteúdo

…

Conteúdo != URLURL

● URL

Uniform Resource Locator

● URI

Uniform Resource Identifier

● Recursos

Parte de um contéudo que é identificado por uma URI e localizado por uma URL


Resource Addressability Framework - Piece-of-Content (POC)

POC fornece mecanismos para encontrar uma "view" de uma peça-de-conteúdo em um determinado contexto do portal

WebSphere Portal

POCFramework

Piece of ContentWCM Item

Piece of ContentDocument

…

Markup (HTML)

Data (ATOM,binary, …)

O framework POC acrescenta um ponto de entrada para o WebSphere Portal que permite acessar POCs em uma variedade de mime-types


Resource Addressability Framework - Piece-of-Content (POC)

Navigation Model

Como uma POC é identificada?

A POCé identificada por uma URI (RFC 3986) POCURI = <scheme> : <scheme-specific-part>

Interpretado pelo POC framework para tratar a POC

Interpretadopelo POC handler

Como uma POC é acessada?

A URL para um POC pode ser construída via concatenação de string ou via Portal-API

/wps/[my]poc[/<vp>]?uri=<scheme>:<ssp> (1)

/wps/[my]poc[/<vp>]/<scheme>/<ssp> (2)

Quando usar o framework– para referenciar conteúdo em URLs para usuário– se você quiser link para o conteúdo e não para o estado de navegação (por exemplo, resultados de pesquisa, documentos, etc)

Piece of Content(POC)


Data Sources atualmente suportados

ByteDataSource● Nível mais baixo, apenas trasmite bytes

CharDataSource● Transmite caracteres, usado para dados baseado em texto

XmlDataSource● Baseado em XML, usados para feeds, por exemplo

JsonDatasource● Tramite no formato JSON

MultipartDataSource● Combina multiplos data sources em um único multipart stream

(usado, por exemplo, por questões de performance para poupar requests)

WebdavDataSource ● Transmite POCs pelo protocolo WebDAV

Todos Data Sources são transmitidos independentemente do tamanho dos dados!


Criação de URLs POC

● POC-URLs podem ser geradas via PocService API(com.ibm.portal.resolver.service.PocService)

● Via uma TAG API <resolver:resolvedURL/>

- Entrando com o URI dinâmicamente

- Informando o endereço URI diretamente

<%@ taglib uri="http://www.ibm.com/xmlns/prod/websphere/portal/v7.0/resolver" prefix="resolver" %><form method="GET" action="<resolver:resolvedURL/>">Enter POC-URI: <input type="text" name="uri" value=""> <input type="submit" name="submit" value=„Display"></form>

<%@ taglib uri="http://www.ibm.com/xmlns/prod/websphere/portal/v7.0/resolver" prefix="resolver" %><a href="<resolver:resolvedURL uri='cm:oid:wps.content.root'/>">Go to Root Page</resolver:resolvedURL>


WebDAV System Programming Interface (SPI)

● Extensão HTTP, Web Distributed Authoring and Versioning (RFC 4918)● Extende metódos HTTP para gerênciamento de recursos (REST) ● Interface fácil de administração e programação● Grande variedade de softwares implementam este protocolo

WebDAV

WebDAV Client WebSphere Portal

OPTIONSGET

HEADPOSTPUT

DELETETRACE

CONNECT

PROPFIND PROPPATCH

MKCOL COPY MOVE

(UN)LOCK


WebDAV Clients

Multiplataforma● AnyClient (Java/httpclient), cURL, DAV Explorer (Java)

Windows● Incluído no S.O. WindowsXP / Windows 7● Cyberduck, Bitkinex, Novell NetDrive, WebDrive● Microsoft Office / Open Office● Adobe Dreamweaver

Linux● Neon, davfs2, Cadaver, GNOME Nautilus, KDE Konqueror

MacOS / iPad ● Incluído no S.O. MacOS, iPad (iWork), Cyberduck


Portal WebDAV – Recursos disponíveis

Recurso Descrição

X X X

X X X

X X X

Loca

lized

Met

adat

a

File

stor

e m

irror

Sta

tic C

onte

nt

Filestore / JCR Filestore based on JCR

ThemeList Representação do ThemeList (List)

SkinList Representação do SkinList (List)

ContentModel Representação do ContentModel (Tree)


WebDAV SPI

WebDAV SPI permite criar serviços baseados no protocolo WebDAV

WebdavTreeModel

WebSphere Portal

Portal WebDAV Layer

HTTP

WebdavTreeModelController


Exemplo de Uso - Portal Theme

O tema combina o uso de Model SPI, REST SPI e WebDAV SPI

Browser

Model SPI

REST SPI

WebDAV SPI

Web Experience Suite

Theme Client Engine

Theme Server Engine


1878A

Parte 3: Criando Portlets com JSF


Utilizando Frameworks

● Frameworks cuidam da infra-estrutura permitindo-nos focar nas funcionalidades

● Escrever Portlets do zero, sem ferramentas de apoio, é obviamente uma opção

● Existem várias opções no mercado (JSF, Spring MVC, Struts 2, etc), neste workshop vamos utilizar o JSF


Por que Java Server Faces (JSF)?

● Produtividade

- Permite criar interface de usuário de forma rápida- Suporte incluso para coisas que de outra forma você teria de codificar por si mesmo: Ajax, Validação, Navegação, etc

● É uma especificação (JSF 2.0 é JSR 314)

- Já assimilado por muitas organizações e no mercado- Apoio da IBM: usado em muitos portlets fornecidos- Apoiado por ferramentas como o Rational Application Developer


Por que Java Server Faces (JSF)?

● Extensibilidade

- Permite criar componentes personalizados e reutilizáveis

- Muitas extensões de terceiros disponiveis:

PrimeFaces (Prime Technology)IceFaces (IceSoft)RichFaces (Jboss)ADF Faces (Oracle)PrettyFaces (OCPSoft)MyFaces (Apache)...


Arquitetura do JSF

● Modelo de componentes de interface - É uma estrutura que cria componentes de UI personalizada

● Modelo de redenrização - Fornece a estrutura para separar as funções dos componentes da forma como ele é processado

● Modelo de programação orientada a eventos - Fornece um framework manipulador de eventos para processar eventos client-driven

● Modelo de conversão ou de formatação - Fornece uma maneira de transformar dados entre o modelo e as camadas de apresentação

● Modelo de validação - Oferece estrutura de validação para a entrada de dados

● Modelo de navegação - Fornece rotas de navegação entre as páginas sem a necessidade de escrever código


Processamento de um JSF request

O ciclo de vida do processamento de um JSF request trabalha com as seguintes estruturas inter-relacionadas:



1.Restore View

- Recupera a árvore de componentes do cliente ou sessão



1.Restore View

2.Apply Request Values

- Decodifica os componentes- Preenche-os com valores do tipo string



1.Restore View


3.Process Validation

- Converte strings para objetos- Valida os objetos



1.Restore View



4.Update Model Values

- Chama os métodos setters dos managed beans



1.Restore View




5.Invoke Application

- Invoca os métodos- Verifica a navegação



1.Restore View




5.Invoke Application

6.Render Response

- Chama os métodos getters para preencher os componentes


Checkpoint

Qual dessas fases NÃO faz parte do ciclo de vida de um JSF request

A – Restore View

B – Process Validation

C – Apply Request Values

D – Render parameters

E – Invoke Application


Evolução do Java Server Faces

JSF 1.x, 1.2

● Complexidade para criação de componentes

● Não tem requisições GET apenas POST... URL’s nada amigáveis

● Sem suporte a Ajax nativo, necessário suporte de terceiros

● Permite uso de JSP, scriptlets (código java na sua página web)

● Configurações baseadas em XML

JSF 2.0

● Suporte nativo a Ajax e Annotations

● Templates baseados em Facelets

● Componentes UI com xhtml

● Navegação implícita e condicional

● Melhorias no mecanismo de eventos

● Suporte a requisição via GET, novos escopos


Páginas no JSF 2.0

● XML no lugar de JSP... JSP era a tecnologia padrão de Java para Web, inclusive no JSF 1.x

● Vários conceitos de JSF não são suportados por JSP, e conceitos do JSP se tornam desnecessários para JSF.

Exemplo: a necessidade de tradução e compilação dos arquivos JSP. Faz sentido para os JSPs, mas não para o JSF que apenas pretende representar uma árvore de componentes.


Páginas no JSF 2.0

● As páginas da aplicação JSF 2 são definidas através de arquivos xhtml

Esses arquivos são processados pela engine do Facelets que faz parte do JSF 2.0

● Os Componentes de Interface que formam as telas da aplicação são inseridos através de tags xhtml

● Suporte à instrução HTTP GET, permitindo usar páginas JSF como favoritos em navegadores

● Integração com a nova especificação Bean Validation, facilitando a validação de JavaBeans


Anotações do JSF 2.0

● O suporte a anotações faz com que na maioria das vezes não seja necessário ter o arquivo faces-config.xml.

Apenas para algumas exceções como message bundle

● Algumas anotações:

@ManagedBean

@ManagedProperty

@*Scoped (View, Session, Application, etc)

@FacesConverter

@FacesComponent

@FacesValidator


Suporte Ajax nativo no JSF 2.0

● Inspirado em frameworks como: ADF Faces, Richfaces, Icefaces

● Javascript ajax API

● Suporte à tag <f:ajax>

<h:commandButton id=“btnDelete” action=“#{contactBean.delete}”>

<f:ajax update=“contactsList” />

</h:commandButton>


Economizando código com Facelets

● Economiza código, promovendo a reutilização

● Manutenção mais rápida

● Não seja um “Code Monkey”


Construindo Portlets JSF com o RAD

● Passo 1 - Criar um projeto de portlet que especifica Faces portlet

● Passo 2 - Criar suas páginas

● Passo 3 - Adicionar componentes e dados JSF nas páginas

● Passo 4 - Configurar atributos para cada componente JSF, incluindo propriedades de conversão e validação

● Passo 5 - Escrever o código de ação que está associado com os componentes de comando

● Passo 6 - Especificar regras de navegação para o fluxo da aplicação


Laboratório 5: Criando um Faces Portlet

● Criar um portlet do tipo Faces Portlet

● Utilizar componentes JSF

● Publicar o Faces Portlet no portal


1878A

Parte 4: Melhores Práticas


Diretrizes para codificação de Portlets

● Projeto de portlet

O projeto correto de um portlet é dividido em três partes distintas: Model, View e Controller (MVC). Este modelo é o padrão de projeto clássico da orientacão a objetos, onde cada parte é auto-suficiente e modular, facilitando a manutenção, extensões, e os avanços

● Construindo com blocos

Para aproveitar a flexibilidade dos portlets, eles podem ser utilizados como blocos de construção, os programadores podem projetar pequenos portlets que contêm uma função específica em vez de um grande portlet que inclui todas as funções.



● Não use as variáveis de instância

Portlets, assim como servlets, existem como uma instância singleton dentro da JVM do servidor. Os dados armazenados em variáveis de instância estarão acessíveis nas solicitações e entre usuários e pode colidir com outros pedidos. Os dados devem ser passados para métodos internos como parâmetros

● Passe dados para a view como um bean no request

Use o objeto RenderRequest para passar dados para a view, de modo que quando o pedido for concluído, os dados estão fora do escopo e eliminados



● Limite o uso da sessão de portlet para armazenamento

O PortletSession é um local conveniente para armazenar dados globais, que é específico ao usuário e portlet e que abrange os portlet requests. No entanto, há uma sobrecarga considerável na gestão da sessão, tanto em ciclos de CPU, bem como heap consumption

● Agrupe portlets que utilizam o mesmo back-end em uma aplicação de portlet

Adote o conceito de aplicação de portlet agrupando portlets utilizam os mesmos dados de back-end. Os portlets desta aplicação podem compartilhar as definições de configuração, como o nome do servidor ou dados de usuário / senha, dados, etc



● Usar cache, tanto quanto possível

Se o conteúdo do portlet é estático por natureza ou é válido por um longo período de tempo antes de ser atualizado, então o seu portlet deve habilitar cache

Defina um tempo de expiração padrão no descritor de implementação do portlet (portlet.xml) usando a tag:

<expiration-cache>

Durante a execução do portlet, pode ser adicionado um tempo de expiração para cada response individualmente usando a chamada:

RenderResponse.setProperty (EXPIRATION_CACHE, time)



● Evite usar threads

Porque portlets são multi-threaded, gerar child threads pode criar problemas de sincronização. Use threads com extrema cautela e, quando necessário, use-as brevemente

● Evite métodos sincronizados

Sincronização provoca um gargalo através de seu portlet, ou um caminho que permite apenas um thread por vez para passar. Além de retardar o portal como um todo, a possibilidade de ocorrência de um deadlock também é alta, o que pode indisponibilizar o portlet ou portal, para todos os usuários



● Inicialize serviços no método init() do portlet

Como chamadas JNDI são bastante caras, portlets devem usar serviços de pesquisa JNDI no método init()

● Não use o mesmo nome para portlets e servlets dentro da mesma aplicação web

Ferramentas e portais podem usar o nome do portlet para identificar o portlet em um aplicativo Web e podem se confundir, se o aplicativo da Web inclui um servlet com o mesmo nome



● Minimize dependências de JavaScript

Porque implementações e comportamento de JavaScript diferem amplamente entre os tipos e versões de navegadores, quanto mais o seu portlet depender de JavaScript, mais dependente de navegador seu portlet se torna

● URIs, nome de elementos HTML, e os recursos JavaScript devem ser namespace encoded

Uma vez que muitos portlets podem existir em uma página e é possível que mais do que um portlet produza conteúdo contendo elementos com o mesmo nome, existe um risco de colisão entre elementos, causando problemas funcionais na página



● Forneça informações sobre a versão

A fim de permitir aos administradores do portal diferenciar as diferentes versões do aplicativo de portlet e fornecer suporte para a atualização

Declare a versão do seu aplicativo de portlet no META-INF/MANIFEST.MF usando o atributo Implementation-Version

Use a especificação Java Product Versioning Specification que sugere major.minor.micro, onde:

major - identifica alterações funcionais significativas.

minor - identifica extensões menores para funcionalidades

micro - são ainda menores que a versão minor



● Projete o portlet para caber em uma página com outros portlets

Ao contrário de outras aplicações Web, portlets geralmente ocupam uma parte da página. O tamanho da sua janela pode determinar a facilidade com que o portlet pode caber em uma página com várias colunas e outros portlets. Uma janela grande vai "apertar" outros portlets para fora da tela e criar barras de rolagem, resultando em problemas de usabilidade

● Use IFRAMEs com cautela

IFRAMEs são uma maneira fácil de incluir conteúdo externo dentro de um portlet, mas mina todo o princípio de portlets. Portanto, IFRAMEs devem ser usados somente em casos muito especiais, como integração de aplicações legadas



● Internacionalize os portlets utilizando resource bundles

Use um resource bundle por portlet para internacionalizar a exibição do portlet, e declare este resource bundle no descritor de implementação do portlet

● Crie páginas totalmente acessíveis

Para permitir que os usuários do portal com deficiência sejam capazes de usar seu portlet, as páginas devem ser totalmente habilitadas para uso apenas do teclado e outras tecnologias de assistência


Adote bons hábitos de documentação de código

● Comentar código não é necessário para a funcionalidade do portlet, é essencial para a sua manutenção

● A manutenção de um portlet pode mudar de mãos ao longo do tempo, e portlets bem escritos podem servir como modelos para outros portlets

● Exemplos de documentação a serem seguidos:

a. Insira JavaDoc em todas as classes públicas, variáveis e métodos. Entradas e saídas de documentos

b. Incluir comentários na linha, mas não incluí-los na mesma linha do código Java. É difícil alinhar e seguir observações que estão na mesma linha do código

c. Use nomes significativos para as variáveis e métodos


A importância da interface com o usuário

● É onde normalmente os usuários passam a maior parte do tempo realizando suas tarefas diárias

● Precisa ser simples e amigável


Utilizando frameworks JavaScript no seu Portlet

● Por que utiliza-los?

- Reduz significativamente o número de recargas da página

- Permite tornar atraente experiência do usuário, com efeitos, animações, transições, etc

- Existem várias opções no mercado (jQuery, Dojo, ExtJS, Prototype, etc), neste workshop utilizamos o jQuery



● Comportamento de JavaScript em portlets

- Não pode assumir nada sobre como outros portlets ou o Portal está usando JavaScript

- Não pode assumir que haverá apenas uma cópia do seu próprio conteúdo da página

● Evite problemas

- Use <c.url> para se referir aos recursos na sua webapp

- Declare variáveis JS com <portlet:namespace/> (isto é RenderResponse.getNamespace ())

- Utilize o Namespace tags HTML importantes da mesma forma

- Coloque o código JS em:

$(document)ready(function() {...});



● Exemplo de uso

<script src=”<c:url value=”rs/jquery/1.3.2/jquery.min.js” />”

<c:set var=”n”><portlet-namespace/></c:set>

<div id=”${n}container”>

<script type=”text/javascript”>

var ${n} = {}${n}.jQuery = jQuery.noConflict(true);

${n}.jQuery(function() {//Código Javascript aqui

}

</script>


Integrando frameworks externos ao RAD

● Drag and Drop de componentes a partir da paleta de componentes

● Assistentes de codificação dentro do Editor

● Customização dos componentes para incluir attributos ou códigos JavaScript associados com o componente

● Maior produtividade


Integrando frameworks externos ao RAD

Demonstração


Para saber mais...

WebSphere Portal and IBM Web Content Manager Information Centerhttp://www.ibm.com/developerworks/websphere/zones/portal/proddoc.html

WebSphere Portal and Web Content Manager Business Solutions Cataloghttps://greenhouse.lotus.com/catalog/

WebSphere Portal developerWorks forumhttp://www.ibm.com/developerworks/forums/forum.jspa?forumID=168

The WebSphere Portal wikihttp://www-10.lotus.com/ldd/portalwiki.nsf/xpViewCategories.xsp?lookupNa

me=IBM%20WebSphere%20Portal%208%20Product%20Documentation

IBM Redbooks® publicationshttp://www.redbooks.ibm.com/portals/websphere


Obrigado!!!

Rodrigo [email protected]

IT Specialist & Application Architect IBM Software Services for Collaboration


© IBM Corporation 2013. All Rights Reserved.

The information contained in this publication is provided for informational purposes only. While efforts were made to verify the completeness and accuracy of the information contained in this publication, it is provided AS IS without warranty of any kind, express or implied. In addition, this information is based on IBM’s current product plans and strategy, which are subject to change by IBM without notice. IBM shall not be responsible for any damages arising out of the use of, or otherwise related to, this publication or any other materials. Nothing contained in this publication is intended to, nor shall have the effect of, creating any warranties or representations from IBM or its suppliers or licensors, or altering the terms and conditions of the applicable license agreement governing the use of IBM software

.

References in this presentation to IBM products, programs, or services do not imply that they will be available in all countries in which IBM operates. Product release dates and/or capabilities referenced in this presentation may change at any time at IBM’s sole discretion based on market opportunities or other factors, and are not intended to be a commitment to future product or feature availability in any way. Nothing contained in these materials is intended to, nor shall have the effect of, stating or implying that any activities undertaken by you will result in any specific sales, revenue growth or other results.

Performance is based on measurements and projections using standard IBM benchmarks in a controlled environment. The actual throughput or performance that any user will experience will vary depending upon many factors, including considerations such as the amount of multiprogramming in the user's job stream, the I/O configuration, the storage configuration, and the workload processed. Therefore, no assurance can be given that an individual user will achieve results similar to those stated here.

Adobe, the Adobe logo, PostScript, and the PostScript logo are either registered trademarks or trademarks of Adobe Systems Incorporated in the United States, and/or other countries.

Java and all Java-based trademarks are trademarks of Sun Microsystems, Inc. in the United States, other countries, or both.

Microsoft and Windows are trademarks of Microsoft Corporation in the United States, other countries, or both.

ries in the United States and other countries.

Linux is a registered trademark of Linus Torvalds in the United States, other countries, or both. Other company, product, or service names may be trademarks or service marks of others.

All references to OpenFinancial, Greenwell and Open Bier refer to a fictitious company and are used for illustration purposes only.