Uma Thread pode ser considerada um fluxo de controle sequencial dentro de um programa, onde damos algum job e ela o realiza, provendo maior performance. Em programação é muito importante saber aplicar formas de processamento assíncrono, pois atualmente temos processadores altamente velozes e não sabemos explorá-los devidamente. No nosso chat que criaremos nesse artigo, a Thread será usada para controlar o fluxo de mensagens enviadas e recebidas por um cliente, pois imagina se todos elas fossem armazenadas numa fila e processadas unicamente por uma thread: o serviço seria precário e provavelmente ninguém usaria.

O que é Socket

Socket é um meio de comunicação usado para viabilizar a conexão cliente/servidor, onde um cliente informa o endereço de IP e a respectiva porta do servidor. Se este aceitar a conexão, ele irá criar um meio de comunicação com esse cliente. Logo, a combinação de Threads e Socket é perfeita para implementação de um chat.

OOP

Frente a quantidade de linguagens orientadas a objetos (OO) existentes, como C#, C++, Java, entre outras, fica evidente que para dominá-las é necessário entender bem os pilares OO, como Herança (por interface e por classe), Encapsulamento, Polimorfismo e Abstração. Se dominar bem esses assuntos, com certeza terá mais facilidade em construir códigos simples e com qualidade, tendo baixo acoplamento e alta coesão. Neste artigo nos depararemos com Herança por interface e classe base, abstração e encapsulamento, mas não será o foco do mesmo abordar seus conceitos.

A seguir são descritas as responsabilidades e comportamentos das classes Server.java e Cliente.java usadas para a construção do Chat:

  • Responsabilidade e comportamentos do Server.java: o servidor servirá como unidade centralizadora de todas as conexões recebidas via socket e terá como responsabilidade o envio de uma mensagem (recebida de um cliente) para todos os demais conectados no servidor. Quando um cliente se conecta a ele o mesmo cria uma Thread para aquele cliente, ou seja, cada conexão terá sua respectiva Thread e o servidor fará a gestão disso;
  • Responsabilidade e comportamentos do Client.java: Cada usuário criará uma instância do cliente e fará uma conexão com o servidor socket. O cliente deverá informar o endereço do server socket e a respectiva porta, por isso é necessário executar o Server.java antes.

Lembre-se: escolha uma porta que não esteja sendo usada para a execução do server socket e certifique-se que o firewall ou algum antivírus não esteja bloqueando a porta escolhida. Para esse artigo definimos como 12345.

Na Listagem 1 temos a declaração dos pacotes usados na classe servidor.java. Veja que usamos “streams”, “collections” e classes para a construção de formulários.

Listagem 1. 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;

A seguir temos a declaração da classe servidor.java. Veja que ela extends Thread, logo é um tipo de Thread, adotando todos os comportamentos e propriedades desta classe

public class Servidor extends Thread {

Na Listagem 2 temos 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.

Listagem 2. 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;      

Na Listagem 3 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.

Listagem 3. 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();
   }                          
}           

A Listagem 4 mostra 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.

Listagem 4. 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();
   
   }                       
}           

Na Listagem 5 temos a declaração do método “sendToAll”. Quando um cliente envia uma mensagem, o servidor recebe e manda esta 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.

Listagem 5. 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 Listagem 6 mostra a declaração do método main, que ao 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.

Listagem 6. 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

A Listagem 7 mostra a declaração dos pacotes usados na classe cliente.java.

Listagem 7. 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:

public class Cliente extends JFrame implements ActionListener, KeyListener {

Para a construção do formulário foram usados objetos do pacote javax.swing. A Listagem 8 mostra a declaração dos atributos estáticos e de instâncias da classe Cliente.java.

Listagem 8. 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;      

Ao executar a classe cliente aparecerá 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.

A Listagem 9 mostra 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.

Listagem 9. 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 da Listagem 10 é 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.

Listagem 10. 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();
}

A Listagem 11 tem o método 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.

Listagem 11. 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("");        
}

Na Listagem 12 temos o método 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.

Listagem 12. 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 da Listagem 13 é usado para desconectar do server socket. Nele o sistema apenas fecha os streams de comunicação.

Listagem 13. 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 na Listagem 14. 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.

Listagem 14. 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 da Listagem 15 é acionado quando o usuário pressiona “Enter”, verificando se o key code é o Enter. Caso seja, a mensagem é enviada para o servidor.

Listagem 15. 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               
}           

A Listagem 16 mostra o método main, onde é criado apenas um cliente e são configurados os métodos conectar e escutar.

Listagem 16. Declaração do método main

  public static void main(String []args) throws IOException{
              
   Cliente app = new Cliente();
   app.conectar();
   app.escutar();
}           

Depois do código implementado na IDE Eclipse ou 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 mensagem sendo enviada para ninguém.

Quando executar o servidor pela primeira vez aparecerá uma caixa para informar os parâmetros necessários. Informe o número da porta, conforme mostra a Figura 1.

Input
para informar o número da porta onde o servidor socket receberá as conexões

Figura 1. 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, como vemos na Figuras 2.

Inputs do IP do servidor socket, a porta e o nome que será visto por você e pelos outros
usuários

Figura 2. 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

Figura 3. 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 da Figura 3 , em que o Paul começa a conversa.

Vimos como é simples a construção básica de um chat, desde de que a ideia de Thread e Socket seja bem compreendida.

Espero que tenham gostado!