openremoteserviceservlet.java

是离开的肌肤了卡机是离开的就富利卡及是了的开发及拉考试及的福利科技阿斯利康的肌肤莱卡及时的离开福建阿斯顿发

        ServletContext servletContext = getServletContext();
        servletContext.log("Exception while dispatching incoming RPC call", e);

        // Send GENERIC_FAILURE_MSG with 500 status.
        //
        respondWithFailure(getThreadLocalResponse());
    }

    /**
     * Gets the <code>HttpServletRequest</code> object for the current call. It
     * is stored thread-locally so that simultaneous invocations can have
     * different request objects.
     */
    protected final HttpServletRequest getThreadLocalRequest() {
        return (HttpServletRequest) perThreadRequest.get();
    }

    /**
     * Gets the <code>HttpServletResponse</code> object for the current call. It
     * is stored thread-locally so that simultaneous invocations can have
     * different response objects.
     */
    protected final HttpServletResponse getThreadLocalResponse() {
        return (HttpServletResponse) perThreadResponse.get();
    }

    /**
     * Override this method to examine the serialized response that will be
     * returned to the client. The default implementation does nothing and need
     * not be called by subclasses.
     */
    protected void onAfterResponseSerialized(String serializedResponse) {
    }

    /**
     * Override this method to examine the serialized version of the request
     * payload before it is deserialized into objects. The default implementation
     * does nothing and need not be called by subclasses.
     */
    protected void onBeforeRequestDeserialized(String serializedRequest) {
    }

    /**
     * Determines whether the response to a given servlet request should or should
     * not be GZIP compressed. This method is only called in cases where the
     * requestor accepts GZIP encoding.
     * <p/>
     * This implementation currently returns <code>true</code> if the response
     * string's estimated byte length is longer than 256 bytes. Subclasses can
     * override this logic.
     * </p>
     *
     * @param request         the request being served
     * @param response        the response that will be written into
     * @param responsePayload the payload that is about to be sent to the client
     * @return <code>true</code> if responsePayload should be GZIP compressed,
     *         otherwise <code>false</code>.
     */
    protected boolean shouldCompressResponse(HttpServletRequest request,
                                             HttpServletResponse response, String responsePayload) {
        return estimateByteSize(responsePayload) > UNCOMPRESSED_BYTE_SIZE_LIMIT;
    }

    /**
     * Called when the machinery of this class itself has a problem, rather than
     * the invoked third-party method. It writes a simple 500 message back to the
     * client.
     */
    private void respondWithFailure(HttpServletResponse response) {
        try {
            response.setContentType("text/plain");
            response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
            response.getOutputStream().write(GENERIC_FAILURE_MSG.getBytes());
        } catch (IOException e) {
            getServletContext().log(
                    "respondWithFailure failed while sending the previous failure to the client",
                    e);
        }
    }

    /**
     * Write the response payload to the response stream.
     */
    private void writeResponse(HttpServletRequest request,
                               HttpServletResponse response, String responsePayload) throws IOException {

        byte[] reply = responsePayload.getBytes(CHARSET_UTF8);
        String contentType = CONTENT_TYPE_TEXT_PLAIN_UTF8;

        if (acceptsGzipEncoding(request)
                && shouldCompressResponse(request, response, responsePayload)) {
            // Compress the reply and adjust headers.
            //
            ByteArrayOutputStream output = null;
            GZIPOutputStream gzipOutputStream = null;
            Throwable caught = null;
            try {
                output = new ByteArrayOutputStream(reply.length);
                gzipOutputStream = new GZIPOutputStream(output);
                gzipOutputStream.write(reply);
                gzipOutputStream.finish();
                gzipOutputStream.flush();
                response.setHeader(CONTENT_ENCODING, CONTENT_ENCODING_GZIP);
                reply = output.toByteArray();
            } catch (IOException e) {
                caught = e;
            } finally {
                if (null != gzipOutputStream) {
                    gzipOutputStream.close();
                }
                if (null != output) {
                    output.close();
                }
            }

            if (caught != null) {
                getServletContext().log("Unable to compress response", caught);
                response.sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
                return;
            }
        }

        // Send the reply.
        //
        response.setContentLength(reply.length);
        response.setContentType(contentType);
        response.setStatus(HttpServletResponse.SC_OK);
        response.getOutputStream().write(reply);
    }

    public final SerializationPolicy getSerializationPolicy(String moduleBaseURL, String strongName)
    {
        SerializationPolicy serializationPolicy = getCachedSerializationPolicy(moduleBaseURL, 
                strongName);
        if (serializationPolicy != null)
            return serializationPolicy;


        serializationPolicy = doGetSerializationPolicy(getThreadLocalRequest(),
                moduleBaseURL, strongName);

        if (serializationPolicy == null) 
        {
            // Failed to get the requested serialization policy; use the default
            getServletContext().log(
                "WARNING: Failed to get the SerializationPolicy '"
                    + strongName
                    + "' for module '"
                    + moduleBaseURL
                    + "'; a legacy, 1.3.3 compatible, serialization policy will be used.  You may experience SerializationExceptions as a result.");
            serializationPolicy = RPC.getDefaultSerializationPolicy();
        }

        // This could cache null or an actual instance. Either way we will not
        // attempt to lookup the policy again.
        putCachedSerializationPolicy(moduleBaseURL, strongName, serializationPolicy);

        return serializationPolicy;
    }
    
    private SerializationPolicy getCachedSerializationPolicy(String moduleBaseURL, 
            String strongName) 
    {
        synchronized (serializationPolicyCache) 
        {
            return serializationPolicyCache.get(moduleBaseURL + strongName);
        }
    }
    
    private void putCachedSerializationPolicy(String moduleBaseURL, String strongName, 
            SerializationPolicy serializationPolicy) 
    {
        synchronized (serializationPolicyCache) 
        {
            serializationPolicyCache.put(moduleBaseURL + strongName, serializationPolicy);
        }
    }
    
    /**
     * Gets the {@link SerializationPolicy} for given module base URL and strong
     * name if there is one.
     * 
     * Override this method to provide a {@link SerializationPolicy} using an
     * alternative approach.
     * 
     * @param request the HTTP request being serviced
     * @param moduleBaseURL as specified in the incoming payload
     * @param strongName a strong name that uniquely identifies a serialization
     *          policy file
     * @return a {@link SerializationPolicy} for the given module base URL and
     *         strong name, or <code>null</code> if there is none
     */    
    protected SerializationPolicy doGetSerializationPolicy(HttpServletRequest request, 
            String moduleBaseURL, String strongName) 
    {
        // The request can tell you the path of the web app relative to the
        // container root.
        String contextPath = request.getContextPath();

        String modulePath = null;
        if (moduleBaseURL != null) 
        {
            try 
            {
                modulePath = new URL(moduleBaseURL).getPath();
            } 
            catch (MalformedURLException ex) 
            {
                // log the information, we will default
                getServletContext().log("Malformed moduleBaseURL: " + moduleBaseURL, ex);
            }
        }

        SerializationPolicy serializationPolicy = null;

        /*
         * Check that the module path must be in the same web app as the servlet
         * itself. If you need to implement a scheme different than this, override
         * this method.
         */
        if (modulePath == null || !modulePath.startsWith(contextPath)) 
        {
            String message = "ERROR: The module path requested, "
                + modulePath
                + ", is not in the same web application as this servlet, "
                + contextPath
                + ".  Your module may not be properly configured or your client and server code maybe out of date.";
            getServletContext().log(message);
        } 
        else 
        {
            // Strip off the context path from the module base URL. It should be a
            // strict prefix.
            String contextRelativePath = modulePath.substring(contextPath.length());

            String serializationPolicyFilePath = SerializationPolicyLoader.getSerializationPolicyFileName(contextRelativePath
                + strongName);

            // Open the RPC resource file read its contents.
            InputStream is = getServletContext().getResourceAsStream(
                serializationPolicyFilePath);
            try 
            {
                if (is != null) 
                {
                    try 
                    {
                        serializationPolicy = SerializationPolicyLoader.loadFromStream(is, null);
                    } 
                    catch (ParseException e) 
                    {
                        getServletContext().log(
                                "ERROR: Failed to parse the policy file '"
                                    + serializationPolicyFilePath + "'", e);
                    } 
                    catch (IOException e) 
                    {
                        getServletContext().log(
                                "ERROR: Could not read the policy file '"
                                    + serializationPolicyFilePath + "'", e);
                    }
                } 
                else 
                {
                    String message = "ERROR: The serialization policy file '"
                        + serializationPolicyFilePath
                        + "' was not found; did you forget to include it in this deployment?";
                    getServletContext().log(message);
                }
            } 
            finally 
            {
                if (is != null) 
                {
                    try 
                    {
                        is.close();
                    } 
                    catch (IOException e) 
                    {
                        // Ignore this error
                    }
                }
            }
        }

        return serializationPolicy;
    }
    

}