Apress bắt đầu ứng dụng với java google - p 7 docx

CHAPTER 3 ■ GETTING STARTED WITH GOOGLE APP ENGINE FOR JAVA
38
■ Note Google Suggest, AdSense for Content, and Orkut are among the many products created through
the “20 percent time” perk.

Figure 3-8. The Google App Engine launcher for Mac
You don’t have to use the launcher to start your development projects on the local
development server. If you’re using Eclipse and the Google Eclipse Plugin, you can
launch your application locally by selecting Debug As ➤ Web Application from the
Run menu.
For more control or to script the launch of your applications locally, you can
launch the development web server from the command line. You should execute this
command from the SDK’s appengine-java-sdk/bin directory.
If you are using Windows, run the following command:

appengine-java-sdk\bin\dev_appserver.cmd [options] war-location

If you are using Mac OS X or Linux, run the following command:

appengine-java-sdk/bin/dev_appserver.sh [options] war-location
CHAPTER 3 ■ GETTING STARTED WITH GOOGLE APP ENGINE FOR JAVA
39

These commands are OS-specific wrapper scripts that run the Java class com.google.
appengine.tools.KickStart in appengine-java-sdk/lib/appengine-tools-api.jar. For
details on the available command options reference the online documentation.
■ Note To stop the development server, press Control + C (on Windows, Mac, or Linux).
Deploying Your Sample Application
It’s time to deploy your application to App Engine where you can browse it
publicly and share it with the world. There’s a small Jet Engine icon in your
Eclipse tool bar that was created when you installed the Google Eclipse Plugin.

Click that icon while making sure that your ChapterThree sample application is
selected in the Package Explorer. It’s important to note that, at the time of this
writing, you get 10 applications per account. You may consider choosing generic
application IDs for the examples in this book and reusing them for each chapter.
You’ll be presented with a Deploy Project to Google App Engine dialog like the
one shown in Figure 3-9. The project name should have been defaulted to the project
you had selected in Eclipse. If it’s blank or doesn’t look quite right, click cancel, select
the ChapterThree project in Eclipse, and click the Jet Engine button again.

Figure 3-9. The Deploy Project to Google App Engine dialog
CHAPTER 3 ■ GETTING STARTED WITH GOOGLE APP ENGINE FOR JAVA
40
Once you’re ready to move forward click the App Engine project settings… link at
the bottom of the dialog window. You’ll see something similar to Figure 3-10.

Figure 3-10. The App Engine project settings dialog
Note that the Application ID field of your dialog isn’t populated. You first have to
create the application in your Google App Engine console to move past this point in
the deployment process. Use the My applications… link to open the Application
Registration form for your App Engine account. Figures 3-11 and 3-12 follow the
process for your account. You’ll have to create a unique Application identifier, which
must be unique across the appspot.com domain. Use the Check Availability feature
to verify that your application ID is available.
CHAPTER 3 ■ GETTING STARTED WITH GOOGLE APP ENGINE FOR JAVA
41

Figure 3-11. Registering kylechapterthree.appspot.com (use a unique name)

Figure 3-12. Confirming that the application was registered
Now that you’ve deployed your application you have a few options for production

use. You can browse to your application live on appspot.com by navigating to your
application’s unique domain on appspot. In the example case (shown in Figures 3-11
and 3-12), the application lives at , as shown in
CHAPTER 3 ■ GETTING STARTED WITH GOOGLE APP ENGINE FOR JAVA
42
Figure 3-13. If you’re using Google Apps you can create a unique domain name for
your App Engine application. We’ll look at that later in the book.

Figure 3-13. The application live on appspot.com
Summary
In this chapter you built your first Google App Engine for Java application using the
Guestbook demo application that comes with the SDK. You set up and configured
the SDK and Google Plugin for Eclipse and even deployed your application to
appspot.com. We’re going to dive a little deeper into some development
technologies and application components in Chapter 4, where you’ll look at
different approaches to constructing a user interface in an App Engine application
and review some libraries and development frameworks.
C H A P T E R 4

■ ■ ■

43
Servlet Container and Frameworks
Now that you’ve set up your development environment and configured the SDK, it's
time to look at the design of your application. Out of the box, App Engine uses the
Java Servlet standard for web applications, but you may be able to use your favorite
framework as well. In this chapter we’ll look at different libraries and frameworks that
run in App Engine. You’ll build a small application with servlets and JavaServer (JSP)
pages as well as applications using Spring MVC and Adobe Flex with GraniteDS.
Choosing a Framework

Choosing the best application framework almost always generates a heated debate.
There are pros and cons for each framework, and every developer has an opinion. Some
developers may prefer a robust Enterprise JavaBeans (EJB) framework while others
prefer a lightweight, agile approach. To ensure that your application will run within the
App Engine server runtime environment, App Engine imposes some constraints that
enable applications to run “nicely” together and be scalable across multiple distributed
runtime instances.
While Google doesn't officially support the libraries or frameworks that run on App
Engine, it does take a community-oriented approach to compatibility. While many
frameworks will run seamlessly on App Engine, others will not. Some frameworks will
require modifications, and there is an active and vibrant community dedicated to
interoperability.
Popular Java libraries and frameworks are listed in Table 4-1. Frameworks marked
as compatible should work out-of-the-box with some minor configuration changes or
code tweaks. Ones marked “Semi-compatible” typically include some features that
will not operate properly due to App Engine restrictions (for example, writing to the
file system, multithreading). Most incompatible frameworks fail to run due to their
reliance on classes not supported by App Engine.
CHAPTER 4 ■ SERVLET CONTAINER AND FRAMEWORKS
44
Table 4-1. Java libraries and frameworks from Google’s “Will it play in App Engine”
page
Framework Version(s) Status
Apache Commons FileUpload 1.2.1 Semi-Compatible
Apache POI ? Incompatible
BlazeDS 3.2.0 Compatible
Compass ? Semi-Compatible
Direct Web Remoting (DWR) 2.0.5, 3.0 RC1 Compatible
dyuproject ? Compatible
Ehcache 1.6.0 Compatible

Facelets 1.1.14 Compatible
Google Data (GData) client library for
Java
All Compatible
Grails 1.1.1 Compatible
GraniteDS ? Compatible
Guice ? Semi-Compatible
Hibernate All Incompatible
iText ? Incompatible
Java Topology Suite (JTS) 1.10 Compatible
JBoss Seam ? Semi-Compatible
Jersey 1.0.2 Semi-Compatible
log4j ? Compatible
CHAPTER 4 ■ SERVLET CONTAINER AND FRAMEWORKS
45
Framework Version(s) Status
MyFaces 1.1.6 Compatible
OpenSocial client library for Java 20090402 Compatible
OSGi ? Semi-Compatible
Restlet ? Compatible
RichFaces 3.1.6 Incompatible
SiteMesh 2.4.2 + Compatible
Spring MVC 2.5.6 Compatible
Spring ORM 2.5.6 Compatible
Spring Security ? Semi-Compatible
Stripes Framework ? Compatible
Struts 1 1.2.28 Compatible
Struts 2 ? Compatible
Tapestry 5.0.18 Compatible
Tapestry 5.1 Incompatible

Tiles 2.0.7 Compatible
Vaadin ? Semi-Compatible
VRaptor 2 ? Compatible
WebORB ? Compatible
Wicket ? Semi-Compatible
ZK 3.6.2 + Compatible

CHAPTER 4 ■ SERVLET CONTAINER AND FRAMEWORKS
46
Depending on your application’s needs, you may or may not choose to use a
framework. You can certainly develop feature-rich, scalable applications for
App Engine using servlets and JSPs. We are going to take a quick peek at some
applications built using the Java Servlet standard, Swing MVC, and Adobe Flex with
GraniteDS.
Servlets and JavaServer Pages
For web applications, the Java Servlet standard is one of the major foundations of
the server stack. By default App Engine utilizes this tried-and-true standard for web
applications as well. As with most servlet containers, App Engine serves up servlets,
JSPs, static files, and other data files from the web archive (WAR) directory based
on the configuration in the deployment descriptor. Gone are the days of manually
configuring and load-balancing your servers based on traffic. A major advantage of
App Engine is that it automatically scales your application for you. Applications run
on multiple web servers simultaneously and Google automatically adjusts the server
pool based on the load.
As with most multitenant environments, App Engine runs the JVM in a secured
“sandbox” environment to isolate applications from one another for security and
service availability. The sandbox ensures that applications don’t step on one another,
hog server resources, or perform actions that they shouldn’t. These restrictions
can be great for ensuring scalability but can make you want to pull your hair out
sometimes. For instance, applications don’t have access to the local file system for

write operations, cannot spawn threads, cannot leverage JNI or other native code,
and cannot make ad hoc network connections. Most of the time it’s not an issue, but
in certain cases you’ll find yourself wanting to write to the local file system or spawn a
new thread to perform operations more efficiently.
To get started with App Engine, you’re going to build a small application
that incorporates some basic functionality. The application is a simple telesales
application that sales representatives can use to field inbound sales calls. Users will
be able to search for existing accounts or create new accounts. They can view existing
sales opportunities for the account or create new opportunities that other sales reps
can follow up on. Your application will contain a single servlet and a number of JSPs.
You’ll persist your data to Bigtable. (We’ll just skim over the functionality here, as
we’ll dig into Bigtable in detail in Chapter 7.)
Views
Starting with the views for your application, the servlet container serves a welcome
page (Figure 4-1 and Listing 4-1), a simple form that allows the user to perform a
CHAPTER 4 ■ SERVLET CONTAINER AND FRAMEWORKS
47
keyword search for existing accounts in Bigtable. Users can also choose to create a
new account for sales opportunities.

Figure 4-1. The default welcome web page
Listing 4-1. The code for index.html
<html>
<head>
<title>Google App Engine Servlet Example with Bigtable</title>
<link rel="stylesheet" type="text/css"
href="/stylesheets/styles.css"/>
</head>
<body>
<span class="title">Google App Engine Servlet Example with

Bigtable</span>
<p>Before creating a new Opportunity, ensure that the Account does
not already exist. You can also <a
href="telesales?action=accountCreate"/>create a new account</a>.</p>
<p/>
<form method="post" action="telesales">