Domande e Risposte su Java

HttpComponents - Invocazione di una Servlet da un Client Java

2013-10-07T09:00:00.000+02:00

DOMANDA:

Posso invocare una servlet da un client Java?

RISPOSTA:

E' possibile stabilire una connessione con un endpoint attraverso le famose API del framework HttpClient. Purtroppo, come si può notare dalla seguente frase riportata nella home page ufficiale della libreria

"The Commons HttpClient project is now end of life, and is no longer being developed. It has been replaced by the Apache HttpComponents project "

HttpClient è stato sostituito da HttpComponents.

Per garantire vita lunga al nostro software, in questo post descriveremo un esempio di utilizzo proprio utilizzando la nuova libreria HttpComponents per eseguire una richiesta POST verso una Servlet.

Innanzitutto eseguiamo il download dei jar di HttpComponents dal link HttpComponents v4.3.

Apriamo quindi Eclipse, creiamo un nuovo progetto Java e, prima di scrivere codice, aggiungiamo al build path i jar appena scaricati.

Creiamo la classe MyHttpClient:

import java.io.IOException;
import java.net.URI;
import java.net.URISyntaxException;
import java.util.GregorianCalendar;

import org.apache.http.HttpEntity;
import org.apache.http.HttpResponse;
import org.apache.http.client.HttpClient;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.client.utils.URIBuilder;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.util.EntityUtils;


public class MyHttpClient {
 
 private static final String PROTOCOL="http";
 private static final String HOST="localhost";
 private static final int PORT=8080;
 
 public static void main(String [] args){
  
  HttpClient httpclient = null;
  HttpPost httpPost = null;
  
  System.out.println("Preparo il metodo POST");
  URIBuilder builder = new URIBuilder();//Costruzione endpoint servlet con parametri
  builder.setScheme(PROTOCOL).setHost(HOST).setPort(PORT).setPath("/MyHttpServlet/MyServlet")
      .setParameter("name", MyHttpClient.class.getName())
      .setParameter("date", String.valueOf(GregorianCalendar.getInstance().getTimeInMillis()));
  
  try {
   URI uri = builder.build();
   httpPost = new HttpPost(uri);
   
   System.out.println("Instanzio un http client");
   httpclient = HttpClients.createDefault();

   System.out.println("Invoco la servlet: "+httpPost.getURI());
   
   HttpResponse response = httpclient.execute(httpPost);
   HttpEntity entity = response.getEntity();
   
   System.out.println("Risposta: "+EntityUtils.toString(entity));
  } catch (IOException e) {
   e.printStackTrace();
  } catch (URISyntaxException e) {
   e.printStackTrace();
  } finally {
            httpPost.releaseConnection();
        }
 }
}

La servlet MyServlet può essere realizzata in questo modo:

import java.io.IOException;
import java.io.PrintWriter;
import java.util.Date;

import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

@WebServlet("/MyServlet")
public class MyServlet extends HttpServlet {
 

 protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
  String name = request.getParameter("name");
  System.out.println("Ricevuto: "+name);
  String dateParam = request.getParameter("date");
  
  long date = Long.parseLong(dateParam);
  
  response.setContentType("text/plain");
  PrintWriter out = response.getWriter();
  out.write("Ciao "+name+"\n");
  out.write("Richiesta ricevuta il: "+new Date(date));
  
  out.flush();
  out.close();
 }

 
 protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
  doGet(request, response);
 }

}

Avviando opportunamente un Servlet Container (ad esempio Tomcat) in cui verrà effettuato il "deploy" della nostra semplice servlet, il client MyHttpClient potrà invocare MyServlet in qualsiasi momento.

Infatti, dopo l'avvio, l'output di MyHttpClient sarà:

Preparo il metodo POST
Instanzio un http client

Invoco la servlet: http://localhost:8080/MyHttpServlet/MyServlet?name=MyHttpClient&date=1372361403328

Risposta: Ciao MyHttpClient

Richiesta ricevuta il: Thu Oct 03 20:10:03 CEST 2013

Mentre l'output di MyServlet sarà:

Ricevuto: MyHttpClient

Riferimenti

GitHub

Http client

Recuperare programmaticamente i campi di un oggetto

2013-07-02T09:00:00.000+02:00

DOMANDA:

Come posso recuperare tutti i campi di un oggetto programmaticamente?

RISPOSTA:

Per recuperare tutti gli attributi/campi di un oggetto è sufficiente usare la Reflection di Java con un po' di ricorsione.

Definiamo una classe User con delle proprietà:

package lancill.objectfields.pojo;

import java.util.List;

public class User extends Person{
 
 private String mail;
 private String userid;
 private List<String> contacts;
 private List<User> friends;
 
 public User(){}
 
 public User(String name){
  super(name);
 }
 
 public String getMail() {
  return mail;
 }
 public void setMail(String mail) {
  this.mail = mail;
 }
 public String getUserid() {
  return userid;
 }
 public void setUserid(String userid) {
  this.userid = userid;
 }
 public List<String> getContacts() {
  return contacts;
 }
 public void setContacts(List<String> contacts) {
  this.contacts = contacts;
 }
 public List<User> getFriends() {
  return friends;
 }
 public void setFriends(List<User> friends) {
  this.friends = friends;
 }
}

La classe User estende la classe Person qui di seguito:

package lancill.objectfields.pojo;

public class Person {
 
 private String name;
 private String surname;
 private String age;
 
 public Person(){}
 
 public Person(String name) {
  this.name=name;
 }
 public String getName() {
  return name;
 }
 public void setName(String name) {
  this.name = name;
 }
 public String getSurname() {
  return surname;
 }
 public void setSurname(String surname) {
  this.surname = surname;
 }
 public String getAge() {
  return age;
 }
 public void setAge(String age) {
  this.age = age;
 }

}

Partiamo con un semplice algoritmo per recuperare i campi base dell'oggetto User; perfezioneremo poi l'algoritmo per recuperare i campi ereditati e gli oggetti contenuti nelle liste.

import java.lang.reflect.Array;
import java.lang.reflect.Field;
import java.util.ArrayList;
import java.util.List;

import lancill.objectfields.pojo.User;

public class PrintBaseObjectFields {

 public static void main(String[] args) {

  User user = getUser();
  printBaseUserField(user, "user");
 }

 
 private static void printBaseUserField(Object object, String aFieldName) {

  String parentFieldName = aFieldName;

  try {
   //recupero tutti i campi della classe del mio ogetto
   Field[] classFields = object.getClass().getDeclaredFields();
 
   for (Field field : classFields) {
    //imposto il campo accessibile altrimenti JAva solleva una eccezione
    field.setAccessible(true);
 
    String fieldName = field.getName();
    Object value;
    try {
     //recupero il valore del campo per l'istanzia della classe
     value = field.get(object);
     System.out.println("FIELD UTENTE: Nome attributo: "
       + parentFieldName + "." + fieldName + ", Valore attributo: "
       + value);
    } catch (Exception e) {
     System.out.println("Impossobile recuperare una proprieta'");
     e.printStackTrace();
    }
 
   }
  } catch (Exception e) {
   System.out.println("Errore recupero field di "+aFieldName);
   e.printStackTrace();
  }

 }
 
 private static User getUser() {
  User user = new User();
  user.setName("Peter");
  user.setSurname("Pan");
  user.setAge("12");
  user.setMail("peterpan@isolachenonce.net");
  user.setUserid("pp");
  
  List<String> contacts = new ArrayList<>();
  contacts.add("555010101");
  contacts.add("333000000");
  
  user.setContacts(contacts);
  
  List<User> friends = new ArrayList<User>();
  friends.add(new User("Campanellino"));
  friends.add(new User("Mary"));
  
  user.setFriends(friends);
  
  return user;
 }
 
}

L'output della classe PrintBaseObjectFields sarà:

FIELD UTENTE: Nome attributo: user.mail, Valore attributo: peterpan@isolachenonce.net
FIELD UTENTE: Nome attributo: user.userid, Valore attributo: pp
FIELD UTENTE: Nome attributo: user.contacts, Valore attributo: [555010101, 333000000]
FIELD UTENTE: Nome attributo: user.friends, Valore attributo: [lancill.objectfields.pojo.User@6fafc4c2, lancill.objectfields.pojo.User@7c9ed5d6]

Come potete notare, i campi ereditati (della classe Person) non sono stati recuperati e le liste di oggetti complessi non sono stampate correttamente.

Perfezioniamo il nostro algoritmo per gestire anche i campi ereditati e le liste.
Dovremo manipolare degli array, quindi per eseguire il prossimo algoritmo è necessario scaricare la libreria Apache Commons Lang.

Creiamo la classe PrintAllObjectFields che utilizzerà il metodo printAllUserField (diversamente da quanto fatto prima con printBaseUserField).

Il nuovo metodo questa volta fa uso della ricorsione per eseguire il parsing in profondità di tutti i tipi di campo complessi.

import java.lang.reflect.Array;
import java.lang.reflect.Field;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

import org.apache.commons.lang3.ArrayUtils;

import lancill.objectfields.pojo.User;

public class PrintAllObjectFields {

 public static void main(String[] args) {

  User user = getUser();
  printAllUserField(user, "user");
 }

 private static void printAllUserField(Object object, String aFieldName) {

  
  String parentFieldName = aFieldName;

  try{
   
  
   Field[] classFields = object.getClass().getDeclaredFields();
 
   //definisco un identificatore delle mie classi per discriminare in seguito il tipo di parsing
   String PACKAGE = "lancill.objectfields.pojo";
   
   Field [] superClassFields;
   //Creo un array con tutti i campi dell'oogetto
   Field [] allClassFields = ArrayUtils.addAll(classFields);
   
   //Recupero i campi della classe Person
   Class superClass = object.getClass().getSuperclass();
   if(superClass.getCanonicalName().startsWith(PACKAGE)){
    superClassFields = superClass.getDeclaredFields();
    
    allClassFields = ArrayUtils.addAll(superClassFields, classFields);
   }
   
   
   for (Field field : allClassFields) {
    field.setAccessible(true);
 
    String fieldName = field.getName();
    Object value;
    try {
     //recupeo il tipo del campo
     String canonicalName =field.getType().getCanonicalName();
     
     //controllo se è un campo di un tipo primitivo Java
     if(!canonicalName.startsWith("java.util.List") && !canonicalName.startsWith(PACKAGE)){
 
      value = field.get(object);
      System.out.println("FIELD UTENTE: Nome attributo: "
        + parentFieldName + "." + fieldName + ", Valore attributo: "
        + value);
     }else{
      /**
       * Eseguo il parsing di un campo complesso:
       * Liste
       * Classi del mio package
       **/
      Object complexObj = field.get(object);
      
      if(complexObj!=null){
       if(complexObj instanceof List){//GESTIONE LISTE
        System.out.println("FIELD UTENTE: START Attributo complesso:"+parentFieldName+"."+fieldName);
        //Recupeo l'istanza della lista
        List<Object> list = (List<Object>)complexObj;
        int count=1;
        //Ciclo su tutti gli elementi della lista
        for(Object objInList : list){
         String objCanonicalName =objInList.getClass().getCanonicalName(); 
         if(!objCanonicalName.startsWith(PACKAGE)){//se il tipo dell'oggetto non è complesso
          System.out.println("FIELD UTENTE: Nome attributo: "
            + parentFieldName + "." + fieldName +".[elemento-"+count+"], Valore attributo: "
            + objInList);
         }else{
          //uso la ricorsione per eseguire gli stessi calcoli in profondita
          printAllUserField(objInList, parentFieldName+"."+fieldName+".[elemento-"+count+"]");
         }
         count++;
        }
        System.out.println("FIELD UTENTE: END Attributo complesso:"+fieldName);
        
       }else{//GESTIONE OGGETTO COMPLESSO DEL MIO PACKAGE
        System.out.println("FIELD UTENTE: START Attributo complesso:"+parentFieldName+"."+fieldName);
        //uso la ricorsione per eseguire gli stessi calcoli in profondita
        printAllUserField(complexObj, parentFieldName+"."+fieldName);
        System.out.println("FIELD UTENTE: END Attributo complesso:"+fieldName);
       }
      }
     }
    } catch (Exception e) {
     System.out.println("Impossobile recuperare una proprieta'");
     e.printStackTrace();
    }
 
   }
  } catch (Exception e) {
   System.out.println("Errore recupero field di "+aFieldName);
   e.printStackTrace();
  }

 }
 
 private static User getUser() {
  User user = new User();
  user.setName("Peter");
  user.setSurname("Pan");
  user.setAge("12");
  user.setMail("peterpan@isolachenonce.net");
  user.setUserid("pp");
  
  List<String> contacts = new ArrayList<>();
  contacts.add("555010101");
  contacts.add("333000000");
  
  user.setContacts(contacts);
  
  List<User> friends = new ArrayList<User>();
  friends.add(new User("Campanellino"));
  friends.add(new User("Mary"));
  
  user.setFriends(friends);
  
  return user;
 }
 
}

L'output della classe PrintAllObjectFields sarà:

FIELD UTENTE: Nome attributo: user.name, Valore attributo: Peter
FIELD UTENTE: Nome attributo: user.surname, Valore attributo: Pan
FIELD UTENTE: Nome attributo: user.age, Valore attributo: 12
FIELD UTENTE: Nome attributo: user.mail, Valore attributo: peterpan@isolachenonce.net
FIELD UTENTE: Nome attributo: user.userid, Valore attributo: pp
FIELD UTENTE: START Attributo complesso:user.contacts
FIELD UTENTE: Nome attributo: user.contacts.[elemento-1], Valore attributo: 555010101
FIELD UTENTE: Nome attributo: user.contacts.[elemento-2], Valore attributo: 333000000
FIELD UTENTE: END Attributo complesso:contacts
FIELD UTENTE: START Attributo complesso:user.friends
FIELD UTENTE: Nome attributo: user.friends.[elemento-1].name, Valore attributo: Campanellino
FIELD UTENTE: Nome attributo: user.friends.[elemento-1].surname, Valore attributo: null
FIELD UTENTE: Nome attributo: user.friends.[elemento-1].age, Valore attributo: null
FIELD UTENTE: Nome attributo: user.friends.[elemento-1].mail, Valore attributo: null
FIELD UTENTE: Nome attributo: user.friends.[elemento-1].userid, Valore attributo: null
FIELD UTENTE: Nome attributo: user.friends.[elemento-2].name, Valore attributo: Mary
FIELD UTENTE: Nome attributo: user.friends.[elemento-2].surname, Valore attributo: null
FIELD UTENTE: Nome attributo: user.friends.[elemento-2].age, Valore attributo: null
FIELD UTENTE: Nome attributo: user.friends.[elemento-2].mail, Valore attributo: null
FIELD UTENTE: Nome attributo: user.friends.[elemento-2].userid, Valore attributo: null
FIELD UTENTE: END Attributo complesso:friends

GitHub

GetAllObjectFields Project

Riferimenti

Java Reflection: accesso e metodi a campi privati

Come definire e utilizzare a runtime delle custom Annotation

2013-05-30T17:52:00.000+02:00

DOMANDA:

Come si definiscono delle Annotation custom per utilizzarle nel mio programma?

RISPOSTA:

Le Annotation introdotte in Java 5 consentono di definire dei metadata per tre diversi livelli di scoping:

SOURCE - Annotation disponibile solo nello scope del sorgente e viene ignorato dal compilatore
CLASS - Annotation disponibile nello scope dal compilatore in fase di compilazione, ma viene ignorata dalla Java Virtual Machine (JVM)
RUNTIME - Annotation disponibile nello scope della JVM in modo che possa essere utilizzato da l'ambiente di runtime

Le Annotation NON aggiungono logica all'applicazione e non sono uno strumento per programmare componenti. Sono invece in grado di fornire delle informazioni (metadati) per capire meglio il tipo di codice che stiamo eseguendo ed eventualmente intraprendere delle azioni o eseguire delle configurazioni).

In questo post ci concentreremo sulle Annotation di tipo RUNTIME per riuscire ad eseguire delle azioni durante l'esecuzione dell'applicazione.

Innanzitutto realizziamo un file di properties e lo chiamiamo (ad esempio) city.properties. Il contenuto sarà semplice:

name=Roma
country=Italia

Adesso realizziamo un bean City che legge delle informazioni dal file di properties appena creato:

package lancill.test.pojo;

import java.io.FileInputStream;
import java.util.Properties;
import lancill.annotation.ReadPropertiesAnnotation;

public class City {
 
 private Properties props = new Properties();
 private final String PROPERTIES_FILE_NAME = "city.properties";
 public City(){
  try {
   props.load(new FileInputStream(PROPERTIES_FILE_NAME));
  } catch (Exception e) {
   props.setProperty("name","N/A");
   props.setProperty("country","N/A");
   e.printStackTrace();
  }
 }
 
 public String getName(){
  return props.getProperty("name");
 }
 
 public String getCountry(){
  return props.getProperty("country");
 }
}

Il prossimo passo è realizzare una Annotation custom che ci consentirà di capire qual è il file di properties su cui si basa il bean City e quali sono i valori delle property che utilizzerà il bean a runtime.

Definiamo la nostra Annotation ReadPropertiesAnnotation nel seguente modo:

package lancill.annotation;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface ReadPropertiesAnnotation {
 
 String fileName();
 String propertyName() default "N/A";

}

Vediamo quali sono le parole chiave che descrivono l'Annotation:

@interface consente di definire la classe ReadPropertiesAnnotation di tipo Annotation
@Target indica che l'Annotation che stiamo definendo può essere applicata solo ai metodi
@Retention definisce il livello di scope (in questo RUNTIME)

la @Retention deve essere obbligatoriamente RUNTIME se vogliamo che le informazioni della nostra Annotation siano disponibili durante l'esecuzione dell'applicazione

Applichiamo ora la nostra Annotation ai metodi del bean City:

package lancill.test.pojo;

import java.io.FileInputStream;
import java.util.Properties;
import lancill.annotation.ReadPropertiesAnnotation;

public class City {
 
 private Properties props = new Properties();
 private final String PROPERTIES_FILE_NAME = "city.properties";
 public City(){
  try {
   props.load(new FileInputStream(PROPERTIES_FILE_NAME));
  } catch (Exception e) {
   props.setProperty("name","N/A");
   props.setProperty("country","N/A");
   e.printStackTrace();
  }
 }
 
 @ReadPropertiesAnnotation (fileName=PROPERTIES_FILE_NAME, propertyName="name")
 public String getName(){
  return props.getProperty("name");
 }
 
 @ReadPropertiesAnnotation (fileName=PROPERTIES_FILE_NAME, propertyName="country")
 public String getCountry(){
  return props.getProperty("country");
 }
}

A questo punto dobbiamo definire una classe che sia in grado di recuperare le informazioni delle nostra Annotation e interpretarle correttamente.

Definiamo quindi la classe AnnotationAnalyzer che, attraverso il metodo analyze(), recupera il bean City e i relativi metodi con le annotation di tipo ReadPropertiesAnnotation.

Una volta individuati i metodi, carica l'annotation ed esegue il parsing delle informazioni:

package lancill.annotation.parser;

import java.io.FileInputStream;
import java.lang.reflect.Method;
import java.util.Properties;
import lancill.annotation.ReadPropertiesAnnotation;

public class AnnotationAnalyzer {
    
 public void analyze() {

  try {
   Class annotationClass = AnnotationAnalyzer.class.getClassLoader()
     .loadClass(("lancill.test.pojo.City"));
   
   for (Method method : annotationClass.getMethods()) {
    if (method
      .isAnnotationPresent(lancill.annotation.ReadPropertiesAnnotation.class)) {

     try {
      ReadPropertiesAnnotation metodoAnnotation = method
        .getAnnotation(ReadPropertiesAnnotation.class);

      if (!metodoAnnotation.fileName().isEmpty()) {
       System.out.println("Annotation @ReadPropertiesAnnotation:\n");
       System.out.println("\t- Metodo: "+ method);
       
       System.out.println("\t- Nome file di properties: "+ metodoAnnotation.fileName());
       System.out.println("\t- Property associata al metodo: "+  metodoAnnotation.propertyName());
       System.out.println("\t- Valore restituito dal metodo: "+ getPropertyValue(metodoAnnotation.fileName(),metodoAnnotation.propertyName())+"\n");
      }

     } catch (Throwable ex) {
      ex.printStackTrace();
     }
    }
   }
  } catch (Exception e) {
   e.printStackTrace();
  }
 }

 private String getPropertyValue(String fileName, String propertyName) {
  Properties props=new Properties();
  
  try {
   props.load(new FileInputStream(fileName));
   return props.getProperty(propertyName);
  } catch (Exception e) {
   e.printStackTrace();
  }
  
  return "Impossibile calcolare il valore";
 }
}

Possiamo ora definire una semplice applicazione che lancia il metodo analyze():

package lancill.test;

import lancill.annotation.parser.AnnotationAnalyzer;

public class TestAnnotation {

 public static void main(String[] args) {
  AnnotationAnalyzer aa = new AnnotationAnalyzer();
  aa.analyze();
 }
}

L'output sarà il seguente:

Annotation @ReadPropertiesAnnotation:

- Metodo: public java.lang.String lancill.test.pojo.City.getName()
- Nome file di properties: city.properties
- Property associata al metodo: name
- Valore restituito dal metodo: Roma

Annotation @ReadPropertiesAnnotation:

- Metodo: public java.lang.String lancill.test.pojo.City.getCountry()
- Nome file di properties: city.properties
- Property associata al metodo: country
- Valore restituito dal metodo: Italia

Riferimenti

Abilitazione Cross Application Scope in Tomcat per condivisione dati tra webapp

2013-05-27T09:00:00.000+02:00

DOMANDA:

Come posso condividere dati tra diverse webapp utilizzando l'Application Scope?

RISPOSTA:

Di default l'Application Scope è utilizzato per memorizzare oggetti a livello di web application. Questo livello di scope è il più alto rispetto ai classici scope di Request e Session

Nome	Scope	Durata
Request	Singola richiesta, verso il server	Fino a quando la risposta non viene inviata al client
Session	Tutte le richieste inviate dallo stesso browser	Fino a quando non scade il timeout della sessione o l'ID di sessione non viene invalidato (ad es. chiusura del browser)
Application	Tutte le richieste inviate a una stessa Web Application	Container

Per poter recuperare un oggetto memorizzato a livello di Application Scope è necessario utilizzare il ServletContext.

Se vogliamo recuperare un oggetto memorizzato nell'Application Scope della WebAppA dalla WebAppB è necessario fare attenzione ai seguenti aspetti:

Abilitare il crossContext nel file context.xml presente nella cartella config di Tomcat:

<context crosscontext="true">

    ...

</context>

Recuperare dalla WebAppA il ServletContext della WebAppB in questo modo:

import java.io.IOException;
import javax.servlet.ServletConfig;
import javax.servlet.ServletContext;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

@WebServlet("/ServletWebAppA/CrossApplicationScopeServlet")
public class CrossApplicationScopeServlet extends HttpServlet {
 protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
 
  ServletContext sc = request.getServletContext().getContext("/WebAppB");
  
  String valore = (String)sc.getAttribute("CHIAVE");
  
 }
}

Quando si utilizzano dati condivisi, bisogna stare attenti ai possibili errori di ClassCastException. Potete consultare il post ClassCastException con oggetto in ClassLoader diversi per prendere le giuste precauzioni.

La ricorsione in Java

2013-05-16T09:00:00.000+02:00

DOMANDA:

Che cos'è la ricorsione?

RISPOSTA:

La ricorsione è forse una delle prime cose che si studiano in programmazione e, diciamoci la verità, non è così intuitiva per chi è alle prime armi. A cosa serve la ricorsione? A creare dei cicli (o chiamate cicliche) in maniera alternativa al classico for. In questo post cerchiamo di semplificarne il concetto utilizzando Java, ma è praticamente uguale in tutti i linguaggi di programmazione.

Guardiamo subito un esempio a scopo puramente didattico:

package ricorsione;

public class RicorsioneTest {

 public static void main(String[] args) {

  int variabile = metodoRicorsivo(); 
  
 }
 
 public static int metodoRicorsivo(){
  return metodoRicorsivo();
 }
}

Cosa succede eseguendo questo frammento di codice? Innanzitutto sconsiglio di eseguirlo dato che sarà un'inconclusiva Exception a Runtime (java.lang.StackOverflowErrorloop)! In pratica l'unica riga di codice del main richiama un metodo che richiama se stesso che a sua volta richiama nuovamente se stesso e così via all'infinito (in questo caso)!

Anche se in modo errato, abbiamo già realizzato una ricorsione, in parole povere un "qualcosa" che richiama se stessa.

Come rendere utile (e soprattutto funzionante) questo concetto? Guardiamo subito l'esempio RicorsioneTest:

package ricorsione;

public class RicorsioneTest {

 public static void main(String[] args) {

  metodoRicorsivo(10); 
  
 }
 
 public static int metodoRicorsivo(int numero){
  System.out.println("Numero valutato: " +numero);
  numero--;  
  if(numero == 1)  
   return 1;  
    
  return metodoRicorsivo(numero);
 }
}

L'output in questo caso è finito e corretto:

Numero valutato: 10
Numero valutato: 9
Numero valutato: 8
Numero valutato: 7
Numero valutato: 6
Numero valutato: 5
Numero valutato: 4
Numero valutato: 3
Numero valutato: 2

Cosa è cambiato?

Abbiamo inserito una condizione base (numero == 1) che permette al metodo di terminare man mano che le chiamate si annidano l'una con l'altra e, soprattutto, abbiamo aggiunto una variante che modifica il valore della variabile ad ogni chiamata (numero--). Queste due condizioni garantiscono che arriveremo (prima o poi) ad una base in cui il metodo non richiamerà più se stesso e comincerà la risalita e la restituzione dei valori al chiamante.

Per chiarire i dubbi sulla ricorsione guardiamo un esempio leggermente più complesso. Il classico algoritmo di Fibonacci. L'algoritmo seguente calcola il numero della sequenza di fibonacci nella posizione i-esima:

package ricorsione; 

public class FibonacciRicorsivo {

  public static long fibonacci(long i) {
    if(i == 0) 
      return 0;
  
    else if(i == 1) 
      return 1;
  
    else 
      return fibonacci(i-1) + fibonacci(i-2);
  }

  public static void main(String[] args){
    long i = 4; //numero su cui calcolare la funzione di fibonacci
    System.out.println("INIZIO CALCOLO DELLA FUNZIONE DI FIBONACCI("+i+")");
    System.out.print("RISULTATO = " + fibonacci(i));
  }
}

L'output sarà banalmente il numero della sequenza di Fibonacci indicato dall'indice i (nell'esempio "4"):

INIZIO CALCOLO DELLA FUNZIONE DI FIBONACCI(4):
RISULTATO: 3

In questo caso (molto semplice) la sequenza di chiamate è questa:

Prima scomposizione di fib(4)

Seconda scomposizione di fib(3);
fib(1) termina le sottochiamate in quanto caso base

Terza scomposizione di fib(2), fib(1) e fib(0) sono casi base

Terminate le chiamate del ramo, comincia la risalita
e la restituzione dei risultati, qui a fib(2)

Restituzione a fib(3)

Terminata la restituzione del primo ramo,
cominciano le chiamate al secondo ramo

Come nel primo caso, terminate le chiamate, si restituiscono i risultati

Infine l'ultima somma restituisce il risultato finale (esatto)

Nell'utilizzare la ricorsione è necessario sapere che in genere è molto più pesante in termini di elaborazione rispetto alla normale iterazione. Infatti, in algoritmi come questo il numero di chiamate sale esponenzialmente: guardiamo lo schema finale delle chiamate se provassimo a calcolare il 5° numero della sequenza di fibonacci (nella sequenza precedente era fibonacci(4)):

In arancione ci sono i 2 casi base che restituiscono 0 o 1
e tra parentesi la somma parziale fino a quel momento

Immaginiamo cosa accadrebbe per numeri più grandi.

In sintesi l'utilità della ricorsione è di consentire la scrittura di algoritmi di una certa complessità in maniera più semplice (per determinate categorie di problemi) ed elegante. Di contro, la sua dispendiosità in termini di risorse ne limita fortemente il campo di applicazione.

Realizzare un servizio REST con JAX-RS 2.0 e Jersey 2.0

2013-05-09T09:00:00.000+02:00

DOMANDA:

Come realizzo un servizio REST 2.0 e un client per testarlo?

RISPOSTA:

Per addentrarsi nel mondo REST consiglio di leggere il post REST 2.0: Definizione e configurazione con il framework Jersey. Il post spiega brevemente i concetti REST e cosa occorre per configurare un ambiente che lo utilizzi. La lettura servirà anche per conoscere quali sono i jar da includere nei progetti che stiamo per realizzare.

In questo post creeremo un Servizio REST che risponderà, con un semplice "echo", alle richieste di un Client.

Partiamo con la programmazione del Servizio.

Creiamo un nuovo Dynamic Web Project in Eclipse denominato RESTfulService e ricordiamoci di selezionare, nell'ultimo step del wizard, di creazione la checkbox "Generate web.xml deployment descriptor".

Questa opzione ci permetterà di avere a disposizione un web.xml di base creato da Eclipse da modificare secondo le nostre preferenze (ovviamente non è un passo obbligatorio, ma di sicuro ci permette di risparmiare tempo e fatica).

Dividiamo la costruzione del servizio in due parti:

Configurazione
Creazione del servizio di Echo

1 - Configurazione.

Per prima cosa dobbiamo personalizzare il web.xml appena creato da Eclipse in questo modo:

<web-app version="3.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://java.sun.com/xml/ns/javaee" xsi:schemalocation="http://java.sun.com/xml/ns/javaee
 http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd">
  <servlet>
  <servlet-name>JerseyWeb</servlet-name>
  <servlet-class>org.glassfish.jersey.servlet.ServletContainer</servlet-class>
  <init-param>
   <param-name>javax.ws.rs.Application</param-name>
   <param-value>echo.application.EchoApplication</param-value>
  </init-param>
  <init-param>
   <param-name>jersey.config.xml.security.disable</param-name>
   <param-value>true</param-value>
  </init-param>
  <load-on-startup>1</load-on-startup>
 </servlet>

 <servlet-mapping>
  <servlet-name>JerseyWeb</servlet-name>
  <url-pattern>/*</url-pattern>
 </servlet-mapping>
  
 </web-app>

Creiamo ora la classe echo.application.EchoApplication referenziata nella riga in evidenza del web.xml.

La classe EchoApplication (necessaria per configurare il gestore della nostra architettura REST).

package echo.application;

import java.util.HashSet;
import java.util.Set;

import javax.ws.rs.core.Application;

import echo.resource.EchoResource;

public class EchoApplication extends Application {

     @Override
     public Set<Class<?>> getClasses() {
         Set<Class<?>> classes = new HashSet<Class<?>>();
         classes.add(EchoResource.class);
         return classes;
     }
}

2 - Servizio REST: echo.resource.EchoResource.

package echo.resource;

import javax.ws.rs.GET;
import javax.ws.rs.Path;
import javax.ws.rs.Produces;
import javax.ws.rs.QueryParam;

@Path("/echo")
public class EchoResource {
  @GET
  @Produces("text/plain")
  public String echo(@QueryParam("echo_msg") String echoString) {
    return echoString;
  }   
}

Come potete notare, la classe EchoResource fa un forte uso delle Annotation. Vediamole nel dettaglio:

@Path definisce l'endpoint della nostra risorsa (o servizio). Questo url insieme al context path della nostra web application forma l'endpoint completo (nel nostro esempio http://localhost:8080/RESTfulService/echo). Grazie a questo endpoint, il servizio sarà invocabile a quell'indirizzo dal client.
@GET indica quale metodo del protocollo HTTP sarà utilizzato per invocare il metodo echo
@Produces indica il content-type della risposta (da notare la s della terza persona del verbo to produce)
@QueryParam indica semplicemente che l'attributo echoString deve essere mappato sul parametro in query string "echo_msg"

Realizzazione del Client

Creiamo un semplice Java Project da Eclipse. Questo progetto conterrà il client del nostro servizio e sarà una Java Application standard.

Di seguito il codice del client REST EchoClient che invia la stringa di cui il servizio fornirà l'echo in risposta:

import javax.ws.rs.client.Client;
import javax.ws.rs.client.ClientBuilder;
import javax.ws.rs.client.WebTarget;
import javax.ws.rs.core.Response;

public class EchoClient {
 
  public static void main(String [] args){
    // Recupero instance di Client
    Client client = ClientBuilder.newClient();
  
    // Creo un WebTarget con l'endpoint del servizio REST 
    WebTarget target = client.target("http://localhost:8080/RESTfulService/echo");
    //Aggiungo un parametro alla richiesta REST
    //Il parametro rappresenta il messaggio di cui fare l'echo
    target=target.queryParam("echo_msg", "ciao");
  
    // Invocazione del servizio
    Response res = target.request("text/plain").get();
  
    // Visualizzato l'intera risposta e il suo contenuto
    System.out.println(res);
    System.out.println(res.readEntity(String.class));
  }
}

Notiamo il WebTarget che punta all'url definita precedentemente con l'Annotation @Path

Eseguiamo ora il deploy della nostra web application RESTfulService (creando il war ed installandolo nella cartella di pubblicazione del server - ad esempio webapps in Tomcat) e lanciamo il client appena creato.

L'output del client sarà il seguente:

ScopedJaxrsResponse{ClientResponse{method=GET, uri=http://localhost:8080/RESTfulService/echo?echo_msg=ciao, status=200, reason=OK}}
ciao

REST 2.0: Definizione e configurazione con il framework Jersey

2013-05-07T09:00:00.000+02:00

DOMANDA:

Cos'è REST e come configurare un ambiente per utilizzarlo?

RISPOSTA:

REST (REpresentational State Transfer) è un paradigma per la definizione di architetture distribuite.

I suoi principi si basano sulla leggerezza e sull'utilizzo dei metodi offerti dal protocollo HTTP:

Ogni entità/operazione viene rappresentata come una Risorsa
Per l'invocazione si utilizzano i metodi HTTP (GET,PUT,POST,DELETE)
La rappresentazione dei dati è snella (es. JSON)

REST non è un concetto nuovo: un sito web rispetta i principi REST, cosi come un feed RSS. Di recente si sta estendendo il concetto REST alle architetture orientate ai servizi, oggi principalmente basate su HTTP/SOAP.

Una funzionalità/servizio che rispetta i principi REST è denominata RESTful.

In Java esiste la specifica JAX-RS (JSR-339) che regola l'utilizzo di REST.

L'ultima release di JAX-RS è la 1.1 ma è in fase di approvazione la versione 2.0 che introduce miglioramenti, semplificazioni e nuove funzionalità.

La specifica 2.0 farà parte di Java EE 7 prevista per il Q2 2013

Dato l'imminente arrivo, in questo post vedremo come utilizzare REST 2.0.

Sebbene sia possibile utilizzare le API già messe a disposizione da JAX-RS, è preferibile avere il supporto di un framework in grado di semplificare e ridurre le operazioni di routine o di basso livello richieste da JAX-RS.

Uno di questi è Jersey che implementa le specifiche JAX-RS.
Oggi è già disponibile l'implementazione per la versione 2.0 (per chi volesse approfondire l'argomento qui si possono trovare i vari framework messi a confronto).

Jersey quindi ci consentirà di semplificare la realizzazione di un servizio REST.

A questo punto cosa devo fare per provare a realizzare un semplice servizio?

Ecco gli ingredienti:

Eclipse
Tomcat 7
JAX-RS 2.0 (rc3)

javax.ws.rs-api-2.0-rc3.jar
javax.ws.rs-api-2.0-SNAPSHOT.jar

Jersey 2.0 (rc1)

jersey-client-2.0-rc1.jar
jersey-common-2.0-rc1.jar
jersey-container-servlet-2.0-rc1.jar
jersey-container-servlet-core-2.0-rc1.jar
jersey-container-servlet-core-2.0-rc1.jar

Dipendenze (che trovate nella distribuzione di Jersey nella cartella ext)

asm-all-repackaged-2.1.78.jar
cglib-2.1.78.jar
guava-14.0.jar
hk2-api-2.1.78.jar
hk2-locator-2.1.78.jar
hk2-utils-2.1.78.jar
javax.annotation-api-1.2-b02.jar
javax.inject-1.jar
javax.inject-2.1.78.jar
osgi-resource-locator-1.0.1.jar
validation-api-1.1.0.CR3.jar

Utilizzeremo queste librerie per creare un client REST e un servizio REST che espone un semplice metodo.

Il client sarà una standard Java Application mentre il servizio sarà realizzato come Web Application (Dynamic Web Project di Eclipse).

Nel prossimo post, scopriremo insieme come con poche e semplici righe di codice è possibile esporre una funzionalità service-oriented basata su REST.

ClassCastException con oggetto in ClassLoader diversi

2013-05-02T09:00:00.000+02:00

DOMANDA:

Perchè ricevo un errore di ClassCastException se dalla mia webapp recupero lo stesso oggetto creato da un'altra webapp?

RISPOSTA:

Di solito questo errore si verifica quando stiamo utilizzando un oggetto in due class loader diversi. Ad esempio ho una webapp A che utilizza un oggetto X del jar X.jar presente nella sua WEB-INF/lib. Decido di recuperare l'oggetto X dalla webapp B che avrà anch'essa nella sua WEB-INF/lib il jar X.jar.

In questo caso è vero che l'oggetto X è lo stesso ma viene caricato sia nel class loader di A che in quello di B. Ciò comporta la generazione di un errore di ClassCastException quando si tenta di recuperare l'oggetto X da B.

Per ovviare facilmente a questo errore si potrebbe decidere di inserire il jar X.jar in un class loader condiviso tra le due webapp A e B (ad esempio il class loader dell'Application Server).

Una soluzione più elegante, che offre una serie di vantaggi e rispetta le tecniche di Design Pattern, è quella di inserire a livello di class loader condiviso, solo una interfaccia e demandare l'implementazione di tale interfaccia alle classi che saranno caricate dai diversi class loader.

Vediamo un esempio:

N.B.

Per provare l'esempio, abilitare il crossContext nel file context.xml presente nella cartella config di tomcat

<context crosscontext="true">

    ...

</context>

Definizione dell'interfaccia ICar contenuta nel jar Interfaces.jar

package interfaces;
public interface ICar {
 
 public void setNome(String nome);
 public String getNome();
 
 public void setModello(String modello);
 public String getModello();
 
}

Definizione della classe BMWCar (che implementa ICar) contenuta nel jar Pojo.jar

import interfaces.ICar;

public class BMWCar implements ICar{
 
 private String nome;
 private String modello;

 public void setNome(String nome) {
  this.nome=nome;
 }
 public String getNome(){
  return this.nome;
 }
 
 public void setModello(String modello){
  this.modello=modello;
 }
 
 public String getModello(){
  return this.modello;
 }

}

Servlet CreateCar della webapp A:

crea un oggetto bmw di tipo BMWCar utilizzando l'interfaccia ICar
memorizza l'oggetto bmw nell'Application Scope con chiave CAR

import java.io.IOException;
import java.io.PrintWriter;
import javax.servlet.ServletContext;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import interfaces.ICar;
import pojo.BMWCar;

@WebServlet("/CreateBMWCar")
public class CreateBMWCar extends HttpServlet {
 private static final long serialVersionUID = 1L;

 protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
  ServletContext sc = request.getServletContext();
  
  ICar bmw = new BMWCar();
  bmw.setModello("Serie 3");
  bmw.setNome("320d");
  
  sc.setAttribute("CAR", bmw);
  
  response.setContentType("text/plain");
  PrintWriter out = response.getWriter();
  out.write("Creata auto:\n");
  out.write("Nome: "+bmw.getNome() + "Modello: "+bmw.getModello() );
 }
}

Servlet ReadCar della WebApp B: recupera dall'Application Scope della webapp A l'auto creata:

import java.io.IOException;
import java.io.PrintWriter;
import javax.servlet.ServletContext;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import interfaces.ICar;

@WebServlet("/ReadCar")
public class ReadCar extends HttpServlet {
 protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
  
  ServletContext sc = request.getServletContext().getContext("/WebAppA");
  
  ICar car = (ICar) sc.getAttribute("CAR");
  
  response.setContentType("text/plain");
  PrintWriter out = response.getWriter();
  out.write("Auto recuperata:\n");
  out.write("Nome: "+car.getNome() + " Modello: "+car.getModello()+"" );
 }

}

Di seguito un'immagine per capire come e dove sono organizzate/definite le classi descritte

Rappresentare le Date in Java con Apache Commons DateFormatUtils

2013-04-17T09:00:00.000+02:00

DOMANDA:

Come posso personalizzare le date in Java?

RISPOSTA:

Dopo aver visto come utilizzare le date con il SimpleDateFormat, passiamo a vedere una possibile alternativa fornita da un package di Apache Commons contenente l'oggetto DateFormatUtils.

Per utilizzarlo è necessario scaricare commons-lang3-3.1.jar (versione testata in questo post).

Dopo aver settato il build path del progetto ed importato il jar appena scaricato, guardiamo nell'esempio come rappresentare le date in maniera semplice e veloce:

package date;

import java.util.Calendar;
import java.util.Date;

import org.apache.commons.lang3.time.DateFormatUtils;

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

     // utilizziamo DateFormatUtils con la data odierna
     String dataOdierna = DateFormatUtils.format((new java.util.Date()), "MM/dd"); 
     System.out.println("dataOdierna = " + dataOdierna); 

     // impostiamo la data a nostro piacimento
     Calendar cal = Calendar.getInstance();
     cal.set(2009, 11, 9); // il mese è zero based, quindi 0 = GENNAIO, 11 = DICEMBRE!!

     // utilizziamo DateFormatUtils con un oggetto Calendar
     String pattern = "dd-MM-yyyy hh:mm z"; 
     String dataPersonalizzata = DateFormatUtils.format(cal, pattern); 
     System.out.println("dataPersonalizzata1 = " + dataPersonalizzata); 

     // utilizziamo DateFormatUtils con un oggetto java.util.Date
     Date data = cal.getTime(); 
     dataPersonalizzata = DateFormatUtils.format(data, "dd/MM/yyyy HH:mm"); 
     System.out.println("dataPersonalizzata2 = " + dataPersonalizzata);
   }
}

L'output sarà il seguente:

dataOdierna = 04/15
dataPersonalizzata1 = 09-12-2009 09:12 CET
dataPersonalizzata2 = 09/12/2009 21:38

Possiamo personalizzare ulteriormente il pattern utilizzando la tabella di riferimento qui sotto:

Pattern - Tabella di riferimento

Per inserire del testo non interpretato come pattern è sufficiente metterlo tra singoli apici.

Per ulteriori approfondimenti consiglio una lettura alla documentazione ufficiale.

Rappresentare le Date in Java con SimpleDateFormat

2013-04-15T09:00:00.000+02:00

DOMANDA:

Come posso rappresentare le date in Java?

RISPOSTA:

Java ha una molteplicità di oggetti che gestiscono le date, qualcuno con un funzionamento intuitivo, altri meno. Un tentativo di semplificare la loro gestione è fornito dalla classe SimpleDateFormat (java.text.SimpleDateFormat).

Vediamo come funziona con il seguente esempio SimpleDateFormatTest:

package date;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Locale;

public class SimpleDateFormatTest {
  public static void main(String[] args) throws ParseException {
  
    SimpleDateFormat sdf = new SimpleDateFormat(); // creo l'oggetto
  
    // primo pattern: 2009, 12, 09
    sdf.applyPattern("yyyy, MM, dd");
    Date data = sdf.parse("2009, 12, 9");
    String dataStringa = sdf.format(data);
    System.out.println(dataStringa);  
        
    // modifico il pattern: 2009-12-09
    sdf.applyPattern("yyyy-MM-dd");
    dataStringa = sdf.format(data);
    System.out.println(dataStringa);  
        
    // settiamo il formato data (pattern) nel costruttore: 080413231216100
    sdf = new SimpleDateFormat("ddMMyyHHmmssSS");
    dataStringa = sdf.format(new Date()); // data corrente (8 aprile 2013)
    System.out.println(dataStringa);
  
    // pattern: 08-04-13-23.12.16100
    sdf.applyPattern("dd-MM-yy-HH:mm:ssSS");
    dataStringa = sdf.format(new Date());
    System.out.println(dataStringa); 
  
    // pattern: 08/04/2013
    sdf = new SimpleDateFormat("dd/MM/yyyy");
    dataStringa = sdf.format(new Date());
    System.out.println(dataStringa); 
  
    // settiamo la data in inglese: 01 June 1990
    data = sdf.parse("01/06/1990");
    Locale.setDefault(Locale.ENGLISH);
    sdf = new SimpleDateFormat("dd MMMM yyyy"); //necessario dichiarare un nuovo oggetto per applicare i settaggi di localizzazione
    dataStringa = sdf.format(data);
    System.out.println(dataStringa); 
  
    // e in italiano: 01 giugno 1990
    Locale.setDefault(Locale.ITALIAN);
    sdf = new SimpleDateFormat("dd MMMM yyyy"); 
    dataStringa = sdf.format(data);
    System.out.println(dataStringa); 
  }
}

Il codice è ricco di commenti auto-esplicativi, ma vediamo lo stesso l'output fornito dal programma:

2009, 12, 09
2009-12-09
080413233647979
08-04-13-23:36:47979
08/04/2013
01 June 1990
01 giugno 1990

Ecco una breve tabella riepilogativa su come comporre i pattern:

Tabella pattern SimpleDateFormat

Per inserire del testo non interpretato come pattern è sufficiente metterlo tra singoli apici.

NOTA: SimpleDateFormat non è ThreadSafe, quindi non è sincronizzato. La raccomandazione è quindi di creare ciascuna istanza SimpleDateFormat in Thread separati oppure di sincronizzarne esternamente l'accesso.

Un metodo alternativo a SimpleDateFormat può essere trovato qui.

Ordinamento HashMap basato su proprietà custom

2013-04-11T09:00:00.000+02:00

DOMANDA:

Come posso ordinare un HashMap basandomi su una proprietà degli oggetti che contiene?

RISPOSTA:

E' possibile eseguire un ordinamento di un HashMap basato su una proprietà dei suoi oggetti attraverso l'utilizzo di due elementi:

Comparator
TreeMap

Innanzitutto creiamo un bean per rappresentare gli elementi da ordinare in base ad una proprietà. Il bean sarà Tab e la proprietà position. Come avrete intuito, faremo l'ordinamento di una serie di tab come quelli che troviamo in quasi tutte le interfacce grafiche dei moderni siti web.

La nostra lista di tab (non ordinata) sarà la seguente:

Portfolio
Home
Contatti
Chi siamo

Da ordinare nel seguente modo:

Home
Chi siamo
Portfolio
Contatti

Innanzitutto creiamo il bean Tab:

public class Tab {
 
 private int position;

 public Tab(int position) {
  this.position=position;
 }

 public int getPosition() {
  return position;
 }

 public void setPosition(int position) {
  this.position = position;
 }
 
 @Override
 public String toString(){
  return "Tab in posizione "+position;
  
 }

}

Creiamo la classe PositionComparator che implementa Comparator e ci permette di definire i criteri di ordinamento (per approfondimenti vi rimando al post su Comparator):

class PositionComparator implements Comparator<String> {

 Map<String, Tab> unsortedMap;

 public PositionComparator(Map<String, Tab> unsortedMap) {
  this.unsortedMap = unsortedMap;
 }

 @Override
 public int compare(String a, String b) {
  if (unsortedMap.get(a).getPosition() < unsortedMap.get(b).getPosition()) {
   /* System.out.println(a +" e' prima di "+b);*/
   return -1;
  } else if (unsortedMap.get(a).getPosition() > unsortedMap.get(b)
    .getPosition()) {
   // System.out.println(a +" e' dopo di "+b);
   return 1;
  } else {
   return 0;
  }

 }
}

A questo punto non resta che creare la nostra applicazione Java che crea i tab in sequenza "casuale" per poi ordinarli attraverso il metodo sortTabs():

import java.util.Comparator;
import java.util.HashMap;
import java.util.Map;
import java.util.TreeMap;

public class SortMap {

 public static void main(String[] args) {
  Map<String, Tab> tabs = new HashMap<String, Tab>();
  tabs.put("Portfolio", new Tab(3));
  tabs.put("Home", new Tab(1));
  tabs.put("Contatti", new Tab(4));
  tabs.put("Chi siamo", new Tab(2));

  System.out.println("------------Map non ordinata-----------");
  System.out.println("unsorted map: " + tabs);
  for (String key : tabs.keySet()) {
   System.out.println("tab: " + tabs.get(key).getPosition());
  }
  System.out.println("-----------------------------------\n");

  //Ordinamento
  tabs = sortTabs(tabs);

  System.out.println("------------Map ordinata-----------");
  System.out.println("sorted map: " + tabs);
  for (String key : tabs.keySet()) {
   System.out.println("tab: " + tabs.get(key).getPosition());
  }
  System.out.println("-----------------------------------");
  
 }

 public static Map<String, Tab> sortTabs(Map<String, Tab> tabs) {

  PositionComparator pc = new PositionComparator(tabs);
  TreeMap<String, Tab> sorted_map = new TreeMap<String, Tab>(pc);

  sorted_map.putAll(tabs);

  return sorted_map;
 }
}

Notiamo come la Map iniziale (riga 9) utilizzi una HashMap mentre il metodo sortTabs() una TreeMap (riga 37). La differenza fondamentale tra le due strutture dati è che TreeMap memorizza gli elementi in un albero e consente di recuperarli in un ordine di default oppure definito da chi la usa (custom, come nel nostro caso).

Ricapitoliamo brevemente il flusso logico del codice per riuscire ad ordinare una Map preesistente:

Si associa la Map non ordinata al Comparator

Creo il PositionComparator fornendo in input la Map dei tab

Si crea una TreeMap associandole il Comparator

Istanzio una TreeMap fornendo in input il PositionComparator

La TreeMap creata viene popolata con la Map iniziale

sorted_map.putAll(tabs)

L'output dell'applicazione sarà il seguente:

------------Map non ordinata-----------
unsorted map: {Chi siamo=Tab in posizione 2, Home=Tab in posizione 1, Contatti=Tab in posizione 4, Portfolio=Tab in posizione 3}
tab: 2
tab: 1
tab: 4
tab: 3
-----------------------------------

------------Map ordinata-----------
sorted map: {Home=Tab in posizione 1, Chi siamo=Tab in posizione 2, Portfolio=Tab in posizione 3, Contatti=Tab in posizione 4}
tab: 1
tab: 2
tab: 3
tab: 4
-----------------------------------

Java Application per ridimensionamento immagine in proporzione

2013-04-09T09:00:00.000+02:00

DOMANDA:

Come posso ridimensionare un'immagine rispettando le sue proporzioni?

RISPOSTA:

Di seguito una breve guida per creare una piccola Java Application che visualizza un'immagine ridimensionata rispettando le sue proporzioni.
L'applicazione inoltre salva l'immagine su disco attraverso il metodo saveImage().

Il codice utilizza il metodo getScaledDimension() riportato su StackOverflow.

import java.awt.BorderLayout;
import java.awt.Dimension;
import java.awt.Graphics2D;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

import javax.imageio.ImageIO;
import javax.swing.ImageIcon;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.WindowConstants;

public class ImageResizeProportionally {

 public static void main(String[] args) {

  String path_immagine = "C:\\mia_immagine.jpg";

  BufferedImage srcImage;
  try {
   srcImage = ImageIO.read(new File(path_immagine));

   BufferedImage scaledImage = getScaledImage(srcImage);

   showImage(scaledImage);
 
   saveImage(scaledImage);
  } catch (Exception e) {
   e.printStackTrace();
  }

 }

 // Ridimensionamento 100x118
 private static BufferedImage getScaledImage(BufferedImage originalImage) {

  int MAX_IMG_WIDTH = 110;
  int MAX_IMG_HEIGHT = 118;

  int width = originalImage.getWidth();
  int height = originalImage.getHeight();

  Dimension originalDimension = new Dimension(originalImage.getWidth(),
    originalImage.getHeight());
  Dimension boundaryDimension = new Dimension(MAX_IMG_WIDTH,
    MAX_IMG_HEIGHT);
  Dimension scalingDimension = getScaledDimension(originalDimension,
    boundaryDimension);

  width = (int) scalingDimension.getWidth();
  height = (int) scalingDimension.getHeight();

  BufferedImage resizedImage = new BufferedImage(width, height,
    originalImage.getType());
  Graphics2D g = resizedImage.createGraphics();

  g.drawImage(originalImage, 0, 0, width, height, null);

  return resizedImage;

 }

public static Dimension getScaledDimension(Dimension imgSize, Dimension boundary) {

    int original_width = imgSize.width;
    int original_height = imgSize.height;
    int bound_width = boundary.width;
    int bound_height = boundary.height;
    int new_width = original_width;
    int new_height = original_height;

    // Controllo se e' necessario eseguire lo scaling
    if (original_width > bound_width) {
        //scaling della larghezza in base alla larghezza massima
        new_width = bound_width;
        //eseguo lo scaling dell'altezza per mantenere le proporzioni
        new_height = (new_width * original_height) / original_width;
    }

    // Dopo aver calcolato la nuova altezza, controllo se è ancora fuori limite
    if (new_height > bound_height) {
        
        new_height = bound_height;
        //rieseguo lo scaling per mantenere le proporzioni
        new_width = (new_height * original_width) / original_height;
    }

    return new Dimension(new_width, new_height);
}

 /**
  * Visualizzazione dell'immagine ridimensionata in un JFrame
  */
 private static void showImage(BufferedImage image) {

  JFrame editorFrame = new JFrame("Immagine ridimensionata");
  editorFrame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);

  ImageIcon imageIcon = new ImageIcon(image);

  JLabel jLabel = new JLabel();
  jLabel.setIcon(imageIcon);

  editorFrame.getContentPane().add(jLabel, BorderLayout.CENTER);

  editorFrame.pack();
  editorFrame.setLocationRelativeTo(null);
  editorFrame.setVisible(true);

 }

 private static void saveImage(BufferedImage scaledImage) throws FileNotFoundException, IOException {
  FileOutputStream file = new FileOutputStream("C:\\mia_immmagine_ridimensionata.jpg");
  ImageIO.write(scaledImage, "jpg", file);
  file.close();
 }
}

L'output sarà una finestra Java che mostrerà l'immagine ridimensionata e, grazie al metodo saveImage(), in C: avremo una copia in scala dell'originale mia_immagine.jpg.

Problemi sendRedirect con reverse proxy?

2013-04-03T09:00:00.000+02:00

DOMANDA:

Come posso evitare l'utilizzo di sendRedirect quando questa istruzione crea problemi in un ambiente con reverse proxy?

RISPOSTA:

Si può sostituire l'istruzione response.sendRedirect(url_path) impostando gli header della response HTTP.

Gli header da impostare sono:

Location
Status Code

il codice da utilizzare è il 302 - Moved Temporarily

Vediamo come:

import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;

public class SomeServlet extends HttpServlet {
  public void doGet(HttpServletRequest request,
                    HttpServletResponse response)
      throws ServletException, IOException {
      
    response.setStatus(HttpServletResponse.SC_MOVED_TEMPORARILY);
  
    response.setHeader("Location", "/mia_pagina.jsp");

  }
}

Creare PDF da un XML con Apache FOP 1.1

2012-12-19T09:00:00.000+01:00

DOMANDA:

Come si crea un PDF da un file XML?

RISPOSTA:

E' possibile creare un PDF a partire da un XML con Apache FOP 1.1, ultima versione attualmente disponibile. E' indispensabile sapere che per la trasformazione è necessario un file "intermedio" .xsl utilizzato come template (modello) in cui vengono conservate le informazioni di impaginazione.

Come al solito, guardiamo con degli esempi ad hoc ogni singolo step anche se, in questo post, si da per scontata una conoscenza basilare di xml ed xsl.

La seguente classe Xml2Pdf trasforma l'XML in PDF grazie alle informazioni contenute nel .xsl:

package fop;

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStream;

import javax.xml.transform.Result;
import javax.xml.transform.Source;
import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.sax.SAXResult;
import javax.xml.transform.stream.StreamSource;

import org.apache.fop.apps.FOUserAgent;
import org.apache.fop.apps.Fop;
import org.apache.fop.apps.FopFactory;
import org.apache.fop.apps.MimeConstants;

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

    File xmlIn = new File("C:\\rubrica.xml");
    File xslt = new File("C:\\rubrica.xsl");
    File pdfOut = new File("C:\\rubrica.pdf");

    // Setup output
    OutputStream out = new java.io.FileOutputStream(pdfOut);
    out = new java.io.BufferedOutputStream(out);

    try {
      FopFactory fopFactory = FopFactory.newInstance();
      FOUserAgent foUserAgent = fopFactory.newFOUserAgent();

      // Costruisco il fop con l'output desiderato
      Fop fop = fopFactory.newFop(MimeConstants.MIME_PDF, foUserAgent, out);

      // Setup XSLT
      TransformerFactory factory = TransformerFactory.newInstance();
      Transformer transformer = factory.newTransformer(new StreamSource(new InputStreamReader(new FileInputStream(xslt), "UTF-8")));
      transformer.setOutputProperty("encoding", "UTF-8"); // Setto l'encoding di output
      transformer.setParameter("versionParam", "2.0"); // Setto il valore di versionParam nello stylesheet

      Source src = new StreamSource(xmlIn); // Setup input per la trasformazione XSLT 

      Result res = new SAXResult(fop.getDefaultHandler());
   
      transformer.transform(src, res); // Inizio XSLT transformation XSLT e FOP processing

    } catch (Exception e) {
       e.printStackTrace(System.err);
       System.exit(-1);
    } finally {
       out.close();
    }
  }
}

Per il corretto funzionamento della classe è necessario scaricare ed aggiungere al classpath/buildpath alcune librerie Apache FOP versione 1.1 (10,5 MB). Il file .rar contiene tutti i jar necessari elencati di seguito:

fop.jar
avalon-framework-4.2.0.jar
batik-all-1.7.jar
commons-io-1.3.1.jar
commons-logging-1.0.4.jar
serializer-2.7.0.jar
xalan-2.7.0.jar
xercesImpl-2.7.1.jar
xml-apis-1.3.04.jar
xml-apis-ext-1.3.04.jar
xmlgraphics-commons-1.5.jar

Il file rubrica.xsl:

<?xml version="1.0" encoding="UTF-8"?>

<xsl:stylesheet version="1.1" xmlns:xsl="http://www.w3.org/1999/XSL/Transform" xmlns:fo="http://www.w3.org/1999/XSL/Format" exclude-result-prefixes="fo">
<xsl:output method="xml" version="1.0" omit-xml-declaration="no" indent="yes"/>
<xsl:param name="versionParam" select="'1.0'"/>

<!-- definizione di rubrica -->
<xsl:template match="rubrica">
  <fo:root xmlns:fo="http://www.w3.org/1999/XSL/Format">
    <fo:layout-master-set>
      <fo:simple-page-master master-name="simpleA4" page-height="29.7cm" page-width="21cm" margin-top="2cm" margin-bottom="2cm" margin-left="2cm" margin-right="2cm">
        <fo:region-body/>
      </fo:simple-page-master>
    </fo:layout-master-set>

    <fo:page-sequence master-reference="simpleA4">
      <fo:flow flow-name="xsl-region-body">
        <fo:block font-size="16pt" font-weight="bold" space-after="5mm">Titolo: <xsl:value-of select="titolo"/>
        </fo:block>
        <fo:block font-size="12pt" space-after="5mm">Version <xsl:value-of select="$versionParam"/>
        </fo:block>
        <fo:block font-size="10pt">
          <fo:table table-layout="fixed" width="100%" border-collapse="separate">
            <fo:table-column column-width="4cm"/>
            <fo:table-column column-width="4cm"/>
            <fo:table-column column-width="4cm"/>
            <fo:table-column column-width="5cm"/>
            <fo:table-body>
                <xsl:apply-templates select="persona"/>
            </fo:table-body>
          </fo:table>
        </fo:block>
      </fo:flow>
    </fo:page-sequence>
  </fo:root>
</xsl:template>

<!-- definizione dell'elemento PERSONA -->
<xsl:template match="persona">
  <fo:table-row>
    <xsl:if test="professione = 'blogger'">
      <xsl:attribute name="font-weight">bold</xsl:attribute>
    </xsl:if>
    <fo:table-cell>
      <fo:block>
        <xsl:value-of select="nome"/>
      </fo:block>
    </fo:table-cell>
    <fo:table-cell>
      <fo:block>
        <xsl:value-of select="telefono"/>
      </fo:block>
    </fo:table-cell>
    <fo:table-cell>
      <fo:block>
        <xsl:value-of select="professione"/>
      </fo:block>
    </fo:table-cell>
    <fo:table-cell>
      <fo:block>
        <xsl:value-of select="email"/>
      </fo:block>
    </fo:table-cell>
  </fo:table-row>
</xsl:template>

</xsl:stylesheet>

Ed infine il file rubrica.xml:

<?xml version="1.0" encoding="UTF-8"?>
<rubrica>
  <titolo>La mia rubrica</titolo>
  
  <persona>
    <nome>Pippo</nome>
    <telefono>06123456789</telefono>
    <professione>programmatore</professione>
    <email>pippo@unemail.it</email>
  </persona>

  <persona>
    <nome>Fabrizio</nome>
    <telefono>0655555555</telefono> 
    <professione>blogger</professione>
    <email>fabrizio@unemail.it</email>
  </persona>

  <persona>
    <nome>Pluto</nome>
    <telefono>0644444444</telefono>
    <professione>programmatore</professione>
    <email>pluto@unemail.it</email>
  </persona>

  <persona>
    <nome>Paperino</nome>
    <telefono>0633333333</telefono>
    <professione>giornalista</professione>
    <email>paperino@unemail.it</email>
  </persona>

  <persona>
    <nome>Clarabella</nome>
    <telefono>0622222222</telefono>
    <professione>disoccupato</professione>
    <email>clarabella@unemail.it</email>
  </persona>

</rubrica>

Posizionate il file rubrica.xml e rubrica.xsl in C:\ e lanciate la classe Xml2Pdf. Il risultato sarà un file rubrica.pdf con i dati contenuti nel file .xml impaginato secondo i criteri del file .xsl.

Differenza tra JRE e JDK

2012-12-12T09:00:00.000+01:00

DOMANDA:

Che differenza c'è tra Java Runtime Environment (JRE) e Java Development Kit (JDK)?

RISPOSTA:

Se la vostra esigenza è quella di eseguire delle applicazioni Java, è sufficiente la JRE. Infatti Java Runtime Enviroment è un'implementazione della Java Virtual Machine (JVM) necessaria per far girare i programmi Java sul vostro calcolatore. E' quindi necessaria la JRE per eseguire ad esempio Eclipse, le applet, Tomcat, ecc...

La JDK invece è indispensabile nel caso voi abbiate la necessità di sviluppare software Java. Infatti la JDK contiene al suo interno una o più JRE e tutti gli applicativi utili per la programmazione in Java: debuggers, compilatori come javac, librerie per lo sviluppo, ecc...

Sono entrambe gratuite e scaricabili dal sito ufficiale Oracle Java.

NOTA: per Eclipse è sufficiente la JRE perché al suo interno contiene già il compilatore, le librerie e i tools necessari al programmatore.

Codifica e decodifica di un'immagine in Base64

2012-11-26T09:00:00.000+01:00

DOMANDA:

Come si effettua la codifica in Base64 di un'immagine in Java?

RISPOSTA:

Differentemente da quanto visto per la codifica Base64 delle stringhe, per le immagini abbiamo alcune varianti dovute soprattutto alla conversione della stessa in un array di byte.

Scarichiamo la classe Base64 di Apache Commons contenuta nel pacchetto commons-codec-1.2.jar.

Il codice nell'esempio mostra come convertire in Base64 un'immagine JPG, ma è adattabile anche ad altri formati:

package base64;

import java.awt.image.BufferedImage;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.IOException;
import javax.imageio.ImageIO;

import org.apache.commons.codec.binary.Base64;

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

    BufferedImage immagine = ImageIO.read(new File("C:\\immagine.jpg"));
    ByteArrayOutputStream byteArrOS = new ByteArrayOutputStream();
    ImageIO.write(immagine, "jpg", byteArrOS);

    // ENCODING
    byte[] encoded = Base64.encodeBase64(byteArrOS.toByteArray());

    System.out.println("Base64 Encoded String : " + new String(encoded));

    // DECODING
    byte[] decoded = Base64.decodeBase64(encoded); 
    System.out.println("Base 64 Decoded  String : " + new String(decoded));
  }
}

L'output (con omissis data la lunghezza eccessiva della stringa):

Codificata Base64: /9j/4AAQSkZJRgABAgAAAQABAAD/2wBDAAgGBgcGBQgHBwcJCQgKDBQNDAsLDBkSEw8UHRofHh0aHBwgJ
[...]
L24/56n8hTlvLlj/AK9x9DiiipbZahHsPS4umP8Ax+XI+khFRG8uiObq4P1lb/GiipuzTkj2JBJMTzcTH6uaiMCM2WyT7miipTKSQnlovRRUN1M1uPkC/iM0UUobmj0izLlnlmYs7kmoaKK60fP1viEoyaKKoxFFKKKKlgOBNSp0oopAiDUmIt0UHhm5qhH0FFFar4QZoQ/cH+e1ODFbBsdhx+QooqBosXCiO1kVRgYH866fwxhdUt8KP9cvb3oorGr8JpT+JHpuTSZJoorhO8bTTRRVALRRRQI//9k=

Decodificata Base64:
[...]

Come è possibile vedere dal risultato dell'output, la prima stringa è la codifica Base64 dell'immagine immagine.jpg presente in C:, la seconda è l'immagine decodificata (in pratica il risultato equivalente all'apertura dell'immagine con il blocco note).

Codifica e decodifica di una stringa in Base64

2012-11-22T09:00:00.000+01:00

DOMANDA:

Come si converte una stringa in Base64 con Java?

RISPOSTA:

In Java esiste una classe chiamata Base64 della libreria Apache Commons che permette in pochi passi di convertire una stringa in Base64.

Scarichiamo quindi il pacchetto commons-codec-1.2.jar ed importiamolo nel nostro progetto.

Una volta effettuate correttamente queste operazioni, guardiamo l'esempio che effettua codifica e decodifica:

package base64;

import org.apache.commons.codec.binary.Base64;

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

    String daConvertire = "Stringa originale";

    // CODIFICA BASE64
    byte[] encoded = Base64.encodeBase64(daConvertire.getBytes()); 
    System.out.println("Stringa da convertire: " + daConvertire );
    System.out.println("Base64: " + new String(encoded));

    // DECODIFICA BASE64
    byte[] decoded = Base64.decodeBase64(encoded); 
    System.out.println("Stringa decodificata : " + new String(decoded));
  }
}

L'output:

Stringa da convertire: Stringa originale
Base64: U3RyaW5nYSBvcmlnaW5hbGU=
Stringa decodificata : Stringa originale

Per la codifica Base64 delle immagini consiglio la lettura di questo post.

Comprimere e convertire immagini in JPG

2012-11-21T09:00:00.000+01:00

DOMANDA:

Come convertire un'immagine in JPG in Java?

RISPOSTA:

Java mette a disposizione diversi oggetti che permettono la conversione di un'immagine in JPG/JPEG e anche la regolazione della compressione (e quindi della qualità).

Guardiamo l'esempio TestCompressione, opportunamente commentato per capire tutti i passaggi da intraprendere:

package immagini;

import java.awt.image.*;
import java.io.*;
import java.util.Iterator;

import javax.imageio.*;
import javax.imageio.stream.FileImageOutputStream;

import javax.swing.JFileChooser;

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

    BufferedImage immagine = null;

    // Seleziono il file con finestra di dialogo
    JFileChooser fileScelto = new JFileChooser("C:\\");

    int selezione = fileScelto.showDialog(null, "Seleziona il file da aprire");
    if(selezione == JFileChooser.APPROVE_OPTION)
       immagine = ImageIO.read(fileScelto.getSelectedFile());

    System.out.println("Il file selezionato è: "+fileScelto.getSelectedFile());

    System.out.println("Inizio procedure compressione");
    // recupero gli ImageWriters che possono convertire in jpeg
    Iterator<ImageWriter> it = ImageIO.getImageWritersByFormatName("jpg");
    ImageWriter jpgWriter = it.next(); // prendo il primo disponibile
    ImageWriteParam parametri = jpgWriter.getDefaultWriteParam();
    parametri.setCompressionMode(ImageWriteParam.MODE_EXPLICIT);
    parametri.setCompressionQuality(0.7f); // Imposto la qualità di compressione a 0.7 (0 massima compressione)

    // scrivo in output l'immagine risultante
    FileImageOutputStream out = new FileImageOutputStream(new File("C:\\imgCompressa.jpg"));
    jpgWriter.setOutput(out);
    jpgWriter.write(null, new IIOImage(immagine, null, null), parametri);
    jpgWriter.dispose();
    out.close();

    System.out.println("Fine procedure compressione, il file è stato creato");
  }
}

L'output sarà molto semplice:

Il file selezionato è: C:\immagine.bmp
Inizio procedure compressione
Fine procedure compressione, il file è stato creato

E ovviamente in C:\ sarà generato il file imgCompressa.jpg.

Java mette a disposizione diversi ImageWriters (non solo JPG) come ad esempio BMP, PNG e GIF.

Per ulteriori informazioni a riguardo rimando alla documentazione ufficiale.

Per approfondimenti sul funzionamento e sull'utilizzo del JFileChooser vi consiglio la lettura di questo post.

Differenza tra equals() ed ==

2012-11-19T09:00:00.000+01:00

DOMANDA:

Che differenza c'è tra il metodo equals() e ==?

RISPOSTA:

Utilizzare il metodo equals(Object o) ereditato da Object() o utilizzare l'operatore di confronto == è estremamente differente.

METODO equals()

Utilizzando questo metodo stiamo confrontando due oggetti secondo dei criteri di uguaglianza di contenuto, cioè potremmo confrontare una persona con un'altra persona, un animale con un altro animale e così via. Il metodo equals() permette infatti, con opportune personalizzazioni, di selezionare quali sono i criteri di confronto. Così potremo decidere se una persona è uguale ad un'altra se hanno nome e cognome uguali, oppure nome, cognome e data di nascita, ecc... ecc...

OPERATORE ==

Questo operatore di confronto valuta l'uguaglianza sostanziale, ovvero se l'oggetto, il riferimento o il tipo di dato primitivo a sinistra è effettivamente lo stesso di quello a destra. Quindi risulterà vero soltanto quando i riferimenti di memoria coincideranno.

Vediamo la differenza con un esempio pratico in Java usando una classe Coordinate che ha come attributi soltanto i due interi x e y:

Classe Coordinate:

package equals;

public class Coordinate {

  private int x;
  private int y;

  public Coordinate(int x, int y){
    this.x = x;
    this.y = y;
  }

  public int getX() {
    return x;
  }

  public int getY() {
    return y;
  }

  @Override
  public boolean equals(Object coordinate){
    Coordinate c = (Coordinate) coordinate;
    return (this.x == c.getX()) && (this.y == c.getY()); // restituisco vero solo se sia la x che la y coincidono
  }
}

Classe di Test:

package equals;

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

    Coordinate c1 = new Coordinate(13, 15);
    Coordinate c2 = new Coordinate(16, 17);
    Coordinate c3 = new Coordinate(13, 15);
    Coordinate c4 = c1;

    System.out.println("CONFRONTO 1: c1(13,15) - c2(16,17)");
    System.out.println("c1 == c2? " + (c1 == c2));
    System.out.println("c1.equals(c2)? " + c1.equals(c2));
    System.out.println();

    System.out.println("CONFRONTO 2: c1(13,15) - c3(13,15)");
    System.out.println("c1 == c3? " + (c1 == c3));
    System.out.println("c1.equals(c3)? " + c1.equals(c3));
    System.out.println();

    System.out.println("CONFRONTO 3: c4 -> c1(13,15)");
    System.out.println("c1 == c4? " + (c1 == c4));
    System.out.println("c1.equals(c4)? " + c1.equals(c4));
  }
}

Infine l'output:

CONFRONTO 1: c1(13,15) - c2(16,17)
c1 == c2? false
c1.equals(c2)? false

CONFRONTO 2: c1(13,15) - c3(13,15)
c1 == c3? false
c1.equals(c3)? true

CONFRONTO 3: c4 -> c1(13,15)
c1 == c4? true
c1.equals(c4)? true

Commentiamo brevemente i risultati associando un'immagine esplicativa:

CONFRONTO 1 - c1 == c2 è false perché ho due oggetti che risiedono in locazioni di memoria differenti. Il confronto con equals() è altrettanto falso perché il test dei contenuti tra la x e la y è effettivamente diverso.

CONFRONTO 1: c1 == c2 FALSE - c1.equals(c2) FALSE

CONFRONTO 2 - c1 == c3 è false nonostante i valori delle coordinate siano uguali. Questo perché, come già detto, == confronta i riferimenti di memoria che risultano, quindi, differenti. Il secondo invece, dato che confronta i valori delle coordinate x e y, restituisce true.

CONFRONTO 2: c1 == c3 FALSE - c1.equals(c3) TRUE

CONFRONTO 3 - In questo caso abbiamo entrambi i confronti true perché il riferimento in memoria è lo stesso (c4 punta alla locazione di memoria c1) e di conseguenza anche i valori confrontati sono uguali.

CONFRONTO 3: c1 == c4 TRUE - c1.equals(c4) TRUE

Rappresentare numeri grandissimi

2012-11-15T09:00:00.000+01:00

DOMANDA:

E' possibile rappresentare in Java dei numeri grandissimi che hanno un valore oltre quello consentito dai tipi di dati primitivi long e int?

RISPOSTA:

Come abbiamo visto nel post sul range di valori rappresentabili con i diversi tipi di dati primitivi, effettuare un'operazione il cui risultato vada oltre tale limite comporta un errore di calcolo con conseguenze potenzialmente disastrose.

La soluzione a tali limitazioni esiste: la prima, più complessa, rientra nell'analisi numerica e in algoritmi di troncamento, arrotondamento e bit shifting, ma non è scopo di questo post.

La seconda invece è messa a disposizione da Java con le classi java.math.BigInteger e java.math.BigDecimal (rispettivamente per i numeri interi e decimali).

Guardiamo con un esempio come funzionano:

package bignumbers;

import java.math.BigInteger;

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

    // rappresentazione errata oltre i limiti
    long primo = 9999999999999L;
    long secondo = 9999999999999L;
    long risultato = primo * secondo;
    System.out.println("Risultato primo * secondo = " + risultato);

    // rappresentazione corretta
    BigInteger bigPrimo = new BigInteger("9999999999999");
    BigInteger bigSecondo = new BigInteger("9999999999999");
    BigInteger bigRisultato = bigPrimo.multiply(bigSecondo); 
    System.out.println("Risultato bigPrimo * bigSecondo = " + bigRisultato);
  }
}

L'output sarà:

Risultato primo * secondo = -2537784290115403775
Risultato bigPrimo * bigSecondo = 99999999999980000000000001

Come si può vedere, nel primo caso abbiamo avuto un risultato errato dovuto al superamento dei limiti rappresentabili dal tipo di dato long. Nel secondo, gli algoritmi della classe BigInteger ci hanno permesso di superare il range rappresentabile e stampare il risultato corretto.

La classe BigInteger, così come la classe BigDecimal, non ha limiti ben definiti come i tipi di dati primitivi, ma dipende dalla dotazione hardware del calcolatore.

Queste classi forniscono anche altri metodi per effettuare le diverse operazioni aritmetiche e anche quelle logiche (come ad esempio il confronto). Per ulteriori approfondimenti vi rimando alla documentazione ufficiale.

Stampare un file su carta

2012-11-13T09:37:00.000+01:00

DOMANDA:

Come si manda in stampa un file in Java?

RISPOSTA:

Ci sono diversi modi per stampare un file su carta direttamente da Java. Vediamo quello più veloce ed immediato grazie alla classe java.awt.Desktop introdotta a partire da Java 6:

package stampa;

import java.awt.Desktop;
import java.io.File;
import java.io.IOException;

import javax.print.PrintException;

public class StampaFile {
  public static void main(String[] args) throws PrintException, IOException {

    if(!java.awt.Desktop.isDesktopSupported()) {
      System.out.println("Funzione non supportata!");
      return;
    }

    try {
      Desktop desk = java.awt.Desktop.getDesktop();

      // mando in stampa il file
      desk.print(new File("C:\\prova.pdf"));

    } catch (NullPointerException | IllegalArgumentException | UnsupportedOperationException |
             IOException | SecurityException ex) {
      ex.printStackTrace();
    }
  }
}

Eseguendo questa classe invierete direttamente il file alla stampante senza dover confermare nulla, nemmeno nella finestra di dialogo.

E' importante precisare che tale metodo di stampa è estremamente semplice perché demanda tutto al gestore predefinito del file del Sistema Operativo. Nel nostro caso, se non avessimo un gestore per i file PDF (come ad esempio Adobe Reader) riceveremmo un'eccezione. Stesso dicasi per la stampante: è necessario averne impostata una predefinita.

Un'ulteriore limitazione di questo metodo è l'impossibilità di gestire e regolare le diverse impostazioni di stampa.

Annotations: @Override

2012-11-09T09:05:00.000+01:00

DOMANDA:

Perché si utilizza l'annotazione @Override? A cosa serve e quali sono i vantaggi?

RISPOSTA:

@Override è una annotazione aggiunta a partire da Java 5 ed utilizzata per indicare al compilatore che il metodo su cui è posta sta effettuando un override (sovrascrittura) di un metodo della sua superclasse o, da Java 6, anche di un'interfaccia.

La domanda nasce spontanea: "cosa cambia se non lo utilizzo?". Proviamo a fare un override sul metodo equals() della superclasse Object:

public class Animale{
  private String nome;

  public boolean equals(Animale animale){
    return nome.equals(animale.nome);
  }
}

Come si nota non abbiamo utilizzato @Override... e infatti non stiamo effettuando un override, bensì un overloading! Sicuramente la maggior parte di voi non avrà fatto caso all'errore. Il metodo equals() ereditato della classe Object accetta come parametro un Object (non un Animale), di conseguenza il compilatore riconoscerà il metodo equals() della classe Animale() come un metodo aggiuntivo e non come uno che sovrascrive l'originale.

La risposta è quindi facile: @Override nasce per soddisfare esigenze di pratiche di buona programmazione e facilitare il programmatore nel prevenire errori di difficile individuazione (come nel caso dell'esempio).

Inserendo @Override nella classe Animale otterremmo infatti un errore:

public class Animale{
  private String nome;
  
  @Override
  public boolean equals(Animale animale){
    return nome.equals(animale.nome);
  }
}

Il compilatore non ci permetterà di creare il .class fornendo a video il seguente messaggio:

The method equals(Animale) of type Animale must override or implement a supertype method

Invece, se utilizzassimo correttamente @Override potremmo compilare la classe Animale correttamente:

package override;

public class Animale{
  private String nome;

  @Override
  public boolean equals(Object animale){
    return nome.equals(((Animale) animale).nome);
  }
}

Java Reflection: accesso a metodi e campi privati

2012-10-29T09:00:00.000+01:00

DOMANDA:

Come si può accedere da un classe generica ai metodi e alle variabili di istanza private di un'altra classe?

RISPOSTA:

Genericamente non è possibile accedere ai campi o metodi privati di un'altra classe. Ma genericamente non vuol dire in modo assoluto! Infatti, grazie alla Reflection Java possiamo accedere ai campi privati di un'altra classe.

Analizziamo alcuni metodi che ci mette a disposizione la classe java.lang.Class:

getFields(): permette di recuperare la lista di tutti i campi pubblici della classe e della sua superclasse;
getDeclaredFields(): fornisce la lista di tutti i campi presenti nella classe (senza distinzione di visibilità);
getDeclaredMethods(): come sopra ma applicato ai metodi;
getDeclaredField(String nome): restituisce il Field indicato come parametro (senza distinzione di visibilità);
getDeclaredMethos(String nome): restituisce il Method indicato come parametro (senza distinzione di visibilità).

Guardiamo l'esempio, prima con la ClassePrivata da analizzare:

package reflection;

public class ClassePrivata {
  public int publicValue = 99999;
  protected int protectedValue = 200;
  int packageProtectedValue = 10000;
  private int secretValue = 12345;

  public String getPublicValue(){
     return "Il valore pubblico è: " +publicValue;
  }

  protected String getProtectedValue(){
     return "Il valore protected è: " +protectedValue;
  }

  String getPackageProtectedValue(){
     return "Il valore packageProtected è: "+packageProtectedValue;
  }

  private String getSecretValue(){
     return "Il valore segreto è: " +secretValue;
  }
}

E poi con la classe analizzatrice ElencoCampiMetodi:

package reflection;

import java.util.Arrays;

public class ElencoCampiMetodi {
  public static void main(String args[]) throws ClassNotFoundException {

    Class<ClassePrivata> pvtClass = 
         (Class<ClassePrivata>) Class.forName("reflection.ClassePrivata");

    //getFields() non restituisce i campi privati
    System.out.println("Fields: " + 
                   Arrays.toString(pvtClass.getFields()));

    //getDeclaredFields() restituisce sia i campi privati che non
    System.out.println("Declared Fields: " +
                   Arrays.toString(pvtClass.getDeclaredFields()));    

    //getDeclaredMethods() restituisce sia i metodi privati che non
    System.out.println("Declared methods: " +
                   Arrays.toString(pvtClass.getDeclaredMethods()));
  }
}

L'output, come previsto, sarà:

Fields: [public int reflection.ClassePrivata.publicValue]
Declared Fields: [public int reflection.ClassePrivata.publicValue, int reflection.ClassePrivata.packageProtectedValue, private int reflection.ClassePrivata.secretValue]
Declared methods: [private java.lang.String reflection.ClassePrivata.getSecretValue(), public java.lang.String reflection.ClassePrivata.getPublicValue()]

Passiamo ora al recupero vero e proprio del valore di un campo privato e all'esecuzione di un metodo privato:

public class PrivateAccessTest {
  public static void main(String args[]) throws ClassNotFoundException {

    Class<ClassePrivata> pvtClass = 
         (Class<ClassePrivata>) Class.forName("reflection.ClassePrivata");

    try {
      ClassePrivata myClassPvt = new ClassePrivata();

      // recupero il campo privato e lo rendo accessibile
      Field campoPrivato = pvtClass.getDeclaredField("secretValue");
      campoPrivato.setAccessible(true);

      // recupero il valore del campo privato
      int valore =  campoPrivato.getInt(myClassPvt);   

      // stampo il campo privato e il suo valore
      System.out.println("Campo Privato: " + campoPrivato);
      System.out.println("Valore campo privato: " + valore);

      // recupero il metodo privato e lo rendo accessibile
      Method metodoPrivato = pvtClass.getDeclaredMethod("getSecretValue");
      metodoPrivato.setAccessible(true);

      // recupero il valore di ritorno del metodo privato
      String result = (String) metodoPrivato.invoke(myClassPvt);
      System.out.println(result);

    } catch (IllegalAccessException | IllegalArgumentException
           | InvocationTargetException | NoSuchFieldException
           | SecurityException | NoSuchMethodException e) {
      e.printStackTrace();
    }
  }
}

L'output anche in questo caso ci darà conferma del risultato voluto:

Campo Privato: private int reflection.ClassePrivata.secretValue
Valore campo privato: 12345
Il valore segreto è: 12345

NOTA: per accedere ad un campo o metodo privato dobbiamo renderlo accessibile grazie al metodo setAccessible(true). Se non lo facessimo, appena tentiamo l'accesso al campo o al metodo ci ritroveremo un'eccezione di questo tipo:

java.lang.IllegalAccessException:
Class reflection.PrivateAccessTest can not access a member of class reflection.ClassePrivata with modifiers "private"

NOTA FINALE: il codice utilizza il multicatch introdotto da Java 7. Se state utilizzando una versione precedente di Java dovete sostituirlo con il catch alla vecchia maniera! Per ulteriori informazioni sul multicatch vi invito a leggere questo post.

Java 7: Multicatch

2012-10-22T09:00:00.000+02:00

DOMANDA:

In un try/catch c'è modo di scrivere più eccezioni nello stesso catch evitando così codice ridondante nel caso di stesso comportamento?

RISPOSTA:

Fino a Java 6 succede una cosa alquanto scomoda nell'utilizzo del try/catch: quando ci troviamo di fronte ad un codice che ha lo stesso comportamento con diverse eccezioni, siamo costretti a dover ripetere lo stesso codice più volte dentro diversi catch.

Guardiamo nel dettaglio un esempio in cui posso avere due eccezioni a runtime: una NumberFormatException qualora inserisca in input un formato non compatibile con la conversione in int (ad esempio delle lettere), oppure una ArithmeticException qualora inserisca un numero non compreso nell'intervallo 0 e 5 (estremi esclusi):

package multicatch;

import java.util.Scanner;

public class OldCatch {
  public static void main(String args[]) {
    try {
      Scanner scanner = new Scanner(System.in);
      String number = scanner.next();
      scanner.close();
      
      int num = Integer.parseInt(number);
    
      if (num < 0 || num > 5)
        throw new ArithmeticException();
 
    } catch (NumberFormatException e) {
      e.printStackTrace();
    } catch (ArithmeticException e) {
      e.printStackTrace();
    }
  }
}

Per risolvere la ridondanza possiamo utilizzare uno stratagemma di questo tipo:

package multicatch;

import java.util.Scanner;

public class OldCatchAdvanced {
  public static void main(String args[]) {
    try {
      Scanner scanner = new Scanner(System.in);
      String number = scanner.next();
      scanner.close();

      int num = Integer.parseInt(number);

      if (num < 0 || num > 5)
        throw new ArithmeticException();

    } catch (Exception e) {
      if((e instanceof NumberFormatException) || (e instanceof ArithmeticException))
        e.printStackTrace();
      else
        throw new RuntimeException(e);
    }
  }
}

NOTA: Personalmente trovo questo stratagemma abbastanza "sporco" e ne sconsiglio l'utilizzo.

JAVA 7

Per fortuna, le problematiche dei programmatori Java non restano inascoltate e da Java 7 in poi è stato introdotto il multicatch.

Guardiamo come possiamo riscrivere il codice di sopra:

package multicatch;

import java.util.Scanner;

public class MultiCatch {
  public static void main(String args[]) {
    try {
      Scanner scanner = new Scanner(System.in);
      String number = scanner.next();
      scanner.close();

      int num = Integer.parseInt(number);
      
      if (num < 0 || num > 5)
        throw new ArithmeticException();

    } catch (NumberFormatException | ArithmeticException e) {
      e.printStackTrace();
    }
  }
}

Come è facile capire dall'esempio, qualora avessimo più eccezioni che scatenano comportamenti simili, basterà dividerle con un | (OR bit a bit), risolvendo così i problemi di ridondanza di codice. Negli esempi abbiamo utilizzato solo due eccezioni ma è possibile concatenarne quante vogliamo.

Creare una finestra di scelta file con JFileChooser

2012-10-17T09:00:00.000+02:00

DOMANDA:

Come si fa a visualizzare una finestra per la scelta di un file in Java?

RISPOSTA:

Java mette a disposizione la classe javax.swing.JFileChooser che permette di aprire con poche righe di codice una finestra di selezione (Dialog) per i file.

Guardiamo l'esempio con la classe FileDialog:

package file;

import java.io.File;

import javax.swing.JFileChooser;
import javax.swing.filechooser.FileFilter;
import javax.swing.filechooser.FileNameExtensionFilter;

public class FileDialog {
  public static void main(String[] args) {
    
    // impostazione della directory di partenza
    JFileChooser fileScelto = new JFileChooser("C:\\");
    
    // creazione di due filtri
    FileFilter filtroJpg = new FileNameExtensionFilter("JPEG file", "jpg", "jpeg");
    FileFilter filtroTxt = new FileNameExtensionFilter("TXT file", "txt");
    
    // inserisco nella scelta del tipo di file un filtro TXT
    fileScelto.addChoosableFileFilter(filtroTxt);
    // di default filtro solo i file Jpg (lo aggiunge in automatico alla combo sottostante)
    fileScelto.setFileFilter(filtroJpg);
    // imposto di default il nome del file da cercare
    fileScelto.setSelectedFile(new File("immagine.jpg"));

    int selezione = fileScelto.showDialog(null, "Seleziona il file da aprire");
    if(selezione == JFileChooser.APPROVE_OPTION)
      System.out.println(fileScelto.getSelectedFile());
  }
}

Quindi eseguendo l'esempio ci aspettiamo l'apertura di una finestra di questo tipo:

JFileChooser - All'apertura

...e nella select "Tipo File" i filtri personalizzati.

JFileChooser - Combo di selezione Tipo File (Filtri)

Ora che abbiamo visto l'effetto grafico, anche se i commenti all'interno del codice chiarificano già lo scopo delle singole righe, analizziamo brevemente qualche istruzione.

Creando i filtri (javax.swing.filechooser.FileFilter) possiamo scremare la scelta del tipo di file a seconda delle nostre esigenze. Nell'esempio abbiamo creato un filtro per i file Jpeg e uno per i Txt. Il primo parametro ("JPEG file") è una semplice stringa che fornisce un'etichetta (visibile nella select Tipo file) associata agli effettivi filtri. Gli altri parametri (variabili da 1 a n) identificano le estensioni dei file da filtrare (nel nostro caso .jpg e .jpeg).

Il metodo addChoosableFileFilter(), applicato sul FileChooser, aggiunge nella select dei tipi di file il filtro passato come parametro (nell'esempio filtroTxt con etichetta TXT file e associazione con le estensioni .txt).

Invece con il metodo setFileFilter(), applicato sempre al FileChooser, stiamo impostando, all'apertura della finestra, un filtro di default sui file. Da notare che setFileFilter() in automatico aggiunge una voce alla select dei tipi di file.

Infine setSelectedFile() imposta, sempre all'apertura, il nome del file che ci aspettiamo di aprire (nel nostro caso immagine.jpg).

Per ulteriori personalizzazioni ed approfondimenti vi rimando alla relativa pagina della documentazione di JFileChooser