Jso

Una carrellata di tutte le novità attese in Java 8. E sono davvero tante!

• Miglioramento nelle interacce
• Interfacce funzionali
• Espressioni Lambda
• Miglioramento nei tipi generici
• Aggiunte alla Collections API
• Aggiunte alla Concurrency API
• Aggiunte alle IO/NIO API
• Cambiamenti a Reflection ed Annotation
• Nashorn JavaScript Engine
• Miglioramenti delle performance

Leggi anche l’articolo originale.

Ecco un articolo piuttosto tecnico, ma molto ben fatto e dettagliato sulla taratura delle performance per  l’Application Server di riferimento nel mondo Java, Glassfish.

L’articolo inizia con alcune best practise comuni del mondo JavaEE (multi thread model, gestione delle sessioni HTTP,  caching dei beans, gestione dei pool e delle transazioni) per poi divenire più specifico. In particolare vengono trattati diffusamente:

• Ottimizzazione del Server
  • Deployment
  • Logging
  • Web Container
  • EJB Container
  • Network Listener
  • Thread Pool
  • Resources
• Ottimizzazione della JVM
• Ottimizzazione del Sistema Operativo
  • Parametri di rete
  • Numero massimo di files aperti
  • TCP/IP
  • Gestione del timing (orologio di sistema)
  • Network Interface Card (NIC)
• Test di un caso pratico (con grafici)

Leggi anche l’articolo originale.

Finalmente Java 7!
Certo i rilasci delle Java VM non sono così frequenti; specie dopo l’acquisizione da parte di Oracle, in effetti, un po’ di apprensione per l’uscita della versione 7 c’era…

Ma ora ci siamo quasi e le novità introdotte nella JVM non sono di così poco conto:

• Modularizzazione
• Supporto per linguaggi dinamici
• Nuove API per l’I/O e per il file system
• Supporto nativo per l’XML (probabile)
• Safe rethrow delle eccezioni
• Null dereference expressions, in stile Groovy
  
• Better type inference, per l’instanziazione dei generics
• Multi-catch, clausole multiple nella gestione delle eccezioni
• Class loader ulteriormente migliorato
• Migliorata la pipeline per i componenti Java 2D
• Miglioramenti a Swing
• JavaFX

ed altri ancora…

E’ interessante inoltre notare come il processo di incremento delle performance, già iniziato con Java 6, non si si a fermato, anzi! I test effettuati evidenziano un aumento percentuale anche più rilevante rispetto al precedente passaggio di versione. Che dire? Oracle sembra aver fatto un buon lavoro, forse anche superiore alle attese…

Leggi anche l’articolo completo.

Nulla da fare, purtroppo sembra veramente che l’acquisizione di Sun da parte di Oracle, come purtroppo si temeva all’inizio, stia portanto alla fuga di moltissime teste illustri.

Proprio in questi giorno sono state annunciate le dimissioni niente meno che di James Gosling, il padre di Java. E non è il solo purtroppo.

Dovremo aspettarci presto qualcosa di nuovo da open jdk?

Leggi tutti gli annunci: 1, 2, 3 e 4

Mi è capitato di dover salvare un file di properties “ordinato” ovvero nel quale le chiavi fossero ordinate rispetto ad un certo criterio. Poichè la classe java.util.Properties estende java.util.Hashtable<Object, Object> normalmente le properties sono memorizzate senza alcun ordinamento specifico.
In qualche caso invece, se il file ottenuto è di grandi dimensioni, può essere utile disporre di un qualche tipo di ordinamento. La soluzione è abbastanza “tricky”, pertanto la pubblico.
La seguente classe rappresenta la chiave:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

/**
 * A key in the form Sn, where n is an integer number.
 *
 */
public class MessageKey implements Comparable {
 
    private Integer key;
 
    public MessageKey(final String pKey) {
        final String vKey = pKey.substring(1);
        try {
            key = Integer.valueOf(vKey);
        } catch (NumberFormatException vExc) {
            Logger.error(vExc);
        }
    }
 
    public Integer getId() {
        return key;
    }
 
    public int compareTo(final MessageKey pKey) {
        return key.compareTo(pKey.getId());
    }
 
    @Override
    public String toString() {
        return "S" + key;
    }
 
}

A questo punto occorre creare il nuovo oggetto Properties, facendo l’override del metodo keys() per ottenere, all’atto del salvataggio, il file ordinato. Il tutto senza ridefinire classi di sistema. Sono necessari alcuni passaggi per costruire una Enumeration ordinata (utilizzata nell’implementazione base della classe Properties), transitanto attraverso un Vector ed una List, riordinabile con il metodo standard Collections.sort(…). La soluzione risulta compatibile con Java5 e Java6.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

final Properties vProps = new Properties() {
    private static final long serialVersionUID = 1127046528812232390L;
 
    @Override
    public Enumeration keys() {	// this is for key reordering...	
       final Vector vKeysEnum = new Vector();	
       for (Enumeration<object> vEn = super.keys(); vEn.hasMoreElements();) {	    
          vKeysEnum.add(new MessageKey((String) vEn.nextElement()));	
       }	
 
       final List<messagekey> vKeysList = Collections.list(vKeysEnum.elements());	
       Collections.sort(vKeysList);	
       final Vector<object> vOrderedKeys = new Vector<object>();	
       for (final MessageKey vKey : vKeysList) {	    
          vOrderedKeys.add(vKey.toString());	
       }	
       return vOrderedKeys.elements();    
    }
};
//...vProps.setProperty("S" + vMsgKey.getId(), "something");
//...vProps.store(...);

Il problema di trovare un buon cms open-source mi ha sempre affascinato. La gestione dei contenuti (e dei documenti) ad oggi è un problema tutt’altro che nuovo. In rete si trovano davvero centinaia, se non migliaia di alternative sviluppate sulla piattafoma LAMP, piuttosto che in Python, Java o .NET e c’è anche un sito che si è preso la briga di catalogarle e confrontarle (quasi) tutte. Ma in tutta questa varietà come si fa ad orientarsi? E perchè tante alternative? E come mai la scelta vincente è spesso il php, tantochè addirittura molti portali che trattano di Java si basano proprio su cms php?

Le alternative sono molteplici ma tra tutte sembrano proprio Mambo, Joomla e Drupal a suscitare il maggiore interesse nella comunity. Perchè sono in effetti davvero facili da usare, user-friendly e potenti al tempo stesso. Richiedono una semplice installazione, c’è una ricchissima dotazione di plugin e il costo di hosting e gestione in molti casi è davvero ridicolo.

Più complesse le soluzioni Java (Alfresco, Magnolia per citarne alcune) che richiedono risorse e tempi di startup più consistenti. Inoltre questi cms sono più orientati alla gestione documentale piuttosto che alla gestione/publicazione dei contenuti sul web. Anche Plone (basato su Python/Zope) richiede competenze maggiori ed è giustificato generalmente in contesti Enterprise.

Alcune alternative che ho trovato interessanti perchè ben si avvicinano ai cms php ma offrono alcune caratteristiche enterprise proprie di Java (supporto multi-db, clustering, versioning, chiara separazione e riuso dei contenuti rispetto alla presentation logic, livelli di autorizzazione sul singolo componente, esportazione dei contenuti in formato xml…) sono dotCMS e OpenCms. Tra l’altro dotCMS è costruito su LifeRay probabilmente il più promettente e potente portlet container sviluppato in Java, che come Riot offre una sorta di framework (c’è da stupirsi?) per lo sviluppo di portali Java. Molti interessanti, se non altro perchè utilizzano al loro interno il meglio della tecnologia Java attualmente disponibile 🙂

• http://www.cmsmatrix.org/