Gerenciando conteúdo em Portais Java usando Portlets

(1)

portlet_

Gerenciando

conteúdo em

Portais Java

usando Portlets

Como a especificação dos Portlets pode

ajudar a gerenciar grandes Portais no

ambiente Java

O artigo irá mostrar como utilizar a tecnologia dos Portais em Java

para rapidamente criar websites. Esses websites podem, facilmente,

agregar conteúdos de fontes diferentes e a disponibilização deste

conteúdo pode ser feita por usuários sem conhecimento técnico na

tecnologia.

(2)

André Luís Fonseca | andreluisfonseca@yahoo.com.br é formado em Ciência da Computação pela Universidade Federal de São Carlos (UFSCar). Com mais de 12 anos de experiência, já trabalhou em empresas de diversos setores, como: Telecom, Bancos e Indústria utilizando Java, PHP e C. Possui as certificações SCJP, SCWCD, SCBCD e SCEA (I).

U

m Portal pode ser considerado como uma “plata-forma” para construção de websites e aplicações web. Na sequência algumas situações comuns onde encontramos o uso de Portais:

» Websites que apresentem conteúdos

diferen-tes dependendo do “status” do usuário logado.

» Websites que apresentem conteúdos

diferen-tes dependendo das “permissões” do usuário logado.

» Websites que necessitem de integração com outras aplicações web.

» Websites que permitem que grupos de usuá-rios colaborem com a construção da aplicação. » Websites que necessitem “salvar” o conteúdo

para ser recuperado no próximo “login” do usuário.

A criação destes websites utilizando a tecnologia dos Portais é feita agregando-se Portlets em uma pá-gina.Um Portlet contém uma parte específica de um conteúdo (uma informação ou um serviço) podendo ser incluído como parte de uma página de um Por-tal. Ele é gerenciado por um Portlet Container, que processa as requisições e gera o conteúdo dinami-camente (semelhante a uma Servlet Java, portanto). Portlets são usados por Portais como “componentes plugáveis” de interfaces com o usuário que provêem

uma camada de apresentação para sistemas de in-formação.

O conteúdo dinâmico gerado por um Portlet é conhecido também como fragmento. Um fragmento é um pedaço de código em uma linguagem de mar-cação (como, por exemplo, HTML, XML ou WML) que segue algumas regras específicas e pode ser agrupa-do com outros fragmentos a fim de formar um agrupa- do-cumento completo. Dessa forma, o conteúdo de um Portlet é normalmente agregado com o conteúdo de outros Portlets a fim de formar uma página em um Portal.

Os clientes web interagem com um Portlet en-viando requisições para o Portal e recebendo a res-posta com o conteúdo gerado. O conteúdo gerado pelo Portlet difere para cada usuário dependendo da configuração do Portlet.

Existem duas especificações organizadas pela JCP (Java Community Process) com o objetivo de es-tabelecer as definições para os Portlets em Java, são elas: JSR168 e JSR286 (Portlet 2.0). Alguns portais implementam apenas uma delas, outros, são compa-tíveis com as duas. Felizmente não temos quebra de compatibilidade entre as especificações. O ciclo de vida, API para acesso, além de personalização, apre-sentação e segurança dos Portlets também é definido pelas especificações.

Figura 1. Cada Portlet é responsável pela geração de um fragmento de conteúdo.

Estadão PORTLET Estado dE são paulo o Globo folha dE são paulo o Globo PORTLET folha dE são paulo PORTLET iGoogle

(3)

Um Portlet Container é responsável por fornecer um ambiente de execução (runtime) e gerenciar o ciclo de vida de um Portlet. Ele é responsável tam-bém por tratar as requisições feitas pelos clientes do Portal e endereçá-las para os Portlets específicos, conforme mostrado na figura 1, entretanto ele não é responsável por agregar o conteúdo dos diversos Por-tlets, isso é responsabilidade do Portal.

Outra responsabilidade do Portlet Container é a de armazenar uma referência para cada Portlet, per-mitindo que o seu estado seja recuperado.

Na sequência temos alguns exemplos de Por-tais, como o iGoogle (que será descontinuado, sen-do substituísen-do pelo Google Play) e o GWT Portlets Demo, mostrados nas figuras 2 e 3, respectivamente. Os links para acessar estes portais podem ser consul-tados nas referências do artigo.

Figura 2. Portal do Google (iGoogle) contendo alguns gadgets (Portlets).

Figura 3. “Showcase” do Portal GWT-Ext.

Portlet x Servlet

Existem algumas semelhanças entre um Portlet e uma Servlet em Java. Da mesma forma que uma Ser-vlet, um Portlet é um componente web que possui o ciclo de vida gerenciado por um container e é capaz de gerar conteúdo dinamicamente. Falando tecnica-mente, um Portlet é uma classe Java que implementa a interface “javax.portlet.Portlet” ou extende a classe “javax.portlet.GenericPortlet“ e é empacotado e ins-talado como um arquivo/artefato WAR dentro de um Portlet Container. Abaixo temos um resumo das simi-laridades e diferenças entre Portlets e Servlets.

Portlets são similares às Servlet em Java no sen-tido de que:

» Portlets são gerenciados por um container es-pecífico.

» Portlets são capazes de gerar conteúdo dinami-camente.

» O ciclo de vida dos Portlets é gerenciado por um container.

» Portlets interagem com clientes web através do paradigma de requisição/resposta.

Portlets são diferentes das Servlets em Java no sentido de que:

» Portlets apenas geram fragmentos de markup, não documentos completos.

» Portlets não podem ser acessados diretamente através de URLs. Apenas a página que contém o Portlet pode ser acessada através de uma URL.

(4)

» Portlets não podem gerar conteúdos arbitrá-rios, uma vez que o conteúdo gerado pelo Por-let irá fazer parte de uma página de um Portal. Por exemplo, se o Portal está requisitando um conteúdo do tipo html/text o Portlet só poderá gerar conteúdo neste formato.

Exemplo de um Portlet em Java

A Listagem 1 mostra um exemplo de código em Java para uma Portlet. Neste exemplo estamos esten-dendo a classe GenericPortlet. Uma Portlet tem três modos de exibição: EDIT, VIEW e HELP. Pelo menos um deles deve ser definido no código. Isso pode ser feito sobrescrevendo os métodos “doEdit”, “doView” ou “doHelp” ou então utilizando a anotação “Render-Mode”. O exemplo a seguir apenas escreve na respon-se a String “Olá Mundo!”.

Listagem 1.

Código em Java de um Portlet.

import java.io.IOException; import java.io.PrintWriter; import javax.portlet.GenericPortlet; import javax.portlet.PortletException; import javax.portlet.RenderRequest; import javax.portlet.RenderResponse; import javax.portlet.RenderMode; import java.io.IOException; import java.io.PrintWriter; import javax.portlet.GenericPortlet; import javax.portlet.PortletException; import javax.portlet.RenderRequest; import javax.portlet.RenderResponse; import javax.portlet.RenderMode; publicclass HelloWorldPortlet extends GenericPortlet {

@RenderMode(name = “VIEW”)

publicvoidsayHello(RenderRequest request, RenderResponse response)

throws PortletException, IOException { PrintWriter out = response.getWriter(); out.println(“Olá Mundo!”);

} }

Acessando um Portal

Quando um cliente acessa um Portal as seguintes ações acontecem:

» O cliente, após se autenticar, faz uma requisi-ção HTTP para o Portal.

» A requisição é tratada pelo Portal.

» O Portal define qual Portlet (ou Portlets) deverá tratar a requisição recebida.

» O Portal invoca os Portlets responsáveis,

(5)

vés do Portlet Container, para obter os frag-mentos de conteúdo que devem ser incluídos na página do Portal.

» O Portal agrupa os conteúdos gerados pelos

diferentes Portlets em uma página do Portal e exibe de volta para o cliente.

Configurando o Ambiente no Eclipse

Nessa seção iremos ver como utilizar o Eclipse junto com um plugin para o Portal Liferay para criar uma aplicação de exemplo e publicá-la no Tomcat.

O Portal Liferay – usaremos a versão Community Edition – é escrito em Java e distribuído sobre a licen-ça GNU LGPL. Para o nosso ambiente utilizaremos a versão que vem empacotada com o Tomcat, entre-tanto poderíamos utilizar outras versões compatíveis com outros servidores, como Glassfish, JBoss ou Jetty. O Liferay é o ambiente de execução onde iremos pu-blicar nossos Portlets.

Utilizaremos também o Liferay IDE que é um plu-gin para o desenvolvimento de Portlets o qual pode ser baixado gratuitamente a partir de um Update Site do Eclipse.

Instalando o Liferay Portal

Utilize o link das referências do artigo para baixar a versão Community Edition do Liferay empacotada com o Tomcat. Apenas descompacte o arquivo zip baixado para uma pasta qualquer. A figura 4 mostra onde pode ser feito esse download.

Para iniciar o Portal Liferay precisamos apenas iniciar o Tomcat. No caminho onde o arquivo foi des-compactado vá até a pasta do Tomcat, depois pasta bin e dê um duplo clique no arquivo startup.bat ou rode o arquivo startup.sh, como mostrado na figura 5, dependendo se você estiver no Windows ou Linux, isso irá iniciar o Tomcat juntamente com o Portal.

Figura 5. Para iniciar o Portal Liferay basta iniciar o Tomcat da pasta descompactada.

Depois de terminada a inicialização do Tom-cat podemos então acessar o Liferay através da URL http://localhost:8080.

Algumas configurações precisarão ser feitas no primeiro acesso como: linguagem padrão, primeiro e último nome do usuário, e-mail do usuário e nome do Portal. A figura 6 mostra a tela onde isso é feito. Para fazer as configurações clique no botão “Basic Confi-guration.” O Liferay vem de uma base de desenvolvi-mento para o HSQLDB, que é um banco de dados em memória, entretanto suporta outros bancos de dados, como Oracle, MySQL, Firebird, SQL Server, entre ou-tros. Após finalizar as configurações, clique no botão “Ir para meu Portal”. Você pode também selecionar Português do Brasil como linguagem padrão. Altere também a sua senha de acesso ao Portal, como mos-trado na figura 7.

Figura 6. No primeiro acesso ao Portal Liferay algumas configura-ções devem ser realizadas.

Figura 7. Altere sua senha para acesso.

Instalando o Eclipse com o plugin para

o Liferay

Agora iremos instalar o plugin do Liferay no Eclipse. Utilizaremos a versão do Eclipse Juno para desenvolvedores JEE. Após ter feito o download desta versão (link nas referências) vá até o menu superior e

(6)

selecione a opção “Help” > “Eclipse Marketplace”. No campo find, digite “Liferay” e pressione “Enter” para a busca. Deve aparecer a tela apresentada na figura 8. Clique no botão “Install”, mantenha os valores pré--selecionados e prossiga digitando “Next”. Não se es-queça de aceitar a licença.

Figura 8. Instalando o plugin do Liferay pelo Eclipse Marketplace.

Configurando o plugin para o SDK do

Liferay

Antes de criar um projeto para o Liferay no Eclip-se é necessário configurar o SDK (Software Develo-pment Kit) que é o kit de desenvolvimento para que você consiga fazer o deploy de seus projetos no Portal Liferay.

Vá até a página de downloads (link presente nas referências) e faça o download do plugin SDK, como mostrado na figura 9.

Figura 9. Faça o download do Plugin SDK.

Depois de terminado o download no Eclipse, se-lecione no menu “Window” > “Preferences” e depois a opção “Liferay” > “Installed Plugin SDKs” e clique no botão “Add” (adicionar). Será aberta a janela mos-trada na figura 10.

Figura 10. Adicione um novo Plugin SDK para o Liferay.

No pop-up “New Liferay Plugin SDK” preencha

com o caminho para onde foi descompactado o ar-quivo de download do Plugin SDK. Mantenha selecio-nado “Add Eclipse .project file (if it does not exist)”. Após a configuração, o SDK deve aparecer na lista como mostrado na figura 11.

Figura 11. Plugin SDK configurado no Eclipse para o Liferay.

Criando um novo Server Runtime para o

Tomcat

Para iniciar o Tomcat dentro do Eclipse, você pre-cisa criar um novo Server Runtime apontando para o Tomcat que vem junto com o Liferay (download do arquivo ZIP). No menu do Eclipse, vá em “Window”

(7)

> “Preferences” > “Runtime Environment”. Clique no botão “Add”, selecione “Apache Tomcat v7.0”, como mostrado na figura 12, depois “Next”, então selecio-ne no Windows Explorer a pasta do Tomcat do Life-ray. Pronto! Agora já temos o ambiente configurado para desenvolvermos os nossos primeiros Portlets no Eclipse!

Figura 12. Adicione um novo Server Runtime para o Tomcat 7.

Figura 13. No menu do Eclipse crie um novo “Liferay Project”.

Figura 14. Selecione “Plugin Type” como “Portlet” nas configu-rações do projeto.

Figura 15. Selecione Liferay MVC como Portlet Framework.

Criando projetos para Liferay no Eclipse

Agora que temos todo nosso ambiente configu-rado podemos criar um projeto no Eclipse para o Li-feray. No menu do Eclipse selecione “File” > “New” > “Liferay Project”, como mostrado na figura 13.

Nas configurações de projeto selecione Plugin Type como Portlet, como mostrado na figura 14.

Na próxima tela apresentada na figura 15, se-lecione “Liferay MVC” para “Portlet Framework” (o Liferay possibilita também desenvolver os Portlets usando JSF ou Vaadin Framework).

Após finalizar a criação do projeto teremos a es-trutura no Eclipse mostrada na figura 16.

A pasta docroot é a raiz da aplicação contento todo o conteúdo web. Ela apresenta os arquivos de configuração, css, javascript e tag libraries (pasta tld). O Eclipse gera também scripts do ANT para manu-tenção do projeto. Este projeto “em branco” já é o su-ficiente para adicionarmos conteúdo no Liferay, isso sem ter criado nenhuma classe “Java”.

(8)

Instalando o projeto

HelloWorldLiferay-portlet no Liferay

Vamos agora fazer o “deploy” do projeto no Por-tal. No Eclipse, clique com o botão direito sobre o projeto e selecione a opção “Run As” > “Run on Ser-ver”, como mostrado na figura 17. Selecione o Tomcat configurado anteriormente e clique em “Finish”. Isso irá iniciar o Portal Liferay e fazer o deploy de nosso projeto.

Figura 17. Fazendo o deploy do projeto no Servidor.

Figura 16. Estrutura do projeto HelloWorldLiferay no Eclipse.

Finalizado o deploy temos agora o Portlet Hello-WorldLiferay disponível para ser instalado no Portal. Acesse o Portal (http://localhost:8080) vá até o menu superior e selecione a opção “Adicionar” > “Mais”, como mostrado na figura 18.

Figura 18. Adicionando conteúdo ao Liferay.

Na janela de busca, digite “HelloWorldLiferay”, que o Portlet será listado como na figura 19. Você pode depois clicar no link “Adicionar” ou apenas ar-rastar o Portlet para o Portal. Após ter sido adiciona-do o conteúadiciona-do adiciona-do Portlet, a figura 20 mostra como ele pode ser visualizado no Liferay.

(9)

Figura 19. Buscando o Portlet HelloWorldLiferay para ser adicio-nado ao Portal.

Figura 20. Conteúdo do Portlet HelloWorldLiferay adicionado ao Portal.

Instalando um projeto no Liferay sem

utilizar o Eclipse

Nessa seção iremos mostrar como fazer o deploy de um novo projeto no Portal Liferay sem utilizar o Eclipse. Para isso utilizaremos o plugin SDK (já confi-gurado) além do Apache ANT.

Após ter instalado e configurado o Apache ANT – para instalar e configurar o ANT consultar as refe-rências do artigo – abra um prompt de comando do DOS na pasta portlets dentro do diretório onde foi instalado o plugin SDK e digite o comando a seguir: ant -Dportlet.name=ola -Dportlet.display.name=”Ola MundoJ!” create

Podemos perceber pela saída do prompt de co-mando que foi criado um novo projeto de Portlets na pasta portlets de nome ola-portlet. Esse projeto tem praticamente a mesma estrutura do projeto criado no Eclipse e já pode ser instalado na nossa instância do Portal Liferay.

Ainda usando o prompt do DOS vá até a pasta ola-portlet – que acabou de ser criada no passo ante-rior – e digite o seguinte comando: ant deploy. Isso irá fazer com que o projeto seja disponibilizado no Liferay.

Após ter sido feito o deploy você pode adicionar o portlet ao Portal da mesma forma que foi feita antes através do Menu Adicionar.

Portlets com Spring MVC

Na sequência iremos mostrar como utilizar o Spring Framework para facilitar a integração com os Portlets em Java. Crie um “Novo Projeto Liferay” no Eclipse e chame de “helloWorld”. Faça o download da última versão do Spring Framework (no momento da escrita do artigo 3.2.3). Você irá precisar também dos jars do commons-logging (Apache) e também do JSTL. Na pasta “docroot/WEB-INF/lib” teremos a es-trutura mostrada na figura 21.

Crie uma nova classe Java e chame-a de “Hello-WorldController”. Na Listagem 2 temos o código que deve ser escrito nessa classe.

(10)

Figura 22. Instalando o projeto ola-portlet no Portal Liferay usando o ANT.

(11)

A interface “org.springframework.web.portlet.mvc. Controller” faz o papel da interface “javax.portlet. Portlet”. Ela é usada pelo “Portlet Container” para invocar os Portlets. O processamento das requisições aos Portlets é dividido em duas etapas pelo Contai-ner: primeiro é processado a “Action” da requisição, depois é gerado o “Conteúdo” que será exibido pelo Portlet no Portal. No caso da interface Controller os métodos responsáveis por estes processamentos são “handleActionRequest” (equivalente ao método processAction da interface Portlet) e “handleRen-derRequest” (equivalente ao método render da classe Portlet), respectivamente. Mais detalhes podem ser encontrados na especificação dos Portlets e também na documentação do Spring (link nas referências). Não vamos entrar em detalhes no uso do Framework Spring para não sobrecarregar o leitor de informa-ções.

Na sequência temos uma breve explicação dos principais arquivos de configuração do projeto. Estes arquivos devem estar presentes na pasta WEB-INF. Listagem 3. Arquivo liferay-portlet.xml, responsável por dizer ao Liferay quais portlets a aplicação possui.

<?xmlversion=”1.0”?>

<!DOCtYPE liferay-portlet-app PUBLIC “-//Liferay//DTD Portlet Application 6.1.0//EN”

“http://www.liferay.com/dtd/liferay-portlet-app_6_1_0.dtd”> <liferay-portlet-app> <portlet> <portlet-name>helloWorld</portlet-name> <instanceable>true</instanceable> </portlet> </liferay-portlet-app>

Listagem 4.

Arquivo portlet.xml, responsável pelas configurações gerais dos Portlets (JSR168 e JSR 286).

<?xmlversion=”1.0” encoding=”UTF-8”?>

<portlet-app xmlns=”http://java.sun.com/xml/ns/portlet/

portlet-app_2_0.xsd” xmlns:xsi=”http://www.w3.org/2001/ XMLSchema-instance”version=”2.0” xsi:schemaLocation=”http://java.sun.com/xml/ns/ portlet/portlet-app_2_0.xsd http://java.sun.com/xml/ns/portlet/portlet-app_2_0.xsd”> <portlet> <portlet-name>helloWorld</portlet-name> <portlet-class>org.springframework.web.portlet. DispatcherPortlet</portlet-class> <supports> <mime-type>text/html</mime-type> <portlet-mode>view</portlet-mode> </supports>

Figura 24. Jar’s necessários para o projeto do Spring MVC Portlet.

Listagem 2. Código da classe HelloWorldController.

package mundoj.portlets; import java.util.HashMap; import java.util.Map; import javax.portlet.ActionRequest; import javax.portlet.ActionResponse; import javax.portlet.RenderRequest; import javax.portlet.RenderResponse; import org.springframework.web.portlet.ModelAndView; import org.springframework.web.portlet.mvc.Controller; publicclass HelloWorldController implements Controller {

@Override

publicvoidhandleActionRequest(ActionRequest req, ActionResponse resp) throws Exception {

}

@Override

public ModelAndView handleRenderRequest( RenderRequest req, RenderResponse resp) throws Exception {

Map<String, Object> model = new HashMap<String, Object>();

model.put(“helloWorldMessage”, “Hello World”); returnnewModelAndview(“helloWorld”, model); }

}

(12)

<resource-bundle>Language-ext</resource-bundle> </portlet>

</portlet-app>

Listagem 5.

Arquivo helloWorld-portlet.xml, respon-sável pelas configurações do Spring MVC Porlet.

<?xmlversion=”1.0” encoding=”UTF-8”?> <beans xmlns=http://www.springframework.org/schema/ beans xmlns:xsi= ”http://www.w3.org/2001/XMLSchema-instance” xmlns:p=http://www.springframework.org/ schema/p xmlns:context=http://www.springframework.org/ schema/context xsi:schemaLocation=” http://www. springframework.org/Schema/beans http://www.springframework.org/schema/beans/spring- beans-3.0.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsd”>

<bean id=”helloWorldController”

class=”mundoj.portlets.HelloWorldController”/>

<bean id=”portletModeHandlerMapping”

class=”org.springframework.web.portlet.handler. PortletModeHandlerMapping”>

Figura 26. Tela de Administração do Apache Pluto. Figura 25. Tela Inicial do Apache Pluto.

(13)

</map> </property> </bean>

<bean id=”viewResolver”

class=”org.springframework.web.servlet.view. InternalResourceViewResolver”>

<property name=”viewClass”

value=”org.springframework.web.servlet.view. InternalResourceView” />

</bean> </beans>

Listagem 6.

Arquivo liferay-display.xml , arquivo de configurações do Liferay, neste caso define em qual categoria o Portlet pertence.

<?xmlversion=”1.0”?>

<!DOCtYPE display PUBLIC “-//Liferay//DTD Display 6.1.0//EN” “http://www.liferay.com/dtd/liferay-display_6_1_0.dtd”>

</category> </display>

Listagem 7.

Arquivo web.xml de configuração da aplicação, configura ContextLoaderListener e ViewRen-dererServlet para o Spring.

<?xmlversion=”1.0” encoding=”UTF-8”?>

<web-app xmlns:xsi=”http://www.w3.org/2001/ XMLSchema-instance”xmlns=”http://java.sun.com/xml/ ns/j2ee”xmlns:javaee=”http://java.sun.com/xml/ns/ javaee”xmlns:web=”http://java.sun.com/xml/ns/javaee/ web-app_2_5.xsd”xsi:schemaLocation=”http://java.sun. com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd”id=”WebApp_ID”version=”2.4”>

<listener> <listener-class>org.springframework.web.context. ContextLoaderListener</listener-class> </listener> <servlet> <servlet-name>view-servlet</servlet-name> <servlet-class>org.springframework.web .servlet.ViewRendererServlet</servlet-class> <load-on-startup>1</load-on-startup> </servlet> <servlet-mapping> <servlet-name>view-servlet</servlet-name> <url-pattern>/WEB-INF/servlet/view</url-pattern> </servlet-mapping> </web-app>

Apache Pluto e Jetspeed

O Apache Pluto é a implementação de referên-cia para as especificações de Portlets em Java. Ele é também um Portlet Container provendo um ambien-te de execução para os Portlets, como mostrado na figura 25. As duas especificações de Portlets (JSR168 e JSR286) são completamente suportadas.

Para instalar o Apache Pluto você deve seguir o seguinte procedimento:

» Faça o download da última versão (consultar o site nas referências do artigo).

» Descompacte o arquivo em uma pasta

qual-quer.

» Rode o arquivo startup.bat ou startup.sh (que ficam dentro da pasta bin) dependendo se você está no Windows ou Linux.

» Acesse no browser a URL http://localhost:8080/ pluto/portal

» Se autentique no Portal usando usuário=pluto e senha=pluto.

Na página de exemplos temos alguns testes que podem ser executados. A aba “Pluto Admin” permite adicionar ou remover páginas no Portal ou instalar uma nova aplicação Portlet. Essa interface é exibida na figura 26.

O Apache Jetspeed 2 é uma plataforma para o de-senvolvimento de Portais semelhante ao Liferay. Ele é distribuído sobre a Licença Apache e é todo desen-volvido em Java e outros padrões abertos de mercado. A última versão disponível quando na escrita deste artigo é a 2.2.2 lançada em outubro de 2011. O Jetspeed provê os mesmos serviços comuns de um Portal como: segurança centralizada, integração en-tre aplicações, personalização, componentização de conteúdo (baseada na especificação Portlet) além de outros serviços.

(14)

> Especificação Portlet (JSR 168) http://www.jcp.org/en/jsr/detail?id=168 > Especificação Portlet 2.0 (JSR 286) http://www.jcp.org/en/jsr/detail?id=286 > Especificação Portlet Bridge para JSF http://www.jcp.org/en/jsr/detail?id=301 > Javadoc Liferay

Podemos acessar uma demo do Jetspeed na se-guinte URL: https://ulc-community.canoo.com/jets-peed/.

A vantagem de se usar o Jetspeed é que ele é bem mais leve do que o Liferay e é baseado apenas em Java e XML. Entretanto o Liferay possui mais funcio-nalidades além de ser provavelmente o que possui a maior base de usuários hoje em dia. Além destes dois Portais mencionados no artigo temos outros tantos não apenas em Java, o leitor deve escolher aquele que se adaptar melhor as suas necessidades.

Considerações Finais

Portais Web são indicados quando temos atuali-zação constante de conteúdo além de muitos usuários acessando estes conteúdos de forma personalizada e persistente. As especificações JSR 168 e JSR 286 têm como objetivo padronizar a criação destes Portais no ecossistema Java.

O Liferay é uma das soluções de Portais mais adotadas hoje. Ele é escrito em Java e é open source (na versão Community). Pode ser instalado em vários ambientes, possuindo fácil configuração, suportando vários bancos de dados, application servers e/ou ser-vlet containers diferentes. Possui também uma base muito grande de clientes e desenvolvedores espalha-dos pelo mundo. Além disso, possui boa documenta-ção e muitos exemplos espalhados pela web.

Os projetos Pluto e Jetspeed 2 podem ser consi-derados como boas alternativas para o Liferay. A van-tagem principal é que o Apache Pluto é a implemen-tação de referência das especificações de Portlets em Java. Ele pode servir como uma boa fonte de apren-dizado para depois escolhermos que implementação adotar no desenvolvimento de nossos Portais.

http://docs.liferay.com/portal/6.1/javadocs/overview-summary.html

> iGoogle (Portal Google) http://www.google.com.br/ig > GWT Portlets Demo

http://095-beta.latest.gwtportletdemo.appspot.com/ > Liferay Faces Demos

http://www.liferay.com/pt/community/liferay-projects/ liferay-faces/demos

> Página de Download do Liferay Portal (Community Edition e Plugin SDK)

http://www.liferay.com/downloads/liferay-portal/ available-releases

> Página de Download do Eclipse

http://www.eclipse.org/downloads/packages/release/ juno/sr1

> Lista de Portais

http://en.wikipedia.org/wiki/List_of_enterprise_portal_ vendors

> Artigo Portlets com Spring MVC

http://books.dzone.com/articles/hello-world-portlet-using-Spring-3-portlet-MVC

> Artigo Portlets com Spring MVC – Parte 2

http://books.dzone.com/articles/spring-30-portlet-mvc-part-2

> Código-fonte do Livro Portlets in Action

https://code.google.com/p/portletsinaction/downloads/ list

> Download Apache Pluto

http://www.apache.org/dyn/closer.cgi/portals/pluto/ > Demo Liferay

https://ulc-community.canoo.com/jetspeed/ Instalando e Configurando o Apache ANT

http://www.vogella.com/articles/ApacheAnt/article.html

> Livro Portlets in Action

> Livro Liferay in Action