Interfejsy ObjectInputObjectOutput rozszerzają interfejsy odpowiednio: DataInputDataOutput aby umożliwić zapis i odczyt obiektów. DataInputDataOutput posiadają metody umożliwiające zapis danych typów wewnętrznych Javy, ObjectInputObjectOutput rozszerzają te klasy umożliwiając odpowiednio zapis i odczyt obiektów, tablic i danych typu String.

ObjectInputValidation

Interfejs pozwalający sprawdzić obiekty w grafie obiektów. Pozwala na to, aby obiekt był wołany gdy cały graf obiektów został odtworzony (ang. deserialized).

Przykłady użycia strumieni

W pierwszym przykładzie do operacji ze strumieniami użyto klas strumieni bajtowych. Natomiast w drugim przykładzie wykorzystano klasy strumieni znakowych.

Wykonanie poniższej aplikacji powoduje utworzenie pliku grupaI9.dat

import java.io.*;
class TestIO 
{
	public static void main(String[] args) 
	{
		try 
		{
			// Utworzenie strumienia wyjściowego danych zapisującego
			// do strumienia plikowego (czyli do pliku grupaI9.dat)
			DataOutputStream dos = new DataOutputStream(new FileOutputStream("grupaI9.dat"));
			String studenci[] = { "Jan Well", "Ola Jawa", "Oleg Tork","Ho Si Wan", "Radek Nowak" };
			double srednie[] = { 3.21, 4.65, 4.01, 4.12, 3.42 };
			// zapisanie danych do pliku
			for (int i = 0; i < srednie.length; i ++) 
			{ 
				dos.writeDouble(srednie[i]);
				dos.writeChar('\t');
				dos.writeChars(studenci[i]);
				dos.writeChar('\n');
			}
			dos.close();
	 	}
		catch (IOException e) 
		{ System.err.println("DataIOTest: " + e);	}
		try 
		{
			// utworzenie strumienia wejściowego danych, którego źródłem 
			// jest plikowy strumień wejściowy (czytanie z pliku)
			DataInputStream dis = new DataInputStream( new FileInputStream("grupaI9.dat"));
			double srednia;
			double sredniaGrupy = 0.0d;
			char chr;
			byte licz = 0;
			try 
			{
				// odczytanie danych z pliku i wyprowadzenie ich na ekran
				while (true) 
				{
					srednia = dis.readDouble();
					StringBuffer bufor = new StringBuffer(10);
					while ((chr = dis.readChar()) != '\n')
					bufor.append(chr);
					System.out.println("Student: " + bufor + " uzyskal(a) srednia ocen: " + srednia);
					sredniaGrupy = sredniaGrupy + srednia;
					licz++; 
				}
			}
			catch (EOFException e) { }
			// Wyprowadzenie na ekran średniej ocen grupy studentów
			System.out.println("Srednia grupy: " + sredniaGrupy/licz);
			dis.close();
		} 
		catch (FileNotFoundException e) 
			{System.err.println("Blad przy operacji na pliku: " + e);}
		catch (IOException e) 
			{System.err.println("Blad wejscia wyjscia: " + e);}
	}
}

Po wykonaniu powyższej aplikacji na ekranie otrzymamy:

D:\!Prace J++\IO streams 1.1>java TestIO
Student: Jan Well uzyskal(a) srednia ocen: 3.21
Student: Ola Jawa uzyskal(a) srednia ocen: 4.65
Student: Oleg Tork uzyskal(a) srednia ocen: 4.01
Student: Ho Si Wan uzyskal(a) srednia ocen: 4.12
Student: Radek Nowak uzyskal(a) srednia ocen: 3.42
Srednia grupy: 3.8820000000000006

Druga przykładowa aplikacja ilustruje wykorzystanie klas FileReader, FileWriter, BufferedReader, PrintWriter, PipedReader, PipedWriter, StreamTokenizer Z pliku dane.txt

Strumień wejściowy FileReaderFileWriterwyniki.txtPrinterWriterPipedWriterPipedReader (dzięki użyciu których zapewniona jest synchronizacja przepływu danych między wątkami).

wyniki.txtPIPEstreams

Metoda obliczPotege jako parametr wejściowy dostaje strumień wejściowy dane typu FileReader, zawierający liczby, dla których zostanie obliczona trzecia potęga.

W metodzie obliczPotege ten strumień wejściowy zostaje skierowany do strumienia BufferedReader (przyspieszającego czytanie). W metodzie obliczPotege tworzony jest PipedWriterPipedReader. Następnie strumień typu PipedWriterPrintWriter, co umożliwia użycie metody println do zapisywania wyników obliczeń do strumienia PipedWriter.

Po wykonaniu tych operacji tworzony jest wątek watekPotegiPrintWriter dołączony do PipedWriterBufferedReader dołączony do źródła danych) i następnie wątek zostaje uruchamiany.

Wątek typu watekPotegi, w metodzie runBufferedReader, oblicza ich potęgę i zapisuje do strumienia wyjściowego PrintWriter. Ponieważ PipedWriterPipedReader, wszystkie dane zapisane do PipedWriterPipedReader. Dane mogą być czytane z PipedReaderobliczPotegePipedReader, dzięki czemu dane mogą być czytane przez inny program lub wątek. W naszej przykładowej aplikacji PIPEstreams dane są czytane przez wątek watekSinusy uruchamiany w metodzie obliczSinus.

Dzięki uruchomieniu dwu wątków, każdy z potoków (ang. pipe) działa niezależnie od drugiego oraz zapobiega to zablokowaniu metody main, w przypadku, gdy jeden z końców potoku (pipe) jest zablokowany w oczekiwaniu na zakończenie operacji I/O.

import java.io.*;
class PIPEstreams {
	public static void main(String[] args) 
	{	
		try 
		{
			FileReader dane = new FileReader("dane.txt");
			FileWriter wyniki = new FileWriter("wyniki.txt");
			
			// obliczenie potęgi i sinusa
			Reader liczby = obliczSinus(obliczPotege(dane));
			
			// wyświetlenie danych na ekranie oraz zapisanie ich do pliku
			BufferedReader br = new BufferedReader(liczby);
			String input;
			PrintWriter stdout = new PrintWriter(System.out, true);
			
			while ((input = br.readLine()) != null) {
				stdout.println(input);
				wyniki.write(input+"\n");
			}
			br.close();
			wyniki.close();	
		} 
		catch (Exception e) 
		{ System.err.println(e); }
	}
	
	public static Reader obliczPotege(Reader zrodlo) 
	{
		PipedWriter pw = null;
		PipedReader pr = null;	
		try {
			BufferedReader br = new BufferedReader(zrodlo);
			
			pw = new PipedWriter();
			pr = new PipedReader(pw);
			PrintWriter output = new PrintWriter(pw);
			new watekPotegi(output, br).start();	
		} 
		catch (Exception e) 
		{ System.err.println(e); }
		return pr;
	}
	public static Reader obliczSinus(Reader zrodlo) 
	{
		PipedWriter pw = null;
		PipedReader pr = null;	
		try {
			BufferedReader br = new BufferedReader(zrodlo);
			
			pw = new PipedWriter();
			pr = new PipedReader(pw);
			PrintWriter output = new PrintWriter(pw);
			new watekSinusy(output, br).start();
		} 
		catch (Exception e) 
		{ System.err.println(e); }
		return pr;
	}
}

Poniżej przedstawiono definicję klasy watekPotegiStreamTokenizer. StremTokenizernextTokenStremTokenizer.TT_NUMBER (liczba), StreamTokenizer.TT_WORD (słowo), StreamTokenizer.TT_EOF (koniec pliku), StreamTokenizer.TT_EOL (koniec linii). Wartość pobrana przez metodę przechowywana jest w polu nval (gdy jest to liczba) lub sval (słowo) obiektu typu StreamTokenizer.

watekPotegi

import java.io.*;
class watekPotegi extends Thread {
	PrintWriter pw;
	BufferedReader br;
	watekPotegi(PrintWriter pw, BufferedReader br) 
	{
		this.pw = pw;
		this.br = br;
	}
	public void run() {
		if (pw != null && br != null) {
			try {
				StreamTokenizer tokenizer = new StreamTokenizer(br);
				int coNastepne;
				while((coNastepne = tokenizer.nextToken()) != StreamTokenizer.TT_EOF)
				{
					double number = 0;
					if ((coNastepne == StreamTokenizer.TT_NUMBER) )
					{
						number = tokenizer.nval;	
						pw.println(number+" szescian "+Math.pow(number,2));
					}
					// odblokowanie potoku (PIPE) do odczytu 
					//przez inne programy lub watki
					pw.flush();
				}
				pw.close();
			} 
			catch (IOException e) 
			{ System.err.println("blad w metodzie run watekPotegi: "+e);}
		}
	}
	protected void finalize() 
	{
		try 
		{
			if (pw != null) 
			{	pw.close();	pw = null; }
			if (br != null) 
			{	br.close();	br = null; }
		} 
		catch (IOException e) 
{
	System.err.println("blad w metodzie finalize watekPotegi: "+ e);
}
	}
}

Definicja drugiego z używanych przez nas w aplikacji PIPEstreamswatekPotegi różni się tylko w definicji metody run. Dlatego w poniższym przykładzie przedstawiono tylko tę metodę.

Do strumienia wyjściowego przepisywane są wszystkie słowa i liczby pobrane ze strumienia wejściowego, oprócz ostatniej liczby w linii, dla której obliczany jest jej sinus.

runwatekSinusy

	public void run() 
	{
		if (pw != null && br != null) 
		{
			try 
			{
				StreamTokenizer tokenizer = new StreamTokenizer(br);
				// ponizsza metoda umożliwia traktowanie jako tokenu znaku 
				// końca linii
				tokenizer.eolIsSignificant(true);
				int coNastepne;
				coNastepne = tokenizer.nextToken();
				while(coNastepne != StreamTokenizer.TT_EOF)
				{
					double number = 0;
					// jesli koniec linii
					if (coNastepne == StreamTokenizer.TT_EOL) 
					{
						number = tokenizer.nval;
						pw.println("\tsin("+number+")\t= "+Math.sin(number));
					}
					else
					{
						if (coNastepne == StreamTokenizer.TT_NUMBER)
							pw.print(" "+tokenizer.nval);
						if (coNastepne == StreamTokenizer.TT_WORD)
							pw.print(" "+tokenizer.sval);
					}
					coNastepne = tokenizer.nextToken();
					pw.flush();
				}
				pw.close();
			} 
			catch (IOException e) 
			{	
				System.err.println("blad w metodzie run watekSinusy: "+e);
			}
		}
	}

Praca w sieci

Programy pracujące w sieci Internet oparte są na koncepcji klient/serwer. Gdzieś w sieci Internet (lub lokalnie na naszym komputerze) znajduje się program serwera, który dostarcza naszemu programowi klienta potrzebnych danych. Dane te to np. pliki, gdy łączymy się z serwerem FTP, poczta elektroniczna przysłana do nas (serwer POP), strony WWW (serwer HTTP), możemy także wysłać dane do serwera w celu ich przetworzenia lub skorzystania z jakiejś usługi np. połączenie z serwerem SMTP pozwala nam na wysłanie poczty elektronicznej. Aby skorzystać z tych usług na nasz komputer musi obsługiwać protokoły TCP i UDP.

W Javie czasami korzystamy z możliwości sieciowych bez implementacji ich, np. gdy ładujemy rysunek z odległego hosta:

Image image = getImage(new URL("http://cari.put.poznan.pl/cos.gif"));      

Java stała się najpopularniejszym językiem programowania w Internecie nie tylko dlatego, że umożliwia pisanie programów działających w heterogenicznych środowiskach ale także dzięki możliwościom sieciowym, jakie dostarcza pakiet java.net

URL

URL jest skrótem od ''Uniform Resource Locator'' oznaczającym referencje (adres) do zasobu w sieci Internet. Wpisanie w przeglądarce adresu URL: "http://www.put.poznan.pl" powoduje połączenie z serwerem WWW Politechniki Poznańskiej (z wykorzystaniem protokołu HTTP), natomiast adres URL: "ftp://ftp.amu.edu.pl" powoduje połączenie z serwerem FTP w Uniwersytecie Adama Mickiewicza w Poznaniu (jeśli przeglądarka obsługuje ten protokół).

Programy napisane w Javie mogą korzystać z URL'a w celu znalezienia zasobów sieci Internet, do których chcemy uzyskać dostęp. Pakiet java.net zawiera klasę o nazwie URL, która może zostać użyta do reprezentacji adresów URL (poprzez obiekt klasy URL) w programach Javy. Należy rozróżnić adres URL, opisujący zasób sieci Internet, od obiektu klasy URL reprezentującego adres URL w Javie.

Przykład użycia klasy URL ilustruje poniższy aplet. Po wpisaniu poprawnego adresu URL w polu tekstowym apletu, w przeglądarce wyświetlana jest strona WWW (lub obsługiwana jest inna usługa, np.: FTP, Telnet, - jeśli przeglądarka obsługuje te protokoły) opisana adresem URL.

Aby stworzyć stronę HTML zawierającą aplet ZaladujURL

<html><head><title>AWTLoadDocument</title></head><body>
<applet
    code=ZaladujURL.class
    width=320
    height=60 >
</applet>
</body></html>

Przykład 2.44 Użycie URL'a

import java.applet.*;
import java.awt.*;
public class ZaladujURL extends Applet
{
	Button btnZaladuj = new Button("Zaladuj strone");
	TextField txtCo = new 	TextField("http://friko.onet.pl/po/arturt/index.html");
	public void init()
	{
		setLayout(new BorderLayout());	
		add("North",txtCo);
		add("Center",btnZaladuj);
	}
	public boolean action(Event e, Object arg) 
	{
		if (e.target instanceof Button) 
		{
			try
			{
				getAppletContext().showDocument(new java.net.URL(txtCo.getText()),"_self");
				/* opis parametrów metody showDocument
				 "_self"   	wyświetla dokument w bieżącym oknie
				 "_parent" 	wyświetla w bieżącej ramce (ang. frame)
				 "_top" 	wyświetla w szczytowej ramce
				 "_blank" 	wyświetla w nowym oknie bez nazwy
				 name 		wyświetla w nowym oknie o nazwie: name
				*/
			}
			catch (Exception exc)
			{ 
				exc.printStackTrace(); 
				txtCo.setText("Zly adres");
			}
			return true;
		}
		return false;
	}
}

Dzięki użyciu metody getAppletContext uzyskujemy dostęp do przeglądarki, w której uruchamiany jest aplet i możemy skorzystać z metody showDocument, która każe przeglądarce wyświetlić stronę opisaną adresem zawartym w obiekcie URL. W tym celu tworzymy nowy obiekty typu URLString

ZaladujURL

Ponieważ w chwili pisania tej pracy nie była dostępna przeglądarka obsługująca nowy standard Javy 1.1. Aplet ZaladujURL

Klasa URL

• URL(String)

tworzący obiekt URL znakowego,

• URL(String, String, int, String)

tworzący obiekt URL

• URL(String, String, String)

tworzący obiekt URL

• URL(URL, String)

tworzący nowy obiekt URLURL

Przykładowo, tworzymy obiekt URL:

URL mojProvider = new URL("http://friko.onet.pl");

i chcemy stworzyć nowy obiekt URL opisujący adres URL mojej strony domowej:

URL mojaStrona = new URL(mojProvider, "/po/arturt/index.html");

Możemy także stworzyć obiekt URL odnoszący się do wybranego miejsca na stronie HTML (ang. anchor):

URL koniecMojejStrony = new URL(mojaStrona, "#KONIEC_STRONY"); 

Powyższy obiekt można oczywiście stworzyć używając pierwszego konstruktora:

URL koniecMojejStrony = new URL("http://friko.onet.pl/po/arturt/index.html#KONIEC_STRONY"); 

Użycie konstruktora postaci:

URL mojaStrona = new URL("http","friko.onet.pl","/po/arturt/index.html");

jest równoważne z URL("http://friko.onet.pl/po/arturt/index.html").

Natomiast:

URL mojaStrona = new URL("http","friko.onet.pl",80,"/po/arturt/index.html");

z URL("http://friko.onet.pl:80/po/arturt/index.html"), pojawił się tu nowy argument oznaczający port wykorzystywany podczas połączenia.

Po stworzeniu obiektu URLURLConnection

import java.net.*;
import java.io.*;
class TestPolaczenia 
{
	public static void main(String[] args) 
	{
		try 
		{
			// Utworzenie obiektu URL
			URL friko = new URL("http://friko.onet.pl/");
			// otwarcie połączenia z URL, metoda openConection zwraca
			// referencję do obiektu typu URLConnection, dzięki któremu 
			// możemy czytać i zapisywać dane, z utworzonego połączenia 
			URLConnection polaczenieDoFriko = friko.openConnection();
			BufferedReader br = new BufferedReader(new InputStreamReader(polaczenieDoFriko.getInputStream()));
			String inputLine;
			// wyprowadzenie odczytanych z serwera HTTP friko.onet.pl danych na ekran
			while ((inputLine = br.readLine()) != null) 
			{ System.out.println(inputLine); }
			br.close();
		}
		catch (MalformedURLException me)
		{System.out.println("MalformedURLException: " + me);}
		catch (IOException ioe) 
		{System.out.println("IOException: " + ioe);}
	}
} 

Aby zapisać (wysłać do serwera) dane do strumienia wyjściowego połączenia z URL, po drugiej stronie musi być np. skrypt CGI potrafiący te dane odebrać i wykorzystać.

Klasy URLURLConnection wykorzystywane są do komunikacji na relatywnie wysokim poziomie i do specyficznych zastosowań (dostęp do zasobów Internetu). Niekiedy programy wymagają niższego poziomu komunikacji w sieci, np. wtedy, gdy chcemy napisać aplikację typu klient/serwer.

W aplikacjach klient-serwer, serwer dostarcza pewnych usług, jak np.: wykonanie zapytań do bazy danych. Klient natomiast wykorzystuje dane dostarczone przez serwer. Komunikacja między serwerem i klientem musi być niezawodna (dane nie mogą być gubione i muszą przybywać do w tej samej kolejności w jakiej zostały wysłane).

Protokół TCP dostarcza niezawodnego, punkt-punkt (ang. point-to-point) kanału komunikacyjnego, który jest używany do komunikacji przez aplikacje klient/serwer w Internecie. Klasy Javy SocketServerSocketjava.net

Przedstawiony w przykładach 2.46SocketServerSocket oraz klas strumieni wejściowych i wyjściowych do komunikacji pomiędzy serwerem i klientem z użyciem protokołu TCP.

Jako pierwszy musi zostać uruchomiony program serwera, aby klient miał się z czym łączyć.

MojSerwer

Na innym komputerze w sieci (lub jak na poniższym przykładzie w innej sesji, na tym samym komputerze) uruchamiamy program klienta.

Aplikacja klienta MojKlient łączy się z serwerem MojSerwer

MojKlient

Klient może wysłać do serwera: polecenie "Czesc" - serwer odpowiada wtedy "Co tam?", liczbę - serwer odsyła kwadrat odebranej liczby, polecenie "Koniec" - powodujące zamknięcie połączenia i zakończenie pracy serwera. W przypadku wysłania przez klienta pustej linii serwer odpowiada "Dostałem puste ?!" a dla innych poleceń serwer odpowiada "Nie zinterpretowane". Użycie tak zdefiniowanego sposobu komunikacji po stronie klienta (i odpowiedzi serwera), pokazano na ilustracji 2-28.

Przykład 2.46 Kod serwera MojSerwer

import java.net.*;
import java.io.*;
class MojSerwer 
{
	public static void main(String[] args) 
	{
		ServerSocket gniazdkoSerwera = null;
		int nrPortu = 3535; 
		try 
		{
			// utworzenie gniazdka na którym nasłuchuje serwer
			gniazdkoSerwera = new ServerSocket(nrPortu);
			System.out.println("Serwer nasluchuje na porcie: " + nrPortu);
		}
		catch (IOException e) 
		{
			System.out.println("Nasluchiwanie na porcie: " + nrPortu + " niemozliwe, " + e);
			System.exit(1);
		}
		Socket gniazdkoKlienta = null;
		try 
		{
			// serwer czeka na połączenie 
			gniazdkoKlienta = gniazdkoSerwera.accept();
			// połączenie zostało nawiązane (wykonano metode accept)

			System.out.println("Operacja accept wykonana! :)");
		}
		catch (IOException e) 
		{
			System.out.println("Operacja accept nie powiodla sie: " + nrPortu + ", " + e);
			System.exit(1);
		}
		try
		{
			// ustawienie jako strumienia wejściowego danych przysłanych 
			// przez klienta do gniazdka
			BufferedReader br = new BufferedReader(new InputStreamReader(gniazdkoKlienta.getInputStream()));
			// ustawienie jako strumienia wyjściowego danych zapisywanych 
			// przez serwer do strumienia PrintWriter 
			// dane te następnie poprzez gniazdko zostają wysłane do
			// programu klienta
			PrintWriter pw = new PrintWriter(new BufferedOutputStream(
							gniazdkoKlienta.getOutputStream(), 1024), false);
			pw.println("Serwer wita !");
			pw.flush();
			int i=0;
			String liniaWe, liniaWy;
			// pętla while implementuje wymianę komunikatów pomiędzy 
			// klientem i serwerem
			while ((liniaWe = br.readLine()) != null) 
			{
				liniaWy = odpowiedzSerwera(liniaWe);				
				pw.println(liniaWy);
				// wyczyszczenie strumienia (wysłanie danych do serwera)
				pw.flush();
				if (liniaWy.equals("Koniec pracy serwera")) break;
			}
			// zamknięcie strumieni i gniazdek, zakończenie połączenia
			pw.close();
			br.close();
			gniazdkoKlienta.close();
			gniazdkoSerwera.close();
		}
		catch (IOException e) 
		{ e.printStackTrace(); }
	}
	// metoda odpowiedzSerwera definiuje odpowiedzi serwera 
	// na polecenia przysłane przez klienta
	static String odpowiedzSerwera(String s)
	{
		try
		{
			int i = Integer.parseInt(s);
			return "Obliczony kwadrat liczby "+ i +" wynosi:"+ i*i;
		}
		catch (NumberFormatException nfe)
		{}
		if (s.equals(null)) return "Dostalem puste ?!";
		if (s.equals("Czesc")) return "Co tam?";
		if (s.equals("Koniec")) return "Koniec pracy serwera";
		return s+" Nie zinterpretowane";
	}
}

Aplikacja MojKlient, której kod przedstawiono poniżej, łączy się z serwerem, odczytuje polecenia z klawiatury, wysyła je do serwera, odbiera otrzymane dane i wyświetla je na ekranie.

MojKlient

import java.io.*;
import java.net.*;
public class MojKlient 
{
	public static void main(String[] args) 
	{
		Socket gniazdkoMojSerwer = null;
		PrintWriter pw = null;
		BufferedReader br = null;
		// nazwaHosta określa host na którym uruchomiono 
		// aplikację serwera; ponieważ program klienta i serwera 
		// uruchomiono na tym samym komputerze wartością tej 
		// zmiennej jest 'localhost'  deklaracja postaci:
		// String nazwaHosta = "coral.put.poznan.pl";
		// oznacza, że aplikację serwera uruchomiono na hoście
		// coral.put.poznan.pl 
		String nazwaHosta = "localhost"; 
		int nrPortu = 3535;
		try
		{
			// próba połączenia z serwerem znajdującym się na hoście 
			// o nazwie "nazwaHosta" nasłuchującym na porcie o numerze
			// równym wartości zmiennej "nrPortu"
			gniazdkoMojSerwer = new Socket(nazwaHosta, nrPortu);
			// ustawienie jako strumienia wyjściowego danych zapisywanych 
			// przez klienta do strumienia PrintWriter 
			// dane te następnie poprzez gniazdko zostają wysłane do
			// programu serwera
			pw = new PrintWriter(gniazdkoMojSerwer.getOutputStream());
			// ustawienie jako strumienia wejściowego danych przysłanych 
			// przez serwer do gniazdka
			br = new BufferedReader(new InputStreamReader(gniazdkoMojSerwer.getInputStream()));
		}
		catch (UnknownHostException e) 
		{ System.err.println("Host: "+ nazwaHosta +" nieznany"); }
		catch (IOException e) 
		{System.err.println("Blad operacji I/O dla: "+nazwaHosta);}
		if (gniazdkoMojSerwer != null && pw != null && br != null) 
		{
			try
			{
				StringBuffer buf = new StringBuffer(50);
				int c;
				String odpSerwera;
				// w pętli while odczytane z klawiatury polecenia, wysyłane
				// są do aplikacji serwera, a następnie wyświetlane są 
				// odpowiedzi przysłane przez serwer 
				while ((odpSerwera = br.readLine()) != null) 
				{
					System.out.println("Serwer: " + odpSerwera);
					if (odpSerwera.equals("Koniec pracy serwera")) break;
					// odczytanie linii danych z klawiatury
					while ((c = System.in.read()) != '\n') 
					{ buf.append((char)c); }
					System.out.println("Klient: " + buf);
					pw.println(buf.toString().trim());
					// wyczyszczenie strumienia (wysłanie danych do serwera)
					pw.flush();
					buf.setLength(0);
				}
				pw.close();
				br.close();
				gniazdkoMojSerwer.close();
			}
			catch (UnknownHostException e) 
			{
				System.err.println("Proba polaczenia do nieznanego hosta: " + e);
			}
			catch (IOException e)
			{ System.err.println("Blad I/O: " + e);}
		}
	}
}

Datagramy

Niektóre aplikacje komunikujące się ze sobą poprzez sieć, nie potrzebują stałego, dostarczanego przez TCP, kanału komunikacyjnego. Stosowana jest wtedy komunikacja bezpołączeniowa dostarczana przez protokół UDP. Protokół UDP, definiuje sposób komunikacji, w którym dane wysyłane są w pakietach nazywanych datagramami. Komunikacja za pomocą datagramów z użyciem protokołu UDP implementowana jest w klasach DatagramPacketDatagramSocketjava.net.

Programy klienta i serwera, które komunikują się ze sobą z wykorzystaniem kanału komunikacyjnego (takiego jak URL lub gniazdko), posiadają dedykowany kanał między nimi. Proces wymiany informacji polega na: ustanowieniu połączenia, transmisji danych i zamknięciu połączenia. Wszystkie dane wysyłane przez kanał komunikacyjny zostają odebrane w tej samej kolejności, w jakiej zostały wysłane. Jest to zagwarantowane przez kanał komunikacyjny.

Inaczej jest, gdy programy komunikują się poprzez datagramy, wysyłają i odbierają niezależne pakiety danych. Wtedy programy te nie mają dedykowanego im kanału komunikacyjnego. Dostarczenie datagramu do jego miejsca przeznaczenia nie jest zagwarantowane, tak jak kolejność ich przybycia.

Aby zilustrować użycie datagramów napisano aplikację serwera SerwerPolecenCoMamZrobic. Klient łączy się z serwerem podając nazwę użytkownika, jeśli aplikacja serwera znajdzie plik tekstowy o nazwie nazwa_użytkownika.txt

Na poniższej ilustracji pokazano informacje jakie są wyświetlane przez program serwera w czasie jego działania.

SerwerPolecen

Na innym komputerze w sieci (lub jak tak jak na poniższym przykładzie w innej sesji) uruchamiamy program klienta z następującymi parametrami:

java CoMamZrobic nazwaHosta nrPortu użytkownik

gdzie:

nazwaHostaSerwerPolecen. W przykładzie jest to adres 127.0.0.1 oznaczający bieżący komputer, dzięki czemu można tego typu programy testować lokalnie.

nrPortu

użytkownikzamknij.txt,

CoMamZrobic

Na poniższym listingu przedstawiono kod serwera SerwerPolecenmain utworzony i uruchomiony jest wątek typu WatekSerweraPolecen

SerwerPolecen

class SerwerPolecen 
{
	public static void main(String[] args) 
	{
		new WatekSerweraPolecen().start();
	}
}

Cała komunikacja z użyciem datagramów realizowana jest właśnie przez wątek WatekSerweraPolecen

WatekSerweraPolecen

import java.io.*;
import java.net.*;
import java.util.*;
class WatekSerweraPolecen extends Thread 
{
	private DatagramSocket m_gniazdkoDat = null;
	private BufferedReader m_strumienPolecen = null;
	WatekSerweraPolecen() 
	{
		super("Watek Serwera Polecen");
		try 
		{
			// utworzenie nowego gniazdka przeznaczonego do komunikacji 
			// z wykorzystaniem datagramów
			m_gniazdkoDat = new DatagramSocket();
			// zarezerwowanie portu do komunikacji datagramowej, metoda 
			// getLocalPort rezerwuje najbliższy wolny port. Dzięki temu 
			// unikamy sytuacji gdy port, który chcemy zająć jest 
			// wykorzystywany przez inną usługę. 
			System.out.println("SerwerPolecen nasluchuje na porcie: " + 
							m_gniazdkoDat.getLocalPort());
		}
		catch (java.io.IOException e) 
		{ System.err.println("Nie moge utworzyc gniazdka I/O datagramow.");	 }
	}
	
	public void run() 
	{
		if (m_gniazdkoDat == null)
			return;

		while(true)
		{
			try 
			{
				byte[] bufor = new byte[256];
				DatagramPacket pakiet;
				InetAddress adres;
				int port;
				String daneDoWyslania = null;
				
				// odebranie zapytania od klienta
				pakiet = new DatagramPacket(bufor, 256);
				m_gniazdkoDat.receive(pakiet);
				adres = pakiet.getAddress();
				port = pakiet.getPort();
				String daneOdebrane = new String(pakiet.getData()).trim();
				System.out.println("Zapytanie o informacje dla " + daneOdebrane);
				// wysłanie odpowiedzi
				// pobranie polecenia z pliku
				daneDoWyslania = polecenie(daneOdebrane);
				// zamienia string w tablice bajtów w celu
				// umożliwienia wysłania jej w datagramie
				bufor = daneDoWyslania.getBytes();
				// utworzenie pakietu przeznaczonego do wysłania
				pakiet = new DatagramPacket(bufor, bufor.length, adres, port);
				// wysłanie datagramu
				m_gniazdkoDat.send(pakiet);
				// Jeśli w polu użytkownik zostało podane słowo zamknij
				// serwer kończy swoje działanie
				if (daneOdebrane.compareTo("zamknij")==0) break;
			} 
			catch (IOException e) 
			{
				System.err.println("IOException:  " + e);
				e.printStackTrace();
			}
		}
	}
	protected void finalize() 
	{
		if (m_gniazdkoDat != null) 
		{
			m_gniazdkoDat.close();
			m_gniazdkoDat = null;
			System.out.println("Zamknięcie gniazdka datagramow.");
		}
	}
	// metoda polecenie, czyta z pliku polecenia
	// przeznaczone dla użytkownika
	private String polecenie(String kto) 
	{
		String linia = "Nie ma polecen dla "+ kto;
		try 
		{
			StringBuffer info = new StringBuffer("Wiadomosc wyslana " + new Date().toLocaleString()+": \n");
			m_strumienPolecen = new BufferedReader(new InputStreamReader(new FileInputStream(kto+".txt")));
			while((linia = m_strumienPolecen.readLine())!=null)
				info.append(linia+"\n");	
			return info.toString();
		} 
		catch (FileNotFoundException e) 
		{ 
			System.err.println("Nie moge otworzyc pliku z poleceniami. " + kto + ".txt"); 
		}
		catch (IOException e)  
		{ linia = "Na serwerze wystapil blad IOException.";	 }
		return linia;
	}
}

Aplikacja klienta wysyła na adres i port podane jako parametr wywołania aplikacji, nazwę użytkownika podaną jako ostatni parametr wywołania. Następnie odbierane są dane odesłane przez serwer i wyświetlane na ekranie.

CoMamZrobic

import java.io.*;
import java.net.*;
import java.util.*;
class CoMamZrobic 
{
	public static void main(String[] args) 
	{
		int port;
		InetAddress adres;
		DatagramSocket gniazdko = null;
		DatagramPacket pakiet;
		byte[] buforWys = new byte[256];
		if (args.length != 3) 
		{
			System.out.println("Uzycie: java CoMamZrobic <nazwahosta>" + " <port#> <uzytkownik>");
			return;
		}
		try 
		{
			// przyłączenie do gniazdka
			gniazdko = new DatagramSocket();
		} 
		catch (java.io.IOException e) 
		{ System.err.println("Nie moge utworzyc gniazdka I/O datagramow."); }
		if (gniazdko != null) 
		{
			try 
			{
				// wysłanie zapytania
				adres = InetAddress.getByName(args[0]);
				port = Integer.parseInt(args[1]);
				buforWys = args[2].getBytes();
				// utworzenie datagramu
				pakiet = new DatagramPacket(buforWys, buforWys.length, adres, port);
				// wysłanie
				gniazdko.send(pakiet);
				
				// odbiór odpowiedzi
				byte buforOdb[] = new byte[256];
				pakiet = new DatagramPacket(buforOdb, 256);
				gniazdko.receive(pakiet);
				String tekstOdebrany = new String(pakiet.getData()).trim();
				System.out.println("Polecenie:\n" + tekstOdebrany);
				
				gniazdko.close();
			} 
			catch (IOException e) 
			{
				System.err.println("Wyjatek IOException:  " + e);
				e.printStackTrace();
			}
		}
	}
}