Ciclo de vida JSP: introdução, fases, métodos

O que é JSP LifeCycle?

O ciclo de vida JSP é definido como a tradução da página JSP em servlet, pois uma página JSP precisa ser convertida em servlet primeiro para processar as solicitações de serviço. O Ciclo de Vida começa com a criação do JSP e termina com a desintegração deste.

Vamos aprender as diferentes fases do ciclo de vida JSP

Quando o navegador pede um JSP, o mecanismo JSP primeiro verifica se ele precisa compilar a página. Se o JSP foi compilado pela última vez ou a modificação recente foi feita no JSP, o mecanismo JSP compila a página.

O processo de compilação da página JSP envolve três etapas:

  • Análise de JSP
  • Transformando JSP em servlet
  • Compilando o servlet

O JSP Lifecycle é descrito no diagrama abaixo.

As etapas a seguir explicam o ciclo de vida JSP:

  1. Tradução da página JSP
  2. Compilação da página JSP (Compilação da página JSP em _jsp.java)
  3. Carregamento de classe (_jsp.java é convertido para o arquivo de classe _jsp.class)
  4. Instanciação (o objeto do servlet gerado é criado)
  5. Inicialização (método _jspinit () é invocado pelo contêiner)
  6. Processamento de solicitação (método _jspservice () é invocado pelo contêiner)
  7. Método Destroy (_jspDestroy () invocado pelo contêiner)

Vamos ter um resumo mais detalhado dos pontos acima:

  1. Tradução da página JSP:

Um arquivo de servlet Java é gerado a partir de um arquivo de origem JSP. Esta é a primeira etapa do ciclo de vida JSP. Na fase de tradução, o contêiner valida a correção sintática da página JSP e dos arquivos de tag.

  • O contêiner JSP interpreta as diretivas e ações padrão e as ações personalizadas que fazem referência às bibliotecas de tags (todas fazem parte da página JSP e serão discutidas na seção posterior) usadas nesta página JSP.
  • Na descrição pictórica acima, demo.jsp é traduzido para demo_jsp.java na primeira etapa
  • Vamos dar um exemplo de 'demo.jsp' conforme mostrado abaixo:

Demo.jsp

 Demo JSP Count is: 

Explicação do código para Demo.jsp

Linha de Código 1 : tag de início html

Linha de Código 2 : Tag de cabeça

Linha de código 3 - 4 : Tag de título, ou seja, JSP de demonstração e tag de cabeçalho de fechamento

Linha de Código 5,6 : Tag Scriptlet em que inicializar a demonstração da variável

Linha de código 7 - 8 : Na tag body, um texto a ser impresso na saída (a contagem é:)

Linha de código 9: Tag Scriplet onde se tenta imprimir o demovar variável com valor incrementado

Linha de código 10-11: Tags de corpo e HTML fechadas

A página JSP de demonstração é convertida em servlet demo_jsp no código a seguir.

Explicação do código para Demo_jsp.java

Linha de Código 1 : A classe servlet demo_jsp está estendendo a classe pai HttpServlet

Linha de Código 2,3 : Substituindo o método de serviço de jsp, ou seja, _jspservice que tem objetos HttpServletRequest e HttpServletResponse como seus parâmetros

Linha de Código 4 : Método de abertura

Linha de Código 5 : Chamando o método getWriter () do objeto de resposta para obter o objeto PrintWriter (imprime a representação formatada de objetos no fluxo de saída de texto)

Linha de Código 6 : Chamando o método setContentType do objeto de resposta para definir o tipo de conteúdo

Linha de Código 7 : Usando o método write () do objeto PrintWriter tentando analisar html

Linha de Código 8 : Inicializando a variável demovar para 0

Linha de Código 9 : Chamando o método write () do objeto PrintWriter para analisar o texto

Linha de Código 10 : Chamando o método print () do objeto PrintWriter para incrementar o demovar variável de 0 + 1 = 1. Portanto, a saída será 1

Linha de Código 11 : Usando o método write () do objeto PrintWriter tentando analisar html

Saída:

  • Aqui você pode ver que na captura de tela a Saída é 1 porque o demvar é inicializado para 0 e então incrementado para 0 + 1 = 1

No exemplo acima,

  • demo.jsp, é um JSP em que uma variável é inicializada e incrementada. Este JSP é convertido para o servlet (demo_jsp.class) em que o mecanismo JSP carrega a página JSP e converte para o conteúdo do servlet.
  • Quando a conversão ocorre, todo o texto do modelo é convertido em instruções println () e todos os elementos JSP são convertidos em código Java.

É assim que uma página JSP simples é traduzida em uma classe de servlet.

  1. Compilação da página JSP
  • O arquivo de servlet java gerado é compilado na classe de servlet java
  • A tradução da página de origem java para sua classe de implementação pode acontecer a qualquer momento entre a implementação da página JSP no contêiner e o processamento da página JSP.
  • Na descrição pictórica acima, demo_jsp.java é compilado em um arquivo de classe demo_jsp.class
  1. Classloading
  • A classe de servlet que foi carregada da fonte JSP agora está carregada no contêiner
  1. Instanciação
  • Nesta etapa, o objeto, ou seja, a instância da classe, é gerado.
  • O contêiner gerencia uma ou mais instâncias desta classe na resposta a solicitações e outros eventos. Normalmente, um contêiner JSP é construído usando um contêiner de servlet. Um contêiner JSP é uma extensão do contêiner de servlet, pois o contêiner suporta JSP e servlet.
  • Uma interface JSPPage fornecida pelo contêiner fornece os métodos init () e destroy ().
  • Há uma interface HttpJSPPage que atende a solicitações HTTP e também contém o método de serviço.
  1. Inicialização
     public void jspInit() { //initializing the code }
  • O método _jspinit () iniciará a instância do servlet que foi gerada a partir do JSP e será invocado pelo contêiner nesta fase.
  • Assim que a instância for criada, o método init será invocado imediatamente após isso
  • É chamado apenas uma vez durante um ciclo de vida JSP, o método de inicialização é declarado conforme mostrado acima
  1. Solicitar processamento
     void _jspservice(HttpServletRequest request HttpServletResponse response) { //handling all request and responses }
  • O método _jspservice () é chamado pelo contêiner para todas as solicitações levantadas pela página JSP durante seu ciclo de vida
  • Para esta fase, ele deve passar por todas as fases acima e, então, apenas o método de serviço pode ser chamado.
  • Ele passa objetos de solicitação e resposta
  • Este método não pode ser sobrescrito
  • O método é mostrado acima: é responsável pela geração de todos os métodos HTTP, ou seja, GET, POST, etc.
  1. Destruir
     public void _jspdestroy() { //all clean up code }
  • método _jspdestroy () também é invocado pelo contêiner
  • Este método é chamado quando o contêiner decide que não precisa mais da instância do servlet para atender às solicitações.
  • Quando a chamada para o método destroy é feita, o servlet está pronto para uma coleta de lixo
  • Este é o fim do ciclo de vida.
  • Podemos substituir o método jspdestroy () quando executamos qualquer limpeza, como liberar conexões de banco de dados ou fechar arquivos abertos.