Java Language
Socket Java
Ricerca…
introduzione
I socket sono un'interfaccia di rete di basso livello che aiuta a creare una connessione tra due programmi principalmente client che possono o meno essere in esecuzione sulla stessa macchina.
Socket Programming è uno dei concetti di networking più diffusi.
Osservazioni
Esistono due tipi di traffico Internet Protocol -
1. TCP - Transmission Control Protocol 2. UDP - User Datagram Protocol
TCP è un protocollo orientato alla connessione.
UDP è un protocollo senza connessione.
TCP è adatto per applicazioni che richiedono un'elevata affidabilità e il tempo di trasmissione è relativamente meno critico.
UDP è adatto per applicazioni che richiedono una trasmissione rapida ed efficiente, come i giochi. La natura stateless di UDP è anche utile per i server che rispondono a piccole query da un numero enorme di client.
In parole più semplici -
Usa TCP quando non puoi permetterti di perdere dati e quando il tempo di inviare e ricevere dati non ha importanza. Usa UDP quando non puoi permetterti di perdere tempo e quando la perdita di dati non è importante.
È assolutamente garantito che i dati trasferiti rimangano intatti e arrivino nello stesso ordine in cui è stato inviato in caso di TCP.
mentre non vi è alcuna garanzia che i messaggi o i pacchetti inviati raggiungano affatto l'UDP.
Un semplice back server echo TCP
Il nostro server back echo TCP sarà un thread separato. È semplice come un inizio. Restituirà solo ciò che viene inviato, ma in forma maiuscola.
public class CAPECHOServer extends Thread{
// This class implements server sockets. A server socket waits for requests to come
// in over the network only when it is allowed through the local firewall
ServerSocket serverSocket;
public CAPECHOServer(int port, int timeout){
try {
// Create a new Server on specified port.
serverSocket = new ServerSocket(port);
// SoTimeout is basiacally the socket timeout.
// timeout is the time until socket timeout in milliseconds
serverSocket.setSoTimeout(timeout);
} catch (IOException ex) {
Logger.getLogger(CAPECHOServer.class.getName()).log(Level.SEVERE, null, ex);
}
}
@Override
public void run(){
try {
// We want the server to continuously accept connections
while(!Thread.interrupted()){
}
// Close the server once done.
serverSocket.close();
} catch (IOException ex) {
Logger.getLogger(CAPECHOServer.class.getName()).log(Level.SEVERE, null, ex);
}
}
}
Ora per accettare connessioni. Aggiorniamo il metodo di esecuzione.
@Override
public void run(){
while(!Thread.interrupted()){
try {
// Log with the port number and machine ip
Logger.getLogger((this.getClass().getName())).log(Level.INFO, "Listening for Clients at {0} on {1}", new Object[]{serverSocket.getLocalPort(), InetAddress.getLocalHost().getHostAddress()});
Socket client = serverSocket.accept(); // Accept client conncetion
// Now get DataInputStream and DataOutputStreams
DataInputStream istream = new DataInputStream(client.getInputStream()); // From client's input stream
DataOutputStream ostream = new DataOutputStream(client.getOutputStream());
// Important Note
/*
The server's input is the client's output
The client's input is the server's output
*/
// Send a welcome message
ostream.writeUTF("Welcome!");
// Close the connection
istream.close();
ostream.close();
client.close();
} catch (IOException ex) {
Logger.getLogger(CAPECHOServer.class.getName()).log(Level.SEVERE, null, ex);
}
}
// Close the server once done
try {
serverSocket.close();
} catch (IOException ex) {
Logger.getLogger(CAPECHOServer.class.getName()).log(Level.SEVERE, null, ex);
}
}
Ora se puoi aprire telnet e provare a connetterti vedrai un messaggio di benvenuto.
È necessario connettersi con la porta specificata e l'indirizzo IP.
Dovresti vedere un risultato simile a questo:
Welcome!
Connection to host lost.
Bene, la connessione è andata persa perché l'abbiamo interrotta. A volte dovremmo programmare il nostro client TCP. In questo caso, abbiamo bisogno di un client per richiedere l'input dell'utente e inviarlo attraverso la rete, ricevere l'input in maiuscolo.
Se il server invia prima i dati, il client deve prima leggere i dati.
public class CAPECHOClient extends Thread{
Socket server;
Scanner key; // Scanner for input
public CAPECHOClient(String ip, int port){
try {
server = new Socket(ip, port);
key = new Scanner(System.in);
} catch (IOException ex) {
Logger.getLogger(CAPECHOClient.class.getName()).log(Level.SEVERE, null, ex);
}
}
@Override
public void run(){
DataInputStream istream = null;
DataOutputStream ostream = null;
try {
istream = new DataInputStream(server.getInputStream()); // Familiar lines
ostream = new DataOutputStream(server.getOutputStream());
System.out.println(istream.readUTF()); // Print what the server sends
System.out.print(">");
String tosend = key.nextLine();
ostream.writeUTF(tosend); // Send whatever the user typed to the server
System.out.println(istream.readUTF()); // Finally read what the server sends before exiting.
} catch (IOException ex) {
Logger.getLogger(CAPECHOClient.class.getName()).log(Level.SEVERE, null, ex);
} finally {
try {
istream.close();
ostream.close();
server.close();
} catch (IOException ex) {
Logger.getLogger(CAPECHOClient.class.getName()).log(Level.SEVERE, null, ex);
}
}
}
}
Ora aggiorna il server
ostream.writeUTF("Welcome!");
String inString = istream.readUTF(); // Read what the user sent
String outString = inString.toUpperCase(); // Change it to caps
ostream.writeUTF(outString);
// Close the connection
istream.close();
E ora esegui il server e il client, dovresti avere un output simile a questo
Welcome!
>