Novidades do GlassFish 3.1 - Artigo Java Magazine 91

O GlassFish serve para hospedar aplicações Web e corporativas que sigam o padrão Java EE 6. Em sua versão anterior, 3.0, o servidor já era compatível com a versão 6 do padrão Java para aplicações enterprise, porém as novidades da versão 3.1 fazem do GlassFish um servidor mais robusto e preparado para contextos de produção.

Descobrir, experimentar e aprender funcionalidades novas de uma ferramenta como o GlassFish é útil para desenvolvedores de aplicações Web e corporativas, além de arquitetos de software ou gerentes de projeto, que devem decidir um servidor a ser utilizado em um determinado projeto de desenvolvimento.

O GlassFish 3.0 foi desenvolvido como implementação de referência do padrão Java EE 6 e, agora em sua versão 3.1, conta com novas funcionalidades que adicionam características como alta disponibilidade, escalabilidade e tolerância a falhas, que são essenciais para um servidor de produção que hospede aplicações de médio e grande porte. Neste artigo, mostramos como instalar o GlassFish e integrá-lo com as duas IDEs open source mais utilizadas atualmente – Eclipse e NetBeans (Figuras 1 a 4) e, em seguida, detalhamos quatro das novidades da versão 3.1: administração de clusters (Listagens 1 a 3, Figuras 5 a 8), versionamento de aplicações, recursos com escopo de aplicação (Listagens 4 e 5) e a API RESTful de administração (Listagem 6, Figura 9). Para cada funcionalidade, são dadas instruções para que o leitor possa experimentá-las.

Java é uma plataforma de desenvolvimento bastante versátil. Subdividida em várias edições, cada uma possui um propósito específico: Java SE para desenvolvimento de aplicações desktop, Java ME para aplicações móveis, Java Card para desenvolvimento em Smart Cards, etc. Uma destas edições é a Enterprise Edition, ou Java EE, que encontra-se atualmente na versão 6. O Java EE permite a criação de aplicações Web e corporativas. Por “aplicação corporativa” entende-se um software que tem por objetivo resolver um problema de uma empresa ou organização como um todo e, por este motivo, possui requisitos particulares, como escalabilidade, segurança, acessibilidade, dentre outros.

Para executarem, aplicações corporativas devem ser implantadas em servidores de aplicação Java. Um destes servidores é o GlassFish, desenvolvido pela Oracle e disponibilizado em versões gratuita e comercial. O GlassFish nasceu em 2005 como um projeto da Sun a partir do servidor de aplicações comercial já existente na empresa, o Sun Java Application Server 9. Sua versão 1.0 foi desenvolvida para servir de implementação de referência do padrão Java EE 5 (uma implementação completa da especificação construída para demonstrar como ela funciona).

Como o objetivo desta primeira versão era prover uma implementação de referência para o Java EE 5, lhe faltavam funcionalidades que tornassem o GlassFish um servidor interessante para uso em produção, como alta disponibilidade e tolerância a falhas. Assim, este foi o objetivo da versão 2.0 do GlassFish, que adicionou capacidade de clustering (aglomerado de computadores) ao servidor.

Com a publicação, em dezembro de 2009, da nova versão do padrão para aplicações corporativas, o Java EE 6, o GlassFish foi novamente utilizado como implementação de referência e a história se repetiu: o GlassFish 3.0 provia uma implementação completa da especificação Java EE 6, porém sem funcionalidades que o tornassem um servidor de produção escalável e disponível. Somente agora, no final de fevereiro deste ano, que as antigas funcionalidades de clustering além de uma série de outras melhorias foram adicionadas ao servidor com o lançamento do GlassFish 3.1. Algumas destas melhorias – conforme divulgadas pela própria equipe do GlassFish – são:

• Evocação dinâmica de serviços (somente os serviços utilizados são iniciados);
• Melhorias de extensibilidade, tanto no servidor quanto na interface de administração;
• Ciclos de inicialização e implantação (deploy) 29% mais rápidos que na versão 3.0.1;
• Sessão, Stateful Session Beans e EJB Timers são preservados entre re-deploys;
• Melhor integração com ferramentas (NetBeans, Eclipse, plug-in Maven para testes unitários);
• Desempenho da funcionalidade de alta disponibilidade 34% melhor do que a versão 2.1.1;
• Administração centralizada dos clusters, com escalabilidade melhorada (até 100 instâncias gerenciadas);
• Suporte a autenticação via PAM;
• Suporte a upgrade da versão 2.x ou 3.x para a 3.1;
• Mais funcionalidades disponíveis na versão comercial do GlassFish (Oracle GlassFish Server), como interoperabilidade com WebSphere e WebLogic, backup e recuperação, analisador de desempenho, balanceamento de carga, etc.

Este artigo, no entanto, demonstra por meio de exemplos quatro das diversas novidades do GlassFish 3.1, a saber:

• Gerenciamento de clusters: criação de múltiplas instâncias do servidor, locais ou remota, com replicação da sessão para alta disponibilidade das aplicações, além de escalabilidade por meio de balanceamento de carga;
• Versionamento de aplicações: possibilidade de implantar diferentes versões da mesma aplicação, adicionando tags que identificam cada versão, podendo habilitar a versão desejada em qualquer momento;
• Recursos com escopo de aplicação: para simplificar a implantação de aplicações, é possível declarar recursos (como conexões a banco de dados, por exemplo) dentro do pacote EAR/WAR da aplicação, sem precisar utilizar a administração do servidor. Tais recursos terão escopo de aplicação, sendo acessíveis somente dentro das mesmas;
• API RESTful para administração do servidor: permite ler e modificar recursos da configuração do GlassFish por meio de uma interface RESTful, facilitando a escrita de programas que integrem com o GlassFish.

Apesar disso, o artigo começa detalhando o download e a instalação do servidor GlassFish e a sua integração com as duas IDEs open source mais utilizadas atualmente: o Eclipse e o NetBeans.

Download e Instalação

Assim como em versões anteriores, o GlassFish pode ser utilizado sozinho ou integrado com uma IDE. Nesta seção serão descritos os procedimentos de instalação do GlassFish nas IDEs Eclipse e NetBeans. Veja na seção Links os endereços para download de todas estas ferramentas.

NetBeans 7

A versão mais recente desta IDE, o NetBeans 7.0 (Beta 2 no momento da escrita deste artigo), já vem de fábrica com o plug-in de integração com o GlassFish 3.1. Na verdade, ao fazer o download do pacote (bundle) “Java EE” e executar seu assistente de instalação, o servidor GlassFish 3.1 será instalado juntamente com o NetBeans, que já estará pronto para uso.

Para testar a integração, criaremos um novo projeto Java EE 6 e faremos sua implantação no servidor utilizando o NetBeans. Deste modo, clique em Arquivo > Novo Projeto... e, na categoria Java EE, escolha Aplicativo Corporativo e clique no botão Próximo. Na tela seguinte, dê um nome qualquer ao seu projeto (ex.: HelloGlassFish) e clique novamente em Próximo. Na última tela do assistente, verifique que o servidor GlassFish Server 3.1 esteja escolhido e clique em Finalizar.

Feito isso, um projeto corporativo com uma página Web chamada JSP Page contendo a frase Hello, World! será criado. Portanto, se a aplicação for implantada no servidor será possível abrir esta página e verificar que a integração NetBeans – GlassFish funciona. Clique com o botão direito no seu projeto (HelloGlassFish) e escolha a opção Executar. Após alguns segundos o NetBeans terá iniciado o servidor GlassFish 3.1 e aberto o seu navegador Web padrão no endereço http://localhost:8080/HelloGlassFish-war/ (HelloGlassFish será substituído pelo nome que você escolheu para o projeto).

O gerenciamento do servidor GlassFish pode ser feito de dentro do NetBeans, abrindo a aba Serviços e expandindo o item Servidores, como mostra a Figura 1. A integração NetBeans – GlassFish permite realizar uma série de coisas, dentre elas: registrar domínios remotos e locais, iniciar (em modo normal ou depuração) e interromper o servidor, ver logs de domínios locais ou remotos, ver documentação JavaDoc da API Java EE 6 dentro da IDE e criar e registrar recursos do GlassFish. Veremos algumas destas ferramentas ao longo do artigo.

Quando uma tarefa de administração não puder ser feita diretamente pela IDE, devemos abrir o console de administração, clicando com o botão direito em GlassFish Server 3.1 e escolhendo a opção Visualizar Console Admin. Algumas das demonstrações feitas neste artigo terão que ser feitas nesta interface de administração.

Eclipse 3.6 e GlassFish plug-in

O Eclipse não vem com suporte nativo para o GlassFish, mas é possível instalar facilmente o plug-in responsável pela integração da IDE com o servidor. Para fazê-lo, após instalar e executar o Eclipse, clique no menu Help > Install New Software... e insira o endereço do Update Site do GlassFish – http://download.java.net/glassfish/eclipse/helios – no campo Work with e pressione Enter. A lista de componentes será preenchida com as seguintes opções, como nos mostra a Figura 2:

• GlassFish 3.1 Application Server runtime: o servidor GlassFish (caso você não tenha instalado separadamente);
• Java EE 5 Documentation: documentação do Java EE 5;
• Java EE 6 Documentation: documentação do Java EE 6;
• Oracle GlassFish Server Tools: o plug-in em si, que realiza a integração entre a IDE e o servidor de aplicações.

Selecione o servidor, o plug-in e, opcionalmente, a documentação do Java EE e conclua o assistente como se faz em qualquer instalação de plug-in para o Eclipse. Após reiniciar a IDE, teste a integração IDE – servidor da mesma forma sugerida para o NetBeans: criando um novo projeto corporativo e implantando-o no GlassFish.

Primeiro, troque a perspectiva clicando em Window > Open Perspective > Other... e selecionando Java EE na lista. Em seguida, clique em File > New > Enterprise Application Project. Dê um nome qualquer ao seu projeto (ex.: HelloGlassFish) e clique em Next. Na tela seguinte, marque a opção Generate application.xml deployment descriptor, clique no botão New Module..., selecione apenas módulos EJB e Web, clique em Finish e finalize o assistente para que os projetos sejam criados. Neste momento são criados três projetos: um projeto representa a aplicação corporativa como um todo (HelloGlassFish) e outros dois projetos representam seus módulos EJB (HelloGlassFishEJB) e Web (HelloGlassFishWeb).

Antes de testar a aplicação é preciso criar um EJB qualquer, do contrário o servidor mostrará uma mensagem de erro Invalid ejb jar [HelloGlassFishEJB.jar]: it contains zero ejb. Portanto, clique com o botão direito em HelloGlassFishEJB > ejbModule e escolha New > Session Bean (EJB 3.x). Preencha valores quaisquer para os campos Java package (ex.: hello) e Class name (ex.: HelloBean) e clique em Finish. Agora que a aplicação possui ao menos um EJB, pode ser implantada para testar o plug-in do GlassFish. Na visão Project Explorer, clique com o botão direito no projeto HelloGlassFish e selecione Run As > Run on Server. Em seguida, clique em Window > Show View > Console para acompanhar o GlassFish ser iniciado e, após concluída a implantação, abra o endereço http://localhost:8080/HelloGlassFishWeb/ em seu navegador Web preferido.

Assim como no NetBeans, no Eclipse é possível configurar alguns aspectos do servidor na visão Servers. O console de administração pode também ser acessado clicando com o botão direito no servidor Internal GlassFish 3.1 e escolhendo GlassFish > View Admin Console.

Instalação e execução separada do GlassFish

Se não quiser utilizar nenhuma IDE e desejar instalar o GlassFish separadamente, basta executar o assistente de instalação disponível para plataformas Windows, Linux e Mac (veja Links para o download). O servidor será instalado no diretório especificado durante o procedimento de instalação. Nas instruções a seguir, a variável $GF_HOME representa este diretório e deve ser substituída pelo caminho (path) da pasta que você escolheu para instalação do GlassFish em seu computador.

Após instalado, para executar o GlassFish, utilize a ferramenta de administração asadmin (a próxima subseção aborda alguns aspectos desta ferramenta). Abra um terminal (prompt de comando), acesse o diretório $GF_HOME/glassfish/bin e execute o seguinte comando:

asadmin start-domain 

Nos comandos demonstrados no artigo, usuários de Linux e Mac deverão incluir os caracteres ./ no início do comando (ex.: ./asadmin start-domain). Estes caracteres são necessários para indicar ao sistema operacional que o usuário deseja executar um programa que encontra-se no diretório atual.

Com o servidor executando, é possível acessar o console de administração abrindo um navegador Web na página http://localhost:4848/, como mostra a Figura 3. Repare também na figura que ao iniciar o GlassFish manualmente, o caminho para o log do servidor é informado caso o usuário queira acompanhar o que está acontecendo: $GF_HOME/glassfish/domains/domain1/logs/server.log.

Sem utilizar uma IDE, para implantar e testar uma aplicação existem duas alternativas: a primeira é copiar o arquivo EAR (ou WAR) da aplicação para o diretório $GF_HOME/glassfish/domains/domain1/autodeploy e acompanhar a implantação pelo log do servidor; a segunda é abrir o item Applications na árvore de tarefas do console de administração, clicar no botão Deploy... e preencher o formulário de implantação, especificando este mesmo arquivo EAR/WAR.

A ferramenta de administração asadmin

A distribuição do GlassFish conta com um programa chamado asadmin (no diretório $GF_HOME/glassfish/bin) que pode ser utilizado via terminal (prompt de comando) para iniciar e desligar o GlassFish, além de alterar uma série de configurações (que também podem ser modificadas utilizando o Console de Administração via interface Web).

O utilitário asadmin efetua alterações em instalações locais ou remotas do servidor GlassFish por meio de subcomandos. Alguns exemplos de subcomandos são start-domain (para iniciar um domínio do GlassFish), stop-domain (para desligar um domínio), deploy (para implantar uma aplicação), dentre outros.

A ferramenta pode funcionar em modo “comando único” ou “multi-comandos”. No primeiro caso, executa-se o comando asadmin [parâmetros do asadmin] [parâmetros do subcomando] e a ferramenta executa o subcomando especificado, retornando imediatamente depois para o terminal. No segundo caso, executa-se o comando asadmin [parâmetros do asadmin] (sem subcomando) e a ferramenta abrirá um prompt de comando interno do asadmin, onde os subcomandos podem ser especificados diretamente (usando [parâmetros do subcomando]). O modo multi-comandos é interessante quando se deve executar diversos subcomandos em sequência.

Para mais informações, você pode consultar a ajuda do asadmin. Os seguintes comandos são bastante úteis:

• asadmin help: mostra a sintaxe da ferramenta e seus possíveis parâmetros;
• asadmin list-commands: mostra os subcomandos existentes;
• asadmin help : mostra a sintaxe e os parâmetros de um subcomando específico (ex.: asadmin help deploy).

Instalando componentes do GlassFish com o Update Tool

O GlassFish possui uma ferramenta chamada Update Tool (ferramenta de atualização) que permite instalar componentes do servidor que não encontram-se ainda instalados, além de atualizar componentes já presentes.

Para executá-la, acesse o diretório $GF_HOME/bin/ e execute o programa updatetool (updatetool.bat no Windows). Caso a ferramenta não tenha sido instalada juntamente com o GlassFish, ela será instalada durante sua primeira execução (o que deve demorar alguns minutos, dependendo da sua conexão com a Internet).

Ao abri-la, os servidores GlassFish existentes em seu sistema serão listados à esquerda, abaixo de Application Images. Para cada servidor, é possível verificar os componentes disponíveis para instalação (Available Add-ons), para atualização (Available Updates) e os já instalados (Installed Components). A Figura 4 mostra a ferramenta aberta com a lista de componentes que podem ser instalados.

Para instalar um novo componente, clique em Available Add-ons, aguarde que a lista seja preenchida, marque os itens desejados e clique no botão Install. Para atualizar os componentes, clique em Available Updates e prossiga de maneira similar. A Figura 4 mostra os códigos de exemplo do Java EE marcados para instalação.

Clustering

Uma das novidades mais significativas desta nova versão do GlassFish é a capacidade de clustering, ou seja, a possibilidade de criar e administrar clusters (aglomerados) de servidores GlassFish com o mesmo domínio de aplicações. Antes de criar e administrar um cluster, no entanto, é interessante entender alguns conceitos básicos:

• Instância (de servidor): é um processo executando o servidor de aplicação GlassFish, hospedando as diversas aplicações corporativas implantadas no cluster;
• Nó (node): um computador que executa ao menos uma instância do cluster. Cada nó possui uma configuração do GlassFish e pode ser gerenciado localmente ou via SSH;
• Cluster: é uma entidade lógica que reúne as diversas instâncias espalhadas pelos diferentes nós que, juntos, servem um mesmo conjunto de aplicações corporativas;
• Domínio (de aplicações): um namespace administrativo, reúne as aplicações corporativas que nele forem implantadas ao redor de uma configuração GlassFish. Quando executado, um domínio funciona como um servidor de aplicações Java EE completo. O GlassFish permite que sejam criados diversos domínios;
• Servidor de administração do domínio: dentro de um cluster, é o servidor central, ou seja, aquele que administra o domínio de aplicações daquele cluster.

A utilização de múltiplos computadores servindo a mesma aplicação corporativa aumenta a escalabilidade e a disponibilidade desta aplicação com as seguintes características:

• Várias instâncias do servidor de aplicação executam em paralelo (na mesma máquina ou em máquinas distintas) com o mesmo domínio de aplicações (ou seja, servindo o mesmo conjunto de aplicações corporativas). As instâncias se comunicam entre si e funcionam como se fossem um servidor único;
• Quando a carga nas instâncias existentes ficar muito alta e a capacidade de processamento destes não forem suficientes para servir todas as requisições, é possível adicionar um novo servidor, criando uma nova instância no cluster;
• Se um dos servidores do cluster falha, uma outra instância assume e o serviço não é interrompido, garantindo a disponibilidade. Para isso, é preciso replicar tanto as aplicações quanto as sessões dos usuários em múltiplas instâncias do cluster.

Na prática, clustering no GlassFish funciona da seguinte maneira: cada nó do cluster deve ter o servidor GlassFish instalado de antemão. Utilizando o console de administração, o programa asadmin via terminal (prompt de comando), uma IDE integrada ou uma aplicação qualquer que utilize a interface REST provida pelo GlassFish, o administrador cria um cluster no servidor de administração do domínio e, em seguida, cria instâncias nos diferentes nós, adicionando-as ao cluster. Após iniciado, o cluster é gerenciado pelo GlassFish, que garante a comunicação entre as diferentes instâncias e o equilíbrio de carga (load balancing), distribuindo as requisições entre os participantes do cluster.

Criando um cluster e instâncias

Por meio de um terminal, o programa asadmin será utilizado para demonstrar a funcionalidade de clustering do GlassFish. Com o servidor GlassFish em execução, para criar um cluster, utilize o comando asadmin com o subcomando create-cluster:

asadmin create-cluster cluster1 

O nome cluster1 pode ser substituído por um outro nome que desejar dar ao cluster que está sendo criado. Em seguida, instâncias devem ser criadas e adicionadas a ele. Por exemplo, para criar duas instâncias (instance1 e instance2) em cluster1, utilize o comando create-local-instance, como nas seguintes linhas de comando:

  asadmin create-local-instance --cluster cluster1 instance1
  asadmin create-local-instance --cluster cluster1 instance2 

Sempre que quiser, é possível verificar todas as instâncias do servidor com o subcomando lista-instances. A opção -l retorna uma lista mais detalhada, indicando o nó e o cluster aos quais cada instância pertence:

asadmin list-instances -l 

Criando um nó remoto

Instâncias na mesma máquina auxiliam na disponibilidade da aplicação, pois no caso de um dos processos morrer o outro pode assumir. No entanto, no caso de falha do nó como um todo, e também com o objetivo de melhorar a escalabilidade, seria interessante criarmos um nó (e instâncias) em uma máquina remota. Podemos fazer isso nos beneficiando de mais uma novidade do GlassFish 3.1: gerenciamento centralizado. Ou seja, todo o cluster pode ser gerenciado a partir do GlassFish instalado na máquina local.

Nos exemplos a seguir, o SSH (Secure Shell) será utilizado para efetuar o gerenciamento centralizado. Para gerenciar nós via SSH, os seguintes requisitos devem ser cumpridos (mais detalhes podem ser encontrados na documentação do GlassFish sobre gerenciamento remoto via SSH – veja Links):

• Cada máquina remota deve ter o servidor GlassFish 3.1 instalado e em execução;
• Cada máquina remota deve ter o servidor SSHD instalado e um usuário registrado que tenha acesso de execução e escrita ao GlassFish. Você deve saber a senha deste usuário;
• A máquina local deve ter o cliente SSH instalado;
• Todas as máquinas remotas devem estar na mesma sub-rede da máquina local, pois a implementação do gerenciamento remoto utiliza UDP multicast para a comunicação, impondo tal limitação.

Fizemos, então, a seguinte instalação utilizando dois computadores em uma mesma rede: a máquina local possui IP 10.25.0.76, cliente SSH instalado e GlassFish 3.1 instalado e executando; a máquina remota possui IP 10.25.0.74, servidor SSHD e GlassFish 3.1 instalados e executando, usuário vitor e senha glassfish. Na máquina remota, o GlassFish foi instalado no diretório /home/vitor/Software/glassfish-3.1/.

Dada esta configuração, para que seja criado um nó na máquina remota, o arquivo $GF_HOME/glassfish/bin/sshpwd deve ser criado com o conteúdo da Listagem 1 e, em seguida, o seguinte comando deve ser executado:

asadmin --passwordfile sshpwd create-node-ssh 
--nodehost 10.25.0.74 --sshuser vitor remotenode 

  AS_ADMIN_SSHPASSWORD=glassfish 

Em primeiro lugar, o arquivo $GF_HOME/glassfish/bin/sshpwd (que pode ser criado em qualquer pasta e com qualquer nome, desde que seja especificado corretamente no comando asadmin create-node-ssh) especifica a senha do usuário da máquina remota que possui acesso ao servidor GlassFish. Caso você não queira escrever diretamente a senha no arquivo, a autenticação pode ser feita também via chave e frase senha (passphrase), utilizando o comando asadmin create-password-alias minha-frase-senha e colocando como conteúdo do arquivo sshpwd: AS_ADMIN_SSHKEYPASSPHRASE=ALIAS=minha-frase-senha. Utilizar passphrase é, de fato, a abordagem recomendada pois promove uma maior segurança (maior ainda se o arquivo sshpwd for criado e apagado a cada execução do comando que o utiliza).

Criado o arquivo, o comando asadmin create-node-ssh especifica: o arquivo com a senha (opção --passwordfile), o IP da máquina remota (--nodehost), o usuário remoto a ser utilizado pelo SSH (--sshuser) e, finalmente, o nome do nó a ser criado (último parâmetro do comando). O GlassFish da máquina local, então, utiliza o cliente SSH para conectar ao servidor SSHD da máquina remota e chamar o GlassFish instalado ali, criando um novo nó e associando-o ao cluster.

Logo em seguida, é possível ver que o nó foi criado com o subcomando list-nodes (a linha que começa com o caractere # indica o comando a ser executado, sendo as linhas seguintes o resultado de sua execução):

  # asadmin list-nodes
  localhost-domain1  CONFIG  localhost
  remotenode  SSH  10.25.0.74
  Command list-nodes executed successfully. 

O resultado do subcomando list-nodes mostra um nó local do tipo CONFIG (gerenciado localmente) e o nó remotenode que acabamos de criar, do tipo SSH (gerenciado remotamente via SSH). Na subseção anterior foram criadas instâncias para o nó local. Para criar duas instâncias no nó remoto, utilizamos o subcomando create-instance, especificando o nó, o cluster e o nome da instância a ser criada, como nos seguintes exemplos:

  asadmin create-instance --cluster cluster1 --node remotenode instance3
  asadmin create-instance --cluster cluster1 --node remotenode instance4 

Gerenciamento de clusters via console de administração

Tudo que fizemos utilizando a ferramenta asadmin via terminal pode ser feito dentro do console de administração. Neste caso, primeiramente é necessário criar o nó remoto para, posteriormente, criar o cluster e suas instâncias. Na árvore de funções à esquerda, clique em Nodes e, em seguida, clique em New.... Será exibido um formulário como na Figura 5.

Preencheremos os campos deste formulário com os valores que utilizamos anteriormente para criar o nó remotenode:

• Name: remotenode;
• Node Host: 10.25.0.74;
• SSH User Name: vitor
• SSH User Authentication: password;
• SSH Password: glassfish;
• Confirm SSH Password: glassfish.

Após clicar em OK para criar o nó remoto, selecione Clusters à esquerda e clique no botão New.... No formulário que se abrirá, informe o nome do cluster e, abaixo de Server Instances to Be Created, clique no botão New... quatro vezes, uma para cada instância a ser criada. Em seguida preencha as informações sobre as instâncias, como fizemos anteriormente utilizando o asadmin. O formulário preenchido é mostrado na Figura 6.

Clique em OK e aguarde enquanto o GlassFish contata o servidor remoto e cria todas as configurações necessárias. Após criado o cluster, é possível ver suas instâncias, iniciá-lo e interrompê-lo via console de administração, bastando para isso clicar na funcionalidade Clusters e utilizar a interface apresentada na Figura 7. Clicando no nome de um cluster ou de uma instância, é possível acessar configurações mais detalhadas de cada elemento.

Alta disponibilidade

Após criado e iniciado um cluster, um servidor GlassFish estará disponível em cada instância e uma aplicação implantada no cluster poderá ser acessada em qualquer uma das instâncias. Além disso, o GlassFish 3.1 possui capacidade de session fail-over, que consiste em replicar a sessão dos usuários de uma instância em outras instâncias caso a primeira falhe.

Para exemplificar estas funcionalidades, será utilizada uma aplicação corporativa de exemplo do GlassFish 2, chamada clusterjsp.ear (veja Links). Em primeiro lugar, ela deve ser implantada no cluster. Para fazê-lo utilizando o asadmin, execute o comando a seguir:

 asadmin deploy --target cluster1 --availabilityenabled=true clusterjsp.ear 

A opção --target indica que a implantação deve ser feita no cluster – e não no servidor GlassFish normal – e a opção --availabilityenabled ativa a capacidade de alta disponibilidade para esta aplicação.

Para implantar utilizando o console de administração, clique na função Clusters para abrir a lista de clusters mostrada na Figura 7. Em seguida, clique em cluster1, abra a aba Applications e clique no botão Deploy.... Então, insira no campo Location o arquivo clusterjsp.ear e marque a opção Enabled no campo Availability. Depois clique em OK para implantar a aplicação e aguarde.

Uma observação importante: além de marcar a opção “alta disponibilidade” durante a implantação, como acabamos de ver, para que uma aplicação funcione em um cluster ela deve ser configurada. Para isso, a tag deve estar presente no arquivo de configuração WEB-INF/web.xml.

Depois de implantada, a aplicação estará disponível em cada instância. Antes de abri-la no navegador Internet, no entanto, é preciso saber a porta HTTP utilizada por cada instância. No console de administração, retorne à lista de clusters (Figura 7) e clique em uma das instâncias. Uma página com informações gerais sobre a instância será aberta e no item HTTP Port(s) serão listadas três portas, sendo a do meio aquela que devemos utilizar para acessar a aplicação via browser.

Quando fizemos o teste, instance1 e instance3 rodavam na porta 28080, enquanto instance2 e instance4 utilizavam a porta 28081. Sendo assim, em nossos testes, a aplicação clusterjsp.ear pôde ser acessada nas seguintes URLs: http://localhost:28080/clusterjsp/ (instance1), http://localhost:28081/clusterjsp/ (instance2), http://10.25.0.74:28080/clusterjsp/ (instance3) e http://10.25.0.74:28081/clusterjsp/ (instance4). Qualquer desses endereços abrirá a página de boas-vindas da aplicação (HaJsp.jsp), como mostra a Figura 8.

A figura mostra a página sendo aberta na instance3. No corpo da página é possível ver o IP do servidor, porta utilizada, nome da instância, etc. No formulário apresentado em seguida, é possível inserir qualquer atributo na sessão, atribuindo-lhe um nome (Name of the Session Attribute) e um valor (Value of Session Attribute) a sua escolha e clicando no botão Add Session Data. Os atributos adicionados à sessão serão listados abaixo do formulário, sob o título Data retrieved from the HttpSession.

Como um teste, abra a página em instance1 (http://localhost:28080/clusterjsp/) e adicione um atributo qualquer na sessão e veja que ele será listado na página. Em seguida, em uma nova aba/janela do navegador, abra a página em instance2 (http://localhost:28081/clusterjsp/) e veja que o atributo também encontra-se listado ali. O mecanismo de alta disponibilidade do GlassFish efetuou a cópia da sessão do usuário, pois no caso de uma falha em uma das instâncias (e você pode simular isso no console de administração, clicando no botão Stop na página de informações gerais de uma instância), outras instâncias poderiam continuar servindo o cliente.

Balanceamento de carga

Montar um cluster com alta disponibilidade somente não é o suficiente, pois obrigaria os usuários de sua aplicação saber os endereços e portas de todas as instâncias para, no caso de uma falha, trocá-los manualmente e continuar a utilizar o sistema. Além disso, nada garante que seus usuários serão igualmente distribuídos entre as diversas instâncias para alcançar boa escalabilidade da sua aplicação. Para completar o cluster, portanto, é preciso utilizar alguma ferramenta de balanceamento de carga.

A versão de código aberto GlassFish Server Open Source Edition 3.1 não possui um balanceador de cargas integrado. A versão comercial, Oracle GlassFish Server 3.1, possui um plug-in que pode ser instalado e gerenciado pelo console de administração (veja a seção “Instalando componentes do GlassFish com o Update Tool” no início do artigo). Caso prefira optar por utilizar softwares open source, é possível instalar e integrar um balanceador de carga externo ao GlassFish, como por exemplo o servidor HTTP Apache e seu módulo mod-jk.

A instalação do servidor e módulo estão fora do escopo deste artigo, porém será discutido aqui como integrar os dois servidores para prover balanceamento de carga. Em primeiro lugar, após instalar o servidor HTTP Apache e instalar e ativar o módulo mod_jk, adicione as linhas da Listagem 2 na configuração do Apache. Os trechos em destaque devem ser alterados com o caminho correto dos arquivos em seu sistema.

  LoadModule jk_module diretorio-do-mod-jk/mod_jk.so
  JkWorkersFile diretorio-de-configuracao-apache/workers.properties
  JkMount /*.jsp loadbalancer 

A primeira linha ativa o mod_jk e é possível que esta configuração já esteja presente, dependendo de como as ferramentas foram instaladas (por exemplo, em sistemas Debian e derivados – ex.: Ubuntu – ao instalar o pacote relativo ao mod_jk o arquivo /etc/apache2/mods-enables/jk.load será criado contendo a linha de ativação do módulo). A instrução JkWorkersFile indica onde o Apache deve encontrar o arquivo de configuração do mod_jk, que deve possuir o conteúdo da Listagem 3. Finalmente, JkMount indica que o balanceamento será feito para todas as URLs que terminam em .jsp, utilizando o componente loadbalancer.

  worker.list=loadbalancer
  worker.instance1.type=ajp13
  worker.instance1.host=127.0.0.1
  worker.instance1.port=8011
  worker.instance1.lbfactor=50
  worker.instance1.socket_keepalive=1
  worker.instance1.socket_timeout=300
  worker.instance2.type=ajp13
  worker.instance2.host=127.0.0.1
  worker.instance2.port=8012
  worker.instance2.lbfactor=50
  worker.instance2.socket_keepalive=1
  worker.instance2.socket_timeout=300
  worker.loadbalancer.type=lb
  worker.loadbalancer.balance_workers=instance1,instance2 

A configuração do mod_jk (Listagem 3) configura o componente loadbalancer e define suas instâncias com o mesmo nome das instâncias do cluster GlassFish. Para simplificar o exemplo, foram consideradas somente as duas primeiras instâncias do nó local do cluster. Utilizando o protocolo AJP/1.3, o mod_jk irá receber as requisições *.jsp do Apache e alterná-la entre as duas instâncias locais (host=127.0.0.1), utilizando as portas 8011 e 8012 para comunicação com o GlassFish.

Após efetuar a configuração no lado do Apache, reiniciando-o para que as alterações entrem em vigor, é hora de configurar o GlassFish para receber estas requisições e direcioná-las às instâncias do cluster. Com o servidor GlassFish em execução, efetue os seguintes comandos utilizando o asadmin:

  asadmin create-network-listener --jkenabled true --target cluster1 
  --protocol http-listener-1 --listenerport \${AJP_PORT} jk-listener
  asadmin create-jvm-options --target cluster1 "-DjvmRoute=\${AJP_INSTANCE_NAME}"
  asadmin create-system-properties --target instance1 AJP_INSTANCE_NAME=instance1
  asadmin create-system-properties --target instance1 AJP_PORT=8011
  asadmin create-system-properties --target instance2 AJP_INSTANCE_NAME=instance2
  asadmin create-system-properties --target instance2 AJP_PORT=8012 

Em primeiro lugar, é importante notar que os comandos acima utilizam uma barra antes do cifrão que indica uma variável (\$) porque a sintaxe ${VARIAVEL}, utilizada dentro do GlassFish para indicar variáveis, é a mesma utilizada em sistemas como o Linux. Como não queremos avaliar a variável no comando mas sim passá-la para dentro do GlassFish para que ela seja avaliada posteriormente, utilizamos \${AJP_PORT} e \${AJP_INSTANCE_NAME} ao invés de ${AJP_PORT} e ${AJP_INSTANCE_NAME}. No Windows, utilize a versão sem a barra.

Os comandos acima criam um monitor HTTP na porta ${AJP_PORT} no cluster cluster1 para integração com o mod_jk (--jkenabled true). Um parâmetro da JVM também é incluído no cluster para indicar a instância para a qual as requisições devem ser direcionadas. Tanto a porta quanto o nome da instância são especificadas na forma de variável, sendo substituída pelo valor correto dependendo do caso. Após executar todos estes comandos, reinicie o GlassFish (asadmin restart-domain) para que as alterações tenham efeito.

Todas as configurações feitas acima podem ser vistas no console de administração do GlassFish e poderiam também terem sido feitas utilizando esta interface Web. O monitor encontra-se em Configurations > cluster1-config > Network Config > Network Listeners > jk-listener; o parâmetro da JVM pode ser visto em Configurations > cluster1-config > JVM Settings, na aba JVM Options; e as propriedades das instâncias podem ser vistas selecionando Clusters > cluster1, abrindo a aba Instances, clicando no nome da instância desejada e, finalmente, abrindo a aba Properties.

Se tudo for configurado de forma adequada e não houver nenhum problema em sua rede (aconselha-se desligar firewalls e utilizar ferramentas de análise de rede caso não funcione), a partir de agora não é mais necessário escolher uma instância e abrir a aplicação usando sua URL específica (ex.: http://localhost:28080/clusterjsp/ para a instance1), ficando a aplicação acessível em um endereço único – http://localhost/clusterjsp/ – e o Apache encarregado de dividir igualmente a carga de acessos entre as diferentes instâncias.

Boas práticas para alta disponibilidade

Para um melhor resultado em termos de alta disponibilidade de uma aplicação corporativa não basta saber montar um cluster no GlassFish. Existem uma série de recomendações e boas práticas que devem ser seguidas. Abaixo, listamos algumas delas:

• Analise a topologia da rede que conecta os nós do cluster e procure pontos de falha. Considere todos os elementos da rede: roteadores, switches, firewalls, balanceadores de carga, cabos e fontes de energia. Proveja redundância em todos os pontos em que haja risco de falha;
• Considere armazenar a sessão do usuário em banco de dados para uma garantia ainda maior de que tais informações não serão perdidas em caso de falha. Para não comprometer muito o desempenho, minimize ao máximo os dados da sessão e armazene em banco de dados somente aqueles que não são alterados com muita frequência. A sessão HTTP pode, também, servir de cache para informações que são lidas mais frequentemente do que alteradas;
• Use ferramentas de monitoramento para diagnosticar falhas como deadlocks e vazamento de memória o mais rápido possível. Monitore as threads Java, pontos de sincronização, recursos compartilhados, etc.;
• Conheça os erros e como contorná-los. Por exemplo, alguns erros advindos do banco de dados tornam a conexão atual inutilizável, devendo a aplicação criar uma conexão nova. Já outras falhas menos graves podem ser solucionadas simplesmente tentando a operação novamente após alguns segundos;
• Crie um calendário de reinicializações proativas do servidor ao invés de aguardar que ele falhe para reiniciá-lo. Desta forma será possível programar tais operações para o momento mais adequado, evitando assim consequências indesejadas da degradação gradual do desempenho do servidor;
• Faça também um calendário de backups e tenha sempre uma cópia recente do software e de seus dados para que a aplicação possa ser restaurada em casos graves.

Versionamento de Aplicações

Outra novidade do GlassFish 3.1 é a capacidade de implantar a mesma aplicação no servidor, adicionando tags que indicam a versão que está sendo implantada e, posteriormente, especificar qual versão da aplicação deve estar ativa.

Para demonstrar esta funcionalidade, será utilizada a aplicação de exemplo HelloGlassFish criada anteriormente no NetBeans ou no Eclipse, porém efetuaremos sua implantação utilizando o asadmin. Para tanto, precisaremos do arquivo HelloGlassFish.ear, contendo a aplicação corporativa empacotada. Se você utilizou o NetBeans, basta efetuar a construção completa da aplicação (menu Executar > Construir projeto principal) e o arquivo poderá ser encontrado no diretório dist, abaixo do diretório do projeto. No caso do Eclipse, clique com o botão direito no projeto HelloGlassFish e selecione Export > EAR.

Para começar, caso ainda não o tenha feito, faça a implantação normal da aplicação com o seguinte comando:

asadmin deploy HelloGlassFish.ear 

Ao abrir a aplicação no navegador Web na URL http://localhost:8080/HelloGlassFish-war/ será exibida a mensagem “Hello, World!”, como já havia sido feito anteriormente. Além disso, é possível ver que a aplicação foi implantada no servidor com o subcomando list-applications:

# list-applications

HelloGlassFish  <ear, web> 

Utilizando a IDE de sua escolha, faça agora uma alteração na página index.jsp da aplicação de exemplo, trocando a mensagem Hello, World! por Hello, World 2.0 Beta!, na página index.jsp. Em seguida, efetue novamente a implantação da aplicação no GlassFish, porém desta vez atribuindo-lhe um nome com a tag BETA-2.0 indicando sua versão:

  asadmin deploy --name=HelloGlassFish:BETA-2.0 HelloGlassFish.ear 

O subcomando list-application mostrará, agora, as duas versões implantadas:

  # asadmin list-applications
   
  HelloGlassFish           <ear, web>  
   
  HelloGlassFish:BETA-2.0  <ear, web>  

Agora abra a aplicação em seu navegador Internet e veja que o texto “2.0 Beta” foi adicionado à mensagem que era exibida anteriormente. Isso acontece porque a nova versão implantada foi ativada automaticamente. Utilizando o subcomando show-component-status é possível ver qual a versão ativa de uma aplicação implantada:

  # asadmin show-component-status HelloGlassFish:*
   
  Status of HelloGlassFish is disabled.
   
  Status of HelloGlassFish:BETA-2.0 is enabled. 

Também é possível implantar uma versão de uma aplicação e não ativá-la automaticamente. Para isso, altere novamente a mensagem da página index.jsp para dizer, agora, 2.1 Beta. Ao implantar, especifique que a aplicação não deverá ser habilitada da seguinte forma:

  asadmin deploy --name=HelloGlassFish:BETA-2.1 --enabled=false HelloGlassFish.ear 

Usando o subcomando show-component-status você poderá ver que a versão 2.0 continua ativa e, se abrir a aplicação no navegador, a mensagem da versão 2.0 continua. Para ativar a versão 2.1, utilize um outro comando do asadmin:

  asadmin enable HelloGlassFish:BETA-2.1 

Finalmente, a remoção de uma aplicação do servidor com o subcomando undeploy também obedece ao esquema de tags, inclusive aceitando * como curinga. Portanto, para remover todas as versões Beta do servidor, basta efetuar o comando (caso seja sua intenção voltar à aplicação original, não se esqueça de reabilitá-la em seguida – asadmin enable HelloGlassFish):

  asadmin undeploy HelloGlassFish:BETA* 

O versionamento de aplicações é uma boa prática ao realizar modificações em aplicações que encontram-se em produção, pois permite a rápida restauração da versão anterior no caso de erros serem encontrados na versão mais recente. Também é útil para aplicações ainda em fase de teste, para disponibilizar uma funcionalidade experimental temporariamente para, posteriormente, voltar com um simples comando à versão anterior.

Recursos com Escopo de Aplicação

Uma aplicação Java EE utiliza diversos recursos externos, como conexões JDBC, filas JMS, recursos do JavaMail. Tais recursos devem ser cadastrados no servidor de aplicação e depois podem ser obtidos via busca (lookup JNDI) ou, dependendo do caso, injeção de dependências (CDI).

Até a versão 3.0 do GlassFish, recursos tinham que ser registrados via asadmin ou console de administração e tinham escopo global, ou seja, qualquer aplicação implantada no servidor poderia acessá-los. A versão 3.1 do GlassFish permite, agora, registrar recursos com escopo de uma aplicação ou um módulo da aplicação, trazendo as seguintes vantagens:

• O recurso fica disponível somente a uma aplicação específica, impedindo que outras aplicações que não deveriam acessá-lo o façam;
• O recurso é registrado automaticamente junto ao GlassFish quando a aplicação é implantada e removido quando a aplicação é retirada do servidor, permitindo “implantação em um único clique”. Não é mais necessário registrar recursos “por fora”.

Como exemplo, será utilizado o mesmo projeto anterior (HelloGlassFish), ao qual será adicionado um recurso JDBC. Para criar este recurso é preciso primeiro criar um banco de dados em algum sistema de gerenciamento de bancos de dados (SGBD) em seu sistema. Instruções para esta tarefa estão fora do escopo deste artigo, porém se você instalou o NetBeans 7, pode abrir a aba Serviços, clicar com o botão direito em Banco de dados > Java DB e escolher a opção Criar banco de dados.... Nos exemplos a seguir, foi criado um banco de dados chamado hello, com usuário hello e senha hello.

Para adicionar um recurso a uma aplicação, basta descrevê-lo em um arquivo chamado glassfish-resources.xml (que deve seguir um formato pré-definido) e colocá-lo em um dos seguintes locais:

• Colocando-o na pasta META-INF do arquivo EAR que contém a aplicação, o recurso terá escopo da aplicação como um todo, sendo acessível a qualquer um de seus módulos;
• Colocando-o na pasta META-INF do arquivo JAR que contém o módulo EJB da aplicação, o recurso terá escopo de módulo, sendo acessível somente dentro daquele módulo EJB;
• Colocando-o na pasta WEB-INF do arquivo WAR que contém o módulo Web da aplicação, o recurso terá como escopo aquele módulo Web.

Para testar esta funcionalidade, crie o arquivo glassfish-resources.xml com o conteúdo da Listagem 4 e adicione-o ao diretório WEB-INF do projeto HelloGlassFish-war. Em seguida, altere o arquivo index.jsp e adicione o trecho de código da Listagem 5. Faça a implantação e acesse a página JSP para ver que, abaixo da mensagem “Hello, World!” será impresso o resultado da chamada do método toString() no objeto java.sql.DataSource que representa o recurso JDBC registrado (algo como com.sun.gjc.spi.jdbc40.DataSource40@e65575).

  <?xml version="1.0" encoding="UTF-8"?>
  <!DOCTYPE resources PUBLIC "-//GlassFish.org//DTD GlassFish 
  Application Server 3.1 Resource Definitions//EN" 
  "http://glassfish.org/dtds/glassfish-resources_1_5.dtd">
  <resources>
    <jdbc-resource enabled="true" jndi-name="java:module/jdbc/helloDS" 
    object-type="user" pool-name="helloPool" />
    <jdbc-connection-pool datasource-classname="org.apache.derby.jdbc.ClientDataSource" 
    max-pool-size="32" name="helloPool" pool-resize-quantity="2" res-type="javax.sql.DataSource">
      <property name="URL" value="jdbc:derby://localhost:1527/cdiviagens"/>
      <property name="serverName" value="localhost"/>
      <property name="PortNumber" value="1527"/>
      <property name="DatabaseName" value="cdiviagens"/>
      <property name="User" value="cdiviagens"/>
      <property name="Password" value="cdiviagens"/>
    </jdbc-connection-pool>
  </resources> 

  <%
  javax.naming.InitialContext ic = new javax.naming.InitialContext();
  Object ds = ic.lookup("java:module/jdbc/helloDS");
  %>
  <%= ds %>

O arquivo glassfish-resources.xml registra um pool de conexões e um recurso JDBC (uma fonte de dados, ou data source) da mesma forma como eles eram registrados anteriormente, de forma global. A única diferença, que encontra-se em destaque na Listagem 4, é o nome dado ao recurso que a aplicação deverá acessar. Tal nome deve seguir uma convenção, começando com java:module/ para recursos com escopo de módulo ou java:app/ para recursos com escopo de aplicação.

Com o recurso registrado, a página index.jsp pode obter o recurso fazendo uma busca JNDI pelo nome declarado anteriormente. Em seguida, o exemplo imprime o objeto na página, somente para testar que, de fato, uma fonte de dados JDBC está sendo registrada. Note que acessar fontes de dados diretamente de páginas JSP não é uma boa prática de desenvolvimento e foi feito somente para experimentar o registro automático do recurso por parte do GlassFish. Em uma aplicação real, sugere-se utilizar o CDI para injetar o recurso em algum bean da aplicação utilizando, por exemplo, a anotação @Resource(lookup = "java:module/jdbc/helloDS").

Recursos com escopo de aplicação e módulo são bastante úteis quando a utilização de um determinado recurso é, de fato, restrita a um destes dois escopos. Neste caso, não registrar o recurso como global no servidor evita que outras aplicações ou módulos acessem-no, possivelmente criando conflitos na disputa do recurso. Além disso, esta nova funcionalidade traz mais praticidade na implantação de aplicações, pois os recursos são automaticamente registrados no servidor, evitando que tenhamos que fazê-lo manualmente.

API RESTful para Administração

REST, acrônimo de Representational State Transfer (Transferência de Estado Representacional) é um estilo de arquitetura de software para sistemas hipermídia (por exemplo, aplicações Web). Consiste em um cliente e um servidor que se comunicam por meio de requisições e respostas, transferindo em tais comunicações representações do estado dos objetos (ou recursos de maneira geral, em inglês: resources) que estão sendo manipulados.

Nos últimos anos, cresceu a utilização de RESTful Web Services como uma alternativa ao padrão W3C SOAP, por se tratar de uma forma mais leve e rápida de comunicação com um servidor, utilizando XML, JSON ou qualquer outro padrão de representação de estado. Um exemplo deste crescimento está no desenvolvimento de frameworks, como o brasileiro Restfulie (veja Links), que auxiliam na criação de clientes e servidores que utilizam esta tecnologia.

Seguindo esta tendência, o GlassFish 3.1 disponibiliza, além do asadmin e do console de administração, uma API RESTful (ou seja, em conformidade com a arquitetura REST) para administração do servidor. Esta API permite que qualquer cliente possa ler e fazer modificações nas configurações do servidor por meio de requisições e respostas.

O endereço base da API RESTful do GlassFish é http://localhost:4848/management/domain/. Se esta URL for aberta em um navegador Web, uma requisição HTTP será feita à API RESTful e esta retornará um documento HTML que mostra os elementos de configuração. Atributos são exibidos em formulários e seus valores podem ser alterados e atualizados. Sub-recursos (Child Resources) são exibidos ao final da página e nos permitem navegar para outros elementos da configuração.

A Figura 9 mostra um navegador Web acessando um determinado elemento da configuração: as configurações da aplicação HelloGlassFish, que encontra-se implantada no servidor. Para chegar a esta tela a partir da URL base da API RESTful, basta clicar nos sub-recursos applications > application > HelloGlassFish (que, não por acaso, são os mesmos elementos que são adicionados à URL base para montar a URL deste elemento específico).

A utilidade de uma API RESTful, porém, não é prover uma interface Web menos amigável que o console de administração, mas sim permitir que outros clientes sejam desenvolvidos e tenham fácil acesso aos valores de configuração. Para demonstrar como isso é possível, utilizaremos uma ferramenta simples que nos permite enviar requisições REST a um servidor qualquer: o cURL. Em sistemas Linux e Mac esta ferramenta geralmente já encontra-se instalada. Caso seja necessário instalá-la no seu sistema, basta obtê-la na página de download do projeto (veja Links).

Usando o cURL, podemos ler a configuração da aplicação implantada (as mesmas informações que encontram-se na página mostrada na Figura 9), porém em formato JSON, e posteriormente fazer uma análise (parsing) deste resultado, chegando à informação desejada. Para obter as informações em formato JSON, use o cURL da seguinte forma:

curl -s -H "Accept: application/json" 
http://localhost:4848/management/domain/applications/application/HelloGlassFish 

Uma quantidade enorme de dados será mostrada em um formato difícil de ler para uma pessoa (a não ser que você formate-o com alguma solução de pretty printing), porém fácil de ler para um computador. Se quisermos, por exemplo, ver se a aplicação está habilitada (propriedade enabled), podemos obter o objeto JSON extraProperties, dentro dele obter o objeto entity e, finalmente, acessar a propriedade enabled. Utilizando o JSON-java (uma das muitas implementações de parser JSON em Java – veja Links), o código da Listagem 6 realiza esta navegação e imprime o valor da propriedade enabled.

  package json;
   
  import java.util.Scanner;
  import org.json.JSONObject;
   
  public class TesteParserJson {
   public static void main(String[] args) throws Exception {
    Scanner scanner = new Scanner(System.in);
    String line = scanner.nextLine();
    Object enabled = jsonObj.getJSONObject("extraProperties")
    .getJSONObject("entity").get("enabled");
    System.out.println(enabled);
   }
  } 

O programa da Listagem 6 espera que a string JSON seja passada via System.in. Para que isso aconteça, combine o cURL com o programa Java utilizando o seguinte comando (tudo em uma única linha):

curl -s -H "Accept: application/json" 
http://localhost:4848/management/domain/applications/application/HelloGlassFish 
| java json.TesteParserJson 

Podemos utilizar o cURL também para modificar dados da configuração via API RESTful. Para alterar o valor da propriedade enabled para false, use o seguinte comando:

curl -F enabled=true 
http://localhost:4848/management/domain/applications/application/HelloGlassFish 

Depois de executá-lo, abra a URL http://localhost:4848/management/domain/applications/application/HelloGlassFish no navegador Web e confira que o valor da propriedade foi alterado (a aplicação foi desabilitada). De fato, se tentar acessá-la em http://localhost:8080/HelloGlassFish-war/, o GlassFish retornará uma página 404 (“recurso não encontrado”).

Conclusão

Neste artigo, foram apresentadas as novidades da versão 3.1 do GlassFish, um servidor para aplicações corporativas Java EE 6. Em particular, foram descritas em mais detalhes e com exemplos práticos as funcionalidades de gerenciamento de clusters, versionamento de aplicações, recursos com escopo de aplicação e a API RESTful para administração.

A cada nova versão, ferramentas que utilizamos para desenvolvimento trazem novidades que facilitam o trabalho do desenvolvedor e/ou melhoram o resultado final da aplicação. Esperamos que este artigo ajude-o a manter-se atualizado com as novidades do GlassFish, o encoraje a experimentar tais novidades e, possivelmente, utilizá-la em um contexto de trabalho.

Confira também

O que é Java?

Curso

Java: Hello Word

Curso

O que é JDBC?

Curso