java.lang.OutOfMemoryError no Servidor Apache Tomcat

Segue abaixo um problema que um de meus alunos do curso de Struts teve ao configurar uma aplicação Web no servidor Tomcat. Pude auxiliá-lo na resolução do problema e pedi a ele que escrevesse um post apresentando o problema e a solução do mesmo. Este post com certeza será útil para outras pessoas que venham a ter o mesmo problema.

Por Rafael Diego

Possuo um servidor com o FreeBSD e sistema Java Web, que faz conexão com um BD, existente que rodava normalmente no servidor, sobre o Tomcat 5.5, ainda estava exibindo a tela de Login.
O usuário conseguia logar e visualizar o menu principal. Porém, quando clicava em qualquer submenu, o redirecionamento demorava alguns segundos (mais que o normal) e era exibida uma mensagem de erro, provida pelo próprio Tomcat:

type Exception report

message

description The server encountered an internal error () that prevented it from fulfilling this request.

exception

javax.servlet.ServletException: javax.servlet.jsp.JspException: java.lang.OutOfMemoryError: Java heap space
org.apache.jasper.runtime.PageContextImpl.doHandlePageException(PageContextImpl.java:842)
org.apache.jasper.runtime.PageContextImpl.handlePageException(PageContextImpl.java:779)
org.apache.jsp.pages.cadastro_005famostra_jsp._jspService(cadastro_005famostra_jsp.java:149)
org.apache..jasper.runtime.HttpJspBase.service(HttpJspBase.java:94)
javax.servlet.http.HttpServlet.service(HttpServlet.java:802)
org.apache.jasper.servlet.JspServletWrapper.service(JspServletWrapper.java:324)
org.apache.jasper.servlet.JspServlet.serviceJspFile(JspServlet.java:292)
org.apache.jasper.servlet..JspServlet.service(JspServlet.java:236)
javax.servlet..http.HttpServlet.service(HttpServlet.java:802)
com.sun.faces.context.ExternalContextImpl.dispatch(ExternalContextImpl.java:322)
com.sun.faces.application.ViewHandlerImpl.renderView(ViewHandlerImpl.java:142)
com.sun.faces.lifecycle.RenderResponsePhase.execute(RenderResponsePhase.java:87)
com.sun.faces.lifecycle.LifecycleImpl.phase(LifecycleImpl.java:200)
com.sun.faces.lifecycle.LifecycleImpl.render(LifecycleImpl.java:117)
javax.faces.webapp.FacesServlet.service(FacesServlet.java:19

root cause

javax.faces.el.EvaluationException: java.lang.OutOfMemoryError: Java heap space
com.sun.faces.el.ValueBindingImpl.getValue(ValueBindingImpl.java:185)
com.sun.faces.el.ValueBindingImpl.getValue(ValueBindingImpl.java:136)
javax.faces.component.UIComponentBase.isRendered(UIComponentBase.java:30
javax.faces.webapp.UIComponentTag.isSuppressed(UIComponentTag.java:82
javax.faces.webapp.UIComponentTag.doStartTag(UIComponentTag.java:460)
com.sun.faces.taglib.html_basic.PanelGridTag.doStartTag(PanelGridTag.java:436)
org.apache.jsp.pages.cadastro_005famostra_jsp._jspx_meth_h_panelGrid_0(cadastro_005famostra_jsp.java:269)
org.apache.jsp.pages.cadastro_005famostra_jsp._jspx_meth_h_form_0(cadastro_005famostra_jsp.java:221)
org.apache.jsp.pages.cadastro_005famostra_jsp._jspx_meth_f_view_0(cadastro_005famostra_jsp.java:191)
org.apache.jsp.pages.cadastro_005famostra_jsp._jspService(cadastro_005famostra_jsp.java:139)
org.apache.jasper.runtime.HttpJspBase.service(HttpJspBase.java:94)
javax.servlet.http.HttpServlet.service(HttpServlet.java:802)
org.apache.jasper.servlet.JspServletWrapper.service(JspServletWrapper.java:324)
org.apache.jasper.servlet.JspServlet..serviceJspFile(JspServlet.java:292)
org.apache.jasper..servlet.JspServlet.service(JspServlet.java:236)
javax..servlet.http.HttpServlet.service(HttpServlet.java:802)
com.sun.faces.context.ExternalContextImpl.dispatch(ExternalContextImpl.java:322)
com.sun.faces.application.ViewHandlerImpl.renderView(ViewHandlerImpl.java:142)
com.sun.faces.lifecycle.RenderResponsePhase.execute(RenderResponsePhase.java:87)
com.sun.faces.lifecycle.LifecycleImpl.phase(LifecycleImpl.java:200)
com.sun.faces.lifecycle.LifecycleImpl.render(LifecycleImpl.java:117)
javax.faces.webapp.FacesServlet.service(FacesServlet.java:19

note The full stack trace of the root cause is available in the Apache Tomcat/5.0.30 logs.
Após consulta na Internet, pelos sites de busca, fóruns e pedindo auxílios à outras pessoas e ainda tentando entender a mensagem de erro, vi que era problema de “memória insuficiente” alocada para a JVM.

Encontrei o seguinte comando que setava o tamanho de memória utilizado pela JVM:
export CATALINA_OPTS=”-Xms256m -Xmx512m”
Este comando seta a memória mínima (Xms) em 256MB e a memória máxima a ser usada (Xmx) em 512MB.

Adicionei o comando nas configurações do arquivo catalina.sh. Após reiniciar o servidor, o problema foi corrigido.
Agora, minha aplicação roda com memória entre 256 e 512MB.

Struts e o MVC: Relações entre Classes

Segue abaixo algumas tabelas do livro “Struts in Action” que apresentam algumas das relações entre o padrão MVC e o framework Apache Struts.

Java Persistence API: Artigo da Sun

Segue abaixo um link de um artigo interessante en inglês falando sobre a Java Persistence API.

Link Artigo da Sun

Outros Links:

• Using Hibernate with the Java Persistence API
• An Introduction to Java Persistence for Client-Side Developers

Mapeamento Objeto/Relacional com Hibernate

Extraído da Wikipedia

O Hibernate é um framework para o mapeamento objeto-relacional escrito na linguagem Java, mas também é disponível em .Net como o nome NHibernate. Este programa facilita o mapeamento dos atributos entre uma base tradicional de dados relacionais e o modelo objeto de uma aplicação, mediante o uso de arquivos (XML) para estabelecer esta relação.

Hibernate é um software livre de código aberto distribuído com a licença LGPL.

Características

O objetivo do Hibernate é diminuir a complexidade entre os programas Java, baseado no modelo orientado a objeto, que precisam trabalhar com um banco de dados do modelo relacional (presente na maioria dos SGDBs). Em especial, no desenvolvimento de consultas e atualizações dos dados.

Sua principal característica é a transformação das classes em Java para tabelas de dados (e dos tipos de dados Java para os da SQL). O Hibernate gera as chamadas SQL e libera o desenvolvedor do trabalho manual da conversão dos dados resultante, mantendo o programa portável para quaisquer bancos de dados SQL, porém causando um pequeno aumento no tempo de execução.

Nas questões relacionadas para o gerenciamento de transações e na tecnologia de acesso à base de dados são de responsabilidade de outros elementos na infraestrutura do programa. Apesar de existirem API no Hibernate para possuir operações de controle transacional, ele simplesmente delegará estas funções para a infrestrutura na qual foi instalada.

No caso de aplicações construídas para serem executadas em servidores de aplicação, o gerenciamento das transações é realizado segundo o padrão JTA (Java Transaction API). Ja nas aplicações standalone, o programa delega o tratamento transacional ao driver JDBC.

Hibernate pode ser utilizado em aplicações Java standalone ou em aplicações Java EE, utilizando servlet ou sessões EJB beans.

Mapeamento Objeto-Relacional

O mapeamento objeto-relacional (ou ORM) é uma técnica de desenvolvimento utilizada para reduzir a impedância da programação orientada aos objectos utilizando bancos de dados relacionais. As tabelas do banco de dados são representadas através de classes e os registos de cada tabela são representados como instâncias das classes correspondentes.

Com esta técnica, o programador não precisa de se preocupar com os comandos em linguagem SQL; irá usar uma interface de programação simples que faz todo o trabalho de persistência.

Não é necessária uma correspondência directa entre as tabelas de dados e as classes do programa. A relação entre as tabelas onde originam os dados e o objecto que os disponibiliza é configurada pelo programador, isolando o código do programa das alterações à organização dos dados nas tabelas do banco de dados.

A forma como este mapeamento é configurado depende da ferramenta que estamos a usar. Como exemplo, o programador que use Hibernate na linguagem Java pode usar ficheiros XML ou o sistema de anotações que a linguagem providencia.

Além do Hibernate, O Apache OJB (ObJectRelationalBridge) também fornece este recurso de mapeamento objeto-relacional.

Links:

Hibernate

• HomePage
• Reference Docs

OJB

• HomePage

Core J2EE Patterns: Índice de Padrões

A própria Sun possui um catálogo de padrões de projeto muito utilizados em projetos de desenvolvimento de sistemas Web em JavaEE. Este catálogo apresenta cada um destes padrões, com exemplos de código, estrutura em UML, dentre outras informações.

Link da página

Apache Struts - Introdução

por Marcelo Ribeiro Costa
extraído do site: http://www.portaljava.com.brIntrodução

Introdução

O Struts é um framework open-source do projeto Jakarta que auxilia a construção de aplicações para a Web. Ele é construído em Java, e seu coração consiste numa camada de controle flexível baseada nas tecnologias Java Servlets, JavaBeans, ResourceBundles e XML.

O Struts favorece o desenvolvimento de aplicações seguindo o paradigma MVC (Model-View-Controller). O Struts fornece um componente Controller e se integra a outras tecnologias para oferecer suporte aos componentes Model (como JDBC, EJB’s, etc.), e View (como JSP, XSLT, etc.).

2. O Design Pattern MVC

No design pattern MVC, o fluxo da aplicação é mediado por um controlador central (Controller). O controlador delega requisições para um tratadores apropriados, que estão localizados no modelo (Model), que representa a lógica de negócio e o estado da aplicação. A requisição então é respondida, através do controlador, e apresentada na visão (View), da maneira adequada. No Struts, essas respostas são orientadas através de mapeamentos, que são carregados através de um arquivo de configuração (struts-config.xml). Isso faz com que não haja dependência entre a visão e o modelo, que auxilia na criação e na manutenção da aplicação.

3. Instalação

A versão do Struts mais utilizada é a versão 1.1, que ainda se encontra em versão beta. Apesar de ainda não estar completamente finalizada, é uma versão estável e que deve sofrer poucas alterações. Para que nossos exemplos funcionem adequadamente, utilizaremos essa versão. Será então necessário fazer o download do arquivo jakarta-struts-1.1-b3.zip no site do Jakarta Struts (http://jakarta.apache.org/struts), e descompactá-lo no computador. O pacote vem com as bibliotecas necessárias para a utilização do framework e alguns exemplos.

4. Componentes do Struts

1. Componentes Model

Os componentes Model englobam dois conceitos: a lógica de negócio da aplicação e seu estado. As tecnologias utilizadas nessa camada, são JavaBeans, e freqüentemente, Enterprise JavaBeans e JDBC.

Através destas tecnologias, deverá ser construída a lógica de negócio da aplicação.

2. Componentes View

Os componentes View representam a visão da aplicação, ou seja, a maneira como o sistema interage com o usuário. A tecnologia mais comumente utilizada nessa camada é Java Server Pages.

Nessa camada, o Struts oferece suporte a dois importantes aspectos: internacionalização e construção de interfaces JSP através de custom tag’s.

Para permitir a internacionalização, é necessário que se crie, sob o diretório WEB-INF/resources da aplicação, um arquivo chamado ApplicationResources.properties, que conterá mensagens para a linguagem padrão do seu servidor. As mensagens são colocadas nos arquivos através de strings simples, como:

app.cliente.nome=Nome do cliente

Para possibilitar que se crie mensagens em outras linguagens, é necessário criar o arquivo ApplicationResources_xxx.properties, onde xxx será o nome ISO da linguagem a ser utilizada.

Outro importante recurso é a disponibilidade de custom tag’s do Struts, que permitirá, além da utilização dos arquivos de internacionalização, uma série de funcionalidades, que, na grande maioria dos casos, dispensará a utilização de código Java dentro da página (aliás, esse é um dos objetivos da arquitetura MVC, pois o fluxo de controle e lógica de negócio da aplicação não devem estar na camada de visão). Além disso, a extensibilidade de Java permite que o próprio desenvolvedor crie suas próprias custom tag’s, que, aliás, é uma tarefa bastante simples.

As custom tag’s do Struts são divididas em cinco bibliotecas:

· html: permite a criação e manipulação integrada de formulários HTML com o Struts;

· logic: permite a criação de estruturas de condição e repetição, além da administração do fluxo da aplicação;

· bean: permite a criação e manipulação de JavaBeans dentro da página;

· nested: permite a definição de modelos de objetos aninhados e a capacidade de representá-los e administrá-los;

· template: permite a criação de modelos dinâmicos de páginas JSP que compartilham de um formato comum.

3. Componentes Controller

Os componentes Controller são responsáveis pelo fluxo da aplicação. O principal componente Controller do Struts é a ActionServet, que é uma extensão de Servlet, exercendo o papel de controlador principal da aplicação. Sua principal função é fazer o mapeamento das requisições do servidor.

Para isso, é necessário criar um arquivo de configuração, denominado struts-config.xml, que é usado para mapear a navegação da aplicação. Depois disso, deverão ser criadas as classes Action (que são extensões da classe Action do Struts), que conterão as ações a serem executadas a cada requisição. O objetivo da classe Action é processar a requisição e retornar um objeto da classe ActionForward que identifica para qual componente de visão (normalmente uma página JSP) será gerada a resposta. As classes Action são compostas de um único método, com a assinatura public ActionForward execute(ActionMapping mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response) throws IOException, ServletException, que será invocado quando a ActionServlet receber a requisição e processá-la.

O Ainda na camada controller, Struts oferece para os chamados ActionForm beans, ou, mais comumente chamados, form-beans. Form-beans são classes Java que estendem ActionForm e se integram a um formulário de entrada de dados em sua aplicação. O conceito dos form-beans é simples: são JavaBeans que contém uma propriedade para cada campo de seus formulários HTML, com seus respectivos métodos getters e setters. Os form-beans não implementam qualquer método, exceto reset e validate, servindo para limpar o conteúdo do formulário e validar seus dados, respectivamente.

5. Configuração

Antes de utilizar o Struts, é necessário configurar seu ambiente para que ele saiba como mapear todas as requisições através de uma determinada extensão de arquivo para a ActionServet do Struts. Isso deverá estar no arquivo web.xml, que fica abaixo do diretório WEB-INF de sua aplicação.

O próximo passo é configurar o arquivo fundamental do Struts, o struts-config.xml. Enquanto o arquivo web.xml define aonde a requisição deve chegar, o struts- config.xml determina exatamente o que vai acontecer com ela. Nada acontece sem sua permissão ou seu conhecimento: é onde os mapeamentos são definidos. Toda a navegação da aplicação está definida nesse arquivo, o que é uma grande vantagem, pois a mantém modularizada e de fácil manutenção. Todo esse arquivo é lido na inicialização do servidor e armazenado na memória, por questões de performance.

Além disso, é necessário que se tenha todos os arquivos .jar necessários à aplicação abaixo do diretório WEB-INF/lib, e todos os descritores de custom-tag’s abaixo do diretório WEB-INF.

6. Criando uma aplicação exemplo com o Struts

O primeiro passo será criar a estrutura padrão para aplicativos WEB utilizando Servlets, contendo uma pasta WEB-INF, onde será colocado o arquivo web.xml.

No diretório WEB-INF, deverão ser colocados os descritores de custom tag’s do Struts (arquivos .tld).

Depois disso, devemos criar o diretório WEB-INF/classes, onde serão colocados os arquivos .class, dentro de seus determinados pacotes, e o diretório WEB-INF/lib, onde serão colocados os arquivos .jar do Struts.

Após as configurações acima, pode-se criar as ações, os forms e os documentos JSPs da aplicação que se deseja desenvolver, configurando-os no arquivo struts-config.xml.

MyEclipse Struts Modeler/Workbench 6.0

Na minha busca por plugins que suportam o Struts, encontrei uma página muito interessante sobre o MyEclipse Struts Modeler/Editor.

O plugin MyEclipse para a IDE Eclipse possibilita uma quantidade significativa de atividades relacionadas ao desenvolvimento de uma aplicação Web com o Apache Struts.

Uma destas permite visualizar o fluxo das páginas definidas no arquivo de configuração struts-config.xml, conforme mostrado na figura abaixo:

O Plugin não é gratuito, mas existe uma versão trial de 30 dias para quem quiser baixar.

Link da apresentação

Link oficial do MyEclipse

Struts: Struts Blank 1.3.8 para as IDEs Eclipse 3.3 JEE e Netbeans 6.1 Web

Acabei de postar no Google Groups do curso de Desenvolvimento para Web com Apache Struts e JSP os projetos de configuração iniciais para uma aplicação Web com o Framework Apache Struts 1.3.8, o próprio framework que estamos usando no curso. Desta forma fica mais fácil a criação de projetos baseados no framework nestas duas ferramentas.

Struts_blank_138_Netbeans.zip

Struts_blank_138_Eclipse33.zip

Só é necessário descompactar os arquivos e importar os projetos direto por cada IDE específica.

JavaEE: Abordagem Multi-camadas

A arquitetura de aplicações desenvolvidas em JavaEE segue um padrão de divisão de responsabilidades em camadas:

1. Apresentação
2. Lógica de apresentação
3. Lógica de negócio
4. Modelo de dados

1. Apresentação

Esta camada apresenta o “look & feel” e a apresentação da aplicação. Em JavaEE, JSPs são usados para implementar a visão.

2. Lógica de apresentação

Esta camada define o código necessário para a chamada de métodos contendo a lógica de negócio e retornar a saída para a camada de apresentação.
Em JavaEE, os JavaBeans e os Servlets são utilizados para implementar serviços da lógica de apresentação.

3. Lógica de negócio

Nesta camada, executa-se as ações dos casos de uso e manipulações sobre o modelo de dados. Os beans EJBs de sessão são utilizados nesta camada para
definir a lógica de negócio de todos os casos de uso.

4. Modelo de dados

Esta camada define uma abstração útil para o modelo de dados denominado de beans de entidade EJBs. Estes são objetos persistentes que modelam as abstrações do mundo real.

Benefícios
Os benefícios da abordagem de uma arquitetura em camadas são:

• Encapsulamento – cada camada esconde os detalhes das outras. Sendo assim, uma destas pode ser modificada sem que afete as outras.
• Separação - a complexidade do sistema é menor e mais fácil de gerenciar, pois cada camada está focada em uma quantidade coesiva de responsabilidades.
• Reuso – cada camada pode prover serviços à camada acima. Desta forma, classes podem ser reutilizadas e também abstrair detalhes de implementação.

As vantagens acima levam à construção de aplicações que são mais flexíveis e manuteníveis.

Enterprise JavaBeans: Introdução

Introdução

Basicamente, o EJB define uma arquitetura de componentes multi-plataforma para o desenvolvimento de aplicações Java, muiti-tier, distribuídas, escaláveis e orientadas a objetos.

O objetivo da arquitetura EJB é facilitar o trabalho do desenvolvedor para que ele não tenha que se preocupar com diversos aspectos de infra-estrutura.

Tipos

Existem 3 tipos de EJBs (objetos distribuídos):

1. Session Bean - é o tipo mais simples de EJB, pode ter estado (stateful) ou não ter (stateless).
2. Entity Bean - mapeam tabelas de um banco de dados relacional através de um arquivo de mapeamento. Na prática cada objeto entity representa uma linha de uma tabela. Existe uma linguagem de query específica para buscar entitys chamada EQL (Entreprise Query Language).
3. MDB - são consumidores assincronos de mensagens de filas / tópicos JMS.

Na teoria, o uso de EJBs tornaria mais fácil escrever aplicações de empresariais como componentes provendo um conjunto de serviços automáticos para suportar aplicações transacionais, o que não acontece na prática.

O EJB é um dos principais componentes da plataforma J2EE (Java 2 Enterprise Edition). É um componente do tipo servidor que é executado no container para EJB do servidor de aplicação. Os principais objetivos da tecnologia EJB são fornecer um rápido e simplificado desenvolvimento de aplicações Java baseado em componentes distribuídas, transacionais, seguras e portáveis.

Atualmente ele encontra-se na versão 3.0 e o seu futuro é definido conjuntamente entre grandes empresas como Sun, IBM, Oracle e HP como também por uma vasta comunidade de programadores numa rede mundial de colaboração sob o portal do JCP.

A grande mudança entre a versão 2.1 e a versão 3.0 é a introdução de anotações Java. As anotações facilitam o desenvolvimento diminuindo a quantidade de código e o uso de arquivos de configuração XML.

A plataforma JEE provê algumas facilidades dedicadas à camada de lógica de negócio e para o acesso a banco de dados. Através do EJB o programador utiliza a infraestrutura do servidor de aplicação voltada para o desenvolvimento de aplicações de missão crítica (de alta importância para a empresa) e de aplicações empresariais em geral.

Figura: Visão sobre as camadas de uma aplicação JEE.

Especificação

De acordo com a especificação (JSR 220), o padrão EJB define quais serviços e como estes serviços deverão ser disponibilizados à aplicação:

* Persistência
* Processamento de transções
* Controle de concorrência
* Gerenciamento de eventos usando o Java Message Service (JMS)
* Serviços de nomes e diretório - Naming and directory services (JNDI)
* Segurança ( Java Cryptography Extension (JCE) e JAAS )
* Deployment de componentes de software em um servidor de aplicações
* Chamada remota de procedimentos via RMI-IIOP
* Exposição de métodos de negócio em forma de Web Services

Links Úteis

http://jcp.org/en/jsr/detail?id=220
http://java.sun.com/products/ejb/

Tópicos relacionados: JMS, JSR, JCP, JEE