GWT in Action, Second Edition
Adam Tacy, Robert Hanson, Jason Essington, and Anna Tokke
  • January 2013
  • ISBN 9781935182849
  • 680 pages
  • printed in black & white
free previous edition eBook included
An eBook copy of the previous edition of this book is included at no additional cost. It will be automatically added to your Manning Bookshelf within 24 hours of purchase.

Covers all the newest features—a must-read for any GWT professional.

Michael Moossen, AG


An eBook copy of the previous edition, GWT in Action (First Edition), is included at no additional cost. It will be automatically added to your Manning account within 24 hours of purchase.

GWT in Action, Second Edition is a completely revised edition of the best-selling GWT book. It covers the new features introduced in GWT 2.4 and 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.

About the Technology

Google Web Toolkit works on a simple idea. Write your web application in Java, and GWT crosscompiles it into JavaScript. It is open source, supported by Google, and version 2.5 now includes a library of high-quality interface components and productivity tools that make using GWT a snap. The JavaScript it produces is really good.

About the book

GWT in Action, Second Edition is a revised edition of the best-selling GWT book. In it, you'll explore key concepts like managing events, interacting with the server, and creating UI components. As you move through its engaging examples, you'll absorb the latest thinking in application design and industry-grade best practices, such as implementing MVP, using dependency injection, and code optimization.

Table of Contents detailed table of contents



about this book

about the cover illustration

Part 1 Basics

1. GWT

1.1. Unplanned consequences (or the road to GWT)

1.2. Exploring the toolkit

1.3. Setting up your development environment

1.4. Summary

2. Building a GWT application: saying “Hello World!”

2.1. What’s a GWT application?

2.2. Examining the options for building an application

2.3. Creating the HelloWorld application with the GPE

2.4. Running HelloWorld in development mode

2.5. Finding out where it went wrong

2.6. Compiling HelloWorld for web mode

2.7. Understanding modules vs. packages

2.8. Digging deeper into the uncompiled application

2.9. Reviewing the deployable application part of a GWT application

2.10. Building on your understanding

2.11. Summary

3. Building a GWT application: enhancing HelloWorld

3.1. Reexamining the example application

3.2. Updating the HTML

3.3. Enhancing the code

3.4. Creating your user interface

3.5. Manipulating the page

3.6. Handling events

3.7. Managing history

3.8. Styling components

3.9. Securing your application

3.10. Building on your understanding

3.11. Summary

Part 2 Next steps

4. Creating your own widgets

4.1. What is a widget, again?

4.2. Creating a new widget from the DOM

4.3. Extending an existing widget

4.4. Extending a panel

4.5. Creating a composite

4.6. Using layout panels

4.7. Applying animation to widgets

4.8. Exploring the lifecycle of a widget

4.9. Getting Elemental, my dear Watson!

4.10. Summary

5. Using client bundles

5.1. Client bundle basics using DataResources

5.2. Text resource types

5.3. ImageResource

5.4. CssResource

5.5. Summary

6. Interface design with UiBinder

6.1. Binding the designer’s HTML to Java code

6.2. Handling events with UiBinder

6.3. Introducing the UiBinder expression language

6.4. Applying style with UiBinder

6.5. Using the Eclipse plug-in with UiBinder

6.6. Summary

7. Communicating with GWT-RPC

7.1. Surveying GWT-RPC

7.2. Learning GWT-RPC with Twitter

7.3. Fetching data from Twitter the non-GWT way

7.4. Defining a GWT-RPC-compatible model

7.5. Building and deploying the server side

7.6. Writing the client

7.7. Debugging GWT-RPC

7.8. Securing GWT-RPC against XSRF attacks

7.9. Summary

8. Using RequestFactory

8.1. Enabling annotation processing

8.2. Understanding RequestFactory architecture

8.3. Understanding the example project in this chapter

8.4. Making calls to the server

8.5. Using custom Locators and ServiceLocators (the “long way”)

8.6. Summary

9. The Editor framework

9.1. Framework and editor overview

9.2. Examining the chapter’s examples

9.3. Editor types

9.4. Constructing your first editor

9.5. Binding an editor with drivers

9.6. Editor subinterfaces

9.7. Accessing the RequestContext

9.8. Alternate way to construct an editor

9.9. Adapters

9.10. Summary

10. Data-presentation (cell) widgets

10.1. Understanding cells

10.2. Creating custom cells

10.3. Reviewing GWT’s cell widgets

10.4. Looking at a CellList

10.5. Walking through a CellTree

10.6. Browsing a CellBrowser

10.7. Constructing a CellTable

10.8. Building a DataGrid

10.9. Summary

11. Using JSNI—JavaScript Native Interface

11.1. What is JSNI?

11.2. Should you use JavaScript Native Interface?

11.3. Benefiting from the Google Plugin for Eclipse

11.4. Interacting with the browser

11.5. Handling objects from JavaScript

11.6. Wrapping a third-party library

11.7. Exposing an API to JavaScript

11.8. Summary

12. Classic Ajax and HTML forms

12.1. Understanding the underlying technology

12.2. Using RequestBuilder

12.3. Posting data with RequestBuilder

12.4. Using the JSON API and JsonpRequestBuilder

12.5. Using JSON with JS overlay

12.6. Using the XML API and RequestBuilder

12.7. Using FormPanel

12.8. Summary

13. Internationalization, localization, and accessibility

13.1. Making a user feel comfortable

13.2. Using static string internationalization

13.3. Using static-string i18n with UiBinder

13.4. Determining the locale for static-string internationalization

13.5. Internationalizing client bundles through static internationalization

13.6. Dynamic string internationalization

13.7. Localization of dates, times, and currencies

13.8. Displaying the right direction

13.9. Accessibility

13.10. Summary

Part 3 Advanced

14. Advanced event handling and event busses

14.1. Understanding events

14.2. How GWT manages events

14.3. Previewing and canceling events

14.4. Preventing default actions

14.5. Programmatically firing events

14.6. Creating your own events

14.7. Event busses

14.8. Summary

15. Building MVP-based applications

15.1. What is MVP?

15.2. Looking at the PhotoApp’s MVP foundations

15.3. Building MVP yourself

15.4. Altering an MVP application

15.5. Activity and Place (GWT’s reference MVP approach)

15.6. Fitting editors/data-presentation widgets into MVP

15.7. Summary

16. Dependency injection

16.1. Dependency injection—the fundamentals

16.2. Guice—a Java dependency injection framework

16.3. GIN—how DI differs in a GWT application

16.4. When to avoid DI

16.5. Summary

17. Deferred binding

17.1. What is deferred binding?

17.2. Pulling it all together

17.3. Using GWT properties to drive deferred binding

17.4. Managing explosive permutation numbers

17.5. Determining a property value

17.6. Coping when deferred binding isn’t enough

17.7. Summary

18. Generators

18.1. What does a generator do?

18.2. What can a generator do?

18.3. Indicating what generator to use and when

18.4. Configuration properties

18.5. Pulling it all together

18.6. Preparing to write a generator

18.7. Creating your own generator

18.8. Using your new generator

18.9. Summary

19. Metrics and code splitting

19.1. Using the lightweight metrics tool

19.2. Using the Compile Report

19.3. Making use of code splitting

19.4. Summary

© 2014 Manning Publications Co.

What's inside

  • Covers GWT 2.4 and up
  • Efficient use of large data sets
  • Optimizing with client bundles, deferred binding, and code splitting
  • Using generators and dependency injection

About the reader

Written for Java developers, the book requires no prior knowledge of GWT.

About the authors

Adam Tacy and Robert Hanson coauthored the first edition of GWT in Action. Jason Essington is a Java developer and an active contributor to the GWT mailing list and the GWT IRC channel. Anna Tökke is a programmer and solutions architect working with GWT on a daily basis.

placing your order...

Don't refresh or navigate away from the page.
print book $49.99 pBook + eBook + liveBook
includes previous edition eBook
Additional shipping charges may apply
Prints and ships within 3-5 days
GWT in Action, Second Edition (print book) added to cart
continue shopping
go to cart

eBook $39.99 3 formats + liveBook
includes previous edition eBook
GWT in Action, Second Edition (eBook) added to cart
continue shopping
go to cart

Prices displayed in rupees will be charged in USD when you check out.

FREE domestic shipping on three or more pBooks