Java Sockets

Neste artigo vamos ficar a conhecer o suporte que Java oferece para a utilização do mecanismo de comunicação Socket, o mecanismo mais utilizado para a comunicação entre aplicações.Java permite o uso de socktes pelos seguintes modos utilização.

  • Modo Orientado à Conexão – Funciona com o protocolo TCP.
  • Modo Orientado ao Datagrama – Funciona com o protocolo UDP.
Ambos os modos funcionam sobre o protocolo IP(Internet Protocol).
Cada um destes modos tem a sua utilidade, vantagens e desvantagens na sua utilização.Modo Orientado á Conexão (TPC/IP).

  • Vantagens :

– Serviços confiáveis , sem perda de dados na rede e ordem dos pacotes.

– Possibilidade de usar DataStreams.

  • Desvantagens :

– É mais lento que o modo orientado ao datagrama.

– O comportamento do servidor é diferente do comportamento do cliente.Modo Orientado ao

Datagrama (UDP/IP).
  • Vantagens :

– É bastante mais rápido que o modo orientado a conexão.

  • Desvantagens :

– Serviços não confiáveis, mensagens perdidas na rede e perda da ordem das mensagens.

– Cada mensagem é um datagrama : [Remetente, Destinatário, Conteúdo].

Devido a uma maior utilização e estabilidade iremos apenas analisar e implementar o Modo Orientado à Conexão – TCP/IP.

Sockets TCP/IP

O processo de comunicação entre sockets TCP/IP, de uma forma simples, o servidor escolhe uma porta e aguarda conexões a essa porta, o cliente deve conter as seguintes informações :

– Endereço do Servidor (HOST).

– A porta usada pelo servidor(PORT).

Com essa informação o cliente solicita uma conexão ao servidor (Figura 1).

Figura1

Se após o pedido de conexão não ocorrer nenhum problema, o servidor aceita a conexão gerando um socket numa porta do servidor, o que vai criar um canal de comunicação entre o ciente e o servidor (Figura 2).

Figura2

Por norma o servidor funciona em ciclo (loop) esperando por novas conexões e criando sockets para solicitações de clientes.

Em seguida iremos ver as acções necessárias para implementar comunicações sobre TCP através de um socket cliente e um socket servidor.

Socket Client

1 – Abrir Conexão.

import java.io.*;
import java.net.*;
//Conectar ao servidor localhost na porta 8080.
Socket client = new Socket("127.0.0.1",8080);

2 – Obter Streams de entrada e saída para comunicação com o servidor.

//Cria um canal para receber dados.
DataInputStream in = new DataInputStream(client.getInputStream());
//Cria um canal para enviar dados.
DataOutputStream out = new DataOutputStream(client.getOutputStream());

3 – Realizar a comunicação com o servidor.

//Envia o inteiro 3000.
out.writeInt(3000);
//Envia a String “Olá - Socket Cliente.”.
out.writeUTF("Olá - Socket Cliente.");
//Espera pelo recebimento de um inteiro.
int valor = in.readInt();
//Espera pelo recebimento de uma String.
String texto = in.readUTF();

4 – Fechar as Streams e a conexão.

//Fecha o canal de entrada.
in.close();
//Fecha o canal de saída.
out.close();
//Fecha o Socket.
client.close();

Socket Servidor

1 – Criar Socket Server.

import java.io.*;
import java.net.*;
//Cria um socket servidor na porta 8080.
ServerSocket serveer = new ServerSocket(8080);

2 – Aguardar Conexões.

//O método accept retorna um socket para comunicação com o proximo cliente.
Socket sock = server.accept();

3 – Obter Streams de entrada e saída para comunicação com o cliente.

//Cria um canal para receber dados.
DataInputStream in = new DataInputStream(sock.getInputStream());
//Cria um canal para enviar dados.
DataOutputStream out = new DataOutputStream(sock.getOutputStream());

4 – Realizar a comunicação com o cliente.

//Espera pelo recebimento de um inteiro.
int valor = in.readInt();
//Espera pelo recebimento de uma String.
String texto = in.readUTF();
//Envia o inteiro 6000.
out.writeInt(6000);
//Envia a String “Olá - Socket Servidor.”.
out.writeUTF("Olá - Socket Servidor.");

5 – Fechar Streams e socket cliente.

//Fecha o canal de entrada.
in.close();
//Fecha o canal de saída.
out.close();
//Fecha o Socket que está a atender o cliente.
sock.close();

6 – Fechar o socket Servidor.

//Fecha o servidor.
server.close();

Em seguida podemos ver as classes Cliente e Servidor completamente implementadas.

Classe Cliente

1 import java.io.*;
2 import java.net.*;
3
4 public class Cliente{
5	public Socket client;
6	public DataInputStream in;
7	public DataOutputStream out;
8
9	public Cliente(){
10		try{
11			this.client = new Socket("127.0.0.1",8080);
12			this.in = new DataInputStream(client.getInputStream());
13			this.out = new DataOutputStream(client.getOutputStream());
14		}
15		catch(IOException e){
16			System.out.println(e.getMessage());
17		}
18	}
19
20	public static void main(String args[]){
21		try{
22			Cliente cli = new Cliente();
23			cli.out.writeInt(3000);
24			cli.out.writeUTF("Olá - Socket Cliente.");
25			int valor = cli.in.readInt();
26			String texto = cli.in.readUTF();
27			System.out.println(valor);
28			System.out.println(texto);
29			cli.in.close();
30			cli.out.close();
31			cli.client.close();
32		}
33		catch(IOException e){
34			System.out.println(e.getMessage());
35		}
36	}
37 }
Classe Servidor
1 import java.io.*;
2 import java.net.*;
3
4 public class Servidor{
5	public ServerSocket server;
6 	public Socket sock;
7	public DataInputStream in;
8	public DataOutputStream out;
9
10	public Servidor(){
11		try{
12			this.server = new ServerSocket(8080);
13			this.sock = this.server.accept();
14			this.in = new DataInputStream(sock.getInputStream());
15			this.out = new DataOutputStream(sock.getOutputStream());
16		}
17		catch(IOException e){
18			System.out.println(e.getMessage());
19		}
20	}
21
22	public static void main(String args[]){
23		try{
24			Servidor serv = new Servidor();
25			int valor = serv.in.readInt();
26			String texto = serv.in.readUTF();
27			System.out.println(valor);
28			System.out.println(texto);
29			serv.out.writeInt(6000);
30			serv.out.writeUTF("Olá - Socket Servidor.");
31			serv.in.close();
32			serv.out.close();
33			serv.sock.close();
34			serv.server.close();
35		}
36		catch(IOException e){
37			System.out.println(e.getMessage());
38		}
39	}
40 }

Este artigo foi originalmente escrito por Fábio Correira (magician) para a 6ª Edição da Revista PROGRAMAR

Anúncios

One thought on “Java Sockets

Deixe uma Resposta

Preencha os seus detalhes abaixo ou clique num ícone para iniciar sessão:

Logótipo da WordPress.com

Está a comentar usando a sua conta WordPress.com Terminar Sessão /  Alterar )

Google photo

Está a comentar usando a sua conta Google Terminar Sessão /  Alterar )

Imagem do Twitter

Está a comentar usando a sua conta Twitter Terminar Sessão /  Alterar )

Facebook photo

Está a comentar usando a sua conta Facebook Terminar Sessão /  Alterar )

Connecting to %s