4º Semestre - Tecnologia Cliente - Servidor PDF

Tecnologia Cliente - Servidor
CURSO SUPERIOR DE TECNOLOGIA EM

SISTEMAS PARA INTERNET
.:: 4º SEMESTRE ::.
GUIA DE ESTUDO DA DISCIPLINA
TECNOLOGIA
CLIENTE - SERVIDOR
AUTOR
MSc Nelcileno Virgílio de Souza Araújo
Julho / 2009
GOVERNO FEDERAL
Luis Inácio Lula da Silva

Presidente do Brasil
Fernando Haddad
Ministro da Educação
Carlos Eduardo Bielschowsky

Secretário de Educação a Distância
Jorge Almeida Guimarães

Presidente da Coordenação de Aperfeiçoamento de Pessoal de Nível Superior (CAPES)
Celso José da Costa

Diretor de Educação a Distância da Universidade Aberta do Brasil (UAB) na CAPES
INSTITUTO FEDERAL DE EDUCAÇÃO, CIÊNCIA

E TECNOLOGIA DO MATO GROSSO (IFMT)
José Bispo Barbosa

Reitor
Willian Silva de Paula

Pró Reitor de Ensino
Alexandre José Schumacher

Coordenador Geral UAB/IFMT
Vinícius de Matos Rodrigues

Coordenador Adjunto UAB/IFMT
Coordenação da UAB/IFMT
Instituto Federal de Educação, Ciência e Tecnologia do Mato Grosso (IFMT) - Campus Bela Vista - Avenida
Juliano Costa Marques S/N, CEP: 78.050-560, Bela Vista, Cuiabá/MT - Brasil
Flaviana Abdo Esteves

Editoração eletrônica
Luisa do Amparo Carvalho Patatas

Revisão de português
A produção deste material didático obteve financiamento no âmbito do Programa Universidade Aberta do
Brasil, CAPES/FNDE/MEC.
Autoriza-se o uso e a reprodução da obra no âmbito do Sistema UAB e o IFMT desde que citada a fonte. É
vedado o uso desta obra para fins de comercialização.
CURSO SUPERIOR DE TECNOLOGIA EM SISTEMAS PARA INTERNET
___________________________________________________________________________________________________________________________________________________________________________________________________

SUMÁRIO
UNIDADE I
Conceitos Fundamentais sobre a Tecnologia Cliente-Servidor
UNIDADE II
Programação e Desenvolvimento de Aplicações com Threads
UNIDADE III
Programação e Desenvolvimento de Aplicações com
Sockets
UNIDADE IV
Programação e Desenvolvimento de Aplicações com conexões
de Banco de Dados
UNIDADE V
Servlets
UNIDADE VI
Java Server Pages (JSP)
UNIDADE VII
Programação Distribuída
_________________________________________________________________________________________________
SUMÁRIO 1
___________________________________________________________________________________________________________________________________________________________________________________________________

APRESENTAÇÃO
Prezado(a) aluno(a),
Atualmente fica cada vez mais difícil imaginar uma aplicação que seja empregada de forma isolada. A
necessidade de programas que façam acesso remoto a base de dados localizadas em outros computadores
tornou-se imprescindível.
Para suprir essa carência foi necessária a criação de aplicações que utilizassem uma tecnologia de
solicitação e resposta. Nessa tecnologia, existe a entidade que faz a requisição (cliente) e aquele que a
responde (servidor). Aplicações desenvolvidas nesta tecnologia são denominadas cliente-servidor.
Um bom exemplo a ser citado é o dos navegadores de Internet (Firefox, Internet Explorer, dentre outros)
os quais utilizam esta tecnologia para fazer acesso a inúmeras funções no sítio informado. Nesse caso, os
navegadores desempenham o papel de cliente e as páginas acessadas o papel de servidores, aliás, elas estão
armazenadas em servidores web, como podemos ver, o próprio nome já indica o papel desenvolvido por elas.
A nossa disciplina terá como objetivo apresentar para vocês quais são os passos para o desenvolvimento
de uma aplicação cliente-servidor, para isso, é essencial conhecer as principais metodologias de
desenvolvimento e os conceitos essenciais para desenvolver a habilidade de programação neste paradigma.
É interessante que vocês façam uma revisão básica sobre arquitetura TCP/IP antes de iniciar este módulo
de estudo. Já que, neste paradigma, as camadas de aplicação e transporte são bastante citadas. Como também,
ter um conhecimento prévio de Sistemas Operacionais na unidade curricular de comunicação e sincronização
de processos.
Desejo-lhes um bom trabalho, e quero me colocar à sua inteira disposição para troca de idéias e
vivências. Entre em contato, sempre que quiser, através do seu tutor ou dos coordenadores do curso, ou se
preferir, diretamente para o seguinte e-mail: nelcileno@yahoo.com.br
Tenha um excelente ano letivo!
O Autor
Prof. MSc Nelcileno Virgílio de Souza Araújo
_________________________________________________________________________________________________
CONCEITOS FUNDAMENTAIS SOBRE A TECNOLOGIA CLIENTE‐SERVIDOR ‐ UNIDADE I 2 1
___________________________________________________________________________________________________________________________________________________________________________________________________

TECNOLOGIA CLIENTE-SERVIDOR
1. EMENTA DO CURSO
Conceitos e fundamentos da tecnologia cliente-servidor. Tipos de aplicações cliente-servidor.
Desenvolvimento de aplicações com comunicação por multithread, conexões de banco de dados, sockets e
objetos remotos.
2. PROGRAMA DA DISCIPLINA
Carga Horária: 80 horas
Objetivo Geral
Desenvolver no aluno a competência em implementar aplicações na tecnologia cliente servidor e

escolher qual a metodologia de desenvolvimento adequada para o seu problema.
3. DEFINIÇÃO DAS UNIDADES (TEMAS)

A disciplina está dividida em 7 unidades, da seguinte forma:
Unidade 1 – Conceitos Fundamentais sobre a Tecnologia Cliente-Servidor
Unidade 2 – Programação e Desenvolvimento de Aplicações com Threads
Unidade 3 – Programação e Desenvolvimento de Aplicações com Sockets
Unidade 4 – Programação e Desenvolvimento de Aplicações com conexões de Banco de Dados
Unidade 5 – Servlets
Unidade 6 – JavaServer Pages (JSP)
Unidade 7 – Aplicações Multicamadas
_________________________________________________________________________________________________
___________________________________________________________________________________________________________________________________________________________________________________________________

UNIDADE I
Conceitos Fundamentais sobre a Tecnologia Cliente-
Servidor
Nesta unidade, será feita uma revisão sobre os princípios que formam o conceito de tecnologia cliente-
servidor.
Para darmos início ao desenvolvimento de aplicações cliente-servidor é interessante que você tenha um
embasamento teórico sobre esse assunto. Sendo assim, bom estudo e vamos começar a nossa aula.
TÓPICO 1 – INTRODUÇÃO A SISTEMAS DISTRIBUÍDOS

Uma página Web quando é acessada no seu computador por meio de um navegador, percorre um trajeto
até alcançar um ou vários outros computadores que hospedam este conteúdo. Este processo é completamente
transparente para o usuário. Cada servidor que hospeda este conteúdo pode rodar um tipo de sistema
operacional diferente, mas para o usuário é como se visse um único sistema.
Qual é a tecnologia que permite essa transparência para o usuário no acesso das páginas
no navegador web?
A resposta para nossa pergunta anterior são os sistemas distribuídos. São eles que passam essa sensação
para o usuário de que está acessando apenas um único servidor, mas pode estar havendo acesso a vários
servidores antes de ter a resposta.
Vamos formalizar o conceito de sistemas distribuídos,
É um conjunto de computadores independentes que se apresenta a seus usuários

como um sistema único e coerente (Tanenbaum et. al, 2008).
A independência afirmada por Tanembaum consiste no fato de você poder ter computadores com
diferentes sistemas operacionais e arquiteturas de hardware sem causar problema de incoerência.
Então, quem faz essa compatibilidade de software e hardware tornar-se transparente para o usuário? O
responsável por essa função é uma camada intermediária entre uma camada de nível mais alto, composta por
usuários e aplicações, e uma camada subjacente, formada por sistemas operacionais e protocolos de
comunicação, como mostra a Figura 1. Essa camada é conhecida como middleware.
.
_________________________________________________________________________________________________
___________________________________________________________________________________________________________________________________________________________________________________________________

Figura 1 – Sistema distribuído organizado como middleware.
E então, você compreendeu o que é um sistema distribuído e qual é o

papel do middleware dentro de um sistema distribuído?
Agora, pode surgir uma dúvida: “Qual a relação entre sistema distribuído e tecnologia cliente-servidor?”
Calma, antes de respondermos a essa pergunta precisamos apresentar mais algumas definições para depois
fazermos essa relação.
O próximo tópico a ser estudado é sobre os tipos de sistemas distribuídos. Então, vamos lá.
TÓPICO 2 – TIPOS DE SISTEMAS DISTRIBUÍDOS

Um sistema distribuído pode ser desenvolvido de diversas formas. O que define a sua implementação é a
aplicação a que será destinada. Seguindo esse ponto de vista, ele assume três perfis: um sistema de
computação distribuído, um sistema de informação distribuído e um sistema embutido distribuído.
O primeiro perfil, apresentado na Figura 2, é voltado para tarefas de computação de alto desempenho, ou
seja, o usuário possui uma aplicação que necessita de uma grande carga computacional e utiliza uma aplicação
distribuída para compartilhar a carga de trabalho com inúmeros computadores.
Um exemplo a ser citado é o projeto SETI@home, desenvolvido pela Universidade de Berkeley, no qual
computadores processam informações recebidas por dispositivos, cuja intenção é procurar vida inteligente em
outros planetas.
_________________________________________________________________________________________________
___________________________________________________________________________________________________________________________________________________________________________________________________

Figura 2 – Computação distribuída
Nos sistemas de informações distribuídos, o foco da aplicação é gerencial. Há a necessidade de que as

aplicações em rede rodando nas estações de uma organização sejam interoperáveis, quem faz isso acontecer é
exatamente a camada de middleware do sistema distribuído.
A Figura 3 apresenta um tipo de solução utilizada em sistemas de informações distribuídos, que é a

integração de aplicações corporativas (EAI – Enterprise Application Integration). Ela desenvolve a integração
das diferentes aplicações existentes na empresa através de um middleware de comunicação.
Aplicação Aplicação
cliente cliente
Middleware de comunicação
Aplicação Aplicação Aplicação

do lado do lado do lado
servidor servidor servidor
Figura 3 – Middleware como facilitador de comunicação em integração de aplicações corporativas

(Tanembaum, 2008).
Por último, existem os sistemas embutidos distribuídos que procuram oferecer essa visão única do
sistema para dispositivos de computação móveis e embutidos. Nesse tipo de sistema, o controle administrativo
humano deve ser o mínimo possível. A máquina precisa ser autoconfigurável e autogerenciável.
A casa inteligente, mostrada na Figura 4, é uma aplicação de sistemas embutidos distribuídos, onde
_________________________________________________________________________________________________
___________________________________________________________________________________________________________________________________________________________________________________________________

ocorre a integração dos diversos sistemas (iluminação, segurança, hidráulica, entretenimento) eletrônicos de
uma casa. Com a integração, cada sistema tem informações do outro e, assim, um pode influenciar nas
decisões dos outros.
Figura 4 – Casa inteligente
Calma, alunos! Estamos quase chegando à relação entre sistemas distribuídos e tecnologia cliente-
servidor. No tópico seguinte, trataremos sobre as arquiteturas de software de um sistema distribuído. Aí, vocês
entenderão essa relação.
Para finalizar, faço uma pergunta:
Uma aplicação cliente-servidor se enquadra em qual dos tipos de sistemas

distribuídos apresentados neste tópico? Justifique sua resposta.
TÓPICO 3 – ARQUITETURAS DE SOFTWARE EM UM SISTEMA DISTRIBUÍDO

Sistemas distribuídos são compostos por componentes de software espalhados em diferentes estações. A
arquitetura de software tem a responsabilidade de definir como os diversos componentes de software devem
ser organizados e como devem interagir.
Sendo assim, para iniciarmos o desenvolvimento de aplicações distribuídas devemos escolher qual
modelo de arquitetura de software será utilizado. Discutiremos, a seguir, as seguintes arquiteturas: cliente-
servidor, peer-to-peer e híbrida.
Na arquitetura cliente-servidor, os serviços oferecidos pelo sistema distribuído ficam centralizados num
_________________________________________________________________________________________________
___________________________________________________________________________________________________________________________________________________________________________________________________

único servidor, que pode ser uma ou mais estações. Já as estações clientes fazem acesso remoto ao servidor
para solicitar os serviços distribuídos.
A Figura 5 ilustra um exemplo clássico deste tipo de arquitetura, na qual temos um servidor web que
fornece serviços de um portal de turismo aos usuários (estação cliente) interessados em obter informações
turísticas.
Figura 5 – Aplicação cliente-servidor.
Se a arquitetura cliente-servidor possui uma organização centralizada de serviços. O modelo peer-to-

peer vai em direção contrária, pois todas as estações da rede tanto podem oferecer serviços como podem
acessá-los. Por isso, se diz que sua organização é descentralizada.
Para que haja uma simetria nos processos de solicitação e resposta conduzida pelas estações, há uma
rede de sobreposição onde os processos interagem através de troca de mensagens por meio de canais de
comunicação existentes. A Figura 6 apresenta um bom exemplo de aplicação peer-to-peer, o eMule, onde os
nós oferecem o serviço de compartilhamento de arquivos.
Vejamos como funciona o eMule: quando você libera um grupo de arquivos para compartilhamento, a
aplicação inicia um processo servidor que ficará a espera de alguma solicitação para, a seguir, oferecer o
serviço de compartilhamento. Enquanto, simultaneamente, esta mesma aplicação pode gerar um processo
cliente solicitando o serviço de compartilhamento de um nó em que há comunicação disponível.
_________________________________________________________________________________________________
___________________________________________________________________________________________________________________________________________________________________________________________________

Figura 6 – Aplicação peer-to-peer.
Finalmente, a arquitetura híbrida congrega características de uma aplicação cliente-servidor e peer-to-

peer. Um exemplo disso é a aplicação de mensagem instantânea, ilustrada na Figura 7. Nela, a conversa entre
dois usuários é tipicamente peer-to-peer, ou seja, o texto enviado entre dois usuários não passa por um
servidor central. Entretanto, quando um usuário executa sua aplicação de mensagem instantânea, ela se
registra em um servidor central; e quando um outro usuário quer conversar com alguém inscrito na sua lista de
amigos, seu cliente de mensagem instantânea acessa o servidor central para buscar quais desses seus amigos
estão atualmente on-line e disponíveis (Kurose, 2006).
Neste tópico, mostramos que uma aplicação cliente-servidor é uma forma de organização dos
componentes de software de um sistema distribuído. Vamos, no próximo tópico, entrar mais a fundo nos
princípios da tecnologia cliente-servidor. Até lá e respondam à pergunta abaixo.
Qual a relação existente entre a tecnologia cliente-servidor e sistemas

distribuídos?
_________________________________________________________________________________________________
___________________________________________________________________________________________________________________________________________________________________________________________________

Figura 7 – Aplicação híbrida
TÓPICO 4 – PRINCÍPIOS DA TECNOLOGIA CLIENTE-SERVIDOR

Como já foi apresentada no tópico anterior, a tecnologia cliente-servidor baseia-se no princípio de que os
serviços oferecidos pela rede estão centralizados num único componente conhecido como servidor, enquanto
os elementos que usufruem desses serviços são chamados de cliente.
Neste tópico, trataremos das diferentes formas de representar uma tecnologia cliente-servidor.
Primeiramente, é necessário ofertarmos uma visão geral da arquitetura cliente-servidor.
O modelo de camadas é o estilo arquitetônico mais comumente usado na tecnologia cliente-servidor. As

funções atribuídas a cada camada podem ser representadas pelas seguintes ações: realizar interface do usuário
com a aplicação (camada de apresentação), criar e manter as regras de serviço da aplicação (camada de
aplicação) e gerenciar os dados que estão sendo executados em alguma aplicação (camada de dados). Agora,
como essas ações estão distribuídas tanto no lado cliente quanto no lado servidor da aplicação que determina o
tipo de arquitetura a ser utilizada, ela pode ser implementada em 2, 3, 4 ou n camadas.
Uma aplicação com duas camadas, apresentada na Figura 8, é a forma mais tradicional de uma
arquitetura cliente-servidor. Nela, o lado cliente contém a interface lógica com o usuário, navegação e
apresentação do sistema de informação. O lado servidor é responsável pela base de dados e sua lógica de
manipulação. Geralmente, elas se encontram em plataformas diferentes, comunicando-se através de protocolos
de rede e de uma API. Mas, também podem estar numa mesma máquina, comunicando-se por interprocessos.
_________________________________________________________________________________________________
___________________________________________________________________________________________________________________________________________________________________________________________________

Figura 8 – Arquitetura em duas camadas.
Este tipo de aplicação ficou mais conhecida como “cliente gordo”. Uma vez que, o lado cliente
centralizava a maioria das ações da aplicação, ficando para o lado servidor apenas a função de gerir a base de
dados referenciada por ela.
Observamos que nos últimos anos tem ocorrido forte tendência para abandonar o estilo “cliente gordo”.
A razão para isso é simples: embora as máquinas clientes tenham capacidade computacional para oferecer tais
serviços, também são mais problemáticas para gerenciar. Ter mais funcionalidades no lado cliente torna a
aplicação mais propensa a erros e mais dependente da plataforma existente no cliente.
Com a limitação deste modelo, surge uma nova proposição com três camadas na qual temos uma
aplicação cliente que solicita serviços de um servidor de aplicação e ele manipula dados de um banco de dados
ou de outro servidor de aplicação. A Figura 9 ilustra como estes componentes são representados numa
arquitetura em três camadas.
Figura 9 – Arquitetura em três camadas.
Como o lado cliente de uma aplicação em três camadas é bem enxuto, usamos o termo “cliente magro”
para identificá-la. Um exemplo típico de cliente magro é o aplicativo de navegador Web executando um
conjunto de páginas HTML, em que há pouquíssimos aplicativos no cliente. Quase todo o trabalho é realizado
em um ou mais servidores de aplicação e servidores de dados.
_________________________________________________________________________________________________
___________________________________________________________________________________________________________________________________________________________________________________________________

Com a introdução da camada de aplicação, no modelo em três camadas, resolvemos o problema de

termos que atualizar a aplicação, em centenas ou milhares de computadores, cada vez que uma regra do
negócio for alterada. Porém continuamos com o problema de atualização da aplicação, cada vez que forem
necessárias mudanças na Interface. Por isso surgiram os modelos em 4 camadas.
A idéia básica do modelo em 4 camadas é centralizar as funções de apresentação do aplicativo num

componente conhecido como servidor Web e deixar no lado cliente apenas um navegador (Internet Explorer,
Firefox) responsável por realizar as requisições de serviço a este novo componente. As requisições que
chegam nele, por meio de parâmetros, são repassadas para o componente de aplicação que executará o serviço
solicitado e criará um documento HTML com o resultado, e em seguida o apresentará ao cliente. A Figura 10
ilustra a organização de um modelo em 4 camadas, em que o servidor de aplicação utiliza a tecnologia CGI
para executar as solicitações do usuário.
Figura 10 – Arquitetura em 4 camadas.
Apesar disso, ainda persistiam algumas limitações no modelo em 4 camadas, tais como: a necessidade
do acesso ao sistema de informação ser feito apenas por meio de um navegador, dificuldade de integração das
aplicações, forte acoplamento entre os componentes de serviço, falta de padronização, dentre outros. Tudo
isso, tornava difícil o desenvolvimento de uma aplicação mais robusta que integrasse diferentes serviços. Com
o intuito de solucionar esse problema foi introduzido o componente de middleware num servidor de aplicação,
que integra diferentes serviços que passam a ser vistos como objetos distribuídos. Essa nova organização do
modelo cliente-servidor é chamada de arquitetura multicamadas ou orientada a componentes.
A plataforma Java 2 Enterprise Edition (J2EE), mostrada na Figura 11, é uma solução que representa
este tipo de arquitetura, onde temos o componente Enterprise Java Beans (EJB) como middleware que integra
os diferentes serviços oferecidos pela aplicação, tais como: permitir criar conexões de banco de dados
(JDBC), serviços de nomeação e diretórios (JNDI), comunicação entre aplicações por serviços de mensagens
(JMS), serviços de gerenciamento de transações distribuídas (JTA), dentre outros.
_________________________________________________________________________________________________
___________________________________________________________________________________________________________________________________________________________________________________________________

Figura 11 – Plataforma J2EE
Depois que estudamos as diversas formas de arquitetura cliente-servidor, me respondam:
Qual é a diferença de filosofia existente entre os diversos tipos de

arquitetura cliente-servidor apresentados neste tópico?
Bem, pessoal! Sei que neste tópico vimos muitos conceitos sobre os diversos tipos de tecnologia cliente-
servidor. Eles serão aprofundados numa abordagem mais prática a partir das próximas unidades. A primeira
abordagem a ser trabalhada será o modelo em duas camadas, que iremos tratar nas unidades 2, 3 e 4 sobre o
desenvolvimento cliente-servidor utilizando conexões com threads, sockets e banco de dados. A seguir, nas
unidades 5 e 6 veremos a programação com servlets e JavaServer Pages (JSP) enfocando os modelos em 3/4
camadas. Finalmente, na última unidade estudaremos como construir uma aplicação multicamadas utilizando
a plataforma J2EE. Sendo assim, encerramos essa unidade. Qualquer dúvida ou sugestão, procure o seu tutor e
não esqueça de fazer os exercícios de aplicação no final da unidade.

REFERÊNCIAS BIBLIOGRÁFICAS

KUROSE, J. F.; ROSS, K. W. Redes de computadores e a Internet: uma abordagem top-down. 3. ed.
São Paulo: Pearson Prentice Hall, 2006.
ROCHA, C. A. de S. Análise de desempenho em ambientes cliente/servidor 2-camadas e 3-camadas.

2002. 139f. Dissertação (Mestrado em Ciência da Computação) - Universidade Federal de Santa Catarina,
Florianópolis.
_________________________________________________________________________________________________
___________________________________________________________________________________________________________________________________________________________________________________________________

TANENBAUM, A. S.; STEEN, M. V. Sistemas distribuídos: princípios e paradigmas. 2. ed. São Paulo:
Pearson Prentice Hall, 2007.
Introdução e Motivação: Arquitetura em n camadas. Disponível em

http://www.dsc.ufcg.edu.br/~jacques/cursos/j2ee/html/intro/intro.htm. Acesso em 29 de janeiro de 2009.
Criando aplicações em 3, 4 ou n camadas. Disponível em

http://www.juliobattisti.com.br/artigos/ti/ncamadas.asp. Acesso em 29 de janeiro de 2009.
RESPOSTAS PARA AS AUTO-AVALIAÇÕES
Vamos então ver se você respondeu aos questionamentos

deixados ao longo da unidade, representados pelo ícone.
E então, você compreendeu o que é um sistema distribuído e qual é o papel do middleware

dentro de um sistema distribuído?
O sistema distribuído agrega o poder computacional de diversos computadores, interligados em redes,

para processar colaborativamente uma determina tarefa. Mas, para o usuário é como se apenas um único e
centralizado computador estivesse executando a tarefa.
Quem é responsável por essa transparência do sistema é a camada de middleware. Ela promove a
adaptabilidade de hardware e software das diferentes estações que fazem parte do sistema.
Uma aplicação cliente-servidor se enquadra em qual dos tipos de sistemas distribuídos

apresentados neste tópico? Justifique sua resposta.
Ela se enquadra em sistemas de informações distribuídos. Já que este tipo de modelo tem um foco no
lado gerencial. Tendo de um lado, um usuário que solicita serviços à empresa através da aplicação cliente, e
do outro, a empresa que presta informações através da aplicação servidor.
Qual a relação existente entre a tecnologia cliente-servidor e sistemas distribuídos?
A relação é que a tecnologia cliente-servidor é um tipo de arquitetura de software utilizada pelos

sistemas distribuídos na qual os serviços oferecidos pela rede se concentram num único componente chamado
servidor.
_________________________________________________________________________________________________
___________________________________________________________________________________________________________________________________________________________________________________________________

Qual é a diferença de filosofia existente entre os diversos tipos de arquitetura cliente-

servidor apresentado neste tópico?
Num modelo em duas camadas ocorre a centralização de serviços no lado cliente da aplicação, enquanto
o lado servidor fica somente responsável por gerenciar os dados utilizados por esses serviços. Já, o modelo em
três camadas retira as regras de serviço do lado cliente e as coloca num componente chamado servidor de
aplicação. Na arquitetura em quatro camadas, a parte de apresentação da aplicação é retirada do lado cliente e
colocada num componente servidor web. Por último, o modelo multicamadas ou multicomponentes coloca
cada serviço oferecido pela aplicação em um componente independente e os interliga através de um
middleware de comunicação.
EXERCÍCIOS DE APLICAÇÃO
1) Cite um exemplo de uma aplicação que seja um sistema distribuído, mostrando como ela dá a impressão
de ser um sistema único, ou seja, o fato de vários computadores poderem estar sendo utilizados torna-se
transparente para o usuário.
2) Procure num site de busca ou em livros na sua biblioteca, mais duas definições para middleware e depois
monte sua própria definição para ele e cite um exemplo.
3) Quais são os três perfis de sistemas distribuídos que uma aplicação pode assumir? Cite um exemplo
(diferente dos apresentados nesta unidade) de aplicação para cada um desses perfis, justificando sua
resposta.
4) Liste dois exemplos dos seguintes tipos de aplicações: cliente-servidor, peer-to-peer e híbrida.
Referenciando, em cada exemplo, as características que os enquadram neste tipo de aplicação.
5) Construa uma tabela identificando as características, vantagens e desvantagens de uma aplicação cliente-
servidor implementada em 2, 3, 4 ou n camadas.
_________________________________________________________________________________________________
___________________________________________________________________________________________________________________________________________________________________________________________________

UNIDADE II
Threads
O desenvolvimento de aplicações cliente-servidor com conexões threads é o foco desta unidade, na
qual serão abordados, inicialmente, os seus princípios de funcionamento. A seguir, veremos como a
linguagem JAVA implementa o uso de threads na programação de aplicações. Para tanto, estudaremos as
construções básicas, classes e métodos que envolvem a programação multithreading e, também, mostraremos
sua aplicação em interfaces gráficas e redes. Como podemos ver nessa breve introdução, teremos uma unidade
rica em conhecimento e bem prática. Então, vamos iniciar.
TÓPICO 1 – THREADS
O que é uma
thread? Com certeza, alguns leitores devem estar se perguntando
o que vem a ser um thread. Para entendermos, vamos
exemplificar uma situação: Um editor de texto em execução
apresenta vários eventos, tais como: interface gráfica,
movimentação do cursor, gravação automática do texto,
autocorreção, dentre outros. O aplicativo na sua totalidade é
visto pelo sistema operacional como um processo em que são
alocados recursos (memória principal, processador, dispositivos
de E/S) do computador. Este processo, por sua vez, delega suas funções a elementos coordenados por ele, que
as executam paralelamente. Estes elementos subordinados ao processo são os threads.
Sendo assim, um thread pode ser conceituado como: “uma sub-rotina de um programa que pode ser
executada de forma assíncrona, ou seja, executada paralelamente ao programa chamador” (MACHADO e
MAIA, 2002).
Um programa pode ser implementado num ambiente monothread, cujo processo suporta apenas um
thread para executar as funções do aplicativo. Nesse modo, o desenvolvimento de aplicações concorrentes
continua centrado nos processos, o que ocasiona um custo excessivo dos recursos do sistema.
Uma forma mais útil de implementar aplicações concorrentes sem abusar dos recursos do computador é
em um ambiente multithread, cujo processo compartilha os recursos do sistema com inúmeros threads de
execução.
Uma vez que o ambiente multithread oferece essa vantagem de compartilhamento dos
recursos computacionais, vamos implementar as aplicações cliente-servidor com conexões threads
utilizando o ambiente multithread.
_________________________________________________________________________________________________
PROGRAMAÇÃO E DESENVOLVIMENTO DE APLICAÇÕES COM THREADS ‐ UNIDADE II 2 15
___________________________________________________________________________________________________________________________________________________________________________________________________

Impressão de relatórios, cálculos matemáticos, exibição de interfaces gráficas e acesso a

recursos de rede são algumas das tarefas que pode ser realizadas de forma concorrente em
aplicações multithread.
No próximo tópico, iremos estudar como a linguagem JAVA trabalha com a programação
multithread.
Quais os problemas de aplicações concorrentes desenvolvidas em

ambientes monothread?
TÓPICO 2 – PROGRAMAÇÃO MULTITHREAD EM JAVA

A linguagem JAVA foi escolhida para implementarmos aplicações multithread por causa da sua
portabilidade e por já ter nativo o conceito multithreading, ou seja, delegar o controle de sub-rotinas do
programa para threads que funcionam de forma paralela.
Criando meu primeiro programa multithreading

1. public class Principal {
2. public static void main(String[] args) {
3. new PingPong("ping",33).start(); //tempo de pausa = 33ms
4. new PingPong("PONG",100).start(); //tempo de pausa = 100ms
5. }
6. }
7.
8. public class PingPong extends Thread {
9. private String palavra; //qual palavra imprimir
10. private int delay; // quanto tempo pausar
11.
12. public PingPong (String s, int t) {
13. palavra = s;
14. delay = t;
15. }
_________________________________________________________________________________________________
___________________________________________________________________________________________________________________________________________________________________________________________________

16.
17. public void run() {
18. try {
19. for (int i=0;i<=100;i++) {
20. System.out.print(palavra + " ");
21. Thread.sleep(delay);
22. }
23. } catch (InterruptedException e) {
24. return;
25. }
26. }
27. }
Exemplo 1 – Programa ping pong
No Exemplo 1, utilizamos duas threads para imprimir as palavras “ping” e “PONG” em diferentes
ordens. Para desenvolver essa aplicação criamos duas classes: a primeira fica responsável por criar e iniciar a
thread (Principal.java) e na outra definimos o comportamento a ser desempenhado pela thread
(PingPong.java).
Entre as linhas 1 e 6 é definida a classe Principal. No único método escrito nessa classe é iniciada
automaticamente a primeira thread, que é a thread main. Na linha 3 e 4 são criadas duas threads da classe
PingPong que são inicializadas com a palavra “ping” e “PONG”, respectivamente. Além disso, são
atribuídos tempos de pausa de 33 milisegundos para a primeira thread e 100 milisegundos para a segunda. A
seguir, os dois objetos invocam o método start() para iniciar a execução da thread.
Entre as linhas 8 e 27 é definida a classe PingPong. Como serão geradas threads a partir de
PingPong, é feita uma herança direta entre essa classe e a classe Thread.
Assim como a thread main inicia num método, as threads criadas na classe Principal serão
inicializadas pelo método run() presente em todas as subclasses da classe Thread.
Normalmente, precisamos sobrescrever o método run() de acordo com as tarefas que queremos que a
thread desempenhe. No Exemplo 1 (linhas 17-25), quando a thread invoca o método run(). Ela entra numa
repetição onde imprime a palavra armazenada na instanciação (“ping” ou “PONG”) e coloca a thread em
estado de latência por um determinado tempo definido também no momento da criação.
Visto como implementar nosso primeiro programa multithreading, existe alguma dúvida?
_________________________________________________________________________________________________
___________________________________________________________________________________________________________________________________________________________________________________________________

Para respondermos a essa pergunta, vamos observar os

estados assumidos por uma thread em JAVA na Figura 1. A
Quais são os
principais partir disso, afirmamos que os principais métodos são:
métodos definidos
run(): é o método que executa as atividades
pela Classe
Thread? de uma thread. Quando este método finaliza, a
thread também termina.
start(): método que dispara a execução de
uma thread. Este método chama o método
run( ) antes de terminar.
sleep(int x): método que coloca a thread
para dormir por x milisegundos.
join( ): método que espera o término da thread para qual foi enviada a mensagem para
ser liberada.
interrupt( ): método que interrompe a execução de uma thread.
interrupted( ): método que testa se uma thread está ou não interrompida.
Figura 1 – Estados de uma thread em JAVA.
Na próxima seção, vamos ver como fazer um aplicação concorrente sem obrigatoriamente ter que herdar
todos os métodos.
_________________________________________________________________________________________________
___________________________________________________________________________________________________________________________________________________________________________________________________

Como resolver esse

problema da
extensão da classe
Usando a interface Runnable
Thread?
Quando estendemos a classe Thread para uma outra
classe, passamos juntos todos os métodos e interfaces
pertencentes à classe estendida, o que para nós é desnecessário,
pois a nova classe precisa herdar apenas o método run() para
torná-la executável. Além disso, ficamos impedidos de estender
qualquer outra classe devido a extensão de classes ser feita por
herança simples.
Uma solução para esse problema é utilizar a interface Runnable que permite executar o método
run() dentro do objeto thread. Vamos ver a seguir o nosso primeiro exemplo modificado para utilizar a
interface Runnable. O código-fonte é apresentado no Exemplo 2.
1. public class Main {
3. Runnable ping = new PingPong("ping",33);
4. Runnable pong = new PingPong("PONG",100);
5. new Thread(ping).start();
6. new Thread(pong).start();
7. }
8. }
9.
10. public class PingPong implements Runnable {
11. private String palavra;
12. private int delay;
13. PingPong(String s, int t){
14. palavra = s;
15. delay = t;
16. }
_________________________________________________________________________________________________
___________________________________________________________________________________________________________________________________________________________________________________________________

17. public void run(){
18. try{
19. for (int i=0;i<=100;i++) {
20. System.out.print(palavra + " ");
21. Thread.sleep(delay);
22. }
23. } catch (InterruptedException e) {
24. return;
25. }
26. }
27. }
Exemplo 2 – Ping Pong usando a interface Runnable.
As mudanças do Exemplo 2, quando comparado com o Exemplo 1, concentram-se principalmente na

classe Main, pois criamos dois objetos Runnable (ping e pong) com diferentes temporizações. Depois, os
passamos como parâmetros dos dois novos objetos thread que foram gerados e iniciados imediatamente.
Uma outra modificação ocorreu ao definir a classe PingPong, uma vez que ao invés de estendermos a
classe, implementamos a interface Runnable.
Agora que vimos para utilizar conexões threads em uma aplicação, podemos estender a classe Thread
ou implementar a interface Runnable. Vamos, a seguir, apresentar uma aplicação cliente-servidor que faz
uso desta técnica.
Construindo uma aplicação cliente-servidor com conexões threads

O Exemplo 3 mostra um servidor Web que trata de requisições de um aplicativo cliente. Aqui entra um
ponto importante de muitas implementações práticas de threads. Em diversas ocasiões, é necessário que uma
thread fique constantemente realizando determinada tarefa. No exemplo 3, o servidor Web fica
constantemente aguardando a requisição de abertura de conexão. Quando uma requisição deste tipo ocorre,
uma conexão é estabelecida e um novo procedimento de espera por requisições de novas conexões deve ser
adotado.
_________________________________________________________________________________________________
___________________________________________________________________________________________________________________________________________________________________________________________________

1. import java.net.*;
3. public static void main(String[] args)throws Exception {
4. ServerSocket server = new ServerSocket(6791);
5. while (true)
6. {
7. Socket connection = server.accept();
8. //Construir um objeto para processar a mensagem de requisição HTTP.
9. HTTPrequest request = new HTTPrequest(connection);
10. // Criar um novo thread para processar a requisição.
11. Thread thread = new Thread(request);
12. //Iniciar o thread.
13. thread.start();
14. }
15. }
16. }
Exemplo 3 – Servidor Web
Nesse código é interessante observamos o trecho entre as linhas 9 e 13. Acontece, exatamente como já
vimos no Exemplo2. Cria-se um objeto request que implementa Runnable através da classe
HTTPrequest, passa-o como parâmetro na criação da thread e depois a inicia. Sendo assim, fazemos uso de
interface Runnable. Além disso, observa-se na linha 7 que o servidor fica indefinidamente esperando
requisições para associá-las às threads de execução.
Então, não existe Não vamos detalhar a classe HTTPrequest, pois

nenhum cuidado
especial ao programar existem muitos elementos de programação em sockets e
aplicações isso será abordado na próxima unidade. O fundamental é
multithreading? a compreensão do uso de multithreading dentro de uma
aplicação de servidor Web.
Com certeza, existe. O problema da programação

multithreading reside no compartilhamento das áreas de
dados pelos threads em execução, pois se não há um
_________________________________________________________________________________________________
___________________________________________________________________________________________________________________________________________________________________________________________________

devido tratamento, podem ocorrer problemas de inconsistência e ineficiência da informação apresentada.
Uma forma de resolver isso é prover sincronização entre threads. O que iremos abordar no próximo
tópico.
Qual é a diferença entre criar uma aplicação multithreading através da

extensão da classe Thread e por meio da interface Runnable?
TÓPICO 3 – SINCRONIZAÇÃO ENTRE THREADS

Para entendermos melhor como a falta de sincronismo causa inconsistência no recurso compartilhado
por threads, vamos ver nos Exemplos 4.a, 4.b, 4.c e 4.d , o clássico problema do produtor consumidor, no qual
eles executam as operações de produzir e consumir sobre uma mesma área compartilhada chamada
repositório.
3. Repositorio area = new Repositorio();
4. Produtor p = new Produtor(area);
5. Consumidor c = new Consumidor(area);
6. new Thread(p).start();
7. new Thread(c).start();
8. }
9. }
Exemplo 4.a – Classe Main
1. public class Repositorio {
2. private int dados;
3. public Repositorio() {
4. dados = 0;
5. }
6. public void escreverDados(int d) {
7. dados = d;
8. System.out.println("A área de dados recebeu o valor "+d);
_________________________________________________________________________________________________
___________________________________________________________________________________________________________________________________________________________________________________________________

9. }
10. public int lerDados() {
11. System.out.println("O valor "+dados+" foi lido da área de dados");
12. return dados;
13. }
14. }
Exemplo 4.b – Classe Repositório
1. public class Produtor implements Runnable {
2. private Repositorio area;
3. public Produtor(Repositorio a) {
4. area = a;
5. }
7. int dados =1;
8. while (dados<=10) {
9. try{
10. Thread.sleep((int)(Math.random()*4000));
11. }catch (Exception e) {
12. System.err.println("Exceção encontrada: "+e.getMessage());
13. }
14. area.escreverDados(dados);
15. dados++;
16. }
17. }
18. }
Exemplo 4.c – Classe Produtor
1. public class Consumidor implements Runnable{
2. private int cont = 0;
3. private int soma = 0;
4. private Repositorio area;
_________________________________________________________________________________________________
___________________________________________________________________________________________________________________________________________________________________________________________________

5. public Consumidor(Repositorio a) {
6. area = a;
7. }
9. do{
10. try{
11. Thread.sleep((int)(Math.random()*4000));
12. }catch (Exception e) {
13. System.err.println("Exceção encontrada: "+e.getMessage());
14. }
15. cont = area.lerDados();
16. soma = soma+cont;
17. } while (cont!=10);
18. System.out.println("A soma dos valores lidos pelo consumidor foi "+soma);
19. }
20. }
Exemplo 4.d – Classe Consumidor
Um objeto da classe Repositório, definida no Exemplo 4.b, será compartilhado por duas threads,
uma da classe Produtor e outra da classe Consumidor. O inteiro produzido pela thread da classe
Produtor será armazenado na variável dados da classe Repositório. O conteúdo dessa variável será lido
pela thread da classe Consumidor.
_________________________________________________________________________________________________
___________________________________________________________________________________________________________________________________________________________________________________________________

A operação padrão das duas threads é “dormir” por um tempo aleatório e inserir ou ler o
conteúdo da variável dados, dependendo se a thread é produtora ou consumidora no contexto do
programa

Figura 2 – Execução do problema do produtor-consumidor.
Para testar o programa executei-o três vezes e obtive valores diferentes na soma dos valores lidos pela
thread consumidora em todas as vezes, como mostra a Figura 2. Isso ocorreu ou porque a thread consumidora
foi mais rápida que a thread produtora e acabou lendo valores repetidos, ou porque a thread produtora foi
mais rápida e valores inseridos no repositório não foram lidos pela thread consumidora.
A situação apresentada a seguir é conhecida como condição de corrida, ou seja, o resultado da soma é
dependente da ordem em que as threads são executadas. Para evitar este problema, deve ser utilizado um
mecanismo que não permita a mais de uma thread acessar um recurso compartilhado.
No JAVA, a forma de bloquear o acesso ao recurso compartilhado quando uma thread o estiver
utilizando é por meio dos métodos definidos como synchronized. Se uma thread invoca um método
synchronized sobre um objeto, primeiro é adquirido o bloqueio desse objeto, o corpo do método é
executado e só após o bloqueio é liberado. Uma outra thread invocando um método synchronized sobre o
mesmo objeto ficará bloqueada até que o bloqueio seja liberado.
Vejamos o Exemplo 5 que trata do mesmo problema do produto-consumidor, mas agora aplicando
_________________________________________________________________________________________________
___________________________________________________________________________________________________________________________________________________________________________________________________

sincronização entre threads.

1. public class Repositorio {
2. private int dados;
3. boolean escrever;
4. public Repositorio() {
5. dados = 0;
6. escrever = true;
7. }
8. public synchronized void escreverDados(int d) {
9. while (escrever==false) {
10. try{
11. wait();
12. }
13. catch (InterruptedException e){
14. e.printStackTrace();
15. }
16. }
17. dados = d;
18. System.out.println("A área de dados recebeu o valor "+d);
19. escrever = false;
20. notify();
21. }
22. public synchronized int lerDados() {
23. while (escrever) {
24. try {
25. wait();
26. }
_________________________________________________________________________________________________
___________________________________________________________________________________________________________________________________________________________________________________________________

27. catch (InterruptedException e) {
29. }
30. }
31. notifyAll();
32. System.out.println("O valor "+dados+" foi lido da área de dados");
33. escrever = true;
34. return dados;
35. }
36. }
Exemplo 5 – Classe repositório com métodos sincronizados.
Como podem perceber, o Exemplo 5 redefiniu apenas a classe Repositório e manteve as outras classes
do projeto Produtor-consumidor, mostrado no Exemplo 4. Isso ocorreu devido aos métodos que precisavam
ser sincronizados estarem localizados na classe Repositório.

_________________________________________________________________________________________________
___________________________________________________________________________________________________________________________________________________________________________________________________

Figura 3 – Execução do problema produtor-consumidor com sincronismo entre as threads.
A variável escrever criada e inicializada com true funciona como o protocolo de acesso à região
crítica, Toda vez que um thread deseja utilizar o recurso compartilhado, obrigatoriamente deve executar um
protocolo de entrada nela. Da mesma forma, ao sair da região crítica, um protocolo de saída deve ser ativado.
Dessa forma, garantimos que não haverá inconsistência entre os valores apresentados pela variável
compartilhada, como pode ser observado na Figura 3.
A influência da variável escrever na sincronização das threads é fazer com que o método
lerDados() somente seja executado se houver algo escrito na variável dados. Caso contrário, a thread
que invocou o método de leitura é colocada em estado de espera pelo método wait(). Quando o dado é
escrito na variável, o método notify() é invocado e muda o estado da thread leitora para pronto. Da
mesma forma, quando uma thread leitora tiver o acesso da variável dados bloqueará todas as outras threads.
Ao terminar a leitura, ela desbloqueia as threads através do método notifyAll().
No próximo tópico apresentaremos os utilitários de concorrência (java.util.concurrent)

oferecidos pela linguagem JAVA para aprimorar a programação multihreading, automatizando várias tarefas
vistas anteriormente.
Porque os métodos chamados pelas threads num aplicativo devem ser

sincronizados?
TÓPICO 4 – UTILITÁRIOS DE CONCORRÊNCIA

Nos tópicos anteriores, vimos como montar uma aplicação multihreading utilizando extensão da classe
Thread ou implementando a interface Runnable com e sem sincronismo. Agora, vamos estudar como
aplicar os utilitários de concorrência existentes no pacote java.util.concurrent para automatizar
algumas tarefas executadas numa aplicação multithreading, principalmente a sincronização entre as threads.
O estudo de caso, mostrado no Exemplo 5, apresenta o uso de utilitários de concorrência (Lock e

Condition) que fornecem serviços de bloqueio e de aguardo para modificar o conteúdo exibido em uma
interface gráfica Swing.
Antes de iniciarmos a explicação do exemplo, vamos mostrar as funcionalidades dos utilitários de

concorrência utilizados nele.
A interface Lock flexibiliza a funcionalidade de bloqueio ao permitir que possa mudar de estado
bloqueado/desbloqueado entre métodos, o que não é possível fazer em blocos ou métodos sincronizados.
Enquanto, a interface Condition contém os métodos await(), signal() e signalAll() que
possuem a mesma operação dos métodos wait(), notify() e notifyAll() da classe Thread. Mas,
com a vantagem de associar quantos objetos Condition quiser a um mesmo Lock. Ao contrário da classe
_________________________________________________________________________________________________
___________________________________________________________________________________________________________________________________________________________________________________________________

Thread, onde existe uma condição relacionada com cada objeto de bloqueio.
1. import java.util.Random;
2. import java.util.concurrent.locks.Condition;
3. import java.util.concurrent.locks.Lock;
4. import javax.swing.JLabel;
5. import javax.swing.SwingUtilities;
6. import java.awt.Color;
7. public class ObjetoExecutavel implements Runnable{
8. private static Random gerador = new Random(); //para letras aleatórias
9. private Lock objetobloqueado; //bloqueio de aplicativo; passado para o construtor
10. private Condition suspender; //utilizado para suspender e retomar a thread
11. private boolean suspenso = false; // true se a thread for suspensa
12. private JLabel saída; //JLabel para a saída
13. // Construtor da classe
14. public ObjetoExecutavel(Lock bloq,JLabel s) {
15. objetobloqueado = bloq; //armazena o objeto bloqueado para o aplicativo
16. suspender = objetobloqueado.newCondition(); //Cria uma nova condição
17. saída = s; //armazena o objeto s para gerar a saída de caractere
18. }
19. //Coloca os caracteres aleatorios na GUI
20. public void run() {
21. final String nomedathread = Thread.currentThread().getName();
22. while (true) {
23. try {
24. Thread.sleep(gerador.nextInt(1000));
25. objetobloqueado.lock(); //obtem o bloqueio
26. try {
_________________________________________________________________________________________________
___________________________________________________________________________________________________________________________________________________________________________________________________

27. while (suspenso) {
28. suspender.await();
29. }
30. }
31. finally {
32. objetobloqueado.unlock();
33. }
34. }
35. catch (InterruptedException e) {
37. }
38. SwingUtilities.invokeLater(
39. new Runnable() {
41. char caractermostrado = (char) (gerador.nextInt(26)+65);
42. saída.setText(nomedathread + ": " + caractermostrado);
43. }
44. }
45. );
46. }
47. }
48. public void mudardeEstado() {
49. suspenso = !suspenso;
50. saída.setBackground(suspenso ? Color.RED : Color.GREEN);
51. objetobloqueado.lock();
52. try {
53. if (!suspenso) {
_________________________________________________________________________________________________
___________________________________________________________________________________________________________________________________________________________________________________________________

54. suspender.signal();
55. }
56. }
57. finally {
58. objetobloqueado.unlock();
59. }
60. }
61. }// Fim da classe ObjetoExecutavel
62. import java.awt.Color;
63. import java.awt.GridLayout;
64. import java.awt.event.ActionEvent;
65. import java.awt.event.ActionListener;
66. import java.util.concurrent.Executors;
67. import java.util.concurrent.ExecutorService;
68. import java.util.concurrent.locks.Condition;
69. import java.util.concurrent.locks.Lock;
70. import java.util.concurrent.locks.ReentrantLock;
71. import javax.swing.JCheckBox;
72. import javax.swing.JFrame;
73. import javax.swing.JLabel;
74. public class Main extends JFrame implements ActionListener{
75. private final static int DIMENSÃO = 3; // número de threads;
76. private JCheckBox componentes[];
77. private Lock objetobloqueado = new ReentrantLock(true);
78. private ObjetoExecutavel[] caracteresrandomicos = new ObjetoExecutavel[DIMENSÃO];
79. public Main() {
80. componentes = new JCheckBox[DIMENSÃO];
_________________________________________________________________________________________________
___________________________________________________________________________________________________________________________________________________________________________________________________

81. setLayout(new GridLayout(DIMENSÃO,2,5,5));
82. ExecutorService executor = Executors.newFixedThreadPool(DIMENSÃO);
83. for (int cont=0; cont< DIMENSÃO;cont++) {
84. JLabel saídaJLabel = new JLabel();
85. saídaJLabel.setBackground(Color.GREEN);
86. saídaJLabel.setOpaque(true);
87. add(saídaJLabel);
88. componentes[cont] = new JCheckBox("Suspenso");
89. componentes[cont].addActionListener(this);
90. add(componentes[cont]);
91. caracteresrandomicos[cont] = new ObjetoExecutavel(objetobloqueado,saídaJLabel) ;
92. executor.execute(caracteresrandomicos[cont]);
93. }
94. setSize(275,90);
95. setVisible(true);
96. executor.shutdown();
97. }
98. public void actionPerformed(ActionEvent evento) {
99. for (int cont=0; cont<componentes.length; cont++) {
100. if (evento.getSource()==componentes[cont]) {
101. caracteresrandomicos[cont].mudardeEstado();
102. }
103. }
104. }
106. Main aplicação = new Main();
107. aplicação.setDefaultCloseOperation(EXIT_ON_CLOSE);
_________________________________________________________________________________________________
___________________________________________________________________________________________________________________________________________________________________________________________________

108. }
109. }Fim da classe Main
Exemplo 5 – Aplicação multithreadcomgui.
A execução do Exemplo 5, apresentado na Figura 4, gera uma letra aleatória (linha 8), associa-o a uma
thread de execução (linha 21) e apresenta o nome dessa thread junto com a letra gerada numa caixa de
checagem (linhas 38-45).
Se o usuário selecionar a opção suspenso na thread associada à letra (linhas 48-60). O objeto invoca na
linha 28 o método await() para suspender a execução da thread e modifica a sua cor de fundo para
vermelho. Da mesma forma quando você retirar a seleção de suspenso (linha 54), o objeto suspender
retoma a execução da thread por meio do método signal() e, a seguir, a cor de fundo com o nome da
thread em execução é alterado para verde.
Figura 4 – Execução do programa multithreadcomgui.
Por fim, a classe Main cria um JFrame com três objetos caracteresrandomicos da classe
ObjetoExecutavel e três JCheckBoxes para permitir ao usuário suspender e retornar as threads.
Com isso encerramos a unidade II. Na próxima unidade trataremos como criar aplicações cliente-
servidor com conexões via rede ou sockets. Até lá e não esqueçam de fazer os exercícios de fixação.
Preencha as lacunas em cada uma das seguintes afirmações:
a) Para pausar por um número designado de milissegundos e retomar

a execução, uma thread deve chamar o método ____________.
b) O método _____________ da classe Condition move uma única
thread no estado de espera de um objeto para o estado executável.
c) O método _____________ da classe Condition move toda thread
no estado de espera de um objeto para o estado executável.
d) Uma thread pode chamar o método _________ em um objeto
Condition para liberar o Lock associado e colocar essa thread no
estado _______.
_________________________________________________________________________________________________
___________________________________________________________________________________________________________________________________________________________________________________________________

ARNOLD, K.; GOSLING, J.; HOLMES, D. A linguagem de programação JAVATM. 4. ed. Porto Alegre:
Bookman, 2007.
COSTA, D. G. JAVATM em rede: programação distribuída na Internet. Rio de Janeiro: Brasport, 2008.
DEITEL, H. M.; DEITEL, P. J. JAVATM como programar. 6. ed. São Paulo: Pearson Prentice Hall, 2005.
(Professor, as referências bibliográficas são sempre em ordem alfabética.).

deixados ao longo da unidade, representados pelo ícone
Quais os problemas de aplicações concorrentes desenvolvidas em ambientes monothread?
Ausência de compartilhamento de recursos, prejudica a multiprogramação e o uso excessivo dos

recursos computacionais.
Uma vez que, ambientes monothread têm seu funcionamento focado no processo e uma aplicação
concorrente dispara várias operações paralelamente. Quando uma operação associada a um processo obtém o
recurso do processador, impede todos os outros processos de acessá-lo, mesmo quando não está utilizando.
Essa falta de compartilhamento de recursos causa um gasto desnecessário do processador. Além de prejudicar
a multiprogramação.
Qual é a diferença entre criar uma aplicação multithreading através da extensão da classe
Thread e por meio da interface Runnable?
Quando criamos uma classe extensão de Thread, estendemos todos os seus métodos para a nova
classe. Por conseqüência, mesmo utilizando apenas o método run() todos os outros métodos são carregados
na aplicação. Enquanto a interface Runnable implementa somente o método run(), fazendo com que a
aplicação seja mais leve.
Porque os métodos chamados pelas threads num aplicativo devem ser sincronizados?
Para evitar problemas de inconsistência de dados no recurso compartilhado. O uso da sincronização

torna-se essencial, pois se não implementamos o conceito de exclusão mútua no recurso compartilhado as
_________________________________________________________________________________________________
___________________________________________________________________________________________________________________________________________________________________________________________________

threads podem alterar as informações de forma ineficiente causando uma inconsistência nos dados
apresentados para o usuário.
Preencha as lacunas em cada uma das seguintes afirmações:
a) Para pausar por um número designado de milissegundos e retomar a execução, uma

thread deve chamar o método _sleep(int milissegundos)_.
b) O método _signal()_ da classe Condition move uma única thread no estado de
espera de um objeto para o estado executável.
c) O método _signalAll()_ da classe Condition move toda thread no estado de espera
de um objeto para o estado executável.
d) Uma thread pode chamar o método _await()_ em um objeto Condition para liberar o
Lock associado e colocar essa thread no estado _de espera_.
O método sleep() coloca a thread que está executando atualmente em hibernação por n
milissegundos. Enquanto, o método signal() ativa uma determinada thread que estava em
condição de espera. Já, signalAll() ativa todas as threads que estão em condição de espera.
Por último, o método await() coloca um thread em condição de espera.
Exercícios de Aplicação
1. A partir do programa abaixo, faça as seguintes operações:

Programa 1 (Deposito.java)
public class Deposito {
private int items=0;
private final int capacidade=10;
public int retirar() {
if (items>0) {
items--;
System.out.println("Caixa retirada: Sobram "+items+" caixas");
return 1; }
return 0;
public int colocar () {
if (items<capacidade) {
items++;
System.out.println("Caixa armazenada: Passaram a ser "+items+"
_________________________________________________________________________________________________
___________________________________________________________________________________________________________________________________________________________________________________________________

caixas");
return 1; }
return 0;
public static void main(String[] args) {
Deposito dep = new Deposito();
Produtor p = new Produtor(d, 2);
Consumidor c = new Consumidor(d, 1);
//arrancar o produtor
//...
//arrancar o consumidor
//...
System.out.println("Execucao do main da classe Deposito terminada");
a) Crie uma classe Deposito com as mesmas instruções contidas no código-fonte acima.
b) Crie uma classe Produtor que funcione como uma thread independente e que vai
invocando o método colocar da classe depósito de forma a acrescentar caixas ao
depósito. A classe Produtor deve receber no construtor uma referência para o objeto dep
onde os métodos vão ser invocados e um inteiro correspondente ao tempo em segundos
entre produções de caixas. Defina a classe Produtor como sendo uma classe que
implementa a interface Runnable.
c) Crie uma classe Consumidor que funcione como uma thread independente e que vai
invocando o método retirar da classe depósito de forma a retirar caixas do depósito. A
classe Consumidor deve receber no construtor uma referência para o objeto dep onde os
métodos vão ser invocados e um inteiro correspondente ao tempo em segundos entre
consumos de caixas. Defina a classe Consumidor como sendo uma extensão da classe
Thread.
d) Indique que motivos poderão levar a que se opte por realizar uma thread através da
implementação da interface Runnable ou como extensão de Thread.
e) Execute o projeto e experimente algumas variantes, como por exemplo:
− Adicione à classe consumidor mensagens que permitam identificar o que cada
objeto Consumidor está fazendo em cada momento, e em particular se está
bloqueado à espera que existam caixas.
_________________________________________________________________________________________________
___________________________________________________________________________________________________________________________________________________________________________________________________

− Altere o número de consumidores ou de produtores e os tempos médios entre

produções e consumos.
2. Escreva um programa que imprima o tempo decorrido cada segundo após o início da execução,
com outra thread que imprime uma mensagem a cada quinze segundos. Faça a thread de
impressão de mensagens ser notificada pela thread de impressão de tempo à medida que cada
mensagem é passada. Adicione outra thread que imprime uma mensagem diferente a cada
sete segundos, sem modificar a thread de impressão de tempo.
_________________________________________________________________________________________________
___________________________________________________________________________________________________________________________________________________________________________________________________

UNIDADE III
Sockets
A comunicação de aplicações cliente-servidor utilizando socket é o foco desta unidade, cujos princípios
de funcionamento abordaremos inicialmente. A seguir, veremos dois protocolos de transporte que são
responsáveis pela comunicação na Internet, o TCP (Transmission Control Protocol) e o UDP (User Datagram
Protocol), veremos suas implementações em Java, e as características de cada um.
TÓPICO 1 – SOCKETS
Nas comunicações na Internet que seguem o modelo
O que é um cliente/servidor há sempre dois computadores (hosts) envolvidos,
Socket?
sendo que o servidor fica esperando por uma solicitação de
comunicação de um cliente. Então, para que possa haver essa
comunicação entre hosts é necessário que haja uma conexão de
socket.
Segundo (Sierra e Bates, 2007), “Um socket é um objeto que

representa uma conexão de rede entre duas máquinas”. Mas, aí surge
a seguinte dúvida: o que é uma conexão? É um relacionamento entre
duas máquinas, no qual dois sistemas sabem da existência um do outro. O mais importante é que esses dois
sistemas sabem como se comunicar entre si, ou seja, sabem como enviar bits um para o outro. Não importa se
a infra-estrutura de comunicação é formada por redes sem fio ou cabeada, a abstração criada pelos sockets
garante que um cliente conseguirá enviar bits para um servidor, os detalhes da operação dos protocolos de
transporte não precisam ser conhecidos, mas apenas as funções de enviar e receber dados pela rede.
A Figura 1 apresenta a criação de uma conexão de socket em JAVA, na qual é preciso saber duas coisas
sobre o servidor: quem é ele e em que porta está sendo executado, em outras palavras, o endereço IP e o
número da porta TCP.
Socket clienteSocket = new Socket(“139.82.17.10”, 22);
Servidor Cliente
Figura 1 – Criação de uma conexão de socket
_________________________________________________________________________________________________
PROGRAMAÇÃO E DESENVOLVIMENTO DE APLICAÇÕES COM SOCKETS ‐ UNIDADE III 2 38
___________________________________________________________________________________________________________________________________________________________________________________________________

No próximo tópico iremos estudar o protocolo TCP, seus serviços e o seu modo de funcionamento.
O que é um socket e qual o papel dele numa aplicação cliente-servidor?
TÓPICO 2 – PROTOCOLO TCP (TRANSMISSION CONTROL PROTOCOL)

Se uma aplicação deseja utilizar os recursos de comunicação da Internet é necessário que esta utilize os
serviços de um protocolo de transporte.
No protocolo IP (Internet Protocol) os datagramas, que são unidade de dados da camada de rede, são
processados por cada roteador no caminho da origem ao destino. Devido ao fato do protocolo IP não ser
orientado à conexão e nem ter controle de erros e de fluxo, a confiabilidade na entrega dos dados não é
garantida. Explicando de maneira resumida, um protocolo que possui controle de erros permite que sempre
que um pacote seja perdido, o mesmo seja retransmitido, ou evitar que um pacote que já foi enviado e
recebido seja retransmitido, evitando assim a duplicação de pacotes. O controle de fluxos evita que um
transmissor muito rápido sobrecarregue um receptor muito lento. Para usufruir desses serviços é necessário
utilizar o protocolo TCP, pois ele oferece um nível de confiabilidade e controle não existente na camada de
rede da Internet.
Para se estabelecer uma comunicação entre dois hosts utilizando o protocolo TCP vejamos a Figura 2,
onde o bit SYN enviado pelo cliente para o servidor significa a sincronização inicial da conexão, ou seja,
funciona como uma solicitação de conexão. O servidor devolve um bit ACK de confirmação e um bit SYN
que indica que o servidor também quer manter uma conexão com o cliente. E por último, o cliente devolve um
bit ACK de confirmação. A esse processo é dado o nome de Three Way Handshake.
Figura 2 – O processo de conexão do protocolo TCP numa aplicação cliente-servidor.
_________________________________________________________________________________________________
___________________________________________________________________________________________________________________________________________________________________________________________________

A seguir, no Tópico 3, trataremos sobre o desenvolvimento de aplicações cliente-servidor com conexões

de socket de fluxo, ou seja, que utilizam o protocolo TCP para realizar a interação cliente-servidor.
Comente sobre as características mais marcantes do protocolo TCP.
TÓPICO 3 – DESENVOLVIMENTO DE APLICAÇÕES CLIENTE-SERVIDOR COM

CONEXÕES DE SOCKETS TCP EM JAVA
Java oferece suporte à programação em rede através de sockets por meio de classes contidas no pacote
java.net. Adicionalmente, é necessário utilizar classes do pacote java.io. O envio e recebimento de
dados por meio de sockets nada mais são do que operações de entrada e saída.
Os principais métodos empregados no

desenvolvimento de aplicações cliente-servidor com
Quais são os
principais métodos conexões de sockets TCP em JAVA são:
definidos para Socket(): é um método construtor que cria
sockets TCP em
um socket de fluxo e conecta-o a um endereço
JAVA?
IP e a um número de porta especificado.
getInputStream(): obtém um fluxo de
entrada originado do servidor através do
socket.
getOuputStream(): obtém um fluxo de
saída que será enviado para o servidor a partir
do socket.
close() : Fecha o socket e encerra o canal de comunicação com o servidor.
Todos os métodos apresentados anteriormente estão contidos no pacote java.net. Contudo, existem
métodos pertencente ao pacote java.io que precisamos apresentar por serem responsáveis pelo envio e
recebimento dos dados pela porta do aplicativo. Entre eles, podemos citar:
DataOutputStream(): é um método construtor que cria um canal de comunicação, no
sentido cliente-servidor, entre o aplicativo e a porta na camada de transporte para enviar
dados.
DataInputStream() : é um método construtor que tem função semelhante ao
DataOutputStream, mas o fluxo de dados corre no sentido contrário, ou seja, servidor-
cliente.
writeBytes() : Envia o fluxo de dados no canal de comunicação através da porta para o
servidor.
_________________________________________________________________________________________________
___________________________________________________________________________________________________________________________________________________________________________________________________

Criando minha primeira aplicação cliente-servidor utilizando o

protocolo TCP
Vamos usar a seguinte aplicação cliente-servidor para demonstrar uma programação de portas para o
TCP:
O cliente lê uma linha a partir de sua entrada-padrão (teclado) e a envia através de sua
porta para o servidor.
O servidor lê a linha a partir de sua porta de conexão.
O servidor converte a linha para letras maiúsculas.
O servidor envia a linha modificada, através de sua porta-padrão, ao cliente.
O cliente lê a linha modificada através de sua porta e apresenta a linha para sua saída-
padrão (monitor).
No Exemplo 1.a apresentamos a codificação do lado cliente da aplicação:

1. import java.io.*; // classes para entrada e saída de dados
2. import java.net.*; // classes para socket, servidorsocket e clientesocket
3.
4. class ClienteTCP {
5. public static void main(String argv[]) throws Exception {
6. String sentenca;
7. String sentencaModificada;
8.
9. // cria o stream do teclado

10. BufferedReader cadeiaUsuario = new BufferedReader( new
11. InputStreamReader(System.in));
12.
13. // cria o socket de acesso ao server hostname na porta 6789
14. Socket clienteSocket = new Socket("hostname", 6789);
15.
16. // cria os streams (encadeamentos) de entrada e saida com o servidor

17. DataOutputStream clienteParaServidor =
18. new DataOutputStream(clienteSocket.getOutputStream());
19. BufferedReader cadeiaServidor =

20. new BufferedReader(new inputStreamReader(
21. clienteSocket.getInputStream()));
22.
_________________________________________________________________________________________________
___________________________________________________________________________________________________________________________________________________________________________________________________

23. // le uma linha do teclado e coloca em sentenca

24. sentenca = cadeiaUsuario.readLine();
25.
26. // envia a linha para o server
27. clienteParaServidor.writeBytes(sentenca + '\n');
28.
29. // lê uma linha do server
30. sentencaModificada = cadeiaServidor.readLine();
31.
32. // apresenta a linha do server no vídeo
33. System.out.println("Para o servidor " + sentencaModificada);
34.
35. // fecha o cliente
36. clienteSocket.close();
37. }
38. }
Exemplo 1.a – Classe ClienteTCP
Na classe ClienteTCP, nas linhas 6 e 7 declaramos objetos do tipo String, o primeiro objeto
sentença é a cadeia digitada pelo usuário e enviada ao servidor. O objeto sentencaModificada é a
cadeia obtida do servidor e enviada à saída-padrão do usuário. A seguir, as linhas 8 a 12 criam o objeto
cadeiaUsuario do tipo BufferedReader. A cadeia de entrada é inicializada com
System.in, que vincula a cadeia à entrada-padrão. O comando permite que o cliente leia
o texto do seu teclado. A próxima linha cria o objeto clienteSocket que ativa a conexão
TCP entre cliente e servidor. A cadeia deve ser substituída pelo nome do hospedeiro
(“ead.cefetmt.br”) ou pelo endereço IP (“192.168.10.3”).O número 6789 é o número da
porta. Você pode usar um número de porta diferente, mas precisa se certificar de que está
usando o mesmo número de porta do lado do servidor. Na sequência são gerados objetos de
cadeia que são anexados à porta. A cadeia clienteParaServidor fornece ao processo uma saída para a
porta. A cadeia cadeiaServidor fornece ao processo uma entrada para a porta.
Nas linhas 23 a 38 temos que a entrada digitada pelo usuário é repassada para dentro da cadeia
sentenca por meio do método readLine() da cadeiaUsuario. Logo após, envia a cadeia
sentenca para dentro do canal de comunicação clienteParaServidor. A sentença ampliada flui pela
_________________________________________________________________________________________________
___________________________________________________________________________________________________________________________________________________________________________________________________

porta do cliente para dentro do canal TCP. O cliente então espera para receber os caracteres do servidor.
Quando eles chegam ao servidor são modificados e transmitidos de volta para o cliente através de cadeia
cadeiaServidor. Ao receber a cadeia modificada de cadeiaServidor, o cliente a escreve na saída
padrão acrescida da expressão “Para o servidor”. Por fim, encerra o canal de comunicação TCP através do
método close().
No Exemplo 1.b codificamos o lado servidor da aplicação.

2. import java.net.*; // classes para socket, servidorocket e clientesocket
3.
4. class ServidorTCP {
6. String clienteSentenca;
7. String sentencaCapturada;
8.
9. // cria socket de comunicação com os clientes na porta 6789

10. ServerSocket bemVindoSocket = new ServerSocket(6789);
11.
12. // espera msg de algum cliente e trata

13. while(true) {
14.
15. // espera conexão de algum cliente

16. Socket conexaoSocket = bemVindoSocket.accept();
17. // cria streams de entrada e saida com o cliente que chegou
18. BufferedReader cadeiaCliente =
19. new BufferedReader(new InputStreamReader(
20. conexaoSocket.getInputStream()));
21. DataOutputStream servidorParaCliente = new
22. DataOutputStream(
23. conexaoSocket.getOutputStream());
24.
25. // lê uma linha do cliente
26. clienteSentenca = cadeiaCliente.readLine();
27.
28. // transforma a linha em maiúsculas

29. sentencaCapturada = clienteSentenca.toUpperCase() + '\n';
30. // envia a linha maiúscula para o cliente
31. servidorParaCliente.writeBytes(sentencaCapturada);
32. }
33. }
34. }
_________________________________________________________________________________________________
___________________________________________________________________________________________________________________________________________________________________________________________________

Exemplo 1.b – Classe ServidorTCP
Na classe ServidorTCP temos muitas semelhanças com a classe ClienteTCP. Então falaremos
apenas das diferenças.
A linha 10 é substancialmente diferente do que já vimos em ClienteTCP, pois cria o objeto

bemVindoSocket, que é uma porta que fica à espera de um cliente. O número 6789 identifica o processo
no servidor. A linha seguinte cria o canal de comunicação denominada conexaoSocket, quando algum
cliente bate à porta bemVindoSocket. O TCP então estabelece uma tubulação virtual direta entre
clienteSocket no cliente e conexaoSocket no servidor. O cliente e o servidor podem enviar e receber
bytes um para o outro pelo canal criado, e pelo fato do TCP ser orientado à conexão todos os bytes chegam na
ordem correta. Estabelecida a conexaoSocket, o servidor pode continuar na escuta por outros clientes que
vão requisitar a aplicação usando bemVindoSocket. O programa cria diversos objetos de cadeia, análogos
aos criados em clienteSocket. A seguir, na linha 29, é realizada a modificação da sentença enviada pelo
cliente de forma que todos os caracteres se tornem letras maiúsculas. Finalmente, envia a sentença modificada
para o cliente através do canal de comunicação servidorParaCliente.
No próximo tópico abordaremos sobre o protocolo de transporte UDP (User Datagram Protocol) e suas
características.
Suponha que você compile e rode o ClienteTCP antes de rodar o

ServidorTCP. O que acontece? Por quê?
TÓPICO 4 – PROTOCOLO UDP (USER DATAGRAM PROTOCOL)

Para a maior parte dos programas que envolvam comunicação em rede, o protocolo TCP será utilizado
para prover o serviço de comunicação no nível de transporte. Isto acontece devido à confiabilidade das
conexões TCP, que garante que os dados sejam entregues na ordem correta. O serviço UDP é naturalmente
menos utilizado para aplicações em rede, mas nem por isso é menos importante, por isso seu uso se faz
necessário em protocolos de aplicação que utilizam o UDP, como o SNMP (Simple Network Management
Protocol) e o DNS (Domain Name System) e aplicações de comunicação multimídia em tempo real.
O protocolo UDP é rápido e eficiente, sem qualquer tipo de controle de erro ou de fluxo. O objetivo
principal deste protocolo é fornecer o compartilhamento do canal entre diversas comunicações por meio do
conceito de porta.
Para realizar comunicações com o UDP, é necessário enviar um datagrama para um endereço IP e uma
porta. Esses datagramas são as unidades de transmissão do UDP, os datagramas UDP são iguais aos
datagramas IP, ou seja, sem conexão e não confiáveis. Após a aplicação, enviar um datagrama UDP para um
endereço IP e uma porta, se houver processos aguardando mensagens UDP naquela porta, o datagrama é
recebido e processado, como não há abertura de conexão, também não há encerramento de conexão.
_________________________________________________________________________________________________
___________________________________________________________________________________________________________________________________________________________________________________________________

Como os datagramas UDP não são numerados, eles são recebidos fora de ordem na estação destino. O
UDP é indicado para serviços de comunicação que operam de forma simples, não querendo arcar com
procedimentos de abertura de comunicação, como o serviço de tradução de nomes e endereços oferecidos pelo
DNS, e serviços que exijam apenas rapidez na entrega, como por exemplo, as aplicações usuárias de
tecnologia multicast IP, que é a entrega de um datagrama de uma origem para mais de um destino, e a
transmissão de vídeo pela internet (streaming), onde a perda de um pacote de dados não interromperá a
transmissão. Por outro lado, se os pacotes não chegarem ou demorarem a chegar, haverá congelamentos na
imagem, causando irritação no usuário. Na Figura 3 podemos entender o funcionamento do protocolo de
transporte UDP.
Maq 1 Maq 7 Maq2
[sender: Maq 1, Receiver: Maq 2, content: “Ola”]
Mensagem
Figura 3 – Troca de datagrama UDP entre duas máquinas.
A seguir, no Tópico 5 abordaremos o desenvolvimento de aplicações cliente-servidor sem conexão com

datagramas, ou seja, que utilizam o protocolo UDP para realizar a interação cliente-servidor..
Comente sobre as características mais marcantes do protocolo

UDP.

CONEXÕES DE SOCKETS UDP EM JAVA
Os sockets UDP funcionam de maneira diferente dos sockets TCP. Veremos que no socket UDP não há
apresentação inicial entre dois processos (abertura de conexão) e, portanto, não há necessidade da porta de
entrada, não há cadeias ligadas às portas, os hospedeiros remetentes criam pacotes anexando o endereço IP do
destinatário e o número de porta a cada conjunto de bytes que enviam e o processo destinatário deve
desmontar cada pacote recebido para obter os bytes de informação do pacote.
Os principais métodos empregados no desenvolvimento de aplicações cliente-servidor com conexões de

sockets UDP em JAVA são:
DatagramSocket(): é um método construtor que cria um socket de datagrama e ligá-o a
qualquer porta pertencente ao hospedeiro local (localhost).
_________________________________________________________________________________________________
___________________________________________________________________________________________________________________________________________________________________________________________________

getByName() : Dado o nome de uma máquina,

Quais são os
tal como: localhost. Ele retorna o endereço IP
principais métodos
gerado pelo sistema. definidos para
DatagramPacket(byte[] buf,int lengt sockets UDP em
JAVA?
h,InetAddress address,int port) : é
um método construtor empregado para realizar o
serviço de entrega de pacotes sem uma conexão.
Ele monta o datagrama com os dados a ser
enviados, o tamanho a ser utilizado, o endereço
IP e a porta do servidor que irá receber.
DatagramPacket(byte[] buf,int length) : também é um método construtor que
declara o formato do datagrama a ser recebido .
send() : envia o datagrama de pacotes para o socket que irá transmiti-lo para o servidor.
receive() : recebe o datagrama a partir do socket que obteve os pacotes do servidor.
close() : encerra o ponto de recebimento ou envio de pacotes, ou seja, fecha o socket.
Criando minha primeira aplicação cliente-servidor utilizando o protocolo

UDP
Vamos retornar mais uma vez nossa aplicação:
O servidor lê uma linha a partir de sua entrada-padrão (teclado) e a envia através de sua
porta para o servidor.
O servidor lê a linha a partir de sua porta.
O servidor converte a linha para letras maiúsculas.
O servidor envia a linha modificada através de sua porta ao cliente.
O cliente lê a linha modificada através de sua porta e apresenta a linha para sua saída
padrão (monitor).
No exemplo 2.a codificamos o lado cliente da aplicação:

3.
4. public class ClienteUDP {

6.
7. // cria o stream do teclado
8. BufferedReader cadeiaUsuario = new BufferedReader( new
9. InputStreamReader(System.in));
10.
_________________________________________________________________________________________________
___________________________________________________________________________________________________________________________________________________________________________________________________

11. // declara socket cliente
12. DatagramSocket clienteSocket = new DatagramSocket();
13.
14. // obtem endereço IP do servidor com o DNS
15. InetAddress enderecoIP = InetAddress.getByName("localhost");
16.
17. byte[] enviaDados = new byte[1024];
18. byte[] recebeDados = new byte[1024];
19.
20. // lê uma linha do teclado
21. String sentenca = cadeiaUsuario.readLine();
22. enviaDados = sentenca.getBytes();
23.
24. // cria pacote com o dado, o endereço do server e porta do servidor
25. DatagramPacket enviaPacote = new DatagramPacket(enviaDados,
26. enviaDados.length, enderecoIP, 9876);
27.
28. //envia o pacote
29. clienteSocket.send(enviaPacote);
30.
31. // declara o pacote a ser recebido
32. DatagramPacket recebePacote = new DatagramPacket(recebeDados,
33. recebeDados.length);
34.
35. // recebe pacote do servidor
36. clienteSocket.receive(recebePacote);
37.
38. // separa somente o dado recebido
39. String sentencaModificada = new String(recebePacote.getData());
40.
_________________________________________________________________________________________________
___________________________________________________________________________________________________________________________________________________________________________________________________

41. // mostra no vídeo
42. System.out.println("Datagrama UDP enviado com sucesso" +
43. sentencaModificada);
44.
45. // fecha o cliente
46. clienteSocket.close();
47. }
48. }
Exemplo 2.a – Classe ClienteUDP
Vamos agora examinar as linhas da classe ClienteUDP. Primeiramente, cria-se o objeto

clienteSocket do tipo DatagramSocket. A máquina cliente não contata a máquina servidora durante
a execução dessa linha. Por isso, o construtor DatagramSocket() não toma como argumento o nome do
servidor ou número da porta. Desse modo, a execução da linha acima cria um canal para o processo cliente.
Contudo, para enviar bytes a um processo destinatário, é preciso o endereço do processo. Parte desse
endereço é o endereço IP do destinatário. A linha 15 traduz o nome do destinatário para o endereço IP, essa
transformação é feita por meio de uma consulta ao DNS. O método getByName() toma como argumento o
nome do hospedeiro e devolve o endereço IP desse mesmo servidor, ele coloca esse endereço no objeto
enderecoIP. Na sequência, os vetores de Bytes enviaDados e recebeDados vão reter os dados que o
cliente envia e recebe, respectivamente. A seguir, realiza uma conversão de tipo. Ela pega a cadeia
sentença e a renomeia como enviaDados, que é um vetor de bytes.
As linhas 25 e 26 constroem o datagrama enviaPacote que o cliente envia para a rede por meio de
sua porta. Esse pacote inclui os dados que não estão contidos nele (enviaDados), o comprimento desses
dados, o endereço IP do servidor e o número de porta da aplicação. Logo após, o método send() do objeto
clienteSocket toma o datagrama recém-construído e o envia pela rede através dele.
Na última parte da classe ClienteUDP (linhas 30 a 48), enquanto o cliente espera pelo datagrama do
servidor, ele cria um objeto recebePacote que irá armazená-lo.
O cliente fica ‘dormindo’ até a chegada de um novo datagrama, quando então o recebe ele coloca em
recebePacote. A seguir, extrai os dados dele e realiza uma conversão de tipo, convertendo vetor de bytes
na cadeia sentencaModificada. Para finalizar, invoca o método close() para fechar a porta, como o
UDP não é orientado à conexão, essa linha não faz com que o cliente envie uma mensagem de camada de
transporte para o servidor, como no TCP.
No exemplo 2.b codificamos o lado servidor da aplicação:
_________________________________________________________________________________________________
___________________________________________________________________________________________________________________________________________________________________________________________________


3.
4. public class ServidorUDP {

6.
7. // cria socket do servidor com a porta 9876
8. DatagramSocket servidorSocket = new DatagramSocket(9876);
9.
10. byte[] dadosRecebidos = new byte[1024];
11. byte[] dadosEnviados = new byte[1024];
12. while(true){
13.
14. // declara o pacote a ser recebido
15. DatagramPacket pacoteRecebido = new
16. DatagramPacket(dadosRecebidos,dadosRecebidos.length);
17. // recebe o pacote do cliente
18. servidorSocket.receive(pacoteRecebido);
19.
20. // pega os dados, o endereço IP e a porta do cliente
21. // para poder mandar a msg de volta
22. String sentenca = new String(pacoteRecebido.getData());
23. InetAddress enderecoIP = pacoteRecebido.getAddress();

24. int porta = pacoteRecebido.getPort();
25.
26. // transforma em maiúsculas
27. String sentencaCapturada = sentenca.toUpperCase();
28. dadosEnviados = sentencaCapturada.getBytes();
29.
30. // monta o pacote com enderço IP e porta
31. DatagramPacket pacoteEnviado = new
32. DatagramPacket(dadosEnviados, dadosEnviados.length,
33. enderecoIP, porta);
_________________________________________________________________________________________________
___________________________________________________________________________________________________________________________________________________________________________________________________

34.
35. // envia ao cliente
36. servidorSocket.send(pacoteEnviado);
37. }
38. }
39. }
Exemplo 4 – Classe ServidorUDP
A classe ServidorUDP inicia construindo o objeto servidorSocket na porta 9876. Todos os

dados enviados e recebidos devem passar por esta porta, como o UDP não é orientado à
conexão, não temos de gerar uma nova porta e ficar na escuta por novas requisições de
conexão, como é feito na classe ServidorTCP, se vários clientes acessarem esta
aplicação, todos enviarão seus pacotes por essa única porta. A seguir, nas linhas 10 a 19
criam-se o objeto pacoterecebido que armazena os dados recebidos do cliente através
do método receive() chamado por servidorSocket.
Na sequência, extraem-se todas as informações que estão dentro do datagrama. Primeiramente, extraem-
se os dados por meio do método getData(). A seguir, se obtém o endereço IP através do método
getAddress() e, por último, o método getPort() consegue o número da porta que é escolhido pelo
cliente e é diferente do número de porta do servidor. O servidor precisa obter o endereço (endereço IP e
número de porta) do cliente para retornar a sentença em letras maiúsculas.
Na parte final da classe, transforma-se a cadeia capturada para maiúscula, converte-a para um vetor de
bytes, cria o datagrama com o endereço IP e a porta do cliente destinatário e a envia de volta.
Suponha que você rode o ClienteUDP antes de rodar o ServidorUDP. O

que acontece? Por quê?
COSTA, D. G. JAVATM em rede: programação distribuída na Internet. Rio de Janeiro: Brasport, 2008.
KUROSE, J. F; ROSS, K. W. Redes de Computadores e a Internet – Uma nova abordagem. 1. ed. São
Paulo: Addison Wesley, 2003.
SIERRA, K.; BATES, B. Use a cabeça! Java. 2ª ed. Rio de Janeiro: Alta Books, 2007.
_________________________________________________________________________________________________
___________________________________________________________________________________________________________________________________________________________________________________________________


O que é um socket e qual o papel dele numa aplicação cliente-servidor?
São as extremidades no canal de comunicação entre duas máquinas. Essas extremidades são formadas
pelo endereço IP e pela porta das máquinas comunicantes.
O principal papel dos sockets numa aplicação cliente-servidor é definir o endereço de envio e
recebimento no processo de comunicação entre os threads.
O protocolo TCP é um protocolo orientado à conexão confiável que permite a entrega sem erros, e em
ordem (a ordem é de acordo com que o fluxo de bytes foi enviado) de um fluxo originário de uma determinada
máquina em qualquer computador da Internet. Ele possui o controle de fluxo, impedindo que um transmissor
rápido sobrecarregue um receptor lento com um volume de mensagens maior do que ele pode manipular, e
ainda conta com o controle de erro, que é o envio de mensagens ao receptor para indicar quais dados foram
recebidos corretamente e quais não foram.
Suponha que você compile e rode o ClienteTCP antes de rodar o ServidorTCP. O que
acontece? Por quê?
Ocorrerá um erro de execução, pois é necessário que haja um servidor à espera de uma conexão. Quando
o clienteTCP é executado, ele cria uma conexão com o servidor por meio dessa linha:
Socket clienteSocket = new Socket("localhost", 6789);
Mas, aplicação servidor ServidorTCP não foi inicializada, fazendo com que a solicitação da
aplicação cliente não tenha resposta e gere o erro de execução.
O protocolo UDP não é orientado à conexão, ou seja, não estabelece um canal de comunicação para o
serviço de entrega de pacotes. Ao invés disso, compartilha uma porta do aplicativo para comunicar-se com
outras aplicações. Devido a essa característica, é possível o envio de mais de um pacote pela mesma porta,
algo que era impossibilitado no protocolo TCP. Essa possibilidade de diversos envios ou recebimentos torna a
entrega de pacotes, um serviço rápido. Contudo, não existe nenhum mecanismo de controle de fluxo ou erro.
_________________________________________________________________________________________________
___________________________________________________________________________________________________________________________________________________________________________________________________

Este tipo de protocolo é indicado para aplicações que sejam tolerantes a perda de pacotes, tais como: DNS,
aplicações de transmissão de vídeo pela Internet.
Suponha que você rode o ClienteUDP antes de rodar o ServidorUDP. O que acontece? Por
quê?
A aplicação funcionará normalmente, pois como o protocolo UDP não é orientado à conexão, não é
necessário que haja a criação de um canal entre cliente e servidor para que os datagramas sejam trocados.
1. Desenvolver um aplicativo de bate-papo para a troca de mensagens de texto entre um cliente e um

servidor. O servidor fica aguardando pela conexão de um cliente. Quando um cliente se conecta ao
servidor é enviada uma mensagem para o cliente, informando que a conexão foi bem sucedida. A partir
desse momento, ambos podem começar a trocar mensagens através de "JTextFields" e visualizá-las em
"JTextAreas". Quando o cliente ou o servidor envia a String "FIM", a conexão entre ambos é finalizada.
Então, o servidor passa a esperar por outra conexão.
2. Desenvolva um servidor de frases baseado em sockets. O seu programa deve criar um servidor que ouve
uma porta específica. Quando uma conexão é recebida pelo cliente, o servidor deve responder com uma
frase aleatória escolhida do banco de dados de frases.
_________________________________________________________________________________________________
___________________________________________________________________________________________________________________________________________________________________________________________________

UNIDADE IV
conexões de Banco de Dados
Nesta unidade, abordaremos aplicações que utilizam conexões de banco de dados para realizar a
interação cliente-servidor. Primeiramente, faremos uma revisão sobre os conceitos básicos de banco de dados
relacionais. A seguir, apresentaremos como utilizar SQL(Structured Query Language) para acessar e
manipular dados de um banco de dados. Na seqüência, mostramos passo a passo como instalar, configurar e
gerar tabelas no banco de dados MySQL. Finalmente, a JDBCTM API do pacote java.sql é empregada para
mostrar o acesso e manipulação num banco de dados relacional. Como pode ser observado, teremos uma
unidade bastante rica no tema acesso e manipulação de banco de dados. Sendo assim, desejo bom estudo a
todos.
TÓPICO 1 – BANCO DE DADOS RELACIONAIS

Banco de dados é um conjunto de registros organizado em estrutura regular que possibilita o acesso e
manipulação dos mesmos para a produção de informação. Um banco de dados normalmente agrupa registros
utilizáveis para um determinado objetivo. Um exemplo é um Sistema de Controle Acadêmico, que possui
registros sobre cada aluno de uma Instituição e esses dados podem ser utilizados para obter o perfil do aluno
(KORTH, 2006).
Um banco de dados é geralmente mantido e acessado por meio de um software conhecido como Sistema
Gerenciador de Banco de Dados (SGBD). Normalmente, um SGBD adota um modelo de dados, de forma
pura, reduzida ou estendida. Muitas vezes, o termo banco de dados é usado como sinônimo de SGDB.
O modelo de dados mais adotado hoje em dia é o modelo relacional, onde as estruturas têm a forma de
tabelas, compostas por tuplas (linhas) e colunas. A Figura 1 ilustra um modelo relacional para uma aplicação
de vendas de ingressos on-line, onde cada tabela representa uma entidade e as linhas indicam o modo de
relacionamento entre as entidades.
_________________________________________________________________________________________________
PROGRAMAÇÃO E DESENV. DE APLICAÇÕES COM CONEXÕES DE BANCO DE DADOS ‐ UNIDADE IV
53
___________________________________________________________________________________________________________________________________________________________________________________________________

Figura 1 – Modelo relacional de uma aplicação de vendas de ingressos on-line.
Para realizar consulta e manipular dados num banco de dados relacional, geralmente, utilizamos a
linguagem SQL que será discutida no Tópico 2.
Finalmente, os principais SGBD relacionais empregados atualmente no mercado são: Microsoft SQL
Server, Oracle, Sybase, IBM DB2, Informix, PostgreSQL e MySQL. Na nossa unidade foi escolhido o SGBD
MySQL devido à fácil instalação e configuração do mesmo e por possuir uma versão gratuita.
A seguir, estudaremos as operações para consulta e modificação do banco de dados relacional através da
linguagem de consulta SQL.
Defina sucintamente banco de dados relacional. Cite um exemplo através de

um modelo relacional de uma aplicação.
TÓPICO 2 – LINGUAGEM SQL

A linguagem SQL, Structured Query Language (Linguagem de Consulta Estruturada), é um padrão
adotado pela maioria dos bancos de dados para manipulação e consulta dos registros. Em termos mais simples,
suponha que cada banco de dados seja de uma nacionalidade diferente. Se desejássemos nos comunicar com
um desses bancos, teríamos que aprender seu idioma específico. Cada banco necessitaria de uma mudança
completa na comunicação. Para facilitar isso, todos os bancos de dados além de terem um idioma próprio
aprenderam um segundo idioma que chamamos de padrão ANSI-SQL. Existem algumas extensões a esses
parâmetros que cada banco de dados particularmente criou, mas elas já fogem ao padrão que adotaremos.
Assim, basta que aprendamos esta linguagem e poderemos nos comunicar com qualquer banco de dados como
mostrado na Figura 2.
_________________________________________________________________________________________________
54
___________________________________________________________________________________________________________________________________________________________________________________________________

Figura 2 – Comunicação com vários bancos de dados
A linguagem SQL é dividida em duas partes: A primeira trata da definição dos dados e a segunda é a de
manipulação dos dados. A definição dos dados é empregada normalmente no início do projeto, quando
estamos gerando o banco de dados. Apenas as estruturas são criadas e não as informações. Já a manipulação
de dados se concentra em inserir as informações nessa estrutura definida.
Um exemplo prático seria o cadastro de aluno. Na primeira parte, definimos quais informações
gostaríamos de obter do aluno, como nome, telefone, endereço; definimos também o tamanho máximo que
cada informação poderá ter; e a obrigatoriedade de não deixar algumas informações vazias. A partir disso,
passamos para a manipulação dos dados, que consiste em preencher cada uma dessas informações com os
dados dos alunos. Para cada aluno, uma linha, ou um registro, com todas essas informações será criado o
banco de dados. A manipulação de dados envolve também o momento em que procuramos uma determinada
informação cadastrada.
Na nossa unidade não nos aprofundaremos na linguagem SQL que trata da definição de dados, pois a
maioria dos bancos possui uma interface simples para a criação dessa parte e este não é o foco do nosso
estudo. Concentraremo-nos, então, somente na parte da manipulação dos dados que consiste na inserção,
alteração, deleção ou consulta de um ou vários registros. Para isso, devemos instalar e configurar o nosso
banco de dados e definir, logo a seguir, toda a estrutura das informações para, então, criarmos uma aplicação
que interaja com elas. Este será o assunto do nosso próximo tópico.
É correto afirmar que a linguagem SQL serve apenas para manipular as

informações do banco de dados? Por quê?
TÓPICO 3 – INSTALAÇÃO E CONFIGURAÇÃO DO BANCO DE DADOS MySQL

O banco de dados relacional My-SQL é uma linguagem bastante popular e de fácil utilização. Ela é
_________________________________________________________________________________________________
55
___________________________________________________________________________________________________________________________________________________________________________________________________

normalmente recomendada para bancos de dados mais simples por possuir apenas ferramentas básicas para a
manutenção dos dados. Mas a sua utilização, bem empregada, pode atender qualquer necessidade requerida de
um sistema.
Para começar, primeiro devemos saber que a comunicação de um software com um banco de dados
passa por um driver de comunicação específico. Então, se estamos desenvolvendo um programa em java para
se comunicar com um banco de dados My-SQL, além de ter esses dois programas, é preciso baixar um
terceiro arquivo, que corresponde ao driver de comunicação que intermediará os dois. Bem, você deve estar se
perguntando do porquê isso ser necessário, já que um o banco de dados compreende o idioma com o qual você
deseja se comunicar. Isto é simples, para cada banco de dados, é exigida uma burocracia na comunicação. Se
quiséssemos, por exemplo, falar com pessoas importantes, em alguns casos teríamos que agendar com a
secretária, em outros, deveríamos aguardar na fila, e alguns desses nos responderiam só por email ou fax, e
assim por diante.
Para instalar o banco de dados My-SQL você deverá fazer download do arquivo no site
www.mysql.com, procure preferencialmente por uma versão estável do banco, isto é, provavelmente uma
versão anterior à mais recentemente lançada. Descompacte o arquivo e clique em setup.exe. Siga todos os
passos e quando solicitados um usuário e uma senha, digite e guarde essa informação, pois ela será utilizada
no acesso a este banco mais tarde.
Depois de finalizada a instalação, baixe o driver do Java para My-SQL no site

http://www.mysql.com/downloads/api-jdbc.html e cole o arquivo dentro da subpasta bin do diretório onde
instalou o JDK.
Agora vamos criar o banco de dados. No nosso exemplo, criaremos um banco que controlará as
informações das aulas de uma escola com seus respectivos alunos e professores.
Figura 3 – Estrutura de um banco para controle de aulas
Na Figura 3, está o resultado da estrutura criada para registrarmos o controle de aula dos alunos em uma
determinada escola. Os relacionamentos entre os registros também estão representados. Eles ajudam a
melhorar a integridade do banco e a sua eficiência. No exemplo da Figura 3, as notações em colchetes
representam o tipo do relacionamento entre as tabelas. Por exemplo, o relacionamento entre o professor e a
_________________________________________________________________________________________________
56
___________________________________________________________________________________________________________________________________________________________________________________________________

aula pode ser explicado assim: Um professor poderá ministrar no mínimo uma e no máximo várias
(representado pelo asterisco) aulas [1,*]. A aula poderá ser ministrada por no mínimo um e no máximo um
professor [1,1]. Já no relacionamento entre Aluno e Aula, uma tabela intermediária surgiu chamado
Aluno_Aula como consequência do relacionamento deles. Isto normalmente acontece em relacionamentos
chamados N x N, ou muitos por muitos. Como um aluno poderá estar em no mínimo uma aula e no máximo
várias [1,*] e a Aula poderá conter no mínimo um e no máximo vários alunos [1,*], este tipo de
relacionamento, em que o máximo de ambos são vários, necessita de uma tabela auxiliar para o correto
funcionamento. Os detalhes desse relacionamento você irá compreender melhor mais tarde, no próximo
tópico, quando estivermos manipulando as informações cadastradas. Por hora, vamos nos concentrar na
criação da estrutura.
Existem vários programas que você pode instalar para criar essas tabelas automaticamente como:
Mysqlfront, Dbdesigner, DBManager, e etc. Utilizaremos o DBManager para gerar as tabelas através do seu
console SQL. Baixe o software do site www.aindavouver.com.br e instale-o com as opções padrão. Abra o
software e clique para abrir o servidor local Mysql@localhost. Se pedir um usuário e senha, você deverá
digitar o mesmo utilizado no momento da instalação do banco de dados My-SQL. Clique com o botão direito
em database e escolha create Database. Os databases são como prateleiras de uma biblioteca criadas para
organizar seus livros, onde cada livro corresponderia a uma tabela do seu banco. Após isso, clique com o
botão direito no database que você criou e escolha New Query. Uma página em branco se abrirá para que você
digite as especificações em SQL. Copie os comandos apresentado no Exemplo 1 para sua query e pressione F5
para executar.
CREATE TABLE Aluno (
Cod_Aluno INTEGER UNSIGNED NOT NULL AUTO_INCREMENT,
Nome VARCHAR(50) NULL,
Idade INTEGER UNSIGNED NULL,
PRIMARY KEY(Cod_Aluno)
);
CREATE TABLE Aluno_Aula (
Aluno_Cod_Aluno INTEGER UNSIGNED NOT NULL,
Aula_Cod_Aula INTEGER UNSIGNED NOT NULL,
PRIMARY KEY(Aluno_Cod_Aluno, Aula_Cod_Aula),
INDEX Aluno_has_Aula_FKIndex_1(Aula_Cod_Aula),
INDEX Aluno_has_Aula_FKIndex_2(Aluno_Cod_Aluno)
_________________________________________________________________________________________________
57
___________________________________________________________________________________________________________________________________________________________________________________________________

);
CREATE TABLE Aula (
Cod_Aula INTEGER UNSIGNED NOT NULL AUTO_INCREMENT,
Professor_Cod_Professor INTEGER UNSIGNED NOT NULL,
Materia VARCHAR(50) NULL,
Horário TIME NULL,
Carga INT NULL,
PRIMARY KEY(Cod_Aula),
INDEX Aula_FKIndex_3(Professor_Cod_Professor)
);
CREATE TABLE Professor (
Cod_Professor INTEGER UNSIGNED NOT NULL AUTO_INCREMENT,
Nome VARCHAR(50) NULL,
PRIMARY KEY(Cod_Professor)
);
Exemplo 1 – Código-fonte para criação das tabelas do banco Controle de Aulas.
Pronto. Toda a sua estrutura está criada. Você também poderia utilizar os recursos gráficos que o
software possui para criar as tabelas, e com certeza seria bem mais simples, mas deixarei para que você faça
este experimento sozinho, pois o nosso objetivo principal é trabalhar com os dados.
Agora que você já configurou toda a plataforma para o desenvolvimento vamos finalmente tratar da
construção do sistema que conectará no banco de dados e manipulará as informações da nossa base.
Crie outra base de dados utilizando o próprio editor do software DBManager.

Gere as tabelas necessárias para desenvolver uma aplicação de agenda de
compromissos.

CONEXÕES JDBC NUM BANCO DE DADOS
Primeiramente, vamos apresentar o Exemplo 2 que cria um programa em java que apenas se conecta
_________________________________________________________________________________________________
58
___________________________________________________________________________________________________________________________________________________________________________________________________

com o banco de dados e informa se houve algum erro.

1. import java.sql.*;
2.
5. conecta();
6. }
7. public static void conecta(){
8. Connection conexao;
9. String driver = "com.mysql.jdbc.Driver";
10. String ulr = "jdbc:mysql://localhost:3306/teste";
11. String login = "root";
12. String senha = "";
13. try {
14. Class.forName(driver);
15. conexao = DriverManager.getConnection(ulr, login, senha);
16. System.out.println("Conexão Bem Sucedida");
17. } catch (Exception e) {
18. e.printStackTrace(); //nesta linha é impresso o erro!
19. }
20. }
21. }
Exemplo 2 – Conexão com o Banco de Dados
Vamos nos concentrar somente nos comandos novos que aparecem neste exemplo. Primeiramente,
importamos todas as bibliotecas para conexão com o banco de dados na linha 1 com import
java.sql.*. O procedimento conecta() começa criando as variáveis que serão utilizadas para conexão e já
atribuindo os valores a elas, linha 8 à 12. Apenas a variável conexao é de um tipo especial, Connection,
importado da biblioteca do java.
A variável driver, como já dito, é a que conterá o caminho do driver jdbc para conexão do java com o
My-SQL.
A variável url é o caminho que seu software fará para chegar até o banco de dados. Primeiramente,
definindo o acesso ao driver jdbc:mysql configurado na linha anterior. Logo em seguida é especificado o
computador onde está o banco. Se você tiver instalado o banco de dados na mesma máquina em que criará a
aplicação em java poderá utilizar a expressão localhost, como neste exemplo. Se estiver em outra máquina,
deverá substituir a palavra localhost pelo IP (endereço de rede) da máquina onde está instalado seu banco de
dados. Em seguida, é definida a porta de comunicação, sendo, por padrão, utilizada a porta 3306. E por
último, o nome da database que você criou em seu banco de dados, como foi instruído a fazer anteriormente
durante o nosso estudo. Neste caso, o nome da nossa database é teste.
As variáveis login e senha são aquelas que você criou ao instalar o banco My-SQL. Se você não
configurou nenhuma senha no banco então poderá seguir com as mesmas informações de acesso utilizadas
nesse modelo.
Na linha 14 carregamos, na biblioteca do java, o driver de conexão e na linha seguinte, finalmente, nos
conectamos com o banco de dados através do comando DriverManager.getConnection, passando as
_________________________________________________________________________________________________
59
___________________________________________________________________________________________________________________________________________________________________________________________________

informações do local do banco, usuário e senha de acesso. A variável conexao conterá o ponteiro de
comunicação para o banco de dados.
A linha 17 é exigida na linguagem Java para tratar o erro do algum possível problema durante a
conexão.
Agora que aprendemos a criar um canal de comunicação com o banco de dados, vamos nos comunicar
com ele através da linguagem SQL. Para isso, vamos aprender os comandos mais comuns utilizados para
manipular as informações contidas nele, conforme ilustrado na Tabela 1.
Tabela 1 – Principais comandos da Linguagem SQL
Comando SQL Descrição

INSERT Utilizado para criar novos registros na tabela
UPDATE Altera um ou vários registros de uma tabela.
DELETE Deleta um ou vários registros
SELECT Seleciona, pesquisa, e lista os registros cadastrados no seu banco.

A sintaxe de cada comando será explicada no momento de sua utilização nos nossos exemplos.
Agora vamos ampliar a nossa aplicação em Java para que ela possa executar os comandos SQL direto no
banco de dados.
1. import java.sql.*;
2.
4. static Connection conexao;
5. public static void main(String[] args)throws Exception {
6. conecta();
7. executa("INSERT INTO Aluno(Cod_Aluno,Nome,Idade) VALUES
(1,'Anderlei','27')");
8. executa("INSERT INTO Aluno(Cod_Aluno,Nome,Idade) VALUES (2,'Kim','22')");
9. executa("INSERT INTO Aluno(Cod_Aluno,Nome,Idade) VALUES
(3,'Nelcileno','65')");
10. executa("INSERT INTO Professor(Cod_Professor,Nome) VALUES (1,'Nelcileno')");
11. executa("INSERT INTO
Aula(Cod_Aula,Professor_Cod_Professor,Materia,Horario,Carga) VALUES
(1,1,'Informática','10:00',60)");
12. executa("INSERT INTO Aluno_Aula(Aluno_Cod_Aluno,Aula_Cod_Aula) VALUES
(1,1)");
13. executa("INSERT INTO Aluno_Aula(Aluno_Cod_Aluno,Aula_Cod_Aula) VALUES
(2,1)");
14.
15. listar_aluno();
16. executa("UPDATE Aluno SET Nome = 'Anderlei Jr.' WHERE Cod_Aluno = 1");
17. executa("DELETE FROM Aluno WHERE Cod_Aluno = 3");
18. listar_aluno();
19. desconecta();
20. }
21. public static void conecta(){
22. String driver = "com.mysql.jdbc.Driver";
23. String ulr = "jdbc:mysql://localhost:3306/teste";
24. String login = "root";
25. String senha = "";
26. try {
27. Class.forName(driver);
28. conexao = DriverManager.getConnection(ulr, login, senha);
29. System.out.println("Conexão Bem Sucedida");
_________________________________________________________________________________________________
60
___________________________________________________________________________________________________________________________________________________________________________________________________

30. } catch (Exception e) {

31. e.printStackTrace(); //nesta linha é impresso o erro!
32. }
33. }
34. public static void executa(String sql)throws Exception{
35. Statement st = null;
36. st = conexao.createStatement();
37. st.executeUpdate(sql);
38.
39. }
40. public static void listar_aluno()throws Exception{
41. Statement st;
42. st = conexao.createStatement();
43. ResultSet rs = st.executeQuery("SELECT Cod_Aluno, Nome, Idade FROM Aluno");
44. System.out.println("---------------------------------------");
45. while (rs.next()) {
46. System.out.println("Codigo: " + rs.getString(1) + " Nome: "
+rs.getString(2)+" Idade: "+rs.getString("Idade"));
47. }
48. }
49. public static void desconecta()throws Exception {
50. conexao.close();
51. }
52. }
Exemplo 3 – Manipulação de registros no Banco de Dados.
O Exemplo 3 ainda é um exemplo simples, em cujo procedimento principal executamos uma sequência
de comandos SQL para inserir, alterar, remover e listar os dados da tabela, tudo de uma só vez. Dificilmente
seria criado um sistema assim, visto que o programa solicita uma interação do usuário para entrar com os
dados de uma determinada tabela antes de executar um INSERT. Mas para um melhor aprendizado, colocamos
passo a passo esses comandos para que você consiga analisar os resultados gerados por eles.
Antes de começar, uma mudança foi feita na variável conexao, que antes estava dentro do
procedimento conectar(), e no Exemplo 3 ele foi para o início da classe na linha 4 como variável geral.
Isto é importante no nosso exemplo, pois se não tivéssemos a conexão como uma variável global teríamos
que refazer todo o código da linha 22 à 32 a cada comando executado em SQL. Embora isso funcionasse, o
programa se torna mais eficiente quando aproveitamos uma conexão realizada com o banco de dados para
tudo que desejamos fazer e depois a fechamos. Para exemplificar isto, basta imaginar o trabalho que seria
fazer uma ligação de telefone para cada item que você quisesse que o almoxarifado te trouxesse.
Três novos procedimentos foram acrescentados no Exemplo 3, eles estão na linha 34, 40 e 49 e são,
respectivamente, executa(sql), listar_aluno() e desconecta().
A função desconecta() já está claro para que serve, então iremos analisar os procedimentos
executa e listar_aluno. A primeira sub-rotina está preparada para executar qualquer comando SQL
que tenha sido passado como parâmetro a ele. No entanto, somente a utilizamos para inserir, remover e alterar
registros, pois essas operações não retornam nenhum dado que precise ser mostrado logo em seguida, ao
contrário do SELECT, utilizado no procedimento listar_aluno, no qual você espera obter as informações
cadastradas no banco.
Na linha 35 é criada uma variável do tipo Statement e, logo em seguida, ela recebe a criação de um
Statement através do comando conexao.createStatement() que é a nossa variável de conexão
_________________________________________________________________________________________________
61
___________________________________________________________________________________________________________________________________________________________________________________________________

criando um lugar onde será executado o comando SQL. Na linha 37, o comando contido em sql é finalmente
executado através de st.executeUpdate(), e já podemos constatar o seu resultado no banco de dados.
O procedimento listar_aluno só difere do executa a partir da linha 43. O comando para executar a
instrução SQL é st.executeQuery() e ele retorna uma variável do tipo ResultSet que é um ponteiro
para uma matriz contendo todos os dados lidos do banco de dados de acordo com o que foi solicitado. O
ResultSet fica posicionado na linha zero quando criado. Nesta linha não há nada. Por isso, o comando
rs.next() é executado para que ele vá para a primeira linha da tabela e leia esse registro. Para lermos os
campos desses registros é só utilizar o comando rs.getString(?) colocando dentro o nome do campo
que existe em sua tabela ou o índice dele na ordem em que você solicitou no SELECT. A linha 46 emprega
essas duas formas. As linhas 45 a 47 representam um laço que se repetirá até que rs.next() não tenha mais
linhas a percorrer.
Bem, agora vamos tratar da sintaxe SQL utilizado em nosso exemplo. Das linhas 7 a 13 fizemos várias
inserções no banco de dados. Para facilitar o aprendizado, colocamos em caixa alta as palavras que nunca
mudam na instrução SQL.
Começamos cadastrando o aluno Anderlei e depois Kim. A instrução para inserção começa com
INSERT INTO, logo em seguida informamos o nome da tabela a qual queremos inserir um registro. Na linha
7, a tabela é Aluno. Logo em seguida, colocamos entre parênteses o campo que desejamos preencher, que para
a tabela Aluno, foi definido na criação do nosso banco de dados na Figura 3. A palavra fixa VALUES
antecede as informações que iremos digitar do nosso primeiro aluno. Entre parênteses colocamos as
informações de preenchimento na mesma ordem em que foram colocados os campos da tabela separados por
vírgulas. É importante lembrar que campos textos, datas e horas; devem ser colocados entre apóstrofes. Após
isso, nossa instrução está completa para ser enviada ao banco.
A instrução
UPDATE Aluno SET Nome = 'Anderlei Jr.' WHERE Cod_Aluno = 1
executada na linha 16 altera o primeiro registro que inserimos na tabela, mudando o nome Anderlei para
Anderlei Jr. Este instrução contêm a palavra fixa UPDATE seguida do nome da tabela que desejamos alterar e
depois SET. Após isso informaremos os campos que desejamos alterar utilizando o símbolo '=' e depois a
nova informação para este campo. Se mais um campo fosse necessário alterar, colocaríamos uma vírgula, e
então o outro campo seguindo da atribuição de seu novo valor. A palavra reservada WHERE restringe os
registros em que serão alterados pelo comando UPDATE. Se ela não existisse, todos os alunos da nossa tabela
após esse comando passariam a ter seu nome cadastrado como Anderlei Jr. Com a restrição WHERE
definimos que apenas o registro com o Cod_Aluno igual a 1 deve ser alterado.
O Comando para remoção é mais simples, utilizamos a palavra reservada DELETE FROM, logo em
seguida o nome da tabela e depois informamos a restrição dos registros que serão removidos através do
comando WHERE, esta parte é igual ao comando UPDATE. Na linha 17 somente o aluno com o código igual
_________________________________________________________________________________________________
62
___________________________________________________________________________________________________________________________________________________________________________________________________

a 3 foi retirado de nossa tabela através desse comando.
A Figura 4 mostra o conteúdo da tabela de alunos antes e depois de aplicar as operações de alteração e
remoção.
Conexão Bem Sucedida
---------------------------------------
Codigo: 1 Nome: Anderlei Idade: 27
Codigo: 2 Nome: Kim Idade: 22
Codigo: 3 Nome: Nelcileno Idade: 65
---------------------------------------
Codigo: 1 Nome: Anderlei Jr. Idade: 27
Codigo: 2 Nome: Kim Idade: 22
Figura 4 – Conteúdo da tabela Alunos.
Se você tentar executar o Exemplo 3 mais de uma vez obterá um erro. Isto acontece porque na nossa
definição do banco de dados restringimos que não pode existir um cod_aluno igual em toda a tabela. Por
isso, na segunda vez que executamos este exemplo, o nosso programa tenta inserir novamente outro registro
com o código do aluno igual a 1 e o banco de dados bloqueia. Isto é chamado de chave primária. Como na
nossa definição do banco de dados definimos que o Cod_Aluno seria AUTOINCREMENT, isto é,
automaticamente sequencial, basta retirarmos o preenchimento do campo Cod, de qualquer tabela, que ele
será preenchido automaticamente com o próximo código.
Bem, as instruções ensinadas até aqui, inserem, apagam ou alteram registros. O comando SELECT em
SQL serve principalmente como leitura. Numa instrução simples poderíamos ler com esse comando os
registros de cada tabela executando a instrução: SELECT * FROM <Tabela>. Substituindo a informação
<Tabela> pelo nome de uma tabela do seu banco de dados, você obteria todos os registros cadastrados nela. O
caractere '*' (asterisco) serve para informar que você gostaria de ver as informações de todos os campos da
tabela escolhida. Se não o utilizarmose, deveríamos informar os campos da tabela separados por vírgulas
como foi feito na linha 43 do Exemplo 3.
Uma das instruções mais importantes do comando SELECT é a possibilidade de combinar informações
de duas ou mais tabelas e trazê-las numa simples listagem. Por exemplo: Ao consultarmos os registros da
tabela Aula, seria mais completa a informação, se ao invés de vermos o código do professor, obtivéssemos o
nome do professor, que para nós seria mais útil, pois dificilmente alguém saberia de cor os códigos de cada
professor. Com o comando SELECT, existe a possibilidade de combinarmos essas duas tabelas e retornarmos
só as informações que nos são interessantes.
SELECT Aula.Materia, Aula.Carga, Professor.Nome
_________________________________________________________________________________________________
63
___________________________________________________________________________________________________________________________________________________________________________________________________

FROM Aula LEFT JOIN Professor ON Aula.Professor_Cod_Professor =

Professor.Cod_Professor
ORDER BY Aula.Materia
Exemplo 4 – Selecionando informações de duas tabelas.
No Exemplo 4, começando na primeira linha, já podemos ver uma diferença em relação ao nosso SQL
tradicional. Antes informávamos diretamente o campo da tabela. Agora, como vamos trabalhar com mais
tabelas, devemos informar a tabela, seguido de um ponto, e o campo correspondente dela.
Na instrução Aula LEFT JOIN Professor informamos que vamos relacionar a tabela aula com
a tabela professor.
A seguir, na instrução ON Aula.Professor_Cod_Professor =

Professor.Cod_Professor colocamos a condição que seleciona apenas os registros cujo o campo
Professor_Cod_Professor da tabela aula seja igual ao campo Cod_Professor que se encontra na
tabela Professor.
Por fim, a instrução ORDER BY Aula.Materia, especifica que os registros serão ordenados em
ordem alfabética pelo campo Matéria da tabela Aula. Esta consulta retornará a tabela apresentada na
Figura 5.
Matéria Carga Professor

Informática 60 Nelcileno
Figura 5 – Consulta SELECT no banco de dados Controle de Aulas.
Depois dessa instrução básica, vamos complicar um pouquinho mais o nosso comando SELECT para
que você tenha uma noção do poder que ele tem.
SELECT Aula.Materia, Professor.Nome, Aluno.Nome, Aluno.Idade
FROM ((Aula LEFT JOIN Professor ON Aula.Professor_Cod_Professor =

Professor.Cod_Professor) LEFT JOIN Aluno_Aula ON Aula.Cod_Aula =
Aluno_Aula.Aula_Cod_Aula) LEFT JOIN Aluno_Aula ON
Aluno_Aula.Aluno_Cod_Aluno = Aluno.Cod_Aluno
WHERE Aluno.Idade >23
ORDER BY Aula.Materia
Exemplo 5 – Selecionando registros de muitas tabelas com restrição.
O Exemplo 5 combina todas as tabelas do banco de dados para obter o resultado das aulas cadastradas
mostrando seus respectivos alunos e professores. Restringimos, ainda, os alunos pela idade, e no caso, serão
mostrados somente aqueles maiores que 23 anos.
Além disso, no Exemplo 5 convém mostrar a organização da instrução SQL quando associada a várias
tabelas. Eles são organizados como uma equação matemática. Primeiro se resolve os parênteses mais internos,
_________________________________________________________________________________________________
64
___________________________________________________________________________________________________________________________________________________________________________________________________

de dentro para fora. Assim, o resultado de cada parênteses resolvido é como se fosse uma tabela intermediária
intermediária
que será associado a outra tabela que está fora do parêntese na nossa instrução. A cláusula WHERE é
semelhante ao UPDATE e DELETE, mostrará apenas os registros que atenderem àquela condição.
Existem muitos outros parâmetros que fazem parte da instrução SELECT que facilitam ainda mais a
consulta ao banco, mas isto foge do escopo da unidade. Deixamos esse tópico para ser realizado como
pesquisa em conjunto com o tutor.
Crie uma consulta em SQL que liste somente os alunos e a matéria que eles
pertencem.

DEITEL, H. M; DEITEL, P. J. Java como programar. 6ª. ed. São Paulo: Pearson Brasil, 2005.
KURNIAWAN, B. Java para Web com Servlets, JSP e EJB. Rio de Janeiro: Ciência Moderna, 2002.
SIERRA, K.; BATES, B. Use a cabeça! Java. 2ª ed. Rio de Janeiro: Alta Books, 2007.

Defina sucintamente banco de dados relacional. Cite um exemplo através de um modelo

relacional de uma aplicação.
É uma forma de organização de dados através de relações, onde cada relação pode ser vista como uma
tabela composta por atributos (as colunas) e tuplas (as linhas). Por exemplo, um sistema de controle de
locação de produtos representado num modelo relacional contém pelo menos três relações: Produto,
Cliente e LocaProduto. A Figura abaixo mostra o modelo relacional dessas três relações, onde os
atributos são os campos da tabela, tal como código na tabela Cliente e as tuplas, o registro formado pelos
campos existentes na tabela, ou seja, em Cliente a tupla é composta pelos campos código, nome e
endereço.
_________________________________________________________________________________________________
65
___________________________________________________________________________________________________________________________________________________________________________________________________

É correto afirmar que a linguagem SQL serve apenas para manipular as informações do
banco de dados? Por quê?
Não. A linguagem SQL também serve para criar a estrutura das tabelas. Normalmente, esta fase é
realizada no início do projeto quando o banco de dados está sendo criado.
Crie outra base de dados utilizando o próprio editor do software DBManager. Gere as tabelas
necessárias para desenvolver uma aplicação de agenda de compromissos.
Para criar uma nova base de dados no DBManager, abra o programa e clique com o botão direito do mouse
no ícone de servidor My‐SQL. Clique em New Database. Para criar novas tabelas, clique em expandir o seu
database até a opção Tables. Clique com o botão direito em Table e escolha New Table. Algumas tabelas
úteis a serem criadas em um controle de agenda seria: Compromisso (Cod, Data, Cod_Tipo, Hora) e
Tipo_Compromisso (Cod, Descricao). A segunda tabela definiria se o compromisso é uma
reunião, lembrete ou um trabalho.
Crie uma consulta em SQL que liste somente os alunos e a matéria a que eles pertencem.
Esta consulta é uma simplificação do Exemplo 5, pois não haverá necessidade de associarmos a
tabela Professor. A consulta ficaria assim:
SELECT Aula.Materia, Aluno.Nome, Aluno.Idade
FROM (Aula LEFT JOIN Aluno_Aula ON Aula.Cod_Aula =

Aluno_Aula.Aula_Cod_Aula) LEFT JOIN Aluno_Aula ON
Aluno_Aula.Aluno_Cod_Aluno = Aluno.Cod_Aluno
_________________________________________________________________________________________________
66
___________________________________________________________________________________________________________________________________________________________________________________________________

1. Crie uma instrução em SQL que insira um registro na tabela Compromisso e na tabela
Tipo_Compromisso, cuja estrutura está definida na resposta do exercício de auto-avaliação do Tópico 3.
2. Agora altere o registro utilizando a instrução SQL UPDATE para que o campo data receba uma data
diferente.
3. A seguir, faça uma consulta em SQL que liste o seu compromisso associando a tabela Tipo_Compromisso
mostrando a Descrição do mesmo.
4. Remova os dois registros criados.
_________________________________________________________________________________________________
67
___________________________________________________________________________________________________________________________________________________________________________________________________

UNIDADE V
Servlets
Continuando nosso estudo no desenvolvimento de aplicações cliente-servidor, vamos abordar um novo

método de programação que ganhou muita popularidade com o advento da internet. Este tópico tratará sobre
Servlet, nele você aprenderá a configurar um servidor web, o Tomcat, e fará uma simples implementação em
java da utilização de um servlet.
TÓPICO 1 – SERVLETS
Você deve estar preocupado com tantos novos nomes
aparecendo neste estudo, e provavelmente inseguro em memorizar
todos os conceitos. Não se preocupe, com o desenvolvimento dos
exemplos propostos você irá automaticamente se familiarizando
com essas tecnologias. Para entendermos como essas novas
maneiras de desenvolver aplicações cliente-servidor foram
surgindo, basta ter em mente a evolução por que passa uma
empresa de montagem. No princípio, poucos funcionários da
empresa constroem o produto desde o início até o final. Com o
passar do tempo, e o crescimento do número de funcionários, há
especialização de alguns em um estágio da montagem, enquanto
outros, ao mesmo tempo, constroem a etapa seguinte. Logo, a empresa cria departamentos especializados, ou
filiais, que são responsáveis por um estágio de montagem do produto, e por fim, com o aumento da produção,
resolve terceirizar alguns serviços com empresas que oferecem uma melhor qualidade em alguns setores de
sua empresa. Grosseiramente, poderíamos comparar o início dessa empresa com o desenvolvimento de um
programa simples que processa uma solicitação do início ao fim. Para o desenvolvimento do produto em
estágios, mas ainda no mesmo setor, podemos comparar aos THREADS, tarefas desempenhadas
concorrentemente no mesmo computador. A execução do serviço em diferentes setores ou filiais da mesma
empresa é semelhante aos SOCKETS que são criados para atender especificamente à arquitetura de uma rede
interna da empresa, onde cada computador seria um departamento. E finalmente, quando a empresa terceiriza
os serviços, estamos utilizando SERVLETS, estes são serviços que podem ser disponibilizados por qualquer
servidor web do mundo. Esses servidores podem receber as solicitações de qualquer cliente, desenvolvidas em
qualquer linguagem, e retornar a informação solicitada através do protocolo HTTP que é o protocolo padrão
da internet.
_________________________________________________________________________________________________
SERVLETS ‐ UNIDADE V 2 68
___________________________________________________________________________________________________________________________________________________________________________________________________

Figura 1 – Exemplo de utilização de Thread, Sockets e Servlets
Na Figura 1 está apenas uma amostra de como podem ser utilizadas as tecnologias de programação
distribuída, embora possamos utilizar servlets também numa intranet já que basta configurar o protocolo de
comunicação para o mesmo utilizado na internet.
Bem, para entendermos servlets devemos lembrar que sua principal utilização é na internet, por isso sua
comunicação se baseia no protocolo HTTP. Na Figura 2 podemos analisar uma requisição a um servlet através
de um navegador. Ele acessa um computador que tem um servidor web instalado e um serviço disponível para
utilização. Este servidor requisita ao Servlet uma resposta para a solicitação que lhe foi enviada, e este retorna
em formato HTTP o resultado do processamento.
Figura 2 – Funcionamento de um Servlet
_________________________________________________________________________________________________
___________________________________________________________________________________________________________________________________________________________________________________________________

Além disso, a Figura 2 apresenta que o mesmo servlet poderia fazer requisições a outros servlets ou a
um banco de dados que não precisa estar necessariamente na mesma máquina. Um exemplo de como utilizar
um serviço pela internet utilizando servlets é a previsão do tempo. Suponha que criamos um servlet para
calcular a média da temperatura de uma semana inteira à frente. Através de um navegador você acessaria a
página que disponibiliza este serviço. Esta página acionaria seu servlet para contar as temperaturas da semana
e obter a média. No entanto, para conseguir a temperatura de cada dia, esta página poderia acessar outro
servidor web que lhe informaria apenas a temperatura respectiva ao dia solicitado. Assim poderíamos
desenvolver diversos sistemas que se beneficiem de outros em qualquer lugar do mundo.
Gostou? Então vamos, agora, aprender a preparar o ambiente que possa disponibilizar um serviço desse
tipo para qualquer pessoa que utilize a internet e, em seguida, vamos aprender a utilizar este serviço.
Por que utilizar Servlets? Cite algumas vantagens de sistemas que utilizam
essa tecnologia?
TÓPICO 2 – UTILIZANDO O TOMCAT.

O Tomcat é um projeto – que faz parte da Apache Foundation – que consegue executar as aplicações
JAVA criando os repositórios (containers) responsáveis pelo controle das requisições. O Container é um
objeto que contém outros objetos, que no nosso caso, são os servlets habilitados para responder às requisições
feitas pelo navegador. Assim, as solicitações feitas pelo cliente são enviadas pelo nosso servidor web ao
container, que por sua vez se encarrega de controlar a requisição ao servlet que está carregado dentro dele. Por
causa dessa estrutura, é possível gerenciar o ciclo de vida das operações realizadas.
Para configurar o Tomcat você deve primeiramente fazer download do jakarta-tomcat do site
http://tomcat.apache.org e realizar os seguintes passos para a correta configuração:
 Extraia os arquivos, se o mesmo vier compactado, no disco rígido do seu computador.
 Clique com o botão direito do mouse no ícone Meu Computador na sua área de trabalho e selecione
Propriedades no menu. O diálogo Propriedades do sistema aparece.
_________________________________________________________________________________________________
___________________________________________________________________________________________________________________________________________________________________________________________________

Figura 3 – Acessando Propriedades do Sistema
 Selecione a guia Avançado na parte superior do diálogo Propriedades do sistema. Clique no botão
Variáveis de ambiente para exibir o diálogo Variáveis de ambiente.
Figura 4 – Acessando Variáveis de Ambiente
_________________________________________________________________________________________________
___________________________________________________________________________________________________________________________________________________________________________________________________

 Clique no botão Nova na caixa Variáveis de usuário. Isso fará com que o diálogo Editar variável do
usuário apareça.
Figura 5 – Caixa de Edição da Nova Variável de Usuário
 Insira JAVA_HOME para Variable name e C:\Arquivos de Programas\Java\\jkd1.5.0 (Este

caminho em seu computador poderá ser diferente) para Valor da variável. Clique no botão OK para
completar a configuração da variável.
Figura 6 – Criando a variável JAVA_HOME
Clique no botão Nova na caixa Variáveis de usuário novamente.
Insira CATALINA_HOME para Nome da variável e C:\apache-tomcat-6.0.13 (Este caminho em seu

computador poderá ser diferente) para o Valor da variável. Clique no botão OK.
Figura 7 – Criando a variável CATALINA_HOME
 Clique nos botões OK para fechar os diálogos Variáveis de ambiente e Propriedades do sistema.
 Reinicie o computador para se certificar que as alterações tenham efeito.
 Para iniciar o Tomcat basta executar o arquivo startup.bat que se encontra na subpasta 'bin' do
lugar onde instalou o Tomcat.
Após estes passos, abra o navegador e digite o seguinte endereço http://localhost:8080. Se tudo
estiver certo, uma página do Tomcat aparecerá em seu navegador como mostrado na Figura 8.
_________________________________________________________________________________________________
___________________________________________________________________________________________________________________________________________________________________________________________________

Figura 8 – Página Inicial do Tomcat
Qual a finalidade principal do Container em um servidor web?
TÓPICO 3 – CONSTRUINDO SEU PRIMEIRO SERVLET.

Agora vamos criar um servlet em java para que você possa se familiarizar com as principais operações
utilizadas nele. Se você estiver usando o Eclipse, ou o Netbeans, você deverá adicionar a biblioteca servlet-
api.jar que se encontra na pasta onde você instalou o Tomcat.
1. import java.io.*;
2. import javax.servlet.ServletException;
3. import javax.servlet.http.HttpServletRequest;
4. import javax.servlet.http.HttpServletResponse;
5.
6. public class ExemploServlet extends javax.servlet.http.HttpServlet {
7.
8. public void doPost(HttpServletRequest request, HttpServletResponse
response) throws ServletException, IOException {
9. response.setContentType("text/html");
10.
11. //instanciando o Writer e enviando a resposta
12. PrintWriter out = response.getWriter();
13. out.println("<HTML>");
14. out.println("<HEAD><TITLE> Teste de
servlet.</TITLE></HEAD>");
15. out.println("<BODY>Meu Primeiro Servlet Funcionando!!!
<br>");
_________________________________________________________________________________________________
___________________________________________________________________________________________________________________________________________________________________________________________________

16. out.println("Meu nome é <b>" +

request.getParameter("nome") +"</b><BODY>");
17.
18. out.println("</HTML>");
19. out.close();
20. }
21. public void doGet(HttpServletRequest request, HttpServletResponse
response) throws ServletException, IOException{
22. doPost(request,response);
23. }
24.
}
Exemplo 1 – Exemplo Básico de um Servlet.
No Exemplo 1, as primeiras 4 linhas importam as bibliotecas utilizadas neste exemplo, das quais apenas
a primeira não corresponde especificamente ao servlet e sim à operação de escrita do sistema. Todas as classes
criadas devem herdar a classe principal HttpServlet como mostrado na linha 6. Existem dois
procedimentos no Exemplo 1, doGet() e doPost(). Ambos são executados no momento em que é acessado o
servlet. A diferença é que os parâmetros que são passados na URL, no link da página, são acessados pelo
procedimento doGet() enquanto que os parâmetros de um formulário, páginas html com campos de edição,
são acessados por doPost(). No nosso exemplo, fizemos que o procedimento doGet() chamasse o doPost(),
assim poderíamos em uma só função acessar os parâmetros que foram passados em ambas.
Tanto o procedimento doPost() da linha 8 e doGet() da linha 21 recebem 2 parâmetros: request e

response. Através do request podemos acessar os parâmetros, variáveis, que foram passados pelo navegador.
O response incorpora respostas que serão enviadas ao navegador, é o resultado do nosso servlet.
Na linha nove, informamos o tipo da informação que retornaremos ao navegador através do comando
response.setContentType("text/html"), e na linha 12 instanciamos a escrita na página do navegador para nossa
variável através do comando PrintWriter out = response.getWriter();. Por fim, através do método println do
nosso novo objeto instanciado out, podemos escrever na página utilizando as tags htmls como se estivéssemos
em um editor. A linha 19 finaliza o objeto de escrita.
Dê um exemplo de como acessar a variável 'idade' passada como

parâmetro no link da página. Em qual procedimento você pode acessá-la?
no doGET() ou doPost()? Por quê?
TÓPICO 4 – TESTANDO SEU PRIMEIRO SERVLET.

Bem, agora que terminamos nossa aplicação, ainda não podemos testá-la tão facilmente como fizemos
com os exemplos anteriores. O Servlet, por ser um serviço que pode ser disponibilizado na internet, deve estar
alinhado com o servidor de web. Por isso, devemos configurar no servidor algumas informações para que o
serviço seja utilizado pela web.
A primeira coisa que você deve localizar no seu servidor web, o Tomcat, é a pasta WEB-INF, que
_________________________________________________________________________________________________
___________________________________________________________________________________________________________________________________________________________________________________________________

normalmente está na subpasta webapps/ROOT/. Crie dentro da pasta WEB-INF a subpasta CLASSES e copie
o seu arquivo ExemploServlet.class dentro dela. Este será o local onde seu servidor web acessará os arquivos
.class que você criar em Java.
Na pasta WEB-INF você também encontrará um arquivo chamado Web.xml. Este arquivo é responsável
por configurar todos os objetos que são visíveis para internet do seu servidor. O Exemplo 2 mostra o conteúdo
de um arquivo xml configurado para executar o nosso servlet desenvolvido no Exemplo 1.

1. <?xml version="1.0" encoding="ISO‐8859‐1"?>
2. <web‐app xmlns="http://java.sun.com/xml/ns/javaee"
3. xmlns:xsi="http://www.w3.org/2001/XMLSchema‐instance"
4. xsi:schemaLocation="http://java.sun.com/xml/ns/javaee
5. http://java.sun.com/xml/ns/javaee/web‐app_2_5.xsd" version="2.5">
6. <display‐name>Welcome to Tomcat</display‐name>
7. <description> Welcome to Tomcat </description>
8. <servlet>
9. <servlet‐name>ExemploServlet</servlet‐name>
10. <servlet‐class>ExemploServlet</servlet‐class>
11. </servlet>
12. <servlet‐mapping>
13. <servlet‐name>ExemploServlet</servlet‐name>
14. <url‐pattern>/servlet/PrimeiroExemplo</url‐pattern>
15. </servlet‐mapping>
16. </web‐app>
Exemplo 2 – Configurando o arquivo WEB.XML.
No Exemplo 2, vamos só considerar as alterações necessárias para que nosso servlet seja executado pelo
navegador. Estas alterações estão descritas nas linhas de 8 a 15. Nas linhas de 8 a 11 você define o nome do
seu Servlet, linha 9, e o caminho onde se encontra o seu servlet, linha 10. Como nosso servlet está na pasta
CLASSES do Tomcat, a pasta raiz, então só informamos diretamente o nome do arquivo no caminho. As linhas
de 12 a 15 definem como o servlet será chamado pelo navegador. A linha 13 referencia o nome do servlet já
criado na linha 9, para definir na linha 14 o link como ele será chamado no navegador da web. No nosso
exemplo, teremos que digitar no navegador:
http://localhost:8080/servlet/PrimeiroExemplo
Pronto, terminamos de configurar o servidor web, agora devemos reiniciar o Tomcat e você já poderá
testar o seu servlet pelo navegador. No entanto, se usar o link acima, perceberá que está faltando uma
informação, pois no nosso exemplo consideramos alguns parâmetros que poderiam ser passados pelo
navegador. Você pode ver isso na linha 16 através do comando request.getParameter("nome"). Este comando
acessa o conteúdo da variável nome que foi passada pelo navegador. Dessa forma, mudaremos o nosso link de
_________________________________________________________________________________________________
___________________________________________________________________________________________________________________________________________________________________________________________________

acesso apenas para acrescentar um valor à variável nome,

nome ele ficará assim:
http://localhost:8080/servlet/PrimeiroExemplo?nome=MeuNome
A Figura 9 é o resultado do navegador para o nosso exemplo de servlet criado.
Fig
ura 9 – Configurando o arquivo WEB.XML.
ATENÇÃO
A cada nova alteração do seu servlet você deve reiniciar o servidor Tomcat para que ela tenha
efeito
Para que serve o arquivo Web.xml? Exemplifique como habilitar um novo

serviço dentro do web.xml do objeto Teste.class.
Agora você já está pronto para disponibilizar serviços na internet. No próximo estudo, veremos como
utilizar estes servlets de uma maneira mais organizada dentro de um sistema utilizando a tecnologia JSP.
BASHAN, B.; SIERRA, K.; BATES, B. Use a Cabeça! Servlets & JSP. São Paulo: Alta Books, 2005.
_________________________________________________________________________________________________
___________________________________________________________________________________________________________________________________________________________________________________________________


Por que utilizar Servlets? Cite algumas vantagens de sistemas que utilizam essa tecnologia?
Utilizar servlets facilita a interação de sistemas a distância sem a necessidade de estarem totalmente
interligados por terem uma via de transmissão muito popular, a internet. As diversas vantagens em utilizar esta
tecnologia são: o fato de podermos desenvolver sistemas em diferentes plataformas que possam se comunicar;
a possibilidade de desenvolver apenas uma regra de negócio sem nos preocuparmos com a interface do
usuário; e, finalmente, a capacidade de interligar diversos sistemas distantes através de uma comunicação
simples e de fácil utilização.
Qual a finalidade principal do Container em um servidor web?
Um container no servidor web é responsável por carregar todos os serviços, ou objetos disponíveis no
servidor para controlar as requisições feitas a eles de maneira que não haja conflito ou sobrecarga nos
componentes.
Dê um exemplo de como acessar a variável 'idade' passada como parâmetro no link da

página. Em qual procedimento você pode acessá-la? doGET() ou doPost()? Por quê?
Para acessar a variável idade, passada como parâmetro pelo navegador, utilizamos o seguinte comando
request.getParameter("idade"). Só obteremos um valor para essa variável dentro do
procedimento doGet(), pois toda a variável passada no link do navegador é tratada por esse procedimento,
enquanto que doPost() trata as variáveis que são passadas em um formulário HTML.
Para que serve o arquivo Web.xml? Exemplifique como habilitar um novo serviço dentro do
web.xml do objeto Teste.class.
O Web.xml é um arquivo do Tomcat que, quando o servidor web é iniciado,e carrega os serviços e
componentes definidos dentro dele em um container para que seja utilizado pelo servidor para as requisições
feitas.
Para se definir um serviço do objeto Teste.class devem ser acrescentadas dentro do web.xml as seguintes
linhas:
<servlet>
_________________________________________________________________________________________________
___________________________________________________________________________________________________________________________________________________________________________________________________

<servlet-name>Teste</servlet-name>
<servlet-class>Teste</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>Teste</servlet-name>
<url-pattern>/servlet/Teste</url-pattern>
</servlet-mapping>
Estas informações deverão ser colocadas dentro das tags <web-app>
1. Utilize o formulário HTML abaixo que dispõe das seguintes informações de um aluno: Nome, Idade,
Nota1, Nota2 e Nota3. Esse formulário chama um servlet de nome servlet/Media. Este servlet deverá
retornar as informações do aluno e a média dele.
<html><head>
<title>Calcula Media do Aluno</title>
</head>
<body>
<form name="form1" method="post" action="http://localhost/servlet/Media">
Nome do Aluno: <input name="nome" type="text" id="nome"><br>
Idade: <input name="idade" type="text" id="idade"><br>
Nota1:<input name="nota1" type="text" id="nota1"><br>
</form>
</body>
</html>
Obs: Você deverá salvar este formulário com a extensão html.
2. Crie um servlet que, através do parâmetro response, envie um parâmetro a outro servlet. Faça com que
este último imprima o resultado na tela.
_________________________________________________________________________________________________
___________________________________________________________________________________________________________________________________________________________________________________________________

UNIDADE VI
Java Server Pages (JSP)

Nesse nosso estudo vamos abordar as páginas em java que interagem tanto com o navegador quanto com
a linguagem de desenvolvimento java e os outros componentes como JavaBens, JDBC e etc. Java Server
Pages, na verdade, é uma extensão do nosso estudo anterior sobre Servlets. Tudo que fizermos em JSP
poderíamos fazer utilizando somente Servlets.

TÓPICO 1 – Funcionamento de um JSP
Se podemos fazer em Servlets tudo o que fazemos em JSP,

então qual a vantagem de utilizar JSP? O JSP é uma facilitação
na utilização da tecnologia Servlets. Ele também estende a
biblioteca javax.servlet e utiliza os componentes java como se
fosse um programa interno de sistema. Mas ao processar o
resultado, ele gera um conteúdo estático para páginas HTML.
Um outro grande motivo em se utilizar JSP é a separação do
código de desenvolvimento do layout da página. Normalmente os
códigos em HTML e as funções em java ficariam misturadas em um Servlet dificultando a manutenção e o
entendimento do software. Com o JSP podemos ter duas equipes de desenvolvimentos distintos, uma que se
preocupa apenas com a parte funcional do sistema e outra que estrutura a parte visual de interação com o
usuário: Desenvolvedores e Designers.
Quando o cliente solicita uma página JSP criada por você, o conteiner de JSP traduz essa página em um
servlet Java que após fazer os devidos processamentos retorna uma página HTML para o solicitante. Na
Figura 1, vemos a solicitação do cliente para a JSP Engine, que envia a sua solicitação a qualquer componente
(este, além de poder ser um servlet, pode ser diretamente um JavaBeans ou um Enterprise Bean) especificado
no arquivo. No fim da solicitação, é passado o objeto response de volta para a JSP Engine e, assim, para o
cliente.
_________________________________________________________________________________________________
JAVA SERVER PAGES (JSP) ‐ UNIDADE VI 2 79
___________________________________________________________________________________________________________________________________________________________________________________________________

Figura 1 – Funcionamento de um JSP
A estrutura das pastas de nossa aplicação foi abordada superficialmente no capítulo anterior. Como
estamos trabalhando com vários tipos de arquivos é interessante deixar bem claro como eles devem ser
armazenados em nosso servidor web. A pasta ROOT que se encontra dentro do Tomcat\webapps é a pasta
principal do seu servidor, onde você irá salvar as suas páginas com extensão JSP. Nesta mesma pasta ROOT,
existirá uma pasta WEB-INF. Dentro dela você poderá criar duas pastas: classes e lib. Dentro da pasta classes
você guardará todos os arquivos class que você criar em java, e dentro da pasta lib você guardará as
bibliotecas utilizadas em java .jar. A Figura 2 mostra como ficarão os arquivos.
Figura 2 – Estrutura das pastas do servidor Web
Agora vamos começar a construir nosso primeiro programa em JSP, mas para entendermos a sua
verdadeira utilidade, vamos construir outros arquivos que interajam com o JSP. Vamos construir uma página
HTML, um JavaBean e por fim um JSP.
_________________________________________________________________________________________________
___________________________________________________________________________________________________________________________________________________________________________________________________

Qual a diferença entre um JSP e um Servlet?
TÓPICO 2 – CONSTRUINDO UM FORMULÁRIO HTML.

Vamos agora construir a primeira página que será acessada pelo cliente em seu navegador e onde ele
cadastrará as informações que desejamos incluir no nosso banco de dados. Esta página consiste em HTML
puro, sem nenhuma surpresa como você poderá ver no Exemplo 1.
 <html>
 <head>
 <title>Cadastro de Aluno</title>
 </head>
 <body>
 <form name="form1" method="post" action="GravarAluno.jsp">
 Cadastro de Aluno<br>
 <br>
 Nome:
 <input type="text" name="Nome">
 <br>
 <br>
 Idade:
 <input type="text" name="Idade">
 <br>
 <br>
 <input name="Gravar" type="submit" id="Gravar" value="Gravar">
 </form>
 </body>
 </html>
Exemplo 1 – Formulário HTML para cadastro de Aluno.
Para facilitar o nosso exemplo de cadastro, utilizamos a mesma estrutura de tabela criada na unidade 4.
Como você pode ver, o campo aluno tem apenas duas informações. A estrutura HTML é simples. Embora não
seja o objetivo desse estudo, vamos apenas dar uma breve descrição das tags em HTML. A estrutura das
linhas de 1 a 5 é um cabeçalho básico das tags HTML que são finalizadas na linha 19 e 20. Nas linhas 6 a 18 é
onde você digita o conteúdo de sua página entre as tags <body>. Na linha 6 é definida a tag de formulário
<form> com os parâmetros que definem que o envio do formulário será através do método post para a página
GravarAluno.jsp. Nas linhas 10 e 14, são definidas as tags <input> que guardarão as informações digitadas
pelo usuário nas variáveis Nome e Idade, respectivamente. A linha 17 é um botão que enviará os dados para a
página configurada no formulário assim que clicado. O resultado visual deste exemplo pode ser verificado na
Figura 3.
_________________________________________________________________________________________________
___________________________________________________________________________________________________________________________________________________________________________________________________

Figura 3 – Formulário HTML
Qual a utilidade de um formulário criado em HTML para um JSP?
TÓPICO 3 – CONSTRUINDO UM JAVABEAN.

Um Bean é simplesmente uma classe em java que segue um conjunto de convenções simples de
nomeações de seus métodos de acordo com a especificação de Javabeans. Eles não deixam de ser um simples
objeto em java, mas como seguem um padrão fica mais fácil de manipulá-los.
Um JavaBean é criado para que um JSP abstraia algumas

declarações de código que seriam necessárias ao manipular as
informações de uma classe. Isto significa que automaticamente o
JSP busca alguns métodos padrões que deverão conter em um
JavaBean sem que você precise escrevê-los no código,
otimizando e facilitando a programação.
Para explicarmos algumas convenções desse padrão, vamos

analisar o Exemplo 2, que descreve um Bean criado para o aluno,
que será utilizado no arquivo JSP do próximo tópico.
1. package beans;
2. public class BeanAluno {
3. private String nome;
4. private int idade;
5.
6. public BeanAluno() {
7. nome = "";
8. idade = 0;
9. }
10. public String getNome() {
11. return nome;
12. }
13. public int getIdade() {
14. return idade;
15. }
16. public void setNome(String valor) {
_________________________________________________________________________________________________
___________________________________________________________________________________________________________________________________________________________________________________________________

17. nome = valor;

18. }
19. public void setIdade(int valor) {
20. idade = valor;
21. }
22. public boolean Gravar(){
23. //Validar os campos e
24. //Gravar no banco de dados
25. return true;
26. }
27.
28. }
Exemplo 2 – JavaBean para o cadastro Aluno.
Na linha 1 do Exemplo 2 definimos um pacote que conterá todos os nossos beans que seguem esta
convenção JavaBean. Como você pode ver na linha 2, associaremos sempre a palavra bean ao nome da classe
apenas para facilitar a identificação de que a classe segue este modelo. As propriedades, linhas 3 e 4, devem
ser declaradas como privadas. E para cada propriedade haverá um método público com o prefixo get e set
seguido pelo nome da propriedade específica. Somente através dele você poderá acessar ou setar as
informações da classe. Linhas 10 a 21. A linha 6 do nosso exemplo define o constructor da classe bean que
não deve conter argumentos para que seja devidamente acessado por um JSP. No método descrito na linha 22
implementaríamos a validação dos campos e a gravação no banco de dados utilizando as técnicas já abordadas
no estudo da unidade 4 que trata do registro no banco de dados. Para simplificar, fixamos o retorno à função
gravar true, pois não implementamos a gravação ao banco de dados.
Através das informações apresentadas neste tópico defina com suas

palavras o que é um JavaBean?
TÓPICO 4 – CONSTRUINDO UM JSP.

Agora vamos finalmente construir nosso primeiro programa em JSP. O arquivo GravarAluno.jsp
descrito no Exemplo 3 implementa o nosso último arquivo.
1. <%@page pageEncoding="UTF-8" contentType="text/html; charset=UTF-8" %>
2. <%@ page import="beans.BeanAluno" %>
3. <html>
4. <head>
5. <title></title>
6. </head>
7. <body>
8. <jsp:useBean id="aluno" class="beans.BeanAluno" scope="request">
9. <jsp:setProperty name="aluno" property="nome"
10. value=’<%=request.getParameter("nome")%>’ />
11. <jsp:setProperty name="aluno" property="idade" />
12. <%
13. aluno.setIdade(request.getParameter("idade"));
14. %>
15.
16. <%
17. if (aluno.Gravar()) {
18. %>
19. <jsp:forward page="/sucesso.jsp"/>
_________________________________________________________________________________________________
___________________________________________________________________________________________________________________________________________________________________________________________________

20. <%
21. } else {
22. %>
23. <jsp:forward page="RetryMidia.jsp" />
24. <%
25. }
26. %>
27. </jsp:useBean>
28. </body>
29. </html>
Exemplo 3 – Construindo um JSP – GravarAluno.jsp.
O atributo import da diretiva page, linha 2, estende o conjunto de classes Java que podem ser
referenciadas em uma página JSP sem ter que especificar o nome dos pacotes. A tag <jsp:useBean> referencia
a classe que você vai usar no momento. A linha 8 define o Bean a ser usado pelo parâmetro
class=“beans.BeanAluno” o id é o apelido que o JSP vai referenciar essa classe que, neste caso, foi definido
como “aluno”. O atributo escopo define por quanto tempo esse bean estará disponível. Os valores podem ser
page, request, session e application. As linhas 9 e 10 utiliza a tag <jsp:setProperty>. O parâmetro name desta
tag referencia o apelido atribuído ao bean na linha 9 e define para a parâmetro property o valor ”nome”, ele é
o atributo existente no bean que receberá o que estiver listado no parâmetro value desta tag:
value=’<%=request.getParameter("nome")%>’. Request.getParameter(“nome”) acessa as informações
postadas na página HTML que chamou o seu arquivo JSP, neste exemplo, ele busca a informação passada em
nome. A linha 11 faz a mesma coisa que as linhas de 12 a 14. Eles foram colocados apenas para ilustrar as
duas outras maneiras de setar as informações do seu bean. A primeira, linha 11, é a mais simples e ela só
funciona se o nome da variável HTML do formulário for igual ao atributo do bean, fazendo assim a
associação automaticamente. A segunda maneira acessa diretamente o comando das classes para setar as
informações. Fechamos a utilização da tag na linha 15. Da linha 17 à 25, utilizamos o método gravar do nosso
bean e através do retorno da função exibimos uma página de sucesso ou erro. Estes comandos são descritos
pela tag <jsp:forward> com o parâmetro page contendo a página para onde será enviado o navegador.
Pronto, finalizado esses arquivos, e colocando-os de acordo como definido na Figura 2, lembrando que
dentro de classes haverá uma pasta beans onde você gravará os seus beans criados, você poderá executar o seu
primeiro programa em JSP.
No próximo estudo iremos fazer utilizar todos os conhecimentos vistos até aqui, por isso, tome um
tempo para revisar todas as lições aprendidas e refazer os questionamentos de cada tópico.
Mostre as diversas maneiras que podemos atribuir um valor através da

página JSP a uma classe do tipo JavaBean.
_________________________________________________________________________________________________
___________________________________________________________________________________________________________________________________________________________________________________________________

NETO, R. H.; CURSO DE JSP. Florianópolis, Outubro de 2002.

deixados ao longo da unidade, representados pelo ícone?
Qual a diferença entre um JSP e um Servlet?
O JSP poderia ser considerado um aprimoramento do Servlet ou uma extensão, que apenas nos ajuda a
codificar melhor nossos serviços de uma maneira estruturada e organizada. O primeiro passo que o servidor
web executa ao carregar um JSP é a transformação dele em um servlet e então as operações solicitadas por ele.
Qual a utilidade de um formulário criado em HTML para um JSP?
Os formulários em HTML são a porta de entrada do usuário para carregar as informações que ele deseja
enviar ao servidor. Uma página html que estiver entre as tags <form></form> disponibiliza, através da
requisição post, todas as informações contidas em seus objetos de interação com o usuário. Isto possibilita que
uma página JSP, ou feita em qualquer outra linguagem para web, acesse os parâmetros e informações
digitadas pelo usuário.
Através das informações apresentadas neste tópico defina com suas palavras o que é um
JavaBean?
Um JavaBean é um objeto java criada principalmente para manipular as informações de entrada e

saída para um banco de dados mas que obedece uma regra na sua forma de construção que facilita a sua
manipulação através das páginas JSP.
Mostre as diversas maneiras que podemos atribuir um valor através da página JSP a uma
classe do tipo JavaBean.
A primeira maneira segundo o nosso exemplo é setando o atributo value com uma operação request
_________________________________________________________________________________________________
___________________________________________________________________________________________________________________________________________________________________________________________________

disponível em java
<jsp:setProperty name="aluno" property="nome"
value=’<%=request.getParameter("nome")%>’ />
Na segunda maneira podemos abstrair as informações dos nomes dos campos simplesmente por
sabermos estar tratando de um objeto do tipo bean. Por isso, a informação value não foi declarada, pois está
implícito na atribuição.
<jsp:setProperty name="aluno" property="idade" />
A terceira maneira é utilizarmos a própria operação do objeto sem utilizar as tags jsp. Esta seria a
maneira tradicional dentro de um servlet.
<%
aluno.setIdade(request.getParameter("idade"));
%>
1. Através deste nosso estudo, podemos completar o nosso sistema em JSP criando as páginas em HTML
para os cadastros de professor e aula. Cada página HTML deverá ter seu respectivo arquivo JSP e
JavaBean para cadastro no banco de dados.
2. Após criado todo o seu sistema em JSP, crie uma nova página que imprima a lista de salas disponíveis e,
através da seleção de uma sala, crie um JSP que acesse um JavaBean e imprima todos os alunos que
pertencem a ela.
_________________________________________________________________________________________________
___________________________________________________________________________________________________________________________________________________________________________________________________

UNIDADE VII
Programação Distribuída

Nos capítulos anteriores abordamos diversas técnicas utilizadas em programação distribuída. Neste
capítulo, estaremos analisando uma arquitetura criada para programação distribuída considerada uma evolução
dos conceitos e das técnicas estudadas até agora.
TÓPICO 1 – ARQUITETURA MVC

Com a crescente necessidade de se reaproveitar cada vez
mais o código de partes comuns nos sistemas criou-se o conceito
O que é uma
arquitetura de programação MVC (Model View Control). Este tipo de
MVC? programação facilita a utilização de antigas operações
implementadas, como transação bancária e consulta de CEP, sem
alterarmos uma linha de código nestes componentes prontos. A
técnica se baseia na separação de um sistema desenvolvido em 3
partes: Modelo, Visão e Controle. Para exemplificarmos melhor o
funcionamento desta arquitetura vamos imaginar uma empresa de
assistência técnica. O usuário leva o seu micro-computador para o
atendente da empresa que solicita as informações úteis para o
encaminhamento do seu computador à assi
assisstência. O técnico da assistência confere as informações e detecta o
problema do micro. Ele solicita as peças para o estoque ou para a empresa com a qual mantém serviços de
compra de acessórios de informática. O técnico instala as peças no micro e arruma o problema. Devolve ao
atendente, que por fim devolve ao cliente. A sequência destas atividades está diagramada na Figura 1.
Figura 1 – Arquitetura MVC em paralelo a uma empresa de Assistência
Como podemos ver, a camada de visão é a parte que interage com o cliente. Pode ser definida como a
_________________________________________________________________________________________________
PROGRAMAÇÃO DISTRIBUÍDA ‐ UNIDADE VII 2 87
___________________________________________________________________________________________________________________________________________________________________________________________________

tela apresentada solicitando os dados do usuário. Esta camada se preocupa apenas com a apresentação. A
classe controle é a responsável por saber o que fazer com as informações de entrada e qual a próxima tela a
camada de visão irá exibir para o usuário. Ela também interage com a camada modelo, onde se encontram as
informações estáticas da aplicação, o banco de dados. A camada modelo é que se preocupa em como interagir
com o banco de dados e em atender as solicitações específicas da camada controle. Assim como numa
assistência técnica, ela não precisa saber o que acontece nos outros departamentos, apenas consultar o banco
de dados, o estoque de produtos, e disponibilizar as peças de informações requisitadas.
Este novo modelo agiliza muito a programação, pois um usuário especialista em design não precisa mais
se preocupar com o código de programação; enquanto que um programador de banco de dados se preocupa
apenas em interagir de maneira segura e eficiente com o banco de dados na produção das informações. As
regras de negócio estão normalmente concentradas na camada de modelo, fazendo com que o
desenvolvimento dessa parte se atente apenas em como processar os dados para atender os pedidos dos
clientes.
Dê um outro exemplo prático para explicar a arquitetura MVC. Quais as

vantagens dessa tecnologia no quesito design para as aplicações?
TÓPICO 2 – ARQUTETURA J2EE

A arquitetura J2EE (Java 2 Enterprise Edition) é um conceito de programação em Java voltado para
programação multi-camada. E pode ser utilizada para a implementação do modelo MVC. Essa arquitetura em
java é escrita e compilada como qualquer programa java mas possui regras adicionais que visam a
programação distribuída. Isto acontece por tratar de acessar APIs de uma maneira padrão que funcione
independente do sistema operacional ou da plataforma em que esta sendo executado.
Figura 2 – Arquitetura J2EE
_________________________________________________________________________________________________
___________________________________________________________________________________________________________________________________________________________________________________________________

Na Figura 2 está exemplificado como podemos dividir as camadas de desenvolvimento na Arquitetura

J2EE. A programação nela é caracterizada principalmente pela componentização. Cria-se um componente
especializado em construir relatório, por exemplo, e se encapsula dentro da área de negócio. Na Figura 2, as
camadas principais podem ter subdivisões, como a camada de negócio que tem os componentes Web (JSP e
Servlet) e os componentes de negócios EJB. Esta figura não está seguindo o padrão da arquitetura MVC, pois
a camada de controle, que direciona as requisições, não foi contemplada.
A Figura 3 apresenta uma forma de implementar a arquitetura MVC em J2EE que normalmente é
chamada de “MVC 2.0” na arquitetura java.
Figura 3 – Arquitetura MVC em Java
Como podemos analisar na Figura 3, o funcionamento desse sistema começa quando o usuário requisita
um endereço, que já esta carregado nos serviços disponíveis, de um controller. Este controller define qual
View será apresentada ao cliente utilizando a função Forward. O cliente carrega o View (Página da camada
visão) e digita as informações solicitadas nesta camada. Este View contém o link do controller mediador que
responderá às requisições Post do cliente. Como você pode ver, o controller interage com a camada de
negócio, que por sua vez interage com a camada responsável pela manipulação do banco de dados. Eles
retornam as informações que deverão ser carregadas na próxima View e apresentadas ao cliente.
A arquitetura J2EE define os padrões EJB (Enterprise Java Beans) que é uma estruturação dos
componentes que são utilizados nas páginas JSP, como foi estudado na unidade anterior.
Assim, como você acabou de perceber, na Unidade 6 foi desenvolvido um programa utilizando a
arquitetura J2EE, no entanto, não segundo uma arquitetura MVC. Para atualizarmos o sistema segundo esse
modelo devemos criar um servlet que intermediará as requisições da página. Sendo assim, devemos alterar o
action do form do arquivo HTML para “servletcontrole.class” que está especificado no Exemplo 1 logo
abaixo:
_________________________________________________________________________________________________
___________________________________________________________________________________________________________________________________________________________________________________________________

 import javax.servlet.http.*;
 import javax.servlet.*;
 import javax.naming.*;
 import java.util.*;
 import java.io.IOException;
 import beans.BeanAluno;

 public class servletcontrole extends HttpServlet
 {
 protected void doPost(HttpServletRequest req,
 HttpServletResponse res)
 throws ServletException, IOException {
 try
 {
 BeanAluno clienteEJB;
 alunoEJB = new BeanAluno();
 alunoEJB.setNome(req.getParameter("Nome"));

 req.setAttribute("aluno", alunoEJB);
 req.getRequestDispatcher("/GravarAluno.jsp").forward(req, res);
 }
 catch(Throwable ex)
 {
 req.setAttribute("Mensagem de Erro", "Erro do EJB: " +
 ex.getMessage());
 req.getRequestDispatcher("/error.jsp").forward(req, res);
 }
 }
 }
Exemplo 1 – Servlet para a camada de controle
Este é um servlet de controle muito simples que não faz nada além de retransmitir o que uma página
requisitou para o devido código JSP. Mas nas linhas 15 a 17, embora esse código não produza nada de útil ao
nosso sistema, serviu apenas para que você pudesse saber que é possível executar algumas operações no
controler antes de encaminhar à próxima página para processamento, inclusive trabalhar com os Beans que
criamos. A linha 17 atribui ao nome da classe criada aluno o que foi recuperado da página HTML através do
comando: req.getParameter(“Nome”). A linha 19 cria uma nova variável chamada aluno que conterá a classe
BeanAluno. Assim, no momento da chamada da linha 20, GravarAluno.jsp poderá recuperar três variáveis em
seu contexto: Nome, Idade e aluno; este último sendo uma classe bean.
Qual a vantagem de utilizar uma camada intermediária? Defina a camada a

que cada arquivo java pertence no modelo MVC 2.0.
TÓPICO 3 – APLICAÇÃO ORIENTADA A SERVIÇO E WEBSERVICE.

Após abordarmos os conceitos utilizados de MVC para melhorar a programação distribuída,
estamos prontos para dar o próximo passo que atualmente está na moda em programação
distribuída: SOA (Service Oriented Aplication).
_________________________________________________________________________________________________
___________________________________________________________________________________________________________________________________________________________________________________________________

SOA é um novo conceito de programação, que colabora com o modelo MVC e é direcionado
principalmente para integração de sistemas. Isto significa que, ao invés de construirmos componentes
específicos para nossa linguagem de desenvolvimento, construiremos componentes, que denominaremos aqui
de serviços, que possam ser utilizados por qualquer aplicação desenvolvida em qualquer linguagem.
SOA é na verdade apenas o conceito do funcionamento dessa comunicação, a implementação desse

conceito são os webservices. Eles implementam essa tecnologia utilizando o protocolo da internet como
comunicação e XML para definir todas as suas operações. Assim, podemos ter cada camada ou sub-camada de
nossa aplicação desenvolvida em uma linguagem diferente.
A implementação de um Webservice está descrita na Figura 4.
Figura 4 – Arquitetura WebService
Para cada webservice criado é gerado um WSDL que define a estrutura das funções e dos parâmetros
necessários para o webservice. Logo em seguida é registrado (UDDI) o serviço para que qualquer máquina
possa acessá-lo. Assim, um cliente primeiro busca o endereço do serviço que procura, preenche os parâmetros
segundo as determinações de WSDL e compila um pacote SOAP fazendo a solicitação diretamente para o
Webservice que responde utilizando o mesmo protocolo.
Com isso, ganhamos vantagens em nossos sistemas em obter serviços disponíveis na internet que podem
ser incorporados dentro do corpo de nosso programa. Um exemplo desse serviço é a consulta de CEP.
Atualmente, quase todas as linguagens dão suporte à criação de webservice em sua plataforma. No
próximo tópico abordaremos como criar este serviço em java.
Qual a utilidade de um Webservice? Dê exemplos de serviços que

poderiam ser disponibilizados utilizando esta tecnologia.
_________________________________________________________________________________________________
___________________________________________________________________________________________________________________________________________________________________________________________________

TÓPICO 4 – CONSTRUINDO UM WEBSERVICE.

Agora, para desenvolvermos nossa aplicação, vamos pensar num modelo bem simples para que se
entenda o que se está construindo.
Figura 5 – Programando Webservices.
Temos então três passos para seguir durante a construção desse sistema. Primeiro, haverá uma aplicação
que será mostrada ao cliente e que acessará um webservice dando uma resposta visual ao cliente. Depois
teremos a criação do webservice e, por fim, a criação dos arquivos em java que acessam o banco de dados de
nossa aplicação.
CRIANDO O ACESSO AO BANCO

Agora vamos aplicar os conceitos que aprendemos de acesso ao banco de dados de uma maneira
organizada para o nosso sistema. Ele será composto de 2 tipos de arquivos: Um arquivo do tipo Bean e um
arquivo do tipo DAO (Direct Access Object – nele digitaremos os comandos SQL para acessar o banco).
Para o acesso aos dados de Aluno vamos criar uma classe BeanAluno.java e DAOAluno.java.
Considerando ainda que poderíamos ter várias classes para cada cadastro, alguns comandos, como conexão e
desconexão, iriam se repetir muito, por isso convencionou-se criar mais uma classe para encapsular estes
comandos chamada DAOConexao.java. Os arquivos estão descritos logo a seguir:
package dao;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.Statement;
public class DAOConexao {
static Connection conexao;
public DAOConexao() {
String driver = "com.mysql.jdbc.Driver";
_________________________________________________________________________________________________
___________________________________________________________________________________________________________________________________________________________________________________________________

String ulr = "jdbc:mysql://localhost:3306/teste";
String login = "root";
String senha = "";
try {
Class.forName(driver);
DAOConexao.conexao = DriverManager.getConnection(ulr, login,

senha);
System.out.println("Conexão Bem Sucedida");
} catch (Exception e) {
e.printStackTrace(); //nesta linha é impresso o erro!
public void executa(String sql)throws Exception{
Statement st = null;
st = DAOConexao.conexao.createStatement();
st.executeUpdate(sql);
public void desconecta()throws Exception {
DAOConexao.conexao.close();
Exemplo 2 – DAOConexao.java
package dao;
import java.sql.Connection;
import beans.BeanAluno;
public class DAOAluno {
Connection conexao;
_________________________________________________________________________________________________
___________________________________________________________________________________________________________________________________________________________________________________________________

public void insere(BeanAluno aluno) throws Exception{
DAOConexao conexao = new DAOConexao();
conexao.executa("INSERT INTO Aluno(Nome,Idade) VALUES ('"+
aluno.getNome()+"','"+aluno.getIdade()+"')");
conexao.desconecta();
Exemplo 3 – DAOAluno.java
package beans;
import dao.DAOAluno;
public class BeanAluno {
private String nome;
private int idade;
public BeanAluno() {
nome = "";
idade = 0;
public String getNome() {
return nome;
public int getIdade() {
return idade;
public void setNome(String valor) {
nome = valor;
public void setIdade(int valor) {
_________________________________________________________________________________________________
___________________________________________________________________________________________________________________________________________________________________________________________________

idade = valor;
public boolean Inserir() throws Exception{
DAOAluno aluno = new DAOAluno();
aluno.insere(this);
return true;
Exemplo 4 – BeanAluno.java
A implementação destas 3 classes não apresenta nenhuma novidade em nosso assunto, apenas tivemos o
cuidado de organizá-las melhor em classes diferente usando as relações de classe para acessá-la. O nosso
BenAluno.java ainda continua semelhante ao da unidade anterior, exceto pelo fato do procedimento inserir,
agora, interagir com a classe DAOAluno.java para que ela manipule o banco de dados.
CRIANDO O SERVIÇO
Para se criar um webservice teríamos que além de criar o arquivo em java, criar o WSDL que especifica
o corpo do serviço e criar o link UDDI do serviço disponível. Este é um trabalho cansativo, por isso foram
desenvolvidos alguns frameworks para facilitar a parte que corresponde ao WSDL e UDDI. Este framework,
chamado Axis, pode ser baixado no seguinte endereço: http://ws.apache.org/axis/. Descompacte o arquivo e
copie a pasta axis que se encontra dentro desse arquivo em webapps para a subpasta webapps da pasta onde
foi instalado o seu Tomcat. Teste o seu servidor acrescentando a subpasta axis na URI: http://localhost/axis.
Se tudo estiver certo, uma página com informações do AXIS aparacerá.
Agora vamos criar nosso webservice e disponibilizá-lo para utilização na internet.

import beans.BeanAluno;
public class Aluno {
public String gravar(String nome, int idade) throws Exception{
BeanAluno aluno = new BeanAluno();
aluno.setNome(nome);
aluno.setIdade(idade);
aluno.Inserir();
return "Gravou";
public String pesquisa(String nome){
_________________________________________________________________________________________________
___________________________________________________________________________________________________________________________________________________________________________________________________

return "(Implemente você)";
Exemplo 4 – Aluno.java
Agora, renomeie o arquivo Aluno.java para Aluno.jws e copie-o para a pasta axis do Tomcat. Para
verificar se o serviço foi instalado é só digitar: http://localhost/axis/Aluno.jws e aparecerá um link
descrevendo o WSDL do seu serviço. Agora você deverá copiar as pastas beans e dao, que são os pacotes
onde estão criados os seus arquivos de acesso de banco de dados, para dentro da pasta classes do axis.
Reinicie o apache e Execute o seguinte comando no seu navegador para testar o procedimento gravar do seu
webservice:

http://localhost:8080/axis/Aluno.jws?method=gravar&nome=Marcio&idade=14
Se tudo correr bem alguns dizeres semelhantes a estes serão mostrados em sua tela:
<?xml version="1.0" encoding="UTF-8" ?>
- <soapenv:Envelope xmlns:soapenv="http://schemas.xmlsoap.org/soap/envelope/"
xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:xsi="http://www.w3.org/2001/XMLSchema-
instance">
- <soapenv:Body>
- <gravarResponse soapenv:encodingStyle="http://schemas.xmlsoap.org/soap/encoding/">
<gravarReturn xsi:type="xsd:string">Gravou</gravarReturn>
</gravarResponse>
</soapenv:Body>
</soapenv:Envelope>
Verifique se no seu banco de dados foi cadastrado um aluno chamado Marcio, de 14 anos, por esse teste
que fizemos. Agora você está pronto para a última camada: A interface com o usuário (Visão).
ACESSANDO O WEBSERVICE
Poderíamos muito bem nessa parte desenvolver um HTML igual à unidade 6 passando as
informações através de POST. Mas o nosso objetivo aqui é chamar o serviço disponível no corpo
de nossa página e obter o resultado ali mesmo, como se fosse um procedimento apenas. E se
_________________________________________________________________________________________________
___________________________________________________________________________________________________________________________________________________________________________________________________

chamássemos diretamente o webservice, a resposta seria apenas instruções em XML que deve ser
totalmente abstraído do usuário.
Antes de executar o seu arquivo em java, certifique-se que as biliotecas Axis.jar e jaxrpc.jar
estejam disponíveis para seu programa. Como construiremos um jsp para acessar o webservice
deveremos colocar essas bibliotecas na pasta lib dentro de WEB-INF do tomcat,
c:\tomcat\webapp\root\WEB-INF\lib.
1. <%@page pageEncoding="UTF-8" contentType="text/html; charset=UTF-8" %>

2. <%@ page import="org.apache.axis.client.Call"%>
3. <%@ page import="org.apache.axis.client.Service"%>
4. <html>
5. <head>
6. <title></title>
7. </head>
8. <body>
9.
10. <%
11. String urlWS = "http://localhost:8080/axis/Aluno.jws";
12. Object[] params = {new String("Frajunilda"), new Integer(23)};
13.
14. Service service = new Service();
15. Call call = (Call) service.createCall();
16. call.setTargetEndpointAddress(urlWS);
17. call.setOperationName("gravar");
18. String ret = (String) call.invoke(params);
19. out.println("Resultado: " + ret);
20.
21. %>
22.
23. <%
24.
25. %>
26.
27. </body>
28. </html>
Coloque este arquivo na raiz do seu servidor web: c:\tomcat\webapps\ROOT. Quando você executar o
arquivo descrito no Exemplo 5, ele inserirá um novo registro no banco de dados utilizando o seu webservice e
retornará a mensagem do webservice diretamente no seu navegador.
As novidades estão concentradas nesse último arquivo do nosso sistema. Para acessarmos as funções de
serviço e de chamada acrescentamos duas bibliotecas da linha 2 e 3 para que possamos trabalhar com o
webservice. Nas linhas 12 e 13, definimos o link onde se encontra o nosso webservice e os parâmetros que ele
necessita para trabalhar, respectivamente. Nas linhas 14 e 15, criamos o canal para acessar o serviço. Nas
linhas 16, 17 e 18, fizemos a chamada do link da página, informamos o procedimento e solicitamos a resposta
através dos parâmetros passados pelo comando call.invoke(params). Na linha 19, imprimimos o resultado
obtido do webservice no browser da internet.
_________________________________________________________________________________________________
___________________________________________________________________________________________________________________________________________________________________________________________________

Explique como funciona o processo para se acessar um serviço disponível

na internet.
NETO, R. H.; CURSO DE JSP. Florianópolis, Outubro de 2002.

deixados ao longo da unidade, representados pelo ícone?
Dê um outro exemplo prático para explicar a arquitetura MVC. Quais as vantagens dessa
tecnologia no quesito design para as aplicações?
Um exemplo para explicar a arquitetura MVC é o call center. Diversos clientes ligam no call center para
realizar as suas reclamações: Camada de Visão. O call center leva as reclamações para o seu supervisor que
decide o que fazer com elas: Camada de Controle. O supervisor determina os serviços a serem feitos, os
funcionários responsáveis e o próximo contato com o cliente. Todo esse processo pode ser considerada a
camada Modelo.
Nem sempre os bons programadores tinham paciência para desenvolver um design atraente para o
usuário além de não terem muita experiência em combinar cores e telas. Por outro lado, pessoas que eram
especialistas em design tinham muito trabalho em arrumar uma página que era misturada de códigos, ou
dependiam muito dos programadores para poder terminar o seu trabalho. Com essa divisão de camada, design
e programadores podem programar ao mesmo tempo, sem necessidade de misturar suas matérias,
estabelecendo apenas uma planejamento de interação entre eles, que será definido pela camada de controle da
aplicação. Isto resulta em mais qualidade e eficiência na interface com usuário.
Qual a vantagem de utilizar uma camada intermediária? Defina a camada que cada arquivo
java pertence no modelo MVC 2.0.
A vantagem de se utilizar uma camada intermediária é poder primeiramente desmembrar qualquer
_________________________________________________________________________________________________
___________________________________________________________________________________________________________________________________________________________________________________________________

função problemática do sistema a qualquer momento sem nenhum retrabalho. A possibilidade de mudar
versões de componentes, melhoramentos, sem incomodar a parte visual do sistema. Utilizar recursos externos,
de outros servidores web, e ao mesmo tempo, poder escolher qual serviço utilizar dependendo da
disponibilidade.
Os arquivos, na nossa arquitetura, utilizados na camada Visão: JSP e HTML.
Camada Controle: Servlets
Camada Modelo: JavaBeans, JDBC, Bibliotecas (Jar).
Qual a utilidade de um Webservice? Dê exemplos de serviços que poderiam ser

disponibilizados utilizando esta tecnologia.
O Webservice é um serviço que pode ser compartilhado com qualquer sistema de qualquer linguagem de
programação pela internet. Isto concentra as especializações de serviços úteis por cada sistema e agiliza o
desenvolvimento de novos sistemas tendo como base serviços já criados. Os muitos serviços que podem ser
disponibilizados por eles são: temperatura e clima; posição geográfica no GPS; consulta CEP; Consulta
SERASA; Autenticação bancária; e etc.
Explique como funciona o processo para se acessar um serviço disponível na internet.
Primeiramente são consultados no servidor UDDI os serviços registrados. Através dele acessamos o
WSDL do serviço escolhida para sabermos as funções existentes e os parâmetros de que ele necessita, assim
como a resposta a ser retornada. Criamos o nosso cliente para acesso a esse serviço com as informações
obtidas e nos comunicamos através do protocolo SOAP diretamente com o Webservice que nos retorna em
XML as informações que solicitamos.

1. Crie um webservice que funcione como uma calculadora, fazendo operações de divisão, multiplicação e
potenciação.
2. No nosso Exemplo 4, a função pesquisa não foi implementada. Desenvolva esta operação e acrescente em
todos os arquivos os dados necessários para que, através do código informado, você obtenha o nome do
aluno no seu browser da internet.
_________________________________________________________________________________________________

4º Semestre - Tecnologia Cliente - Servidor PDF

Enviado por

Dados do documento

Descrição original:

Título original

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

4º Semestre - Tecnologia Cliente - Servidor PDF

Enviado por

Direitos autorais:

Formatos disponíveis

Tecnologia Cliente - Servidor

CURSO SUPERIOR DE TECNOLOGIA EM

GUIA DE ESTUDO DA DISCIPLINA

Luis Inácio Lula da Silva

Carlos Eduardo Bielschowsky

Jorge Almeida Guimarães

Celso José da Costa

INSTITUTO FEDERAL DE EDUCAÇÃO, CIÊNCIA

José Bispo Barbosa

Willian Silva de Paula

Alexandre José Schumacher

Vinícius de Matos Rodrigues

Flaviana Abdo Esteves

Luisa do Amparo Carvalho Patatas

Tenha um excelente ano letivo!

Prof. MSc Nelcileno Virgílio de Souza Araújo

Desenvolver no aluno a competência em implementar aplicações na tecnologia cliente servidor e

3. DEFINIÇÃO DAS UNIDADES (TEMAS)

Unidade 1 – Conceitos Fundamentais sobre a Tecnologia Cliente-Servidor

Unidade 2 – Programação e Desenvolvimento de Aplicações com Threads

Unidade 3 – Programação e Desenvolvimento de Aplicações com Sockets

Unidade 4 – Programação e Desenvolvimento de Aplicações com conexões de Banco de Dados

Unidade 6 – JavaServer Pages (JSP)

Unidade 7 – Aplicações Multicamadas

TÓPICO 1 – INTRODUÇÃO A SISTEMAS DISTRIBUÍDOS

É um conjunto de computadores independentes que se apresenta a seus usuários

Figura 1 – Sistema distribuído organizado como middleware.

E então, você compreendeu o que é um sistema distribuído e qual é o

TÓPICO 2 – TIPOS DE SISTEMAS DISTRIBUÍDOS

Figura 2 – Computação distribuída

Nos sistemas de informações distribuídos, o foco da aplicação é gerencial. Há a necessidade de que as

A Figura 3 apresenta um tipo de solução utilizada em sistemas de informações distribuídos, que é a

Aplicação Aplicação Aplicação

Figura 3 – Middleware como facilitador de comunicação em integração de aplicações corporativas

Figura 4 – Casa inteligente

Para finalizar, faço uma pergunta:

Uma aplicação cliente-servidor se enquadra em qual dos tipos de sistemas

TÓPICO 3 – ARQUITETURAS DE SOFTWARE EM UM SISTEMA DISTRIBUÍDO

Figura 5 – Aplicação cliente-servidor.

Se a arquitetura cliente-servidor possui uma organização centralizada de serviços. O modelo peer-to-

Figura 6 – Aplicação peer-to-peer.

Finalmente, a arquitetura híbrida congrega características de uma aplicação cliente-servidor e peer-to-

Qual a relação existente entre a tecnologia cliente-servidor e sistemas

Figura 7 – Aplicação híbrida

TÓPICO 4 – PRINCÍPIOS DA TECNOLOGIA CLIENTE-SERVIDOR

O modelo de camadas é o estilo arquitetônico mais comumente usado na tecnologia cliente-servidor. As

Figura 8 – Arquitetura em duas camadas.

Figura 9 – Arquitetura em três camadas.

Com a introdução da camada de aplicação, no modelo em três camadas, resolvemos o problema de

A idéia básica do modelo em 4 camadas é centralizar as funções de apresentação do aplicativo num

Figura 10 – Arquitetura em 4 camadas.

Figura 11 – Plataforma J2EE

Depois que estudamos as diversas formas de arquitetura cliente-servidor, me respondam:

Qual é a diferença de filosofia existente entre os diversos tipos de

ROCHA, C. A. de S. Análise de desempenho em ambientes cliente/servidor 2-camadas e 3-camadas.

Introdução e Motivação: Arquitetura em n camadas. Disponível em

Criando aplicações em 3, 4 ou n camadas. Disponível em

RESPOSTAS PARA AS AUTO-AVALIAÇÕES

Vamos então ver se você respondeu aos questionamentos

E então, você compreendeu o que é um sistema distribuído e qual é o papel do middleware

O sistema distribuído agrega o poder computacional de diversos computadores, interligados em redes,

Uma aplicação cliente-servidor se enquadra em qual dos tipos de sistemas distribuídos