Visualizzazione post con etichetta ingegneria del softweare. Mostra tutti i post
Visualizzazione post con etichetta ingegneria del softweare. Mostra tutti i post

lunedì 9 aprile 2012

Riflettiamo con la Java Reflection

L'idea di questo post nasce da un test preselezione che ho fatto per un'azienda inglese. Dato un pezzo di codice veniva chiesto quale caratteristica del linguaggio Java era utilizzata. Si trattava della reflection.

La reflection è quella caratteristica del linguaggio Java che permette ad un programma  in esecuzione di accedere a proprietà interne del programma stesso. Tutto ciò ovviamente in contro tendenza con il paradigma orientato agli oggetti. Ad esempio con questa caratteristica è possibile per un classe Java ottenere e accedere al nome di tutti i suoi metodi e attributi ed eventualmente mostrarli.

Perché la reflection?

La violazione del principio di incapsulamento dei linguaggi object oriented può essere pericoloso ma se trattato con le giuste accortezze diventa uno strumento potentissimo. In particolare può essere utile nei framework e in casi in cui si necessità di un forte riutilizzo di codice. Consideriamo ora un esempio di codice Java (fonte sito ufficiale della Oracle):


   import java.lang.reflect.*;
 
   public class DumpMethods {
      public static void main(String args[])
      {
         try {
            Class c = Class.forName(args[0]);
            Method m[] = c.getDeclaredMethods();
            for (int i = 0; i < m.length; i++)
            System.out.println(m[i].toString());
         }
         catch (Throwable e) {
            System.err.println(e);
         }
      }
   }


Per usare la reflection occore effettuare l'import del package java.lang.reflect.Ora richiamando la classe DumpMethods e passando come input la stringa "java.util.Stack" l'output che otteniamo è il seguente:


 public java.lang.Object java.util.Stack.push(
    java.lang.Object)
   public synchronized 
     java.lang.Object java.util.Stack.pop()
   public synchronized
      java.lang.Object java.util.Stack.peek()
   public boolean java.util.Stack.empty()
   public synchronized 
     int java.util.Stack.search(java.lang.Object)



otteniamo quindi l'elenco dei metodi della classe Stack compreso di parametri e il tipo restituito da ogni metodo.

Un ottimo esempio di come sia utile la reflection è nella conversioni di documenti XML in oggetti Java (più facilmente manipolabili all'interno di un applicazione scritta in linguaggio Java). Trovate un ottimo esempio di codice qui.

Infine per una illustrazione completa dei diversi usi della reflection date anche un'occhiata qui.

martedì 22 novembre 2011

Interview question: differenza tra architettura a 2 tier e achitettura a 3 tier

Partiamo col dire che quando si parla di tier la ment va subito a un'applicazione di tipo client-server. Per spiegare la differenza tra queste due architetture partiamo da un esempio.

Supponiamo di voler scrivere un programma che permetta in una scuola agli studenti di sapere la media dei voti nelle diverse materie. Il programma è strutturato in modo che i voti degli alunni siano memorizzati nel database che risiede sul server, mentre l'applicazione che permette di accedere ai voti e alla media risiede lato client. Quando gli studenti vogliono sapere la media dei loro voti utilizzano il programma (cliccando sui pulsanti, aprendo le fineste ecc.) inviando cosi una query al database che risiede sul server. Il database risponderà con i dati richiesti e l'applicazione calcolerà cosi la media. 
Questo è un esempio di architettura a 2 tier. I 2 tier sono:
  1. Data server, dove girà il database contenente le informazioni
  2. L'applicazione client
Questa architettura va bene se la scuola avesse solo una cinquantina di studenti. Ma supponiamo che la scuola abbia 10000 studenti. Ora la situazione inizia a farsi più problematica...
Ogni volta che uno studente, attraverso l'applicazione client, effettua una query il data server dovrà gestire questa query. Questo diventa un enorme lavoro per una risorsa di rete.
Per ovviare a tale problema si utilizza l'architettura a 3 tier, inserendo un altro programma a livello server, chiamato server application. In questo modo l'applicazione client non farà più riferimento al database ma passerà prima attraverso l'application server che poi girerà le queries al database.
Ora ogni studente per sapere la sua media dovrà eseguire i seguenti passi:
  1. Lo studente interroga l'applicazione client
  2. L'applicazione client interroga l'applicazione server
  3. L'applicazione server effettua la query sul data server
  4. Il data server restituisce un recordset contenente i voti dello studente
  5. L'applicazione server effettuerà tutti i calcoli per determinare la media
  6. L'applicazione server restituisce la media calcolata all'applicazione client
  7. L'applicazione client mostra la media allo studente
Anche se il processo sembra più lungo su carta, in realtà è molto più veloce. Questo perchè al paso 6 all'applicazione client non viene più resitutito un recordset (che generà un grande ammontare di traffico di rete) ma solo un semplice numero!



Ovviamente esistono altri vantaggi di un'architettura a 3 tier ma in questo articolo ho solo voluto dare un'idea generale sulle 2 architetture.


Questo articolo prende spunto principalmente da link