Google Web Toolkit, or GWT, works on a simple but powerful idea. You write a web application in Java, and GWT cross-compiles it into JavaScript. This free, open source collection of tools is both supported and used by Google.

The latest version, GWT 2.5, includes a library of high-quality interface components, an easy-to-use UI designer, and a set of productivity tools that make using GWT a snap, and it supports industry-grade development techniques such as MVP, dependency injection, and event busses. And yes, the JavaScript it produces is really, really good, especially if you turn on the optional Closure compiler!

GWT in Action, Second Edition is a completely revised edition of the best-selling GWT book. It covers all the new features introduced in GWT 2.5, as well as the best development practices that have emerged in the GWT community. It begins with a rapid-fire introduction to GWT and Ajax to get you up to speed with GWT concepts and tools. Then, you’ll explore key concepts like managing events, interacting with the server, creating UI components, building your user interface declaratively using UiBinder, and more.

As you move through the engaging examples, you’ll pick up the skills you need to stay ahead of the pack. You’ll absorb the latest thinking in application design and industry-grade best practices, such as these:

• Writing code that handles internationalization and localization; you can make your applications usable by as many people as possible while keeping the download size as small as it can be (and small download sizes mean quicker starts and better user experience).
• Driving out browser differences in your coding; why worry that IE does things differently than other browsers requiring you to pepper your code with if/then/else statements? GWT does away with those concerns for you in the majority of cases, and when you implement your own functionality you can harness the same approaches to minimize your final application code size as well as have an easily maintainable code base (cutting your maintenance costs).
• Implementing the MVP pattern becomes easy in GWT with the arrival of Activitys and Places, though you’re not forced to implement MVP or forced to use Activitys and Places to do so.
• Using dependency injection to manage dependencies between various aspects of your application; you’ll see how to use the GIN library, which is based on the popular Guice library, to do dependency injection within GWT client-side code.
• Harnessing event busses to further loosely couple your application.
• Presenting large data sets in the new lightweight cell-based widgets, which support paging, sorting, and data retrieval while giving the best GUI performance possible.
• Editing data by using Editors, allowing the GWT compiler to take the strain of ensuring that code is produced to keep presentation and models in sync.
• Optimizing your code by implementing code splitting; even though GWT produces fantastically compact JavaScript code, it also supports you in pushing the complexity boundaries of your functionality. That probably will increase your code size, and so you can split up your application so that only necessary code segments are downloaded when appropriate. GWT also comes with a lightweight metrics mechanism and compiler reports to allow you to further tweak and optimize your code.

Any substantial application requires server-side components, and many books can tell you about all the server-side development techniques (Java, PHP, and so on) for which GWT is highly flexible and which it can plug into. Our approach in GWT in Action is to concentrate several chapters on ensuring you get a thorough understanding of GWT’s client/server communication techniques. For example:

• JSON processing
• GWT-RPC
• Form handling
• Traditional Ajax communication
• RequestFactory

Although we don’t have a dedicated section on security, we do highlight GWT techniques as and where appropriate, for example, using SafeHtml when creating new widgets, manipulating the DOM, or using i18n; using SafeHtmlTemplates in Cell widgets; and protecting against cross-site forgery requests in GWT-RPC.

We’ve substantially updated and rewritten the examples from the first edition, splitting them into examples that focus purely on the topic of the chapter. Our hope is that these new examples give you a much more focused view of how to use GWT as well as show off what GWT can do. By breaking out into examples per chapter, it should be much easier to see the techniques in use and then employ them directly in your applications as needed.

Who should read this book

The book is aimed at anyone with an interest in

• Understanding GWT initially and in more detail
• Pushing the boundaries of web application functionality in a controlled manner
• Reducing the headache of maintaining web applications
• Reducing the lifecycle costs of web applications that continuously excite your users

We appreciate that the readership will come from varied backgrounds—JavaScript programmers looking to see what the fuss is about or wanting, just as we did, to give better structure to their web applications; Java programmers learning that they can now program Ajax applications simply; server-side developers interested in understanding how GWT would affect them (it doesn’t have to); web designers looking to see how this useful development approach fits in with their approach (and to see how to guide programmers to use GWT’s built-in approaches to ensure their life is easier); managers/technicians looking to see how to get the web application beast under control; and many others.

In the first edition we spent a lot of time selling GWT itself. In this edition we no longer feel a need for that; rather we can spend the time on the exciting array of techniques and tools in GWT and get going more quickly.

Readers looking for an introduction to GWT concepts and components should find it in chapters 2 and 3. Here we go through using the tools to create a simple GWT HelloWorld application and show how to run in various modes (developer and super dev) as well as how to compile and debug problems. We then look at a more complex GWT application to show how to use concepts such as widgets, panels, history management, and styling. By the end of these two chapters, you should be familiar with creating a basic application, enhancing it to give some real complexity, as well as running/debugging the application in development mode and compiling it for web mode.

The middle part of the book covers techniques you’d use in everyday applications: building your own widgets, using client bundles, separating design from coding with UiBinder, communicating with the server in various ways, using widgets as editors, efficiently displaying/sorting/paging through large data sets, and interfacing with JavaScript (JSNI/fast JSON parsing with overlay objects).

More advanced readers will find that the book addresses the industry-grade approaches GWT supports that you may well have thought of but perhaps haven’t yet implemented—and we hope a few things you haven’t thought of yet! We cover MVP, dependency injection, deferred binding, generators, and using metrics and code splitting to squeeze out the most performant code possible.

You should be familiar with the concept of Java classes and packages, although we feel this is something you can pick up as you read the book, follow the code examples, and use an IDE, such as Eclipse. A lot of GWT (and Java) issues revolve around classpaths and GWT’s package structure, so we recommend a good read of chapter 2 if you get stuck.

Roadmap

Part 1 “Basics” consists of chapters 1 through 3. It aims to get you going in GWT and producing a first real-world example. We would suggest reading it in the order it is presented:

• Chapter 1 provides an introduction to GWT. We begin by defining what GWT is and how it fits into this new ecosphere of rich-client web development. Then for readers new to GWT we provide an overview of what GWT means and some explanation of the more popular components of the toolkit. The chapter then explains how to set up your development environment so that you can begin writing applications using GWT.
• Chapter 2 starts our journey with GWT. We look at how to use the Google Plugin for Eclipse to create a basic GWT application and then examine its structure and what we can do with it. It’s a hands-on chapter where you can create the application yourself as we reinforce the points (or you can just download the result). We also show how to run the application in development mode (and touch on the new experimental super dev mode), how to use standard debug tools to hunt problems, and how to compile the application for web mode, as well as clarify a number of GWT concepts such as modules and client- and server-side code.
• Chapter 3 takes the next step in building a real application. Typically you perform the steps in chapter 2 to get a base structure and then build your application on that result. In this chapter we look at an application that has been through those steps and examine the concepts of widgets, panels, event handling, managing history, and styling components to get from a mockup introduced at the start of the chapter to the actual implementation at the end.

Part 2 we have called “Next Steps” and covers chapters 4 through 13. Here we discuss the usual technologies that you will often use when taking your application to the next level. You can read this part in order or jump directly to the topics that you are interested in:

• Chapter 4 is where we really start to dig into GWT. We look at widgets (which include panels) in detail, covering their lifecycle and three ways to create new widgets should GWT not contain something you need (including creating composite widgets). We also spend a moment looking at the GWT 2.5 Elemental library and examine Layout panels because they’re the future of GWT panels.
• Chapter 5 introduces you to client bundles, a unique tool that allows you to create bundles of images, binary documents, stylesheets, and more and have them optimized by the GWT compiler. In this chapter you’ll also learn about GWT’s extension to CSS, which allows you to include runtime-evaluated expressions in your styles including constants and conditional statements.
• Chapter 6 is where we dive into UiBinder, one of the defining features of GWT. In this chapter we provide a superior method of creating complex composite widgets. We begin the chapter by showing you how to transform HTML into a UiBinder template and bind that template to a Java class. Next, we explain how to bind events to methods in the Java class and then how to apply CSS styles to the template elements.
• Chapter 7 introduces you to GWT-RPC, the first of several methods of communicating with the server. In this chapter we explain how you can send Java objects between the client and server, as opposed to using some other message format like JSON or XML. We then look at how you can debug client/server communications and how to protect your users from cross-site request forgery attacks.
• Chapter 8 examines RequestFactory, an alternate method of client/server communication. Whereas GWT-RPC is more general purpose, RequestFactory specifically targets the communication of domain objects that will ultimately be persisted in a database. In this chapter we provide an overview of the architecture and show you how to build the interfaces and objects required to use this tool and how to integrate it with Java’s Bean Validation specification (JSR-303).
• Chapter 9 The Editor framework supports editing of any bean-like object holding a bunch of properties using widgets. It reduces the amount of code needed to glue bean objects to widgets. Values are moved back and forth between the widget and the bean object with ready-to-use controllers called drivers. There are two types of drivers: the RequestFactoryEditorDriver that is used to edit remote objects and the SimpleBeanEditorDriver used for editing beans residing on the client. In this chapter you start by learning how to construct editors to support both remote and local beans.  You’ll find out how the framework can be used in both simple and complex situations. The chapter ends by presenting generic logic provided by the framework for even more effective ways to use the framework.
• Chapter 10’s data-presentation (aka Cell) widgets allow efficient display of large datasets and support paging and sorting through that data both locally and from the server. In this chapter we look at the provided underlying cells and how to create them, including via the GWT 2.5 UiBinder approach. Then we explore the six built-in widgets—including Lists, Tables, and Trees—and how they can be used, finishing off by writing your own builders to create more complex table layouts.
• Chapter 11 looks under the hood at GWT as we examine how to interface to JavaScript to interact with the browser (if you can’t do it another way in GWT), how to wrap an existing JavaScript library, how to handle JSONP return objects, and how to expose your application as an API.
• Chapter 12 covers a collection of communication and data-parsing tools. In this chapter we look at how to create and parse JSON and XML messages and how to pass these messages between the client and the server. In addition we explore GWT’s FormPanel widget, which can be used to transmit traditional form data to the server in a slightly less traditional way.
• Chapter 13 covers all the aspects you need to know to internationalize your application with different messages/constants, to manage plurals and user-defined changes in messages, and to drive localization (date, time, and currency formats). We also cover GWT 2.5’s approach to accessibility to make sure your application is as widely usable as possible.

Part 3 is “Advanced Topics.” In chapters 14 through 19 we cover topics that are more involved or complicated. As with the previous part, you can read in the order presented or dive into the chapters as you want.

• Chapter 14 moves us into the advanced part of the book, and we start off by looking at advanced event handling—creating your own events, preventing event propagation, and how GWT avoids browser differences. The second half of the chapter looks at how event busses can be used to loosely couple your application and shows a user-defined event in action.
• Chapter 15 considers how the MVP pattern can be applied to GWT applications in two ways: building the pattern yourself or by using GWT’s Activitys and Places.
• Chapter 16 examines how dependency injection (DI) can be used in GWT applications to manage dependencies. We look more at how DI is supported on the client side using the Guice library but build on an examination of the GIN library that can be used server side (and we discuss why it’s different on the client and server sides).
• Chapter 17 is the first of two chapters that look at manipulating code at compile time. Here we consider the deferred-binding approach to use different defined code implementations depending on particular values of properties. You create your own property and see how to generate the property provider that determines the property value.
• Chapter 18 finishes our look at compile-time code manipulation started in the previous chapter by showing how generators can create new code that’s then used in the compilation.
• Chapter 19 introduces you to several tools related to finding and fixing performance-related issues. The chapter starts with a discussion of lightweight metrics, a tool that will allow you to capture performance information about your application, and then moves on to the compile report so that you can better understand the size of the JavaScript files generated by the GWT compiler. The chapter then explains how you can use code splitting to break your application into smaller parts, leading to improved performance for your users.

Code conventions and downloads

The following typographical conventions are used throughout the book:

• Courier typeface is used in all code listings.
• Courier typeface is used within text for certain code words.
• Italics are used for emphasis and to introduce new terms.
• Code annotations are used in place of inline comments in the code. These highlight important concepts or areas of the code. Some annotations appear with numbered bullets like this that are referenced later in the text.

Source code for the examples in this book is available for download from the publisher’s website at www.manning.com/GWTinActionSecondEdition.

The purchase of GWT in Action, Second Edition includes free access to a private forum run by Manning Publications where you can make comments about the book, ask technical questions, and receive help from the authors and other users. You can access and subscribe to the forum at www.manning.com/GWTinActionSecondEdition. This page provides information on how to get on the forum once you’re registered, what kind of help is available, and the rules of conduct in the forum.