You are previewing GWT in Action, Second Edition.
O'Reilly logo
GWT in Action, Second Edition

Book Description

Summary

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 this 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.

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

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 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.

Table of Contents

  1. Copyright
    1. Dedication
  2. Brief Table of Contents
  3. Table of Contents
  4. Praise for the First Edition of GWT in Action
  5. Preface
  6. Acknowledgments
  7. About This Book
    1. Who should read this book
    2. Roadmap
    3. Code conventions and downloads
    4. Author Online
    5. About the title
    6. About the authors
  8. About the Cover Illustration
  9. Part 1. Basics
    1. Chapter 1. GWT
      1. 1.1. Unplanned consequences (or the road to GWT)
      2. 1.2. Exploring the toolkit
      3. 1.3. Setting up your development environment
      4. 1.4. Summary
    2. Chapter 2. Building a GWT application: saying “Hello World!”
      1. 2.1. What’s a GWT application?
      2. 2.2. Examining the options for building an application
      3. 2.3. Creating the HelloWorld application with the GPE
      4. 2.4. Running HelloWorld in development mode
      5. 2.5. Finding out where it went wrong
      6. 2.6. Compiling HelloWorld for web mode
      7. 2.7. Understanding modules vs. packages
      8. 2.8. Digging deeper into the uncompiled application
      9. 2.9. Reviewing the deployable application part of a GWT application
      10. 2.10. Building on your understanding
      11. 2.11. Summary
    3. Chapter 3. Building a GWT application: enhancing HelloWorld
      1. 3.1. Reexamining the example application
      2. 3.2. Updating the HTML
      3. 3.3. Enhancing the code
      4. 3.4. Creating your user interface
      5. 3.5. Manipulating the page
      6. 3.6. Handling events
      7. 3.7. Managing history
      8. 3.8. Styling components
      9. 3.9. Securing your application
      10. 3.10. Building on your understanding
      11. 3.11. Summary
  10. Part 2. Next steps
    1. Chapter 4. Creating your own widgets
      1. 4.1. What is a widget, again?
      2. 4.2. Creating a new widget from the DOM
      3. 4.3. Extending an existing widget
      4. 4.4. Extending a panel
      5. 4.5. Creating a composite
      6. 4.6. Using layout panels
      7. 4.7. Applying animation to widgets
      8. 4.8. Exploring the lifecycle of a widget
      9. 4.9. Getting Elemental, my dear Watson!
      10. 4.10. Summary
    2. Chapter 5. Using client bundles
      1. 5.1. Client bundle basics using DataResources
      2. 5.2. Text resource types
      3. 5.3. ImageResource
      4. 5.4. CssResource
      5. 5.5. Summary
    3. Chapter 6. Interface design with UiBinder
      1. 6.1. Binding the designer’s HTML to Java code
      2. 6.2. Handling events with UiBinder
      3. 6.3. Introducing the UiBinder expression language
      4. 6.4. Applying style with UiBinder
      5. 6.5. Using the Eclipse plug-in with UiBinder
      6. 6.6. Summary
    4. Chapter 7. Communicating with GWT-RPC
      1. 7.1. Surveying GWT-RPC
      2. 7.2. Learning GWT-RPC with Twitter
      3. 7.3. Fetching data from Twitter the non-GWT way
      4. 7.4. Defining a GWT-RPC-compatible model
      5. 7.5. Building and deploying the server side
      6. 7.6. Writing the client
      7. 7.7. Debugging GWT-RPC
      8. 7.8. Securing GWT-RPC against XSRF attacks
      9. 7.9. Summary
    5. Chapter 8. Using RequestFactory
      1. 8.1. Enabling annotation processing
      2. 8.2. Understanding RequestFactory architecture
      3. 8.3. Understanding the example project in this chapter
      4. 8.4. Making calls to the server
      5. 8.5. Using custom Locators and ServiceLocators (the “long way”)
      6. 8.6. Summary
    6. Chapter 9. The Editor framework
      1. 9.1. Framework and editor overview
      2. 9.2. Examining the chapter’s examples
      3. 9.3. Editor types
      4. 9.4. Constructing your first editor
      5. 9.5. Binding an editor with drivers
      6. 9.6. Editor subinterfaces
      7. 9.7. Accessing the RequestContext
      8. 9.8. Alternate way to construct an editor
      9. 9.9. Adapters
      10. 9.10. Summary
    7. Chapter 10. Data-presentation (cell) widgets
      1. 10.1. Understanding cells
      2. 10.2. Creating custom cells
      3. 10.3. Reviewing GWT’s cell widgets
      4. 10.4. Looking at a CellList
      5. 10.5. Walking through a CellTree
      6. 10.6. Browsing a CellBrowser
      7. 10.7. Constructing a CellTable
      8. 10.8. Building a DataGrid
      9. 10.9. Summary
    8. Chapter 11. Using JSNI—JavaScript Native Interface
      1. 11.1. What is JSNI?
      2. 11.2. Should you use JavaScript Native Interface?
      3. 11.3. Benefiting from the Google Plugin for Eclipse
      4. 11.4. Interacting with the browser
      5. 11.5. Handling objects from JavaScript
      6. 11.6. Wrapping a third-party library
      7. 11.7. Exposing an API to JavaScript
      8. 11.8. Summary
    9. Chapter 12. Classic Ajax and HTML forms
      1. 12.1. Understanding the underlying technology
      2. 12.2. Using RequestBuilder
      3. 12.3. Posting data with RequestBuilder
      4. 12.4. Using the JSON API and JsonpRequestBuilder
      5. 12.5. Using JSON with JS overlay
      6. 12.6. Using the XML API and RequestBuilder
      7. 12.7. Using FormPanel
      8. 12.8. Summary
    10. Chapter 13. Internationalization, localization, and accessibility
      1. 13.1. Making a user feel comfortable
      2. 13.2. Using static string internationalization
      3. 13.3. Using static-string i18n with UiBinder
      4. 13.4. Determining the locale for static-string internationalization
      5. 13.5. Internationalizing client bundles through static internationalization
      6. 13.6. Dynamic string internationalization
      7. 13.7. Localization of dates, times, and currencies
      8. 13.8. Displaying the right direction
      9. 13.9. Accessibility
      10. 13.10. Summary
  11. Part 3. Advanced
    1. Chapter 14. Advanced event handling and event busses
      1. 14.1. Understanding events
      2. 14.2. How GWT manages events
      3. 14.3. Previewing and canceling events
      4. 14.4. Preventing default actions
      5. 14.5. Programmatically firing events
      6. 14.6. Creating your own events
      7. 14.7. Event busses
      8. 14.8. Summary
    2. Chapter 15. Building MVP-based applications
      1. 15.1. What is MVP?
      2. 15.2. Looking at the PhotoApp’s MVP foundations
      3. 15.3. Building MVP yourself
      4. 15.4. Altering an MVP application
      5. 15.5. Activity and Place (GWT’s reference MVP approach)
      6. 15.6. Fitting editors/data-presentation widgets into MVP
      7. 15.7. Summary
    3. Chapter 16. Dependency injection
      1. 16.1. Dependency injection—the fundamentals
      2. 16.2. Guice—a Java dependency injection framework
      3. 16.3. GIN—how DI differs in a GWT application
      4. 16.4. When to avoid DI
      5. 16.5. Summary
    4. Chapter 17. Deferred binding
      1. 17.1. What is deferred binding?
      2. 17.2. Pulling it all together
      3. 17.3. Using GWT properties to drive deferred binding
      4. 17.4. Managing explosive permutation numbers
      5. 17.5. Determining a property value
      6. 17.6. Coping when deferred binding isn’t enough
      7. 17.7. Summary
    5. Chapter 18. Generators
      1. 18.1. What does a generator do?
      2. 18.2. What can a generator do?
      3. 18.3. Indicating what generator to use and when
      4. 18.4. Configuration properties
      5. 18.5. Pulling it all together
      6. 18.6. Preparing to write a generator
      7. 18.7. Creating your own generator
      8. 18.8. Using your new generator
      9. 18.9. Summary
    6. Chapter 19. Metrics and code splitting
      1. 19.1. Using the lightweight metrics tool
      2. 19.2. Using the Compile Report
      3. 19.3. Making use of code splitting
      4. 19.4. Summary
  12. Index
  13. List of Figures
  14. List of Tables
  15. List of Listings