gdataresponse.java

一套java版本的搜索引擎源码

     * @param service - the service to render the feed
     * @throws IOException -
     *             if an I/O exception occurs, often caused by an already
     *             closed Writer or OutputStream
     */
    public void sendResponse(BaseEntry entry, ProvidedService service)
            throws IOException {
        if (entry == null)
            throw new IllegalArgumentException("entry must not be null");
        if (service == null)
            throw new IllegalArgumentException(
                    "service must not be null");
        DateTime time = entry.getUpdated();
        if (time != null)
            setLastModifiedHeader(time.getValue());
        FormatWriter writer = FormatWriter.getFormatWriter(this,service);
        writer.generateOutputFormat(entry,this.response);

        
    }


    /**
     * This encoding will be used to encode the xml representation of feed or
     * entry written to the {@link HttpServletResponse} output stream.
     * 
     * @return - the entry / feed encoding
     */
    public String getEncoding() {
        return this.encoding;
    }

    /**
     * This encoding will be used to encode the xml representation of feed or
     * entry written to the {@link HttpServletResponse} output stream. <i>UTF-8</i>
     * <i>ISO-8859-1</i>
     * 
     * @param encoding -
     *            string represents the encoding
     */
    public void setEncoding(String encoding) {
        this.encoding = encoding;
    }

    /**
     * @return - the response
     *         {@link org.apache.lucene.gdata.server.GDataRequest.OutputFormat}
     */
    public OutputFormat getOutputFormat() {
        return this.outputFormat;
    }

    /**
     * @param outputFormat -
     *            the response
     *            {@link org.apache.lucene.gdata.server.GDataRequest.OutputFormat}
     */
    public void setOutputFormat(OutputFormat outputFormat) {
        this.outputFormat = outputFormat;
    }

    /**
     * @see Object#toString()
     */
    @Override
    public String toString() {
        StringBuilder builder = new StringBuilder(" GDataResponse: ");
        builder.append("Error: ").append(this.error);
        builder.append(" outputFormat: ").append(getOutputFormat());
        builder.append(" encoding: ").append(this.encoding);

        return builder.toString();

    }

    protected void setLastModifiedHeader(long lastModified) {
        String lastMod = DateFormater.formatDate(new Date(lastModified),
                DateFormater.HTTP_HEADER_DATE_FORMAT);
        this.response.setHeader(HEADER_LASTMODIFIED, lastMod);
    }
    
    /**
     * @see HttpServletResponse#setStatus(int)
     * @param status - the request status code
     */
    public void setStatus(int status){
        this.response.setStatus(status);
    }

    private static abstract class FormatWriter{
        
        static FormatWriter getFormatWriter(final GDataResponse response, final ProvidedService service ){
            OutputFormat format = response.getOutputFormat();
            if(format == OutputFormat.HTML){
                return new HTMLFormatWriter(service);
            }
            return new SyndicateFormatWriter(service,format,response.getEncoding());
        }
        
        abstract void generateOutputFormat(final BaseFeed feed, final HttpServletResponse response) throws IOException;
        abstract void generateOutputFormat(final BaseEntry entry, final HttpServletResponse response) throws IOException;
        
        private static class HTMLFormatWriter extends FormatWriter{
            private static final String CONTENT_TYPE = "text/html";
            private final ProvidedService service;
            
            HTMLFormatWriter(final ProvidedService service){
                this.service = service;
            }
            @Override
            void generateOutputFormat(BaseFeed feed, final HttpServletResponse response) throws IOException {
                Templates template = this.service.getTransformTemplate();
                response.setContentType(CONTENT_TYPE);
                if(template == null){
                    sendNotAvailable(response);
                    return;
                }
                StringWriter writer = new StringWriter();
                XmlWriter xmlWriter = new XmlWriter(writer);
                feed.generateAtom(xmlWriter,this.service.getExtensionProfile());
                try {
                    writeHtml(template,response.getWriter(),writer);
                } catch (TransformerException e) {
                 LOG.error("Can not transform feed for service "+this.service.getName(),e);
                 sendNotAvailable(response);
                    
                }
            }

            @Override
            void generateOutputFormat(BaseEntry entry, final HttpServletResponse response)  throws IOException{
                Templates template = this.service.getTransformTemplate();
                response.setContentType(CONTENT_TYPE);
                if(template == null){
                    sendNotAvailable(response);
                    return;
                }
                StringWriter writer = new StringWriter();
                XmlWriter xmlWriter = new XmlWriter(writer);
                entry.generateAtom(xmlWriter,this.service.getExtensionProfile());
                try {
                    writeHtml(template,response.getWriter(),writer);
                } catch (TransformerException e) {
                 LOG.error("Can not transform feed for service "+this.service.getName(),e);
                 sendNotAvailable(response);
                    
                }

            }
            
            private void writeHtml(final Templates template, final Writer writer, final StringWriter source ) throws TransformerException{
                Transformer transformer = template.newTransformer();
                Source tranformSource = new StreamSource(new StringReader(source.toString())); 
                transformer.transform(tranformSource,new StreamResult(writer));
            }
            
            private void sendNotAvailable(final HttpServletResponse response) throws IOException{
                response.sendError(HttpServletResponse.SC_SERVICE_UNAVAILABLE, "No transformation stylesheet available");
            }
            
        }
        private static class SyndicateFormatWriter extends FormatWriter{
            private static final String DEFAUL_NAMESPACE_URI = "http://www.w3.org/2005/Atom";

            private static final Namespace DEFAULT_NAMESPACE = new Namespace("",
                    DEFAUL_NAMESPACE_URI);
            private final ProvidedService service;
            private final String encoding;
            private final OutputFormat format;
            
            SyndicateFormatWriter(final ProvidedService service,final OutputFormat format, String encoding){
                this.service = service;
                this.format = format;
                this.encoding = encoding;
                
            }
            @Override
            void generateOutputFormat(final BaseFeed feed, final HttpServletResponse response) throws IOException {
                XmlWriter writer = null;
                try{
                 writer = createWriter(response.getWriter());
                if (this.format == OutputFormat.ATOM) {
                    response.setContentType(XMLMIME_ATOM);
                    feed.generateAtom(writer, this.service.getExtensionProfile());
                } else {
                    response.setContentType(XMLMIME_RSS);
                    feed.generateRss(writer, this.service.getExtensionProfile());
                }
                }finally{
                    if(writer != null)
                        writer.close();
                }
            }

            @Override
            void generateOutputFormat(final BaseEntry entry, final HttpServletResponse response) throws IOException {
                XmlWriter writer = null;
                try{
                 writer = createWriter(response.getWriter());
                if (this.format == OutputFormat.ATOM) {
                    response.setContentType(XMLMIME_ATOM);
                    entry.generateAtom(writer, this.service.getExtensionProfile());
                } else {
                    response.setContentType(XMLMIME_RSS);
                    entry.generateRss(writer, this.service.getExtensionProfile());
                }
                }finally{
                    if(writer != null)
                        writer.close();
                }
            }
            private XmlWriter createWriter(final Writer target) throws IOException {
                XmlWriter writer = new XmlWriter(target, this.encoding);
                // set the default namespace to Atom if Atom is the response format
                if (this.format == OutputFormat.ATOM)
                    writer.setDefaultNamespace(DEFAULT_NAMESPACE);
                return writer;
            }
        }
    }
    
    
    
}