In questo articolo vi mostrerò una semplice tecnica che evidenzia un concetto molto potente della programmazione, ovvero la possibilità di poter creare un DSL (Domain Specific Language). Un DSL ci permette di scrivere codice pulito e di poter impostare la scrittura del codice di dominio in modo semplice e funzionale. Nella programmazione orientata agli oggetti tale concetto è applicabile utilizzando insieme diversi design-pattern e interfacce di tipo "Fluent". Per semplicità immaginiamo di sviluppare per il dominio automobili e di dover rappresentare una "preview" di un'auto. La cosa che ci viene immediato fare è creare il bean Car con le sue proprietà.....

// imports...

public class Car {

   private String brand;
   private String engineType;
   private int passengerCount = 2;

   // getters and setters for each field
} 

...ogni volta che abbiamo bisogno di creare un oggetto Car ci viene naturale istanziare e impostare le proprietà dell'oggetto in questo modo...

Car car = new Car();
car.setColor(RED);
car.EngineType("DIESEL");
car.setBrand("Fiat"); 

Un DSL (nell'esempio specifico un Internal DSL) ci permette di evitare di scrivere codice in OO style e di immaginare la scrittura di codice in maniera più funzionale. Per creare un DSL bisogna innanzitutto stabilire quale aspetto del dominio vogliamo rendere funzionale e quali funzioni vogliamo dare, l'insieme delle funzioni sarà il nostro DSL.
Nel nostro caso ci piacerebbe avere un DSL per la creazione di automobili del tipo:

/*creaAuto().diColoreRosso().adAlimentazioneDiesel().con4Posti() */

che dal punto di vista funzionale diventa:

/* automobile = crea()
                      .automobile()
                      .colore("rosso")
                      .alimentazione(benzina)
                      .posti(4);
*/

Per ottenere lo stesso effetto in Java abbiamo bisogno di un oggetto intermedio che ci permette di creare oggetti di tipo Car e di esporre i metodi di facciata per la modalità di creazione e impostazione delle proprietà, ad esempio la classe CarBuilder scritta in questo modo, può fare al caso nostro:

public class CarBuilder {

   public static Car newCar() {
     return new CarBuilder();
   }

   private final Car car;

   private CarBuilder() {
     car = new Car ();
   }

   public Car build() { return car; }

   public CarBuilder brand(String brand) {
     car.setBrand(brand);
     return this;
   }

   public CarBuilder engineType(String engineType) {
     car.setEngineType(engineType);
     return this;
   }

   public CarBuilder passengers(int passengers) {
     car.setPassengerCount (passengers);
     return this;
   }
} 

A questo punto creare oggetti di tipo Car diventa veramente semplice, ma l'aspetto davvero importante è che abbiamo creato un vero e proprio linguaggio funzionale alla creazione di oggetti Car.

Car car = CarBuilder.newCar()
                     .brand("Fiat")
                     .color(RED)
                     .engineType("DIESEL")
                     .passengerCount(4)
                     .build();

L'esempio è davvero banale ma esprime concetti davvero potenti. Inoltre con Java8 risulta ancora più semplice applicare concetti di questo tipo.
La cosa importante è capire che possiamo sfruttare in un solo colpo due tipi di linguaggi quello Java che ci garantisce il mantenimento di informazioni strutturali e il controllo sui tipi evitando di fare casini e quello funzionale (il DSL) che ci permette di by-passare il compilatore quando ad esempio desideriamo semplicemente creare "un auto solo di colore rosso " oppure un "auto modello Fiat" :)



  • submit to reddit
blog comments powered by Disqus