Example usage for com.google.gwt.user.server.rpc RPCRequest RPCRequest

Introduction

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

Prototype

public RPCRequest(Method method, Object[] parameters, RpcToken rpcToken,
        SerializationPolicy serializationPolicy, int flags) 

Source Link

Document

Construct an RPCRequest.

Usage

From source file:com.brightedu.server.util.MyRPC.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.
 * /* www  .  ja v a2 s  . 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);

        RpcToken rpcToken = null;
        if (streamReader.hasFlags(AbstractSerializationStream.FLAG_RPC_TOKEN_INCLUDED)) {
            // Read the RPC token
            rpcToken = (RpcToken) streamReader.deserializeValue(RpcToken.class);
        }

        // Read the name of the RemoteService interface
        String serviceIntfName = maybeDeobfuscate(streamReader, 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();
        if (paramCount > streamReader.getNumberOfTokens()) {
            throw new IncompatibleRemoteServiceException("Invalid number of parameters");
        }
        Class<?>[] parameterTypes = new Class[paramCount];

        for (int i = 0; i < parameterTypes.length; i++) {
            String paramClassName = maybeDeobfuscate(streamReader, 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, rpcToken, serializationPolicy,
                    streamReader.getFlags());

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

---