protected Object getLookupKey(PortletRequest request) throws Exception 
{
		PortletMode mode = request.getPortletMode();
		String parameter = request.getParameter(this.parameterName);
		return new LookupKey(mode, parameter);
}

Returns a lookup key that combines the current PortletMode and the current value of the specified parameter.

 public  void initApplicationContext() throws BeansException 
{
		super.initApplicationContext();
		registerHandlers(this.portletModeParameterMap);
}

Calls the registerHandlers method in addition to the superclass's initialization.

 protected  void registerHandler(PortletMode mode,
    Map parameterMap) throws BeansException 
{
		for (Iterator it = parameterMap.entrySet().iterator(); it.hasNext();) {
			Map.Entry entry = (Map.Entry) it.next();
			String parameter = (String) entry.getKey();
			Object handler = entry.getValue();
			registerHandler(mode, parameter, handler);
		}
}

Register all handlers specified in the given parameter map.

 protected  void registerHandler(PortletMode mode,
    String parameter,
    Object handler) throws IllegalStateException, BeansException 
{
		// Check for duplicate parameter values across all portlet modes.
		if (!this.allowDuplicateParameters && this.parametersUsed.contains(parameter)) {
			throw new IllegalStateException(
					"Duplicate entries for parameter [" + parameter + "] in different Portlet modes");
		}
		this.parametersUsed.add(parameter);
		registerHandler(new LookupKey(mode, parameter), handler);
}

Register the given handler instance for the given PortletMode and parameter value, under an appropriate lookup key.

 protected  void registerHandlers(Map portletModeParameterMap) throws BeansException 
{
		if (CollectionUtils.isEmpty(portletModeParameterMap)) {
			logger.warn("'portletModeParameterMap' not set on PortletModeParameterHandlerMapping");
		}
		else {
			for (Iterator it = portletModeParameterMap.entrySet().iterator(); it.hasNext();) {
				Map.Entry entry = (Map.Entry) it.next();
				String modeKey = (String) entry.getKey();
				PortletMode mode = new PortletMode(modeKey);
				Object parameterMap = entry.getValue();
				if (!(parameterMap instanceof Map)) {
					throw new IllegalArgumentException(
							"The value for the portlet mode must be a Map of parameter Strings to handler Objects");
				}
				registerHandler(mode, (Map) parameterMap);
			}
		}
}

Register all handlers specified in the Portlet mode map for the corresponding modes.

 public  void setAllowDuplicateParameters(boolean allowDuplicateParameters) 
{
		this.allowDuplicateParameters = allowDuplicateParameters;
}

Set whether to allow duplicate parameter values across different portlet modes. Default is "false".

Doing this is dangerous because the portlet mode can be changed by the portal itself and the only way to see that is a rerender of the portlet. If the same parameter value is legal in multiple modes, then a change in mode could result in a matched mapping that is not intended and the user could end up in a strange place in the application.

 public  void setParameterName(String parameterName) 
{
	              	 
		Assert.hasText(parameterName, "'parameterName' must not be empty");
		this.parameterName = parameterName;
}

Set the name of the parameter used for mapping to handlers.

Default is "action".

 public  void setPortletModeParameterMap(Map portletModeParameterMap) 
{
		this.portletModeParameterMap = portletModeParameterMap;
}

Set a Map with portlet mode names as keys and another Map as values. The sub-map has parameter names as keys and handler bean or bean names as values.

Convenient for population with bean references.