List of usage examples for com.google.gwt.user.server.rpc.impl ServerSerializationStreamReader readString
public String readString() throws SerializationException
From source file:com.apress.progwt.server.gwt.RPC1524.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./*from w w w .j a va 2s .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); } catch (NoSuchMethodException e) { throw new IncompatibleRemoteServiceException( formatMethodNotFoundErrorMessage(serviceIntf, serviceMethodName, parameterTypes)); } } catch (SerializationException ex) { throw new IncompatibleRemoteServiceException(ex.getMessage(), ex); } }
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. * //from w w w . ja va 2s.c om * <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); } }
From source file:com.google.gwt.sample.dynatable.utils.RPC_2_0_1.java
/** * 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 com.google.gwt.user.client.rpc.RemoteService} interface * requested in the encoded request string. * <p/>/* w ww .j av a 2 s . c o m*/ * <p> * If the serializationPolicyProvider parameter is not <code>null</code>, it * is asked for a {@link com.google.gwt.user.server.rpc.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/> * <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 com.google.gwt.user.client.rpc.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 com.google.gwt.user.client.rpc.RemoteService} interface encoded * in the encoded request string. * @param serializationPolicyProvider if not <code>null</code>, the * implementation asks this provider for a * {@link com.google.gwt.user.server.rpc.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 com.google.gwt.user.client.rpc.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 com.google.gwt.user.client.rpc.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 com.google.gwt.user.client.rpc.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 = 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, serializationPolicy, streamReader.getFlags()); } catch (NoSuchMethodException e) { throw new IncompatibleRemoteServiceException( formatMethodNotFoundErrorMessage(serviceIntf, serviceMethodName, parameterTypes)); } } catch (SerializationException ex) { throw new IncompatibleRemoteServiceException(ex.getMessage(), ex); } }
From source file:com.guit.server.guice.GuiceGwtServlet.java
License:Apache License
public String decodeRequest(String encodedRequest, Class<?> type, SerializationPolicyProvider serializationPolicyProvider) { ClassLoader classLoader = Thread.currentThread().getContextClassLoader(); Method method = execute;//from w ww .j a v a2 s . c o m try { ServerSerializationStreamReader streamReader = new ServerSerializationStreamReader(classLoader, serializationPolicyProvider); streamReader.prepareToRead(encodedRequest); SerializationPolicy serializationPolicy = streamReader.getSerializationPolicy(); // Predecible values streamReader.readString(); // Method name String methodName = streamReader.readString(); // Ignore, we know the values streamReader.readInt(); streamReader.readString(); Object[] parameterValues = new Object[1]; if ("execute".equals(methodName)) { method = execute; parameterValues[0] = streamReader.deserializeValue(Action.class); } else { method = executeBatch; parameterValues[0] = streamReader.deserializeValue(ArrayList.class); } int flags = streamReader.getFlags(); try { return encodeResponse(method.getReturnType(), method.invoke(service, parameterValues), false, flags, serializationPolicy); } catch (InvocationTargetException e) { Throwable cause = e.getCause(); if (!(cause instanceof CommandException)) { throw new UnexpectedException( "Service method threw an unexpected exception: " + cause.toString(), cause); } return encodeResponse(cause.getClass(), cause, true, flags, serializationPolicy); } } catch (Exception ex) { throw new RuntimeException(ex); } }
From source file:de.csenk.gwt.ws.server.filter.serialization.ServerGWTSerializer.java
License:Open Source License
@Override public Object deserialize(String serializedContent) throws SerializationException { ClassLoader classLoader = Thread.currentThread().getContextClassLoader(); ServerSerializationStreamReader streamReader = new ServerSerializationStreamReader(classLoader, serializationPolicyProvider); streamReader.prepareToRead(serializedContent); if (serializationPolicy == null) serializationPolicy = streamReader.getSerializationPolicy(); String objClassName = maybeDeobfuscate(streamReader, streamReader.readString()); try {/* w w w .j a va 2 s . com*/ Class<?> objClass = Class.forName(objClassName, false, classLoader); return streamReader.deserializeValue(objClass); } catch (ClassNotFoundException e) { throw new SerializationException(e); } }
From source file:org.gwtspringhibernate.reference.rlogman.spring.GwtServiceExporter.java
License:Apache License
/** * This is public so that it can be unit tested easily without HTTP. *//*from www . ja v a2s . c o m*/ public String processCall(String payload) throws SerializationException { // Let subclasses see the serialized request. // onBeforeRequestDeserialized(payload); // Create a stream to deserialize the request. // ServerSerializationStreamReader streamReader = new ServerSerializationStreamReader(serializableTypeOracle); streamReader.prepareToRead(payload); // Read the service interface // String serviceIntfName = streamReader.readString(); // TODO(mmendez): need to check the signature // Verify that this very servlet implements the specified interface // name. // if (!isImplementedRemoteServiceInterface(serviceIntfName)) { // Bad payload, possible hack attempt. // throw new SecurityException("Blocked attempt to access interface '" + serviceIntfName + "', which is either not implemented by this servlet or which doesn't extend RemoteService; this is either misconfiguration or a hack attempt"); } // Actually get the service interface, so that we can query its methods. // Class serviceIntf; try { serviceIntf = getClassFromName(serviceIntfName); } catch (ClassNotFoundException e) { throw new SerializationException("Unknown service interface class '" + serviceIntfName + "'", e); } // Read the method name. // String methodName = streamReader.readString(); // Read the number and names of the parameter classes from the stream. // We have to do this so that we can find the correct overload of the // method. // int paramCount = streamReader.readInt(); Class[] paramTypes = new Class[paramCount]; for (int i = 0; i < paramTypes.length; i++) { String paramClassName = streamReader.readString(); try { paramTypes[i] = getClassFromName(paramClassName); } catch (ClassNotFoundException e) { throw new SerializationException("Unknown parameter " + i + " type '" + paramClassName + "'", e); } } // For security, make sure the method is found in the service interface // and not just one that happens to be defined on this class. // Method serviceIntfMethod = findInterfaceMethod(serviceIntf, methodName, paramTypes, true); // If it wasn't found, don't continue. // if (serviceIntfMethod == null) { // Bad payload, possible hack attempt. // throw new SecurityException("Method '" + methodName + "' (or a particular overload) on interface '" + serviceIntfName + "' was not found, this is either misconfiguration or a hack attempt"); } // Deserialize the parameters. // Object[] args = new Object[paramCount]; for (int i = 0; i < args.length; i++) { args[i] = streamReader.deserializeValue(paramTypes[i]); } // Make the call via reflection. // String responsePayload = GENERIC_FAILURE_MSG; ServerSerializationStreamWriter streamWriter = new ServerSerializationStreamWriter(serializableTypeOracle); Throwable caught = null; try { Class returnType = serviceIntfMethod.getReturnType(); /** * The method is not invoked from <code>this</code> but from <code>this.proxy</code>; * <code>this</code> is the exporter, <code>this.proxy</code> is the actual service * implementation * @author rlogman@gmail.com */ Object returnVal = serviceIntfMethod.invoke(this.proxy, args); responsePayload = createResponse(streamWriter, returnType, returnVal, false); } catch (IllegalArgumentException e) { caught = e; } catch (IllegalAccessException e) { caught = e; } catch (InvocationTargetException e) { // Try to serialize the caught exception if the client is expecting // it, // otherwise log the exception server-side. caught = e; Throwable cause = e.getCause(); if (cause != null) { // Update the caught exception to the underlying cause caught = cause; // Serialize the exception back to the client if it's a declared // exception if (isExpectedException(serviceIntfMethod, cause)) { Class thrownClass = cause.getClass(); responsePayload = createResponse(streamWriter, thrownClass, cause, true); // Don't log the exception on the server caught = null; } } } if (caught != null) { responsePayload = GENERIC_FAILURE_MSG; // servletContext may be null (for example, when unit testing) /** * Our logger will not be servlet context's log (we don't have * direct access to it at this point) * @author rlogman@gmail.com */ if (logger != null) { // Log the exception server side logger.error("Exception while dispatching incoming RPC call", caught); } } // Let subclasses see the serialized response. // onAfterResponseSerialized(responsePayload); return responsePayload; }
From source file:org.jboss.seam.remoting.gwt.GWTRemoteServiceServlet.java
License:Open Source License
/** * This is public so that it can be unit tested easily without HTTP. *//*ww w .ja va 2s . c o m*/ public String processCall(String payload) throws SerializationException { // Let subclasses see the serialized request. // onBeforeRequestDeserialized(payload); // Create a stream to deserialize the request. // ServerSerializationStreamReader streamReader = new ServerSerializationStreamReader( Thread.currentThread().getContextClassLoader(), null); streamReader.prepareToRead(payload); // Read the service interface // String serviceIntfName = streamReader.readString(); // // TODO(mmendez): need a way to check the type signature of the service intf // // Verify that this very servlet implements the specified interface name. // // // if (!isImplementedRemoteServiceInterface(serviceIntfName)) { // // Bad payload, possible hack attempt. // // // throw new SecurityException( // "Blocked attempt to access interface '" // + serviceIntfName // + "', which is either not implemented by this servlet or which doesn't extend RemoteService; this is either misconfiguration or a hack attempt"); // } // Actually get the service interface, so that we can query its methods. // // Class serviceIntf; // try { // serviceIntf = getClassFromName(serviceIntfName); // } catch (ClassNotFoundException e) { // throw new SerializationException("Unknown service interface class '" // + serviceIntfName + "'", e); // } // Read the method name. // String methodName = streamReader.readString(); // Read the number and names of the parameter classes from the stream. // We have to do this so that we can find the correct overload of the // method. // int paramCount = streamReader.readInt(); Class[] paramTypes = new Class[paramCount]; for (int i = 0; i < paramTypes.length; i++) { String paramClassName = streamReader.readString(); try { paramTypes[i] = getClassOrPrimitiveFromName(paramClassName); } catch (ClassNotFoundException e) { throw new SerializationException("Unknown parameter " + i + " type '" + paramClassName + "'", e); } } // // For security, make sure the method is found in the service interface // // and not just one that happens to be defined on this class. // // // Method serviceIntfMethod = findInterfaceMethod(serviceIntf, methodName, // paramTypes, true); // // If it wasn't found, don't continue. // // // if (serviceIntfMethod == null) { // // Bad payload, possible hack attempt. // // // throw new SecurityException( // "Method '" // + methodName // + "' (or a particular overload) on interface '" // + serviceIntfName // + "' was not found, this is either misconfiguration or a hack attempt"); // } // Deserialize the parameters. // Object[] args = new Object[paramCount]; for (int i = 0; i < args.length; i++) { args[i] = streamReader.deserializeValue(paramTypes[i]); } GWTToSeamAdapter adapter = new GWTToSeamAdapter(); // Make the call via reflection. // String responsePayload = GENERIC_FAILURE_MSG; ServerSerializationStreamWriter streamWriter = new ServerSerializationStreamWriter( LegacySerializationPolicy.getInstance()); Throwable caught = null; try { //call the component ReturnedObject returnedObject = adapter.callWebRemoteMethod(serviceIntfName, methodName, paramTypes, args); Class returnType = returnedObject.returnType; Object returnVal = returnedObject.returnedObject; // Class returnType = serviceIntfMethod.getReturnType(); // Object returnVal = serviceIntfMethod.invoke(this, args); responsePayload = createResponse(streamWriter, returnType, returnVal, false); } catch (IllegalArgumentException e) { caught = e; } catch (IllegalAccessException e) { caught = e; } catch (InvocationTargetException e) { // Try to serialize the caught exception if the client is expecting it, // otherwise log the exception server-side. caught = e; Throwable cause = e.getCause(); if (cause != null) { // Update the caught exception to the underlying cause caught = cause; // Serialize the exception back to the client if it's a declared // exception if (cause instanceof SerializableException) { Class thrownClass = cause.getClass(); responsePayload = createResponse(streamWriter, thrownClass, cause, true); // Don't log the exception on the server caught = null; } } } if (caught != null) { responsePayload = GENERIC_FAILURE_MSG; ServletContext servletContext = getServletContext(); // servletContext may be null (for example, when unit testing) if (servletContext != null) { // Log the exception server side servletContext.log("Exception while dispatching incoming RPC call", caught); } } // Let subclasses see the serialized response. // onAfterResponseSerialized(responsePayload); return responsePayload; }
From source file:org.slim3.gwt.server.rpc.GWTServiceServlet.java
License:Apache License
/** * Returns RPC request.//from w ww . j av a2 s . c om * * @param encodedRequest * a string that encodes the service interface, the service * method, and the arguments * @return RPC request * * @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> */ protected S3RPCRequest decodeRequest(String encodedRequest) { if (encodedRequest == null) { throw new NullPointerException("The encodedRequest parameter cannot be null."); } if (encodedRequest.length() == 0) { throw new IllegalArgumentException("The encodedRequest parameter cannot be empty."); } ClassLoader classLoader = Thread.currentThread().getContextClassLoader(); try { ServerSerializationStreamReader streamReader = new ServerSerializationStreamReader(classLoader, this); streamReader.prepareToRead(encodedRequest); String interfaceName = readClassName(streamReader); Class<?> serviceClass = getServiceClass(interfaceName); Object service = getService(serviceClass); SerializationPolicy serializationPolicy = streamReader.getSerializationPolicy(); String methodName = streamReader.readString(); int paramCount = streamReader.readInt(); Class<?>[] parameterTypes = new Class[paramCount]; for (int i = 0; i < parameterTypes.length; i++) { String paramClassName = readClassName(streamReader); parameterTypes[i] = getClass(paramClassName); } try { Method method = serviceClass.getMethod(methodName, parameterTypes); Object[] parameterValues = new Object[parameterTypes.length]; for (int i = 0; i < parameterValues.length; i++) { parameterValues[i] = streamReader.deserializeValue(parameterTypes[i]); } return new S3RPCRequest(service, new RPCRequest(method, parameterValues, serializationPolicy, streamReader.getFlags())); } catch (NoSuchMethodException e) { throw new IncompatibleRemoteServiceException(e.getMessage(), e); } } catch (SerializationException ex) { throw new IncompatibleRemoteServiceException(ex.getMessage(), ex); } }
From source file:org.slim3.gwt.server.rpc.GWTServiceServlet.java
License:Apache License
/** * Returns class name./*from ww w. j a v a2 s . c o m*/ * * @param streamReader * the stream reader * @return class name * @throws SerializationException * if {@link SerializationException} occurred */ protected String readClassName(ServerSerializationStreamReader streamReader) throws SerializationException { String name = streamReader.readString(); int index; if (streamReader.hasFlags(AbstractSerializationStream.FLAG_ELIDE_TYPE_NAMES)) { SerializationPolicy serializationPolicy = streamReader.getSerializationPolicy(); if (!(serializationPolicy instanceof TypeNameObfuscator)) { throw new IncompatibleRemoteServiceException("RPC request was encoded with obfuscated type names, " + "but the SerializationPolicy in use does not implement " + TypeNameObfuscator.class.getName()); } String maybe = ((TypeNameObfuscator) serializationPolicy).getClassNameForTypeId(name); if (maybe != null) { return maybe; } } else if ((index = name.indexOf('/')) != -1) { return name.substring(0, index); } return name; }
From source file:org.talend.mdm.webapp.general.gwt.ProxyGWTServiceImpl.java
License:Open Source License
private String getServiceIntfName(String encodedRequest) { ClassLoader classLoader = Thread.currentThread().getContextClassLoader(); ServerSerializationStreamReader streamReader = new ServerSerializationStreamReader(classLoader, this); try {/*w ww .j av a2 s .c o m*/ streamReader.prepareToRead(encodedRequest); return streamReader.readString(); } catch (SerializationException ex) { throw new IncompatibleRemoteServiceException(ex.getMessage(), ex); } }