Ako vytvoriť sieťovú aplikáciu v jazyku Java (s obrázkami)

Písanie kódu, ktorý sa vykonáva na určitom zariadení, je veľmi uspokojivé. Ale písanie kódu, ktorý sa vykonáva na viacerých zariadeniach, ktoré navzájom komunikujú, je jednoducho životne dôležité. Tento článok vás naučí, ako sa pripojiť a vymieňať si správy cez sieť pomocou protokolu TCP (transmission control protocol).

V tomto článku nastavíte aplikáciu, ktorá prepojí váš počítač so sebou samým a v podstate z neho urobí crazy – hovoriť sám so sebou. Dozviete sa tiež, aký je rozdiel medzi dvoma najpoužívanejšími prúdmi na vytváranie sietí v jazyku Java a ako fungujú.

Dátové a objektové prúdy

Predtým, ako sa ponoríte do kódu, je potrebné rozlišovať rozdiel medzi dvoma tokmi používanými v článku.

Dátové prúdy

Dátové prúdy spracúvajú primitívne dátové typy a reťazce. Údaje odosielané prostredníctvom dátových tokov sa musia ručne serializovať a deserializovať, čo sťažuje prenos zložitých údajov. Dátové prúdy však môžu komunikovať so servermi a klientmi napísanými v iných jazykoch ako Java. Raw streamy sú v tomto ohľade podobné dátovým streamom, ale dátové streamy zabezpečujú formátovanie údajov spôsobom nezávislým od platformy, čo je výhodné, pretože obe strany budú môcť čítať odoslané údaje.

Objektové prúdy

Objektové prúdy spracúvajú primitívne dátové typy a objekty, ktoré implementujú Serializovateľné Rozhranie. Údaje odosielané cez objektové prúdy sa automaticky serializujú a deserializujú, čo uľahčuje prenos zložitých údajov. Objektové prúdy však môžu komunikovať len so servermi a klientmi napísanými v jazyku Java. Tiež, ObjectOutputStream, po inicializácii odošle hlavičku InputStream druhej strany, ktorá po inicializácii blokuje vykonávanie, kým nedostane hlavičku.

Kroky



Vytvorenie triedy. Vytvorte triedu a pomenujte ju, ako chcete. V tomto článku sa bude nazývať NetworkAppExample.

public class NetworkAppExample {



Vytvorte hlavnú metódu. Vytvorte metódu main a deklarujte, že môže vyhadzovať výnimky Výnimka typ a každá jeho podtrieda – všetky výnimky. Toto sa považuje za zlý postup, ale je prijateľný pre základné príklady.

public class NetworkAppExample {
public static void main(String[] args) throws Exception {



Deklarovať adresu servera. Tento príklad použije miestnu adresu hostiteľa a ľubovoľné číslo portu. Číslo portu musí byť v rozsahu od 0 do 65535 (vrátane). Číslam portov sa však vyhnite v rozsahu od 0 do 1023 (vrátane), pretože sú to rezervované systémové porty.

public class NetworkAppExample {
public static void main(String[] args) throws Exception {
String host = "localhost";
int port = 10430;



Vytvorenie servera. Server je viazaný na adresu a port a počúva prichádzajúce spojenia. V jazyku Java, ServerSocket predstavuje koncový bod na strane servera a jeho funkciou je prijímanie nových spojení. ServerSocket nemá toky na čítanie a odosielanie údajov, pretože nepredstavuje spojenie medzi serverom a klientom.

import java.net.InetAddress;
import java.net.ServerSocket;
public class NetworkAppExample {
public static void main(String[] args) throws Exception {
String host = "localhost";
int port = 10430;
ServerSocket server = new ServerSocket(port, 50, InetAddress.getByName(host));



Záznam o založení servera. Na účely logovania vypíšte na konzolu, že bol spustený server.

import java.net.InetAddress;
import java.net.ServerSocket;
public class NetworkAppExample {
public static void main(String[] args) throws Exception {
String host = "localhost";
int port = 10430;
ServerSocket server = new ServerSocket(port, 50, InetAddress.getByName(host));
System.out.println("Server bol spustený.");



Vytvorenie klienta. Klient je viazaný na adresu a port servera a po vytvorení spojenia počúva pakety (správy). V jazyku Java, Socket predstavuje buď koncový bod na strane klienta pripojený k serveru, alebo spojenie (zo servera) ku klientovi a používa sa na komunikáciu so stranou na druhej strane.

import java.net.InetAddress;
import java.net.ServerSocket;
import java.net.Socket;
verejná trieda NetworkAppExample {
public static void main(String[] args) throws Exception {
String host = "localhost";
int port = 10430;
ServerSocket server = new ServerSocket(port, 50, InetAddress.getByName(host));
System.out.println("Server spustený.");
Socket client = new Socket(host, port);



Zaznamenanie pokusu o pripojenie. Na účely logovania vypíšte na konzolu, že bol vykonaný pokus o pripojenie.

import java.net.InetAddress;
import java.net.ServerSocket;
import java.net.Socket;
public class NetworkAppExample {
public static void main(String[] args) throws Exception {
String host = "localhost";
int port = 10430;
ServerSocket server = new ServerSocket(port, 50, InetAddress.getByName(host));
System.out.println("Server bol spustený.");
Socket client = new Socket(host, port);
Systém.out.println("Pripojenie k serveru...");



Nadviazanie spojenia. Klienti sa nikdy nepripoja, pokiaľ server nebude počúvať a prijímať, inými slovami nadväzovať, spojenia. V jazyku Java sa spojenia vytvárajú pomocou accept() metódy ServerSocket trieda. Metóda bude blokovať vykonávanie, kým sa nepripojí klient.

import java.net.InetAddress;
import java.net.ServerSocket;
import java.net.Socket;
public class NetworkAppExample {
public static void main(String[] args) throws Exception {
String host = "localhost";
int port = 10430;
ServerSocket server = new ServerSocket(port, 50, InetAddress.getByName(host));
Systém.out.println("Server spustený.");
Socket client = new Socket(host, port);
Systém.out.println("Pripojenie k serveru...");
Spojenie socket = server.accept();



Zaznamenajte nadviazané spojenie. Na účely protokolovania vypíšte na konzolu, že bolo vytvorené spojenie medzi serverom a klientom.

import java.net.InetAddress;
import java.net.ServerSocket;
import java.net.Socket;
public class NetworkAppExample {
public static void main(String[] args) throws Exception {
String host = "localhost";
int port = 10430;
ServerSocket server = new ServerSocket(port, 50, InetAddress.getByName(host));
System.out.println("Server spustený.");
Socket client = new Socket(host, port);
System.out.println("Pripojenie k serveru...");
Socket connection = server.accept();
System.out.println("Spojenie vytvorené.");



Príprava komunikačných tokov. Komunikácia sa uskutočňuje prostredníctvom tokov a v tejto aplikácii je potrebné reťaziť nespracované toky (spojenie zo) servera (ku klientovi) a klienta buď na dátové, alebo objektové toky. Nezabudnite, že obe strany musia používať rovnaký typ prúdu.

  • Dátové prúdy

    import java.io.DataInputStream;
    import java.io.DataOutputStream;
    import java.net.InetAddress;
    import java.net.ServerSocket;
    import java.net.Socket;
    public class NetworkAppExample {
    public static void main(String[] args) throws Exception {
    String host = "localhost";
    int port = 10430;
    ServerSocket server = new ServerSocket(port, 50, InetAddress.getByName(host));
    System.out.println("Server sa spustil.");
    Socket client = new Socket(host, port);
    Systém.out.println("Pripojenie k serveru...");
    Socket connection = server.accept();
    Systém.out.println("Spojenie nadviazané.");
    DataOutputStream clientOut = new DataOutputStream(client.getOutputStream());
    DataInputStream clientIn = new DataInputStream(client.getInputStream());
    DataOutputStream serverOut = new DataOutputStream(connection.getOutputStream());
    DataInputStream serverIn = new DataInputStream(connection.getInputStream());
    
  • Object streams
    Ak sa používa viacero objektových tokov, vstupné toky sa musia inicializovať v rovnakom poradí ako výstupné toky, pretože ObjectOutputStream odošle druhej strane hlavičku a ObjectInputStream blokuje vykonávanie, kým sa neprečíta hlavička.

    import java.io.ObjectInputStream;
    import java.io.ObjectOutputStream;
    import java.net.InetAddress;
    import java.net.ServerSocket;
    import java.net.Socket;
    public class NetworkAppExample {
    public static void main(String[] args) throws Exception {
    String host = "localhost";
    int port = 10430;
    ServerSocket server = new ServerSocket(port, 50, InetAddress.getByName(host));
    System.out.println("Server bol spustený.");
    Socket client = new Socket(host, port);
    System.out.println("Pripojenie k serveru...");
    Socket connection = server.accept();
    System.out.println("Spojenie nadviazané.");
    ObjectOutputStream clientOut = new ObjectOutputStream(client.getOutputStream());
    ObjectOutputStream serverOut = new ObjectOutputStream(connection.getOutputStream());
    ObjectInputStream clientIn = new ObjectInputStream(client.getInputStream());
    ObjectInputStream serverIn = new ObjectInputStream(connection.getInputStream());
    

    Poradie, ako je uvedené vo vyššie uvedenom kóde, by mohlo byť ľahšie zapamätateľné – najprv inicializujte výstupné prúdy a potom vstupné prúdy v rovnakom poradí. Iný postup inicializácie objektových tokov je však nasledovný:

    ObjectOutputStream clientOut = new ObjectOutputStream(client.getOutputStream());
    ObjectInputStream serverIn = new ObjectInputStream(connection.getInputStream());
    ObjectOutputStream serverOut = new ObjectOutputStream(connection.getOutputStream());
    ObjectInputStream clientIn = new ObjectInputStream(client.getInputStream());
    



Zaznamenajte, že komunikácia je pripravená. Na účely protokolovania vypíšte na konzolu, že komunikácia je pripravená.

// kód vynechaný
import java.net.InetAddress;
import java.net.ServerSocket;
import java.net.Socket;
public class NetworkAppExample {
public static void main(String[] args) throws Exception {
String host = "localhost";
int port = 10430;
ServerSocket server = new ServerSocket(port, 50, InetAddress.getByName(host));
System.out.println("Server spustený.");
Socket client = new Socket(host, port);
Systém.out.println("Pripojenie k serveru...");
Socket connection = server.accept();
System.out.println("Spojenie vytvorené.");
// kód vynechaný
Systém.out.println("Komunikácia je pripravená.");



Vytvorenie správy. V tejto aplikácii, Hello World text bude odoslaný na server buď ako byte[] alebo String. Deklarovať premennú typu, ktorý závisí od použitého prúdu. Použitie byte[] pre dátové prúdy a String pre objektové prúdy.

  • Dátové prúdy
    Pomocou dátových tokov sa serializácia vykonáva konverziou objektov na primitívne dátové typy alebo String. V tomto prípade, String je prevedený na byte[] namiesto zápisu pomocou writeBytes() metódu, ktorá ukáže, ako by sa to urobilo s inými objektmi, ako sú obrázky alebo iné súbory.

    import java.io.DataInputStream;
    import java.io.DataOutputStream;
    import java.net.InetAddress;
    import java.net.ServerSocket;
    import java.net.Socket;
    verejná trieda NetworkAppExample {
    public static void main(String[] args) throws Exception {
    String host = "localhost";
    int port = 10430;
    ServerSocket server = new ServerSocket(port, 50, InetAddress.getByName(host));
    System.out.println("Server sa spustil.");
    Socket client = new Socket(host, port);
    System.out.println("Pripojenie k serveru...");
    Spojenie socket = server.accept();
    System.out.println("Spojenie nadviazané.");
    DataOutputStream clientOut = new DataOutputStream(client.getOutputStream());
    DataInputStream clientIn = new DataInputStream(client.getInputStream());
    DataOutputStream serverOut = new DataOutputStream(connection.getOutputStream());
    DataInputStream serverIn = new DataInputStream(connection.getInputStream());
    System.out.println("Komunikácia je pripravená.");
    byte[] messageOut = "Hello World".getBytes();
    
  • Prúdy objektov

    import java.io.ObjectInputStream;
    import java.io.ObjectOutputStream;
    import java.net.InetAddress;
    import java.net.ServerSocket;
    import java.net.Socket;
    public class NetworkAppExample {
    public static void main(String[] args) throws Exception {
    String host = "localhost";
    int port = 10430;
    ServerSocket server = new ServerSocket(port, 50, InetAddress.getByName(host));
    System.out.println("Server bol spustený.");
    Socket client = new Socket(host, port);
    Systém.out.println("Pripojenie k serveru...");
    Spojenie socket = server.accept();
    System.out.println("Spojenie nadviazané.");
    ObjectOutputStream clientOut = new ObjectOutputStream(client.getOutputStream());
    ObjectOutputStream serverOut = new ObjectOutputStream(connection.getOutputStream());
    ObjectInputStream clientIn = new ObjectInputStream(client.getInputStream());
    ObjectInputStream serverIn = new ObjectInputStream(connection.getInputStream());
    System.out.println("Komunikácia je pripravená.");
    String messageOut = "Hello World";
    



Odoslanie správy. Zápis údajov do výstupného prúdu a prepláchnutie prúdu, aby sa zabezpečilo, že údaje boli zapísané úplne.

  • Dátové prúdy
    Dĺžka správy sa musí najprv odoslať, aby druhá strana vedela, koľko bajtov potrebuje prečítať. Po odoslaní dĺžky ako primitívneho celočíselného typu možno odoslať bajty.

    import java.io.DataInputStream;
    import java.io.DataOutputStream;
    import java.net.InetAddress;
    import java.net.ServerSocket;
    import java.net.Socket;
    public class NetworkAppExample {
    public static void main(String[] args) throws Exception {
    String host = "localhost";
    int port = 10430;
    ServerSocket server = new ServerSocket(port, 50, InetAddress.getByName(host));
    Systém.out.println("Server bol spustený.");
    Socket client = new Socket(host, port);
    System.out.println("Pripojenie k serveru...");
    Socket connection = server.accept();
    System.out.println("Spojenie nadviazané.");
    DataOutputStream clientOut = new DataOutputStream(client.getOutputStream());
    DataInputStream clientIn = new DataInputStream(client.getInputStream());
    DataOutputStream serverOut = new DataOutputStream(connection.getOutputStream());
    DataInputStream serverIn = new DataInputStream(connection.getInputStream());
    System.out.println("Komunikácia je pripravená.");
    byte[] messageOut = "Hello World".getBytes();
    clientOut.writeInt(messageOut.length);
    clientOut.write(messageOut);
    clientOut.flush();
    
  • Object streams

    import java.io.ObjectInputStream;
    import java.io.ObjectOutputStream;
    import java.net.InetAddress;
    import java.net.ServerSocket;
    import java.net.Socket;
    public class NetworkAppExample {
    public static void main(String[] args) throws Exception {
    String host = "localhost";
    int port = 10430;
    ServerSocket server = new ServerSocket(port, 50, InetAddress.getByName(host));
    Systém.out.println("Server spustený.");
    Socket client = new Socket(host, port);
    Systém.out.println("Pripojenie k serveru...");
    Socket connection = server.accept();
    Systém.out.println("Spojenie nadviazané.");
    ObjectOutputStream clientOut = new ObjectOutputStream(client.getOutputStream());
    ObjectOutputStream serverOut = new ObjectOutputStream(connection.getOutputStream());
    ObjectInputStream clientIn = new ObjectInputStream(client.getInputStream());
    ObjectInputStream serverIn = new ObjectInputStream(connection.getInputStream());
    System.out.println("Komunikácia je pripravená.");
    String messageOut = "Hello World";
    clientOut.writeObject(messageOut);
    clientOut.flush();
    



Zaznamenať odoslanú správu. Na účely logovania vypíšte na konzolu, že správa bola odoslaná.

  • Dátové prúdy

    import java.io.DataInputStream;
    import java.io.DataOutputStream;
    import java.net.InetAddress;
    import java.net.ServerSocket;
    import java.net.Socket;
    public class NetworkAppExample {
    public static void main(String[] args) throws Exception {
    String host = "localhost";
    int port = 10430;
    ServerSocket server = new ServerSocket(port, 50, InetAddress.getByName(host));
    System.out.println("Server sa spustil.");
    Socket client = new Socket(host, port);
    Systém.out.println("Pripojenie k serveru...");
    Socket connection = server.accept();
    System.out.println("Spojenie vytvorené.");
    DataOutputStream clientOut = new DataOutputStream(client.getOutputStream());
    DataInputStream clientIn = new DataInputStream(client.getInputStream());
    DataOutputStream serverOut = new DataOutputStream(connection.getOutputStream());
    DataInputStream serverIn = new DataInputStream(connection.getInputStream());
    System.out.println("Komunikácia je pripravená.");
    byte[] messageOut = "Hello World".getBytes();
    clientOut.writeInt(messageOut.length);
    clientOut.write(messageOut);
    clientOut.flush();
    System.out.println("Správa odoslaná na server: " + new String(messageOut));
    
  • Object streams

    import java.io.ObjectInputStream;
    import java.io.ObjectOutputStream;
    import java.net.InetAddress;
    import java.net.ServerSocket;
    import java.net.Socket;
    public class NetworkAppExample {
    public static void main(String[] args) throws Exception {
    String host = "localhost";
    int port = 10430;
    ServerSocket server = new ServerSocket(port, 50, InetAddress.getByName(host));
    System.out.println("Server sa spustil.");
    Socket client = new Socket(host, port);
    System.out.println("Pripojenie k serveru...");
    Spojenie socket = server.accept();
    System.out.println("Spojenie nadviazané.");
    ObjectOutputStream clientOut = new ObjectOutputStream(client.getOutputStream());
    ObjectOutputStream serverOut = new ObjectOutputStream(connection.getOutputStream());
    ObjectInputStream clientIn = new ObjectInputStream(client.getInputStream());
    ObjectInputStream serverIn = new ObjectInputStream(connection.getInputStream());
    System.out.println("Komunikácia je pripravená.");
    String messageOut = "Hello World";
    clientOut.writeObject(messageOut);
    clientOut.flush();
    System.out.println("Správa odoslaná na server: " + messageOut);
    



Čítanie správy. Čítanie údajov zo vstupného prúdu a ich konverzia. Keďže presne poznáme typ odosielaných údajov, vytvoríme buď String z byte[] alebo cast Objekt to String bez kontroly, v závislosti od použitého prúdu.

  • Dátové toky
    Keďže najprv bola odoslaná dĺžka a potom bajty, čítanie sa musí vykonať v rovnakom poradí. V prípade, že dĺžka je nula, nie je čo čítať. Objekt sa deserializuje, keď sa bajty konvertujú späť na inštanciu, v tomto prípade String.

    import java.io.DataInputStream;
    import java.io.DataOutputStream;
    import java.net.InetAddress;
    import java.net.ServerSocket;
    import java.net.Zásuvka;
    public class NetworkAppExample {
    public static void main(String[] args) throws Exception {
    String host = "localhost";
    int port = 10430;
    ServerSocket server = new ServerSocket(port, 50, InetAddress.getByName(host));
    System.out.println("Server bol spustený.");
    Socket client = new Socket(host, port);
    Systém.out.println("Pripojenie k serveru...");
    Socket connection = server.accept();
    System.out.println("Spojenie vytvorené.");
    DataOutputStream clientOut = new DataOutputStream(client.getOutputStream());
    DataInputStream clientIn = new DataInputStream(client.getInputStream());
    DataOutputStream serverOut = new DataOutputStream(connection.getOutputStream());
    DataInputStream serverIn = new DataInputStream(connection.getInputStream());
    System.out.println("Komunikácia je pripravená.");
    byte[] messageOut = "Hello World".getBytes();
    clientOut.writeInt(messageOut.length);
    clientOut.write(messageOut);
    clientOut.flush();
    System.out.println("Správa odoslaná na server: " + new String(messageOut));
    int length = serverIn.readInt();
    if (length > 0) {
    byte[] messageIn = new byte[length];
    serverIn.readFully(messageIn, 0, messageIn.length);
    
  • Object streams

    import java.io.ObjectInputStream;
    import java.io.ObjectOutputStream;
    import java.net.InetAddress;
    import java.net.ServerSocket;
    import java.net.Zásuvka;
    verejná trieda NetworkAppExample {
    public static void main(String[] args) throws Exception {
    String host = "localhost";
    int port = 10430;
    ServerSocket server = new ServerSocket(port, 50, InetAddress.getByName(host));
    Systém.out.println("Server bol spustený.");
    Socket client = new Socket(host, port);
    System.out.println("Pripojenie k serveru...");
    Socket connection = server.accept();
    System.out.println("Spojenie nadviazané.");
    ObjectOutputStream clientOut = new ObjectOutputStream(client.getOutputStream());
    ObjectOutputStream serverOut = new ObjectOutputStream(connection.getOutputStream());
    ObjectInputStream clientIn = new ObjectInputStream(client.getInputStream());
    ObjectInputStream serverIn = new ObjectInputStream(connection.getInputStream());
    Systém.out.println("Komunikácia je pripravená.");
    String messageOut = "Hello World";
    clientOut.writeObject(messageOut);
    clientOut.flush();
    Systém.out.println("Správa odoslaná na server: " + messageOut);
    String messageIn = (String) serverIn.readObject();
    



Zaznamenajte správu o čítaní. Na účely protokolovania vypíšte na konzolu, že správa bola prijatá, a vypíšte jej obsah.

  • Dátové toky

    import java.io.DataInputStream;
    import java.io.DataOutputStream;
    import java.net.InetAddress;
    import java.net.ServerSocket;
    import java.net.Socket;
    verejná trieda NetworkAppExample {
    public static void main(String[] args) throws Exception {
    String host = "localhost";
    int port = 10430;
    ServerSocket server = new ServerSocket(port, 50, InetAddress.getByName(host));
    System.out.println("Server sa spustil.");
    Socket client = new Socket(host, port);
    System.out.println("Pripojenie k serveru...");
    Pripojenie socket = server.accept();
    System.out.println("Spojenie nadviazané.");
    DataOutputStream clientOut = new DataOutputStream(client.getOutputStream());
    DataInputStream clientIn = new DataInputStream(client.getInputStream());
    DataOutputStream serverOut = new DataOutputStream(connection.getOutputStream());
    DataInputStream serverIn = new DataInputStream(connection.getInputStream());
    System.out.println("Komunikácia je pripravená.");
    byte[] messageOut = "Hello World".getBytes();
    clientOut.writeInt(messageOut.length);
    clientOut.write(messageOut);
    clientOut.flush();
    Systém.out.println("Správa odoslaná na server: " + new String(messageOut));
    int length = serverIn.readInt();
    if (length > 0) {
    byte[] messageIn = new byte[length];
    serverIn.readFully(messageIn, 0, messageIn.length);
    Systém.out.println("Správa prijatá od klienta: " + new String(messageIn));
    
  • Object streams

    import java.io.ObjectInputStream;
    import java.io.ObjectOutputStream;
    import java.net.InetAddress;
    import java.net.ServerSocket;
    import java.net.Socket;
    public class NetworkAppExample {
    public static void main(String[] args) throws Exception {
    String host = "localhost";
    int port = 10430;
    ServerSocket server = new ServerSocket(port, 50, InetAddress.getByName(host));
    System.von.println("Server spustený.");
    Socket client = new Socket(host, port);
    Systém.out.println("Pripojenie k serveru...");
    Spojenie socket = server.accept();
    Systém.out.println("Spojenie vytvorené.");
    ObjectOutputStream clientOut = new ObjectOutputStream(client.getOutputStream());
    ObjectOutputStream serverOut = new ObjectOutputStream(connection.getOutputStream());
    ObjectInputStream clientIn = new ObjectInputStream(client.getInputStream());
    ObjectInputStream serverIn = new ObjectInputStream(connection.getInputStream());
    System.out.println("Komunikácia je pripravená.");
    String messageOut = "Hello World";
    clientOut.writeObject(messageOut);
    clientOut.flush();
    System.out.println("Správa odoslaná na server: " + messageOut);
    String messageIn = (String) serverIn.readObject();
    System.out.println("Správa prijatá od klienta: " + messageIn);
    



Odpojenie pripojenia. Spojenie je prerušené, keď jedna strana uzavrie svoje toky. V jazyku Java sa uzavretím výstupného prúdu uzavrie aj pridružený soket a vstupný prúd. Keď strana na druhej strane zistí, že spojenie je mŕtve, musí uzavrieť aj svoj výstupný tok, aby sa zabránilo úniku pamäte.

// kód vynechaný
import java.net.InetAddress;
import java.net.ServerSocket;
import java.net.Socket;
public class NetworkAppExample {
public static void main(String[] args) throws Exception {
String host = "localhost";
int port = 10430;
ServerSocket server = new ServerSocket(port, 50, InetAddress.getByName(host));
System.out.println("Server bol spustený.");
Socket client = new Socket(host, port);
System.out.println("Pripojenie k serveru...");
Socket connection = server.accept();
System.out.println("Spojenie nadviazané.");
// kód vynechaný
System.out.println("Komunikácia je pripravená.");
// kód vynechaný
clientOut.close();
serverOut.close();



Zaznamenať odpojenie. Na účely logovania vypíšte na konzolu spojenia boli odpojené.

// kód vynechaný
import java.net.InetAddress;
import java.net.ServerSocket;
import java.net.Socket;
public class NetworkAppExample {
public static void main(String[] args) throws Exception {
String host = "localhost";
int port = 10430;
ServerSocket server = new ServerSocket(port, 50, InetAddress.getByName(host));
System.out.println("Server sa spustil.");
Socket client = new Socket(host, port);
Systém.out.println("Pripojenie k serveru...");
Socket connection = server.accept();
System.out.println("Spojenie nadviazané.");
// kód vynechaný
Systém.out.println("Komunikácia je pripravená.");
// kód vynechaný
clientOut.close();
serverOut.close();
Systém.out.println("Spojenia sú uzavreté.");



Ukončiť server. Pripojenia sú odpojené, ale server je stále v prevádzke. Ako ServerSocket nie je spojený so žiadnym tokom, je potrebné ho explicitne uzavrieť volaním close() metóda.

// kód vynechaný
import java.net.InetAddress;
Import java.net.ServerSocket;
import java.net.Zásuvka;
public class NetworkAppExample {
public static void main(String[] args) throws Exception {
String host = "localhost";
int port = 10430;
ServerSocket server = new ServerSocket(port, 50, InetAddress.getByName(host));
System.out.println("Server bol spustený.");
Socket client = new Socket(host, port);
Systém.von.println("Pripojenie k serveru...");
Socket connection = server.accept();
System.out.println("Spojenie nadviazané.");
// kód vynechaný
Systém.out.println("Komunikácia je pripravená.");
// kód vynechaný
clientOut.close();
serverOut.close();
System.out.println("Spojenia sú uzavreté.");
server.close();



Zaznamenať ukončenie servera. Na účely protokolovania bola ukončená tlač na konzolový server.

// kód vynechaný
import java.net.InetAddress;
import java.net.ServerSocket;
import java.net.Socket;
public class NetworkAppExample {
public static void main(String[] args) throws Exception {
String host = "localhost";
int port = 10430;
ServerSocket server = new ServerSocket(port, 50, InetAddress.getByName(host));
Systém.out.println("Server spustený.");
Socket client = new Socket(host, port);
System.out.println("Pripojenie k serveru...");
Spojenie socket = server.accept();
System.out.println("Spojenie vytvorené.");
// kód vynechaný
Systém.out.println("Komunikácia je pripravená.");
// kód vynechaný
clientOut.close();
serverOut.close();
System.odoslaním .println("Spojenia sú uzavreté.");
server.close();
System.out.println("Server bol ukončený.");


  • Zkompilujte a spustite. Protokolovanie nám umožnilo zistiť, či bola aplikácia úspešná alebo nie. Očakávaný výstup:

    Spustenie servera.
    Pripojenie k serveru...
    Spojenie nadviazané.
    Komunikácia je pripravená.
    Správa odoslaná na server: Hello World
    Správa prijatá od klienta: Hello World
    Spojenia sú uzavreté.
    Server ukončený.
    

    V prípade, že váš výstup nie je taký, ako je uvedený vyššie, čo je nepravdepodobné, existuje niekoľko riešení:

    • Ak sa výstup zastaví na riadku Spojenie nadviazané. a objektové prúdy sa používajú, spláchnite každý ObjectOutputStream okamžite po inicializácii, pretože hlavičky z nejakého dôvodu neboli odoslané.
    • Ak sa na výstupe vypíše java.net.BindException: Adresa sa už používa, vyberte iné číslo portu, pretože zadané číslo je už použité.