Java Language
Java-uttag
Sök…
Introduktion
Sockets är ett nätverksgränssnitt på låg nivå som hjälper till att skapa en anslutning mellan två program huvudsakligen klienter som kanske eller kanske inte körs på samma maskin.
Socket-programmering är ett av de mest använda nätverkskoncepten.
Anmärkningar
Det finns två typer av Internetprotokollstrafik -
1. TCP - Transmission Control Protocol 2. UDP - User Datagram Protocol
TCP är ett anslutningsorienterat protokoll.
UDP är ett anslutningsfritt protokoll.
TCP är lämplig för applikationer som kräver hög tillförlitlighet och överföringstiden är relativt mindre kritisk.
UDP är lämplig för applikationer som behöver snabb och effektiv överföring, till exempel spel. UDP: s statslösa karaktär är också användbar för servrar som svarar på små frågor från ett stort antal klienter.
I enklare ord -
Använd TCP när du inte har råd att förlora data och när tiden för att skicka och ta emot data inte spelar någon roll. Använd UDP när du inte har råd att förlora tid och när förlust av data inte spelar någon roll.
Det finns en absolut garanti för att de överförda uppgifterna förblir intakta och anländer i samma ordning som de skickades för TCP.
Det finns ingen garanti för att de meddelanden eller paketen som skickas skulle nå alls i UDP.
En enkel TCP-eko-backserver
Vår TCP echo back-server kommer att vara en separat tråd. Det är enkelt som en början. Det kommer bara att återspegla vad du skickar det, men i kapitaliserad form.
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 för att acceptera anslutningar. Låt oss uppdatera körmetoden.
@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);
}
}
Om du nu kan öppna telnet och försöka ansluta ser du ett välkomstmeddelande.
Du måste ansluta till porten du angav och IP-adress.
Du bör se ett resultat som liknar detta:
Welcome!
Connection to host lost.
Anslutningen försvann eftersom vi avslutade den. Ibland måste vi programmera vår egen TCP-klient. I det här fallet behöver vi en klient för att begära inmatning från användaren och skicka den över nätverket, få den aktiverade ingången.
Om servern skickar data först måste klienten läsa informationen först.
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);
}
}
}
}
Uppdatera nu servern
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();
Och nu kör servern och klienten. Du bör ha en utgång som liknar den här
Welcome!
>
