cmsxmltemplateloader.java

OpenCms 是一个J2EE的产品

            CmsResponseHttpServlet cmsRes = new CmsResponseHttpServlet(req, res);
            cms.getRequestContext().setAttribute(I_CmsRequest.C_CMS_REQUEST, cmsReq);
            cms.getRequestContext().setAttribute(I_CmsResponse.C_CMS_RESPONSE, cmsRes);
        } catch (IOException e) {
            throw new CmsLegacyException("Trouble setting up legacy request / response", e);
        }    
    }
    
    /**
     * Internal utility method for checking and loading a given template file.
     * @param cms CmsObject for accessing system resources.
     * @param templateName Name of the requestet template file.
     * @param doc CmsXmlControlFile object containig the parsed body file.
     * @return CmsFile object of the requested template file.
     * @throws CmsException if something goes wrong
     */
    private CmsFile loadMasterTemplateFile(CmsObject cms, String templateName, com.opencms.template.CmsXmlControlFile doc) throws CmsException {
        CmsFile masterTemplate = null;
        try {
            masterTemplate = cms.readFile(templateName);
        } catch (Exception e) {
            handleException(cms, e, "Cannot load master template " + templateName + ". ");
            doc.removeFromFileCache();
        }
        return masterTemplate;
    }
    
    /**
     * Processes the XmlTemplates and writes the result to 
     * the apropriate output stream, which is obtained from the request 
     * context of the cms object.<p>
     *
     * @param cms the cms context object
     * @param file the selected resource to be shown
     * @throws CmsException if something goes wrong
     */
    private void processXmlTemplate(CmsObject cms, CmsFile file) throws CmsException {

        // first some debugging output.
        if ((DEBUG > 0) && CmsLog.getLog(this).isDebugEnabled()) {
            CmsLog.getLog(this).debug("Loader started for " + file.getName());
        }

        // check all values to be valid
        String errorMessage = null;
        if (file == null) {
            errorMessage = "CmsFile missing";
        }
        if (cms == null) {
            errorMessage = "CmsObject missing";
        }
        if (errorMessage != null) {
            if (CmsLog.getLog(this).isErrorEnabled()) {
                CmsLog.getLog(this).error(errorMessage);
            } 
            throw new CmsLegacyException(errorMessage, CmsLegacyException.C_LOADER_GENERIC_ERROR);
        }

        // Check the clearcache parameter
        String clearcache = getRequest(cms.getRequestContext()).getParameter("_clearcache");
        
        // Clear loader caches if this is required
        clearLoaderCache(((clearcache != null) && ("all".equals(clearcache) || "file".equals(clearcache))), 
            ((clearcache != null) && ("all".equals(clearcache) || "template".equals(clearcache))));
        
        // get the CmsRequest
        I_CmsRequest req = getRequest(cms.getRequestContext());
        byte[] result = generateOutput(cms, file, req);
        if (result != null) {
            writeBytesToResponse(cms, result);
        }
    }    
        
    /**
     * @see org.opencms.loader.I_CmsResourceLoader#service(org.opencms.file.CmsObject, org.opencms.file.CmsResource, javax.servlet.ServletRequest, javax.servlet.ServletResponse)
     */
    public void service(CmsObject cms, CmsResource file, ServletRequest req, ServletResponse res)
    throws CmsException, IOException {
        
        long timer1 = 0;
        if (DEBUG > 0) {
            timer1 = System.currentTimeMillis();        
            System.err.println("============ CmsXmlTemplateLoader loading: " + cms.getSitePath(file));            
            System.err.println("CmsXmlTemplateLoader.service() cms uri is: " + cms.getRequestContext().getUri());            
        }
        // save the original context settings
        String rnc = cms.getRequestContext().getEncoding().trim();
        // String oldUri = cms.getRequestContext().getUri();
        
        initLegacyRequest(cms, (HttpServletRequest)req, (HttpServletResponse)res);        
        I_CmsRequest cms_req = CmsXmlTemplateLoader.getRequest(cms.getRequestContext());        
        HttpServletRequest originalreq = cms_req.getOriginalRequest();
        
        try {                        
            // get the CmsRequest
            byte[] result = null;
            org.opencms.file.CmsFile fx = cms.readFile(cms.getSitePath(file));            
            // care about encoding issues
            String dnc = OpenCms.getSystemInfo().getDefaultEncoding().trim();
            String enc = cms.readPropertyObject(cms.getSitePath(fx), CmsPropertyDefinition.PROPERTY_CONTENT_ENCODING, true).getValue(dnc).trim();
            // fake the called URI (otherwise XMLTemplate / ElementCache would not work)            
            cms_req.setOriginalRequest((HttpServletRequest)req);
            cms.getRequestContext().setEncoding(enc);      
            if (DEBUG > 1) {
                System.err.println("CmsXmlTemplateLoader.service(): Encodig set to " + cms.getRequestContext().getEncoding());
                System.err.println("CmsXmlTemplateLoader.service(): Uri set to " + cms.getRequestContext().getUri());
            }
            // process the included XMLTemplate
            result = generateOutput(cms, fx, cms_req);                                    
            // append the result to the output stream
            if (result != null) {
                if (DEBUG > 1) {
                    System.err.println("CmsXmlTemplateLoader.service(): encoding=" + enc + " requestEncoding=" + rnc + " defaultEncoding=" + dnc);
                }
                res.getOutputStream().write(result);
            }        
        } finally {
            // restore the context settings
            cms_req.setOriginalRequest(originalreq);
            cms.getRequestContext().setEncoding(rnc);
            // cms.getRequestContext().setUri(oldUri);
            if (DEBUG > 1) {
                System.err.println("CmsXmlTemplateLoader.service(): Encodig reset to " + cms.getRequestContext().getEncoding());
                System.err.println("CmsXmlTemplateLoader.service(): Uri reset to " + cms.getRequestContext().getUri());
            }
        }
        
        if (DEBUG > 0) {
            long timer2 = System.currentTimeMillis() - timer1;        
            System.err.println("============ CmsXmlTemplateLoader time delivering XmlTemplate for " + cms.getSitePath(file) + ": " + timer2 + "ms");            
        }
    } 

    /**
     * Writes a given byte array to the HttpServletRespose output stream.<p>
     * 
     * @param cms an initialized CmsObject
     * @param result byte array that should be written.
     * @throws CmsException if something goes wrong
     */
    private void writeBytesToResponse(CmsObject cms, byte[] result) throws CmsException {
        try {
            I_CmsResponse resp = getResponse(cms.getRequestContext());
            if ((result != null) && !resp.isRedirected()) {
                // Only write any output to the response output stream if
                // the current request is neither redirected nor streamed.
                OutputStream out = resp.getOutputStream();

                resp.setContentLength(result.length);
                resp.setHeader("Connection", "keep-alive");
                out.write(result);
                out.close();
            }
        } catch (IOException ioe) {
            if (CmsLog.getLog(this).isDebugEnabled()) {
                CmsLog.getLog(this).debug("IO error while writing to response stream for " + cms.getRequestContext().getUri(), ioe);
            }
        } catch (Exception e) {
            String errorMessage = "Cannot write output to HTTP response stream";
            handleException(cms, e, errorMessage);
        }
    }

    /**
     * @see org.opencms.loader.I_CmsResourceLoader#dump(org.opencms.file.CmsObject, org.opencms.file.CmsResource, java.lang.String, java.util.Locale, javax.servlet.http.HttpServletRequest, javax.servlet.http.HttpServletResponse)
     */
    public byte[] dump(CmsObject cms, CmsResource file, String element, Locale locale, HttpServletRequest req, HttpServletResponse res) 
    throws CmsException {
        initLegacyRequest(cms, req, res);        
        String absolutePath = cms.getSitePath(file);
        // this will work for the "default" template class com.opencms.template.CmsXmlTemplate only
        CmsXmlTemplate template = new CmsXmlTemplate();
        // get the appropriate content and convert it to bytes
        return template.getContent(cms, absolutePath, element, null);
    }

    /**
     * @see org.opencms.loader.I_CmsResourceLoader#isStaticExportEnabled()
     */
    public boolean isStaticExportEnabled() {
        return true;
    }
    
    /**
     * @see org.opencms.loader.I_CmsResourceLoader#isStaticExportProcessable()
     */
    public boolean isStaticExportProcessable() {
        return true;
    }
    
    
    /**
     * @see org.opencms.loader.I_CmsResourceLoader#isUsableForTemplates()
     */
    public boolean isUsableForTemplates() {
        return true;
    }

    /**
     * @see org.opencms.loader.I_CmsResourceLoader#isUsingUriWhenLoadingTemplate()
     */
    public boolean isUsingUriWhenLoadingTemplate() {
        return true;
    }

    /**
     * @see org.opencms.loader.I_CmsLoaderIncludeExtension#includeExtension(java.lang.String, java.lang.String, boolean, java.util.Map, javax.servlet.ServletRequest, javax.servlet.ServletResponse)
     */
    public String includeExtension(String target, String element, boolean editable, Map parameterMap, ServletRequest req, ServletResponse res) throws CmsException {
        // the Flex controller provides access to the interal OpenCms structures
        CmsFlexController controller = CmsFlexController.getController(req);
        // simple sanity check, controller should never be null here
        if (controller == null) {
            return target;
        }
        // special code to handle XmlTemplate based file includes        
        if (element != null) {
            if (!("body".equals(element) || "(default)".equals(element))) {
                // add template selector for multiple body XML files
                CmsJspTagInclude.addParameter(parameterMap, CmsXmlTemplate.C_FRAME_SELECTOR, element, true);
            }
        }        
        boolean isPageTarget;
        try {            
            // check if the target does exist in the OpenCms VFS
            CmsResource targetResource = controller.getCmsObject().readResource(target);
            isPageTarget = ((CmsResourceTypePage.getStaticTypeId() == targetResource.getTypeId()));
        } catch (CmsException e) {
            controller.setThrowable(e, target);
            throw new CmsLegacyException("File not found: " + target, e);
        }
        String bodyAttribute = (String) controller.getCmsObject().getRequestContext().getAttribute(CmsDefaultPageEditor.XML_BODY_ELEMENT);               
        if (bodyAttribute == null) {
            // no body attribute is set: this is NOT a sub-element in a XML mastertemplate
            if (isPageTarget) {
                // add body file path to target 
                if (! target.startsWith(CmsCompatibleCheck.VFS_PATH_BODIES)) {
                    target = CmsCompatibleCheck.VFS_PATH_BODIES + target.substring(1);
                }
                // save target as "element replace" parameter for body loader
                CmsJspTagInclude.addParameter(parameterMap, CmsXmlTemplateLoader.C_ELEMENT_REPLACE, "body:" + target, true);  
                target = C_BODYLOADER_URI;                   
            }
        } else {
            // body attribute is set: this is a sub-element in a XML mastertemplate
            if (target.equals(controller.getCmsObject().getRequestContext().getUri())) {
                // target can be ignored, set body attribute as "element replace" parameter  
                CmsJspTagInclude.addParameter(parameterMap, CmsXmlTemplateLoader.C_ELEMENT_REPLACE, "body:" + bodyAttribute, true);
                // redirect target to body loader
                target = C_BODYLOADER_URI;                
            } else {
                if (isPageTarget) {
                    // add body file path to target 
                    if (isPageTarget && ! target.startsWith(CmsCompatibleCheck.VFS_PATH_BODIES)) {
                        target = CmsCompatibleCheck.VFS_PATH_BODIES + target.substring(1);
                    }           
                    // save target as "element replace" parameter  
                    CmsJspTagInclude.addParameter(parameterMap, CmsXmlTemplateLoader.C_ELEMENT_REPLACE, "body:" + target, true);  
                    target = C_BODYLOADER_URI;                     
                }
            }          
        }
        
        return target;
    }
    
    /**
     * Provides access to the current request through a CmsRequestContext, 
     * required for legacy backward compatibility.<p>
     * 
     * @param context the current request context
     * @return the request, of null if no request is available
     */
    public static I_CmsRequest getRequest(CmsRequestContext context) {
        return (I_CmsRequest)context.getAttribute(I_CmsRequest.C_CMS_REQUEST);
    }

    /**
     * Provides access to the current response through a CmsRequestContext, 
     * required for legacy backward compatibility.<p>
     * 
     * @param context the current request context
     * @return the response, of null if no request is available
     */
    public static I_CmsResponse getResponse(CmsRequestContext context) {
        return (I_CmsResponse)context.getAttribute(I_CmsResponse.C_CMS_RESPONSE);
    }
       
    /**
     * Provides access to the current session through a CmsRequestContext, 
     * required for legacy backward compatibility.<p>
     * 
     * @param context the current request context
     * @param value if true, try to create a session if none exist, if false, do not create a session
     * @return the response, of null if no request is available
     */
    public static I_CmsSession getSession(CmsRequestContext context, boolean value) {
        I_CmsRequest req = (I_CmsRequest)context.getAttribute(I_CmsRequest.C_CMS_REQUEST);
        HttpSession session = req.getOriginalRequest().getSession(value);
        if (session != null) {
            return new CmsSession(session);
        } else {
            return null;
        }
    }

    /**
     * @see org.opencms.configuration.I_CmsConfigurationParameterHandler#addConfigurationParameter(java.lang.String, java.lang.String)
     */
    public void addConfigurationParameter(String paramName, String paramValue) {
        
        m_configuration.put(paramName, paramValue);        
    }

    /**
     * @see org.opencms.configuration.I_CmsConfigurationParameterHandler#getConfiguration()
     */
    public Map getConfiguration() {
        
        // return the configuration in an immutable form
        return Collections.unmodifiableMap(m_configuration);  
    }
}