Example usage for com.google.gwt.user.server.rpc.impl ServerSerializationStreamReader readString

Introduction

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

Prototype

public String readString() throws SerializationException 

Source Link

Usage

From source file:us.gibb.dev.gwt.server.remote.RPCGilead.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.
 * //  w w  w.  j  ava2s  . c  o  m
 * <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 {
        ServerSerializationStreamReader streamReader = new ServerSerializationStreamReader(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);
    }
}

---

• «
• 1
• 2
• »