Obsługa zdarzeń i logika aplikacji¶

Ćwiczenie 1¶

Na podstawie przykładu napisz implementację komunikatora internetowego, który będzie pozwalał na wprowadzanie kolejnych komunikatów z klawiatury i przesyłaniu ich do serwera.

Ćwiczenie 2¶

Napisz prostą implementację tekstowego komunikatora internetowego działającego w trybie simpleks. Twoja implementacja powinna obejmować następujące etapy

1. nawiązanie połączenia,
2. utworzenie obiektów reprezentujących strumienie danych pobieranych z klawiatury i z gniazda sieciowego oraz strumienie danych dostarczanych do gniazda sieciowego,
3. etap właściwej komunikacji w trybie simpleks (pętla wykonująca na przemian odbieranie i wysyłanie komunikatów tekstowych) oraz
4. zakończenie komunikacji i
5. zamknięcie połączenia.

Komunikacja powinna się odbywać do momentu przesłania przez którąkolwiek ze stron komunikatu koniec albo KONIEC (pomocna może tu być metoda equalsIgnoreCase() klasy String). Po przesłaniu takiego komunikatu zarówno klient jak i serwer powinny wypisać komunikat Koniec polaczenia i zakończyć działanie.

Ćwiczenie 3¶

Po stronie klienta zidentyfikuj i obsłuż wyjątek (try{}catch()) który wystąpi np. wtedy kiedy klient próbuje nawiązać połączenie z serwerem w sytuacji kiedy pod wskazanym adresem i numerem portu nie działa żaden serwer. W przypadku wystąpienia tego wyjątku Twój komunikator powinien wypisać komunikat Połączenie zostalo przerwane i zakończyć działanie.

Ćwiczenie 4¶

Po stronie klienta obsłuż wyjątek java.net.SocketException (try/catch) oznaczający wystąpienie błędu związanego z protokołem TCP.

Ćwiczenie 5¶

Poniżej znajdziesz szkielet implementacji komunikatora internetowego działającego w trybie duplex (komunikaty mogą być wysyłane i odbierane równolegle i w dowolnych sekwencjach, niekoniecznie na przemian). W tym przypadku wysyłanie komunikatów i odbieranie komunikatów musi odbywać się w oddzielnych wątkach.

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

class Odbior extends Thread   {
   Socket sock;
   BufferedReader sockReader;

   public Odbior(Socket sock) throws IOException
   {
      this.sock=sock;
      this.sockReader=new BufferedReader(new InputStreamReader(sock.getInputStream()));
   }

   public void run()
   {

   }
}

public class Serwer
{
   public static final int PORT=50007;

   public static void main(String args[]) throws IOException
   {
      //tworzenie gniazda serwerowego
      ServerSocket serv;
      serv=new ServerSocket(PORT);

      //oczekiwanie na polaczenie i tworzenie gniazda sieciowego
      System.out.println("Nasluchuje: "+serv);
      Socket sock;
      sock=serv.accept();
      System.out.println("Jest polaczenie: "+sock);

      //tworzenie watka odbierajacego
      new Odbior(sock).start();

      //zamykanie polaczenia
      serv.close();
      sock.close();
   }
}

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

class Odbior extends Thread
{
   Socket sock;
   BufferedReader sockReader;

   public Odbior(Socket sock) throws IOException
   {
      this.sock=sock;
      this.sockReader=new BufferedReader(new InputStreamReader(sock.getInputStream()));
   }

   public void run()
   {

   }
}

public class Klient
{
   public static final int PORT=50007;
   public static final String HOST = "127.0.0.1";

   public static void main(String[] args) throws IOException
   {
      //nawiazanie polaczenia z serwerem
      Socket sock;
      sock=new Socket(HOST,PORT);
      System.out.println("Nawiazalem polaczenie: "+sock);

      //tworzenie watka odbierajacego
      new Odbior(sock).start();

      //zamykanie polaczenia
      sock.close();
   }
}

Na podstawie powyższego przykładu napisz implementację komunikatora internetowego działającego w trybie duplex (komunikaty mogą być wysyłane i odbierane równolegle, niekoniecznie na przemian). W tym przypadku wysyłanie komunikatów i odbieranie komunikatów musi odbywać się w oddzielnych wątkach. Trzeba w tym celu napisać klasę która rozszerza klasę biblioteczną java.lang.Thread i umieścić instrukcje składające się na cykl życia wątku w metodzie run() tej klasy. W wątku głównym trzeba utworzyć instancję tej klasy i wywołać na jego rzecz metodę start(). Twój komunikator powinien działać do momentu, kiedy jedna ze stron prześle komunikat koniec albo KONIEC, a potem wypisać odpowiedni komunikat i zakończyć działanie.

Ćwiczenie 6¶

Poniżej znajdziesz szkielet implementacji serwera wielowątkowego, który oczekuje na połączenia klientów, a następnie dla każdego klienta tworzy oddzielny wątek który zajmie się obsłużeniem tego klienta.

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

class ObslugaZadania extends Thread
{
   Socket sock;

   ObslugaZadania(Socket klientSocket)
   {
      this.sock=klientSocket;
   }

   public void run()
   {

   }
}

public class Serwer
{
   public static void main(String[] args) throws IOException
   {
      ServerSocket serv=new ServerSocket(80);
      while(true)
      {
         //przyjecie polaczenia
         System.out.println("Oczekiwanie na polaczenie...");
         Socket sock=serv.accept();

         //tworzenie watku obslugi tego polaczenia
         new ObslugaZadania(sock).start();
      }
   }
}

Na podstawie powyższego przykładu napisz implementację serwera który będzie czekał na zgłoszenia klientów, przyjmował połączenia, a następnie przekazywał komunikaty otrzymane od dowolnego klienta do wszystkich przyłączonych mobilnych aplikacji klienckich. Powinieneś w tym celu zaimplementować klasę której obiekt będzie wątkiem reprezentującym obsługę danego klienta. Po nawiązaniu połączenia z kolejnym klientem, Twój serwer powinien utworzyć wątek który będzie porozumiewał się z tym klientem. Obiekty reprezentujące wątki możesz przechowywać za pomocą bibliotecznej implementacji listy java.util.ArrayList.