Arhiva

Archive for the ‘Java’ Category

Curs scris online de EJB3

octombrie 7, 2009 Alex Chiri 2 comentarii

În feed-urile urmărite în dimineața asta am dat de cursul ăsta de EJB3. Ce are special? Mi-a placut că este un curs practic care constă în construirea unor aplicații pornindu-se de la niște cerințe concrete. Suportul din partea autorului scade gradual în construirea aplicațiilor. Este interesant că oferă o abordare completă a soluției aplicațiilor, pornind de la diagrame UML, arhitectură și cod.

Este inclusă și o carte electronică gratuită, “Mastering Enterprise JavaBeans 3.0”, ca suport teoretic. Soluțiile complete (proiecte Netbeans) sunt oferite de autor. La o primă vedere, mi se pare un curs util și o abordare care te invață prin practică.

Categories: Java Tags:

Java EE: despre interceptori

septembrie 27, 2009 Alex Chiri Lăsați un comentariu

Citind cartea despre care v-am vorbit într-un articol anterior, am descoperit niște clase despre care nu mai auzisem până acum: interceptorii.

Prezentarea lor începe cu o scurtă introducere despre AOP, noțiune nouă pentru mine. După cum am înțeles, AOP înseamnă să “decorezi” logică refolosibilă, în general, cu diferite funcționalități, fără aduce modificări asupra logicii menționate. De exemplu, AOP ar putea fi transformarea ușoară a unui Session Bean într-un web service sau într-un RESTful service.

În Java EE “aspectele” sunt numite interceptori. Un interceptor este o clasă cu o metodă adnotată și are controlul complet asupra execuției unei metode. Un interceptor este “atașat” unei clase cu ajutorul adnotării @Interceptors({interceptori}). Între acolade este o listă de clase de interceptori.

Iata un exemplu scurt de interceptor:

   1: public class InterceptorDeTest {

   2:  

   3:     @AroundInvoke

   4:     public Object interceptM(InvocationContext ic) {

   5:  

   6:         //fă ceva

   7:         return ic.proceed();

   8:     }

   9: }

Și o clasă care are atașat un interceptor:

   1: @Stateless

   2: @Interceptors({InterceptorDeTest.class})

   3: public class ClasaDeTest{

   4:     public String helloWorld() {

   5:         return "HelloWorld!";

   6:     }

   7: }

În momentul în care este apelată metoda helloWorld firul execuției va trece mai întâi prin interceptor. Acesta execută prelucrările sale și apelează metoda proceed() care are ca efect trecerea la executarea codului următorului interceptor din listă, dacă există, sau a metodei interceptate (în cazul nostru, metoda helloWorld()).

Interceptorii pot fi folosiți pentru diferite inițializări sau validări înainte sau după execuția unei metode. În cartea lui Adam Bien e și un exemplu cu interceptori în care se pot redenumi firele de execuție a unei aplicații în funcție de metoda pe care o execută, pentru o mai bună observare într-un profiler sau într-un dump, scăpând astfel de numele random și lipsite de înțeles date firelor de execuție.

PS: Un articol general despre utilizarea interceptorilor și cel cu redenumirea thread-urilor.

Categories: Java Tags: ,

Recomandări JavaEE

septembrie 22, 2009 Alex Chiri Lăsați un comentariu

Am dat de curând peste blogul unui tip care a făcut o serie de articole despre JPA și diferite implementări ale lui. Conținutul articolelor vine din experiența acestui domn, ceea ce înseamnă că sunt pline de lucruri învățate “the hard way”, care nu le găsiți scrise în manuale sau cărți “obișnuite” de JavaEE. Unele din aceste soluții le-am aflat și eu încercând să rezolv diferite excepții de care dădeam, dar nu înțelesesem foarte bine de ce se întâmplă ceea ce se întâmplă.

De asemenea mi-am luat (adică am cumpărat-o :D ) o carte foarte interesantă care mi-a atras atenția pentru că tratează subiectul în același stil ca și blogul de mai sus, dar mult mai pe larg. Deocamdată doar am răsfoit-o, revin cu mai multe impresii mai târziu.

Categories: Java Tags: ,

Scala

septembrie 18, 2009 Alex Chiri Lăsați un comentariu

Este unul din limbajele de programare promovate mai intens în ultima perioadă ce rulează pe mașina virtuală Java. Scala promite cod mai inteligibil și surse mai mici față de Java și un strop de programare funcțională. Părerea mea e că seamănă destul de tare cu Ruby, de altfel n-ar fi primul limbaj/framework adus în lumea Java ce aduce a Ruby & Rails (vezi Groovy & Grails).

Un articol ce face o scurtă comparație între Scala și Java găsiți aici.

Categories: Java Tags: ,

Schimbări de limbaj în Java 7, propuse de proiectul Coin

septembrie 1, 2009 Alex Chiri 1 comentariu

Proiectul Coin este unul din proiectele desfășurate cu ajutorul comunității Java pentru a îmbunătăți limbajul. Lista de propuneri a proiectului Coin ce va fi implementată în noua versiune este finală și aprobată. Cele 5 (sau mai multe) îmbunătățiri propuse de Coin și ajunse în lista finală sunt:

  1. Posibilitatea de a folosi String-uri în switch;
  2. Management automat de resurse;
  3. Instanțare îmbunătățită a tipurilor cu generice;
  4. Invocare a metodelor cu aritate variabilă simplificată;
  5. Suport pentru literale binare și posibilitatea de a include “underscores” în numerele foarte lungi, pentru a fi mai ușor de citit;
  6. Suport îmbunătățit pentru colecții;
  7. Suport pentru JSR 292.

Mai pe larg puteți citi aici și aici.

Categories: Java Tags: ,

G1, noul “gunoier” al Java

Este foarte posibil ca în următoarea versiune de JVM să fie lansat un  nou “garbage collector”. Acesta ar aduce îmbunătățiri la colectarea în timp real a resurselor redundante, însă creatorii lui nu garantează că în anumite situații nu va afecta performanțele aplicației.

Citiți mai multe aici.

Categories: Java Tags: ,

Call-by-reference sau call-by-value în Java?

Cei care ați făcut C sau C++ vă aduceți aminte de așa numitele transmiteri de parametri prin valoare sau prin referință. În Java nu există ‘sau’ ci doar call-by-value, indiferent de tipul parametrului.

În momentul în care apelăm o metodă cu parametrii primitivi atunci valoarea lor este transmisă parametrilor formali din metodă. În cazul unor obiecte, valoarea referință este transmisă parametrilor formali și nu obiectul cu totul. Ceea ce înseamnă că și parametrul formal, dar și parametrul inițial din apel vor referenția același obiect din memorie. Acest lucru are cel puțin două consecințe:

  1. Orice modificări făcute asupra stării obiectului referențiat de către parametrul formal, vor fi vizibile și după încheierea apelului metodei;
  2. Dacă modificăm parametrul formal din metodă(deci nu starea obiectului referențiat de el), modificarea nu va fi vizibilă după ieșirea din apel.
   1: public class Test {

   2:     public String rezultat = "bun";

   3:     public Test() {

   4:         System.out.println("Constructor din Test");

   5:     }

   6:     

   7:     public void schimba(Test tst) {

   8:         tst.rezultat = "rau";

   9:         tst = null;

  10:     }

  11:     

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

  13:         Test tst = new Test();

  14:         System.out.println(tst.rezultat);

  15:         tst.schimba(tst);

  16:         System.out.println(tst.rezultat);

  17:     }

  18: }

După compilare și rulare, acest program va afișa:

Constructor din Test

bun

rau

La linia 8 se modifică starea obiectului Test referențiat de parametrul formal tst, iar la linia 9 se asociază lui tst valoarea null. Modificarea asupra atributului rezultat se poate observa la ieșirea din apelul metodei schimbă.

Metode cu număr de parametri variabil

Începând cu Java 1.5 a fost introdusă facilitatea de a creea metode cu număr de parametrii variabil. Astfel de metode sunt numite metode cu aritate variabilă și pot permite apeluri cu un număr mai mare de parametri decât parametrii formali din semnătura metodei.

Pentru o metodă cu aritate variabilă, ultimul parametru formal trebuie declarat în felul următor:

<tip>… <nume parametru formal>

Prin urmare, în semnătura unei metode cu aritate variabilă putem avea un singur parametru formal ca mai sus și acesta trebuie să fie ultimul în lista de parametri formali. De asemenea, o altă consecință este că parametrii care pot varia ca număr sunt de același tip.

Parametrul formal ce variază este, de fapt, un array care este umplut cu parametrii dați în plus la apel. Prin urmare, următoarele semnături ale metodei angajare sunt considerate identice:

public void angajare(String… candidati);

public void angajare(String[] candidati);

Dacă cele două semnături sunt considerate identice, în momentul în care am încerca să facem overload la prima formă cu a doua(sau invers), am primi eroare la compilare.

Categories: D'ale SCJP-ului Tags: ,

Declararea și inițializarea de Array

După cum bine se știe un Array, în Java, se poate declara în felul următor:

int[] numere[] = new int[10][10];

Parantezele pătrate se pot pune ori la tipul de date, ori la numele variabilei, ori la amândouă. De asemenea dimensiunea poate lipsi la ultimele dimensiuni ale array-ului. Deci aș fi putut scrie și așa:

int[] numere[] = new int[10][];

Există două modalități de a face declararea și inițializarea unui Array:

  1. int[] numere = new int[] {1, 2, 3, 4};
    Atenție: cand se face inițializarea array-ului nu se mai trece dimensiunea!
  2. int[] numere = {1, 2, 3, 4};
    Acesta este un bloc de inițializare, care poate fi folosit în locul liniei de mai sus, are același efect.

Diferența între cele două modalități este că cea de-a doua nu este o expresie și nu poate fi folosită în felul următor:

int[] numere;

numere = {1, 2, 3, 4}; //nu e ok

numere = new int[] {1, 2, 3, 4}; //e ok

Categories: D'ale SCJP-ului Tags: , ,

Tipul Enum* (java.lang.Enum)

Câte ceva despre tipul Enum:

  • un tip care conține un set de constante;
  • un tip enum poate avea constructori, dar aceștia trebuie declarați după definirea constantelor și pot fi doar private;
  • toate enum-urile sunt subtipuri ale clasei java.lang.Enum, prin urmare sunt comparabile și serializabile;
  • la definirea constantelor se poate specifica o listă de parametri pentru fiecare, iar la încărcarea enum-ului pentru fiecare constantă se va apela constructorul corespunzător semnăturii ei;
  • un enum poate fi declarat în cadrul unei alte clase, dar doar ca membru de prim nivel sau în cadrul unui membru static; toate enum-urile declarate în cadrul unei alte clase sunt implicit statice;
  • deși un enum poate coține diferite metode abstracte, tipul nu va fi marcat ca și abstract, ca în cazul claselor obișnuite;
  • fiecare constantă a unui enum poate implementa diferite metode specifice, sub forma unor clase anonime care sunt instanțiate la “runtime”;
  • un enum poate implementa interfețe dar nu poate extinde;
  • Compararea cu == sau cu equals este echivalentă în cazul constantelor unui enum;

*Conform Java 1.6

Categories: D'ale SCJP-ului Tags: , ,