/**
 *
 *  La pc debe estar conectada a internet
 *  es la representacion de una direccion ip, tanto para ipv4 e ipv6, siendo usada
 *  por las demas clases Socket,ServerSocket, URL, DatagramSocket, DatagramPacket y mas.
 *  usualmente incluye el nombre de host aka hostname, y la direccion ip
 *
 *  No tiene constructores publicos, usa metodos factoria publicos que se conectan
 *  a un servidor DNS para resolver el nombre de host
 */
public class HostNameIPInetAddress {
 
    private static final Logger LOGGER = Logger.getLogger(HostNameIPInetAddress.class.getSimpleName());
 
    public HostNameIPInetAddress() {
        //resolverNombreDeDominio();
        //obtenerIpLocal();
        tiposDeDirecciones();
    }
 
    private void resolverNombreDeDominio() {
        try {
            final InetAddress inetAddress = InetAddress.getByName("www.facebook.com");
            LOGGER.info(inetAddress.toString());
 
            /**
             *
             * www.facebook.com/31.13.83.36
             * Process finished with exit code 0
             */
 
            final InetAddress inetAddress2 = InetAddress.getByName("31.13.83.36");
            LOGGER.info(inetAddress2.getHostName());
 
            final InetAddress[] inetAddresses3 = InetAddress.getAllByName("93.115.28.104");
            Stream.of(inetAddresses3).forEach(e -> LOGGER.info(e.toString()));
 
 
        } catch (UnknownHostException e) {
            e.printStackTrace();
        }
    }
 
    /**
     * Obtiene la ip local y el nombre del host
     * _0x52eb/192.168.56.1
     */
    private void obtenerIpLocal() {
        try {
            final InetAddress inetAddress = InetAddress.getLocalHost();
            LOGGER.info(inetAddress.toString());
            LOGGER.info(inetAddress.getHostAddress());
        } catch (UnknownHostException e) {
            e.printStackTrace();
        }
    }
 
    /**
     * Tipos de direcciones
     *
     * Cada direccion ip tiene un patron, 127.0.0.1 es la ip loopback
     * ipv4 en el rango de 224.0.0.0 a 239.255.255.255 son multicast
     *
     * Java incluye 10 metodos para saber que direccion ip es de un tipo
     *
     */
    private void tiposDeDirecciones() {
        try {
            final InetAddress globalAddress = InetAddress.getByName("www.facebook.com");
            if(globalAddress.isAnyLocalAddress()) {
 
            } else if(globalAddress.isLoopbackAddress()) {
 
            } else if(globalAddress.isLinkLocalAddress()) {
 
            } else if(globalAddress.isSiteLocalAddress()) {
 
            } else {
                LOGGER.info("Es una direccion global: " + globalAddress.getHostAddress());
            }
 
        } catch (UnknownHostException e) {
            e.printStackTrace();
        }
    }
 
    public static void main(String  ...ablalb) {
        new HostNameIPInetAddress();
    }
}
 

import javax.swing.*;
import java.io.*;
import java.net.Socket;
import java.net.UnknownHostException;
import java.nio.charset.StandardCharsets;
import java.util.Objects;
 
/**
 * Usando al Server dict.org con fd-eng-spa para traducir de ingles a español
 * no es lo maximo, pero es un buen ejemplo, logrando alguna utilidad que quieras.
 *
 * Te puedes conectar a este dominio via telnet desde la consola de windows
 * previamente activando telnet en, activar caracteristicas de windows, puedes usar otra app para telnet
 * como putty tambien.
 */
public class SocketEscribiendoDictOrg {
 
    public SocketEscribiendoDictOrg(final String palabraTraducir) {
 
        try(final Socket socket = new Socket("dict.org",2628);
 
            final OutputStream out = socket.getOutputStream();
            final BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(out, StandardCharsets.UTF_8))) {
 
            //tiempo de espera maximo 10 segundos
            socket.setSoTimeout(10000);
 
            bw.write("DEFINE fd-eng-spa " + palabraTraducir);
            bw.write(System.lineSeparator());
            bw.flush();
 
            InputStreamReader in = new InputStreamReader(socket.getInputStream(),StandardCharsets.UTF_8);
            BufferedReader br = new BufferedReader(in);
            String line;
            while (Objects.nonNull(line = br.readLine())) {
                if(line.startsWith("250 ")) {
                    return;
                } else if(line.startsWith("552 ")){
                    System.out.print("No exite la palabra");
                    return;
                } else if(line.matches("[0-9]{1,3}\\d .*")) {
                    continue;
                } else if(line.trim().equals(".")) {
                    continue;
                } else {
                    System.out.println(line);
                }
            }
            //escribiendo quit al server para salir
            bw.write("quit");
            bw.write(System.lineSeparator());
            bw.flush();
        } catch (UnknownHostException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
 
    public static void main(String ...blaBla) {
        final String palabra = JOptionPane.showInputDialog(null,"Introduce palabra en ingles");
        if(Objects.nonNull(palabra)) {
            new SocketEscribiendoDictOrg(palabra);
        } else {
          JOptionPane.showMessageDialog(null,"No introdujo palabra");
          System.exit(0);
        }
    }
}
 

import java.time.Instant;
import java.time.ZoneId;
import java.time.format.DateTimeFormatter;
import java.util.Locale;
import java.util.logging.Logger;
 
/**
 * Interface basica de ejemplo para los logs.
 */
public interface LoggerForSockets {
 
    default void info(final String info) {
        Logger.getLogger("UdpLogger").info(info);
    }
 
    default void error(final String error) {
        Logger.getLogger("UdpLogger").warning(error);
    }
 
    /**
     *
     * @return String con la hora formateada
     */
    default String getHora() {
        return DateTimeFormatter.ofPattern("eeee, d  'de' MMMM 'de' uuuu hh:mm:ssS a")
                .withLocale(Locale.getDefault())
                .withZone(ZoneId.systemDefault())
                .format(Instant.now());
    }
}

import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.concurrent.*;
 
import static java.util.Objects.requireNonNull;
 
/**
 *
 * Uso:
 *          ServerSocketHora.newBuilder()
 *                 .conPuerto(13)
 *                 .conNumeroDeHilos(10)
 *                 .crearServerSocket()
 *                 .respuestaAsincrona()
 *                 .build();
 *
 *
 * @autor rub´n
 */
public class ServerSocketHora implements LoggerForSockets, Serializable {
 
    private ExecutorService executorService;
    private ScheduledExecutorService scheduled = Executors.newScheduledThreadPool(2);
    private int puerto;
    private ServerSocket serverSocket;
    private Socket socket;
 
    private ServerSocketHora() {
    }
 
    public static ServerSocketHora newBuilder() {
        return new ServerSocketHora();
    }
 
    public ServerSocketHora conNumeroDeHilos(final int numHilos) {
        if (numHilos < 0) { // preconfigurados con 50 hilos
            this.executorService = Executors.newFixedThreadPool(50);
        } else {
            this.executorService = Executors.newFixedThreadPool(numHilos);
        }
        return this;
    }
 
    public ServerSocketHora conPuerto(final Integer puerto) {
        this.puerto = requireNonNull(puerto, "Puerto no debe ser nulo");
        return this;
    }
 
    public ServerSocketHora crearServerSocket() {
        try {
            this.serverSocket = new ServerSocket(puerto);
            info("Conexion establecida por el puerto " + puerto);
        } catch (IOException ex) {
            error(ex.toString());
        }
        return this;
    }
 
    /**
     * Aqui es donde esta la parte mas dificil en realidad
     * asincrono
     *
     * @return ServerSocketHora con la hora al cliente
     */
    public ServerSocketHora respuestaAsincrona() {
        scheduled.scheduleAtFixedRate(() -> {
            try {
                /*
                 * Sin try-with resources en este caso, por que
                 * se cerrara inmediatamente, impidiento que se engendre un nuevo thread
                 */
                this.socket = serverSocket.accept();
                info("Conectado con cliente: "+  socket.getLocalAddress()+":"+ socket.getLocalPort());
            } catch (IOException e) {
                error(e.toString());
            }
            CompletableFuture.runAsync(() -> {
                try (final BufferedOutputStream bos = new BufferedOutputStream(socket.getOutputStream());
                     final DataOutputStream data = new DataOutputStream(bos)) {
 
                    synchronized (this) {
                        data.writeUTF("Hora Servidor: " + getHora());
                        data.writeUTF(System.lineSeparator());
                        data.flush();
                    }
                } catch (IOException ex) {
                    error(ex.toString());
                }
            }, executorService);
        },0,1,TimeUnit.NANOSECONDS);
        return this;
    }
 
    public ServerSocketHora build() {
        return new ServerSocketHora();
    }
 
    public static void main(String... blabla) {
        ServerSocketHora.newBuilder()
                .conPuerto(13)
                .conNumeroDeHilos(10)
                .crearServerSocket()
                .respuestaAsincrona()
                .build();
    }
 
}
 

import java.io.*;
import java.net.InetAddress;
import java.net.Socket;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import static java.util.Objects.requireNonNull;
 
/**
 * Uso:
 *          ServerClientHora.newBuilder()
 *                 .conPuerto(13)
 *                 .conNumeroDeHilos(10)
 *                 .crearSocketCliente()
 *                 .solicitudAsincrona()
 *                 .build();
 *
 * @author rub´n
 */
public class ServerClientHora implements Serializable,LoggerForSockets {
 
    private ExecutorService executorService;
    private int puerto;
    private Socket socket;
 
    private ServerClientHora() {
    }
 
    public static ServerClientHora newBuilder() {
        return new ServerClientHora();
    }
 
    /**
     *
     * @param numHilos preconfigurados con 50
     * @return ServerClientHora
     */
    public ServerClientHora conNumeroDeHilos(final int numHilos) {
        if (numHilos < 0) {
            this.executorService = Executors.newFixedThreadPool(50);
        } else {
            this.executorService = Executors.newFixedThreadPool(numHilos);
        }
        return this;
    }
 
    public ServerClientHora conPuerto(final Integer puerto) {
        this.puerto = requireNonNull(puerto, "Puerto no debe ser nulo");
        return this;
    }
 
    /**
     *
     * @return ServerClientHora
     */
    public ServerClientHora crearSocketCliente() {
        try {
            this.socket = new Socket(InetAddress.getLocalHost(), puerto);
            info("Conexion establecida por el puerto " + puerto);
            socket.setSoTimeout(5000);//10 segundos de espera maximo
            info("Cliente conectado " + socket.getLocalAddress() + ":" + socket.getLocalPort());
 
        } catch (IOException ex) {
            error(ex.toString());
        }
        return this;
    }
 
    /**
     * Aqui se leera la respuesta del ServerSocket aka Server
     * @return ServerClientHora
     */
    public ServerClientHora solicitudAsincrona() {
        CompletableFuture.runAsync(() -> {
            try (final BufferedInputStream bis = new BufferedInputStream(socket.getInputStream());
                 final DataInputStream data = new DataInputStream(bis)) {
 
                synchronized (this) {
                    info(data.readUTF());
                }
            } catch (IOException ex) {
                error(ex.toString());
            }
        }, executorService);
        return this;
    }
 
    /**
     *
     * @return a new ServerClientHora
     */
    public ServerClientHora build() {
        return new ServerClientHora();
    }
 
    public static void main(String... blabla) {
 
        ServerClientHora.newBuilder()
                .conPuerto(13)
                .conNumeroDeHilos(10)
                .crearSocketCliente()
                .solicitudAsincrona()
                .build();
 
    }
 
}