Java Language
Java-Sockets
Suche…
Einführung
Sockets sind eine untergeordnete Netzwerkschnittstelle, mit deren Hilfe eine Verbindung zwischen zwei Programmen hergestellt werden kann, hauptsächlich Clients, die möglicherweise auf demselben Computer ausgeführt werden.
Socket-Programmierung ist eines der am häufigsten verwendeten Netzwerkkonzepte.
Bemerkungen
Es gibt zwei Arten von Internet Protocol Traffic -
1. TCP - Transmission Control Protocol (Protokoll für die Übertragungssteuerung) 2. UDP - User Datagram Protocol (Protokoll für Benutzerdaten)
TCP ist ein verbindungsorientiertes Protokoll.
UDP ist ein verbindungsloses Protokoll.
TCP eignet sich für Anwendungen, die eine hohe Zuverlässigkeit erfordern, und die Übertragungszeit ist relativ unkritisch.
UDP eignet sich für Anwendungen, die eine schnelle und effiziente Übertragung erfordern, wie z. B. Spiele. Die Stateless-Eigenschaft von UDP ist auch für Server nützlich, die kleine Anfragen von einer großen Anzahl von Clients beantworten.
In einfacheren Worten -
Verwenden Sie TCP, wenn Sie es sich nicht leisten können, Daten zu verlieren, und wenn die Zeit zum Senden und Empfangen von Daten keine Rolle spielt. Verwenden Sie UDP, wenn Sie es sich nicht leisten können, Zeit zu verlieren und wenn der Datenverlust keine Rolle spielt.
Es besteht die absolute Garantie, dass die übertragenen Daten erhalten bleiben und in der gleichen Reihenfolge ankommen, in der sie bei TCP gesendet wurden.
Es gibt jedoch keine Garantie dafür, dass die gesendeten Nachrichten oder Pakete in UDP überhaupt erreicht werden.
Ein einfacher TCP-Echo-Back-Server
Unser TCP-Echo-Back-Server wird ein separater Thread sein. Es ist ganz einfach als Anfang. Es wird nur das wiedergeben, was Sie senden, jedoch in Großschreibung.
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);
}
}
}
Jetzt Verbindungen annehmen. Lassen Sie uns die Run-Methode aktualisieren.
@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);
}
}
Wenn Sie nun Telnet öffnen und versuchen, eine Verbindung herzustellen, wird eine Begrüßungsnachricht angezeigt.
Sie müssen eine Verbindung mit dem angegebenen Port und der IP-Adresse herstellen.
Sie sollten ein ähnliches Ergebnis sehen:
Welcome!
Connection to host lost.
Nun, die Verbindung ging verloren, weil wir sie abgebrochen haben. Manchmal müssen wir unseren eigenen TCP-Client programmieren. In diesem Fall benötigen wir einen Client, um die Eingabe vom Benutzer anzufordern und über das Netzwerk zu senden.
Wenn der Server zuerst Daten sendet, muss der Client die Daten zuerst lesen.
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);
}
}
}
}
Aktualisieren Sie jetzt den 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();
Führen Sie nun den Server und den Client aus. Sie sollten eine ähnliche Ausgabe haben
Welcome!
>
