Guida a Spring Expression con Spring Boot
Una guida per imparare ad utilizzare il linguaggio di programmazione Spring Expression con annotazione @value.

Il linguaggio Spring Expression (conosciuto anche come SpEL) è un potente linguaggio di “espressioni”, che può essere utilizzato per eseguire query e manipolare un grafo di oggetti in fase di esecuzione. SpEL è disponibile tramite XML o annotazione, viene valutato durante il tempo di creazione.
In questo articolo vedremo alcuni esempi di base dell’utilizzo di SpEL in Spring Boot, un linguaggio che rende semplice e rapida la creazione di progetti basati sui Framework Spring.
Una breve introduzione
Spring Boot supporta la maggior parte degli operatori aritmetici e logici, utilissimi per interrogare e manipolare un gruppo di oggetti. Per capire quali sono gli operatori più utilizzati guardiamo questa lista:
- Condizionali, ? :
- Aritmetica, +, -, *, /,%, ^, div, mod
- Logica, and, or, not, &&, ||, !
Come vedremo nelle prossime sezioni, la creazione e la manipolazione di file XML è molto semplice, veloce e risulta facile l'iniezione di valori al suo interno.
Questo linguaggio permette anche l'analisi di espressioni al di fuori del contesto di configurazione, attraverso un tool chiamato SpELExpressionParser. Questo tool permette l'analisi di stringhe, l'impostazione di valori e la configurazione di un parser.
Vediamo più nello specifico come si comporta e come interagisce col mondo Spring Framework.
Impostazione dell’applicazione Spring Boot
In questa sezione creeremo una semplice applicazione Spring Boot con un file chiamato emplyee.properties, che salveremo nella directory delle risorse del nostro computer.
Guardiamo il codice:
employee.names=Petey Cruiser,Anna Sthesia,Paul Molive,Buck Kinnear
employee.type=contract,fulltime,external
employee.age={one:'26', two : '34', three : '32', four: '25'}
Come vediamo le proprietà del tipo che stiamo modellando sono tre:
- Nome,
- Tipo di Contratto e
- Età.
Ora che abbiamo definito le caratteristiche di un employee generale definiamo una classe che configura le varie proprietà.
Creeremo, quindi, una classe EmployeeConfig come segue:
package com.techshard.spel;
import
org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.PropertySource;
@Configuration
@PropertySource (name = "employeeProperties", value = "employee.properties")
@ConfigurationProperties
public class EmployeeConfig {
}
Lettura della configurazione tramite SpEL e annotazione @Value
Creati questi due file siamo pronti per la lettura della classe Employee.Config trammite Spring Boot.
Aggiungeremo alcuni campi per leggere la configurazione direttamente da emplyee.properties usando l’annotazione @Value.
L’annotazione @Value può essere utilizzata per iniettare valori nei campi "bean" gestiti da Spring e può essere applicata a tre diversi livelli:
- campo,
- costruttore,
- parametro del metodo.
Nel prossimo esempio presentiamo l'annotazione SpEL per le espressioni: iniziano tutte con il simbolo "#" e sono racchiuse tra parentesi graffe. L'espressione tipica è:
#{expression}.
E' possibile, come mostrato successivamente, fare riferimento alle proprietà in modo simile, iniziando l'interrogazione con il simbolo "$", sempre racchiuse tra parentesi graffe:
${property.name}.
Il metodo "split", originario di Java, viene utilizzato per dividere le stringhe che vengono create, dividendole una dall'altra con una virgola ",".
@Value ("#{'${employee.names}'.split(',')}")
private List<String> employeeNames;
Stiamo, quindi, usando il linguaggio Spring Expression per ottenere un elenco di nomi di dipendenti (employee). Ora siamo in grado di manipolare le proprietà per ottenere l’elenco dei valori.
Il campo employee.names fornirà un elenco di questo tipo: [Peter Cruiser, Anna Sthesia, Paul Molive, Buck Kinnear].
Supponiamo, ora, di voler ottenere solo la prima voce dal nostro elenco dei dipendenti.
Useremo la stessa interrogazione spiegata prima, ma questa volta ci riferiremo ad una lista di oggetti in cui ci interessa il primo.
SpEL è un linguaggio che parte dal numero 0, quindi il nostro ""primo" elemento sarà [0].
Possiamo scrivere l’espressione come segue:
@Value ("#{'${employee.names}'.split(',')[0]}")
private String firstEmployeeName;
Questo ci farà ottenere il primo nome della lista: Peter Cruiser.
Ora vediamo come utilizzare @Value con la funzione di maps. Abbiamo definito la seguente proprietà, riguardante l'età degli employee:
employee.age={one:'26', two : '34', three : '32', four: '25'}
Come sappiamo la funzione map, mappa diversi valori "legandoli" insieme.
Utiliziando sempre il modo spiegato in precedenza per fare riferimento alla proprietà desiderato.
Possiamo iniettare, quindi, il valore della proprietà nella map come segue:
@Value ("#{${employee.age}}")
private Map<String, Integer> employeeAge
Supponiamo, ora, di ottenere il valore desiderato utilizzando una determinata chiave.
Come abbiamo fatto con i nomi, ci possiamo riferire ad un particolare elemento "definando" in che posizione trovarlo.
Possiamo ottenere il valore come segue:
@Value ("#{${employee.age}.two}")
private String employeeAgeTwo;
Se non siamo, però, sicuri che esista una determinata chiave e desideriamo ottenere un valore prefinito, a prescindere dalla sua esistenza o meno, possiamo scrivere la seguente espressione:
@Value ("#{${employee.age}['five'] ?: 30}")
private Integer ageWithDefaultValue;
In questo modo diamo come valore 30, se la chiave ‘five’ non esiste. Come possiamo notare è stato utilizzato l'operatore condizionale che ha definito l'esistenza o meno del valore "five".
In queste circostanze, in cui non sappiamo se un determinato valore o una determinata chiave esiste, gli operatori messi a disposizione da SpEL sono molto utili per creare delle query funzionali.
Leggere le proprietà del sistema mediante l’annotazione @Value
Possiamo inserire proprietà di sistema usando SpEL. Ad esempio, la Home di Java può essere iniettata ed aggiunta alle proprietà del sistema come segue:
@Value ("#{systemProperties['java.home']}")
private String javaHome;
Allo stesso modo la directory dell’utente può essere inserita come segue:
@Value ("#{systemProperties['user.dir']}")
private String userDir;
Conclusioni
In questo articolo abbiamo esaminato varie possibilità di utilizzare SpEL con annotazione @Value. Se desideri saperne di più sul linguaggio Spring Expression leggi la documentazione Spring qui.
SpEL è un linguaggio rivolto alle espressioni molto potente e ben supportato che può essere utilizzato in tutti i prodotti del Framework Spring.
Può configurare delle applicazioni Spring o anche scrivere parser per eseguire attività più generali.
Buona programmazione a tutti!
FONTE: Medium - Swathi Prasad
CONCORRENZA E BLOCCO JPA: LA GUIDA COMPLETA PER SCEGLIERE LA GIUSTA STRATEGIA
Immaginate di avere un sistema distribuito ed utilizzato da molti utenti che contemporaneamente cercano di modificare la stessa entità. Come si garantisce all’utente che l’integrità dei dati sottostanti al sistema stesso sia preservata anche quando si accede simultaneamente?
La risposta è semplice: Java Persistance API.
Java Persistance API è una specifica Java per l’accesso, la persistenza e la gestione dei dati tra oggetti (JAVA) e Database relazionali come MySQL, PostgreSQL, SQL server e Oracle.
Generalmente i provider di persistenza offrono una strategia di blocco (“locking” in inglese) per gestire la concorrenza. Esistono principalmente due tipi di blocco: quello pessimistico e quello ottimistico.
Prima di addentrarci in questo ambito, cerchiamo di fare chiarezza su cosa sono le transazioni ACID e quanto sono importanti per i database moderni.
ACID che significa Atomico, Coerente, Isolato e Durevole, assicura che una transazione del database sia completata in modo tempestivo. Una transazione all’interno di un database può essere suddivisa in più componenti: i database compatibili con ACID, ossia quelli relazionali, assicurano che una transazione sia mantenuta ed eseguita solo quando tutti i componenti della transazione stessa hanno esito positivo. Se uno qualsiasi dei componenti fallisce, la transazione verrà ripristinata e non verrà apportata alcuna modifica.
In caso di più transazioni, dobbiamo definire una strategia di blocco per assicurarci che l’integrità dei dati sottostanti sia preservata.
Andiamo più nel dettaglio e cerchiamo di capire come i due tipi di blocco funzionano nello specifico.
BLOCCO OTTIMISTICO
La specifica JPA fornisce l’annotazione javax.persistance per contrassegnare una proprietà con l’attributo @Version di una entità. Questa proprietà può essere un campo numerico (int, long, short) o java.sql.timestamp. Può esistere solo una proprietà con annotazione @Version per entità e l’attributo deve trovarsi nella tabella principale per un’entità mappata su più tabelle.
@Entity
public class User{
@Id
@Column (name = "ID", nullable = false)
@GeneratedValue (strategy = GenerationType.AUTO)
private long id;
@Version
private long version;
@OneToMany(mappedBy = "user", cascade = CascadeType.ALL)
private List<Order> orders = new ArrayList<>();
}
Qui, ogni transazione che legge i dati contiene il valore della proprietà @Version e prima di modificare i dati sottostanti, si verifica il valore.
Se nel frattempo il valore è cambiato, verrà lanciata una eccezione chiamata OptimisticLockException e verrà eseguito il rollback (ossia si ricopiano indietro i dati copiati in precedenza) della transazione. In caso contrario la transazione esegue il commit dell’aggiornamento e aumenta il valore della @Version.
MODALITA’ DI BLOCCO OTTIMISTICHE
JPA fornisce due modalità di blocco ottimistico: OPTIMISTIC e OPTIMISTIC_FORCE_INCREMENT.
• OPTIMISTIC ottiene il blocco in lettura per le entità con proprietà @Version.
• OPTIMISTIC_FORCE_INCREMENT invece, ottiene sempre il blocco di lettura per le entità con la proprietà @Version e incrementa quel valore.
BLOCCO PESSISTICO
In caso di blocco pessimistico, JPA crea una transazione che ottiene un blocco sui dati fino al completamento della transazione. Ciò quindi impedisce ad altre transazioni di apportare aggiornamenti all’entità fino al rilascio del blocco. Il blocco pessimistico è molto utile quando i dati sono frequentemente accessibili e modificabili da più transazioni.
Bisogna tenere presente che l’utilizzo del blocco pessimistico comporta una riduzione notevole delle prestazioni dell’applicazione se le entità non sono suscettibili a frequenti modifiche.
MODALITA’ DI BLOCCO PESSIMISTICO
JPA con questo tipo di blocco offre tre modalità: PESSIMISTIC_READ, PESSIMISTIC_FORCE_INCREMENT e PESSIMISTIC_WRITE.
• PESSIMISTIC_READ ottiene un blocco di lettura a lungo termine sui dati per impedire che questi vengano aggiornati o eliminati: le altre transazioni possono leggere i dati durante il blocco, ma non sono in grado di aggiornarli o eliminarli.
•PESSIMISTIC_FORCE_INCREMENT ottiene sempre un blocco di lettura a lungo termine sui dati per impedire modifiche, ma inoltre aumenta la proprietà della @Version.
• PESSIMISTIC_WRITE invece, ottiene un blocco di lettura a lungo termine sui dati per impedire sempre l’eliminazione o l’aggiornamento, ma anche la lettura dall’esterno.
Se non è possibile avere un blocco pessimistico, si ottiene un rollback della transazione e verrà generata una PessimisticLockException. Tuttavia, se il blocco fallisce e non risulta un rollback della transazione, verrà generata una LockTimeOutException.
CONCLUSIONI
A seconda delle esigenze della vostra applicazione, scegliete bene la giusta strategia di blocco e applicare la strategia solo se necessario. L’approccio ottimistico migliora le prestazione ma al contempo diminuisce la sicurezza, quello pessimistico migliora notevolmente la sicurezza ma le prestazioni diminuiscono di conseguenza. A seconda dell’ambito è giusto adottare un approccio piuttosto che un altro. A voi la scelta!


