5. Programowanie klient-serwer z użyciem gniazd i protokołów sieciowych

5.1. Architektura klient-serwer i sieć.

• możliwość podziału pracy pomiędzy różnymi maszynami odpowiednio do ich potencjału i efektywności,
• możliwość uzyskiwania usług serwera na odległość,
• dane mogą być prowadzone w sposób scentralizowany (na serwerze) co zapewnia spójność i bezpieczeństwo,
• mogą też być przechowywane w sposób rozproszony pomiędzy róznymi loakalizacjami geograficznymi (różnymi serwerami i/lub klientami w różnych miejscach), co zmniejsza ryzyko utraty danych przy awariach.

Model OSI składa się z  siedmiu warstw:

Komputer 1   Komputer 2 dane Wa rstwa aplikacji Warstwa aplikacji dane |dane Warstwa prezentacji Warstwa prezentacji |dane ||dane Warstwa sesji Warstwa sesji ||dane |||dane Warstwa transportowa Warstwa transportowa |||dane ||||dane Warstwa sieci Warstwa sieci ||||dane |||||dane Warstwa łącza danych Warstwa łącza danych |||||dane ||||||dane Warstwa fizyczna Warstwa fizyczna ||||||dane

1. aplikacje, działające na dwóch komputerachw  sieci (klient i serwer) wymieniają dane.
2. kolejne protokoły w kolejnych warstwach dodają nagłówki do danych otrzymywanycyh z warstwy powyżej. Dane opakowane w nagłówki są transmitowane w tzw.  Protocol Data Units (PDUs). 
3. PDU są przesyłane w dół sekwencji warstw i transmitowane fizycznie przez warstwę fizyczną, która reprezentuje fizyczne połączenie w sieci.
4. Dane otrzymane są przesyłane "w górę" warstw i "odpakowywane" z kolejnych nagłówków.

5.2. Gniazda.

• multicasting (w Javie - klasa MulticastDatagramSocket)
• bezpieczną transmisja danych opartą na protokole SSL/TSL (Secure Socket Layer/Transport Secure Layer).

1. Serwer tworzy gniazdo związane z określonym portem i na tym kanale komunikacyjnym czeka na prośbę połączenia od klienta.
2. Inicjatywa połączenia wychodzi od klienta; klient musi znać host serwera oraz numer portu otwartego do przyjmowania połączeń i podaje tę informację tworząc "u siebie" gniazdo związane z tak określonym adresem
3. Serwer akceptuje połaczenie od klienta i - aby pozostać dostępnym dla innych klientów na "kanale połączeniowym" - tworzy inne gniazdo do komunikacji z danym klientem;
4. Z punktu widzenia klienta jest to (zazwyczaj) to samo gniazdo na którym zainicjowano połączenie; strumienie wejściowy i wyjściowy związane z tym gniazdem służą do komunikacji pomiędzy klientem i serwerem zgodnie z protokołem serwera.

• gniazdami serwerowymi, w Javie  reprezentowanymi przez klasę ServerSocket, używanymi przy programowaniu serwerów,
• gniazdami klienckimi, w Javie reprezentowanymi przez klasę Socket, używanymi w  programowaniu klientów, a w serwerach do komunikacji z klientem po zaakceptowaniu połączenia od niego.

5.3. Klienci. Protokoły i porty

1. Utworzeniu gniazda - obiektu klasy Socket, dającego połączenie  z serwerem.
2. Uzyskaniu od tego obiektu strumieni wyjściowego i wejściowego, związanych z gniazdem.
3. Posyłanie zleceń dla serwera poprzez zapis do strumienia wyjściowego gniazda.
4. Odczytywanie odpowiedzi serwera poprzez odczyt ze strumienia wejściowego.
5. Zamknięcie strumieni.
6. Zamknięcie gniazda
   

• HTTP (Hypertext Transfer Protocol) służący m.in. do uzyskiwania dostępu do stron WWW oraz przesyłania fromularzy (jego wersja HTTPS, oparta na protokole TSL/ SSL - Transport Security Layer/Secure Sockets Layer - pozwala na bezpieczną transmisję danych),
• FTP (File Transfer Protocol) służący do pobierania/zapisywania plików (i jego bezpieczna wersja oparta na TSL/SSL - FTPS)
• SMTP (Simple Mail Transfer Protocol)  służący do przesyłania poczty elektronicznej (ESMPT -  SMPT z rozszerzeniami).
• POP3 (Post Office Protocol) służący do pobierania poczty z serwera
• IMAP (Internet Message Access Protocol) j.w., z dodatkowymi możliwościami.
• TELNET - umożliwiający zdalną prace na komputerze-hoście
• TIME  - proste uzyskiwanie aktualnego czasu od serwerów czasu
• DAYTIME - proste uzyskiwanie daty i czasu
• NTP (Network Time Protocol) - zaawansowane możliwości uzyskiwania dokładnego czasu
• NNTP (Network News Transfer Protocol) - przesyłanie, dystrybucja i odbiór wiadomości z tzw. newsgroups.
• IRC - Internet Relay Chat - znane wszystkim internetowe "czaty",
• ECHO -  "odbijający" dane posyłane przez klienta (służy głównie do celów testowania klientów)
• DICT - wyszukiwanie definicji w bazach słownikowych.

import java.net.*;
import java.io.*;

class DateTime1 {

  public static void main(String[] args) {

    String host = null;
    int port = 13;

    try {
      host = args[0];  // host - jako argument wywołania

      // Utworzenie gniazda
      Socket socket = new Socket(host, port);

      // Pobranie strumienia wejściowego gniazda
      // Nakładamy dekodowanie i buforowanie
      BufferedReader br = new BufferedReader(
                            new InputStreamReader(
                             socket.getInputStream()
                             )
                          );

      // Odczyt odpowiedzi serwera (data i czas)
      String line;
      while ((line = br.readLine()) != null) {
        System.out.println(line);
      }

      // Zamknięcie strumienia i gniazda
      br.close();
      socket.close();
    } catch (UnknownHostException exc) {
        System.out.println("Nieznany host: " + host);
    } catch (Exception exc) {
         exc.printStackTrace();
    }
  }

}

8.4. Adresowanie i wyjątki przy próbie połączenia z serwerem

import java.io.*;
import java.net.*;

public class EchoClient {

  final static int ECHO_PORT = 7;
  private Socket sck;
  private PrintWriter out;
  private BufferedReader in;

  public EchoClient() {}

  public void connect(String host)
              throws UnknownHostException, IOException   {
    sck = new Socket(host, ECHO_PORT);
    in = new BufferedReader (
            new InputStreamReader(sck.getInputStream()));
    out = new PrintWriter (
            new OutputStreamWriter(sck.getOutputStream()), true);
    System.out.println("Połączony z hostem:" + sck.getInetAddress() );
  }

  public void echoMsg(String msg) throws IOException {
    out.println(msg);
    String response = in.readLine();
    System.out.println("Klient: " + msg);
    System.out.println("Serwer: " + response);
  }

  public void disconnect() throws IOException  {
    in.close();
    out.close();
    sck.close();
  }



  public static void main(String[] args) {
    String[] hosts = { "aeneas.mit.edu",
                       "cs.toronto.edu",
                       "cs.utah.edu",
                       "web.mit.edu",
                       "boulder.ibm.com",
                       "somethin"
                     };
    int i = 0;
    EchoClient ec = new EchoClient();
    for (; i<hosts.length; i++) {
      try {
        ec.connect(hosts[i]);
        ec.echoMsg("Dzień dobry!");
        ec.disconnect();
      } catch(UnknownHostException exc) {
          System.out.println("Nieznany host: " + hosts[i]);
      } catch(IOException exc) {
          System.out.println(hosts[i] + " - " + exc);
      }
    }
  }


}

• wyjątki powstające przy braku możliwości połączenia są klasy ConnectException (i jest to podklasa IOException),
• wadliwy (nieistniejący) host zgłaszany jest w  formie wyjątku UnknownHostException,

• InetAddres InetAddress.getByName(nazwa_hosta) - zwraca adres IP podanego hosta,
• InetAddress[] InetAddress.getAllByName(nazwa_hosta) - zwraca tablicę adresów IP podanego hosta (nazwa hosta np. java.sun.com może być skojarzona z kilkoma adresami IP, używanymi alternatywnie dla zmniejszania obciążenia serwerów).

• podając nazwę hosta w postaci DNS (np. java.sun.com) uzyskujemy rozwiązanie referencji przez serwisy DNS (Domain Name Service) czy NIS (Network Information Service); wywołanie jest blokujące i ew. - dla nieistniejącego hosta może powstać wyjątek UnknownHostException
• podając nazwę hosta w tekstowej postaci IP (np. "192.33.87.12") uzyskujemy tylko formalne sprawdzenie poprawności adresu,
• podając null uzyskamy adres interfejsu loopback.

    String host = "time.nist.gov";
    int port = 13;

    try {
      // Utworzenie adresu
      InetAddress inetadr = InetAddress.getByName(host);

      // Utworzenie gniazda
      Socket socket = new Socket(inetadr, port);
     ....
    }

  public static void main(String[] args) {

    String host = "time.nist.gov";
    int port = 13;
    Socket socket = new Socket(); // utworzenie niezwiązanego gniazda

    try {
      // Utworzenie adresów
      InetAddress inetadr = InetAddress.getByName(host);
      InetSocketAddress conadr = new InetSocketAddress(inetadr, port);

      // Połaczenie z serwerem
      socket.connect(conadr);

      // Pobranie strumienia wejściowego gniazda
      // Nakładamy buforowanie
      BufferedReader br = new BufferedReader(
                            new InputStreamReader(
                             socket.getInputStream()
                             )
                          );

      // Odczyt odpowiedzi serwera (data i czas)
      String line;
      while ((line = br.readLine()) != null) {
        System.out.println(line);
      }

      // Zamknięcie strumienia i gniazda
      br.close();
      socket.close();
    } catch (UnknownHostException exc) {
        System.out.println("Nieznany host: " + host);
    } catch (Exception exc) {
         exc.printStackTrace();
    }
  }

5.5.  Limity czasu łączenia i odczytu

socket.connect(conadr, 100);

    try {
      // Utworzenie adresów
      InetAddress inetadr = InetAddress.getByName(host);
      InetSocketAddress conadr = new InetSocketAddress(inetadr, port);

      // Połaczenie z serwerem
      // Określenie maksymalnego czasu oczekiwania na połączenie
      socket.connect(conadr, 200);


      // Pobranie strumienia wejściowego gniazda
      // Nakładamy buforowanie
      BufferedReader br = new BufferedReader(
                            new InputStreamReader(
                             socket.getInputStream()
                             )
                          );
      // Okreslenie maksymalnego czasu oczekiwania na odczyt danych z serwera
      socket.setSoTimeout(50);

      // Odczyt odpowiedzi serwera (data i czas)
      String line;
      while ((line = br.readLine()) != null) {
        System.out.println(line);
      }

      // Zamknięcie strumienia i gniazda
      br.close();
      socket.close();
    } catch (UnknownHostException exc) {
        System.out.println("Nieznany host: " + host);
    } catch (Exception exc) {
         exc.printStackTrace();
    }
  }

5.6. Inne parametry gniazd kliencich.

import java.net.*;
import java.io.*;
import java.lang.reflect.*;

class DateTime2 {

  public static void main(String[] args) {

    String host = "time.nist.gov";
    int port = 13;
    Socket socket = new Socket();

    try {
      // Utworzenie adresów
      InetAddress inetadr = InetAddress.getByName(host);
      InetSocketAddress conadr = new InetSocketAddress(inetadr, port);

      // Połaczenie z serwerem
      // Określenie maksymalnego czasu oczekiwania na połączenie
      socket.connect(conadr, 200);


      // Pobranie strumienia wejściowego gniazda
      // Nakładamy buforowanie
      BufferedReader br = new BufferedReader(
                            new InputStreamReader(
                             socket.getInputStream()
                             )
                          );
      // Okreslenie maksymalnego czasu oczekiwania na odczyt danych z serwera
      socket.setSoTimeout(200);

      // Czego możemy się dowiedzieć o stanie gniazda?
      report(socket);

      // Odczyt odpowiedzi serwera (data i czas)
      String line;
      while ((line = br.readLine()) != null) {
        System.out.println(line);
      }

      // Zamknięcie strumienia i gniazda
      br.close();
      socket.close();
    } catch (UnknownHostException exc) {
        System.out.println("Nieznany host: " + host);
    } catch (Exception exc) {
         exc.printStackTrace();
    }
  }

  // Dynamiczne wołanie metod z klasy Socket
  static void report(Socket s) throws Exception {
    Method[] methods = (java.net.Socket.class).getMethods();
    Object[] args = {};
    for (int i=0; i<methods.length; i++) {
      String name = methods[i].getName();
      if ((name.startsWith("get") || name.startsWith("is")) &&
          !name.equals("getChannel") &&
          !name.equals("getInputStream") &&
          !name.equals("getOutputStream")) {

        System.out.println(name + "() = " +
                           methods[i].invoke(s, args));
      }
    }
  }


}

5.7. Klient SMTP

import java.io.*;
import java.net.*;

public class EmailClient {

  Socket smtpSocket = null;
  PrintWriter sockOut = null;
  InputStream sockIn = null;

  public void connect(String server, String myDomain) {
    try {
      smtpSocket = new Socket(server, 25);
      sockOut = new PrintWriter(
             new OutputStreamWriter(smtpSocket.getOutputStream(), "UTF-8"),
             true);
      sockIn = smtpSocket.getInputStream();

      // Czy połączenie zostało nawiązane?
      // Musi być kod 220 - wtedy Ok
      // Odczytując odpowiedż serwera,
      // sprawdzamy w metodzie readResponse kod 220

      readResponse(220);

      // Przedstawiamy się serwerowi
      // Jeśli nas zaakceptuje - poda kod 250
      doRequest("HELO " + myDomain, 250);


    } catch (UnknownHostException e) {
        System.err.println("Nieznany host: " + server);
        cleanExit(1);
    } catch (IOException exc) {
        System.err.println(exc);
        cleanExit(2);
    }
  }


  // Posyłanie maila
  public void send(String from, String to, String fname) {
    try {

      // Inicjacja transakcji
      // Kod 250 - jesli OK
      doRequest("MAIL FROM:<" + from + ">", 250);

      // Określenie adresata
      // Kod 250 - jesli OK
      doRequest("RCPT TO:<" + to + ">", 250);

      // Posyłanie danych listu
      // Odpowiedź serwera - 354 = jestem gotowy na przyjęcie danych
      doRequest("DATA", 354);

      // Teraz będziemy zapisywać treść listu
      // bezpośrednio do strumienia wyjściowego gniazda
      // Najpierw jakieś nagłówki
      sockOut.println("From: " + from);
      sockOut.println("To: " + to);

      // Czytanie treści listu z pliku
      // Ponieważ samotna kropka w wierszu kończy dane listu
      // to samotną kropkę w treści zamieniamy na dwie kropki
      BufferedReader br = new BufferedReader(
                            new FileReader(fname));
      String line;
      while ((line = br.readLine()) != null) {
        if (line.equals(".")) line += ".";
        sockOut.println(line);
      }
      // Sekwencja CRLF.CRLF oznacza koniec treści listu
      // Drugie CRLF dodane w metodzie doRequest przez println
      doRequest("\r\n.", 250);

    } catch (IOException e) {
        System.err.println(e);
        cleanExit(2);
    }
  }

  // Zamknięcie połączenia
  public void closeConnection() {
    try {
      doRequest("QUIT", 221);
    } catch (Exception exc) {
      System.err.println(exc);
    }
    cleanExit(0);
  }


  private void doRequest(String req, int checkCode)
              throws IOException {
    sockOut.println(req);
    System.out.println("Klient: " + req);
    readResponse(checkCode);
  }

  // Uwaga: nie powinniśmy tu stosować buforowania i metody
  // readLine(), ponieważ nie wiadomo ile wierszy zwrówci serwer
  // a wywołanie readLine jest blokujące
  // Zakłądamy: że każda odpowiedź zmieści się w 10000 bajtów  
  private void readResponse(int checkCode) throws IOException {
    byte[] readBytes = new byte[10000];
    int num = sockIn.read(readBytes);
    String resp = new String(readBytes, 0, num);
    System.out.println("Serwer: " + resp);
    if (!resp.startsWith(String.valueOf(checkCode)))
     throw new IOException("Niespodziewany kod wyniku od serwera");
  }

  private void cleanExit(int code) {
    try {
      sockIn.close();
      sockOut.close();
      smtpSocket.close();
    }
    catch (Exception exc) {}
    System.exit(code);
  }

  public static void main(String[] args) {
    String server = "mail.somemailer.net";
    String myDomain = "62.125.12.111";
    String from = "[email protected]";
    String to = "you@anywhere";
    EmailClient email = new EmailClient();
    email.connect(server, myDomain);
    email.send(from, to, "list1");
    email.send(from, to, "list2");
    email.closeConnection();
  }
}

• potrzebę zgodnego z protokołem, starannego ustalenia kolejności przesyłania zleceń i odczytywania odpowiedzi,
• potrzebę uważnej analizy możliwych (często elastycznych) formatów odpowiedzi serwera: tutaj musieliśmy się liczyć z wielowierszowymi odpowiedziami serwera, przy czym liczba wierszy nie jest ustalona - wobec tego przy czytaniu odpowiedzi serwera nie należało stosować metody readLine (która - oczywiście - jest blokująca), a zamiast tego trzeba było czytać ze strumienia bajty.

5.8. Klient DICT

• polecenie "DEFINE * słowo" powoduje, iż serwer przegląda wszystkie prowadzone przez niego bazy danych i przesyła klientowi wszystkie odnalezione w nich definicje słowa.
• koniec ciągu definicji oznaczany jest kodem 250 w nowym wierszu,
• jeśli brak definicji - zwracany jest wiersz zawierający na początku kod 552.

import java.io.*;
import java.net.*;
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
import java.util.*;

public class DictClient extends JFrame
{
   public final static int port = 2628;
   private String server;
   private Socket clientSocket;
   private PrintWriter out;
   private BufferedReader in;
   private String database = "*";  // info ze wszystkich baz

   JTextArea ta = new JTextArea(20, 40);
   Container cp = getContentPane();



   public DictClient (String server, int timeout)   {

     try {
       clientSocket = new Socket (server, port);
       in = new BufferedReader (
                new InputStreamReader(clientSocket.getInputStream(), "UTF8"));
       out = new PrintWriter (
                new OutputStreamWriter(clientSocket.getOutputStream(), "UTF8"),
                             true);

       String resp = in.readLine(); // połączenie nawiązane - info o tym
       System.out.println(resp);
       if (!resp.startsWith("220")) {
         cleanExit(1); // jeżeli dostęp niemożliwy
       }

       // Ustalenie maksymalnego czasu blokowania
       // na operacji czytania ze strumienia gniazda

       clientSocket.setSoTimeout(timeout);


     } catch(UnknownHostException exc) {
         System.err.println("Uknown host " + server);
         System.exit(2);
     } catch(Exception exc) {
         exc.printStackTrace();
         System.exit(3);
     }

     // wszystko poszło dobrze - tworzymy i pokazujemy okno wyszukiwania

    Font f = new Font("Dialog", Font.BOLD, 14);
    ta.setFont(f);
    cp.add(new JScrollPane(ta));
    final JTextField tf = new JTextField();
    tf.setFont(f);
    tf.setBorder(BorderFactory.createLineBorder(Color.blue, 2));
    cp.add(tf, "South");

    tf.addActionListener( new ActionListener() {
      public void actionPerformed(ActionEvent e) {
         doSearch(tf.getText());
      }
    });

    addWindowListener( new WindowAdapter() {
      public void windowClosing(WindowEvent e) {
        dispose();
        cleanExit(0);
      }
    });

    pack();
    show();

    // Ustalenie fokusu na polu wprowadzania szukanych słów
    SwingUtilities.invokeLater( new Runnable() {
      public void run() {
        tf.requestFocus();
      }
    });
  }

  // Wyszukiwanie

  public void doSearch(String word) {
    try {
      String resp = "",
            defin = "Uzyskano następujące definicje:\n";

      // Zlecenie dla serwera
      out.println("DEFINE " + database + " " + word);

      // Czytamy odpowiedź
      // Kod 250 na początku wiersza oznacza koniec definicji
      while (resp != null && !resp.startsWith("250")) {
        resp = in.readLine();
        defin += resp + "\n";
        if (resp.startsWith("552")) break;  // słowo nie znalezione
      }
      ta.setText(defin);
    } catch(SocketTimeoutException exc) {
       ta.setText("Za długie oczekiwanie na odpowiedź");
    } catch(Exception exc) {
          exc.printStackTrace();
    }
  }

  private void cleanExit(int code) {
    try {
      out.close();
      in.close();
      clientSocket.close();
    } catch(Exception exc) {}
    System.exit(code);
  }

  public static void main(String[] args) {

    int timeout = 0;
    String server = "dict.org";
    try {
      timeout = Integer.parseInt(args[0]);
      server = args[1];
    } catch(NumberFormatException exc) {
      server = args[0];
    } catch(ArrayIndexOutOfBoundsException exc) {}

    new DictClient(server, timeout);
  }

}

5.9. Kanały gniazd klienckich i nieblokujące wejście/wyjście

• czytamy dane z kanału do bufora bajtowego (ByteBuffer) za pomocą metod read(...), zapisujemy dane do kanału z bufora bajtowego (ByteBuffer) za pomocą metody write(...); możemy przy tym korzystać z tzw. czytania rozprowadzającego po wielu buforach (scattering read) i gromadzącego pisania z wielu buforów (gathering write),
• bufory bajtowe muszą być alokowane za pomocą metod allocate(...), allocateDirect(...), albo muszą opakowywać istniejące w postaci tablic typu byte[] struktury danych.
•  praca z buforami bajtowymi jest specyficzna, wymaga bowiem manipulacji parametrami (pozycjami) bufora; np. po wczytaniu danych do bufora musimy go przestawić zapomocą metody flip(), po to by móc z tych dancyh korzystać,
• przekazywanie danych znakowych (tekstów) za pośrednictwem kanałów wymaga ich kodowania/dekodowania (użycie klas Charset i CharBuffer).

• klasa DictGui utworzy kanał, skonfiguruje go w trybie nieblokującym i połączy go z serwerem słownikowym; definiuje ona również interfej graficzny, w którym mamy do dyspozycji edytor tekstu oraz pole tekstowe, do którego możemy wpisać szukany termin; po wciśnięciu ENTER na polu tekstowym uruchomioiny zostanie wątek wyszukiwania słownikowego (klasa ReadDef), a informacje o postępach szukania będą uwidaczniane w informacyjnej etykiecie interfejsu graficznego; po skompletowaniu wyników przyciskiem "Wklej definicje" będziemy mogli wkleić wyniki otrzymane od serwera słownikowego do edytora w miejscu kursora; klasa ta również (jeszcze przed utworzeniem GUI) utworzy kanał, skonfiguruje go w trybie nieblokującym i połączy go z serwerem słownikowym;
• klasa ReadDef zapisuje do kanału zlecenie dla serwera (podaj definicję słowa przekazanego jako argument kosntruktora) i w sposób nieblokujący czyta odpowiedź serwera, pokazując w GUI ile czasu serwerowi zajęło szukanie i ile porcji danych trzeba było odczytać z kanału.

import java.io.*;
import java.net.*;
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
import java.util.*;
import java.nio.*;
import java.nio.channels.*;
import java.nio.charset.*;
import java.util.regex.*;


class DictGui extends JFrame implements ActionListener {

  public final static int port = 2628;
  private String server;
  private SocketChannel channel;

  private JTextArea ta = new JTextArea(20, 20);
  private JTextField tf = new JTextField(20);
  private JLabel infoLab = new JLabel("Nie było szukania");
  private JButton paste = new JButton("Wklej definicję");
  private Container cp = getContentPane();
  private ReadDef rd;

  public DictGui(String server) {
    this.server = server;

    // Otwarcie i połączenie kanału
    // metoda connect - zdefiniowana u końca klasy
    try {
      channel = SocketChannel.open();
      channel.configureBlocking(false);
      connect();
    } catch(UnknownHostException exc) {
        System.err.println("Uknown host " + server);
        System.exit(1);
    } catch(IOException exc) {
        exc.printStackTrace();
        System.exit(2);
    }

    // Konfiguracja GUI
    Font f = new Font("Dialog", Font.BOLD, 14);
    ta.setFont(f);
    tf.setFont(f);
    tf.setBorder(BorderFactory.createLineBorder(Color.orange, 1));
    infoLab.setPreferredSize(new Dimension(200,30));
    JPanel p = new JPanel();
    p.setBorder(BorderFactory.createLineBorder(Color.red, 2));
    p.add(tf);
    p.add(infoLab);
    p.add(paste);
    cp.add(new JScrollPane(ta));
    cp.add(p, "South");

    tf.addActionListener(this);
    paste.addActionListener(this);

    // Przy zamykaniu aplikacji
    // zamykamy kanał i gniazdo
    addWindowListener( new WindowAdapter() {
      public void windowClosing(WindowEvent e) {
        dispose();
        try {
         channel.close();
         channel.socket().close();
        } catch(Exception exc) {}
        System.exit(0);
      }
    });

    pack();
    show();
  }

  // Obsługa akcji
  public void actionPerformed(ActionEvent e) {
    // Kliknięcie w przycisk "Wklej definicję"
    // definicję przechowuje dla nas obiekr klasy ReadDef
    if (e.getSource() == paste && rd != null) {
       ta.insert(rd.getResult(), ta.getCaretPosition());
    }
    else {  // ENTER na polu tekstowym tf - start wątku komuniakcji z serwerem
     if (!channel.isConnected()) try {
       connect();
     } catch(Exception exc) {
        exc.printStackTrace();
        return;
     }
     rd = new ReadDef(this, channel, tf.getText());
     rd.start();
    }
  }

  // Łączenie kanału z serwerem
  private void connect() throws UnknownHostException, IOException {
    if (!channel.isOpen()) channel = SocketChannel.open();
    channel.connect(new InetSocketAddress(server, port));
    System.out.print("Łącze się ...");
    while (!channel.finishConnect()) {
      try { Thread.sleep(200); } catch(Exception exc) { return; }
      System.out.print(".");
    }
    System.out.println("\nPołączony.");
  }

  // Metoda wykorzystywana przez ReadDef
  // do pokazywania postepów komuniakcji z serwerem
  public void setInfo(String s) {
    infoLab.setText(s);
  }
}

class ReadDef extends Thread {

  private static Charset charset  = Charset.forName("ISO-8859-2");
  private static ByteBuffer inBuf = ByteBuffer.allocateDirect(1024);
  private static Matcher matchCode =
                 Pattern.compile("(\n250 ok)|(552 no match)").matcher("");
  private SocketChannel channel;
  private DictGui gui;
  private String word;


  public ReadDef(DictGui gui, SocketChannel ch, String wordToSearch) {
    this.gui = gui;
    channel = ch;
    word = wordToSearch;
  }

  private StringBuffer result;

  public void run() {
    result = new StringBuffer("Wyniki wyszukiwania:\n");
    int count = 0, rcount = 0;
    try {
      CharBuffer cbuf = CharBuffer.wrap("DEFINE * " + word + "\n");
      ByteBuffer outBuf = charset.encode(cbuf);
      channel.write(outBuf);

      while (true) {
        inBuf.clear();
        int readBytes = channel.read(inBuf);
        if (readBytes == 0) {
          gui.setInfo("Czekam ... " + ++count);
          Thread.sleep(200);
          continue;
        }
        else if (readBytes == -1) {
          gui.setInfo("Kanał zamknięty");
          channel.close();
          break;
        }
        else {
          inBuf.flip();
          cbuf = charset.decode(inBuf);
          result.append(cbuf);
          matchCode.reset(cbuf);
          if (matchCode.find()) break;
          else gui.setInfo("Czytam ... " + ++rcount);
        }
      }
    } catch(Exception exc) {
         exc.printStackTrace();
         return;
    }
    gui.setInfo("Czekałem: " + count + " / Czytałem: " + rcount + ". Gotowe.");
  }

  public String getResult() {
    if (result == null) return "Brak wyników wyszukiwania";
    return result.toString();
  }
}

class Main {
  public static void main(String[] args) {
    String server = "dict.org";
    new DictGui(server);
  }
}

• przed utworzeniem i wystartowaniem wątku ReadDef sprawdzane jest czy kanał nadal jest połączony (isConnected()); jeśli nie to następuje próba ponownego połączenia;
• przy łączeniu w metodzie connect() sprawdzamy czy kanał jest otwarty, jeśli nie to otwieramy go ponownie; kanał może być automatycznie zamknięty na skutek utraty połączenia z serwerem.
• interakcja pomiędzy klasami DictGUI i ReadDef odbywa się za pomocą metod: setInfo(...) i getResult(...); metoda klasy DictGUI setInfo(), wywoływana z klasy ReadDef jest wielowątkowo bezpieczna, gdyż praktycznie wywołuje tylko wielowątkowo bezpieczną metodę setlText(...) z klasy JLabel;
• przy czytaniu/zapisywaniu tekstów z/do kanału stosujemy dekodowanie/kodowanie za pomocą klas Charset (teksty mamy w CharBuffer),
• kody zwracane przez serwer wyszukujemy za pomocą wyrażeń regularnych; wzorzec zastosowany do wyszukiwania nie jest najbardziej uniwersalny, ale wystarczający dla celów ilustracji,
• użyte w programie rozwiązanie polegające na uruchamianiu nowego wątku ReadDef dla każdego wyszukiwania nie jest najlepsze; ogólnie powinien działać jeden wątek ReadDef synchronizowany i koordynowany z DictGUI za pomocą mechanizmu wait-notify; tego rozwiązania nie pokazuję, aby nie zaciemniać obrazu, który ma jedynie ilustrować nieblokujące wejście-wyjście i użycie kanałów gniazd klienckich.

5.10. Serwery

1. Utworzeniu gniazda serwera (klasa ServerSocket)
2. Związaniu go z określonym adresem (adres hosta, na którym działa serwer + adres portu)
3. Oczekiwaniu na połączenie od klienta "na tym" gnieździe
4. Po zaakceptowaniu połączenia od klienta - utworzeniu ganiazda wymiany informacji z połączonym klientem (klasa Socket) i obsłudze zleceń tego klienta posyłanych poprzez strumień związany z tym gniazdem.
5. Kontynuacji "nasłuchu" połączeń od innych klientów na gnieżdzie serwera.

import java.util.*;
import java.io.*;

public class PhoneDirectory {

  private Map pbMap = new HashMap();

  public PhoneDirectory(String fileName) {
    // Inicjalna zawartość książki telefonicznej
    // jest wczytywana z pliku o formacie
    //  imię  numer_telefonu
    try {
      BufferedReader br = new BufferedReader(
                             new FileReader(fileName));
      String line;
      while ((line = br.readLine()) != null) {
        String[] info = line.split(" +", 2);
        pbMap.put(info[0], info[1]);
      }
    } catch (Exception exc) {
        exc.printStackTrace();
        System.exit(1);
    }
  }

  // Zwraca numer telefonu dla podanej osoby
  public String getPhoneNumber(String name) {
    return (String) pbMap.get(name);
  }

  // Dodaje nową osobę do książki
  // Wynik:
  // - true - dodana
  // - false - nie (przy próbie dodania osoby zapisanej już w książce)
  public boolean addPhoneNumber(String name, String num) {
    if (pbMap.containsKey(name)) return false;
    pbMap.put(name, num);
    return true;
  }

  // Zastępuje numer podanej osoby nowym
  // Wynik:
  // - true (numer zastąpiony)
  // - false (nie - próba podania nowegu numeru nieistniejącej osoby)
  public boolean replacePhoneNumber(String name, String num) {
    if (!pbMap.containsKey(name)) return false;
    pbMap.put(name, num);
    return true;
  }

}  

• get imię (podaj numer telefonu dla wskazanej osoby),
• add imię numer (dopisz do książki osobę i jej numer telefoniczny),
• replace imię numer (zastąp w książece numer telefony pdoanej osoby nowym numerem).
• bye ( zakończenie komunikacji)
  

import java.net.*;
import java.io.*;
import java.util.regex.*;

public class PhoneBookServer1  {

  private PhoneDirectory pd = null;  // mapa osoby-numery tel.
  private ServerSocket ss = null;
  private BufferedReader in = null;  // strumienie gniazda
  private PrintWriter out = null;    // komunikacji z klientem

  public PhoneBookServer1(PhoneDirectory pd, ServerSocket ss) {
    this.pd = pd;
    this.ss = ss;
    System.out.println("Server started");
    System.out.println("at port: " + ss.getLocalPort());
    System.out.println("bind address: " + ss.getInetAddress());

    serviceConnections();  // nasłuchiwanie połączeń
  }

  // Metoda nasłuchuje połączeń od klientów
  // po zaakceptowaniu połączenia - tworzy gniazdo komunikacyjne
  // i przekazuje obsługę zleceń metdodzie serviceRequest

  private void serviceConnections() {
    boolean serverRunning = true;   // serwer działa ciągle
    while (serverRunning) {
      try {
        Socket conn = ss.accept();  // nasłuch i akceptaccja połączeń

        System.out.println("Connection established");

        serviceRequests(conn);      // obsługa zleceń dla tego połączenia

      } catch (Exception exc) {
          exc.printStackTrace();
      }
    }                               // zamknięcie gniazda serwera
    try { ss.close(); } catch (Exception exc) {}
  }

  // wzorzec do rozbioru zlecenia (maks. trzy "słowa" rozdzielone spacjami)
  private static Pattern reqPatt = Pattern.compile(" +", 3);

  // Słowne komunikaty serwera
  // odpowidające im indeksy tablicy - kody wyniku
  private static String msg[] = { "Ok", "Invalid request", "Not found",
                                  "Couldn't add - entry already exists",
                                  "Couldn't replace non-existing entry",
                                  };


  // Obsługa zleceń od klienta
  private void serviceRequests(Socket connection)
                              throws IOException {
    try {
      in = new BufferedReader(                   // utworzenie strumieni
               new InputStreamReader(
                   connection.getInputStream()));
      out = new PrintWriter(
                connection.getOutputStream(), true);

      // Odczytywanie zleceń (line zawiera kolejne zlecenie)
      for (String line; (line = in.readLine()) != null; ) {

        String resp;                           // odpowiedź
        String[] req = reqPatt.split(line, 3); // rozbiór zlecenia
        String cmd = req[0];                   // pierwsze słowo - polecenie

        if (cmd.equals("bye")) {        // zlecenie "bye" - koniec komunikacji
          writeResp(0, null);
          break;
        }
        else if (cmd.equals("get")) {   // "get" - klient chce dostać nr tel.
          if (req.length != 2) writeResp(1, null);
          else {
            String phNum = (String) pd.getPhoneNumber(req[1]); // pobranie
            if (phNum == null) writeResp(2, null);             // numeru tel.
            else writeResp(0, phNum);                          // i zapis
          }
        }
        else if (cmd.equals("add"))  {  // "add" - klient chce dodać numer
          if (req.length != 3) writeResp(1, null);
          else {
            boolean added = pd.addPhoneNumber(req[1], req[2]); // dodany?
            if (added) writeResp(0, null);                     // tak - ok
            else writeResp(3, null);                           // nie
          }
        }
        else if (cmd.equals("replace"))  {  // klient chce zmienić nr tel.
          if (req.length != 3) writeResp(1, null);
          else {
            boolean replaced = pd.replacePhoneNumber(req[1], req[2]);
            if (replaced) writeResp(0, null);
            else writeResp(4, null);
          }
        }
        else writeResp(1, null);             // nieznane zlecenie
      }
    } catch (Exception exc) {
        exc.printStackTrace();

    } finally {
        try {                                // zamknięcie strumieni
          in.close();                        // i gniazda
          out.close();
          connection.close();
          connection = null;
        } catch (Exception exc) { }
    }
  }


  // Przekazanie odpowiedzi klientowi poprzez zapis do strumienia
  // gniazda komuniakcyjnego
  private void writeResp(int rc, String addMsg)
               throws IOException {
    out.println(rc + " " + msg[rc]);
    if (addMsg != null) out.println(addMsg);
  }

  public static void main(String[] args) {
    PhoneDirectory pd = null;
    ServerSocket ss = null;
    try {
      String phdFileName = args[0];
      String host = args[1];
      int port = Integer.parseInt(args[2]);

      pd = new PhoneDirectory(phdFileName); // utworzenie mapy numerów z pliku

      InetSocketAddress isa = new InetSocketAddress(host, port);

      ss =  new ServerSocket();             // Utworzenie gniazda serwera
      ss.bind(isa);                         // i związanie go z adresem

    } catch(Exception exc) {
        exc.printStackTrace();
        System.exit(1);
    }
    new PhoneBookServer1(pd, ss);
  }

}

import java.net.*;
import java.io.*;

public class PhoneBookClient {

  private Socket sock = null;
  private PrintWriter out = null;
  private BufferedReader in = null;

  public PhoneBookClient(String host, int port) {
    try {
      sock = new Socket(host, port);
      out = new PrintWriter(sock.getOutputStream(), true);
      in = new BufferedReader(
               new InputStreamReader(
                   sock.getInputStream()));

      makeRequest("get Asia");
      makeRequest("get Alicja");
      makeRequest("add Adam 77777");
      makeRequest("add Adam");
      makeRequest("get Adam");
      makeRequest("add Adam 333333");
      makeRequest("replace Adam 333333");
      makeRequest("replace Alicja 202020");
      makeRequest("get Adam");
      makeRequest("add");
      makeRequest("");
      makeRequest("bye");
      in.close();
      out.close();
      sock.close();
    } catch (UnknownHostException e) {
        System.err.println("Nieznany host: "+host);
        System.exit(2);
    } catch (IOException e) {
        System.err.println("I/O err dla");
        System.exit(3);
    } catch (Exception exc) {
        exc.printStackTrace();
        System.exit(4);
    }
  }

  private boolean makeRequest(String req) throws IOException {
    System.out.println("Request: " + req);
    out.println(req);
    String resp = in.readLine();
    System.out.println(resp);
    boolean ok = resp.startsWith("0");
    if (req.startsWith("get") && ok)
       System.out.println(in.readLine());
    return ok;
  }

  public static void main(String[] args) {
    new PhoneBookClient(args[0], Integer.parseInt(args[1]));
  }
}

import java.net.*;
import java.io.*;

public class PhoneBookClients extends Thread {

  private Socket sock = null;
  private PrintWriter out = null;
  private BufferedReader in = null;
  private String nameToSearch;

  public PhoneBookClients(String host, int port, String name ) {
    try {
      sock = new Socket(host, port);
      out = new PrintWriter(sock.getOutputStream(), true);
      in = new BufferedReader(
               new InputStreamReader(
                   sock.getInputStream()));

      nameToSearch = name;

    } catch (Exception exc) {
        exc.printStackTrace();
        System.exit(4);
    }
    start();
  }

  public void run() {
    try {
      for (int i=1; i <= 5; i++) {
        find(nameToSearch);
        Thread.sleep(500);
      }
      out.println("bye");
    } catch (Exception exc) {
        exc.printStackTrace();
    }
  }

  private void find(String name) throws IOException {
    out.println("get " + name);
    String resp = in.readLine();
    boolean ok = resp.startsWith("0");
    String tel = ok ? in.readLine() : " - not found";
    System.out.println(name + " - tel. " + tel);
  }

  public static void main(String[] args) {
    String host = args[0];
    int port = Integer.parseInt(args[1]);
    String[] names = { "Asia", "Adam", "Jacek" };
    for (int i=0; i<names.length; i++)
      new PhoneBookClients(host, port, names[i]);
  }
}

5.11. Serwery wielowątkowe

• utworzenie gniazda serwera (ServerSocket) i związanie go z adresem (bind),
• po czym uruchomienie wielu wątków serwera, każdy z których będzie rownolegle  nasłuchiwał i akceptował połączenia na tym gnieździe i obsługiwał akceptowane połączenia.

import java.net.*;
import java.io.*;
import java.util.regex.*;

public class PhoneBookServerMT1 extends Thread {

  private PhoneDirectory pd = null;
  private ServerSocket ss = null;
  private BufferedReader in = null;
  private PrintWriter out = null;

  private volatile boolean serverRunning = true; // można zakończyć wątek
                                         // metodą ustalającą
                                         // wartość tej zmiennej na false

  private String serverTID;              // identyfikator wątku

  public PhoneBookServerMT1(String serverTID, PhoneDirectory pd,
                          ServerSocket ss) {
    this.serverTID = serverTID;
    this.pd = pd;
    this.ss = ss;
    System.out.println("Server " + serverTID + " started");
    System.out.println("listening at port: " + ss.getLocalPort());
    System.out.println("bind address: " + ss.getInetAddress());

    start();    // uruchomienie wątku
  }


  public void run() {
    while (serverRunning) {
      try {
        Socket conn = ss.accept();

        System.out.println("Connection established by " + serverTID);

        serviceRequests(conn);

      } catch (Exception exc) {
          exc.printStackTrace();
      }
    }                               // zamknięcie gniazda serwera
    try { ss.close(); } catch (Exception exc) {}
  }

  // Pozoatełe metody m.in.serviceRequest jak w poprzednio pokazanej klaeie

  private void serviceRequests(Socket connection) {
     // ...
  }

  private void writeResp(int rc, String addMsg)
               throws IOException {
     // ...
  }

  public static void main(String[] args) {
    final int SERVERS_NUM = 4;   // liczba serwerów
    PhoneDirectory pd = null;
    ServerSocket ss = null;
    try {
      String phdFileName = args[0];
      String host = args[1];
      int port = Integer.parseInt(args[2]);
      pd = new PhoneDirectory(phdFileName);
      InetSocketAddress isa = new InetSocketAddress(host, port);
      ss =  new ServerSocket();
      ss.bind(isa);
    } catch(Exception exc) {
        exc.printStackTrace();
        System.exit(1);
    }

    // Start wielu wątków (serwerow) dzialających równolegle
    // na tym samym gnieżdzie serwera

    for (int i=1; i <= SERVERS_NUM; i++) {
      new PhoneBookServerMT1("serv thread " + i, pd, ss);
    }
  }

}

import java.net.*;
import java.io.*;

public class PhoneBookServerMT2  {

  private PhoneDirectory pd = null;
  private ServerSocket ss = null;

  public PhoneBookServerMT2(PhoneDirectory pd,ServerSocket ss) {
    this.pd = pd;
    this.ss = ss;
    System.out.println("Server started");
    System.out.println("listening at port: " + ss.getLocalPort());
    System.out.println("bind address: " + ss.getInetAddress());

    serviceConnections();
  }


  private void serviceConnections() {
    boolean serverRunning = true;
    while (serverRunning) {
      try {
        Socket conn = ss.accept();
        System.out.println("Connection established");

        // start wątku obsługi zleceń
        new RequestHandler(pd, conn).start();

      } catch (Exception exc) {
          exc.printStackTrace();
      }
    }
    try { ss.close(); } catch (Exception exc) {}
  }

//...

}

import java.net.*;
import java.io.*;
import java.util.regex.*;

class RequestHandler extends Thread {

  private PhoneDirectory pd = null;
  private Socket connection = null;
  private BufferedReader in = null;
  private PrintWriter out = null;

  private static Pattern reqPatt = Pattern.compile(" +", 3);

  private static String msg[] = { "Ok", "Invalid request", "Not found",
                                  "Couldn't add - entry already exists",
                                  "Couldn't replace non-existing entry",
                                  };

  public RequestHandler(PhoneDirectory pd, Socket connection) {
    this.pd = pd;
    this.connection = connection;
    try {
      in = new BufferedReader(
               new InputStreamReader(
                   connection.getInputStream()));
      out = new PrintWriter(
                connection.getOutputStream(), true);
    } catch (Exception exc) {
        exc.printStackTrace();
        try { connection.close(); } catch(Exception e) {}
        return;
    }
  }

  public void run() {
    try {
      for (String line; (line = in.readLine()) != null; ) {
        String resp;
        String[] req = reqPatt.split(line, 3);
        String cmd = req[0];
        if (cmd.equals("bye")) {
          writeResp(0, null);
          break;
        }
        else if (cmd.equals("get")) {
          if (req.length != 2) writeResp(1, null);
          else {
            String phNum = (String) pd.getPhoneNumber(req[1]);
            if (phNum == null) writeResp(2, null);
            else writeResp(0, phNum);
          }
        }
        else if (cmd.equals("add"))  {
          if (req.length != 3) writeResp(1, null);
          else {
            boolean added = pd.addPhoneNumber(req[1], req[2]);
            if (added) writeResp(0, null);
            else writeResp(3, null);
          }
        }
        else if (cmd.equals("replace"))  {
          if (req.length != 3) writeResp(1, null);
          else {
            boolean replaced = pd.replacePhoneNumber(req[1], req[2]);
            if (replaced) writeResp(0, null);
            else writeResp(4, null);
          }
        }
        else writeResp(1, null);
      }
    } catch (Exception exc) {
        exc.printStackTrace();

    } finally {
        try {                  // by nie być zbyt drobiazgowym:
          connection.close();  // przy zamknięciu gniazda
          connection = null;   // strumienie są zamykane automatycznie
        } catch (Exception exc) { }
    }
  }

  private void writeResp(int rc, String addMsg)
               throws IOException {
    out.println(rc + " " + msg[rc]);
    if (addMsg != null) out.println(addMsg);
  }
}

public class PhoneDirectory {

  private Map pbMap = Collections.synchronizedMap(new HashMap());
  // ...
}

5.12. Nieblokujące kanały i  użycie selektorów przy programowaniu serwerów

1. Najpierw kanały są rejestrowane do monitorowania przez selektor (obiekt klasy Selector). Rejestracja kanału tworzy klucz selekcji dla tego kanału (obiekt klasy SelectionKey).
2. W kluczach zapisywane są stany gotowości kanałów do wykonania określonych operacji.
3. Selektor reaguje na zmiany stanów kanałów, wynikające z żądań klientów.
4. Gdy jakiś klient łączy się z serwerem przez kanał, związany z gniazdem serwera, selektor ustala stan gotowości klucza identyfikującego ten kanał, tak by klucz wskazywał , że istnieje połączenie gotowe do zaakceptowania przez serwer.
5. Gdy klient pisze do kanału komunikacyjnego, selektor ustala stan gotowości klucza  identyfikującego ten kanał, tak by wskazywał na  to, że w kanale są gotowe dane do odczytania   

import java.net.*;
import java.io.*;
import java.util.*;
import java.util.regex.*;
import java.nio.*;
import java.nio.channels.*;
import java.nio.charset.*;

public class PhoneBookServerNB {

  private PhoneDirectory pd = null;
  private ServerSocketChannel ssc = null;
  private Selector selector = null;

  public PhoneBookServerNB(PhoneDirectory pd, String host, int port ) {
    this.pd = pd;
    try {
      // Utworzenie kanału dla gniazda serwera
      ssc = ServerSocketChannel.open();

      // Tryb nieblokujący
      ssc.configureBlocking(false);

      // Ustalenie adresu (host+port) gniazda kanału
      ssc.socket().bind(new InetSocketAddress(host, port));

      // Utworzenie selektora
      selector = Selector.open();

      // Zarejestrowanie kanału do obsługi przez selektor
      // dla tego kanału interesuje nas tylko nawiązywanie połączeń
      // tryb - OP_ACCEPT
      ssc.register(selector,SelectionKey.OP_ACCEPT);

    } catch(Exception exc) {
        exc.printStackTrace();
        System.exit(1);
    }
    System.out.println("Server started and ready for handling requests");
    serviceConnections();
  }

  private void serviceConnections() {
    boolean serverIsRunning = true;

    while(serverIsRunning) {
      try {
        // Wywołanie blokujące
        // czeka na zajście  zdarzenia związanego z kanałami
        // zarejestrowanymi do obslugi przez selektor
        selector.select();

        // Coś się wydarzyło na kanałach
        // Zbiór kluczy opisuje zdarzenia
        Set keys = selector.selectedKeys();

        Iterator iter = keys.iterator();
        while(iter.hasNext()) {   // dla każdego klucza

          SelectionKey key = (SelectionKey) iter.next(); // pobranie klucza
          iter.remove();                                 // usuwamy, bo już
                                                         // go zaraz obsłużymy

          if (key.isAcceptable()) { // jakiś klient chce się połączyć

            // Uzyskanie kanału do komunikacji z klientem
            // accept jest nieblokujące, bo już klient się zgłosił
            SocketChannel cc = ssc.accept();

            // Komunikacja z klientem - nieblokujące we/wy
            cc.configureBlocking(false);

            // rejestrujemy kanał komunikacji z klientem
            // do obsługi przez selektor
            // - typ zdarzenia - dane gotowe do czytania przez serwer
            cc.register(selector, SelectionKey.OP_READ);
            continue;
          }

          if (key.isReadable()) {  // któryś z kanałów gotowy do czytania
            // Uzyskanie kanału na którym czekają dane do odczytania
            SocketChannel cc = (SocketChannel) key.channel();
            serviceRequest(cc);    // obsluga zlecenia
            continue;
          }
        }
      } catch(Exception exc) {
          exc.printStackTrace();
          continue;
      }
    }
  }

  private static Pattern reqPatt = Pattern.compile(" +", 3);

  private static String msg[] = { "Ok", "Invalid request", "Not found",
                                  "Couldn't add - entry already exists",
                                  "Couldn't replace non-existing entry",
                                  };

  // Strona kodowa do kodowania/dekodowania buforów
  private static Charset charset  = Charset.forName("ISO-8859-2");
  private static final int BSIZE = 1024;

  // Bufor bajtowy - do niego są wczytywane dane z kanału
  private ByteBuffer bbuf = ByteBuffer.allocate(BSIZE);

  // Tu będzie zlecenie do pezetworzenia
  private StringBuffer reqString = new StringBuffer();

  // Obsługa (JEDNEGO) zlecania
  private void serviceRequest(SocketChannel sc) {
    if (!sc.isOpen()) return; // jeżeli kanał zamknięty - nie ma nic do roboty

    // Odczytanie zlecenia
    reqString.setLength(0);
    bbuf.clear();
    try {
      readLoop:                    // Czytanie jest nieblokujące
      while (true) {               // kontynujemy je dopóki
        int n = sc.read(bbuf);     // nie natrafimy na koniec wiersza
        if (n > 0) {
          bbuf.flip();
          CharBuffer cbuf = charset.decode(bbuf);
          while(cbuf.hasRemaining()) {
            char c = cbuf.get();
            if (c == '\r' || c == '\n') break readLoop;
            reqString.append(c);
          }
        }
      }
      // Analiza zlecenia (jak poprzednio) i wołanie nowej metody
      // writeResp zapisującej odpowiedź do kanału
      String[] req = reqPatt.split(reqString, 3);
      String cmd = req[0];

      if (cmd.equals("bye")) {             // koniec komunikacji
          writeResp(sc, 0, null);          // - zamknięcie kanału
          sc.close();                      // i gniazda
          sc.socket().close();
      }
      else if (cmd.equals("get")) {
        if (req.length != 2) writeResp(sc, 1, null);
        else {
          String phNum = (String) pd.getPhoneNumber(req[1]);
          if (phNum == null) writeResp(sc, 2, null);
          else writeResp(sc, 0, phNum);
        }
      }
      else if (cmd.equals("add"))  {
        if (req.length != 3) writeResp(sc, 1, null);
        else {
          boolean added = pd.addPhoneNumber(req[1], req[2]);
          if (added) writeResp(sc, 0, null);
          else writeResp(sc, 3, null);
        }
      }
      else if (cmd.equals("replace"))  {
        if (req.length != 3) writeResp(sc, 1, null);
        else {
          boolean replaced = pd.replacePhoneNumber(req[1], req[2]);
          if (replaced) writeResp(sc, 0, null);
          else writeResp(sc, 4, null);
        }
      }
      else writeResp(sc, 1, null);             // nieznane zlecenie

    } catch (Exception exc) {                  // przerwane polączenie?
        exc.printStackTrace();
        try { sc.close();
              sc.socket().close();
        } catch (Exception e) {}
    }
  }

  private StringBuffer remsg = new StringBuffer(); // Odpowiedź

  private void writeResp(SocketChannel sc, int rc, String addMsg)
                         throws IOException {
    remsg.setLength(0);
    remsg.append(rc);
    remsg.append(' ');
    remsg.append(msg[rc]);
    remsg.append('\n');
    if (addMsg != null) {
      remsg.append(addMsg);
      remsg.append('\n');
    }
    ByteBuffer buf = charset.encode(CharBuffer.wrap(remsg));
    sc.write(buf);
  }

  public static void main(String[] args) {
    try {
      String phdFileName = args[0];
      String host = args[1];
      int port = Integer.parseInt(args[2]);

      PhoneDirectory pd = new PhoneDirectory(phdFileName);
      new PhoneBookServerNB(pd, host, port);
    } catch(Exception exc) {
        exc.printStackTrace();
        System.exit(1);
    }
  }

}

• istnieje wersja metody register(...) z klasy SelectableChannel, pozwalająca podać - jako trzeci argument - dowolny obiekt, który będzie związany z utworzonym przy rejestracji kluczem. Możemy też związać obiekt z kluczem już po rejestracji za pomocą metody attach(Object) z klasy SelctionKey. Obiekt ten póżniej - w fazie selekcji gotowych do wykonania operacji - będziemy mogli uzyskać od klucza za pomocą metody attachment() i wykorzystać np. do wykonania wybranej operacji. Pozwala to nie tylko na lepszą strukturyzację kodu, ale jest jednym ze sposobów uruchamiania wątków obsługi zleceń;
• oprócz blokującej metody select() w klasie Selector mamy do dyspozycji dwie inne  wersje tej metody: select(long) blokuje, ale nie dłużej niż podany jako arguemnt czas, selectNow() jest wywołaniem nieblokującym (zatem przy braku gotowosci kanałów i operacji nasz serwer może wykonywac inne czynności, sprawdzając tę gotowośc co jakiś czas np. 300 ms);
• metoda wakeup() z klasy Selector przerywa blokowanie na select(..); jest intensywnie używana przy łączeniu "dużej dozy" współbieżności z mechanizmem selekcji.

5.13. Klasy Javy wspomagające programowanie aplikacji klienckich

• (niestandardowy) pakiet sun.net.ftp, służący do programowania klientów FTP (a także liczne, publicznie dostępne pakiety klientów FTP dostępne w Sieci),
• zestaw klas pozwalajacych na połączenia i komuniakcję z zasobami sieciowymi, w szczególności przy wykorzystaniu protokołu HTTP.

import java.io.*;
import sun.net.ftp.FtpClient;    // podstawowa klasa pakietu sun.net.ftp
import java.text.*;

import javax.swing.*;

public class FtpFileRetriever {

  public static void main(String args[]) {
    FtpClient client = null;
    String userName = null;
    try {
     String host = args[0];
     userName = args[1];
     String password = args[2];
     client = new FtpClient(host);
     client.login(userName, password);  // logowanie
     client.binary();                   // tryb transmisji - binarny
    } catch(Exception exc) {
        exc.printStackTrace();
        System.exit(1);
    }

    String dir = null;
    String file = "";
    String dialogMsg = "Podaj nazwę pliku do pobrania:";
    while((file = JOptionPane.showInputDialog(dialogMsg)) != null) {
      try {
        String fileName = file;
        int lastSlash = file.lastIndexOf('/');

        // jeżeli w podanej nazwie pliku występuje ścieżka katalogowa
        // zmieniamy biezący katalog, jesli nie - pobierany jest plik
        // z aktualnego bieżącego katalogu
        if (lastSlash != -1) {
           fileName = file.substring(lastSlash+1);
           dir = file.substring(0,lastSlash);
           client.cd(dir);                     // zmiana biezącego katalogu
        }
        BufferedInputStream in = new BufferedInputStream(
                                  client.get(fileName)  // zwraca strumień
                                 );                     // do czytania pliku

        BufferedOutputStream out = new BufferedOutputStream(
                                     new FileOutputStream(fileName)
                                   );
        System.out.println("Pobieram: " + fileName);

        byte[] data = new byte[1024];
        int bytesRead, totalBytes = 0;
        long start = System.currentTimeMillis();
        while( (bytesRead = in.read(data)) > 0) {
          out.write(data, 0, bytesRead);
          totalBytes += bytesRead;
          System.out.print("\r... " + totalBytes);
        }
        out.close();
        double sec = (System.currentTimeMillis() - start)/1000.0;
        double kb =   totalBytes/1024.0;
        double kbps = kb/sec;
        DecimalFormat dn = new DecimalFormat("#.#");
        System.out.println("\nPobieranie ukonczone");
        System.out.println("Pobrano " + dn.format(kb) + "KB" +
                            " - " + dn.format(kbps) + " KB/sek.");
      } catch (IOException exc) {
         exc.printStackTrace();
      }
      dialogMsg = "Ostatnio pobrany plik: " + file +'\n' +
                  "Podaj nazwę pliku do pobrania:";
    }
    // Zamkniecie połaczenia
    try {client.closeServer(); } catch(Exception exc) {}
    System.exit(1);
  }
}

• opisu protokołu (np. http, ftp, gopher, file)
• nazwy hosta (np. www.ibm.com)
• odniesienia do konkretnego zasobu  (np. ścieżki dostępu do pliku i jego nazwy).

• stworzyć URL za pomocą jednego z konstruktorów klasy URL (jęsli podamy błędny adres powstanie wyjątek MalformedURLException),
• uzyskać od niego strumień wejściowy za pomocą metody getInputStream(),
• odczytać treść zasobu ze strumienia.

import java.net.*;
import java.io.*;
import java.util.*;
import java.util.regex.*;

public class SimpleGet {

  public SimpleGet(String urlString) {
    try {
      URL url = new URL(urlString);
      BufferedReader in = new BufferedReader(
                          new InputStreamReader(
                               url.openStream() // zwraca InputStream
                                                // związany z URLem
                          ));
      // Częsci URL-a
      String protocol = url.getProtocol();
      String host = url.getHost();
      String file = url.getFile();
      System.out.println("Protocol: " + protocol);
      System.out.println("Host: " + host);
      System.out.println("File: " + file);

      // Zapiszemy dokument za pomocą strumienia StringWriter
      StringWriter sw = new StringWriter(10240);
      String line;
      while ((line = in.readLine()) != null) {
         sw.write(line);
      }
      in.close();

      // Matcher do wyodrebniania referencji do plików graficznych na stronie
      Matcher matcher = Pattern.compile("img src=\"(.+?)\"",
                            Pattern.CASE_INSENSITIVE).matcher(sw.toString());

      // Obrazy będziemy przechosywać na liście
      java.util.List imgList = new ArrayList();

      while (matcher.find()) {
        String imgRef = matcher.group(1); // wyodrębniamy zapisany na stronie
                                          // url obrazka
        // zwykle będzie relatywny
        // za pomocą konstruktora URL(kontekst, referencja)
        // uzyskamy właściwy lokalizator wskazujący zasób
        URL imgUrl = new URL(url, imgRef);
        System.out.println(imgRef + " ==> " + imgUrl);
        // utworzenie obiektu Image i dodanie do listy
        imgList.add(Toolkit.getDefaultToolkit().createImage(imgUrl));
      }
      System.out.println("Preparation complete... wait for viewer init");

      // Listę obrazów przekażemy utworzonemu obiektowi przeglądarki obrazków
      new ImageViewer(imgList);

    } catch (MalformedURLException exc) {
        exc.printStackTrace();
        System.exit(1);
    } catch (Exception exc) {
        exc.printStackTrace();
    }

  }

  public static void main(String[] args) {
    String url = JOptionPane.showInputDialog("Adres");
    new SimpleGet(url);
  }
}

• rozwikłać relatywne adresy, czyli skomponować url, w którym brakujące w spec składniki są brane z context (urla dokumentu bazowego - czyli adresu wczytanej strony),
• znormalizować rozwikłane adresy, czyli odpowiednio usunąć wszystkie niepotrzebne "." i ".." (oznaczające w symboliczny sposób: katalog bieżący i katalog nadrzędny) ze ścieżki opisującej dostep do zasobu.

import java.util.*;
import java.util.regex.*;
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;

class ImagePanel extends JPanel {

  private Image img;
  private boolean correct;
  private Dimension defd = new Dimension(200,200);
  private String msg;

  public ImagePanel(String msg) {
    this.msg = msg;
    setPreferredSize(defd);
    setBorder(BorderFactory.createLineBorder(Color.blue, 2));
  }

  public void setImage(Image img) {
    this.img = img;
    int w = img.getWidth(this);       // szerokość obrazka
    int h = img. getHeight(this);     // wysokość obrazka
    if (w != -1 && w != 0 && h != -1 && h != 0) {
      correct = true;
      setPreferredSize(new Dimension(w, h));
    }
    else setPreferredSize(defd);
    repaint();
  }

  public void paintComponent(Graphics g) {
    super.paintComponent(g);
    if (img != null && correct)
      g.drawImage(img, 0, 0, getWidth(), getHeight(), this);
    else
      g.drawString(msg, 10, 10);
  }

}

class ImageViewer extends JFrame implements ActionListener {

  private ListIterator lit;
  private ImagePanel imagePanel = new ImagePanel("Loading images ...");
  private JButton left = new JButton(new ImageIcon("arrow1.gif"));
  private  JButton right = new JButton(new ImageIcon("arrow2.gif"));
  private JButton os = new JButton("<html><b>Oryginalna<br>skala</b></html>");

  public ImageViewer(java.util.List imgList) {

    lit = imgList.listIterator();

    getContentPane().add(imagePanel);
    JPanel p = new JPanel(new FlowLayout(FlowLayout.CENTER));
    left.addActionListener(this);
    right.addActionListener(this);
    os.addActionListener(this);
    p.add(left); p.add(right); p.add(os);
    getContentPane().add(p, "South");
    setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    pack();
    show();


    MediaTracker mt = new MediaTracker(this);
    int i=0;
    while(lit.hasNext()) mt.addImage((Image) lit.next(), ++i);
    try {
      mt.waitForAll();
    } catch (InterruptedException exc) { }
    System.out.println("Image viewer ready");

    SwingUtilities.invokeLater(new Runnable() {
      public void run() { getNext(); }
    });
  }

  public void actionPerformed(ActionEvent e) {
    Object src = e.getSource();
    if (src == right) getNext();
    else if (src == left) getPrevious();
    else pack();
  }

  private boolean lastOperWasNext = true;

  private void getNext() {
    if (!lastOperWasNext) lit.next();
    if (!lit.hasNext()) while (lit.hasPrevious()) lit.previous();
    imagePanel.setImage( (Image) lit.next() );
    lastOperWasNext = true;
  }

  private void getPrevious() {
    if (lastOperWasNext) lit.previous();
    if (!lit.hasPrevious()) while (lit.hasNext()) lit.next();
    imagePanel.setImage( (Image) lit.previous() );
    lastOperWasNext = false;
  }

}

• nie pozwala na odczytanie i interpretację nagłówków odpowiedzi serwera HTTP,
• nie pozwala na uzyskanie przekazywanych przez serwer kodów błędów  HTTP i związanych z nimi komunikatów.

• nazwy metody zlecenia ,
• nagłówków HTTP zlecenia ,
• treści. 

import java.net.*;
import java.io.*;
import java.util.*;
import javax.swing.*;

public class Connection1 {

  public Connection1(String urlString) {
    try {
      URL url = new URL(urlString);
      URLConnection conn = url.openConnection();
      conn.setUseCaches(false);
      conn.connect();

      Map map = conn.getHeaderFields();
      for (Iterator it = map.keySet().iterator(); it.hasNext(); ) {
        String header = (String) it.next();
        System.out.println(header + ":" + map.get(header));
      }

      BufferedReader in = new BufferedReader(
                           new InputStreamReader(
                            conn.getInputStream() ) );

      for ( String line; (line = in.readLine()) != null; ) {
        System.out.println(line);
      }
      in.close();
    } catch (MalformedURLException exc) {
        exc.printStackTrace();
        System.exit(1);
    } catch (FileNotFoundException exc) {
        System.out.println("Podanego zasobu nie ma na serwerze");
        System.exit(2);
    } catch (Exception exc) {
        exc.printStackTrace();
    }
  }

  public static void main(String[] args) {
    String url = JOptionPane.showInputDialog("Adres");
    new Connection1(url);
  }
}

import java.io.*;
import java.net.*;

public class Client1 {

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

     // Z tego pliku przeczytamy zlecnie do posłania
     // bedą to pary "nazwa_parametru=wartość"
      BufferedReader br = new BufferedReader(
                              new FileReader(args[0])
                            );

      URL url = new URL("http://....");                // adres aplikacji
                                                       // po stronie serwera
                                                       // obsługującej klienta
      URLConnection connection = url.openConnection();

      // Ustalenie nagłówka "accept-language" zlecenia
      // Po stronie serwera da to informację o lokalizacji
      // Tutaj jej nie używamy, ale może sie przydac w innych okolicznościach  
      connection.setRequestProperty("accept-language", "pl");

      // Będziemy pisać treść zlecenia
      connection.setDoOutput(true);

      String charset = "UTF-8";          // kodowanie treści
      PrintWriter out = new PrintWriter(
                             new OutputStreamWriter(
                              connection.getOutputStream(), charset)
                           );
      // Czytamy z pliku i zapisujemy jako treść zlecenia
      // pary: nazwa_parametru=wartośc parametru
      String line;
      while ((line = br.readLine()) != null)
       out.println(URLEncoder.encode(line, "UTF-8"));
      br.close();
      out.close();

      System.out.println("Zapis dokonany");

      // Odczytujemy odpowiedź serwera
      BufferedReader in = new BufferedReader(
                            new InputStreamReader(
                              connection.getInputStream(), charset));

      while ((line = in.readLine()) != null)
        System.out.println(line);

      in.close();
   }


}