Witam.
Bardzo prosiłbym o pomoc.
Dostaliśmy zadanie:

Komunikacja TCP i UDP

  1. Ze strony WWW należy pobrać przykłady dotyczące komunikacji. Zapoznać się z działaniem serwera TCP w pliku MultiServer.java. Napisać program klienta współpracujący z tym serwerem. Klient ma działać w następujący sposób: odebrać komunikat powitalny serwera (data i godzina), w pętli nieskończonej pobierać tekst z klawiatury, wysłać pobrany tekst do serwera, odebrać komunikat wysłany przez serwer i wyświetlić go na konsoli. (3 punkty)
  2. Zapoznać się z działaniem plików ChatterServer.java oraz ChatterClient.java. Na ich podstawie napisać aplikację rozsyłającą tekst z aktualną pogodą. Zakładamy, że serwer oczekuje na zgłoszenie się trzech klientów, a następnie przechodzi w stan rozsyłania informacji. Tekst z pogodą rozsyłać co pięć sekund (Thread.sleep). Klienci natomiast wpierw rejestrują się na serwerze (zachować odebrany przez serwer adres IP oraz port), po czym przechodzą w stan odbierania

Zadanie pierwsze jako tako udało się ogarnąć. Wklejam kod pliku otrzymanego MultiServer oraz program który należało wykonać

MultiServer.java

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

/** klasa obsługująca połączenie pomiędzy serwerem i klientem */
class SingleService extends Thread
{
    /** gniazdo reprezentujące połączenie między serwerem i klientem */
    private Socket socket;

    /** buforowany strumień wejściowy */
    private BufferedReader in;

    /** strumień wyjściowy */
    private PrintWriter out;

    /**
     * konstruktor obiektu
     * @param s gniazdo reprezentujące połączenie pomiędzy serwerem a klientem
     * @throws IOException błąd podczas pobierana strumienia wyjściowego z
     *             gniazda
     */
    public SingleService(Socket s) throws IOException
    {
        socket = s;

        // bufor wyjściowy (do niego będziemy zapisywać dane wysyłane do
        // klienta); true oznacza auto-flush
        out = new PrintWriter(new BufferedWriter(new OutputStreamWriter(socket
                .getOutputStream())), true);

        // bufor wejściowy (z niego będziemy odczytywać dane od klienta)
        in = new BufferedReader(new InputStreamReader(socket.getInputStream()));

        // uruchom wątek
        start();
    }

    /** metoda wątku */
    public void run()
    {
        try
        {
            // wyślij do klienta komunikat powitalny - aktualną datę i godzinę
            out.println(new java.util.Date().toString());

            // odbieraj dane od klienta
            while (true)
            {
                // odbierz dane i odeślij je z powrotem do klienta
                String str = in.readLine();
                out.println(str);

                // odebrano słowo "quit" - koniec połączenia
                if (str.equals("quit"))
                    break;

                // wyświetl odebrane dane
                System.out.println(str);
            }

            System.out.println("zamykanie...");
        }
        catch (IOException e)
        {
            System.out.println(e.getMessage());
        }
        finally
        {
            try
            {
                socket.close(); // zamknij gniazdo reprezentujące połączenie
            }
            catch (IOException e)
            {
                System.out.println(e.getMessage());
            }
        }
    }
}

/** klasa implementująca serwer w oparciu o protokół TCP */
public class MultiServer
{
    /** numer portu na którym serwer będzie nasłuchiwał zgłoszeń */
    static final int PORT = 8000;

    /**
     * główna metoda aplikacji
     * @param args argumenty wywołania programu
     * @throws IOException błąd podczas tworzenia gniazda
     */
    public static void main(String args[]) throws IOException
    {
        // utwórz klasę serwera
        ServerSocket server = new ServerSocket(PORT);

        System.out.println("Server started");

        try
        {
            while (true)
            {
                // zatrzymanie aż do nawiązania połączenia, metoda zwraca
                // odnośnik do gniazda reprezentującego połączenie
                Socket client = server.accept();

                try
                {
                    // utwórz obiekt obsługujący połączenie reprezentowane przez
                    // "client"
                    new SingleService(client);
                }
                catch (IOException e)
                {
                    client.close();
                    System.out.println(e.getMessage());
                }
            }
        }
        finally
        {
            // "zamknij" serwer
            server.close();
        }
    }

} 
Klient.java

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

public class Klient extends Thread{

    private static Socket socket = null;
    private static BufferedReader in = null;
    private static PrintWriter out = null;
    private static InputStreamReader wylot = null;
    private static int port;
    private static String host, txt, end;   
    private static boolean polacz = false, trwaj = false;

    public static void main(String args[]){ 

        try{
        host = "127.0.0.1";
        port = 8000;

            wylot = new InputStreamReader(System.in);
            in = new BufferedReader(wylot);

            polacz();
            odbieraj();
            do{
                try{

                    wyslij();
                    odbieraj();
                }catch(Exception e){}

            }while(polacz == true);
            //if(polacz){
            //System.out.println("Nadac ponownie T/N");
            //try{
            //  end = in.readLine();
            //}catch(IOException er){}
            //if(end.equals("N")||end.equals("n")){
            //  trwaj = true;
            //}
        //  }

        }catch(ArrayIndexOutOfBoundsException er){
            System.out.println("Usage: Host(Adress IP) port");
        }
    }

    public static void polacz(){
        if(!polacz){
            try{
                socket = new Socket(host, port);
                in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
                out = new PrintWriter(socket.getOutputStream(), true);
                polacz = true;              
                System.out.println("Polaczono");

            }catch(UnknownHostException er){System.out.println("Blad polaczenia");}
            catch(IOException er){System.out.println("Brak serwera");}          
        }   
    }

    public static void wyslij(){
        if(polacz){
            wylot = new InputStreamReader(System.in);
            in = new BufferedReader(wylot);         
            System.out.println("Wpisz wiadomosc");
            try{
                txt = in.readLine();
            }catch(IOException er){};
            if(!txt.equals("")){
                out.println(txt);
                System.out.println("Wiadomosc wyslana");                
            }

        }
    }
    public static void odbieraj(){
        if(polacz){
            BufferedReader we = null;
            PrintWriter wy = null;
            try{
                //Socket s = new Socket( "127.0.0.1" , 8000 );

                we = new BufferedReader(
                                new InputStreamReader(socket.getInputStream()));

                wy = new PrintWriter(
                                new BufferedWriter(
                                    new OutputStreamWriter(
                                        socket.getOutputStream())), true);
                }catch(Exception e){

                }
            try
            {

                    // odbierz dane 
                    String str = we.readLine();
                    System.out.println(str);

            }catch(Exception e){

            }
        }
        }

}

Pliki otrzymane do zadania drugiego:

ChatterClient.java

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

/** klasa implementująca klienta w oparciu o protokół UDP */
public class ChatterClient extends Thread
{
    /** gniazdo do wysyłania i przyjmowania pakietów */
    private DatagramSocket s;

    /** numer portu na którym odbędzie się komunikacja z serwerem */
    static final int PORT = 1711;

    /** adres serwera */
    private InetAddress hostAddress;

    /** bufor do przechowywania danych */
    private byte[] buf = new byte[1000];

    /** identyfikator klienta */
    private int id;

    /**
     * konstruktor obiektu klienta
     * @param identifier identyfikator klienta
     */
    public ChatterClient(int identifier)
    {
        id = identifier;

        try
        {
            // utwórz gniazdo
            s = new DatagramSocket();

            // adres serwera
            hostAddress = InetAddress.getByName("localhost");
        }
        catch (UnknownHostException e)
        {
            System.err.println("Serwer nieznany!");
            System.exit(1);
        }
        catch (SocketException e)
        {
            System.err.println("Nie można nawiązać połączenia!");
            e.printStackTrace();
            System.exit(1);
        }

        System.out.println("Klient " + id + " uruchomiony");
    }

    /** metoda wątku klienta */
    public void run()
    {
        try
        {
            // wyślij 25 porcji danych do serwera
            for (int i = 0; i < 25; i++)
            {
                // pakiet danych
                DatagramPacket dp = new DatagramPacket(buf, buf.length);

                // dane wysyłane do serwera
                String outMessage = "Client #" + id + ", message #" + i;

                // skopiuj do bufora dane do wysłania
                byte[] buf = outMessage.getBytes();

                // wyślij pakiet danych
                s.send(new DatagramPacket(buf, buf.length, hostAddress, PORT));

                // odbierz echo z serwera
                s.receive(dp);

                // dane odebrane z serwera wraz z adresem i numerem portu
                String rcvd = "Client #" + id + ", rcvd from "
                        + dp.getAddress() + ", " + dp.getPort() + ": "
                        + new String(dp.getData(), 0, dp.getLength());

                // wyświetl odebrane dane
                System.out.println(rcvd);
            }
        }
        catch (IOException e)
        {
            e.printStackTrace();

            System.exit(1);
        }
    }

    /**
     * główna metoda aplikacji
     * @param args argumenty wywołania programu
     */
    public static void main(String[] args)
    {
        // utwórz 5 klientów
        for (int i = 0; i < 5; i++)
            new ChatterClient(i).start();
    }
} 

ChatterServer.java

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

/** klasa implementująca serwer w oparciu o protokół UDP */
public class ChatterServer
{
    /** port na którym serwer będzie nasłuchiwał zgłoszeń */
    static final int PORT = 1711;

    /** bufor do przechowywania danych */
    private byte[] buf = new byte[1000];

    /** gniazdo do wysyłania i przyjmowania pakietów */
    private DatagramSocket socket;

    /** konstruktor obiektu serwera */
    public ChatterServer()
    {
        try
        {
            // utwórz gniazdo
            socket = new DatagramSocket(PORT);

            System.out.println("Server started");
            while (true)
            {
                // pakiet danych
                DatagramPacket dp = new DatagramPacket(buf, buf.length);

                // odbierz pakiet danych
                socket.receive(dp);

                // odebrane dane wraz z adresem i numerem portu
                String rcvd = new String(dp.getData(), 0, dp.getLength())
                        + ", from address: " + dp.getAddress() + ", port: "
                        + dp.getPort();

                // wyświetl odebrane dane
                System.out.println(rcvd);

                // dane które zostaną wysłane z powrotem do klienta - echo
                String echoString = "Echoed: " + rcvd;

                // skopiuj do bufora do wysłania (echo)
                buf = echoString.getBytes();

                // utwórz pakiet danych
                DatagramPacket echo = new DatagramPacket(buf, buf.length, dp
                        .getAddress(), dp.getPort());

                // wyślij do klienta
                socket.send(echo);
            }
        }
        catch (SocketException e)
        {
            System.err.println("Nie można nawiązać połączenia!");
            System.exit(1);
        }
        catch (IOException e)
        {
            System.err.println("Błąd podczas połączenia!");
            e.printStackTrace();
        }
    }

    /**
     * główna metoda aplikacji
     * @param args argumenty wywołania programu
     */
    public static void main(String[] args)
    {
        // utwórz egzemplarz klasy serwera
        new ChatterServer();
    }
}

Moja prośba. Czy dałby ktoś rade to wykonać? Niestety nie wiem jak się zabrać za tą część. Jeśli trzeba to zapłacę. Na wykonanie zadania mam 1h

Z gory dziekuje