| /* |
| * Copyright 2007 Google Inc. |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); you may not |
| * use this file except in compliance with the License. You may obtain a copy of |
| * the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT |
| * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the |
| * License for the specific language governing permissions and limitations under |
| * the License. |
| */ |
| package com.google.gwt.examples.rpc.server; |
| |
| import com.google.gwt.user.client.rpc.IncompatibleRemoteServiceException; |
| import com.google.gwt.user.server.rpc.RPC; |
| import com.google.gwt.user.server.rpc.RPCRequest; |
| |
| import java.lang.reflect.InvocationTargetException; |
| import java.lang.reflect.Method; |
| |
| import javax.servlet.http.HttpServlet; |
| import javax.servlet.http.HttpServletRequest; |
| import javax.servlet.http.HttpServletResponse; |
| |
| /** |
| * Example demonstrating a more complex RPC integration scenario. |
| */ |
| public class AdvancedExample extends HttpServlet { |
| /** |
| * An example of how you could integrate GWTs RPC functionality without using |
| * the {@link com.google.gwt.user.server.rpc.RemoteServiceServlet}. Note that |
| * it also shows how mapping between and RPC interface and some other POJO |
| * could be performed. |
| */ |
| @Override |
| public void doPost(HttpServletRequest httpRequest, |
| HttpServletResponse httpResponse) { |
| String payload = readPayloadAsUtf8(httpRequest); |
| |
| try { |
| try { |
| RPCRequest rpcRequest = RPC.decodeRequest(payload); |
| |
| Object targetInstance = getInstanceToHandleRequest(httpRequest, |
| rpcRequest); |
| |
| Method targetMethod = maybeMapRequestedMethod(targetInstance, |
| rpcRequest.getMethod()); |
| |
| Object[] targetParameters = maybeMapParameters(rpcRequest.getParameters()); |
| |
| try { |
| Object result = targetMethod.invoke(targetInstance, targetParameters); |
| |
| result = maybeMapResult(rpcRequest.getMethod(), result); |
| |
| /* |
| * Encode the object that will be given to the client code's |
| * AsyncCallback::onSuccess(Object) method. |
| */ |
| String encodedResult = RPC.encodeResponseForSuccess( |
| rpcRequest.getMethod(), result); |
| |
| sendResponseForSuccess(httpResponse, encodedResult); |
| } catch (IllegalArgumentException e) { |
| SecurityException securityException = new SecurityException( |
| "Blocked attempt to invoke method " + targetMethod); |
| securityException.initCause(e); |
| throw securityException; |
| } catch (IllegalAccessException e) { |
| SecurityException securityException = new SecurityException( |
| "Blocked attempt to access inaccessible method " |
| + targetMethod |
| + (targetInstance != null ? " on target " + targetInstance |
| : "")); |
| securityException.initCause(e); |
| throw securityException; |
| } catch (InvocationTargetException e) { |
| Throwable cause = e.getCause(); |
| |
| Throwable mappedThrowable = maybeMapThrowable(cause, |
| rpcRequest.getMethod()); |
| |
| /* |
| * Encode the exception that will be passed back to the client's |
| * client code's AsyncCallback::onFailure(Throwable) method. |
| */ |
| String failurePayload = RPC.encodeResponseForFailure( |
| rpcRequest.getMethod(), mappedThrowable); |
| |
| sendResponseForFailure(httpResponse, failurePayload); |
| } |
| } catch (IncompatibleRemoteServiceException e) { |
| sendResponseForFailure(httpResponse, RPC.encodeResponseForFailure(null, |
| e)); |
| } |
| } catch (Throwable e) { |
| /* |
| * Return a generic error which will be passed to the client code's |
| * AsyncCallback::onFailure(Throwable) method. |
| */ |
| sendResponseForGenericFailure(httpResponse); |
| } |
| } |
| |
| private Object getInstanceToHandleRequest(HttpServletRequest httpRequest, |
| RPCRequest rpcRequest) { |
| return null; |
| } |
| |
| private Method maybeMapRequestedMethod(Object targetInstance, Method method) { |
| return null; |
| } |
| |
| private Object[] maybeMapParameters(Object[] parameters) { |
| return null; |
| } |
| |
| private Object maybeMapResult(Method method, Object targetResult) { |
| return null; |
| } |
| |
| private Throwable maybeMapThrowable(Throwable cause, Method method) { |
| return null; |
| } |
| |
| private String readPayloadAsUtf8(HttpServletRequest httpRequest) { |
| return null; |
| } |
| |
| private void sendResponseForFailure(HttpServletResponse httpResponse, |
| String failurePayload) { |
| } |
| |
| private void sendResponseForGenericFailure(HttpServletResponse httpResponse) { |
| } |
| |
| private void sendResponseForSuccess(HttpServletResponse httpResponse, |
| String encodedResult) { |
| } |
| } |