Java network-sockets-etc

http://publicationslist.org/junio
Rede
Prof. Jose Fernando Rodrigues Junior
http://www.icmc.usp.br/~junio
junio@icmc.usp.br
INSTITUTO DE CIÊNCIAS MATEMÁTICAS E DE COMPUTAÇÃO - USP
SCC0504 - Programação Orientada a
Objetos

Rede – conceitos básicos
• A comunicação entre computadores é denominada comunicação via
rede de computadores
• Para que esta comunicação ocorra, os computadores participantes da
rede precisam seguir um protocolo
• Um protocolo é uma sequência de passos necessária para que os dois
computadores saibam:
• quando uma conexão começa e quando termina
• quando uma transmissão começa e quando termina
• quando ocorre uma falha, e como se recuperar da falha
• entre outras funcionalidades necessárias

Rede – conceitos básicos - TCP
• O protocolo mais usado é o Transmission Control Protocol (TCP)
• O TCP provê a transmissão segura (garantia de entrega),
ordenada, com verificação de erro, de um stream de bytes entre
dois programas de computador, cada um em um computador diferente
• O protocolo Internet Protocol (IP) funciona de maneira
complementar ao TCP (e a outros protocolos) oferecendo
funcionalidades de roteamento entre computadores
• Segundo o IP, um computador é identificado por um número IP
• Em cada computador, processos são identificados por números
de portas

Sockets
• Socket: trata-se de um conceito presente em diversas plataformas de
programação, o qual abstrai o uso do protocolo TCP para a
comunicação entre computadores
• Definição: uma socket é ponto terminal (endpoint = IP:port) de uma
conexão bi-direcional entre dois programas que usam a rede para se
comunicar.
• Uma socket é atrelada a um número de porta, de maneira que o
protocolo TCP possa identificar a aplicação para a qual os dados são
destinados

Sockets
O pacote java.net provê duas classes que possibilitam o uso de sockets:
• ServerSocket: usado para receber conexões
• Socket: usado para fazer conexões
• Basicamente o uso destas classes ocorre na seguinte ordem:
1. Abertura da Socket
2. Abertura de streams de leitura e escrita na Socket
3. Escrita e leitura de dados nas/das streams
4. Fechamento dos streams
5. Fechamento da socket
• O Java abstrai as funcionalidades de rede usando implementações
específicas de cada plataforma (Windows, Mac, Linux, ...)

Servidor TCP simples

• Servidor que repete o que o cliente envia:
Servidor
SERVIDOR

ServerSocket OUVIDO = new ServerSocket(8008);
Servidor
ServerSocket
OUVIDO
SERVIDOR

Socket SERVIDOR_SOCKET = OUVIDO.accept();
Servidor
ServerSocket
OUVIDO
OUVIDO.accept( )
SERVIDOR

Servidor
ServerSocket
OUVIDO
OUVIDO.accept( )
SERVIDOR CLIENTE
Socket

BufferedReader RECEBE = new BufferedReader(
new InputStreamReader(
SERVIDOR_SOCKET.getInputStream()));
Servidor
ServerSocket
OUVIDO
RECEBE
SERVIDOR CLIENTE
ENVIA

PrintWriter ENVIA = new PrintWriter(
new OutputStreamWriter(
SERVIDOR_SOCKET.getOutputStream()));
Servidor
ServerSocket
OUVIDO
RECEBE
SERVIDOR CLIENTE
RECEBE
ENVIA
ENVIA

String str = "";
while(str.compareTo("BYE") != 0){
str = RECEBE.readLine();
ENVIA.println("O servidor repete: "" + str + """);
ENVIA.flush();
}
Servidor
ServerSocket
OUVIDO
RECEBE
SERVIDOR
ENVIA
CLIENTE
RECEBE
ENVIA

String str = "";
ENVIA.flush();
}
RECEBE.close();
Servidor
ServerSocket
OUVIDO
SERVIDOR
ENVIA
CLIENTE
RECEBE

String str = "";
ENVIA.flush();
}
RECEBE.close();
ENVIA.close();
Servidor
ServerSocket
OUVIDO
SERVIDOR CLIENTE

String str = "";
ENVIA.flush();
}
RECEBE.close();
ENVIA.close();
SERVIDOR_SOCKET.close();
OUVIDO.close();
Servidor
SERVIDOR CLIENTE

String str = "";
ENVIA.flush();
}
RECEBE.close();
ENVIA.close();
OUVIDO.close();
Servidor
SERVIDOR CLIENTE
Perceba que existe um protocolo entre o servidor e o
cliente:
• no servidor: receber, e em seguida enviar
• no cliente: enviar, e em seguida receber
Protocolos são necessários em comunicação entre
computadores, pois eles definem o quê e quando as coisas irão
acontecer.
Em todos os próximos exemplos, sempre haverá um
protocolo, por mais simples que seja.

Cliente TCP simples

• Cliente que envia texto ao servidor:
ServerSocket
OUVIDO
OUVIDO.accept( )
SERVIDOR CLIENTE
Cliente

Socket CLIENTE_SOCKET = new Socket("localhost", 8008);
Cliente
ServerSocket
OUVIDO
OUVIDO.accept( )
SERVIDOR CLIENTE
Socket

ENVIA = new PrintWriter(
CLIENTE_SOCKET.getOutputStream(), true);
Cliente
ServerSocket
OUVIDO
SERVIDOR CLIENTE
Socket
RECEBE
ENVIA

RECEBE = new BufferedReader(
CLIENTE_SOCKET.getInputStream()));
Cliente
ServerSocket
OUVIDO
SERVIDOR CLIENTE
Socket
RECEBE
ENVIA RECEBE
ENVIA

BufferedReader LEITOR_ENTRADA_PADRAO = new BufferedReader(
new InputStreamReader(System.in));
Cliente
ServerSocket
OUVIDO
SERVIDOR CLIENTE
Socket
RECEBE
ENVIA RECEBE
ENVIA

String userInput = "";
while(userInput.compareTo(“BYE") != 0){
userInput = LEITOR_ENTRADA_PADRAO.readLine();
ENVIA.println(userInput);
System.out.println(RECEBE.readLine());
}
Cliente
ServerSocket
OUVIDO
SERVIDOR CLIENTE
Socket
RECEBE
ENVIA RECEBE
ENVIA

}
ENVIA.close();
Cliente
ServerSocket
OUVIDO
SERVIDOR CLIENTE
Socket
ENVIA RECEBE

}
ENVIA.close();
RECEBE.close();
Cliente
ServerSocket
OUVIDO
SERVIDOR CLIENTE
Socket

}
ENVIA.close();
RECEBE.close();
LEITOR_ENTRADA_PADRAO.close();
Cliente
ServerSocket
OUVIDO
SERVIDOR CLIENTE
Socket

}
ENVIA.close();
RECEBE.close();
LEITOR_ENTRADA_PADRAO.close();
CLIENTE_SOCKET.close();
Cliente
ServerSocket
OUVIDO
SERVIDOR CLIENTE

Servidor TCP simples para múltiplos clientes usando
Threads

String str = "";
ENVIA.flush();
}
RECEBE.close();
ENVIA.close();
OUVIDO.close();
Servidor com Threads

String str = "";
ENVIA.flush();
}
RECEBE.close();
ENVIA.close();
OUVIDO.close();
Este código se torna o run de uma
Thread.

while (bEscutando) {
EchoServerThread threadServidora = new EchoServerThread(SERVIDOR_SOCKET);
threadServidora.start();
}
OUVIDO.close();

public class EchoServerThread extends Thread {
private Socket SERVIDOR_SOCKET = null;
public EchoServerThread(Socket umCLIENTE) {
this.SERVIDOR_SOCKET = umCLIENTE;
}
public void run() {
String str = "";
ENVIA.flush();
}
RECEBE.close();
ENVIA.close();
}
}

public class EchoServerThread extends Thread {
private Socket SERVIDOR_SOCKET = null;
public EchoServerThread(Socket umCLIENTE) {
this.SERVIDOR_SOCKET = umCLIENTE;
}
public void run() {
String str = "";
ENVIA.flush();
}
RECEBE.close();
ENVIA.close();
}
}
AThread recebe um socket para se
comunicar com o cliente, e passa a
ser o servidor para aquele cliente.

Servidor TCP para objetos

• Servidor que recebe objetos do cliente:
Servidor
SERVIDOR

Servidor
ServerSocket
OUVIDO
SERVIDOR

Servidor
ServerSocket
OUVIDO
OUVIDO.accept( )
SERVIDOR

Servidor
ServerSocket
OUVIDO
OUVIDO.accept( )
SERVIDOR CLIENTE
Socket

ObjectInputStream RECEBE_OBJETO = new ObjectInputStream(
SERVIDOR_SOCKET.getInputStream());
Servidor
ServerSocket
OUVIDO
RECEBE
SERVIDOR CLIENTE
ENVIA

Servidor
ServerSocket
OUVIDO
RECEBE
SERVIDOR CLIENTE
RECEBE
ENVIA
ENVIA

Object oTemp = null;
do{
oTemp = RECEBE_OBJETO.readObject();
ENVIA.println(“Objeto recebido");
ENVIA.flush();
}while(oTemp != null);
Servidor
ServerSocket
OUVIDO
RECEBE
SERVIDOR
ENVIA
CLIENTE
RECEBE
ENVIA

do{
ENVIA.flush();
RECEBE_OBJETO.close();
Servidor
ServerSocket
OUVIDO
SERVIDOR
ENVIA
CLIENTE
RECEBE

do{
ENVIA.flush();
ENVIA.close();
Servidor
ServerSocket
OUVIDO
SERVIDOR CLIENTE

do{
ENVIA.flush();
ENVIA.close();
OUVIDO.close();
Servidor
SERVIDOR CLIENTE

Cliente TCP para objetos

• Cliente que envia objetos ao servidor:
ServerSocket
OUVIDO
OUVIDO.accept( )
SERVIDOR CLIENTE
Cliente

Cliente
ServerSocket
OUVIDO
OUVIDO.accept( )
SERVIDOR CLIENTE
Socket

ObjectOutputStream ENVIA_OBJETO = new ObjectOutputStream(
CLIENTE_SOCKET.getOutputStream());
Cliente
ServerSocket
OUVIDO
SERVIDOR CLIENTE
Socket
RECEBE
ENVIA

Cliente
ServerSocket
OUVIDO
SERVIDOR CLIENTE
Socket
RECEBE
ENVIA RECEBE
ENVIA

lista.add(new Retangulo());
lista.add(new Quadrado());
lista.add(new Triangulo());
Cliente
ServerSocket
OUVIDO
SERVIDOR CLIENTE
Socket
RECEBE
ENVIA RECEBE
ENVIA

for(Object o : lista){
ENVIA_OBJETO.writeObject(o);
}
Cliente
ServerSocket
OUVIDO
SERVIDOR CLIENTE
Socket
RECEBE
ENVIA RECEBE
ENVIA

}
ENVIA_OBJETO.writeObject(null);
Cliente
ServerSocket
OUVIDO
SERVIDOR CLIENTE
Socket
RECEBE
ENVIA RECEBE
ENVIA

}
ENVIA_OBJETO.close();
Cliente
ServerSocket
OUVIDO
SERVIDOR CLIENTE
Socket
ENVIA RECEBE

}
RECEBE.close();
Cliente
ServerSocket
OUVIDO
SERVIDOR CLIENTE
Socket

}
RECEBE.close();
CLIENTE_SOCKET.close();
Cliente
ServerSocket
OUVIDO
SERVIDOR CLIENTE

Rede – conceitos básicos - UDP
• Como vimos, o TCP provê a transmissão segura (com garantia de
entrega), ordenada, e com verificação de erro, de um stream de
bytes entre dois programas de computador, cada um em um computador
diferente
• No entanto, nem todas as aplicações tem estas necessidades, suponha,
por exemplo, uma aplicação peer-to-peer de transferência de
arquivos, como o BitTorrent
• Nesta aplicação, garantir entrega e ordem dos bytes pode
impedir seu uso, pois dificultará a gerência e a negociação de
múltiplos peers de transferência de arquivo, ao mesmo tempo em que
se recebem múltiplos arquivos – isto é, os dados não vem como
streams mas sim como torrentes (do dicionário: água rápida e impetuosa
que provém de grandes chuvas)

Rede – conceitos básicos - UDP
• Em sistemas desta natureza são usados datagramas UDP, ao invés de
streamsTCP
• O protocolo UDP prevê a transmissão de pacotes de dados
independentes uns dos outros, sem garantia de entrega, e sem
ordem de chegada
• A API Java tem duas classes para o uso do UDP
• DatagramPacket
• DatagramSocket

Servidor UDP simples

• Servidor que recebe e envia pacotes para o cliente:
Servidor
SERVIDOR
ip1:port1
CLIENTE
ip2:port2
UDP_SOCKET_CLIENTE

DatagramSocket UDP_SOCKET_SERVIDOR = new DatagramSocket(4445);
byte[] CAIXA_CORREIO = new byte[256];
Servidor
UDP_SOCKET_SERVIDOR
SERVIDOR
ip1:port1
CLIENTE
ip2:port2
UDP_SOCKET_CLIENTE

Servidor
SERVIDOR
ip1:port1
CLIENTE
ip2:port2
Internet
UDP_SOCKET_SERVIDOR UDP_SOCKET_CLIENTE

DatagramPacket UDP_PACOTE = new DatagramPacket(CAIXA_CORREIO, CAIXA_CORREIO.length);
UDP_SOCKET_SERVIDOR.receive(CAIXA_CORREIO);
Servidor
SERVIDOR
ip1:port1
CLIENTE
ip2:port2
Internet

InetAddress REMETENTE_IP = UDP_PACOTE.getAddress();
int REMETENTE_PORTA = UDP_PACOTE.getPort();
Servidor
SERVIDOR
ip1:port1
CLIENTE
ip2:port2
Internet

byte[] A_ENVIAR = new byte[256];
A_ENVIAR = (“O poder se consegue pela mão esquerda, mas se dá pela mão direita”).getBytes();
UDP_PACOTE = new DatagramPacket(A_ENVIAR,A_ENVIAR.length, REMETENTE_IP, REMETENTE_PORTA);
Servidor
SERVIDOR
ip1:port1
CLIENTE
ip2:port2
Internet

UDP_SOCKET_SERVIDOR.send(UDP_PACOTE);
Servidor
SERVIDOR
ip1:port1
CLIENTE
ip2:port2
Internet

UDP_SOCKET_SERVIDOR.send(UDP_PACOTE);
UDP_SOCKET_SERVIDOR.close();
Servidor
SERVIDOR
ip1:port1
CLIENTE
ip2:port2
Internet
UDP_SOCKET_CLIENTE

Cliente UDP simples

• Cliente que recebe e envia pacotes para o servidor:
Cliente
SERVIDOR
ip1:port1
CLIENTE
ip2:port2

A_ENVIAR = (“Me envie sabedoria”).getBytes();
DatagramPacket UDP_PACOTE = new DatagramPacket(A_ENVIAR,IP1, PORT1);
Cliente
SERVIDOR
ip1:port1
CLIENTE
ip2:port2
UDP_SOCKET_SERVIDOR

DatagramSocket UDP_SOCKET_CLIENTE = new DatagramSocket();
Cliente
SERVIDOR
ip1:port1
CLIENTE
ip2:port2
InternetInternet
UDP_SOCKET_CLIENTEUDP_SOCKET_SERVIDOR

UDP_SOCKET_CLIENTE.send(UDP_PACOTE);
Cliente
SERVIDOR
ip1:port1
CLIENTE
ip2:port2
InternetInternet

Cliente
SERVIDOR
ip1:port1
CLIENTE
ip2:port2
Internet

byte[] A_RECEBER = new byte[256];
UDP_PACOTE = new DatagramPacket(A_RECEBER, A_RECEBER.length);
UDP_SOCKET_CLIENTE.receive(UDP_PACOTE);
Cliente
SERVIDOR
ip1:port1
CLIENTE
ip2:port2
Internet

System.out.println(new String(UDP_PACOTE.getData(),0,UDP_PACOTE.getLength());
Cliente
SERVIDOR
ip1:port1
CLIENTE
ip2:port2
Internet
O poder se
consegue pela
mão esquerda,
mas se dá pela
mão direita.

Cliente
SERVIDOR
ip1:port1
CLIENTE
ip2:port2
Internet

UDP_SOCKET_CLIENTE.close();
Cliente
SERVIDOR
ip1:port1
CLIENTE
ip2:port2
Internet
UDP_SOCKET_SERVIDOR

Java network-sockets-etc

Recomendados

Mais conteúdo relacionado

Mais procurados (20)

Destaque (20)

Semelhante a Java network-sockets-etc (20)

Mais de Universidade de São Paulo (17)

Java network-sockets-etc