2.1/user/javadoc/com/google/gwt/examples/rpc/server/AdvancedExample.java

/*
 * 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) {
  }
}