All articles by andrea.como

 

Migliora i tuoi log con il Mapped Diagnostic Context

Stai scrivendo dei servizi web in Java e vorresti sempre loggare l’utente collegato e l’IP del chiamante in modo automatico e trasparente per darli in pasto a ELK? O assegnare un identificativo univoco ad un batch multithread perché non capisci più cosa sta loggando ogni thread? In realtà è una cosa più semplice di quanto si pensi perché è una feature supportata da tempo dalla maggior parte dei sistemi di logging in Java come Log4j, Log4j2 o Logback, e, ovviamente da loro “padre” SLF4J!...
Continue reading...  

Microservizi in Java con Spring Boot e Spring Cloud

Negli ultimi anni non si sente altro che parlare di microservizi: se fai microservizi sei cool, altrimenti sei vecchio. Il salto da una applicazione monolitica ad una costellazione di piccole applicazioni però può essere più doloroso di quanto si pensi se non si hanno strumenti in grado di supportare le problematiche introdotte dai sistemi distribuiti.
Spring è sempre stato una garanzia e non sorprende se oggi come oggi Spring Cloud si sia ritagliato nel giro di poco tempo il ruolo di framework leader quando si pensa ai microservizi nel mondo Java....
Continue reading...  

Introduzione ad Angular CLI

Lo startup di un progetto può essere sempre un problema se non si conoscono le best practices o non si sa esattamente come strutturare l’applicazione. Fortunatamente è già da diversi anni che, per i progetti frontend web, tool come Yeoman ci vengono in soccorso non solo per lo scaffolding dello startup di un progetto, ma anche per supporto durante la...
Continue reading...  

Angular 2 diventa 4 (per adesso)!

Dove sono stato nell’ultimo anno? Sembra ieri che parlavamo di Angular 2 ancora alla RC1 e, il tempo di distrarsi un attimo, quel 2 è divento un 4!! In realtà, c’è una spiegazione: con l’adozione del Semantic Versioning, ogni release che provoca rottura col passato richiede il salto di una major version.. e di rotture ce ne sono state! Già...
Continue reading...  

JCache con Spring Boot e Hazelcast

La specifica JCache non è riuscita ad entrare nell’ultima versione di Java EE (7) ma è già viva e supportata nel mondo circostante, per esempio da Spring. In realtà Spring aveva già una sua implementazione del sistema di caching che poi ha esteso per supportare la specifica...
Continue reading...  

AngularJS 1.5+ incontra i Components

AngularJS non molto tempo fa, con la versione 1.5, ha introdotto nativamente il concetto di WebComponent, “portando a casa” gran parte dell’esperienza fatta con Angular 2. Cominciare ad usare i Components con AngularJS oggi non solo significa scrivere codice molto più facilmente aggiornabile verso Angular 2, soprattutto se scritto in ES6, ma permette anche di modularizzare e riusare il codice...
Continue reading...  

AngularJS in ES6

Non molto tempo fa con un post di Nicola Malizia abbiamo visto le novità introdotte da JavaScript 6 (o meglio ECMAScript 6 o ES6 per gli amici). Nonostante la matrice di compatibilità di ES6 con i maggiori browser sia sempre più “piena”, si ricorre spesso ai transpiler (come o Babel) per usare oggi gran parte delle caratteristiche future di JavaScript. Vediamo quindi come usare oggi alcune delle caratteristiche di ES6 anche con AngularJS!...
Continue reading...  

Integration Test con Maven e Docker

Non è la prima volta che parliamo di integration test, croce e delizia dello sviluppo. Sono complessi da fare perché richiedono la compartecipazione dei sistemi necessari all’applicazione che siamo sviluppando. Avevamo visto come nel ciclo di build di Maven l’uso del plugin failsafe ci aiuta ad eseguire questo tipo di test nella fase giusta. Abbiamo visto poi come Arquillian permette...
Continue reading...  

Java EE integration test con Arquillian

Scrivere i test durante lo sviluppo (o prima, se fate TDD) è molto importante. L’uso quotidiano di framework di mocking come Mockito o EasyMock (magari aiutati dal mitico PowerMock) hanno notevolmente semplificato la scrittura di test di unità permettendo di svincolarsi dai framework e dal resto del mondo che circonda la funzionalità che stiamo sviluppando. ...
Continue reading...  

Introduzione ad Angular 2 – Parte 2

Introduzione ad Angular 2 – Parte 2 Nel primo post introduttivo abbiamo affrontato i concetti base di Angular 2 come i Componenti, i Template e soprattutto il modo in cui comunicano tramite il nuovo two-way databindig. Se questi elementi si occupano di gestire l’interazione utente, i Servizi invece si preoccupano di reperire i dati da mostrare o inviare gli input...
Continue reading...  

Introduzione ad Angular 2 – Parte 1

E’ tanto che se ne parla e finalmente Angular 2 è arrivato alla versione beta! Possiamo considerare le API ormai stabili dal punto di vista sintattico (visto che dalla alpha qualcosa è cambiato), per cui è il momento di cominciare a studiarlo senza aspettarsi straordinari cambiamenti da qui alla release ufficiale. Quei rumors che dicevano che Angular 2 era del tutto diverso dalla versione 1 erano veri? Ebbene si, Angular 2 fa un grande passo a vanti, si trasforma e diventa… !!! Apparte gli scherzi, a prima vista sembra che Angular 2 sia più parente del framework di Facebook che del suo predecessore, almeno per quanto riguarda i concetti base. Scavando un po’ però si riconosce il nostro vecchio amico AngularJS…...
Continue reading...  

So di non sapere JavaScript – Scope e Closures

Una delle frasi che hanno reso famoso il filosofo greco Socrate era: “Io so di non sapere”. Sicuramente non si riferiva a JavaScript, ma è il giusto approccio da tenere davanti a questo linguaggio che tutti noi crediamo di conoscere senza averlo mai studiato. Ebbene, dopo aver letto alcuni volumi della serie “You don’t know JavaScript“, posso dire di aver scoperto molte cose che non sapevo, come per esempio, udite udite, che JS è compilato e non interpretato!...
Continue reading...  

Java Annotation Processing

Nel lavoro di tutti i giorni può capitare di dover scrivere del codice boilerplate, senza valore aggiunto, magari ripetitivo o con classi che differiscono pochissimo tra loro. Se la logica è fatta in modo tale che non si riesce a mettere a fattor comune, magari conviene spostarsi ad un livello di programmazione dichiarativo con le annotations, interpretate tramite Reflection di...
Continue reading...  

SPI: Java Service Provider Interface

Durante la programmazione in Java vi sarà capitato di imbattervi nell’acronimo SPI: non si tratta di un typo per API (la S è vici alla A d’altro canto…) ma di un altro acronimo, ovvero Service Provider Interface. Ma di cosa si tratta? In una parola, aderire a questo framework significa creare applicazioni “estendibili“, dove cioè si possono estendere certi servizi...
Continue reading...  

JPA 2.1 Attribute Converters

Ormai si sa, molto spesso la piattaforma Java Enterprise prende, migliora e rende standard ciò che c’è di buono in giro e che alcuni vendor hanno sviluppato per spingere le specifiche Java EE sempre avanti con soluzioni praticamente già consolidate e apprezzate. Un esempio tra questi sono gli Attribute Converters JPA, già implementati in EclipseLink e a modo suo anche...
Continue reading...  

I miei primi passi con Node.js ed Express.js

Il mondo della programmazione web è pieno di “qualcosa.js“: nomi come Node.js ed Express.js non son certo hot topics, anzi sono ormai piuttosto consolidati, ma di fatto non ce ne eravamo mai occupati. Fortunatamente sto partecipando ad un progetto con Giampaolo e Francesco in cui abbiamo decido si usare un full-stack javascript basato su Node.js, Express.js, MongoDB e React.js, così...
Continue reading...  

RxJavaEE: RxJava, WebSocket e Concurrency in Java EE 7

Si parla tanto di RxJava ultimamente (anche noi su CNJ), e a ragion veduta direi. Nell’ambito Java, ha spopolato soprattuto nel mondo Android perché permette di semplificare notevolmente la gestione degli eventi asincroni e scrivere un codice decisamente più moderno. Mi sono sempre chiesto se RxJava fosse altrettanto utile negli applicativi web, dove la “reattività” tra client e server (o...
Continue reading...  

Java EE 7 e WebSocket (con WildFly e AngularJS) – Parte 2

Nel post precedente abbiamo conosciuto WebSocket nelle sue caratteristiche architetturali e affrontato la sua implementazione lato server con WildFly, in riferimento ad un progetto di esempio ben preciso che trovate su GitHub e in live demo su OpenShift. E’ il momento adesso di vedere come gestire l’invio e la ricezione di oggetti lato client, e come integrare il tutto in...
Continue reading...  

Java EE 7 e WebSocket (con WildFly e AngularJS) – Parte 1

Per rendere i nostri applicativi web sempre più reattivi, la gestione asincrona degli eventi è fondamentale. WebSocket può essere una soluzione, essendo una tecnologia che possiamo ormai considerare consolidata. Non è una novità nemmeno per il vecchio e caro mondo Java, che ci ha sempre provato con l’”architettura” Comet, e soprattutto con Java EE 7. Meglio tardi che mai La...
Continue reading...  

Comunicazione tra tab del browser – parte 2

Nel post precedente abbiamo visto due modalità che ci permettono di comunicare tra tab del browser, uno a parità di dominio e l’altro no. Entrambi i metodi avevano però il limite di dover avere il riferimento del tab aperto, cosa non sempre possibile. Vediamo adesso come è possibile aggirare questo problema. Le 4 vie – reprise Le modalità viste nello...
Continue reading...  

Comunicazione tra tab del browser – parte 1

Lo sviluppo degli applicativi web è sempre più orientato al versante client: gli utenti richiedono sempre di più che le interfacce web siano sempre più “rich”, con una UX paragonabile a quella degli applicativi client, reattiva al cambiamento dei dati. Lo stato dell’applicazione risiede quindi nel client stesso, mentre il server, stateless, espone le proprie funzionalità come servizi web: secondo...
Continue reading...  

Retrolambda: lambda expression anche su Java 7

Non vedete l’ora di poter lavorare in modo funzionale con le espressioni lambda anche in Java? Purtroppo però siete bloccati su Java 7 e potete solo sognarle la notte… Almeno fino ad oggi! Esiste un progetto molto interessante su GitHub che porta le espressioni lambda su Java 7 (e in teoria anche prima), vediamo insieme cosa offre. Vade retro Basta...
Continue reading...  

Maven Integration Tests

I test di integrazione sono una parte molto importante dello sviluppo di un software: permettono di uscire dal piccolo mondo del test di unità per vedere se tutto il puzzle sta in piedi. Maven, nel suo ciclo di vita, riserva addirittura quattro fasi a questo scopo ed un plugin realizzato ad hoc. Vediamo di che si tratta. Maven Failsafe Plugin...
Continue reading...  

JSON Web Token: JAAS stateless authentication per Tomcat

La protezione delle risorse web tramite sistemi di autenticazione e autorizzazione è un elemento che non si può prescindere durante lo sviluppo di applicazioni web. Ne ha parlato recentemente anche il nostro Mauro in un post su Spring Security, perché è un tema molto sentito. Un sistema di autenticazione per applicativi web può essere realizzato in modo stateless o statefull....
Continue reading...  

Alfresco InboundSMTP: come inviare e-mail ad Alfresco

In questi giorni mi sono trovato alle prese con l’abilitare il server “inbound” SMTP di Alfresco per potergli inviare mail da poter archiviare come documenti, insieme agli allegati. Fin qui niente di nuovo, l’abilitazione è ben documentata, ma come fare ad inviare mail ad Alfresco per esempio dal proprio indirizzo gmail? Bisogna che l’smtp di Google veda quello di Alfresco:...
Continue reading...  

EJB, JPA, eccezioni, JTA e Resource Local: facciamo un po’ di chiarezza – Parte 2

Nel post precedente abbiamo affrontato EJB, JPA e JTA nel loro utilizzo più frequente (e più semplice). Vediamo adesso di capire cosa possiamo fare quando rinunciamo all’EntityManager a favore dell’EntityManagerFactory. Perché scendere di un livello e avere più controllo? In un contesto Java EE magari non è molto utile perché complica il codice, ma è bene sapere cosa si può...
Continue reading...  

EJB, JPA, eccezioni, JTA e Resource Local: facciamo un po’ di chiarezza – Parte 1

Mi è capitato di leggere nei forum: “chi ha più bisogno degli EJB? Ormai è roba vecchia”. Posizione opinabile a mio avviso: in Java EE 5 e soprattutto nella 6, creare un EJB si è ridotto alla scrittura di un POJO annotato, per cui perché fare a meno delle funzionalità che la specifica ci offre? Quali dite? In primis JTA...
Continue reading...  

BeanValidation e JAX-RS

Con la piattaforma Java Enterprise 6, tra le varie nuove specifiche, è stata introdotta anche quella conosciuta come Bean Validation. Come abbiamo già avuto modo di parlare in un post su MokaByte e qua su CoseNonJaviste, la Bean Validation dà la possibilità di definire in modo semplice i vincoli e le validazioni direttamente sul modello del nostro dominio. Data la...
Continue reading...  

Bean Validation 1.1 e i validatori personalizzati

In occasione di un contributo tra CoseNonJaviste e MokaByte, avevamo avuto modo di presentare la bean validation e le sue caratteristiche principali. Ovviamente come ogni buon framework che si rispetti è possibile personalizzarlo e aggiungere del nostro. Vediamo come. Custom validation: casi d’uso Nella modellazione di un dominio, ci imbattiamo sempre in una serie di vincoli strutturali che possono avere...
Continue reading...  

Spring e datasource: come criptare la password del database

Eccoci al terzo e ultimo episodio della saga sulla sicurezza della vostra password del database. In due post precedenti abbiamo visto come cifrare la password del datasource in JBoss AS 7 e in Tomcat. Se però non lavorate né con JBoss né con Tomcat, usate Spring e preferite far gestire il datasource a lui e rimanere più generici possibili, ecco...
Continue reading...  

Tomcat e datasource: come criptare la password del database

Siamo al secondo appuntamento con i datasource e la cifratura della password del database. Nel post precedente abbiamo visto come risolvere il problema in JBoss AS 7, adesso vediamo come si fa con Tomcat. Con questo tipo di server è possibile dichiarare un datasource a livello globale, ovvero visibile ad altre applicazioni, o locale, cioè strettamente legato all’applicazione corrente. Vediamo...
Continue reading...  

JBoss AS 7 e datasource: come criptare la password del database

Nelle architetture applicative a 3 livelli, e quindi quelle web solitamente, l’account dell’utente che vi accede non è mai quello del database, come invece avviene comunemente in quelle a due livelli. Questo significa che in realtà l’account che ha accesso ai dati è impersonale (e fin qui…), non deve essere quello di amministrazione – leggi root in MySQL per esempio...
Continue reading...  

Primi passi con Spring Batch

Realizzando applicazioni business-to-business non è raro incontrare la necessità di fare movimentazione massiva di dati in modo automatico, schedulato e fail-safe. Un bel batch quindi è quello che ci vuole! 🙂 Ovviamente si può fare in mille modi, usare mille framework differenti se necessario, schedularli tramite Cron per esempio o Quartz e così via. Ultimamente mi è capitato di dover...
Continue reading...  

Maven Archetype per JSF 2, Spring 4 e JPA 2

Sono passati ormai più di due anni dal post che spiegava come creare un progetto con JSF, Spring e Hibernate/JPA. E’ arrivato il momento di aggiornarlo a Maven, con tutte le nuove dipendenze! Un archetipo tutto nuovo Ovviamente se si parla di migrare il progetto a Maven, non possiamo che partire da un archetipo. Cercando in rete, quello più interessante...
Continue reading...  

Migrare da RichFaces a PrimeFaces? Si-può-fareeee!

Stando a quanto mostra Google Trends, l’interesse della comunità di sviluppatori JSF si è spostato esponenzialmente da RichFaces a PrimeFaces tanto da superare il rivale intorno al settembre del 2011. CoseNonJaviste si è già avvicinata a PrimeFaces con un tutorial che mostra le potenzialità del framework, che si mostra molto curato, potente ed accattivante rispetto alla concorrenza. Lasciare la vecchia...
Continue reading...  

JSONP e jQuery: conosciamoli meglio

Negli ultimi anni il formato JSON si sta conquistando la simpatia di tutti: si legge bene, non è verboso (quindi leggero), e va a braccetto con JavaScript. Molte delle API web che si trovano in giro per interagire con i social netword per esempio, utilizzano questo formato di scambio dati. Meno nota, o confusa con esso, è invece la notazione JSONP (che sta per JavaScript Object Notation with Padding) che spesso usiamo forse inavvertitamente se lavoriamo per esempio con le API di Twitter o Facebook. Ma che significa? Perché mi dovrebbe interessare la differenza?...
Continue reading...  

EclipseLink, Oracle Stored Function e Object Types appassionatamente insieme

Recentemente ho avuto a che fare con chiamate a Stored Function Oracle da una applicazione web basata su JPA come framework di persistenza. Purtroppo questo tipo di operazione non è coperto dalla specifica JPA, per cui bisogna ricorrere alle funzionalità specifiche del vendor che abbiamo scelto. Usando EclipseLink (ex Oracle TopLink) diciamo che si gioca in casa, anche se le cose si fanno molto complesse quando i parametri da scambiare con la funzione sono tipi complessi...
Continue reading...  

Ajax e JSON con JSF2

JSF2 ha imparato molto dall’esperienza della versione precedente e dai framework che gli ruotavano attorno a tal punto da averne integrati alcuni. Un esempio è Facelets, ma sicuramente quella più utile è stata l’integrazione nativa con Ajax, prendendo spunto da Ajax4JSF (a4j), confluito in RichFaces da molti anni ormai. Una cosa però manca all’implementazione nativa di JSF2, ovvero l’attributo data...
Continue reading...  

MDB e JMS con JBoss AS 7

Nell’era delle App dove tutto è smart e veloce, parlare di Message Driven Bean (MDB) e Java Message Service (JMS) sembra retrogrado e pesante. In realtà, se sviluppate applicazioni a livello enterprise, non è così strano dover ricorrere a bus di messaggistica per risolvere determinati scenari di business. In Java EE 5 inoltre, come già affrontato a suo tempo, se...
Continue reading...  

EclipseLink AdditionalJoinExpression: questo sconosciuto

A chi non è mai capitato nelle proprie query di dover aggiungere sempre gli stessi filtri per esempio per non caricare righe con stati non logicamente validi o righe valide in certi intervalli di date? EclipseLink permette di inserire questi filtri una volta per tutte, dimenticandoci di doverci portare sempre il fardello....
Continue reading...  

JUnit Test the REST!

Ormai sviluppare servizi web secondo l’architettura REST sembra una moda. Era quello che in fondo pensavo prima di leggere REST in Practice, un libro da leggere assolutamente per capire come approcciarsi a questo nuovo modo di accesso a risorse web. Che poi tanto nuovo non è… bastava accorgersi che HTTP aveva già tutto quello che occorreva per essere un “Application Protocol” e non semplicemente un “Transport Protocol” come siamo abituati ad usarlo....
Continue reading...  

CDI ViewScoped: abbandoniamo i backing bean JSF!

Il ViewScoped in JSF 2 è molto usato e molto importante: ci permette di salvare lo stato di una vista per il solo arco di tempo in cui questa è attiva. Recentemente abbiamo introdotti dalla specifica CDI. Sarebbe bello quindi poter usare la potenza dei bean CDI con la semplicità della gestione del ViewScoped. Come? Esistono diverse vie....
Continue reading...  

Injection o lookup programmatico? Aiutati che CDI t’aiuta

Siamo tutti un po’ innamorati della Dependancy Injection (DI), come quella di CDI per esempio: ci piace per l’estrema eleganza del codice, per il disaccoppiamento tra classi, per mille altre ragioni del mondo, e un po’ anche per pigrizia! Purtroppo però, esistono situazioni in cui l’idillio si infrange e la DI non viene risolta dal nostro Inversion of Control (IoC) container preferito: ci sono infatti alcuni artefatti come i Converter e i Validator di JSF che non sono gestiti da questi contesti, non meno lo è CDI. Urge un lookup programmatico! Vediamo come fare....
Continue reading...  

ViewScoped vs ConversationScoped. JSF vs CDI. Chi vincerà?

Tra le novità della piattaforma Java EE 6, sicuramente spicca CDI. Spring e Seam hanno fatto scuola e il meglio entra nella specifica Java Enperprise. Uno dei primi concetti con cui dobbiamo fare i conti è il lifecycle dei bean CDI, governato dagli scopes. Già da subito si nota che molti di questi scope si sovrappongono a quelli della specifica JSF 2, e il fatto che i bean CDI siano referenziabili anche da pagine web tramite Expression Language (EL), fa pensare che CDI stia invadendo il campo di JSF. Cerchiamo di capire su cosa....
Continue reading...  

JBoss 7 ed EclipseLink 2: una coppia quasi perfetta – Parte II (a.k.a weaving statico con Maven)

abbiamo visto le difficoltà incontrate nel far andare d’amore e d’accordo JBoss 7.0.2 ed EclipseLink 2.3. Probabilmente i problemi incontrati dipendevano dal fatto che la versione 7.0.2 non era completamente Java EE complinant, ma lo era solo per il profilo web. Con la nuova versione di JBoss (al momento 7.1.1) le cose sono leggermente migliorate ma, come anticipato, è meglio aggiornare anche EclipseLink alla versione 2.4. Vediamo perché....
Continue reading...  

JBoss 7 ed EclipseLink 2: una coppia quasi perfetta – Parte I (a.k.a. weaving statico con Ant)

Gli Application Server (AS) basati sulle specifiche Java EE ci permettono spostare una applicazione da uno all’altro senza problemi, e allo stesso tempo ci mettono in condizione di essere in grado di lavorare indistintamente con uno o l’altro AS… questo almeno in teoria! In pratica invece ci scontriamo con tutte le configurazioni specifiche di ogni AS, nonché con deployment descriptors proprietari che variano da server a server. Di solito quindi, una volta scelto l’AS su cui lavorare, è bene affidarsi a tutte le implementazioni delle specifiche che esso porta con se, per avere meno problemi possibile. Prendiamo per esempio JBoss 7, che come implementazione di JPA ha Hibernate. Finché usiamo questa implementazione della specifica JPA, funziona tutto correttamente: se però abbiamo bisogno di passare per esempio ad EclipseLink, perché magari preferiamo qualche sua caratteristica peculiare, dobbiamo armarci di pazienza e rimboccarci le maniche!...
Continue reading...  

JCache fai-da-te con JBoss 7 e Infinispan

In un post precedente abbiamo già visto cos’è Infinispan e come si configura una cache con JBoss AS 7. In vista degli ultimi ritocchi a Java EE 7, Infinispan tende la mano a CDI con il nuovo modulo infinispan-cdi, fornendo al momento una parziale implementazione alla specifica JCache (JSR-107) che, come suggerisce il nome, regolamenterà la gestione della cache nelle...
Continue reading...  

JBoss 7 e Infinispan, una cache per tutti i gusti

Con la nuova versione dell’Application Server firmato JBoss, ovvero JBoss AS 7, tra le mille modifiche e le mille cose cambiate, troviamo anche JBoss Cache. La nuova gestione della cache, a differenza della precedente, è confluita sotto l’ala di Infinispan, ovvero una piattaforma di caching distribuita e scalabile, pensata appositamente per data grid. Per noi comuni mortali che significa?...
Continue reading...  

Il Pattern Decorator e Java EE 6: quando il vecchio si fa nuovo con CDI

Per chi è cresciuto a pane e GoF non sarà certo la prima volta che sente parlare del Pattern Decorator. In due parole, questo pattern permette di aggiungere in modo modulare funzionalità, a compile-time, ai metodi di una classe esistente, mantenendone l’interfaccia intatta. L’aggiunta o la rimozione di queste funzionalità risulta quindi totalmente trasparente all’utilizzatore. Nel contesto attuale dello sviluppo Java, sempre più governato da “container” che risolvono automaticamente le dipendenze, implementare questo pattern poteva non essere banale fino a ieri. La nuova specifica Context and Dependancy Injection (CDI) introdotta in Java EE 6 invece supporta nativamente i decoratori: vediamo come....
Continue reading...  

Finalmente Contexts and Dependency Injection (CDI) anche in Java EE 6!

Il concetto di Inversion of Control (IoC) ormai è noto da anni: si demanda a terzi (un Container) la responsabilità, il controllo, di istanziare i nostri oggetti e le loro interdipendenze. Se ne guadagna in termini di riusabilità e testing del codice...
Continue reading...