Aula03 Programacao de Redes de Computadores em Java PDF

Programaode
RedesdeComputadores
emJava
RafaelSantos
Material reescrito para os alunos da disciplina CAP312 Programao

de Redes de Computadores do programa de ps-graduao em
Computao Aplicada do Instituto Nacional de Pesquisas Espaciais
(INPE)
ltima modificao: 17 de junho de 2006

http://www.lac.inpe.br/rafael.santos
ii
Sumrio
1 Introduo 1
2 Programao Cliente-Servidor 1
2.1 Introduo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1
2.2 Conceitos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
3 Desenvolvimento de aplicaes cliente-servidor em Java 4
4 Clientes simples 8
4.1 Exemplo: Cliente de daytime . . . . . . . . . . . . . . . . . . . . . . 8
4.2 Exemplo: Cliente de echo . . . . . . . . . . . . . . . . . . . . . . . . 10
5 Servidores simples (requisies no-simultneas) 13

5.1 Exemplo: Servidor de strings revertidas . . . . . . . . . . . . . . . . . 13
5.2 Exemplo: Servidor e cliente de instncias de classes . . . . . . . . . . . 17
5.3 Exemplo: Servidor e cliente de nmeros aleatrios . . . . . . . . . . . 21
5.4 Exemplo: Servidor simples de arquivos . . . . . . . . . . . . . . . . . 25
6 Servidores para mltiplas requisies simultneas 31

6.1 O problema de mltiplas requisies simultneas . . . . . . . . . . . . 31
6.2 Linhas de execuo (threads) . . . . . . . . . . . . . . . . . . . . . . . 35
6.3 Exemplo: Servidor de nmeros aleatrios (para requisies simultneas) 39
7 Aplicaes baseadas em um servidor e vrios clientes 42

7.1 Exemplo: Servidor de jogo-da-velha . . . . . . . . . . . . . . . . . . . 43
8 Aplicaes baseadas em um cliente e vrios servidores 49

8.1 Exemplo: Cliente e servidores para clculo de integrais . . . . . . . . . 51
9 Mais informaes 58
Lista de Figuras
1 Algoritmo para leitura e processamento de uma string . . . . . . . . . . 5
2 Algoritmo para o servidor de strings . . . . . . . . . . . . . . . . . . . 5
3 Algoritmo integrado do cliente e servidor de strings . . . . . . . . . . . 6
4 Outro algoritmo integrado do cliente e servidores . . . . . . . . . . . . 7
5 Protocolo de comunicao entre o cliente e o servidor de daytime . . . 8
6 Protocolo de comunicao entre o cliente e o servidor de echo . . . . . 11
7 Protocolo de comunicao entre o cliente e o servidor de inverso de
strings . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
Rafael Santos Programao Cliente-Servidor Usando Java

iii
8 Exemplo de acesso ao servidor de strings invertidas usando telnet . . 17

9 Protocolo de comunicao entre o cliente e o servidor de instncias da
classe Livro . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
10 Protocolo de comunicao entre o cliente e o servidor de nmeros alea-
trios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
11 Protocolo de comunicao entre o cliente e o servidor de arquivos . . . 26
12 Protocolo de comunicao entre o cliente e o servidor de nmeros alea-
trios (segunda verso) . . . . . . . . . . . . . . . . . . . . . . . . . . 32
13 Posies para jogo e linhas vencedoras no jogo-da-velha . . . . . . . . 43
14 Protocolo de comunicao entre o servidor e os clientes de jogo-da-velha 44
15 Exemplo de interao entre um cliente (telnet) e servidor de jogo-da-
velha . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50
16 Clculo de uma integral usando parties e trapzios . . . . . . . . . . 51
17 Protocolo para aplicao que faz o clculo de uma integral . . . . . . . 53
Lista de Listagens
1 Cliente de daytime . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
2 Cliente de echo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
3 Servidor de strings invertidas . . . . . . . . . . . . . . . . . . . . . . . 13
4 A classe Livro . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
5 Servidor de instncias da classe Livro . . . . . . . . . . . . . . . . . . 18
6 Cliente para o servidor de livros . . . . . . . . . . . . . . . . . . . . . 20
7 Servidor de nmeros aleatrios . . . . . . . . . . . . . . . . . . . . . . 21
8 Cliente de nmeros aleatrios . . . . . . . . . . . . . . . . . . . . . . . 24
9 Servidor de arquivos . . . . . . . . . . . . . . . . . . . . . . . . . . . 26
10 Cliente de arquivos . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
11 Segunda verso do servidor de nmeros aleatrios . . . . . . . . . . . . 31
12 Segunda verso do cliente de nmeros aleatrios . . . . . . . . . . . . 34
13 Classe que representa um carro de corrida para simulao. . . . . . . . 35
14 Simulao usando instncias de CarroDeCorrida. . . . . . . . . . . . 36
15 Classe que representa um carro de corrida para simulao (herdando de
Thread). . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
16 Simulao usando instncias de CarroDeCorridaIndependente. . . . 38
17 Classe que implementa o servio de nmeros aleatrios . . . . . . . . . 40
18 Terceira verso do servidor de nmeros aleatrios . . . . . . . . . . . . 41
19 O servidor de Jogo-da-Velha . . . . . . . . . . . . . . . . . . . . . . . 45
20 O servidor de clculo de integrais . . . . . . . . . . . . . . . . . . . . 52
21 Uma linha de execuo para o cliente de clculo de integrais . . . . . . 55
22 O cliente de clculo de integrais . . . . . . . . . . . . . . . . . . . . . 57

1
1 Introduo
Este documento ilustra os conceitos bsicos de programao cliente-servidor usando
Java, usando protocolos, clientes e servidores desenvolvidos pelo programador. Para
melhor compreenso dos tpicos, alguns clientes simples para servidores j existentes
sero demonstrados.
Para a compreenso dos exemplos deste documento, o leitor deve ter os seguintes co-
nhecimentos tcnicos:
Conhecer algoritmos e a implementao de diversas estruturas de controle em Java
(condicionais, estruturas de repetio);
Programao orientada a Objetos usando a linguagem Java. Em especial neces-
srio compreender os conceitos de encapsulamento e herana, mecanismo de ex-
cees e o uso de mtodos estticos;
Conhecer alguns dos mecanismos de entrada e sada em Java (streams);
Conhecer conceitos bsicos do funcionamento de um computador ligado em uma
rede.
2 Programao Cliente-Servidor
2.1 Introduo
Consideremos os seguintes cenrios:
1. Precisamos executar uma aplicao especfica mas o computador ao qual temos

acesso no pode execut-la por uma razo qualquer (exemplos podem ser falta de
hardware adequado, como disco, processador ou memria; necessidade de acesso
a um hardware especfico para execuo do software, etc.).
2. Precisamos de uma informao para efetuar um processamento ou tomar uma de-
ciso, mas esta informao atualizada frequentemente. Existe um outro compu-
tador que tem a verso mais atual desta informao.
3. Precisamos executar uma tarefa usando computadores que precise de mediao,
ou seja, de uma maneira imparcial e independente de avaliar resultados. Frequen-
temente existiro vrias fontes de informao que precisam ser avaliadas, e em
muitos casos as fontes devem permanecer ocultas umas das outras.
4. Precisamos executar uma aplicao cujo tempo para concluso seria excessiva-
mente longo no computador ao qual temos acesso, e possivelmente muito longo
mesmo usando hardware mais eficiente.

2
5. Precisamos obter informaes que esto em algum outro computador (de forma
semelhante ao caso 2) mas no sabemos onde estas informaes esto localiza-
das. Sabemos, no entanto, que um outro computador contm um catlogo destas
informaes.
No caso do exemplo 1, poderamos emprestar o hardware necessrio sem precisar-

mos mudar fisicamente de lugar. Basta que exista a possibilidade de enviarmos a tarefa
para este computador remoto e receber o resultado. Um exemplo deste cenrio seria
a consulta a bancos de dados do Genoma, que so grandes e complexos demais para
serem reproduzidos em computadores pessoais.
O caso do exemplo 2 muito similar ao uso da Internet para acesso a informaes. O

exemplo mais claro o acesso a jornais on-line: como a informao modificada a
cada dia (ou, em alguns casos, o tempo todo), um usurio pode simplesmente recarre-
gar, atravs de uma pgina, a informao desejada atualizada. Um outro exemplo mais
simples seria de um registro global de tempo, que teria a hora certa em um computador
especial, e outros computadores poderiam acertar seus relgios internos usando a hora
fornecida por este computador especial.
Para o exemplo 3 podemos pensar em enviar as informaes ou resultados de diversas

fontes para um computador que tomaria a deciso assim que tivesse todas as fontes de
dados. A aplicao mais simples deste tipo de cenrio seriam jogos de computador,
onde cada jogador enviaria suas informaes (por exemplo, posies de um tabuleiro)
e o computador mediador decidiria se as jogadas foram vlidas e quem seria o vencedor.
Para o exemplo 4 podemos considerar uma soluo cooperativa: se o problema a ser re-
solvido puder ser dividido em vrios subproblemas menores independentes, poderamos
usar vrios computadores diferentes para resolver cada um destes pequenos problemas.
Um computador seria o responsvel para separar o problema em subproblemas, en-
viar estes subproblemas para diversos outros computadores e integrar o resultado. Um
exemplo deste tipo de cenrio a anlise de dados de genoma e proteoma, onde usu-
rios cedem parte do tempo de seus computadores para execuo de uma tarefa global.
No caso do exemplo 5, poderamos ter os computadores dos usurios consultando um

computador central que no contm informaes mas sabe quais computadores as con-
tm. Este computador central teria ento meta-informaes ou meta-dados, ou seja,
informaes sobre informaes. Este cenrio semelhante ao que ocorre em mecanis-
mos de busca na Internet, que no contm pginas com uma informao especfica mas
podem indicar quais computadores as contm.
Em todos estes casos, estaremos usando alguma variante de aplicao cliente-servidor,

onde parte do processamento dos dados feito do lado do cliente ou usurio que deseja

3
processar a informao; e parte processamento do lado do servidor, ou do computador

que capaz de processar ou obter a informao desejada. Em alguns casos teremos a
relao um cliente para um servidor (como nos cenrios 1 e 2), mas possvel considerar
arquiteturas onde existem vrios clientes para um servidor (cenrio 3), vrios servidores
para um cliente (cenrio 4) ou mesmo vrias camadas de servidores (cenrio 5). Em
todos estes casos podemos supor que os computadores esto conectados via rede local,
Internet ou outro mecanismo remoto qualquer.
2.2 Conceitos
Alguns conceitos cuja compreenso se faz necessria so listados a seguir.
Servidor o computador que contm a aplicao que desejamos executar via remota.
Servio uma aplicao sendo executada no servidor. Para cada tipo de servio (apli-
cao) pode ser necessrio ter um tipo de cliente especfico, capaz de realizar a
comunicao da forma adequada. comum usar os termos servio e servidor
para designar a aplicao a ser executada (ex. servidor de FTP).
Cliente a aplicao remota que far a comunicao e interao com o servio/servidor.
Endereo a informao da localizao de um computador em uma rede local ou na
Internet. Podem ser usados como endereos o nmero IP (Internet Protocol) do
computador ou um nome que possa ser resolvido por um servidor DNS (Domain
Name System).
Porta um endereo local em um computador conectado a uma rede, identificado por
um nmero nico. Todos os dados originados ou destinados a um computador
na rede passam pela conexo (geralmente nica) daquele computador, identificada
pelo seu endereo. Como vrias aplicaes podem estar enviando e recebendo
dados, necessrio um segundo identificador para que o computador saiba que
dados devem ir para cada aplicao. Este segundo identificador a porta, associada
com um servio.
Porta Bem Conhecida uma porta cujo nmero menor que 1024, e que corresponde
a servios bem conhecidos. Alguns exemplos so as portas 7 (servio echo), 13
(servio daytime), 21 (servio ftp) e 80 (servio http). Usurios comuns (isto ,
sem privilgios de administrao) geralmente no podem usar nmeros de portas
bem conhecidas para instalar servios.
Protocolo o dilogo que ser travado entre cliente e servidor1 . Este dilogo muito
importante quando vamos criar clientes e servidores especficos, pois dados devem
ser enviados do cliente para o servidor em uma ordem e formatos predeterminados.
1O termo protocolo mais conhecido para designar a maneira pela qual os dados sero recebidos e enviados entre cliente
e servidor; alguns exemplos mais conhecidos so TCP (Transmission Control Protocol) e UDP (User Datagram Protocol).

4
O protocolo define que partes do algoritmo que resolve o problema em questo

sero resolvidas pelo cliente, resolvidas pelo servidor ou enviadas de/para o cliente
e o servidor.
Socket o terminal de um canal de comunicaes de duas vias entre cliente e servidor.
Para que a comunicao entre cliente e servidor seja efetuada, o cliente e o servidor
criaro cada um um socket que sero associados um com o outro para o envio e
recebimento de informaes.
3 Desenvolvimento de aplicaes cliente-servidor em Java

Alguns dos exemplos comentados na seo 2.1 podem ser resolvidos com servidores e
clientes j existentes por exemplo, para receber notcias de um jornal basta usarmos
um navegador que acessar o servidor HTTP da empresa que mantm o jornal. Em mui-
tos casos, entretanto, teremos que escrever o servidor pois ele far tarefas especficas
que no so especialidade de servidores j existentes. Em alguns casos, tambm deve-
remos escrever um cliente especial pois o protocolo de comunicao com o servidor e
os tipos de dados que sero enviados e recebidos devem ter tratamento especial.
Uma aplicao cliente-servidor em Java segue um padro relativamente simples de de-

senvolvimento: a parte complexa determinar que parte do processamento ser feita
pelo cliente e que parte pelo servidor, e como e quando os dados devero trafegar entre
o cliente e o servidor. Imaginemos uma aplicao onde o cliente deva recuperar uma
linha de texto enviada pelo servidor (a linha de texto pode conter a hora local, uma
cotao de moeda, etc.). O algoritmo do cliente (mostrado como um fluxograma ou
diagrama semelhante a um diagrama de atividades de UML) seria como o mostrado na
figura 1.

5
Cliente
Incio
Abre conexo
L string
Processa a string
Fim
Figura 1: Algoritmo para leitura e processamento de uma string
O diagrama/algoritmo para o servidor o mostrado na figura 2.
Servidor
Incio
Aguarda conexo do cliente
Cria conexo
Envia string
Figura 2: Algoritmo para o servidor de strings
O algoritmo mostrado na figura 1 no est completo: aps o passo Solicita conexo a

aplicao deveria aguardar a conexo entre o cliente e servidor ser estabelecida antes de
ler a string enviada pelo servidor. Da mesma forma, o algoritmo do servidor (mostrado
na figura 2) no cria conexes e envia strings a qualquer hora: estes passos ocorrem em
resposta a solicitaes do cliente. Os dois algoritmos devem ento estar sincronizados
para a aplicao funcionar corretamente.
Para descrevermos a aplicao como um todo usando diagramas similares aos de ati-

6
Cliente Servidor
Incio Incio
Solicita conexo Aguarda conexo
Cria conexo
L string Envia string
Imprime String lida
Fim
Figura 3: Algoritmo integrado do cliente e servidor de strings
vidades2 devemos descrever os algoritmos lado a lado, inclusive registrando os passos

nos quais os algoritmos devem estar sincronizados. Para isto, basta mudar o fluxo dos
passos para incluir a dependncia de passos no cliente e servidor. Um algoritmo que
mostra as atividades do cliente e servidor ilustrando os passos que precisam ser sincro-
nizados mostrado na figura 3.
Um outro exemplo de diagrama simplificado que mostra a interao entre um cliente e

dois servidores mostrada na figura 4. Este algoritmo de uma aplicao hipottica na
qual um cliente verifica preos em dois servidores diferentes para comparao e deciso.
interessante observar no algoritmo da figura 4 que alguns passos poderiam estar em

ordem diferente sem afetar o funcionamento da aplicao como um todo. Por exemplo,
as conexes do cliente com os servidores poderiam ser estabelecidas uma logo aps a
outra assim como a leitura dos dados. Como no existe um tempo de processamento
grande entre o estabelecimento da conexo e a leitura dos dados, esta modificao no
causaria tempo de conexo sem uso desnecessariamente longo com o servidor.
2 Evitando usar as notaes de bifurcao e unio para manter os diagramas simples

7
Cliente Servidor 1 Servidor 2

Incio Incio
Cria conexo
L valor do produto Envia valor
Incio
Cria conexo
L valor do produto Envia valor
Processa informaes
Fim
Figura 4: Outro algoritmo integrado do cliente e servidores

8
4 Clientes simples
Veremos nesta seo alguns clientes simples para servios existentes3 . Estes clientes
so totalmente funcionais, e servem para demonstrar o uso das classes para comunica-
o entre clientes e servidores.
4.1 Exemplo: Cliente de daytime

O servio daytime registrado na porta 13 e retorna, quando conectado e solicitado,
uma string contendo a data e hora do servidor. O protocolo de comunicao com um
servidor destes , ento, muito simples: basta estabelecer a conexo, ler uma nica
string e encerrar a conexo. Este protocolo mostrado na figura 5.
Cliente Servidor
Incio Incio
Cria conexo
L string Envia string
Imprime String lida
Fim
Figura 5: Protocolo de comunicao entre o cliente e o servidor de daytime
No sistema operacional Linux, o servio daytime pode ser acessado com o aplicativo
telnet, que deve receber como argumentos o nome do servidor e o nmero da porta,
separados por espao (por exemplo, telnet localhost 13). Ao invs de acessar o
servio desta forma, vamos escrever uma aplicao em Java que o faa para ns. A
aplicao mostrada na listagem 1.
Listagem 1: Cliente de daytime
1 package cap312;
2 import java.io.BufferedReader;
3 import java.io.IOException;
3 Osservios utilizados nesta seo so servios padro do sistema operacional Linux, desabilitados por default. Para
computadores executando o sistema operacional Red Hat, verifique os arquivos no diretrio /etc/xinetd.d para habilitao
dos servios.

9
4 import java.io.InputStreamReader;
5 import java.net.Socket;
6 import java.net.UnknownHostException;
7
8 /**
9 * Esta classe implementa um cliente simples para o servio daytime (porta 13).
10 * A classe simplesmente cria um socket para um servidor (no exemplo,
11 * localhost) usando aquela porta, obtm um BufferedReader (usando um
12 * InputStreamReader a partir do InputStream da conexo) e l uma linha do
13 * servidor.
14 */
15 public class ClienteDeDaytime
16 {
17 public static void main(String[] args)
18 {
19 String servidor = "localhost";
20 // Tentamos fazer a conexo e ler uma linha...
21 try
22 {
23 Socket conexo = new Socket(servidor,13);
24 // A partir do socket podemos obter um InputStream, a partir deste um
25 // InputStreamReader e partir deste, um BufferedReader.
26 BufferedReader br =
27 new BufferedReader(
28 new InputStreamReader(conexo.getInputStream()));
29 String linha = br.readLine();
30 System.out.println("Agora so "+linha+" no servidor "+servidor);
31 // Fechamos a conexo.
32 br.close();
33 conexo.close();
34 }
35 // Se houve problemas com o nome do host...
36 catch (UnknownHostException e)
37 {
38 System.out.println("O servidor no existe ou est fora do ar.");
39 }
40 // Se houve problemas genricos de entrada e sada...
41 catch (IOException e)
42 {
43 System.out.println("Erro de entrada e sada.");
44 }
45 }
46 }
Os pontos interessantes e chamadas a APIs da listagem 1 so:
O primeiro passo do algoritmo (a criao de uma conexo) feita pela criao

de uma instncia da classe Socket. O construtor desta classe espera um nome
de servidor (ou o seu IP, na forma de uma string) e o nmero da porta para co-
nexo. A criao de uma instncia de Socket pode falhar, criando a exceo
UnknownHostException se o endereo IP do servidor no puder ser localizado ou
IOException se houver um erro de entrada ou sada na criao do socket.
Podemos obter uma stream de entrada a partir da instncia de Socket (usando o
mtodo getInputStream), e a partir desta stream podemos criar uma instncia de
InputStreamReader (que transforma os bytes lidos pela stream em caracteres). A

10
partir desta instncia de InputStreamReader (usando-a como argumento para o

construtor) podemos criar uma instncia de BufferedReader que pode ser usada
para ler linhas de texto completas.
O resto do processamento realmente simples, lemos uma string do servidor (na
verdade, solicitamos a leitura, e o servidor criar esta string para ser enviada
quando for requisitado), imprimimos a string lida e fechamos a stream e conexo.
Uma nota interessante sobre a aplicao mostrada na listagem 1: aps terminar a leitura
da string vinda do servidor, devemos manualmente fechar a conexo com o mesmo
(pois sabemos, de acordo com seu protocolo, que somente uma string ser enviada a
cada conexo). Se usarmos o aplicativo telnet para acessar este servio, o mesmo
automaticamente encerrar a conexo com o servidor.
4.2 Exemplo: Cliente de echo

Um servio ligeiramente mais complexo que o daytime o echo, que responde por co-
nexes na porta 7 e retorna cada string enviada pelo cliente de volta. O servidor reenvia
cada string enviada pelo cliente at que a string seja um sinal de trmino (o caracter de
controle Control+] no caso do cliente telnet) indicando o fim da interao. O cliente
precisa, ento, de um mecanismo que envie e receba dados do servidor, sendo que estes
dados vo ser somente texto (strings). A figura 6 ilustra o protocolo de comunicao
entre um cliente e um servidor de echo.
A diferena principal entre o diagrama mostrado na figura 6 e outros vistos anterior-

mente que este tem uma ramificao possvel (condicional), dependendo da entrada
do usurio um dos dois possveis caminhos ser tomado. Para a implementao em
Java, ao invs de usar o cdigo de controle do telnet, usaremos uma string composta
do caracter ponto (.). Se esta string for enviada, fecharemos a conexo com o servidor.
A implementao do cliente de echo mostrada na listagem 2.
Listagem 2: Cliente de echo
1 package cap312;
3 import java.io.BufferedWriter;
6 import java.io.OutputStreamWriter;
9
10 /**
11 * Esta classe implementa um cliente simples para o servio echo (porta 7).
12 * A classe simplesmente cria um socket para um servidor (no exemplo,

11
Cliente Servidor
Incio Incio
Cria conexo
L string do teclado
Sinal de trmino?
sim
no
Envia string para o servidor L string do cliente
L string do servidor Envia string para o cliente
Imprime string lida
Encerra conexo
Fim
Figura 6: Protocolo de comunicao entre o cliente e o servidor de echo
13 * localhost) usando aquela porta, obtm um BufferedReader (usando um

14 * InputStreamReader a partir do InputStream da conexo) e um BufferedWriter
15 * (usando um OutputStreamWriter a partir do OutputStream da conexo), e repete
16 * o seguinte lao:
17 * 1 - L uma string do teclado
18 * 2 - Envia esta string para o servidor
19 * 3 - L uma string do servidor
20 * 4 - Imprime a string lida do servidor
21 * Se a string entrada via teclado for igual a um ponto (".") o lao ser
22 * interrompido.
23 */
24 public class ClienteDeEcho
25 {
27 {
30 try
31 {

12

35 BufferedReader br =
36 new BufferedReader(
37 new InputStreamReader(conexo.getInputStream()));
38 // A partir do socket podemos obter um OutputStream, a partir deste um
39 // OutputStreamWriter e partir deste, um Bufferedwriter.
40 BufferedWriter bw =
41 new BufferedWriter(
42 new OutputStreamWriter(conexo.getOutputStream()));
43 // Executamos este lao "para sempre":
44 while(true)
45 {
46 // Lemos uma linha do console.
47 String linhaEnviada = Keyboard.readString();
48 // Se o usurio tiver digitado Cancel, samos do lao.
49 if (linhaEnviada.equals(".")) break;
50 // Enviamos a linha para o servidor.
51 bw.write(linhaEnviada);
52 bw.newLine();
53 bw.flush();
54 // Lemos uma linha a partir do servidor e a imprimimos no console.
55 String linhaRecebida = br.readLine();
56 System.out.println(linhaRecebida);
57 }
59 br.close();
60 bw.close();
61 conexo.close();
62 }
65 {
67 }
70 {
72 }
73 }
74 }
Os pontos interessantes da listagem 2 so:
Novamente o primeiro passo a criao de uma instncia da classe Socket, nova-

mente usando como exemplo o servidor localhost mas com a porta 7.
Como preciso enviar e receber strings do cliente para o servidor e vice-versa,
precisamos criar mecanismos para o envio e recebimento de strings. Isto feito
separadamente: para o recebimento de strings enviadas do servidor, obtemos uma
stream de leitura com o mtodo getInputStream da instncia de Socket, usa-
mos esta stream para criar uma instncia de InputStreamReader e usamos esta
instncia para criar uma instncia de BufferedReader. Similarmente, usamos
uma stream de escrita obtida com o mtodo getOutputStream da instncia de

13
Socket, para criar uma instncia de OutputStreamWriter e usamos esta instn-

cia para criar uma instncia de BufferedWriter.
Aps a criao das streams de entrada e sada, entramos no lao principal do cli-
ente, que recebe uma string do teclado, compara com a string de trmino, e se for
diferente, envia a string para o servidor, recebendo uma string de volta e repetindo
o lao. Notem que aps enviar uma string para o servidor, necessrio execu-
tar os mtodos newLine e flush da classe BufferedWriter para que os bytes
correspondentes string sejam realmente enviados.
Este exemplo usa a classe Keyboard para entrada de strings. Esta classe pode ser
copiada do site http://www.directnet.com.br/users/rafael.santos/4 .
5 Servidores simples (requisies no-simultneas)

5.1 Exemplo: Servidor de strings revertidas
Vamos ver um exemplo de servidor agora, ou seja, uma aplicao que vai enviar infor-
maes a um cliente. O cliente pode ser um aplicativo simples como o prprio telnet.
Considere que seja necessrio por algum razo inverter uma string. A inverso de uma
string a simples modificao da ordem de seus caracteres para que a mesma seja lida
ao contrrio, ou da direita para a esquerda. Como um exemplo, a inverso da string
Java seria avaJ. O algoritmo de inverso simples, basta criar uma string vazia e
concatenar a esta string cada caracter da string original, lidos de trs para frente.
O protocolo de comunicao entre um cliente e o servidor de strings invertidas mos-

trado na figura 7.
O diagrama mostra uma nfase no passo Inverte string pois este realiza o que, em
princpio, o cliente no saberia como ou teria recursos para processar. Em muitos ca-
sos de aplicaes cliente-servidor este passo seria o mais crucial: o processamento da
informao do lado do servidor.
A implementao do servidor de strings invertidas mostrada na listagem 3.
Listagem 3: Servidor de strings invertidas
1 package cap312;
4 Curiosamente,se usarmos o mtodo showInputDialog da classe JOptionPane, a aplicao no ser terminada correta-
mente para isso deveremos usar o mtodo System.exit ao final da aplicao.

14
Cliente Servidor
Incio Incio
Cria conexo
L string do teclado
Envia string para o servidor L string do cliente
Inverte string
L string do servidor Envia string para o cliente
Imprime string lida
Fim
Figura 7: Protocolo de comunicao entre o cliente e o servidor de inverso de strings
7 import java.net.BindException;
8 import java.net.ServerSocket;
10
11 /**
12 * Esta classe implementa um servidor simples que fica aguardando conexes de
13 * clientes. Quando uma conexo solicitada, o servidor recebe do cliente uma
14 * string, a inverte e envia este resuldado para o cliente, fechando a conexo.
15 */
16 public class ServidorDeStringsInvertidas
17 {
18 // Mtodo que permite a execuo da classe.
20 {
21 ServerSocket servidor;
22 try
23 {
24 // Criamos a instncia de ServerSocket que responder por solicitaes
25 // porta 10101.
26 servidor = new ServerSocket(10101);
27 // O servidor aguarda "para sempre" as conexes.

15
28 while(true)
29 {
30 // Quando uma conexo feita,
31 Socket conexo = servidor.accept();
32 // ... o servidor a processa.
33 processaConexo(conexo);
34 }
35 }
36 // Pode ser que a porta 10101 j esteja em uso !
37 catch (BindException e)
38 {
39 System.out.println("Porta j em uso.");
40 }
41 // Pode ser que tenhamos um erro qualquer de entrada ou sada.
43 {
44 System.out.println("Erro de entrada ou sada.");
45 }
46 }
47
48 // Este mtodo atende a uma conexo feita a este servidor.

49 private static void processaConexo(Socket conexo)
50 {
51 try
52 {
53 // Criamos uma stream para receber strings, usando a stream de entrada
54 // associado conexo.
55 BufferedReader entrada =
56 new BufferedReader(new InputStreamReader(conexo.getInputStream()));
57 // Criamos uma stream para enviar strings, usando a stream de sada
59 BufferedWriter sada =
60 new BufferedWriter(new OutputStreamWriter(conexo.getOutputStream()));
61 // Lemos a string que o cliente quer inverter.
62 String original = entrada.readLine();
63 String invertida = "";
64 // Invertemos a string.
65 for(int c=0;c<original.length();c++)
66 {
67 invertida = original.charAt(c)+invertida;
68 }
69 // Enviamos a string invertida ao cliente.
70 sada.write(invertida);
71 sada.newLine();
72 sada.flush();
73 // Ao terminar de atender a requisio, fechamos as streams de entrada e sada.
74 entrada.close();
75 sada.close();
76 // Fechamos tambm a conexo.
77 conexo.close();
78 }
79 // Se houve algum erro de entrada ou sada...
81 {
82 System.out.println("Erro atendendo a uma conexo !");
83 }
84 }
85 }
Existem vrios pontos interessantes na listagem 3, descritos a seguir:

16
Para comodidade e compreenso de tpicos intermedirios, a listagem foi dividida

em duas partes (dois mtodos): o mtodo main que representa o fluxo principal do
servidor (criao de sockets e lao principal) e o mtodo processaConexo que
ser responsvel por processar uma nica conexo com um cliente.
O mtodo main cria uma instncia de ServerSocket que ser responsvel por
aguardar conexes do cliente. Uma instncia de ServerSocket criada passando-
se para o seu construtor a porta na qual este servidor ir responder por conexes.
O mtodo main tambm contm um lao aparentemente infinito (while(true))
onde ficar aguardando conexes de clientes. Quando um cliente se conectar a
este servidor, o mtodo accept da classe ServerSocket criar uma instncia de
Socket para a comunicao com o cliente, e prosseguir a execuo do lado do
servidor. importante observar que enquanto o cliente no solicitar uma conexo,
o mtodo accept bloquear o processamento do servidor, como se a aplicao
estivesse pausada naquele ponto.
Assim que uma conexo do cliente for aceita, o mtodo processaConexo ser
executado, usando como argumento a instncia recm-criada da classe Socket,
correspondente conexo com o cliente.
Ainda no mtodo main temos os blocos catch responsveis pelo processamento
das excees que podem ocorrer neste mtodo: BindException que ser criada
caso o endereo desejado j esteja em uso e IOException que ser criada caso
ocorra algum erro de entrada e sada genrico.
O mtodo processaConexo ser responsvel por processar uma nica conexo
com este servidor, criada quando o mtodo accept foi executado. Este mtodo
criar streams para envio e recebimento de strings, conforme ilustrado e descrito
na seo 4.2. importante notar que a stream de entrada para o servidor ser as-
sociado stream de sada do cliente e vice-versa.
O mtodo processaConexo ento recebe uma string do cliente, a inverte com
um algoritmo simples e a envia para o cliente (garantindo que os bytes desta
string sero realmente enviados usando os mtodos newLine e flush da classe
BufferedWriter).
O mtodo processaConexo tambm processa em um bloco catch a exceo
IOException que pode ocorrer.
Para testar este servidor, um cliente simples como telnet ou mesmo a aplicao Cli-
enteDeEcho (listagem 2) modificada para usar a porta 10101 poderia ser usado. Um
exemplo de execuo de interao com o servidor de strings invertidas usando o telnet
mostrado na figura 8.

17
5.2 Exemplo: Servidor e cliente de instncias de classes

At agora vimos clientes que se comunicam com servidores conhecidos ou servidores
que podem usar clientes existentes como telnet Veremos agora um exemplo mais es-
pecfico que exige que tanto o cliente quanto o servidor sejam escritos especialmente
para atender ao protocolo de comunicao entre cliente e servidor (ou para poder rece-
ber e enviar dados que no sejam strings). Em outras palavras, o servidor ser diferente
dos existentes (echo, daytime) e o cliente no poder ser o telnet.
Vamos ver como podemos escrever um servidor para servir instncias de classes em
Java. O cliente tambm dever ser capaz de receber do servidor estas instncias. Vamos
usar a classe Livro (listagem 4) para criar as instncias que sero enviadas.
Listagem 4: A classe Livro
1 package cap312;
2 import java.io.Serializable;
3
4 public class Livro implements Serializable

5 {
6 private String ttulo;
7 private String autores;
8 private int ano;
9
10 public Livro(String t,String aut,int a)

11 {
12 ttulo = t;
13 autores = aut;
14 ano = a;
15 }
16
17 public void imprime()

18 {
19 System.out.println(ttulo+" ("+autores+"),"+ano);
20 }
21
22 }
Para que instncias de classes possam ser enviadas e recebidas por servidores e clien-
tes necessrio que elas sejam serializveis. Para isto, basta declarar a classe como
implementando a interface Serializable, sem precisar implementar nenhum mtodo
Figura 8: Exemplo de acesso ao servidor de strings invertidas usando telnet

18
adicional. A classe Livro (listagem 4) implementa esta interface.
O protocolo de comunicao entre o servidor e o cliente de instncias da classe Livro

bem simples, e similar a outros mostrados anteriormente. Este protocolo mostrado
na figura 9.
Cliente Servidor
Incio Incio
Cria conexo
L instncia de Livro Envia instncia de Livro
Executa mtodo da
instncia lida
Fim
Figura 9: Protocolo de comunicao entre o cliente e o servidor de instncias da classe Livro
O servidor de instncias da classe Livro segue o mesmo padro do servidor de strings

invertidas (listagem 3): a classe contm um mtodo main responsvel por criar o socket
do lado do servidor e atender a requisies dos clientes, que sero processadas pelo m-
todo processaConexo. Este mtodo cria uma stream do tipo ObjectOutputStream
para enviar uma das instncias da classe Livro contidas na estrutura coleo.
O servidor de instncias da classe Livro implementado na classe ServidorDeLivros,

mostrada na listagem 5.
Listagem 5: Servidor de instncias da classe Livro
1 package cap312;
3 import java.io.ObjectOutputStream;
7 import java.util.ArrayList;
8
9 /**

19
11 * clientes. Este servidor, quando conectado, envia uma instncia da classe

12 * Livro para o cliente e desconecta.
13 */
14 public class ServidorDeLivros
15 {
16 // Estrutura que armazenar uma coleo de livros (instncias da classe Livro).
17 private static ArrayList<Livro> coleo;
18

21 {
22 // Criamos uma coleo de livros.
23 coleo = new ArrayList<Livro> ();
24 coleo.add(new Livro("Java 1.4 Game Programming",
25 "Andrew Mulholland, Glen Murphy",2003));
26 coleo.add(new Livro("Developing Games In Java","David Bracken",2003));
27 coleo.add(new Livro("Java 2 Game Programming","Thomas Petchel",2001));
28 coleo.add(new Livro("Board And Table Games From Many Civilizations",
29 "R.C.Bell",1969));
30 coleo.add(new Livro("A Gamut Of Games","Sid Sackson",1969));
31 try
32 {
34 // porta 12244.
35 ServerSocket servidor = new ServerSocket(12244);
37 while(true)
38 {
43 }
44 }
45 // Pode ser que a porta j esteja em uso !
47 {
49 }
52 {
54 }
55 }
56

59 {
60 try
61 {
62 // Criamos uma stream para enviar instncias de classes, usando a stream
63 // de sada associado conexo.
64 ObjectOutputStream sada =
65 new ObjectOutputStream(conexo.getOutputStream());
66 // Escolhemos um livro aleatoriamente.
67 int qual = (int)(Math.random()*coleo.size());
68 sada.writeObject(coleo.get(qual));
69 // Ao terminar de atender a requisio, fechamos a stream de sada.
70 sada.close();

20
72 conexo.close();
73 }
76 {
78 }
79 }
80 }
Para acessar este servio, no podemos usar clientes como telnet: uma conexo feita
via telnet para o servidor executando esta aplicao retornaria strings com alguns ca-
racteres de controle (correspondente serializao de uma instncia da classe Livro)
que torna os resultados da interao praticamente inutilizveis. Precisamos de um cli-
ente especializado em receber e processar instncias da classe Livro.
O cliente para o servidor mostrado na listagem 5 tambm simples e similar a outros

clientes vistos anteriormente. A principal diferena que ao invs de usar uma ins-
tncia de BufferedReader para ler dados do servidor, iremos usar uma instncia de
ObjectInputStream. O cliente (classe ClienteDeLivros) mostrado na figura 6.
Listagem 6: Cliente para o servidor de livros
1 package cap312;
3 import java.io.ObjectInputStream;
6
8 /**
9 * Esta classe implementa um cliente simples para o servio de livros.
10 * Ele se conecta ao servidor (pela porta 12244) e recebe uma instncia da classe
11 * Livro enviada pelo servidor.
12 */
13 public class ClienteDeLivros
14 {
16 {
19 try
20 {
23 // ObjectInputStream.
24 ObjectInputStream dis = new ObjectInputStream(conexo.getInputStream());
25 Livro umLivro = (Livro)dis.readObject();
26 System.out.println("Livro obtido do servidor:");
27 umLivro.imprime();
29 dis.close();
30 conexo.close();
31 }

21
34 {
36 }
39 {
41 }
42 // Essa exceo poderia ocorrer se tivssemos o cliente sendo executado em
43 // outro computador e a classe Livro no tivesse sido distribuda.
44 catch (ClassNotFoundException e)
45 {
46 System.out.println("A classe Livro no est presente no cliente.");
47 }
48 }
49 }
Existe uma outra diferena entre este cliente e outros: este deve, obrigatoriamente, ter
um bloco catch para processar a exceo ClassNotFoundException, que ser criada
caso a classe cuja instncia desejamos recuperar no existir do lado do cliente. Embora
para finalidade de testes esta classe deva estar sempre presente, importante lembrar
que em aplicaes mais complexas o servidor pode enviar uma instncia de uma classe
que no exista no cliente quando a aplicao do lado cliente for distribuda para uso,
devemos sempre lembrar de incluir todas as classes que podem ser serializadas para
aquela aplicao.
5.3 Exemplo: Servidor e cliente de nmeros aleatrios

Consideremos como um outro exemplo um servidor que envie para o cliente um nmero
aleatrio5 entre zero e um, do tipo double. Embora qualquer computador que tenha a
mquina virtual Java possa facilmente obter nmeros aleatrios, podemos imaginar ra-
zes para fazer disto um servio: uma razo comum que o nmero deve ser coerente
com os enviados para outros clientes (no caso de jogos). O protocolo de comunicao
entre um cliente e um servidor de nmeros aleatrios mostrado na figura 10.
O protocolo de comunicao entre o cliente e servidor de nmeros aleatrios to sim-

ples quanto o protocolo de comunicao entre cliente e servidor de echo, de strings
invertidas ou de uma instncia de uma classe, a diferena que em vez de strings ou
instncias estaremos recebendo valores de um dos tipos nativos (no caso, double).
A implementao do servidor semelhante do servidor de strings invertidas ou de

instncias da classe Livro. O cdigo-fonte do servidor mostrado na listagem 7.
Listagem 7: Servidor de nmeros aleatrios
5 OK, so pseudo-aleatrios, mas para as finalidades deste documento vamos ignorar a diferena entre nmeros realmente
aleatrios e os gerados pelo mtodo Math.random.

22
Cliente Servidor
Incio Incio
Cria conexo
L double Envia double
Imprime valor lido
Fim
Figura 10: Protocolo de comunicao entre o cliente e o servidor de nmeros aleatrios
1 package cap312;
2 import java.io.DataOutputStream;
7
8 /**
10 * clientes. Quando uma conexo solicitada, o servidor envia para o cliente
11 * um nmero aleatrio e fecha a conexo.
12 */
13 public class ServidorDeNumerosAleatorios
14 {
17 {
19 try
20 {
22 // porta 9999.
25 while(true)
26 {
31 }
32 }

23

35 {
37 }
40 {
42 }
43 }
44

47 {
48 try
49 {
50 // Criamos uma stream para enviar valores nativos, usando a stream de sada
52 DataOutputStream sada =
53 new DataOutputStream(conexo.getOutputStream());
54 double rand = Math.random();
55 sada.writeDouble(rand);
56 // Para demonstrar que realmente funciona, vamos imprimir um log.
57 System.out.println("Acabo de enviar o nmero "+rand+" para o cliente "+
58 conexo.getRemoteSocketAddress());
60 sada.close();
62 conexo.close();
63 }
66 {
68 }
69 }
70 }
O cdigo-fonte do servidor segue praticamente os mesmos passos do servidor de strings

invertidas (listagem 3) exceto pela criao da classe que ser responsvel pelo envio
dos dados do servidor para o cliente. Usaremos, para este servidor, a instncia de
OutputStream retornada pelo mtodo getInputStream da classe Socket para criar
uma instncia da classe DataOutputStream. Para instncias desta classe no neces-
srio enviar terminadores de linhas nem executar mtodos que forcem o envio dos bytes.
Um ponto de interesse no cdigo do servidor (listagem 7) que quando um nmero ale-

atrio enviado para o cliente, uma mensagem impressa no terminal onde o servidor
est sendo executado. Isso facilita a depurao do servidor, caso seja necessrio, e serve
como ilustrao da criao de arquivos de registro (logs) como feito com servidores
mais complexos.
O servidor de nmeros aleatrios est pronto para receber conexes pela porta 9999,
mas os clientes existentes no so capazes de receber bytes correspondentes a valores

24
do tipo double: se executarmos o comando telnet localhost 9999 o mesmo re-

tornar caracteres sem sentido. Precisamos de um cliente especfico para este tipo de
servio.
Um cliente adequado para receber um nico valor do tipo double de um servidor

mostrado na listagem 8. Novamente a diferena entre um cliente que processa strings,
como ClienteDeEcho (listagem 2) o tipo de classe que ser criado usando as streams
de entrada e sada obtidas da classe Socket. No caso do cliente, usamos uma instncia
de DataInputStream criada a partir do InputStream obtido pelo mtodo getInput-
Stream da classe Socket.
Listagem 8: Cliente de nmeros aleatrios
1 package cap312;
2 import java.io.DataInputStream;
6
8 /**
9 * Esta classe implementa um cliente simples para o servio de nmeros aleatrios.
10 * Ele se conecta ao servidor (pela porta 9999) e recebe um nmero aleatrio
11 * gerado no servidor.
12 */
13 public class ClienteDeNumerosAleatorios
14 {
16 {
19 try
20 {
23 // DataInputStream.
24 DataInputStream dis = new DataInputStream(conexo.getInputStream());
25 double valor = dis.readDouble();
26 System.out.println("Li o valor "+valor+" do servidor "+servidor+".");
28 dis.close();
29 conexo.close();
30 }
33 {
35 }
38 {
40 }
41 }
42 }

25
5.4 Exemplo: Servidor simples de arquivos

Vamos considerar mais um exemplo de aplicao cliente-servidor, onde o tipo de dados
e seu processamento ser diferenciado durante a execuo do protocolo de comunica-
o. Consideremos um servidor extremamente simples de arquivos, similar a um ser-
vidor de FTP mas com boa parte da funcionalidade (ex. acesso a diferentes diretrios,
autenticao de usurios) removida. Durante a interao com o cliente, este servidor
ter que se comunicar enviando e recebendo strings (comandos, listas de arquivos, etc.)
que sero impressas no terminal e tambm enviando bytes que sero gravados em um
arquivo pelo cliente.
O protocolo de comunicao entre o servidor e o cliente simples: o servidor envia para

o cliente a lista de arquivos, o cliente seleciona um, o servidor envia os bytes daquele
arquivo para o cliente que armazena estes bytes em um arquivo local. Este protocolo
ilustrado na figura 11.
A implementao do servidor de arquivos feita na classe ServidorDeArquivos, que

mostrada na listagem 9.

26
Cliente Servidor
Incio Incio
Cria conexo
Imprime lista de arquivos Envia lista de arquivos locais
L nome do arquivo
Seleciona arquivo e envia
selecionado
L contedo do arquivo Envia contedo do

selecionado arquivo selecionado
Armazena contedo em disco
Fim
Figura 11: Protocolo de comunicao entre o cliente e o servidor de arquivos
Listagem 9: Servidor de arquivos
1 package cap312;
5 import java.io.File;
6 import java.io.FileInputStream;
12
13 /**
15 * clientes. Este servidor, quando conectado, envia uma lista de arquivos locais
16 * para o cliente, aguarda a seleo de um nome de arquivo e envia o contedo
17 * deste arquivo para o cliente.
18 */
19 public class ServidorDeArquivos
20 {
23 {

27
24 try
25 {
27 // porta 2048.
30 while(true)
31 {
36 }
37 }
40 {
42 }
45 {
47 }
48 }
49

52 {
53 try
54 {
55 // Criamos uma stream para receber comandos do cliente - estes comandos
56 // sero somente strings.
57 BufferedReader entrada =
58 new BufferedReader(new InputStreamReader(conexo.getInputStream()));
59 // Criamos uma stream para enviar textos e dados para o cliente.
62 // Mandamos uma mensagem de boas vindas.
63 sada.writeUTF("Bem-vindo ao servidor de arquivos locais.");
64 sada.writeUTF("=========================================");
65 // Enviamos ao cliente a lista de arquivos locais.
66 File diretrio = new File("."); // bom para Linux, ser que funciona no Windows?
67 String[] arquivos = diretrio.list(); // oops, inclui diretrios tambm !
68 for(int a=0;a<arquivos.length;a++)
69 {
70 sada.writeUTF(arquivos[a]);
71 }
72 // Aguardamos a seleo do usurio.
73 sada.writeUTF("-----------------------------------------");
74 sada.writeUTF("Selecione um dos arquivos acima.");
75 // Informamos ao cliente que terminamos de mandar texto.
76 sada.writeUTF("#####");
77 // Garantimos que as mensagens foram enviadas ao cliente.
78 sada.flush();
79 // Lemos o nome de arquivo selecionado pelo cliente.
80 String nomeSelecionado = entrada.readLine();
81 // Criamos uma representao do arquivo.
82 File selecionado = new File(nomeSelecionado);
83 // Enviamos uma mensagem esclarecedora para o cliente.
84 sada.writeUTF("Enviando arquivo "+nomeSelecionado+" ("+

28
85 selecionado.length()+" bytes)");
86 sada.flush();
87 // Abrimos o arquivo localmente.
88 DataInputStream entradaLocal =
89 new DataInputStream(new FileInputStream(selecionado));
90 // Lemos todos os bytes do arquivo local, enviando-os para o cliente.
91 // Para maior eficincia, vamos ler e enviar os dados em blocos de 25 bytes.
92 byte[] arrayDeBytes = new byte[25];
93 while(true)
94 {
95 // Tentamos ler at 25 bytes do arquivo de entrada.
96 int resultado = entradaLocal.read(arrayDeBytes,0,25);
97 if (resultado == -1) break;
98 // Escrevemos somente os bytes lidos.
99 sada.write(arrayDeBytes,0,resultado);
100 }
101 // Ao terminar de ler o arquivo local, o fechamos.
102 entradaLocal.close();
104 sada.close();
106 conexo.close();
107 }
110 {
112 e.printStackTrace();
113 }
114 }
115 }
Alguns dos pontos de interesse na classe ServidorDeArquivos (listagem 9) so:

O servidor segue o mesmo padro de ter uma classe main e uma processaConexo
isto far o desenvolvimento de servidores capazes de atender mltiplas requisi-
es (veja seo 6) mais simples.
Para receber os dados do cliente, o servidor usa uma instncia de BufferedReader,
pois assumimos que o cliente somente enviar strings para o servidor. Para enviar
os dados para o cliente, usando a mesma conexo, usamos uma instncia da classe
DataOutputStream, que capaz de enviar strings (usando o mtodo writeUTF) e
valores de tipos nativos, inclusive arrays de bytes, com o mtodo write.
Em determinado ponto da interao entre cliente e servidor, o servidor ir enviar
um nmero desconhecido de linhas de texto para o cliente (os nomes de arquivos
disponveis no servidor). Para facilitar a interao com o cliente, que no sabe
antecipadamente quantas linhas de texto sero enviadas, usamos um marcador para
informar ao cliente que no existem mais linhas de texto a ser lidas: quando o
cliente receber a string ##### ele saber que deve parar de ler linhas de texto do
servidor.
Quando o servidor for enviar os bytes do arquivo selecionado para o cliente, o
procedimento ser outro: o servidor enviar bytes enquanto existirem (em um lao

29
que ser encerrado quando no for mais possvel ler bytes do arquivo local) e o
cliente monitorar estes bytes lidos para verificar o final da transmisso. Desta
forma, demonstramos duas maneiras de verificar se todos os dados de uma sesso
de comunicao foram enviados pelo servidor ou cliente: um usando marcadores
ou tags que indicam final de transmisso e outro usando mtodos da API de Java.
Vejamos agora o cliente para este servidor de arquivos. No poderemos usar o cliente
telnet pois em determinado momento da comunicao o servidor enviar bytes para o
cliente, que devem ser armazenados em um arquivo e no mostrados na tela. Um cliente
adequado mostrado na classe ClienteDeArquivos (listagem 10).
Listagem 10: Cliente de arquivos
1 package cap312;
5 import java.io.EOFException;
6 import java.io.FileOutputStream;
11
12 /**
13 * Esta classe implementa um cliente simples para o servidor de arquivos.
14 * A principal diferena entre este cliente e um cliente simples de texto
15 * (telnet, por exemplo) que existe uma ordem no protocolo de comunicao
16 * entre cliente-servidor que pede que em determinado momento, ao invs de
17 * receber textos para mostrar no terminal, o cliente deve receber dados para
18 * armazenar em um arquivo.
19 */
20 public class ClienteDeArquivos
21 {
23 {
25 // Tentamos fazer a conexo...
26 try
27 {
31 DataInputStream entrada =
32 new DataInputStream(conexo.getInputStream());
34 // OutputStreamWriter e partir deste, um BufferedWriter.
35 BufferedWriter sada =
36 new BufferedWriter(
37 new OutputStreamWriter(conexo.getOutputStream()));
38 // Lemos a lista de arquivos do servidor. Sabemos que vamos ler um
39 // nmero desconhecido de linhas do servidor. Usamos um lao que
40 // l linhas enquanto existirem dados a ser lidos. O servidor enviar
41 // a string ##### quando no houverem mais dados.
42 while(true)
43 {
44 String linha = entrada.readUTF();

30
45 if(linha.equals("#####")) break; // cdigo do servidor: acabaram as linhas.

46 System.out.println(linha);
47 }
48 // Lemos o nome do arquivo que desejamos do teclado e o
49 // enviamos para o servidor.
50 String arquivo = Keyboard.readString();
51 sada.write(arquivo);
52 sada.newLine();
53 sada.flush();
54 // O servidor envia para o cliente mais uma informao como texto.
55 String linha = entrada.readUTF();
56 System.out.println(linha);
57 // Abrimos o arquivo local. Vamos dar um nome diferente para ele s
58 // para no complicar a vida de quem estiver rodando cliente e servidor
59 // no mesmo computador.
60 DataOutputStream sadaParaArquivo =
61 new DataOutputStream(new FileOutputStream("_"+arquivo));
62 // A partir deste momento o servidor vai nos enviar bytes. Lemos todos os
63 // bytes enviados do servidor, gravando-os em um arquivo local.
64 // Para maior eficincia, vamos ler os dados em blocos de 25 bytes.
65 byte[] array = new byte[25];
66 while(true)
67 {
68 int resultado = entrada.read(array,0,25);
69 if (resultado == -1) break;
70 // Escrevemos somente os bytes lidos.
71 sadaParaArquivo.write(array,0,resultado);
72 }
73 // Fechamos as streams e a conexo.
74 sada.close();
75 entrada.close();
76 conexo.close();
77 }
80 {
82 }
84 catch (EOFException e)
85 {
86 System.out.println("Erro de EOF.");
87 }
90 {
92 }
93 }
94 }
O cliente mostrado na listagem 10 tem, como pontos de interesse, o esquema de lei-

tura de vrias linhas do servidor, que continua lendo linhas do servidor at que a linha
##### seja enviada; e o trecho que l bytes do servidor (em blocos de 25 bytes) e
armazena estes bytes em um arquivo local.

31
6 Servidores para mltiplas requisies simultneas

At agora os servidores implementados (exceto pelos servidores j existentes como
echo e daytime) so capazes de atender uma nica requisio simultnea dos clientes
- se um cliente j estivesse acessando o servio e outros clientes tambm tentassem o
acesso, estes outros clientes teriam que aguardar a conexo com o primeiro cliente ser
encerrada.
Felizmente, os servidores demonstrados so muito simples, enviando dados para o cli-

ente e imediatamente encerrando a conexo, permitindo a conexo por parte de outro
cliente logo em seguida. caso os servidores, por alguma razo, demorassem demais para
atender os clientes, outros clientes experimentariam uma demora no acesso ou mesmo
a negao do servio. Podemos assumir que servidores comuns (como, por exemplo,
http) so capazes de atender mltiplas requisies simultaneamente, caso contrrio um
usurio teria que esperar outro terminar a sua conexo em uma espcie de fila.
Nesta seo veremos por que que alguns servidores devem estar preparados para aten-
der mltiplas requisies simultaneamente e como podemos preparar servidores para
esta tarefa.
6.1 O problema de mltiplas requisies simultneas

Consideremos uma pequena alterao no protocolo de comunicao entre o cliente e
o servidor de nmeros aleatrios: o cliente agora envia para o servidor o nmero de
valores que este deseja receber. O servidor, por sua vez, ao invs de enviar somente um
nmero aleatrio, envia a quantidade de nmeros solicitada pelo cliente.
O protocolo de comunicao para esta verso de cliente e servidor mostrado na fi-

gura 12.
Embora o diagrama da figura 12 parea mais complicado do que os outros, a nica di-
ferena fundamental que existem dois laos, do lado do cliente e do lado do servidor,
que garantem que o mesmo nmero de valores ser requisitado e lido.
Considerando estas modificaes, a classe servidora de nmeros aleatrios foi reescrita

como mostra a listagem 11. Esta classe segue o mesmo padro de dois mtodos, um
main e um responsvel por processar uma requisio.
Listagem 11: Segunda verso do servidor de nmeros aleatrios
1 package cap312;

32
8
9 /**
11 * clientes. Quando uma conexo solicitada, o servidor l do cliente a
12 * quantidade de nmeros aleatrios desejada e envia para o cliente
13 * estes nmeros aleatrios, terminando ento a conexo.
14 */
15 public class SegundoServidorDeNumerosAleatorios
16 {
19 {
21 try
22 {
Cliente Servidor
Incio Incio
Cria conexo
L valor inteiro do teclado
Envia inteiro para servidor L inteiro do cliente
Aindaexistem Aindaexistem
valores valores
aserlidos? aserenviados?
N N
S S
L double do servidor Envia double para cliente
Imprime valor lido
Fim
Figura 12: Protocolo de comunicao entre o cliente e o servidor de nmeros aleatrios (segunda verso)

33
24 // porta 9999.
27 while(true)
28 {
33 }
34 }
37 {
39 }
42 {
44 }
45 }
46

49 {
50 try
51 {
52 // Criamos uma stream para receber valores nativos, usando a stream de entrada
60 // Lemos do cliente quantos nmeros ele deseja.
61 int quantidade = entrada.readInt();
62 // Enviamos para o cliente os nmeros.
63 for(int q=0;q<quantidade;q++)
64 {
70 }
71 // Ao terminar de atender a requisio, fechamos as streams.
72 entrada.close();
73 sada.close();
75 conexo.close();
76 }
79 {
81 }
82 }
83 }

34
O cliente para este servio tambm precisa ser reescrito. O cliente para a segunda verso
do servidor de nmeros aleatrios mostrado na listagem 12.
Listagem 12: Segunda verso do cliente de nmeros aleatrios
1 package cap312;
7
8 public class SegundoClienteDeNumerosAleatorios

9 {
11 {
14 try
15 {
18 // DataInputStream.
19 DataInputStream dis =
22 // DataOutputStream.
23 DataOutputStream dos =
25 // Quantos nmeros aleatrios vamos querer ?
26 System.out.print("Quantos nmeros:");
27 int quantos = Keyboard.readInt();
28 // Enviamos esta informao para o servidor.
29 dos.writeInt(quantos);
30 // Lemos os nmeros desejados do servidor.
31 for(int q=0;q<quantos;q++)
32 {
33 double valor = dis.readDouble();
34 System.out.println("O "+(q+1)+"o valor "+valor+".");
35 }
37 dis.close();
38 conexo.close();
39 }
42 {
44 }
47 {
49 }
50 }
51 }
O cliente modificado mostrado na listagem 12 tambm bem simples, contendo so-

mente um lao adicional quando comparado com outros clientes.

35
O cliente e servidor de mltiplos nmeros aleatrios funcionam corretamente, mas po-

dem causar um srio problema. Imagine que este seja um servio concorrido, com
vrias pessoas a qualquer momento solicitando nmeros aleatrios. Se um usurio soli-
citar uma quantidade exageradamente grande de nmeros aleatrios, outro cliente estar
impossibilitado de usar o servio, pois o mtodo processaConexo do servidor deve
terminar o seu processamento para retornar o controle ao mtodo main, que ento po-
der atender outra conexo quando o mtodo accept for executado.
Temos algumas possibilidades para a soluo deste problema em potencial:
Fazer clientes aguardarem sua vez sem maiores informaes - no existe maneira
de informar aos clientes quanto tempo eles tero que esperar na fila para atendi-
mento (analogia: telefone ocupado).
Executar mais de um servidor simultaneamente, em portas diferentes - se a pri-
meira tentativa de conexo fracassar, o cliente dever descobrir, por conta prpria,
qual das portas que oferecem o servio est desocupada (analogia: vrios telefones
para a mesma pessoa, alguns ocupados).
Limitar a quantidade de nmeros a serem servidos para que a conexo seja liberada
o mais rpido possvel para outros clientes.
Evidentemente estas opes so muito restritivas. Uma outra alternativa, mais interes-
sante, seria fazer uso de linhas de execuo ou threads. Basicamente threads permitem
que aplicaes executem mais de uma tarefa de forma aparentemente simultnea. Con-
tinuamos com uma aplicao que tem um nico mtodo main, mas durante a execuo
deste mtodo ele cria vrias instncias de classes que podem ser executadas concorren-
temente. Para escrever um servidor capaz de tratar vrias requisies de forma aparen-
temente simultnea, podemos usar os conceitos de threads e as classes em Java que os
implementam.
6.2 Linhas de execuo (threads)

Para melhor compreender linhas de execuo, consideremos um exemplo simples no
relacionado com programao cliente-servidor. Imaginemos uma simulao que en-
volva alguns objetos que poderiam se comportar independentemente, como por exem-
plo, uma simulao de corrida onde cada carro tem uma velocidade e independente de
outros carros. Vamos criar uma classe CarroDeCorrida para representar um carro de
corrida para esta simulao. Esta classe mostrada na listagem 13.
Listagem 13: Classe que representa um carro de corrida para simulao.
1 package cap312;
2 /**

36
3 * Esta classe representa um carro da Corrida Maluca para uma simulao.

4 */
5 public class CarroDeCorrida
6 {
7 private String nome;
8 private int distncia;
9 private int velocidade;
10
11 /**
12 * O construtor da classe inicializa o nome do carro e a velocidade do mesmo.
13 */
14 public CarroDeCorrida(String n,int vel)
15 {
16 nome = n;
17 distncia = 0;
18 velocidade = vel;
19 }
20
21 /**
22 * Este mtodo imprime os passos percorridos pelo carro.
23 */
24 public void executa()
25 {
26 while(distncia <= 1200)
27 {
28 System.out.println(nome+" rodou "+distncia+" km.");
29 distncia += velocidade;
30 // Pausa o processamento com um clculo intil.
31 for(int sleep=0;sleep<1000000;sleep++)
32 {
33 double x = Math.sqrt(Math.sqrt(Math.sqrt(sleep)));
34 }
35 }
36 }
37
38 }
A classe CarroDeCorrida (listagem 13) realmente simples, tendo como mtodos so-
mente o construtor e um mtodo executa que executar a simulao para a instncia
da classe. A simulao consiste em mudar a distncia percorrida pelo carro, imprimir
na tela e fazer uma pequena pausa (artificialmente criada por um lao que executa uma
operao matemtica).
A simulao de uma corrida poderia ser feita atravs de uma classe com vrias instn-
cias da classe CarroDeCorrida. A classe SimulacaoSemThreads, na listagem 14, cria
uma simulao simples.
Listagem 14: Simulao usando instncias de CarroDeCorrida.
1 package cap312;
2 /**
3 * Esta classe faz uma simulao de corrida usando instncias da classe
4 * CarroDeCorrida.
5 */
6 public class SimulacaoSemThreads
7 {

37
8 // Este mtodo permite a execuo da classe.

10 {
11 // Criamos instncias da classe CarroDeCorrida.
12 CarroDeCorrida penlope =
13 new CarroDeCorrida("Penlope Charmosa",60);
14 CarroDeCorrida dick =
15 new CarroDeCorrida("Dick Vigarista",100);
16 CarroDeCorrida quadrilha =
17 new CarroDeCorrida("Quadrilha da Morte",120);
18 // Criados os carros, vamos executar as simulaes.
19 penlope.executa();
20 dick.executa();
21 quadrilha.executa();
22 }
23 }
A classe SimulacaoSemThreads tambm relativamente simples: criamos as instn-

cias de CarroDeCorrida e executamos os seus mtodos executa. O problema, para
uma simulao, que os trs mtodos so executados de forma dependente um do outro:
s podemos executar o mtodo executa da instncia quadrilha depois de ter termi-
nado completamente a execuo dos mtodos das instncias penlope e dick. Para
uma simulao mais realista, isso no seria aceitvel os mtodos deveriam ser execu-
tados em paralelo. O resultado da execuo da classe SimulacaoSemThreads mostrar
a simulao para a instncia penlope, seguida da simulao para a instncia dick e
finalmente a simulao para a instncia quadrilha.
A forma mais simples para fazer com que as instncias possam ter um de seus mtodos
executados em paralelo com outros fazer a classe que contm o mtodo herdar da
classe Thread e implementar o mtodo run, que ser o mtodo a ser executado em
paralelo. Isto demonstrado na classe CarroDeCorridaIndependente, mostrada na
listagem 15.
Listagem 15: Classe que representa um carro de corrida para simulao (herdando de Thread).
1 package cap312;
2 /**
3 * Esta classe representa um carro da Corrida Maluca para uma simulao.
4 * Esta verso da classe herda da classe Thread, ento o mtodo run de
5 * instncias desta classe poder ser executado independentemente.
6 */
7 public class CarroDeCorridaIndependente extends Thread
8 {
9 private String nome;
10 private int distncia;
11 private int velocidade;
12
13 /**
14 * O construtor da classe inicializa o nome do carro e a velocidade do mesmo.
15 */
16 public CarroDeCorridaIndependente(String n,int vel)
17 {
18 nome = n;

38
19 distncia = 0;
20 velocidade = vel;
21 }
22
23 /**
24 * Este mtodo imprime a distncia percorrida at agora.
25 */
26 public void run()
27 {
28 while(distncia <= 1200)
29 {
30 System.out.println(nome+" rodou "+distncia+" km.");
31 distncia += velocidade;
32 // Pausa o processamento com um clculo intil.
33 for(int sleep=0;sleep<1000000;sleep++)
34 {
35 double x = Math.sqrt(Math.sqrt(Math.sqrt(sleep)));
36 }
37 }
38 }
39
40 }
importante observar que a assinatura do mtodo run deve obrigatoriamente ser public
void este mtodo no deve receber argumentos nem relanar excees.
A classe SimulacaoComThreads (listagem 16) demonstra a simulao de instncias da

classe CarroDeCorridaIndependente.
Listagem 16: Simulao usando instncias de CarroDeCorridaIndependente.
1 package cap312;
2 /**
3 * Esta classe faz uma simulao de corrida usando instncias da classe
4 * CarroDeCorridaIndependente.
5 */
6 public class SimulacaoComThreads
7 {
8 // Este mtodo permite a execuo da classe.
10 {
11 // Criamos instncias da classe CarroDeCorrida.
12 CarroDeCorridaIndependente penlope =
13 new CarroDeCorridaIndependente("Penlope Charmosa",60);
14 CarroDeCorridaIndependente dick =
15 new CarroDeCorridaIndependente("Dick Vigarista",100);
16 CarroDeCorridaIndependente quadrilha =
17 new CarroDeCorridaIndependente("Quadrilha da Morte",120);
18 // Criados os carros, vamos executar as simulaes.
19 penlope.start();
20 dick.start();
21 quadrilha.start();
22 }
23 }
Quando a classe SimulacaoComThreads (listagem 16) for executada, veremos que as

impresses dos nomes dos carros e respectivas posies aparecero intercaladas e em

39
ordem aparentemente imprevisvel, pois esto sendo executadas concorrentemente. Se

o trecho de cdigo que simula uma pausa no processamento for reescrito para a pausa
ser maior, este efeito de ordem imprevisvel ser aumentado. Se o trecho for eliminado,
quase sempre as simulaes sero executadas na mesma ordem em que os mtodos run
forem chamados, embora no exista garantia que isso sempre vai acontecer. Mesmo se
o tempo de pausa fosse simulado de forma aleatria para cada execuo, o resultado da
execuo da classe SimulacaoSemThreads seria o mesmo (na ordem de chamada do
mtodo executa) enquanto que seguramente os resultados seriam diferentes para cada
execuo da classe SimulacaoComThreads.
importante notar que declaramos o mtodo run na classe CarroDeCorridaIndepen-

dente (listagem 15) como sendo o ponto de entrada do processamento a ser feito em
paralelo, mas devemos executar o mtodo start (veja listagem 16) para dar incio
execuo do mtodo run.
O que possibilita a execuo de mtodos concorrentemente o fato do mtodo start

inicializar a execuo da thread e retornar imediatamente. No exemplo da classe Simu-
lacaoComThreads (listagem 16), logo depois que a thread para processamento dos
dados da instncia penlope inicializada, o controle retorna para o mtodo main, que
executa o mtodo start para a instncia dick, retornando novamente o controle para
o mtodo main, que finalmente executa o mtodo start para a instncia quadrilha.
Enquanto o mtodo main continua sendo executado, os mtodos run das instncias da
classe CarroDeCorridaIndependente iam so executados concorrentemente.
6.3 Exemplo: Servidor de nmeros aleatrios (para requisies simultneas)

Vamos reescrever o servidor de nmeros aleatrios (segunda verso) para usar linhas
de execuo, assim fazendo com que o servidor no bloqueie usurios que tentem
se conectar enquanto uma sesso estiver em andamento. Usando o conceito de li-
nhas de execuo, o servidor, ao invs de executar um mtodo de sua prpria classe
(processaConexo) quando tiver que atender um cliente, ir criar uma classe que herda
de Thread cujo mtodo run executa exatamente o que o mtodo processaConexo fa-
ria.
Os passos para transformar uma classe que implementa um servidor sem mltiplas li-
nhas de execuo para classes que implementam servidores com mltiplas linhas de
execuo so, ento:
1. Criar uma classe que implementa o atendimento a uma nica conexo. Esta classe
dever herdar da classe Thread, ter um construtor (para possibilitar o armazena-
mento da instncia de Socket relacionada com a conexo que deve ser atendida
por uma instncia desta mesma classe) e o mtodo run, que dever ser respon-

40
svel pelo processamento do atendimento da conexo. Em geral, o contedo do

mtodo run deve ser o mesmo dos mtodos processaConexo usados em outros
exemplos.
2. Reescrever a classe do servidor para que a mesma, ao receber uma conexo (atra-
vs do mtodo accept da classe ServerSocket, crie uma nova instncia da classe
responsvel pelo atendimento a uma nica conexo e execute o mtodo start
desta instncia.
Usando estes passos, reescreveremos o servidor de nmeros aleatrios. Primeiro, es-

crevemos a classe ServicoDeNumerosAleatorios cujas instncias sero responsveis
por processar uma nica conexo. A classe ServicoDeNumerosAleatorios mos-
trada na listagem 17 e contm somente o construtor e o mtodo run que executa todo o
atendimento conexo.
Listagem 17: Classe que implementa o servio de nmeros aleatrios
1 package cap312;
6
7 /**
8 * Esta classe representa o processamento que deve ser feito quando uma
9 * nica requisio for feita a um servidor. A classe herda de Thread para que
10 * vrias instncias dela possam ser executadas concorrentemente.
11 */
12 public class ServicoDeNumerosAleatorios extends Thread
13 {
14 // Precisamos armazenar o socket correspondente conexo.
15 private Socket conexo = null;
16
17 /**
18 * O construtor desta classe recebe como argumento uma instncia de Socket
19 * e o armazena em um campo da classe.
20 */
21 public ServicoDeNumerosAleatorios(Socket conn)
22 {
23 conexo = conn;
24 }
25
26 /**
27 * Este mtodo executa a rotina de atendimento a uma conexo com o servidor.
28 */
30 {
31 try
32 {

41
41 // Lemos do cliente quantos nmeros ele deseja.
42 int quantidade = entrada.readInt();
43 // Enviamos para o cliente os nmeros.
44 for(int q=0;q<quantidade;q++)
45 {
51 }
53 entrada.close();
54 sada.close();
56 conexo.close();
57 }
60 {
62 }
63 }
64
65 }
necessrio armazenar na classe ServicoDeNumerosAleatorios (listagem 17) uma

instncia da classe Socket que corresponde ao socket que foi criado para comunicao
com o cliente, pois no poderamos passar esta instncia como argumento para o m-
todo run o mesmo deve ser sempre executado sem argumentos.
A classe que representa o servidor tambm foi modificada de acordo com os passos in-
dicados. A classe TerceiroServidorDeNumerosAleatorios contm agora somente o
mtodo main que cria novas instncias de ServicoDeNumerosAleatorios quando no-
vas conexes so estabelecidas, e que executa o mtodo start destas instncias, retor-
nando o controle ao mtodo main imediatamente. A classe TerceiroServidorDeNu-
merosAleatorios mostrada na listagem 18.
Listagem 18: Terceira verso do servidor de nmeros aleatrios
1 package cap312;
6
7 /**
9 * clientes. Quando uma conexo solicitada, o servidor l do cliente a
10 * quantidade de nmeros aleatrios desejada e envia para o cliente
11 * estes nmeros aleatrios, terminando ento a conexo.
12 */
13 public class TerceiroServidorDeNumerosAleatorios

42
14 {
17 {
19 try
20 {
22 // porta 9999.
25 while(true)
26 {
29 // ... criamos um servio para atender a esta conexo...
30 ServicoDeNumerosAleatorios s = new ServicoDeNumerosAleatorios(conexo);
31 // ... e executamos o servio (que ser executado independentemente).
32 s.start();
33 }
34 }
37 {
39 }
42 {
44 }
45 }
46 }
Quando o mtodo main da classe TerceiroServidorDeNumerosAleatorios (lista-

gem 18) for executado, aguardar uma conexo do cliente. Quando esta conexo for
criada (ou seja, quando o mtodo accept for executado e retornar uma instncia de
Socket, uma instncia da classe ServicoDeNumerosAleatorios ser criada para tra-
tar desta conexo, e o seu mtodo start ser executado. Imediatamente (isto , sem
aguardar o final da execuo do mtodo start ou run) o controle passar de volta para
o mtodo main, que estar liberado para aceitar novas conexes.
O cliente desta classe no precisa de modificaes, como cliente podemos usar a classe
SegundoClienteDeNumerosAleatorios (listagem 12).
7 Aplicaes baseadas em um servidor e vrios clientes

Veremos agora como funciona uma aplicao onde existe um servidor e vrios clientes
conectados simultaneamente, mas de forma que cada cliente tenha a sua vez de interagir
com o servidor (os clientes no so independentes). Este exemplo de interao ilustra o
papel de um servidor como mediador em um jogo, por exemplo.

43
7.1 Exemplo: Servidor de jogo-da-velha

Vejamos um exemplo de aplicao cliente-servidor com um servidor e dois clientes sin-
cronizados (isto , que tem a sua vez para interagir com o servidor determinadas e em
ordem). O jogo-da-velha um bom exemplo: dois jogadores, atravs dos seus clientes,
se conectam com o servidor, e um depois do outro, enviam comandos para este. Alm
de receber e processar os movimentos feitos pelos clientes, o servidor responsvel por
analisar estes movimentos (isto , verificar se eles so vlidos), informar os jogadores
dos movimentos de ambos e determinar quando o jogo tiver um vencedor (terminando
as conexes com os clientes).
O algoritmo para controlar as jogadas e verificar se houve vencedores no jogo-da-velha

simples. Consideremos que o jogo implementado como um tabuleiro de 3x3 posi-
es. Internamente este tabuleiro ser um array bidimensional de caracteres, onde cada
posio (caracter) poder ser igual a um X ou O se estiver ocupado ou espao se estiver
livre. Para que seja mais fcil para o jogador indicar a posio onde quer jogar, as linhas
do tabuleiro sero indicadas por A, B e C e as colunas por 1, 2 e 3. A figura 13 mostra
o tabuleiro com os indicadores de linhas e colunas.
1 2 3
Figura 13: Posies para jogo e linhas vencedoras no jogo-da-velha
O algoritmo que verifica se houve um vencedor para o jogo tambm simples. Existem
oito combinaes de posies que se forem ocupadas pelo mesmo jogador determinam
a vitria deste jogador: se as trs linhas, trs colunas ou duas diagonais do tabuleiro
forem totalmente preenchidas pelo mesmo jogador, este ganhou o jogo. As setas mos-
tradas na figura 13 indicam estas combinaes.
Para que um jogo possa ser executado, so necessrios dois jogadores (dois clientes).
Conforme mencionado anteriormente, os clientes no se conectam e enviam/recebem
informaes do servidor simultaneamente (usando linhas de execuo): a comunicao
feita por vezes, uma vez sendo a de um cliente/jogador e a vez seguinte sendo do outro.

44
O protocolo do jogo simples: o servidor aguarda a conexo de dois clientes, e alterna

o recebimento de comandos (posies para jogo) de um cliente para o outro. Depois da
jogada de cada cliente, o servidor verifica se a jogada vlida, modificando o tabuleiro
do jogo se o for. Se houver vencedor, ou se no houver mais posies onde o jogador
da vez possa jogar, o resultado apresentado e a conexo com os clientes encerrada.
O protocolo de interao entre os clientes e o servidor mostrado na figura 14.
Cliente 1 Servidor Cliente 2

Incio Incio Incio
Solicita conexo Aguarda conexo Solicita conexo
Cria conexo
Aguarda conexo
Cria conexo
Envia movimento Recebe movimento
Venceuo
jogo?
S
N
Imprime situao Envia situao Imprime situao
Recebe movimento Envia movimento
Venceuo
N jogo?
Imprime situao Envia situao Imprime situao
Fim Fim
Figura 14: Protocolo de comunicao entre o servidor e os clientes de jogo-da-velha
A implementao de uma classe que atua como servidora de jogo-da-velha (classe

ServidorDeJogoDaVelha) mostrada na listagem 19.

45
Listagem 19: O servidor de Jogo-da-Velha
1 package cap312;
10
11 /**
12 * Esta classe implementa um servidor de jogo-da-velha. Este servidor aguarda
13 * a conexo de dois clientes e gerencia o jogo entre eles.
14 */
15 public class ServidorDeJogoDaVelha
16 {
17 // Declaramos uma matriz de caracteres como sendo o tabuleiro do jogo.
18 private static char[][] tabuleiro;
19
20 // Assumimos que toda a entrada e sada ser feita por strings.

21 // Declaramos instncias de BufferedReader e BufferedWriter para cada cliente.
22 private static BufferedReader entrada1,entrada2;
23 private static BufferedWriter sada1,sada2;
24

27 {
28 // Alocamos memria para o tabuleiro do jogo.
29 tabuleiro = new char[3][3];
30 try
31 {
33 // porta 12345.
36 while(true)
37 {
38 // Aguardamos a primeira conexo...
39 Socket conexo1 = servidor.accept();
40 System.out.println("Conexo 1 aceita para o cliente "+
41 conexo1.getRemoteSocketAddress());
42 // Criamos as streams de entrada e sada para o cliente 1.
43 entrada1 =
44 new BufferedReader(new InputStreamReader(conexo1.getInputStream()));
45 sada1 =
46 new BufferedWriter(new OutputStreamWriter(conexo1.getOutputStream()));
48 enviaMensagem(sada1,"Ol, voc ser o primeiro jogador (X).");
49 enviaMensagem(sada1,"Por favor aguarde o outro jogador...");
50 // Aguardamos a segunda conexo...
51 Socket conexo2 = servidor.accept();
52 System.out.println("Conexo 2 aceita para o cliente "+
53 conexo2.getRemoteSocketAddress());
54 // Criamos as streams de entrada e sada para o cliente 1.
55 entrada2 =
56 new BufferedReader(new InputStreamReader(conexo2.getInputStream()));
57 sada2 =
58 new BufferedWriter(new OutputStreamWriter(conexo2.getOutputStream()));

46
60 enviaMensagem(sada2,"Ol, voc ser o segundo jogador (O).");

61 enviaMensagem(sada1,"Segundo jogador conectado.");
62 // Quando as duas conexes tiverem sido estabelecidas e as streams
63 // criadas, iniciamos o processamento.
64 processaJogo();
65 // Ao terminar de atender a requisio de jogo, fechamos os streams.
66 entrada1.close();
67 entrada2.close();
68 sada1.close();
69 sada2.close();
70 // Fechamos tambm as conexes.
71 conexo1.close();
72 conexo2.close();
73 }
74 }
77 {
79 }
82 {
84 }
85 }
86
87 // Este mtodo executa a lgica do jogo, tendo acesso aos mecanismos de entrada
88 // e sada de duas conexes.
89 private static void processaJogo()
90 {
91 // A primeira coisa a fazer "limpar" o tabuleiro.
92 for(int linha=0;linha<3;linha++)
93 for(int coluna=0;coluna<3;coluna++)
94 tabuleiro[linha][coluna] = ;
95 // String que ser reusada para as entradas de comandos.
96 String jogada;
97 // Coordenadas da jogada.
98 int linha,coluna;
99 // Pea do vencedor.
100 char vencedor;
101 try
102 {
103 // Enviamos o tabuleiro para os dois jogadores pela primeira vez.
104 mostraTabuleiro();
105 // Executamos um lao "eterno"
106 while(true)
107 {
108 // Lemos e verificamos a jogada do primeiro jogador.
109 enviaMensagem(sada2,"Aguarde movimento do jogador X.");
110 enviaMensagem(sada1,"Jogador X, entre seu movimento.");
111 jogada = entrada1.readLine();
112 enviaMensagem(sada1,"Jogador X escolheu "+jogada);
113 enviaMensagem(sada2,"Jogador X escolheu "+jogada);
114 // Quais so as coordenadas da jogada ?
115 linha = jogada.charAt(0)-A; // A = 0; B = 1; C = 2;
116 coluna = jogada.charAt(1)-1; // 1 = 0; 2 = 1; 3 = 2;
117 // A jogada vlida ?
118 if ((linha >= 0) && (linha <= 2) &&
119 (coluna >= 0) && (coluna <= 2) &&
120 (tabuleiro[linha][coluna] == ))

47
121 {
122 tabuleiro[linha][coluna] = X;
123 }
124 else
125 {
126 enviaMensagem(sada1,"Jogada do jogador X em posio invlida.");
127 enviaMensagem(sada2,"Jogada do jogador X em posio invlida.");
128 }
129 // Enviamos o tabuleiro para os dois jogadores.
131 // Verificamos se algum venceu o jogo.
132 vencedor = verificaVencedor();
133 if (vencedor == V)
134 {
136 enviaMensagem(sada1,"Empate!");
138 break;
139 }
140 else if (vencedor != )
141 {
143 enviaMensagem(sada1,"Vencedor: jogador "+vencedor);
145 break;
146 }
147 // Lemos e verificamos a jogada do segundo jogador.
148 enviaMensagem(sada1,"Aguarde movimento do jogador O.");
149 enviaMensagem(sada2,"Jogador O, entre seu movimento.");
150 jogada = entrada2.readLine();
151 enviaMensagem(sada1,"Jogador O escolheu "+jogada);
152 enviaMensagem(sada2,"Jogador O escolheu "+jogada);
153 // Quais so as coordenadas da jogada ?
154 linha = jogada.charAt(0)-A; // A = 0; B = 1; C = 2;
155 coluna = jogada.charAt(1)-1; // 1 = 0; 2 = 1; 3 = 2;
156 // A jogada vlida ?
157 if ((linha >= 0) && (linha <= 2) &&
158 (coluna >= 0) && (coluna <= 2) &&
159 (tabuleiro[linha][coluna] == ))
160 {
161 tabuleiro[linha][coluna] = O;
162 }
163 else
164 {
165 enviaMensagem(sada1,"Jogada do jogador O em posio invlida.");
166 enviaMensagem(sada2,"Jogada do jogador O em posio invlida.");
167 }
168 // Enviamos o tabuleiro para os dois jogadores.
170 // Verificamos se algum venceu o jogo.
171 vencedor = verificaVencedor();
172 if (vencedor == V)
173 {
177 break;
178 }
179 else if (vencedor != )
180 {

48

183 break;
184 }
185 } // fim do while true
186 } // fim do bloco try
189 {
190 System.out.println("Erro executando o lao principal do jogo !");
191 }
192 }
193
194 /**
195 * Este mtodo mostra o tabuleiro do jogo para os dois clientes. Ele monta
196 * uma string contendo o tabuleiro (inclusive movimentos j jogados) com alguma
197 * decorao para o usurio saber que posies ainda podem ser jogadas. A string
198 * ento enviada para os dois clientes.
199 */
200 private static void mostraTabuleiro()
201 {
202 String tabuleiroFormatado = "";
203 String tempLinha;
204 tabuleiroFormatado += " \n";
205 tabuleiroFormatado += " 1 2 3 \n";
206 tabuleiroFormatado += " +-+-+-+\n";
208 {
209 tempLinha = (char)(A+linha)+"|";
211 tempLinha += tabuleiro[linha][coluna]+"|";
212 tempLinha += "\n";
213 tabuleiroFormatado += tempLinha;
214 tabuleiroFormatado += " +-+-+-+\n";
215 }
216 enviaMensagem(sada1,tabuleiroFormatado);
217 enviaMensagem(sada2,tabuleiroFormatado);
218 }
219
220 /**
221 * Este mtodo verifica se houve algum vencedor considerando a situao atual do
222 * tabuleiro. Se houver vencedor, o mtodo retorna o caracter correspondente ao
223 * vencedor (X ou O), seno retorna espao.
224 */
225 private static char verificaVencedor()
226 {
227 // Vamos verificar as 8 possveis combinaes para ganhar o jogo.
228 // Primeira linha.
229 if ((tabuleiro[0][0] == tabuleiro[0][1]) &&
230 (tabuleiro[0][1] == tabuleiro[0][2])) return tabuleiro[0][0];
231 // Segunda linha.
232 else if ((tabuleiro[1][0] == tabuleiro[1][1]) &&
234 // Terceira linha.
237 // Primeira coluna.
240 // Segunda coluna.

49
243 // Terceira coluna.

246 // Diagonal descendente.
249 // Diagonal ascendente.
252 else // Nenhuma das combinaes existe.
253 {
254 // Ainda existe posies abertas no tabuleiro ?
255 int posiesAbertas = 0;
258 if(tabuleiro[linha][coluna] == ) posiesAbertas++;
259 if (posiesAbertas == 0) return V; // Velha !
260 else return ; // Ningum venceu at agora.
261 }
262 }
263
264 /**
265 * Este mtodo facilita o envio de mensagens para os clientes, executando
266 * o mtodos write, newLine e flush de uma instncia de BufferedWriter.
267 */
268 private static void enviaMensagem(BufferedWriter bw,String mensagem)
269 {
270 try
271 {
272 bw.write(mensagem);
273 bw.newLine();
274 bw.flush();
275 }
277 {
278 System.out.println("Erro enviando mensagem.");
279 }
280 }
281
282 }
Um exemplo de interao de um cliente (telnet) com o servidor de jogo-da-velha pode

ser visto na figura 15.
8 Aplicaes baseadas em um cliente e vrios servidores

Se considerarmos que servidor o lado da aplicao que fornece uma informao ou
executa um processamento e cliente o lado que consume esta informao ou usa o
recurso do servidor, podemos imaginar aplicaes aonde ao invs de ter um ou mais
clientes usando os servios de um servidor, podemos ter um nico cliente usando os
servios de vrios servidores.
Consideremos uma tarefa computacional cujo tempo para execuo seja potencialmente
longo, mas que possa ser dividida em subtarefas menores. Podemos escrever uma apli-

50
Figura 15: Exemplo de interao entre um cliente (telnet) e servidor de jogo-da-velha
cao servidora que ser executada ao mesmo tempo em vrios computadores, cada
uma responsvel pela soluo de uma parte do problema. Podemos criar uma aplicao
cliente que solicita a cada aplicao servidora a execuo de sua parte, e que integra as
solues em uma s.
Evidentemente este tipo de aplicao deve envolver o processamento de dados cuja

transmisso entre cliente e servidor gaste muito menos tempo do que o processamento,
caso contrrio a execuo da aplicao ser mais lenta. Cuidados especiais tambm de-
vem ser tomados para garantir a integridade do resultado, caso um dos servidores falhe.
O lado cliente das aplicaes tambm precisa ser criado de forma a dar suporte a ml-
tiplas linhas de execuo (seo 6.2), caso contrrio ele no poder enviar requisies
a vrios servidores simultaneamente. Tambm ser necessrio usar algum mecanismo
que informe aplicao cliente que todos os servidores j terminaram o processamento

51
f(x)
a b
a b
delta
Figura 16: Clculo de uma integral usando parties e trapzios
de seus dados.
Nesta seo veremos um exemplo de tarefa computacional que pode ser dividida, en-
viada a servidores para processamento e integrada pelo cliente, alcanando assim um
possvel tempo menor de execuo quando comparado com a execuo em um nico
computador.
8.1 Exemplo: Cliente e servidores para clculo de integrais

Um bom exemplo de problema que pode ser dividido em pequenos problemas menores
o clculo de integrais. Consideremos uma funo matemtica qualquer, considerada
entre os valores A e B. O valor da integral desta funo entre A e B a rea que a funo
projeta sobre o eixo X, como mostrado na figura 8.1.
Na parte superior da figura 8.1 temos uma funo f (x) definida entre os pontos A e B.
O valor da integral de f (x) entre A e B a rea mostrada em cinza na figura 8.1. Uma
maneira de calcular esta rea de forma aproximada dividir a rea em muitos peque-

52
nos trapzios que cobrem a mesma rea, como mostrado na parte inferior da figura 8.1.
Para calcular a rea coberta pela funo basta ento calcular a somatria das reas dos
trapzios. Considerando a funo f (x) entre os pontos A e B e que a rea da funo
ser dividida de forma que a largura da base de cada trapzio seja igual a delta, pode-
mos calcular a rea do mesmo como sendo a somatria da rea do trapzio cuja base
delta, lado direito igual a f (a) e lado esquerdo igual a f (a + delta), ou seja, igual a
delta ( f (a) + f (a + delta))/2.
De posse do mtodo e equaes acima, fcil ver que podemos dividir o problema da
somatria em problemas menores, onde cada um deles, para ser executado, dever re-
ceber o valor de A (primeiro valor, ou valor inferior para clculo), B (segundo valor, ou
valor superior), delta e claro, a funo a ser integrada.
O protocolo de comunicao entre cliente e servidor(es) de clculo de integrais mos-

trado na figura 17. Nesta figura mostramos somente um cliente (o normal para este tipo
de aplicao) e um servidor, mas em casos normais o clculo dever ser efetuado usando
vrios servidores. Uma linha cinza usada para mostrar, do lado do cliente, que trecho
do cdigo ser executado concomitantemente pelas linhas de execuo do cliente. Para
cada linha de execuo do lado do cliente, teremos uma conexo com um dos servidores.
O cdigo para o servidor de clculo de integrais mostrado na listagem 20.
Listagem 20: O servidor de clculo de integrais
1 package cap312;
8
9 /**
11 * clientes. Quando uma conexo solicitada, o servidor l do cliente o
12 * intervalo e preciso para o clculo da funo, efetua o clculo e retorna
13 * para o cliente o resultado.
14 */
15 public class ServidorDeCalculoDeIntegrais
16 {
19 {
20 // O nmero da porta ser obtido da linha de comando.
21 int porta = Integer.parseInt(args[0]);
23 try
24 {
26 // porta.
27 servidor = new ServerSocket(porta);

53
Cliente Servidor 1
Incio Incio
Divide tarefa em
subtarefas
Para cada subtarefa...
Cria conexo
Envia valores A, B e delta Recebe valores
Efetua clculo
Recebe resultado Envia resultado
Aguarda todos os
resultados
Imprime resultado
Fim
Figura 17: Protocolo para aplicao que faz o clculo de uma integral

29 while(true)
30 {
35 }
36 }
39 {
40 System.out.println("Porta "+porta+" j em uso.");
41 }
44 {

54
46 }
47 }
48

51 {
52 try
53 {
62 // Lemos do cliente o intervalo da funo.
63 double incio = entrada.readDouble();
64 double fim = entrada.readDouble();
65 // Lemos do cliente a largura do trapzio para clculo da funo.
66 double delta = entrada.readDouble();
67 // Fazemos o clculo.
68 double resultado = calculaIntegral(incio,fim,delta);
69 // Enviamos para o cliente o valor do clculo.
70 sada.writeDouble(resultado);
72 System.out.println("Acabo de enviar o resultado "+resultado+" para o cliente "+
75 entrada.close();
76 sada.close();
78 conexo.close();
79 }
82 {
84 }
85 }
86
87 /**
88 * Este mtodo calcula a integral de uma funo entre os valores passados
89 * usando como delta o valor tambm passado. O mtodo usa a regra do
90 * trapzio.
91 */
92 private static double calculaIntegral(double incio,double fim,double delta)
93 {
94 double a = incio;
95 double somaDasreas = 0;
96 // Vamos percorrendo os valores para argumentos da funo...
97 while((a+delta) <= fim)
98 {
99 double alturaA = funo(a);
100 double alturaB = funo(a+delta);
101 // Calculamos a rea do trapzio local.
102 double reaTrapzio = delta*(alturaA+alturaB)/2;
103 // Somamos rea total.
104 somaDasreas += reaTrapzio;
105 a += delta;
106 }

55
107 return somaDasreas;

108 }
109
110 /**
111 * Este mtodo calcula uma funo em determinado ponto.
112 */
113 private static double funo(double argumento)
114 {
115 return Math.sin(argumento)*Math.sin(argumento);
116 }
117
118 }
Alguns pontos notveis no cdigo da classe ServidorDeCalculoDeIntegrais (lista-

gem 20) so:
Quando executarmos a aplicao servidora devemos passar o nmero da porta
como parmetro. Em algumas situaes isso pode ser incmodo (o cliente de-
ver saber em que endereos e em que portas ele deve se conectar), o uso de uma
porta padro recomendado (isso no foi feito para finalidades de testes).
O servidor usa o mesmo padro de desenvolvimento de outros servidores: um lao
eterno que aguarda conexes do cliente para receber seus dados, process-los e
retorn-los. Desta forma o mesmo servidor pode ser reutilizado por um ou mais
clientes, embora somente processe uma requisio de cada vez o servidor no
executa mltiplas linhas de execuo.
O mtodo processaConexo processa uma nica conexo do cliente, onde sero
recebidos os valores de A, B e delta; e enviado o valor da integral entre A e B. Este
mtodo executa o mtodo calculaIntegral usando estes parmetros, e calcu-
lando a somatria das reas de todos os trapzios entre A e B. Para isto, o mtodo
calculaIntegral executa o mtodo funo que calcula o valor da funo em
um determinado ponto. Para este exemplo, a funo foi codificada diretamente no
servidor, e a funo sin(x) sin(x), escolhida pois sua integral entre os valores 0
e /2 exatamente6 igual a /4, facilitando a verificao do algoritmo.
Conforme mencionado anteriormente, o cliente para esta aplicao dever ser capaz de
tratar com linhas de execuo. Mais exatamente, o cliente dever criar uma linha de
execuo para cada subtarefa que ser enviada por sua parte para um servidor. A classe
que representa uma subtarefa ou linha de execuo a classe LinhaDeExecucaoDeCal-
culoDeIntegrais, mostrada na listagem 21.
Listagem 21: Uma linha de execuo para o cliente de clculo de integrais
1 package cap312;
6 Usaremos o valor do resultado desejado (/4) para comparar o resultado obtido, mas j sabendo de antemo que os
resultados no sero exatamente iguais por causa de vrios fatores: impreciso do valor /4, erros de arredondamento naturais
e preciso do algoritmo de clculo dependente do valor delta.

56
7
8 /**
9 * Esta classe representa o processamento que deve ser feito quando uma
10 * requisio de clculo de intgrais for feita a um servidor.
11 * A classe herda de Thread para que vrias instncias dela possam ser
12 * executadas concorrentemente.
13 */
14 public class LinhaDeExecucaoDeCalculoDeIntegrais extends Thread
15 {
16 // Precisamos armazenar o socket correspondente conexo.
17 private Socket conexo = null;
18 // Tambm precisamos armazenar os valores para clculo.
19 private double incio,fim,delta,resultado;
20
21 /**
22 * O construtor desta classe recebe como argumento o nmero da porta do
23 * servidor e o armazena em um campo da classe. O construtor tambm recebe
24 * como argumentos o intervalo e delta para clculo da integral.
25 */
26 public LinhaDeExecucaoDeCalculoDeIntegrais(String servidor,int porta,
27 double i,double f,double d)
28 {
29 try
30 {
31 conexo = new Socket(servidor,porta);
32 }
34 {
35 System.out.println("Host desconhecido !");
36 }
38 {
39 System.out.println("Erro de entrada ou sada !");
40 }
41 incio = i;
42 fim = f;
43 delta = d;
44 }
45
46 /**
47 * Este mtodo executa a rotina de atendimento a uma conexo com o servidor.
48 */
50 {
51 try
52 {
61 // Enviamos ao servidor o intervalo da funo.
62 sada.writeDouble(incio);
63 sada.writeDouble(fim);

57
64 // Enviamos ao servidor o nmero de intervalos da funo.

65 sada.writeDouble(delta);
66 // Lemos do servidor o resultado do clculo.
67 resultado = entrada.readDouble();
69 entrada.close();
70 sada.close();
72 conexo.close();
73 }
76 {
78 }
79 }
80 /**
81 * Este mtodo permite recuperar o valor calculado.
82 */
83 public double getResultado()
84 {
85 return resultado;
86 }
87
88 }
A classe LinhaDeExecucaoDeCalculoDeIntegrais (listagem 21) contm campos para

armazenar o nome e porta do servidor com o qual ir se comunicar, alm dos parmetros
para clculo da integral (A, B e delta). Estes campos so inicializados pelo construtor
da classe. Como a classe herda de Thread deve implementar seu mtodo run para
que suas instncias possam ser executadas concomitantemente. O mtodo run simples-
mente cria a conexo com o servidor, envia os dados, recebe o valor da somatria e o
armazena para que outra aplicao o possa recuperar com o mtodo getResultado.
A classe que implementa o cliente, que por sua vez ir criar algumas instncias da classe
LinhaDeExecucaoDeCalculoDeIntegrais, a classe ClienteDeCalculoDeInte-
grais, mostrada na listagem 22.
Listagem 22: O cliente de clculo de integrais
1 package cap312;
2 /**
3 * Esta classe implementa um cliente simples para o servio de clculo de
4 * integrais.
5 * Ele se conecta a dois servidores (pela portas nas quais estes servidores
6 * esto respondendo), envia trechos para clculo da integral e calcula a soma
7 * dos resultados.
8 */
9 public class ClienteDeCalculoDeIntegrais
10 {
12 {
14 // Dividimos a tarefa em duas metades que sero executadas com diferentes
15 // precises.

58
16 LinhaDeExecucaoDeCalculoDeIntegrais l1 =
17 new LinhaDeExecucaoDeCalculoDeIntegrais("localhost",11111,
18 0,Math.PI/4,0.000001);
19 LinhaDeExecucaoDeCalculoDeIntegrais l2 =
20 new LinhaDeExecucaoDeCalculoDeIntegrais("localhost",11112,
21 Math.PI/4,Math.PI/2,0.0000001);
22 // Iniciamos a execuo das duas tarefas.
23 l1.start();
24 l2.start();
25 // Aguardamos at que as duas instncias tenham terminado de processar
26 // o mtodo run.
27 while(l1.isAlive() || l2.isAlive())
28 {
29 }
30 // Calculamos o resultado final e comparamos com o esperado.
31 double resFinal = l1.getResultado()+l2.getResultado();
32 System.out.println("Resultado:"+resFinal);
33 System.out.println("Esperado :"+Math.PI/4);
34 }
35 }
A classe ClienteDeCalculoDeIntegrais (listagem 22) simplesmente cria duas ins-

tncias da classe LinhaDeExecucaoDeCalculoDeIntegrais, usando (para demons-
trao), o servidor local e duas portas previamente definidas, onde servidores esto
aguardando conexes. Cada linha de execuo calcular metade dos trapzios corres-
pondentes rea da integral, mas a segunda linha de execuo calcular a sua parte da
integral com um valor de delta mais preciso, para que o tempo de execuo seja defini-
tivamente diferente.
Em algum ponto precisaremos verificar se as linhas de execuo j terminaram o seu

processamento, para evitar erros grosseiros de clculo. Estes erros podem acontecer fa-
cilmente pois a partir do momento em que o mtodo start da classe LinhaDeExecu-
caoDeCalculoDeIntegrais for executado, j ser possvel executar o mtodo get-
Resultado das mesmas, que pode retornar zero se o clculo no tiver sido terminado
em outras palavras, se o mtodo run ainda estiver sendo executado.
Para garantir que o mtodo getResultado somente ser executado depois que o mtodo
run tiver terminado seu processamento, podemos criar um lao infinito que aguarda
at que o resultado dos mtodos isAlive das classes que herdam de Thread sejam
ambos false este mtodo verifica se uma linha de execuo ainda est viva, se
o mtodo retorna true se a linha de execuo ainda est sendo executada. Ao final
do processamento basta somar os resultados obtidos pelas duas linhas de execuo e
apresentar o resultado esperado para comparao.
9 Mais informaes
Considero este documento ainda inacabado existem outros tpicos interessantes que
podemos explorar, como por exemplo:

59
Criao de aplicaes que usem servidores em mltiplas camadas, como servido-

res de meta-dados, por exemplo. Estas aplicaes tem clientes que precisam de
dados mas no sabem onde estes dados esto: estes clientes se conectam a um
servidor de meta-dados, que por sua vez se comunica com vrios servidores (co-
nhecidos) de dados para descobrir qual deles contm a informao que o cliente
necessita.
Balanceamento simples de carga: consideremos o exemplo do clculo de integrais
apresentado na seo 8.1. Duas linhas de execuo foram criadas, cada uma efe-
tuando um clculo desbalanceado: a primeira linha de execuo demorou muito
mais do que a segunda. Podemos considerar esquemas simples de balanceamento,
que fazem com que servidores aparentemente ociosos recebam carga a mais, para
tentar chegar ao final do processamento como um todo em menos tempo.
Servios de descoberta de servidores e balanceamento dinmico, que combinam
as idias apresentadas nos dois tpicos acima. O cliente de clculo de integrais po-
deria ento tentar descobrir quais servidores existem e esto disposio, mesmo
enquanto estiver sendo executado, para obter melhor performance. Esta desco-
berta seria mediada por um servidor de meta-dados, que estaria sendo atualizado
permanentemente com informaes sobre os servidores e sua carga.
Explorar outros exemplos como renderizao de cenas por computadores distri-
budos, processamento de imagens distribudo, srevios de anlise e descoberta de
informaes, jogos multi-usurios, servios Peer to Peer, etc. como estes exem-
plos envolvem outras tecnologias e conhecimentos alm de programao, possi-
velmente sero tratados caso a caso, se houver interesse por parte de algum.
Como existiram restries de tempo quando escrevi este documento, e o contedo do

mesmo atende plenamente finalidade original (servir de subsdio aos alunos da disci-
plina Linguagem de Programao Orientada a Objetos do curso de Tecnlogo em Redes
de Computadores do Instituto Brasileiro de Tecnologia Avanada - IBTA, Unidade de
So Jos dos Campos), encerrei o documento com somente os tpicos apresentados. Em
outra ocasio, se houver demanda, poderei cobrir alguns dos tpicos sugeridos acima.
Rafael Santos
Maro de 2004

Aula03 Programacao de Redes de Computadores em Java PDF

Enviado por

Dados do documento

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

Aula03 Programacao de Redes de Computadores em Java PDF

Enviado por

Direitos autorais:

Formatos disponíveis

Programaode

Material reescrito para os alunos da disciplina CAP312 Programao

ltima modificao: 17 de junho de 2006

3 Desenvolvimento de aplicaes cliente-servidor em Java 4

5 Servidores simples (requisies no-simultneas) 13

6 Servidores para mltiplas requisies simultneas 31

7 Aplicaes baseadas em um servidor e vrios clientes 42

8 Aplicaes baseadas em um cliente e vrios servidores 49

Rafael Santos Programao Cliente-Servidor Usando Java

8 Exemplo de acesso ao servidor de strings invertidas usando telnet . . 17

Rafael Santos Programao Cliente-Servidor Usando Java

1. Precisamos executar uma aplicao especfica mas o computador ao qual temos

Rafael Santos Programao Cliente-Servidor Usando Java

No caso do exemplo 1, poderamos emprestar o hardware necessrio sem precisar-

O caso do exemplo 2 muito similar ao uso da Internet para acesso a informaes. O

Para o exemplo 3 podemos pensar em enviar as informaes ou resultados de diversas

No caso do exemplo 5, poderamos ter os computadores dos usurios consultando um

Em todos estes casos, estaremos usando alguma variante de aplicao cliente-servidor,

Rafael Santos Programao Cliente-Servidor Usando Java

processar a informao; e parte processamento do lado do servidor, ou do computador

Rafael Santos Programao Cliente-Servidor Usando Java

O protocolo define que partes do algoritmo que resolve o problema em questo

3 Desenvolvimento de aplicaes cliente-servidor em Java

Uma aplicao cliente-servidor em Java segue um padro relativamente simples de de-

Rafael Santos Programao Cliente-Servidor Usando Java

Figura 1: Algoritmo para leitura e processamento de uma string

O diagrama/algoritmo para o servidor o mostrado na figura 2.

Aguarda conexo do cliente

Figura 2: Algoritmo para o servidor de strings

O algoritmo mostrado na figura 1 no est completo: aps o passo Solicita conexo a

Rafael Santos Programao Cliente-Servidor Usando Java

Solicita conexo Aguarda conexo

L string Envia string

Imprime String lida

Figura 3: Algoritmo integrado do cliente e servidor de strings

vidades2 devemos descrever os algoritmos lado a lado, inclusive registrando os passos

Um outro exemplo de diagrama simplificado que mostra a interao entre um cliente e

interessante observar no algoritmo da figura 4 que alguns passos poderiam estar em

Rafael Santos Programao Cliente-Servidor Usando Java

Cliente Servidor 1 Servidor 2

Solicita conexo Aguarda conexo

L valor do produto Envia valor

Solicita conexo Aguarda conexo

L valor do produto Envia valor

Figura 4: Outro algoritmo integrado do cliente e servidores

Rafael Santos Programao Cliente-Servidor Usando Java

4.1 Exemplo: Cliente de daytime

Solicita conexo Aguarda conexo

L string Envia string

Imprime String lida

Figura 5: Protocolo de comunicao entre o cliente e o servidor de daytime

Rafael Santos Programao Cliente-Servidor Usando Java

Os pontos interessantes e chamadas a APIs da listagem 1 so:

O primeiro passo do algoritmo (a criao de uma conexo) feita pela criao

Rafael Santos Programao Cliente-Servidor Usando Java

partir desta instncia de InputStreamReader (usando-a como argumento para o

4.2 Exemplo: Cliente de echo

A diferena principal entre o diagrama mostrado na figura 6 e outros vistos anterior-

A implementao do cliente de echo mostrada na listagem 2.

Listagem 2: Cliente de echo

Rafael Santos Programao Cliente-Servidor Usando Java

Solicita conexo Aguarda conexo

Envia string para o servidor L string do cliente