Ciclo de Vida JSP

Por: James Hartmann James Hartmann
Hours Atualização do

ciclo de vida jsp

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.

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

Diagrama do Ciclo de Vida JSP

O ciclo de vida JSP é representado no diagrama abaixo.

Ciclo de Vida JSP

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 (_jsp.java é convertido no arquivo de classe _jsp.class)
  4. Instanciação (Objeto do servlet gerado é criado)
  5. Inicialização(_jspinit() método é invocado pelo contêiner)
  6. Processamento de solicitação (_jspservice() método é invocado pelo contêiner)
  7. Destruir (_jspDestroy() método 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 customizadas 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
  • 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 write() método do objeto PrintWriter tentando analisar html

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

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

Linha de código 10: Ligando print() método 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 write() método 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 para println() declarações e tudo Elementos JSP são convertidos para Java código.

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

ARTIGOS RELACIONADOS

2) 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

3) Carregamento de classe

  • A classe servlet que foi carregada da origem JSP agora é 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 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 init() e destroy() métodos.
  • Existe uma interface HttpJSPPage que atende solicitações HTTP e também contém o método de serviço.

5) Inicialização

public void jspInit()
{
	//initializing the code
}
  • _jspinit() O método iniciará a instância do servlet que foi gerada a partir do JSP e será chamada 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

6) Processamento de solicitação

void _jspservice(HttpServletRequest request HttpServletResponse response)
{
	//handling all request and responses
}
  • _jspservice() O método é 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 por gerar todos os métodos HTTP, ou seja, GET, POST, etc.

7) Destruir

public void _jspdestroy()
{
            //all clean up code
}
  • _jspdestroy() O método 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.
  • Nós podemos substituir jspdestroy() método quando realizamos qualquer limpeza, como liberar conexões de banco de dados ou fechar arquivos abertos.

Você pode gostar: