Enviando e Recebendo dados via Sockets (Parte I)

Comunicação de Computadores utilizando Sockets

Enviando e Recebendo dados via Sockets

Mais Invormação sobre socket basta entrar nesta página.
<<<Clique Aqui>>>

 

Arquivo: chatserver.java
import java.awt.*;
import java.net.*;
import java.io.*;
import java.util.*;

public class chatserver extends Thread
{
  int DEFAULT_PORT=4321;
  protected int port;
  protected ServerSocket server_port;
  protected ThreadGroup CurrentConnections;
  protected Vector connections;
  protected ServerWriter writer;
  private Calendar datatual;

  //Criar um ServerSocket
  public chatserver()
  {
    super("Server");
    this.port=DEFAULT_PORT;
  
    try
    {
      server_port=new ServerSocket(port);
    }
    catch (IOException e)
    {
      System.err.println(e+"Exception");
    }

    //Cria um threadgroup para as conexoes
    CurrentConnections=new ThreadGroup("Server Connections");

    //Mensagem inicial na janela do servidor
    System.out.println("=== Conexoes Realizadas ===");

    //Um vetor para armazenar as conexoes
    connections=new Vector();

    writer=new ServerWriter(this);

    //Inicia o servidor para ouvindo as conexoes
    this.start();
  }

  public void run()
  {
    try
    {
      while(true)
      {
        datatual = Calendar.getInstance();
        Socket cliente_socket=server_port.accept();
        //Exibe na janela do servidor os clientes que conectam (mostra o host
        //do cliente, a porta e a data e hora da conexao
        System.out.println("Host:"+cliente_socket.getInetAddress()+"| Porta:"+
        cliente_socket.getPort()+"| "+datatual.getTime());
        Connection c=new Connection(cliente_socket,CurrentConnections,3,writer);

        //evita o acesso simultaneo
        synchronized(connections)
        {
          //adiciona esta nova conexao a lista
          connections.addElement(c);
        }
      }
    }
    catch(IOException e)
    {
      System.err.println(e+"Exception");
    }
  }

  //Inicia o servidor
  public static void main(String[] args)
  {
    new chatserver();
  }
}

//----------------------------------------------------------------------------
class Connection extends Thread
{
  static int numberOfConnections=0;
  protected Socket client;
  protected DataInputStream in;
  protected PrintStream out;
  protected ServerWriter writer;
 
  public Connection(Socket cliente_socket, ThreadGroup CurrentConnections,
                                             int priority, ServerWriter writer)
  {
    super(CurrentConnections,"Connection number"+numberOfConnections++);
 
    //define a prioridade
    this.setPriority(priority);
    client=cliente_socket;
    this.writer=writer;
    try
    {
      //Atarraxa os streams aos streams de entrada e saida do socket do
      //cliente e adiciona este outputstream ao vetor que contem todos
      //os streams de saida, usados pelo escritor writer
      in=new DataInputStream(client.getInputStream());
      out=new PrintStream(client.getOutputStream());
      writer.OutputStreams.addElement(out);
    }
    catch(IOException e)
    {
      try
      {
        client.close();
      }
      catch (IOException e2)
      {
        System.err.println("Exception while getting socket streams:"+e);
        return;
      }
    }

    //dispara Thread
    this.start();
  }

  //O metodo run faz um laco lendo as mensagens recebidas
  public void run()
  {
    String inline;
  
    //Envia uma mensagem de boas vindas ao cliente
    out.println("Bem vindo ao MiniChat...");
    try
    {
      while(true)
      {
        //le uma linha de mensagem
        inline=in.readLine();
        //A conexao eh interrompida se null

        if (inline==null)
          break;

        //Joga a linha no escritor writer
        writer.setOutdata(inline);

        synchronized(writer)
        {
          //chama o escritor synchronized() para evitar que duas linhas
          //Connection o chamem ao mesmo tempo. Esta e uma forma de "bloqueio".
          writer.notify();
        }
      }
    }
    catch(IOException e)
    {}
    finally
    {
      try
      {
        client.close();
      }
      catch(IOException e2)
      {}
    }
  }
}  

//----------------------------------------------------------------------------
class ServerWriter extends Thread
{
  protected chatserver server;
  public Vector OutputStreams;
  public String outdata;
  private String outputline;
 
  public ServerWriter(chatserver s)
  {
    super(s.CurrentConnections,"Server Writer");
    server=s;
    OutputStreams=new Vector();
    this.start();
  }

  public void setOutdata(String mensagem)
  {
    outdata=mensagem;
  }

  public synchronized void run()
  {
    while(true)
    {
      //A linha faz um laco para sempre, mas na vedade so e executada quando
      //a condicao wait for reinicializada por um notify. Isso num bloco
      //sincronizado para bloquear a linha e evitar o acesso multiplo.
      try
      {
        this.wait();
      }
      catch (InterruptedException e)
      {
        System.out.println("Caught an Interrupted Exception");
      }
      outputline=outdata;
      synchronized(server.connections)
      {
        for (int i=0 ; i<OutputStreams.size() ; i++)
        {
          //Eh impressa a mensagem em cada um OutputStreams.
          PrintStream out;
          out=(PrintStream)OutputStreams.elementAt(i);
          out.println(outputline);
        }
      }
    }
  }
}
Arquivo: clientechat.java
import java.io. * ;
import java.net. * ;
import java.awt. * ;
import java.awt.event. * ;
import javax.swing. * ;
import java.awt.event. * ;

public class clientechat extends JFrame {

    public static final int DEFAULT_PORT = 4321;
    public Socket clisoc;
    private Thread reader;
    public JTextArea OutputArea;
    public JTextField InputArea, nomefield;
    public PrintStream out;
    public String Name;

    //Cria as linhas de leitura e escrita e as inicia.
    public clientechat() {

        super("Cliente Chato");
        this.setSize(320, 460);
        this.setLocation(50, 100);
        this.setResizable(false);

        Container ct = this.getContentPane();
        ct.setLayout(null);

        JLabel xlabel_01 = new JLabel("MiniChat usando conexao (Socket TCP)");
        xlabel_01.setBounds(10, 0, 300, 20);
        ct.add(xlabel_01);

        JLabel xlabel_02 = new JLabel("Nome do usuario");
        xlabel_02.setBounds(10, 20 + 1, 150, 20);
        ct.add(xlabel_02);

        nomefield = new JTextField("");
        nomefield.setBounds(10, 20 * 2 + 1, 150, 20);
        ct.add(nomefield);

        OutputArea = new JTextArea("");
        OutputArea.setBounds(10, 20 * 3 + 10, 300, 300);
        ct.add(OutputArea);

        JLabel xlabel_03 = new JLabel("Digite uma mensagem e pressione ENTER");
        xlabel_03.setBounds(10, 20 * 4 + 1 + 300, 300, 20);
        ct.add(xlabel_03);

        InputArea = new JTextField("");
        InputArea.setBounds(10, 20 * 5 + 1 + 300, 300, 20);
        ct.add(InputArea);

        Image Icone = Toolkit.getDefaultToolkit().getImage("icon.gif");
        setIconImage(Icone);

        this.setVisible(true);

        this.addWindowListener(new WindowAdapter() {
            public void windowClosing(WindowEvent e) {
                System.exit(0);
            }
        });

        InputArea.addKeyListener(new KeyAdapter() {
            public void keyPressed(KeyEvent tecla) {
                int c = tecla.getKeyCode();

                if (c == KeyEvent.VK_ENTER)
                //Vigia se o usuario pressiona a tecla ENTER.
                //Isso permite saber a mensagem esta pronta para ser enviada!
                {
                    String InLine = InputArea.getText();
                    Name = nomefield.getText();
                    out.println(Name + ">" + InLine);
                    InputArea.setText("");
                    //Envia a mensagem, mas adiciona o nome do usuario a ela para que os
                    //outros clientes saibam quem a enviou.
                }
            }
        });
        try {
            //Cria um socket cliente passando o endereco e a porta do servidor
            clisoc = new Socket("127.0.0.1", DEFAULT_PORT);
            reader = new Reader(this, OutputArea);
            out = new PrintStream(clisoc.getOutputStream());
            //Define prioridades desiguais para que o console seja compartilhado
            //de forma efetiva.
            reader.setPriority(3);
            reader.start();
        } catch (IOException e) {
            System.err.println(e);
        }
    }

    public static void main(String[] args) {
        new clientechat();
    }
}

//----------------------------------------------------------------------------
//A classe Reader le a entrada do soquete e atualiza a OutputArea com as
//novas mensagens.
class Reader extends Thread {
    protected clientechat cliente;
    private JTextArea OutputArea;
    public Reader(clientechat c, JTextArea OutputArea) {
        super("chatclient Reader");
        this.cliente = c;
        this.OutputArea = OutputArea;
    }

    public void run() {
        DataInputStream in = null;
        String line;
        try { in = new DataInputStream(cliente.clisoc.getInputStream());
            while (true) {
                line = in .readLine();
                //Adiciona a nova mensagem a OutputArea
                OutputArea.append(line + "\r\n");
            }
        } catch (IOException e) {
            System.out.println("Reader:" + e);
        }
    }
}

Enviando e Recebendo dados via Socket (Parte II)

Enviando e Recebendo dados via Socket

Arquivo: ServidorDatagrama.java
import java.io.*;
import java.net.*;

public class ServidorDatagrama
{
  public static void main(String[] args)
  {
    DatagramSocket socket=null;
    DatagramPacket recvPacket, sendPacket;
    try
    {
      System.out.println("=== Servidor de eco no ar !!! ===");
      socket=new DatagramSocket(4545);
      while(socket!=null)
      {
        recvPacket=new DatagramPacket(new byte[512], 512);
        socket.receive(recvPacket);
        sendPacket=new DatagramPacket(recvPacket.getData(), recvPacket.getLength(),
                                  recvPacket.getAddress(), recvPacket.getPort());
        socket.send(sendPacket);
        System.out.println("Mensagem recebida do Cliente: "+recvPacket.getAddress()+
                                                        ":"+recvPacket.getPort());
        System.out.print("=> ");
        System.out.write(recvPacket.getData(),0,recvPacket.getLength());
        System.out.print("\r\n");
        System.out.print("\r\n");
      }
    }
    catch(SocketException se)
    {
      System.out.println("Erro no ServidorDatagrama: "+se);
    }
    catch(IOException ioe)
    {
      System.out.println("Erro no ServidorDatagrama: "+ioe);
    }
  }
}
Arquivo: ClienteDatagrama.java
import java.io.*;
import java.net.*;

public class ClienteDatagrama
{
  private DatagramSocket socket=null;
  private DatagramPacket recvPacket, sendPacket;
  public static void main(String[] args)
  {
    DatagramSocket socket=null;
    DatagramPacket recvPacket, sendPacket;
    try
    {
      socket=new DatagramSocket();
      InetAddress hostAddress=InetAddress.getByName("127.0.0.1");
      DataInputStream userData=new DataInputStream(System.in);
      while (socket !=null)
      {
        //leitura da mensagem para enviar para o servidor Datagrama
        System.out.print("Mensagem para enviar: ");
        String userString=userData.readLine();
        if ((userString==null)||(userString.equals("")))
          return;
   
        //converte o String para um Array de bytes
        byte sendbuf[]=new byte[userString.length()];
        userString.getBytes(0,userString.length(),sendbuf,0);
        sendPacket=new DatagramPacket(sendbuf, sendbuf.length, hostAddress, 4545);
  
        //envia o Datagrama para o servidor
        socket.send(sendPacket);
  
        //recebe o Datagrama do servidor
        recvPacket=new DatagramPacket(new byte[512], 512);
        socket.receive(recvPacket);
  
        //exibe na tela do cliente a mensagem de eco do servidor Datagrama
        System.out.print("Mensagem recebida (eco): ");
        System.out.write(recvPacket.getData(),0,recvPacket.getLength());
        System.out.print("\r\n");
        System.out.print("\r\n");
      }
    }
    catch(SocketException se)
    {
      System.out.println("Erro no ClienteDatagrama: "+se);
    }
    catch(IOException ioe)
    {
      System.out.println("Erro no ClienteDatagrama: "+ioe);
    }
  }
}

Criptografia

Somente criptografar

Arquivo: JavaCript.java 
/*
segue uma sugestão....

Por que a necessidade de Descriptografar a senha?
Um método mais seguro, é vc compara as criptografias.
O que eu estou tentando dizer é que é muito mais seguro vc criptografar
a senha que o usuário digitou e comparar esse valor (criptografado)
com a senha criptografada que vc tem no seu Banco de Dados. Isso evita que senha
seja interceptadas num trafego de rede.
*/

import java.util.Scanner;

public class JavaCript {
public static void main(String[] args) {
String Texto = "";
Scanner teclado = new Scanner(System.in);
System.out.println("Texto: ");
Texto = teclado.next();
String cript = encrypt(Texto);
System.out.println("Criptografar: " + cript);
}
    public static String encrypt(String sign) {   
       try {   
          java.security.MessageDigest md =   
             java.security.MessageDigest.getInstance("MD5");   
          md.update(sign.getBytes());   
          byte[] hash = md.digest();   
          StringBuffer hexString = new StringBuffer();   
          for (int i = 0; i < hash.length; i++) {   
             if ((0xff & hash[i]) < 0x10)   
                hexString.append(   
                   "0" + Integer.toHexString((0xFF & hash[i])));   
             else   
                hexString.append(Integer.toHexString(0xFF & hash[i]));   
          }   
          sign = hexString.toString();   
       }   
       catch (Exception nsae) {   
          nsae.printStackTrace();   
       }   
       return sign;   
    }
}

Criptografar e Descriptografar

Este código abaixo é só um exemplo, um resumo, você pode criar um código criptográfico a partir deste modelo:

Obs:

Arquivo: crypt.java 
public class crypt {
public static  void main(String[] args){
String Texto = "Ola tudo bem!";
System.out.println("Texto = "+Texto);

String cript = Criptografar(Texto);
System.out.println("Criptografar = "+cript);

String descript = Descriptografar(cript);
System.out.println("Descriptografar = "+ descript);

}
public static String Criptografar(String teste){
    String s = "";
    for(int x = 0; x <= teste.length(); x++){
        try {
            s += ""+(char)(((int)teste.charAt(x))+10);
        } catch (Exception err1) {}
    }
    return s;
}
public static String Descriptografar(String teste){
    String s = "";
    for(int x = 0; x <= teste.length(); x++){
        try {
            s += ""+(char)(((int)teste.charAt(x))-10);
        } catch (Exception err1) {}
    }
    return s;
}
}