Techiella: GWT Interview questions

Why GWT?

Use Java for creating Ajax applications

No need to worry about browser dependencies, it works in all the browsers.

debugging UI is easy

UIBinder - useful for designing the GUI using XML format ( you can mix HTML and GWT Widgets)

Code Splitting is easy

Important modules in GWT?

GWT Compiler

JRE Emulation library

Hosted Mode ( Run as java)

Web Mode ( Run as JavaScript)

What is GWT Compiler?

GWT Compiler used to convert the client side Java code to Javascript at the time of building the source files.

Is GWT works in all the browsers? If yes why?

Yes GWT works in all the browsers because GWT compiler creates javascript code per browser and per localization.

I meant, if you configure module.xml with Firefox and IE then GWT compiler will create javascript code for both browsers seperately.

And when you load the application it first check from which browser you are opening the application and it will load the corresponding javascript.

It means GWT supports Cross browser functionality.

GWT - Java Emulation library?

Google Web Toolkit includes a library that emulates a subset of the Java run-time library. The list below shows the set of JRE packages, types and methods that GWT can translate automatically. Note that in some cases, only a subset of methods is supported for a given type.

    java.lang
    java.lang.annotation
    java.math
    java.io
    java.sql
    java.util
    java.util.logging

HTML

-- > .nocache.js (bootstrap JavaScript file)
-- > Which loads the browser specific files (Permutation javascript file)

Module.xml

         -- > Basic inherits (required modules)
         -- >Entry point class (onModuleLoad () method)
         -- > cross site linker (useful for code splitting)

GWT Panels:

RootPanel is the top level panel.

For layout the page, we could use following layout panels, finally we need to add all those layout panels in RootPanel.

DockLayoutPanel

SplitLayoutPanel

StackLayoutPanel

TabLayoutPanel

Use below panels inside the Layout panels for holding the widgets.

HorizontalPanel

VerticalPanel ( Prefer using FlowPanel )

Code Splitting:

Using GWT Way:

        GWT.runAsync(new RunAsyncCallback() {
          public void onFailure(Throwable caught) {
            Window.alert("Code download failed");
          }
          public void onSuccess() {
            Window.alert("Hello, AJAX");
          }
        });

Using GWTP Way (just with Annotations in Presenter Proxy)

@ProxyStandard – Initial loading
@ProxyCodeSplitting – On demand loading

GWT Linkers:

             IFrameLinker – Default
                XSLinker – For cross site support
                SingleScriptLinker

Refer following URL for detailed description

http://www.gwtproject.org/doc/latest/DevGuideCodeSplitting.html

How to create custom widgets in GWT?

Create a class that should extends Composite class of GWT.
Inside the constructor you can write you logic to create a widget and call the initWidget method().

Then you can use this class in anywhere in the application and add this widget in any panels.

Refer following URL

https://developers.google.com/web-toolkit/doc/latest/DevGuideUiCustomWidgets

What is the advantage of using Cell Widgets in GWT and Why?

Why we need to use CellTable instead FlexTable or GRID?

CellTable gives the following features

Pagination
Default Header and Footer - Using DataGrid
Column Sorting
Column Width setting

You can even create Custom Cells

What is AsyncDataProvider in GWT cell widgets?

When you want to display dynamic data or a range of data, not just a static list, then we should use AsyncDataProvider.

What is the use of ValueUpdater vs FieldUpdater in Cell Widgets?

GWT ClientBundle:

In GWT we can use ClientBundle to load all the images and CSS files in one single file and use it anywhere in the application. It provides flexible way to get the resources.

1. It creates a single image from the collection of images at compile time to reduce the image size.
2. Enable more aggressive caching headers for program resources. It will go to server for every-time to get the images.
3.Eliminate mismatches between physical file names and constants in Java code by performing consistency checks during the compile

Examples

To use ClientBundle, add an inherits tag to your gwt.xml file:

If you write this interface:

public interface MyResources extends ClientBundle {
  public static final MyResources INSTANCE =  GWT.create(MyResources.class);

  @Source("my.css")
  public CssResource css();

  @Source("config.xml")
  public TextResource initialConfiguration();

  @Source("manual.pdf")
  public DataResource ownersManual();
}

You can then say:

 // Inject the contents of the CSS file
  MyResources.INSTANCE.css().ensureInjected();

  // Display the manual file in an iframe
  new Frame(MyResources.INSTANCE.ownersManual().getURL());

Server side communication:

-- > Using GWT RPC
      To user GWT RPC we need to create couple of interfaces and one implementation class.
      1. Synchronous interface
      2. Asynchronous interface
      3. Implementation class implements Synchronous interface

      Why two interfaces?
      GWT Supports non blocking calls, it means call from client side to server side is non blocking. It just call the server side method and proceed with remaining lines.

      So, how are we going to get the response from server side?
       For this purpose only GWT has one Asynchronous interface which has one parameter called AsyncCallBack, using this callback object it will call the client side code once the server completed the execution.
       So basically all the calls to server side method will have two call back methods
       onSuccess()
       onFailure()

       If the server side method executed properly then onSuccess() method will be called otherwise onFailure() method will be called, so based on this we can proceed with our functionality.

-- > Using RequestBuilder

          To use RequestBuilder we need to inherit HTTP Module in module.xml file


--> Using Command Pattern (GWTP Dispatcher)
      We could use GWTP framework, which is basically a MVP based framework supports lot of good features like.

Dependency injection through GIN and Guice;
Simple but powerful history management mechanism;
Support for nested presenters;
Lazy instantiation for presenter and view;
Effortless and efficient code splitting;
Integrated command pattern supporting undo/redo.

GWT Serialization:

-- >Using GWT IsSerializable OR Java Serializable

Please find below couple of good links related to this topic

http://stackoverflow.com/questions/3065135/what-is-the-purpose-of-the-isserializable-interface-in-gwt-regarding-the-rpc-me

https://groups.google.com/forum/#!topic/gwt-dispatch/Yl-tsNgU_GU

What are some advantages for the Model-View-Presenter pattern?

What is Entry-point class in GWT and how to configure this?

Entry point class in GWT is like normal main class in Java application. So this is the class going to be called on application startup.

We need to configure this class in module.XML file

It has a method called onModuleLoad(), this method will be called first when we start any GWT based application.

How GWT Navigation works?

In GWT we can handle page navigation using couple of ways.

1. Using History tokens

2. Clearing the content panel and load the new page in the content panel.

GWT RPC vs GWT RequestBuilder ( for server side communication )

1. When we use GWT RPC we dont need to handle Serialization / Deserialization of the request.

2. When we use RequestBuilder we need to handle Serialization / Deserialization of the request/response.

What is the use of UIBInder in GWT and why we should use UIBinder?

How can you test a GWT application?

What is deferred binding in GWT?

Describe what a GWT generator does
    Refer the following URL
    http://stackoverflow.com/questions/3298317/what-is-the-use-gwt-generator

What are some benefits of using CssResource, ImageResource, TextResource, etc

How does GWT app work? (compiling to JavaScript, cross-browser support, bootstrapping script, etc.)

When would you NOT use GWT? (rather general and open-ended question, but it demonstrates if developer is really into this technology)
    Follow-up question: What GWT alternatives would you consider?

What 3d party libraries have used with GWT? Which libraries would you recommend? Why?
        GUICE - for Server side dependency injection
        GIN - for client side dependency injection
        GWTP - Model - View - Presenter framework

Describe server-side development with GWT.

Did you use DI framework with GWT?
        GUICE - For server side dependency injection
        GIN - Client side dependency injection

What does make MVP better fit for GWT than general MVC?

Serialization and Un-serialization. What is required of a user defined class for it to be serializable?

       All we need to do is create a class which implements GWT IsSerializable or Java Serializable interface.

IsSerializable Vs Serializable:

Both are acceptable in GWT to make a class serializable.

When you use Normal java Serializable you need to take care all the serialized classes are available in the Serialization policy file or not.

But when you use GWT IsSerializable, you don't need to worry about Serialization policy file.

So, if your class is only used by GWT application, better we can go for GWT IsSerializable.

If your model class is used by more than one Application then better use Java Serializable.

Event handling. Describe how an event bus is used and implemented.
    Create a Classs that extends GWTEvent
        Define a new handler and marker interface for the event class.
        Register the event using EventBus where you implement interface( the one written inside the event class)
        implement the interface method and call the event fire method

    Refer the following link for more detailed information.
        http://stackoverflow.com/questions/998621/gwt-custom-event-handler

Describe how one module can inherit or use members from another GWT module.
    http://stackoverflow.com/questions/890352/gwt-module-xml-how-to-redefine-and-use-more-than-one-user-agent
    http://groups.google.com/group/google-web-toolkit/browse_thread/thread/2df682d31e50511e/b42924ca8e40e559
    stackoverflow.com/questions/3292671/multiple-entry-points-in-gwt
    http://stackoverflow.com/questions/332285/large-apps-in-gwt-one-module-or-several

GWT Interview Questions

What is Google Web Toolkit?

Google Web Toolkit (GWT) is an open source Java development framework that lets you escape the matrix of technologies that make writing AJAXapplications so difficult and error prone. With GWT, you can develop and debug AJAX applications in the Java language using the Java development tools of your choice. When you deploy your application to production, the GWT compiler translates your Java application to browser-compliant JavaScript and HTML.
Here's the GWT development cycle:Use your favorite Java IDE to write and debug an application in the Java language, using as many (or as few) GWT libraries as you find useful.
Use GWT's Java-to-JavaScript compiler to distill your application into a set of JavaScript and HTML files that you can serve with any web server.
Confirm that your application works in each browser that you want to support, which usually takes no additional work.

Write a Sample GWT programm ?

public class Slicr implements EntryPoint {public void onModuleLoad() {
final Button button = new Button("Click me");
final Label label = new Label();
button.addClickListener(new ClickListener() {
public void onClick(Widget sender) {
if (label.getText().equals(""))
label.setText("Hello World!");
else
label.setText("");
}
});
RootPanel.get("slot1").add(button);
RootPanel.get("slot2").add(label);
}
}

What are the different listeners in GWT ?

Here is the list of listeners HistoryListener,Changes to Browser History,WindowCloseListener,WindowResizeListener,ChangeListener,ClickListener,
FormHandler,FocusListener,KeyBoardListener,LoadListener,MouseListener,PopupListener,
ScrollListener,TableListener,TabListener,TreeListener.

GWTevent listeners

GWT defines event listeners that you can attach to your widgets to monitor browser events. Event Listeners are just interfaces that you can implement in your widget. If you want to trap mouse click events, then your widget should implement theClickListener interface and define theonClick(Widget sender)method. The code inside this method will be fired every time the userclicks on your widget.

You can create a new anonymous ClickListener every time you want toassignit to a widget as given in the Hello gwt example.

button.addClickListener(new ClickListener() {
 public void onClick(Widget sender) {
  processData(sender.getText());
  reportData(sender.getText());
  logResults();
 }
});

But this results in localized code and lesser code reusability. Let us say we want to add another widget (a HTML link), which has to run the same code as in the onClick()method. We would be using the addClickListenermethod for this link and would be rewriting the same code again separately. And if we need to add another method in theonClick() method code between processData() and reportData() we will have to change each instance of onClick().

Alternatively, we can implement the listeners in the container widget to handle the events of contained widgets as shown below, making the code more reusable.

public class MainPanel extends Composite 
 implements ClickListener{
 private Button button=new Button("Button");
 public MainPanel(){
 
  //...
  button.addClickListener(this);
 }
 public void onClick(Widget sender){
  if(sender==button){
   processData(sender.getText());
   reportData(sender.getText());
   logResults();
  }
 }
}

With this approach, if we want to add a HTML widget link that implements the same function, we would just have to add the line

link.addClickListener(this);

in MainPanel() and modify one line in the onClick(Widget sender) method

if(sender==button||sender==link)

Given Below is a listing of GWT Event listeners for handling various events:

Listener	Event notifications	Methods Defined
HistoryListener	Changes to Browser History	onHistoryChanged(String historyToken)
WindowCloseListener	Window Closure Events	onWindowClosed() onWindowClosing()
WindowResizeListener	Window Resizing Events	onWindowResized(int width, int height)
ChangeListener	fires when a widget changes	onChange(Widget sender)
ClickListener	fires when a widget receives a 'click'	onClick(Widget sender)
FormHandler	fires on receiving Form events from the FormPanel to which it is attached	onSubmit(FormSubmitEvent event) onSubmitComplete( FormSubmitCompleteEvent event)
FocusListener	Focus Events	onFocus(Widget sender) onLostFocus(Widget sender)
KeyBoardListener	Keyboard Events	onKeyDown(Widget sender, char keycode, int modifiers) onKeyPress(Widget sender, char keycode, int modifiers) onKeyUp(Widget sender, char keycode, int modifiers)
LoadListener	listens to 'load' event of a widget	onLoad(Widget Sender) onError(Widget Sender)
MouseListener	listens to mouse events of a widget	onMouseEnter(Widget sender) onMouseLeave(Widget sender) onMouseDown(Widget sender, int x, int y) onMouseUp(Widget sender, int x, int y) onMouseMove(Widget sender, int x, int y)
PopupListener	listens to the events of a PopupPanel widget	onPopupClosed(PopupPanel sender, boolean autoClose)
ScrollListener	listens to Scroll events	onScroll(Widget widget, int scrollLeft, int scrollTop)
TableListener	listens to events pertaining to a Table widget	onCellClicked( SourcesTableEvents sources, int row, int cell)
TabListener	listens to the events of a Tab Widget	onBeforeTabSelected( SourcesTabEvents sender, int tabIndex) onTabSelected( SourcesTabEvents sender, int tabIndex)
TreeListener	listens to the events of a Tree Widget	onTreeItemSelected( TreeItem item) onTreeItemChanged( TreeItem item)

The Button widget defines the addClickListener method which attaches aClickListener object to it. Similarly, the Tree widget defines theaddTreeListenermethod. Not all event listeners are available for all widgets - for example, theaddMouseListener method is not defined for a DockPanelWidget. One way to add theMouseListener functionality to this DockPanel is to create a composite that includes aFocusPanel widget (which supportsaddMouseListener) and wrap the DockPanelwidget within it.

Why doesn't GWT provide a synchronous server connection option?

GWT's network operations are all asynchronous, or non-blocking. That is, they return immediately as soon as called, and require the user to use a callback method to handle the results when they are eventually returned from the server. Though in some cases asynchronous operators are less convenient to use than synchronous operators, GWT does not provide synchronous operators.

The reason is that most browsers' JavaScript engines are single-threaded. As a result, blocking on a call to XMLHTTPRequest also blocks the UI thread, making the browser appear to freeze for the duration of the connection to the server. Some browsers provide a way around this, but there is no universal solution. GWT does not implement a synchronous network connection because to do so would be to introduce a feature that does not work on all browsers, violating GWT's commitment to no-compromise, cross-browser AJAX. It would also introduce complexity for developers, who would have to maintain two different versions of their communications code in order to handle all browsers.

What is AsyncCallback Interface?

public interface AsyncCallbackThe primary interface a caller must implement to receive a response from a remote procedure call.

If an RPC is successful, then onSuccess(Object) is called, otherwise onFailure(Throwable) is called.

Each callable asynchronous method corresponds to a method in the correlated service interface. The asynchronous method always takes an AsyncCallback as its last parameter, where T is the return type of the correlated synchronous method.

A call with a typical use of AsyncCallback might look like this:

service.getShapes(dbName, new AsyncCallback() {
public void onSuccess(Shape[] result) {
// It's always safe to downcast to the known return type.
controller.processShapes(result);
}

public void onFailure(Throwable caught) {
// Convenient way to find out which exception was thrown.
try {
throw caught;
} catch (IncompatibleRemoteServiceException e) {
// this client is not compatible with the server; cleanup and refresh the
// browser
} catch (InvocationException e) {
// the call didn't complete cleanly
} catch (ShapeException e) {
// one of the 'throws' from the original method
} catch (DbException e) {
// one of the 'throws' from the original method
} catch (Throwable e) {
// last resort -- a very unexpected exception
}
}
});

What are the language differences between web mode and hosted mode?

Typically, if your code runs as intended in hosted mode and compiles to JavaScript without error, web mode behavior will be equivalent. Occasional different problems can cause subtle bugs to appear in web mode that don't appear in hosted mode. Fortunately those cases are rare.

How do I make a call to the server if I am not using GWT RPC?

The heart of AJAX is making data read/write calls to a server from the JavaScript application running in the browser. GWT is "RPC agnostic" and has no particular requirements about what protocol is used to issue RPC requests, or even what language the server code is written in. Although GWT provides a library of classes that makes the RPC communications with a J2EE server extremely easy, you are not required to use them. Instead you can build custom HTTP requests to retrieve, for example, JSON or XML-formatted data.

To communicate with your server from the browser without using GWT RPC:

Create a connection to the server, using the browser's XMLHTTPRequest feature.
Construct your payload according to whatever protocol you wish to use, convert it to a string, and send it to the server over the connection.
Receive the server's response payload, and parse it according to the protocol.
You must use an asynchronous server connection.

Can I use GWT with my favorite server-side templating tool?

Yes, you are free to use GWT with any server-side templating tool.

With GWT development, your Java client code gets compiled into equivalent JavaScript that is loaded into your host pages. The generated product is totally independent from the server-side technology that you choose to use in your web application.

You can go ahead and use your favorite server-side templating tool and include your template directives into your host pages along with your GWT-generated JavaScript files. The server-side technology you're using to realize the templates is invisible to the browser and works just as it does without your GWT modules.

What is Gwt Sever Side RemoteServiceServlet?

public class RemoteServiceServlet extends javax.servlet.http.HttpServletimplements SerializationPolicyProvider
The servlet base class for your RPC service implementations that automatically deserializes incoming requests from the client and serializes outgoing responses for client/server RPCs.

Techiella

Saturday, April 18, 2015

GWT Interview questions

Why GWT?

Important modules in GWT?

Examples

GWT Interview Questions

Blog Archive