Example usage for com.google.gwt.user.server.rpc.impl ServerSerializationStreamReaderCopy_GWT16 getSerializationPolicy

Introduction

In this page you can find the example usage for com.google.gwt.user.server.rpc.impl ServerSerializationStreamReaderCopy_GWT16 getSerializationPolicy.

Prototype

public SerializationPolicy getSerializationPolicy() 

Source Link

Usage

From source file:us.gibb.dev.gwt.server.remote.RPCAppengine.java

License:Apache License

/**
 * Returns an {@link RPCRequest} that is built by decoding the contents of an
 * encoded RPC request and optionally validating that type can handle the
 * request. If the type parameter is not <code>null</code>, the
 * implementation checks that the type is assignable to the
 * {@link RemoteService} interface requested in the encoded request string.
 * /*ww w .j  a v  a 2  s. com*/
 * <p>
 * If the serializationPolicyProvider parameter is not <code>null</code>,
 * it is asked for a {@link SerializationPolicy} to use to restrict the set of
 * types that can be decoded from the request. If this parameter is
 * <code>null</code>, then only subtypes of
 * {@link com.google.gwt.user.client.rpc.IsSerializable IsSerializable} or
 * types which have custom field serializers can be decoded.
 * </p>
 * 
 * <p>
 * Invoking this method with <code>null</code> for the type parameter,
 * <code>decodeRequest(encodedRequest, null)</code>, is equivalent to
 * calling <code>decodeRequest(encodedRequest)</code>.
 * </p>
 * 
 * @param encodedRequest a string that encodes the {@link RemoteService}
 *          interface, the service method, and the arguments to pass to the
 *          service method
 * @param type if not <code>null</code>, the implementation checks that the
 *          type is assignable to the {@link RemoteService} interface encoded
 *          in the encoded request string.
 * @param serializationPolicyProvider if not <code>null</code>, the
 *          implementation asks this provider for a
 *          {@link SerializationPolicy} which will be used to restrict the set
 *          of types that can be decoded from this request
 * @return an {@link RPCRequest} instance
 * 
 * @throws NullPointerException if the encodedRequest is <code>null</code>
 * @throws IllegalArgumentException if the encodedRequest is an empty string
 * @throws IncompatibleRemoteServiceException if any of the following
 *           conditions apply:
 *           <ul>
 *           <li>if the types in the encoded request cannot be deserialized</li>
 *           <li>if the {@link ClassLoader} acquired from
 *           <code>Thread.currentThread().getContextClassLoader()</code>
 *           cannot load the service interface or any of the types specified
 *           in the encodedRequest</li>
 *           <li>the requested interface is not assignable to
 *           {@link RemoteService}</li>
 *           <li>the service method requested in the encodedRequest is not a
 *           member of the requested service interface</li>
 *           <li>the type parameter is not <code>null</code> and is not
 *           assignable to the requested {@link RemoteService} interface
 *           </ul>
 */
public static RPCRequest decodeRequest(String encodedRequest, Class<?> type,
        SerializationPolicyProvider serializationPolicyProvider) {
    if (encodedRequest == null) {
        throw new NullPointerException("encodedRequest cannot be null");
    }

    if (encodedRequest.length() == 0) {
        throw new IllegalArgumentException("encodedRequest cannot be empty");
    }

    ClassLoader classLoader = Thread.currentThread().getContextClassLoader();

    try {
        ServerSerializationStreamReaderCopy_GWT16 streamReader = new ServerSerializationStreamReaderCopy_GWT16(
                classLoader, serializationPolicyProvider);
        streamReader.prepareToRead(encodedRequest);

        // Read the name of the RemoteService interface
        String serviceIntfName = streamReader.readString();

        if (type != null) {
            if (!implementsInterface(type, serviceIntfName)) {
                // The service does not implement the requested interface
                throw new IncompatibleRemoteServiceException("Blocked attempt to access interface '"
                        + serviceIntfName + "', which is not implemented by '" + printTypeName(type)
                        + "'; this is either misconfiguration or a hack attempt");
            }
        }

        SerializationPolicy serializationPolicy = streamReader.getSerializationPolicy();
        Class<?> serviceIntf;
        try {
            serviceIntf = getClassFromSerializedName(serviceIntfName, classLoader);
            if (!RemoteService.class.isAssignableFrom(serviceIntf)) {
                // The requested interface is not a RemoteService interface
                throw new IncompatibleRemoteServiceException("Blocked attempt to access interface '"
                        + printTypeName(serviceIntf)
                        + "', which doesn't extend RemoteService; this is either misconfiguration or a hack attempt");
            }
        } catch (ClassNotFoundException e) {
            throw new IncompatibleRemoteServiceException(
                    "Could not locate requested interface '" + serviceIntfName + "' in default classloader", e);
        }

        String serviceMethodName = streamReader.readString();

        int paramCount = streamReader.readInt();
        Class<?>[] parameterTypes = new Class[paramCount];

        for (int i = 0; i < parameterTypes.length; i++) {
            String paramClassName = streamReader.readString();
            try {
                parameterTypes[i] = getClassFromSerializedName(paramClassName, classLoader);
            } catch (ClassNotFoundException e) {
                throw new IncompatibleRemoteServiceException(
                        "Parameter " + i + " of is of an unknown type '" + paramClassName + "'", e);
            }
        }

        try {
            Method method = serviceIntf.getMethod(serviceMethodName, parameterTypes);

            Object[] parameterValues = new Object[parameterTypes.length];
            for (int i = 0; i < parameterValues.length; i++) {
                parameterValues[i] = streamReader.deserializeValue(parameterTypes[i]);
            }

            return new RPCRequest(method, parameterValues, serializationPolicy, 0);

        } catch (NoSuchMethodException e) {
            throw new IncompatibleRemoteServiceException(
                    formatMethodNotFoundErrorMessage(serviceIntf, serviceMethodName, parameterTypes));
        }
    } catch (SerializationException ex) {
        throw new IncompatibleRemoteServiceException(ex.getMessage(), ex);
    }
}

---