liferay
Comunicación entre portlets

Introducción

Observaciones

Usando el parámetro de renderizado público

Este enfoque fue introducido en JSR 286.

En JSR 168, los parámetros de representación establecidos en processAction de un portlet estaban disponibles solo en ese portlet. Con la función de parámetros de representación públicos, los parámetros de representación establecidos en la processAction de un portlet también estarán disponibles en la representación de otros portlets. Para configurar esto, para todos los portlets que soportan esto:

Agregue la etiqueta <supported-public-render-parameter> , justo antes de que la etiqueta del portlet termine en portlet.xml

<security-role-ref>
    <role-name>user</role-name>
</security-role-ref>
<supported-public-render-parameter>{param-name}</supported-public-render-parameter>
</portlet>

Agregue <public-render-parameter> etiqueta <public-render-parameter> justo antes de que finalice la etiqueta <portlet-app>

  <public-render-parameter>
    <identifier>{param-name}</identifier>
    <qname xmlns:x="localhost">x:{param-name}</qname>
  </public-render-parameter>
</portlet-app>

En el método processAction , el valor param debe establecerse en la respuesta

res.setRenderParameter({param-name},{param-value});

Después de haber ejecutado la fase de acción del portlet en cuestión, el parámetro debe estar disponible en la fase de procesamiento para todos los portlets de soporte en la página, independientemente de ser parte de la misma aplicación o de la diferente. ).

Usando sesión de portlet

Este es un enfoque que ha estado allí desde JSR 168. Nos permite compartir atributos utilizando la sesión de portlet. Una sesión de portlet puede tener diferentes tipos de ámbitos:

1. Alcance del portlet (atributos disponibles solo dentro del portlet)
2. Ámbito de aplicación (atributos disponibles dentro de toda la aplicación [guerra])

Para utilizar este enfoque, no necesitamos realizar ninguna entrada en la configuración del portlet, ya que la sesión del portlet está disponible en la solicitud del portlet:

PortletSession session = renderRequest.getPortletSession();
session.setAttribute("attribute-name","attribute-value", PortletSession.APPLICATION_SCOPE);

o

PortletSession session = renderRequest.getPortletSession();
session.setAttribute("attribute-name","attribute-value", PortletSession.PORTLET_SCOPE);

El atributo solo se puede recuperar solo del ámbito respectivo. Al igual que para el atributo establecido en el ámbito de portlet, necesitamos obtenerlo usando

PortletSession session = renderRequest.getPortletSession();
String attributeValue = (String) session.getAttribute("attribute-name", PortletSession.PORTLET_SCOPE);

La principal limitación de este enfoque es la falta de intercambio entre otros portlets, fuera del alcance de la aplicación. Para superar esto, existe un enfoque específico de por vida para agregar <private-session-attributes > a liferay-portlet.xml

    <private-session-attributes>false</private-session-attributes>
    <header-portlet-css>/css/main.css</header-portlet-css>
    <footer-portlet-javascript>/js/main.js</footer-portlet-javascript>
    <css-class-wrapper>{portlet-name}</css-class-wrapper>
</portlet>

para todos los portlets, donde se establecen y recuperan los atributos.

Usando la función de eventos

El mecanismo de eventos es una versión extendida del parámetro de render público, con una función adicional para pasar objetos personalizados a otros portlets, pero con una sobrecarga de fase de eventos.

Para lograr esto, este mecanismo consiste en

1. Portlet editor
2. Portlet del procesador (consumidor), donde ambos pueden formar parte de diferentes aplicaciones de portlet.

Para empezar,

Agregue la etiqueta <supported-publishing-event> al portlet del editor en portlet.xml

    <security-role-ref>
        <role-name>user</role-name>
    </security-role-ref>
    <supported-publishing-event>
         <qname xmlns:x="http:sun.com/events">x:Employee</qname>
    </supported-publishing-event>
  </portlet>

Agregue la etiqueta <supported-processing-event> al portlet del procesador en portlet.xml

<security-role-ref>
        <role-name>user</role-name>
    </security-role-ref>
    <supported-processing-event>
        <qname xmlns:x="http:sun.com/events">x:Employee</qname>
     </supported-processing-event>
</portlet>

Agregue la etiqueta <event-definition> a ambos portlets, definiendo el nombre del evento y escriba portlet.xml

<event-definition>   
  <qname xmlns:x="http:sun.com/events">x:Employee</qname>
  <value-type>com.sun.portal.portlet.users.Employee</value-type>
</event-definition>
   </portlet-app>

A continuación, necesitamos crear una clase para el tipo de evento (en el caso de un tipo personalizado)

public class Employee implements Serializable {
  public Employee() {
  }
  private String name;
  private int userId; 

  public String getName() {
    return name;
  }

  public void setName(String name) {
    this.name = name;
  }

  public int getUserId() {
    return userId;
  }
  public void setUserId(int id)
  {
    this.userId = id;
  }

}

Ahora, en el portlet del editor, el evento debe publicarse en la fase de acción

    QName qname = new QName("http:sun.com/events" , "Employee");
    Employee emp = new Employee();
    emp.setName("Rahul");
    emp.setUserId(4567);
    res.setEvent(qname, emp);

Después de que hayamos publicado el evento, debe ser procesado por el portlet del editor en la fase del evento.

La fase de eventos se introdujo en JSR 286 y se ejecuta antes de la fase de procesamiento del portlet, cuando corresponda

@ProcessEvent(qname = "{http:sun.com/events}Employee")
public void processEvent(EventRequest request, EventResponse response) {

    Event event = request.getEvent();
    if(event.getName().equals("Employee")){
      Employee payload = (Employee)event.getValue();
      response.setRenderParameter("EmpName",
      payload.getName());
    }

}

que luego se puede recuperar del parámetro de renderización a través de la petición de render