Java开发指南：利用Google App Engine构建云端高可用应用

需积分: 10 75 浏览量更新于2024-07-20 收藏 5.82MB PDF 举报

《用Java编程Google App Engine》是一本由Dan Sanderson撰写的实用指南，适合中级和高级Web及移动应用开发者，指导他们如何在Google的云计算平台——Google App Engine上构建高度可扩展的Java应用程序。这本书是针对Google App Engine开发的最新版，相较于早期版本，它提供了更为全面的教育资源，无论对于初次接触的开发者还是经验丰富的技术专家，都极具价值。在第一版的基础上，此书内容经过精心更新，覆盖了App Engine的最新特性和最佳实践。书中深入探讨了如何利用Google App Engine的自动扩展功能，让应用程序能够随着流量的增长而无缝扩展，无需用户手动管理基础设施。作为Google Cloud Platform的核心组成部分，本书不仅关注技术细节，还强调了如何充分利用Google提供的强大工具和服务来构建高效、可靠的应用程序。作者以清晰的语言和实例演示，带领读者从基础入门到高级应用设计，涵盖了关键的主题，如服务架构、数据存储（包括NoSQL和Bigtable）、RESTful API设计、安全性以及与Google其他云服务的集成。此外，书中还包含了关于云计算概念、微服务架构以及现代Web开发最佳实践的讨论，帮助开发者更好地理解和应对云环境中的挑战。该书得到了业内权威人士的高度评价，如Ben Kamens，Khan Academy的首席开发者，他称赞这是一本不可或缺的资源，认为阅读完整本书将使读者成为App Engine的专家。另一位前Google App Engine技术负责人Kevin Gibbs也表示，这是关于App Engine最全面、写得最好的书籍之一，阅读后足以让读者精通该平台。《用Java编程Google App Engine》是一本不仅对现有开发者有提升作用，还能为初学者提供坚实基础的专业参考书，无论是希望通过Google App Engine实现业务增长的企业，还是个人开发者寻求技术突破，都将从中获益良多。定价适中，对于投资于云端Java应用开发的人来说，这是一本值得长期珍藏的宝典。

either shut down machines when no longer needed or leave them running in tradi‐

tional or custom configurations.

App Engine and Compute Engine take different approaches to provide different capa‐

bilities. But these technologies are already starting to blend. In early 2014, Google

announced Managed VMs, a new way to run VM-based code in an App Engine-like

way. (This feature is not fully available as I write this, but check the Google Cloud

Platform website for updates.) Overall, you’re able to adopt as much of the platform

as you need to accomplish your goals, investing in flexibility when needed, and letting

the platform’s automaticity handle the rest.

This book is being written at a turning point in App Engine’s history. Services that

were originally built for App Engine are being generalized for Cloud Platform, and

given REST APIs so you can call them from off the platform as well. App Engine

development tools are being expanded, with a new universal Cloud SDK and Cloud

Console. We’re even seeing the beginnings of new ways to develop and deploy soft‐

ware, with integrated Git-based source code revision control. As with any book about

an evolving technology, what follows is a snapshot, with an emphasis on major con‐

cepts and long-lasting topics.

The focus of this book is building web applications using App Engine and related

parts of the platform, especially Cloud Datastore. We’ll discuss services currently

exclusive to App Engine, such as those for fetching URLs and sending email. We’ll

also discuss techniques for organizing and optimizing your application, using task

queues and offline processes, and otherwise getting the most out of Google App

Engine.

Using This Book

Programming Google App Engine with Java focuses on App Engine’s Java runtime

environment. The Java runtime includes a complete Java 7 JVM capable of running

bytecode produced by the Java compiler, as well as that produced by compilers for

other languages that target the JVM. App Engine is a J2EE standard servlet container,

and includes the standard libraries and features for Java web development. You can

even deploy your apps as WAR files.

App Engine supports three other runtime environments: Python, PHP, and Go. The

Python environment provides a fast interpreter for the Python programming lan‐

guage, and is compatible with many of Python’s open source web application frame‐

works. The PHP environment runs a native PHP interpreter with the standard library

and many extensions enabled, and is capable of running many off-the-shelf PHP

applications such as WordPress and Drupal. With the Go runtime environment, App

Engine compiles your Go code on the server and executes it at native CPU speeds.

xiv | Preface

The information contained in this book was formerly presented in a single volume,

Programming Google App Engine, which also covered Python. To make it easy to find

the information you need for your language, that book has been split into language-

specific versions. You are reading the Java version. Programming Google App Engine

with Python covers the same material using the Python language, as well as Python-

specific topics.

We are considering PHP and Go versions of this book as a future endeavor. For now,

the official App Engine documentation is the best resource for using these languages

on the platform. If you’re interested in seeing versions of this book for PHP or Go, let

us know by sending email to bookquestions@oreilly.com.

The book is organized so you can jump to the subjects that are most relevant to you.

The introductory chapters provide a lay of the land, and get you working with a com‐

plete example that uses several features. Subsequent chapters are arranged by App

Engine’s various features, with a focus on efficient data storage and retrieval, commu‐

nication, and distributed computation. Project life cycle topics such as deployment

and maintenance are also covered.

Cloud Datastore is a large enough subject that it gets multiple chapters to itself. Start‐

ing with Chapter 6, datastore concepts are introduced alongside Java APIs related to

those concepts. We also dedicate a chapter to JPA (Chapter 10), a standard interface

and portability layer for accessing data storage and modeling data objects, which you

can use with Cloud Datastore.

Here’s a quick look at the chapters in this book:

Chapter 1, Introducing Google App Engine

A high-level overview of Google App Engine and its components, tools, and

major features, as well as an introduction to Google Cloud Platform as a whole.

Chapter 2, Creating an Application

An introductory tutorial in Java, including instructions on setting up a develop‐

ment environment, using template engines to build web pages, setting up

accounts and domain names, and deploying the application to App Engine. The

tutorial application demonstrates the use of several App Engine features—Google

Accounts, the datastore, and memcache—to implement a pattern common to

many web applications: storing and retrieving user preferences.

Chapter 3,

Conguring an Application

A description of how App Engine handles incoming requests, and how to config‐

ure this behavior. This introduces App Engine’s architecture, the various features

of the frontend, app servers, and static file servers. We explain how the frontend

routes requests to the app servers and the static file servers, and manages secure

connections and Google Accounts authentication and authorization. This chapter

also discusses quotas and limits, and how to raise them by setting a budget.

Preface | xv

Chapter 4, Request Handlers and Instances

A closer examination of how App Engine runs your code. App Engine routes

incoming web requests to request handlers. Request handlers run in long-lived

containers called instances. App Engine creates and destroys instances to accom‐

modate the needs of your traffic. You can make better use of your instances by

writing threadsafe code and enabling the multithreading feature. You can orga‐

nize your app’s architecture into modules, individually addressible collections of

instances each running their own code and configuration.

Chapter 5, Using Modules

Modules let you build your application as a collection of parts, where each part

has its own scaling properties and performance characteristics. This chapter

describes modules in full, including the various scaling options, configuration,

and the tools and APIs you use to maintain the modules of your app.

Chapter 6, Datastore Entities

The first of several chapters on Cloud Datastore, a scalable object data storage

system with support for local transactions and two modes of consistency guaran‐

tees (strong and eventual). This chapter introduces data entities, keys and prop‐

erties, and Java APIs for creating, updating, and deleting entities from App

Engine.

Chapter 7, Datastore Queries

An introduction to Cloud Datastore queries and indexes, and the Java APIs for

queries. This chapter describes the features of the query engine in detail, and how

each feature uses indexes. The chapter also discusses how to define and manage

indexes for your application’s queries. Advanced features like query cursors and

projection queries are also covered.

Chapter 8, Datastore Transactions

How to use transactions to keep your data consistent. Cloud Datastore uses local

transactions in a scalable environment. Your app arranges its entities in units of

transactionality known as entity groups. This chapter attempts to provide a com‐

plete explanation of how the datastore updates data, and how to design your data

and your app to best take advantage of these features.

Chapter 9, Datastore Administration

Managing and evolving your app’s datastore data. The Cloud Console, SDK tools,

and administrative APIs provide a myriad of views of your data, and information

about your data (metadata and statistics). You can access much of this informa‐

tion programmatically, so you can build your own administration panels. This

chapter also discusses how to use the Remote API, a proxy for building adminis‐

trative tools that run on your local computer but access the live services for your

app.

xvi | Preface

Chapter 10, e Java Persistence API

A brief introduction to the Java Persistence API (JPA), how its concepts translate

to the datastore, how to use it to model data schemas, and how using it makes

your application easier to port to other environments. JPA is a Java EE standard

interface. App Engine also supports another standard interface known as Java

Data Objects (JDO), although JDO is not covered in this book. This chapter cov‐

ers Java exclusively.

Chapter 11, Using Google Cloud SQL with App Engine

Google Cloud SQL provides fully managed MySQL database instances. You can

use Cloud SQL as a relational database for your App Engine applications. This

chapter walks through an example of creating a SQL instance, setting up a data‐

base, preparing a local development environment, and connecting to Cloud SQL

from App Engine. We also discuss prominent features of Cloud SQL such as

backups, and exporting and importing data. Cloud SQL complements Cloud

Datastore and Cloud Storage as a new choice for persistent storage, and is a pow‐

erful option when you need a relational database.

Chapter 12,

e Memory Cache

App Engine’s memory cache service (“memcache”), and its Java APIs. Aggressive

caching is essential for high-performance web applications.

Chapter 13, Fetching URLs and Web Resources

How to access other resources on the Internet via HTTP by using the URL Fetch

service. Java applications can call this service using a direct API as well as via Java

standard library calls.

Chapter 14, Sending and Receiving Email Messages

How to use App Engine services to send email. This chapter covers receiving

email relayed by App Engine by using request handlers. It also discusses creating

and processing messages by using tools in the API.

Chapter 15, Sending and Receiving Instant Messages with XMPP

How to use App Engine services to send instant messages to XMPP-compatible

services (such as Google Talk), and receive XMPP messages via request handlers.

This chapter discusses several major XMPP activities, including managing pres‐

ence.

Chapter 16, Task Queues and Scheduled Tasks

How to perform work outside of user requests by using task queues. Task queues

perform tasks in parallel by running your code on multiple application servers.

You control the processing rate with configuration. Tasks can also be executed on

a regular schedule with no user interaction.

Preface | xvii

剩余430页未读，继续阅读

libingchen

粉丝: 29
资源: 263

Java开发指南：利用Google App Engine构建云端高可用应用

Programming Google App Engine with Java-2015年英文原版，0积分

Programming Google App Engine with Java mobi

an introduction to network programming with java: java 7 compatible

mastering concurrency programming with java 8

learning java: an introduction to real-world programming with java (early re

easyar java

matlab java

java不用框架开发app

java driver 谷歌版本

java native

最新资源