portletcontainerimpl.java.svn-base

portal越来越流行了

        debugWithName("Redirect URL sent.");        
    }
    
    /**
     * Loads the portlet associated with the specified portlet window.
     * @param portletWindow  the portlet window.
     * @param request  the servlet request.
     * @param response  the servlet response.
     * @throws PortletException
     * @throws IOException
     * @throws PortletContainerException
     */
    public void doLoad(PortletWindow portletWindow,
                       HttpServletRequest request,
                       HttpServletResponse response)
    	throws PortletException, IOException, PortletContainerException {
    	
    	ensureInitialized();
    	
        debugWithName("Load request received for portlet: "
        		+ portletWindow.getPortletEntity().getPortletDefinition().getPortletName());
        

        InternalRenderRequest renderRequest =
            getOptionalContainerServices().getPortletEnvironmentService()
                .createRenderRequest(this, request, response, portletWindow);

        InternalRenderResponse renderResponse =
            getOptionalContainerServices().getPortletEnvironmentService()
                .createRenderResponse(this, request, response, portletWindow);

        PortletInvokerService invoker = optionalContainerServices.getPortletInvokerService();

        try {
            getInvocationService().setInvocation(this, portletWindow);
            invoker.load(renderRequest, renderResponse, portletWindow);
        } finally {
            getInvocationService().clearInvocation();
        }

        debugWithName("Portlet loaded for: " + portletWindow.getPortletEntity().getPortletDefinition().getPortletName());
    }
    

    public void doAdmin(PortletWindow portletWindow,
                        HttpServletRequest servletRequest,
                        HttpServletResponse servletResponse)
    throws PortletException, IOException, PortletContainerException {
        ensureInitialized();

        debugWithName("Admin request received for portlet: "
            +portletWindow.getPortletEntity().getPortletDefinition().getPortletName());

        InternalPortletRequest internalRequest =
            new AdminRequest(this, portletWindow, servletRequest) { };

        InternalPortletResponse internalResponse =
            new AdminResponse(this, portletWindow, servletRequest, servletResponse);

        PortletInvokerService invoker = optionalContainerServices.getPortletInvokerService();

        try {
            getInvocationService().setInvocation(this, portletWindow);
            invoker.admin(internalRequest, internalResponse, portletWindow);
        } finally {
            getInvocationService().clearInvocation();
        }

        debugWithName("Admin request complete.");
    }


    public String getName() {
        return name;
    }

    public RequiredContainerServices getRequiredContainerServices() {
        return requiredContainerServices;
    }

    /**
     * Retrieve the optional container services used by the container.
     * If no implementation was provided during construction, the default
     * instance will be returned.
     *
     * @return services used by the container.
     */
    public OptionalContainerServices getOptionalContainerServices() {
        return optionalContainerServices;
    }
    
    /**
     * Fire Event for the portlet associated with the given portlet window and eventName
     * @param portletWindow  the portlet window.
     * @param request  the servlet request.
     * @param response  the servlet response.
     * @param eventName the event name
     * @throws PortletException
     * @throws IOException
     * @throws PortletContainerException
     * 
     * @see {@link javax.portlet.EventPortlet#processEvent(javax.portlet.EventRequest, javax.portlet.EventResponse)
     */
    public void fireEvent(HttpServletRequest request, HttpServletResponse response,
    		PortletWindow window, Event event) 
    		throws PortletException, IOException, PortletContainerException {

    	ensureInitialized();

    	debugWithName("Event request received for portlet: "
    			+ window.getPortletEntity().getPortletDefinition().getPortletName());

    	EventRequestImpl eventRequest = new EventRequestImpl(
    			this, window, request, event);
    	EventResponseImpl eventResponse = new EventResponseImpl(
    			this, window, request, response);

    	PortletInvokerService invoker = optionalContainerServices.getPortletInvokerService();

        try {
            getInvocationService().setInvocation(this, window);
            FilterManager filterManager = filterInitialisation(window,PortletRequest.EVENT_PHASE);
            invoker.event(eventRequest, eventResponse, window, filterManager);
        }
        finally {
            getInvocationService().clearInvocation();
        }

    	debugWithName("Portlet event processed for: "
    			+ window.getPortletEntity().getPortletDefinition().getPortletName());

    	// After processing event, change the redirect URL for rendering.
    	String location = eventResponse.getRedirectLocation();

    	if (location == null) {

    		// Create portlet URL provider to encode redirect URL.
    		debugWithName("No redirect location specified.");
    		PortletURLProvider redirectURL = requiredContainerServices
    		.getPortalCallbackService()
    		.getPortletURLProvider(request, window);

    		saveChangedParameters(request, eventRequest, eventResponse, redirectURL);

    		// save redirectURL in request
    		redirectURL.savePortalURL(request);
    	}
    }
    
    private ContainerInvocationService getInvocationService()
    {
        return requiredContainerServices.getContainerInvocationService();
    }
    
    // Private Methods ---------------------------------------------------------
    
    /**
     * Ensures that the portlet container is initialized.
     * @throws IllegalStateException  if the container is not initialized.
     */
    private void ensureInitialized() throws IllegalStateException {
    	if (!isInitialized()) {
    		throw new IllegalStateException(
    				"Portlet container [" + name + "] is not initialized.");
    	}
    }
    
    /**
     * Prints a message at DEBUG level with the container name prefix.
     * @param message  log message.
     */
    private void debugWithName(String message) {
    	if (LOG.isDebugEnabled()) {
    		LOG.debug("Portlet Container [" + name + "]: " + message);
    	}
    }
    
    /**
     * Prints a message at INFO level with the container name prefix.
     * @param message  log message.
     */
    private void infoWithName(String message) {
    	if (LOG.isInfoEnabled()) {
    		LOG.info("Portlet Container [" + name + "]: " + message);
    	}
    }
    
    /**
     * Prints a message at ERROR level with the container name prefix.
     * @param message  log message.
     */
    private void errorWithName(String message) {
        if (LOG.isErrorEnabled()) {
            LOG.info("Portlet Container [" + name + "]: " + message);
        }
    }

	/**
	 * @param request
	 * @param response
	 * @param redirectURL
	 */
	protected void saveChangedParameters(HttpServletRequest servletRequest, PortletRequest request, StateAwareResponseImpl response, PortletURLProvider redirectURL) 
	{
		// Encode portlet mode if it is changed.
		if (response.getChangedPortletMode() != null) {
			redirectURL.setPortletMode(
					response.getChangedPortletMode());
		}

		// Encode window state if it is changed.
		if (response.getChangedWindowState() != null) {
			redirectURL.setWindowState(
					response.getChangedWindowState());
		}

		// Encode render parameters retrieved from action response.
		Map renderParameters = response.getRenderParameters();
		
		// clear render parameter only once per request
		// (there could be more than one (eventing))
		if (!isAlreadyCleared(request))
			redirectURL.clearParameters();
		
		redirectURL.setParameters(renderParameters);
		redirectURL.setPublicRenderParameters(response.getPublicRenderParameter());

		// Encode redirect URL as a render URL.
		redirectURL.setAction(false);

		// Set secure of the redirect URL if necessary.
		if (redirectURL.isSecureSupported()) {
			try {
				redirectURL.setSecure();
			} catch (PortletSecurityException e) {
				LOG.error("Problem calling PortletURLProvider.setSecure()", e);
				throw new IllegalStateException("Security cannot be set on the redirect URL (" + e.toString() + ").");
			}
		}
	}


	/**
	 * Checks if render parameter are already cleared,
	 * bye storing/reading an ID in the request
	 * 
	 * @param request the portlet request
	 * 
	 * @return true, if already cleared
	 */
	protected boolean isAlreadyCleared(PortletRequest request) 
	{
		String cleared = (String) request.getAttribute(Constants.RENDER_ALREADY_CLEARED);
		if (cleared == null || cleared.equals("false")) {
			request.setAttribute(Constants.RENDER_ALREADY_CLEARED,"true");
			return false;
		}
		return true;
	}    
	
	/**
	 * The method initialise the FilterManager for later use in the PortletServlet
	 * @param PortletWindow the PortletWindow
	 * @param lifeCycle like ACTION_PHASE, RENDER_PHASE,...
	 * @return FilterManager
	 * @throws PortletContainerException
	 */
	private FilterManager filterInitialisation(PortletWindow portletWindow,String lifeCycle) throws PortletContainerException{
	    PortletEntity pe = portletWindow.getPortletEntity();
        return requiredContainerServices.getPortalCallbackService().getFilterManager(pe.getPortletDefinition().getApplication(),pe.getPortletDefinition().getPortletName(),lifeCycle);
    }
	
	class AdminRequest extends PortletRequestImpl 
	{

	    public Integer getRequestMethod()
	    {
	        return Constants.METHOD_ADMIN;
	    }
	     
        public AdminRequest(PortletContainer container,
                            PortletWindow portletWindow,
                            HttpServletRequest servletRequest) {
            super(container, portletWindow, servletRequest);
        }

        public PortletPreferences getPreferences() {
            throw new IllegalStateException("Can not access preferences during admin request.");
        }
    }

    class AdminResponse extends PortletResponseImpl {

        public AdminResponse(PortletContainer container,
                             PortletWindow portletWindow,
                             HttpServletRequest servletRequest,
                             HttpServletResponse servletResponse) {
            super(container, portletWindow, servletRequest, servletResponse);
        }
    }
}