SwTc - CTS

In laborator:

1. Deschideti proiectul numit picture.

2. Vizualizati codul sursa al clasei Picture, fie double-click pe , fie right-click, Open Editor.

3. Care este numele clasei? Gasiti instructiunea care defineste numele clasei.

4. Gasiti campurile pentru soare si partile componente ale casei. Observati cum sunt declarate.

In laborator:

1. Gasiti codul metodei a carei declaratie (semnatura) este public void draw().

2. Care sunt sarcinile elementare (instructiunile de tip apel) indeplinite pentru a crea zidul?

3. Conteaza ordinea in care sunt efectuate aceste sarcini?

In laborator:

1. Vizualizati codul sursa al clasei Square. Gasiti semnaturile metodelor invocate in metoda draw() a clasei Picture. Care sunt sarcinile indeplinite de codurile acestor metode?

2.3. Utilizarea firelor de executie (threads) in Java

2.3.1. Modalitati de a crea un fir de executie

Programele de calcul simple sunt secventiale, fiecare avand un inceput, o secventa de executii si un sfarsit. In orice moment pe durata executiei unui astfel de program exista un singur punct de executie.

Un fir de executie (thread), sau mai simplu, un fir, este similar acestor programe secventiale, in sensul ca are un inceput, o secventa de executii si un sfarsit, si in orice moment pe durata executiei firului exista un singur punct de executie.

Totusi, un fir nu este el insusi un program, deoarece nu poate fi executat de sine statator. In schimb, firul este executat (ruleaza) intr-un program. Posibilitatea utilizarii mai multor fire de executie intr-un singur program, ruland (fiind executate) in acelasi timp si realizand diferite sarcini (nu in mod necesar diferite), este numita multithreading.

Pentru a crea un nou fir de executie exista doua modalitati.

1. Se poate declara o clasa ca subclasa a clasei Thread, subclasa care trebuie sa rescrie codul (override) metodei run() a clasei Thread (care nu contine nici un cod), noul fir de executie fiind creat prin alocarea si lansarea unei instante a subclasei.

Formatul pentru crearea unei subclase care extinde clasa Thread si ii reimplementeaza metoda run() este urmatorul:

     class FirT extends Thread {

        public void run() {

                              // codul firului de executie

Formatul pentru crearea unei instante a subclasei este urmatorul:

       FirT fir = new FirT();

2. Se poate declara o clasa care implementeaza interfata Runnable, interfata care contine doar declaratia unei metode run() (declaratie identical celei din clasa Thread, deoarece clasa Thread implementeaza interfata Runnable), noul fir de executie fiind creat prin alocarea unei instante a noii clase, pasarea acestei instante ca parametru al constructorului, la crearea unei instante a clasei Thread, si lansarea acelei instante a clasei Thread.

Formatul pentru crearea unei clase care implementeaza interfata Runnable si ii implementeaza metoda run() este urmatorul:

     class FirR implements Runnable {

        public void run() {

                              // codul firului de executie

Formatul pentru crearea unei instante a noii clase si apoi a unei instante a clasei Thread este urmatorul:

       FirR r = new FirR();

       Thread fir = new Thread(r);

In ambele cazuri formatul pentru lansarea noului fir de executie, este urmatorul:

      fir.start();

Variante compacte pentru crearea si lansarea noilor fire de executie:

       new FirT().start();                   // nu exista variabila de tip FirT

                                             // care sa refere explicit firul

       FirR r = new FirR();                  // nu exista variabila de tip Thread

       new Thread(r).start();                // care sa refere explicit firul

       Thread fir = new Thread(new FirR());  // nu exista variabila de tip FirR

       fir.start();                          // care sa refere explicit firul

       new Thread(new FirR()).start();       // nu exista variabila de tip Thread

                                             // si nici variabila de tip FirR

                                             // care sa refere explicit firul

2.3.2. Programe de lucru cu fire de executie

Urmatorul program va fi folosit pentru a ilustra lucrul cu fire de executie. Clasa FirSimplu extinde clasa Thread, iar metoda principala lanseaza metoda run() ca nou fir de executie.

public class FirSimplu extends Thread { // obiectele din clasa curenta sunt thread-uri

public FirSimplu(String str) {

super(str); // invocarea constructorului Thread(String)

} // al superclasei Thread

public void run() { // “metoda principala” a thread-ului curent

for (int i = 0; i < 5; i++) {

System.out.println(i + " " + getName()); // obtinerea numelui thread-ului

try {

sleep((long)(Math.random() * 1000)); // thread-ul “doarme” 0...1 secunda

} catch (InterruptedException e) {}

}

System.out.println("Gata! " + getName()); // obtinerea numelui thread-ului

}

public static void main (String[] args) {

new FirSimplu("Unu").start(); // “lansarea” thread-ului (apeleaza run())

}

Rezultatul executiei programului:

Clasa DemoDouaFire lanseaza doua fire de executie de tip FirSimplu executate concurent.

public class DemoDouaFire {

public static void main (String[] args) {

new FirSimplu("Unu").start(); // “lansarea” primului thread

new FirSimplu("Doi").start(); // “lansarea” celui de-al doilea thread

}

Firele au evolutii diferite, in functie de durata intarzierii introdusa in linia de cod:

sleep((long)(Math.random() * 1000));

a programului FirSimplu.

In laborator:

1. Lansati mediul BlueJ. Inchideti proiectele anterioare (Ctrl+W). Creati un nou proiect fire

(Project -> New Project…, selectati D:/, apoi SwTc2007, apoi numarul grupei, si scrieti fire).

2. Creati o noua clasa, numita FirSimplu, folosind codul dat mai sus.

3. Tot in proiectul fire creati clasa DemoDouaFire folosind codul de mai sus. Compilati clasele.

4. Right-click pe clasa, selectati si executati main(). Urmariti efectul in Terminal Window.

Rezultatele a doua executii succesive:

Doua variante (aplicatie de sine statatoare si applet) de program "ceas" bazat pe threads:

import java.util.*;

import java.text.DateFormat;

import java.io.*;

public class CeasConsola implements Runnable

{

private Thread firCeas = null;

private static int contor = 0;

public void start() { // (re)pornire fir

if (firCeas == null) {

firCeas = new Thread(this);

firCeas.start(); // apeleaza run()

}

System.out.println("Ceas pornit");

}

public void run() { // executie fir

Thread firulMeu = Thread.currentThread();

contor++;

while (firCeas == firulMeu) {

Calendar cal = Calendar.getInstance();

Date date = cal.getTime();

DateFormat df = DateFormat.getTimeInstance();

System.out.println("[" + contor + "] " +

df.format(date));

try { Thread.sleep(1000); }

catch (InterruptedException e){ }

}

public void stop() { // oprire fir

System.out.println("Ceas oprit");

firCeas = null; // firul dispare

}

public static void main(String[] args)

throws IOException {

CeasConsola ceas;

BufferedReader in = new BufferedReader

(new InputStreamReader(System.in));

while (true) {

ceas = new CeasConsola();

ceas.start(); // (re)pornire fir la citirea

in.readLine(); // unui caracter de la consola

ceas.stop(); // oprire fir la citirea

in.readLine(); // unui caracter de la consola

}

import java.applet.Applet;

import java.awt.*;

import java.util.*;

import java.text.DateFormat;

public class CeasApplet extends Applet

implements Runnable {

private Thread firCeas = null;

private static int contor = 0;

public void init() { setBackground(Color.white); }

public void start() { // (re)pornire fir

if (firCeas == null) {

firCeas = new Thread(this, "Ceas");

firCeas.start(); // apeleaza run()

}

public void run() { // executie fir

Thread firulMeu = Thread.currentThread();

contor++;

while (firCeas == firulMeu) {

repaint(); // apeleaza paint() (redeseneaza)

try { Thread.sleep(1000); }

catch (InterruptedException e){ }

}

public void paint(Graphics g) { // deseneaza

Calendar cal = Calendar.getInstance();

Date date = cal.getTime();

DateFormat df = DateFormat.getTimeInstance();

g.drawString("[" + contor + "] " +

df.format(date), 5, 10);

}

public void stop(){ // oprire fir

firCeas = null; // firul dispare

}

// Applet-ul nu are metoda principala.

// Metodele start(), stop(), run(), etc. sunt invocate

// de Browserul Web in care este “executat”.

/* Exemplu de includere intr-o pagina Web:

    <HTML>

         <TITLE>

              Applet Ceas

         </TITLE>

         <BODY>

              <APPLET CODE=CeasApplet.class

                     WIDTH=200 HEIGHT=50>

              </APPLET>

         </BODY>

    </HTML>     */

Varianta applet (miniaplicatie) Java CeasApplet:

Ceas

In laborator: Testati applet-ul CeasApplet folosind link-ul de mai sus.

2.4. Introducere in socket-uri Java

2.4.1. Utilizarea clasei java.net.InetAddress

Clasa InetAddress incapsuleaza o adresa IP intr-un obiect care poate intoarce informatia utila. Aceasta informatie utila se obtine invocand metodele unui obiect al acestei clase. De exemplu, equals() intoarce adevarat daca doua obiecte reprezinta aceeasi adresa IP.

Clasa InetAddress nu are constructor public. De aceea, pentru a crea obiecte ale acestei clase trebuie invocata una dintre metodele de clasa getByAddress() si getByName().

O adresa IP speciala este adresa IP loopback (tot ce este trimis catre aceasta adresa IP se intoarce si devine intrare IP pentru gazda locala), cu ajutorul careia pot fi testate local programe care utilizeaza socket-uri. Pentru a identifica adresa IP loopback sunt folosite numele "localhost" si valoarea numerica "127.0.0.1".

Pentru a obtine InetAddress care incapsuleaza adresa IP loopback pot fi folosite apelurile:

InetAddress.getByName(null)

InetAddress.getByName("localhost")

InetAddress.getByName("127.0.0.1")

2.4.2. Socket-uri flux (TCP) Java

Java ofera, in pachetul java.net, mai multe clase pentru lucrul cu socket-uri flux (TCP). Urmatoarele clase Java sunt implicate in realizarea conexiunilor TCP obisnuite: ServerSocket, Socket.

Clasa ServerSocket reprezinta socket-ul (aflat eventual pe un server bazat pe TCP) care asteapta si accepta cereri de conexiune (eventual de la un client bazat pe TCP).

Clasa Socket reprezinta punctul terminal al unei conexiuni TCP intre doua masini (eventual un client si un server).

Clientul (sau, mai general, masina conector) creeaza un punct terminal Socket in momentul in care cererea sa de conexiune este lansata si acceptata.

Serverul (sau, mai general, masina acceptor) creeaza un Socket in momentul in care primeste si accepta o cerere de conexiune, si continua sa asculte si sa astepte alte cereri pe ServerSocket.

Secventa tipica a mesajelor schimbate intre client si server este urmatoarea:

Odata conexiunea stabilita, metodele getInputStream() si getOutputSteam() ale clasei Socket trebuie utilizate pentru a obtine fluxuri de octeti, de intrare respectiv iesire, pentru comunicatia intre aplicatii.

2.4.3. Utilizarea clasei Socket

Secventa tipica pentru crearea socket-ului unei aplicatii conector (client):

// Stabilirea adresei serverului

String adresaServer = "localhost";

// Stabilirea portului serverului

int portServer = 2000;

// Crearea socketului (implicit este realizata conexiunea cu serverul)

Socket socketTCPClient = new Socket(adresaServer, portServer);

Dupa utilizare, socket-ul este inchis. Secventa tipica pentru inchiderea socket-ului:

1 2	*// Inchiderea socketului (implicit a fluxurilor TCP)* socketTCPClient.close();

Crearea unui socket pentru aplicatii conector/client si afisarea informatiilor privind socketul:

import java.net.*; // pachetul claselor de biblioteca pentru socketuri

import java.io.*; // pachetul claselor de biblioteca pentru intrare-iesire

public class InfoSocketTCP { // Afiseaza info. privind conexiunea TCP creata

public static void main (String args[]) {

BufferedReader inConsola = new BufferedReader(new

InputStreamReader(System.in));

String adresaIP = null;

int numarPort = 0;

Socket conexiuneTCP;

try {

System.out.print("Introduceti adresa IP dorita: ");

adresaIP = inConsola.readLine();

System.out.print("Introduceti numarul de port dorit: ");

numarPort = Integer.parseInt(inConsola.readLine());

conexiuneTCP = new Socket(adresaIP, numarPort); // creare socket

afisareInfoSocketTCP(conexiuneTCP); // afisare info socket

conexiuneTCP.close(); // inchidere socket

}

catch (NumberFormatException ex) { // eroare numar port

System.err.println("Numarul de port nu are format intreg");

}

catch (UnknownHostException ex) { // eroare DNS

System.err.println("Nu poate fi gasita adresa " + adresaIP);

}

catch (SocketException ex) { // eroare conectare

System.err.println("Nu se conecteaza la " + adresaIP + ":" + numarPort);

}

catch (IOException ex) {

System.err.println(ex);

}

// Afiseaza informatii privind socketul TCP primit ca parametru

public static void afisareInfoSocketTCP (Socket socketTCP) {

System.out.println("\nConexiune de la adresa "+socketTCP.getLocalAddress()

+ " de pe portul " + socketTCP.getLocalPort()

+ " catre adresa " + socketTCP.getInetAddress()

+ " pe portul " + socketTCP.getPort() + "\n");

}

In laborator:

1. Lansati mediul BlueJ. Inchideti proiectele anterioare (Ctrl+W). Creati un nou proiect socket

(Project->New Project…, selectati D:/, SwTc2007, numarul grupei, si scrieti socket).

2. Creati o noua clasa, numita InfoSocketTCP, folosind codul dat mai sus. Compilati codul.

3. Right-click pe clasa, selectati si executati main().

4. Folositi adresa localhost si numarul de port 3000. Urmariti efectul in Terminal Window.

5. Folositi apoi adresa www.google.com si numarul de port 7. Folositi si alte adrese.

Observatie: Cat timp bara de stare a executiei este activa () codul nu poate fi recompilat, nu poate fi inchisa fereastra Terminal Window, etc.

Pentru a opri executia, folositi right click pe si selectati Reset Machine (sau folositi direct Ctrl+Shift+Tab).

2.4.4. Utilizarea clasei ServerSocket

Secventa tipica pentru crearea socket-ului server al unei aplicatii acceptor (server):

// Stabilirea portului serverului

int portServer = 2000;

// Crearea socketului server (care accepta conexiunile)

ServerSocket serverTCP = new ServerSocket(portServer);

Secventa tipica pentru crearea socket-ului pentru tratarea conexiunii TCP cu un client:

// Blocare in asteptarea cererii de conexiune - in momentul acceptarii

// cererii se creaza socketul care serveste conexiunea

Socket conexiuneTCP = serverTCP.accept();

Un caz special este acela in care se creaza un socket server fara a se preciza portul pe care asculta serverul. In acest caz, este alocat un numar de port aleator (unul dintre cele neocupate in acel moment). Acest lucru se realizeaza prin pasarea valorii 0 constructorului ServerSocket().

Program pentru crearea unui socket server cu numar de port alocat aleator.

import java.net.*;

import java.io.*;

public class InfoPortTCPAleator {

public static void main (String args[]) {

try { ServerSocket serverTCP = new ServerSocket(0);

System.out.println("\nServer pe portul " + serverTCP.getLocalPort());

serverTCP.close();

}

catch (IOException ex) { System.err.println(ex); }

}

2.5. Programe de lucru cu socket-uri – clienti si servere

2.5.1. Server ecou TCP care poate trata doar un client (single threaded)

Secventa tipica pentru crearea fluxurilor de octeti asociate socket-ului:

// Obtinerea fluxului de intrare octeti TCP

InputStream inTCP = socketTCPClient.getInputStream();

// Obtinerea fluxului de intrare caractere dinspre retea

InputStreamReader inTCPCaractere = new InputStreamReader(inTCP);

// Adaugarea facilitatilor de stocare temporara

BufferedReader inRetea = new BufferedReader(inTCPCaractere);

// Obtinerea fluxului de iesire octeti TCP

OutputStream outTCP = socketTCPClient.getOutputStream();

// Obtinerea fluxului de iesire spre retea,

// cu facilitate de afisare (similare consolei standard de iesire)

PrintStream outRetea = new PrintStream(outTCP);

Secventa tipica pentru trimiterea de date:

// Crearea unui mesaj

String mesajDeTrimis = "Continut mesaj";

// Scrierea catre retea (trimiterea mesajului)

outRetea.println(mesajDeTrimis);

// Fortarea trimiterii

outRetea.flush();

Secventa tipica pentru primirea de date:

// Citirea dinspre retea (receptia unui mesaj)

String mesajPrimit = inRetea.readLine();

// Afisarea mesajului primit

System.out.println(mesajPrimit);

Program server ecou TCP care raspunde mai multor mesaje trimise succesiv, mesajul format dintr-un punct (".") semnaland serverului terminarea mesajelor de trimis (clientul urmand sa isi termine executia):

import java.net.*;

import java.io.*;

import javax.swing.JOptionPane;

public class ServerEcouFluxRepetiv { // Server ecou flux

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

int portServer = Integer.parseInt(JOptionPane.showInputDialog(

"Introduceti numarul de port dorit: "));

// Crearea socketului server (care accepta conexiunile)

ServerSocket serverTCP = new ServerSocket(portServer);

System.out.println("Server in asteptare pe portul "+portServer+"...");

// Blocare in asteptarea cererii de conexiune - in momentul acceptarii

// cererii se creaza socketul care serveste conexiunea

Socket conexiuneTCP = serverTCP.accept();

System.out.println("Conexiune TCP pe portul " + portServer + "...");

// Crearea fluxurilor de caractere conectate la fluxurile de octeti

// obtinute de la socketul TCP

PrintStream outRetea = new PrintStream(conexiuneTCP.getOutputStream());

BufferedReader inRetea = new BufferedReader(

new InputStreamReader(conexiuneTCP.getInputStream()));

while (true) {

// Citirea unei linii din fluxul de intrare TCP

String mesajPrimit = inRetea.readLine();

// Afisarea liniei citite la consola de iesire

System.out.println("Mesaj primit: " + mesajPrimit);

// Scrierea liniei in fluxul de iesire TCP, cu fortarea trimiterii

outRetea.println(mesajPrimit);

outRetea.flush();

// Testarea conditiei de oprire a servirii

if (mesajPrimit.equals(".")) break;

}

// Inchiderea socketului (si implicit a fluxurilor)

conexiuneTCP.close();

System.out.println("Bye!");

}

In laborator:

1. In acelasi proiect (socket) creati o clasa numita ServerEcouFluxRepetiv folosind codul dat.

2. Compilati codul, apoi right-click pe clasa, selectati si executati main().

3. Folositi numarul de port 4000. Urmariti efectul in Terminal Window.

Nu uitati: Pentru a opri executia, right click pe si Reset Machine (sau Ctrl+Shift+Tab).

2.5.2. Client ecou TCP

Cu ajutorul unui client potrivit putem testa serverul ecou TCP.

Program client pentru serverul ecou TCP anterior (care raspunde mai multor mesaje trimise succesiv):

import java.net.*;

import java.io.*;

import javax.swing.JOptionPane;

public class ClientEcouFluxRepetitiv { // Client pentru server ecou flux

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

String adresaServer = JOptionPane.showInputDialog(

"Introduceti adresa IP a serverului: ");

int portServer = Integer.parseInt(JOptionPane.showInputDialog(

"Introduceti numarul de port al serverului: "));

Socket conexiuneTCP = new Socket(adresaServer, portServer); // Creare socket

System.out.println("Conexiune TCP cu serverul " + adresaServer +

":" + portServer + "...");

System.out.println("Pentru oprire introduceti '.' si <Enter>");

PrintStream outRetea = new

PrintStream(conexiuneTCP.getOutputStream()); // Creare fluxuri

BufferedReader inRetea = new BufferedReader(

new InputStreamReader(conexiuneTCP.getInputStream()));

while (true) { // Cat timp conditia de oprire nu este indeplinita

String mesajTrimis = JOptionPane.showInputDialog("Se trimite: "); // Mesaj

outRetea.println(mesajTrimis); // Scrierea in fluxul de iesire TCP

outRetea.flush();

String mesajPrimit = inRetea.readLine(); // Citirea din fluxul de intrare TCP

JOptionPane.showMessageDialog(null, "S-a primit: " + mesajPrimit); // Afisare

System.out.println("S-a primit: " + mesajPrimit); // Afisarea la consola

if (mesajPrimit.equals(".")) break; // Testarea conditiei de oprire

}

conexiuneTCP.close(); // Inchiderea socketului (si implicit a fluxurilor)

System.out.println("Bye!");

}

In laborator:

1. In proiectul socket creati o clasa ClientEcouFluxRepetitiv cu codul dat. Compilati codul.

2. Right-click pe clasa, executati main(). Folositi adresa localhost si portul 4000. Ce observati?

In laborator:

1. La unul dintre calculatoare right-click pe clasa ServerEcouFluxRepetiv.

2. Selectati si executati main(). Folositi numarul de port 4000.

3. La un alt calculator right-click pe clasa ClientEcouFluxRepetitiv, selectati si executati main().

4. Folositi adresa primului calculator (cel pe care se executa ServerEcouFluxRepetiv)

si numarul de port 4000. Urmariti efectul in Terminal Window pe cele doua calculatoare.

In laborator (codul complet este parte din tema de casa!):

1. Pornind de la codul ServerEcouFluxRepetiv sa se creeze o clasa ServerRepetiv care sa afiseze mesajele primite de la client si sa astepte un utilizator uman sa furnizeze mesajul de raspuns catre client. Sa se compileze si testeze codul folosind un calculator pentru server si unul pentru client.

2.5.3. Server ecou TCP care trateaza mai multi clienti succesiv (single threaded)

Serverul ecou TCP poate fi transformat astfel incat sa poata trata mai multi clienti (de exemplu, ClientEcouFluxRepetitiv) succesiv.

Program server ecou TCP care poate trata mai multi clienti (ClientEcouFluxRepetitiv) succesiv.

import java.net.*;

import java.io.*;

import javax.swing.JOptionPane;

public class ServerEcouFluxRepetivSecvential {

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

int portServer = Integer.parseInt(JOptionPane.showInputDialog(

"Introduceti numarul de port al serverului: "));

// Crearea socketului server (care accepta conexiunile)

ServerSocket serverTCP = new ServerSocket(portServer);

// Servirea mai multor clienti succesivi (in mod secvential)

while (true) {

System.out.println("Server in asteptare pe port "+portServer+"...");

// Blocare in asteptarea cererii de conexiune - in momentul

// acceptarii cererii se creaza socketul care serveste conexiunea

Socket conexiuneTCP = serverTCP.accept();

System.out.println("Conexiune TCP pe portul " + portServer + "...");

// Crearea fluxurilor de caractere conectate la fluxurile de octeti

// obtinute de la socketul TCP

PrintStream outRetea = new

PrintStream(conexiuneTCP.getOutputStream());

BufferedReader inRetea = new BufferedReader(

new InputStreamReader(conexiuneTCP.getInputStream()));

// Servirea clientului curent

while (true) {

// Citirea unei linii din fluxul de intrare TCP

String mesajPrimit = inRetea.readLine();

// Afisarea liniei citite la consola de iesire

System.out.println("Mesaj primit: " + mesajPrimit);

// Scrierea liniei in fluxul de iesire TCP, cu fortarea trimiterii

outRetea.println(mesajPrimit);

outRetea.flush();

// Testarea conditiei de oprire a servirii

if (mesajPrimit.equals(".")) break;

}

// Inchiderea socketului (si implicit a fluxurilor)

conexiuneTCP.close();

System.out.println("Bye!");

}

In laborator:

1. In acelasi proiect (socket) creati o clasa ServerEcouFluxRepetivSecvential cu codul dat.

2. Compilati codul.

In laborator:

1. La unul dintre calculatoare right-click pe clasa ServerEcouFluxRepetivSecvential.

2. Selectati si executati main(). Folositi numarul de port 4000.

3. La un alt calculator right-click pe clasa ClientEcouFluxRepetitiv, selectati si executati main().

4. Folositi adresa primului calculator (cel pe care se executa ServerEcouFluxRepetivSecvential)

si numarul de port 4000. Urmariti efectul in Terminal Window pe cele doua calculatoare.

5. Pastrand serverul deschis repetati operatia cu clienti de pe diverse calculatoare.

2.5.4. Server ecou TCP care trateaza mai multi clienti succesiv (single threaded)

Serverul ecou TCP poate fi transformat astfel incat sa poata trata mai multi clienti in acelasi timp (concurent).

In cazul serverelor care pot trata mai multi clienti in mod concurent (in paralel), codul necesar pentru stabilirea conexiunilor cu clientii ce urmeaza a fi tratati de obiecte fir de executie (a caror clasa este numita generic ClasaFiruluiDeTratare) este urmatorul:

// initializare portServer

// Crearea socketului server (care accepta conexiunile)

ServerSocket serverTCP = new ServerSocket(portServer);

// Servirea mai multor clienti in paralel (in mod concurent)

while (true) {

// Blocare in asteptarea cererii de conexiune

Socket conexiuneTCP = serverTCP.accept();

// Crearea si lansarea firului de executie pentru tratarea noului client

ClasaFiruluiDeTratare firExecutie = new ClasaFiruluiDeTratare(conexiuneTCP);

firExecutie.start();

} // Gata pentru a accepta urmatorul client

Codul necesar pentru comunicatia cu un client (care se va afla in clasa din care se vor crea obiecte fir de executie, numita generic ClasaFiruluiDeTratare) este urmatorul:

Socket socketTCP; // Atribut

public ClasaFiruluiDeTratare(Socket s) { // Constructor

socketTCP = s; // Initializarea atributului

}

public void run() { // Implementarea firului de executie

// Crearea fluxurilor conectate la fluxurile obtinute de la socketul TCP

PrintStream out = new PrintStream(conexiuneTCP.getOutputStream());

BufferedReader in = new BufferedReader(

new InputStreamReader(conexiuneTCP.getInputStream()));

// Tratarea clientului curent

while (true) {

// Citiri din fluxul de intrare TCP cu in.readLine();

// Scrieri in fluxul de iesire TCP cu out.println(); out.flush();

} // Incheierea tratarii clientului

// Inchiderea socketului

conexiuneTCP.close();

}

O varianta mai simpla poate fi utilizarea unei singure clase, care sa extinda clasa Thread, si:

- in metoda main() sa implementeze stabilirea conexiunilor cu clientii

- in metoda run() sa implementeze codul necesar pentru comunicatia cu un client.

Exemplu de server ecou care poate trata mesaje sosite de la mai multi clienti in paralel:

import java.net.*;

import java.io.*;

import javax.swing.JOptionPane;

public class ServerEcouFluxRepetivConcurent extends Thread {

private Socket conexiuneTCP;

public ServerEcouFluxRepetivConcurent(Socket socketTCP) {

conexiuneTCP = socketTCP;

}

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

int portServer = Integer.parseInt(JOptionPane.showInputDialog(

"Introduceti numarul de port al serverului: "));

// Crearea socketului server (care accepta conexiunile)

ServerSocket serverTCP = new ServerSocket(portServer);

System.out.println("Server in asteptare pe portul "+portServer+"...");

// Servirea mai multor clienti in acelasi timp (in mod concurent)

while (true) {

// Blocare in asteptarea cererii de conexiune - in momentul

// acceptarii cererii se creaza socketul care serveste conexiunea

Socket socketTCP = serverTCP.accept();

System.out.println("Conexiune TCP pe portul " + portServer + "...");

new ServerEcouFluxRepetivConcurent(socketTCP).start(); // run()

}

public void run() { // Fir de servire client

try {

// Crearea fluxurilor de caractere conectate la fluxurile de octeti

// obtinute de la socketul TCP

PrintStream outRetea = new

PrintStream(conexiuneTCP.getOutputStream());

BufferedReader inRetea = new BufferedReader(

new InputStreamReader(conexiuneTCP.getInputStream()));

// Servirea clientului curent

while (true) {

// Citirea unei linii din fluxul de intrare TCP

String mesajPrimit = inRetea.readLine();

// Afisarea liniei citite la consola de iesire

System.out.println("Mesaj primit: " + mesajPrimit);

// Scrierea liniei in fluxul de iesire TCP, cu fortarea trimiterii

outRetea.println(mesajPrimit);

outRetea.flush();

// Testarea conditiei de oprire a servirii

if (mesajPrimit.equals(".")) break;

}

// Inchiderea socketului (si implicit a fluxurilor)

conexiuneTCP.close();

System.out.println("Bye!");

}

catch (IOException ex) {

System.err.println(ex);

}

In laborator:

1. In acelasi proiect (socket) creati o clasa ServerEcouFluxRepetivConcurent cu codul dat.

2. Compilati codul.

In laborator:

1. La unul dintre calculatoare right-click pe clasa ServerEcouFluxRepetivConcurent.

2. Selectati si executati main(). Folositi numarul de port 5000.

3. La un alt calculator right-click pe clasa ClientEcouFluxRepetitiv, selectati si executati main().

4. Folositi adresa primului calculator (cel pe care se executa ServerEcouFluxRepetivConcurent)

si numarul de port 5000. Urmariti efectul in Terminal Window pe cele doua calculatoare.

5. Pastrand serverul deschis lansati si utilizati si alti clienti de pe diverse calculatoare.

2.6. Teme pentru acasa

I. Codul final al clasei ServerRepetiv (cerut in paragraful 2.5.2).

II. O varianta a clasei ServerRepetiv, numita ServerRepetivClientiSuccesivi, care permite tratarea mai multor clienti unul dupa altul.

Codurile vor fi predate sub forma de listing sau scrise de mana!

Categorie	Tip	Valoare implicita	Spatiu memorie	Gama valori	Conversii explicite (cast, trunchiere)	Conversii implicite (extindere)
Valori intregi cu semn	byte	0	8 biti (1B)	-128 … 127	La char	La short, int, long, float, double
	short	0	16 biti (2B)	-32768 … 32767	La byte, char	La int, long, float, double
	int	0	32 biti (4B)	-2147483648 … 2147483647	La byte, short, char	La long, float, double
	long	0l	64 biti (8B)	-9223372036854775808 …9223372036854775807	La byte, short, int, char	La float, double
Valori in virgula mobile cu semn	float	0.0f	32 biti (4B)	+/-1.4E-45 … +/-3.4028235E+38, +/-infinity, +/-0, NAN	La byte, short, int, long, char	La double
Valori in virgula mobile cu semn	double	0.0	64 biti (8B)	+/-4.9E-324 … +/-1.8+308, +/-infinity, +/-0, NaN	La byte, short, int, long, float, char	Nu exista (nu sunt necesare)
Caractere codificate UNICODE	char	\u0000 (null)	16 biti (2B)	\u0000 … \uFFFF	La byte, short	La int, long, float, double
Valori logice	boolean	`false`	1 bit folosit din 32 biti	true, false	Nu exista (nu sunt posibile)	Nu exista (nu sunt posibile)

Laborator 2

Introducere in programarea orientate spre obiecte (OO). Fire de executie (threads) si socket-uri flux (TCP) in Java

2.1. Descrierea laboratorului

2.2. Obiecte si clase (Java)

2.2.1. Definitii

2.2.2. Crearea obiectelor

2.2.3. Apelul (invocarea) metodelor

2.2.4. Parametrii metodelor

2.2.5. Tipuri de date

2.2.6. Starea unui obiect

2.2.7. Comportamentul unui obiect

2.2.8. Interactiunea (colaborarea) obiectelor

2.2.9. Codul sursa Java. Editarea si compilarea cu BlueJ

2.3. Utilizarea firelor de executie (threads) in Java

2.3.1. Modalitati de a crea un fir de executie

2.3.2. Programe de lucru cu fire de executie

2.4. Introducere in socket-uri Java

2.4.1. Utilizarea clasei java.net.InetAddress

2.4.2. Socket-uri flux (TCP) Java

2.4.3. Utilizarea clasei Socket

2.4.4. Utilizarea clasei ServerSocket

2.5. Programe de lucru cu socket-uri – clienti si servere

2.5.1. Server ecou TCP care poate trata doar un client (single threaded)

2.5.2. Client ecou TCP

2.5.3. Server ecou TCP care trateaza mai multi clienti succesiv (single threaded)

2.5.4. Server ecou TCP care trateaza mai multi clienti succesiv (single threaded)

2.6. Teme pentru acasa