Index
A
- AbsName / Data class inheritance
- Acid3 test / JavaScript browser's implementation is not consistent
- Activity stream classes
- StreamItem persistent class / The StreamItem persistent class
- StreamItem DTOs / The StreamItem DTOs
- addChild method / Creating entities in the same entity group
- addFeedURls method / Processing changes to Friend URLs
- addFriend method / Creating new Friend objects, Transactional tasks
- addToCache() method / Defining a cacheable interface, The StreamItem persistent class
- Admin Console
- about / The Admin Console
- versions log, browsing / Browsing an app version's logs
- startup latency / App server startup latency
- quotas / Quotas and billing
- billable resources / Quotas and billing
- resource usage, monitoring / Monitoring your quota levels and resource usage
- quota levels, monitoring / Monitoring your quota levels and resource usage
- developers, adding for application / Adding developers for an application
- Ajax (Asynchronous JavaScript and XML)
- Ajax application
- Ajax programming
- challenges / Challenges associated with AJAX programming and how GWT solves them, JavaScript browser's implementation is not consistent
- JavaScript browsers' implementation, inconsistency / JavaScript browser's implementation is not consistent
- JavaScript, mastering / Mastering JavaScript—an uphill battle
- appcfg.sh, command-line administration
- about / Using appcfg.sh
- locating / Locating appcfg.sh
- using / Using appcfg.sh
- application logs, downloading / Downloading application logs
- app Datastore
- bulk download / Bulk download and upload of an app's Datastore
- data, uploading / Downloading data
- App Engine
- Servlets, using / Using Servlets in App Engine
- Blobstore service / The JRE whitelist and system restrictions
- Admin Console / The Admin Console
- XMPP service / Introduction
- App Engine's Java Data Objects (JDOs) / First look: The anatomy of a web application project
- appengine-generated directory / The local development console
- appengine-web.xml
- Servlet sessions, enabling / Enabling Servlet sessions
- Admin Console pages, adding / Adding Admin Console pages
- system properties, logging / System properties and logging
- system properties, setting / System properties and logging
- log level, setting / Logging properties
- log messages, generating / Generating log messages
- static files / Static and resource files
- resource file / Static and resource files
- static file, specifying / Specifying static and resource files
- resource file, specifying / Specifying static and resource files
- App Engine Admin Console
- about / Your App Engine Admin Console
- dashboard / Your App Engine Admin Console
- App Engine app
- own domain name, using / Using your own domain for an app
- App Engine configuration
- about / Configuration
- deployment descriptor / The deployment descriptor—web.xml
- dos.xml / Configuring DoS protection blacklists—dos.xml
- DoS protection blacklists, configuring / Configuring DoS protection blacklists—dos.xml
- appengine-web.xml / App configuration—appengine-web.xml
- versions / App engine application versions
- application deployment / Application deployment and Datastore indexes
- Datastore Indexes / Application deployment and Datastore indexes
- Admin Console / App versions and the Admin Console
- App versions / App versions and the Admin Console
- file-related limitations / Application file limits
- App Engine Datastore
- browsing / Browsing the App Engine Datastore
- application data statistics, viewing / Viewing application data statistics
- App Engine Datastore index
- about / The App Engine Datastore index
- automatically-generated indexes / Automatically-generated indexes
- custom index / Custom indexes
- query constraints, revisiting / Revisiting constraints on queries
- Admin Console Datastore index viewer, using / Using the Admin Console Datastore index viewer and index vacuuming
- index vacuuming / Using the Admin Console Datastore index viewer and index vacuuming
- App Engine Python SDK
- URL / Resources
- App Engine queries
- speed / App Engine queries are fast
- App Engines Datastore
- about / The Datastore
- App Engine XMPP service
- about / The App Engine XMPP service and API
- XMPP addresses / XMPP addresses
- XMPP message, sending / Sending an XMPP message
- XMPP message, receiving / Receiving an XMPP message
- XMPP-related limits / XMPP-related quotas and limits
- XMPP-related quotas / XMPP-related quotas and limits
- application
- developing, in Eclipse / Developing your application in Eclipse
- running, in development mode / Running your application in Development Mode
- developing, in debug mode / Developing the application in debug mode
- development mode and GWT browser plugin / Development Mode and the GWT browser plugin
- run configuration, defining / Defining a run or debug configuration
- debug configuration, defining / Defining a run or debug configuration
- debugging / Debugging
- deploying / Deploying your application, Uploading and deploying your application
- ID, registering / Registering and setting an application ID for your application
- ID, setting / Registering and setting an application ID for your application
- ID of project, setting / How to set the application ID and version for a project
- version of project, setting / How to set the application ID and version for a project
- uploading / Uploading and deploying your application
- App Engine Admin Console / Your App Engine Admin Console
- importing / Importing an existing application
- Google SDKs, adding to projects build path / Adding the Google SDKs to your project's build path
- third-party JAR files, adding / Adding third-party JAR files
- multiple Google SDKs, managing / Managing multiple Google SDKs
- Google's demo apps, running in Eclipse / Running Google's demo apps in Eclipse
- application controller
- adding / Adding an application controller
- ApplicationController class / Bootstrapping the browser history at application startup
- application ID
- Appstats
- about / Using Appstats
- configuring / Enabling and configuring Appstats
- enabling / Enabling and configuring Appstats
- statistics page, browsing / Browsing the Appstats statistics page
- apps Datastore
- bulk download / Bulk download and upload of an app's Datastore
- bulk upload / Bulk download and upload of an app's Datastore
- data downloading / Downloading data
- data, uploading / Uploading or restoring data
- data, restoring / Uploading or restoring data
- AsyncCallback interface / Creating the asynchronous interface
- asynchronous calls / Getting data from the server using GWT RPC
- asynchronous fetch / The "low-level" Java URL Fetch API
- asynchronous server-side tasks, in Connectr
- background tasks, feed updates / Feed updates
- background tasks, feed updating for active users / Updating feeds for active users
- background tasks, recently-accessed feeds updation / Updating recently-accessed feeds
- data purging, from Datastore / Purge of old data from the Datastore
- context-Specific feed update tasks / Context-Specific feed update tasks, Feed update on URL addition
- AuthenticationProvider class / Uniquely identifying Connectr users
B
- background feed-related processing
- about / Enabling background feed updating and processing
- feed update request handlers / Enabling background feed updating and processing
- FeedInfo objects, updating / Enabling background feed updating and processing
- test feeds, adding / Add some test feeds to your app
- FeedInfo feed content, updating / Updating the most recently requested FeedInfo objects
- FeedUpdateServlet Mapping / The FeedUpdateServlet mapping
- admin-only Servlet URL, using / Using an admin-only Servlet URL for the feed update job
- UserAccount Friends feeds, updating / Updating all feeds for the Friends of a UserAccount
- feeds, updating for specific friend / Updating the feeds for a specific Friend
- feed contents, displaying / A simple Servlet to display feed contents
- batch fetch / Filtering the StreamItems on a subset of the user's Friends: Using key paths and contains()
- begin() method / Example—a JDO transaction
- bi-directional owned relationships
- about / Bi-directional owned relationships
- one-to-one relationship / Bi-directional one-to-one relationship
- one-to-many relationship / Bi-directional one-to-many relationship
- bind method / Responding to user interface events, Logging out when authenticating against Google or Twitter
- Blobstore / Quotas and billing
- Blob types / Core value types
- Boolean value / Core value types
- browser history
- support, adding / Adding support for browser history
- navigation tokens / Introducing the browser history stack and navigation tokens
- stack / Introducing the browser history stack and navigation tokens
- implementing, GWT used / Implementing browser history management
- bootstrapping, at application startup / Bootstrapping the browser history at application startup
- BusyIndicatorView class / Displaying a loading indicator when the app is busy
- byte[] task / Transactional tasks
C
- cacheable interface
- defining / Defining a cacheable interface
- cacheDelete method / Using the App Engine Memcache Java API in Connectr
- cacheGet method / Using the App Engine Memcache Java API in Connectr
- cachePutExp method / Using the App Engine Memcache Java API in Connectr
- cachePut method / Using the App Engine Memcache Java API in Connectr
- callback function / Getting data from the server using GWT RPC
- callback parameter / Invoking the login service
- Canvas page / Integrating Connectr inside Facebook
- category / Core value types
- Channel API / Updating feeds for active users
- ChannelServer class / Under the hood of ChannelServer
- checked exceptions / Catching exceptions
- class keyword / Adding CSS styles to the application
- client.service.MessagesService class / Supporting synchronous content delivery: Datastore queries and caching
- ClientBundle / Grouping CSS files and images for faster speed with ClientBundle
- creating / Creating a ClientBundle
- image resources, using in Connectr / Using image resources in Connectr
- CSS styles checking automatically, at compile time with CssResource / Automatically checking CSS styles at compile time with CssResource
- close() call / The PersistenceManager and the PersistenceManagerFactory
- close() method / The PersistenceManager and the PersistenceManagerFactory
- closeAll() method / Extents: fetching all objects of a particular kind
- code splitting
- about / Introduction to GWT
- com.google.appengine.api.memcache documentation
- URL / Memcache error handlers
- command-line administration
- appcfg.sh, using / Using appcfg.sh
- apps Datastore, bulk download / Bulk download and upload of an app's Datastore
- apps Datastore, bulk upload / Bulk download and upload of an app's Datastore
- commit() method / Example—a JDO transaction
- commit, transaction
- ComplexBlobMessage class / Creating custom classes of pushed messages
- complex join queries
- semantics, supporting / Supporting the semantics of more complex joins
- semnatics, supporting / Supporting the semantics of more complex joins
- complex joins
- semantics, supporting / Supporting the semantics of more complex joins
- complex objects
- referencing / Referencing complex objects
- Connectr
- about / Example application: Connectr, A look ahead
- new Friend objects, creating / Creating new Friend objects
- Friend object, deleting / Deleting a Friend object
- Friend object list fetching, key list used / Fetching a list of Friend objects using the key list
- MVP, coding / Coding MVP into Connectr
- RSS/Atom feeds, using / Using RSS/Atom feeds in the Connectr app
- integrating, with Facebook / Integrating with Facebook
- registering, with Facebook / Registering Connectr with Facebook
- integrating, inside Facebook / Integrating Connectr inside Facebook, Authenticating against Google
- Google, authenticating against / Authenticating against Google
- logging out / Logging out
- users, identifying / Uniquely identifying Connectr users
- App Engine Memcache Java API / Using the App Engine Memcache Java API in Connectr
- push techology, implementing / Implementation overview
- client inactivation status, informing / Telling the server a client is inactive
- Refresh now button, adding / Adding a refresh button to allow on-demand news updates
- latest activity / What the client sees
- components / What goes on behind the scenes
- StreamItem objects / What goes on behind the scenes
- Connectr's data models
- creating / Creating Connectr's data models
- Connectr, setting as XMPP client
- about / Setting up Connectr as an XMPP client
- subscribing, to XMPP Breaking News Gateway App / Subscribing a Connectr app to the XMPP Breaking News Gateway App
- Incoming XMPP Notifications, processing / Processing the incoming XMPP notifications
- ConnectrApp class / Starting up the application
- Connectr application
- building, user interface way / Building the Connectr application—the user interface
- user interface design, elements / User interface design elements of Connectr
- CSS styles, adding / Adding CSS styles to the application
- logo, adding / Adding a logo to the application
- Data Transfer Objects (DTOs) / DTOs in the Connectr application
- transactional control, adding / Adding transactional control to the Connectr application
- lifecycle listener / The Connectr application's lifecycle listeners
- Connectr MVP application
- architecture / Connectr MVP application architecture overview
- package organization / Package and file organization
- file organization / Package and file organization
- Connectr project
- in Eclipse, installing / Installing the (first version of) the Connectr project in Eclipse
- Connectr registration, with Facebook
- about / Registering Connectr with Facebook
- Facebook OAuth, authenticating with / Authenticating with Facebook OAuth
- Connectr server-side object model
- Connectr user interface
- coding / Coding the Connectr user interface
- contains() operator / The contains() operator and ||
- ContentAvailableEvent event / Adding a handler to process pushed messages
- createUI() / Starting up the application
- cron.xml file
- updating / Using appcfg.sh
- cron job / The FeedUpdateServlet mapping
- Cross-site scripting (XSS) attacks / Introduction to GWT
- CSS styles
- implementing, in global CSS file / Implementing CSS styles in a global CSS file
- currentTransaction() method
- about / Example—a JDO transaction
- custom event class
- creating / Creating a custom event class
- custom index / One-to-many Collection ordering
D
- --dump option / Uploading or restoring data
- data
- getting from server, GWT RPC used / Getting data from the server using GWT RPC
- Data Access Objects (DAOs) / Saving, updating, and deleting data objects
- data class inheritance
- about / Data class inheritance
- data entity / Splitting a model by creating an "index" and a "data" entity
- data models
- splitting into multiple entities / Splitting big data models into multiple entities to make access more efficient
- DataNucleus site
- URL / Setting up JDO
- Datastore
- about / The Datastore
- design / The Datastore
- entities / Datastore entities and their properties
- property data types / Datastore entities and their properties
- kind / Datastore entities and their properties
- entity keys / Entity keys
- indexes / Datastore queries and indexes
- queries and indexes / Datastore queries and indexes
- App Engine queries are fast / App Engine queries are fast
- vs relational database / The Datastore versus a relational database
- inspecting / Inspecting the Datastore
- local development console / The local development console
- App Engine Datastore / The App Engine Datastore
- App Engine Datastore, browsing / Browsing the App Engine Datastore
- Datastore, Google App Engine
- about / The Datastore
- transactions / The Datastore
- App Engine's scalable services / App Engine's scalable services
- Java App Engine runtime and application development environment / Java App Engine runtime and the application development environment
- GAE/J and the Eclipse IDE / GAE/J and the Eclipse IDE
- application hosting / App Engine application hosting
- Google App Engine, for Business / Google App Engine for Business
- Data Transfer Objects (DTO) / The model
- Data Transfer Objects (DTOs)
- about / The Connectr server-side object model
- detached / Detached Data Access Objects and Data Transfer Objects
- in Connectr application / DTOs in the Connectr application
- date-time / Core value types
- debug mode
- application, developing in / Developing the application in debug mode
- deferred binding
- about / Introduction to GWT
- deleteFriend() method / Deleting a Friend object
- deleteFriend method / Transactional tasks
- deployment descriptor
- authentication / Servlet declarations and mappings, security, and authentication
- security / Servlet declarations and mappings, security, and authentication
- servlet mappings / Servlet declarations and mappings, security, and authentication
- servlet filters / Servlet filters
- design considerations, ask Queue
- Task Names / Fanout and Task Names
- fanout / Fanout and Task Names
- multiple quick-running tasks, creating / Create many quick-running tasks
- design patterns
- detachedCopy() / Detached objects
- details field / Splitting big data models into multiple entities to make access more efficient
- developer browser plugin / The GWT/GAE Eclipse plugin
- development mode
- application, running in / Running your application in Development Mode
- and GWT browser plugin / Development Mode and the GWT browser plugin
- DialogBox object / Declarative UiBinder versus procedural Java—let's compare
- dispatch() method / Creating a custom event class
- display.setData() / Populating the Friend list view
- DockLayoutPanel / Implementing the application layout with UiBinder
- doGet method / Defining a Servlet
- doPost method / Defining a Servlet, Transactional tasks
- DoS / Configuring DoS protection blacklists—dos.xml
- dos.xml file
- updating / Using appcfg.sh
- downloading
- Eclipse / Installing Eclipse
E
- @Extension annotation / Key as encoded string
- e-mail address / Core value types
- Eclipse
- installing / Installing Eclipse
- downloading / Installing Eclipse
- application, developing / Developing your application in Eclipse
- new web application project, creating / Creating a new web application project in Eclipse
- web application project, anatomy / First look: The anatomy of a web application project
- Google Plugin wizards / The Google plugin wizards and helpers
- Google Plugin helpers / The Google plugin wizards and helpers
- Google's demo apps, running / Running Google's demo apps in Eclipse
- edetails field / Embedded classes
- embedded classes
- about / Embedded classes
- creating / Embedded classes
- encompassing RPC class / Introducing an encompassing RPC class
- entities
- about / Datastore entities and their properties
- creating, in same entity group / Creating entities in the same entity group
- entity group
- about / Owned relationships and entity groups
- and transactions / Transactions and entity groups
- entity group design
- considerations / Entity group design considerations
- entity ID / Entity keys
- entity key / Core value types
- entity keys
- about / Entity keys
- entity parent key
- getting from child key / Getting the entity parent key from the child key
- entry point class / First look: The anatomy of a web application project
- event
- ContentAvailableEvent / Adding a handler to process pushed messages
- event bus
- about / The model, Events and the event bus
- listening to / Listening to the event bus
- events
- about / Events and the event bus
- custom event class, creating / Creating a custom event class
- eventual consistency
- execute() method / Query examples
F
- Facebook
- Connectr, integrating, with / Integrating with Facebook
- Connectr, registering with / Registering Connectr with Facebook
- feed-related server-side processing
- tasks / Tasks and Task Queues
- Task Queue / Tasks and Task Queues
- transactional tasks / Tasks and Task Queues
- cron jobs / Cron Jobs
- asynchronous server-side tasks, in Connectr / Asynchronous server-side tasks in Connectr
- FeedIndex.addFeedURLs method / Transactional tasks
- FeedIndex.updateFeedURLs method / Transactional tasks
- FeedIndex child / App Engine transactions use optimistic concurrency
- FeedIndex constructor / Creating entities in the same entity group
- FeedIndex object / Splitting a model by creating an "index" and a "data" entity, Adding transactional control to the Connectr application
- FeedInfo.updateFeed() method / The StreamItem persistent class
- FeedInfo classes / Defining a cacheable interface
- FeedInfo key / Splitting a model by creating an "index" and a "data" entity, Creating entities in the same entity group
- FeedInfo methods / Adding and removing friend feeds
- FeedInfo object / Splitting a model by creating an "index" and a "data" entity
- FeedInfo persistent class / Splitting a model by creating an "index" and a "data" entity
- FeedUpdateServlet.doPost() method / Updating recently-accessed feeds
- FeedUpdateUserServlet.doPost() method / Feed update on login
- fetchFriendSummaryDTO() / Listening to the event bus
- fetch group
- about / Fetch groups
- Filter class / Servlet filters
- finally clause / The PersistenceManager and the PersistenceManagerFactory, Example—a JDO transaction
- findOrCreate(user) method / Automatically registering users when they login
- firstName property / Class and field annotations
- floating point number / Core value types
- Friend.updateFromDTO() / DTOs in the Connectr application
- Friend class / Using migrations to evolve the Datastore entities
- FriendDetails child object / The Connectr server-side object model
- FriendDetails class / Using a serialized field to hold friend details, Implementing a Migration: The FriendMigration class
- FriendDetails object / Browsing the App Engine Datastore, Splitting big data models into multiple entities to make access more efficient
- FriendDetails sub-object / Changing the value of a serialized field
- FriendDTO class / The Connectr server-side object model
- FriendDTO object / Creating new Friend objects
- FriendEditEventHandler class / Creating a custom event class
- FriendEditPresenter class / Listening to the event bus
- friendKeys list / Adding transactional control to the Connectr application
- FriendListPresenter / Starting up the application
- FriendListPresenter class / Inside a presenter, Populating the Friend list view
- Friend object / The Connectr server-side object model
- creating / Creating new Friend objects
- about / Creating new Friend objects
- deleting / Deleting a Friend object
- list fetching, key list used / Fetching a list of Friend objects using the key list
- Friend objects / Adding transactional control to the Connectr application
- FriendPopupPresenter class / Integrating UiBinder views into MVP
- FriendPopupView.ui.xml / Integrating UiBinder views into MVP
- FriendSummaryDTO class / The Connectr server-side object model
G
- GAE
- about / Introduction to Google App Engine
- App Engine Datastore / Introduction to Google App Engine
- App Engines Datastore / The Datastore
- App Engine's scalable services / App Engine's scalable services
- App Engine application hosting / App Engine application hosting
- GWT with / GWT with GAE
- gae.pk-id field / Key as encoded string
- gae.pk-name field / Key as encoded string
- GAE/Java documentation, URL / Documentation, blogs, and discussion groups
- GAE/Java Google Group, URL / Documentation, blogs, and discussion groups
- GAE documentation, URL / Documentation, blogs, and discussion groups
- general GAE Google Group, URL / Documentation, blogs, and discussion groups
- geographical point / Core value types
- getDefaultUser method / Connectr example: creating and modifying UserAccount
- getExent() method / Extents: fetching all objects of a particular kind
- getFeedInfo() / Defining a cacheable interface
- getFriend method / DTOs in the Connectr application
- getFriendSummaries() method / Fetching a list of Friend objects using the key list
- getFriendViaCache() method / Checking for a cache hit
- getHeader method / Servlet requests and responses
- getInputStream method / Setting request headers
- getKey() method / Creating entities in the same entity group
- getLoggedInUser method / Step-by-step implementation of the login sequence
- getObjectById method / Fetching a persisted object by its k
- getParent() / Getting the entity parent key from the child key
- getParent() method / Splitting a model by creating an "index" and a "data" entity, Getting the entity parent key from the child key
- getSession() method / Sessions
- getValue() method / The StreamItem DTOs
- Google's BigTable
- URL / Resources
- Google's demo apps
- running, in Eclipse / Running Google's demo apps in Eclipse
- Google account / Core value types
- Google App Engine (GAE)
- for business / Google App Engine for Business
- surprises, for new developers / App Engine "surprises" for new developers
- Google App Engine Java (GAE/J)
- about / Java App Engine runtime and the application development environment
- and Eclipse IDE / GAE/J and the Eclipse IDE
- Google Code blog, URL / Documentation, blogs, and discussion groups
- Google Plugin
- installing / Installing the Google plugin
- updating / Updating the Google plugin
- helpers / The Google plugin wizards and helpers
- wizards / The Google plugin wizards and helpers
- Google SDKs
- adding, to projects build path / Adding the Google SDKs to your project's build path
- Google Web Toolkit (GWT)
- overview / Google Web Toolkit overview—modern tools for modern developers
- building interfaces / Google Web Toolkit overview—modern tools for modern developers
- event handling / Google Web Toolkit overview—modern tools for modern developers
- internationalization / Google Web Toolkit overview—modern tools for modern developers
- accessibility / Google Web Toolkit overview—modern tools for modern developers
- testing / Google Web Toolkit overview—modern tools for modern developers
- optimization / Google Web Toolkit overview—modern tools for modern developers
- Remote Procedure Calls (RPC) / Google Web Toolkit overview—modern tools for modern developers
- user interface building blocks / GWT user interface building blocks
- GQL / Browsing the App Engine Datastore
- greetServer() method / Development Mode and the GWT browser plugin, Debugging
- GWT
- uses / Introduction to GWT
- UI support / GWT UI support
- features / Other GWT features
- Remote Procedure Call (RPC) API / GWT's RPC API
- with GAE / GWT with GAE
- /GAE Eclipse plugin / The GWT/GAE Eclipse plugin
- support, for Java / GWT support for Java
- background / Recommended GWT background
- used, for implementing browser history / Implementing browser history management
- GWT browser plugin
- and development mode / Development Mode and the GWT browser plugin
- GWT client, preparing
- about / Preparing the GWT client for pushed messages
- handler, adding / Adding a handler to process pushed messages
- GWT code
- compiling, for production mode / Compiling your GWT code for production mode
- GWT Developer browser plugin
- GWT documentation, URL / Documentation, blogs, and discussion groups
- GWT Google Group, URL / Documentation, blogs, and discussion groups
- GWT module configuration file / First look: The anatomy of a web application project
- GWT RPC
- used, for getting data from server / Getting data from the server using GWT RPC
- login service, creating / Creating the login service
- server-side login service, implementing / Implementing the server-side login service
- asynchronous interface, creating / Creating the asynchronous interface
- login service, invoking / Invoking the login service
- exceptions, catching / Catching exceptions
H
- handleMessage method / Creating custom classes of pushed messages
- HandlerManager / Events and the event bus
- headerPanel class / Tying the view to the Java code
- home programmer / Introducing MVP – The need for design patterns in software
- HTML host page / First look: The anatomy of a web application project
- HTTP(S) URLConnection objects
- about / Using HTTP(S) URLConnection objects
- request headers, setting / Setting request headers
- POST request, making / Making a POST request
- Blob using, for binary response storage / Using a Blob to store a binary response
- HTTP methods / Defining a Servlet
I
- identityType attribute / Class and field annotations
- iFrame mechanism / Integrating Connectr inside Facebook
- incrementAll() method / Atomic increment/decrement of Memcache values
- index entity / Splitting a model by creating an "index" and a "data" entity
- indexes, datastore
- about / Datastore queries and indexes
- inequality filters
- about / Constraints on using inequality filters
- using, constraints / Constraints on using inequality filters
- installing
- Java, on Mac OS X / Installing Java on Mac OS X
- Java, on other platforms / Installing Java on other platforms
- Eclipse / Installing Eclipse
- Google Plugin / Installing the Google plugin
- Connectr project, in Eclipse / Installing the (first version of) the Connectr project in Eclipse
- InstanceLifecycleEvent event / JDO lifecycle listeners
- instant messaging handle / Core value types
- integer / Core value types
J
- Java
- installing, on Mac OS X / Installing Java on Mac OS X
- installing, on other platforms / Installing Java on other platforms
- java.lang.Class objects / JDO lifecycle listeners
- java.net.URLConnection
- about / Using java.net.URLConnection
- limitations / Using java.net.URLConnection
- HTTP request, making / Making an HTTP request
- HTTP(S) URLConnection objects, using / Using HTTP(S) URLConnection objects
- Java Data Objects (JDO)
- and Java Persistence API (JPA) / JDO
- advantages / JDO
- setting up / Setting up JDO
- collection types / Collections and multi-valued properties
- @PrimaryKey fields, types / Datastore keys and JDO key fields
- Java Persistence API (JPA)
- JavaScript
- mastering / Mastering JavaScript—an uphill battle
- Java SE Runtime Environment (JRE)
- JCache
- URL / Using Memcache
- JDO API / Entity keys
- JDO data objects
- Memcache, using with / Using Memcache with JDO data objects
- JDOHelper.makeDirty() method / Changing the value of a serialized field
- JDO lifecycle listeners
- about / JDO lifecycle listeners
- JDOQL / Finding objects—queries and indexes
- about / Finding objects—queries and indexes
- queries, constructing / Constructing JDOQL queries
- query filter operators / Query filter operators
- query filters, on multiple values fields / Query filters on fields with multiple values
- Query sort orders / Query sort orders and ranges
- query, executing / Executing a query and getting the results
- JDOQL query
- components / Constructing JDOQL queries
- constructing / Constructing JDOQL queries
- explicit parameters / Constructing JDOQL queries
- implicit parameters / Constructing JDOQL queries
- examples / Query examples, Example 1:, Example 5:
- JDO transaction
- about / Example—a JDO transaction
- join behavior
- using, to support join behavior / Use of property lists to support "join" behavior
K
- key / Key
- about / Datastore entities and their properties
- as encoded string / Key as encoded string
- KeyFactory.Builder class / Creating entities in the same entity group
- KeyFactory.createKey() method / Key
- KeyFactory utility methods / Key as encoded string
- Key object / Creating entities in the same entity group
- keys
- FeedIndex key / The feed classes
- Friend key / Adding and removing friend feeds
- keyToString / Key as encoded string
- kind, Datastore
L
- lastName property / Datastore queries and indexes, Unset and unindexed entity fields
- lifecycle listener, Connectr application
- lifecycle listeners, Connectr application
- using / Using the lifecycle listeners consistently
- cache hit, checking for / Checking for a cache hit
- loading indicator
- displaying / Displaying a loading indicator when the app is busy
- logging out, Connectr
- about / Logging out
- when authentication against Twitter / Logging out when authenticating against Google or Twitter
- when authentication against Google / Logging out when authenticating against Google or Twitter
- of Facebook / Logging out of Facebook
- login function / Creating the asynchronous interface
- LoginHelper class / Automatically registering users when they login
- login implementation, Connectr
- login sequence / Connectr login implementation
- user accesses stalkr / Step-by-step implementation of the login sequence
- authentication provider, choosing / Step-by-step implementation of the login sequence
- Connectr backend servlet / Step-by-step implementation of the login sequence
- Google Accounts, code / Step-by-step implementation of the login sequence
- LoginServiceImpl class / Logging out when authenticating against Google or Twitter
- LoginStart method / Server side channel creation
- long byte string / Core value types
- long key field / Long key field
- long text string / Core value types
- low-level / Resources
M
- Mac OS X
- Java, installing on / Installing Java on Mac OS X
- mainPanel class / Tying the view to the Java code
- makePersistent() method / Persisting an object
- makePersistentAll method / Persisting an object
- makePersistent method / Fetching a persisted object by its k
- Memcache
- about / Using Memcache
- operations / Using Memcache
- App Engine Memcache Java API, using in Connectr / Using the App Engine Memcache Java API in Connectr
- error handlers / Memcache error handlers
- statistics / Memcache statistics
- using, with JDO data objects / Using Memcache with JDO data objects
- Memcache values
- atomic increment / Atomic increment/decrement of Memcache values
- atomic decrement / Atomic increment/decrement of Memcache values
- merge join / Automatically-generated indexes
- MessageBuilder class / Sending an XMPP message
- Message class / Creating custom classes of pushed messages
- messagePanel class / Tying the view to the Java code
- MessagesServiceImpl.getFeedIds() method / Filtering the StreamItems on a subset of the user's Friends: Using key paths and contains()
- MessagesServiceImpl class / What goes on behind the scenes, Supporting synchronous content delivery: Datastore queries and caching
- method
- getObjectById() / Finding objects—queries and indexes
- do Get / Defining a Servlet
- doPost / Defining a Servlet
- migrate_down / Approach—defining a migration
- migrate_up / Implementing a Migration: The FriendMigration class
- setConnectTimeout / Using java.net.URLConnection
- getInputStream / Setting request headers
- updateFeedURLs / Processing changes to Friend URLs
- getLoggedInUser / Step-by-step implementation of the login sequence
- showLoginView() / Step-by-step implementation of the login sequence
- findOrCreate(user) / Automatically registering users when they login
- StreamItem.builditems() / The StreamItem persistent class
- migrate_down method / Approach—defining a migration
- migrate_up method / Approach—defining a migration
- migrations
- using, for Datastore entitie evolution / Using migrations to evolve the Datastore entities
- field removing, from JDO data class definition / Removing a field from a JDO data class definition
- field adding, to JDO data class definition / Adding a field to a JDO data class definition
- schema transitions, facilitating / Facilitating "schema" transitions via migrations
- running / Running the Migration: A Migration Servlet and the Task Queue
- Task Queue / Running the Migration: A Migration Servlet and the Task Queue
- Servlet, invoking as web request / Invoking the Servlet as a web request
- Servlet admin authentication / Servlet admin authentication
- model
- about / The model
- Model-View-Presenter pattern (MVP)
- about / Introducing MVP – The need for design patterns in software, Introduction to MVP
- view / The view
- model / The model
- presenter / The Presenter
- multiple Google SDKs
- managing / Managing multiple Google SDKs
- MVP
- coding, into Connectr / Coding MVP into Connectr
- application, starting / Starting up the application
- Friend list view, populating / Populating the Friend list view
- user interface events, responding to / Responding to user interface events
- event bus, listening to / Listening to the event bus
- UiBinder views, integrating / Integrating UiBinder views into MVP
N
- @NotPersistent annotation / Class and field annotations
- network socket listener / Setting up the application to handle pushed messages
- newQuery method / Query examples
O
- OAuth
- about / OAuth: a new way to login and authorize
- version 2.0 / OAuth: a new way to login and authorize
- object
- persisting / Persisting an object
- official GWT blog, URL / Documentation, blogs, and discussion groups
- onFailure() / Invoking the login service
- onFailure method / Putting it all together
- online resources
- about / Online resources
- GAE galleries / GAE and GWT galleries
- GWT galleries / GAE and GWT galleries
- GWT documentation / Documentation, blogs, and discussion groups
- GAE documentation / Documentation, blogs, and discussion groups
- GAE/Java documentation / Documentation, blogs, and discussion groups
- official GAE blog / Documentation, blogs, and discussion groups
- official GWT blog / Documentation, blogs, and discussion groups
- Google Code blog / Documentation, blogs, and discussion groups
- GWT Google Group / Documentation, blogs, and discussion groups
- general GAE Google Group / Documentation, blogs, and discussion groups
- GAE/Java Google Group / Documentation, blogs, and discussion groups
- onLoginClick() method / Declarative UiBinder versus procedural Java—let's compare
- onModuleLoad / Starting up the application
- onModuleLoad() method / First look: The anatomy of a web application project, Development Mode and the GWT browser plugin, Debugging
- onResponse() function / Logging out of Facebook
- onRPCComIn() method / Displaying a loading indicator when the app is busy
- onSuccess() method / Invoking the login service, Populating the Friend list view
- onValueChange method / Implementing browser history management
- own domain name
- using, for App Engine app / Using your own domain for an app
- owned relationship
P
- @PersistenceCapable / Persistable field types
- @PersistenceCapable annotation / Class and field annotations, Detached objects
- @Persistent annotation / Class and field annotations
- @PrimaryKey annotation / Unencoded String key field, Long key field
- panels
- persistable field types
- about / Persistable field types
- core value types / Core value types
- collections and multi-valued properties / Collections and multi-valued properties
- Datastore keys and JDO key fields / Datastore keys and JDO key fields
- unencoded key field / Unencoded String key field
- long key field / Long key field
- key / Key
- persisted object
- fetching, by key / Fetching a persisted object by its k
- deleting / Deleting a persisted object
- Persistence Manager / An object has an associated PersistenceManager
- detached / Detached objects
- persistence-capable classes / Referencing complex objects
- PersistenceManager
- and PersistenceManagerFactory / The PersistenceManager and the PersistenceManagerFactory
- PersistenceManager deletePersistent() method / Deleting a Friend object
- PersistenceManagerFactory
- and PersistenceManager / The PersistenceManager and the PersistenceManagerFactory
- about / The PersistenceManager and the PersistenceManagerFactory
- PersistenceManager instance / The PersistenceManager and the PersistenceManagerFactory, Making data classes persistable, Persisting an object, Fetch groups, JDO lifecycle listeners
- phone number / Core value types
- point object / Responding to user interface events
- polling technology
- about / Why use push technology
- PopupPanel class / Displaying a loading indicator when the app is busy
- postal address / Core value types
- postDelete() method / JDO lifecycle listeners
- postLoad() Listener method / Checking for a cache hit
- presenter
- about / The Presenter
- Friend list view, populating / Populating the Friend list view
- user interface events, responding to / Responding to user interface events
- procedural Java
- versus declarative UiBinder / Declarative UiBinder versus procedural Java—let's compare
- production mode
- GWT code, compiling for / Compiling your GWT code for production mode
- about / Compiling your GWT code for production mode
- propClicked variable / Responding to user interface events
- properties
- property data types, Datastore / Datastore entities and their properties, Creating Connectr's data models
- property lists
- using, to support join behavior / Use of property lists to support "join" behavior
- pushed messages
- custom classes, creating / Creating custom classes of pushed messages
- push technology
- using, need for / Why use push technology
- push technology implementation, in Connectr
- application, setting up / Setting up the application to handle pushed messages
- application setup, for pushed messages handling / Setting up the application to handle pushed messages
- server side channel, creating / Server side channel creation
- ChannelServer, using / Under the hood of ChannelServer
- GWT client, preparing / Preparing the GWT client for pushed messages
- push techology implementation, in Connectr
- overview / Implementation overview
- working / Implementation overview
Q
- queries
- and indexes / Datastore queries and indexes
- about / Datastore queries and indexes
- supported by indexes / Queries are supported by indexes
- query
- JDOQL queries, constructing / Constructing JDOQL queries
- results, obtaining / Executing a query and getting the results
- executing / Executing a query and getting the results
- deleting by / Deleting by query
- batch fetch / Batch fetches using a list of keys
- Keys-only queries / Keys-only queries
- objects of particular kind, fetching / Extents: fetching all objects of a particular kind
- query constraints
- revisiting / Revisiting constraints on queries
- indexes, exploding / Exploding indexes
- side-stepping / Side-stepping query constraints
- pre-persist callbacks / Pre-persist callbacks—normalizing Friend name information
- query execution
- about / Executing a query and getting the results
- query cursor / Query cursors
- unindexed entity fields / Unset and unindexed entity fields
- unset entity fields / Unset and unindexed entity fields
- query filter operators, JDOQL
- about / Query filter operators
- inequality filters usage, constraints / Constraints on using inequality filters
- contains() operator / The contains() operator and ||
- OR (||) / The contains() operator and ||
- queue.xml file
- updating / Using appcfg.sh
R
- RDBMS / The Datastore versus a relational database
- Refresh now button
- relational database
- vs Datastore / The Datastore versus a relational database
- relationships, modeling between objects
- about / Modeling relationships between objects
- entity groups / Owned relationships and entity groups
- owned relationships / Owned relationships and entity groups
- uni-directional owned relationships / Uni-directional owned relationships
- bi-directional owned relationships / Bi-directional owned relationships
- one-to-many Collection ordering / One-to-many Collection ordering
- unowned relationships / Unowned relationships
- Remote Procedure Call (RPC) / Getting data from the server using GWT RPC
- Remote Procedure Call (RPC) API
- about / GWT's RPC API
- Remote Procedure Calls (RPC)
- removeFromCache() / Defining a cacheable interface
- removeFromCache() method / Defining a cacheable interface
- resetFeedInfo method / Subclassing the ROME Fetcher HttpURLFeedFetcher class
- retrieveFeedInfo method / Adding and removing friend feeds
- rollback, transaction
- RPC calls
- centralizing / Centralizing RPC calls for better handling and usability and reliability
- encompassing RPC class, introducing / Introducing an encompassing RPC class
- loading indicator, displaying / Displaying a loading indicator when the app is busy
- server exceptions, catching / Catching server exceptions
- call, retrying after failure / Retrying a call after failure
- RSS/Atom feeds, using in Connectr
- about / Using RSS/Atom feeds in the Connectr app
- feed support, adding / Adding feed support
- feed classes / The feed classes
- friend feeds, removing / Adding and removing friend feeds
- friend feeds, adding / Adding and removing friend feeds
- feeds, updating / Fetching and updating feeds
- feeds, fetching / Fetching and updating feeds
- ROME Fetcher HttpURLFeedFetcher class, subclassing / Subclassing the ROME Fetcher HttpURLFeedFetcher class
- changes, processing to Friend URLs / Processing changes to Friend URLs
S
- schema transition facilitation, via migration
- about / Facilitating "schema" transitions via migrations
- migration, defining / Approach—defining a migration
- Migration interface / The Migration interface
- FriendMigration class, implementing / Implementing a Migration: The FriendMigration class
- Secure Data Connector / URL Fetch
- selectedRows / Responding to user interface events
- sendMessage() method / Sending an XMPP message
- serializable
- objects / Serializable objects and serialized fields
- fields / Serializable objects and serialized fields
- field, value changing of / Changing the value of a serialized field
- Serializable interface / Invoking the login service, Detached Data Access Objects and Data Transfer Objects
- serialized field
- server.domain.Friend.updateFromDTO() method / Changing the value of a serialized field, DTOs in the Connectr application
- server.domain.Friend class / Class and field annotations, Key as encoded string, Using a serialized field to hold friend details, Bi-directional one-to-many relationship
- server.domain.FriendDetails class / Using a serialized field to hold friend details
- server.domain.Friend primary key field / Defining keys and core value type fields for Friend and UserAccount
- server.domain.StreamItem class / The StreamItem persistent class
- server.domain.UserAccount.getDefaultUser() method / Detached objects
- server.domain.UserAccount class / Long key field
- server.FriendsServiceImpl method / Processing changes to Friend URLs
- server.MessagesServiceImpl class / What goes on behind the scenes, Supporting synchronous content delivery: Datastore queries and caching
- server.servlets.UpdateFeedUrlsServlet class / Transactional tasks
- server.utils.cache.Cacheable interface / Defining a cacheable interface
- server.utils.cache.CacheMgmtTxnLifecycleListener class / The Connectr application's lifecycle listeners
- Service Level Agreement (SLA) / Google App Engine for Business
- Servlets, using in App Engine
- about / Using Servlets in App Engine
- deployment descriptor, using / Making your Servlets accessible—the deployment descriptor
- defining / Defining a Servlet
- responses / Servlet requests and responses
- requests / Servlet requests and responses
- response, generating / Generating a response
- limitations / App Engine Servlet limitations
- access, restricting / Restricting access to a Servlet
- sessions / Sessions
- whitelist / The JRE whitelist and system restrictions
- static application files, accessing / Accessing static application files
- setConnectTimeout method / Using java.net.URLConnection
- setOrdering method / Example 3:
- setRequestHeaders method / Subclassing the ROME Fetcher HttpURLFeedFetcher class
- ShowFriendPopupEvent / Responding to user interface events
- showLoginView() method / Step-by-step implementation of the login sequence
- standalone presenters / Starting up the application
- StreamItem.builditems() method
- about / The StreamItem persistent class
- StreamItem class / The StreamItem DTOs
- StreamItem DTOs
- about / The StreamItem DTOs
- StreamItem persistent class
- about / The StreamItem persistent class
- HTML sanitization / HTML 'sanitization'
- StreamItemPurge class / Purge of old data from the Datastore
- StreamItemSummaryDTO class / The StreamItem DTOs
- stringToKey / Key as encoded string
- strong consistency
- subList() method / Filtering the StreamItems on a subset of the user's Friends: Using key paths and contains()
- synchronous calls / Getting data from the server using GWT RPC
- synchronous content delivery
- supporting / Supporting synchronous content delivery: Datastore queries and caching
- StreamItem queries speed, increasing / Making StreamItem queries fast, Finding StreamItems for all Friends of a user: doing write-time work to make queries fast, Filtering the StreamItems on a subset of the user's Friends: Using key paths and contains()
- Stream cache management / Stream cache management
T
- TaskOptions.Builder methods
- param() / Defining a task: TaskOptions
- method() / Defining a task: TaskOptions
- url() / Defining a task: TaskOptions
- payload() / Defining a task: TaskOptions
- taskName() / Defining a task: TaskOptions
- Task Queue
- specifications / Task Queue specification
- frfeedupdates / Task Queue specification
- userfeedupdates / Task Queue specification
- quotas / Task Queue quotas and limits
- limits / Task Queue quotas and limits
- tasks, monitoring in App Engine Admin Console / Monitoring tasks in the App Engine Admin Console
- application-defined Task Queues, using / Using application-defined Task Queues
- task, defining / Defining a task: TaskOptions
- design considerations / Some Task Queue design considerations
- Text types / Core value types
- third-party JAR files
- adding / Adding third-party JAR files
- transaction
- about / Using transactions
- commit / Transaction commits and rollbacks
- rollback / Transaction commits and rollbacks
- JDO transaction / Example—a JDO transaction
- App Engine transactions / App Engine transactions use optimistic concurrency
- and entity groups / Transactions and entity groups
- using, rules / When to use a transaction
- control, adding to Connectr application / Adding transactional control to the Connectr application
- Transactional tasks / Entity group design considerations
- transactional tasks
- about / Transactional tasks
- triad
- about / Introduction to MVP
- try block / The PersistenceManager and the PersistenceManagerFactory
- Twitter authentication implementation
- about / Authenticating against Twitter with OAuth
- Connectr, registering / Registering Connectr with Twitter
- AppEngine.xml file / Registering Connectr with Twitter
- login servlet / Introducing the Twitter login servlet
- callback servlet, analysing / Analyzing the Twitter callback servlet
U
- @UiHandler / Catching mouse and keyboard events
- @UiHandler annotation / Catching mouse and keyboard events
- ui
- field attribute / Adding custom widgets to UiBinder
- UiBinder
- about / Introducing UiBinder to increase productivity
- declarative UiBinder versus procedural Java / Declarative UiBinder versus procedural Java—let's compare
- Declarative UiBinder versus procedural Java / Declarative UiBinder versus procedural Java—let's compare
- application layout, implementing / Implementing the application layout with UiBinder
- custom widgets, adding / Adding custom widgets to UiBinder
- UiBinder template / Declarative UiBinder versus procedural Java—let's compare, Implementing the application layout with UiBinder
- UiBinder views
- integrating, into MVP / Integrating UiBinder views into MVP
- unencoded key field / Unencoded String key field
- unexpected exceptions / Catching exceptions
- uni-directional owned relationships
- about / Uni-directional owned relationships
- supporting, in Connectr / Supporting uni-directional owned relationships in Connectr
- owned one-to-one relationship / Supporting uni-directional owned relationships in Connectr
- one-to-many relationship / Supporting uni-directional owned relationships in Connectr
- dependent children / Dependent children
- updateFeed method / Fetching and updating feeds
- updateFriend method / Transactional tasks
- updateIfNeeded method / Fetching and updating feeds
- updateRequestedFeed method / Fetching and updating feeds
- updating
- Google Plugin / Updating the Google plugin
- URL / Core value types
- URL Fetch service
- using / The JRE whitelist and system restrictions
- about / Pulling in Feeds: The URL Fetch service, URL Fetch
- App Engine services / App Engine services
- limitations / URL Fetch
- Java support / Java support for URL Fetch
- java.net.URLConnection, using / Using java.net.URLConnection
- low level Java URL Fetch API / The "low-level" Java URL Fetch API
- ROME RSS/Atom library / The ROME and ROME Fetcher RSS/Atom libraries
- ROME Fetcher RSS/Atom library / The ROME and ROME Fetcher RSS/Atom libraries
- ROME Fetcher RSS/Atom library, downloading / Downloading the ROME and ROME Fetcher jars and their dependencies
- ROME RSS/Atom library, downloading / Downloading the ROME and ROME Fetcher jars and their dependencies
- library JAR files, installing / Installing the library JAR files
- user-provided rating / Core value types
- UserAccount class / Uniquely identifying Connectr users
- UserAccount instance / The Connectr server-side object model
- UserAccount object / Defining keys and core value type fields for Friend and UserAccount, Referencing complex objects, Fetching a persisted object by its k, Connectr example: creating and modifying UserAccount, Deleting a Friend object, Detached objects
- UserAccount primary key / Defining keys and core value type fields for Friend and UserAccount
- UserAcount object / Using transactions
- user interface loading indicator / Catching exceptions
- users, Connectr
- identifying / Uniquely identifying Connectr users
- automatic registration, on login / Automatically registering users when they login
V
- ValueChangeHandler interface / Implementing browser history management
- valueStrategy annotation / Long key field
- verifyCredential method / Analyzing the Twitter callback servlet
- view
- about / The view
W
- web application project
- creating, in Eclipse / Creating a new web application project in Eclipse
- anatomy / First look: The anatomy of a web application project
- web hooks / Tasks and Task Queues
- Web Tools Platform (WTP) plugins / Installing Eclipse
- whitelist / The JRE whitelist and system restrictions
- widgets
- about / GWT user interface building blocks
- panels / GWT user interface building blocks
X
- XMPP
- about / XMPP: Information push to the app
- App Engine XMPP service / The App Engine XMPP service and API
- Connectr, setting as client / Setting up Connectr as an XMPP client
- XMPPService.parseMessage() method / Receiving an XMPP message