Páginas Dinâmicas

Loading...

En provenance du cours de Instituto Tecnológico de Aeronáutica

Desenvolvimento Ágil com Java Avançado

167 notes

Instituto Tecnológico de Aeronáutica

Desenvolvimento Ágil com Java Avançado

167 notes

Neste curso, assumimos que você já sabe projetar e desenvolver programas mais complexos em Java, graças às boas práticas e princípios orientados a objetos e TDD exercitados nos cursos anteriores; mas você talvez não se sinta ainda confortável em projetar programas para Web e com dados armazenados em banco de dados, bem como em aplicar conceitos mais avançados de Java. O objetivo deste curso é enriquecer sua experiência com conceitos avançados de Java, programação de aplicações Web e acesso a banco de dados no contexto de modelagem ágil. Os conceitos apresentados neste curso no contexto da programação Java incluem o seguinte: APIs fundamentais do Java: tipos genéricos, reflexão e anotações; expressões lambda do Java 8; aplicação Web com Java: Java Servlets, páginas JSP, padrão MVC e teste de aplicação Web com Selenium; e acesso a banco de dados em Java: JDBC, desenvolvimento de aplicação empresarial e testes com DBUnit. Ao final deste curso, você terá amadurecido de tal modo suas habilidades de programação que será capaz de implementar de modo ágil uma versão inicial da aplicação Web em associação com o componente de gamificação constantes do Trabalho de Conclusão da Especialização, com base nas boas práticas exercitadas neste curso.

À partir de la leçon

Semana 1

Olá, bem-vindo ao Curso 3 – Desenvolvimento Ágil com Java Avançado. Neste módulo você será introduzido ao maravilhoso mundo das aplicações Web com Java, criando páginas dinâmicas com servlets e conduzindo testes de aplicações Web por meio da ferramenta Selenium. Você será exposto também aos tipos genéricos do Java, entendendo os conceitos subjacentes e fazendo uso deles para prover tanto segurança de tipo em tempo de compilação, quanto para reduzir código redundante em exemplo prático.

Fundamentos de Aplicações Web15:17

Páginas Dinâmicas6:55

Criando Java Servlets8:54

Hands-on: Meu primeiro Servlet10:27

Teste de Aplicações Web com Selenium7:38

Hands-on: Gravando e Executando Testes com Selenium - Parte 17:59

Hands-on: Gravando e Executando Testes com Selenium - Parte 212:01

Rencontrer les enseignants

Clovis Fernandes
Professor Titular in Portuguese
Ciência da Computação
Eduardo Guerra
Professor Colaborador

[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]

Explorer notre catalogue

Rejoignez-nous gratuitement et obtenez des recommendations, des mises à jour et des offres personnalisées.

Coursera propose un accès universel à la meilleure formation au monde, en partenariat avec des universités et des organisations du plus haut niveau, pour proposer des cours en ligne.

© 2018 Coursera Inc. Tous droits réservés.

Télécharger dans l'App Store

Disponible sur Google Play