Java RequestDispatcher.include方法代码示例

import javax.servlet.RequestDispatcher; //导入方法依赖的package包/类
public String getFileText( String originalPath, boolean virtual ) throws IOException {
try {
    ServletContextAndPath csAndP = getServletContextAndPath( originalPath, virtual );
    ServletContext context = csAndP.getServletContext();
    String path = csAndP.getPath();

    RequestDispatcher rd =
	context.getRequestDispatcher( path );
    if ( rd == null ) {
	throw new IOException("Couldn't get request dispatcher for path: " + path );
    }
    ByteArrayServletOutputStream basos = new ByteArrayServletOutputStream();
    ResponseIncludeWrapper responseIncludeWrapper =
	new ResponseIncludeWrapper(res, basos );
    rd.include(req, responseIncludeWrapper );

    //We can't assume the included servlet flushed its output
    responseIncludeWrapper.flushOutputStreamOrWriter();
    byte[] bytes = basos.toByteArray();

    //Assume that the default encoding is what was used to encode the bytes. Questionable.
    String retVal = new String( bytes );

    //make an assumption that an empty response is a failure.  This is a problem if a truly empty file 
    //were included, but not sure how else to tell.
    if ( retVal.equals("") ) {
	throw new IOException("Couldn't find file: " + path );
    }
    return retVal;
} catch (ServletException e) {
    throw new IOException("Couldn't include file: " + originalPath + " because of ServletException: " + e.getMessage() );
}
   }
 

import javax.servlet.RequestDispatcher; //导入方法依赖的package包/类
@Override
public CharSequence execute(String path)
        throws Exception {
    String responseString = "";
    if (!isInvalidPath(path)) {
        TemplateContentModelImpl contentModel = contentModel();
        SlingHttpServletRequest request = contentModel.request();
        ResourceResolver resourceResolver = request.getResourceResolver();
        Resource resource = request.getResource();
        if (path != null) {
            path = interpolate(path);
            path = attachSuffixOrPrefix(path, (String) param("prefix"), (String) param("suffix"));
            if (!path.startsWith("/")) {
                path = request.getResource().getPath() + "/" + path;
            }
            path = ResourceUtil.normalize(path);
        }
        ComponentManager componentManager = resourceResolver.adaptTo(ComponentManager.class);
        Resource tmp = request.getResourceResolver().resolve(path);
        String resourceType = interpolate((String) param("resourceType"));

        final RequestDispatcherOptions opts = new RequestDispatcherOptions();
        opts.setForceResourceType(resourceType);
        RequestDispatcher dispatcher;
        if (tmp != null) {
            if (tmp instanceof NonExistingResource) {
                if (resourceType != null) {
                    resource = new IncludeHelperSyntheticResource(request.getResourceResolver(), path, resourceType);
                    opts.remove(RequestDispatcherOptions.OPT_FORCE_RESOURCE_TYPE);
                }
            } else {
                resource = tmp;
            }
        }
        com.day.cq.wcm.api.components.Component component = componentManager.getComponentOfResource(resource);

        dispatcher = request.getRequestDispatcher(resource, opts);
        HttpServletResponse wrappedResponse = contentModel().wrappedResponse();
        dispatcher.include(request, wrappedResponse);
        responseString = wrappedResponse.toString();
    } else {
        LOG.error("{} It is not valid", path);
    }
    return new Handlebars.SafeString(responseString);
}
 

import javax.servlet.RequestDispatcher; //导入方法依赖的package包/类
public String getFileText(String originalPath, boolean virtual)
        throws IOException {
    try {
        ServletContextAndPath csAndP = getServletContextAndPath(
                originalPath, virtual);
        ServletContext context = csAndP.getServletContext();
        String path = csAndP.getPath();
        RequestDispatcher rd = context.getRequestDispatcher(path);
        if (rd == null) {
            throw new IOException(
                    "Couldn't get request dispatcher for path: " + path);
        }
        ByteArrayServletOutputStream basos =
            new ByteArrayServletOutputStream();
        ResponseIncludeWrapper responseIncludeWrapper =
            new ResponseIncludeWrapper(context, req, res, basos);
        rd.include(req, responseIncludeWrapper);
        //We can't assume the included servlet flushed its output
        responseIncludeWrapper.flushOutputStreamOrWriter();
        byte[] bytes = basos.toByteArray();

        //Assume platform default encoding unless otherwise specified
        String retVal;
        if (inputEncoding == null) {
            retVal = new String( bytes );
        } else {
            retVal = new String (bytes, inputEncoding);
        }

        //make an assumption that an empty response is a failure. This is
        // a problem
        // if a truly empty file
        //were included, but not sure how else to tell.
        if (retVal.equals("") && !req.getMethod().equalsIgnoreCase(
                org.apache.coyote.http11.Constants.HEAD)) {
            throw new IOException("Couldn't find file: " + path);
        }
        return retVal;
    } catch (ServletException e) {
        throw new IOException("Couldn't include file: " + originalPath
                + " because of ServletException: " + e.getMessage());
    }
}
 

import javax.servlet.RequestDispatcher; //导入方法依赖的package包/类
private void doInterpret(String requestURL,Map<String, Object> variables, OutputStream output) throws IOException, ServletException {
 	/**
      * 创建ServletContext对象，用于获取RequestDispatcher对象
      */
     ServletContext sc = request.getSession().getServletContext();
     /**
      * 根据传过来的相对文件路径，生成一个reqeustDispatcher的包装类
      */
     RequestDispatcher rd = sc.getRequestDispatcher(requestURL);
     /**
      * 创建一个ByteArrayOutputStream的字节数组输出流,用来存放输出的信息
      */
     final ByteArrayOutputStream baos = new ByteArrayOutputStream();
      
     /**
      * ServletOutputStream是抽象类，必须实现write的方法
      */
     final ServletOutputStream outputStream = new ServletOutputStream(){
         
         public void write(int b) throws IOException {
             /**
              * 将指定的字节写入此字节输出流
              */
             baos.write(b);
         }

	@SuppressWarnings("unused")
public boolean isReady() {
		return false;
	}

     }; 
     /**
      * 通过现有的 OutputStream 创建新的 PrintWriter
      * OutputStreamWriter 是字符流通向字节流的桥梁：可使用指定的 charset 将要写入流中的字符编码成字节
      */
     final PrintWriter pw = new PrintWriter(new OutputStreamWriter(baos, config.getOutputEncoding() ),true);
     /**
      * 生成HttpServletResponse的适配器，用来包装response
      */
     HttpServletResponse resp = new HttpServletResponseWrapper(response){
         /**
          * 调用getOutputStream的方法(此方法是ServletResponse中已有的)返回ServletOutputStream的对象
          * 用来在response中返回一个二进制输出对象
          * 此方法目的是把源文件写入byteArrayOutputStream
          */
         public ServletOutputStream getOutputStream(){
             return outputStream;
         }
          
         /**
          * 再调用getWriter的方法(此方法是ServletResponse中已有)返回PrintWriter的对象
          * 此方法用来发送字符文本到客户端
          */
         public PrintWriter getWriter(){
             return pw;
         }
     }; 
     /**
      * 在不跳转下访问目标jsp。 就是利用RequestDispatcher.include(ServletRequest request,
      * ServletResponse response)。 该方法把RequestDispatcher指向的目标页面写到response中。
      */
     rd.include(request, resp);
     pw.flush();
     /**
      * 使用ByteArrayOutputStream的writeTo方法来向文本输出流写入数据，这也是为什么要使用ByteArray的一个原因
      */
     baos.writeTo(output);
 }
 

import javax.servlet.RequestDispatcher; //导入方法依赖的package包/类
/**
 * Processes requests for both HTTP <code>GET</code> and <code>POST</code>
 * methods.
 *
 * @param request servlet request
 * @param response servlet response
 * @throws ServletException if a servlet-specific error occurs
 * @throws IOException if an I/O error occurs
 */
protected void processRequest(HttpServletRequest request, HttpServletResponse response)
        throws ServletException, IOException {
    response.setContentType("text/html;charset=UTF-8");
    RequestDispatcher rd = request.getRequestDispatcher("JSP/RessurserM11.jsp");
        rd.include(request, response);    
}
 

import javax.servlet.RequestDispatcher; //导入方法依赖的package包/类
/**
 * Processes requests for both HTTP <code>GET</code> and <code>POST</code>
 * methods.
 *
 * @param request servlet request
 * @param response servlet response
 * @throws ServletException if a servlet-specific error occurs
 * @throws IOException if an I/O error occurs.
 */ 
protected void processRequest(HttpServletRequest request, HttpServletResponse response)   
        throws ServletException, IOException {
    response.setContentType("text/html;charset=UTF-8");
        RequestDispatcher rd = request.getRequestDispatcher("JSP/lagTilbakemelding.jsp");
        rd.include(request, response);
        
}
 

import javax.servlet.RequestDispatcher; //导入方法依赖的package包/类
/**
 * Processes requests for both HTTP <code>GET</code> and <code>POST</code>
 * methods.
 *
 * @param request servlet request
 * @param response servlet response
 * @throws ServletException if a servlet-specific error occurs
 * @throws IOException if an I/O error occurs
 */
protected void processRequest(HttpServletRequest request, HttpServletResponse response)
        throws ServletException, IOException {
    response.setContentType("text/html;charset=UTF-8");
    RequestDispatcher rd = request.getRequestDispatcher("JSP/RessurserM4.jsp");
        rd.include(request, response);    
}
 

import javax.servlet.RequestDispatcher; //导入方法依赖的package包/类
/**
 * Processes requests for both HTTP <code>GET</code> and <code>POST</code>
 * methods.
 *
 * @param request servlet request
 * @param response servlet response
 * @throws ServletException if a servlet-specific error occurs
 * @throws IOException if an I/O error occurs
 */
protected void processRequest(HttpServletRequest request, HttpServletResponse response)
        throws ServletException, IOException {
    response.setContentType("text/html;charset=UTF-8");
    RequestDispatcher rd = request.getRequestDispatcher("JSP/RessurserM15.jsp");
        rd.include(request, response);    
}
 

import javax.servlet.RequestDispatcher; //导入方法依赖的package包/类
/**
 * Processes requests for both HTTP <code>GET</code> and <code>POST</code>
 * methods.
 *
 * @param request servlet request
 * @param response servlet response
 * @throws ServletException if a servlet-specific error occurs
 * @throws IOException if an I/O error occurs
 */
protected void processRequest(HttpServletRequest request, HttpServletResponse response)
        throws ServletException, IOException {
    response.setContentType("text/html;charset=UTF-8");
    RequestDispatcher rd = request.getRequestDispatcher("JSP/RessurserM2.jsp");
        rd.include(request, response);    
}
 

import javax.servlet.RequestDispatcher; //导入方法依赖的package包/类
/**
 * Processes requests for both HTTP <code>GET</code> and <code>POST</code>
 * methods.
 *
 * @param request servlet request
 * @param response servlet response
 * @throws ServletException if a servlet-specific error occurs
 * @throws IOException if an I/O error occurs
 */
protected void processRequest(HttpServletRequest request, HttpServletResponse response)
        throws ServletException, IOException {
    response.setContentType("text/html;charset=UTF-8");
    RequestDispatcher rd = request.getRequestDispatcher("JSP/RessurserM5.jsp");
        rd.include(request, response);    
}
 

import javax.servlet.RequestDispatcher; //导入方法依赖的package包/类
/**
 * Processes requests for both HTTP <code>GET</code> and <code>POST</code>
 * methods.
 *
 * @param request servlet request
 * @param response servlet response
 * @throws ServletException if a servlet-specific error occurs
 * @throws IOException if an I/O error occurs
 */
protected void processRequest(HttpServletRequest request, HttpServletResponse response)
        throws ServletException, IOException {
    response.setContentType("text/html;charset=UTF-8");
    RequestDispatcher rd = request.getRequestDispatcher("JSP/RessurserM12.jsp");
        rd.include(request, response);    
}
 

import javax.servlet.RequestDispatcher; //导入方法依赖的package包/类
/**
 * Processes requests for both HTTP <code>GET</code> and <code>POST</code>
 * methods.
 *
 * @param request servlet request
 * @param response servlet response
 * @throws ServletException if a servlet-specific error occurs
 * @throws IOException if an I/O error occurs
 */
protected void processRequest(HttpServletRequest request, HttpServletResponse response)
        throws ServletException, IOException {
    response.setContentType("text/html;charset=UTF-8");
    RequestDispatcher rd = request.getRequestDispatcher("JSP/RessurserM9.jsp");
        rd.include(request, response);    
}
 

import javax.servlet.RequestDispatcher; //导入方法依赖的package包/类
/**
 * Processes requests for both HTTP <code>GET</code> and <code>POST</code>
 * methods.
 *
 * @param request servlet request
 * @param response servlet response
 * @throws ServletException if a servlet-specific error occurs
 * @throws IOException if an I/O error occurs
 */
protected void processRequest(HttpServletRequest request, HttpServletResponse response)
        throws ServletException, IOException {
    response.setContentType("text/html;charset=UTF-8");
    RequestDispatcher rd = request.getRequestDispatcher("JSP/RessurserM14.jsp");
        rd.include(request, response);    
}
 

import javax.servlet.RequestDispatcher; //导入方法依赖的package包/类
/**
 * Processes requests for both HTTP <code>GET</code> and <code>POST</code>
 * methods.
 *
 * @param request servlet request
 * @param response servlet response
 * @throws ServletException if a servlet-specific error occurs
 * @throws IOException if an I/O error occurs
 */
protected void processRequest(HttpServletRequest request, HttpServletResponse response)
        throws ServletException, IOException {
    response.setContentType("text/html;charset=UTF-8");
    RequestDispatcher rd = request.getRequestDispatcher("JSP/RessurserM13.jsp");
        rd.include(request, response);    
}
 

import javax.servlet.RequestDispatcher; //导入方法依赖的package包/类
/**
 * Processes requests for both HTTP <code>GET</code> and <code>POST</code>
 * methods.
 *
 * @param request servlet request
 * @param response servlet response
 * @throws ServletException if a servlet-specific error occurs
 * @throws IOException if an I/O error occurs
 */
protected void processRequest(HttpServletRequest request, HttpServletResponse response)
        throws ServletException, IOException {
    response.setContentType("text/html;charset=UTF-8");
    RequestDispatcher rd = request.getRequestDispatcher("JSP/Innstillinger.jsp");
        rd.include(request, response);    
}