Google App Engine编程(第二版,影印版)
Dan Sanderson
“毋庸置疑,这是一本最完备、最优秀和最及时的关于App Engine的书籍。我认为一旦你完整地读完该书,你就会成为一名App Engine的专家。”
——Kevin Gibbs
Google App Engine的技术领导者和主管

Google App Engine(谷歌应用引擎)使得创建Web应用变得简单易行。它仅需少量的投资即可如仅仅服务数百用户那样灵巧地服务于百万量级的用户。在《Google App Engine编程》中,Google工程师Dan Sanderson提供了专业的实用指南,你可以学习到如何运用App Engine的可扩展服务和简单的开发模型在Google的强大平台上进行设计和开发应用。

通过简明扼要的指导,你将学会如何充分运用App Enigne接近无限的计算能力。本次第二版的更新完全覆盖了Python 2.7与Java 6的支持、多线程、异步服务API以及诸如Django 1.3和webapp2这样的框架的使用。

· 理解App Engine如何处理web请求并执行应用代码
· 学习新的数据存储特性,包括查询和索引、事务以及数据建模
· 通过Blobstore来创建、操纵和提供大数据文件
· 使用任务队列在平台上并行化和分发工作
· 把可扩展的服务应用于电子邮件、即时消息和基于web服务的通信
· 跟踪资源消耗并从速度和经济效益上来优化你的应用

Dan Sanderson是一位技术作家、Google公司的软件工程师。他作为Google、Amazon.
com和Walt Disney互联网集团的软件工程师和技术作家,在Web行业工作已超过十年。
  1. Chapter 1: Introducing Google App Engine
  2. The Runtime Environment
  3. The Static File Servers
  4. The Datastore
  5. The Services
  6. Namespaces
  7. Google Accounts, OpenID, and OAuth
  8. Task Queues and Cron Jobs
  9. Developer Tools
  10. The Administration Console
  11. Things App Engine Doesn’t Do...Yet
  12. Getting Started
  13. Chapter 2: Creating an Application
  14. Setting Up the SDK
  15. Developing the Application
  16. Registering the Application
  17. Uploading the Application
  18. Introducing the Administration Console
  19. Chapter 3: Configuring an Application
  20. The App Engine Architecture
  21. Configuring a Python App
  22. Configuring a Java App
  23. Domain Names
  24. App IDs and Versions
  25. Multithreading
  26. Request Handlers
  27. Static Files and Resource Files
  28. Secure Connections
  29. Authorization with Google Accounts
  30. Environment Variables
  31. Inbound Services
  32. Custom Error Responses
  33. Administration Console Custom Pages
  34. More Python Features
  35. Java Servlet Sessions
  36. Chapter 4: Request Handlers and Instances
  37. The Runtime Environment
  38. The Request Handler Abstraction
  39. Introducing Instances
  40. Request Scheduling and Pending Latency
  41. Warm-up Requests
  42. Resident Instances
  43. The Instances Console
  44. Instance Hours and Billing
  45. Instance Classes
  46. Chapter 5: Datastore Entities
  47. Entities, Keys, and Properties
  48. Introducing the Python Datastore API
  49. Introducing the Java Datastore API
  50. Property Values
  51. Keys and Key Objects
  52. Using Entities
  53. Allocating System IDs
  54. The Development Server and the Datastore
  55. Chapter 6: Datastore Queries
  56. Queries and Kinds
  57. Query Results and Keys
  58. GQL
  59. The Python Query API
  60. The Java Query API
  61. Introducing Indexes
  62. Automatic Indexes and Simple Queries
  63. Custom Indexes and Complex Queries
  64. Not-Equal and IN Filters
  65. Unset and Nonindexed Properties
  66. Sort Orders and Value Types
  67. Queries and Multivalued Properties
  68. Query Cursors
  69. Projection Queries
  70. Configuring Indexes
  71. Chapter 7: Datastore Transactions
  72. Entities and Entity Groups
  73. What Can Happen in a Transaction
  74. Transactions in Python
  75. Transactions in Java
  76. How Entities Are Updated
  77. How Entities Are Read
  78. Batch Updates
  79. How Indexes Are Updated
  80. Cross-Group Transactions
  81. Chapter 8: Datastore Administration
  82. Inspecting the Datastore
  83. Managing Indexes
  84. The Datastore Admin Panel
  85. Accessing Metadata from the App
  86. Remote Controls
  87. Chapter 9: Data Modeling with Python
  88. Models and Properties
  89. Property Declarations
  90. Modeling Relationships
  91. Model Inheritance
  92. Queries and PolyModels
  93. Creating Your Own Property Classes
  94. Chapter 10: The Java Persistence API
  95. Setting Up JPA
  96. Entities and Keys
  97. Entity Properties
  98. Embedded Objects
  99. Saving, Fetching, and Deleting Objects
  100. Transactions in JPA
  101. Queries and JPQL
  102. Relationships
  103. For More Information
  104. Chapter 11: The Memory Cache
  105. Calling Memcache from Python
  106. Calling Memcache from Java
  107. Keys and Values
  108. Setting Values
  109. Getting Values
  110. Deleting Values
  111. Atomic Increment and Decrement
  112. Compare and Set
  113. Batching Calls to Memcache
  114. Memcache and the Datastore
  115. Handling Memcache Errors
  116. Memcache Administration
  117. Chapter 12: Large Data and the Blobstore
  118. Accepting User Uploads
  119. Using BlobInfo Entities
  120. Serving Blobstore Values
  121. Deleting Blobstore Values
  122. Reading Blobstore Values
  123. A Complete Example
  124. Chapter 13: Fetching URLs and Web Resources
  125. Fetching URLs in Python
  126. Fetching URLs in Java
  127. Outgoing HTTP Requests
  128. HTTP Over SSL (HTTPS)
  129. Request and Response Sizes
  130. Request Deadlines
  131. Handling Redirects
  132. Response Objects
  133. Chapter 14: Sending and Receiving Email Messages
  134. Sending Email Messages
  135. Receiving Email Messages
  136. Chapter 15: Sending and Receiving Instant Messages with XMPP
  137. Inviting a User to Chat
  138. Sending Chat Messages
  139. Receiving Chat Messages
  140. Handling Error Messages
  141. Managing Presence
  142. Chapter 16: Task Queues and Scheduled Tasks
  143. Configuring Task Queues
  144. Enqueuing a Task
  145. Task Parameters
  146. Push Queues
  147. Pull Queues
  148. Transactional Task Enqueueing
  149. Task Chaining
  150. Task Queue Administration
  151. Deferring Work
  152. Scheduled Tasks
  153. Chapter 17: Optimizing Service Calls
  154. Calling Services Asynchronously
  155. Visualizing Calls with AppStats
  156. Chapter 18: The Django Web Application Framework
  157. Using the Bundled Django Library
  158. Creating a Django Project
  159. Hooking It Up to App Engine
  160. Creating a Django App
  161. Using Django Templates
  162. Using Django Forms
  163. The django-nonrel Project
  164. Chapter 19: Managing Request Logs
  165. Writing to the Log
  166. Viewing Recent Logs
  167. Downloading Logs
  168. Logs Retention
  169. Querying Logs from the App
  170. Flushing the Log Buffer
  171. Chapter 20: Deploying and Managing Applications
  172. Uploading an Application
  173. Using Versions
  174. Managing Service Configuration
  175. Application Settings
  176. Managing Developers
  177. Quotas and Billing
  178. Getting Help
书名:Google App Engine编程(第二版,影印版)
作者:Dan Sanderson
原版书书名:Programming Google App Engine, 2nd Edition
原版书出版商:O'Reilly Media
Dan Sanderson
Dan Sanderson既是Google的技术文档工程师,也是软件工程师。他已在互联网行业工作了15年,曾经是Google、Amazon和Walt Disney Internet Group的软件工程师和技术文档工程师。他生活在华盛顿州西雅图。想要了解与Dan相关的更多信息,可以访问他的网站。
The animal on the cover of Programming Google App Engine is a waterbuck (Kobusellipsiprymnus), a type of antelope found in western, eastern, and southern Africa.Waterbucks stand at about five feet at the shoulder and have reddish-brown coats thatbecome darker in color as the animals age. Long, sinuous horns distinguish malewaterbucks, while a ring of white hair around the tail distinguishes both genders fromother antelopes.

Waterbucks live in savannas and other vegetative areas, where they graze on roughgrass and leaves from trees and bushes. Contrary to its name, the waterbuck spendsmost of its time on land, but it will often take refuge in a body of water to avoidpredators.

African myth claims that the meat of the waterbuck is inedible, but this isn’t so. Althoughthe waterbuck’s sweat glands produce a strong odor reminiscent of turpentinein order to better protect itself from predators, the animal’s meat—while not especiallyflavorful—is safe to consume.

Male waterbucks frequently use their horns as a means of defense against their enemies.As the males are polygamous and highly possessive of their mates, they are especiallyprone to fatally goring other male waterbucks who enter their territories and try to stealmembers of their harems.