LOG4J

Log4j é um Framework utilizado para o desenvolvimento de Softwares que necessitam de recursos de
geração de logs. Bem, o Tomcat já possui estes recursos, basta que sejam ativados.

Segue os passos para ativar a geração de logs e o rotacionamento de arquivos de log:

Baixe o Log4j e o commons-logging:

- Log4j ->http://logging.apache.org/site/binindex.cgi

- Commons-logging ->http://jakarta.apache.org/site/downloads/downloads_commons-logging.cgi

Descompacte os dois arquivos, entre no diretório descompactado do Log4j vá em dist/lib, copie o .jar para $TOMCAT_HOME/common/lib.

Agora entre no diretório descompactado do commons-logging, copie o commons-logging-x.x.jar para $TOMCAT_HOME/common/lib

Crie o arquivo de configuração log4j.properties dentro de $TOMCAT_HOME/common/classes

Conteúdo e descrição do arquivo:

  # Início - log4j.properties

  log4j.rootLogger=INFO, LOG

  log4j.appender.LOG=org.apache.log4j.RollingFileAppender

  log4j.appender.LOG.layout=org.apache.log4j.PatternLayout

  log4j.appender.LOG.layout.ConversionPattern=%d [%t] %p %c - %m%n

  log4j.appender.LOG.File=$TOMCAT_HOME/logs/catalina.out

  log4j.appender.LOG.MaxFileSize=10MB

  log4j.appender.LOG.MaxBackupIndex=10

  # Fim

Conceitos importantes:

Appender - Qual os destinos das mensagens de log (arquivos, console, email etc.).

Layout - Formatação das mensagens de log.

log4j.rootLogger=INFO, LOG -> Define o nível das mensagens de log e um nome para o appender, os níveis podem ser: INFO, DEBUG, WARN, ERROR, FATAL,ALL e OFF.

log4j.appender.LOG=org.apache.log4j.RollingFileAppender -> Define o appender, neste caso o appender RollingFileAppender é utilizado para rotacionar os arquivos de log. Existem vários appenders diferentes, como por exemplo SMTPAppender utilizado para enviar as mensagens de log por email.

log4j.appender.LOG.layout=org.apache.log4j.PatternLayout -> Define qual layout (formatação das mensagens) será usado, PatternLayout depende da regra abaixo.

log4j.appender.LOG.layout.ConversionPattern=%d [%t] %p %c - %m%n -> Personalização da saída das mensagens, descrição:

- %d - Mostra a data e a hora em que a mensagem foi gerada.

- %t - Mostra qual thread gerou a mensagem.

- %p - Mostra o nível das mensagens.

- %c - Mostra a classe que gerou o erro.

- %m - Mostra a mensagem de log.

- %n - Quebra a linha.

Exemplo:

- 2006-06-20 15:20:26,122 [main] INFO org.apache.catalina.startup.Catalina -

Server startup in 54689 ms

- log4j.appender.LOG.File=$TOMCAT_HOME/logs/catalina.out -> Caminho onde será

armazenado o arquivo de log.

- log4j.appender.LOG.MaxFileSize=10MB -> Tamanho máximo que o arquivo pode

atingir antes de ser rotacionado.

- log4j.appender.LOG.MaxBackupIndex=10 -> Numero de arquivos utilizados para o

rotacionamento.

Depois de tudo isso basta iniciar o Tomcat para que Log4j entre em ação.

OBS (opcao na instalacao):

descompacte o arquivo jakarta-log4j-X.X.X.zip em um diretório de sua escolha e adicione a seguinte entrada ao seu CLASSPATH:

<diretório onde você descompactou o log4j>/dist/lib/log4j-X.X.X.jar

Está na hora de colocar o Log4J pra funcionar. Primeiramente, é preciso saber que o Log4J divide os logs em níveis hierárquicos (do nível mais baixo ao mais severo):

- DEBUG

- INFO

- WARN

- ERROR

- FATAL

Isso traz uma grande vantagem: é possível ajustar o nível de logging que você quer utilizar. Por exemplo: se você, testando sua aplicação, insere instruções de nível DEBUG, você poderia facilmente desligar este nível depois dos testes sem precisar apagar as instruções dentro do código.

Vamos aos exemplos:

import org.apache.log4j.Logger;

import org.apache.log4j.Level;

import org.apache.log4j.BasicConfigurator;

public class LoggingTest {

    static Logger logger = Logger.getLogger(LoggingTest.class);

    public static void main(String[] args) {

        BasicConfigurator.configure();

        logger.setLevel(Level.INFO);

        logger.debug(?Isso nao vai aparecer...?);

        logger.info(?Inicializando...?);

       

        try {

            throw new Exception(?Loga esse, Log4J!?);

        } catch (Exception e) {

            logger.error(?Oops, deu erro: ? + e.getMessage());

        }

        logger.info(?Finalizando...?);

     }   

} 

No código acima, o objeto da classe Logger é usado para enviar as mensagens de log. Primeiramente, é chamado o método

1 BasicConfigurator.configure() 

, que inicializa o sistema de logging com as configurações padrão. A seguir, o método setLevel() é utilizado para ajustar o nível de logging para INFO. A primeira instrução que realmente envia uma mensagem para o log é logger.debug(?Isso não vai aparecer...?);

Note que o nível de logging foi ajustado para INFO, que é um nível acima de DEBUG, portanto essa instrução não enviará nada para o log.

É possível enviar as mensagens de log para mais de um dispositivo de saída. Por exemplo: quando você faz uma chamada ao método configure() da classe BasicConfigurator, o Log4J é iniciado com a sua configuração padrão. Porém, muitas vezes é interessante armazenar um arquivo de log, para que as mensagens possam ser analisadas posteriormente. Para solucionar esse problema, o Log4J implementou os Appenders.

Um appender representa um dispositivo de saída de log. Para que um arquivo seja criado com as mensagens de log da sua aplicação, é necessário registrar um FileAppender para sua instância de Logger. Isto é feito através do método addAppender(). Exemplo:

import java.io.IOException;

import org.apache.log4j.Logger;

import org.apache.log4j.Level;

import org.apache.log4j.Appender;

import org.apache.log4j.FileAppender;

import org.apache.log4j.PatternLayout;

import org.apache.log4j.BasicConfigurator;

public class LoggingToFile {

    static Logger logger = Logger.getLogger(LoggingToFile.class);

    public static void main(String[] args) throws IOException {

        BasicConfigurator.configure();

        /* Cria um novo FileAppender baseado no layout padrão,

         * pré-definido na constante TTCC_CONVERSION_PATTERN

         * da classe PatternLayout. */

Appender fileAppender = new FileAppender(

            new PatternLayout(PatternLayout.TTCC_CONVERSION_PATTERN), ?myLogFile.log?);

       

         logger.addAppender(fileAppender);

       

        try {

            throw new Exception(?Loga esse no arquivo, Log4J!?);

        } catch (Exception e) {

            logger.error(?Oops, deu erro: ? + e.getMessage());

        }

    }   

} 

A novidade no código acima fica por conta da parte que registra um novo appender, no caso, um FileAppender, que armazena as mensagens de log em um arquivo. O construtor de FileAppender aceita dois argumentos: o primeiro é o Layout das mensagens; o segundo, o nome do arquivo de log que será criado. Vale lembrar que se o arquivo especificado já existir, as mensagens serão escritas no final do arquivo, mantendo o conteúdo já existente; senão, o Log4J criará o arquivo para você.

Além do FileAppender, existem ainda as classes ConsoleAppender (padrão, para mensagens no console), JDBCAppender (banco de dados), SMTPAppender (servidores de e-mail SMTP), SocketAppender (para servidores remotos) e IMAppender (para instant messengers!).

No nosso exemplo, as mensagens serão gravadas com o mesmo layout das mensagens padrão que vão para o console. Este layout é pré-definido na constante TTCC_CONVERSION_PATTERN da classe PatternLayout. Existem vários outros layouts que podem ser usados, representados pelas classes SimpleLayout, DateLayout, HTMLLayout e XMLLayout. Todas essas classes estendem a superclasse abstrata Layout. Além desses layouts pré-definidos, você pode criar seu próprio layout, criando uma subclasse de Layout e implementando seus métodos.     

JavaBeans

É um componente (classe) reutilizavel que quando chamada de um JSP ou ServLet segue certas regras:

1-    implementa a interface java.io.Serializable (que possibilita a persistência e restauração do estado do objeto da classe)

2-    possui um construtor sem argumentos;

3-    Suas propriedades sao acessíveis através de métodos "get" e "set", seguindo um padrão de nomenclatura

4-    Contem qualquer método de tratamento de eventos.

OBS: Em JSP, JavaBeans são usados para armazenar valores informados em um formulário, manter dados em sessão, recuperar e guardar informações de um banco de dados, etc. Em resumo, um JavaBean é uma classe Java a partir da qual nós podemos instanciar um objeto e usá-lo para passar informações entre as diversas páginas que compoêm uma aplicação web escrita em JSP.

Para incluir um bean dentro de um JSP usa-se:

<jsp:useBean id=”id_do_bean” class=”classe_do_bean” scope=”tipo_de_escopo”>

Tipo de escopo:  page (termina quando a pagina termina de gerar resposta), request (termina quando a resposta e enviada), session (quando a sessão e destruida), application. (quando aplicação web e destruida).

WEB-INF

            Classes           Serão colocados os arquivos .class (Servlets)
            Lib                   Serão colocados os arquivos .jar     (Beans)

Um beans pode estar em WEB-INF/lib/bean.jar, ou em WEB-INF/classes/package/bean.class.
C:\jboss-3.0.8_tomcat-4.1.24\server\default\deploy\teste.war\WEB-INF\lib\testeBean.jar
C:\jboss-3.0.8_tomcat-4.1.24\server\default\deploy\teste.war\WEB-INF\classes\testeBean\TesteBean.class.

jar cvfm [nome do jar][mf][class]
jar cvf [nome do jar][class]

Observação importante:

1-    Podemos criar um diretório por exemplo teste.war no webapps e tudo que colocarmos la será atualizado, ele funcionaria como um jar.

Modelo JavaBean:

package jbean;

import java.io.*;

public class bean_modelo implements Serializable
{
            private String nome;      

            public bean_modelo(){
            }         

            public void setNome(String nome){
                        this.nome= nome;
            }         

            public String getNome(){
                        return nome;
            }
}

obs. Para se acessar .jar em /lib e necessario definer o web.xml

ex.

<?xml version="1.0" encoding="ISO-8859-1"?>
<web-app xmlns="http://java.sun.com/xml/ns/j2ee"
               xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"               xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee  http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd" version="2.4">
            <display-name>Desenvolvimento</display-name>
            <description>
                        Descritor do contexto de desenvolvimento.
            </description>

            <servlet>
                        <servlet-name>dev-invoker</servlet-name>
                        <servlet-class>
                                   org.apache.catalina.servlets.InvokerServlet
                        </servlet-class>
                        <init-param>
                                   <param-name>debug</param-name>
                                   <param-value>0</param-value>
                        </init-param>
                        <load-on-startup>2</load-on-startup>
            </servlet>

            <servlet-mapping>
                        <servlet-name>dev-invoker</servlet-name>
                        <url-pattern>/servlet/*</url-pattern>
            </servlet-mapping>
</web-app>

Um package Java é um mecanismo para agrupar classes de finalidades afins ou de uma mesma aplicação. Além de facilitar a organização conceitual das classes, o mecanismo de pacotes permite localizar cada classe necessária durante a execução da aplicação. No entanto, a principal funcionalidade de um pacote Java é evitar a explosão do espaço de nome, ou seja, classes com o mesmo nome em pacotes diferentes podem ser diferenciadas pelo nome completo, pacote.classe.

Criando Javabeans (JAR)

A ferramenta jar é uma aplicação que combina múltiplos arquivos dentro de um simples arquivo .jar.

Arquivos .jar são geralmente usados para agrupar todos os arquivos de uma determinada aplicação Java. Pode também ser um arquivo executável.

Passo 1 Crie as classes

package pacoteJar;

public class Principal {

               public static void main(String[ ] args) {

                               new criarFrame();

               }

}

package pacoteJar;

import javax.swing.*;

public class criarFrame extends JFrame {

               public criarFrame() {

                               super(“Frame de exemplo”);

                               setBounds(120,120,250,250);

                               show();

               }

}

Passo 2 Crie o arquivo JAR

Para criar um arquivo jar basta apenas que você digite o seguinte comando no console:


>jar cvf classes.jar Foo.class Bar.class

O que esse comando faz é criar um arquivo chamado classes.jar contendo Foo.class e Bar.class. Os parâmetros passados, cvf significam:
-c = Crie um novo arquivo;
-v = Gere um output sobre o que está acontecendo;
-f = Especifique o nome do arquivo.

Passo 3 Crie o arquivo de manifesto (manifest.txt)

Pode-se também usar um comando mais "requintado" para inserir um arquivo Manisfest, determinado por você, em seu .jar. Isso porque o comando acima cria um Manifest.mf automaticamente sem configurações mais avançadas. Um arquivo manifest determina o funcionamento do seu jar. Ele é apenas um documento de texto que pode indicar a classe principal da sua aplicação ou outros arquivo necessários para que a sua aplicação funcione. Um exemplo de arquivo Manifest pode ser:

Manifest-Version: 1.0

Name: pacoteJar/Principal.class

Java-Bean: True

Main-Class: Principal.Principal    

Created-By: 1.2 (Sun Microsystems Inc.)

Name: pacoteJar/criarFrame.class

Java-Bean: True

Note que a ultima linha do Manifest deve estar em branco. O arquivo manifest é geralmente criado com o nome de MANIFEST.MF e, por default, fica num diretório chamado META-INF dentro do jar. O comando para gerar um jar com um manifest epecificado por você é: 

jar cvfm classes.jar mymanifest classes