Ciclo de Vida JSP: Introdução, Fases, Métodos

O que é ciclo de vida JSP?

O ciclo de vida JSP é definido como a tradução da página JSP em servlet, pois uma página JSP precisa primeiro ser convertida em servlet 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 solicita um JSP, o mecanismo JSP primeiro verifica se é necessário 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 ciclo de vida JSP é representado no diagrama abaixo.

Ciclo de Vida JSP

Following etapas 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 no arquivo de classe _jsp.class)
  4. Instanciação (Objeto do servlet gerado é criado)
  5. Inicialização (o método_jspinit() é invocado pelo contêiner)
  6. Processamento de solicitação (o método _jspservice() é invocado pelo contêiner)
  7. Destruir (método _jspDestroy() invocado pelo contêiner)

Deixe-nos ter um resumo mais detalhado sobre os pontos acima:

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

A Java O arquivo servlet é 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 tags.

  • 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 no later seção) usada nesta página JSP.
  • Na descrição pictórica acima, demo.jsp é traduzido para demo_jsp.java na primeira etapa
  • Vejamos um exemplo de “demo.jsp” conforme mostrado abaixo:

Demo.jsp

<html>
<head>
<title>Demo JSP</title>
</head>
<%
int demvar=0;%>
<body>
Count is:
<% Out.println(demovar++); %>
<body>
</html>

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

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

Linha de código 2: Etiqueta de cabeça

Linha de código 3 – 4: Tag de título, ou seja, Demo JSP e tag de fechamento head

Linha de código 5,6: Tag Scriptlet onde inicializa a variável demo

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

Linha de código 9: Tag scriplet onde tenta imprimir a variável demovar com valor incrementado

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

A página Demo JSP é convertida em servlet demo_jsp no código abaixo.

Ciclo de Vida JSP

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 os 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 a variável demovar 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:

Ciclo de Vida JSP

  • Aqui você pode ver que na captura de tela a saída é 1 porque demvar é inicializado em 0 e depois incrementado em 0+1=1

No exemplo acima,

  • demo.jsp, é um JSP onde uma variável é inicializada e incrementada. Este JSP é convertido no servlet (demo_jsp.class ) em que o mecanismo JSP carrega a página JSP e converte em conteúdo do servlet.
  • Quando a conversão acontece, todo o texto do modelo é convertido em instruções println() e todos 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 java servlet gerado é compilado na classe java servlet
  • A tradução da página de origem Java para sua classe de implementação pode acontecer a qualquer momento entre a implantaçã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. Carregamento de classe
  • A classe servlet que foi carregada da origem JSP agora é 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 ambos suportam JSP e servlet.
  • Uma interface JSPPage fornecida pelo contêiner fornece métodos init() e destroy ().
  • Existe uma interface HttpJSPPage que atende 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 de JSP e será invocada 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 o 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() é invocado pelo contêiner para todas as solicitações levantadas pela página JSP durante seu ciclo de vida
  • Para esta fase, é necessário passar por todas as fases acima e então apenas o método de serviço poderá ser invocado.
  • Ele passa objetos de solicitação e resposta
  • Este método não pode ser substituído
  • O método é mostrado acima: É responsável pela geração de todos os métodos HTTP, isto é.eGET, POST, etc.
  1. Destruir
    public void _jspdestroy()
    {
                //all clean up code
    }
  • O 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 realizamos qualquer limpeza, como liberar conexões de banco de dados ou fechar arquivos abertos.