com.google.gwt.sample.simplerpc.client.SimpleRPC.java Source code

Introduction

Here is the source code for com.google.gwt.sample.simplerpc.client.SimpleRPC.java

Source

/*
 * 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.sample.simplerpc.client;

import com.google.gwt.core.client.EntryPoint;
import com.google.gwt.core.client.GWT;
import com.google.gwt.user.client.Window;
import com.google.gwt.user.client.rpc.AsyncCallback;
import com.google.gwt.user.client.ui.FlexTable;
import com.google.gwt.user.client.ui.HTML;
import com.google.gwt.user.client.ui.Panel;
import com.google.gwt.user.client.ui.RootPanel;

import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;

/**
 * Demonstrates a simple use of the RPC mechanism.
 */
public class SimpleRPC implements EntryPoint {

    public void onModuleLoad() {
        final Panel root = RootPanel.get();

        // Create the RPC client.
        SimpleRPCServiceAsync simpleRPCService = createSimpleRPCServiceAsync();

        // Collection of very simple RPC calls to "getString".
        callGetString(root, simpleRPCService);

        // A single simple call to "getMultipleStrings".
        callGetMultipleStrings(root, simpleRPCService);
    }

    /**
     * Creates a single call to <code>getMultipleStrings</code>.
     */
    private void callGetMultipleStrings(final Panel root, SimpleRPCServiceAsync simpleRPCService) {
        AsyncCallback<Map<Integer, String>> getMultipleStringsCallback = createGetMultipleStringsCallback(root);

        // Should print a table of key value pairs.
        List<Integer> indexes = new ArrayList<Integer>();
        indexes.add(Integer.valueOf(0));
        indexes.add(Integer.valueOf(2));
        simpleRPCService.getMultipleStrings(indexes, getMultipleStringsCallback);
    }

    /**
     * Calls <code>getString</code> three times, the first two should return
     * valid answers, the third should give back an error. <p/> Control flow will
     * continue after making each call. Later the 'callback' onSuccess or
     * onFailure method will be invoked when the RPC completes. There is no order
     * guarantee here, the three results could appear on the page in any order.
     */
    private void callGetString(final Panel root, SimpleRPCServiceAsync simpleRPCService) {
        // Create a callback to use.
        AsyncCallback<String> singleGetStringCallback = createGetStringCallback(root);

        // Should print 'Hello World'.
        simpleRPCService.getString(0, singleGetStringCallback);

        // Should print 'Bonjour monde'.
        simpleRPCService.getString(1, singleGetStringCallback);

        // Should print an IndexOutOfBoundsException.
        simpleRPCService.getString(3, singleGetStringCallback);
    }

    /**
     * Create an asynchronous callback for the <code>getMultipleStrings</code>
     * RPC call. The same callback can be used for many RPC calls or customized
     * for a single one.
     */
    private AsyncCallback<Map<Integer, String>> createGetMultipleStringsCallback(final Panel root) {
        return new AsyncCallback<Map<Integer, String>>() {

            public void onFailure(Throwable caught) {
                Window.alert("error: " + caught);
            }

            public void onSuccess(Map<Integer, String> result) {
                FlexTable t = new FlexTable();
                t.setBorderWidth(2);
                t.setHTML(0, 0, "<b>Map Key</b>");
                t.setHTML(0, 1, "<b>Map Value</b>");
                int index = 1;
                for (Entry<Integer, String> element : result.entrySet()) {
                    Integer key = element.getKey();
                    String value = element.getValue();
                    t.setText(index, 0, key.toString());
                    t.setText(index, 1, value);
                    ++index;
                }
                root.add(new HTML("<h3>Result(on success)</h3>"));
                root.add(t);
            }
        };
    }

    /**
     * Create an asynchronous callback for the <code>getString</code> RPC call.
     * The same callback can be used for many RPC calls or customized for a single
     * one.
     */
    private AsyncCallback<String> createGetStringCallback(final Panel root) {
        return new AsyncCallback<String>() {
            public void onFailure(Throwable caught) {
                root.add(new HTML("<h3>Result (on failure) </h3>"));
                root.add(new HTML("<i>" + caught.getMessage() + "</i>"));
            }

            public void onSuccess(String result) {
                root.add(new HTML("<h3>Result (on success) </h3>" + result));
            }
        };
    }

    /**
     * Returns an configured instance of the <code>SimpleRPCService</code>
     * client proxy. <p/> Note that although you are creating the service
     * interface proper, you cast the result to the asynchronous version of the
     * interface. The cast is always safe because the generated proxy implements
     * the asynchronous interface automatically.
     */
    private SimpleRPCServiceAsync createSimpleRPCServiceAsync() {
        return GWT.<SimpleRPCServiceAsync>create(SimpleRPCService.class);
    }
}