Eventi di dominio in Spring framework

Qualche giorno fa un collega mi ha chiesto consigli su come disaccoppiare il codice che gestisce la logica di business dal codice che produce eventuali “reazioni” del sistema all’operazione eseguita. La sua necessità sorgeva dal fatto che l’applicazione su cui sta lavorando, realizzata con Spring framework, sarebbe stata utilizzata da diversi clienti, ciascuno dei quali avrebbe potenzialmente richiesto, per la medesima operazione principale, l’esecuzione di differenti operazioni secondarie. Una soluzione a questo problema è l’introduzione nel sistema degli eventi di dominio.

Eventi di dominio

Il concetto di evento di dominio appartiene al Domain-driven design (DDD), ma a ben vedere non viene esplicitamente citato nel testo di Eric Evans del 2003. L’autore del DDD infatti introdusse gli eventi di dominio solo in lavori successivi e forse è per questo che la loro adozione è meno diffusa rispetto ai concetti di Entity e Value Object.

In estrema sintesi, un evento di dominio rappresenta un accadimento che ha modificato lo stato del sistema, del modello, avvenuto in un preciso istante di tempo e scatenato da una precisa causa, ad esempio da una richiesta dell’utente. Ad un evento sono associate anche altre caratteristiche, come la tipologia dell’evento (“prodotto acquistato”, “utente iscritto”, ecc.) ed ulteriori informazioni specifiche per ciascuna tipologia (identificativo del prodotto acquistato, identificativo dell’utente registrato, ecc.).

Gli eventi di dominio possono essere utilizzati per molteplici scopi. Ad esempio, memorizzandoli su file o database si realizza un log dettagliato delle operazioni effettuate sul sistema. Oppure possono essere impiegati per disaccoppiare cause ed effetti all’interno di uno stesso dominio, o ancora per notificare le modifiche subite da un dominio a domini esterni.

Eventi di Spring framework

Spring framework, fin dalle sue prime versioni, possiede un sistema di gestione degli eventi. Inizialmente era destinato principalmente alla gestione degli eventi specifici del framework, come il “refresh del context”, ma di recente (versioni 4.2+) tale sistema è stato reso più flessibile per semplificare la gestione di eventi definiti dallo sviluppatore, come ad esempio gli eventi di dominio.

Per modellare un evento, come ad esempio la creazione di un nuovo post di un blog, basta creare una generica classe, con gli attributi che riteniamo sufficienti a descrivere i dettagli dell’evento. E’ consigliabile assegnare alla classe un nome che sia identificativo della tipologia di evento. Inoltre è opportuno renderla immutabile: una volta istanziato un evento non deve poter essere modificato, non c’è motivo per farlo.

<br />
public final class PostCreatedEvent {</p>
<p>	private final int postId;</p>
<p>	private final int userId;</p>
<p>	private final boolean isPublished;</p>
<p>	private final LocalDateTime creationDateTime;</p>
<p>	public PostCreatedEvent(int postId, int userId, boolean isPublished) {<br />
		this.postId = postId;<br />
		this.userId = userId;<br />
		this.isPublished = isPublished;<br />
		this.creationDateTime = LocalDateTime.now();</p>
<p>	}</p>
<p>	public int getPostId() {<br />
		return postId;<br />
	}</p>
<p>	public int getUserId() {<br />
		return userId;<br />
	}</p>
<p>	public boolean isPublished() {<br />
		return isPublished;<br />
	}</p>
<p>	public LocalDateTime getCreationDateTime() {<br />
		return creationDateTime;<br />
	}<br />
}<br />

Pubblicare un evento

Per trasmettere un evento ai potenziali fruitori è sufficiente utilizzare il metodo publishEvent della classe ApplicationEventPublisher di Spring.

<br />
public class PostService {</p>
<p>	@Autowired<br />
	ApplicationEventPublisher publisher;</p>
<p>	public void create() {<br />
		...<br />
		publisher.publishEvent(new PostCreatedEvent(123, 456, true));<br />
	}<br />
}<br />

Ricevere un evento

Per processare un evento basta sviluppare un metodo che lo preveda come parametro di input, in una qualunque classe, e annotare il metodo con @EventListener:

<br />
@Component<br />
public class PostEventsListener {</p>
<p>	private static final Logger logger = LoggerFactory.getLogger(PostEventsListener.class);</p>
<p>	@EventListener<br />
	public void onCreate(PostCreatedEvent event) {<br />
		logger.info(&quot;PostEventsListener.onCreate for post &quot; + event.getPostId());<br />
	}<br />
}<br />

In caso di presenza di più listener per lo stesso tipo di evento, per specificare un ordine è possibile utilizzare l’annotazione @Order.

Nel precedente esempio, abbiamo definito il metodo onCreate come void. Interessante notare che se invece avessimo restituito un oggetto, questo sarebbe stato interpretato da Spring come un nuovo evento. In questo modo è possibile, ad esempio, realizzare un layer di traduzione degli eventi di un dominio in eventi di un dominio esterno.

Ricezione condizionata di un evento

E’ anche possibile ricevere l’evento in maniera condizionata, ovvero soltanto se uno specifico attributo dell’evento vale true, utilizzando una SpEl:

<br />
@EventListener(condition = &quot;#event.isPublished&quot;)<br />

E’ inoltre possibile condizionare la ricezione di un evento legandolo ad una fase della transazione corrente. Ad esempio, se vogliamo ricevere un evento solo se la transazione si è conclusa correttamente, al posto dell’annotazione @EventListener dovremo usare l’annotazione @TransactionalEventListener, che di default attiva il metodo listener solo in caso di commit. Potremo configurare questa annotazione per ricevere l’evento anche in altre fasi della transazione, ad esempio BEFORE_COMMIT,  AFTER_ROLLBACK e AFTER_COMPLETION.

Ricezione sincrona e asincrona

I metodi annotati con @EventListener ricevono l’evento in maniera sincrona con il metodo che ha generato l’evento. Anche i metodi annotati con @TransactionalEventListener vengono eseguiti in maniera sincrona, con l’unica differenza che non vengono invocati nell’esatto momento in cui l’evento viene generato ma la loro esecuzione è posticipata all’esecuzione della fase della transazione a cui sono associati, ad esempio al commit della transazione. Sono quindi eseguiti dallo stesso thread che ha generato l’evento e pertanto, in una applicazione web, la response non viene restituita al chiamante fintanto che sono in esecuzione i metodi listener.

E’ possibile però utilizzare un altra caratteristica dello Spring framework per rendere asincrona l’esecuzione dei listener, quindi affidare la loro esecuzione ad un thread differente da quello nel quale è stato generato l’evento. Per farlo è sufficiente configurare l’applicazione con l’annotazione @EnableAsync e applicare sui metodi listener l’annotazione @Async.

<br />
@Component<br />
public class PostEventsListener {</p>
<p>	private static final Logger logger = LoggerFactory.getLogger(PostEventsListener.class);</p>
<p>	@EventListener<br />
	public void onCreate(PostCreatedEvent event) {<br />
		logger.info(&quot;PostEventsListener.onCreate for post &quot; + event.getPostId());<br />
	}</p>
<p>	@TransactionalEventListener<br />
	public void onCreateTrans(PostCreatedEvent event) {<br />
		logger.info(&quot;PostEventsListener.onCreateTrans for post &quot; + event.getPostId());<br />
	}</p>
<p>	@Async<br />
	@TransactionalEventListener<br />
	public void onCreateAsyncTrans(PostCreatedEvent event) {<br />
		logger.info(&quot;PostEventsListener.onCreateAsyncTrans for post &quot; + event.getPostId());<br />
	}<br />
}<br />

Spring in questo caso, nel momento in cui viene generato un evento, avvia un nuovo thread in cui eseguire il metodo del listener.

Se questa modalità di esecuzione è molto utilizzata nella nostra applicazione allora, per evitare l’overhead dovuto alla creazione di sempre nuovi thread, è possibile indicare a Spring di adottare un gestore dei thread asincroni che supporti meccanismi di cache (pool) dei thread, come il ThreadPoolTaskExecutor, istanziabile nel seguente modo:

<br />
@Bean<br />
public ThreadPoolTaskExecutor threadPoolTaskExecutor() {<br />
	ThreadPoolTaskExecutor pool = new ThreadPoolTaskExecutor();<br />
	pool.setCorePoolSize(10);<br />
	return pool;<br />
}<br />

Eventi di dominio in un sistema distribuito

L’approccio descritto è utile a disaccoppiare il codice che genera un evento di dominio da quello che lo gestisce ma richiede che produttore e consumatore di eventi siano sviluppati all’interno della stessa applicazione Spring. Spesso però è necessario notificare un evento di dominio ad un altro applicativo, ma purtroppo le cose si complicano poiché significa che ci troviamo di fronte ad un sistema distribuito. In tal caso è opportuno utilizzare strumenti di integrazione, come Apache KafkaRabbitMQ.

In questo caso l’approccio descritto tornerebbe comunque utile, ad esempio, per disaccoppiare il codice che genera l’evento dal codice che inoltra l’evento ad uno di questi sistemi di integrazione.

Lascia un commento