bloggers bloggers

Marco Napolitano
Messaggi: 68
Stelle: 0
Data: 15/11/17
Jader Jed Francia
Messaggi: 50
Stelle: 0
Data: 22/09/17
Ezio Lombardi
Messaggi: 9
Stelle: 0
Data: 23/06/17
Chiara Mambretti
Messaggi: 25
Stelle: 0
Data: 27/02/17
Serena Traversi
Messaggi: 3
Stelle: 0
Data: 21/07/16
Francesco Falanga
Messaggi: 8
Stelle: 0
Data: 14/06/16
Antonio Musarra
Messaggi: 2
Stelle: 0
Data: 18/11/13
Simone Celli Marchi
Messaggi: 6
Stelle: 0
Data: 09/07/13
marcello marangio
Messaggi: 4
Stelle: 0
Data: 05/07/13
Marco Mancini
Messaggi: 1
Stelle: 0
Data: 05/06/13
Indietro

Utilizzare una classe helper in un ADT custom

In un precedente articolo (Integrazione con l'ADT Framework) abbiamo visto come integrare una portlet custom con l'ADT framework di Liferay 6.2.

Chi ha avuto modo di creare un ADT per l'Asset Publisher, si sarà reso conto che questo tipo di ADT mette a disposizione una classe di helper che fornisce dei metodi (uno solo per la verità...) di utility da usare nel template (vedi figura sotto).

ADT Helper Class

Viene quindi da chiedersi... come posso fornire una classe helper in un ADT custom?

Innanzitutto dobbiamo aggiungere al metodogetTemplateVariableGroups un blocco di codice con cui iniettiamo nell'editor del template la nostra classe:

TemplateVariableGroup myUtilTemplateVariableGroup =
    new TemplateVariableGroup("my-entities-util", restrictedVariables);
myUtilTemplateVariableGroup.addVariable(
    "my-entities-helper", MyPortletHelper.class, "myPortletHelper");
templateVariableGroups.put("my-entities-util", myUtilTemplateVariableGroup);

Analizziamo il blocco di codice:

  • l'oggettomyUtilTemplateVariableGrouprappresenta la sezione che comparirà nell'editor del template, con la sua label (my-entities-util);
  • all'interno del blocco viene aggiunta la nostra classe helper denotata da 3 elementi:
    • la label,my-entities-helper;
    • l'interfaccia che espone i metodi,MyPortletHelper.class;
    • il nome della variabile usata nell'editor del template,myPortletHelper;
  • come ultima operazione aggiungiamo la nostra sezione custom a quella generale dell'ADT.

Una volta fatto questo è necessario iniettare all'interno del contesto dell'ADT, un'implementazione della classe di helper; pertanto, nel file view.jsp visto in precedenza, andremo ad aggiungere:

<%
Map<String, Object> contextObjects = new HashMap<String, Object>();
contextObjects.put("pageContext", pageContext);
contextObjects.put("myPortletHelper", MyPortletHelperUtil.getMyPortletHelper());
%> <%=PortletDisplayTemplateUtil.renderDDMTemplate( pageContext, portletDisplayDDMTemplateId, applications, contextObjects) %>

Attenzione ad utilizzare lo stesso nome di variabile (myPortletHelper) utilizzato sopra!

Rimane ora solo l'ultimo sforzo: creare lo stack della classe di helper: dovremo infatti definire ben 3 classi diverse...

Iniziamo dalla prima, l'interfaccia, con alcuni metodi di esempio:

public interface MyPortletHelper {
    public String firstMethod(
        MyEntity entity, ThemeDisplay themeDisplay);

    public String secondMethod(
        MyEntity entity, RenderRequest renderRequest, RenderResponse renderResponse);
}
Dopodichè è il turno della classe di implementazione:
public class MyPortletHelperImpl implements MyPortletHelper {
    @Override
    public String firstMethod(
        MyEntity entity, ThemeDisplay themeDisplay) {
        // implementazione...
    }

    @Override
    public String secondMethod(
        MyEntity entity, RenderRequest renderRequest, RenderResponse renderResponse) {
// implementazione... }
}
Infine la classe di util, che viene utilizzata nella JSP per ottenere la classe di implentazione:
public class MyPortletHelperUtil {
    private static MyPortletHelper _myPortletHelper;

    public static String firstMethod(
        MyEntity entity, ThemeDisplay themeDisplay) {
return getMyPortletHelper().firstMethod(entity, themeDisplay);
} public static String secondMethod(
        MyEntity entity, RenderRequest renderRequest, RenderResponse renderResponse) {
return getMyPortletHelper().secondMethod(entity, renderRequest, renderResponse);
} public static MyPortletHelper getMyPortletHelper() {
return _myPortletHelper;
} public void setMyPortletHelper(MyPortletHelpermyPortletHelper) {
_myPortletHelper= myPortletHelper;
} }

Ok, ma la classe di implementazione come viene istanziata?

Ovviamente tramite Spring; andremo quindi a creare il file WEB-INF/src/META-INF/ext-spring.xml in cui definiremo i nostri bean:

<?xml version="1.0"?>

<beans
    default-destroy-method="destroy"
    default-init-method="afterPropertiesSet"
    xmlns="http://www.springframework.org/schema/beans"
    xmlns:aop="http://www.springframework.org/schema/aop"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://www.springframework.org/schema/aop
    http://www.springframework.org/schema/aop/spring-aop-3.0.xsd
    http://www.springframework.org/schema/beans
    http://www.springframework.org/schema/beans/spring-beans-3.0.xsd"
>
    <bean id="...util.MyPortletHelper" class="...util.MyPortletHelperImpl" />
    <bean id="...util.MyPortletHelperUtil" class="...util.MyPortletHelperUtil">
<property name="myPortletHelper" ref="...util.MyPortletHelper" /> </bean> </beans>
Precedente
Commenti
Nessun commento. Vuoi essere il primo.