App Engine的开发模型简单到不能再简单了：
创建应用程序； 在你自己的电脑上测试一下这个应用程序（使用App Engine开发包自带的那个Web 服务器软件）； 将做好的应用程序上传到App Engine。 我们将在本章中详细地了解整个工作流程：新建一个应用程序，利用开发服务器对其进行测试，注册一个新的应用程序ID，设置一个域名，将应用程序上传至App Engine。
我们将会看一下Python和Java软件开发包（SDK）以及App Engine管理控制台的部分功能。此外，我们还要讨论一下有关应用程序开发和部署方面的工作流程。
利用这个机会，我们还将介绍Web应用程序的一个经典模式：管理用户偏好数据。这个模式将会用到App Engine的多个服务和功能。
应用程序开发工作所需的全部工具和库都能在App Engine SDK中找到。Python和Java都有各自专门的SDK，它们都含有许多对开发工作大有裨益的功能。这两个SDK都能用于不同的平台，包括Windows、Mac OS X以及Linux。
Python和Java的SDK都含有一个能够在本地计算机上运行的Web服务器，其目的是在模拟的运行时环境中运行应用程序。开发服务器能够强制执行完整运行时环境的沙盒约束，还可以模拟所有的App Engine服务。启动这个开发服务器之后，你可以在开发应用程序的同时让它一直运行，这样，只需在浏览器中重新加载页面就可以立刻看到修改后的效果了。
这两个SDK都自带一个实用工具，专门用于跟那些正在App Engine上运行着的应用程序交互。你可以使用该工具上传应用程序的代码、静态文件以及配置文件。该工具还可以管理数据存储区索引、任务队列以及计划任务等。此外，它还能下载由在线应用程序所产生的日志消息，以便对应用程序的负载和行为进行分析。
由于首先支持的是Python而不是Java，因此Python SDK中有一些Java SDK所没有的工具。最重要的一点是，Python SDK含有向数据存储区上传数据以及从数据存储区下载数据的工具。这对于制作备份、改变已有数据的结构、离线处理数据等工作而言是很有用的。如果你用的是Java也没有关系，只要稍微花点功夫就可以用上这些基于Python的数据工具了。
针对Windows和Mac OS X平台的Python SDK中都带有一个“启动器”应用程序，它使你能够通过一个简单的图形界面创建、编辑、测试和上传应用程序。如果再配上一款较好的编程型文本编辑器（比如Windows上的Notepad++或者Mac OS X上的extMate），那么你就可以得到一个非常快速、直观的Python开发体验了。
对于Java开发人员Google公司提供了一个用于Eclipse集成开发环境的插件，它实现了完整的App Engine开发流程。该插件含有一个用于新建App Engine Java应用程序的模板，还有一个用于在Eclipse调试器中运行应用程序和开发服务器的配置文件。若要将项目部署到App Engine上，你只需单击Eclipse工具条上的一个按钮就可以了。
此外，这两个SDK中还含有一组支持上述全部功能的跨平台的命令行工具。你可以在命令行中使用这些工具，也可以将它们集成到你自己的开发环境中去，随你高兴。
我们将先讨论Python SDK，然后在本章后面的“安装Java SDK”一节中介绍Java SDK。如果某节所使用的语言不合你的意，直接跳过就是了。
安装Python SDK 针对Python运行时环境的App Engine SDK可以运行在任何安装了Python 2.5的电脑上。如果你用的是Mac OS X或Linux，又或者你以前就用过Python，那么你的系统中可能已经安装有Python了。通过在命令行提示符（在Windows中叫做命令行提示符，即Command Prompt，在Mac OS X中叫做终端，即Terminal）中执行下面这条命令即可检查系统中是否已经安装了Python及其版本号：
（其中V为大写。）如果已经安装了Python，其版本号就会显示出来，如下所示：
也可以从Python的网站上下载并安装适用于其他平台的Python 2.5：
务必保证你在该网站的“Download”区下载的是2.5版（比如2.5.4）的Python。到编写本书时为止，Python最新的主版本号是3.1，最新的2.x兼容版是2.6。虽然App Engine的Python SDK可以使用Python 2.6，不过在开发的时候还是用跟App Engine一样的版本会比较好，因为这样你就不会被那些莫名其妙的兼容性问题搞得抓耳挠腮了。
注意： App Engine暂时还不支持Python 3。Python 3含有一些新的语言和库特性，而这些特性都不能向下兼容早期的版本。当App Engine添加了Python 3支持时，很可能是在Python 2运行时环境之外再添加一个新的运行时环境。可以通过应用程序配置文件中的一个设置来控制应用程序应该使用哪个运行时环境，也就是说，在新版运行时环境发布之后，你的应用程序仍然可以一如既往地运行。 可以在GAE的网站上下载到与你的操作系统相匹配的App Engine Python SDK。
下载并安装适合于你的操作系统的文件：
对于Windows，Python SDK是一个.msi（Microsoft Installer）文件。单击相应的链接即可下载，然后双击文件即可启动安装进程。这将会安装GAE Launcher应用程序，同时向开始菜单中添加一个图标，还会把命令行工具添加到命令行路径中。 对于Mac OS X，Python SDK是一个.dmg（磁盘镜像）文件形式的Mac应用程序。单击相应的链接即可下载，然后双击文件即可安装该磁盘镜像。将GAE Launcher 图标拖拽到你的“Applications”文件夹中。为了安装命令行工具，可以先双击这个图标以启动GAE Launcher，然后在弹出的对话框中允许其创建“symlinks”。 如果你用的是Linux或别的平台，则可以使用.zip文件形式的Python SDK。下载并解压（一般使用unzip命令）以创建一个名为google_appengine的目录。命令行工具都在这个目录中。按需调整你的命令路径即可。 为了测试一下刚刚安装的这个App Engine Python SDK，在命令提示符那里运行下面这个命令即可：
该命令将会输出帮助信息并退出。如果你看到的是“找不到该命令”之类的消息，检查一下安装程序是否成功完成，以及dev_appserver.py命令的位置信息是否写到了命令路径中。
Windows的用户们，如果你们在运行这个命令时弹出了一个上面写着“Windows不能打开此文件……要打开此文件，Windows需要知道哪个程序创建了它”的对话框，你们必须告诉Windows用Python去打开这个文件。选中该对话框中的“从列表中选择程序”并单击确定。单击浏览，然后找到你的Python安装目录（比如C:\Python25）。在这个文件夹中选中python并单击打开。选中“始终使用选择的程序打开这种文件”，单击确定。然后就会有一个窗口打开并尝试运行该命令，接着很快就自己关掉了。然后你就可以在命令行提示符那里运行这个命令了。
Windows和Mac OS X版的Python SDK都含有一个叫做GAE Launcher（下文中将简称为Launcher）的应用程序。有了Launcher，你就可以在图形界面下创建和管理多个App Engine Python项目了。图2-1展示了在Mac OS X中的Launcher窗口。
图2-1：GAE Launcher for Mac OS X的主窗口，其中选中了一个项目
单击“File”菜单中的“Create New Application”即可创建一个新项目（也可以单击窗口下方那个加号按钮）。选定你想要把这个项目放到什么位置，然后为其输入一个名字。然后Launcher就会在那个地方创建一个新目录并以项目的名称命名（该目录用于存放该项目的文件），然后再创建一堆初始文件。现在，这个项目就会出现在Launcher主窗口的项目列表中了。
为了启动开发服务器，首先要选中一个项目，然后单击“Run”按钮。可以通过“Stop”按钮来停止开发服务器。单击“Browse”按钮即可在浏览器中打开运行着的应用程序的主页。“Logs”按钮用于显示应用程序在开发服务器中记录的日志消息。
“SDK Console”按钮用于打开开发服务器的Web界面，这个界面上有一些用于检视应用程序运行状态的功能，包括查看（模拟的）数据存储区和内存缓存中的内容的工具， 以及一个用于执行Python语句并显示结果的交互式控制台。
“Edit”按钮用于在默认文本编辑器中打开指定项目的文件。在Mac OS X版中，这对于那些能够打开整个目录中的文件的编辑器（比如TextMate或Emacs）而言是尤为有用的。在Windows版本中，就只能打开app.yaml。
“Deploy”按钮用于将项目上传到AppEngine。在部署项目之前，你必须先在AppEngine上注册一个应用程序ID，并把这个ID放到应用程序的配置文件中。“Dashboard”按钮用于在浏览器窗口中打开已部署应用程序的App Engine管理控制台。在本章部稍后的分中，我们将会讨论配置文件、注册过程以及管理控制台。
整个App Engine Python SDK（包括命令行工具）都位于Launcher的应用程序目录中。在Windows版中，安装程序会将相应的目录添加到命令路径中，这样你就可以通过命令提示符来运行这些工具了。
在Mac OS X中，当你第一次启动Launcher时，它会要求创建“symlink”的权限。该操作将会在/usr/local/bin/目录中创建一些指向该应用程序包中的命令行工具的符号链接。有了这些链接，你只需在Terminal提示符中输入命令的名字就可以运行它了。如果之前没有创建symlink，也可以通过GAE Launcher菜单中的“Make Symlinks”来创建。
你还可以在Launcher中为开发服务器设置命令行参数。做法是这样的：选中应用程序， 然后单击“Edit”菜单中的“Application Settings”，在Extra Flags文本框中输入所需的命令行参数，然后单击“Update”。
注意： Mac OS X版的Launcher会安装Google公司的软件更新功能，它用于检查新版的App Engine SDK。当新版本发布之后，该功能就会向你发出提醒并实施更新。 安装Java SDK 针对Java运行时环境的App Engine SDK可以运行在任何安装了Java SE Development Kit（JDK）的电脑上。App Engine支持JDK 5和JDK 6。当运行在App Engine上时，Java运行时环境将使用Java 6 JVM。
如果你还没有安装Java 6 JDK，可以从Sun的网站下载，绝大多数平台都有对应的版本可供下载（Mac用户请看下一节）：
通过在命令提示符中运行如下所示的命令即可测试系统中是否已经安装了Java开发包及其具体的版本号：
如果安装的是Java 6 JDK，该命令将会显示类似于“javac 1.6.0”这样的版本号。如果安装的是Java 5 JDK，则该命令将会显示类似于“javac 1.5.0”这样的版本号。实际的输出值取决于你所安装的具体版本。
App Engine的Java应用程序会用到Java Enterprise Edition（Java EE）中的接口和功能。App Engine SDK含有Java EE相关功能的具体实现，因此你没必要安装独立的Java EE 实现。
针对Java的App Engine SDK的安装步骤取决于你是否想要在Eclipse IDE中使用Google公司的插件。我们将分别讨论这两种情况。
Mac OS X上的Java 如果你用的是Mac OS X，那么Java和JDK就算是已经安装好了。具体的使用方法取决于操作系统的版本，以及你的电脑用的是32位处理器（比如Intel Core Duo）还是64位处理器（比如Intel Core 2 Duo、Intel Xeon）。通过“Apple”菜单中的“About This Mac” 就可以看到你究竟用的是哪种处理器了。
Mac OS X 10.6 Snow Leopard含有Java 6及其JDK，而且有专门的32位处理器版和64位处理器版。如果是64位处理器，那么默认就是64位的Java 6。如果是32位处理器，那么默认就是32位的Java 6。
Mac OS X 10.5 Leopard既有Java 5也有Java 6，但默认的是Java 5。这是因为Leopard上的Java 6只能工作于64位处理器。如果你用的就是64位处理器，则可以把64位的Java 6设置为默认的。
通过Java Preferences实用工具（可以在/Applications/Utilities/中找到）可以修改系统所使用的Java版本。在“Java Applications”列表中，将所需的版本（比如“Java SE 6, 64-bit”） 拖到列表顶部即可。OS X将使用该列表最上面的那个（与系统兼容的）版本。
如果运行Leopard的是一台32位的Mac机，那就只能用Java 5了。在Java 5版本下，App Engine SDK也是没问题的，而且用Java 5构建的应用程序在App Engine上也能正常运行。使用Java 5时唯一需要注意的就是：你所找到的那些App Engine代码示例所采用的可能会是Java 6。
如果你正在使用Eclipse，则还必须保证其版本与你的处理器和Java的版本相对应。Eclipse IDE for Java EE Developers分别有对应的32位和64位处理器的版本。
更多关于Java和Mac OS X的信息，请参见苹果公司的开发人员网站：http://developer.apple.com/java/
用Java开发App Engine应用程序最简单的方法之一就是使用Eclipse IDE和GPlugin for Eclipse。该插件可用于Eclipse 3.3（Europa）、Eclipse 3.4（Ganymede）以及Eclipse 3.5 （Galileo）。可以从Eclipse网站免费下载到适用于各种平台的Eclipse：
如果你只打算用Eclipse来进行App Engine开发，下载Eclipse IDE for Java EE Developers软件包即可。该软件包中有许多对开发Web应用程序有帮助的组件，比如Eclipse Web Tools Platform（WTP）包。
可以通过“Preferences”窗口告诉Eclipse使用你已经安装好的JDK。在Eclipse 3.5中，打开“Preferences”（如果是Windows或Linux，该项在Window菜单中；如果是Mac OS X，该项则在Eclipse菜单中）。在Java大类中，选中“Installed JREs”。如果需要，则可以把SDK的位置添加到列表中，并确保复选框是选中的。
使用Eclipse的软件安装功能即可安装App Engine Java SDK和GPlugin。在Eclipse 3.5中，单击“Help”菜单中的“New Software...”，然后在“Work with”文本框中输入URL并单击“Add...”按钮（这个URL在浏览器中是无效的，它只对Eclipse的软件安装器起作用，具体的URL参见使用说明）。
在弹出的对话框窗口的“Name”文本框中输入Google公司的英文LOGO，并单击“OK”。然后将会有两个条目被添加到列表中，一个针对插件（Plugin），另一个则针对AppEngine和GWeb Toolkit SDK（SDK）。图2-2展示了Install Software窗口的样子，其中选中了相应的项。
图2-2：Eclipse 3.5（Galileo）的“Install Software”窗口，其中选中了GPlugin
选中这两项前面的复选框。单击“Next >”按钮并按照提示进行操作。
更多有关安装GPlugin for Eclipse的信息（包括针对Eclipse 3.3或3.4的指引信息），请参阅该插件的网站。
安装完成之后，Eclipse的工具栏中将会出现三个新按钮，如图2-3所示。
图2-3：在安装完GPlugin 之后，Ecl ipse 3.5的工具栏中将会出现三个新按钮：New Web Application Project、GWT Compile Project以及Deploy App Engine Project
该插件将会向Eclipse的界面中添加一些新东西：
工具栏中的三个新按钮：New Web Application Project、GWT Compile Project以及Deploy App Engine Project； 在“File”菜单的“New”下面会多出一个“Web Application Project”； Web应用程序调试配置文件。有了它，就能通过Eclipse调试器在开发Web服务器中运行应用程序了。 你可以利用Eclipse来开发应用程序，并将其部署到App Engine上去。为了使用App Engine SDK的其他功能（如下载日志数据），你必须使用其中的命令行工具。Eclipse会将这个SDK安装到你的Eclipse应用程序目录中（在eclipse/plugins/中）。实际的目录名取决于你所安装的SDK的版本，不过看上去跟下面这个长得差不多：
com.google.appengine.eclipse.sdkbundle_1.2.5.v200909021031/appengine-java-sdk-1.2.5/
该目录含有一个叫做bin/的子目录，用于存放命令行工具。在Mac OS X或Linux中，为了能在命令行中使用这些工具，你可能需要将这些文件的权限修改为可执行：
chmod 755 bin/*
虽然可以把bin/目录添加到命令行路径中，不过请时刻记住：每当你更新了SDK之后，这个路径就会发生变化。
如果你没有使用Eclipse IDE，又或者你不愿意使用GPlugin，则可以从App Engine网站下载.z i p文件形式的App Engine Java SDK。该文件会解压成一个目录，其名字类似于appengine-java-sdk-1.2.5。
这个SDK的bin/子目录中含有命令行启动脚本。为了在使用这些命令时能够更加轻松，你可以将该目录添加到命令行路径中。
注意： AppCfg和开发服务器都是通过执行Java类的方式来实现其功能的。在将这些工具集成到IDE中或是创建脚本时，既可以调用启动脚本，也可以直接调用Java类。看启动脚本的内容就能知道具体的语法了。 在命令行提示符中运行下面这条命令即可检查App Engine Java SDK是否已经成功安装：
dev_appserver --help
Mac OS X和Linux的用户请使用dev_appserver.sh作为命令名。
该命令先显示一些信息，然后退出。如果出现了“该命令找不到”之类的消息，则应该首先检查一下文件是否解压成功，然后再看看SDK的bin/目录是否在你的命令行路径中。
开发应用程序 App Engine应用程序会响应Web请求。它是通过调用请求处理器（request handler，这是一段接受请求参数并返回响应的程序）来完成此工作的。对于来自某个URL的请求，App Engine会判断应该使用哪个请求处理器，其依据是应用程序中的一个配置文件（其中有URL和请求处理器之间的映射关系）。
应用程序也可以包含静态文件，比如图片、CSS样式表以及浏览器JavaScript等。对于来自相应URL的请求，App Engine会在其响应中直接将这些文件发送给客户端，无须调用任何代码。应用程序的配置文件会指出哪些文件是静态的，以及哪些URL是用来访问这些文件的。
应用程序的配置文件中还会包含有关该应用程序的元数据，比如应用程序ID和版本号等。在将应用程序部署到App Engine时，所有的应用程序文件（包括代码、配置文件和静态文件）都会被上传，并与配置文件中所提到的应用程序ID和版本号关联起来。应用程序还可以拥有专门针对服务（比如数据存储区索引、任务队列以及计划任务等）的配置文件。这些文件是与整个应用程序关联的，而不是与某个特定版本关联的。
虽然Python应用程序跟Java应用程序的代码和配置文件的结构、格式均不同，不过其概念是类似的。在接下来的几节中，我们将用Python和Java分别为一个简单应用程序创建一些必要的文件，并看看如何使用这两个SDK中的工具和库。
用户偏好模式 我们将在本节中创建的应用程序是一个简单的时钟。当用户访问该网站时，应用程序将根据服务器的系统时钟显示当前时间。默认情况下，应用程序将显示协调世界时间（Coordinated Universal Time，UTC）时区的当前时间。用户通过GAccount登录并设置一个偏好之后即可实现对时区的自定义。
该应用程序演示了App Engine的三个功能：
数据存储区。它是用户配置数据的主要存储区，是持久的、可靠的、可扩展的。 内存缓存（也就是memcache）。它是次要存储区，比数据存储区快，但不能长期保持数据。 GAccount。利用Google公司的用户账户系统对用户进行鉴权和识别。 GAccount的工作方式跟大多数用户账户系统类似。如果用户没有登录时钟应用程序，则只会看到一个带有默认设置（UTC时区）的普通界面，当然，该界面上面还有登录或创建新账户的链接。如果用户选择登录或注册，应用程序就会将其转向至一个由GAccount管理的登录表单。登录或创建账户之后，用户又会被带回到应用程序。
当然，你也可以不用GAccount而自己实现一个账户机制。使用GAccount有利有弊，最主要的好处就是你不用亲自去实现账户机制。如果你的某个用户已经有了一个GAccount，那么他就可以直接用这个账户登录了，而不用再专门为你的应用程序去创建一个新的。
如果用户在访问应用程序的时候已经登录过了，应用程序就会加载该用户的偏好数据并用它来呈现页面。应用程序获取偏好数据的步骤有两个。首先，它将尝试从快速的次要存储区（即内存缓存）中获取数据。如果数据不在内存缓存中，应用程序就会尝试从主要存储区（数据存储区）中获取数据。如果成功，应用程序就会把找到的数据放入内存缓存中以便今后使用。
也就是说，对于大多数请求而言，应用程序都能从memcache中得到用户的偏好数据，而无需访问数据存储区。虽然从数据存储区中读取数据已经够快的了，不过从memcache中读取数据还要比这快得多。如果用户每次在访问页面时都必须读取相同数据，这个差别就比较大了。
我们的时钟应用程序有两个请求处理器。一个用于显示当前时间，以及登录和注销的链接。它还将显示一个能让登录用户调整时区的Web表单。另一个请求处理器用于处理被提交的时区表单。用户在提交了偏好表单之后，应用程序会保存修改并将浏览器转回到主页面。
应用程序通过它所在的服务器的系统时钟获取当前时间。有一点需要注意，App Engine不保证它的所有Web服务器的系统时钟是同步的。由于本应用程序的任何两个请求都可能由不同的服务器处理，因此不同的请求可能会有不同的时钟。服务器时钟虽然不像真实应用程序的时间数据源那么和谐，不过对本例而言还是足够了。
在下一节中，我们将使用Python来实现这个应用程序。在“开发一个Java应用程序” 一节中，我们会用Java再做一次。跟之前一样，如果某节的内容不适合你，直接跳过就是了。
开发一个Python应用程序 为App Engine开发的最简单的Python应用程序只有一个目录，其中有两个文件：一个叫做app.yaml的配置文件，以及一个实现了请求处理器的Python代码文件。含有app.yaml文件的目录是应用程序的根目录。在使用工具的时候，你将会经常用到这个目录。
注意： 如果使用Launcher，则可以通过“File”菜单中的“Create New Application....”来新建项目。Launcher会创建一个新项目以及几个文件，随着对这个示例应用程序逐步深入的讲解，我们将会编辑所有这些文件。另外，你也可以手工创建项目目录和那些文件，然后通过“File”菜单中的“Add Existing Application....”将其添加到Launcher中。 创建一个名为clock的目录以存放本项目。使用你最喜欢的文本编辑器在这个目录中创建一个名为app.yaml的文件，其内容如示例2-1所示。
示例2-1：这个简单应用程序的app.yaml配置文件
application: clock
version: 1
runtime: python
api_version: 1
handlers:
- url: / . *
script: main. py 该配置文件的格式叫做YAML，这是一种用于配置文件和网络消息的开放格式。目前，你还不需要了解关于此格式的更多知识，只要能看明白这个配置文件就行了。
在本例中，该配置文件将告诉App Engine：这是一个版本号为1的名叫clock的应用程序，它用的是版本号为1的Python运行时环境（API version），该应用程序的每个请求（所有URL都匹配正则表达式/.*）都由名为main.py的Python脚本进行处理。
在app.yaml的同一个目录中，再创建一个名为main.py的文件，其内容如示例2-2所示。
示例2-2：一个简单的Python请求处理器脚本
import datetime
print 'Content-Type: text/html'
print ''
print 'The time is: %s
' % str( datetime. datetime. now( ) ) 这个简单的Python程序从Python标准库中引入了datetime模块，输出一个声明了文档类型（HTML）的HTTP头，然后再输出一个包含当前时间（根据Web服务器的时钟）的消息。
Python请求处理器使用CGI协议与App Engine进行通信。当App Engine接收到来自Python应用程序的请求时，会根据该请求的数据在环境变量中建立一个运行时环境，根据配置文件判断应该运行哪段处理器脚本，然后再根据请求体（如果有）在标准输入流上运行该脚本。处理器脚本用于执行请求所需的全部动作，然后把响应（包括一个有效的HTTP头）输出到标准输出流。这个简单示例会忽略掉请求数据，输出一个声明了响应数据的类型的头，然后再输出一段带有当前时间的消息。
现在，我们来测试一下刚才所做的这个应用程序。运行dev_appserver.py命令以打开开发服务器，注意把项目目录（clock）的路径作为参数：
dev_appserver.py clock
注意： 如果当前工作目录就是刚才所创建的那个clock目录，则在运行该命令时可以使用一个点（.）作为项目的路径： 服务器启动之后会在控制台输出一些消息。如果这是你第一次在命令行中运行该服务器，它可能会问你要不要检查更新，输入你的答案，然后按Enter键。不用理会“Could not read datastore data”和“Could not initialize images API”之类的警告。如果你按照之前所讲的那些安装步骤安装，这些警告都是正常的。最后一条消息应该是这样的：
INFO . . . Running application clock on port 8080: http: / / localhost: 8080 这条消息说明服务器启动成功了。如果没看到这条消息，则可以在其他消息里面看看有没有什么提示，还有就是再看看app.yaml文件中的语法是不是对的。
通过在Web浏览器中访问服务器的URL可测试你的应用程序：
浏览器将会显示出与图2-4类似的页面。
图2-4：第1版的时钟应用程序在浏览器中的样子
在开发应用程序的时候，你可以一直把这个Web服务器开着。它会一直盯着那些文件，在你对文件作出修改之后，它就会根据需要自动重新加载修改后的文件。
注意：在Launcher中，你可以通过单击“Run”按钮的方式来启动开发服务器。当服务器成功启动之后，项目旁边的那个图标就会变绿。单击“Browse”按钮即可在浏览器中打开这个项目。 webapp框架简介 示例2-2中的代码试图直接实现CGI协议，不过在真实的应用程序中禁止这样做。Python标准库中就有这样的模块（还有名字就叫cgi的），它们不仅实现了CGI协议，而且还能完成一些其他的Web应用程序任务。这些实现不仅是完整的、快速的，而且是彻底测试过的，所以一般来说，直接使用这些模块要比自己重新做一个好。
Web应用程序框架不仅仅是一堆模块库那么简单，它通过一组和谐的工具、组件和模式为我们提供了最好的Web应用程序开发实践：数据建模接口、模板系统、请求处理机制、项目管理工具以及开发环境等，这些东西组合到一起就能降低原本需要由你亲自编写和维护的代码量了。用Python编写的Web框架有很多，其中不少已经很成熟了，不仅有着漂亮的文档，而且还有人气旺盛的开发人员社区。Django、web2py和Pylons就是这类Python Web框架中的优秀典范。
并不是每个Python Web框架都完全适用于App Engine的Python运行时环境。App Engine的沙盒原则所强制要求的那些约束（含有C代码的模块被约束得尤为厉害）限制了那些需要使用沙盒外部功能的框架。目前已知的能够良好运行的Web框架是Django（），其他的都需要额外软件的配合才行。我们将在第14章讨论如何在App Engine中使用Django。
为了方便大家学习，App Engine还提供了一个名为“webapp”的简单框架。webapp框架小巧且易于使用。它虽然没有大型框架中那么完备的功能，不过对小项目而言已经是足够好的了。如果你是通过Launcher创建出这个clock项目，则可以发现那些初始文件所用的就是webapp框架。
为了简单起见，本书中大部分的Python示例都将使用webapp框架。虽然我们不会在本书中详细介绍webapp框架，但是会介绍它的一些功能。对于更大的应用程序，你可能会希望使用像Django这样的拥有更多功能的框架。
让我们用webapp框架来更新一下这个时钟应用程序。根据示例2-3的内容，对main.py做一些修改。在浏览器中重新加载该页面即可看到新版本的运行效果了。（除时间被更新了之外，你将看不到有其他任何区别。这个示例跟前一个版本是等效的。）
示例2-3：一个简单使用了webapp框架的请求处理器
from google. appengine. ext import webapp
from google. appengine. ext. webapp. util import run_wsgi_app
import datetime
class MainPage( webapp. RequestHandler) :
def get( self) :
time = datetime. datetime. now( )
self. response. headers[ 'Content-Type' ] = 'text/html'
self. response. out. write( 'The time is: %s
' % str( time) )
application = webapp. WSGIApplication( [ ( '/' , MainPage) ] ,
debug= True)
def main( ) :
run_wsgi_app( application)
if __name__ = = '__main__' :
main( ) 示例2-3引入了模块google.appengine.ext.webapp，然后定义了一个叫做MainPage的请求处理器类（它是webapp.RequestHandler的一个子类）。该类将为请求处理器所支持的每个HTTP方法定义单独的方法，在本例中，就只有一个针对HTTP GET的叫做get()的方法。当应用程序在处理请求时，首先将处理器类实例化，并设置self.request和self.response，然后再调用适当的处理器方法（本例中就是get()）。当处理器方法退出之后，应用程序会将self.response的值作为HTTP响应。
应用程序本身是由webapp.WSGIApplication类的一个实例来表示的。其初始化过程依赖于一组映射信息，即处理器类与URL之间的映射关系。如果应用程序是在开发服务器上运行，那么debug参数的作用是：告诉应用程序当请求处理器返回异常时是否要在浏览器窗口中输出一条出错信息。webapp会自动侦测它现在到底是在开发服务器上运行还是在App Engine上运行。如果是在App Engine上运行，就算debug值为True，也不会把出错信息输出到浏览器上。若将debug设置为False，即可在开发服务器上模拟应用程序在App Engine上出错的情况。
这段脚本中还定义了一个main()函数，它通过一个实用工具方法来运行应用程序。最后，这段脚本用了一条固定形式的Python语句if__name__ == '__main__':...来实现对main()的调用；只要是由Web服务器来运行这段脚本，则该条件就永远为真。这条语句使你可以将这段脚本（包括其中定义的类和函数）作为一个模块引入别的代码中，那时就不会执行main()了。
注意： 用这种方式定义main()函数，App Engine就会将已编译的处理器脚本缓存起来，这样，后续请求执行起来就会快很多了。更多有关应用程序缓存的知识，请参见第3章。 单个WSGIApplication实例可以处理多个URL，它会根据URL的模式把不同的请求路由到不同的RequestHandler类。但是我们之前所看到的那个app.yaml文件已经把URL模式跟处理器脚本映射起来了。那么，究竟URL模式该被放到app.yaml文件中呢，还是该被放到WSGIApplication中呢？许多Web框架都有自己的一套URL调度逻辑，而且通常都会将所有的动态URL路由给它自己的调度器（app.yaml）。对webapp而言，主要还是看你想如何组织你的代码。在这个时钟应用程序中，我们还将在一个单独的脚本文件中创建第二个请求处理器，目的是利用app.yaml的用户验证功能。当然，你也可以将这个逻辑写到main.py中，也就是说，用WSGIApplication对象来路由URL。
用户和GAccount
到目前为止，我们的时钟对每个用户显示的都是一样的东西。为了使用户能够自定义显示结果（还要保存其偏好数据以便今后使用），我们需要找到一个能够识别出发起请求的用户的办法。最简单的方案之一就是GAccount。
接下来，我们给这个页面加上点能够判断“用户是否登录”的东西，再加入一个用于“登入和登出应用程序”的链接。按照示例2-4的方式编辑main.py。
示例2-4：能够显示GAccount信息和相关链接的main.py
from google. appengine. api import users
from google. appengine. ext import webapp
from google. appengine. ext. webapp. util import run_wsgi_app
import datetime
class MainPage( webapp. RequestHandler) :
def get( self) :
time = datetime. datetime. now( )
user = users. get_current_user( )
if not user:
navbar = ( 'Welcome! Sign in or register to customize.
'% ( users. create_login_url( self. request. path) ) )
else :
navbar = ( 'Welcome, %s! You can sign out .
'% ( user. email( ) , users. create_logout_url( self. request. path) ) )
self. response. headers[ 'Content-Type' ] = 'text/html'
self. response. out. write( '' '
The Time Is...
%s
The time is: %s
''' % ( navbar, str( time) ) )
application = webapp. WSGIApplication( [ ( '/' , MainPage) ] , debug= True) def main( ) :
run_wsgi_app( application)
if __name__ = = '__main__' :
main( ) 在真实的应用程序中，你应该用一个模板系统来进行输出，把HTML和显示逻辑与应用程序代码分开。许多Web应用程序框架都有一个模板系统，不过webapp没有。由于这个时钟应用程序只有一个页面，所以我们就直接把HTML放到请求处理器代码中（用Python的字符串格式化来组织各种信息）。
注意： Python运行时环境中带有Django，其模板系统可以用于webapp。当Google公司发布第1版Python
运行时环境时，最新的Django是0.96版，所以运行时环境中所包含的就是这个版本了。更多有关如何在webapp中使用Django模板的知识，请参阅App Engine的文档。
在浏览器中重新加载该页面。新页面如图2-5所示。
图2-5：当用户没有登录时，时钟应用程序会显示一个指向GAccount的链接
用于GAccount的Python API由google.appengine.api.users模块提供。如果用户没有登录，则该模块中的get_current_user()函数将返回None；否则将返回一个带有用户账户信息的User类实例。User对象的email()方法用于返回该用户的电子邮件地址。
create_login_url()和create_logout_url()方法用于生成指向GAccount的URL。这两个方法都以该应用程序的URL路径为参数，在执行完相关任务之后用户就会被带回到那个URL上去。登录URL所指向的GAccount页面可以让用户登录或注册一个新账户。注销URL则访问GAccount以注销当前用户，并立即转回指定的应用程序URL。
当应用程序运行于开发服务器时，单击链接“Sign in or register”将会打开GAccount登录界面的开发服务器模拟版，如图2-6所示。在这个界面上，不管你输入什么电子邮件地址，开发服务器都会接受，就好像你真的有这么一个账户一样。
图2-6：开发服务器所模拟出来的GAccount登录界面
当应用程序运行在App Engine上时，登录和注销URL将会指向真正的GAccount地址。登录或注销之后，GAccount将立刻转向在线应用程序所指定的URL。
单击“Sign in or register”，然后在模拟的GAccount页面上单击“Login”按钮，这时使用的是默认的测试电子邮件地址（test@example.com）。时钟应用程序现在看上去如图2-7所示。单击“sign out”链接即可注销。
Web表单和数据存储区 现在我们已经知道用户是谁了，接下来就可以问问她喜欢哪个时区，并保存她的偏好以便她在下次访问时可以使用。
首先，为了今后的请求能够访问到用户的偏好数据，我们需要先找到一个能够记住这些数据的办法。App Engine的数据存储区是一种可靠且可扩展的存储手段，刚好满足我们的要求。Python API中有一个能够把Python对象跟数据存储区实体映射起来的数据建模接口。我们可以用它来编写一个UserPrefs类。
创建一个名为models.py的文件，其内容如示例2-5所示。
图2-7：用户已经登录了这个时钟应用程序
示例2-5：models.py文件中有一个用于将用户偏好存放到数据存储区的类
from google. appengine. api import users
from google. appengine. ext import db
class UserPrefs( db. Model) :
tz_offset = db. IntegerProperty( default= 0)
user = db. UserProperty( auto_current_user_add= True) def get_userprefs( user_id= None) :
if not user_id:
= users. get_current_user( )
if not user:
return None
= user. user_id( )
= db. Key. from_path( 'UserPrefs' , user_id)
= db. get( key)
if not userprefs:
= UserPrefs( key_name= user_id)
return userprefs Python的数据建模接口由google.appengine.ext.db模块提供。数据模型其实就是基类为db.Model的一个类。模型子类通过类属性定义出每个对象的数据结构。当值被赋给实例属性时，db.Model将会强制执行这个结构。对于UserPrefs而言，我们定义了两个属性：tz_offset（这是个整型值）以及user（由GAccount API返回的一个User对象）。
每个数据存储区实体都有一个主键。跟关系型数据库中的表主键不同，实体键是固定不变的，只能在实体创建时设置其值。系统中所有实体的键都是唯一的，由多个部分组成，其中包括实体的类别（本例中是'UserPrefs'）。从这个API中可以看出，应用程序可以将键的键名（key name）部分设置为任意值。
时钟应用程序以用户的唯一ID（由User对象的user_id()方法提供）作为UserPrefs实体的键名。这就使得应用程序可以根据键来获取实体了，因为它可以从GAccount API中获知用户的ID。通过键来获取实体的方式要比执行数据存储区查询的方式快一些。
在models.py中，我们定义了一个名为get_userprefs()的函数，它用于获取指定用户的UserPrefs对象。在得到用户ID之后，该函数将通过类别'UserPrefs'和键名（等于用户ID）构造出实体的数据存储区键。如果实体在数据存储区中，则该函数就会返回UserPrefs对象。
如果实体不在数据存储区中，则该函数将使用默认设置以及对应于该用户的键名新建一个UserPrefs对象。新对象不会被自动保存到数据存储区。调用者必须调用UserPrefs实例的put()方法才能将其保存。
现在我们已经有了一个用于获取UserPrefs对象的机制，接下来对主页做两个修改。如果用户登录了，我们就可以获取其偏好数据（如果有）并调整时钟的时区。下面，我们来给主页添加一个能让用户设置时区偏好的Web表单。如示例2-6所示修改main.py即可实现这些功能。
示例2-6：新版main.py，它可以根据用户的时区调整时钟，还可以显示一个偏好表单
from google. appengine. api import users
from google. appengine. ext import webapp
from google. appengine. ext. webapp. util import run_wsgi_app
import datetime
import models
class MainPage( webapp. RequestHandler) : def get( self) :
time = datetime. datetime. now( )
user = users. get_current_user( )
if not user:
navbar = ( 'Welcome! Sign in or register to customize.
'
% ( users. create_login_url( self. request. path) ) )
tz_form = ''
else :
userprefs = models. get_userprefs( )
navbar = ( 'Welcome, %s! You can sign out .
'
% ( user. nickname( ) , users. create_logout_url( self. request. path) ) )
tz_form = '' '
Timezone offset from UTC (can be negative):
size="4" value="%d" />
''' % userprefs. tz_offset
time + = datetime. timedelta( 0, 0, 0, 0, 0, userprefs. tz_offset)
self. response. headers[ 'Content-Type' ] = 'text/html'
self. response. out. write( '' '
The Time Is...
%s
The time is: %s
%s
''' % ( navbar, str( time) , tz_form) ) application = webapp. WSGIApplication( [ ( '/' , MainPage) ] , debug= True)
def main( ) :
run_wsgi_app( application)
if __name__ = = '__main__' :
main( ) 为了实现偏好表单，我们还需要另外做一个专门的请求处理器来解析表单数据和更新数据存储区。我们在一个新的脚本文件中实现这个请求处理器。创建一个名为prefs.py的文件，其内容如示例2-7所示。
示例2-7：这是一个新的处理器脚本（prefs.py），它用于处理偏好表单
from google. appengine. ext import webapp
from google. appengine. ext. webapp. util import run_wsgi_app
import models class PrefsPage( webapp. RequestHandler) :
def post( self) :
= models. get_userprefs( )
try :
= int( self. request. get( 'tz_offset' ) )
. tz_offset = tz_offset
. put( )
except ValueError :
't an integer. Ignore for now.
/ ') application = webapp.WSGIApplication([('/ prefs', PrefsPage)], debug=True) def main():
if __name__ == '__main__ 这个请求处理器将会处理URL/prefs上的HTTP POST请求，也就是这个表单所使用的URL（action）和HTTP方法。处理器调用models.py中的get_userprefs()函数以获取当前用户的UserPrefs对象，这可能是一个新的由默认值填充的未保存的对象，也可能是一个已经存在的实体对象。处理器会将表单数据中的tz_offset参数转换成一个整型值，设置UserPrefs对象的属性，然后调用该对象的put()方法将其保存到数据存储区。如果对象不在数据存储区中，则put()方法将会创建一个新的，否则就更新掉现有的。
如果用户在那个表单文本框中输入的不是整数，那我们就什么也不做。若返回一个出错消息会更好一些，不过为了保持整个示例的简单性，这里就先不管了。
最后，为了将这个请求处理器跟URL /prefs映射关联起来，需要修改一下app.yaml中的handlers:节，如示例2-8所示。
示例2-8：新版的app.yaml，它加上了URL /prefs的映射（还带登录验证）
application: clock
version: 1
runtime: python
api_version: 1
handlers:
- url: / prefs script: prefs. py
login: required - url: / . *
script: main. py login:required这行的意思是说，用户在访问/prefs这个URL的时候必须先登录GAccount。如果用户在没有登录的情况下访问该URL，App Engine会自动将该用户指引到GAccount的登录页面，在完成登录之后再转回到这个URL。这就使我们可以轻松地为站点的某些部分单独添加登录验证了，即在请求处理器被调用之前先验证用户是否已经登录。
务必要把/prefs这个URL的映射信息放到/.*映射信息的前面。URL模式的匹配尝试是按顺序进行的，第一个匹配成功的请求处理器将被用于处理当前请求。由于/.*这个模式会匹配所有的URL，因此/prefs必须在它前面，不然就会被忽略掉。
重新加载页面，时钟应用程序现在是可定制的了。修改一下时区并提交表单。注销一下，然后用同一个电子邮件地址重新登录一次，之后再用别的电子邮件地址登录上去看看。这个应用程序会记住每个用户的时区偏好。
用memcache实现缓存 示例2-5中的代码用于获取用户的偏好数据，在每个登录用户（每次）访问站点的时候，它都会从数据存储区中获取一个实体。由于用户的偏好数据经常被读取而很少被修改，因此处理每个请求时都去数据存储区里取一次UserPrefs就显得有点资源浪费了。只需增加一个缓存层，我们就能降低从主存储区读取数据的成本。
我们可以用memcache服务作为用户偏好数据的次要存储区。只需对models.py做一点点修改就能加上缓存功能。如示例2-9所示修改该文件。
示例2-9：新版的models.py，它能将UserPrefs对象缓存到memcache中
from google. appengine. api import memcache
from google. appengine. api import users
from google. appengine. ext import db
class UserPrefs( db. Model) :
tz_offset = db. IntegerProperty( default= 0)
user = db. UserProperty( auto_current_user_add= True)
def cache_set( self) :
memcache. set( self. key( ) . name( ) , self, namespace= self. key( ) . kind( ) )
def put( self) :
self. cache_set( )
db. Model. put( self) def get_userprefs( user_id= None) :
if not user_id:
user = users. get_current_user( )
if not user:
return None
user_id = user. user_id( )
userprefs = memcache. get( user_id, namespace= 'UserPrefs' )
if not userprefs:
key = db. Key. from_path( 'UserPrefs' , user_id)
userprefs = db. get( key)
if userprefs:
userprefs. cache_set( )
else :
userprefs = UserPrefs( key_name= user_id) return userprefs用于memcache服务的Python API由google.appengine.api.memcache模块提供。memcache存储的是键值对，另外在键上还可以有一个命名空间。值可以是任何能够通过Python中的pickle模块与扁平数据互相转换（序列化）的数据类型：其实，大部分数据对象都是这样的类型。
新的UserPrefs类重写了put()方法。当某个实体上的put()方法被调用时，该实体先是被保存到memcache中，然后再被原来的put()方法保存到数据存储区中。（db.Model.put(self)是Python中调用被重写的基类方法的一种手段。）
UserPrefs类中还有一个新的名叫cache_set()的方法，它的作用是调用memcache.set()。memcache.set()接受一个键、一个值，以及一个可选的键命名空间。这里，我们把实体的键名用作键，整个对象（self）作为值，实体的类别（UserPrefs）作为命名空间。API将会负责对UserPrefs对象进行序列化，也就是说，我们可以直接保存和获取完整的对象。
新版get_userprefs()会在检查数据存储区之前先在memcache中看看有没有想要的UserPrefs对象。如果在缓存中找到了的话，就用它。如果没找到，就去数据存储区中看看，如果在那儿找到了的话，就把它保存到缓存中之后再用。如果对象既不在memcache中也不在数据存储区中的话，get_userprefs()就会用默认值构造一个新的UserPrefs对象并将其返回。
重新加载一下页面，看看新版的效果怎么样。为了让缓存表现得更明显一点，你可以在适当的位置加上一些日志语句，比如：
import logging
class UserPrefs( db. Model) :
# . . .
def cache_set( self) :
logging. info( 'cache set' )
# . . . 开发服务器会在控制台显示日志输出。如果使用Launcher，则只要单击Logs按钮就能打开一个专门显示开发服务器输出信息的窗口了。
接下来，我们将看看同一个例子用Java运行时环境该怎么弄。如果你对Java不感兴趣，可以直接跳到本章“注册应用程序”。
开发一个Java应用程序 App Engine上的Java Web应用程序通过Java Servlet标准接口与应用程序服务器交互。一个应用程序由一个或多个类组成，这些类都扩展自一个servlet基类。servlet是通过一个标准配置文件（叫做“部署描述符”）与URL映射起来的。当App Engine接收到一个请求时，首先会判断该使用哪个servlet类（根据URL和部署描述符），然后初始化该类，并调用这个servlet对象上的某个方法。
Java应用程序的所有文件（包括已编译的Java类、配置文件以及静态文件）都是以一种叫做Web应用程序档案（Web Application Archive，WAR）的标准目录结构组织起来的。
WAR目录中的所有东西都会被部署到App Engine上去。WAR中的内容通常是在开发过程中由一组源文件生成的，你可以使用自动构建过程，也可以使用支持WAR的开发工具。
如果使用的是Eclipse IDE和GPlugin，则可以通过Web Application向导来创建新项目。在“File”菜单中，单击“New”，然后单击“Web Application Project”。在打开的窗口中，输入项目名（如Clock）和包名（如clock）。
取消“Use GWeb Toolkit”复选框的选中状态，并确保“Use GAE”复选框是选中的。
（ 如果选中了“GWT” 复选框， 则新项目在创建时会有一些初始文件。） 单击“Finish”即可创建该项目。
如果没有使用GPlugin for Eclipse，就要使用另一种办法来创建这些目录和文件了。如果对Java的Web开发已经很熟悉了，可以用你现有的工具和工序来生成最终的WAR。在本节余下的内容中，我们将假设该目录结构已经由GPlugin for Eclipse创建好了。
图2-8展示了该项目的文件结构，跟在Eclipse Package Explorer中显示的一样。
图2-8：一个新Java项目的结构，跟Eclipse Package Explorer中所显示的一样该项目的根目录（Clock）含有两个主要的子目录：src和war。src/目录所包含的是该项目全部的类文件，这是常见的Java包结构形式。根据clock的包路径，Eclipse将会在文件clock/ClockServlet.java中创建一个名为ClockServlet的servlet类。
war/目录所包含的是该应用程序完整的最终内容。Eclipse会自动编译src/中的源代码，
并将编译后的类文件保存到war/WEB-INF/classes/中（默认情况下，该目录在Eclipse的Package Explorer中是不可见的）。Eclipse还会自动地将src/META-INF/中的内容复制到war/WEB-INF/classes/META-INF/。其他所有的东西都会被创建在war/目录中的指定位置。
下面，我们从一个简单的servlet开始构建咱们这个时钟应用程序，其功能就是显示当前时间。打开文件src/clock/ClockServlet.java（如果需要，应先创建），然后如示例2-10所示编辑其中的内容。
示例2-10：一个简单的Java servlet
package clock;
import java. io. IOException;
import java. io. PrintWriter;
import java. text. SimpleDateFormat;
import java. util. Date;
import java. util. SimpleTimeZone;
import javax. servlet. http. * ; @SuppressWarnings( "serial" )
public class ClockServlet extends HttpServlet {
public void doGet( HttpServletRequest req, HttpServletResponse resp)
throws IOException {
SimpleDateFormat fmt = new SimpleDateFormat( "yyyy-MM-dd hh:mm:ss.SSSSSS" ) ;
fmt. setTimeZone( new SimpleTimeZone( 0, "" ) ) ;
resp. setContentType( "text/html" ) ;
PrintWriter out = resp. getWriter( ) ;
out. println( "The time is: "
+ fmt. format( new Date( ) ) + "" ) ;
}
} 该servlet类继承自javax.servlet.http.HttpServlet，并为它所希望支持的所有HTTP方法重写了基类中的相应方法。为了能够处理HTTP GET请求，我们的这个servlet重写了doGet()方法。服务器在调用该方法时，将会以一个HttpServletRequest对象和一个HttpServletResponse对象作为参数。HttpServletRequest含有该请求相关的信息，比如URL、表单参数以及cookie等。而该方法则通过HttpServletResponse上的一系列方
法来准备响应，如setContentType()和getWriter()等。当这个servlet方法退出时，App Engine就会将响应发送出去。
为了告诉App Engine使用这个servlet来处理请求，我们还需要一个部署描述符。打开或创建文件war/WEB-INF/web.xml，如示例2-11所示修改其内容。
示例2-11：该web.xml文件（也就是部署描述符）将所有URL都映射到了ClockServlet上
< ? xml version = "1.0" encoding = "utf-8" ? >
< ! DOCTYPE web- app PUBLIC
"-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
"" >
< web- app xmlns= "" version = "2.5" >
< servlet>
< servlet- name > clock< / servlet- name >
< servlet- class > clock. ClockServlet< / servlet- class >
< / servlet>
< servlet- mapping>
< servlet- name > clock< / servlet- name >
< url - pattern > Eclipse可能会在其XML“设计”视图（这是一个表型视图，里面是元素和值）中打开该文件。点击编辑器面板底部的“Source”标签页就可以编辑XML源代码了。
web.xml是一个XML文件，其根元素是
。为了将URL模式映射到servlet，你需要为每个servlet声明一个元素，然后再用一个元素来声明其映射信息。servlet映射信息中的可以使用完整的URL路径，也可以是一个由*开头或结尾（用于表示某个路径的一部分）的URL路径。在本例中，URL模式/* 将匹配所有的URL。值都是由一个正斜杠（/）开头的。若忽略这个符号，可能在开发服务器上能得到预期的效果，不过在App Engine就不一定了。< ? xml version = "1.0" encoding = "utf-8" ? >
< appengine- web- app xmlns= "" >
< application> clock< / application>
< version > 1< / version >
< / appengine- web- app> 用户和GAccount package clock;
import java . io . IOException ;
import java . io . PrintWriter ;
import java . text . SimpleDateFormat ;
import java . util . Date ;
import java . util . SimpleTimeZone ;
import javax . servlet. http. * ;
import com. google. appengine. api. users. User;
import com. google. appengine. api. users. UserService;
import com. google. appengine. api. users. UserServiceFactory;
@SuppressWarnings ( "serial" )
public class ClockServlet extends HttpServlet {
public void doGet( HttpServletRequest req,
HttpServletResponse resp)
throws IOException {
SimpleDateFormat fmt = new SimpleDateFormat ( "yyyy-MM-dd hh:mm:ss.SSSSSS" ) ;
fmt. setTimeZone ( new SimpleTimeZone ( 0, "" ) ) ;
UserService userService = UserServiceFactory. getUserService( ) ;
User user = userService. getCurrentUser( ) ;
String navBar;
if ( user ! = null ) {
navBar = "Welcome, "
+ user. getNickname( ) + "! You can +
userService. createLogoutURL( "/" ) +
"\">sign out." ;
} else {
navBar = "Welcome! + userService. createLoginURL( "/" ) +
"\">Sign in or register to customize." ;
}
resp. setContentType ( "text/html" ) ;
PrintWriter out = resp. getWriter ( ) ;
out. println ( navBar) ;
out. println ( "The time is: "
+ fmt. format ( new Date ( ) ) + "" ) ;
}
} Web表单和数据存储区 < ? xml version = "1.0" encoding = "UTF-8" ? >
< persistence xmlns= ""
xmlns: xsi= ""
xsi: schemaLocation= "
/persistence_1_0.xsd" version = "1.0" >
< persistence- unit name = "transactions-optional" >
< provider > org . datanucleus. store . appengine. jpa. DatastorePersistenceProvider< / provider >
< properties >
< property name = "datanucleus.NontransactionalRead" value = "true" / >
< property name = "datanucleus.NontransactionalWrite" value = "true" / >
< property name = "datanucleus.ConnectionURL" value = "appengine" / >
< / properties >
< / persistence- unit>
< / persistence> package clock;
import javax . persistence. EntityManagerFactory;
import javax . persistence. Persistence;
public final class EMF {
private static final EntityManagerFactory emfInstance =
Persistence. createEntityManagerFactory( "transactions-optional" ) ;
private EMF( ) { }
public static EntityManagerFactory get ( ) {
return emfInstance;
}
} package clock;
import javax . persistence. Basic ;
import javax . persistence. Entity ;
import javax . persistence. EntityManager;
import javax . persistence. Id ;
import com. google. appengine. api. users. User;
import clock. EMF;
import clock. UserPrefs;
@Entity ( name = "UserPrefs" )
public class UserPrefs {
@Id
private String userId;
private int tzOffset;
@Basic
private User user;
public UserPrefs( String userId) {
this . userId = userId;
}
public String getUserId( ) {
return userId;
}
public int getTzOffset( ) {
return tzOffset;
}
public void setTzOffset( int tzOffset) {
this . tzOffset = tzOffset;
}
public User getUser( ) {
return user;
}
public void setUser( User user) {
this . user = user;
}
public static UserPrefs getPrefsForUser( User user) {
UserPrefs userPrefs = null ;
EntityManager em = EMF. get ( ) . createEntityManager( ) ;
try {
userPrefs = em. find ( UserPrefs. class , user. getUserId( ) ) ;
if ( userPrefs = = null ) {
userPrefs = new UserPrefs( user. getUserId( ) ) ;
userPrefs. setUser( user) ;
}
} finally {
em. close ( ) ;
}
return userPrefs;
}
public void save ( ) {
EntityManager em = EMF. get ( ) . createEntityManager( ) ;
try {
em. persist( this ) ;
} finally {
em. close ( ) ;
}
}
} package clock;
import java . io . IOException ;
import javax . servlet. http. HttpServlet;
import javax . servlet. http. HttpServletRequest;
import javax . servlet. http. HttpServletResponse;
import com. google. appengine. api. users. User;
import com. google. appengine. api. users. UserService;
import com. google. appengine. api. users. UserServiceFactory;
import clock. UserPrefs;
@SuppressWarnings ( "serial" )
public class PrefsServlet extends HttpServlet {
public void doPost( HttpServletRequest req,
HttpServletResponse resp)
throws IOException {
UserService userService = UserServiceFactory. getUserService( ) ;
User user = userService. getCurrentUser( ) ;
UserPrefs userPrefs = UserPrefs. getPrefsForUser( user) ;
try {
int tzOffset = new Integer ( req. getParameter ( "tz_offset" ) ) . intValue ( ) ;
userPrefs. setTzOffset( tzOffset) ;
userPrefs. save ( ) ;
} catch ( NumberFormatException nfe) {
// User entered a value that wasn't an integer. Ignore for now.
}
resp. sendRedirect( "/" ) ;
}
} < servlet>
< servlet- name > prefs < / servlet- name >
< servlet- class > clock. PrefsServlet< / servlet- class >
< / servlet>
< servlet- mapping>
< servlet- name > prefs < / servlet- name >
< url - pattern > / prefs < / url - pattern >
< / servlet- mapping>
< security - constraint>
< web- resource- collection >
< web- resource- name > prefs < / web- resource- name >
< url - pattern > / prefs < / url - pattern >
< / web- resource- collection >
< auth - constraint>
< role - name > * < / role - name >
< / auth - constraint>
< / security - constraint> 块告诉App Engine：用户只有在登录了GAccount之后才能访问/prefs这个URL。如果用户在没有登录的情况下访问该URL，App Engine就会将其转向到GAccount以要求其登录。用户在登录之后，会被转回到原来想要访问的那个URL上面去。安全约束是实现一组URL上的GAccount验证的便捷方式。在本例中，它意味着PrefsServlet无须处理“未登录用户试图向该URL提交数据”的问题。用memcache实现缓存 import java . io . Serializable ;
import com. google. appengine. api. memcache. MemcacheService;
import com. google. appengine. api. memcache. MemcacheServiceException;
import com. google. appengine. api. memcache. MemcacheServiceFactory;
// ...
@SuppressWarnings ( "serial" )
@Entity ( name = "UserPrefs" )
public class UserPrefs implements Serializable {
// ...
@SuppressWarnings ( "unchecked" )
public static UserPrefs getPrefsForUser( User myUser) {
UserPrefs userPrefs = null ;
String cacheKey = "UserPrefs:" + myUser. getUserId( ) ;
try {
MemcacheService memcache = MemcacheServiceFactory. getMemcacheService( ) ;
if ( memcache. contains ( cacheKey) ) {
userPrefs = ( UserPrefs) memcache. get ( cacheKey) ;
return userPrefs;
}
// If the UserPrefs object isn't in memcache,
// fall through to the datastore.
} catch ( MemcacheServiceException e) {
// If there is a problem with the cache,
// fall through to the datastore.
}
EntityManager em = EMF. get ( ) . createEntityManager( ) ;
try {
userPrefs = em. find ( UserPrefs. class , myUser. getUserId( ) ) ;
if ( userPrefs = = null ) {
userPrefs = new UserPrefs( myUser. getUserId( ) ) ;
userPrefs. setUser( myUser) ;
} else {
try {
MemcacheService memcache = MemcacheServiceFactory. getMemcacheService( ) ;
memcache. put ( cacheKey, userPrefs) ;
} catch ( MemcacheServiceException e) {
// Ignore cache problems, nothing we can do.
}
}
} finally {
em. close ( ) ;
}
return userPrefs;
}
public void save ( ) {
EntityManager em = EMF. get ( ) . createEntityManager( ) ;
try {
em. persist( this ) ;
} finally {
em. close ( ) ;
}
}
} import java.util.logging.*;
import javax.persistence.Transient;
// ...
public class UserPrefs implements Serializable {
@Transient
private static Logger logger = Logger.getLogger(UserPrefs.class.getName());
// ...
if (cache.containsKey(cacheKey)) {
logger.warning("CACHE HIT");
userPrefs = (UserPrefs) cache.get(cacheKey);
return userPrefs;
}
logger.warning("CACHE MISS"); 开发控制台 from google. appengine. ext import db
import models
q = models. UserPrefs. gql( "WHERE tz_offset = -8" )
for prefs in q:
print prefs . user 注册应用程序 应用程序的ID和标题 元素中。设置域名 Apps和身份验证 handlers:
- url : / . *
script: main. py
login : required 上传应用程序 