[MÚSICA] Olá,
meu nome é Eduardo Guerra, esse é curso de Desenvolvimento Ágil com Java Avançado.
Hoje vamos estar falando das páginas dinâmicas.
Na aula passada a gente viu pouquinho sobre o HTTP,
como que funciona essa questão de fazer a requisição de uma página.
Nessa aula eu quero que vocês entendam como que funciona a geração dinâmica
de conteúdo, como que eram as primeiras páginas dinâmicas e
como que a gente faz hoje no Java, com Servlets,
certo, então as primeiras páginas dinâmicas,
elas funcionavam mais ou menos assim: você mandava
uma requisição para o servidor web,
ele pegava os parâmetros e mandava para Script CGI,
que foi dos primeiros tipos de página dinâmica.
Então esse Script CGI é como se fosse
programa que é executado ali a cada requisição e o output desse programa é
a resposta que vai ser encaminhada pro usuário.
Fazendo paralelo, uma analogia bem a grosso modo,
é mais ou menos como se fosse o seguinte: quando o servidor web,
ele pega, ele vai rodar como se fosse programa de linha de comando,
passando aqueles parâmetros ali naquela linha de comando,
vai pegar o output que foi gerado, meio que
vai dar como se fosse Ctrl+C Ctrl+V e vai retornar aquilo para o usuário.
Qual que é o problema disso?
É que a cada requisição que for feita no servidor,
essa série de passos aqui acaba tendo que ser feita,
ou seja, alocar a memória, copiar a aplicação,
aquela aplicação pra memória, executar a aplicação,
pegar a saída, gerar a resposta e limpar aquela memória.
Agora imagina isso daí com várias requisições ao mesmo tempo.
Com o tempo foi visto que esse modelo não escalava pra muitas requisições
feitas ao mesmo tempo, pra uma quantidade muito grande de pessoas acessando o site.
No começo da internet talvez isso não fosse tanto problema,
mas hoje existem sites que recebem milhares,
até centenas de milhares de requisições simultâneas,
ao mesmo tempo, então hoje dia se utiliza modelo diferente,
eu vou falar aqui não de todas as formas, todas as abordagens,
mas eu vou falar especificamente sobre o modelo que a gente utiliza no Java EE,
que é o modelo dos Servlets, que também não é tão diferente de modelos de outras
linguagens e outras plataformas que existem aí hoje.
Então, o que acontece?
A gente tem o navegador,
a gente pode acompanhar aqui pelos numerozinhos ali na figura,
que eu vou até sair da frente pra vocês poderem ver direitinho.
O Navegador, ele vai submeter ali uma requisição,
é o que tá representado ali no número isso aí vai ser recebido pelo Web Container e
a primeira coisa que ele vai fazer vai ser criar objetos pra representar o Request,
que é a nossa requisição e o Response, que é a nossa resposta.
A partir do que tiver ali no objeto response vai ser gerada a resposta.
Esses objetos, é criado uma thread que vai
executar o método Service de Servlet e aí esse método
service vai olhar qual que é o método que tá sendo utilizado,
então se for o método Get, vai ser o método doGet, se for o Post,
vai ser o método doPost, então o método Blá,
vai ser o método doBlá, o método do HTTP ele é sempre: do+O
nome do método HTTP e ele passa como parâmetro o Request e o Response.
Então a partir da execução desse método, doGet ou doPost,
dependendo do caso, ele vai tá retornando,
depois da execução ele pega ali o que tem no response e e retorna.
A gente vai ver até tem uma questão ali de streaming,
ele pode já ir mandando enquanto tá executando,
a questão é que depois que ele manda a resposta pro Web Container,
o Web Container retorna isso pro Navegador como a resposta daquela requisição,
e aquela Thread, aquele Request e o Response acabam,
entre aspas, sendo destruídos, a Thread, na verdade,
ela é meio que reutilizada, mas podemos considerar pra uma descrição mais,
digamos assim abstrata, que ela não vai ser mais utilizada, na prática,
por economia de recursos ela acaba sendo reutilizada,
vai pra pool de Threads mas não é esse o escopo da nossa aula aqui hoje.
Então deixa eu voltar pra falar pouquinho sobre essa questão das Threads.
Então uma coisa importante que a gente tem que entender,
é que o mesmo Servlet é executado por Threads diferentes.
Se a gente for observar, a gente vai ter o mesmo método rodando o mesmo objeto,
que no caso é o Servlet, só que vão ter Threads diferentes.
Por causa disso a gente tem que tomar alguns cuidados, quando a gente for
falar de Threads a gente vai retomar essa questão pra explicar pouquinho mais,
mas a gente tem que tomar vários cuidados.
O que é interessante é que diferente lá daquela abordagem anterior onde
a gente tinha programa sendo executado a cada requisição,
aqui a gente tem o mesmo objeto sendo executado por processos diferentes.
Então essa questão da alocação de memória e tal, a gente tem uma série de vantagens
que permite que esse modelo escale bem melhor do que o modelo anterior.
Com isso a gente viu pouquinho como que funcionam essas páginas dinâmicas,
como que era o modelo antigo que utilizava os Scripts CGI e como
que é esse modelo mais recente, mais moderno,
que hoje dia é utilizado pelas principais plataformas web.
Muito obrigado e retornamos na próxima aula.
[MÚSICA]
Clovis FernandesProfessor Titular in Portuguese
Eduardo GuerraProfessor Colaborador
