MDB (Message Driven Bean) in 5 minuti

MDB: Cosa sono

Di solito le comunicazioni fra i componenti di un’applicazione sono sincrone, ossia l’oggetto che effettua la chiamata e l’oggetto che viene invocato devono essere entrambi presenti affinché la comunicazione possa avvenire.
Un message-oriented middleware (MOM) è un software che consente a due componenti di comunicare in maniera asincrona. Java Messaging Service (JMS) fornisce uno standard di accesso ai MOM che costituisce un’alternativa all’utilizzo di API proprietarie; ad eccezione di Microsoft Message Queuing, la maggior parte dei prodotti MOM infatti supporta JMS. Il client notifica una certa operazione al server inviando un messaggio (il client in questo caso è detto producer). Il server inserisce i messaggi in un canale sulla quale stanno in ascolto altri client che prelevano il messaggio ed eseguono le operazioni richieste (i componenti in ascolto vengono detti consumer).
Un modello di messaging definisce il modo in cui il processo di messaging coinvolge mittenti e destinatari. I due modelli più popolari, standardizzati in Java EE, sono il point-to-point e il pubish-subscribe.
Nello schema point to point il mittente (Producer) invia un messaggio verso una particolare destinazione. Il ricevente (Consumer) sta in ascolto e riceve i messaggi su quella destinazione(chiamata coda o queue). L’intento del producer è inviare un messaggio ad uno specifico consumer che sarà l’unico a riceverlo, anche se al momento dell’invio non è disponibile. (ci sarà solo un consumer per quella coda queue). Sarà infatti il JMS Broker (servizio che gestisce lo scambio dei messaggi) a tenerlo in coda finché non sarà prelevato dal consumer.
Nello schema publish-subscribe un singolo produttore invia un messaggio ad una destinazione ( che prende il nome di topic) e tutti i consumatori che sono registrati presso quel topic possono riceverlo. Questo modello lavora si adatta particolarmente bene nel caso in sui si voglia effettuare il broadcasting di informazioni verso diversi sistemi.
Un Message-Driven Bean (MDB) è un componente EJB che consuma messaggi da una queue/topic, inviati da un valido client JMS. Per crearlo è sufficiente usare l’annotation:

@MessageDriven

e implementare l’interfaccia MessageListener.

MDB: Esempio

Continua a leggere

Ejb Session Stateless Esempio

EJB Session Staleless: cosa sono

Gli EJB Session Bean sono delle classi con dei metodi invocabili da remoto (semplificando molto possiamo dire che sono come le servlet, ma le servlet hanno solo due metodi doget e dopost, i session invece possono avere tutti i metodi che vogliamo). Sono composti da una classe e due interfacce. Per poter invocare un EJB Session bisogna avere una delle interfacce. Le interfacce sono dette locali o remote, in basa a dove permettono di richiamare il session. Da remoto vengono utilizzati i protocolli distribuiti come RMI-IIOP (Remote Method Invocation o RMI è una tecnologia che consente l’invocazione remota dei metodi);
Gli EJB Session sono transazionali, ossia permettono di gestire le transazioni.
Esistono due tipi di session bean:

  • stateful:  viene memorizzato lo stato fra una richiesta e l’altra del client, ossia garantisce che tutti i campi   dell’EJB Session saranno salvati per la successiva richiesta dello stesso client.
  • stateless: non viene mantenuto alcun stato e vengono utilizzati per modellare quelle elaborazioni che si completano con una sola richiesta

 

 

EJB Session Staleless: esempio

Continua a leggere

Java Syncronized: Come si usa esempio

Java Syncronized: Cos’è

Ad ogni oggetto (o anche ad un pezzo di codice) si può associare un semaforo (un lock). Ogni semaforo ha due operazioni: Get e Release. Quando un thread accede ad una zona critica tenta di prendere possesso del semaforo (Get); se non ci riesce verrà messo a dormire e ci ritenterà fino a quando un altro thread rilascerà (Release) tale semaforo.
Questi “semafori” in java vengono introdotti con la parola chiave “syncronized“. Si possono sincronizzare sia classi che metodi.
Quando un thread vuole accedere ad un metodo/blocco synchronized, deve acquisire il lock dell’oggetto (impedendo così l’accesso ad ogni altro thread).  Il lock viene automaticamente rilasciato quando il thread esce dal metodo/blocco synchronized(o se viene interrotto da un’eccezione).
Un thread che non riesce ad acquisire un lock rimane sospeso sulla richiesta della risorsa fino a che il lock non è disponibile. Ad ogni oggetto viene assegnato un solo lock: due thread non possono accedere contemporaneamente a due metodi/blocchi synchronized diversi di uno stesso oggetto.Tuttavia altri thread sono liberi di accedere a metodi/blocchi non synchronized associati allo stesso oggetto.

Java Syncronized: Esempio

Continua a leggere

Java HashMap – Esempio Collisione

Per poter usare correttamente l’HashMap bisogna implementare correttamente l’override delle funzioni hashcode() e equals() altrimenti si incorre nel problema delle collisioni, ossia per due chiavi diverse che hanno lo stesso hashcode,e quindi andranno nella stessa locazione,  non ci sarà modo di capire se si devono essere sovrascritti o aggiunti in quella locazione.

Per risolvere questo problema si deve fare l’override di haschcode (in modo da ridurre al minimo la possibilità che due chiavi diverse abbiano lo stesso hash) e anche di equals.In questo modo quando due chiavi diverse (due chiavi associati a due valori diversi) hanno lo stesso hashcode  viene utilizzata la  funzione equals per capire se è la stessa chiave o no. Se è la stessa chiave, viene aggiornata la coppia chiave-valore (ricordiamoci che nella locazione vengono inserite le coppie chiavi-valori), altrimenti viene aggiunta.

Vediamo un esempio che mostra un caso di hashmap con collisione risolto tramite l’equals:

Esempio:

Definiamo una classe Persona in cui l override di hashcode è fatto in modo tale che ritorni l’id.


package example.hashmap;

public class Persona {
private String nome;
private int id;

public Persona(String nome, int id) {
this.nome = nome;
this.id = id;
}

public String getNome() {
return nome;
}
public void setNome(String nome) {
this.nome = nome;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}

@Override
public int hashCode() {

System.out.println("chiamato hashCode per ="+ id+"."+nome);
return id;
}

@Override
public boolean equals(Object obj) {
System.out.println("called equals on ="+ id+"."+nome + " to compare with = "+ ((Persona)obj).getId() + "."+ ((Persona)obj).getNome());

if( ((Persona)obj).getId() == id && ((Persona)obj).getNome().equals(nome) )
return true;
return false;
}
}

Nel main, vengono create 3 chiavi, di cui due i (p1 e p3)  hanno lo stesso id (1), quindi lo stesso hashcode, e inserite dentro una mappa.


package example.hashmap;

import java.util.HashMap;

public class ProvaMap {

public static void main(String[] args) {

// //ESEMPIO COLLISIONE
Persona p1 = new Persona("mario",1);
Persona p2 = new Persona("gino",2);
Persona p3 = new Persona("flavio",1);// viene messo lo stesso id di p1, l hashcode per
// come definito ritorna l id.

HashMap<Persona, String> mappa = new HashMap<Persona, String>();

mappa.put(p1, "ONE");
mappa.put(p2, "TWO");
mappa.put(p3, "THREE");

 

Persona p1Bis = new Persona("mario",1);

String value = mappa.get(p1Bis);
System.out.println(" value: "+ value);

//nell output si vede che chiama l hashcode per "mario" che da 1,
//// ma nella posizione 1 è memorizzato anche "flavio" quindi
//// chiama anche equals per capire quale chiave è corretta

}

}

L’output sarà:

HashMap esempio collisione

Quando inserisco la p3 nella mappa, nell’output si nota  la chiamata al metodo equals per capire se la chiave già presente nella locazione con indirizzo 1 (ossia p1, “1.mario”) è uguale o no alla p3 (“1.flavio”).  Equals dice che sono diversi quindi avremo che nella locazione 1 ci sono due coppie chiave-valore (p1-ONE e p3-THREE)

Spring – Form, Lista di Input

Spring non permette di stampare il contenuto di una lista e collegarlo ad un campo di input.

Un escamotage è usare il tag html <input> al posto di <form:input>:


<input name="order.paymentTransactions[0].payerEmail" />

dove [0] sarà una variabile che indica la posizione dell’array da stampare.

Non si può usare direttamente il tag di spring

<form:input path="order.paymentTransactions[0].payerEmail" name="payerEmail"/>

perchè verra decodificato in:

<input name="order.paymentTransactions0.payerEmail" />

Di seguito un esempio completo in cui stampiamo e rendiamo modificabili una lista di contatti di persone (contactForm.contacts), associandoli ai rispettivi campi:


<c:forEach items="${contactForm.contacts}" var="contact" varStatus="status">
<tr>
<td align="center">${status.count}</td>
<td><input name="contacts[${status.index}].firstname"               value="${contact.firstname}"/></td>
<td><input name="contacts[${status.index}].lastname" value="${contact.lastname}"/></td>
<td><input name="contacts[${status.index}].email" value="${contact.email}"/></td>
<td><input name="contacts[${status.index}].phone" value="${contact.phone}"/></td>
</tr>
</c:forEach>

Java e Excel – Lettura File

Per poter lavorare con un foglio excel con il progetto Apache POI è perfetto. Completo e semplice da capire.
Per poterlo utilizzare è sufficiente aggiungere le seguenti dependency nel pom.xml:


<dependency>
<groupId>org.apache.poi</groupId>
<artifactId>poi</artifactId>
<version>3.9</version>
</dependency>

<dependency>
<groupId>org.apache.poi</groupId>
<artifactId>poi-ooxml</artifactId>
<version>3.9</version>
</dependency>


La lettura di un file Excel è abbastanza semplice e si compone dei seguenti passaggi:

  1. Creare una istanza di workboot dal foglio Excel
  2. Prendere lo sheet desiderato
  3. Incrementare il numero di riga
  4. iterare tutte le celle di una riga
  5. ripetere il punto 3 e 4 fino a quando tutti i dati vengono letti

Traducendo i passaggi in codice si ha:


package com.proxima.util;

import java.io.File;
import java.io.FileInputStream;
import java.util.Iterator;

import org.apache.poi.ss.usermodel.Cell;
import org.apache.poi.ss.usermodel.Row;
import org.apache.poi.xssf.usermodel.XSSFSheet;
import org.apache.poi.xssf.usermodel.XSSFWorkbook;
public class ReadExcel {

public static void main(String[] args)
{
try
{
FileInputStream file = new FileInputStream(new File("esempio.xlsx"));

//Create Workbook instance holding reference to .xlsx file
XSSFWorkbook workbook = new XSSFWorkbook(file);

//Get first/desired sheet from the workbook
XSSFSheet sheet = workbook.getSheetAt(0);

//Iterate through each rows one by one
Iterator<Row> rowIterator = sheet.iterator();
while (rowIterator.hasNext())
{
Row row = rowIterator.next();
//For each row, iterate through all the columns
Iterator<Cell> cellIterator = row.cellIterator();

while (cellIterator.hasNext())
{
Cell cell = cellIterator.next();
//Check the cell type and format accordingly
switch (cell.getCellType())
{
case Cell.CELL_TYPE_NUMERIC:
System.out.print(cell.getNumericCellValue() + "t");
break;
case Cell.CELL_TYPE_STRING:
System.out.print(cell.getStringCellValue() + "t");
break;
}
}
System.out.println("");
}
file.close();
}
catch (Exception e)
{
e.printStackTrace();
}
}

}

Java 8: Espressioni Lambda in 5 minuti

Java 8 Lambda: cosa sono

Le espressioni Lambda costituiscono la principale novità per il linguaggio di programmazione Java 8. Esse sono collegate al concetto di funzione anonima (funzione non classe anonima), ossia una funzione che ha un corpo ma non un nome, definita nel punto in cui viene utilizzata. La loro sintassi è qualcosa di simile:

(arg1, arg2) -> {body}

Java 8 Lambda: Esempi
// espressione che prende in input due interi e restituisce la somma
(int x, int y) -> x + y

// espressione che prende in input una stringa e restituisce la sua lunghezza
s -> s.length()

// espressione senza argomenti che restituisce il valore 50
() -> 50

// espressione che prende in input una stringa e non restituisce nulla
(String s) -> { System.out.println(“Benvenuto “);
System.out.println(s); }

//ERRORE
(int x, 5) -> x + y
In un’espressione lambda o nessuno dei tipi dei parametri è dichiarato oppure lo devono essere tutti. Se c’è solamente un parametro, le parentesi tonde possono essere omesse,
Vengono chiamate interfacce funzionali (functional interface) delle interfacce con un solo metodo astratto. Sono generalmente marcate con l’annotazione @FunctionalInterface, anche se non è obbligatorio. Le lambda sono usate con le funcional interface.

Esempio:
// Anonymous Runnable
Runnable r1 = new Runnable(){

@Override
public void run(){
System.out.println(“Hello world old style!”);
}
};

// Lambda Runnable
Runnable r2 = () -> System.out.println(“Hello world with Lambda!”);

E’ abbastanza evidente come con l’uso delle lambda abbiamo ridotto un pezzo di codice da 5 linee a 1 soltanto.
Esempio:

//Prima:
button.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
System.out.println(“Sintassi arcinota!”);
}
});

//Dopo:
button.addActionListener( (e) -> {
System.out.println(“Nuova sintassi!”);
});

Ricapitolando, l’espressione lambda è una sintassi più semplice e leggibile per definire-creare un’istanza di una classe anonima che implementa un’interfaccia con un solo metodo astratto. Esse si concentrano solamente sulla definizione dell’unico metodo astratto dell’interfaccia.

Usando le espressioni lambda si può utilizzare un altro strumento aggiunto con java8, i reference method. E’ una nuova sintassi per poter invocare un metodo o un costruttore già esistente.
Esempio:
class Numbers {
public static boolean isMoreThanFifty(int n1, int n2) {
return (n1 + n2) > 50;
}

}

public static void main(String[] args) {

// Using an anonymous class
BiPredicate<Integer, Integer> a = new BiPredicate<Integer, Integer>() {
public boolean test(Integer i1, Integer i2) {
return Numbers.isMoreThanFifty(i1, i2);
}
};

// Using a lambda expression
BiPredicate<Integer, Integer> b = Numbers::isMoreThanFifty;

// Using a method reference
BiPredicate<Integer, Integer> c = (i1, i2) -> Numbers.isMoreThanFifty(i1, i2);

//i tre oggetti sono equivalenti
System.out.println(a.test(2, 3));
System.out.println(b.test(2, 3));
System.out.println(c.test(2, 3));

}
da notare che il metodo isMoreThanFifty ha bisogno di due parametri in input. Con il method reference non sono stati menzionati. Questo perche quando invochiamo il metodo test sull’istanza a.test(10,15), i parametri in input vengono passati in automatico al metodo Numbers.isMoreThanFifty(10, 15).

In generale la sintassi di un method reference può essere una delle seguenti:

NomeClasse::metodoIstanza // Il primo parametro è l’oggetto su cui è invocato
// il metodo e gli eventuali altri parametri sono
// passati al metodo
NomeClasse::metodoStatico // Tutti i parametri sono passati al metodo
oggetto::metodoIstanza // Tutti i parametri sono passati al metodo
E’ possibile anche invocare il costruttore con la stessa sintassi:
String:new

Esempio:

BiPredicate<String,String> eqstr = (s1,s2) -> s1.equals(s2);

con lambda diventa

BiPredicate<String,String> eqstr = String::equals;

eqstr.test(tmp, tmp2);

ossia il metodo equals sarà chiamato su tmp:

tmp.equals(tmp2);

Spring 4 MVC REST Esempio Helloworld

REST, o Representional State Transfer, è una architettura usata per il design dei web  services. L’idea di base è che invece di usare delle tecnologie come CORBA, RPC o SOAP per far dialogare due applicazioni, si può usare semplicemente l’HTTP.
Quindi ipotizzando di avere un web services relativo ad un oggetto bean generico si ha:
HTTP POST —> Crea bean
HTTP GET —> Visualizza bean
HTTP PUT —> Update bean
HTTP DELETE –> Delete bean
In genere, la response è in formato JSON o XML.
Vediamo come integrare la tecnologia REST con Spring 4 MVC

Tecnologie Usate

apache tomcat 7.068
Spring 4.2.0.RELEASE

 

Creazione Progetto

Dal meù File/New/Other  cliccare su “Maven Project” spring-mvc-file-upload-1
Continua a leggere

Spring Angularjs HelloWorld

AngularJS è un popolare framework javascript, creato e mantenuto da Google, per applicazioni mobile e rich user interfaces.
Questo tutorial illustra come utilizzare e integrarlo con Spring MVC.
In particolare si mostrerà come accedere al controller Spring MVC e visualizzare i dati di un bean.

Creazione Progetto

Dal meù File/New/Other  cliccare su “Maven Project” spring-mvc-file-upload-1
Continua a leggere