Witam.
Bardzo prosiłbym o pomoc.
Dostaliśmy zadanie:
Komunikacja TCP i UDP
- 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)
- 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