atomservlet.java

这个weblogging 设计得比较精巧

                    }                  
                    // write entry back out to response
                    res.setStatus(HttpServletResponse.SC_CREATED);
                    Writer writer = res.getWriter(); 
                    serializeEntry(savedEntry, writer);                    
                    writer.close();
                }
                else if (handler.isResourceCollectionURI(pathInfo)) 
                {
                    // get incoming file name from HTTP header
                    String name = req.getHeader("Name");
                    
                    // hand input stream of to hander to post file
                    String location = handler.postResource(
                       pathInfo, name, req.getContentType(), req.getInputStream());
                    res.setStatus(HttpServletResponse.SC_CREATED);
                    res.setHeader("Location", location);
                }
                else
                {
                    res.setStatus(HttpServletResponse.SC_NOT_FOUND);
                }
            }
            catch (Exception e)
            {
                res.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
                e.printStackTrace(res.getWriter());
                mLogger.error(e);
            }
        }
        else 
        {
            res.setStatus(HttpServletResponse.SC_UNAUTHORIZED);
        }
    }

    //-----------------------------------------------------------------------------    
    /**
     * Handles an Atom PUT by calling handler to identify URI, reading/parsing
     * data, calling handler and writing results to response.
     */
    protected void doPut(HttpServletRequest req, HttpServletResponse res)
        throws ServletException, IOException
    {
        AtomHandler handler = createAtomRequestHandler(req);
        String userName = handler.getAuthenticatedUsername();
        if (userName != null) 
        {
            String[] pathInfo = getPathInfo(req);
            try
            {
                if (handler.isEntryURI(pathInfo)) 
                {
                    // parse incoming entry
                    Entry unsavedEntry = parseEntry(
                        new InputStreamReader(req.getInputStream()));
                    
                    // call handler to put entry
                    Entry updatedEntry = handler.putEntry(pathInfo, unsavedEntry);
                    
                    // write entry back out to response
                    Writer writer = res.getWriter(); 
                    serializeEntry(updatedEntry, writer);                    
                    res.setStatus(HttpServletResponse.SC_OK);
                    writer.close();
                }
                else if (handler.isResourceCollectionURI(pathInfo)) 
                {
                    // handle input stream to handler
                    handler.putResource(
                        pathInfo, req.getContentType(), req.getInputStream());
                    res.setStatus(HttpServletResponse.SC_OK);
                }
                else
                {
                    res.setStatus(HttpServletResponse.SC_NOT_FOUND);
                }
            }
            catch (Exception e)
            {
                res.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
                e.printStackTrace(res.getWriter());
                mLogger.error(e);
            }
        }
        else 
        {
            res.setStatus(HttpServletResponse.SC_UNAUTHORIZED);
        }
    }

    //-----------------------------------------------------------------------------
    /**
     * Handle Atom DELETE by calling appropriate handler.
     */
    protected void doDelete(HttpServletRequest req, HttpServletResponse res)
        throws ServletException, IOException
    {
        AtomHandler handler = createAtomRequestHandler(req);
        String userName = handler.getAuthenticatedUsername();
        if (userName != null) 
        {
            String[] pathInfo = getPathInfo(req);
            try
            {
                if (handler.isEntryURI(pathInfo)) 
                {
                    handler.deleteEntry(pathInfo); 
                    res.setStatus(HttpServletResponse.SC_OK);
                }
                else if (handler.isResourceURI(pathInfo)) 
                {
                    handler.deleteResource(pathInfo); 
                    res.setStatus(HttpServletResponse.SC_OK);
                }
                else
                {
                    res.setStatus(HttpServletResponse.SC_NOT_FOUND);
                }
            }
            catch (Exception e)
            {
                res.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
                e.printStackTrace(res.getWriter());
                mLogger.error(e);
            }
        }
        else 
        {
            res.setStatus(HttpServletResponse.SC_UNAUTHORIZED);
        }
    }
    
    //-----------------------------------------------------------------------------
    /**
     * Convenience method to return the PathInfo from the request.  
     */
    protected String[] getPathInfo(HttpServletRequest request)
    {
        String mPathInfo = request.getPathInfo();
        mPathInfo = (mPathInfo!=null) ? mPathInfo : "";
        return StringUtils.split(mPathInfo,"/");   
    }

    /** 
     * Utility method to make up for a Rome shortcoming:
     * Rome can only serialize entire feeds, not individual elements
     */
    public static void serializeEntry(Entry entry, Writer writer) 
        throws IllegalArgumentException, FeedException, IOException
    {
        // Build a feed containing only the entry
        List entries = new ArrayList();
        entries.add(entry);
        Feed feed1 = new Feed();
        feed1.setFeedType(AtomServlet.FEED_TYPE);
        feed1.setEntries(entries);
        
        // Get Rome to output feed as a JDOM document
        WireFeedOutput wireFeedOutput = new WireFeedOutput();
        Document feedDoc = wireFeedOutput.outputJDom(feed1);
        
        // Grab entry element from feed and get JDOM to serialize it
        Element entryElement= (Element)feedDoc.getRootElement().getChildren().get(0);
        XMLOutputter outputter = new XMLOutputter();
        outputter.setFormat(Format.getPrettyFormat());
        outputter.output(entryElement, writer);
    }
    
    /** 
     * Utility method to make up for a Rome shortcoming:
     * Rome can only parse Atom data with XML document root 'feed'
     */
    public static Entry parseEntry(Reader rd) 
        throws JDOMException, IOException, IllegalArgumentException, FeedException 
    {
        // Parse entry into JDOM tree        
        SAXBuilder builder = new SAXBuilder();
        Document entryDoc = builder.build(rd);
        Element fetchedEntryElement = entryDoc.getRootElement();
        fetchedEntryElement.detach();
        
        // Put entry into a JDOM document with 'feed' root so that Rome can handle it
        Feed feed = new Feed();
        feed.setFeedType(FEED_TYPE);
        WireFeedOutput wireFeedOutput = new WireFeedOutput();
        Document feedDoc = wireFeedOutput.outputJDom(feed); 
        feedDoc.getRootElement().addContent(fetchedEntryElement);
        
        WireFeedInput input = new WireFeedInput();
        Feed parsedFeed = (Feed)input.build(feedDoc);
        return (Entry)parsedFeed.getEntries().get(0);
    }
}