Universitatea Transilvania din Brasov Facultatea de Matematic˘a ...

Universitatea Transilvania din Bra¸sov 

Facultatea de Matematică–Informatică 

Catedra de Informatică Teoretică 

ERNEST SCHEIBER 

PROGRAMARE DISTRIBUITĂ ÎN 

JAVA 

Bra¸sov

Introducere 

Ret¸elele locale, internetul, răspândirea pe o arie geografică a resurselor ¸si a 

locat¸iilor în care se petrec act¸iuni ce t¸in de o activitate bine definită sau sunt 

urmărite, gestionate din alte locuri au drept consecint¸ă existent¸a aplicat¸iilor 

distribuite. Termenul distribuit se referă tocmai la faptul că componente ale 

aplicat¸iei se află pe calculatoare diferite dar între care au loc schimburi de date. 

Dacă părt¸ile unei aplicat¸ii sau resursele utilizate se găsesc pe calculatoare distincte 

atunci aplicat¸ia se nume¸ste distribuită. 

Între părt¸ile sau resursele unei aplicat¸ii distribuite au loc schimburi de date, 

ceea ce se face utilizând diferite mecanisme la realizarea cărora concură sistemul 

de calcul, sistemul de operare ¸si limbajul de programare. 

Astfel se vorbe¸ste de programare distribuită ca mijloc de realizare a aplicat¸iilor 

distribuite. Pe lângă algoritm, structuri de date, limbaj de programare, la realizarea 

unei aplicat¸ii distribuite intervin comunicat¸iile: schimbul de date dintre 

două componente aflate pe calculatoare diferite. 

Punem în evident¸ă două modele de aplicat¸ii distribuite: 

• client-server: Programul server execută cererile client¸ilor. Amintim următoarele 

tehnologii Java pentru realizarea aplicat¸iilor client-server: 

– RMI (Remote Method Invocation) 

– CORBA (Common Object Request Brocker Arhitecture) 

– JMS (Java Message Service) 

– Servlet ¸si JSP (Java Server Pages) 

– Portlet 

• dispecer-lucrător: Programul dispecer distribuie sarcinile de executat 

lucrătorilor ¸si le coordonează activitatea. Pentru programarea unei aplicat¸ii 

bazată pe modelul dispecer-lucrător se poate utiliza 

– un soft ce implementează una din interfet¸ele: 

∗ PVM (Parallel Virtual Machine) 

∗ MPI (Message Passing Interface) 

3

4 

∗ BSP (Bulk Synchronous Parallel) 

– produse bazate pe modelul Linda: 

∗ TSpaces 

∗ JavaSpaces cont¸inut în jini. 

– Alte abordări: 

∗ Java Parallel Distribute Framework (JPPF); 

∗ Terracotta; 

∗ ProActive. 

Lista opt¸iunilor este departe de a fi completă. 

Scopul acestui curs este prezentarea tehnologiilor de programare Java care 

permit programarea aplicat¸iilor client - server: 

• socluri Java; 

• apelarea metodelor de la distant¸ă (Remote Method Invocation - RMI ); 

• CORBA - Common Object Request Brocker Arhitecture; 

• mesageria Java; 

• servlet; 

• Java Server Pages - JSP; 

• Portlet ¸si Portal. 

Metodele ¸si instrumentele de programare vor fi exemplificate pe problema 

foarte simplă de calcul a celui mai mare divizor comun a două numere naturale. 

Codul metodei de calcul este 

public long cmmdc(long m,long n){ 

long r,c; 

do{ 

c=n; 

r=m%n; 

m=n; 

n=r; 

} 

while(r!=0); 

return c; 

} 

Pentru aplicat¸iile care utilizează o bază de date, sistemul de gestiune a bazei 

de date (SGBD) va fi una dintre sistemele Derby, mysql sau postgresql.

Cuprins 

1 Miniaplicat¸ie (applet) 9 

1.1 Applet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11 

2 Programare cu socluri Java 15 

2.1 Aplicat¸ii client – server . . . . . . . . . . . . . . . . . . . . . . . . . 15 

2.2 Not¸iuni despre ret¸ele . . . . . . . . . . . . . . . . . . . . . . . . . . 16 

2.3 Soclu TCP . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16 

2.3.1 Clasa Socket . . . . . . . . . . . . . . . . . . . . . . . . . . 17 

2.3.2 Clasa ServerSocket . . . . . . . . . . . . . . . . . . . . . . 17 

2.4 Aplicat¸ie client – server cu socluri . . . . . . . . . . . . . . . . . . 18 

2.5 Datagrame . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21 

2.5.1 Clasa DatagramPacket. . . . . . . . . . . . . . . . . . . . . 22 

2.5.2 Clasa DatagramSocket . . . . . . . . . . . . . . . . . . . . . 23 

2.5.3 Clasa InetAddress . . . . . . . . . . . . . . . . . . . . . . . 25 

2.5.4 Aplicat¸ii client – server cu datagrame. . . . . . . . . . . . . 27 

2.5.5 Multicast vs. Broadcast . . . . . . . . . . . . . . . . . . . . 30 

2.6 Canale de comunicat¸ie . . . . . . . . . . . . . . . . . . . . . . . . . 33 

2.6.1 Clasa Buffer . . . . . . . . . . . . . . . . . . . . . . . . . . 33 

2.6.2 Clasa ByteBuffer . . . . . . . . . . . . . . . . . . . . . . . 34 

2.6.3 Clasa InetSocketAddress . . . . . . . . . . . . . . . . . . . 35 

2.6.4 Clasa ServerSocketChannel . . . . . . . . . . . . . . . . . 35 

2.6.5 Clasa SocketChannel . . . . . . . . . . . . . . . . . . . . . 36 

2.7 Conexiuni HTTP . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38 

3 Programare distribuită cu RMI 41 

3.1 Structura RMI . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41 

3.2 Crearea unei aplicat¸ii RMI . . . . . . . . . . . . . . . . . . . . . . . 44 

3.3 Tipare de programare . . . . . . . . . . . . . . . . . . . . . . . . . 48 

3.3.1 Fabrica de obiecte . . . . . . . . . . . . . . . . . . . . . . . 48 

3.3.2 Apeluri inverse – Callback . . . . . . . . . . . . . . . . . . . 51 

3.4 Obiecte activabile la distant¸ă . . . . . . . . . . . . . . . . . . . . . 53 

5

6 CUPRINS 

3.5 RMI ¸si sistemul CORBA . . . . . . . . . . . . . . . . . . . . . . . . 58 

3.6 RMI-IIOP . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59 

3.6.1 Transformarea într-un program RMI-IIOP . . . . . . . . . . 59 

4 Programare distribuită prin CORBA 65 

4.1 Sistemul CORBA . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65 

4.2 Aplicat¸ie Java distribuită prin CORBA . . . . . . . . . . . . . . . 65 

4.2.1 Model cu server temporal . . . . . . . . . . . . . . . . . . . 65 

4.2.2 Model cu server persistent . . . . . . . . . . . . . . . . . . . 69 

5 Mesaje în Java 73 

5.1 Java Message Service (JMS) . . . . . . . . . . . . . . . . . . . . . . 73 

5.2 Sun Java System Message Queue . . . . . . . . . . . . . . . . . . . 74 

5.3 Apache ActiveMQ . . . . . . . . . . . . . . . . . . . . . . . . . . . 75 

5.4 Elemente de programare - JMS . . . . . . . . . . . . . . . . . . . . 76 

5.4.1 Trimiterea unui mesaj . . . . . . . . . . . . . . . . . . . . . 76 

5.4.2 Recept¸ia sincronă a unui mesaj . . . . . . . . . . . . . . . . 81 

5.4.3 Recept¸ia asincronă a unui mesaj . . . . . . . . . . . . . . . 82 

5.4.4 Publicarea mesajelor . . . . . . . . . . . . . . . . . . . . . . 84 

5.4.5 Subscrierea ¸si recept¸ia mesajelor . . . . . . . . . . . . . . . 85 

5.5 Mesaje SOAP prin Java Message Service . . . . . . . . . . . . . . . 87 

5.5.1 SOAP . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 87 

5.5.2 Mesaje SOAP . . . . . . . . . . . . . . . . . . . . . . . . . . 87 

5.5.3 Ata¸samente SOAP . . . . . . . . . . . . . . . . . . . . . . . 94 

6 Servlet 101 

6.1 Marcajul . . . . . . . . . . . . . . . . . . . . . . . . . . . 101 

6.2 Server Web - container de servlet . . . . . . . . . . . . . . . . . . . 103 

6.3 Realizarea unui servlet . . . . . . . . . . . . . . . . . . . . . . . . . 104 

6.3.1 Instalarea unui servlet . . . . . . . . . . . . . . . . . . . . . 104 

6.3.2 Compilarea ¸si apelarea unui servlet . . . . . . . . . . . . . . 106 

6.3.3 Codul unui servlet . . . . . . . . . . . . . . . . . . . . . . . 107 

6.4 Facilităt¸i de programare cu servlet . . . . . . . . . . . . . . . . . . 113 

6.4.1 Program client al unui servlet . . . . . . . . . . . . . . . . . 113 

6.4.2 Servlete înlănt¸uite . . . . . . . . . . . . . . . . . . . . . . . 116 

6.4.3 Sesiune de lucru . . . . . . . . . . . . . . . . . . . . . . . . 117 

6.4.4 Cookie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 119 

6.4.5 Autorizarea accesului prin parola . . . . . . . . . . . . . . . 121 

6.4.6 Servlet cu conexiune la o bază de date . . . . . . . . . . . . 122 

6.4.7 Imagini furnizate de servlet . . . . . . . . . . . . . . . . . . 125 

6.4.8 Servlet cu RMI . . . . . . . . . . . . . . . . . . . . . . . . . 127 

6.5 FileUpload . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 128

CUPRINS 7 

7 Java Server Page – JSP 133 

7.1 Tehnologia JSP . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 133 

7.1.1 Declarat¸ii JSP . . . . . . . . . . . . . . . . . . . . . . . . . 138 

7.1.2 Directive JSP . . . . . . . . . . . . . . . . . . . . . . . . . . 139 

7.1.3 Marcaje JSP predefinite . . . . . . . . . . . . . . . . . . . . 139 

7.1.4 Componentă Java (Java Bean) . . . . . . . . . . . . . . . . 140 

7.1.5 Pagini JSP cu componente Java . . . . . . . . . . . . . . . 141 

7.2 JSP Standard Tag Library JSTL . . . . . . . . . . . . . . . . . . . 144 

7.2.1 Biblioteca de bază . . . . . . . . . . . . . . . . . . . . . . . 145 

7.2.2 Biblioteca de lucru cu baze de date . . . . . . . . . . . . . . 150 

7.3 Marcaje JSP personale . . . . . . . . . . . . . . . . . . . . . . . . . 151 

7.3.1 Marcaje fără atribute ¸si fără corp. . . . . . . . . . . . . . . 151 

7.3.2 Marcaje cu atribute ¸si fără corp. . . . . . . . . . . . . . . . 154 

7.3.3 Marcaje cu corp. . . . . . . . . . . . . . . . . . . . . . . . . 156 

8 Portlet 159 

8.1 Apache-pluto . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 161 

8.2 Portlet container JSR 286 . . . . . . . . . . . . . . . . . . . . . . . 162 

8.3 Dezvoltarea unui portlet . . . . . . . . . . . . . . . . . . . . . . . . 162 

8.4 Elemente de programare . . . . . . . . . . . . . . . . . . . . . . . . 166 

8.5 Produse Portal . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 175 

8.5.1 uPortal . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 176 

8.5.2 Jetspeed-2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . 179 

9 Teme de laborator 181 

9.1 Probleme propuse . . . . . . . . . . . . . . . . . . . . . . . . . . . . 181 

A XML 191 

B Apache-ant 193 

C Utilizarea SGBD în Java 195 

C.1 Derby . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 195 

C.2 mysql . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 196 

C.3 PostgrSQL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 197 

C.4 S¸ablonul de utilizare într-un program Java . . . . . . . . . . . . . . 198 

C.5 Java Persistence API - JPA . . . . . . . . . . . . . . . . . . . . . . 202 

C.5.1 apache-openjpa . . . . . . . . . . . . . . . . . . . . . . . . . 202 

Bibliografie 211

8 CUPRINS

Capitolul 1 

Miniaplicat¸ie (applet) 

O categorie deosebită de programe Java îl reprezintă miniaplicat¸iile (appleturi), 

care se execută prin intermediul unui program de navigare în WWW (World 

Wide Web) – browser. Navigatoarele uzuale de WWW (Firefox, Microsoft Internet 

Explorer, Opera) ¸stiu Java, în sensul că pot executa codul compilat al unui 

applet. 

Astfel, applet-ul este o resursă depusă într-o zona publică, accesibilă prin Internet. 

Un program de navigare preia codul applet-ului ¸si îl execută. Apelarea 

unui applet se face dintr-un fi¸sier html. Acest ansamblu (clasa Java cu documentul 

html de apelare) formează miniaplicat¸ia. 

Datorită acestui mod de folosire, applet-urile au o structură specială ¸si sunt 

supuse la reguli stricte de securitate : nu pot scrie informat¸ii pe calculatorul pe 

care se execută. 

Distribut¸ia jdk (Java Development Kit) cont¸ine un program appletviewer cu 

ajutorul căruia se pot executa pe calculatorul propriu miniaplicat¸iile. Utilizarea 

acestui program este 

appletviewer numeFi¸sier html 

unde numeFi¸sier este fi¸sierul html care apelează applet-ul. 

Elementul applet din HTML 

Un program de navigare în WWW interpretează cont¸inutul (textul) unui fi¸sier 

html (Hyper Text Markup Language) ¸si-l redă. 

Limbajul HTML constă dintr-o colectie de elemente (marcaje, ancore, taguri) 

inserate într-un text ASCII (American Standard Codes for Information Interchange). 

Elementele au rolul de a descrie modul în care va apărea afi¸sat textul, de 

asemenea pot comanda programul de navigare să utilizeze ¸si alte resurse Internet, 

aflate în fi¸siere diferite, în particular codul compilat al unui applet. 

9

10 CAPITOLUL 1. MINIAPLICAT¸ IE (APPLET) 

Sintaxa unui element html este 

 

 

text 

Element ∗ 

Un atribut se scrie sub forma: NumeAtribut = valoare 

Structura unui document html este 

 

 

 

titlul documentului 

 

 

 

corpul documentului 

 

 

 

 

Elementul . Atributele obligatorii ale unui element applet sunt 

• code 

Valoarea atributului este numele clasei applet-ului. 

• width 

Valoarea atributului este lăt¸imea ferestrei atribuită de navigator applet-ului 

la afi¸sarea documentului html. 

• height 

Valoarea atributului este înălt¸imea ferestrei atribuită de navigator appletului 

la afi¸sarea documentului html. 

Atribute opt¸ionale sunt 

• codebase 

Valoarea atributului este adresa URL ( Universal Resource Locator) sau 

calea la fi¸sierul cu clasa applet-ului. În lipsa acestui parametru, căutarea 

clasei are loc în catalogul din care a fost încărcată sursa html. 

• vspace 

Valoarea atributului este lungimea, exprimată în pixeli, care se lasă liberă 

deasupra ¸si dedesuptul ferestrei miniaplicat¸iei.

1.1. APPLET 11 

• hspace 

Valoarea parametrului este lungimea, exprimată în pixeli, care se lasă liberă 

la stânga ¸si la dreapta ferestrei applet-ului. 

În marcajul prin intermediul elementului pot fi inclu¸si 

parametri ce pot fi preluat¸i de applet. Un parametru se define¸ste prin atributele: 

• name 

Valoarea atributului este numele variabilei recunoscut în applet. 

• value 

Valoarea atributului este valoarea recept¸ionat de applet ¸si este de tip String. 

Preluarea se realizează cu metoda 

1.1 Applet 

public String getParameter(String name) 

Clasa Applet extinde clasa java.awt.Panel. 

Structura unui applet este 

import java.applet.*; 

import java.awt.*; 

public classNumeClasă extends Applet{ 

public void init(){ 

Act¸iuni efectuate la instant¸ierea clasei applet-ului. 

} 

public void start(){ 

Act¸iuni efectuate la lansarea applet-ului în execut¸ie sau la 

reîntoarcerea în pagina applet-ului. 

} 

public void paint(Graphics g){ 

Act¸iuni efectuate ori de câte ori este necesară redesenarea 

ferestrei applet-ului. 

} 

public void stop(){ 

Act¸iuni efectuate la oprirea applet-ului, ca urmare a 

închiderii ferestrei corespunzătoare applet-ului. 

} 

public void destroy(){ 

Act¸iuni efectuate la distrugerea applet-ului, ce au loc când 

navigatorul părăse¸ste documentul html din care s-a apelat 

applet-ul.


} 

} 

Executarea applet-ului de către programul navigator revine la apelarea metodelor 

init, start, stop. 

Astfel controlul asupra applet-ului este det¸inut de programul navigator. Acest 

fenomen se nume¸ste inversarea controlului. 

Dacă fi¸sierul class al applet-ului nu se află în acela¸si catalog cu documentul 

html atunci localizarea clasei se face cu valoarea atributului codebase = 

"file://host/calea către catalogul clasei applet-ului" 

Observat¸ie 1.1.1 

Elementul applet activează ma¸sina virtuală Java utilizată de programul navigator. 

Această ma¸sină virtuală s-ar putea să nu fie compatibilă cu ma¸sina virtuală 

Java de la Sun. Dacă pe calculatorul clientului este instalat Java atunci 

documentul html se poate converti astfel încât execut¸ia applet-ului să fie executată 

de ma¸sina virtuală Java a distribut¸iei jdk. Convertirea se face cu utilitarul 

HtmlConverter, din distribut¸ia jdk. 

Exemplul 1.1.1 Miniaplicat¸ia HelloWorld. 

1. HelloWorld. Codul applet-ului este: 



public class Inceput extends Applet{ 

public void init(){} 


g.drawString("Hello World !!", 50, 60 ); 

} 

} 

Documentul html de apelare este: 

 

 

Hello 

 

 

 

 

 

 

 

1.1. APPLET 13 

2. Exemplul 1.1.2 Calculul celui mai mare divizor comun a două naturale. 

Codul sursă este: 



import java.awt.event.*; 

public class Cmmdc extends Applet implements ActionListener{ 

TextField tm,tn,rez; 


setBackground(Color.yellow); 

GridLayout gl=new GridLayout(3,2,30,20); 

setLayout(gl); 

Label lm=new Label("Primul numar:"); 

add(lm); 

tm=new TextField("1",5); 

add(tm); 

Label ln=new Label("Al doilea numar:"); 

add(ln); 

tn=new TextField("1",5); 

add(tn); 

Button compute=new Button("Calculeaza"); 

compute.addActionListener(this); 

add(compute); 

rez=new TextField("1",5); 

rez.setEditable(false); 

add(rez); 

} 


String sm=tm.getText(); 

long m=Long.parseLong(sm); 

String sn=tn.getText(); 

long n=Long.parseLong(sn); 

long c=cmmdc(m,n); 

rez.setText((new Long(c)).toString()); 

} 

public void actionPerformed(ActionEvent ae){ 

repaint(); 

} 

long cmmdc(long m, long n){. . .} 

} 

Documentul html corespunzător este: 

 

 

 

 


 

 

 

Să se ruleze miniaplicat¸ia în mediu distribuit, adica apelarea prin intermediul 

navigatorului, fi¸sierul html ¸si fi¸sierul Cmmdc.class sunt pe trei calculatoare 

diferite.

Capitolul 2 

Programare cu socluri Java 

Limbajul de programare Java oferă facilităt¸i de elaborare ale unor programe 

care utilizează ¸si interact¸ionează cu resurse din Internet ¸si din World Wide Web. 

În plus limbajul Java permite utilizarea URL-ului (Universal Resource Locator 

– adresa resurselor în Internet), a soclurilor (socket) ¸si a datagramelor. 

2.1 Aplicat¸ii client – server 

O aplicat¸ie client – server se compune din: 

• componenta server - alcătuită din programe / clase ce asigură una sau mai 

multe funct¸iuni (servicii), care pot fi apelate de către client¸i. 

• componenta client - alcătuită din programe / clase care permit accesul la 

server ¸si apelarea serviciilor acestuia. 

Serverul ¸si clientul (client¸ii) rulează, de obicei, pe calculatoare distincte. Un 

server trebuie să satisfacă cererile mai multor client¸i. 

Durata de viat¸ă a unei aplicat¸ii client – server este dată de durata funct¸ionării 

serverului. Această durată poate fi alcătuită din intervale disjuncte de timp, între 

acele intervale, din diverse motive, serverul este inactiv. 

Intervalul de timp determinat de conectarea unui client la server ¸si până la 

deconectare poartă numele de sesiune. 

În această perioadă, clientul poate invoca 

mai multe servicii ale serverului. Un client poate init¸ia mai multe sesiuni. 

Un client trebuie să-¸si regăsească datele în cadrul unei sesiuni, între sesiuni, 

pe toată durata de viat¸ă a aplicat¸iei. Astfel se pune problema ret¸inerii datelor 

pentru fiecare client în parte. 

15

16 CAPITOLUL 2. PROGRAMARE CU SOCLURI JAVA 

Autentificare ¸si autorizare 

Uzual, pentru a folosi serviciul unui server, un client trebuie să se înregistreze, 

moment în care i se stabilesc drepturile de care dispune la utilizarea serviciilor 

oferite de server. 

La apelarea serverului, clientul este autentificat - adică i se recunoa¸ste identitatea 

- ¸si apoi i se asigură accesul la servicii în limita drepturilor pe care le 

are. 

2.2 Not¸iuni despre ret¸ele 

Calculatoarele ce rulează în Internet comunică între ele folosind protocolul 

TCP (Transport Control Protocol) sau UDP (User Datagram Protocol). 

Într-un program Java se utilizează clasele pachetului java.net prin intermediul 

cărora se accesează nivelele deservite de protocoalele TCP sau UDP. În 

felul acesta se pot realiza comunicat¸ii independente de platforma de calcul. Pentru 

a alege care clasă Java să fie utilizată trebuie cunoscută diferent¸a dintre TCP 

¸si UDP. 

TCP Când două aplicat¸ii comunică între ele se stabile¸ste o conexiune prin 

intermediul căreia se schimbă date. Folosind protocolul TCP, comunicat¸ia garantează 

că datele trimise dintr-un capăt ajung în celălalt capăt cu păstrarea ordinii 

în care au fost trimise. Acest tip de comunicat¸ie seamănă cu o convorbire telefonică. 

TCP furnizează un canal sigur de comunicat¸ie între aplicat¸ii. 

UDP Utilizarea protocolului UDP presupune trimiterea unor pachete de date 

– numite datagrame – de la o aplicat¸ie la alta fără să se asigure faptul că datagrameleajung 

la destinat¸ie ¸si nici ordinea lor de sosire. Acest tip de comunicat¸ie 

seamănă cu trimiterea scrisorilor prin po¸stă. 

2.3 Soclu TCP 

Conexiunile bazate pe URL reprezintă un mecanism de nivel înalt pentru 

accesarea resurselor din Internet. 

Aplicat¸ii de tip client – server se pot realiza utilizând comunicat¸ii de nivel 

scăzut. Pentru a comunica utilizând TCP programul client ¸si programul server 

stabilesc o conexiune sigură. Fiecare program se leagă la conexiune printr-un 

soclu (socket). Un soclu este capătul unei căi de comunicat¸ie bidirect¸ional între 

două programe ce rulează în ret¸ea. Un soclu este legat de un port – prin care 

nivelul TCP poate identifica aplicat¸ia căreia îi sunt transmise datele. Din punct 

de vedere fizic, un port este o adresă de memorie cuprinsă între 0 ¸si 65535.

2.3. SOCLU TCP 17 

Pentru a comunica atât clientul cât ¸si serverul citesc date de la ¸si scriu date 

la soclul legat la conexiunea dintre ele. 

În pachetul java.net clasele Socket ¸si ServerSocket implementează un soclu 

din partea clientului ¸si respectiv din partea serverului. 

Clientul cunoa¸ste numele calculatorului pe care rulează serverul cât ¸si portul 

la care acesta este conectat. Pentru stabilirea conexiunii, clientul încearcă un 

rendez-vous cu serverul de pe ma¸sina serverului ¸si la portul serverului. Dacă 

totul decurge bine, serverul acceptă conexiunea. După acceptare, serverul crează 

pentru client un nou soclu legat la un alt port în a¸sa fel încât ascultarea cererilor 

la soclul init¸ial să poată continua în timp ce sunt satisfăcute cererile clientului 

conectat. Din partea clientului, după acceptarea conexiunii soclul este creat ¸si 

este utilizat pentru comunicat¸ia cu serverul. 

2.3.1 Clasa Socket 

Resursele clasei Socket sunt destinate clientului. 

Constructori 

• public Socket(String host, int port) throws UnknownHostException, 

IOException 

Crează un soclu conectat la calculatorul cu portul specificat. 

• public Socket(InetAddress host, int port) throws IOException 

Crează un soclu conectat la calculatorul cu portul specificat. 

Metode 

• public InputStream getInputStream() throws IOException 

Returnează un flux de intrare ata¸st soclului, pentru citirea (preluarea) 

informat¸iilor de la soclu. 

• public OutputStream getOutputStream() throws IOException 

Returnează un flux de ie¸sire ata¸st soclului, pentru scrierea (transmiterea) 

informat¸iilor la soclu. 

• public synchronized void close() throws IOException 

închide soclul de referint¸ă. 

2.3.2 Clasa ServerSocket 

Resursele clasei ServerSocket sunt destinate serverului. 

Constructori


• public ServerSocket(int port) throws IOException 

Crează un soclu la portul specificat. Dacă port=0, atunci va fi utilizat 

orice port disponibil. Capacitatea ¸sirului (tamponului) de a¸steptare pentru 

cererile de conectare se fizează la valoarea implicită 50. Cererile în exces 

vor fi refuzate. 

• public ServerSocket(int port, int lung) throws IOException 

În plus fixează lungimea ¸sirului (tamponului) de a¸steptare. 

• public ServerSocket(int port, int lung, InetAddress adr) 

throws IOException 

Se specifică în plus calculatorul de la care se a¸steaptă cereri. Dacă adr=null, 

atunci se acceptă cereri de la orice calculator. 


• public Socket accept() throws IOException 

Metoda blochează procesul (firul de execut¸ie) apelant până la sosirea unei 

cereri de conectare ¸si crează un soclu client prin care se va desfă¸sura comunicarea 

cu solicitantul acceptat. 

• public synchronized void close() throws IOException 

închide soclul de referint¸ă. 

2.4 Aplicat¸ie client – server cu socluri 

Serverul trebuie să satisfacă simultan solicitările mai multor client¸i. Fiecare 

client apelează programul server la acela¸si port ¸si în consecint¸ă cererile de conectare 

sunt recept¸ionate de acela¸si ServerSocket. Serverul recept¸ionează apelurile secvent¸ial. 

La un apel, se crează de partea severului un soclu prin care se va face schimbul 

de date cu clientul. Cererile client¸ilor pot fi satisface concurent/paralel, utilizând 

fire de execut¸ie ce implementează serviciul oferit sau secvent¸ial - în cazul unor 

servicii de durată scurtă. 

Exemplul 2.4.1 Sistem client - server pentru calculul celui mai mare divizor 

comun a două numere naturale. Portul obiectului de tip ServerSocket este 7999. 

Programul client CmmdcClient se conectează la server, transmite serverului 

cele două numere naturale ¸si recept¸ionează rezultatul pe care apoi îl afi¸sează. 

În esent¸ă orice program client trebuie să execute: 

1. Deschide/crează un soclu.

2.4. APLICAT¸ IE CLIENT – SERVER CU SOCLURI 19 

2. Deschide/crează fluxuri de date pentru comunicat¸ia cu serverul. 

3. Transmite ¸si recept¸ionează date potrivit specificului aplicat¸iei (protocolului 

serverului). Acest pas variază de la un program client la altul. 

4. 

5. 

Închiderea fluxurilor de date. 

Închiderea soclului. 

import java.io.*; 

import java.net.*; 

import java.util.Scanner; 

public class CmmdcClient { 

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

String host="localhost"; 

int port=7999; 

if (args.length>0) 

host=args[0]; 


port=Integer.parseInt(args[1]); 

Socket cmmdcSocket = null; 

DataInputStream in=null; 

DataOutputStream out=null; 

try { 

cmmdcSocket = new Socket(host, port); 

out=new DataOutputStream(cmmdcSocket.getOutputStream()); 

in=new DataInputStream(cmmdcSocket.getInputStream()); 

} 

catch (Exception e) { 

System.err.println("Connection Error : "+e.getMessage()); 

System.exit(1); 

} 

Scanner scanner=new Scanner(System.in); 

long m,n,r; 

System.out.println("m="); 

m=scanner.nextLong(); 

System.out.println("n="); 

n=scanner.nextLong(); 

try{ 

out.writeLong(m); 

out.writeLong(n); 

r=in.readLong(); 

System.out.println("Cmmdc : "+r); 

} 

catch(IOException e){ 

System.err.println("Comunication error"+e.getMessage()); 

} 

out.close(); 

in.close(); 

cmmdcSocket.close(); 

} 

}


Se presupune că programul server rulează pe calculatorul local ¸si utilizează 

portul 7999. Dacă ace¸sti parametri se modifică - de exemplu serverul rulează în 

ret¸ea pe calculatorul atlantis la portul 8200 - atunci la apelare transmitem ace¸sti 

parametri prin java CmmdcClient atlantis 8200 

Partea server este alcătuită din mai multe clase: 

• Clasa MyMServer, independentă de un serviciu anume, preia apelurile client¸ilor 

¸si lansează satisfacerea cererii. 



public class MyMServer { 

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


boolean listening=true; 

ServerSocket serverSocket = null; 

try { 

serverSocket = new ServerSocket(port); 

} 

catch (IOException e) { 

System.err.println("Could not listen on port: "+port); 

System.out.println(e.getMessage()); 


} 

while(listening) 

// varianta 1 

new AppThread(serverSocket.accept()).start(); 

// varianta 2 

/* 

{ 

Socket socket=serverSocket.accept(); 

try{ 

DataOutputStream out = new DataOutputStream(socket.getOutputStream()); 

DataInputStream in = new DataInputStream(socket.getInputStream()); 

long m=0,n=0,r; 

App app=new App(); 

m=in.readLong(); 

n=in.readLong(); 

r=app.cmmdc(m,n); 

out.writeLong(r); 

out.close(); 

in.close(); 

socket.close(); 

} 


System.err.println("Server comunication error : "+e.getMessage()); 

} 

} 

*/ 

serverSocket.close(); 

} 

} 

• Clasa AppTread - fir de execut¸ie responsabil de preluarea datelor ¸si de

2.5. DATAGRAME 21 

transmitere a rezultatului. 



public class AppThread extends Thread{ 

Socket socket=null; 

public AppThread(Socket socket){ 

this.socket=socket; 

} 

public void run(){ 

try{ 

DataOutputStream out = new DataOutputStream(socket.getOutputStream()); 

DataInputStream in = new DataInputStream(socket.getInputStream()); 

long m=0,n=0,r; 


m=in.readLong(); 

n=in.readLong(); 

r=app.cmmdc(m,n); 

out.writeLong(r); 

out.close(); 

in.close(); 


} 


System.err.println("Server comunication error : "+e.getMessage()); 

} 

} 

} 

• Clasa App corespunzătoare calcului celui mai mare divizor comul a două 

numere naturale. 

public class App{ 

public long cmmdc(long m,long n){. . .} 

} 

Rularea programelor. Se porne¸ste la început programul server MyMServer 

iar apoi clientul CmmdcClient. Clientul se poate rula de pe orice calculator al 

ret¸elei. Dacă programul client se execută pe alt calculator decât cel pe care 

rulează programul server, atunci la apelarea clientului trebuie precizat numele 

calculatorului server ¸si eventual portul utilizat. 

2.5 Datagrame 

Pentru utilizarea datagramelor pachetul java.net pune la dispozit¸ie clasele


• DatagramSocket 

• DatagramPacket 

• MulticastSocket 

O aplicat¸ie trimite ¸si recept¸ionează pachete DatagramPacket prin intermediul 

unui DatagramSocket. Un pachet DatagramPacket poate fi trimis la mai mult¸i 

destinatari prin intermediul unui MulticastSocket. 

Reamintim că o datagramă este un mesaj trimis prin ret¸ea a cărei sosire nu 

este garantat iar momentul de sosire este neprecizat. 

2.5.1 Clasa DatagramPacket. 

Trimiterea unui pachet UDP necesită crearea unui obiect 

DatagramPachet care cont¸ine corpul mesajului ¸si adresa destinat¸iei. Apoi acest 

obiect DatagramPacket poate fi pus în ret¸ea în vederea trimiterii sale. Primirea 

unui pachet UDP necesită crearea unui obiect DatagramPacket ¸si apoi acceptarea 

unui pachet UDP din ret¸ea. După primire, se poate extrage din obiectul 

DatagramPacket adresa sursă ¸si cont¸inutul mesajului. 

Constructori 

Există doi constructori pentru datagrame UDP. Primul constructor este folosit 

pentru primirea de pachete ¸si necesită doar furnizarea unei memorii tampon, iar 

celălalt este folosit pentru trimiterea de pachete necesită ¸si specificarea adresei. 

• DatagramPacket(byte[ ] buffer,int lung) 

Acest contructor este folosit pentru primirea pachetelor. Un pachet se memorează 

în tamponul buffer având lung octet¸i. Dacă lungimea pachetului 

depă¸se¸ste această lungime, atunci pachetul este trunchiat iar octet¸ii în plus 

se pierd. 

• DatagramPacket(byte[ ] buffer,int lung ,InetAddress adresa ,int port) 

Acest constructor este folosit pentru crearea unui pachet în vederea expedierii. 

Corpul pachetului este cont¸inut în tamponul buffer având lung 

octet¸i. Pachetul va fi trimis către adresa ¸si portul specificat. Trebuie să 

existe un server UDP care ascultă la portul specificat pentru trimiterea pachetelor. 

Un server UDP ¸si un server TCP care ascultă acela¸si port pot 

coexista. 


• InetAddress getAddress() 

returnează adresa IP a pachetului.


• int getPort() 

returnează portul. 

• byte[] getData() 

returnează cont¸inutul pachetului. 

• int getLength() 

returnează lungimea pachetului. 

• void setAddress(InetAddress adresa) 

fixează adresa IP a pachetului. 

• void setPort(int port) 

fixează portul. 

• void setData(byte[] buffer) 

fixează cont¸inutul pachetului. 

• void setLength(int lung) 

fixează lungimea pachetului. 

2.5.2 Clasa DatagramSocket 

Această clasă se folose¸ste atât pentru trimiterea, cât ¸si pentru primirea obiectelor 

DatagramPacket. Un obiect DatagramSocket ascultă la un port cuprins între 1 

¸si 65535 (porturile cuprinse între 1 ¸si 1023 sunt rezervate pentru aplicat¸iile sistem). 

Deoarece UDP nu este orientat pe conexiune, se va crea un singur obiect 

DatagramSocket pentru trimiterea pachetelor către diferite destinat¸ii ¸si primirea 

pachetelor de la diferite surse. 

Constructori 

• DatagramSocket() throws SocketException 

Crează un obiect DatagramSocket cu un număr de port aleator; 

• DatagramSocket(int port) throws SocketException 

Crează un obiect DatagramSocket cu numărul de port specificat; 

• DatagramSocket(int port, InetAddress adresă) throws SocketException 

Crează un obiect DatagramSocket cu numărul de port specificat la adresa 

specificată;



Clasa DatagramSocket cont¸ine metode pentru trimiterea ¸si primirea de obiecte 

DatagramPacket, închiderea soclului, determinarea informat¸iilor adresei locale 

¸si setarea timpului de primire. 

• void send(DatagramPacket pachet) throws IOException 

Trimite pachetul prin ret¸ea. Dacă se trimit pachete la o destinat¸ie necunoscută 

sau care nu ascultă, în cele din urmă se generează o except¸ie 

IOException. 

• void receive(DatagramPacket pachet) throws IOException 

Metoda prime¸ste un singur pachet UDP în obiectul pachet specificat. Apoi, 

pachetul poate fi inspectat pentru determinarea adresei IP sursă, portul 

sursă ¸si lungimea mesajului. Execut¸ia metodei este blocată până când se 

prime¸ste cu succes un pachet sau se scurge timpul de a¸steptare. 

• InetAddress getLocalAddress() 

Returnează adresa locală către care este legat acest DatagramSocket; 

• int getLocalPort() 

Returnează numărul de port unde ascultă DatagramSocket. 

• void close() 

Închide DatagramSocket. 

• void setSoTimeout(int timpDeA¸steptere) throws SocketException 

Metoda fixează timpul de a¸steptare (în milisecunde) a soclului. Metoda 

receive() se va bloca pentru timpul de a¸steptare specificat pentru primirea 

unui pachet UDP, după care va arunca o except¸ie Interrupted Exception. 

Dacă valoarea parametrului este 0, atunci soclul este blocat. 

• int getSoTimeout() throws SocketException 

Returnează timpul de a¸steptare. 

• void setSendBufferSize(int lungime) throws SocketException 

Fixează lungimea tamponului de trimitere a soclului la valoarea specificată. 

Mesaj UDP de lungime mai mare de această valoare nu pot fi trimis. 

• int getSendBufferSize() throws SocketException 

Returnează lungimea tamponului de trimitere a soclului.


• void setReceiveBufferSize(int lungime) throws SocketException 

Fixează lungimea tamponului de primire a soclului la valoarea specificată. 

Mesaj UDP de lungime mai mare de această valoare nu pot fi primit. 

• int getReceiveBufferSize() throws SocketException 

Returnează lungimea tamponului de primire a soclului. 

• void connect(InetAddress adresa, int port) throws SocketException 

Conectează soclul la adresa ¸si portul specificat. Această metodă nu este 

cerută pentru operat¸iile uzuale UDP. 

• void disconnect() 

Deconectează soclul conectat. 

• InetAddress getInetAddress() 

Returnează obiectul InetAddress către care este conectat soclul sau null 

dacă acesta nu este conectat. 

• int getPort() 

Returnează portul la care este conectat soclul sau -1 dacă acesta nu este 

conectat. 

2.5.3 Clasa InetAddress 

Datele pot fi trimise prin ret¸ea indicând adresa IP corespunzătoare ma¸sinii 

destinat¸ie. Clasa InetAddress furnizează acces la adresele IP. 

Nu există constructori pentru această clasă. Instant¸ele trebuie create folosind 

metodele statice: 

• InetAddress getLocalHost() throws UnknownHostException 

Returnează un obiect InetAddress corespunzător ma¸sinii locale. 

• InetAddress getByName(String host) throws UnknownHostException 

Returnează un obiect InetAddress corespunzător ma¸sinii host, parametru 

care poate fi specificat prin nume (de exemplu ”atlantis”) sau prin adresa 

IP (”168.192.0.1”). 

• InetAddress [ ]getAllByName(String host) 

throws UnknownHostException 

Returnează un ¸sir de obiecte InetAddress corespunzător fiecărei adrese IP 

a ma¸sinii host. 

Metodele clasei InetAddress


• byte [ ] getAddress() 

Returnează ¸sirul de octet¸i corespunzător obiectului InetAddress de referint¸ă. 

• String getHostName() 

Returnează numele ma¸sinii gazdă. 

• String getHostAddress() 

Returnează adresa IP a ma¸sinii gazdă. 

• boolean isMulticastAddress() 

Returnează true dacă obiectul InetAddress reprezintă o adresă IP multicast 

(primul octet cuprins între 224 ¸si 239). 

Exemplul următor afi¸sează numele ¸si adresa calculatorului gazdă cât ¸si acela 

al calculatoarelor ale căror nume este transmis programului ca parametru. 

Exemplul 2.5.1 


public class AdreseIP{ 

public static void main(String arg[]){ 

InetAddress adresa=null; 

try{ 

adresa=InetAddress.getLocalHost(); 

System.out.println("Calculatorul gazda are:"); 

System.out.println("numele : "+adresa.getHostName()); 

System.out.println("adresa IP : "+adresa.getHostAddress()); 

} 

catch(UnknownHostException e){ 

System.out.println("UnknownHostException : "+e.getMessage()); 

} 

if(arg.length>0){ 

for(int i=0;i


2.5.4 Aplicat¸ii client – server cu datagrame. 

Un pachet de tip DatagramPacket este alcătuit dintr-un ¸sir de octet¸i. Este 

datoria programatorului să transforme datele (mesajul) în ¸siruri de octet¸i la expediere 

¸si la recept¸ie. 

Transformarea unui obiect serializabil într-un ¸sir de octet¸i ¸si invers se poate 

realiza cu schema 

Object Object 

❄ 

ObjectOutputStream 

✻ 

ObjectInputStream 

❄ 

ByteArrayOutputStream 

✻ 

ByteArrayInputStream 

❄ 

output - DatagramPacket 

✻ 

input - DatagramPacket 

❄ ✻ 

Fie socket un obiect de tip DatagramSocket prin intermediul căruia se execută 

expedierea / recept¸ionarea pachetelor de tip DatagramPacket. 

În principiu expedierea ¸si transformarea obiectului obj într-un ¸sir de octet¸i se 

poate realiza cu secvent¸a de cod 

ByteArrayOutputStream baos=new ByteArrayOutputStream(256); 

ObjectOutputStream out=new ObjectOutputStream(baos); 

out.writeObject(p); 

byte[] bout=baos.toByteArray(); 

DatagramPacket packet=new DatagramPacket(bout,bout.length, 

address,port); 

socket.send(packet); 

unde address ¸si port sunt adresa ¸si portul utilizat de expeditorul mesajului. Dacă 

packet este un obiect DatagramPacket recept¸ionat atunci metodele getAddress() 

¸si getPort() furnizează adresa ¸si portul expeditorului 

Recept¸ionarea ¸si transformarea inversă este 

byte[] bin=new byte[256]; 

packet=new DatagramPacket(bin,bin.length); 

socket.receive(packet); 

ByteArrayInputStream bais=new ByteArrayInputStream(bin); 

ObjectInputStream in=new ObjectInputStream(bais); 

obj=in.readObject();


Dacă mesajul este un obiect String atunci el se transformă într-un ¸sir de 

octet¸i cu metoda byte[] String.getByte() ¸si invers, el se obt¸ine prin new 

String(bin) sau new String(packet.getData()). 

Exemplul 2.5.2 Programăm serviciul calculului celui mai mare divizor comun 

a două numere. 

În vederea transportului definim clasa 


public class Protocol implements Serializable{ 

long x,y; 

Protocol(long x,long y){ 

this.x=x; 

this.y=y; 

} 

} 

Clientul va trimite un obiect Protocol, care va cont¸ine datele problemei ¸si va 

recept¸iona un obiect de acela¸si tip cu rezultatul (cel mai mare divizor comun) în 

primul câmp al obiectului. 

Programul client este 




public class ClientCmmdc{ 

public static void main(String []args){ 

String hostServer="localhost"; 

int portServer=7999; 

if(args.length>0) 

hostServer=args[0]; 


portServer=Integer.parseInt(args[1]); 

try{ 

// Crearea unui soclu Datagramsocket 

DatagramSocket socket=new DatagramSocket(); 

// Formarea mesajului 

Protocol p=new Protocol(0,0); 


System.out.println("Introduceti primul numar: "); 

p.x=scanner.nextLong(); 

System.out.println("Introduceti al doilea numar: "); 

p.y=scanner.nextLong(); 

// Transformarea mesajului intr-un sir de octeti 



out.writeObject(p);



// Expedierea mesajului 

InetAddress address=InetAddress.getByName(hostServer); 

DatagramPacket packet=new 

DatagramPacket(bout,bout.length,address,portServer); 


// Asteptarea raspunsului 




// Prelucrarea raspunsului 



p=(Protocol)in.readObject(); 

System.out.println("Cmmdc = "+p.x); 


} 

catch(Exception e){ 


} 

} 

} 

Programul server este 



public class ServerCmmdc{ 

public static void main(String []args){ 

DatagramSocket socket=null; 

int serverPort=7999; 

try{ 

// Crearea unui soclu DatagramSocket 

socket=new DatagramSocket(serverPort); 

} 


System.out.println("DatagramSocket-error-"+e.getMessage()); 


} 

// Activitatea serverului 

boolean listening=true; 

DatagramPacket packet=null; 


Protocol p=null; 

while(listening){


try{ 

// Receptionarea unui mesaj 




// Prelucrarea datelor 



p=(Protocol)in.readObject(); 

// Rezolvarea cererii clientului 

p.x=app.cmmdc(p.x,p.y); 

p.y=0; 

// Transformarea mesajului de raspuns intr-un sir de octeti 



out.writeObject(p); 


// Expedierea mesajului necesita cunoasterea expeditorului 

InetAddress address=packet.getAddress(); 

int port=packet.getPort(); 

packet=new DatagramPacket(bout,bout.length,address,port); 


} 



} 

} 


} 

} 

Clasa App este cea utilizată la exemplul cu socluri TCP. 

2.5.5 Clasa MulticastSocket 

Multicast vs. Broadcast 

Prin intermediul unui soclu de tip MulticastSocket se pot recept¸iona datagrame 

expediate de un server către tot¸i client¸ii cu un asemenea soclu. 

Constructori 

• MulticastSocket(int port) throws SocketException 


• void joinGroup(InetAddress adresă) throws SocketException


Soclul se ”conectează” la grupul definit de adresa IP (de tip D, adică cuprins 

între 224.0.0.0 ¸si 239.255.255.255). 

• void leaveGroup(InetAddress adresă) throws SocketException 

Soclul se ”deconectează” la grupul definit de adresa IP. 

• void close() 

Pregătirea clientului în vederea recept¸ionării datagramelor printr-un soclu de 

tip MulticastSocket constă din 

MulticastSocket socket= new MulticastSocket(port); 

InetAddress adresa=InetAddress.getByName("230.0.0.1"); 

socket.joinGroup(adresa); 

În final, clientul se deconectează ¸si închide soclul. 

socket.leaveGroup(adresa); 


Pachetele trimise de programul server trebuie să se adreseze grupului, identificat 

prin adresa IP de tip D. 

Astfel prin multicast serverul trimite pachete la o adresă de grup ¸si la un 

port fixat. Pachetele emise de server sunt recept¸ionate de orice client ce crează 

un soclu de tip MulticastSocket pentru portul la care emite serverul ¸si care se 

alătură grupului. 

Prin broadcast serverul emite datagrame către orice calculator al ret¸elei locale 

la un anumit port. Faptul că emiterea datagramelor este de tip broadcast se indică 

prin 

DatagramSocket.setBroadcast(true) 

Orice client care î¸si crează un soclu la portul la care emite serverul recept¸ionează 

datagramele trimise de server. Adresa utilizată de server la crearea datagramelor 

trebuie să identifice ret¸eaua. 

Observat¸ie. În cazul unui calculator ”izolat” este nevoie de instalarea driverului 

Microsoft Loopback Adapter, care simulează existent¸a unei plăci de ret¸ea active. 

În exemplele următoare, programele server emit din cinci în cinci secunde ora 

exactă. Un client va recept¸iona câte cinci datagrame.


MulticastServer BroadcastServer 

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

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

import java.util.*; import java.util.*; 

import java.text.DateFormat; import java.text.DateFormat; 

public class MulticastServer{ public class BroadcastServer{ 

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

long FIVE_SECONDS = 5000; long FIVE_SECONDS = 5000; 

boolean sfarsit=false; boolean sfarsit=false; 

DatagramSocket socket = null; DatagramSocket socket = null; 

int serverPort=7000; int serverPort=7000; 

int clientPort=7001; int clientPort=7001; 

byte[] buf = new byte[256]; byte[] buf = new byte[256]; 

Date data=null; Date data = null; 

DatagramPacket packet = null; DatagramPacket packet = null; 

try{ try{ 

socket=new DatagramSocket(serverPort); socket=new DatagramSocket(serverPort); 

} } 

catch(SocketException e){ catch(SocketException e){ 

System.out.println(e.getMessage()); System.out.println(e.getMessage()); 

} } 

while (! sfarsit){ while (! sfarsit) { 

try{ try{ 

data=new Date(); data=new Date(); 

String df=DateFormat. String df=DateFormat. 

getTimeInstance().format(data); getTimeInstance().format(data); 

buf = df.getBytes(); buf = df.getBytes(); 

// send it 

InetAddress group = InetAddress group = 

InetAddress.getByName("230.0.0.1"); InetAddress.getByName("192.168.0.255"); 

packet=new DatagramPacket(buf, packet=new DatagramPacket(buf, 

buf.length,group,clientPort); buf.length,group,clientPort); 

socket.setBroadcast(true); 

socket.send(packet); socket.send(packet); 

// sleep for a while 

Thread.sleep(FIVE_SECONDS); Thread.sleep(FIVE_SECONDS); 

} } 

catch (Exception e) { catch (Exception e) { 

System.out.println(e.getMessage()); System.out.println(e.getMessage()); 

} } 

} } 

socket.close(); socket.close(); 

} } 

} }

2.6. CANALE DE COMUNICAT¸ IE 33 

MulticastClient BroadcastClient 

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

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

public class MulticastClient { public class BroadcastClient { 

public static void main(String[] args) public static void main(String[] args) 

throws IOException { throws IOException { 

DatagramPacket packet; DatagramPacket packet; 

byte[] buf = new byte[256]; byte[] buf = new byte[256]; 

int clientPort=7001; int clientPort=7001; 

MulticastSocket socket= DatagramSocket socket= 

new MulticastSocket(clientPort); new DatagramSocket(clientPort); 

InetAddress address= 

InetAddress.getByName("230.0.0.1"); 

socket.joinGroup(address); 

int i=-1; int i=-1; 

do{ do{ 

i++; i++; 

packet=new DatagramPacket(buf, buf.length); packet=new DatagramPacket(buf, buf.length); 

socket.receive(packet); socket.receive(packet); 

String received=new String(packet.getData()); String received=new String(packet.getData()); 

System.out.println("Am primit: "+received); System.out.println("Am primit: "+received); 

} } 

while(i


Un obiect de tip typeBuffer este un tampon (container) care cont¸ine date 

de tipul specificat de denumirea clasei. 

Un obiect de tip Buffer este caracterizat de 

• capacitate numărul elementelor care pot fi înmagazitate în tampon; 

• limită marginea superioră a indicelui; 

• indice valoarea curentă a indicelui. 

Metode generale 

• clear() permite unui obiect de tip Buffer să fie reîncărcat. Fixează limita = 

capacitate ¸si indice = 0. 

• flip() pregăte¸ste obiectul de tip Buffer pentru consultare (citire). Fixează 

limita =numărul elementelor din tampon ¸si indice = 0. 

• rewind() pregăte¸ste obiectul de tip Buffer pentru re-citire. 

2.6.2 Clasa ByteBuffer 

Instant¸ierea unui obiect se obt¸ine prin fabrica 

static ByteBuffer allocate(capacitate) 

Introducerea elementelor se face prin metoda put(byte număr) iar accesul 

la elementul corespunzător indicelui se obt¸ine prin metoda byte get(). 

S¸ablonul de prelucrare este 

ByteBuffer bb=ByteBuffer.allocate(10); 

byte elem; 

while(bb.hasRemaining()){ 

elem=. . . 

bb.put(elem); 

} 

bb.flip(); 

while(bb.hasRemaining()){ 

. . . 

byte x=bb.get(); 

. . . 

} 

Metoda public final boolean hasRemaining() reîntoarce true dacă între valoarea 

curentă a indicelui ¸si limită există elemente. 

Un obiect de tip ByteBuffer se poate percepe ca un obiect de tip LongBuffer, 

DoubleBuffer, etc prin



LongBuffer lb=bb.asLongBuffer(); 

DoubleBuffer db=bb.asDoubleBuffer(); 

2.6.3 Clasa InetSocketAddress 

Clasa InetSocketAddress încapsulează adresa unui calculator din Internet 

împreună cu un port în vederea legării la un ServerSocket. Extinde clasa 

SocketAddress 

Constructori: 

• InetSocketAddress(InetAddress addr,int port) 

• InetSocketAddress(String numeCalculator,int port) 

2.6.4 Clasa ServerSocketChannel 

Crearea unui obiect de tip ServerSocketChannel se realizează prin 

static ServerSocketChannel open() throws IOException 

Unui asemenea obiect i se asociază un ServerSocket prin metoda 

ServerSocket socket() throws IOException. 

Obiectul de tip ServerSocket trebuie leagat la un port de comunicat¸ie prin 

metoda 

void bind(InetSocketAddress endpoint) throws IOException. 

S¸ablonul de utilizare este 

try{ 

ServerSocketChannel ssc=ServerSocketChannel.open(); 

ServerSocket ss=ssc.socket(); 

InetSocketAddress isa=new InetSocketAddress(addr,port); 

ss.bind(isa); 

} 

catch(Exception e){. . .} 

La apelul unui client, serverul trebuie să genereze un obiect de tip Socket 

Channel prin care se vor derula comunicat¸iile cu clientul. Acest canal de comunicat¸ie 

se obt¸ine cu metoda accept().


2.6.5 Clasa SocketChannel 

Crearea unui obiect de tip SocketChannel se realizează prin 

static SocketChannel open() throws IOException 

Acest obiect trebuie conectat la obiectul ServerSocketChannel al serverului cu 

metoda connect(InetSocketAddress addr). 

Datele vehiculate printr-un SocketChannel sunt de tip ByteBuffer. Datele 

se transmit prin metoda 

¸si se recept¸ionează prin metoda 

int write(ByteBuffer sursă) 

int read(ByteBuffer destinat¸ie) 

Valoarea returnată de cele două metode reprezintă numărul octet¸ilor trimi¸si 

/ recept¸ionat¸i. 

Canalul se închide cu metoda close(). 

Exemplul 2.6.1 Calculul celui mai mare divizor comun a două numere naturale. 

Aplicat¸ie client-server bazat pe canale de comunicat¸ie prin socluri are programul 

server 



import java.nio.*; 

import java.nio.channels.*; 

public class ChannelCmmdcServer { 

// Serviciul asigurat 

private static void serviciu(ServerSocketChannel ssc){ 

SocketChannel sc = null; 

try { 

sc=ssc.accept(); 

ByteBuffer bb = ByteBuffer.allocate(16); 

LongBuffer lb = bb.asLongBuffer(); 

sc.read(bb); 

bb.flip(); 

long m=lb.get(); 

long n=lb.get(); 


long r=app.cmmdc(m,n); 

lb.clear(); 

lb.put(r); 

sc.write(bb); 

sc.close(); 

} 


System.out.println("Server error : "+e.getMessage());


} 

} 

public static void main(String[] args){ 


ServerSocketChannel ssc=null; 

try{ 

ssc = ServerSocketChannel.open(); 

InetSocketAddress isa=new InetSocketAddress(InetAddress.getLocalHost(), port); 

ServerSocket ss=ssc.socket(); 

ss.bind(isa); 

} 


System.out.println("ServerSocketChannelError : "+e.getMessage()); 


} 

while(true){ 

serviciu(ssc); 

} 

} 

} 

¸si clientul 



import java.nio.*; 

import java.nio.channels.*; 


public class ChannelCmmdcClient { 

public static void main(String[] args) { 




host=args[0]; 



SocketChannel sc=null; 

try{ 

InetSocketAddress isa=new InetSocketAddress(host,port); 

sc=SocketChannel.open(); 

sc.connect(isa); 

} 

catch (UnknownHostException e) { 

System.err.println("Server necunoscut: "+host+" "+e.getessage()); 


} 


System.err.println("Conectare imposibila la: "+ 

host+" pe portul "+port+" "+e.getessage()); 


} 


long m,n,r; 



System.out.println("n=");




LongBuffer lb=bb.asLongBuffer(); 

lb.put(m); 

lb.put(n); 

try{ 

sc.write(bb); 

bb.clear(); 

sc.read(bb); 

lb.flip(); 

r=lb.get(); 

System.out.println("Cmmdc : "+r); 

sc.close(); 

} 


System.err.println("Eroare de comunicatie : "+e.getMessage()); 

} 

} 

} 

2.7 Conexiuni HTTP 

Clasa URL permite realizarea unei conexiuni cu un server Web 1 potrivit protocolului 

HTTP (Hyper Text Transport Protocol) ¸si accesarea fi¸sierelor - uzual 

html - din zona publică. 

Constructori 

• URL(String spec) throws MalformedURLException 

Crează un obiect URL legat de resursa specificată de spec, care trebuie să fie 

o referint¸ă URL validă. 


• InputStream openStream() throws IOException 

Returnează fluxul de intrare pentru citirea resursei. 

Exemplul 2.7.1 Pe baza referint¸ei către un fi¸sier html dintr-un catalog vizibil 

al unui server Web, să se afi¸seze cont¸inutul fi¸sierului. 

În codul reprodus mai jos, fi¸sierul Hello.html se află pe un server apachetomcat, 

în catalogul webapps\myservlet. 



public class ReadHTTP{ 


1 apache-tomcat, apache, Micrsoft IIS (Internet Information Services), etc.

2.7. CONEXIUNI HTTP 39 

try{ 

String adr="http://localhost:8080/myservlet/Hello.html"; 

URL url=new URL(adr); 

InputStream in=url.openStream(); 

InputStreamReader isr=new InputStreamReader(in); 

BufferedReader br=new BufferedReader(isr); 

String s; 

do{ 

s=br.readLine(); 

if(s!=null) 

System.out.println(s); 

} 

while(s!=null); 

br.close(); 

isr.close(); 

in.close(); 

} 



} 

} 

}

40 CAPITOLUL 2. PROGRAMARE CU SOCLURI JAVA

Capitolul 3 

Programare distribuită cu RMI 

3.1 Structura RMI 

Remote Method Invocation (RMI) este un mecanism de dezvoltare a unei 

aplicat¸ii distribuite în mediul omogen Java, bazat pe mecanismului invocării la 

distant¸ă. RMI permite dezvoltarea de aplicat¸ii bazate pe client – server. 

Invocarea la distant¸ă (Remote Procedure Call – RPC) înseamnă apelarea 

metodei unui obiect aflat pe un alt calculator ca ¸si cum acesta s-ar afla pe calculatorul 

local. RMI reprezintă materializarea acestei idei în mediul Java. 

Modul cum de regăsire a obiectele la distant¸ă. Ideea găsirii unui 

obiect la distant¸ă este că serverul înscrie un reprezentant al său – numit stub 

(ciot) – într-un obiect registry - registru. Acest obiect se crează cu programul 

rmiregistry.exe din distribut¸ia java ¸si se lansează în execut¸ie prin 

start rmiregistry [port] 

unde valoarea implicită a portului este 1099. Comanda start apart¸ine sistemului 

de operare. 

Un client obt¸ine din registry stub-ul serverului, prin intermediul căruia realizează 

comunicat¸ia cu programul server. 

Când un obiect al clientului apelează o metodă a unui obiect aflat la distant¸ă, 

se va face, de fapt, un apel de metodă a unui obiect care reprezintă serverul. 

Acesta este stub-ul, aflat pe acea¸si ma¸sină cu clientul. 

Rolul acestui obiect este să împacheteze (marshalling) parametrii de apel ai 

metodei într-un mesaj ce va fi transferat prin ret¸ea. 

Împachetarea se face într-o 

manieră independentă de calculator, mai precis ¸sirurile de caractere ¸si obiecte 

sunt transmise într-un format care nu se bazează pe referint¸e. Pentru obiecte se 

utilizează serializarea obiectelor Java. 

Serializarea datelor reprezintă transformarea acestora din tipuri de date diferite 

într-un ¸sir de octet¸i care va fi transportat prin ret¸ea fără interpretare, dar care 

păstrează informat¸iile despre structura init¸ială a datelor. 

41

42 CAPITOLUL 3. PROGRAMARE DISTRIBUITĂ CU RMI 

Deserializarea este procesul invers de refacere a structurilor trimise prin ret¸ea. 

Mesajul asamblat este transmis către server, care ¸stie să desfacă mesajul 

recept¸ionat invocând în mod corespunzător metoda referită de client. 

Atunci când clientul face apel la o metodă aflată pe o altă ma¸sină, este invocat 

stub-ul client, care începe conversat¸ia cu serverul. Acest lucru este complet 

transparent utilizatorului, care are impresia că invocă o metodă locală. 

Metodele apelate la distant¸ă trebuie declarate ca apart¸inând unei interfet¸e ce 

extinde interfat¸a Remote. Fiecare asemenea metodă trebuie să arunce o except¸ie 

java.rmi.RemoteException. Obiectele care circulă prin ret¸ea trebuie să implementeze 

interfat¸a java.io.Serializable. 

Structura unei aplicat¸ii RMI. O aplicat¸ie RMI este alcătuită din trei 

componente: 

1. O interfat¸ă la distant¸ă (remote) în care se declară serviciile puse la dispozit¸ie 

de server; 

2. Aplicat¸ia server care poate implementa serviciile interfet¸ei la distant¸ă ¸si 

înscrie în registry stub-ul corespunzător; 

3. Aplicat¸ia client ce apelează unul sau mai multe servicii ale serverului. 

Nici o clipă nu trebuie scăpat din vedere faptul că cele trei componente 

evoluează pe calculatoare diferite. 

Registrul rmiregistry implementează interfat¸a Registry. Metodele oferite 

sunt: 

• void bind(String numeServiciu, Remote obj )throws 

RemoteException, AlreadyBoundException, AccessException 

Înregistrează în registry obiectul obj ce implementează interfat¸a Remote sub 

numele numeServiciu. 

• void rebind(String numeServiciu, Remote obj )throws 

RemoteException, AccessException 

Reînregistrează în registry obiectul obj ce implementează interfat¸a Remote 

sub numele numeServiciu. 

Această metodă poate fi apelată doar dacă programul care face înregistrarea 

se află pe acea¸si ma¸sină ca registrul registry. 

• String[] list()throws RemoteException, AccessException 

Returnează o listă a tuturor serviciilor înregistrate în registry. 

• Remote lookup(String numeServiciu)throws 

RemoteException, NotBoundException, AccessException 

Returnează stub-ul serviciului înregistrat sub numele numeServiciu.

3.1. STRUCTURA RMI 43 

• void unbind(String numeServiciu)throws 

RemoteException, NotBoundException, AccessException 

S¸terge din registru serviciul. 

Localizarea registrului se obt¸ine utilizând metoda statică getRegistry a clasei 

LocateRegistry. 

• public static Registry getRegistry() throws RemoteException 

• public static Registry getRegistry(String host) 

throws RemoteException 

• public static Registry getRegistry(int port) 


• public static Registry getRegistry(String host,int port) 


Metoda public static Registry createRegistry(int port) 

throws RemoteException crează un registru la portul specificat pe calculatorul 

local. 

Într-un registry se pot înregistra mai multe servicii, dar pe porturi diferite. 

Interfat¸a Remote serve¸ste la marcarea interfet¸elor ale căror metode urmează 

a fi apelate de pe altă ma¸sină virtuală Java. 

Un obiect de tip UnicastRemoteObject mijloce¸ste transmiterea obiectelor ¸si 

serve¸ste la generarea unui stub unui serviciu. Generarea stub-ului unui serviciu 

se obt¸ine prin intermediul metodei statice 

static Remote UnicastRemoteObject.exportObject(Remote obj ,int port) 

Inregistrarea stub-ului unui serviciu descris de interfat¸a IService ¸si implementat 

de clasa ServiceImpl în registry se face prin 

ServiceImpl obj=new ServiceImpl(); 

IService stub=(IService)UnicastRemoteObject.exportObject(obj,0); 

Registry registry=LocateRegistry.getRegistry(host,port); 

registry.bind("MyServiceName",stub); 

Un client care dore¸ste să folosească trebuie să cunoască : 

• calculatorul pe care se găse¸ste obiectul registry ¸si portul la care ascultă 

serviciul; 

• numele sub care serviciul s-a înregistrat în registry; 

• metodele puse la dispozit¸ie de serviciu.


3.2 Crearea unei aplicat¸ii RMI 

Exemplificăm construirea unei aplicat¸ii RMI în care serviciul asigurat de 

server este calculul celui mai mare divizor comun a două numere naturale. 

Pentru exemplele1 care urmează, presupunem că textele sursă se ret¸in în 

subcataloage ale unui catalog src, la care are acces doar programatorul, iar clasele 

obt¸inute prin compilare se depun în subcataloagele unui catalog public\classes, 

accesibil prin ret¸ea. 

Dezvoltarea unei aplicat¸ii se va face pe un calculator. 

În acest sens, celor 3 

componente li se asociază cataloagele \i - pentru interfat¸a la distant¸ă, \s - pentru 

componenta server ¸si \c - pentru componenta client. Pa¸si necesari compilării ¸si 

desfă¸surării componentelor aplicat¸iei se vor realiza prin intermediul lui ant. 

Pentru fiecare componentă se vor executa succesiv obiectivele: 

1. Install - crează o structură de cataloage src ¸si public\classes. 

2. Init - crează structura de cataloage specifică aplicat¸iei. 

3. Compile - compilează programele sursă. 

Dezvoltarea unei aplicat¸ii RMI constă din parcurgerea următorilor pa¸si: 

1. Definitea interfet¸ei la distant¸ă. 

package cmmdc; 

public interface ICmmdc extends java.rmi.Remote{ 

long cmmdc(long a,long b) throws java.rmi.RemoteException; 

} 

Presupunem ca programatorul interfet¸ei ret¸ine textul sursă 

ICmmdc.java în catalogul \i\src\cmmdc. 

2. Compilarea ¸si arhivarea interfet¸ei se poate realiza fi¸sierul ant-build 

 

Interface actions 

 

 

 

 

 

 

 

 

 

1 Sistemul de operare utilizat este Windows

3.2. CREAREA UNEI APLICAT¸ II RMI 45 

 

 

 

 

 

 

 

 

 

 

 

 

 

3. Implementarea interfet¸ei remote prin construirea aplicat¸iei server. 

package server; 

import java.rmi.*; 

import java.rmi.server.*; 

import java.rmi.registry.*; 

import cmmdc.*; 

public class CmmdcImpl implements ICmmdc{ 

public long cmmdc(long a,long b){. . .} 

public static void main(String args[]) { 




host=args[0]; 



try { 

CmmdcImpl obj=new CmmdcImpl(); 

ICmmdc stub=(ICmmdc)UnicastRemoteObject.exportObject(obj,0); 


registry.bind("CmmdcServer",stub); 

System.out.println("CmmdcServer ready"); 

} 


System.out.println("CmmdcImpl err: " + e.getMessage()); 

} 

} 

} 

Textul sursă al programului server CmmdcImpl.java se ret¸ine în catalogul 

\s\src\server 

4. Compilarea programului server


 

Server actions 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

5. Crearea obiectului registry ¸si lansarea serverului în lucru se obt¸ine cu fi¸sierul 

de comenzi bat 

cd \s\public\classes 

start rmiregistry 

cd \s\public\classes 

start java -cp /s/public/classes -Djava.rmi.server.codebase= 

file:/s/public/classes/ server.CmmdcImpl 

Parametrul -Djava.rmi.server.codebase fixează locat¸ia interfet¸ei la distant¸ă 

de pe calculatorul server. 

6. Realizarea programului client 

package client; 

import cmmdc.*;

3.2. CREAREA UNEI APLICAT¸ II RMI 47 








host=args[0]; 




System.out.println("Primul numar :"); 

long m=Long.parseLong(scanner.next()); 

System.out.println("Al doilea numar :"); 

long n=Long.parseLong(scanner.next()); 

long x=0; 

try { 


ICmmdc obj=(ICmmdc)registry.lookup("CmmdcServer"); 

x=obj.cmmdc(m,n); 

System.out.println("Cmmdc="+x); 

} 


System.out.println("CmmdcClient exception: "+e.getMessage()); 

} 

} 

} 

Sursa programului client CmmdcClient.java apart¸ine catalogului 

\c\src\client 

7. Compilarea programului client ¸si lansarea acestuia în execut¸ie. 

 

Client actions 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 


 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

3.3 Tipare de programare 

3.3.1 Fabrica de obiecte 

Tiparul fabrica de obiecte va permite crearea dinamică a unui server, fapt care 

nu este posibil pe schema prezentată în paragraful precedent. Prin aceea schemă, 

se va crea o clasă - fabrica de obiecte - care implementează câte o metodă get, ce 

returnează o instant¸ă de server. Aceste metode sunt declarate într-o interfat¸ă la 

distant¸ă. Un client, apelând o asemenea metodă, va instant¸ia serverul dorit ¸si va 

obt¸ine stub-ul corespunzător. 

Programarea unui server care poate fi lansat dinamic trebuie să satisfacă 

restrict¸iile: 

• Clasa serverului extinde clasa UnicastRemoteObject. 

• Există un constructor fără argumente ce aruncă except¸ia java.rmi.Remote 

Exception. 

Pentru exemplificarea tehnicii de lucru reluăm aplicat¸ia pentru calculul celui 

mai mare divizor comun a două numere naturale, considerând interfat¸a 

package cmmdc0; 


public interface ICmmdc0 extends Remote{ 

public long compute(long m,long n) throws RemoteException; 

} 

Aceasă interfat¸ă va fi implementată de clasa ServerCmmdc. Metoda compute 

este o metodă de calcul a celui mai mare divizor comun a două numere. 

Obiecte de tip ServerCmmdc se crează, de la distant¸ă prin fabrica de obiecte 

FabObiecte, o clasă ce implementează interfat¸a

3.3. TIPARE DE PROGRAMARE 49 



public interface IFabObiecte extends Remote{ 

public ICmmdc0 getCmmdc() throws RemoteException; 

} 

Codurile claselor ServerCmmdc ¸si FabObiecte sunt 





import java.util.*; 

public class ServerCmmdc extends UnicastRemoteObject implements ICmmdc0{ 

public ServerCmmdc()throws RemoteException{} 

public long compute(long m,long n)throws RemoteException{ 

. . . 

} 

} 

respectiv 





public class FabObiecte implements IFabObiecte{ 

public ICmmdc0 getCmmdc() throws RemoteException{ 

ServerCmmdc cmmdc=new ServerCmmdc(); 

return cmmdc; 

} 

public static void main(String args[]){ 




host=args[0]; 



try{ 

FabObiecte obj=new FabObiecte(); 

IFabObiecte stub=(IFabObiecte)UnicastRemoteObject.exportObject(obj,0); 


registry.bind("ObjectFactory",stub); 

System.out.println("ObjectFactory ready"); 

} 


System.out.println("Factory err "+e.getMessage()); 

} 

} 

} 

Aplicat¸ia client se compune din două clase


1. RemoteClient 

Clientul obt¸ine stub-ul serviciului, prin intermediul căruia apelează metada 

getCmmdc() a fabricii de obiecte, obt¸inând un obiect remote de tip Server- 

Cmmdc, ce implementează interfat¸a la distant¸ă ICmmdc0. 





public class RemoteClient extends UnicastRemoteObject{ 

ICmmdc0 remote=null; 

public RemoteClient() throws RemoteException{} 

public RemoteClient(String host,int port)throws RemoteException{ 

IFabObiecte fabrica=null; 

try{ 


IFabObiecte obj=(IFabObiecte)registry.lookup("ObjectFactory"); 

remote=obj.getCmmdc(); 

} 


System.out.println("ClientException: "+e.getMessage()); 

} 

} 

} 

2. ClientCmmdc0 

Apelează metoda compute a obiectului remote. 



public class ClientCmmdc0{ 





host=args[0]; 




try{ 

RemoteClient ct=new RemoteClient(host,port); 


long m=scanner.nextLong(); 


long n=scanner.nextLong(); 

long x=ct.remote.compute(m,n); 


} 

catch(Exception e){

3.3. TIPARE DE PROGRAMARE 51 


} 


} 

} 

3.3.2 Apeluri inverse – Callback 

Se nume¸ste apel invers apelarea de către programul server a unei metode a 

clientului. 

În RMI realizarea unui apel invers presupune: 

1. definirea unei interfet¸e la distant¸ă ce va fi implementat de programul client; 

2. programul client ce implementează interfat¸a extinde clasa UnicastRemote 

Object ¸si are un constructor ce aruncă o except¸ie java.rmi.RemoteException. 

Extindem aplicat¸ia anterioară cu posibilitatea suplimentară a serverului (Server- 

Cmmdc) de a alege metoda de calcul a celui mai mare divizor comun dintre 

varianta nerecursivă ¸si cea recursivă a algorimului lui Euclid. 

Extindem interfat¸a ICmmdc0 cu metoda 

public void setMethod(ICallbackCmmdc obj)throws RemoteException; 



public interface ICmmdc0 extends Remote{ 

public long compute(long m,long n) throws RemoteException; 

public void setMethod(ICallbackCmmdc obj)throws RemoteException; 

} 

unde ICallbackCmmdc este interfat¸a 



public interface ICallbackCmmdc extends Remote{ 

public String getMethod() throws RemoteException; 

} 

ce va fi implementată în clasa RemoteClient. 

Programul ServerCmmdc devine 





public class ServerCmmdc extends UnicastRemoteObject implements ICmmdc0{ 

private String method=null; 

public ServerCmmdc()throws RemoteException{} 

public long compute(long m,long n){


long x=0; 

if(method.equals("NERECURSIV")) 

x=nerecursiv(m,n); 

if(method.equals("RECURSIV")) 

x=recursiv(m,n); 

return x; 

} 

public void setMethod(ICallbackCmmdc obj)throws RemoteException{ 

method=obj.getMethod(); 

} 

private long recursiv(long a,long b){ 

if (a==b) 

return a; 

else 

if (a

3.4. OBIECTE ACTIVABILE LA DISTANT¸ Ă 53 

String method=null; 

if(x==1) 

method="NERECURSIV"; 

else 

method="RECURSIV"; 

return method; 

} 

public RemoteClient(String host,int port)throws RemoteException{ 

IFabObiecte fabrica=null; 

try{ 


IFabObiecte obj=(IFabObiecte)registry.lookup("ObjectFactory"); 

remote=obj.getCmmdc(); 

} 



} 

} 

} 

¸si 



public class ClientCmmdc0{ 





host=args[0]; 




try{ 

RemoteClient ct=new RemoteClient(host,port); 

ct.remote.setMethod(ct); 


long m=scanner.nextLong(); 


long n=scanner.nextLong(); 

long x=ct.remote.compute(m,n); 


} 



} 


} 

} 

3.4 Obiecte activabile la distant¸ă 

O instant¸ă a clasei UnicastRemoteObject reprezintă un obiect la distant¸ă 

care rulează în permanent¸ă, folosind resursele ma¸sinii server.


Începând cu versiunea JDK 1.2, prin întroducerea clasei java.rmi.activation.Activatable 

¸si a programului rmid (...\jdk...\bin\rmid.exe) se pot crea 

programe care înregistrează informat¸ii despre obiecte la distant¸ă ce vor fi create 

¸si executate la cerere. 

Invocarea de la distant¸ă a unei metode apart¸inând unui asemenea obiect are 

ca efect activarea obiectului. 

Pe fiecare ma¸sină virtuală Java există un grup de activare (activation group), 

care realizează activarea. Activarea este făcută de un activator. Un activator 

cont¸ine o tabelă care face legătura dintre clasa obiectului cu URL-ul acestuia ¸si 

eventual, cu date necesare init¸ializării obiectului. Atunci când activatorul constată 

că nu există un obiect referit, face apel la grupul de activare care va produce 

activarea obiectului. 

Din punctul de vedere al clientului utilizarea mecanismului de activare la 

distant¸ă nu implică modificări. Modificările intervin numai din punctul de vedere 

al serverului ¸si al înregistrării sale. 

Reluăm aplicat¸ia dezvoltată la începutul capitolului, privind calculul celui 

mai mare divizor comun a două numere naturale. 

Aplicat¸ia server este compusă din două clase 

1. o clasa ce implementează interfat¸a ICmmdc : CmmdcActivabil; 

2. clasa Setup, cu metoda main, care face posibilă mecanismul de activare 

¸si înscrie serviciul în registry. Această clasă este preluată din tutorialul 

dedicat activării a documentat¸iei ce însot¸e¸ste distribut¸ia Java. 

Clasa ce implementează interfat¸a la distant¸ă trebuie 

1. să extindă clasa Activatable; 

2. să aibă un constructor ce are doi parametrii 

(a) un identificator al grupului de activare, de tip ActivationID, utilizat 

de demonul de activare rmid; 

(b) un obiect de tip MarchalledObject cu date de init¸ializare a obiectului 

activabil. În cazul nostru, acest parametru nu va fi folosit. 

Codul sursă al clasei CmmdcActivabil este 

package acmmdc; 


import java.rmi.activation.*; 


public class CmmdcActivabil extends Activatable implements ICmmdc{ 

public CmmdcActivabil(ActivationID id,MarshalledObject data) throws RemoteException{ 

super(id, 0);


} 

public long cmmdc(long m,long n){. . .} 

} 

Clasa Setup necesită o serie de date furnizare ca proprietăt¸i: 

1. drepturile de securitate ale grupului de activare 

myactivation.policy=group.policy; 

cu cont¸inutul 

grant codeBase "${myactivation.impl.codebase}" { 

// permission to read and write object’s file 

permission java.io.FilePermission "${myactivation.file}","read,write"; 

// permission to listen on an anonymous port 

permission java.net.SocketPermission "*:1024-","accept"; 

}; 

2. java.class.path=no.classpath 

ceea ce previne grupul de activare să încarce o clasă din classpath-ul local; 

3. localizarea (URL) clasei ce implementează interfat¸a 

myactivation.impl.codebase; 

4. localizarea unui fi¸sier cu date de init¸ializare a obiectului activabil 

myactivation.file; 

5. numele sub care înregistrează serviciul în registry 

myactivation.name. 

Programul Setup realizează: 

1. Construirea unui descriptor al grupului de activare. Grupul de activare este 

un container ce gestionează obiectele activabile cont¸inute. 

2. 

Înregistrarea descriptorului grupului de activare ¸si obt¸inerea unui identificator 

al grupului de activare. 

3. Construirea descriptorului de activare. Trebuie cunoscute 

• idendificatorul grupului de activare; 

• numele clasei ce implementează interfat¸a la distant¸ă; 

• localizarea (URL) clasei ce implementează interfat¸a la distant¸ă;


4. 

5. 

• obiectul de tip MarchalledObject, cu datele de init¸ializare a obiectului 

activabil. 

Înregistrarea descriptorului de activare, în urma căreia se obt¸ine stub-ul 

obiectului activabil. 

Înregistrarea stub-ului împreună cu numele serviciului în registry. 

Codul clasei setup este 

package acmmdc; 


import java.rmi.activation.*; 


import java.util.Properties; 

public class Setup{ 

private Setup() {} 

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

// Argumentul liniei de comanda 

String implClass = ""; 

if (args.length < 1) { 

System.err.println("usage: java [options] examples.activation.Setup "); 


} 

else { 

implClass = args[0]; 

} 

// Construirea descriptorului grupului de activare 

String policy=System.getProperty("myactivation.policy","group.policy"); 

String implCodbase=System.getProperty("myactivation.impl.codebase"); 

String filename=System.getProperty("myactivation.file", ""); 

Properties props = new Properties(); 

props.put("java.security.policy", policy); 

props.put("java.class.path", "no_classpath"); 

props.put("myactivation.impl.codebase", implCodebase); 

if (filename != null && !filename.equals("")) { 

props.put("myactivation.file", filename); 

} 

ActivationGroupDesc groupDesc = new ActivationGroupDesc(props, null); 

// Inregistrarea grupului de activare pentr obtinerea 

// identificatorului de activare 

ActivationGroupID groupID=ActivationGroup.getSystem().registerGroup(groupDesc); 

System.err.println("Activation group descriptor registered."); 

// Construirea descriptorului de activare 

MarshalledObject data = null; 

if (filename != null && !filename.equals("")) { 

data = new MarshalledObject(filename); 

}


ActivationDesc desc=new ActivationDesc(groupID,implClass,implCodebase,data); 

// Inregistrarea descriptorului de activare 

Remote stub = Activatable.register(desc); 

System.err.println("Activation descriptor registered."); 

// Inregistrarea serviciului in registry 

String name = System.getProperty("myactivation.name"); 

LocateRegistry.getRegistry().rebind(name, stub); 

System.err.println("Stub bound in registry."); 

} 

} 

Sursele celor două programe CmmdcActivabil.java ¸si respectiv Setup.java 

sunt în catalogul \c\src\acmmdc. 

Lansarea serverului în execut¸ie constă din 

1. Pornirea demon-ului rmid 

start rmid -J-Djava.security.policy=rmid.policy 

-J-Dmyactivation.policy=group.policy 

unde rmid.policy este 

grant { 

// allow activation groups to use certain system properties 

permission com.sun.rmi.rmid.ExecOptionPermission 

"-Djava.security.policy=${myactivation.policy}"; 


"-Djava.class.path=no_classpath"; 


"-Dmyactivation.impl.codebase=*"; 


"-Dmyactivation.file=*";}; 

iar group.policy are codul 

grant codeBase "${myactivation.impl.codebase}" { 

// permission to read and write object’s file 

permission java.io.FilePermission "${myactivation.file}","read,write"; 

// permission to listen on an anonymous port 

permission java.net.SocketPermission "*:1024-","accept"; 

}; 

2. Pornirea registry-ului 

start rmiregistry 

3. Lansarea programului Setup


set classpath=\s\public\classes\cmmdc.jar;\s\public\classes 

java -Djava.rmi.server.codebase=file:/s/public/classes/ 

-Dmyactivation.impl.codebase=file:/s/public/classes/ 

-Dmyactivation.name=CmmdcServer 

-Dmyactivation.file="" 

-Dmyactivation.policy=group.policy 

acmmdc.Setup acmmdc.CmmdcActivabil 

Localizarea (URL) interfet¸ei la distant¸ă se precizează prin 

java.rmi.server.codebase; 

Drept client se utilizează programul realizat în sect¸iunea 3.1. 

3.5 RMI ¸si sistemul CORBA 

Ret¸elele de calculatoare sunt eterogene în timp ce majoritatea interfet¸elor de 

programare a aplicat¸iilor sunt orientate spre platforme omogene. 

Pentru a orienta ¸si facilita integrarea unor sisteme dezvoltate separat, într-un 

singur mediu distribuit eterogen, OMG (Object Management Group – consort¸iu 

cuprinzând peste 800 de firme) a elaborat standardul CORBA (Common Object 

Request Brocker Arhitecture): un cadru de dezvoltare a aplicat¸iilor distribuite în 

medii eterogene. 

La CORBA au aderat toate marile firme de software - cu exceptia Microsoft, 

firmă care a dezvoltat propriul său model DCOM (Distributed Component Object 

Model), incompatibil CORBA. 

CORBA cont¸ine programe client care utilizează diferite obiecte distribuite în 

sistem. Deoarece în multe sisteme de operare prelucrările trebuie să evolueze într- 

un proces, orice obiect trebuie să evolueze într-un proces. 

În alte cazuri, obiectele 

pot evolua în fire de execut¸ie sau în biblioteci dll. CORBA omogenizează aceste 

posibilităt¸i prin precizarea că obiectele există în servere. Fiecare obiect este 

asociat cu un singur server. 

Interconectarea obiectelor. Implementarea ¸si localizarea unui obiect sunt 

ascunse clientului. Comunicarea între client ¸si obiect este facilitată de Object 

Request Brocker (ORB) – care permite obiectelor să se regăseacă unele pe altele 

în ret¸ea. El ajută obiectele să facă cereri ¸si să primească răspunsuri de la alte 

obiecte aflate în ret¸ea. Acestea se desfă¸soară transparent pentru client – care nu 

¸stie unde este localizat obiectul, care este mecanismul utilizat pentru a comunica 

cu el, cum este activat sau memorat acesta. 

ORB este un pachet de servicii, independent de aplicat¸ii, dar care permit 

aplicat¸iilor să interact¸ioneze prin ret¸ea. ORB face parte din middleware – un 

intermediar între softul de ret¸ea ¸si cel de aplicat¸ie.

3.6. RMI-IIOP 59 

Un ORB se poate executa local pe un singur calculator sau poate fi conectat 

cu oricare alt ORB din Internet, folosind protocolul IIOP -- Internet Inter 

ORB Protocol, definit de CORBA 2 . 

CORBA face o separare între interfat¸a unui obiect ¸si implementarea sa ¸si 

folose¸ste un limbaj neutru pentru definirea interfet¸elor: IDL -- Interface Definition 

Language. 

IDL permite realizarea descrierii de interfet¸e independent de limbajul de programare 

¸si de sistemul de operare folosit. 

Firma SUN a dezvoltat o solut¸ie prin care programele RMI pot fi adaptate 

pentru a putea accesa obiecte CORBA. Aceasta este cunoscută sub numele 

de solut¸ia RMI-IIOP, concretizată printr-o serie de pachete din distribut¸ia 

JDK. În acest fel nu mai este necesar utilizarea limbajului IDL pentru descrierea 

interfet¸elor la distant¸ă. 

3.6 RMI-IIOP 

Instrumente necesare utilizării solut¸iei RMI-IIOP: 

• compilatorul rmic 

Opt¸iunea -iiop genereaza stub-ul ¸si legătura (tie) din partea serverului. 

Cu opt¸iunea -d se specifică catalogul în care aceste fi¸siere sunt scrise. 

• serverul care asigură regăsirea resurselor CORBA. Acest server se lansează 

în execut¸ie prin 

start orbd -ORBInitialPort [port] 

3.6.1 Transformarea unui program RMI într-un program RMI- 

IIOP 

Exemplificăm prin aplicat¸ia care implementează un serviciu de calcul a celui 

mai mare divizor comun a două numere naturale. Etapele realizării aplicat¸iei 

sunt: 

1. Elaborarea interfet¸ei este identică cu cea a aplicat¸iei RMI. 

2. Implementarea interfet¸ei 

package cmmdciiop; 

import javax.rmi.PortableRemoteObject; 



// Se extinde clasa PortableRemoteObject


// si nu UnicastRemoteObject 

public class CmmdcImpl extends PortableRemoteObject implements ICmmdc{ 

// Constructorul clasei 

public CmmdcImpl() throws RemoteException {} 


} 

3. Realizarea programului server. 


import javax.naming.InitialContext; 

import javax.naming.Context; 

public class CmmdcServer { 


try { 

// 1: Crearea unei instante CmmdcImpl 

CmmdcImpl cmmdcRef = new CmmdcImpl(); 

// 2: Inregistrarea unei referinte a serviciului 

// utilizand JNDI API 

Context initialNamingContext = new InitialContext(); 

initialNamingContext.rebind("CmmdcService", cmmdcRef ); 

System.out.println("Cmmdc Server: Ready..."); 

} 


System.out.println("CmmdcServer: " + e.getMessage()); 

} 

} 

} 

4. Compilarea programelor CmmdcImpl.java ¸si CmmdcServer.java. 

5. Generarea stub-ului cmmdc. ICmmdc Stub.class corespunzător interfet¸ei 

ICmmdc ¸si a fi¸sierului Tie cmmdciiop. CmmdcImpl Tie.class corespunzător 

clasei CmmdcImpl. Acestea se obt¸in rulând utilitarul rmic - din distrubut¸ia 

Java – cu opt¸iunea -iiop 

rmic -iiop cmmdciiop.CmmdcImpl 

6. Pornirea serverului CORBA de regăsire a serviciilor 

start orbd -ORBInitialPort 1050 

7. Lansarea serverului în execut¸ie. Trebuie fixate proprietăt¸ile 

java.naming.factory.initial=com.sun.jndi.cosnaming.CNCtxFactory 

java.naming.provider.url=iiop://localhost:1050


Cu except¸ia pct. 6, activităt¸ile legate de server se obt¸in cu fi¸sierul ant-build 

 

Server actions 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 


8. Editarea programului client. 



import java.net.MalformedURLException; 

import javax.rmi.*; 

import javax.naming.*; 




public static void main( String args[] ) { 




host=args[0]; 




System.out.println("Primul numar :"); 

long m=Long.parseLong(scanner.next()); 

System.out.println("Al doilea numar :"); 

long n=Long.parseLong(scanner.next()); 

long x=0; 

Context ic; 

Object objref; 

ICmmdc obj; 

try { 

ic = new InitialContext(); 

// 1. Obtinerea unei referinte de la serviciul CORBA 

// prin apel JNDI. 

objref = ic.lookup("CmmdcService"); 

System.out.println("Client: Obtained a ref. to Cmmdc server."); 

// 2. Asocierea referintei la serviciu cu interfata 

// si invocarea metodei 

obj = (ICmmdc) PortableRemoteObject.narrow(objref,ICmmdc.class); 



} 

catch( Exception e ) { 

System.err.println( "Exception " + e.getMessage()); 

} 

} 

} 

9. Compilarea ¸si lansarea clientului în execut¸ie. Clientul trebuie să dispună 

de fi¸sierul stub (cmmdc. ICmmdc Stub.class) ¸si bineînt¸eles de interfat¸a 

ICmmdc.jar. La apelarea clientului trebuie fixate proprietăt¸ile 

java.naming.factory.initial=com.sun.jndi.cosnaming.CNCtxFactory 

java.naming.provider.url=iiop://localhost:1050


Fi¸sierul buildfile pentru executarea clientului: 

 

Client actions 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 


 

 

 

 

 

Capitolul 4 

Elemente de programare 

distribuită prin CORBA 

4.1 Sistemul CORBA 

Introdus ¸si prezentat în capitolul Programare distribuită cu RMI, CORBA face 

o separare între interfat¸a unui obiect ¸si implementarea sa ¸si folose¸ste un limbaj 

neutru pentru definirea interfet¸elor: IDL -- Interface Definition Language. 

O interfat¸ă IDL define¸ste legătura dintre client ¸si server. 

Scopul acestei sect¸iuni este prezentarea dezvoltării unei aplicat¸ii pe baza unei 

interfet¸e bazat pe IDL. 

IDL permite realizarea descrierii de interfet¸e independent de limbajul de programare 

¸si de sistemul de operare folosit. 

Pentru dezvoltarea aplicat¸iilor în limbajul de programare Java, translatarea 

interfet¸ei IDL în Java se realizează cu utilitarul idlj din distribut¸ia jdk. 

Corespondent¸a între entităt¸ile IDL ¸si Java este dată în Tabelul 4.1 

4.2 Aplicat¸ie Java distribuită prin CORBA 

Mecanismul care leagă cererea unui client de codul serviciului care satisface 

cererea poartă numele Portable Object Adapter (POA). 

4.2.1 Model cu server temporal 

Exemplificăm dezvoltarea unei aplicat¸ii distribuite CORBA în cazul în care 

serviciul pus la dispozit¸ie de server este calculul celui mai mare divizor comun a 

două numere naturale. 

Dezvoltarea unei aplicat¸ii distribuite CORBA cu mediul nativ Java presupune 

parcurgerea urmatoarelor pa¸si: 

65

66 CAPITOLUL 4. PROGRAMARE DISTRIBUITĂ PRIN CORBA 

Tip IDL Tip Java 

module package 

boolean boolean 

char, wchar char 

octet byte 

string, wstring java.lang.String 

short, unsigned short short 

long, unsigned long int 

long long, unsigned long long long 

float float 

double double 

fixed java.math.BigDecimal 

enum, struct, union class 

sequence, array array 

interface (non-abstract) signature interface, 

operations interface, 

helper class, holder class 

Any org.omg.CORBA.Any 

Table 4.1: Entităt¸i IDL ¸si Java 

1. Realizarea interfet¸ei IDL care înseamnă 

(a) Editarea programului de interfat¸ă: 

module CmmdcApp{ 

interface Cmmdc{ 

long long cmmdc(in long long a,in long long b); 

}; 

}; 

Salvăm acest text într-un fi¸sier denumit Cmmdc.idl. 

Cmmdc va fi numele serviciului căutat de un client ¸si implementat de 

server. Serviciul cont¸ine o singură metodă cmmdc. 

(b) Translatarea în Java 

idlj -fall Cmmdc.idl 

Programul idlj crează un subcatalog CmmdcApp cu un pachet Java CmmdcApp 

cont¸inând fi¸sierele: 

• Cmmdc.java

4.2. APLICAT¸ IE JAVA DISTRIBUITĂ PRIN CORBA 67 

• CmmdcPOA.java ; 

• CmmdcOperations.java; 

• CmmdcStub.java; 

• CmmdcHelper.java; 

• CmmdcHolder.java. 

2. Realizarea programelor server. Punem în evident¸a programul servant CmmdcImpl.java 

ce implementează interfat¸a Cmmdc. 

import CmmdcApp.*; 

import org.omg.CORBA.*; 

public class CmmdcImpl extends CmmdcPOA { 

private ORB orb; 

public CmmdcImpl(ORB orb){ 

this.orb = orb; 

} 


} 

¸si programul CmmdcServer.java, care înscrie în registrul ORB referint¸ele 

servantului. Activităt¸ile ce trebuie întreprinse sunt declarate prin comentarii 

în textul sursă al programului 


import org.omg.CosNaming.*; 

import org.omg.CosNaming.NamingContextPackage.*; 


import org.omg.PortableServer.*; 

public class CmmdcServer { 


try{ 

// crearea si initializarea ORB 

ORB orb = ORB.init(args, null); 

// obtinerea unei referinte rootpoa si activarea managerului POAManager 

POA rootpoa = POAHelper.narrow(orb.resolve_initial_references("RootPOA")); 

rootpoa.the_POAManager().activate(); 

// crearea unui servant 

CmmdcImpl cmmdcImpl = new CmmdcImpl(orb); 

// obtinerea unei referinte a servantului 

org.omg.CORBA.Object ref = rootpoa.servant_to_reference(cmmdcImpl); 

Cmmdc href = CmmdcHelper.narrow(ref); 

// Obtinerea serviciului NameService 

org.omg.CORBA.Object objRef = 

orb.resolve_initial_references("NameService");


NamingContextExt ncRef = NamingContextExtHelper.narrow(objRef); 

// legarea referintei servantului in serviciul NameService 

String name = "CmmdcService"; 

NameComponent path[] = ncRef.to_name( name ); 

ncRef.rebind(path, href); 

System.out.println("CmmdcServer ready and waiting ..."); 

// in asteptarea clientilor 

orb.run(); 

} 


System.err.println("ERROR: " + e); 

e.printStackTrace(System.out); 

} 

System.out.println("CmmdcServer Exiting ..."); 

} 

} 

3. Realizarea programului client CmmdcClient.java: 



import org.omg.CosNaming.NamingContextPackage.*; 



public class CmmdcClient{ 

static Cmmdc cmmdcImpl; 


try{ 

// crearea si initializarea unui reprezentant ORB 


// obtinerea unei referinte pentru serviciul denumirilor 

// serviciilor inregistrate 

org.omg.CORBA.Object objRef = 

orb.resolve_initial_references("NameService"); 

NamingContextExt ncRef = NamingContextExtHelper.narrow(objRef); 

// obtinerea unei referinte la serviciul dorit 

String name = "CmmdcService"; 

cmmdcImpl = CmmdcHelper.narrow(ncRef.resolve_str(name)); 

System.out.println("Obtained a handle on server object: " + cmmdcImpl); 


long m,n; 





System.out.println("Cmmdc="+cmmdcImpl.cmmdc(m,n)); 

} 


System.out.println("ERROR : " + e) ; 

e.printStackTrace(System.out);


} 

} 

} 

Programele se compilează 

javac CmmdcApp\*.java 

4. Pornirea serviciului de intregistrare a numelor cu programul orbd.exe din 

distribut¸ia jdk. 

start orbd -ORBInitialHost localhost -ORBInitialPort 1050 

5. Pornirea programului server prin 

start java CmmdcServer -ORBInitialHost localhost -ORBInitialPort 1050 

6. Lansarea programului client prin 

java CmmdcClient -ORBInitialHost localhost -ORBInitialPort 1050 

4.2.2 Model cu server persistent 

Se consideră acea¸si interfat¸ă Cmmdc.idl. 

Partea de server este alcătuită din clasa servant CmmdcImpl.java care implementează 

interfat¸a Cmmdc -prezentat în sect¸iunea anterioară ¸si clasa PersistentServer 

care asigură 

• legătura cu serviciile ORB; 

• accesul la clasa servantului. 




import org.omg.PortableServer.*; 

public class PersistentServer{ 

public static void main( String args[] ) { 

Properties properties = System.getProperties(); 

properties.put( "org.omg.CORBA.ORBInitialHost","localhost" ); 

properties.put( "org.omg.CORBA.ORBInitialPort","1050" ); 

try { 

// Pas 1: Instantiere ORB 

ORB orb = ORB.init(args, properties);


// Pas 2: Instantierea servantului 

CmmdcImpl servant = new CmmdcImpl(orb); 

// Pas3 3 : Crearea unui obiect POA cu securitatea Persistent Policy 

// ******************* 

// Pas 3-1: Obtinerea radacinii rootPOA 

POA rootPOA = POAHelper.narrow(orb.resolve_initial_references("RootPOA")); 

// Pas 3-2: Create securitatii Persistent Policy 

Policy[] persistentPolicy = new Policy[1]; 

persistentPolicy[0] = rootPOA.create_lifespan_policy( 

LifespanPolicyValue.PERSISTENT); 

// Pas 3-3: Crearea obiectului POA cu securitatea the Persistent Policy 

POA persistentPOA = rootPOA.create_POA("childPOA",null,persistentPolicy ); 

// Pas 3-4: Activarea managerului PersistentPOA POAManager, 

persistentPOA.the_POAManager().activate( ); 

// *********************** 

// Pas 4: Asocierea servantului cu PersistentPOA 

persistentPOA.activate_object( servant ); 

// Pas 5: Fixarea contextului RootNaming si legarea de numele servantului 

// Numele serviciului ORBD : ’NameService’ 

// Numele servantului ’PersistentCmmdcServer’ 

org.omg.CORBA.Object obj = orb.resolve_initial_references("NameService"); 

NamingContextExt rootContext = NamingContextExtHelper.narrow( obj ); 

NameComponent[] nc = rootContext.to_name("PersistentCmmdcServer"); 

rootContext.rebind( nc, persistentPOA.servant_to_reference( servant ) ); 

// Pas 6: Gata pentru receptia cererilor clientilor 

orb.run(); 

} 

catch ( Exception e ) { 

System.err.println( "Exception in Persistent Server Startup " + e ); 

} 

} 

} 

Programul client 




import org.omg.PortableServer.POA; 

import CmmdcApp.CmmdcHelper; 

import CmmdcApp.Cmmdc; 


public class PersistentClient { 



String port="1050"; 


host=args[0]; 


port=args[1]; 

try {


// Pas 1: Initializare ORB 


// Pas 2: Rezolvarea persistentei 

// Serviciul NameService ruleaza pe host cu portul port 

// Numele serviciului cerut lui NameService este 

// "PersistentCmmdcServer" 

org.omg.CORBA.Object obj = orb.string_to_object( 

"corbaname::"+host+":"+port+"#PersistentCmmdcServer"); 

Cmmdc cmmdc=CmmdcHelper.narrow(obj); 

// Pas 3: Utilizarea serviciului 


System.out.println( "Calling Persistent Server.." ); 

int m,n,r; 


m=scanner.nextInt(); 


n=scanner.nextInt(); 

System.out.println(cmmdc.cmmdc(m,n)); 

} 

catch ( Exception e ) { 

System.err.println( "Exception in PersistentClient.java..." + e ); 

e.printStackTrace( ); 

} 

} 

} 

Serverul trebuie să fie pe acela¸si calculator pe care rulează orbd. Executarea 

aplicat¸iei presupune: 

1. Pornirea serviciului de intregistrare a numelor cu programul orbd.exe din 

distribut¸ia jdk. 

start orbd -ORBInitialPort 1050 -serverPollingTime 200 

2. Activarea serverului: 

(a) Se lansează utilitarul servertool 

servertool -ORBInitialPort 1050 

(b) Se înregistrează serverul împreună cu numele serviciului pe care îl 

îndepline¸ste: 

servertool > register -server PersistentServer 

-applicationName PersistentCmmdcServer 

-classpath cale_catre_fisierele_server 

3. Executarea clientului 

java PersistentClient [hostORB [portORB]]

72 CAPITOLUL 4. PROGRAMARE DISTRIBUITĂ PRIN CORBA

Capitolul 5 

Mesaje în Java 

Comunicat¸ia prin apelul la distant¸ă - inclusiv RMI - este sincron: programul 

apelant se blochează ¸si a¸steaptă ca metoda apelată să se termine ¸si să furnizeze 

rezultatul cerut. Cu alte cuvinte apelul de procedură la distant¸ă cere atât clientului 

cât ¸si serverului să fie simultan disponibile. 

Comunicat¸iile asincrone între programe permit realizarea unor sisteme de programe 

cu un grad mult mai scăzut de cuplare. 

5.1 Java Message Service (JMS) 

JMS define¸ste un cadru de programare Java (API) pentru realizarea aplicat¸iilor 

bazate pe comunicat¸ii asincrone. Există mai multe implementări JMS, dintre care 

semnalăm: 

• Sun Java System Message Queue a firmei Sun. Versiunea Platform Edition 

este gratuită. 

• ActiveMQ realizată de fundat¸ia apache. 

O aplicat¸ie JMS este alcătuită din 

• un furnizor JMS (provider JMS) : un sistem de mesagerie ce implementează 

specificat¸iile JMS; 

• client JMS : aplicat¸ie Java care trimite ¸si recept¸ionează mesaje; 

• mesaje : obiecte utilizate în schimbul de informat¸ii de client¸i JMS; 

• obiecte administrator : obiecte (resurse) create de administrator pentru a fi 

utilizate de client¸ii JMS, precum fabrica de conexiuni, obiectele destinat¸ie 

împreună cu resursele lor. 

73

74 CAPITOLUL 5. MESAJE ÎN JAVA 

Modele de comunicat¸ie: 

• Comunicat¸ii punctuale : Un mesaj este generat de un producător (expeditor) 

¸si la care va avea acces un singur consumator (destinatar). Mesajul 

este depus într-o coadă, de unde este preluat de către consumatorul care 

s-a legat de coadă. Dacă de coadă nu se leagă nici un consumator, atunci 

mesajul este păstrat în coadă. 

• Comunicat¸ii axate pe subiect (topic) : Mesajele sunt depuse (publicate) în 

destinat¸ii specifice subiectului. Consumatorii ce au subscris la acel subiect 

au acces la mesajele respective. Mai multi producători pot genera mesaje 

specifice unui subiect, mesaje care pot fi accesate de consumatorii care au 

subscris subiectului. 

Structura unui mesaj Un mesaj este alcătuit din 

• Antet (header) : cont¸ine informat¸ii pentru identificarea destinat¸iei cât ¸si 

pentru identificarea mesajului. 

• Proprietăt¸i : au caracter opt¸ional ¸si sunt sub forma (nume, valoare). Proprietăt¸ile 

ajută consumatorii să selecteze mesajele. 

• Corpul mesajului : opt¸ional. Potrivit specificat¸iilor JMS există 6 tipuri de 

mesaje. 

– Message : mesaj fără corp; 

– StreamMessage : corpul mesajului cont¸ine un flux Java de date de tip 

predefinit; 

– ByteMessage : 

– MapMessage : corpul mesajului cont¸ine o familie de perechi (nume, 

valoare); 

– TextMessage : corpul mesajului cont¸ine un string; 

– ObjectMessage : corpul mesajului cont¸ine un obiect serializat. 

5.2 Sun Java System Message Queue 

Instalarea. Funct¸ie de resursa descărcată, în mediul Windows, instalarea 

constă din 

• Se dezarhivează fi¸sierul mq* *-installer-WINNT.zip ¸si se lansează în execut¸ie 

programul de instalare. 

• Se dezarhivează fi¸sierul mq* *-binary-WINNT*.jar ¸si se fixează atributele 

fi¸sierului mq\etc\imqenv.conf.

5.3. APACHE ACTIVEMQ 75 

Lansarea serviciului JMS. Orice aplicat¸ie JMS necesită funct¸ionarea serviciului 

JMS. Serviciul JMS se instalează prin 

imqbrokerd -tty 

Opt¸iunea -tty are ca efect afi¸sarea mesajelor pe ecran. Funct¸ionarea corectă este 

indicată prin mesajul 

imqbroker@hostname:7676 ready 

Dacă se dore¸ste schimbarea portului atunci se folose¸ste opt¸iunea -port port. 

Pe un calculator pot coexista mai multe servicii JMS doar dacă folosesc porturi 

distincte ¸si au nume diferite. În acest caz, lansarea unui nou serviciu se face 

prin 

imqbrokerd -tty -port port -name name 

Cu utilitarul imqsvcadmin putem 

• dezinstala : imqsvcadmin remove 

• verifica : imqsvcadmin query 

• instala : imqsvcadmin install 

serviciul JMS ca serviciu Windows. Dezinstalarea ¸si instalarea are efect odată cu 

repornirea calculatorului. 

Compilarea ¸si executarea unui program necesită completarea variabilei 

sistem classpath cu fi¸sierele 

• JMS HOME\lib\jms.jar 

• JMS HOME\lib\imq.jar 

5.3 Apache ActiveMQ 

Instalarea se face dezarhivând fi¸sierul descărcat într-un catalog ACTIVEMQ HOME. 

Acest fi¸sier este specific sistemului de operare utilizat, Windows sau Linux. 

Lansarea serverului JMS se obt¸ine prin 

set JAVA_HOME=. . . 

set ACTIVEMQ_HOME=. . . 

set PATH=%ACTIVEMQ_HOME%\bin;%PATH% 

activemq 

În cazul unui calculator izolat este nevoie de instalarea driver-ului Microsoft loopback 

Adaptor care sinulează existent¸a funct¸onării unei plăci de ret¸ea active. 

Distribut¸ia apache-activemq-5.0.0 cont¸ine, ca exemplu, clasa EmbeddedBroker.java 

care lansează serverul JMS în lucru. 

Compilarea unui program necesită prezent¸a în variabila de sistem classpath 

a referint¸ei către fi¸sierul ACTIVEMQ HOME\activemq-all-*.*.*.jar. Pentru execut¸ie, 

variabila de sistem classpath nevoie să cont¸ină referint¸ele către fi¸sierele jar din 

catalogul ACTIVEMQ HOME\lib.


5.4 Elemente de programare - JMS 

5.4.1 Trimiterea unui mesaj 

Trimiterea unui mesaj necesită: 

1. Generarea unei fabrici de conexiuni. Fabrica de conexiuni este un obiect 

administrator. Această operat¸ie este specifică distribut¸iei JMS. 

• 

În cazul de fat¸a folosim obiectele create prin MessageQueue. 

Se poate obt¸ine prin 

ConnectionFactory cf= 

new com.sun.messaging.ConnectionFactory(); 

Clasa com.sun.messaging.ConnectionFactory cont¸ine metoda 

setProperty( String name, String value) prin intermediul căreia 

se precizează calculatorul ¸si portul furnizorului de servicii JMS, fixând 

atributele "imqBrokerHostName" ¸si respectiv "imqBrokerHostPort". 

• Utilizând apache-activemq, fabrica de conexiuni se obt¸ine prin 

org.apache.activemq.ActiveMQConnectionFactory cf= 

new org.apache.activemq.ActiveMQConnectionFactory 

("tcp://host:61616"); 

2. Generarea conexiunii. 

Se realizează prin 

Connection conn=cf.createConnection(); 

Pentru realizarea acestui obiectiv se utilizează metoda createConnection, 

după caz, dintr-una din clasele 

class ConnectionFactory{ 

Connection createConnection() throws JMSException; 

Connection createConnection(String userName,String password) 

throws JMSException; 

} 

class QueueConnectionFactory{ 

QueueConnection createQueueConnection() throws JMSException; 

QueueConnection createQueueConnection(String userName, 

String password) throws JMSException; 

} 

class TopicConnectionFactory{

5.4. ELEMENTE DE PROGRAMARE - JMS 77 

} 

TopicConnection createTopicConnection() throws JMSException; 

TopicConnection createTopicConnection(String userName, 

String password) throws JMSException; 

unde Connection, QueueConnection, TopicConnection sunt interfet¸e. 

Amintim următoarele metode ale unei interfet¸e Connection 

interface Connection{ 

Session createSession(boolean transacted, 

int acknowledgeMode) throws JMSException; 

void start() throws JMSException; 

void close() throws JMSException; 

} 

interface QueueConnection{ 

QueueSession createQueueSession(boolean transacted, 




} 

interface TopicConnection{ 

TopicSession createTopicSession(boolean transacted, 




} 

Un obiect ce implementează interfat¸a Connection asigură legătura clientului 

cu furnizorul JMS. Acest obiect este creat de fabrica de conexiuni. 

Un client JMS trebuie să închidă conexiunile create. 

Metoda start() asigură pornirea sau repornirea conexiunii în vederea 

recept¸ionării mesajelor sosite. 

3. Crearea unei sesiuni de lucru se face cu o metodă createSession(). 

Session session=conn.createSession(false, 

Session.AUTO_ACKNOWLEDGE); 

Primul argument asigură (true) sau nu (false) caracterul indivizibil al 

unităt¸ii de lucru, adică al unei sesiuni. 

Al doilea argument indică modul de confirmare al receptării mesajului.


Un obiect de tip Session define¸ste un context format dintr-un singur fir de 

execut¸ie în care are loc producerea ¸si consumul de mesaje. 

Sunt definite 

interface Session{ 

| MessageProducer createProducer(Destination destination); 

| MessageConsumer createConsumer(Destination destination); 

| Message createMessage(); 

| TextMessage createTextMessage(); 

| TextMessage createTextMessage(String s); 

| StreamMessage createStreamMessage(); 

| MapMessage createMapMessage(); 

| ObjectMessage createObjectMessage(); 

| ObjectMessage createObjectMessage(Serializable object); 

| BytesMessage createBytesMessage(); 

| } 

|->interface QueueSession{ 

| QueueSender createQueueSender(Queue queue); 

| QueueReceiver createQueueReceiver(Queue queue); 

| } 

|->interface TopicSession{ 

TopicPublisher createPublisher(Topic topic); 

TopicSubscriber createSubscriber(Topic topic); 

TopicSubscriber createDurableSubscriber(Topic topic, 

String name); 

} 

4. Generarea obiectului destinat¸ie. 

În cazul comunicat¸iilor punctuale obiectul destinat¸ie este de tip Queue, iar 

crearea se face prin 

Destination numeDestinatie=sesssion.createQueue(String numeCoada) 

iar pentru comunicat¸ii axate pe subiect obiectul destinat¸ie, de tip Topic se 

instant¸iază prin 

Destination numeDestinatie=sesssion.createTopic(String numeSubiect) 

Sunt definite arborescent¸ele: 

interface Destination


| 

|->interface Queue 

| 

|->interface Topic 

class Destination implements Destination 

| 

|->class Queue implements Destination, Queue, Serializable 

| 

|->class Topic implements Destination, Topic, Serializable 

Utilizând Sun Java System Message Queue obiecte de tip Queue sau Topic 

se pot crea ¸si prin 

Queue q=new com.sun.messaging.Queue(String numeCoada); 

Topic t=new com.sun.messaging.Topic(String numeSubiect); 

5. Generarea producătorului de mesaje. Se realizează prin 

MessageProducer producer=session.createProducer(obiectDestinatie); 

Sunt definite interfet¸ele 

interface MessageProducer{ 

void send(Message mesaj); 

} 

interface QueueSender{ 

void send(Message mesaj); 

} 

interface TopicPublisher{ 

void publish(Message mesaj); 

} 

6. Generarea mesajelor. Un mesaj de tip TextMessage se poate crea prin 

TextMessage m=session.createTextMessage(); 

m.setText(string); 

7. Expedierea mesajelor se face cu metoda send(...) a producătorului de 

mesaje.


Exemplul 5.4.1 Clasa următoare generează într-un fir de execut¸ie, un număr 

de mesaje de tip TextMessage într-o comunicat¸ie punctuală. Sfâr¸situl expedierii 

mesajelor se indică prin generarea unui mesaj de tip Message. Numărul 

mesajelor este indicat de un parametru al constructorului. 

import javax.jms.*; 

public class MsgSenderT extends Thread{ 

int n; 

String queueName; 

MsgSenderT(String queueName,int n){ 

this.queueName=queueName; 

this.n=n; 

} 


try{ 

// Varianta Sun Message Queue 

com.sun.messaging.QueueConnectionFactory cf= 

new com.sun.messaging.QueueConnectionFactory(); 

// setProperty este metoda a clasei com.sun.messaging.QueueConnnectionFactory 

// ce implementeaza interfata QueueConnectionFactory 

// dar nu este a interfetei QueueConnectionFactory. 

//cf.setProperty("imqBrokerHostName","host"); 

//cf.setProperty("imqBrokerHostPort","7676"); 

// Varianta Apache-MessageQueue 

// org.apache.activemq.ActiveMQConnectionFactory cf= 

// new org.apache.activemq.ActiveMQConnectionFactory("tcp://localhost:61616"); 


Session session=conn.createSession(false,Session.AUTO_ACKNOWLEDGE); 

Destination q=session.createQueue(queueName); 

MessageProducer producer=session.createProducer(q); 


for(int i=0;i


5.4.2 Recept¸ia sincronă a unui mesaj 

Primele patru act¸iuni sunt identice cu cele de la trimiterea unui mesaj, adică 

1. Generarea unei fabrici de conexiuni. 

2. Generarea conexiunii. 

3. Crearea unei sesiuni de lucru. 

4. Generarea obiectului destinat¸ie. 

5. Generarea consumatorului de mesaje. Se realizează prin 

MessageConsumer consumer=session.createConsumer(q); 

Sunt definite interfet¸ele 

interface MessageConsumer{ 

| Message receive(); 

| Message receive(long timeout); 

| Message receiveNoWait(); 

| } 

|-> interface QueueReceiver 

| 

|-> interface TopicSubscriber 

6. Recept¸ia mesajelor se face cu una din metodele consumatorului de mesaje: 

• Message receive() 

• Message receive(long timeout) 

• Message receiveNoWait() 

Exemplul 5.4.2 Recept¸ia de tip sincron a mesajelor într-un fir de execut¸ie este 

efectuat de clasa următoare: 


public class SyncMsgReceiverT extends Thread{ 


SyncMsgReceiverT(String queueName){ 


} 


try{ 

// Varianta Sun Message Queue




// setProperty este metoda a clasei QueueConnnectionFactory 


// dar nu este a interfetei. 




//org.apache.activemq.ActiveMQConnectionFactory cf= 




Destination q=session.createQueue(queueName); 


conn.start(); 

Message msg=null; 

while((msg=consumer.receive())!=null){ 

if(msg instanceof TextMessage){ 

TextMessage m=(TextMessage)msg; 

System.out.println(m.getText()); 

} 

else 

break; 

} 

session.close(); 

conn.close(); 

} 


System.out.println("JMSException : "+e.getMessage()); 

} 

System.out.println("Consumer finished"); 

} 

} 

Exemplul 5.4.3 Trimiterea ¸si recept¸ia mesajelor se face prin aplicat¸ia 

class MsgHelloT{ 


int n=3; 

String queueName="MyQueue"; 


queueName=args[0]; 


n=Integer.parseInt(args[1]); 

MsgSenderT sender=new MsgSenderT(queueName,n); 

SyncMsgReceiverT receiver =new SyncMsgReceiverT(queueName); 

receiver.start(); 

sender.start(); 

} 

} 

5.4.3 Recept¸ia asincronă a unui mesaj 

Recept¸ia asincronă a mesajelor presupune implementarea interfet¸ei 

MessageListener ce cont¸ine o singură metodă


public void onMessage(Message mesaj); 

care fixează prelucrarea mesajului. 

Metoda MessageConsumer.setMessageListener(MessageListener obj ) fixează 

obiectul ce implementează interfat¸a Messagelistener. 

Exemplul 5.4.4 În ideea exemplelor anterioare, un consumator de tip asincron 

al mesajelor este dat în clasa următoare: 


public class AsyncMsgReceiverT extends Thread{ 


AsyncMsgReceiverT(String queueName){ 


} 


try{ 




// setProperty este metoda a clasei QueueConnnectionFactory 


// dar nu este a interfetei. 








Destination q==session.createQueue(queueName); 


TextListener textListener=new TextListener(); 

consumer.setMessageListener(textListener); 

conn.start(); 

textListener.run(); 

conn.close(); 

} 



} 

System.out.println("Consumer finished"); 

} 

} 


public class TextListener implements MessageListener{ 

boolean sfarsit=false; 

public void onMessage(Message message){ 

if(message instanceof TextMessage){ 

TextMessage m=(TextMessage)message; 

try{ 

System.out.println(m.getText());


} 

catch(JMSException e){ 


} 

} 

else 

sfarsit=true; 

} 


while(!sfarsit); 

} 

} 

5.4.4 Publicarea mesajelor 

Publicarea mesajelor corespunzătoare unui subiect se face asemănător cu 

transmiterea mesajelor în comunicat¸ia punctuală, dar folosind instant¸e ale claselor 

dedicate acestui tip de comunicat¸ie. 



public class MsgPublisherT extends Thread{ 

int n; 

String subiect; 

MsgPublisherT(String subiect,int n){ 

this.n=n; 

this.subiect=subiect; 

} 


try{ 


com.sun.messaging.TopicConnectionFactory cf= 

new com.sun.messaging.TopicConnectionFactory(); 




// org.apache.activemq.ActiveMQConnectionFactory cf= 


TopicConnection conn=cf.createTopicConnection(); 

TopicSession session=conn.createTopicSession(false,Session.AUTO_ACKNOWLEDGE); 

Destination t = session.createTopic(subiect); 

MessageProducer producer = session.createProducer(t); 

//Topic t=new com.sun.messaging.Topic(subiect); 

//TopicPublisher publisher=session.createPublisher(t); 


for(int i=0;i


//publisher.publish(m); 

} 

producer.send(session.createMessage()); 

//publisher.publish(session.createMessage()); 


conn.close(); 

} 



} 

System.out.println("Publisher finished"); 

} 

} 

Varianta comentată este o solut¸ie specifică implementării Sun Java System 

Message Queue. 

5.4.5 Subscrierea ¸si recept¸ia mesajelor 

Dacă t este obiectul de tip Destination, client¸ii se abonează - subscriu - 

unui subiect prin 

TopicSubscriber consumer=session.createSubscriber((Topic)t); 

Subscrierea este este valabilă atâta timp cât clientul este activ. Pentru a primi 

toate mesajele specifice subiectului, chiar ¸si când clientul este inactiv, acesta 

trebuie să fie durabil, adică crearea consumatorului să se facă prin 

conn.setClientID("myID"); 

TopicSubscriber consumer=session.createDurableSubscriber((Topic)t,"nameClient"); 

În ambele cazuri, clientul prime¸ste doar mesajele publicate din momentul subscrierii. 



public class MsgSubscriberT extends Thread{ 

String subiect; 

String clientID; 

String clientName; 

MsgSubscriberT(String subiect,String clientID, String clientName){ 

this.subiect=subiect; 

this.clientID=clientID; 

this.clientName=clientName; 

} 


try{ 


com.sun.messaging.TopicConnectionFactory cf=









conn.setClientID(clientID); 


Destination t = session.createTopic(subiect); 

TopicSubscriber consumer=session.createDurableSubscriber((Topic)t,clientName); 

conn.start(); 



if(msg instanceof TextMessage){ 

TextMessage m=(TextMessage)msg; 

System.out.println(clientName+" received : "+m.getText()); 

} 

else 

break; 

} 


conn.close(); 

} 



} 

} 

} 

Apelarea celor două activităt¸i se face prin 


class MsgPS{ 


String subiect="JMS"; 

int n=3,noAbonati=3; 


subiect=args[0]; 


n=Integer.parseInt(args[1]); 

MsgPublisherT publisher=new MsgPublisherT(subiect,n); 

MsgSubscriberT[] abonat=new MsgSubscriberT[noAbonati]; 

publisher.start(); 

for(int i=0;i

5.5. MESAJE SOAP PRIN JAVA MESSAGE SERVICE 87 

5.5 Mesaje SOAP prin Java Message Service 

Rezultatele acestei sect¸iuni sunt valabile doar în cazul pachetului Sun Java 

System Message Queue. 

5.5.1 SOAP 

SOAP - Simple Object Access Protocol - este un protocol de comunicat¸ii 

între aplicat¸ii. În prezent SOAP este protocolul standard pentru servicii Web 

prin Internet. SOAP este independent de platforma de calcul ¸si de limbajul de 

programare. 

SOAP se bazează pe XML (eXtended Markup Language) ¸si este un standard 

W3C (World Wide Web Consortium). 

5.5.2 Mesaje SOAP 

Un mesaj SOAP este un document XML constând din 

• o învelitoare (envelope) care poate cont¸ine 

• un număr arbitrar de antete (header); 

• un corp (body); 

• un număr variabil de obiecte ata¸sate (attachments) MIME (Multipurpose 

Internet Mail Exchange). 

Astfel un mesaj SOAP apare sub forma documentului XML 

 

 

 

 

 

 

 

Facilităt¸ile Java de manipulare a mesajelor SOAP sunt cont¸inute în pachetul 

javax.xml.soap. 

În acestă sect¸iune vom crea mesaje SOAP, le transformăm în mesaje JMS pe 

care le trimitem furnizorului JMS, de unde un client le recept¸ionează, după care 

transformă mesajul JMS în mesaj SOAP ¸si regăse¸ste datele expediate. Solut¸ia 

este specifică implementării Sun Java System Message Queue. Pachetul javax.xml.soap 

aflat în distribut¸ia jdk cont¸ine resursele necesare programării mesajelor SOAP.


Crearea unui mesaj SOAP 

MessageFactory mf=MessageFactory.newInstance(); 

SOAPMessage soapMsg=mf.createMessage(); 

Mesajul creat are definită structura de bază a mesajului SOAP: invelitoarea, 

un antetul ¸si corpul. Aceste elemente pot fi accesate prin 

SOAPPart part=soapMsg.getSOAPPart(); 

SOAPEnvelope envelope=part.getEnvelope(); 

SOAPHeader header=envelope.getHeader(); 

SOAPBody body=envelope.getBody(); 

Completarea corpului unui mesaj SOAP 

Generăm numele elementului, ”e1” în cazul exemplului, 

Name n1=envelope.createName("e1"); 

În body un element se poate include, pe baza numelui creat prin 

SOAPElement e1=body.addBodyElement(n1); 

În general, un element se include în elementul părinte, care pote fi chiar ¸si body, 

prin metoda clasei SOAPElement 

SOAPElement addChildElement(Name name) 

Completăm elementul e1 cu un text: ”primul”, prin 

e1.addTextNode("primul"); 

Exemplul 5.5.1 Mesajul SOAP 

 

 

 

 

primul 

 

al treilea 

 

 

 

al doilea 

 

 

 

se obt¸ine cu programul


import javax.xml.soap.*; 


public class MsgSOAP{ 


Name name=null; 

try{ 








e1.addTextNode("primul"); 



e2.addTextNode("al doilea"); 

Name n11 =envelope.createName("e11"); 

SOAPElement e11=e1.addChildElement(n11); 

e11.addTextNode("al treilea"); 

FileOutputStream f=new FileOutputStream("MySOAPMessage.xml"); 

soapMsg.writeTo(f); 

} 


System.out.println("Exception : "+e.getMessage()); 

} 

} 

} 

Un mesaj SOAP se poate salva într-un fi¸sier text cu 

FileOutputStream f=new FileOutputStream(. . .); 


Transformarea unui mesaj SOAP în mesaj JMS 

SOAPMessage soapMsg=. . . 

Message msg= 

MessageTransformer.SOAPMessageIntoJMSMessage(soapMsg,session); 

Transformarea unui mesaj JMS în mesaj SOAP 

MessageFactory mf=. . . 

Message msg=. . . 

SOAPMessage soapMsg = 

MessageTransformer.SOAPMessageFromJMSMessage(msg,mf); 

Preluarea elementelor din corpul unui mesaj SOAP 

SOAPBody body=. . . 

SOAPBodyElement element=null;


Iterator iterator=body.getChildElements(); 

while(iterator.hasNext()){ 

element=(SOAPBodyElement)iterator.next(); 

String name=element.getElementName(); 

if(name.getLocalName().equals("numeCamp")){ 

String s=element.getValue(); 

. . . 

} 

} 

Exemplul 5.5.2 Un client introduce într-un mesaj SOAP două numere întregi, 

transmite mesajul altui program care calculează cel mai mare divizor comun al 

celor două numere ¸si transmite clientului rezultatul tot sub forma unui mesaj 

SOAP. 

Activitatea clientului este se compune din 

• Transmiterea către server a cererii. Mesajul este alcătuit din cele două 

numere ¸si un topic, în care va găsi răspunsul. 



import com.sun.messaging.xml.MessageTransformer; 


public class MsgSOAPClientSender{ 

long a,b; 

String topicResult; 

String clientID,clientName; 

MsgSOAPClientSender(String clientID,String clientName){ 




System.out.println("Introduceti m :"); 

a=scanner.nextLong(); 

System.out.println("Introduceti n :"); 

b=scanner.nextLong(); 

System.out.println("Introduceti ’Topic’-ul raspunsului"); 

topicResult=scanner.next(); 

} 

public void service(){ 

MessageFactory mf=null; 

SOAPMessage soapMsg=null; 

SOAPPart part=null; 

SOAPEnvelope envelope=null; 

SOAPBody body=null; 

SOAPElement elem=null; 


try{ 

com.sun.messaging.TopicConnectionFactory cf=



//cf.setProperty("imqBrokerHostName","atlantis"); 





Destination tDate=session.createTopic("Cmmdc"); 

MessageProducer producer=session.createProducer(tDate); 

mf=MessageFactory.newInstance(); 

soapMsg=mf.createMessage(); 

part=soapMsg.getSOAPPart(); 

envelope=part.getEnvelope(); 

body=envelope.getBody(); 

name=envelope.createName("n1"); 

elem=body.addChildElement(name); 

elem.addTextNode((new Long(a)).toString()); 

name=envelope.createName("n2"); 


elem.addTextNode((new Long(b)).toString()); 

name=envelope.createName("topic"); 


elem.addTextNode(topicResult); 

Destination tResult=session.createTopic(topicResult); 

TopicSubscriber consumer= 

session.createDurableSubscriber((Topic)tResult,clientName); 

Message m= 


producer.send(m); 

FileOutputStream f=new FileOutputStream("MySOAPMessage.xml"); 


conn.close(); 

} 



} 

System.out.println("Sender finished"); 

} 


if(args.length


String clientID,clientName; 

MsgSOAPClientReceiver(String clientID,String clientName){ 




System.out.println("Introduceti ’Topic’-ul raspunsului"); 

topicResult=scanner.next(); 

} 







SOAPBodyElement element=null; 


try{ 







TopicSession session=conn.createTopicSession(false, 



TopicSubscriber consumer= 

session.createDurableSubscriber((Topic)tResult,clientName); 


conn.start(); 

Message msg=consumer.receive(); 

soapMsg=MessageTransformer.SOAPMessageFromJMSMessage(msg,mf); 

System.out.println("Client Mesaj SOAP receptionat"); 





String s=""; 



name=element.getElementName(); 

if(name.getLocalName().equals("cmmdc")) 

s=element.getValue(); 

} 

System.out.println("Cmmdc: "+s); 

conn.close(); 

} 



} 

System.out.println("Receiver finished"); 

} 


if(args.length



} 

MsgSOAPClientReceiver client=new MsgSOAPClientReceiver(args[0],args[1]); 

client.service(); 

} 

} 

Programul server este 




import java.util.Iterator; 

public class MsgSOAPCmmdcServer{ 

long cmmdc(long m,long n){. . .} 







SOAPBodyElement element=null; 

SOAPElement elem=null; 


try{ 

com.sun.messaging.TopicConnectionFactory 

cf=new com.sun.messaging.TopicConnectionFactory(); 






Destination tDate=session.createTopic("Cmmdc"); 

TopicSubscriber consumer=session.createSubscriber((Topic)tDate); 

conn.start(); 



while(true){ 

msg=consumer.receive(); 

soapMsg=MessageTransformer.SOAPMessageFromJMSMessage(msg,mf); 

System.out.println("Server Mesaj SOAP receptionat"); 





String sn1="",sn2="",topicResult=""; 



name=element.getElementName(); 

if(name.getLocalName().equals("n1")) 

sn1=element.getValue(); 

if(name.getLocalName().equals("n2")) 

sn2=element.getValue(); 

if(name.getLocalName().equals("topic")) 

topicResult=element.getValue(); 

}


System.out.println(sn1+":"+sn2+":"+topicResult); 

long a=Long.parseLong(sn1); 

long b=Long.parseLong(sn2); 

long c=cmmdc(a,b); 

soapMsg=mf.createMessage(); 




name=envelope.createName("cmmdc"); 


elem.addTextNode((new Long(c)).toString()); 

Message m= 



MessageProducer producer=session.createProducer(tResult); 


} 

} 



} 

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

} 


MsgSOAPCmmdcServer server=new MsgSOAPCmmdcServer(); 

server.service(); 

} 

} 

Mesajul SOAP utilizat de client, pentru n1 = 45, n2 = 35 ¸si topic = nume 

este 

 

 

 

45 

35 

nume 

 

 

5.5.3 Ata¸samente SOAP 

Crearea ata¸samentelor 

1. Crearea mesajului SOAP 


SOAPMessage soapMsg=mf.createMessage();


2. • Ata¸sament text 

(a) Crearea unui obiect de tip AttachmentPart 

AttachmentPart attachment=soapMsg.createAttachmentPart(); 

(b) Completarea cont¸inutului 

String stringContent=. . . 

attachment.setContent(stringContent, "text/plain"); 

Cont¸inutului i se poate ata¸sa un cod de identificare 

attachment.setContentId("Text1"); 

• Ata¸sament imagine jpeg/png 

(a) Crearea unui obiect de tip AttachmentPart cu încărcarea imaginii. 

URL url=new URL("file://localhost/c:\\. . .\\***.jpg"); 

DataHandler dataHandler = new DataHandler(url); 

AttachmentPart attachment = 

soapMsg.createAttachmentPart(dataHandler); 

attachment.setContentId("Imagine1"); 

• Ata¸sament cu sunet în format mp3. 

(a) Crearea unui obiect de tip AttachmentPart cu încărcarea fi¸sierului 

mp3. 

URL url=new URL("file://localhost:c:\\. . .\\***.mp3"); 

DataHandler dataHandler=new DataHandler(url); 

AttachmentPart attachment = 


attachment.setContentId("attached_mp3"); 

3. Includerea ata¸samentului în mesajul SOAP 

soapMsg.addAttachmentPart(attachment); 

Extragerea ata¸samentelor 

Tipul unui ata¸sament se poate deduce din rezultatul metodei getContentId 

sau getContentType a clasei AttachmentPart. 

Iterator iterator = soapMsg.getAttachments(); 

while (iterator.hasNext()) { 

AttachmentPart attached = 

(AttachmentPart)iterator.next(); 

// Codul de identificare 

String id = attached.getContentId(); 

// Tipul atasamentului 

String type = attached.getContentType();


// Preluarea unui string 

if (type.equals("text/plain")) { 

Object content = attached.getContent(); 

. . . 

} 

// Preluarea unei imagini 

if (type.equals("image/jpeg")){ 

Image image=(Image)attached.getContent(); 

. . . 

} 

// Preluarea unei inregistrari mp3 

if(type.equals("audio/x-wav")){ 

System.out.println("Play MP3"); 

MP3Player mp3Player=new MP3Player(attached.getRawContent()); 

mp3Player.play(); 

} 

} 

Exemplul 5.5.3 Crearea unui mesaj SOAP cu ata¸samente text, imagine ¸si muzică 

mp3. Textul, imaginea ¸si muzica mp3 sunt cont¸inute în fi¸siere. Căile către aceste 

fi¸siere se vor da ca proprietăt¸i. 





import javax.activation.DataHandler; 

import java.net.URL; 

public class MsgSOAPPublisher extends Thread{ 

String file_location, image_location, mp3_location; 

MsgSOAPPublisher(String file_location,String image_location,String mp3_location){ 

this.file_location=file_location; 

this.image_location=image_location; 

this.mp3_location=mp3_location; 

} 


try{ 






Destination t=session.createTopic("Date"); 

MessageProducer producer=session.createProducer(t); 

MessageFactory mf=MessageFactory.newInstance();






Name bodyName=envelope.createName("verif"); 

SOAPElement element=body.addBodyElement(bodyName); 

element.addTextNode("Atasamente"); 

// Crearea unui atasament text 

AttachmentPart attachment1 = 

soapMsg.createAttachmentPart(); 

// Se completeaza calea la fisierul myText.txt 

FileReader fr = new FileReader(file_location)); 

BufferedReader br = new BufferedReader(fr); 

String stringContent = ""; 

String line = br.readLine(); 

while (line != null) { 

stringContent = stringContent.concat(line); 

stringContent = stringContent.concat("\n"); 

line = br.readLine(); 

} 

attachment1.setContent(stringContent, "text/plain"); 

attachment1.setContentId("attached_text"); 

soapMsg.addAttachmentPart(attachment1); 

// Crearea unui atasament imagine 

// Se completeazu calea la fisierul xml-pic.jpg 

URL url = new URL("file://"+image_location); 

DataHandler dataHandler = new DataHandler(url); 



attachment2.setContentId("attached_image"); 


// Crearea unui atasament de tip mp3 

url=new URL("file://"+mp3_location); 

dataHandler= new DataHandler(url); 



attachment3.setContentId("attached_mp3"); 


Message m=MessageTransformer.SOAPMessageIntoJMSMessage(soapMsg,session); 


conn.close(); 

} 



} 

System.out.println("Publisher finised"); 

} 

} 

Exemplul 5.5.4 Consumarea unui mesaj SOAP cu ata¸samente 


import javax.xml.soap.*;



import java.util.Iterator; 



public class MsgSOAPSubscriber extends Thread{ 


try{ 





Destination t=session.createTopic("Date"); 

TopicSubscriber consumer=session.createSubscriber((Topic)t); 

conn.start(); 




SOAPMessage soapMsg= 

MessageTransformer.SOAPMessageFromJMSMessage(msg,mf); 

// Extragerea atasamentelor 

Iterator iterator = soapMsg.getAttachments(); 

while (iterator.hasNext()) { 

AttachmentPart attached=(AttachmentPart)iterator.next(); 

String id = attached.getContentId(); 

String type = attached.getContentType(); 

System.out.println("Attachment " + id + 

" has content type " + type); 

if (type.equals("text/plain")) { 

Object content = attached.getContent(); 

System.out.println("Attachment contains:\n" + content); 

} 

if (type.equals("image/jpeg")){ 

Image image=(Image)attached.getContent(); 

ShowImage s=new ShowImage(image); 

s.show(); 

} 

if (type.equals("audio/x-wav")){ 

MP3Player mp3Player=new MP3Player(attached.getRawContent()); 

mp3Player.start(); 

} 

} 

} 

conn.close(); 

} 



} 

System.out.println("Subscriber finished"); 

} 

} 

Apelarea celor două fire de execut¸ie se face prin 

class MsgAttach{ 


String file_location=System.getProperty("file_location"); 

String image_location=System.getProperty("image_location");


String mp3_location=System.getProperty("mp3_location"); 

MsgSOAPPublisher publisher= 

new MsgSOAPPublisher(file_location,image_location,mp3_location); 

MsgSOAPSubscriber subscriber=new MsgSOAPSubscriber(); 

publisher.start(); 

subscriber.start(); 

} 

} 

Acest program se execută cu comanda 

java -Dfile location=... -Dimage location=... -Dmp3 location=... MsgAttach 

Programul de afi¸sare a imaginii 


import java.awt.image.*; 

import javax.swing.*; 


import javax.imageio.ImageIO; 


class MyCanvas extends Canvas{ 

Image image=null; 

MyCanvas(Image image){ 

this.image=image; 

} 


g.drawImage(image,0,0,this); 

} 

} 

public class ShowImage{ 

Image image=null; 

MyCanvas mc=null; 

ShowImage(Image image){ 

this.image=image; 

mc=new MyCanvas(image); 

} 

public void show(){ 

// Interfata swing 

JFrame jframe = new JFrame("The received image"); 

jframe.addNotify(); 

jframe.getContentPane().setLayout(new BorderLayout()); 

jframe.getContentPane().add(mc,BorderLayout.CENTER); 

jframe.setDefaultCloseOperation(jframe.EXIT_ON_CLOSE); 

jframe.setSize(200,200); 

jframe.setVisible(true); 

} 

} 

Programul pentru redarea cont¸inutului unui fi¸sier mp3 necesită prezent¸a resursei 

jl1.0.jar din pachetul JLayer1.0, descărcabil din internet. Un program de 

redare este


public class MP3Player extends Thread{ 

private Player player; 

public MP3Player(InputStream is) { 

try { 

BufferedInputStream bis=new BufferedInputStream(is); 

player=new Player(bis); 

} 




} 

} 


try{ 

player.play(); 

} 



} 

if (player != null) player.close(); 

} 

}

Capitolul 6 

Servlet 

Printre aplicat¸iile distribuite de tip client-server, în care comunicat¸iile se 

bazează pe protocolul http, se disting 

• Aplicat¸ii Web (site): Cererea adresată serverului este lansată de o persoană 

prin intermediul unui site, utilizând un program navigator: Mozilla Firefox, 

Opera, Microsoft InternetExplorer, Apple Safari, etc. 

• Servicii Web: Cererea către server se face de un program. 

Un servlet este un program Java care se excută pe un server Web, compatibil, 

¸si este capabil să răpundă cererilor formulate de client¸i. 

Scrierea ¸si utilizarea unui servlet necesită 

• Cunoa¸sterea marcajului html pentru realizarea formularelor de 

introducere a datelor; 

• Utilizarea unui server Web, container de servlet¸i. 

6.1 Marcajul 

Într-un document html introducerea datelor se poate obt¸ine utilizând marcajul 

... . 

Atribute ale marcajului . Reamintim că atributele se prezintă 

ca perechi (nume, valoare) ¸si se scriu în antetul marcajului sub forma nume = 

valoare. 

101

102 CAPITOLUL 6. SERVLET 

Nume Valoare Semnificat¸ia valorii 

action adresa tip URL Resursa care prelucrează formularul. 

method GET Mesajul trimis serverului Web cont¸ine după 

adresa URL numele ¸si valorile parametrilor 

introdu¸si. Adăugarea se face potrivit sintaxei 

?numeParam1=valoare&numeParam2=valoare. . . 

Lungimea mesajului nu poate depă¸si 255 caractere. 

POST Transmisia datelor se face în fluxuri de date. 

Permite transferul unor fi¸siere de pe ma¸sina 

clientului pe ma¸sina serverului. 

Datele sunt transmise prin fluxuri de date. 

id Parametru de identificare a formularului (opt¸ional). 

name Nume atribuit formularului (opt¸ional). 

onSubmit Metodă JavaScript executată înaintea apelării 

serverului Web (opt¸ional). 

În cont¸inutul marcajului putem include elemente de control prin 

marcajele 

• 

• 

• 

• 

Atributele marcajului < input> sunt: 

Nume Valoare Semnificat¸ie 

type text Se a¸steaptă introducerea unui text 

number Se a¸steaptă introducerea unui număr 

password Se a¸steaptă introducerea unei parole 

submit Se marchează sfâr¸situl completării formularului 

reset Se reinit¸ializează formularul 

file Permite selectarea unui fi¸sier 

hidden Transmite mai departe un atribut fără vizualizarea lui 

name numele controlului 

value valoarea (init¸ială) a controlului 

size numărul caracterelor ata¸sat controlului 

În cazul marcajului < select> utilizarea este 

6.2. SERVER WEB - CONTAINER DE SERVLET 103 

Valoare 

. . . . . . . . . . . . . . . . 

 

Valoarea atributului nume este dată de valoarea selectată. 

6.2 Server Web - container de servlet 

În prezent sunt disponibile mai multe servere Web în care poate fi instalat un 

servlet ¸si un fi¸sier JSP. Se spune că serverul Web este container de servlet ¸si JSP. 

Dintre produsele gratuite amintim 

• apache-tomcat 

• jetty 

• Sun Java System Application Server 

Acest server Web este utilizat în Glassfish - o implementare JEE (Java 

Enterprise Edition). 

Geronimo, o alta implementare JEE dezvoltată de apache, poate utiliza containerul 

apache-tomcat sau jetty. 

Serverul Web apache-tomcat 

În continuare se va folosi serverul Web apache-tomcat, pe scurt tomcat. 

Serverul Web tomcat este distribuit gratuit, putând fi descărcat de la adresa 

www.apache.org. 

Instalarea serverului în mediul Windows revine la dezarhivarea fi¸sierului 

descărcat apache-tomcat-***, într-un catalog TOMCAT HOME. Utilizarea serverului 

necesită fixarea a doi parametri sistem: 

• CATALINA HOME= calea la catalogul în care s-a instalat produsul - TOMCAT HOME; 

• JAVA HOME=calea la distribut¸ia Java utilizată. 

Pachetul cont¸ine cataloagele 1 : bin, common, conf, logs, server, shared, 

temp, webapps, work. 

Serverul se lansează prin comanda 

¸si se opre¸ste cu comanda 

TOMCAT HOME\bin\startup 

1 Numele ¸si numărul cataloagelor este dependent de distribut¸ia apache-tomcat.


TOMCAT HOME\bin\shutdown 

Din catalogul TOMCAT HOME, lansarea se poate obt¸ine cu ajutorul fi¸sierului de 

comenzi (*.bat) 

set CATALINA_HOME=. . . 


bin\startup 

Opt¸ional se poate instala / activa managerul / administatorul serverului Web 

tomcat. 

Verificarea funct¸ionării serverului Web tomcat se face apelând dintr-un navigator 

pagina http://host:port unde 

• host este numele calculatorului pe care rulează tomcat; 

• Portul implicit este 8080. 

Reu¸sita este ilustrată de imaginea motanului 

6.3 Realizarea unui servlet 

6.3.1 Instalarea unui servlet 

Pentru un servlet, în catalogul webapps, se crează un subcatalog, de exemplu 

apphello cont¸inând 

apphello 

| |---> WEB-INF 

| | |---> classes 

| | | web.xml 

Catalogul classes cont¸ine fi¸sierele .class ale servletului iar fi¸sierul web.xml 

furnizează serverului web informat¸ii de acces la servlet. Astfel 

1. 

2. 

În elementul se leagă numele servlet-ului definit în elementul 

de clasa servlet-ului dat în elementul 

. 

În elementul se define¸ste numele sub care servlet-ul 

identificat prin nume servlet< /servlet> se invocă din 

programul navigator. Acest identificator - numeApel - se fixează în elementul 

. Identificatorul are ca prefix caracterul / (slash).

6.3. REALIZAREA UNUI SERVLET 105 

Structura unui fi¸sier web.xml este 

 

 

nume_servlet_1 

Nume_clasa 

 

 


Nume_clasa 

 

. . . 

 


/numeApel_1 

 

 


/numeApel_2 

 

. . . 

 

Opt¸ional web.xml poate cont¸ine elementul 

 

 

fisier.html sau jsp 

 

 

cu precizarea fi¸sierelor html sau jsp care lansează servletul. Declarat¸ia fi¸sierului 

index.html este implicită. 

Dacă servlet-ul necesă alte resurse - fi¸siere jar, atunci acestea se depun într-un 

subcatalog lib în WEB-INF. 

O altă variantă de instalare a unui servlet, de exemplu reprezentat prin clasa 

HelloServlet.class, în serverul Web tomcat constă din: 

1. Se crează oriunde structura de cataloage ¸si fi¸siere 

apphello 

| |---> WEB-INF 

| | |---> classes 

| | | | HelloServlet.class 

| | | web.xml 

2. Din catalogul apphello se realizează arhiva apphello.war 

jar cfv apphello.war WEB-INF\∗ 

care se copiază în catalogul TOMCAT HOME\webapps.


3. Se porne¸ste serverul tomcat, operat¸ie în urma căreie arhiva este dezarhivată. 

Astfel servlet-ul este instalat. 

Dacă serverul tomcat este pornit atunci arhiva se dezarhivează automat 

¸si servlet-ul este gata de utilizare. Această instalare se nume¸ste instalare 

dinamică - hot deployment. 

Dacă fi¸sierul war este creat, atunci în locul copierii, instalarea se poate face 

prin componenta manager a lui tomcat. 

O altă posibilitate de instalare a unui servlet în serverul web tomcat este prin 

intermediul produsului apache-tomcat-deployer. apache-tomcat-deployer permite 

instalarea unui servlet de la distant¸ă cât ¸si instalarea comandată dintr-un program. 

apache-tomcat-*.*.*-deployer se instalează prin dezarhivarea fi¸sierului apache-tomcat-*.*.*-deployer. 

Posibilităt¸ile oferite de apache-tomcat-*.*.*-deployer se obt¸in rulând ant cu un fi¸sierul build.xml 

din distribut¸ia produsului. Obiectivele care pot fi atinse sunt 

• compilarea unui servlet - compile 

• instalarea unui servlet - deploy 

• dezinstalarea unui servlet - undeploy 

În prealabil trebuie completat fi¸sierul de proprietăt¸i deployer.properties cu 

• build=catalogul care va cont¸ine rezultatul compilării ¸si al arhivării. 

• webapp=catalogul cu sursa servlet-ului. 

• path=/catalog-ul servlet-ului. 

• url=url-ul aplicat¸iei manager din Tomcat 

http://host:8080/manager 

• username=numele de acces în manager-ul din Tomcat. 

• password=parola pentru manager-ul din Tomcat. 

Sursa servlet-ului are structura obi¸snuită, precizată anterior. 

6.3.2 Compilarea ¸si apelarea unui servlet 

Compilarea unui program necesită completarea variabilei de mediu classpath 

cu fi¸sierul TOMCAT HOME\. . .\servlet-api.jar din distribut¸ia tomcat. Pozit¸ia 

fi¸sierului depinde de versiunea apache-tomcat utilizată. 

Un servlet se lansează în execut¸ie (se apelează) din 

• meniul File/Open a unui program navigator (ex. Mozilla Firefox, Internet 

Explorer) prin


unde 

http://host:port/catalog/numeApel 

– catalog este numele catalogului ce cont¸ine servlet-ul - apphello. 

– Portul implicit este 8080. 

– numeApel este identificatorul fixat în marcajul url-pattern din fi¸sierul 

web.xml. 

• ca o referint¸ă dintr-un document html 

... 

• ca valoare a atributului action într-un marcaj form 


• public String getServletInfo() 

• public ServletConfig getServletConfig() 

În cele ce urmează un servlet va fi o clasă care extinde clasa HttpServlet. 

În locul metodei service(...), programatorul suprascrie metodele doGet(...) 

sau doPost(...), în funct¸ie de metoda utilizată de client la lansarea cererii. 

Practic, un servlet constă din scrierea metodelor 

• void init(ServletConfig config) 

Această metodă este opt¸ională. 

public void init(ServletConfig config) throws ServletException{ 

super.init(config); 

// cod de initializare 

} 

Obiectul config are o metodă String getInitParameter(String numeParam) 

cu ajutorul căreia se pot recupera parametri de initializare asociat¸i servletului 

¸si care se dau în fi¸sierul web.xml prin marcajele 

 

NumeleParametrului 

Valoare 

 

cuprinse în marcajul . 

• protected void doGet(HttpServletRequest req, HttpServletResponse 

res) throws IOException, ServletException 

Tratează o cerere trimisă cu metoda GET (vezi marcajul ). 

• protected void doPost(HttpServletRequest req, HttpServletResponse 

res) throws IOException, ServletException 

Tratează o cerere trimisă cu metoda POST (vezi marcajul ). 

Activităt¸ile de întreprins într-o metodă doGet() sau doPost() sunt 

1. Stabilirea naturii răspunsului: 

res.setContentType(String tip) 

unde tip specifică tipul MIME - Multipurpose Internet Mail Extensions al 

răspunsului:


• "text/html" - pagină html; 

• "text/xml" - document xml; 

• "text/plain" - text; 

• "image/jpg" - imagine gif; 

• "image/gif" - imagine jpg. 

2. Se obt¸ine o referint¸a către un obiect care realizeaza transmisia datelor către 

navigatorul clientului: 

ServletOutputStream out = res.getOutputStream(); 

sau 

PrintWriter out=res.getWriter(); 

3. Se preiau datele cererii cu una din metodele: 

String getParameter(String numeParapetru) 

java.util.Enumeration getParameterNames() 

4. Rezolvă cererea clientului; 

5. Formează ¸si scrie răspunsul; 

6. 

Închide conexiunea obiectului prin care s-a realizat transmisia datelor către 

navigatorul clientului prin out.close(). 

Un utilizator lansează o cerere către servlet. De obicei acest lucru se realizează 

prin completarea unui formular al unui document html. Programul navigator 

trimite cererea serverului Web prin intermediul căruia este lansat servlet-ul în 

act¸iune. 

Ciclul de viat¸ă al unui servlet. Când un servlet este apelat prima dată 

de către serverul Web se execută metoda init. După aceasta, fiecărei cereri 

lansate de un utilizator i se asociază un fir de execut¸ie în care se apelează metoda 

service. Metoda service apelează apoi metodele doGet(), doPost() sau o 

altă metodă de forma doXXX() depinzând de tipul de cerere primit. 

Exemplul 6.3.1 Servletul Hello: Clientul transmite numele servet-ului care îi 

răspunde cu mesajul de salut ”Hi nume!”. 

Formularul html prin care clientul introduce numele este (index.html) 

 

 

Servlet-ul Hello 

 

 

 

Pagina de apelare a servletului HelloServlet 


action="http://localhost:8080/apphello/hello"> 

Introduceti numele: 

 

 

 

 

 

 

 

Codul servlet-ului este 


import javax.servlet.*; 

import javax.servlet.http.*; 

public class HelloServlet extends HttpServlet { 

public void doGet(HttpServletRequest req,HttpServletResponse res) 

throws ServletException,IOException{ 

res.setContentType("text/html"); 

ServletOutputStream out=res.getOutputStream(); 

String nume=req.getParameter("name"); 

out.println(""); 

out.println("HelloServlet"); 


out.println("HelloServlet"); 


out.println( "Hi "+ nume+" !"); 




out.close(); 

} 

public void doPost(HttpServletRequest req,HttpServletResponse res) 


doGet(req,res); 

} 

} 

Fi¸sierul web.xml pentru acest exemplu este 

 

 

 

 

hello 

HelloServlet 

 

 

hello 

/hello 

 

 

index.html 

 


Compilarea ¸si arhivarea servlet-ului o vom realiza prin intermediul lui apacheant. 

În acest scop se crează structura: 

hello 

| |---> src 

| | | HelloServlet.java 

| |---> lib 

| |---> web 

| | | web.xml 

| |---> web-files 

| | | index.html 

| build.xml 

cu fi¸sierul build.xml 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 


 

 

 

 

 

 

 

 

Observat¸ie. Valoarea parametrului dist.name trebuie să coincidă cu numele 

catalogului în atributul action a elementului form, din documentul index.html. 

În cazul exemplului de fat¸ă, catalogul lib este gol. Dacă aplicat¸ia solicită 

resurse externe, cont¸inute în fi¸sierele jar, atunci aceste fi¸siere se depun în catalogul 

lib. 

Se lansează în execut¸ie serverul Web tomcat, se încarcă servlet-ul în serverul 

Web ¸si dintr-un navigator se deschide pagina http://localhost:8080/apphello 

Exemplul 6.3.2 Servlet pentru calculul celui mai mare divizor comun a două 

numere. 




public class CmmdcServlet extends HttpServlet{ 

public long cmmdc(long m, long n){. . .} 



String sm=req.getParameter("m"),sn=req.getParameter("n"); 

String tip=req.getParameter("tip"); 

long m=Long.parseLong(sm),n=Long.parseLong(sn); 

long x=cmmdc(m,n); 


String title="CmmdcServlet"; 

if(tip.equals("text/html")){ 



out.println(title); 


out.println(""+title+""); 

out.println("Cmmdc is "+x); 


} 

else{ 

res.setContentType("text/plain"); 

out.println(x); 

} 

out.close(); 

} 



doGet(req,res);

6.4. FACILITĂT¸ I DE PROGRAMARE CU SERVLET 113 

} 

} 

apelabil prin documentul html (index.html) 

 

 

 

Primul numar este 

Al doilea numar este 

 

 

 

 

 

Pentru fixarea naturii răspunsului text/html sau text/plain s-a introdus variabila 

tip, care în fi¸sierul de invocare index.html prime¸ste pe ascuns valoarea 

text/html. În cazul în care vom apela servlet-ul dintr-un program, va fi avantajos 

să primim răspunsul ca text/plain. 

6.4 Facilităt¸i de programare cu servlet 

6.4.1 Program client al unui servlet 

Apelarea unui servlet dintr-un program Java – adică lansarea unei cereri 

¸si recept¸ionarea răspunsului furnizat de servlet – se poate realiza cu produsul 

commons-httpclient dezvoltat în cadrul proiectului jakarta al fundat¸iei apache. 

Într-un asemenea caz, din punctul de vedere al clientului este mai avantajos 

ca răspunsul servlet-ului fie text/plain, în loc de text/html. 

Pe lângă commons-httpclient este nevoie de următoarele produse soft: 

• commons-codec de la apache; 

• commons-logging de la apache; 

Pentru compilare trebuie declarată în variabila de sistem classpath referint¸a 

către commons-httpclient, dar pentru execut¸ie este nevoie ¸si de referintele către 

celelalte două produse. 

Dezvoltarea unui client presupune: 

1. Resursele utilizate se declară prin 

import org.apache.commons.httpclient.*; 

import org.apache.commons.httpclient.methods.*; 

import org.apache.commons.httpclient.params.HttpMethodParams;


2. Crearea unui obiect de tip HttpClient: 

HttpClient client=new HttpClient(); 

3. Declararea metodei de transmitere a datelor get, post. 

• GetMethod method = new GetMethod(url); 

unde url este String-ul de apelare a servlet-ului, de forma 

http://host:port/catalog/numeApel?numeCâmp=*&numeCâmp=*, 

* t¸inând locul valorilor introduse de client; 

• PostMethod method = new PostMethod(url); 

cu url=”http://host:port/catalog/numeApel”. 

Datele se adaugă cu metoda 

method.addParameter(String paramName, String paramValue); 

Dacă se transmit atât parametri cât ¸si fi¸siere atunci datele se adaugă 

prin ¸sablonul 

Part[] parts = { 

new StringPart(paramName, paramValue), 

. . . 

new FilePart(file.getName(), file) 

. . . 

}; 

method.setRequestEntity( 

new MultipartRequestEntity(parts, method.getParams()) 

); 

unde o variabilă file corespunde unui fi¸sier care este încărcat. 

4. Specificarea modului de reluare a cererii. 

DefaultHttpMethodRetryHandler retryhandler= 

new DefaultHttpMethodRetryHandler(int numarReluari, 

boolean seFacReluari); 

method.getParams().setParameter(HttpMethodParams.RETRY_HANDLER, 

retryhandler); 

5. Lansarea cererii. 

int statusCode = client.executeMethod(method); 

6. Preluarea răspunsului. Există trei căi de realizare a acestui obiectiv:


7. 

• Ca ¸sir de octet¸i: 

byte[] method.getResponseBody(); 

• Ca String: 

String method.getResponseBodyAsString(); 

• Prin intermediul unui flux: 

InputStream method.getResponseBodyAsStream(); 

Închiderea conexiunii cu servlet-ul. 

method.releaseConnection(); 

Exemplul 6.4.1 Dezvoltăm un program client pentru servlet-ul CmmdcServlet. 


import org.apache.commons.httpclient.*; 

import org.apache.commons.httpclient.methods.*; 

import org.apache.commons.httpclient.params.HttpMethodParams; 


public class ClientCmmdcServlet{ 

private static String url = "http://localhost:8080/myservlet/cmmdc"; 




String m=scanner.nextLine().trim(); 


String n=scanner.nextLine().trim(); 

HttpClient client = new HttpClient(); 

PostMethod method = new PostMethod(url); 

method.addParameter("m",m); 

method.addParameter("n",n); 

method.addParameter("tip","text/plain"); 

DefaultHttpMethodRetryHandler retryhandler=new DefaultHttpMethodRetryHandler(3,true); 

method.getParams().setParameter(HttpMethodParams.RETRY_HANDLER,retryhandler); 

try { 

int statusCode = client.executeMethod(method); 

if (statusCode != HttpStatus.SC_OK) { 

System.err.println("Method failed: " + method.getStatusLine()); 

} 

byte[] responseBody = method.getResponseBody(); 

System.out.println("Cmmdc = "+(new String(responseBody))); 

} 

catch (HttpException e) { 

System.err.println("Http error: " + e.getMessage()); 

} 

catch (IOException e) {


System.err.println("I/O error: " + e.getMessage()); 

} 

finally { 

method.releaseConnection(); 

} 

} 

} 

6.4.2 Servlete înlănt¸uite 

Un servlet apelează la un moment dat alt servlet. S¸ablonul de lucru este 

RequestDispatcher dispatcher= 

getServletContext().getRequestDispatcher("/url_pattern_servlet_apelat"); 

if(dispatcher!=null) 

dispatcher.include(request,response); 

Exemplul 6.4.2 Un servlet VerifServlet verifică parametri cererii. Pentru problema 

calculului celui mai mare divizor comun a două numere, dacă cei doi parametri 

sunt numere întregi, atunci se apelează servletul ComputeServlet, altfel se formează 

un mesaj de eroare. 

Codurile celor două servlete sunt: 

VerifServlet.java 





public class VerifServlet extends HttpServlet{ 






String message=""; 

long m,n; 

if((sm==null)||(sm.equals(""))){ 

message="Numar absent"; 

} 

else{ 

try{ 

m=Long.parseLong(sm); 

} 

catch(NumberFormatException e){ 

message="Nu este numar"; 

} 

} 

if((sn==null)||(sn.equals(""))){ 

message="Numar absent"; 

} 

else{


try{ 

n=Long.parseLong(sn); 

} 

catch(NumberFormatException e){ 

message="Nu este numar"; 

} 

} 


if(message.equals("")){ 

out.println(" Rezultatul obţinut "); 

RequestDispatcher dispatcher=getServletContext().getRequestDispatcher("/calcul"); 

if(dispatcher!=null) 

dispatcher.include(req,res); 

} 

else{ 

out.println(" Date eronate "); 

out.println(message); 

} 


out.close(); 

} 




} 

} 

ComputeServlet.java 





public class ComputeServlet extends HttpServlet{ 

public long cmmdc(long m, long n){. . .} 



long m=Long.parseLong(req.getParameter("m")); 

long n=Long.parseLong(req.getParameter("n")); 


out.println(" Cmmdc = "+cmmdc(m,n)+""); 

} 




} 

} 

6.4.3 Sesiune de lucru 

În cazul protocolului HTTP, de fiecare dată când un client deschide sau revine 

la o pagină Web se deschide o nouă conexiune cu serverul Web iar acesta nu ret¸ine


informat¸iile referitoare la client pe perioada conexiunii respective. Perioada de 

timp cât un client este în conexiune cu o pagină Web se nume¸ste sesiune. 

Există posibilitatea păstrării unor informat¸ii pe durata unei sesiuni (mecanismul 

Session Tracking). 

Înaintea satisfacerii unei cereri, servletul verifică existent¸a unui obiect HttpSession. 

Acest obiect se crează la prima apelare de către un client a servletului prin 

HttpSession sesiune=request.getSession(true); 

Un obiect HttpSession poate ret¸ine atribute, adică perechi de forma (nume, 

valoare). Introducerea unui atribut se realizează prin 

void setAttribute(String nume, Object valoare) 

iar extragerea valorii unui atribut se obt¸ine prin 

Object getAttribute(String nume) 

Metoda String nume[ ] getValueNames() returnează numele tuturor 

atributelor definite. 

Un atribut se elimină cu metoda void removeAttribute(String nume). 

Exemplul 6.4.3 Exemplul următor numără de câte ori se apelează servlet-ul 

într-o sesiune. Se define¸ste un atribut noAcces, care la prima apelare este init¸ializat 

iar apoi este mărit cu câte o unitate la fiecare nouă apelare a servlet-ului. 




public class Sesiune extends HttpServlet{ 




String mesaj; 


HttpSession session=req.getSession(true); 

Integer contor=(Integer)session.getAttribute("noAcces"); 

if(contor==null){ 

contor=new Integer(1); 

mesaj="Salut !"; 

} 

else{ 

contor=new Integer(contor.intValue()+1); 

mesaj="Bine ati revenit !"; 

} 

session.setAttribute("noAcces",contor); 


out.println(""+mesaj+""); 

out.println("Numarul de accesari al aceastei pagini este "+contor.intValue()); 

out.println("");


out.close(); 

} 




} 

} 

Apelarea servletului se face din 

 

 

Sesiune 

 

 

Formular de acces 

 

 

 

 

 

 

6.4.4 Cookie 

Un Cookie este un fi¸sier de mică dimensiune trimisă de către programul server 

clientului ca parte a header-ului Http. 

Acesta cont¸ine informat¸ii despre sesiunea curentă care salvate pe disc vor 

putea fi accesate în sesiuni ulterioare. Când un navigator emite o cerere către un 

server, cookie-urile anterioare primite de către client de la serverul respectiv sunt 

trimise din nou serverului ca parte a cererii formulată de client. 

Cookie-urile sunt sterse automat în momentul expirării. 

Unii client¸i nu permit memorarea cookie-urilor. 

În acest caz, clientul este 

informat că acest fapt ar putea duce la imposibilitatea satisfacerii cereri sale 

/ accesării paginii Web. Implicit, durata de viat¸ă a unui cookie este sesiunea 

curentă a navigatorului (până se închide navigatorul). 

Constructorul clasei Cookie 

Cookie(String nume, String valoare) 


• void setDomain(String model) 

Domeniul este o adresă URL ce restrict¸ionează accesul cookie-urilor la acel 

domeniu. model trebuie să cont¸ină cel put¸in două caractere ”.”. 

• void setMaxAge(int durată) Fixează durata de existent¸ă a cookie-ului - în 

secunde. Valoarea implicită este -1, adică cookie-ul există până la închiderea 

programului navigator.


• void setComment(String comentariu) 

• void setSecure(boolean flag) 

Valoarea implicită este false. 

Trimiterea unui cookie clientului: 

public void HttpServletResponse.addCookie(Cookie cookie) 

Recunoa¸sterea cookie-urilor de către servlet: 

Cookie [ ] cookies=request.getCookies(); 

if(cookies!=null){ 

for(int i=0;i


out.println(""+mesaj+""); 

out.println("Numarul de accesari al aceastei pagini este "+contor); 


out.close(); 

} 




} 

} 

6.4.5 Autorizarea accesului prin parola 

Parolele celor îndreptăt¸it¸i să acceseze servletul sunt cuprin¸si într-un fi¸sier. În 

servlet accesul la fi¸sier se realizează prin preluarea unui parametru a cărei valoare 

este numele fi¸sierului. 

Servlet-ul solicită afi¸sarea pe ma¸sina clientului a unei căsut¸e de dialog prin 

care clientul introduce numele ¸si parola. Dacă datele coincid cu cele înregistrate 

în fi¸sier atunci se autorizează accesul la servlet. 

Date transmise de client sunt codificate. Decodificarea se poate realiza cu 

clasa Base64Coder : www.source-code.biz, Christian d’Heureuse, Inventec Informatik 

AG, Switzerland. 






public class ProtectedPage extends HttpServlet{ 

private Properties passwords; 

private String passwordFile; 

// Parolele sunt intr-un fisier "parole" 

// sub forma nume=parola. 

public void init(ServletConfig config)throws ServletException { 


try { 

passwordFile = config.getInitParameter("passwordFile"); 

passwords = new Properties(); 

passwords.load(new FileInputStream(passwordFile)); 

} 

catch(IOException ioe) {} 

} 

public void doGet(HttpServletRequest request,HttpServletResponse response) 

throws ServletException, IOException { 

response.setContentType("text/html"); 

PrintWriter out = response.getWriter(); 

String authorization = request.getHeader("Authorization"); 

if (authorization == null) { 

cerParola(response);


} 

else{ 

String userInfo = authorization.substring(6).trim(); 

String nameAndPassword = Base64Coder.decodeString(userInfo); 

System.out.println(nameAndPassword); 

int index = nameAndPassword.indexOf(":"); 

String user = nameAndPassword.substring(0, index); 

String password = nameAndPassword.substring(index+1).trim(); 

passwords.list(System.out); 

String realPassword = passwords.getProperty(user); 

System.out.println(user+" "+password+" "+realPassword); 

if ((realPassword != null)&&(realPassword.equals(password))){ 

String title = "Welcome to the Protected Page"; 

out.println(""+title+"" + 

"\n"+"" + title + "\n" + 

"Aveti acces la pagina"+""); 

} 

else { 

cerParola(response); 

} 

} 

} 

// Cererea a fost fara autorizare 

private void cerParola(HttpServletResponse response) { 

response.setStatus(response.SC_UNAUTHORIZED); // Ie 401 

response.setHeader("WWW-Authenticate", 

"BASIC realm=\"privileged-few\""); 

} 

public void doPost(HttpServletRequest request,HttpServletResponse response) 


doGet(request, response); 

} 

} 

Parolele se ret¸in într-un fi¸sier denumit parole.properties alcătuit din înregistrări 

de forma nume=parolă, câte o înregistrare pe linie. Localizarea fi¸sierului se obt¸ine 

prin intermediul datelor din elementul 

 

passwordFile 

d:\\apache-tomcat-*.*.*\\. . .\\parole.properties 

 

Acest element apare în corpul elementului ata¸sat servlet-ului. Servletul 

se apelează prin http://host:port/context/numeApel. 

6.4.6 Servlet cu conexiune la o bază de date 

Folosind Anexa C considerăm 

Exemplul 6.4.6 Consultarea unei agende telefonice. Se utilizează o bază de date 

AgendaTelefonica alcătuită dintr-un singur tabel telef (nume varchar(20), numar 

varchar(20)).


Utilizând SGBD derby servletul este 




import java.sql.*; 

public class Telef extends HttpServlet{ 

Statement instructiune=null; 

public void init(ServletConfig config) throws ServletException{ 


String jdbcDriver="org.apache.derby.jdbc.ClientDriver"; 

String URLBazaDate="jdbc:derby://localhost:1527/AgendaTelefonica"; 

/* 

//Cazul SGBD Access 

String jdbcDriver="sun.jdbc.odbc.JdbcOdbcDriver"; 

String URLBazaDate="jdbc:odbc:AgendaTelefonica"; 

//Cazul SGBD Mysql 

String jdbcDriver="com.mysql.jdbc.Driver"; 

String URLBazaDate="jdbc:mysql://localhost:3306/AgendaT?user=root"; 

*/ 

Connection con=null; 

try{ 

Class.forName(jdbcDriver).newInstance(); 

con=DriverManager.getConnection(URLBazaDate); 

instructiune=con.createStatement(); 

} 

catch(ClassNotFoundException e){ 

System.out.println("N-am gasit driverul JDBC: "+jdbcDriver); 

} 

catch(SQLException e){ 

System.out.println("Eroare cautare date din "+URLBazaDate); 

} 


System.out.println("Eroare : "+e.getMessage()); 

} 

} 



String myAtribut,myVal; 



// Preluarea valorii unui parametru 

myAtribut=req.getParameter("criteriu"); 

myVal=req.getParameter("termen"); 

myVal=’\’’+myVal+’\’’; 

try{ 

String sql="select * from telef where "+ myAtribut+" = " 

+myVal; 

ResultSet rs=instructiune.executeQuery(sql); 


out.println("AgendaTelefonica"); 


out.println("Agenda Telefonica");


while(rs.next()){ 

out.print(rs.getString("nume")+" are numarul de telefon:"+ 

rs.getString("numar")); 

} 



out.close(); 

} 


System.out.println("SQLException: "+e.getMessage()); 

} 



} 

} 




} 

} 

Utilizarea servlet-ului se face din 

 

 

 

Cautare in baza de date telefica 

 

 

 

 

Cautare in baza de date a Societatii de telefoane 

 

 

Criteriu de cautare: 

 

dupa Nume 

dupa Numar 

 

 

Entitatea cautata 

 

 

 

 

 

 

Testarea aplicat¸iei presupune: 

1. Realizarea bazei de date: 

2. Testarea servlet-ului: 

(a) Pornirea serverului bazei de date.


(b) Se verifică prezent¸a în catalogul servlet-ului ...\WEB-INF\lib a fi¸sierului 

derbyclient.jar sau mysql-connector-java-*.*.*-bin.jar. 

(c) Pornirea serverului tomcat sau reîncărcarea servlet-ului. 

(d) Apelarea servlet-ului din pagina Web. 

6.4.7 Imagini furnizate de servlet 

Indicăm două modalităt¸i prin care un client obt¸ine o imagine furnizată de 

un servlet. Imaginea poate proveni dintr-un fi¸sier extern sau poate fi creată de 

servlet. 

• Imaginea este transmisă direct clientului 

response.setContentType("image/gif"); 

În cazul unui fi¸sier extern imaginea este refăcută în memorie ¸si în fluxul de 

ie¸sire de tip ServletOutputStream se transmite recodarea imaginii în format 

gif. Această recodare se poate face cu pachetul Acme.JPM.Encoders, 

disponibil gratuit la adresa web http://www.acme.com. 

Preluarea imaginii dintr-un fi¸sier se programează 

Image image=Toolkit.getDefaultToolkit().getImage(String 

referint¸ăFi¸sier); 

Textul sursă al servlet-ului este: 





import Acme.JPM.Encoders.GifEncoder; 

public class MyGraphG extends HttpServlet{ 


throws ServletException, IOException{ 

res.setContentType("image/gif"); 

// iesire prin flux de octeti 


// Referinta la fisierul grafic 

String f="d:\\apache-tomcat-*.*.*\\webapps\\myservlet\\ 

WEB-INF\\classes\\walking_santa.gif"; 

// Preluarea imaginii grafice 

Image image=Toolkit.getDefaultToolkit().getImage(f); 

// Transmiterea imaginii utilizand pachetul 

GifEncoder encoder = new GifEncoder(image, out); 

encoder.encode(); 

} 

}


• Pe server imaginea se salvează într-un fi¸sier jpg sau png, după care servletul 

scrie în fluxul de ie¸sire un document html ce apelează fi¸sierul cu imaginea 

creată anterior. Navigatorul clientului va descărca ¸si vizualiza imaginea. 

Textul sursă al servlet-ului este: 





import javax.imageio.*; 

import java.awt.image.*; 

import javax.imageio.stream.*; 


public class MyGraphP extends HttpServlet { 





String numeFis="desen"; 

String ext="jpg"; // sau "png" 

// Formarea imaginii 

Frame frame = null; 

Graphics g = null; 

BufferedImage image=null; 

try{ 

frame = new Frame(); 

// addNotify : Cadrul Frame devine afisabil prin 

// legarea lui la o resursa nativa a ecranului. 

// Proprietatea se mosteneste de toti descendentii 

// cadrului 

frame.addNotify(); 

image = (BufferedImage)frame.createImage(800, 60); 

g = image.getGraphics(); 

// Fixarea fontului 

g.setFont(new Font("Serif", Font.ITALIC, 48)); 

// Editarea unui text 

g.drawString(" Tehnologii distribuite in Java", 10, 50); 

// Salvarea imaginii intr-un fisier jpg sau png 

File f=new File(numeFis+"."+ext); 

ImageIO.write(image,"jpg",f); 

// Raspunsul catre client 


out.println("Imagine preluata de pe server "); 


out.println("Vizualizarea imaginii "); 


out.close(); 

} 

finally{


// Eliberarea resurselor 

if (g != null) g.dispose(); 

if (frame != null) frame.removeNotify(); 

} 

} 

} 

6.4.8 Servlet cu RMI 

Un servlet poate fi client al unei aplicat¸ii RMI. Interfat¸a la diatant¸ă se depune 

în catalogul WEB-INF\lib al servletului. Apelarea programului server RMI se face 

prin 

InterfataDistanta obj=(InterfataDistanta) 

Naming.lookup("//"+host+":"+port+"/NumeServiciuRMI"); 

Exemplul 6.4.7 Client servlet pentru aplicat¸ia RMI de calcul al celui mai mare 

divizor comun a două numere naturale. 







public class ServletRMI extends HttpServlet { 

public void doGet(HttpServletRequest req, HttpServletResponse res) 



PrintWriter out = res.getWriter(); 


long m=(new Long(sm)).longValue(),n=(new Long(sn)).longValue(); 

long x=0; 

String host=req.getParameter("host").trim(); 

String sPort=req.getParameter("port"); 

int port=Integer.parseInt(sPort); 

try{ 

ICmmdc obj=(ICmmdc)Naming.lookup("//"+host+":"+port+"/CmmdcServer"); 


} 


System.out.println("CmmdcClient exception: "+e.getMessage()); 

} 

String title="CmmdcServlet"; 



out.println(title); 


out.println(""+title+""); 

out.println("Cmmdc : "+x);



out.close(); 

} 




} 

} 

6.5 FileUpload 

Deseori clientul trebuie să furnizeze unui servlet un volum mare de date, 

depozitate într-un fi¸sier. Un produs care ne ajută să îndeplinim acest obiectiv 

este commons-fileupload - dezvoltat de apache. 

Commons-FileUpload - dezvoltat în cadrul apache - este un produs care simplifică 

transferul unui fi¸sier de la un client la programul server (file upload). 

Interfat¸a de programare a produsului se referă la partea de server - în cazul de 

fat¸ă reprezentat prin servlet. 

Instalarea produsului constă din dezarhivarea fi¸sierului descărcat din Internet. 

În plus este nevoie de 

• commons-io 

Fi¸sierele 

• commons-fileupload-*.*.jar 

• commons-io-*.*.jar 

se depun în catalogul lib al servlet-ului. 

Transferarea unui fi¸sier, din partea clientului nu ridică nici o problemă. În 

fi¸sierul html de apelare, se define¸ste un formular 

 

iar un fi¸sier de încărcat se fixează prin intermediul marcajului 

 

Programul navigator afi¸sează o fereastră de căutare, prin care clientul selectează 

fi¸sierul pe care dore¸ste să-l încarce. 

Dacă partea de client este un program, atunci se utilizează commons-httpclient. 

6.4.1 

De partea serverului, programarea încărcării revine la

6.5. FILEUPLOAD 129 

1. Crearea unei fabrici pentru manipularea fi¸sierelor pe disc 

FileItemFactory factory = new DiskFileItemFactory(); 

2. Crearea unei unelte de încărcare 

ServletFileUpload upload = new ServletFileUpload(factory); 

3. Analiza (parsarea) mesajului furnizat de client 

List fileItems = upload.parseRequest(req); 

Fiecare element al listei implementează interfat¸a FileItem. 

Se pot fixa parametrii 

• dimensiunea zonei de pe disc destinată datelor de încărcat 

DiskFileItemFactory factory = new DiskFileItemFactory(); 

factory.setSizeThreshold(maxMemorySize); 

• catalogul temporar de ret¸inere a datelor de încărcat 

factory.setRepositoryPath(tempDirectory); 

sau direct 

DiskFileItemFactory factory = new DiskFileItemFactory( 

maxMemorySize, tempDirectory); 

• dimensiunea maximă a unui fi¸sier 

upload.setSizeMax(maxRequestSize); 

4. Prelucrarea elementelor încărcate 

Iterator iter=fileItems.iterator(); 

while (iter.hasNext()) { 

FileItem item = (FileItem) iter.next(); 

if (item.isFormField()) { 

// Prelucrarea elementului item care corespunde unei 

// date din formularul html care nu este de tip fisier 

} 

else{ 

// Prelucrarea elementului item de tip fisier 

} 

}


5. 

6. 

În cazul unui element care nu este de tip fi¸sier putem obt¸ine numele ¸si 

valoarea atributului furnizat de client 

String name = item.getFieldName(); 

String value = item.getString(); 

În cazul unui fi¸sier putem afla numele câmpului input, numele fi¸sierului, 

dimensiunea fi¸sierului 

String fieldName = item.getFieldName(); 

String fileName = item.getName(); 

long sizeInBytes = item.getSize(); 

7. Dacă dorim să salvăm fi¸sierul pe calculatorul server atunci prelucrarea este 

File uploadedFile = new File(...); 

item.write(uploadedFile); 

8. Dacă datele fi¸sierului se încarcă în memoria calculatorului atunci prelucrarea 

este 

InputStream in = item.getInputStream(); 

//preluarea datelor din fluxul in 

. . . 

in.close(); 

Alternativ, datele se pot ret¸ine ca un ¸sir de octet¸i prin 

byte[] data = item.get(); 

Exemplul 6.5.1 Să se obt¸ină în memoria serverului matricea cont¸inută într-un 

fi¸sier text. În fi¸sierul text, fiecare linie cont¸ine o linie a matricei, iar elementele 

sunt separate prin spat¸ii. 

Metoda getMatrix utilizată reface matricea din datele fi¸sierului. 

package upload; 





import org.apache.commons.fileupload.disk.*; 

import org.apache.commons.fileupload.servlet.*; 

import org.apache.commons.fileupload.*; 

public class FileUploadServlet extends HttpServlet{

6.5. FILEUPLOAD 131 


throws ServletException,IOException { 

res.setContentType("text/plain"); 


try{ 

boolean isMultipart = ServletFileUpload.isMultipartContent(req); 

FileItemFactory factory = new DiskFileItemFactory(); 

ServletFileUpload upload = new ServletFileUpload(factory); 

List items = upload.parseRequest(req); 

upload.setSizeMax(1000000); 

Iterator iter=items.iterator(); 

while (iter.hasNext()) { 

FileItem item = (FileItem) iter.next(); 

if (!item.isFormField()) { 

String fileName = item.getName(); 

out.println(fileName); 

long sizeInBytes = item.getSize(); 

out.println(sizeInBytes); 

InputStream in=item.getInputStream(); 

InputStreamReader isr=new InputStreamReader(in); 

BufferedReader br=new BufferedReader(isr); 

double[][] matrix=getMatrix(br); 

int m=matrix.length; 

int n=matrix[0].length; 

for(int i=0;i


while(line!=null); 

if(v.size()>0){ 

mn=v.size(); 

n=mn/m; 

matrix=new double[m][n]; 

for(int i=0;i 

 

Incărcarea unui fişier 

 

 

Selectaţi fişierul 

 

 

 

 

 

 

Capitolul 7 

Java Server Page – JSP 

7.1 Tehnologia JSP 

JSP permite includerea codului Java într-un document html. Un asemenea 

document se depozitează pe un server Web, container de servlet¸i, cu extensia 

jsp, eventual jspx. 

Apelarea documentului JSP se realizează prin 

• meniul File/Open a unui navigator, cu 

http://host:port/contex/doc.jsp 

• referint¸ă html 

 

• valoare a atributului action într-un marcaj form 

 

Prin context se înt¸elege calea de la catalogul webapps până la catalogul ce 

cont¸ine fi¸sierul jsp. 

În cazul serverului Web tomcat vom depozita fi¸sierele JSP într-un catalog jsp 

din arborele 

webapps 

|--> JSPApp 

|--> WEB-INF 

|--> classes 

|--> web.xml 

|--> jsp 

|--> doc.jsp 

caz în care contextul va fi JSPApp/jsp. 

Astfel, schimbând numele fi¸sierului Hello.html 

133

134 CAPITOLUL 7. JAVA SERVER PAGE – JSP 

 

 

Hello 

 

 

în Hello.jsp ¸si plasându-l în catalogul jsp se obt¸ine acela¸si efect, dar prelucrarea 

paginilor / documentelor este diferită. Fi¸sierul html este prelucrat doar de programul 

navigator ¸si poate fi deschis ca fi¸sier, în timp ce fi¸sierul JSP este prelucrat de 

serverul Web cu afi¸sarea prin intermediul navigatorului. Prelucrarea efectuată 

de serverul Web constă din transformarea paginii / documentului JSP într-un 

servlet, care este compilat ¸si lansat în execut¸ie. Din aceastră cauză prima invocare 

a paginii / documentului JSP durează mai mult decât apelările ulterioare. 

Apelarea paginii / documentului JSP se face prin 

http://localhost:8080/JSPApp/jsp/Hello.jsp 

Există două moduri de a include elemente JSP într-un text html: 

• prin elemente specifice JSP. 

Fi¸sierul are extensia jsp ¸si se nume¸ste pagină JSP. 

• prin marcaje xml apart¸inând spat¸iului de nume 

http://java.sun.com/JSP/Page 

Fi¸sierul poate avea extensia jsp sau jspx ¸si se nume¸ste document JSP. 

Comentariile JSP se scriu de forma 

 

Considerăm următoarul exemplu introductiv: 

Exemplul 7.1.1 Putem afi¸sa valoarea unei variabile Java (de exemplu data calendaristică) 

prin 

• Varianta paginii JSP 

 

 

 

Data calendaristica 1: 

 

 

 


 

7.1. TEHNOLOGIA JSP 135 

 


 

 

 

Dacă se utilizează operatorul de afi¸sare = atunci după expresia de afi¸sat nu 

se pune ;. 

Variabila predefinită out este de tip javax.servlet.jsp.JspWriter. 

• Varianta documentului JSP 

 

 

 

 

java.util.Date d=new java.util.Date(); 

 

d 

 

 

Codul Java inglobat într-un text html se nume¸ste scriptlet. Sintaxa utilizată 

este 

• Varianta paginii JSP 

• Varianta documentului JSP 

 

codJava 

Domeniul de valabilitate. Domeniul de valabilitate define¸ste intervalul de 

timp, de existent¸ă al unui obiect. În cadrul unei pagini / document JSP sunt 

definite domeniile de valabilitate prin valorile: 

Valoare Domeniu de vizibilitate 

page pagina curentă 

request în pagina curentă, 

în paginile incluse ¸si 

în paginile către care se face o redirectare 

session în sesiunea curentă 

application pe durata rulării aplicat¸iei 

În orice pagină / document JSP sunt predefinite variabilele:


Variabila Tip/Clasa 

out javax.servlet.jsp.JspWriter 

request javax.servlet.ServletRequest 

response javax.servlet.ServletResponse 

session javax.servlet.http.HttpSession 

page java.lang.Object, this 

pageContext javax.servlet.jsp.PageContext 

application javax.servlet.ServletContext 

ServletContext.getServletConfig().getContext() 

exception java.lang.Throwable 

Astfel 

String request.getParameter(String numeParametru) 

furnizează valoarea parametrului numeParametru dintr-un formular html. 

Exemplul 7.1.2 Pagina JSP Hello: Clientul transmite numele paginii care îi 

răspunde cu mesajul de salut ”Hi nume!”. 

Codul paginii JPS (hello.jsp) este 

 

 

jsphello 

 

 

 

Pagina de răspuns 

 

 

 

 

 

apelat din (index.html) 

 

 

JSP Hello 

 

 

 

Pagina de apelare JSP 

 

Numele: 

 

 


 

 

 

 

Compilarea ¸si arhivarea servlet-ului o vom realiza prin intermediul lui apacheant. 

În acest scop se crează structura: 

jsphello 

| |---> jsp 

| | | hello.jsp 

| |---> lib 

| |---> src 

| |---> web 

| | | web.xml 



| build.xml 

Fi¸sierul web.xml este simplu 

 

 

 

 

index.html 

index.jsp 

 

 

Fi¸sierul build.xml prelucrat de apache-ant folosit este 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 


 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

7.1.1 Declarat¸ii JSP 

Într-un scriplet, printr-o declarat¸ie JSP, putem defini câmpuri(variabile) ¸si 

metode Java ce pot fi apoi folosite, respectiv apelate în documentul respectiv. O 

declarat¸ie JSP se define¸ste printr-un marcaj 

sau, în format XML 

 

. . . 

Există două metode jspInit() - utilizată pentru init¸ializarea datelor -, ¸si 

jspDestroy() - utilizată pentru eliberarea resurselor -, care dacă sunt declarate 

de programator atunci sunt executate la începutul ¸si la sfâr¸situl ciclului de execut¸ie 

a paginii / documentului JSP.


7.1.2 Directive JSP 

Directivele JSP fixează informat¸ii pentru tot documentul jsp. O directivă jsp 

se indică prin marcajul 

sau în format XML 

 

 

unde fiecare atribut are sintaxa nume=valoare. 

Directivele pot fi: page, include, taglib. 

• Directiva page are atributele 

extends= ”numeClasă” Servlet-ul corespunzător paginii jsp extinde 

clasa numeClasă. 

import= ”listă de pachete separate prin ,” 

session= "true | false" 

info= ”text” Informat¸ia se poate regăsi apelând metoda 

Servlet.getServletInfo() 

errorPage= ”adresa url a paginii ce tratează except¸ia” 

isErrorPage= "true | false" 

• Directiva include permite includerea unor fi¸siere .html sau .jsp în document 

 

• Directiva taglib indică bibliotecile de marcaje utilizate în documentul jsp, 

având atributele 

uri= ”uri - Universal Resource Identifier - a bibliotecii de marcaje” 

prefix= ”prefixul marcajului” 

7.1.3 Marcaje JSP predefinite 

Un marcaj JSP define¸ste o act¸iune care se execută în timpul procesării paginii 

jsp. Sintaxa marcajelor JSP seamănă cu cea a marcajelor html sau xml 

 

Dintre marcajele JSP predefinite – adică cu prefixul JSP – amintim: 

•


• 

În cazul marcajelor , se pot transmite 

parametri prin marcajele incluse 

 

. . . . . . 

 

• 

unde domeniu precizează domeniul de vizibilitate al componentei Java, 

adică page, request, session, application. 

• 

Acest marcaj este echivalent cu codul Java 

numeComponentăJava.setNumeProp(valoare). 

• 

Daca numeProp=* atunci toate proprietăt¸ile componentei sunt accesibile. 

7.1.4 Componentă Java (Java Bean) 

O componentă Java este o clasă care poate interact¸iona cu alte componente 

Java, cu un document jsp, etc. 

O componenta Java cont¸ine cel put¸in 

• Un constructor fără nici un argument; 

• O mult¸ime de câmpuri declarate private; 

• Pentru fiecare asemenea câmp 

private Tip xyz; 

trebuie definite metodele


public void setXyz(Tip xyz){ 

this.xyz=xyz; 

} 

public Tip getXyz(){ 

return xyz; 

} 

7.1.5 Pagini JSP cu componente Java 

Numele parametrilor din formularelele de introducere a datelor trebuie să 

coincidă cu identificatorii câmpurilor din componenta Java corespunzătoare. 

Reluăm exemplul 7.1.2 cu o componentă Java corespunzătoare numelui din 

formularul index.html. 


package jsp; 

public class HelloBean { 

private String name=""; 

public String getName() { 

return name; 

} 

public void setName(String name) { 

this.name=name; 

} 

} 

În acest caz, pagina JSP este 

 

 

 

 

jsphello 

 

 

Pagina de răspuns 

 

 

 

 

 

Mai mult, se poate include formularul în pagina JSP, bineînt¸eles ¸stergându-l 

din fi¸sierul html: 

jsp:useBean id="obj" class="jsp.HelloBean" scope="request"/> 


 

 

jsphello 

 

 

 

Pagina JSP - aplicaţia Hello 

 

Introduceti numele: 

 

 

 

 

 

 

 

 

 

Desfă¸surarea aplicat¸iei în vederea generării arhivei war va fi 

jsphello 

| |---> jsp 

| | | hello.jsp 

| |---> lib 

| |---> src 

| | |---> jsp 

| | | | HelloBean.java 

| |---> web 

| | | web.xml 



| build.xml 

Exemplul 7.1.4 Pagină JSP pentru calculul celui mai mare divizor comun. 

Documentului html 

 

 

Calculul Cmmdc 

 

 

Primul numar este 

 

 

Al doilea numar este 

 

 

 

 

 

 

 

îi corespunde componenta Java



public class CmmdcBean{ 

private String m=""; 

private String n=""; 

public void setM(String m){ 

this.m=m; 

} 

public void setN(String n){ 

this.n=n; 

} 

public String getM(){ 

return m; 

} 

public String getN(){ 

return n; 

} 

} 

Instant¸iem o componenta Java ¸si îi fixăm proprietăt¸ile (adică îi transmitem 

parametri problemei) după care apelăm metoda ce calculează rezultatul dorit: 

 

 

 

 

 

Cel mai mare divizor comun al numerelor 

 

si 

 

este 

 

 

 

Exemplul 7.1.5 Generarea unei except¸ii (errhandler.jsp): 

 

 

 


%> 

 

 

cu pagina de tratare a except¸iei (errorpage.jsp) 

 

 

 

 

 

 

 

 

 

apelate prin 

 

 

 

Care este materia preferata din anii de studiu universitar ? 

 

Algoritmica si programare 

 

 

Analiza numerica 

 

 

Inteligenta artificiala 

 

 

 

 

 

 

7.2 JSP Standard Tag Library JSTL 

JSTL este o familie de biblioteci de marcaje ce oferă o serie de facilităt¸i 

activităt¸ii de realizare a paginilor Web. JSTL ajută la separarea activităt¸ii de 

programare de aceea a proiectare (design) a paginii Web.

7.2. JSP STANDARD TAG LIBRARY JSTL 145 

JSTL este alcătuită din 5 biblioteci: 

URI Descriere 

http://java.sun.com/jsp/jstl/core Biblioteca de bază 

http://java.sun.com/jsp/jstl/xml Biblioteca de prelucrare 

a documentelor xml 

http://java.sun.com/jsp/jstl/fmt Biblioteca de formatare a datelor 

http://java.sun.com/jsp/jstl/sql Biblioteca de lucru cu baze de date 

http://java.sun.com/jsp/jstl/functions Biblioteca de funct¸ii ajutătoare 

Instalarea bibliotecilor. Bibliotecile sunt livrate împreună cu apachetomcat-* 

în catalogul apache-tomcat-*\webapps\examples\WEB-INF\lib prin 

fi¸sierele jstl.jar ¸si standard.jar. 

Utilizarea bibliotecilor. În vederea utilizării, cele două fi¸siere trebuie copiate 

în catalogul apache-tomcat-*.*\shared\lib 

În pagina / documentul JSP, o bibliotecă utilizată trebuie declarată printr-o 

directivă taglib. 

7.2.1 Biblioteca de bază 

 

Marcaje din biblioteca de bază: 

• c:set Fixează o valoare într-o variabilă. 

Atribute ale marcajului: 

Atribut Fel Descriere 

var obligatoriu Numele variabilei ce va stoca valoarea 

expresiei. 

value opt¸ional Expresia care va fi evaluată ¸si atribuită 

variabilei 

scope opt¸ional Domeniul de vizibilitate al variabilei. 

Unul din valorile: 

page, request, session, application. 

Referirea la o variabilă se face prin sintaxa ${numeVariabilă} 

Referirea la valoarea unui câmp dintr-un formular se face prin sintaxa 

${param.numeCâmp} 

Alături de obiectul param, alte obiecte predefinite sunt cookie, header, 

initParam, pageContext. 

Se pot defini variabile cu acela¸si nume dar având domenii de vizibilitate 

diferită. Referirea se face prin ${pageScope.numeVariabilă},


${requestScope.numeVariabilă}, ${sessionScope.numeVariabilă}, 

${applicationScope.numeVariabilă}. 

Plasând clauza empty înaintea unei variabile, ${empty numeVariabilă}, se 

obt¸ine false sau true după cum variabila are sau nu atribuită o valoare. 

• c:remove S¸terge o variabilă. 



var obligatoriu Numele variabilei ce se ¸sterge. 

scope opt¸ional Domeniul de vizibilitate al variabilei. 



• c:out Afi¸sează o valoare. 



value obligatoriu Valoarea ce se evaluează ¸si se afi¸sează. 

default opt¸ional Cea ce se afi¸sează în cazul în care 

expresia nu poate fi evaluată. 

escapeXml opt¸ional true / false. Valoarea implicită este true. 

Pe false interpretează caracterele din value 

ca ¸si cod html. 

• c:if Test, verificarea unei condit¸ii. 



test obligatoriu Condit¸ia de test. 

var opt¸ional Numele variabilei ce va stoca valoarea 

testului. 

scope opt¸ional Domeniul de vizibilitate al variabilei 

definită anterior. 

În cazul în care condit¸ia are valoarea true se prelucrează corpul marcajului, 

în caz contrar, acesta este ignorat. 

Exemplul 7.2.1 Preluarea datelor unui formular cu câmpurile de intrare 

nume, prenume ¸si email se face prin pagina JSP 

 


 

 

 

 

 

 

Nume: 

 

 

 

 

 

 

Prenume: 

 

 

 

 

 

 

E-mail: 

 

 

 

• c:choose Marcajul de select¸ie poate cont¸ine oricâte marcaje c:when ¸si cel 

mult un marcaj c:otherwise. Fiecare marcaj c:when cont¸ine obligatoriu 

atributul test. Dacă într-un marcaj c:when condit¸ia are valoarea true, 

atunci se prelucrează corrpul acelui marcaj. 

În cazul în care toate mar- 

cajele c:when au fost evaluate cu false atunci se va prelucra marcajul 

c:otherwise (marcaj fără atribute). 

• c:forEach Ciclu. 



items opt¸ional Colect¸ia care se parcurge. 

var opt¸ional Numele variabilei în care se stochează 

valoarea elementului curent. 

begin opt¸ional Valoarea init¸ială a variabilei var. 

end opt¸ional Valoarea finală a variabilei var. 

step opt¸ional Valoarea pasului de iterare. Implicit este 1. 

varStatus opt¸ional Informat¸ii despre elementul curent. 

Variabila varStatus are câmpurile: 

– index valoarea curentă a elementului după care se realizează ciclarea; 

– count numărul iterat¸iei curente; 

– first are valoarea true dacă este primul element al ciclului;


– last are valoarea true dacă este ultimul element al ciclului; 

Exemplul 7.2.2 Lista parametrilor formularului de apelare a exemplului 

anterior se afi¸sează prin: 

Lista parametrilor din formular 

 

 

 

 

 

 

 

Exemplul 7.2.3 Lista parametrilor unui header se afi¸sează prin: 

Lista campurilor din antet 

 

 

 

 

 

 

 

Exemplul 7.2.4 Verificarea fontului cu care se scriu titlurile într-un document 

html: 

 

 

 

• c:forTokens Asigură acea¸si funct¸ionalitate ca ¸si clasei java.util.String 

Tokenizer. 



value obligatoriu Valoarea ce se evaluează ¸si se afi¸sează. 

expresiei. 

default opt¸ional Cea ce se afi¸sează în cazul în care 

expresia nu poate fi evaluată. 

escapeXml opt¸ional true / false. Valoarea implicită este true. 

Pe false interpretează caracterele din value 

ca ¸si cod html.


• c:import Permite includerea altor pagini JSP în pagina curentă. 



url obligatoriu Adresa documentului importat. 

context opt¸ional Context-ul paginii / documentului importat. 

Simbolul /, urmat de numele unei aplicat¸ii 

de pe acela¸si server. 

var opt¸ional Numele variabilei în care va fi stocat 

documentul importat. 

scope opt¸ional Domeniul de vizibilitate al variabilei var. 



Cu marcajul c:param se pot fixa parametri pentru pagina importată. Acest 

marcaj are două atribute name ¸si value. Acesti parametri se transmit cu 

metoda get. 

• c:redirect Redirectarea activitatea către o altă pagină. 



url obligatoriu Adresa paginii către care se face redirectarea. 

context opt¸ional Context-ul paginii către care se face redirectarea. 



Prin redirectare, parametrii nu sunt retransmi¸si automat mai departe. 

• c:url Ret¸ine adrese URL. 



value obligatoriu Adresa documentului de ret¸inut. 

context opt¸ional Context-ul documentului. 



var opt¸ional Numele variabilei în care va fi stocată 

adresa documentului. 



page, request, session, application.


7.2.2 Biblioteca de lucru cu baze de date 

 

Marcaje din biblioteca de bază: 

• sql:setDataSource Fixează referint¸a la baza de date. 



dataSource opt¸ional Referint¸a la baza de date 

driver opt¸ional Driver-ul bazei de date 

url opt¸ional url-ul bazei de date 

username opt¸ional nume utilizatorului bazei de date 

password opt¸ional parola de acces la baza de date 

var opt¸ional variabila cu referint¸a la baza de date 


• sql:query O interogare a bazei de date. 



sql obligatoriu Fraza sql 


startRow opt¸ional Linia de la care se începe interogarea 

maxRows opt¸ional Numărul maxim de rezultate acceptate 

var obligatoriu Variabila cu rezultatele interogării 

bazei de date 


• sql:update Actualizarea a bazei de date. 



sql obligatoriu Fraza sql 


Exemplul 7.2.5 Să se afi¸seze lista din agenda telefonică creată în exemplul din 

Cap. Servlet. 

 

 

 

 

7.3. MARCAJE JSP PERSONALE 151 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

7.3 Marcaje JSP personale 

Programatorul poate crea marcaje JSP proprii care se grupează în colect¸ii 

numite biblioteci de marcaje. 

7.3.1 Marcaje fără atribute ¸si fără corp. 

Pentru a crea unui asemenea marcaj JSP propriu este necesară definirea a 

patru componente: 

1. O clasă de definit¸ie a comportamentului marcajului JSP (tag handler class). 

2. Descriptorul de bibliotecă de marcaje JSP, care leagă clasa de definit¸ie a 

marcajului cu numele simbolic de utilizare. 

3. Marcajul taglib a fi¸sierului web.xml a lui tomcat, care permite serverului 

Web să găsească descriptorul de bibliotecă de marcaje ¸si clasele de definit¸ie 

a comportamentului marcajelor JPS. 

4. Fi¸sierul JSP ce utilizează marcajul JSP (clientul). 

Exemplificăm acestă tehnologie prin


Exemplul 7.3.1 Să se realizeze un marcaj dateTag, a cărui efect să fie afi¸sarea 

datei calendaristice. 

1. Clasa de definit¸ie a comportamentului marcajului. Programul constă din: 

(a) Importul pachetelor 

import javax.servlet.jsp.*; 

import javax.servlet.jsp.tagext.*; 

Aceste pachete se găsesc în fi¸sierul jsp-api.jar. 

(b) Un marcaj fără atribute ¸si fără corp trebuie să extindă clasa TagSupport 

¸si să suprascrie metoda doStartTag, care define¸ste activitatea intreprinsă 

când este întâlnit marcajul într-un document jsp. Metoda 

trebuie să returneze constanta SKIP BODY. 

public class NumeClasa extends TagSupport{ 

public int doStartTag(){ 

. . . 

return SKIP_BODY; 

} 

} 

(c) Scrierea în fluxul de ie¸sire se face cu un obiect JspWriter, care se 

obt¸ine cu pageContext.getOut(). Metoda print a clasei JspWriter 

poate genera o except¸ie IOException. 

Textul sursă al clasei de definit¸ie a comportamentului marcajului dateTag 

este: 

package jsp; 





public class DateTag extends TagSupport{ 


try{ 

JspWriter out=pageContext.getOut(); 

out.println(new Date()); 

} 


System.out.println("DateTagException "+e.getMessage()); 

} 


} 

}


2. Descriptorul de bibliotecă de marcaje JSP este dependent de versiunea tomcat 

folosită. Acest fi¸sier trebuie să aibă extensia tld (Taglib Language 

Definition). Localizarea acestui fi¸sier este definită în elementul taglib din 

web.xml. În cazul unei distribut¸ii ≥ apache-tomcat-5.*, acest fi¸sier este 

(mylibtag.tld): 

 

 

 

 

1.0 

1.2 

mytags 

http://java.apache.org/tomcat/mytaglib 

Librarie de marcaje 

 

dateTag 

jsp.DateTag 

EMPTY 

furnizeaza data curenta 

 

 

Pentru fiecare marcaj propriu se completează un marcaj tag. Pentru un 

marcaj propriu fără atribute elementele acestui marcaj sunt 

(a) name Numele simbolic al marcajului. 

(b) tag-class Referint¸a la fi¸sierul class al clasei de definit¸ie a comportamentului 

marcajului propriu. Referint¸a se face relativ la catalogul 

...\WEB-INF\classes 

(c) description Descrierea marcajului propriu. 

(d) body-content În cazul nostru are valoarea EMPTY. În cazul unui marcaj 

cu corp se dă valoarea JSP. 

3. Marcajul taglib din fi¸sierul web.xml 

 

 

http://java.apache.org/tomcat/mytaglib 

 

 

/WEB-INF/jsp/mylibtag.tld 

 

 

Elementele marcajului taglib sunt:


(a) taglib-uri Referint¸ă a subcatalogului din catalogul webapps în care 

se găse¸ste descriptorul de bibliotecă de marcaje. 

(b) taglib-location Numele complet al fi¸sierului descriptor de bibliotecă 

de marcaje. 

Astfel elementele constitutive se vor găsi în: 

webapps 

|--> mytag 

| |--> WEB-INF 

| | |--> classes 

| | | |--> jsp 

| | | | |--> DateTag.class 

| | | web.xml 

| | |--> jsp 

| | | |--> mylibtag.tld 

| |--> jsp 

| | | dateTag.jsp 

4. Marcajele proprii se utilizează cu sintaxa 

 

Referint¸a la catalogul cu toate componentele necesare marcajului ¸si prefixul 

se fixează în directiva taglib. 

Un fi¸sier jsp care utilizează marcajul realizat este (dateTag.jsp): 

 

 

 

Tag pentru data calendaristica curenta 

 

 

 

 

 

Data curenta este: 

 

 

 

7.3.2 Marcaje cu atribute ¸si fără corp. 

Realizăm un marcaj ziuaTag cu un atribut ziua care va fi afi¸sat în momentul 

prelucrării marcajului.


1. Pentru fiecare atribut clasa ce define¸ste act¸iunea marcajului trebuie să 

cont¸ină o metodă 

2. 

public void setNumeAtribut(String value){...} 

care preia valoarea atributului dată de parametrul value. 


Pentru exemplul enunt¸at această clasă este 

package jsp; 




public class ZiuaTag extends TagSupport{ 

String ziua; 

public void setZiua(String value){ 

ziua=value; 

} 


try{ 


out.println(ziua); 

} 


System.out.println("ZiuaTagException "+e.getMessage()); 

} 


} 

} 

În descriptorul bibliotecii de marcaje pentru fiecare atribut se define¸ste un 

marcaj ...< /attribute> având incluse marcajele 

Nume marcaj Semnificat¸ie Fel 

name numele atributului obligatoriu 

required true | false după cum atributul e obligatoriu 

obligatoriu sau nu 

rtexprvalue true | false după cum atributul opt¸ional 

se poate utiliza într-o expresie 

< %= numeAtribut % > 

Marcajul din descriptorul bibliotecii de marcaje devine


 

ziuaTag 

jsp.ZiuaTag 

EMPTY 

furnizeaza argumentul ziua curenta 

 

ziua 

true 

true 

 

 

3. Utilizarea acestui marcaj este exemplificat în 

 

 

 

Astazi,este 

 

Luni 

Marti 

Miercuri 

Joi 

Vineri 

Simbata 

Duminica 

 

 

 

 

 

unde ziuaTag.jsp este 

 

 

Tag cu marcaj 

 

 

 

 

 

Ziua este: 

 

 

 

7.3.3 Marcaje cu corp. 

În metoda doStartTag valoarea returnată trebuie să fie EVAL BODY INCLUDE, 

în loc de SKIP BODY. 

În descriptorul bibliotecii de marcaje apare


JSP 

în loc de EMPTY. 

Dacă se dore¸ste ca marcajul să execute act¸iuni după interpretarea corpului, 

atunci acele activităt¸i sunt definite în metoda doEndTag. Această metodă 

returnează valoarea EVAL PAGE sau SKIP PAGE după cum se dore¸ste sau nu continuarea 

procesării paginii jsp. 

Exemplul 7.3.3 Fie marcajul modTag care modifica un text în caractere mari 

sau mici după valoarea atributului trans. Acest marcaj poate include ale elemente. 

Codul clasei ce prelucrează marcajul este 

package jsp; 




public class ModTag extends TagSupport{ 

String text; 

boolean toUpperCase; 

public void setText(String value){ 

text=value; 

} 

public void setTrans(String value){ 

toUpperCase=(new Boolean(value)).booleanValue(); 

} 


try{ 


if(toUpperCase) 

out.println(text.toUpperCase()); 

else 

out.println(text.toLowerCase()); 

} 


System.out.println("ModTagException "+e.getMessage()); 

} 

return EVAL_BODY_INCLUDE; 

} 

} 

Descriptorul bibliotecii de marcaje se completează cu 

 

modTag 

jsp.ModTag 

JSP 

modifica caracterele 

 

text 

true


true 

 

 

trans 

true 

true 

 

 

O pagină de utilizare a marcajului modTag cu un corp nevid este 

 

 

 

Introduce o frază 

 

 

Se transformă în litere 

 

mari 

mici 

 

 

 

 

 

împreună cu modtextTag.jsp 

 

 

 

 

 

 

 

 

 

Capitolul 8 

Portlet 

Prezentarea termenului de portlet se face împreună cu cea de portal. Portalul 

ca ¸si portletul sunt aplicat¸ii Web. Practic un portal accesat afi¸sează portleturi în 

ferestre distincte, portleturile fiind aplicat¸ii pe care clientul le poate folosi (Fig. 

1, Fig. 2). 

Fig. 1. Portal - Portlet. 

Această prezentare se raportează la JSR (Java Specification Request) 168. 

JSR 286 este următorul standard pe care trebuie să le îndeplinească un portlet. 

Portalul este o aplicat¸ie Web cu funct¸ionalităt¸ile: 

• Container de portlet¸i. Containerul este responsabil de init¸ializarea ¸si distrugerea 

portlet¸ilor, de transmiterea cererilor către portlet¸i ¸si de colectarea 

răspunsurilor. 

• Agregarea cont¸inuturilor (Content aggregator). Permite afi¸sarea ¸si gestionarea 

mai multor portleturi. 

• Asigură servicii dintre care amintim: 

159

160 CAPITOLUL 8. PORTLET 

Fig. 2. Aparit¸ia portlet-etelor într-o pagină a unui portal. 

– acces la portal pe bază de autentificare ¸si autorizare. Odată autorizat, 

un client are acces la orice portlet. 

– posibilitatea personalizării portleturilor de către client¸i. 

Varietatea serviciilor variază de la un portal la altul. 

Portletul este o aplicat¸ie Web care se aseamănă cu servletul prin: 

• Se instalează într-un container. 

• Generează cont¸inut dinamic. 

• Ciclul de viat¸ă este gestionat de container. 

• Interact¸ionează cu clientul prin modelul request/reply. 

Deosebirile unui portlet fat¸ă de un server sunt: 

• Portletul posedă mai multe variante de tratare a cererilor. 

• Prin conceptul de mod (mode) se specifică variante distincte prin care 

portletul react¸ionează. Sunt definite modurile VIEW, EDIT, HELP. Act¸iunile 

corespunzătoare sunt definite în metodele doView, doEdit, doHelp.

8.1. APACHE-PLUTO 161 

• Prin WindowState se fixează spat¸iul utilizat de portlet. Valorile variabilei 

WindowState sunt NORMAL, MAXIMIZED, MINIMIZED. În varianta MAXI- 

MIZED portletul ocupă întreaga fereastră, în timp ce în varianta MINI- 

MIZED portletul apare într-o bară de titluri. 

8.1 Apache-pluto 

Pentru dezvoltarea portleturilor vom folosi produsul Apache-pluto care generează 

un portal în care se pot instala / dezinstala u¸sor portleturi. 

Instalarea produsului. În funct¸ie de natura distribut¸iei descărcate: 

• pluto-1.1.*-bundle.* 

Cont¸ine pluto integrat într-o versiune apache-tomcat-5.5.*. Instalarea revine 

la dezarhivarea fi¸sierului descăcat. 

• pluto-1.1.*-bin.* 

După dezarhivarea fi¸serului pluto-1.1.*-bin.*, descărcat din internet, în catalogul 

PLUTO HOME, instalarea se face în apache-tomcat-5.5.* prin: 

1. Fi¸sierele jar din catalogul PLUTO HOME\lib se copiază în catalogul 

TOMCAT HOME\shared\lib. 

2. 

În acest catalog mai trebuie introduse fi¸sierele: 

– castor-1.1.1.jar 

– portlet-api.jar 

Aceste fi¸siere sunt incluse în distribut¸ia pluto-1.1.*-bundle.*. 

3. Se crează în TOMCAT HOME catalogul PlutoDomain 

4. Se copiază fi¸sierele war din catalogul PLUTO HOME\webapps în catalogul 

TOMCAT HOME\PlutoDomain 

5. Se crează în catalogul TOMCAT HOME\conf\Catalina\localhost fi¸sierul 

pluto.xml având cont¸inutul 

 

 

6. Se completează fi¸sierul tomcat-users.xml din catalogul TOMCAT HOME\conf 

cu 

 

 

 

 

Utilizarea produsului. Dintr-un navigator, portalul se apelează prin 

http://host:8080/pluto/portal


Accesul se face cu User name = password = pluto. 

Instalarea unui portlet se face în 2 pa¸si: 

1. Desfă¸surarea portlet-ului: Fi¸sierul arhivat al portletului, având estensia 

war, se depune în catalogul PlutoDomain. Apelând managerul lui apachetomcat 

din componenta Pluto admin se obt¸ine instalarea portletului. 

Alternativ, desfă¸surarea portlet-lui se va obt¸ine cu apache-ant cu utilizarea 

unui fi¸sier build.xml dedicat. 

2. Publicarea portlet-ului se face prin componenta Pluto admin. 

8.2 Portlet container JSR 286 

portlet-container-configurator(.jar) instalează un container de portlete în apachetomcat-5.5.* 

/ glassfish v2, container care suportă portlete potrivit specificat¸iei 

JSR 286. Containerului îi este ata¸sat un portal simplu. 

Instalarea containerului de portlete JSR 286. Presupunem că serverul 

Web apache-tomcat-5.5.* este instalat împreună cu componenta manager. Containerul 

de portlete se instalează prin 

java -jar portlet-container-configurator.jar 

În interfat¸a grafică, se fixează serverul Web (Glassfish / Tomcat), locat¸ia apacheant 

(Ant-Home) ¸si locat¸ia serverului Web Select Install Directory). 

Utilizarea portalului. Portalul se apelează prin 

http://host:port/portletdriver 

Prin administratorul portalului (Admin) se pot încărca / sterge portlete. Acestea 

sunt vizibile pe pagina Portlets. 

8.3 Dezvoltarea unui portlet 

Compilarea ¸si arhivarea unui portlet în vederea desfă¸surării se va face rulând 

ant cu fi¸sierul build.xml: 

 

 

 

 

 

8.3. DEZVOLTAREA UNUI PORTLET 163 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 


 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

Fi¸sierul de proprietăt¸i build.properties este 

#build.properties 

#Standard properties for Ant build of a Pluto 1.1 portlet 

#module name 

app.name=NumePortlet 

#Directory that holds source code 

src.dir = src/main 

java.src.dir = ${src.dir}/java 

#Directory that holds documentation

8.3. DEZVOLTAREA UNUI PORTLET 165 

doc.dir = docs 

#Directory that holds files to be built into a jar, war or ear 

build.dir = build 

webbuild.dir = ${build.dir}/webapp 

classbuild.dir = ${webbuild.dir}/WEB-INF/classes 

#Directory that holds configuration files 

conf.dir = ${src.dir}/resource 

#Directory that holds libraries required to build and run the classes 

lib.dir = lib 

#Directory that holds webapp files 

web.dir = ${src.dir}/webapp 

#WEB-INF directory 

web-inf.dir = ${web.dir}/WEB-INF 

#Directory that holds files to build distribution 

dist.dir = ${build.dir}/dist 

Pentru utilizarea acestui build.xml este nevoie de structura următoare de cataloage 

NumePortlet 

|--> lib 

| | castor-1.1.1.jar 

| | commons-logging-*.jar 

| | pluto-ant-tasks-*.jar 

| | pluto-descriptor-api-*-dev.jar 

| | pluto-descriptor-impl-*-dev.jar 

| | pluto-util-*-dev.jar 

| | portlet-api-*.jar 

| | servlet-api-*.jar 

|--> src 

| |--> main 

| | |--> java 

| | | |--> pachetul portletului 

| | |--> resource 

| | | | NumePortlet.xml 

| | |--> webapp 

| | | |--> jsp 

| | | | | fisierele jsp ale portletului 

| | | |--> WEB-INF 

| | | | | portlet.xml 

| | | | | web.xml


Fi¸sierele castor.1.1.1.jar, pluto-descriptor-api-*.jar, pluto-descriptor-impl-*.jar, 

portlet-api.jar se copiază din catalogul PLUTO HOME\shared\lib, iar fi¸sierul servletapi-*.jar 

se ia din PLUTO HOME\common\lib. 

Fi¸sierul web.xml de mai sus este 

 

 

 

Cont¸inutul final al acestui fi¸sier rezultă în urma obiectivului ant assemple, 

în care se preiau date din fi¸sierul de configurare al portletului portlet.xml. 

Editarea fi¸sierului portlet.xml este sarcina programatorului. 

Fi¸sierul NumePortlet.xml este utilizat la desfă¸surarea aplicat¸ie, fiind copiat 

în catalogul conf\Catalina\localhost al lui apache-tomcat sau Apache-pluto. 

Acest fi¸sier are cont¸inutul: 

 

8.4 Elemente de programare 

Orice portlet implementează interfat¸a Portlet. Interfat¸a Portlet declară 4 

metode 

public interface Portlet{ 

public void init(PortletConfig config) throws PortletException; 

} 

public void processAction(ActionRequest request, ActionResponse 

response) throws PortletException, java.io.IOException; 

public void render(RenderRequest request, RenderResponse 


public void destroy(); 

Metoda processAction prelucrează cererea emisă de containerul de portlete. 

La solicitarea containerului, metoda render regenerează cont¸inutul unui portlet. 

Clasa GenericPortlet este implementarea init¸ială a interfet¸ei Portlet. Extinzând 

clasa GenericPortlet, sarcina programatorului este să suprascrie metodele

8.4. ELEMENTE DE PROGRAMARE 167 

• doView pentru tratarea modului VIEW; 

protected void doView(RenderRequest req,RenderResponse res) 

throws PortletException, IOException 

• doEdit pentru tratarea modului EDIT; 

protected void doEdit(RenderRequest req,RenderResponse res) 


• doHelp pentru tratarea modului HELP; 

protected void doHelp(RenderRequest req,RenderResponse res) 


• init, destroy pentru init¸ializarea, respectiv oprirea portletului. 

void init() throws PortletException 

void init(PortletConfig config) throws PortletException 

void destroy() 

¸si eventual, să definească cont¸inutul metodei 

public void processAction(ActionRequest request,ActionResponse 


Exemplul 8.4.1 Portletul HelloWorld. 

package hello; 


import javax.portlet.*; 

public class HelloWorldPortlet extends GenericPortlet{ 

protected void doView(RenderRequest request, RenderResponse response) 

throws PortletException, IOException{ 

response.setContentType("text/html"); 

response.getWriter().println("Hello World!"); 

} 

//Alta varianta de programare 

/* 

public void doView(RenderRequest req, RenderResponse res) 

throws PortletException, IOException { 




out.println("Hello World! "); 


} 

*/ 

} 

Fi¸sierul portlet.xml este


 

 

 

Hello World as a portlet app 

HelloWorld1Portlet 

Hello World Portlet 

hello.HelloWorld1Portlet 

 

text/html 

VIEW 

 

 

Hello World Portlet 

 

 

 

Exemplul 8.4.2 Evident¸ierea modurilor VIEW, EDIT ¸si HELP. 

package hellopluto; 



public class HelloPlutoPortlet extends GenericPortlet{ 




Writer out=res.getWriter(); 

out.write("Hello Pluto in view mode"); 

} 

public void doEdit(RenderRequest req, RenderResponse res) 




out.write("Hello Pluto in edit mode"); 

} 

public void doHelp(RenderRequest req, RenderResponse res) 




out.write("Hello Pluto in help mode"); 

} 

} 

Fi¸sierul portlet.xml este 

 


 

Hello Pluto as a portlet app 

HelloPlutoPortlet 

Hello Pluto 

hellopluto.HelloPlutoPortlet 

 

text/html 

VIEW 

EDIT 

HELP 

 

 

Hello Pluto Portlet 

 

 

 

Exemplul 8.4.3 Portletul Hello. Portletul afi¸sează o zonă text de introducere a 

unui nume ¸si un buton. Odată introdus numele, la apăsarea butonului se afi¸saeză 

textul Hello nume ¸si un buton de reluare. 

package helloname; 



import java.util.Enumeration; 

public class HelloNamePortlet extends GenericPortlet{ 




String nume=(String)req.getParameter("name"); 

PortletRequestDispatcher prd=null; 

if(nume==null){ 

prd=getPortletContext().getRequestDispatcher("/jsp/input.jsp"); 

prd.include(req,res); 

} 

else{ 

// Varianta cu afisare prin View 

/* 


out.write("Hello "+ nume); 

PortletURL renderURL=res.createRenderURL(); 

renderURL.setPortletMode(PortletMode.VIEW); 

renderURL.setWindowState(WindowState.NORMAL); 

out.write(" Reluare "); 

*/ 

// Varianta cu afisare printr-un fisier jsp 

prd=getPortletContext().getRequestDispatcher("/jsp/output.jsp"); 


} 

} 

public void processAction(ActionRequest req, ActionResponse res) 

throws IOException,PortletException{ 

// Preia parametrii si le trimite celui care a emis cererea


Enumeration params=req.getParameterNames(); 

while(params.hasMoreElements()){ 

String parameterName = (String)params.nextElement(); 

String parameterValue=req.getParameter(parameterName); 

res.setRenderParameter(parameterName,parameterValue); 

} 

} 

} 

Fi¸sierele input.jsp ¸si putput.jsp au codurile 

 

 

 

Introduceţi numele: 

 

 

 

 

 

 

Reluare 

. 

Exemplul 8.4.4 Cel mai mare divizor comun a două numere naturale într-un 

portlet. 

Variantă în care calculul este programat în portlet. 





public class CmmdcPortlet extends GenericPortlet{ 





String rez=req.getParameter("rez"); 

if(rez==null){


} 

prd=getPortletContext().getRequestDispatcher("/jsp/input.jsp"); 


} 

else{ 

prd=getPortletContext().getRequestDispatcher("/jsp/output.jsp"); 


} 

} 



// Preia parametrii si le trimite celui care a emis cererea 

String sm=req.getParameter("m"); 

String sn=req.getParameter("n"); 

long m=Long.parseLong(sm); 

long n=Long.parseLong(sn); 

long c=cmmdc(m,n); 

res.setRenderParameter("rez",(new Long(c)).toString()); 

} 

private long cmmdc(long m,long n){. . .} 

Fi¸sierele inputCmmdc.jsp ¸si outputCmmdc.jsp au codurile 

 

 

 

 

 

 

Primul număr 

 

 

 

Al doilea număr 

 

 

 

 

 

 

 

 

 

 

¸si respectiv 

 

 

 

 


%> 

 

 

Reluare 

 

Variantă în care calculul este programat într-o componentă Java (bean) 

¸si care este apelat în pagina jsp de afi¸sare a rezutlatului. 





public class CmmdcPortlet extends GenericPortlet{ 





String sb=req.getParameter("submitButton"); 

if(sb==null){ 

prd=getPortletContext().getRequestDispatcher("/jsp/inputCmmdc.jsp"); 


} 

else{ 

prd=getPortletContext().getRequestDispatcher("/jsp/outputCmmdc.jsp"); 


} 

} 



// Preia parametrii si le trimite celui care a emis cererea 

Enumeration params=req.getParameterNames(); 

while(params.hasMoreElements() ) { 

String parameterName = (String)params.nextElement(); 

String parameterValue=req.getParameter(parameterName); 

System.out.println(" >> parameterName = " + parameterName + 

" parameterValue = " + parameterValue); 

res.setRenderParameter(parameterName,parameterValue); 

} 

} 

} 

Codul componentei Java 

public class CmmdcBean{ 

private String m=""; 

private String n=""; 

public void setM(String m){ 

this.m=m; 

} 

public void setN(String n){ 

this.n=n; 

}


public String getM(){ 

return m; 

} 

public String getN(){ 

return n; 

} 

public String cmmdc(){ 

long m0=Long.parseLong(m); 

long n0=Long.parseLong(n); 

long c,r; 

do{ 

c=n0; 

r=m0%n0; 

m0=n0; 

n0=r; 

} 

while(r!=0); 

return (new Long(c)).toString(); 

} 

} 

Pagina outputCmmdc.jsp 

 

 

 

 

 

 

 

 

 

Reluare 

 

Variantă în care care calculul este programat într-un servlet. Servletul 

utilizat este cel prezentat în capitolul Servlet, (6.3.2), dar inclus în pachetul 

portlet-ului. Fi¸sierul inputCmmdc.jsp are în plus linia 

 

iar în codul clasei CmmdcPortlet, în locul liniei 

prd=getPortletContext().getRequestDispatcher("/jsp/outputCmmdc.jsp"); 

apare 

prd=getPortletContext().getRequestDispatcher("/cmmdc"); 

adică în locul invocării paginii JSP, dispecerul apelează servletul. În servlet este 

esent¸ială furnizarea rezultatului în format html. Pagina html generată se încarcă 

în fereastra portlet-ului. 

Fi¸sierul web.xml, înaintea completării prin ant, este


 

 

 

CmmdcServlet 

cmmdc.CmmdcServlet 

 

 

CmmdcServlet 

/cmmdc 

 

 

Interfat¸a PortletPreferences 

Atribute, adică perechi de tip String (nume,valoare) definite în fi¸sierul portlet.xml 

prin 

 

 

nume_atribut 

valoare_atribut 

true|false 

 

. . . 

 

Atributele se transmit metodelor doView, doEdit ¸si doHelp. Suportul este 

oferit prin interfat¸a PortletPreferences. 


• String getValue(String key, String def ) 

Returnează valoarea primului atribut având numele key. În lipsa atributului 

sau a valurii returnează valoarea def. 

• String[] getValues(String key, String[] def ) 

Returnează toate valorile atributului key. 

• Enumeration getNames() 

Suport pentru acces la numele atributelor care au valoare.

8.5. PRODUSE PORTAL 175 

• Map getMap() 

Suport pentru acces la atribute. 

Un obiect care implementează interfat¸a PortletPreferences se obt¸ine prin 

metoda getPreferences() a clasei RenderRequest. 

Exemplul 8.4.5 Portlet în care se preiau ¸si se afi¸sează valori ale atributelor. 

Codul portletului este 

package pref; 



public class PrefPortlet extends GenericPortlet{ 



PortletPreferences prefs = req.getPreferences(); 

String attr1 = prefs.getValue("ATTR1", "attr1"); 

String attr2 = prefs.getValue("ATTR2", "attr2"); 



out.write(""+attr1+" "+attr2+""); 

} 

} 

iar atributele din fi¸sierul portlet.xml sunt 

 

 

ATTR1 

Programare distribuita 

true 

 

 

ATTR2 

 

true 

 

 

Al doilea atribut nu are valoare.Portletul afi¸sează textul Programare distribuita 

attr2. 

8.5 Produse Portal 

Termenul portal va desemna atât aplicat¸ia informatică prin care o institut¸ie 

comunică cu lumea exterioară cât ¸si produsul informatic care realizează acest 

lucru. 

Dezvoltarea unui portal al unei organizat¸ii se face pe produse specializate 

acestui scop. Dintre asemenea produsele gratuite amintim:


• uPortal; 

• jetspeed-2; 

care vor fi prezentate în continuare. apache-pluto este ideal pentru testarea 

portlet-elor. 

8.5.1 uPortal 

uPortal este un portal cadru, dezvoltat de JA-SIG (Java Architecture Special 

Interest Group) ¸si a fost utilizat de mai multe universităt¸i ca suport în construct¸ia 

portalului specific. 

Instalarea produsului. Distribut¸ia produsului se face în două variante 

• uPortal-*.*.* - uPortal-only; 

• uPortal-*.*.*-quick-start care înglobează toate resursele necesare funct¸ionării 

(apache-ant, apache-tomcat, apache-maven, HypersonicSQLDB). 

În cele ce urmează utilizăm varianta uPortal-quick-start. Instalarea produsului 

revine la dezarhivarea fi¸sierului descărcat. 

Lansarea portalului. În urma dezarhivării, în catalogul uPortal HOME se 

găse¸ste un fi¸sier build.xml, ale cărei obiective asigură lansarea portalului1 . 

Se completează fi¸sierul ant.bat cu referint¸a set JAVA HOME=... 

Lansarea portalului constă în executarea comenzii 

ant start 

De fapt se porne¸ste SGBD HypersonicSQLDB ¸si serverul Web apache-tomcat. 

Oprirea portalului se face prin executarea comenzii 

ant stop 

Dintr-un navigator, portalul se accesează prin 

http://host:8080/uPortal 

Accesarea portalului se poate face doar de det¸inătorii unui cont (UserName, 

Password). Administratorul (UserName=Password=admin) poate crea conturi 

noi. 

Instalarea unui portlet constă în desfă¸surarea ¸si publicarea lui. 

Compilarea ¸si arhivarea portletului se poate face cu apache-ant În acest scop 

se crează structura 

1 La prima executare a unei operat¸ii asupra portalului, calculatorul trebuie să fie conectat 

la internet, deoarece mai multe resurse sunt descărcate prin apache-maven. Aceste resurse se 

depun în c:\Documents and Settings\adminName\.m2\repository.


|--> lib 

| | portlet-api-1.0.jar 

|--> pachetul portlet-ului 

| |--> jsp 

| | | *.jsp 

| |--> WEB-INF 

| | |--> classes 

| | | | *.java 

| | | web.xml 

| | | portlet.xml 

| build.xml 

cu fi¸sierele *.java, *.jsp ¸si portlet.xml corespunzătoare portletului iar web.xml 

este generic 

 

 

 

 

Fi¸sierul build.xml, compilare ¸si arhivare este 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 


webxml="${package}/WEB-INF/web.xml"/> 

 

 

 

 

 

 

Desfă¸surarea portlet-ului se face cu apache-ant utilizând fi¸sierul build.xml 

din uPortal HOME\uPortal-*.*.* prin 

ant deployPortletApp -DportletApp=arhiva portlet-ului.war 

În urma acestei operat¸ii, portlet-ul se dezarhivează în uPortal HOME\apachetomcat-*.*.*\webapps 

iar fi¸sierul web.xml este actualizat. 

Publicarea portlet-ului se face cu rolul de administrator. După conectare la 

uPortal 

1. AdminTools → Portlet Manager → Publish a new channel 

2. Se parcurg meniurile Channel Manager 

(a) Din meniul Channel Type se selectează opt¸iunea Portlet. Clic Next. 

(b) 

(c) 

(d) 

(e) 

(f) 

(g) 

(h) 

În meniul General Settings se fixează tot¸i parametrii indicat¸i. Clic 

Next. 

În meniul Portlet Descriptor se fixează 

• Contextul portlet-ului, adică catalogul din webapps care cont¸ine 

portlet-ul. În mod obligatoriu primul caracter este \; 

• Numele portlet-ului a¸sa cum este definit în fi¸sierul portlet.xml. 

Clic Next. 

În meniul Portlet Preferences, clic Next. 

În meniul Channel Controls, clic Next. 

În meniul Categories se fixează categoria canalului ¸si cel putin un 

membru. 

Select Marked → Next. 

În meniul Groups se fixează grupul ¸si cel putin un membru. 

Select Marked → Next 

Grupul desemnează client¸ii care pot publica portlet-ul. 

În meniul Review, clic Finish. 

Canalul portlet-ului apare în lista afi¸sată.


3. Fiecare client care poate utiliza portlet-ul, îl publică prin componenta Customize. 

Pentru administrator: AdminTools → Customize urmat de 

(a) Clic pe un buton Add Channel corespunzător locului unde vrem să fie 

pozit¸ionat portlet-ul. 

(b) În User Preferences, 

i. se alege categoria portlet-ului, clic go; 

ii. se alege numele portlet-ului, clic Add Channel. 

(c) Clic pe numele canalului corespunzător portlet-ului. Canalul este 

afi¸sat în meniul Welcome. 

(d) Clic pe numele canalului din meniul Welcome lansează portlet-ul. 

Un client elimină un portlet stergând canalul corespunzător în componenta 

Costumize (clic pe butonul de închidere). 

Administratorul portalului ¸sterge un portlet prin clic pe butonul de închidere 

în lista portlet-elor publicate din AdminTools → Portlet Manager → Modify 

a currently published channel. 

Asemănător, se pot publica în uPortal aplicat¸ii Web. Deosebirea esent¸ială 

este că tipul canalului (Channel Type) este WebProxy sau Inline Frame. 

8.5.2 Jetspeed-2 

Jetspeed-2 este un portal cadru dezvoltat de apache. 

Instalarea se execută rulând distribut¸ia jetspeed-2.*.*-installer.jar. 

Portalul se accesează, dintr-un navigator, prin 

http://localhost:8080/jetspeed 

Desfă¸surarea unui portlet constă în copierea arhivei war corespunzătoare, 

realizat în 8.5.1, în catalogul 

Jetspeed HOME\webapps\jetspeed\WEB-INF\deploy 

Pe rol de admin, publicarea portlet-ului presupune 

1. Clic pe icon-ul butonului Edit - aflat în dreapta butonului logout. 

2. Clic pe un buton Add Portlet, stabilind astfel ¸si pozit¸ia în care va fi afi¸sată 

fereastra portlet-ului. 

3. Clic pe butonul Add al portlet-ului care se dore¸ste publicat. 

4. Clic pe săgeata de reîntoarcere, urmat de clic pe iconul butonului View - 

aflat pe pozit¸ia butonului Edit. 

Pentru a ¸sterge un portlet, după primul pas anterior, se apasă butonul de 

închidere din zona portlet-ului.

180 CAPITOLUL 8. PORTLET

Capitolul 9 

Teme de laborator 

9.1 Probleme propuse 

1. Să se realizeze conversia temperaturii exprimată în grade Celsius în grade 

Fahrenheit ¸si invers. Formula de transformare este 

tF = 1.8tC + 32 o F 

Eventual, programul server implementează interfat¸a (la distant¸ă) 

package conversie; 

public interface Grade extends java.rmi.Remote{ 

public double celsiusToFahrenheit(double celsius) 

// throws java.rmi.RemoteException; 

public double fahrenheitToCelsius(double fahrenheit) 


} 

2. Să se realizeze conversia a unei sume de bani între USD, EURO ¸si RON. 

Ratele de schimb sunt fixate de un obiect ce implementează interfat¸a 

public interface IRataSchimb{ 

double OneEuroIsRon(); 

double OneUsdIsRon(); 

} 

accesibil programului server. 

Programul server implementează interfat¸a 

181

182 CAPITOLUL 9. TEME DE LABORATOR 

package exchange; 

public interface IConversie extends java.rmi.Remote{ 

public double usdToEuro(double usd) 


public double usdToRol(double usd) 


public double euroToUsd(double euro) 


public double euroToRol(double euro) 


public double rolToEuro(double rol) 


public double rolToUsd(double rol) 


} 

Rata zilnică de schimb se poate prelua dinamic sub forma unui fi¸sier xml, 

apelând http://www.bnr.ro/nbrfxrates.xml. 

3. Să se realizeze conversia unui număr natural, cuprins între 1 ¸si 3999, din 

cifre arabe în cifre romane ¸si invers. 

4. Să se realizeze conversia unui număr dintr-o bază în alta. 

5. Unui client îi corespunde un număr întreg, valoarea init¸ială fiind 0. La 

o apelare a serverului, clientul transmite un număr care este adunat la 

numărul care îi corespunde clientului. Serverul retransmite clientului valoarea 

actualizată a numărului. Să se implementeze serviciul descris. 

6. Aplicat¸ia producător – consumator. 

Fie un sistem format din două procese P1 ¸si P2, primul producând ni¸ste 

date care apoi vor fi preluate de cel de al doilea. Comunicarea între cele 

două procese se realizează prin intermediul unei zone de memorie – tampon, 

– de o anumită dimensiune, în care procesul P1 introduce informat¸ii (sub 

forma unor înregistrări), pe care apoi P2 le extrage. 

Procesul P2 nu este nevoit să a¸stepte pentru fiecare înregistrare în parte, iar 

P1 nu a¸steptă până ce P2 este gata să recept¸ioneze înregistrarea produsă. 

Procesele evoluează independent unul de celălat, P1 introducând în tampon 

înregistrarea produsă, de unde P2 o va extrage la nevoie. 

Se impun următoarele restrict¸ii: 

• Procesul P1 încearcă să introducă o înregistrare în tampon ¸si constată 

că acesta s-a umplut. În acest caz, el va trebui să a¸stepte până ce se 

ive¸ste un loc în tampon (ceea ce se va întâmpla ca urmare a extrageri 

unei înregistrări de către P2).

9.1. PROBLEME PROPUSE 183 

• Procesul P2 încearcă să extragă o înregistrare ¸si constată că tamponul 

este gol. În acest caz el va trebui să a¸stepte până ce apare o înregistrare 

ca urmare a introduceri unei înregistrări în tampon de câtre P1. 

Se define¸ste interfat¸a 

package iprodcons; 

public interface IBoundedBuffer extends java.rmi.Remote{ 

public void put(Object obj) throws java.rmi.RemoteException; 

public Object get() throws java.rmi.RemoteException; 

} 

Se cere: 

(a) Implementarea interfet¸ei IBoundedBuffer. 

(b) Realizarea a două programe client Producator, care introduce obiecte 

în tampon ¸si Consumator pentru extragerea lor. 

7. Aplicat¸ie de e-mail. 

Un e-mail este definit printr-un ansamblu de 4 variabile de tip String 

(de la (from), catre (to), subiect (subject), mesaj (body)). 

package iemail; 

import java.io.Serializable; 

public class Email implements Serializable { 

public String from = ""; 

public String subject = ""; 

public String to = ""; 

public String body = ""; 

public Email() {} 

public Email(String from, String to, String subject, String body) { 

this.from =from; 

this.subject =subject; 

this.to =to; 

this.body =body; 

} 

} 

Interfat¸a aplicat¸iei IEmailServer este 



public interface IEmailServer extends Remote { 

public boolean login(String name, String password) 

throws RemoteException; 

public void createUser(String name, String password)



public void writeEmail(String from, String to, 

String subject, String body) throws RemoteException, 

UnknownUserException; 

public void readEmail(String userName,ICallbackEmail ce) 


} 

Un client / utilizator al serviciului sau serverului de e-mail este o instant¸ă 

a clasei User. 

package email; 


import iemail.*; 

public class User implements java.io.Serializable{ 

String name, password; 

Vector emails = new Vector(); 

public User(String name, String password) { 

this.name = name; 

this.password = password; 

} 

public void addEmail(Email email) { 

emails.addElement(email); 

} 

} 

Pentru a putea folosi serverul de e-mail, un client trebuie în prealabil să se 

înregistreze (createUser). 

Un client înregistrat se poate conecta la serverul de e-mail (login) după 

care poate scrie (trimite) sau citi (recept¸iona) mesaje. 

Se cere ca la adăgarea unui mesaj (deci înaintea apelării metodei User.addEmail) 

să se verifice dacă emitentul este conectat ¸si dacă destinatarul este înregistrat. 

în caz contrar se generează except¸ia UnknownUserException 


public class UnknownUserException extends Exception { 

public UnknownUserException() { 

super(); 

} 

public UnknownUserException(String exception) { 

super(exception); 

} 

} 

Citirea mesajelor este lăsată la latitudinea client¸ilor în sensul că clientul 

implementează metoda printEmail al interfet¸ei ICallbackEmail.





public interface ICallbackEmail extends Remote { 

public void printEmail(Email email) throws RemoteException; 

} 

Solicitarea recept¸ionării mesajelor se realizează de către server prin apelarea 

metodei printEmail pentru fiecare mesaj primit de client. 

Se cere: 

(a) Implementarea interfet¸ei IEmailServer. 

(b) Realizarea a două programe client AddClient pentru înregistrarea utilizatorilor 

¸si ClientEmail pentru exploatarea serviciului de e-mail. 

Fiecare din cele două programe are ca parametri numele (identificatorul) 

clientului, parola ¸si referint¸a serverului. 

8. Integrare numerică. 

Scopul aplicat¸iei este calculul unei integrale de un program server cu funct¸ia 

de integrat det¸inută de către client. Evaluările funct¸iei cerute de formula 

de integrare numerică se vor realiza prin apel invers. Integrarea numerică 

va fi executat de un server disponibil client¸ilor prin mecanismul de fabrică 

de obiecte. 

Interfat¸a fabricii de obiecte este 

package integ; 


public interface IFabIntegrator extends Remote{ 

IIntegrator getIntegrator() throws RemoteException; 

} 

iar interfat¸a IIntegrator este 



public interface IIntegrator extends Remote{ 

double adaptiveSimpson(double leftEnd, double rightEnd, 

double epsilon, int initParam) throws RemoteException; 

} 

declară o metodă ce calculează un ¸sir (Imk )k până în momentul |Imk − 

| < ε. 

Imk−1 

Propunem utilizarea formulei lui Simpson 

b 

f(x)dx ≈ Im = 

a 

m−1 

b − a 

m−1 

[f(a) + 2 f(a2i) + 4 f(a2i+1) + f(b)] 

6m 

i=1 

i=0


unde ai = a + i b−a 

2m . 

S¸irul (mk)k este definit prin mk = 2 k m0. 

Semnificat¸ia parametrilor metodei adaptiveSimpson este 

Interfat¸a apelului invers este 

leftEnd a 

rightEnd b 

epsilon ε 

initParam m0 



double function(double x)throws RemoteException; 

} 

Se cere implementarea aplicat¸iei cu minimizarea numărului de apelări a 

metodei function. 

9. Agendă telefonică. 

Pentru crearea ¸si întret¸inerea unei agende telefonice considerăm: 

Un ServerCarteTelefon realizează următoarele operat¸ii: 

• adaugă o înregisrare în agenda telefonică; 

O înregistrare este alcătuită dintr-o pereche (nume, număr). 

package itelef; 

import java.io.Serializable; 

public class Entry implements Serializable{ 

public String nume,numar; 

} 

} 

public Entry(String nume,String numar){ 

this.nume=nume; 

this.numar=numar; 

• sterge înregistrarea corespunzătoare unui nume din agenda telefonică. 

• interogarea agendei: furnizează numărul de telefon al unui nume; 

• modificarea numărului de telefon corespunzător unui nume; 

• afi¸sarea înregistrărilor; 

• salvarea înregistrărilor într-un fi¸sier; 

• restaurarea înregistrărilor dintr-un fi¸sier. 

Interfat¸a corespunzătoare ICarteTelefon este




public interface ICarteTelefon extends Remote{ 

void addEntry(Entry e)throws RemoteException; 

String lookupNumber(String p)throws RemoteException; 

void deleteEntry(Entry e)throws RemoteException; 

Entry[] list() throws RemoteException; 

void save(String file)throws RemoteException; 

void restore(String file)throws RemoteException,ClassNotFoundException; 

void modifyEntry(Entry e)throws RemoteException; 

} 

Interfat¸a fabricii de obiecte IFabCarteTelefon este 



public interface IFabCarteTelefon extends Remote{ 

ICarteTelefon getCarteTelefon() throws RemoteException; 

} 

Se cere implementarea aplicat¸iei de creare ¸si întret¸inere a agendei telefonice. 

Se extinde aplicat¸ia anterioară cu funct¸iunea suplimentară a serverului de 

a ret¸ine toate modificările efectuate de către un client ¸si care la solicitare 

pot fi afi¸sate. 

Modificările se ret¸in într-o variabilă mod de tip Vector. La solicitarea 

clientului, pentru fiecare modificare memorată, programul server apelează 

metoda schimbStare declarată în interfat¸a 



public interface IApelInvers extends Remote{ 

void schimbStare(Entry e) throws RemoteException; 

} 

Metoda schimbStare(Entry e) nu face altceva decât afi¸sează câmpurile 

variabilei e. 

Interfat¸a ICarteTelefon declară în plus metoda 

void apelInvers(IApelInvers obj)throws RemoteException; 

Această metodă va fi implementată în programul ServerCarteTelefon.java. 

Elementelor ret¸inute în vectorul mod li se aplică metoda schimbStare(). 

Să se implementeze acestă funct¸iune utilizând tehnica apelului invers. 

Se poate utiliza baza de date AGENDATELEFONICA formată din tabelul


TELEF 

ID 

NUME 

NUMAR 

10. Să se realizeze programe client având o interfat¸ă grafică. Recomandăm 

utilizarea produsului NetBeans. 

R. Exemplu de client pentru problema calculului celui mai mare divizor 

comun a două numere cu soclu TCP. 



public class VisualCmmdcClient extends javax.swing.JFrame { 

public VisualCmmdcClient() { 

initComponents(); 

} 

private void initComponents(){ 

// cod generat de Netbeans 

} 

private void jButton1MouseClicked(java.awt.event.MouseEvent evt){ 

long m=(new Long(jTextField1.getText())).longValue(); 

long n=(new Long(jTextField2.getText())).longValue(); 

String host=jTextField4.getText(); 

int port=(new Integer(jTextField5.getText())).intValue(); 

Socket cmmdcSocket = null; 

DataInputStream in=null; 

DataOutputStream out=null; 

try { 

cmmdcSocket = new Socket(host, port); 

out=new DataOutputStream(cmmdcSocket.getOutputStream()); 

in=new DataInputStream(cmmdcSocket.getInputStream()); 

} 

catch(UnknownHostException e) { 

System.err.println("Server necunoscut: "+host); 


} 


System.err.println("Eroare I/O : "+host+" la portul "+port); 


} 

try{ 

out.writeLong(m); 

out.writeLong(n); 

long r=in.readLong(); 

jTextField3.setText(new Long(r).toString()); 

out.close(); 

in.close(); 

cmmdcSocket.close(); 

} 


System.err.println("Imposibilitate de comunicare");


} 

} 

private void exitForm(java.awt.event.WindowEvent evt) { 


} 


new VisualCmmdcClient().setVisible(true); 

} 

private javax.swing.JButton jButton1; 

private javax.swing.JLabel jLabel1; 




private javax.swing.JTextField jTextField1; 





} 

11. Să se determine zodia (chinezească) corespunzătoare unei date calendaristice. 

12. Să se convertească unităt¸ile de masură pentru masă ¸si lungime între sistemul 

internat¸ional ¸si sistemul anglo-saxon. 

13. Se consideră baza de date NORME-DIDACTICE formată din tabelele 

CADRU-DIDACTIC MATERIA CURSURI 

COD-CADRU-DIDACTIC COD-MATERIE COD-CURS 

NUME DENUMIRE COD-CADRU-DIDACTIC 

COD-MATERIE 

Să se elaboreze programe de întret¸inere ¸si interogare a bazei de date. 

14. Se consideră baza de date APROVIZIONARE formată din tabelele 

RESURSA FURNIZOR CONTRACT 

COD-RESURSA COD-FURNIZOR COD-CONTRACT 

DENUMIRE NUME COD-FURNIZOR 

CANTITATE COD-RESURSA 

CANTITATE 

Să se elaboreze programe de întret¸inere ¸si interogare a bazei de date. 

15. Se consideră baza de date DESFACERE formată din tabelele


PRODUSE BENEFICIAR CONTRACT 

COD-PRODUS COD-BENEFICIAR COD-CONTRACT 

DENUMIRE NUME COD-BENEFICIAR 

CANTITATE COD-PRODUS 

CANTITATE 

Să se elaboreze programe de întret¸inere ¸si interogare a bazei de date.

Appendix A 

XML 

Extended Markup Language (XML) reprezintă un limbaj pentru definirea 

marcajelor de semantică care împart un document în părt¸i ¸si permit identificarea 

lor în document. 

Totodată XML este un meta-limbaj pentru definirea sintaxei de utilizat în 

alte domenii. 

XML descrie structura ¸si semantica ¸si nu formatarea. 

Structura unui document xml este 

 

corpul documentului alcatuit din elemente 

Prima linie reprezintă declarat¸ia de document XML. 

Corpul documentului este alcătuit din elemente. Începutul unui element este 

indicat printr-un marcaj. Textul marcajului constituie denumirea elementului. 

Elementele pot fi cu corp, alcătuit din alte elemente, având sintaxa 

 

corpul elementului 

 

sau fără corp, caz în care sintaxa este 

 

Un marcaj poate avea atribute date prin sintaxa 

numeAtribut="valoareAtribut" 

Valoarea unui atribut este cuprinsă între ghilimele (””). 

Există un singur element rădăcină. Elementele unui document XML formează 

un arbore. Fiecărui marcaj de început unui element trebuie să-i corespundă un 

191

192 APPENDIX A. XML 

marcaj de sfâr¸sit. Caracterele mari ¸si mici din denumirea unui element sunt 

distincte (case sensitive). 

Elementele încuibărite (nested)- incluse într-un alt element - nu se pot amesteca. 

Un comentariu se indică prin 

 

Exemplul A.0.1 

 

 

 

Analiza numerica 

 

2 

1 

1 

 

 

 

Programare distribuita 

 

2 

0 

2 

 

 

 

Soft matematic 

 

2 

0 

1 

 

 

Appendix B 

Apache-ant 

Utilitarul Apache-ant asigură executarea unui ¸sir de comenzi de operare. 

Aceste comenzi se înregistrează într-un fi¸sier de tip xml, cu denumirea build.xml. 

Astfel Apache-ant se substituie unui fi¸sier de comenzi bat. Avantajul obt¸inut 

constă în independent¸a fat¸ă de platforma de calcul (Windows, Linux). 

Instalarea constă în dezarhivarea fi¸sierului descărcat de pe pagina Web 

www.apache.org. 

Lansarea în execut¸ie necesită fixarea parametrului JAVA HOME, ce cont¸ine 

calea la distribut¸ia Java. Lansarea se poate face prin următorul fi¸sier de comenzi 

set ANT_HOME=. . . 


set PATH=%ANT_HOME%\bin;%PATH% 

ant.bat %1 

Parametrul acestui fi¸sier de comenzi reprezintă obiectivul care se dore¸ste a fi 

atins. 

Fi¸sierul build.xml. Un fi¸sier build.xml corespunde unui proiect (project), 

alcătuit din una sau mai multe obiective (target). Atingerea fiecarărui obiectiv 

constă din indeplinirea uneia sau mai multor sarcini (task). Apache-ant cont¸ine o 

familie de sarcini. Programatorul are datoria fixării atributelor sarcinilor. Manualul 

din documentat¸ia produsului cont¸ine descrierea atributelor cât ¸si exemple. 

În general, o sarcină reprezintă o operat¸ie executată uzual în linia de comandă. 

Atributele se dau, respectând sintaxa xml 

Astfel, un proiect apare sub forma 

194 APPENDIX B. APACHE-ANT 

default="obiectiv" 

basedir="catalogDeReferinta"> 

 

sarcini 

 

. . . . . . . 

 

Dacă la apelarea lui Apache-ant lipse¸ste parametrul opt¸ional atunci se va 

executa obiectivul default. 

Într-un proiect se pot defini variabile prin marcajul 

 

O variabilă se utilizează prin sintaxa ${numeVariabila} 

Exemplul B.0.2 Fi¸sierul build pentru execut¸ia programelor din §1.2. 

 

Socluri TCP 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

Appendix C 

Utilizarea SGBD în Java 

Scopul acestei anexe este prezentarea bazelor utilizării unui sistem de gestiune 

a bazelor de date (SGBD) din Java. Exemplificăm modul de operare ¸si utilizare 

pentru crearea ¸si exploatarea unei baze de date corespunzătoare unei agende 

telefonice. 

C.1 Derby 

Instalarea produsului constă în dezarhivarea fi¸sierului descărcat în catalogul 

jdk*.*.*\db. 

Utilizarea produsului. Va fi utilizată varianta de ret¸ea bazată pe un server 

al SGBD care utilizează implicit portul 1527. 

Se întreprind următoarele operat¸ii: 

1. Lansarea serverului Derby: 


set DERBY_HOME=. . . 

set PATH=%DERBY_HOME%\bin;%PATH% 

startNetworkServer.bat 

2. Crearea bazei de date se va face utilizând utilitarul ij din distribut¸ia Derby. 

Acesta se lansează prin: 


set DERBY_HOME=. . . 

set PATH=%DERBY_HOME%\bin;%PATH% 

ij.bat 

Exemplul C.1.1 

Baza de date AgendaTelefonica se crează executând 

195

196 APPENDIX C. UTILIZAREA SGBD ÎN JAVA 

run ’CreateAgendaT.sql’; 

unde fi¸sierul CreateAgendaT.sql este 

connect ’jdbc:derby:AgendaTelefonica;create=true’; 

create table telef( 

id int generated always as identity(start with 1, increment by 1) primary key, 

nume char(20) not null, 

numar char(13) not null 

); 

¸si încărcarea cu date 

run ’ValuesAgendaT.sql’; 

cu fi¸sierul ValuesAgendaT.sql 

insert into telef values(’aaa’,’111111’),(’bbb’,’222222’),(’ccc’,’333333’); 

C.2 mysql 

Instalarea produsului. Pentru instalare s-a descărcat varianta fără instalare 

automată mysql-noinstall-*.*.*-win32.zip. Acest fi¸sier se dezarhivează 

într-un catalog MYSQL HOME. 

Implicit, serverul mysql utilizează portul 3306, iar fi¸sierele bazelor de date vor 

fi găzduite în catalogul MYSQL HOME\data. 

Pentru utilizarea în aplicat¸ii Java trebuie descărcat un conector mysql-connectorjava-*.*.*.tar.gz, 

cont¸inând fi¸sierul mysql-connector-java- 

*.*.*-bin.jar. 

Utilizarea produsului. 

Se întreprind următoarele operat¸ii: 

1. Lansarea serverului mysql: 

set MYSQL_HOME=. . . 

set PATH=%MYSQL_HOME%\bin;%PATH% 

mysqld 

2. Exemplul C.2.1 

Crearea bazei de date AgendaTelefonica se va face prin intermediul fi¸sierului 

de comenzi 

set MYSQL_HOME=d:\mysql-5.0.45-win32\bin 

set path=%MYSQL_HOME%;%PATH% 

mysql -u root < CreateAgendaT.sql 

mysql -u root < ValuesAgendaT.sql

C.3. POSTGRSQL 197 

unde scriptul CreateAgendaT.sql este 

create database AgendaTelefonica; 

use AgendaTelefonica; 

create table telef( 

nume char(20) not null primary key, 

numar char(13) not null 

); 

iar scriptul de populare cu date (ValuesAgendaT.sql) este 

use AgendaTelefonica; 

insert telef values("aaa","111111"); 

insert telef values("bbb","222222"); 

insert telef values("ccc","333333"); 

3. Serverul mysql se opre¸ste prin 

set MYSQL_HOME=d:\mysql-5.0.45-win32 

set PATH=%MYSQL_HOME%\bin;%PATH% 

mysqladmin -u root shutdown 

C.3 PostgrSQL 

Instalarea produsului. PostgreSQL este distribuit gratuit. Pentru sistemul 

de operare Windows se descarcă o distribut¸ie cu instalare. Cu drepturi de administrator 

al sistemului gazdă, se execută instalarea cu serverul PostgreSQL drept 

serviciu Windows. Comunicat¸ia cu acest server se face prin portul 5432. 

Pentru utilizarea în aplicat¸ii Java trebuie descărcat un conector postgresql- 

*.*-*.jdbc4.jar. 

Utilizarea produsului. 


Crearea aceleia¸si baze de date AgendaTelefonică se face cu fi¸sierul de comenzi 

set PGHOME=d:\PostgreSQL 

set PATH=%PGHOME%\8.3\bin;%PATH% 

psql -U postgres -f createdb.sql 

psql -U user -d AgendaTelefonica -f createtable.sql 

psql -U user -d AgendaTelefonica -f insertvalues.sql 

user este numele unui cont PostgreSQL care se poate crea cu componenta de 

administrare pgAdmin III, prin meniul Login Role / New Login Role. 

Script-urile sql sunt 

createdb.sql 

create database "AgendaTelefonica" encoding ’utf8’ owner user;


createtable.sql 

create table telef(id int4 primary key, 

nume varchar(20) not null, numar varchar(15) not null); 

insertvalues.sql 

insert into telef values(1,’aaa’,’111111’); 

insert into telef values(2,’bbb’,’222222’); 

insert into telef values(3,’ccc’,’333333’); 

C.4 S¸ablonul de utilizare a unei baze de date într-un 

program Java 

Pentru a avea acces la o bază de date trebuie stabilită o conexiune la acea 

bază de date. În acest sens este necesar cunoa¸sterea: 

• driver-ului de acces la sistemul de gestiune a bazei de date (SGBD) (String 

jdbcDriver) 

Tip SGBD Driver Fi¸sierul 

driver-ului 

access sun.jdbc.odbc.JdbcOdbcDriver 

mysql com.mysql.jdbc.Driver mysql-connector-java-*.*.*-bin.jar 

(www.mysql.com) 

derby org.apache.derby.jdbc.ClientDriver derbyclient.jar 

(distribut¸ia derby) 

postgrsql org.postgresql.Driver postgresql-*.*-*.jdbc4.jar 

Dacă într-un servlet se realizează o conexiune la o bază de date atunci 

fi¸sierul driver-ului trebuie copiat în catalogul 

%TOMCAT HOME%\common\endorsed. 

• adresa URL a bazei de date (String URLBazaDate), sub forma 

unde protocol este 

Tip SGBD Protocol 

access odbc 

mysql mysql 

derby derby 

postgresql postgresql 


jdbc:protocol://host:port/numeBazaDate

C.4. S¸ABLONUL DE UTILIZARE ÎNTR-UN PROGRAM JAVA 199 

String jdbcDriver=. . . 

String URLBazaDate=. . . 


try{ 



... 

} 

catch(ClassNotFoundException e){. . .} 

catch(SQLException e){. . .} 

Odată conexiunea cu baza de date stabilită se generează un obiect de tip 

Statement prin intermediul căruia se execută interogarea SQL. 

Statement instructiune=con.createStatement(); 

String sql=. . . //fraza select; 

Rezultatele interogării bazei de date se obt¸ine prin 

try{ 

ResultSet rs=instructiune.executeQuery(sql); 


prelucrarea rezultatului 

} 

} 

catch(SQLException e){...} 


O interogare simplă a bazei de date AgendaTelefonica se realizează cu programul 


import java.sql.*; 



public class AgendaT { 

Statement instructiune=null; 


// SGBD Derby 

/* 

String jdbcDriver="org.apache.derby.jdbc.ClientDriver"; 

String URLBazaDate="jdbc:derby://localhost:1527/AgendaTelefonica"; 

*/ 

// SGBD mysql 

String jdbcDriver="com.mysql.jdbc.Driver"; 

String URLBazaDate="jdbc:mysql://localhost:3306/AgendaTelefonica?user=root";


// PostgreSQL 

/* 

String jdbcDriver="org.postgresql.Driver"; 

String URLBazaDate="jdbc:postgresql://localhost:5432/AgendaTelefonica"; 

String username=". . ."; 

String password=". . ."; 

*/ 


try{ 



instructiune=con.createStatement(); 

} 

catch(ClassNotFoundException e){ 

System.out.println("Driver inexistent JDBC: "+jdbcDriver); 

} 


System.out.println("Baza de date inexistenta "+URLBazaDate); 

} 



} 

} 


AgendaT agenda=new AgendaT(); 

agenda.init(); 


int prel,no; 

String ch="Y",nume="",numar="",sql=""; 

ResultSet rs=null; 

try{ 

while(ch.startsWith("Y")){ 

do{ 

System.out.println("Continue ? (Y/N)"); 

ch=scanner.next().toUpperCase(); 

} 

while((!ch.startsWith("Y"))&&(!ch.startsWith("N"))); 

if(ch.startsWith("Y")){ 

System.out.println("Natura interogarii ?"); 

System.out.println("(Dupa nume:1,Dupa numar:2)"); 

do{ 

prel=0; 

try{ 

prel=scanner.nextInt(); 

} 

catch(InputMismatchException e){} 

} 

while((prel2)); 

switch(prel){ 

case 1 : 

System.out.println("Numele"); 

nume=’\’’+scanner.next().trim()+’\’’; 

sql="select * from telef where nume="+nume; 

rs=agenda.instructiune.executeQuery(sql); 

if(rs!=null){ 

System.out.println("S-au gasit numerele de telefon:"); 

while(rs.next()){

C.4. S¸ABLONUL DE UTILIZARE ÎNTR-UN PROGRAM JAVA 201 

System.out.println(rs.getString("numar")); 

} 

} 

else{ 

System.out.println("Fara telefon !"); 

} 

break; 

case 2 : 

System.out.println("Numar"); 

numar=’\’’+scanner.next().trim()+’\’’; 

sql="select * from telef where numar="+numar; 

rs=agenda.instructiune.executeQuery(sql); 

if(rs!=null){ 

System.out.println("S-a gasit numeley" + 

"y:"); 


System.out.println(rs.getString("nume")); 

} 

} 

else{ 

System.out.println("Numar inexistent !"); 

} 

break; 

default: System.out.println("Comanda eronata"); 

} 

} 

} 

} 



} 

} 

} 

Fraza select ¸si interogarea se mai putea programa prin 

String sql="select * from telef where nume =?"; 

PreparedStatement prepStmt=con.prepareStatement(sql); 

prepStmt.setString(1,nume); 

RezultSet rs=prepStmt.executeQuery(); 

. . . 

prepStmt.close(); 

În acest caz, valoarea variabilei nume este fără apostroafe. 

Compilarea ¸si execut¸ia programului necesită declararea în variabila classpath 

a fi¸sierelor 

• Varianta Derby 

derby.jar, derbytools.jar, derbyclient.jar, derbynet.jar din catalogul 

%DERBY INSTALL%\lib. 

• Varianta mysql 

%MYSQL CONNECTOR JAVA HOME%\mysql-connector-java-*.*.*-bin.jar


Execut¸ia programului presupune serverul SGBD activ. 

C.5 Java Persistence API - JPA 

Interfat¸a JPA este standardizarea accesului din Java la un SGBD relat¸ional. 

JPA este un strat care se interpune între programul Java ¸si SGBD. Avantajul 

oferit de JPA constă în independent¸a programelor Java de SGBD utilizat. 

Din punct de vedere al programării, rezultatul interogării unei baze de date 

este un obiect. 

JPA cont¸ine: 

• Persistence: Clasa javax.persistence.Persistence cont¸ine metode statice 

pentru obt¸inerea unei instant¸e a clasei EntityManagerFactory, într-o 

manieră independentă de producătorul JPA. 

• EntityManagerFactory: Clasa javax.persistence.EntityManagerFactory 

este producătorul obiectelor EntityManager. 

• EntityManager: javax.persistence.EntityManager este actorul JPA principal 

într-o aplicat¸ie. Un obiect EntityManager mijloce¸ste întret¸inerea ¸si 

interogarea unei baze de date. Fiecărui obiect de tip EntityManager i se 

asociază un obiect de tip javax.persistence.EntityTransaction. 

• Entity: Obiectele Entity corespund înregistrărilor în tabelele bazei de date. 

• EntityTransaction: asigură integritatea bazei de date. Operat¸iile care privesc 

persistent¸a datelor sunt grupate în unităt¸i de lucru care sunt executate cu 

succes sau deloc. 

• Query: Interfat¸a javax.persistence.Query este specifică implementării. 

Prin obiecte de tip Query se asigură accesul la baza de date. Portivit 

standardului JPA este suportat atât limbajul Structured Query Language 

(SQL) cât ¸si Java Persistence Query Language (JPQL). Un obiect Query 

este instant¸iat prin obiecte EntityManager. 

Există mai multe implementări a interfet¸ei JPA. 

C.5.1 apache-openjpa 

A¸sa cum sugerează numele produsului, openjpa este implementarea oferită de 

apache. 

Instalarea revine la dezarhivarea fi¸sierului descărcat. 

Utilizarea. Compilarea ¸si execut¸ia unei aplicat¸ii o vom face prin intermediul 

lui apache-ant. Construim structura de cataloage ¸si fi¸siere:

C.5. JAVA PERSISTENCE API - JPA 203 

|--> catalogul_aplicatiei 

|--> META-INF 

| | persistence.xml 

| build.xml 

Fi¸sierul persistence.xml specifică unităt¸ile de persistent¸ă. Fiecare unitate de 

persistent¸ă corespunde unui tabel al bazei de date ¸si i se asociază o clasă Entity, 

de fapt o componentă Java. Clasa ¸si tabelul au acela¸si nume. Doar tabelele cărora 

li s-a declarat o unitate de persistent¸ă pot fi accesate prin apache-openjpa. 

Principial fi¸sierul persistence.xml este 

 

 

 

 

Entity_class_name 

 

 

 

 

 

 

appagenda.Telef 

 

 


 

 

--> 

 

 

 

Atributele ce apar în comentarii, pot fi specificate ¸si prin proprietăt¸i System. 


EntityManagerFactory factory= 

Persistence.createEntityManagerFactory("nume_unitate_de_persistenta", 

System.getProperties()); 

EntityManager em=factory.createEntityManager(); 

em.getTransaction().begin(); 

String sql=fraza SQL sau JPQL 

Query query=em.createQuery(sql); 

// introducerea unei inregistrari 

em.persist(obiect_Entity) 

// actualizarea sau stergerea unei inregistrari 

query.executeUpdate(); 

// interogare bazei de date 

List result=query.getResultList(); 

em.getTransaction().commit(); 

em.close(); 

factory.close(); 

Dacă fraza SQL este specifică unui SGBD atunci obiectul de tip Query se instant¸iază 

prin 

Query query=em.createNativeQuery(sql,clasa_Entity_utilizata.class); 

Exemplul C.5.1 Aplicat¸ie pentru întret¸inerea ¸si interogarea bazei de date AgendaTelefonica. 

Tabelei telef a bazei de date îi corespunde clasa Entity 

package appagenda; 

import javax.persistence.*; 

@Entity 

public class Telef implements java.io.Serializable{


private int id; 

private String nume; 

private String numar; 

Telef() {} 

public int getId(){ 

return id; 

} 

public void setId(int id){ 

this.id=id; 

} 

public String getNume() { 

return nume; 

} 

public void setNume(String nume) { 

this.nume = nume; 

} 

public String getNumar() { 

return numar; 

} 

public void setNumar(String numar) { 

this.numar = numar; 

} 

} 

Accessarea bazei de date se face prin clasa AgendaTDAO 




@SuppressWarnings("unchecked") 

public class AgendaTDAO{ 

EntityManagerFactory factory=null; 

EntityManager em; 

public AgendaTDAO(EntityManagerFactory factory){ 

this.factory=factory; 

} 

public void addAgendaT(Telef a){ 

em=factory.createEntityManager(); 


//em.persist(a); 

String sql="insert into telef(nume,numar) values(\’"+a.getNume()+"\’,\’"+a.getNumar()+"\’)"; 

Query query=em.createNativeQuery(sql); 

query.executeUpdate(); 


em.close(); 

} 

public void deleteAgendaT(String nume){ 



String sql="delete from Telef a where a.nume=\’"+nume+"\’"; 


query.executeUpdate();



em.close(); 

} 

public List interogareAgendaT(String nume){ 



String sql="select a from Telef a where a.nume=\’"+nume+"\’"; 


//String sql="select * from telef where nume=\’"+nume+"\’"; 

//Query query=em.createNativeQuery(sql,appagenda.Telef.class); 



em.close(); 

return result; 

} 

public List listAgendaT() { 



String sql="select a from Telef a"; 


//String sql="select * from telef"; 

//Query query=em.createNativeQuery(sql,appagenda.Telef.class); 



em.close(); 

return result; 

} 

} 

iar clientul este AgendaTClient 




public class AgendaTClient{ 


EntityManagerFactory factory= 

Persistence.createEntityManagerFactory("appagenda",System.getProperties()); 

AgendaTDAO dao=new AgendaTDAO(factory); 

String ch="Y"; 

int prel; 


Telef a=null; 

while(ch.startsWith("Y")){ 

do{ 

System.out.println("Continue ? (Y/N)"); 

ch=scanner.next().toUpperCase(); 

} 

while((!ch.startsWith("Y"))&&(!ch.startsWith("N"))); 

if(ch.startsWith("Y")){ 

System.out.println("Natura prelucrarii ?"); 

System.out.println("(Adaug:1,Sterg:2,Inter:3,List:4)"); 

prel=scanner.nextInt(); 

String nume,numar; 

switch(prel){ 

case 1 :


System.out.println("ADAUG"); 

System.out.println("Numele:"); 

nume=scanner.next().trim(); 

System.out.println("Numar telefon:"); 

numar=scanner.next().trim(); 

a=new Telef(); 

a.setNume(nume); 

a.setNumar(numar); 

dao.addAgendaT(a); 

break; 

case 2 : 

System.out.println("STERG"); 



dao.deleteAgendaT(nume); 

break; 

case 3 : 

System.out.println("INTEROGARE"); 



List listInter=dao.interogareAgendaT(nume); 

for(Telef t: (List)listInter){ 

System.out.println("Numele: "+t.getNume()+" Numar: "+t.getNumar()); 

} 

break; 

case 4 : 

List datas=dao.listAgendaT(); 

for(Telef t: (List)datas){ 

System.out.println("Numele: "+t.getNume()+" Numar: "+t.getNumar()); 

} 

break; 

default: System.out.println("Comanda eronata"); 

} 

} 

else 


} 

factory.close(); 

} 

} 

Fi¸sierul persistence.xml pentru exemplul de mai sus este 

 

 

 


 

 


 

 

Fi¸sierul build.xml are codul 


 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 


is passed "System.getProperties()". 

--> 

 

 

 

 

 

 

 

 

 

 

210 APPENDIX C. UTILIZAREA SGBD ÎN JAVA

Bibliografie 

[1] ATHANASIU I., COSTINESCU B., DRĂGOI O.A., POPOVICI F.I., 1998, 

Limbajul Java. O perspectivă pragmatică. Ed. Computer Libris Agora, Cluj- 

Napoca. 

[2] BOIAN F.M., BOIAN R. F., 2004, Tehnologii fundamentale Java pentru 

aplicat¸ii Web. Ed. Albastră, Cluj-Napoca. 

[3] BURAGA S.C., 2001, Tehnologii Web. Ed. Matrix Rom,Bucure¸sti. 

[4] BURAGA S. (ed), 2007, Programarea în Web 2.0., Ed. Polirom, Ia¸si. 

[5] JURCĂ I., 

Timi¸soara. 

2000, Programarea ret¸elelor de calculatoare. Ed. de Vest, 

[6] HUNTER J., CRAWFORD W., 1998, Java Servlet Programming. O’Reilly. 

[7] ALBOAIE L., BURAGA S., 2006, Servicii Web. Ed. Polirom, Ia¸si. 

[8] SCHEIBER E., 2007, Programare concurentă ¸si paralel distribuită în Java. 

Ed. Albastră, Cluj-Napoca. 

[9] TANASĂ S¸., OLARU C., 2005, Dezvoltarea aplicat¸iilor Web folosind Java. 

Ed. Polirom, Bucure¸sti. 

[10] * * * , Java 2 SDK /docs/, Sun Microsystems. 

[11] * * * , JavaWS Tutorial 1.*, Sun Microsystems. 

[12] * * * , J2EE Tutorial, Sun Microsystems. 

[13] * * * , Java 2 Tutorial, Sun Microsystems. 

211

Universitatea Transilvania din Brasov Facultatea de Matematic˘a ...

You also want an ePaper? Increase the reach of your titles

Delete template?

Save as template?