Google App Engine编程(影印版)
Dan Sanderson
Google App Engin是一种与众不同的云计算服务:它为构建自动扩展的百万用户级应用提供了简单的模型。在《Google App Engine 编程》中,你将获得来自专家的实用指南,帮助你用好这个强大的平台。Google工程师Dan Sanderson将向你展示如何设计可扩展的应用,以及如何使用App Engine的API和可扩展服务完成一般的开发任务。
你将学习App Engine的应用服务器架构、运行时环境和可扩展的数据存储,还有优化应用的相关技巧。App Engine可以提供几乎无限的计算能力,本书给出了简明扼要的指导,以便最大化利用其资源——信息来自App Engine开发团队。
· 发现传统 Web开发和App Engine开发之间的差异
· 学习App Engine Python和Java运行时环境的细节
理解App Engine如何处理Web请求并执行应用代码
· 学习如何使用App Engine的可扩展数据存储,包括查询和索引、事务以及数据建模
· 使用任务队列在基础设施中并行化和分布工作
· 轻松部署和管理应用
“毋庸置疑,这是最全面、易读以及内容最新的App Engine 图书。我想这么说是恰如其分的,如果你从头到尾一页不漏地读完这本书,那么现在肯定是App Engine专家了。”
—— Kevin Gibbs,技术领导者兼经理,Google App Engine团队
本书作者Dan Sanderson是一位技术作家、Google公司的软件工程师。他作为Google、Amazon.com和Walt Disney互联网集团的软件工程师和技术作家在Web行业工作超过十年。
(建议读者具备一定的 Python 和 Java Web 应用开发经验。)
  1. Preface
  2. 1. Introducing Google App Engine
  3. The Runtime Environment
  4. The Static File Servers
  5. The Datastore
  6. Entities and Properties
  7. Queries and Indexes
  8. Transactions
  9. The Services
  10. Google Accounts
  11. Task Queues and Cron Jobs
  12. Developer Tools
  13. The Administration Console
  14. Things App Engine Doesn’t Do...Yet
  15. Getting Started
  16. 2. Creating an Application
  17. Setting Up the SDK
  18. Installing the Python SDK
  19. Installing the Java SDK
  20. Developing the Application
  21. The User Preferences Pattern
  22. Developing a Python App
  23. Developing a Java App
  24. The Development Console
  25. Registering the Application
  26. The Application ID and Title
  27. Setting Up a Domain Name
  28. Google Apps and Authentication
  29. Uploading the Application
  30. Introducing the Administration Console
  31. 3. Handling Web Requests
  32. The App Engine Architecture
  33. Configuring the Frontend
  34. Configuring a Python App
  35. Configuring a Java App
  36. Domain Names
  37. App IDs and Versions
  38. Request Handlers
  39. Static Files and Resource Files
  40. Secure Connections
  41. Authorization with Google Accounts
  42. How the App Is Run
  43. The Python Runtime Environment
  44. The Java Runtime Environment
  45. The Sandbox
  46. App Caching
  47. Logging
  48. Quotas and Limits
  49. Request Limits
  50. CPU Limits
  51. Service Limits
  52. Deployment Limits
  53. Billable Quotas
  54. Resource Usage Headers
  55. 4. Datastore Entities
  56. Entities, Keys, and Properties
  57. Introducing the Python Datastore API
  58. Introducing the Java Datastore API
  59. Property Values
  60. Strings, Text, and Blobs
  61. Unset Versus the Null Value
  62. Multivalued Properties
  63. Keys and Key Objects
  64. Using Entities
  65. Getting Entities Using Keys
  66. Inspecting Entity Objects
  67. Saving Entities
  68. Deleting Entities
  69. 5. Datastore Queries
  70. Queries and Kinds
  71. Query Results and Keys
  72. GQL
  73. The Python Query API
  74. The Query Class
  75. GQL in Python
  76. Retrieving Results
  77. Keys-Only Queries
  78. The Java Query API
  79. Keys-Only Queries in Java
  80. Introducing Indexes
  81. Automatic Indexes and Simple Queries
  82. All Entities of a Kind
  83. One Equality Filter
  84. Greater-Than and Less-Than Filters
  85. One Sort Order
  86. Queries on Keys
  87. Kindless Queries
  88. Custom Indexes and Complex Queries
  89. Multiple Sort Orders
  90. Filters on Multiple Properties
  91. Multiple Equality Filters
  92. Not-Equal and IN Filters
  93. Unset and Nonindexed Properties
  94. Sort Orders and Value Types
  95. Queries and Multivalued Properties
  96. A Simple Example
  97. MVPs in Python
  98. MVPs and Equality Filters
  99. MVPs and Inequality Filters
  100. MVPs and Sort Orders
  101. Exploding Indexes
  102. Configuring Indexes
  103. Index Configuration for Python
  104. Index Configuration for Java
  105. 6. Datastore Transactions
  106. Entities and Entity Groups
  107. Keys, Paths, and Ancestors
  108. Ancestor Queries
  109. What Can Happen in a Transaction
  110. Transactional Reads
  111. Transactions in Python
  112. Transactions in Java
  113. How Entities Are Updated
  114. How Entities Are Read
  115. Batch Updates
  116. How Indexes Are Updated
  117. 7. Data Modeling with Python
  118. Models and Properties
  119. Property Declarations
  120. Property Value Types
  121. Property Validation
  122. Nonindexed Properties
  123. Automatic Values
  124. List Properties
  125. Models and Schema Migration
  126. Modeling Relationships
  127. One-to-Many Relationships
  128. One-to-One Relationships
  129. Many-to-Many Relationships
  130. Model Inheritance
  131. Queries and PolyModels
  132. Creating Your Own Property Classes
  133. Validating Property Values
  134. Marshaling Value Types
  135. Customizing Default Values
  136. Accepting Arguments
  137. 8. The Java Persistence API
  138. Setting Up JPA
  139. Entities and Keys
  140. Entity Properties
  141. Embedded Objects
  142. Saving, Fetching, and Deleting Objects
  143. Transactions in JPA
  144. Queries and JPQL
  145. Relationships
  146. For More Information
  147. 9. The Memory Cache
  148. The Python Memcache API
  149. Setting and Getting Values in Python
  150. Setting and Getting Multiple Values
  151. Memcache Namespaces
  152. Cache Expiration
  153. Deleting Keys
  154. Memcache Counters
  155. Cache Statistics
  156. The Java Memcache API
  157. 10. Fetching URLs and Web Resources
  158. Fetching URLs in Python
  159. Fetching URLs in Java
  160. Asynchronous Requests in Python
  161. RPC Objects
  162. Processing Results with Callbacks
  163. 11. Sending and Receiving Mail and Instant Messages
  164. Enabling Inbound Services
  165. Sending Email Messages
  166. Sender Addresses
  167. Recipients
  168. Attachments
  169. Sending Email in Python
  170. Sending Email in Java
  171. Receiving Email Messages
  172. Receiving Email in Python
  173. Receiving Email in Java
  174. Sending XMPP Messages
  175. Sending a Chat Invitation
  176. Sending a Chat Message
  177. Checking a Google Talk User’s Status
  178. Receiving XMPP Messages
  179. Receiving XMPP Messages in Python
  180. Receiving XMPP Messages in Java
  181. 12. Bulk Data Operations and Remote Access
  182. Setting Up the Remote API for Python
  183. Setting Up the Remote API for Java
  184. Using the Bulk Loader Tool
  185. Installing SQLite
  186. Backup and Restore
  187. Uploading Data
  188. Downloading Data
  189. Controlling the Bulk Loader
  190. Using the Remote Shell Tool
  191. Using the Remote API from a Script
  192. 13. Task Queues and Scheduled Tasks
  193. Task Queues
  194. Processing Rates and Token Buckets
  195. Elements of a Task
  196. Task Handlers and Retries
  197. Testing and Managing Tasks
  198. Using Task Queues in Python
  199. Using Task Queues in Java
  200. Transactional Task Enqueueing
  201. Scheduled Tasks
  202. 14. The Django Web Application Framework
  203. Installing Django
  204. Creating a Django Project
  205. The Request Handler Script
  206. The Django App Engine Helper
  207. Creating a Django Application
  208. Using App Engine Models With Django
  209. Using Django Unit Tests and Fixtures
  210. Using Django Forms
  211. 15. Deploying and Managing Applications
  212. Uploading an Application
  213. Using Versions
  214. Managing Service Configuration
  215. Managing Indexes
  216. Browsing and Downloading Logs
  217. Inspecting the Datastore
  218. Application Settings
  219. Managing Developers
  220. Quotas and Billing
  221. Getting Help
  222. Index
书名:Google App Engine编程(影印版)
作者:Dan Sanderson
原版书书名:Programming Google App Engine
原版书出版商: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 (Kobus
ellipsiprymnus), 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 that
become darker in color as the animals age. Long, sinuous horns distinguish male
waterbucks, while a ring of white hair around the tail distinguishes both genders from
other antelopes.
Waterbucks live in savannas and other vegetative areas, where they graze on rough
grass and leaves from trees and bushes. Contrary to its name, the waterbuck spends
most of its time on land, but it will often take refuge in a body of water to avoid
African myth claims that the meat of the waterbuck is inedible, but this isn’t so. Although
the waterbuck’s sweat glands produce a strong odor reminiscent of turpentine
in order to better protect itself from predators, the animal’s meat—while not especially
flavorful—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 especially
prone to fatally goring other male waterbucks who enter their territories and try to steal
members of their harems.