Google App Engine and Java

Summary of GWT Reading

GWT let us write client program as Java program. Client is written in Java which is almost like a traditional GUI application such as having layout managers, attaching event handlers, and so on. In GWT, GUI code is translated into HTML and JavaScript. So, instead of compiling Java UI code to Java bytecodes, it compiles Java to JavaScript source code.

GWT application consists of a set of modules. A module is a GWT package consisting of Java code, JavaScript, HTML files, images, data definitions, and whatever else you need in a web application.

A typical GWT App has the following directory structure:

• GWT libraries
• a source directory named src

Ø       a module declaration (.gwt.xml)

Ø       a package for the client-side Java code

Ø       a package for the server-side Java code.

• a target directory named war. war stands for “web archive”: the deployable package

GWT Module

 - a fundamental unit of code in GWT

- consists of a collection of things: Java code; resources like CSS, HTML, or image files; and GWT customizations, like Java to JavaScript compiler extensions.

- Modules can inherit things from other modules. (including css unlike in Java where it’s basically the code)

- GWT application starts with an entry point. An entry point is, pretty much, the GWT GUI equivalent of a main function. In the module file (.gwt.xml), you declare entry points. The Java class must extend the EntryPoint interface defined in GWT. The onLoadModule() is the entryPoint method. This is where you assemble the components in the UI.

Setting Up the UI

- In setting up, we need interface frame and the Entry Point class.

- The user interface frame is defined by an HTML file. The HTML file isn’t considered source code, so it should not be in the src directory. Instead, it should be placed in the war folder.

- In the html file, you may define the structure of the UI. For example, creating an empty box in the UI. The <td> tag creates a box in the HTML layout, but it’s empty—there’s nothing inside of the tag. In the Java code, we’ll insert something by referencing it using its id= tag.

- In onModuleLoad of the entry point class, we can create there the UI widgets like creating a button and a text box like what we do in AWT or SWING.

- The main panel of GWT is RootPanel.  Components can be arranged using layout managers for example VerticalPanel. 

RPC in GWT

- An RPC is something that looks almost like a normal method call, but under the covers, it’s translated by the system into a request sent from the client to the server. The return value of the RPC is the response

sent from the server back to the client.

Two ways to issue RPC:

1.       Java Native RPC Layer

-          problem with this approach: communication is slow.

2.       Google-style RPC

-          asynchronous or continuation passing style for remote calls. The call itself returns nothing. Instead, it takes an extra parameter, which is a function to invoke on the result of the RPC whenever it’s received.

Two parts of RPC in GWT

1.      Client-Side RPC in GWT

Ø    Synchronous interface for the service methods.

-  In the hello-world application, it’s called the greeting service. The greeting service interface is written in the client package because it is the client who is going to be the user of the interface.

                                    - can be annotated with information about how they’ll fit into the URL structure      

                                   of the application.

                                    - The service interface declaration must extend he GWT interface

                                   com.google.gwt.user.client.rpc.RemoteService.

                - Any parameters to a service method must extend either java.lang.Serializable or 

               the GWT specific variant com.google.gwt.user.client.rpc.IsSerializable.

Ø   Asynchronous interface counterpart of the synchronous interface

- It must have methods with exactly the same name as the methods in the synchronous interface; each method must have return type void; and each method adds a parameter at the end, which is an AsyncCallback and whose type parameter is the return type of the synchronous method.

- It’s really only used by the client—the actual plumbing to map between the asynchronous and synchronous interfaces is generated by GWT. The only purpose of the asynchronous interface is to provide the call interface that the client will use.

2.      Server-Side RPC in GWT

Ø Implement the asynchronous client interface using a class that extends RemoteServiceServlet.

Ø It is here where the data sent by the client will be processed.