GWT RPC

RPC (Remote Procedure Call) helps in client communication with server. RPC is a process of calling a method from a class however, in this process only difference is that the class is located on a server but not actually the part of client program.

There is a problem with RPC, as JavaScript runs in web browser and the RPC call from browser it hangs browser until the response is received.

To avoid the browser hanging, GWT RPC call is made "Asynchronous" and the browser does not hang while waiting for the response.

GWT RPC Mechanism

The implementation of GWT RPC is based on the Java Servlet technology. The server-side code that gets called from the client is usually referred to as a service and the remote procedure call is referred as calling a service.

The RPC implementation in a GWT application is given below.

Creating Service

Service is known as an interface at client side that defines all service methods. It is placed under client-package as service is available at client side.

1) Define Service Interface: We will be creating a client-side Java interface that extends RemoteService interface to develop a new service interface.

SampleService.java

import com.google.gwt.user.client.rpc.RemoteService;
import com.google.gwt.user.client.rpc.RemoteServiceRelativePath;
@RemoteServiceRelativePath("sampleservice")
public interface SampleService extends RemoteService{
String sayHello(String name); 
}

2) Define Async Service Interface: The above service would produce error until unless it is defined inside Async interface with void as return type. This interface should have call back object for the Async service. The name of the Async interface should be same as service interface followed by Async.

SampleServiceAsync.java

import com.google.gwt.user.client.rpc.AsyncCallback;

 public interface SampleServiceAsync { 
void sayHello(String name, AsyncCallback callback);
 }

3) Async Callback and Error Handling: This interface implements two methods OnSuccess and OnFailure. In this the class receives a callback from server and provides its functionality.

SampleCallback.java

import com.google.gwt.user.client.Window;
 import com.google.gwt.user.client.rpc.AsyncCallback;
public class SampleCallback implements AsyncCallback {
@Override 
public void onFailure(Throwable caught) {
 Window.alert("Not able to process client request. Exception occurred at server: " + caught);
 }
@Override
 public void onSuccess(String result) {
 Window.alert("Client request processed successfully. Result from server: " + result)
 }
 }

Implementing Service

Services are implemented to perform some processing to respond to client requests. Service implementation is based on Servlet architecture.

1) Define Service Interface Implementation: GWT Service must extend RemoteServiceServlet class and should implement the associated service interface. It extends RemoteServiceServlet instead of HttpServlet. Serialization of the data is automatically handled by RemoteServiceServlet.

SampleServiceImpl.java

 import com.google.gwt.user.server.rpc.RemoteServiceServlet;
 import com.javatpoint.helloworld.client.service.SampleService;
public class SampleServiceImpl extends RemoteServiceServlet implements SampleService {
 @Override
public String sayHello(String name) {
 return "Hello " + name;
}
 }

2) Update Entry of Service: In this we update the entry inside web.xml where we define the servlet and map the URL.

web.xml

<!-- servlets -->
<servlet>
        <servlet-name> SampleServlet</servlet-name>
         <servlet-class> com.javatpoint.helloworld.server.SampleServiceImpl </servlet-class>
</servlet>
<servlet-mapping>
        <servlet-name> SampleServlet</servlet-name>
        <url-pattern>/samplewebapplication/sampleservice</url-pattern>
</servlet-mapping>

Compilation file: Sample WebApplicaion.java

public class SampleWebApplication implements EntryPoint, ClickHandler{
SampleServiceAsync sampleServiceAsync = GWT.create(SampleService.class); 
Label lbl; TextBox textBox;
/** * This is the entry point method. */
 		public void onModuleLoad() {
VerticalPanel verticalPanel = new VerticalPanel();
verticalPanel.setSize("100%", "100%"); verticalPanel.setVerticalAlignment(HasVerticalAlignment.ALIGN_MIDDLE);
verticalPanel.setHorizontalAlignment(HasHorizontalAlignment.ALIGN_CENTER);
 				textBox = new TextBox();
 Button btn = new Button("Get Update from Server");  btn.addClickHandler(this);
 lbl = new Label("The text will be updated here.");
 Image image = new Image();
 				image.setUrl("https://www.javatpoint.com/ uploads/ Javatpoint-logo.png");
verticalPanel.add(textBox); verticalPanel.add(btn); verticalPanel.add(lbl); verticalPanel.add(image);
RootLayoutPanel.get().add(verticalPanel);
}
@Override
public void onClick(ClickEvent event) {
sampleServiceAsync.sayHello(textBox.getText(), new AsyncCallback() {
@Override
public void onFailure(Throwable caught) {
// handle failure from server.
 Window.alert("Exception Received from server.");
}
@Override
 public void onSuccess(String result) { lbl.setText(result);
}
 });
 }
 }

Output: