APS Quinto Semestre

Prévia do material em texto

UNIVERSIDADE PAULISTA 
 
 
 
 
 
 
 
João Victor Narcizo Pereira – N3104f3 
Marcelo Pereira Conegero Junior – N2852J7 
Matheus de Oliveira – N378786 
 
 
 
 
 
 
 
 
 
 
DESENVOLVIMENTO DE FERRAMENTA PARA 
COMUNICAÇÃO EM REDE 
 
 
 
 
 
 
 
 
 
 
 
 
 
São Paulo 
2020 
João Victor Narcizo Pereira – N3104f3 
Marcelo Pereira Conegero Junior – N2852J7 
Matheus de Oliveira – N378786 
 
 
 
 
 
 
 
 
 
DESENVOLVIMENTO DE FERRAMENTA PARA 
COMUNICAÇÃO EM REDE 
 
 
 
 
 
 
 
Atividades Práticas 
Supervisionadas do curso de 
Ciência da Computação 
apresentado à Universidade 
Paulista. 
 
 
 
 
 
 
 
 
São Paulo 
2020 
Sumario 
 
1. Objetivo..........................................................................................................4 
2. Introdução........................................................................................... ...........5 
3. Fundamentos de comunicação em rede........................................................6 
3.1. Redes de computadores/Protocolos e serviços de rede........................6 
3.2. Funções do Protocolo..............................................................................7 
3.3. Hierarquia........................................................................................... .....7 
3.4. Serviços de Rede...................................................................................9 
3.5. Classificação de Serviços......................................................................9 
4. Linhas do código do programa.....................................................................11 
4.1. Cliente...................................................................................................11 
4.2. Servidor.................................................................................................27 
5. Apresentação do programa..........................................................................37 
6. Bibliografia........................................................................................... .........43 
7. Ficha de atividades práticas supervisionadas..............................................44 
 
1. Objetivo 
 
O objetivo desse trabalho e para construirmos um chat online com trocas 
de mensagens (tempo de resposta) imediatas e temos como foco principal a 
parte profissional pois queremos fazer um chat leve para algumas trocas de 
informações por isso pequenas adições como emoticons, pois não é para servir 
como reunião mas sim como troca de informações básicas ou para tirar 
pequenas dúvidas entre as demais pessoas, esse programa também não seria 
para a parte mais alta da empresa, mas para os menores que fazem sendo assim 
é para grandes empresas ou corporações que tem um grande número de 
funcionários. 
2. Introdução 
 
O desenvolvimento de uma ferramenta para comunicação em rede, tem por 
objetivo demonstrar as utilidades práticas de um aplicativo para comunicação em 
rede entre computadores, desenvolvido em linguagem de programação Java 
através do protocolo TCP/IP. Assim, foi realizada pesquisa teórica para embasar 
o desenvolvimento da aplicação. 
A aplicação foi desenvolvida com o objetivo de interligar os conhecimentos e 
habilidades desenvolvidos durante o decorrer dos semestres anteriores e atual, 
a fim de dar utilidade prática aos conhecimentos teóricos adquiridos em sala de 
aula. 
A aplicação, por tanto, foi desenvolvida utilizando a linguagem de 
programação Java, através do programa Eclipse Java, já utilizados em 
semestres anteriores. Assim, foi desenvolvido um aplicativo que, utilizando-se 
do protocolo TCP/IP permitindo a comunicação em rede entre computadores. 
Essa aplicação permite a troca de mensagens entre computadores, tendo 
como grandes exemplos o Whatssap, Discord ou até mesmo o Skype. 
3. Fundamentos da comunicação de dados em redes 
 
3.1. Redes de computadores/Protocolos e serviços de rede 
 
Podemos pensar em rede de computadores como diversas máquinas 
interligadas fisicamente entre si onde os seus utilizadores promovem a troca de 
informação de seu interesse. Entretanto, uma rede não pode ser bem 
estabelecida considerando apenas o hardware como preocupação principal 
como nas primeiras redes, atualmente o software é considerado uma das partes 
mais importantes na concepção de novas tecnologias de redes de 
computadores. Protocolo é o conjunto de regras sobre o modo como se dará a 
comunicação entre as partes envolvidas. 
Protocolo é a "língua" dos computadores, ou seja, uma espécie de idioma 
que segue normas e padrões determinados. É através dos protocolos que é 
possível a comunicação entre um ou mais computadores. 
Os protocolos de rede nasceram da necessidade de conectar 
equipamentos de fornecedores distintos, executando sistemas distintos, sem ter 
que escrever a cada caso programas específicos. Ambos os computadores 
devem estar configurados com os mesmos parâmetros e obedecer aos mesmos 
padrões para que a comunicação possa ser realizada sem erros. Existem 
diversos tipos de protocolos de rede, variando de acordo com o serviço a ser 
utilizado. De maneira geral há dois tipos de protocolos: Abertos e Proprietários 
ou específicos. Os protocolos Abertos são os protocolos padrões da internet. 
Este pode comunicar com outros protocolos que utilizam o mesmo padrão de 
protocolo. Um exemplo seria o TCP/IP, pois ele pode comunicar com várias 
plataformas como Windows, Linux, Mac e outros. 
Já os protocolos Proprietários são feitos para ambiente específicos (daí o seu 
nome), pois ele apenas pode comunicar com uma plataforma padrão. Exemplos 
desse tipo de protocolo: IPX/SPX, NETBIOS e outros. São exemplos de 
protocolos de rede: IP (Internet Protocol), DHCP (Dynamic Host Configuration 
Protocol), TCP (Transmission Control Protocol), HTTP (Hypertext Transfer 
Protocol), FTP (File Transfer Protocol), Telnet (Telnet Remote Protocol), SSH 
(SSH Remote Protocol), POP3) Post Office Protocol 3), SMTP (Simple Mail 
Transfer Protocol), IMAP (Internet Message Access Protocol). 
 
3.2. Funções do Protocolo 
 
Uma das funções dos protocolos é pegar os dados que serão transmitidos 
pela rede, dividir em pequenos pedaços chamados pacotes, na qual dentro de 
cada pacote há informações de endereçamento que informam a origem e o 
destino do pacote. É através do protocolo que as fases de estabelecimento, 
controle, tráfego e encerramento, componentes da troca de informações são 
sistematizadas. 
O protocolo desempenha as seguintes funções: 
• Endereçamento: especificação clara do ponto de destino da mensagem; 
• Numeração e sequência: individualização de cada mensagem, através de 
número sequencial; 
• Estabelecimento da conexão: estabelecimento de um canal lógico fechado 
entre fonte e destino; 
• Confirmação de recepção: confirmação do destinatário, com ou sem erro, após 
cada segmento de mensagem; 
• Controle de erro: detecção e correção de erros; 
• Retransmissão: repetição da mensagem a cada recepção de mensagem; 
• Conversão de código: adequação do código às características do destinatário; 
• Controle de fluxo: manutenção de fluxos compatíveis com os recursos 
disponíveis. 
 
3.3. Hierarquia 
 
Como já foi visto um protocolo é um conjunto de regras sobre o modo como 
se dará a comunicação entre as partes envolvidas. Com o intuito de reduzir a 
complexidade do projeto, a maioria das redes foi organizada como uma série de 
níveis ou camadas, que são colocadas uma sobre a outra. 
O número, o nome, o conteúdo e a função de cada camada diferem de 
uma rede para outra. Em todas as redes, no entanto, o objetivo de cada camada 
é oferecer determinados serviços para as camadas superiores. 
A camada n de uma máquina comunica -se com a camada n de outra 
máquina. Para isso acontecer, ela baseia-se num conjunto de convenções e 
regras que vão permitir gerenciar esta comunicação na qual foinomeada de 
protocolo da camada n, ou, simplesmente, protocolo n. 
 As entidades que ocupam as mesmas camadas em diferentes máquinas 
são chamadas de PARES. São os pares que se comunicam utilizando o 
protocolo. Os dados não são transferidos diretamente entre os pares, pois não 
existe meio físico entre eles. Então cada camada transfere os dados para a 
camada inferior a ela, até alcançar a última camada. Após a última camada está 
o meio físico (meio de transmissão) através do qual se dá a comunicação. 
Em cada par de camadas adjacentes, há uma INTERFACE (Define as operações 
e serviços que a camada inferior tem a oferecer para a camada superior a ela). 
Ao conjunto das camadas compondo uma rede dá-se o nome de arquitetura da 
rede. As especificações da arquitetura devem conter informações suficientes 
para permitir o correto desenvolvimento da rede, tanto do ponto de vista do 
software quanto do hardware. Por outro lado, os detalhes de implementação dos 
mecanismos em cada camada, assim como as especificações detalhadas das 
interfaces não fazem parte da definição da arquitetura da rede. 
Resumindo, o protocolo é um conjunto de regras que controlam o formato 
e o significado das informações trocadas pelas entidades pares contidas numa 
camada, sendo que as entidades utilizam protocolos com a finalidade de 
implementar as suas definições de serviços e as entidades têm a liberdade de 
trocarem os seus protocolos, desde que não alterem o serviço visível para os 
seus utilizadores. 
 
 
 
 
3.4. Serviços de rede 
 
Um serviço de rede é um conjunto de operações implementado por um 
protocolo através de um a interface, e é oferecido à camada imediatamente 
superior. Ele define o que uma camada é capaz de executar sem se preocupar 
com a maneira pela qual as operações serão executa das. 
Cada serviço é utilizado por aplicações diferentes, podendo uma aplicação 
utilizar vários serviços, como, por exemplo, um browser como o Mozilla Firefox. 
Este utiliza, por exemplo, HTTP, SHTTP, DNS. 
Os serviços podem ser orientados a conexão ou não. Serviços relacionados 
à família TCP são orientados a conexão, enquanto serviços relacionados ao 
protocolo UDP são sem conexão. 
 
3.5. Classificação de serviços 
 
Serviços orienta dos a conexão: é o serviço TCP. Antes do envio de dados, 
um processo conhecido como handshaking cria uma conexão fraca entre os 
hosts. Basicamente, esse processo prepara o receptor para a recepção de 
pacotes. Esta conexão prévia possibilita verificar se todos os pacotes irão chegar 
corretamente ao destino, e em caso negativo, solicitar o reenvio dos mesmos 
(quando o receptor recebe um pacote, ele envia uma mensagem de confirmação 
ao transmissor. Se a confirmação não chegar, o pacote é reenviado), gerando 
uma transferência de dados confiável. Também pode fazer-se um controlo de 
fluxo e congestionamento, para casos em que o receptor não suporta a 
velocidade de envio dos pacotes, ou quando algum roteador na rede está 
congestionado (é enviada uma mensagem ao transmissor, reduzindo ou 
interrompendo a velocidade de envio de pacotes). Como exemplo de serviços 
orientados a conexão, CP, temos: HTTP, FTP, Telnet. 
Serviços sem conexão: é o serviço UDP (Protocolo de Datagrama de 
Usuário). Não há o processo de handshaking. Assim, uma aplicação apenas 
envia dados para um host, e com isso não há como saber se todos os pacotes 
chegaram. É mais rápido, mesmo por não haver a etapa da handshaking, mas é 
menos confiável, além de não possuir a possibilidade de controle de fluxo e 
congestionamento presentes no TCP. Algumas aplicações que usam o UDP: 
conferência de vídeo e telefone por internet. 
Existem outros tipos de serviços, como o DHCP, que automaticamente 
determina um endereço IP válido a cada host conectado à Internet e o DNS, que 
possibilita que o utilizador use strings, ao invés de endereços IP para se conectar 
a outros servidores. O DNS mantém um banco de dados que relaciona cada 
string a um endereço IP. 
 
4. Linhas do código programa 
 
 4.1 Cliente Java 
* To change this template, choose Tools | Templates 
 * and open the template in the editor. 
 */ 
package com.networks.app; 
 
import com.networks.app.frame.ClienteFrame; 
 
public class Cliente { 
 
 public static void main(String args[]) { 
 
 try { 
 for (javax.swing.UIManager.LookAndFeelInfo info : 
javax.swing.UIManager.getInstalledLookAndFeels()) { 
 if ("Nimbus".equals(info.getName())) { 
 javax.swing.UIManager.setLookAndFeel(info.getClassName()); 
 break; 
 } 
 } 
 } catch (ClassNotFoundException ex) { 
 
java.util.logging.Logger.getLogger(ClienteFrame.class.getName()).log(java.util.logging.
Level.SEVERE, null, ex); 
 } catch (InstantiationException ex) { 
 
java.util.logging.Logger.getLogger(ClienteFrame.class.getName()).log(java.util.logging.
Level.SEVERE, null, ex); 
 } catch (IllegalAccessException ex) { 
 
java.util.logging.Logger.getLogger(ClienteFrame.class.getName()).log(java.util.logging.
Level.SEVERE, null, ex); 
 } catch (javax.swing.UnsupportedLookAndFeelException ex) { 
 
java.util.logging.Logger.getLogger(ClienteFrame.class.getName()).log(java.util.logging.
Level.SEVERE, null, ex); 
 } 
 //</editor-fold> 
 
 /* Create and display the form */ 
 java.awt.EventQueue.invokeLater(new Runnable() { 
 public void run() { 
 new ClienteFrame().setVisible(true); 
 } 
 }); 
 } 
} 
 
 Chay Message: 
/* 
 * To change this template, choose Tools | Templates 
 * and open the template in the editor. 
 */ 
package com.networks.app.bean; 
 
import java.io.Serializable; 
import java.util.HashSet; 
import java.util.Set; 
 
public class ChatMessage implements Serializable { 
 
 private static final long serialVersionUID = -2468678952584729445L; 
 
 private String name; 
 private String text; 
 private String nameReserved; 
 private Set<String> setOnlines = new HashSet<String>(); 
 private Action action; 
 
 public String getName() { 
 return name; 
 } 
 
 public void setName(String name) { 
 this.name = name; 
 } 
 
 public String getText() { 
 return text; 
 } 
 
 public void setText(String text) { 
 this.text = text; 
 } 
 
 public String getNameReserved() { 
 return nameReserved; 
 } 
 
 public void setNameReserved(String nameReserved) { 
 this.nameReserved = nameReserved; 
 } 
 
 public Set<String> getSetOnlines() { 
 return setOnlines; 
 } 
 
 public void setSetOnlines(Set<String> setOnlines) { 
 this.setOnlines = setOnlines; 
 } 
 
 public Action getAction() { 
 return action; 
 } 
 
 public void setAction(Action action) { 
 this.action = action; 
 } 
 
 public enum Action { 
 CONNECT, DISCONNECT, SEND_ONE, SEND_ALL, USERS_ONLINE 
 } 
} 
 
Cliente Frame: 
/* 
 * To change this template, choose Tools | Templates 
 * and open the template in the editor. 
 */ 
package com.networks.app.frame; 
 
import com.networks.app.service.ClienteService; 
import com.networks.app.bean.ChatMessage; 
import com.networks.app.bean.ChatMessage.Action; 
import com.vdurmont.emoji.EmojiParser; 
 
import java.io.IOException; 
import java.io.ObjectInputStream; 
import java.net.Socket; 
import java.text.SimpleDateFormat; 
import java.util.Date; 
import java.util.Set; 
import java.util.logging.Level; 
import java.util.logging.Logger; 
import javax.swing.*; 
 
public class ClienteFrame extends javax.swing.JFrame { 
 
 private static final long serialVersionUID = 1478572064896161684L; 
 
 private Socket socket;private ChatMessage message; 
 private ClienteService service; 
 
 public ClienteFrame() { 
 initComponents(); 
 } 
 
 private class ListenerSocket implements Runnable { 
 
 private ObjectInputStream input; 
 
 public ListenerSocket(Socket socket) { 
 try { 
 this.input = new ObjectInputStream(socket.getInputStream()); 
 } catch (IOException ex) { 
 Logger.getLogger(ClienteFrame.class.getName()).log(Level.SEVERE, null, 
ex); 
 } 
 } 
 
 public void run() { 
 ChatMessage message = null; 
 try { 
 while ((message = (ChatMessage) input.readObject()) != null) { 
 Action action = message.getAction(); 
 
 if (action.equals(Action.CONNECT)) { 
 connected(message); 
 } else if (action.equals(Action.DISCONNECT)) { 
 disconnected(); 
 socket.close(); 
 } else if (action.equals(Action.SEND_ONE)) { 
 System.out.println("::: " + message.getText() + " :::"); 
 receive(message); 
 } else if (action.equals(Action.USERS_ONLINE)) { 
 refreshOnlines(message); 
 } 
 } 
 } catch (IOException ex) { 
 Logger.getLogger(ClienteFrame.class.getName()).log(Level.SEVERE, null, 
ex); 
 } catch (ClassNotFoundException ex) { 
 Logger.getLogger(ClienteFrame.class.getName()).log(Level.SEVERE, null, 
ex); 
 } 
 } 
 } 
 
 private void connected(ChatMessage message) { 
 if (message.getText().equals("NO")) { 
 this.txtName.setText(""); 
 JOptionPane.showMessageDialog(this, "Conexão não realizada!\nTente 
novamente com um novo nome."); 
 return; 
 } 
 
 this.message = message; 
 this.btnConnectar.setEnabled(false); 
 this.txtName.setEditable(false); 
 
 this.btnSair.setEnabled(true); 
 this.txtAreaSend.setEnabled(true); 
 this.txtAreaReceive.setEnabled(true); 
 this.btnEnviar.setEnabled(true); 
 this.btnLimpar.setEnabled(true); 
 
 JOptionPane.showMessageDialog(this, "Você está conectado no chat!"); 
 } 
 
 private void disconnected() { 
 
 this.btnConnectar.setEnabled(true); 
 this.txtName.setEditable(true); 
 
 this.btnSair.setEnabled(false); 
 this.txtAreaSend.setEnabled(false); 
 this.txtAreaReceive.setEnabled(false); 
 this.btnEnviar.setEnabled(false); 
 this.btnLimpar.setEnabled(false); 
 
 this.txtAreaReceive.setText(""); 
 this.txtAreaSend.setText(""); 
 
 JOptionPane.showMessageDialog(this, "Você saiu do chat!"); 
 } 
 
 private void receive(ChatMessage message) { 
 Date data = new Date(); 
 SimpleDateFormat formatador = new SimpleDateFormat("HH:mm"); 
 String DataAtual = formatador.format(data); 
 
 this.txtAreaReceive.append(message.getName() + ": " + message.getText() +" " 
+ DataAtual + "\n"); 
 } 
 
 private void refreshOnlines(ChatMessage message) { 
 System.out.println(message.getSetOnlines().toString()); 
 
 Set<String> names = message.getSetOnlines(); 
 
 names.remove(message.getName()); 
 
 String[] array = (String[]) names.toArray(new String[names.size()]); 
 
 this.listOnlines.setListData(array); 
 this.listOnlines.setSelectionMode(ListSelectionModel.SINGLE_SELECTION); 
 this.listOnlines.setLayoutOrientation(JList.VERTICAL); 
 } 
 
 /** 
 * This method is called from within the constructor to initialize the form. 
 * WARNING: Do NOT modify this code. The content of this method is always 
 * regenerated by the Form Editor. 
 */ 
 
 // <editor-fold defaultstate="collapsed" desc="Generated Code">//GEN-
BEGIN:initComponents 
 private void initComponents() { 
 
 jPanel1 = new javax.swing.JPanel(); 
 txtName = new javax.swing.JTextField(); 
 btnConnectar = new javax.swing.JButton(); 
 btnSair = new javax.swing.JButton(); 
 jPanel2 = new javax.swing.JPanel(); 
 jScrollPane3 = new javax.swing.JScrollPane(); 
 listOnlines = new javax.swing.JList(); 
 jPanel3 = new javax.swing.JPanel(); 
 jScrollPane1 = new javax.swing.JScrollPane(); 
 txtAreaReceive = new javax.swing.JTextArea(); 
 jScrollPane2 = new javax.swing.JScrollPane(); 
 txtAreaSend = new javax.swing.JTextArea(); 
 btnEnviar = new javax.swing.JButton(); 
 btnLimpar = new javax.swing.JButton(); 
 
 setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE); 
 
 jPanel1.setBorder(javax.swing.BorderFactory.createTitledBorder("Conectar")); 
 
 btnConnectar.setText("Connectar"); 
 btnConnectar.addActionListener(new java.awt.event.ActionListener() { 
 public void actionPerformed(java.awt.event.ActionEvent evt) { 
 btnConnectarActionPerformed(evt); 
 } 
 }); 
 
 btnSair.setText("Sair"); 
 btnSair.setEnabled(false); 
 btnSair.addActionListener(new java.awt.event.ActionListener() { 
 public void actionPerformed(java.awt.event.ActionEvent evt) { 
 btnSairActionPerformed(evt); 
 } 
 }); 
 
 javax.swing.GroupLayout jPanel1Layout = new 
javax.swing.GroupLayout(jPanel1); 
 jPanel1.setLayout(jPanel1Layout); 
 jPanel1Layout.setHorizontalGroup( 
 
jPanel1Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING) 
 .addGroup(jPanel1Layout.createSequentialGroup() 
 .addContainerGap() 
 .addComponent(txtName) 
 
.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED) 
 .addComponent(btnConnectar) 
 
.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED) 
 .addComponent(btnSair) 
 .addContainerGap()) 
 ); 
 jPanel1Layout.setVerticalGroup( 
 
jPanel1Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING) 
 
.addGroup(jPanel1Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.BA
SELINE) 
 .addComponent(txtName, javax.swing.GroupLayout.PREFERRED_SIZE, 
javax.swing.GroupLayout.DEFAULT_SIZE, 
javax.swing.GroupLayout.PREFERRED_SIZE) 
 .addComponent(btnConnectar) 
 .addComponent(btnSair)) 
 ); 
 
 jPanel2.setBorder(javax.swing.BorderFactory.createTitledBorder("Onlines")); 
 
 jScrollPane3.setViewportView(listOnlines); 
 
 javax.swing.GroupLayout jPanel2Layout = new 
javax.swing.GroupLayout(jPanel2); 
 jPanel2.setLayout(jPanel2Layout); 
 jPanel2Layout.setHorizontalGroup( 
 
jPanel2Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING) 
 .addGroup(javax.swing.GroupLayout.Alignment.TRAILING, 
jPanel2Layout.createSequentialGroup() 
 .addContainerGap() 
 .addComponent(jScrollPane3, javax.swing.GroupLayout.DEFAULT_SIZE, 
80, Short.MAX_VALUE) 
 .addContainerGap()) 
 ); 
 jPanel2Layout.setVerticalGroup( 
 
jPanel2Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING) 
 .addComponent(jScrollPane3) 
 ); 
 
 jPanel3.setBorder(javax.swing.BorderFactory.createEtchedBorder()); 
 
 txtAreaReceive.setEditable(false); 
 txtAreaReceive.setColumns(20);txtAreaReceive.setRows(5); 
 txtAreaReceive.setEnabled(false); 
 txtAreaReceive.setFont(new java.awt.Font("Neue Haas Grotesk", 2, 12)); 
 
 jScrollPane1.setViewportView(txtAreaReceive); 
 
 txtAreaSend.setColumns(20); 
 txtAreaSend.setRows(5); 
 txtAreaSend.setEnabled(false); 
 txtAreaSend.setFont(new java.awt.Font("Neue Haas Grotesk", 2, 12)); 
 jScrollPane2.setViewportView(txtAreaSend); 
 
 btnEnviar.setText("Enviar"); 
 btnEnviar.setEnabled(false); 
 btnEnviar.addActionListener(new java.awt.event.ActionListener() { 
 public void actionPerformed(java.awt.event.ActionEvent evt) { 
 btnEnviarActionPerformed(evt); 
 } 
 }); 
 
 btnLimpar.setText("Limpar"); 
 btnLimpar.setEnabled(false); 
 btnLimpar.addActionListener(new java.awt.event.ActionListener() { 
 public void actionPerformed(java.awt.event.ActionEvent evt) { 
 btnLimparActionPerformed(evt); 
 } 
 }); 
 
 javax.swing.GroupLayout jPanel3Layout = new 
javax.swing.GroupLayout(jPanel3); 
 jPanel3.setLayout(jPanel3Layout); 
 jPanel3Layout.setHorizontalGroup( 
 
jPanel3Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING) 
 .addGroup(jPanel3Layout.createSequentialGroup() 
 .addContainerGap() 
 
.addGroup(jPanel3Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LE
ADING) 
 .addComponent(jScrollPane1, javax.swing.GroupLayout.DEFAULT_SIZE, 
282, Short.MAX_VALUE) 
 .addComponent(jScrollPane2) 
 .addGroup(javax.swing.GroupLayout.Alignment.TRAILING, 
jPanel3Layout.createSequentialGroup() 
 .addGap(0, 0, Short.MAX_VALUE) 
 .addComponent(btnLimpar) 
 
.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED) 
 .addComponent(btnEnviar))) 
 .addContainerGap()) 
 ); 
 jPanel3Layout.setVerticalGroup( 
 
jPanel3Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING) 
 .addGroup(jPanel3Layout.createSequentialGroup() 
 .addContainerGap() 
 .addComponent(jScrollPane1, 
javax.swing.GroupLayout.PREFERRED_SIZE, 113, 
javax.swing.GroupLayout.PREFERRED_SIZE) 
 
.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED) 
 .addComponent(jScrollPane2, 
javax.swing.GroupLayout.PREFERRED_SIZE, 66, 
javax.swing.GroupLayout.PREFERRED_SIZE) 
 
.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.UNRELATED) 
 
.addGroup(jPanel3Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.BA
SELINE) 
 .addComponent(btnEnviar) 
 .addComponent(btnLimpar)) 
 .addContainerGap(javax.swing.GroupLayout.DEFAULT_SIZE, 
Short.MAX_VALUE)) 
 ); 
 
 javax.swing.GroupLayout layout = new 
javax.swing.GroupLayout(getContentPane()); 
 getContentPane().setLayout(layout); 
 layout.setHorizontalGroup( 
 layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING) 
 .addGroup(layout.createSequentialGroup() 
 .addContainerGap() 
 
.addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING) 
 .addComponent(jPanel3, javax.swing.GroupLayout.DEFAULT_SIZE, 
javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE) 
 .addComponent(jPanel1, javax.swing.GroupLayout.DEFAULT_SIZE, 
javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE)) 
 
.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED) 
 .addComponent(jPanel2, javax.swing.GroupLayout.PREFERRED_SIZE, 
javax.swing.GroupLayout.DEFAULT_SIZE, 
javax.swing.GroupLayout.PREFERRED_SIZE) 
 .addContainerGap()) 
 ); 
 layout.setVerticalGroup( 
 layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING) 
 .addGroup(layout.createSequentialGroup() 
 
.addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING) 
 .addGroup(layout.createSequentialGroup() 
 .addComponent(jPanel1, 
javax.swing.GroupLayout.PREFERRED_SIZE, 
javax.swing.GroupLayout.DEFAULT_SIZE, 
javax.swing.GroupLayout.PREFERRED_SIZE) 
 
.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED) 
 .addComponent(jPanel3, javax.swing.GroupLayout.DEFAULT_SIZE, 
javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE)) 
 .addComponent(jPanel2, javax.swing.GroupLayout.DEFAULT_SIZE, 
javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE)) 
 .addContainerGap()) 
 ); 
 
 pack(); 
 }// </editor-fold>//GEN-END:initComponents 
 
 private void btnConnectarActionPerformed(java.awt.event.ActionEvent evt) {//GEN-
FIRST:event_btnConnectarActionPerformed 
 String name = this.txtName.getText(); 
 
 if (!name.isEmpty()) { 
 this.message = new ChatMessage(); 
 this.message.setAction(Action.CONNECT); 
 this.message.setName(name); 
 
 this.service = new ClienteService(); 
 this.socket = this.service.connect(); 
 
 new Thread(new ListenerSocket(this.socket)).start(); 
 
 this.service.send(message); 
 } 
 }//GEN-LAST:event_btnConnectarActionPerformed 
 
 private void btnSairActionPerformed(java.awt.event.ActionEvent evt) {//GEN-
FIRST:event_btnSairActionPerformed 
 ChatMessage message = new ChatMessage(); 
 message.setName(this.message.getName()); 
 message.setAction(Action.DISCONNECT); 
 this.service.send(message); 
 disconnected(); 
 }//GEN-LAST:event_btnSairActionPerformed 
 
 private void btnLimparActionPerformed(java.awt.event.ActionEvent evt) {//GEN-
FIRST:event_btnLimparActionPerformed 
 this.txtAreaSend.setText(""); 
 }//GEN-LAST:event_btnLimparActionPerformed 
 
 private void btnEnviarActionPerformed(java.awt.event.ActionEvent evt) {//GEN-
FIRST:event_btnEnviarActionPerformed 
 String text = this.txtAreaSend.getText(); 
 String newText = EmojiParser.parseToUnicode(text); 
 String name = this.message.getName(); 
 
 this.message = new ChatMessage(); 
 
 if (this.listOnlines.getSelectedIndex() > -1) { 
 this.message.setNameReserved((String) this.listOnlines.getSelectedValue()); 
 this.message.setAction(Action.SEND_ONE); 
 this.listOnlines.clearSelection(); 
 } else { 
 this.message.setAction(Action.SEND_ALL); 
 } 
 
 if (!text.isEmpty()) { 
 this.message.setName(name); 
 this.message.setText(newText); 
 
 Date data = new Date(); 
 SimpleDateFormat formatador = new SimpleDateFormat("HH:mm"); 
 String DataAtual = formatador.format(data); 
 
 this.txtAreaReceive.append("Eu: " + newText +" " + DataAtual +"\n"); 
 this.service.send(this.message); 
 } 
 
 this.txtAreaSend.setText(""); 
 }//GEN-LAST:event_btnEnviarActionPerformed 
 
 // Variables declaration - do not modify//GEN-BEGIN:variables 
 private javax.swing.JButton btnConnectar; 
 private javax.swing.JButton btnEnviar; 
 private javax.swing.JButton btnLimpar; 
 private javax.swing.JButton btnSair; 
 private javax.swing.JPanel jPanel1; 
 private javax.swing.JPaneljPanel2; 
 private javax.swing.JPanel jPanel3; 
 private javax.swing.JScrollPane jScrollPane1; 
 private javax.swing.JScrollPane jScrollPane2; 
 private javax.swing.JScrollPane jScrollPane3; 
 private javax.swing.JList listOnlines; 
 private javax.swing.JTextArea txtAreaReceive; 
 private javax.swing.JTextArea txtAreaSend; 
 private javax.swing.JTextField txtName; 
 // End of variables declaration//GEN-END:variables 
} 
> 
4.2. Servidor 
/* 
 * To change this template, choose Tools | Templates 
 * and open the template in the editor. 
 */ 
package com.networks.app.service; 
 
import java.io.IOException; 
import java.io.ObjectOutputStream; 
import java.net.Socket; 
import java.net.UnknownHostException; 
import java.util.logging.Level; 
import java.util.logging.Logger; 
 
import com.networks.app.bean.ChatMessage; 
 
public class ClienteService { 
 
 private Socket socket; 
 private ObjectOutputStream output; 
 
 public Socket connect() { 
 try { 
 this.socket = new Socket("localhost", 5555); 
 this.output = new ObjectOutputStream(socket.getOutputStream()); 
 } catch (UnknownHostException ex) { 
 Logger.getLogger(ClienteService.class.getName()).log(Level.SEVERE, null, 
ex); 
 } catch (IOException ex) { 
 Logger.getLogger(ClienteService.class.getName()).log(Level.SEVERE, null, 
ex); 
 } 
 
 return socket; 
 } 
 
 public void send(ChatMessage message) { 
 try { 
 output.writeObject(message); 
 } catch (IOException ex) { 
 Logger.getLogger(ClienteService.class.getName()).log(Level.SEVERE, null, 
ex); 
 } 
 } 
} 
 
Servidor: 
/* 
 * To change this template, choose Tools | Templates 
 * and open the template in the editor. 
 */ 
package com.networks.app; 
 
import com.networks.app.service.ServidorService; 
 
public class Servidor { 
 
 public static void main(String[] args) { 
 new ServidorService(); 
 } 
} 
 
ChatMessage: 
/* 
 * To change this template, choose Tools | Templates 
 * and open the template in the editor. 
 */ 
package com.networks.app.bean; 
 
import java.io.Serializable; 
import java.util.HashSet; 
import java.util.Set; 
 
public class ChatMessage implements Serializable { 
 
 private static final long serialVersionUID = -2468678952584729445L; 
 
 private String name; 
 private String text; 
 private String nameReserved; 
 private Set<String> setOnlines = new HashSet<String>(); 
 private Action action; 
 
 public String getName() { 
 return name; 
 } 
 
 public void setName(String name) { 
 this.name = name; 
 } 
 
 public String getText() { 
 return text; 
 } 
 
 public void setText(String text) { 
 this.text = text; 
 } 
 
 public String getNameReserved() { 
 return nameReserved; 
 } 
 
 public void setNameReserved(String nameReserved) { 
 this.nameReserved = nameReserved; 
 } 
 
 public Set<String> getSetOnlines() { 
 return setOnlines; 
 } 
 
 public void setSetOnlines(Set<String> setOnlines) { 
 this.setOnlines = setOnlines; 
 } 
 
 public Action getAction() { 
 return action; 
 } 
 
 public void setAction(Action action) { 
 this.action = action; 
 } 
 
 public enum Action { 
 CONNECT, DISCONNECT, SEND_ONE, SEND_ALL, USERS_ONLINE 
 } 
} 
 
Servidor Service: 
* To change this template, choose Tools | Templates 
 * and open the template in the editor. 
 */ 
package com.networks.app.service; 
 
import com.networks.app.bean.ChatMessage; 
import com.networks.app.bean.ChatMessage.Action; 
 
import java.io.IOException; 
import java.io.ObjectInputStream; 
import java.io.ObjectOutputStream; 
import java.net.ServerSocket; 
import java.net.Socket; 
import java.util.HashMap; 
import java.util.HashSet; 
import java.util.Map; 
import java.util.Set; 
import java.util.logging.Level; 
import java.util.logging.Logger; 
 
public class ServidorService { 
 
 private ServerSocket serverSocket; 
 private Socket socket; 
 private Map<String, ObjectOutputStream> mapOnlines = new HashMap<String, 
ObjectOutputStream>(); 
 
 public ServidorService() { 
 try { 
 serverSocket= new ServerSocket(5555); 
 
 System.out.println("Servidor on!"); 
 
 while (true) { 
 socket = serverSocket.accept(); 
 
 new Thread(new ListenerSocket(socket)).start(); 
 } 
 
 } catch (IOException ex) { 
 Logger.getLogger(ServidorService.class.getName()).log(Level.SEVERE, null, 
ex); 
 } 
 } 
 
 private class ListenerSocket implements Runnable { 
 
 private ObjectOutputStream output; 
 private ObjectInputStream input; 
 
 public ListenerSocket(Socket socket) { 
 try { 
 this.output = new ObjectOutputStream(socket.getOutputStream()); 
 this.input = new ObjectInputStream (socket.getInputStream()); 
 } catch (IOException ex) { 
 Logger.getLogger(ServidorService.class.getName()).log(Level.SEVERE, 
null, ex); 
 } 
 } 
 
 public void run() { 
 ChatMessage message = null; 
 try { 
 while ((message = (ChatMessage) input.readObject()) != null) { 
 Action action = message.getAction(); 
 
 if (action.equals(Action.CONNECT)) { 
 boolean isConnect = connect(message, output); 
 if (isConnect) { 
 mapOnlines.put(message.getName(), output); 
 sendOnlines(); 
 } 
 } else if (action.equals(Action.DISCONNECT)) { 
 disconnect(message, output); 
 sendOnlines(); 
 return; 
 } else if (action.equals(Action.SEND_ONE)) { 
 sendOne(message); 
 } else if (action.equals(Action.SEND_ALL)) { 
 sendAll(message); 
 } 
 } 
 } catch (IOException ex) { 
 ChatMessage cm = new ChatMessage(); 
 cm.setName(message.getName()); 
 disconnect(cm, output); 
 sendOnlines(); 
 System.out.println(message.getName() + " deixou o chat!"); 
 } catch (ClassNotFoundException ex) { 
 Logger.getLogger(ServidorService.class.getName()).log(Level.SEVERE, 
null, ex); 
 } 
 } 
 } 
 private boolean connect(ChatMessage message, ObjectOutputStream output) { 
 if (mapOnlines.size() == 0) { 
 message.setText("YES"); 
 send(message, output); 
 return true; 
 } 
 
 if (mapOnlines.containsKey(message.getName())) { 
 message.setText("NO"); 
 send(message, output); 
 return false; 
 } else { 
 message.setText("YES"); 
 send(message, output); 
 return true; 
 } 
 } 
 
 private void disconnect(ChatMessage message, ObjectOutputStream output) { 
 mapOnlines.remove(message.getName()); 
 
 message.setText(" se desconectou"); 
 
 message.setAction(Action.SEND_ONE); 
 
 sendAll(message); 
 
 System.out.println("User " + message.getName() + " saiu da sala"); 
 } 
 
 private void send(ChatMessage message, ObjectOutputStream output) { 
 try { 
 output.writeObject(message); 
 } catch (IOException ex) {Logger.getLogger(ServidorService.class.getName()).log(Level.SEVERE, null, 
ex); 
 } 
 } 
 private void sendOne(ChatMessage message) { 
 for (Map.Entry<String, ObjectOutputStream> kv : mapOnlines.entrySet()) { 
 if (kv.getKey().equals(message.getNameReserved())) { 
 try { 
 kv.getValue().writeObject(message); 
 } catch (IOException ex) { 
 Logger.getLogger(ServidorService.class.getName()).log(Level.SEVERE, 
null, ex); 
 } 
 } 
 } 
 } 
 
 private void sendAll(ChatMessage message) { 
 for (Map.Entry<String, ObjectOutputStream> kv : mapOnlines.entrySet()) { 
 if (!kv.getKey().equals(message.getName())) { 
 message.setAction(Action.SEND_ONE); 
 try { 
 kv.getValue().writeObject(message); 
 } catch (IOException ex) { 
 Logger.getLogger(ServidorService.class.getName()).log(Level.SEVERE, 
null, ex); 
 } 
 } 
 } 
 } 
 
 private void sendOnlines() { 
 Set<String> setNames = new HashSet<String>(); 
 for (Map.Entry<String, ObjectOutputStream> kv : mapOnlines.entrySet()) { 
 setNames.add(kv.getKey()); 
 } 
 
 ChatMessage message = new ChatMessage(); 
 message.setAction(Action.USERS_ONLINE); 
 message.setSetOnlines(setNames); 
 
 for (Map.Entry<String, ObjectOutputStream> kv : mapOnlines.entrySet()) { 
 message.setName(kv.getKey()); 
 try { 
 kv.getValue().writeObject(message); 
 } catch (IOException ex) { 
 Logger.getLogger(ServidorService.class.getName()).log(Level.SEVERE, 
null, ex); 
 } 
 } 
 } 
} 
 
 
 
5. Apresentação do programa 
 
 
 
6. Bibliografia 
• http://www.tecmundo.com.br/o-que-e/780 -o-que-e-tcp-ip-.htm> 
• https://www.devmedia.com.br/como-criar-um-chat-multithread-com-
socket-em-java/33639 
• https://www.youtube.com/watch?v=8zLewnva66I&list=PLTHYycROn5oL
hyxkCMVBv5LWDG3XfVnmH 
• https://www.youtube.com/watch?v=9__5MRYPVxc 
https://www.youtube.com/watch?v=8zLewnva66I&list=PLTHYycROn5oLhyxkCMVBv5LWDG3XfVnmH
https://www.youtube.com/watch?v=8zLewnva66I&list=PLTHYycROn5oLhyxkCMVBv5LWDG3XfVnmH
7. Ficha de atividades práticas supervisionadas