Stiamo ovviamente parlando di Liferay, un portal server conforme allo standard portlet (JSR 168/268) distribuito in versione open source con un bundle di oltre 60 portlet già pronte all’uso che possono essere sinteticamente rraggruppate nei seguenti insiemi:

• Portlet per la gestione dei contenuti: servono per gestire a livello di editing e di publishing tutto il ciclo di vita dei contenuti web (e non) che il portale dovrà erogare
• Portlet di collaboration: sono disponibili in versione “portlet” tutti i principali strumenti e funzionalità di collaboration più conosciuti e diffusi: rating e commenti sui contenuti, forum, wiki, blog, client IM, Calendario condiviso, client webmail
• Portlet di integrazione: si tratta di portlet finalizzate ad integrare contenuti e/o siti web esterni (via Iframe o Proxy), mappe di Google, feed RSS
• Portlet varie: sono per la maggior parte delle portlet “inutili” con finalità di demo. La più singolare è sicuramente la portlet “Random Bible Verse”

A queste si aggiungono moltissime funzionalità trasversali come ad esempio  la status bar in stile Facebook per contattare gli amici attualmente collegati ed il pannello di controllo che consente ad ogni utente normale di gestire il suo profilo e all’amministratore di tener sotto controllo tutto quello che avviene nel portale, dalle singole azioni degli utenti alle risorse di memoria allocate.

Una volta effettuata l’installazione, lo startup di un portale basato su Liferay rappresenta una procedura molto veloce che può essere effettuata interamente via web attraverso funzioni user-friendly quasi interamente basate sul solo utilizzo del mouse. L’assemblaggio di un portale viene effettuato secondo la seguente sequenza di operazioni:

• Scelta del tema grafico: si tratta di un componente installabile proprio come qualunque altro plugin e che per questo motivo deve essere creato secondo precisi standard e convenzioni. Questo consente da un lato di poter effettuare delle sostituzioni a caldo dell’aspetto grafico e dall’altro ha favorito la nascita di un discreto repository di temi grafici gratuiti che vanno ad aggiungersi a quelli già inclusi nel bundle di installazione di Liferay
• Costruzione dell’alberatura del sito: le pagine possono essere create in maniera visuale con pochi click, quindi possono essere copiate, duplicate e spostate attraverso drag & drop in maniera istantanea
• Assemblaggio delle portlet nelle pagine: per ogni pagina sono disponibili svariati layout (singola colonna, due colonne, tre colonne, ecc…) all’interno dei quali è possibile trascinare le diverse portlet con l’utilizzo del mouse
• Configurazione utenze e permessi: uno dei punti di forza maggiori di questo prodotto (usabilità a parte) consiste proprio nella possibilità di controllare i permessi in maniera molto granulare. Ad esempio è possibile definire quali gruppi di utenti possono vedere una certa pagina o addirittura una certa portlet all’interno di una certa pagina!
• Creazione community e sottositi: il motore di Liferay consente da un lato di gestire più virtual host separati all’interno di un’unica istanza, dando così la possibilità di gestire più portali indipendenti, dall’altro di fornire ai gruppi e ai singoli utenti la possibilità di gestire in piena autonomia una propria area personale che può essere pubblica o privata. In questo senso Liferay si presta molto bene alla gestione di community e social network: non a caso ne esiste anche una versione denominata Liferay Social Office (destinata all’ambito professionale)

Ovviamente però non è tutto oro quel che luccica: per poter funzionare Liferay richiede un hosting Java dedicato e notevoli risorse hardware, motivo per cui si cofigura come un prodotto prevalentemente destinato ad un’ utenza professionale. Dal punto di vista poi della qualità presenta sicuramente anche svariati difetti. In particolare:

• Un sito sviluppato con Liferay rischia di essere particolarmente pesante anche per il browser: l’uso massiccio di Javascript per la costruzione di un’interfaccia user-friendly fa sentire tutto il suo peso. I tempi di latenza nel caricamento delle pagine spesso sono fin troppo percettibili. In questo senso però, soprattutto con le versioni più recenti, sono stati fatti notevoli passi in avanti, grazie all’introduzione di sistemi di compressione, caching ed ottimizzazione.
• La versione open source non è mai bug-free: il team di Liferay rilascia quasi mensilmente una nuova versione, spesso non retrocompatibile, con lo scopo (a mio avviso fin troppo palese) di sfruttare la community nell’identificazione e correzione dei bug. Le versioni stabili e consolidate convergono poi (purtroppo per noi) in Liferay Enterprise, la versione commerciale del portale. Chi decide di sviluppare su Liferay deve quindi preventivare anche un certo impegno nella risoluzione autonoma di problemi e bug di vario genere (personalmente, nei progetti che ho seguito, ne ho dovuti correggere almeno una decina)
• L’infrastruttura applicativa di Liferay è fortemente monolitica: le modifiche o estensioni finalizzate a correggere bug o a modificare/adattare il funzionamento delle portlet in bundle (capita molto spesso, motivo per cui lo svilupaptore ha a disposizione il cosiddetto “Extension Environment”), hanno sempre una portata trasversale su tutti i layer applicativi e nella maggioranza dei casi non sono mai portabili da una versione di Liferay a quella successiva. I problemi poi emergono maggiormente nel momento in cui si renda necessario intervenire sulla logica di presentazione (front end) layer implementato con soluzioni spesso spartane e poco modulari.

Liferay è distribuito in bundle con tutti i più diffusi application server e servlet engine in circolazione (open source e commerciali): si va da Jetty,Resin,Tomcat a Apache Geronimo, Sun GlassFish 2 UR1, JBoss, JOnAS, OracleAS, SUN JSAS, WebLogic, WebSphere. Anche a livello di database è compatibile praticamente con tutti i prodotti in circolazione: Apache Derby, IBM DB2, Firebird,Hypersonic, InterBase, JDataStore, MySQL, Oracle, PostgresSQL, SAP MaxDB, SQL Server, Sybase.

Di seguito un video che può servirvi per farvi un’idea sull’usabilità di Liferay e sulla velocità con cui un utente (esperto) possa configurare un portale complesso e pronto per il go-live:

In conclusione, ritengo che nonostante i concorrenti commerciali lo definiscano come “fumo negli occhi”, Liferay si configura sicuramente come un buon prodotto in grado di apportare notevoli vantaggi in svariate situazioni, soprattutto se lo si adotta “as is” accettandone quindi il funzionamento di default soprattutto in relazione alle portlet che fornisce già pronte in bundle. Nel momento in cui si inizia ad apportarvi estensioni e modifiche tutti i vantaggi acquisiti rischiano di scemare molto velocemente e di farvi convergere verso derive che possono diventare molto insidiose.

Visita il sito ufficiale di Liferay

package net.nothing2hide.jmx;
import java.util.Enumeration;
import java.util.List;
import java.util.Vector;
import org.apache.log4j.Level;
import org.apache.log4j.LogManager;
import org.apache.log4j.Logger;
public class Log4jConfigurator {
  /**
   * Set the log level to INFO for the target logger
   * @param target The name of the logger to change
   */
  public void enableInfo(String target) {
    LogManager.getLogger(target).setLevel(Level.INFO);
  }
  /**
   * Set the log level to WARN for the target logger
   * @param target The name of the logger to change
   */
  public void enableWarn(String target) {
    LogManager.getLogger(target).setLevel(Level.WARN);
  }
  /**
   * Set the log level to ERROR for the target logger
   * @param target The name of the logger to change
   */
  public void enableError(String target) {
    LogManager.getLogger(target).setLevel(Level.ERROR);
  }
  /**
   * Set the log level to DEBUG for the target logger
   * @param target The name of the logger to change
   */
  public void enableDebug(String target) {
    LogManager.getLogger(target).setLevel(Level.DEBUG);
  }
  /**
   * Set the log level to INFO for the ROOT logger
   */
  public void enableInfoGlobally() {
    LogManager.getRootLogger().setLevel(Level.INFO);
  }
  /**
   * Set the log level to WARN for the ROOT logger
   */
  public void enableWarnGlobally() {
    LogManager.getRootLogger().setLevel(Level.WARN);
  }
  /**
   * Set the log level to ERROR for the ROOT logger
   */
  public void enableErrorGlobally() {
    LogManager.getRootLogger().setLevel(Level.ERROR);
  }
  /**
   * Set the log level to DEBUG for the ROOT logger
   */
  public void enableDebugGlobally() {
    LogManager.getRootLogger().setLevel(Level.DEBUG);
  }
  /**
   * @return The list of all the available loggers
   */
  public String listAvailableLoggers(){
    Enumeration en = LogManager.getLoggerRepository()
      .getCurrentLoggers();
    StringBuffer res = new StringBuffer();
    while(en.hasMoreElements()){
      Logger logger = (Logger)en.nextElement();
      res.append(logger.getName()).append("n");
    }
    return res.toString();
  }
}

Lo step successivo consiste nell’ esportazione della classe “Log4jConfigurator” come MBean attraverso Spring:

A questo punto, una volta deployata la nostra applicazione, avremo a disposizione l’MBean “n2h:log4jConfigurator” che attraverso una qualsiasi console JMX ci metterà a disposizione tutti i metodi della classe “Log4jConfigurator”.

Infatti attraverso la reflection è effettivamente possibile andare a forzare i vincoli del linguaggio Java senza eccessiva difficoltà, ammenochè appunto non sia presente un security manager, unico attore in grado realmente di gestire ed eventualmente bloccare tali tipologie di forzature.

Ma veniamo subito all’esempio pratico che vale più di molte disquisizioni. Data la seguente classe:

package net.nothing2hide.test;
public class ClassWithMethodsToHack {
  private void sayHello(String name){
      System.out.println("Hello " + name +
          "! You're calling a private method");
  }
}

vogliamo dimostrare come sia facilmente invocabile dall’esterno il metodo privato “sayHello“; come già vi ho anticipato per farlo utilizzeremo pesantemente la reflection:

package net.nothing2hide.test;
public class PrivateMethodInvocationTest {
  /**
  * This sample class demonstrates how to
  * invoke a protected method on another class
  *
  * @param args
  */
  public static void main(String[] args) {
    String myName = "Davide";
    Method m;
    try {
      //Let'access the private method
      //by reflection. You could do the same
      //with a protected method
      m = ClassWithMethodsToHack.class.getDeclaredMethod(
      "sayHello", new Class[]{String.class});
      if (m != null) {
        //Let's force the java language access
        //checks on the reflected method. Note
        //that if a security manager is defined
        //this workaround could not be permitted
        //and a SecurityException could be raised
        m.setAccessible(true);
        //And finally let's invoke the protected method
        m.invoke(new ClassWithMethodsToHack(),
        new Object[]{myName});
      }
    } catch (Exception e) {
      e.printStackTrace();
    }
  }
}