Ciclo de vida do JSP: fases e diagrama explicados

O que é o ciclo de vida do JSP?

Ciclo de Vida JSP A conversão de uma página JSP em um servlet é definida como a tradução de uma página JSP em um servlet, pois uma página JSP precisa ser convertida em um servlet antes de poder processar requisições de serviço. O ciclo de vida começa com a criação da JSP e termina com a destruição da instância do servlet gerada a partir dela.

Como a classe gerada é um servlet comum, tudo o que você já sabe sobre a classe servlet continua valendo.tracAinda se aplica. Java O código que o contêiner escreve é ​​o que realmente é executado; o arquivo JSP é apenas o código-fonte que você mantém.

Diferentes fases do ciclo de vida JSP

Quando o navegador solicita um JSP, o mecanismo JSP primeiro verifica se precisa compilar a página. Se o JSP nunca foi compilado ou se foi modificado desde a última compilação, o mecanismo JSP compila a página.

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

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

Diagrama do Ciclo de Vida JSP

O ciclo de vida do JSP é representado no diagrama abaixo, que tracé uma única página, desde o arquivo de origem até a classe que o contêiner executa.

As etapas a seguir explicam o ciclo de vida do 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 (o arquivo _jsp.java é convertido no arquivo de classe _jsp.class)
4. Instanciação (um objeto do servlet gerado é criado)
5. Inicialização (o método jspInit() é invocado pelo contêiner)
6. Processamento da requisição (o método _jspService() é invocado pelo contêiner)
7. Destruir (o método jspDestroy() é invocado pelo contêiner)

Explicação das fases do ciclo de vida do JSP

Vamos analisar cada um dos pontos acima com mais detalhes.

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

A Java Um arquivo servlet é gerado a partir de um arquivo fonte JSP. Este é o primeiro passo do ciclo de vida do 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, bem como as ações personalizadas que fazem referência a bibliotecas de tags (todas fazem parte da página JSP e são abordadas no...). Elementos JSP tutorial) usado nesta página JSP.
• Na descrição pictórica acima, o arquivo 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>

Nota sobre a listagem acima: O texto é reproduzido exatamente como publicado para que corresponda à captura de tela do servlet gerado a seguir. Duas grafias incorretas não serão compiladas se copiadas literalmente — a variável é declarada como demvar mas impresso como demovare o objeto de saída implícito é out em minúsculas, não OutCorrija ambos antes de executar a página você mesmo.

Code Explicação para Demo.jsp

Code Linha 1: tag de início html

Code Linha 2: Etiqueta de cabeçalho

Code Linhas 3 e 4: Tag de título, ou seja, "Demo JSP", e tag de fechamento do cabeçalho.

Code Linhas 5-6: Tag do scriptlet onde a variável demo é inicializada.

Code Linhas 7 e 8: Na tag body, um texto a ser impresso na saída (Contagem é: )

Code Linha 9: Tag do scriptlet onde tentamos imprimir a variável demovar com seu valor incrementado.

Code Linhas 10-11: Fechamento das tags body e HTML

A página JSP de demonstração é convertida no servlet demo_jsp mostrado no código abaixo.

Code Explicação para Demo_jsp.java

Code Linha 1: A classe servlet demo_jsp estende a classe pai HttpServlet.

Code Linhas 2 a 3: Sobrescrevendo o método de serviço do JSP, ou seja, _jspService, que tem objetos HttpServletRequest e HttpServletResponse como parâmetros.

Code Linha 4: Método de abertura

Code Linha 5: Chamando o método getWriter() do objeto de resposta para obter uma impressãoWriter objeto (imprime uma representação formatada de objetos em um fluxo de saída de texto)

Code Linha 6: Chamando o método setContentType do objeto de resposta para definir o tipo de conteúdo.

Code Linha 7: Usando o método write() da classe PrintWriter objeto para analisar html

Code Linha 8: Inicializando a variável demovar com o valor 0.

Code Linha 9: Chamando o método write() da classe PrintWriter objeto para analisar o texto

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

Code Linha 11: Usando o método write() da classe PrintWriter objeto para analisar html

Saída:

Em seguida, o navegador renderiza o contador, como mostra a captura de tela abaixo.

• Aqui você pode ver que na captura de tela a saída é 1, porque a variável `demvar` é inicializada com 0 e depois incrementada para 0 + 1 = 1.

No exemplo acima,

• O arquivo demo.jsp é um JSP onde uma variável é inicializada e incrementada. Este JSP é convertido em um servlet (demo_jsp.class), no qual o mecanismo JSP carrega a página JSP e a converte em conteúdo de 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 Java código.

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

2) Compilação da página JSP

• O gerado Java O arquivo servlet é compilado em um Java classe de servlet
• A tradução do Java A conversão da página de origem para sua classe de implementação pode ocorrer 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, o arquivo demo_jsp.java é compilado para um arquivo de classe chamado demo_jsp.class.
• No Apache Tomcat, ambos os artefatos são gravados no diretório de trabalho do servidor, em work/Catalina/localhost/<app>/org/apache/jsp, que é o primeiro lugar a consultar quando se precisa diagnosticar um erro de tradução.

3) Carregamento de classe

• A classe servlet que foi gerada a partir do código-fonte JSP agora está carregada no contêiner.

4) Instanciação

• Nesta etapa, o objeto, ou seja, a instância da classe, é gerado.
• O contêiner gerencia uma ou mais instâncias dessa classe em 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 de um contêiner de servlet, já que ambos suportam JSP e servlets.
• A interface JspPage, fornecida pelo contêiner, declara os métodos jspInit() e jspDestroy().
• Existe uma interface HttpJspPage que atende requisições HTTP e também contém o método de serviço. Sua assinatura depende do protocolo, razão pela qual o contêiner gera esse método em vez de solicitar que o autor da página o declare.

5) Inicialização

public void jspInit()
{
	//initializing the code
}

• O método jspInit() inicializa a instância do servlet que foi gerada a partir do JSP e é invocado pelo contêiner nesta fase.
• Assim que a instância é criada, o método init é invocado imediatamente em seguida.
• Ele é chamado apenas uma vez durante o ciclo de vida de um JSP, e o método para inicialização é declarado conforme mostrado acima.

6) Processamento de solicitação

void _jspservice(HttpServletRequest request HttpServletResponse response)
{
	//handling all request and responses
}

• O método _jspService() é invocado pelo contêiner para todas as requisições feitas pela página JSP durante seu ciclo de vida.
• Nesta fase, a página precisa passar por todas as fases acima, e somente então o método de serviço pode ser invocado.
• Ele passa os objetos de solicitação e resposta.
• Este método não pode ser sobrescrito, pois o contêiner o escreve durante a tradução.
• O método é mostrado acima. Ele é responsável por lidar com todos os métodos HTTP, ou seja, GET, POST e os demais.

7) Destruir

public void _jspdestroy()
{
            //all clean up code
}

• O método jspDestroy() também é invocado pelo contêiner.
• Esse método é chamado quando o contêiner decide que não precisa mais da instância do servlet para atender às solicitações.
• Assim que a chamada ao método destroy for feita, o servlet estará pronto para ser coletado pelo coletor de lixo.
• Este é o fim do ciclo de vida.
• Podemos sobrescrever o método jspDestroy() ao realizar qualquer limpeza, como liberar conexões com o banco de dados ou fechar arquivos abertos.

Uma observação importante sobre a nomenclatura: a partir do Jakarta EE 9, esses tipos de aeronaves residem no jakarta.servlet.jsp pacote em vez de javax.servlet.jspPortanto, as importações mais antigas precisam ser atualizadas quando um aplicativo é migrado para um servidor atual.

Perguntas Frequentes