Java tutorial
/* * This library is part of OpenCms - * the Open Source Content Management System * * Copyright (c) Alkacon Software GmbH (http://www.alkacon.com) * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public * License as published by the Free Software Foundation; either * version 2.1 of the License, or (at your option) any later version. * * This library is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Lesser General Public License for more details. * * For further information about Alkacon Software GmbH, please see the * company website: http://www.alkacon.com * * For further information about OpenCms, please see the * project website: http://www.opencms.org * * You should have received a copy of the GNU Lesser General Public * License along with this library; if not, write to the Free Software * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ package org.opencms.flex; import org.opencms.file.CmsObject; import org.opencms.file.CmsPropertyDefinition; import org.opencms.file.CmsResource; import org.opencms.file.CmsVfsResourceNotFoundException; import org.opencms.loader.I_CmsResourceLoader; import org.opencms.main.CmsException; import org.opencms.main.CmsLog; import org.opencms.main.OpenCms; import java.io.IOException; import java.util.List; import java.util.Map; import javax.servlet.RequestDispatcher; import javax.servlet.ServletException; import javax.servlet.ServletRequest; import javax.servlet.ServletResponse; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse; import org.apache.commons.logging.Log; /** * Implementation of the <code>{@link javax.servlet.RequestDispatcher}</code> interface to allow JSPs to be loaded * from the OpenCms VFS.<p> * * This dispatcher will load data from 3 different data sources: * <ol> * <li>Form the "real" os File system (e.g. for JSP pages) * <li>From the OpenCms VFS * <li>From the Flex cache * </ol> * <p> * * @since 6.0.0 */ public class CmsFlexRequestDispatcher implements RequestDispatcher { /** The log object for this class. */ private static final Log LOG = CmsLog.getLog(CmsFlexRequestDispatcher.class); /** The external target that will be included by the RequestDispatcher, needed if this is not a dispatcher to a cms resource. */ private String m_extTarget; /** The "real" RequestDispatcher, used when a true include (to the file system) is needed. */ private RequestDispatcher m_rd; /** The OpenCms VFS target that will be included by the RequestDispatcher. */ private String m_vfsTarget; /** * Creates a new instance of CmsFlexRequestDispatcher.<p> * * @param rd the "real" dispatcher, used for include call to file system * @param vfs_target the cms resource that represents the external target * @param ext_target the external target that the request will be dispatched to */ public CmsFlexRequestDispatcher(RequestDispatcher rd, String vfs_target, String ext_target) { m_rd = rd; m_vfsTarget = vfs_target; m_extTarget = ext_target; } /** * Wrapper for the standard servlet API call.<p> * * Forward calls are actually NOT wrapped by OpenCms as of now. * So they should not be used in JSP pages or servlets.<p> * * @param req the servlet request * @param res the servlet response * @throws ServletException in case something goes wrong * @throws IOException in case something goes wrong * * @see javax.servlet.RequestDispatcher#forward(javax.servlet.ServletRequest, javax.servlet.ServletResponse) */ public void forward(ServletRequest req, ServletResponse res) throws ServletException, IOException { CmsFlexController controller = CmsFlexController.getController(req); controller.setForwardMode(true); m_rd.forward(req, res); } /** * Wrapper for dispatching to a file from the OpenCms VFS.<p> * * This method will dispatch to cache, to real file system or * to the OpenCms VFS, whatever is needed.<p> * * This method is much more complex than it should be because of the internal standard * buffering of JSP pages. * Because of that I can not just intercept and buffer the stream, since I don't have * access to it (it is wrapped internally in the JSP pages, which have their own buffer). * That leads to a solution where the data is first written to the buffered stream, * but without includes. Then it is parsed again later * in the <code>{@link CmsFlexResponse}</code>, enriched with the * included elements that have been omitted in the first case. * I would love to see a simpler solution, but this works for now.<p> * * @param req the servlet request * @param res the servlet response * * @throws ServletException in case something goes wrong * @throws IOException in case something goes wrong */ public void include(ServletRequest req, ServletResponse res) throws ServletException, IOException { if (LOG.isDebugEnabled()) { LOG.debug(Messages.get().getBundle().key(Messages.LOG_FLEXREQUESTDISPATCHER_INCLUDING_TARGET_2, m_vfsTarget, m_extTarget)); } CmsFlexController controller = CmsFlexController.getController(req); CmsResource resource = null; if ((m_extTarget == null) && (controller != null)) { // check if the file exists in the VFS, if not set external target try { resource = controller.getCmsObject().readResource(m_vfsTarget); } catch (CmsVfsResourceNotFoundException e) { // file not found in VFS, treat it as external file m_extTarget = m_vfsTarget; } catch (CmsException e) { // if other OpenCms exception occurred we are in trouble throw new ServletException( Messages.get().getBundle().key(Messages.ERR_FLEXREQUESTDISPATCHER_VFS_ACCESS_EXCEPTION_0), e); } } if ((m_extTarget != null) || (controller == null)) { includeExternal(req, res); } else if (controller.isForwardMode()) { includeInternalNoCache(req, res, controller, controller.getCmsObject(), resource); } else { includeInternalWithCache(req, res, controller, controller.getCmsObject(), resource); } } /** * Include an external (non-OpenCms) file using the standard dispatcher.<p> * * @param req the servlet request * @param res the servlet response * * @throws ServletException in case something goes wrong * @throws IOException in case something goes wrong */ private void includeExternal(ServletRequest req, ServletResponse res) throws ServletException, IOException { // This is an external include, probably to a JSP page, dispatch with system dispatcher if (LOG.isInfoEnabled()) { LOG.info(Messages.get().getBundle().key(Messages.LOG_FLEXREQUESTDISPATCHER_INCLUDING_EXTERNAL_TARGET_1, m_extTarget)); } m_rd.include(req, res); } /** * Includes the requested resource, ignoring the Flex cache.<p> * * @param req the servlet request * @param res the servlet response * @param controller the flex controller * @param cms the cms context * @param resource the requested resource (may be <code>null</code>) * * @throws ServletException in case something goes wrong * @throws IOException in case something goes wrong */ private void includeInternalNoCache(ServletRequest req, ServletResponse res, CmsFlexController controller, CmsObject cms, CmsResource resource) throws ServletException, IOException { // load target with the internal resource loader I_CmsResourceLoader loader; try { if (resource == null) { resource = cms.readResource(m_vfsTarget); } if (LOG.isDebugEnabled()) { LOG.debug(Messages.get().getBundle().key(Messages.LOG_FLEXREQUESTDISPATCHER_LOADING_RESOURCE_TYPE_1, new Integer(resource.getTypeId()))); } loader = OpenCms.getResourceManager().getLoader(resource); } catch (CmsException e) { // file might not exist or no read permissions controller.setThrowable(e, m_vfsTarget); throw new ServletException(Messages.get().getBundle() .key(Messages.ERR_FLEXREQUESTDISPATCHER_ERROR_READING_RESOURCE_1, m_vfsTarget), e); } if (LOG.isDebugEnabled()) { LOG.debug(Messages.get().getBundle().key(Messages.LOG_FLEXREQUESTDISPATCHER_INCLUDE_RESOURCE_1, m_vfsTarget)); } try { loader.service(cms, resource, req, res); } catch (CmsException e) { // an error occurred during access to OpenCms controller.setThrowable(e, m_vfsTarget); throw new ServletException(e); } } /** * Includes the requested resource, ignoring the Flex cache.<p> * * @param req the servlet request * @param res the servlet response * @param controller the Flex controller * @param cms the current users OpenCms context * @param resource the requested resource (may be <code>null</code>) * * @throws ServletException in case something goes wrong * @throws IOException in case something goes wrong */ private void includeInternalWithCache(ServletRequest req, ServletResponse res, CmsFlexController controller, CmsObject cms, CmsResource resource) throws ServletException, IOException { CmsFlexCache cache = controller.getCmsCache(); // this is a request through the CMS CmsFlexRequest f_req = controller.getCurrentRequest(); CmsFlexResponse f_res = controller.getCurrentResponse(); if (f_req.containsIncludeCall(m_vfsTarget)) { // this resource was already included earlier, so we have a (probably endless) inclusion loop throw new ServletException(Messages.get().getBundle() .key(Messages.ERR_FLEXREQUESTDISPATCHER_INCLUSION_LOOP_1, m_vfsTarget)); } else { f_req.addInlucdeCall(m_vfsTarget); } // do nothing if response is already finished (probably as a result of an earlier redirect) if (f_res.isSuspended()) { // remove this include call if response is suspended (e.g. because of redirect) f_res.setCmsIncludeMode(false); f_req.removeIncludeCall(m_vfsTarget); return; } // indicate to response that all further output or headers are result of include calls f_res.setCmsIncludeMode(true); // create wrapper for request & response CmsFlexRequest w_req = new CmsFlexRequest((HttpServletRequest) req, controller, m_vfsTarget); CmsFlexResponse w_res = new CmsFlexResponse((HttpServletResponse) res, controller); // push req/res to controller stack controller.push(w_req, w_res); // now that the req/res are on the stack, we need to make sure that they are removed later // that's why we have this try { ... } finally { ... } clause here try { CmsFlexCacheEntry entry = null; if (f_req.isCacheable()) { // caching is on, check if requested resource is already in cache entry = cache.get(w_req.getCmsCacheKey()); if (entry != null) { // the target is already in the cache try { if (LOG.isDebugEnabled()) { LOG.debug(Messages.get().getBundle().key( Messages.LOG_FLEXREQUESTDISPATCHER_LOADING_RESOURCE_FROM_CACHE_1, m_vfsTarget)); } controller.updateDates(entry.getDateLastModified(), entry.getDateExpires()); entry.service(w_req, w_res); } catch (CmsException e) { Throwable t; if (e.getCause() != null) { t = e.getCause(); } else { t = e; } t = controller.setThrowable(e, m_vfsTarget); throw new ServletException(Messages.get().getBundle().key( Messages.ERR_FLEXREQUESTDISPATCHER_ERROR_LOADING_RESOURCE_FROM_CACHE_1, m_vfsTarget), t); } } else { // cache is on and resource is not yet cached, so we need to read the cache key for the response CmsFlexCacheKey res_key = cache .getKey(CmsFlexCacheKey.getKeyName(m_vfsTarget, w_req.isOnline())); if (res_key != null) { // key already in cache, reuse it w_res.setCmsCacheKey(res_key); } else { // cache key is unknown, read key from properties String cacheProperty = null; try { // read caching property from requested VFS resource if (resource == null) { resource = cms.readResource(m_vfsTarget); } cacheProperty = cms .readPropertyObject(resource, CmsPropertyDefinition.PROPERTY_CACHE, true) .getValue(); if (cacheProperty == null) { // caching property not set, use default for resource type cacheProperty = OpenCms.getResourceManager().getResourceType(resource.getTypeId()) .getCachePropertyDefault(); } cache.putKey(w_res.setCmsCacheKey(cms.getRequestContext().addSiteRoot(m_vfsTarget), cacheProperty, f_req.isOnline())); } catch (CmsFlexCacheException e) { // invalid key is ignored but logged, used key is cache=never if (LOG.isWarnEnabled()) { LOG.warn(Messages.get().getBundle().key( Messages.LOG_FLEXREQUESTDISPATCHER_INVALID_CACHE_KEY_2, m_vfsTarget, cacheProperty)); } // there will be a valid key in the response ("cache=never") even after an exception cache.putKey(w_res.getCmsCacheKey()); } catch (CmsException e) { // all other errors are not handled here controller.setThrowable(e, m_vfsTarget); throw new ServletException(Messages.get().getBundle().key( Messages.ERR_FLEXREQUESTDISPATCHER_ERROR_LOADING_CACHE_PROPERTIES_1, m_vfsTarget), e); } if (LOG.isDebugEnabled()) { LOG.debug(Messages.get().getBundle().key( Messages.LOG_FLEXREQUESTDISPATCHER_ADDING_CACHE_PROPERTIES_2, m_vfsTarget, cacheProperty)); } } } } if (entry == null) { // the target is not cached (or caching off), so load it with the internal resource loader I_CmsResourceLoader loader = null; String variation = null; // check cache keys to see if the result can be cached if (w_req.isCacheable()) { variation = w_res.getCmsCacheKey().matchRequestKey(w_req.getCmsCacheKey()); } // indicate to the response if caching is not required w_res.setCmsCachingRequired(!controller.isForwardMode() && (variation != null)); try { if (resource == null) { resource = cms.readResource(m_vfsTarget); } if (LOG.isDebugEnabled()) { LOG.debug(Messages.get().getBundle().key( Messages.LOG_FLEXREQUESTDISPATCHER_LOADING_RESOURCE_TYPE_1, new Integer(resource.getTypeId()))); } loader = OpenCms.getResourceManager().getLoader(resource); } catch (ClassCastException e) { controller.setThrowable(e, m_vfsTarget); throw new ServletException(Messages.get().getBundle() .key(Messages.ERR_FLEXREQUESTDISPATCHER_CLASSCAST_EXCEPTION_1, m_vfsTarget), e); } catch (CmsException e) { // file might not exist or no read permissions controller.setThrowable(e, m_vfsTarget); throw new ServletException(Messages.get().getBundle() .key(Messages.ERR_FLEXREQUESTDISPATCHER_ERROR_READING_RESOURCE_1, m_vfsTarget), e); } if (LOG.isDebugEnabled()) { LOG.debug(Messages.get().getBundle().key(Messages.LOG_FLEXREQUESTDISPATCHER_INCLUDE_RESOURCE_1, m_vfsTarget)); } try { loader.service(cms, resource, w_req, w_res); } catch (CmsException e) { // an error occurred during access to OpenCms controller.setThrowable(e, m_vfsTarget); throw new ServletException(e); } entry = w_res.processCacheEntry(); if ((entry != null) && (variation != null) && w_req.isCacheable()) { // the result can be cached if (w_res.getCmsCacheKey().getTimeout() > 0) { // cache entry has a timeout, set last modified to time of last creation entry.setDateLastModifiedToPreviousTimeout(w_res.getCmsCacheKey().getTimeout()); entry.setDateExpiresToNextTimeout(w_res.getCmsCacheKey().getTimeout()); controller.updateDates(entry.getDateLastModified(), entry.getDateExpires()); } else { // no timeout, use last modified date from files in VFS entry.setDateLastModified(controller.getDateLastModified()); entry.setDateExpires(controller.getDateExpires()); } cache.put(w_res.getCmsCacheKey(), entry, variation); } else { // result can not be cached, do not use "last modified" optimization controller.updateDates(-1, controller.getDateExpires()); } } if (f_res.hasIncludeList()) { // special case: this indicates that the output was not yet displayed Map<String, List<String>> headers = w_res.getHeaders(); byte[] result = w_res.getWriterBytes(); if (LOG.isDebugEnabled()) { LOG.debug(Messages.get().getBundle().key(Messages.LOG_FLEXREQUESTDISPATCHER_RESULT_1, new String(result))); } CmsFlexResponse.processHeaders(headers, f_res); f_res.addToIncludeResults(result); result = null; } } finally { // indicate to response that include is finished f_res.setCmsIncludeMode(false); f_req.removeIncludeCall(m_vfsTarget); // pop req/res from controller stack controller.pop(); } } }