Aps 5 periodo - Desenv Ferram Redes

Prévia do material em texto

25 
 
25 
 
129 
 
 
UNIP – UNIVERSIDADE PAULISTA
 
 
 
 
 
 
 
CURSO: CIÊNCIA DA COMPUTAÇÃO
LUCAS LAZZARI LASKOSKI - RA: D87CAH-3
ANTONIO CARLOS A. DO N. JUNIOR - RA: N4695J-2
DANILO CÉSAR MENDES PIMENTA - RA: D93CCC-0
ANDREY MOTA DE ALMEIDA - RA: N4055E-3
LUCAS FONSECA CORREA - RA: F029948
ACKSON MENTA – RA: N464BE4
 
 
 
 
DESENVOLVIMENTO DE UMA FERRAMENTA PARA COMUNICAÇÃO EM REDE
 
 
 
 
 
 
 
 
 
 
 
 
MANAUS
2020
ÍNDICE
Objetivo do trabalho_________________________________________3
Introdução_________________________________________________4
Referencial Teórico__________________________________________6
Desenvolvimento da Aplicação________________________________16
Estrutura do programa______________________________________27
Relatório com as linhas de código_____________________________29
Conclusão________________________________________________39
Bibliografia_______________________________________________41
OBJETIVO DO TRABALHO
Este trabalho tem como objetivo apresentar o desenvolvimento de uma ferramenta para comunicação em rede, quais são suas principais características, demonstrar como funcionam, aplicá-los em um programa, obter os resultados e discutir sobre eles.
INTRODUÇÃO
A linha de conhecimento e pesquisa “Redes de Comunicação de Dados” concentra as áreas tradicionalmente chamadas de “Redes de Comunicações e Redes de Computadores”. A distinção entre estas áreas era mais aparente no passado, no entanto, com o advento da convergência das tecnologias de computação e de comunicação os seus limites se tornarem quase indistintos e uma acaba sobrepondo outra. (Blog União geek, 2016).
A palavra rede (network) tem várias definições. Aplicada aos computadores, rede é uma maneira de conectar computadores para que eles tenham consciência um do outro e possam unir e compartilhar seus recursos. (Nobrega Filho, 2016).
Entre os anos 70 e 80 ocorreu uma fusão dos campos de Ciência da Computação e Comunicação de Dados e isto trouxe vários fatos relevantes. Nas empresas, escolas e em muitos outros tipos de organização, as redes de comunicação de dados, em seus diversos tipos oferecem vários benefícios.
A Comunicação Dados é uma disciplina da área de “Ciências da Computação” que trata da transmissão de informação entre sistemas computacionais e dispositivos diferentes através de um meio de transmissão. A transmissão de informação pressupõe a passagem de sinais através dos meios físicos de comunicação que compõem as redes.
A Transmissão de Dados é uma matéria cada vez mais importante para qualquer pessoa que opere com equipamentos que estejam inseridos num sistema de comunicação, que explora maneiras ou técnicas, através das quais as informações são transmitidas. Para uma transmissão dada numa via de comunicação entre duas máquinas, a comunicação pode ser realizada de diferentes formas.
O modo de transmissão designa o número de unidades elementares de informações (bits) que podem ser transmitidas simultaneamente pelo canal de comunicação, ou seja, trata diretamente, a quantidade de bits a ser transmitida ao mesmo tempo. (André H O Santos, 2016).
Na área comercial, por exemplo, as redes revolucionaram o uso da tecnologia dos computadores. Muitas empresas que costumavam depender de um sistema centralizado em um Mainframe (Servidor Dedicado de Grande Porte) com uma série de terminais agora usam redes de computadores, em que cada empregado tem um computador em sua mesa. A tecnologia e a perícia dos computadores não estão mais centralizadas no Mainframe de uma companhia e em seu departamento de Tecnologia da Informação; elas estão distribuídas por toda a organização, entre uma rede de computadores e usuários preparados. (Nobrega Filho, 2016).
A indústria da computação, por assim dizer, teve um progresso espetacular em um curto período de tempo e as redes de comunicação também fazem parte desse crescimento tendo um papel fundamental nos processos de comunicação para o mundo globalizado. As redes de comunicação, cada vez mais rápidas e eficientes, permitiram a comunicação e o acesso rápido a qualquer parte do globo de forma praticamente instantânea.
Os principais tipos de redes são: LAN; CAN; MAN; WAN; RAN; PAN; SAN; VLAN; WLAN; WMAN; WWAN.
O ambiente de desenvolvimento do programa será o NetBeans, utilizando a linguagem Java.
REFERENCIAL TEÓRICO
História
Antes do advento de computadores dotados com algum tipo de sistema de telecomunicação, a comunicação entre máquinas calculadoras e computadores antigos era realizada por usuários humanos através do carregamento de instruções entre eles. Em setembro de 1940, George Stibitz usou uma máquina de teletipo para enviar instruções para um conjunto de problemas a partir de seu Model K na Faculdade de Dartmouth em Nova Hampshire para a sua calculadora em Nova Iorque e recebeu os resultados de volta pelo mesmo meio. Conectar sistemas de saída como teletipos a computadores era um interesse na Advanced Research Projects Agency (ARPA) quando, em 1962, J. C. R. Licklider foi contratado e desenvolveu um grupo de trabalho o qual ele chamou de a "Rede Intergaláctica", um precursor da ARPANET.
Em 1964, pesquisadores de Dartmouth desenvolveram o Sistema de Compartilhamento de Tempo de Dartmouth para usuários distribuídos de grandes sistemas de computadores. No mesmo ano, no MIT, um grupo de pesquisa apoiado pela General Electric e Bell Labs usou um computador (DEC’s PDP-8) para rotear e gerenciar conexões telefônicas.
Durante a década de 1960, Leonard Kleinrock, Paul Baran e Donald Davies, de maneira independente, conceituaram e desenvolveram sistemas de redes os quais usavam datagramas ou pacotes, que podiam ser usados em uma rede de comutação de pacotes entre sistemas de computadores.
Em 1969, a Universidade da Califórnia em Los Angeles, SRI (em Stanford), a Universidade da Califórnia em Santa Bárbara e a Universidade de Utah foram conectadas com o início da rede ARPANET usando circuitos de 50 kbits/s.
Em 1972, foram implantados X.25 nos serviços comerciais e, mais tarde, usado como uma infraestrutura básica para a expansão de redes TCP/IP.
Em 1973, a rede francesa CYCLADES foi o primeiro a fazer os hosts responsável pela entrega confiável de dados, em vez de este ser um serviço centralizado da própria rede.
Em 1973, Robert Metcalfe escreveu um memorando formal na Xerox PARC, descrevendo um sistema de rede Ethernet, que foi baseada na rede Aloha, desenvolvido na década de 1960 por Norman Abramson e colegas na Universidade do Havaí.
Em 1976, John Murphy da Datapoint Corporation cria a ARCNET, uma rede de passagem de token usada pela primeira vez para compartilhar dispositivos de armazenamento.
Em 1995, a velocidade de transmissão para Ethernet aumentou sua capacidade para 10 Mbit/s e 100 Mbit/s.
Em 1998, a capacidade de transmissão da Ethernet chegou no Gigabit, mas não parou por aí, posteriormente, altas velocidades de até 100 Gbit/s foram adicionadas (em 2016).
A capacidade de Ethernet para escalar facilmente (como se adaptar rapidamente para suportar novas velocidades de cabo de fibra óptica) é um fator que contribui para o seu uso continuado.
Redes de computadores e as tecnologias necessárias para conexão e comunicação através e entre elas continuam a comandar as indústrias de hardware de computador, software e periféricos. Essa expansão é espelhada pelo crescimento nos números e tipos de usuários de redes, desde o pesquisador até o usuário doméstico.
Atualmente, redes de computadores são o núcleo da comunicação moderna. O escopo da comunicação cresceu significativamente na década de 1990 e essa explosão nas comunicações não teria sido possível sem o avanço progressivo das redes de computadores.
Antigamente era comum os centros de computação, que consistia em um ou mais computadores centralizados em um cômodo, responsáveis por realizar todo o processamento de uma organização. A união de computadores e um meio de comunicação entre eles fezcom que esses centros computacionais se tornassem algo arcaico, pois o trabalho de processamento poderia ser distribuído entre diversos dispositivos menos potentes e interconectados. O que permite essa união são as redes de computadores. 
O que é uma rede de computadores? 
Redes de computadores refere-se a interconexão por meio de um sistema de comunicação baseado em transmissões e protocolos de vários computadores com o objetivo de trocar informações, além de outros recursos. Essa conexão é chamada de estações de trabalho (nós, pontos ou dispositivos de rede).
Uma rede de computadores permite que o usuário compartilhe uma enorme quantidade de informações e enviem mensagens uns aos outros, incluindo textos, imagens, áudios e vídeos. 
As redes são divididas em duas categorias principais: redes locais (LANs) e redes remotas (WANs). Esses dois tipos têm diferentes características e diferentes funcionalidades. A Internet é um conjunto de redes LANs e WANs interconectadas por dispositivos de ligação entre elas. 
Sua composição é formada por cinco componentes essenciais, que são: 
 
Mensagem: As mensagens são as informações a serem transmitidas. 
Emissor: O emissor é o dispositivo que envia a mensagem de dados.
Receptor: O receptor é o dispositivo que recebe a mensagem.
Meio de transmissão: O meio de transmissão é o caminho físico pelo qual uma mensagem trafega do emissor ao receptor. 
Protocolo: O protocolo é um conjunto de regras que controla a comunicação de dados. 
Independentemente do tamanho e do grau de complexidade, o objetivo básico de uma rede de computadores é garantir que todos os recursos de informação sejam compartilhados rapidamente, com segurança e de forma confiável. Para tanto, a rede deve possuir meios de transmissão eficientes, regras básicas (protocolos) e mecanismos capazes de garantir o transporte das informações entre os seus elementos constituintes. 
Os diferentes tipos de redes de computadores são definidos por dois fatores principais, sendo eles:
O modelo dos equipamentos que serão conectados a ela;
A distância que esses equipamentos se encontram um do outro.
Tipos de redes
Redes locais: Ela é uma propriedade privada que conecta alguns hosts em um único escritório, prédio, campus. Dependendo da necessidade de uma organização, uma LAN pode ser simples com apenas dois computadores e uma impressora no escritório da casa de alguém ou pode se estender por toda a empresa e incluir dispositivos de áudio e vídeo. Cada host em uma LAN possui um identificador, ou seja, um endereço que o define de forma unívoca na LAN. Um pacote enviado de um host para outro carrega tanto o endereço do host de origem como o de destino. 
 
Redes metropolitanas: Ela abrange uma cidade. O exemplo mais conhecido de uma MAN é a rede de televisão a cabo disponível em muitas cidades. Esse sistema cresceu a partir de antigos sistemas de antenas comunitárias usadas em áreas com fraca recepção do sinal de televisão pelo ar. Nesses primeiros sistemas, uma grande antena era colocada no alto de colina próxima e o sinal era então conduz ido até a casa dos assinantes. 
Redes geograficamente distribuídas: Ela é uma rede de longa distância (WAN – Wide Area Network) como uma interligação de dispositivo capazes de se comunicar. No entanto existem, algumas diferenças entre uma LAN e uma WAN. A LAN normalmente tem tamanho limitado, estendendo-se por um escritório, edifícios ou campus, enquanto uma WAN tem uma extensão geográfica maior, abrangendo uma cidade, um estado, um país ou até mesmo o mundo. 
Redes sem fios: Elas podem ser divididas em três categorias principais: 
 
Interconexão de sistemas: Significa interconectar os componentes de um computador usando rádio de alcance limitado.
LANs sem fios: são sistemas em que todo computador tem um modem de rádio e uma antena por meio dos quais pode se comunicar com outros sistemas.
 
WANs sem fios: é usada em sistemas geograficamente distribuídos. 
 
Inter-redes: Ela é formada quando diferentes redes estão interconectadas. No nosso ponto de vista, a conexão de uma LAN e uma WAN ou a conexão de duas LANs forma uma inter-rede, mas ainda não existe um consenso na indústria quanto à terminologia a ser usada nessa área. Uma regra prática é que, se diferentes organizações pagam pela construção de partes distintas da rede e cada mantém sua parte, temos uma inter-rede, e não uma única rede.
Existem uma série de fatores que influenciam na escolha do tipo de rede ideal para sua empresa, tais como o segmento, porte e número de colaboradores.
Principais redes:
LAN: Esse é o formato com o qual estamos mais habituados. A LAN (Local Area Networks) é uma rede local, ou seja, de curta distância. Ela conecta dispositivos próximos, reunidos em um mesmo ambiente, por exemplo, o escritório de uma PME ou uma residência.
CAN: A CAN (Campus Area Network) – ou seja, uma rede de campus – possui um propósito bastante parecido com a LAN. Contudo, ela já possui um alcance maior. Sua utilidade é permitir a conexão entre redes de um mesmo complexo ou condomínio, como universidades, hospitais e centros comerciais.
MAN: Para conectar as redes locais dentro de distâncias maiores, você pode utilizar a MAN (Metropolitan Area Network), que significa rede metropolitana. Ela pode ser utilizada para estabelecer uma conexão entre escritório que estão em um mesmo município ou cidades vizinhas, cobrindo algumas dezenas de quilômetros.
WAN: A WAN (Wide Area Network) é uma rede de longa distância. Sua cobertura é bastante superior à das redes LAN e MAN. Com ela é possível conectar equipamentos em diferentes localidades, de países até continentes.
RAN: RAN é a sigla para Regional Area Network, em português, rede de área regional. Conta com alcance maior que as redes do tipo LAN e MAN, porém menor que as WAN. A conexão de alta velocidade, através de fibra ótica, é uma de suas principais características.
PAN: A rede PAN (Personal Area Network), que significa rede de área pessoal, é a com maior limitação de alcance. Ela conecta apenas aparelhos que estão a uma distância curtíssima, um exemplo desse tipo de rede é o Bluetooth.
SAN: Já a rede SAN (Storage Area Network), em tradução livre, rede de área para armazenamento, tem apenas uma função. Portanto, ela é a responsável por armazenar dados da rede e fazer a comunicação entre um servidor e os demais dispositivos.
VLAN: A versão virtual da rede LAN, a VLAN (Virtual LAN), reúne diversas máquinas de forma lógica e não física. Sendo assim, ela é capaz de dividir uma LAN física, em diversas redes virtuais.
As redes de computadores sem fio: Como em qualquer outra área, as redes de computadores precisaram se adaptar ao uso das tecnologias sem fio. Além de todas as alternativas que citamos as redes LAN, MAN e WAN também contam suas versões wireless, sendo elas: WLAN; WMAN; WWAN.
Transmissão de Dados
Para uma transmissão dada numa via de comunicação entre duas máquinas, a comunicação pode ser realizada de diferentes formas, definindo-se por:
Sentido da Transmissão (Trocas):
Simples: A comunicação simples é aquela em que há somente um transmissor e um receptor.
Half-duplex: Neste modo, cada estação pode transmitir e receber, mas nunca ao mesmo tempo.
Full-duplex: Neste modo, ambas estações podem transmitir e receber simultaneamente, ou seja, ao mesmo tempo.
Modo de Transmissão (Meio):
Trata-se do número de bits enviadas simultaneamente:
Paralela: Na transmissão em modo paralelo, os bits que compõem o carácter são enviados simultaneamente através de várias vias de dados. 
Serial: Na transmissão em modo série, os bits que compõem a informação são enviados um a um através de uma única via de dados.
Sincronização (Tipos):
Trata-se da sincronização entre emissor e receptor:
Síncrono: Na transmissão em modo Síncrono os dados são enviados em blocos e em intervalos de tempo definidos, dados de sincronismo são enviados durante a transmissão para manter o sincronismo entre as máquinas.
Assíncrono: No modo de transmissão Assíncrono os dados são enviados um a um semcontrole de tempo entre um e outro. 
Modelos de referência 
 
Examinaremos duas importantes arquiteturas de rede, o modelo de referência OSI e o modelo de referência TCP/IP.
 
Referência OSI 
 
Esse modelo se baseia em uma proposta desenvolvida pela ISO (International Standards Organization) como um primeiro passo em direção à padronização internacional dos protocolos empregados nas diversas camadas. Ele foi revisto em 1995. O modelo é chamado Modelo de Referência ISO OSI (Open Systems Interconnection), pois ele trata da interconexão de sistemas abertos. O modelo OSI tem sete camadas. (TANENBAUM e WETHERALL, 2011, p. 28).
Camadas:
Camada Física: A camada física trata da transmissão de bits brutos por um canal de comunicação. O projeto da rede deve garantir que, quando um lado enviar um bit um, o outro lado o receberá como um bit um, não como um bit zero. 
Camada de Enlace de Dados: A principal tarefa da camada de enlace de dados é transformar um canal de transmissão bruta em uma linha que pareça livre de erros de transmissão não detectados para a camada de rede.
Camada de Rede: Controla a operação da sub-rede. Uma questão fundamental de projeto é determinar a maneira como os pacotes são roteados da origem até o destino. 
Camada de Transporte: A função básica da camada de transporte é aceitar dados da camada acima dela, dividi-los em unidades menores, caso necessário, repassar essas unidades à camada de rede e assegurar que todos os fragmentos chegarão corretamente à outra extremidade. 
Camada de Sessão: Permite que os usuários de diferentes máquinas estabeleçam sessões entre eles. Uma sessão oferece diversos serviços, inclusive o controle de diálogo (mantendo o controle de quem deve transmitir em cada momento), o gerenciamento de símbolos (impedindo que duas partes tentem executar a mesma operação crítica ao mesmo tempo) e a sincronização (realizando a verificação periódica de transmissões longas para permitir que elas continuem a partir do ponto em que estavam ao ocorrer uma falha).
Camada de Apresentação: Diferente das camadas mais baixas, que se preocupam principalmente com a movimentação de bits, a camada de apresentação está relacionada à sintaxe e à semântica das informações transmitidas.
Camada de Aplicação: Contém uma série de protocolos comumente necessários para os usuários. Um protocolo de aplicação amplamente utilizado é o HTTP (Hyper Text Transfer Protocol), que constitui a base para a World Wide Web.
Referência TCP/IP 
Quando foram criadas as redes de rádio e satélite, começaram a surgir problemas com os protocolos existentes, o que forçou a criação de uma nova arquitetura de referência. Desse modo, a habilidade para conectar várias redes de maneira uniforme foi um dos principais objetivos de projeto, desde o início. Mais tarde, essa arquitetura ficou conhecida como Modelo de Referência TCP/IP, graças a seus dois principais protocolos. Segundo Comer e Stevens (1999, p. 01) o conjunto de protocolos da internet TCP/IP é o padrão mundial para interconexão de sistemas abertos. Nenhum outro conjunto de protocolos proporciona tanta interoperabilidade ou abrange sistemas de tantos fornecedores. 
Camadas:
Camada Inter-rede: Sua tarefa é permitir que os hosts injetassem pacotes em qualquer rede e garantir que eles trafegarão independentemente e até o destino (talvez em uma rede diferente).
Camada de Transporte: A finalidade dessa camada é permitir que as entidades pares dos hosts de origem e de destino mantenham uma conversação, exatamente como acontece na camada de transporte OSI.
Camada de Aplicação: Acima da camada de transporte, encontramos a camada de aplicação. Ela contém todos os protocolos de nível mais alto. Dentre eles estão o protocolo de terminal virtual (TELNET), o protocolo de transferência de arquivos (FTP) e o protocolo de correio eletrônico (SMTP).
Camada Host/Rede: Abaixo da camada inter-redes, encontra-se um grande vácuo. O modelo de referência TCP/IP não especifica muito bem o que acontece ali, exceto o fato de que o host tem de se conectar à rede utilizando algum protocolo para que seja possível enviar pacotes IP. Esse protocolo não é definido e varia de host para host e de rede para rede. Os livros e a documentação que tratam do modelo TCP/IP raramente descrevem esse protocolo. 
Paradigmas da camada de aplicação
Dois paradigmas foram desenvolvidos desde o surgimento da Internet: o paradigma cliente-servidor e o paradigma peer-to-peer. 
 Paradigma cliente-servidor 
 No paradigma cliente-servidor o provedor de serviços é um aplicativo chamado processo-servidor, é executado continuamente à espera de outro aplicativo, chamado processo-cliente, que cria uma conexão através da rede e solicita o serviço. Normalmente, existem alguns processos-servidores que podem fornecer um tipo específico de serviço, mas há muitos clientes que solicitam o serviço de qualquer um desses processos-servidores. O processo-servidor deve ser executado o tempo todo, o processo-cliente é iniciado quando o cliente precisa receber o serviço. Em um paradigma cliente-servidor, a comunicação na camada de aplicação se dá entre dois aplicativos em execução denominados processos: um cliente e um servidor.
Paradigma par a par 
 O paradigma par a par surgiu para responder às necessidades de novas aplicações. Nesse paradigma, não há necessidade de um processo-servidor que seja executado o tempo todo e espere pela conexão dos processos clientes. A responsabilidade é compartilhada entre os pares (os nós da rede). Um computador conectado à Internet pode prover serviços em dado momento e receber serviços em outro; pode até mesmo prover e receber serviços ao mesmo tempo. 
 Protocolos da camada de transporte 
A camada de transporte está localizada entre a camada de aplicação e a camada de rede na pilha de protocolos TCP/IP. Ela fornece serviços à camada de aplicação e recebe serviços da camada de rede. A camada de transporte atua como uma ligação entre um programa-cliente e um programa-servidor, como uma conexão de processo para processo. A camada de transporte é o coração da pilha de protocolos TCP/IP; ela é o meio lógico fim a fim para transferir dados de um ponto a outro na Internet. 
 Protocolo de datagramas de usuário 
O protocolo de datagramas de usuário (UDP – User Datagram Protocol) é um protocolo de transporte não confiável e não orientado à conexão. Ele não acrescenta nada aos serviços do IP, exceto pelo fornecimento de comunicação processo a processo em vez de comunicação host a host. O UDP é um protocolo muito simples, que tem um uso mínimo de recursos. Se um processo quiser enviar uma mensagem pequena e não se importar muito com a confiabilidade da transmissão, ele pode usar o UDP. Enviar uma mensagem pequena usando o UDP exige muito menos interação entre o emissor e o receptor do que se o TCP for usado. 
Protocolo de controle de transmissão 
 O protocolo de controle de transmissão (TCP – Transmission Control Protocol) é um protocolo orientado à conexão e confiável. O TCP define explicitamente o estabelecimento da conexão, a transferência de dados e o fechamento para oferecer um serviço orientado à conexão. O TCP usa uma combinação de protocolos do tipo GBN e RS para fornecer confiabilidade. Para atingir esse objetivo, faz uso de mecanismos de soma de verificação (checksum, para detecção de erros), retransmissão de pacotes perdidos ou corrompidos, confirmações cumulativas e seletivos e temporizadores.
Sockets 
A interface socket surgiu no início de 1980 na Universidade de Berkeley como parte de um ambiente UNIX; um conjunto de instruções que fornecem comunicação entre a camada de aplicação e o sistema operacional. É um conjunto de instruções que podem ser usadas por um processo para se comunicar com outro.
A ideia de sockets nos permite usar o conjunto de todas as instruções já projetadas em uma linguagem de programação para outros dispositivos de entrada e saída. Por exemplo, na maioria das linguagens de programação existem várias instruções para ler e gravar dados em dispositivos de entradae saída. Podemos usar as mesmas instruções para ler ou escrever em sockets, ou seja, estamos adicionando apenas novas entidades de entrada e saída à linguagem de programação, sem alterar a forma de enviar ou receber dados. Apesar de um socket ter que se comportar como um terminal ou um arquivo, ele não é uma entidade física como eles, mas sim, uma abstração; é uma estrutura de dados criada e utilizada pelo aplicativo. 
Pode-se dizer que, no que diz respeito à camada de aplicação, a comunicação entre um processo-cliente e um processo-servidor se limita à comunicação entre dois sockets como a entidade que recebe o pedido e envia a resposta: o servidor percebe o socket como aquele que tem um pedido e precisa da resposta. Se criarmos dois sockets, um em cada sistema final, e definirmos os endereços de origem e destino corretamente, podem usar as instruções disponíveis para enviar e receber dados. O resto é responsabilidade do sistema operacional e do protocolo TCP/IP a ele incorporado. 
Endereços de socket 
A interação entre um cliente e um servidor é uma comunicação bidirecional, na qual precisamos de um par de endereços: um local (remetente) e um remoto (receptor). O endereço local em uma direção é o endereço remoto na outra direção e vice-versa. Como a comunicação no paradigma cliente-servidor é entre dois sockets, precisamos de um par de endereços de socket para a comunicação: um endereço de socket local e outro de socket remoto. No entanto, devemos definir um endereço de socket em termos de identificadores utilizados na pilha de protocolos TCP/IP. Um endereço de socket deve primeiro definir o computador no qual um cliente ou um servidor está sendo executado. No entanto, vários processos cliente e servidor podem estar em execução ao mesmo tempo em um computador, o que significa que precisamos de um outro identificador para definir o processo-cliente ou servidor específico envolvido na comunicação.
Sockets usados no TCP 
 O servidor TCP usa dois sockets distintos, um para o estabelecimento da conexão e outro para a transferência de dados. Chamamos o primeiro de socket de escuta (ou listen socket) e o segundo simplesmente de socket. O objetivo de se ter dois tipos de socket é separar a fase de conexão da fase de troca de dados. Um servidor usa um socket de escuta para ficar escutando novos clientes tentando estabelecer conexões. Quando uma conexão for estabelecida, o servidor cria um socket para trocar dados com o cliente e, finalmente, encerra a conexão. 
Sockets usados no UDP 
Na comunicação via UDP, o cliente e o servidor utilizam apenas um socket cada. O socket criado no lado do servidor nunca é fechado; o criado no lado do cliente é fechado (destruído) quando o processo-cliente é encerrado. Em outras palavras, diferentes clientes usam sockets distintos, mas o servidor cria um único socket e só muda o endereço de socket remoto quando um novo cliente o acessa. Isto faz sentido, já que o servidor sabe seu próprio endereço de socket, mas não sabe o dos clientes que precisam acessá-lo; ele precisa esperar pelo acesso do cliente para preencher esse campo do socket.
DESENVOLVIMENTO DA APLICAÇÃO
Para começar, temos a declaração dos pacotes usados na classe servidor.java. É usado “streams”, “collections” e classes para a construção de formulários.
Declaração dos imports:
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.Writer;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.ArrayList;
import javax.swing.JLabel;
import javax.swing.JOptionPane;
import javax.swing.JTextField;
Em seguida temos a declaração da classe servidor.java. Ela extends Thread, logo é um tipo de Thread, adotando todos os comportamentos e propriedades desta classe.
Classe:
public class Servidor extends Thread {
Neste momento é feita a declaração dos atributos estáticos e de instâncias da classe servidor.java. O atributo “clientes” é usado para armazenar o BufferedWriter de cada cliente conectado e o server socket é usado para a criação do servidor, que teoricamente deve ser feita apenas uma vez.
Atributos estáticos:
private static ArrayList<BufferedWriter>clientes;
private static ServerSocket server;
private String nome;
private Socket con;
private InputStream in;
private InputStreamReader inr;
private BufferedReader bfr;
Agora temos a declaração do método construtor, que recebe um objeto socket como parâmetro e cria um objeto do tipo BufferedReader, que aponta para o stream do cliente socket.
Declaração do método construtor:
/**
 * Método construtor
 * @param com do tipo Socket
 */
public Servidor(Socket con){
 this.con = con;
 try {
 in = con.getInputStream();
 inr = new InputStreamReader(in);
 bfr = new BufferedReader(inr);
 } catch (IOException e) {
 e.printStackTrace();
 }
}
É feita a declaração do método “run”: toda vez que um cliente novo chega ao servidor, esse método é acionado e alocado numa Thread e também fica verificando se existe alguma mensagem nova. Caso exista, esta será lida e o evento “sentToAll” será acionado para enviar a mensagem para os demais usuários conectados no chat.
Declaração do método run:
/**
 * Método run
 */
public void run(){
 try{
 String msg;
 OutputStream ou = this.con.getOutputStream();
 Writer ouw = new OutputStreamWriter(ou);
 BufferedWriter bfw = new BufferedWriter(ouw);
 clientes.add(bfw);
 nome = msg = bfr.readLine();
 while(!"Sair".equalsIgnoreCase(msg) && msg != null)
 {
 msg = bfr.readLine();
 sendToAll(bfw, msg);
 System.out.println(msg);
 }
 }catch (Exception e) {
 e.printStackTrace();
 }
}
Temos a declaração do método “sendToAll”. Quando um cliente envia uma mensagem, o servidor recebe e manda esta mensagem para todos os outros clientes conectados. Veja que para isso é necessário percorrer a lista de clientes e mandar uma cópia da mensagem para cada um.
Declaração do método sendToAll:
/***
 * Método usado para enviar mensagem para todos os clients
 * @param bwSaida do tipo BufferedWriter
 * @param msg do tipo String
 * @throws IOException
 */
public void sendToAll(BufferedWriter bwSaida, String msg) throws IOException
{
 BufferedWriter bwS;
 for(BufferedWriter bw : clientes){
 bwS = (BufferedWriter)bw;
 if(!(bwSaida == bwS)){
 bw.write(nome + " -> " + msg+"\r\n");
 bw.flush();
 }
 }
}
		A declaração do método main é feita aqui, ela que quando iniciar o servidor, fará a configuração do servidor socket e sua respectiva porta. Veja que ele começa criando uma janela para informar a porta e depois entra no “while(true)”. Na linha “server.accept()” o sistema fica bloqueado até que um cliente socket se conecte: se ele fizer isso é criada uma nova Thread do tipo servidor.
Lembre-se que a classe servidor é um tipo de Thread e é iniciada na instrução “t.start()”. Então o controle do fluxo retorna para a linha “server.accept()” e aguarda outro cliente se conectar.
Declaração do método main:
/***
 * Método main
 * @param args
 */
public static void main(String []args) {
 try{
 //Cria os objetos necessário para instânciar o servidor
 JLabel lblMessage = new JLabel("Porta do Servidor:");
 JTextField txtPorta = new JTextField("12345");
 Object[] texts = {lblMessage, txtPorta };
 JOptionPane.showMessageDialog(null, texts);
 server = new ServerSocket(Integer.parseInt(txtPorta.getText()));
 clientes = new ArrayList<BufferedWriter>();
 JOptionPane.showMessageDialog(null,"Servidor ativo na porta: "+
 txtPorta.getText());
 while(true){
 System.out.println("Aguardando conexão...");
 Socket con = server.accept();
 System.out.println("Cliente conectado...");
 Thread t = new Servidor(con);
 t.start();
 }
 }catch (Exception e) {
 e.printStackTrace();
 }
 }// Fim do métodomain
} //Fim da classe
A declaração dos pacotes usados na classe cliente.java.
Declaração dos Imports:
import java.awt.Color;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.Writer;
import java.net.Socket;
import javax.swing.*;
A seguir temos a declaração da classe Cliente.java:
Classe:
public class Cliente extends JFrame implements ActionListener, KeyListener {
Para a construção do formulário foram usados objetos do pacote javax.swing.
Aqui é mostrada a declaração dos atributos estáticos e de instâncias da classe Cliente.java.
Declaração dos atributos:
private static final long serialVersionUID = 1L;
private JTextArea texto;
private JTextField txtMsg;
private JButton btnSend;
private JButton btnSair;
private JLabel lblHistorico;
private JLabel lblMsg;
private JPanel pnlContent;
private Socket socket;
private OutputStream ou ;
private Writer ouw;
private BufferedWriter bfw;
private JTextField txtIP;
private JTextField txtPorta;
private JTextField txtNome;
Quando a classe cliente é executada aparece uma tela para o usuário informar alguns parâmetros como o IP do servidor, a porta e o nome que será visto para os demais usuários no chat. No código está definido como padrão o IP 127.0.0.1, porta 12345 e nome cliente.
Observe também que a classe herda de JFrame, possibilitando a criação de formulários e implementação das interfaces ActionListener e KeyListener para prover ações nos botões e ações das teclas, respectivamente.
Aqui é mostrada a declaração do método construtor, que verifica os objetos sendo instanciados para a construção da tela do chat. Lembre-se que cada cliente deverá ser uma instância independente.
Declaração do método construtor:
public Cliente() throws IOException{
 JLabel lblMessage = new JLabel("Verificar!");
 txtIP = new JTextField("127.0.0.1");
 txtPorta = new JTextField("12345");
 txtNome = new JTextField("Cliente");
 Object[] texts = {lblMessage, txtIP, txtPorta, txtNome };
 JOptionPane.showMessageDialog(null, texts);
 pnlContent = new JPanel();
 texto = new JTextArea(10,20);
 texto.setEditable(false);
 texto.setBackground(new Color(240,240,240));
 txtMsg = new JTextField(20);
 lblHistorico = new JLabel("Histórico");
 lblMsg = new JLabel("Mensagem");
 btnSend = new JButton("Enviar");
 btnSend.setToolTipText("Enviar Mensagem");
 btnSair = new JButton("Sair");
 btnSair.setToolTipText("Sair do Chat");
 btnSend.addActionListener(this);
 btnSair.addActionListener(this);
 btnSend.addKeyListener(this);
 txtMsg.addKeyListener(this);
 JScrollPane scroll = new JScrollPane(texto);
 texto.setLineWrap(true);
 pnlContent.add(lblHistorico);
 pnlContent.add(scroll);
 pnlContent.add(lblMsg);
 pnlContent.add(txtMsg);
 pnlContent.add(btnSair);
 pnlContent.add(btnSend);
 pnlContent.setBackground(Color.LIGHT_GRAY);
 texto.setBorder(BorderFactory.createEtchedBorder(Color.BLUE,Colo r.BLUE));
 txtMsg.setBorder(BorderFactory.createEtchedBorder(Color.BLUE, Color.BLUE));
 setTitle(txtNome.getText());
 setContentPane(pnlContent);
 setLocationRelativeTo(null);
 setResizable(false);
 setSize(250,300);
 setVisible(true);
 setDefaultCloseOperation(EXIT_ON_CLOSE);
}
O método conectar é usado para conectar o cliente com o servidor socket. Nesse método é possível visualizar a criação do socket cliente e dos streams de comunicação.
Declaração do método conectar:
/***
 * Método usado para conectar no server socket, retorna IO Exception caso dê algum erro.
 * @throws IOException
 */
public void conectar() throws IOException{
 socket = new Socket(txtIP.getText(),Integer.parseInt(txtPorta.getText()));
 ou = socket.getOutputStream();
 ouw = new OutputStreamWriter(ou);
 bfw = new BufferedWriter(ouw);
 bfw.write(txtNome.getText()+"\r\n");
 bfw.flush();
}
O método enviar é usado para enviar mensagens do cliente para o servidor socket. Assim, toda vez que ele escrever uma mensagem e apertar o botão “Enter”, esta será enviada para o servidor.
Declaração do método enviar mensagem:
/***
 * Método usado para enviar mensagem para o server socket
 * @param msg do tipo String
 * @throws IOException retorna IO Exception caso dê algum erro.
 */
 public void enviarMensagem(String msg) throws IOException{
 if(msg.equals("Sair")){
 bfw.write("Desconectado \r\n");
 texto.append("Desconectado \r\n");
 }else{
 bfw.write(msg+"\r\n");
 texto.append( txtNome.getText() + " diz -> " + txtMsg.getText()+"\r\n");
 }
 bfw.flush();
 txtMsg.setText("");
}
O método escutar é usado para escutar (receber) mensagens do servidor. Toda vez que alguém enviar uma, o método será processado pelo servidor e envia para todos os clientes conectados, por isso a necessidade do código.
Declaração do método escutar:
/**
 * Método usado para receber mensagem do servidor
 * @throws IOException retorna IO Exception caso dê algum erro.
 */
public void escutar() throws IOException{
 InputStream in = socket.getInputStream();
 InputStreamReader inr = new InputStreamReader(in);
 BufferedReader bfr = new BufferedReader(inr);
 String msg = "";
 while(!"Sair".equalsIgnoreCase(msg))
 if(bfr.ready()){
 msg = bfr.readLine();
 if(msg.equals("Sair"))
 texto.append("Servidor caiu! \r\n");
 else
 texto.append(msg+"\r\n");
 }
}
O método sair é usado para desconectar do server socket. Nele o sistema apenas fecha os streams de comunicação.
Declaração do método sair
/***
 * Método usado quando o usuário clica em sair
 * @throws IOException retorna IO Exception caso dê algum erro.
 */
 public void sair() throws IOException{
 enviarMensagem("Sair");
 bfw.close();
 ouw.close();
 ou.close();
 socket.close();
}
O método usado para receber as ações dos botões dos usuários é visto aqui.
Nele foi feito um chaveamento: se o usuário pressionar o botão “send” então será enviada uma mensagem, senão será encerrado o chat.
Declaração do método actionPerformed:
@Override
public void actionPerformed(ActionEvent e) {
 try {
 if(e.getActionCommand().equals(btnSend.getActionCommand()))
 enviarMensagem(txtMsg.getText());
 else
 if(e.getActionCommand().equals(btnSair.getActionCommand()))
 sair();
 } catch (IOException e1) {
 // TODO Auto-generated catch block
 e1.printStackTrace();
 }
}
O método keyPressed é acionado quando o usuário pressiona “Enter”, verificando se o key code é o Enter. Caso seja, a mensagem é enviada para o servidor.
Declaração do método keyPressed:
@Override
public void keyPressed(KeyEvent e) {
 if(e.getKeyCode() == KeyEvent.VK_ENTER){
 try {
 enviarMensagem(txtMsg.getText());
 } catch (IOException e1) {
 // TODO Auto-generated catch block
 e1.printStackTrace();
 }
 }
}
@Override
public void keyReleased(KeyEvent arg0) {
 // TODO Auto-generated method stub
}
@Override
public void keyTyped(KeyEvent arg0) {
 // TODO Auto-generated method stub
}
O método main é onde é criado apenas um cliente e são configurados os métodos conectar e escutar.
Declaração do método main:
public static void main(String []args) throws IOException{
 Cliente app = new Cliente();
 app.conectar();
 app.escutar();
}
ESTRUTURA DO PROGRAMA
Logo após a implementação do código no Netbeans, temos duas classes: a Servidor.java e a Cliente.java. 
Execute uma vez a classe Servidor.java e a classe Cliente.java quantas vezes achar necessário, porém, se executar apenas uma vez, você não verá sua mensagemsendo enviada para ninguém.
Assim que for executado o servidor pela primeira vez aparecerá uma caixa para informar os parâmetros necessários.
Informe o número da porta:
Aqui olhamos o input para informar o número da porta onde o servidor socket receberá as conexões.
Ao executar um cliente também será necessário informar alguns parâmetros como a porta e o endereço de IP do servidor socket:
Aqui temos inputs do IP do servidor socket, a porta e o nome que será visto por você e pelos outros usuários.
Chat em execução:
Após executar o servidor e dois ou mais clientes será possível conversar com todos eles. Repare na primeira tela em que o Paul começa a conversa.
RELATÓRIO COM AS LINHAS DE CÓDIGO
Declaração dos imports:
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.Writer;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.ArrayList;
import javax.swing.JLabel;
import javax.swing.JOptionPane;
import javax.swing.JTextField;
Classe:
public class Servidor extends Thread {
Atributos estáticos:
private static ArrayList<BufferedWriter>clientes;
private static ServerSocket server;
private String nome;
private Socket con;
private InputStream in;
private InputStreamReader inr;
private BufferedReader bfr;
Declaração do método construtor:
/**
 * Método construtor
 * @param com do tipo Socket
 */
public Servidor(Socket con){
 this.con = con;
 try {
 in = con.getInputStream();
 inr = new InputStreamReader(in);
 bfr = new BufferedReader(inr);
 } catch (IOException e) {
 e.printStackTrace();
 }
}
Declaração do método run:
/**
 * Método run
 */
public void run(){
 try{
 String msg;
 OutputStream ou = this.con.getOutputStream();
 Writer ouw = new OutputStreamWriter(ou);
 BufferedWriter bfw = new BufferedWriter(ouw);
 clientes.add(bfw);
 nome = msg = bfr.readLine();
 while(!"Sair".equalsIgnoreCase(msg) && msg != null)
 {
 msg = bfr.readLine();
 sendToAll(bfw, msg);
 System.out.println(msg);
 }
 }catch (Exception e) {
 e.printStackTrace();
 }
}
Declaração do método sendToAll:
/***
 * Método usado para enviar mensagem para todos os clients
 * @param bwSaida do tipo BufferedWriter
 * @param msg do tipo String
 * @throws IOException
 */
public void sendToAll(BufferedWriter bwSaida, String msg) throws IOException
{
 BufferedWriter bwS;
 for(BufferedWriter bw : clientes){
 bwS = (BufferedWriter)bw;
 if(!(bwSaida == bwS)){
 bw.write(nome + " -> " + msg+"\r\n");
 bw.flush();
 }
 }
}
Declaração do método main:
/***
 * Método main
 * @param args
 */
public static void main(String []args) {
 try{
 //Cria os objetos necessário para instânciar o servidor
 JLabel lblMessage = new JLabel("Porta do Servidor:");
 JTextField txtPorta = new JTextField("12345");
 Object[] texts = {lblMessage, txtPorta };
 JOptionPane.showMessageDialog(null, texts);
 server = new ServerSocket(Integer.parseInt(txtPorta.getText()));
 clientes = new ArrayList<BufferedWriter>();
 JOptionPane.showMessageDialog(null,"Servidor ativo na porta: "+
 txtPorta.getText());
 while(true){
 System.out.println("Aguardando conexão...");
 Socket con = server.accept();
 System.out.println("Cliente conectado...");
 Thread t = new Servidor(con);
 t.start();
 }
 }catch (Exception e) {
 e.printStackTrace();
 }
 }// Fim do método main
} //Fim da classe
Declaração dos Imports:
import java.awt.Color;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.Writer;
import java.net.Socket;
import javax.swing.*;
Classe:
public class Cliente extends JFrame implements ActionListener, KeyListener {
Declaração dos atributos:
private static final long serialVersionUID = 1L;
private JTextArea texto;
private JTextField txtMsg;
private JButton btnSend;
private JButton btnSair;
private JLabel lblHistorico;
private JLabel lblMsg;
private JPanel pnlContent;
private Socket socket;
private OutputStream ou ;
private Writer ouw;
private BufferedWriter bfw;
private JTextField txtIP;
private JTextField txtPorta;
private JTextField txtNome;
Declaração do método construtor:
public Cliente() throws IOException{
 JLabel lblMessage = new JLabel("Verificar!");
 txtIP = new JTextField("127.0.0.1");
 txtPorta = new JTextField("12345");
 txtNome = new JTextField("Cliente");
 Object[] texts = {lblMessage, txtIP, txtPorta, txtNome };
 JOptionPane.showMessageDialog(null, texts);
 pnlContent = new JPanel();
 texto = new JTextArea(10,20);
 texto.setEditable(false);
 texto.setBackground(new Color(240,240,240));
 txtMsg = new JTextField(20);
 lblHistorico = new JLabel("Histórico");
 lblMsg = new JLabel("Mensagem");
 btnSend = new JButton("Enviar");
 btnSend.setToolTipText("Enviar Mensagem");
 btnSair = new JButton("Sair");
 btnSair.setToolTipText("Sair do Chat");
 btnSend.addActionListener(this);
 btnSair.addActionListener(this);
 btnSend.addKeyListener(this);
 txtMsg.addKeyListener(this);
 JScrollPane scroll = new JScrollPane(texto);
 texto.setLineWrap(true);
 pnlContent.add(lblHistorico);
 pnlContent.add(scroll);
 pnlContent.add(lblMsg);
 pnlContent.add(txtMsg);
 pnlContent.add(btnSair);
 pnlContent.add(btnSend);
 pnlContent.setBackground(Color.LIGHT_GRAY);
 texto.setBorder(BorderFactory.createEtchedBorder(Color.BLUE,Colo r.BLUE));
 txtMsg.setBorder(BorderFactory.createEtchedBorder(Color.BLUE, Color.BLUE));
 setTitle(txtNome.getText());
 setContentPane(pnlContent);
 setLocationRelativeTo(null);
 setResizable(false);
 setSize(250,300);
 setVisible(true);
 setDefaultCloseOperation(EXIT_ON_CLOSE);
}
Declaração do método conectar:
/***
 * Método usado para conectar no server socket, retorna IO Exception caso dê algum erro.
 * @throws IOException
 */
public void conectar() throws IOException{
 socket = new Socket(txtIP.getText(),Integer.parseInt(txtPorta.getText()));
 ou = socket.getOutputStream();
 ouw = new OutputStreamWriter(ou);
 bfw = new BufferedWriter(ouw);
 bfw.write(txtNome.getText()+"\r\n");
 bfw.flush();
}
Declaração do método enviar mensagem:
/***
 * Método usado para enviar mensagem para o server socket
 * @param msg do tipo String
 * @throws IOException retorna IO Exception caso dê algum erro.
 */
 public void enviarMensagem(String msg) throws IOException{
 if(msg.equals("Sair")){
 bfw.write("Desconectado \r\n");
 texto.append("Desconectado \r\n");
 }else{
 bfw.write(msg+"\r\n");
 texto.append( txtNome.getText() + " diz -> " + txtMsg.getText()+"\r\n");
 }
 bfw.flush();
 txtMsg.setText("");
}
Declaração do método escutar:
/**
 * Método usado para receber mensagem do servidor
 * @throws IOException retorna IO Exception caso dê algum erro.
 */
public void escutar() throws IOException{
 InputStream in = socket.getInputStream();
 InputStreamReader inr = new InputStreamReader(in);
 BufferedReader bfr = new BufferedReader(inr);
 String msg = "";
 while(!"Sair".equalsIgnoreCase(msg))
 if(bfr.ready()){
 msg = bfr.readLine();
 if(msg.equals("Sair"))
 texto.append("Servidor caiu! \r\n");
 else
 texto.append(msg+"\r\n");
 }
}
Declaração do método sair
/***
 * Método usado quando o usuário clica em sair
 * @throws IOException retornaIO Exception caso dê algum erro.
 */
 public void sair() throws IOException{
 enviarMensagem("Sair");
 bfw.close();
 ouw.close();
 ou.close();
 socket.close();
}
Declaração do método actionPerformed:
@Override
public void actionPerformed(ActionEvent e) {
 try {
 if(e.getActionCommand().equals(btnSend.getActionCommand()))
 enviarMensagem(txtMsg.getText());
 else
 if(e.getActionCommand().equals(btnSair.getActionCommand()))
 sair();
 } catch (IOException e1) {
 // TODO Auto-generated catch block
 e1.printStackTrace();
 }
}
Declaração do método keyPressed:
@Override
public void keyPressed(KeyEvent e) {
 if(e.getKeyCode() == KeyEvent.VK_ENTER){
 try {
 enviarMensagem(txtMsg.getText());
 } catch (IOException e1) {
 // TODO Auto-generated catch block
 e1.printStackTrace();
 }
 }
}
@Override
public void keyReleased(KeyEvent arg0) {
 // TODO Auto-generated method stub
}
@Override
public void keyTyped(KeyEvent arg0) {
 // TODO Auto-generated method stub
}
Declaração do método main:
public static void main(String []args) throws IOException{
 Cliente app = new Cliente();
 app.conectar();
 app.escutar();
}
CONCLUSÃO
A necessidade do ser humano por comunicação a longa distância sempre esteve presente desde uma simples carta até uma mensagem transmitida via internet por algum tipo de chat. 
O ser humano sempre procurou por maneiras mais rápidas de comunicar informações importantes, seja por um e-mail entre funcionários de uma empresa ou um chat entre dois funcionários em industrias diferentes. 
Atualmente chats em tempo real estão presentes mundialmente desde ferramentas em computador até aplicativos em celular. Diferente dos primeiros chats esses são mais rápidos e possuem criptografia, sempre buscando a segurança de seus usuários. 
A maioria dos chats, hoje em dia, utilizam o protocolo de rede TCP/IP que é algo indispensável para qualquer rede tanto que o mesmo é conhecido como o mestre das redes, pois o mesmo é padronizado logo é sempre o preferido para a montagem de redes e o mesmo sendo mais preciso que a maioria dos protocolos. 
Em redes também é utilizado o protocolo UDP sendo o protocolo menos confiável pois não possui a precisão e garantia de envio que o protocolo TCP, logo não possui necessidade de conexão longa entre cliente e servidor. 
O alicerce para qualquer rede seria a utilização do IP. Ele conserva toda a estrutura da rede permitindo diversos protocolos como TCP e UDP, seria a “identidade” de um cliente ou servidor sendo o que permitiria a conexão. Para um melhor uso dos endereços de equipamentos em rede pelas pessoas, utiliza-se a forma de endereços de domínio, tal como "www.facebook.com". Cada endereço de domínio é convertido em um endereço IP pelo DNS (Domain Name System). Este processo de conversão é conhecido como "resolução de nomes", logo permitindo comunicação por distancias. 
O desenvolvimento do presente trabalho possibilitou uma análise das redes de computadores, que trouxe consigo a busca do conhecimento para a construção do software de telecomunicação com sockets, e também o conhecimento da história das redes de computadores até os dias atuais. Perante todas essas dificuldades que os especialistas de redes de computadores tiveram ao criar as redes modernas que hoje em dia conhecemos. Podemos ver claramente até onde a evolução das redes de computadores nos levou, com aplicativos como Skype.
De modo geral, o aplicativo de telecomunicação com sockets obteve bons resultados de comunicação em escrita, que desde o início na criação do código fonte, até a comunicação feita por escrita, podemos dizer que esse projeto conseguiu alcançar o seu objetivo que é a comunicação entre dois computadores semelhantes. 
O desenvolvimento do aplicativo SmokeSignal teve seu surgimento através de ferramentas e ideias que ajudaram bastante para a criação do software em questão.
Dada a importância do assunto, torna-se necessário o desenvolvimento de formas de melhorar o entendimento das redes de computadores para que os próximos software possam ter uma qualidade cada vez maior, com ferramentas que facilite o desenvolvimento dos próximos aplicativos de telecomunicações. 
Neste sentido, como foi demonstrado nesse trabalho, as redes de computadores só têm a evoluir cada vez mais, mostrando os passos percorridos que esse projeto traçou para a criação desse aplicativo, que por sua vez permite a comunicação entre computadores semelhantes, e que um dia se espera que esse projeto ajude outras pessoas a criar seus próprios aplicativos de comunicação.
BIBLIOGRAFIA
Blog União geek:
https://www.uniaogeek.com.br/redes-de-comunicacao-de-dados-principais-conceitos/#:~:text=Para%20que%20a%20comunica%C3%A7%C3%A3o%20seja,a%20informa%C3%A7%C3%A3o%20a%20ser%20transmitida.&text=Meio%20de%20Transmiss%C3%A3o%3A%20%C3%A9%20o,governa%20a%20comunica%C3%A7%C3%A3o%20de%20dados.
Net support:
https://netsupport.com.br/blog/redes-de-computadores/
Wikipédia:
https://pt.wikipedia.org/wiki/Rede_de_computadores
KUROSE, JIM. Redes de Computadores e a Internet: Uma Abordagem Top-Down.