El tipo de conexion es inversa. Y su objetivo es tomar capturas del escritorio cada cierto intervalo de tiempo y las envia a traves de socket a un servidor en donde se previsualizan una despues de otra. :)

Cliente:

Código:

import java.io.*;
import java.net.*;
import java.awt.Rectangle;
import java.awt.Robot;
import java.awt.Toolkit;
import java.awt.image.BufferedImage;
import javax.imageio.ImageIO;

public class Cliente {
 
   static final int PUERTO = 5000;  // puerto de conexion
   private String HOST;
    private Socket sCliente;
    private ObjectOutputStream salida;
   
    // constructor
   public Cliente( String host ) {
      HOST = host;
   } // fin del constructor
   
   // metodo ejecutarConexion
   private void ejecutarConexion() {
      try {
         conectarServidor();
         salida = new ObjectOutputStream( sCliente.getOutputStream() );
         salida.flush();
         while ( true ) {
            enviarImage();
            Thread.sleep(500); // intervalo de tiempo entre capturas del escritorio
         }
      } catch ( Exception e ) {
           System.out.println(e.getMessage());
        }
   } // fin del metodo ejecutarConexion
   
   // metodo conectarServidor
   private void conectarServidor() throws IOException {
      sCliente = new Socket( HOST, PUERTO );
    } // fin metodo conectarServidor

   // metodo enviarImage
   private void enviarImage() {
      Rectangle rectangleTam = new Rectangle(Toolkit.getDefaultToolkit().getScreenSiz  e());
        try {
            Robot robot = new Robot();
            BufferedImage bufferedImage = robot.createScreenCapture(rectangleTam);
            ByteArrayOutputStream salidaImagen = new ByteArrayOutputStream();
            ImageIO.write(bufferedImage, "jpg", salidaImagen);
            byte[] bytesImagen = salidaImagen.toByteArray();
            salida.writeObject( bytesImagen );
            salida.flush();
        } catch ( Exception e ) {
           System.out.println(e.getMessage());
        }
   } // fin del metodo enviarImage
   
   // metodo Main
   public static void main(String[] args) {
      Cliente principal = new Cliente( "Ip_a_Conectar" ); // cambiar Ip_a_Conectar por la que corresponda
      principal.ejecutarConexion();
   }

}


Servidor:

Código:

import java.io.*;
import java.net.*;
import javax.imageio.ImageIO;
import java.awt.Graphics2D;
import java.awt.RenderingHints;
import java.awt.image.BufferedImage;
import javax.swing.ImageIcon;
import javax.swing.JFrame;
import javax.swing.JLabel;

public class Servidor extends JFrame {

   static final int PUERTO = 5000; // puerto de conexion
   private ServerSocket sServidor;
    private Socket sCliente;
    private ObjectInputStream entrada;
    private JLabel label;
   
   // constructor
   public Servidor() {
      setTitle("Capturador de Pantalla");
      setSize(810, 610); // tamaño de la ventana
      setVisible(true);
      setResizable(false);
      setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
      
      label = new JLabel();
      add(label);
   } // fin del constructor
   
   // metodo ejecutarConexion
   private void ejecutarConexion() {
      try {
         sServidor = new ServerSocket(PUERTO);
         while ( true ) {
                try {
                    esperarConexion();
                    entrada = new ObjectInputStream( sCliente.getInputStream() );
                    procesarImagen();
                } catch ( Exception e ) {
                   System.out.println(e.getMessage());
                }
         }
      } catch ( Exception e ) {
            System.out.println(e.getMessage());
        } finally {
            cerrarConexion();
        }
   } // fin del metodo ejecutarConexion
   
   // metodo esperarConexion
   private void esperarConexion() throws IOException {
      sCliente = sServidor.accept();
    } // fin del metodo esperarConexion
   
   // metodo cerrarConexion
   private void cerrarConexion() {
        try {
            entrada.close();
            sCliente.close();
        } catch( Exception e ) {
           System.out.println(e.getMessage());
        }
    } // fin del metodo cerrarConexion
   
   // metodo procesarImagen
   private void procesarImagen() throws IOException {
      
        // medidas de redimensionado de la imagen
      int WIDTH = 800;
      int HEIGHT = 600;
      
      do {
         try {
                byte[] bytesImagen = (byte[]) entrada.readObject();
                ByteArrayInputStream entradaImagen = new ByteArrayInputStream(bytesImagen);
                BufferedImage bufferedImage = ImageIO.read(entradaImagen);
               
                BufferedImage tnsImg = new BufferedImage(WIDTH,HEIGHT, BufferedImage.TYPE_INT_RGB);
                Graphics2D graphics2D = tnsImg.createGraphics();
                graphics2D.setRenderingHint(RenderingHints.KEY_INT  ERPOLATION,RenderingHints.VALUE_INTERPOLATION_BILI  NEAR);
                graphics2D.drawImage(bufferedImage, 0, 0, WIDTH, HEIGHT, null);
               
                label.setIcon(new ImageIcon( tnsImg ));
         } catch( Exception e ) {
              System.out.println(e.getMessage());
           }     
      } while ( true );
   } // fin del metodo procesarImagen
   
   // metodo Main
   public static void main(String[] args) {
      Servidor principal = new Servidor();
      principal.ejecutarConexion();
   }

}

Antes de ponerle el video les dejo algunas aclaraciones.

En el cliente, en el metodo main tienen que cambiar Ip_a_Conectar por la IP que corresponda. Y en el metodo ejecutarConexion hay un sleep que es el intervalo entre capturas. Pueden cambiarlo a gusto.
Por parte del servidor, en el metodo procesarImagen tiene unas medidas de redimensionado de la imagen. Cuando recibe la imagen la achica a esas dimensiones para que entre en el form. Si uno quiere puede cambiar esas medidas pero como recomendacion tambien necesitara cambiar las medidas de la ventana que hay en el constructor.

Dicho todas las cosas, les dejo un video :)



Saludos