Java Language
Java-sockets
Zoeken…
Invoering
Sockets zijn een netwerkinterface op laag niveau die helpt bij het maken van een verbinding tussen twee programma's, voornamelijk clients die al dan niet op dezelfde machine worden uitgevoerd.
Socket Programming is een van de meest gebruikte netwerkconcepten.
Opmerkingen
Er zijn twee soorten internetprotocolverkeer:
1. TCP - Transmission Control Protocol 2. UDP - User Datagram Protocol
TCP is een verbindingsgericht protocol.
UDP is een verbindingsloos protocol.
TCP is geschikt voor toepassingen die een hoge betrouwbaarheid vereisen en de verzendtijd is relatief minder kritisch.
UDP is geschikt voor toepassingen die snelle, efficiënte overdracht vereisen, zoals games. Het stateless karakter van UDP is ook nuttig voor servers die kleine vragen van grote aantallen klanten beantwoorden.
In eenvoudiger woorden -
Gebruik TCP wanneer u het zich niet kunt veroorloven om gegevens te verliezen en wanneer de tijd voor het verzenden en ontvangen van gegevens niet uitmaakt. Gebruik UDP wanneer u het zich niet kunt veroorloven om tijd te verliezen en wanneer verlies van gegevens er niet toe doet.
Er is een absolute garantie dat de overgedragen gegevens intact blijven en aankomen in dezelfde volgorde waarin ze zijn verzonden in het geval van TCP.
terwijl er geen garantie is dat de verzonden berichten of pakketten überhaupt in UDP zouden komen.
Een eenvoudige TCP echo back-server
Onze TCP echo back-server zal een aparte thread zijn. Het is eenvoudig als een begin. Het echoert gewoon terug wat u het verzendt, maar dan in hoofdletters.
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);
}
}
}
Nu om verbindingen te accepteren. Laten we de run-methode bijwerken.
@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);
}
}
Als u nu Telnet kunt openen en verbinding kunt maken, ziet u een welkomstbericht.
U moet verbinding maken met de opgegeven poort en IP-adres.
U zou een resultaat als dit moeten zien:
Welcome!
Connection to host lost.
Nou, de verbinding is verbroken omdat we deze hebben verbroken. Soms zouden we onze eigen TCP-client moeten programmeren. In dit geval hebben we een client nodig om input van de gebruiker te vragen en over het netwerk te verzenden, de gekapitaliseerde input te ontvangen.
Als de server eerst gegevens verzendt, moet de client de gegevens eerst lezen.
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);
}
}
}
}
Werk nu de server bij
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();
En voer nu de server en de client uit. U zou een soortgelijke output moeten hebben
Welcome!
>
