La tienes en la misma jdk integrada ya, tendras que traducirla tú mismo, un trabajon, eso tomaría líneas de escritura, y las versiones de Java nuevas, como jdk 9 en adelante incluyen mejoras como http 2.0, HttpClient, HttpRequest propias etc.

Estás pidiendo mucho. Un libro completo, incluso los hay.

Muy bien con Sockets está tu solución, a la hora de cifrar claramente se complica un poco más pero no es imposible.

... continuara

---

Ejemplo código enviando datagramas a servidor UDP conteniendo lista de Strings para ser procesada y luego le devolverá el resultado  PoC.

https://foro.elhacker.net/ejercicios/como_enviar_un_arraylist_del_cliente_al_servidor_usando_udp-t496078.0.html;msg2194318#msg2194318

---

Otro ejemplo

/**
 *
 *  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);
        }
    }
}
 

---

Ejemplo Socket mas Cliente con simple builder por separado

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

ServerSocket PoC

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

Cliente PoC

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

Buenas tardes, serian tan amables de explicarme con detalle la relación entre estas clases, ServerSocket, SocketImpl, SocketOptions. Cuando digo que quiero saber la relación, me refiero a que según el API de java el trabajo de la clase ServerSocket es ejecutado por una instancia de la clase SocketImpl, pero como es esto posible si la clase SocketImpl es una clase abstracta y por ende no puede ser instanciada, por otro lado dice que la clase SocketImpl implementa la interfaz SocketOptions. Me podrian explicar gracias.

Buen día, gracias por tu respuesta, si veo que no se instancia pero si se usa a través de la herencia por la jerarquía de clases. ahora bien, aclarado esto, podrías explicarme esta línea de código, "cs = ss.accept();" estoy picando y analizando un código fuente de una aplicación cliente servidor en donde un servidor está esperando por un cliente el cual cuando se conecta envía unos mensajes luego el server y el cliente cierran el socket, no envío el código completo porque la idea es que yo aprenda y no que me des todas las respuestas, solo aclarar dudas pero si aun así deseas verlo te doy el link de donde lo saque. en esta línea lo que puedo entender es que cs es el socket cliente, y ss el socket servidor el cual se instancio para poder usar el método accept() . lo que no entiendo es porque lo que devuelve el método accept se le asigna a la variable tipo socket cs, esta línea de código está en la clase servidor.

Enviado desde mi ANE-LX3 mediante Tapatalk

---

por si necesitas un poco más,  

public void startServer()//Método para iniciar el servidor
{ try
{
System.out.println("Esperando..."); //Esperando conexión
 
cs = ss.accept(); //Accept comienza el socket y espera una conexión desde un cliente
 
System.out.println("Cliente en línea");
 

Enviado desde mi ANE-LX3 mediante Tapatalk

Adjunto una imagen con el código fuente de un programa pequeño para verificar que socket devuelve el método accept una vez que acepta una petición de un cliente, en el primer print se ven direcciones ip 0.0.0.0 puerto 9999 entiendo que corresponde a la dirección ip y el puerto de escucha del Server, en el segundo print aparece local host y local puerto 51271(51271 puerto efímero asignado automáticamente por el SO) entiendo que es el socket cliente haciendo una petición al Socket Server en escucha ip 127.0.0.1 puerto 9999, la duda está en el tercer print, exactamente donde está ubicado ese Socket que devuelve el método accept es decir esta enlazado al cliente o al servidor?  y exactamente que ip y puerto usa? se que tal vez estoy preguntando algo tonto y debería preocuparme por cosas más importantes pero me gusta saber el porqué de las cosas.

Enviado desde mi ANE-LX3 mediante Tapatalk