Liferay Portal额外研究（五）：对多分发命令Action的支持（方案一）

 Liferay默认提供的基于 Struts Action扩展的PortletAction是不支持多分发命令的，也就是我们一般常用的DispatchAction。但在我们日常基于 Struts处理的操作中，已经大量的沿用了DispatchAction处理方式，采用“cmd=queryall”诸如此类的方式。

    本文就来给大家讲解如何通过扩展，让 Liferay实现对多分发命令Action的支持。

 

    首先让我们来看看 Liferay是如何处理的：

      在 portlet.xml中，我们一般会配置如下：

< portlet-class > com.liferay.portlet.StrutsPortlet </ portlet-class >
< init-param >
     < name > view-action </ name >
     < value > /ext/reports/view_reports </ value >
</ init-param >

 

       这样 Liferay面对一个Portlet请求的时候，会根据请求model来执行Portlet的doView或doEdit方式。当执行doView的时候就会请求其view-action所配置的Action URL所代表的Action来处理。

      其处理流程大致是： Portlet类——〉RequestProcessor——〉StrutsAction处理类。
 

     我们可以通过两种扩展方案来实现对多分发的支持：

      方案（一）：扩展 Liferay的StrutsPortlet类，并写一个DispatchPortletAction类，这样不用扩展RequestProcessor实现。

     方案（二）：扩展 RequestProcessor 与，并写一个DispatchPortletAction类，这样可以直接使用Liferay所提供的StrutsPortlet类。对于 RequestProcessor的扩展，在通过portal.properties文件中通过配置 “struts.portlet.request.processor”属性来设置。

 

    接下来就两种方案做分别的详细讲解（本篇先讲方案一）：
 

方案（一）

 

首先让我们写一个 DispatchPortletAction 类，此类可以通过扩展Liferay本身的PortletAction实现，也可以通过扩展Struts本身的DispatchAction实现。本人是选择后一种方式，这样扩展的代码量较少，都不要自己写execute方式，直接使用基类的即可。

对于 DispatchPortletAction 主要扩展dispatchMethod和getMethodName方法。注意在getMechodName方法中，还追加了从 request.getAttribute(parameter)获取方法名称，并注意unspecified方法，这个是在没有指明访问方法的时候默认执行的，所以开发人员在后续写自己的Action一定要实现这个。

public   class  DispatchPortletAction  extends  DispatchAction  ... {
    protected ActionForward dispatchMethod(ActionMapping mapping,
            ActionForm form, HttpServletRequest request,
            HttpServletResponse response, String name) throws Exception ...{

        PortletConfig portletConfig = (PortletConfig) request
                .getAttribute(WebKeys.JAVAX_PORTLET_CONFIG);

        RenderRequest renderRequest = (RenderRequest) request
                .getAttribute(WebKeys.JAVAX_PORTLET_REQUEST);

        RenderResponse renderResponse = (RenderResponse) request
                .getAttribute(WebKeys.JAVAX_PORTLET_RESPONSE);

        if (name == null) ...{
            return this.unspecified(mapping, form, portletConfig,
                    renderRequest, renderResponse);
        }

        Method method = null;
        try ...{
            method = getMethod(name);

        } catch (NoSuchMethodException e) ...{
            String message = messages.getMessage("dispatch.method",
                    mapping.getPath(), name);
            log.error(message, e);

            String userMsg = messages.getMessage("dispatch.method.user",
                    mapping.getPath());
            throw new NoSuchMethodException(userMsg);
        }

        ActionForward forward = null;
        try ...{
            Object args[] = ...{ mapping, form, portletConfig, renderRequest,
                    renderResponse };
            forward = (ActionForward) method.invoke(this, args);

        } catch (ClassCastException e) ...{
            String message = messages.getMessage("dispatch.return",
                    mapping.getPath(), name);
            log.error(message, e);
            throw e;

        } catch (IllegalAccessException e) ...{
            String message = messages.getMessage("dispatch.error",
                    mapping.getPath(), name);
            log.error(message, e);
            throw e;

        } catch (InvocationTargetException e) ...{
            Throwable t = e.getTargetException();
            if (t instanceof Exception) ...{
                throw ((Exception) t);
            } else ...{
                String message = messages.getMessage("dispatch.error",
                        mapping.getPath(), name);
                log.error(message, e);
                throw new ServletException(t);
            }
        }
        return (forward);
    }

    protected String getMethodName(ActionMapping mapping, ActionForm form,
            HttpServletRequest request, HttpServletResponse response,
            String parameter) throws Exception ...{

        String methodName = request.getParameter(parameter);
        if (methodName == null || methodName.length() == 0) ...{
             methodName = (String) request.getAttribute(parameter);
        }
        return methodName;
    }

    public ActionForward unspecified(ActionMapping mapping, ActionForm form,
            PortletConfig config, RenderRequest req, RenderResponse res)
            throws Exception ...{
        return null;
    }
    private static Log log = LogFactory.getLog(DispatchPortletAction.class);
    protected Class[] types = ...{ ActionMapping.class, ActionForm.class,
            PortletConfig.class, RenderRequest.class, RenderResponse.class };
}

        这样后续多分发 Action在书写的时候，只需要定义不同的方法即可，但是方法的参数需要依照如下规范，如下一个queryAll的方法：

public  ActionForward queryAll(ActionMapping mapping, ActionForm form,
            PortletConfig config, RenderRequest req, RenderResponse res)
             throws  Exception {
     // 业务处理
// 返回ActionForward即可
}

 
         在那些portlet配置文件的view-action属性中，是不能够增加参数的，比如你不能够采用 /ext/reports/view_reports?cmd=queryAll这种方式。所以我们需要在扩展的Portlet中做一些拦截。

可能有人会说，我不需要在初始的 view -action中增加参数。事实上这个的确不是强制，如果不追加参数，则会访问unspecified方法。但是对于Portlet的显示，其 Normal和Max页面显示，都会请求默认的view-action。所以我们需要在Portlet类实现上扩展，于是扩展了一个 DispachStrutsPortlet，如下：

public   class  DispachStrutsPortlet  extends  StrutsPortlet {

       public   void  doView(RenderRequest req, RenderResponse res)
                                                                    throws  IOException, PortletException {
                // 注意我的命令参数是cmdx，而不是通常的cmd。
                String cmd  =  req.getParameter( " cmdx " );
                 if (cmd == null   ||  cmd.length() == 0 ){
                        if  (req.getWindowState().equals(WindowState. MAXIMIZED)) {
                        req.setAttribute( " cmdx " , " queryAll " );
                }
                 super .doView(req, res);
        }
}

 

如上面的实现，则表示，如果 Portlet是Normal页面状态请求的时候，则在view-action的时候，则仅访问默认的unspecified方法；如果是Max页面状态，则执行queryAll方法。

 

有一个需要注意的地方，由于“ cmd”参数已经被Liferay使用，所以我们需要用另外的变量来表示方法。这里我采用的是“cmdx”。