JSF 1.2 and Tiles integration

Question

I have a web application using JSF 1.1 and Tiles that I am trying to upgrade to run using JSF 1.2.
It is working as far as working out that it should use the tile, but then it all seems to fall over when trying to render.
Does anyone know if it is possible to use Tiles with JSF 1.2?
Steven

Answer 1

Hi,
I took the Shales TileViewHandler and replaced the renderView method with the one below. This is a copy of the method from the Sun RI except that it passes the tile (ComponentDefinition) along to the subsequent methods.
Then when it gets down to executePageToBuildView the requestURI is obtained from the tile (tile.getPath()) rather than from the UIViewRoot (viewToExecute.getViewId()).
   public void renderView(FacesContext facesContext, UIViewRoot viewToRender)
                                        throws IOException, FacesException {
      String viewId = viewToRender.getViewId();
      String tileName = getTileName(viewId);
      ComponentDefinition tile = getTile(tileName);
      if (log.isDebugEnabled()) {
         String message = null;
         try {
             message = bundle.getString("tiles.renderingView");
         } catch (MissingResourceException e) {
             message = "Rendering view {0}, looking for tile {1}";
         synchronized(format) {
            format.applyPattern(message);
            message = format.format(new Object[] { viewId, tileName });
         log.debug(message);
      if (tile != null) {
         if (log.isDebugEnabled()) {
            String message = null;
            try {
                message = bundle.getString("tiles.dispatchingToTile");
            } catch (MissingResourceException e) {
                message = "Dispatching to tile {0}";
            synchronized(format) {
               format.applyPattern(message);
               message = format.format(new Object[] { tileName });
            log.debug(message);
         dispatchToTile(facesContext, viewToRender, tile);
      else {
         if (log.isDebugEnabled()) {
            String message = null;
            try {
                message = bundle.getString("tiles.dispatchingToViewHandler");
            } catch (MissingResourceException e) {
                message = "Dispatching {0} to the default view handler";
            synchronized(format) {
               format.applyPattern(message);
               message = format.format(new Object[] { viewId });
            log.debug(message);
         defaultViewHandler.renderView(facesContext, viewToRender);
   private void dispatchToTile(FacesContext facesContext, UIViewRoot viewToRender, ComponentDefinition tile) throws java.io.IOException
       ExternalContext externalContext = facesContext.getExternalContext();
       Object request = externalContext.getRequest();
      Object context = externalContext.getContext();
      TilesContext tilesContext = TilesContextFactory.getInstance(context, request);
      ComponentContext tileContext = ComponentContext.getContext(tilesContext);
      if (tileContext == null) {
         tileContext = new ComponentContext(tile.getAttributes());
         ComponentContext.setContext(tileContext, tilesContext);
      else
         tileContext.addMissing(tile.getAttributes());
      renderTile(facesContext, viewToRender, tile);
      // dispatch to the tile's layout
      //externalContext.dispatch(tile.getPath());
   private void renderTile(FacesContext context, UIViewRoot viewToRender, ComponentDefinition tile) throws IOException, FacesException
       // suppress rendering if "rendered" property on the component is
       // false
       if (!viewToRender.isRendered()) {
           return;
       ExternalContext extContext = context.getExternalContext();
       ServletRequest request = (ServletRequest) extContext.getRequest();
       ServletResponse response = (ServletResponse) extContext.getResponse();
       try {
           if (executePageToBuildView(context, viewToRender, tile)) {
               response.flushBuffer();
               //ApplicationAssociate.getInstance(extContext).responseRendered();
               return;
       } catch (IOException e) {
           throw new FacesException(e);
       // set up the ResponseWriter
       RenderKitFactory renderFactory = (RenderKitFactory)
       FactoryFinder.getFactory(FactoryFinder.RENDER_KIT_FACTORY);
       RenderKit renderKit =
               renderFactory.getRenderKit(context, viewToRender.getRenderKitId());       
       ResponseWriter oldWriter = context.getResponseWriter();
       initBuffSize(context);
       WriteBehindStringWriter strWriter =
             new WriteBehindStringWriter(context, bufSize);
       ResponseWriter newWriter;
       if (null != oldWriter) {
           newWriter = oldWriter.cloneWithWriter(strWriter);
       } else {
           newWriter = renderKit.createResponseWriter(strWriter, null,
                   request.getCharacterEncoding());           
       context.setResponseWriter(newWriter);
       newWriter.startDocument();
       doRenderView(context, viewToRender);
       newWriter.endDocument();
       // replace markers in the body content and write it to response.
       ResponseWriter responseWriter;
       if (null != oldWriter) {
           responseWriter = oldWriter.cloneWithWriter(response.getWriter());
       } else {
           responseWriter = newWriter.cloneWithWriter(response.getWriter());
       context.setResponseWriter(responseWriter);
       strWriter.flushToWriter(responseWriter);
       if (null != oldWriter) {
           context.setResponseWriter(oldWriter);
       // write any AFTER_VIEW_CONTENT to the response
       writeAfterViewContent(extContext, response);
   private boolean executePageToBuildView(FacesContext context, UIViewRoot viewToExecute, ComponentDefinition tile)
   throws IOException {
       if (null == context) {
           String message = MessageUtils.getExceptionMessageString
                   (MessageUtils.NULL_PARAMETERS_ERROR_MESSAGE_ID, "context");
           throw new NullPointerException(message);
       if (null == viewToExecute) {
           String message = MessageUtils.getExceptionMessageString
                   (MessageUtils.NULL_PARAMETERS_ERROR_MESSAGE_ID, "viewToExecute");
           throw new NullPointerException(message);
       String mapping = Util.getFacesMapping(context);
       String requestURI =
             updateRequestURI(viewToExecute.getViewId(), mapping);
       String requestURI =
           updateRequestURI(tile.getPath(), mapping);
       if (mapping.equals(requestURI)) {
           // The request was to the FacesServlet only - no path info
           // on some containers this causes a recursion in the
           // RequestDispatcher and the request appears to hang.
           // If this is detected, return status 404
           HttpServletResponse response = (HttpServletResponse)
                 context.getExternalContext().getResponse();
           response.sendError(HttpServletResponse.SC_NOT_FOUND);
           return true;
       ExternalContext extContext = context.getExternalContext();
       // update the JSTL locale attribute in request scope so that JSTL
       // picks up the locale from viewRoot. This attribute must be updated
       // before the JSTL setBundle tag is called because that is when the
       // new LocalizationContext object is created based on the locale.
       // PENDING: this only works for servlet based requests
       if (extContext.getRequest()
       instanceof ServletRequest) {
           Config.set((ServletRequest)
           extContext.getRequest(),
                      Config.FMT_LOCALE, context.getViewRoot().getLocale());
       // save the original response
       Object originalResponse = extContext.getResponse();
       // replace the response with our wrapper
       ViewHandlerResponseWrapper wrapped =
             new ViewHandlerResponseWrapper(
                   (HttpServletResponse)extContext.getResponse());
       extContext.setResponse(wrapped);
       // build the view by executing the page
       extContext.dispatch(requestURI);       
       // replace the original response
       extContext.setResponse(originalResponse);
       // Follow the JSTL 1.2 spec, section 7.4, 
       // on handling status codes on a forward
       if (wrapped.getStatus() < 200 || wrapped.getStatus() > 299) { 
           // flush the contents of the wrapper to the response
           // this is necessary as the user may be using a custom
           // error page - this content should be propagated
           wrapped.flushContentToWrappedResponse();
           return true;           
       // Put the AFTER_VIEW_CONTENT into request scope
       // temporarily
       if (wrapped.isBytes()) {
           extContext.getRequestMap().put(AFTER_VIEW_CONTENT,
                                          wrapped.getBytes());
       } else if (wrapped.isChars()) {
           extContext.getRequestMap().put(AFTER_VIEW_CONTENT,
                                          wrapped.getChars());
       return false;
   }You will also find you need to copy a few other methods from the Sun RI.
There were a couple of calls to ApplicationAssociate.responseRendered() which I just commented out as well (because they are not visible). They stop people changing the StateManager or ViewHandler after responses have been rendered. Probably not a problem since I will have replaced the ViewHandler anyway.
Steven