HTML5 WebSocket权威指南：实时Web应用构建详解

下载需积分: 10 | PDF格式 | 7.33MB | 更新于2024-07-17 | 21 浏览量 | 举报

《HTML5 WebSocket 定义指南》是一本权威的专业书籍，专为希望学习如何构建实时网络应用的读者设计。本书不仅深入讲解了HTML5的新特性WebSocket，还涵盖了WebSocket API、协议、安全性和部署策略等内容。作者通过对即时消息与聊天、STOMP协议的应用、VNC远程帧缓冲协议以及WebSocket流量分析的方法，引导读者理解如何利用WebSocket技术实现高效、实时的通信。第1章，"Introduction to HTML5 WebSocket"，为读者介绍了WebSocket的概念，旨在让那些已经在开发web应用的人明白，WebSocket是如何超越传统HTTP协议，提供全双工通信能力，从而支持真正的实时交互。这一章将为读者打下坚实的理论基础。在第2章，"The WebSocket API"，作者详细剖析了WebSocket API的结构和用法，包括创建连接、发送和接收数据、事件处理等方面，使开发者能够掌握实际操作中的关键技术。第3章深入解析WebSocket协议本身，包括握手过程、数据传输模型、错误处理等内容，这对于理解和优化WebSocket性能至关重要。第4章和第5章分别探讨了如何通过XMPP（Extensible Messaging and Presence Protocol）和STOMP（Simple Messaging Protocol）在WebSocket上实现即时通讯功能，这些是构建聊天应用和实时协作平台的重要工具。第6章展示了WebSocket在VNC（Virtual Network Computing）中的应用，通过远程帧缓冲协议，实现实时的桌面共享体验，这在远程协助或远程教育中有广泛应用。在保障网络安全方面，第7章"WebSocket Security"介绍了WebSocket的安全性问题，如加密、身份验证、防止恶意攻击等，帮助开发者构建可靠的应用环境。第8章则关注部署策略，讨论了如何在实际环境中部署WebSocket服务，包括性能优化、负载均衡、跨域访问等实用技巧。附录A提供了一种方法来分析WebSocket的通信流量，这对于理解和调试网络行为非常有用。而附录B则罗列了更多关于WebSocket的资源，便于读者进一步学习和扩展知识。《The Definitive Guide to HTML5 WebSocket》是一本实用且全面的指南，无论是初学者还是经验丰富的开发者，都能从中获益匪浅，提升构建实时Web应用的能力。

Chapter 2

The WebSocket API

This chapter introduces you to the WebSocket Application Programming Interface (API),

which you can use to control the WebSocket Protocol and create WebSocket applications.

In this chapter, we examine the building blocks of the WebSocket API, including its events,

methods, and attributes. To learn how to use the API, we write a simple client application,

connect to an existing, publicly available server (

http://websocket.org), which allows us

to send and receive messages over WebSocket. By using an existing server, we can focus

on learning about the easy-to-use API that enables you to create WebSocket applications.

We also explain step-by-step how to use the WebSocket API to power HTML5 media using

binary data. Finally, we discuss browser support and connectivity.

This chapter focuses on the client application side of WebSocket, which enables you

to extend the WebSocket Protocol to your web applications. The subsequent chapters

will describe the WebSocket Protocol itself, as well as using WebSocket within your

environment.

Overview of the WebSocket API

As we mentioned in Chapter 1, WebSocket consists of the network protocol and an API

that enable you to establish a WebSocket connection between a client application and the

server. We will discuss the protocol in greater detail in Chapter 3, but let’s first take a look

at the API.

The WebSocket API is an interface that enables applications to use the WebSocket

Protocol. By using the API with your applications, you can control a full-duplex

communication channel through which your application can send and receive messages.

The WebSocket interface is very straightforward and easy to use. To connect to a remote

host, you simply create a new WebSocket object instance and provide the new object with

a URL that represents the endpoint to which you wish to connect.

A WebSocket connection is established by upgrading from the HTTP protocol to

the WebSocket Protocol during the initial handshake between the client and the server,

over the same underlying TCP connection. Once established, WebSocket messages can

be sent back and forth between the methods defined by the WebSocket interface. In your

application code, you then use asynchronous event listeners to handle each phase of the

connection life cycle.

The WebSocket API is purely (and truly) event driven. Once the full-duplex

connection is established, when the server has data to send to the client, or if resources

that you care about change their state, it automatically sends the data or notifications.

CHAPTER 2 ■ THE WEBSOCKET API

With an event-driven API, you do not need to poll the server for the most updated

status of the targeted resource; rather, the client simply listens for desired notifications

and changes.

We will see different examples of using the WebSocket API in the subsequent

chapters when we talk about higher-level protocols, such as STOMP and XMPP. For

now, though, let’s take a closer look at the API.

Getting Started with the WebSocket API

The WebSocket API enables you to establish full-duplex, bidirectional communication

over the Web between your client application and server-side processes. The WebSocket

interface specifies the methods that are available for the client and how the client

interacts with the network.

To get started, you first create a WebSocket connection by calling the WebSocket

constructor. The constructor returns a WebSocket object instance. You can listen for

events on that object. These events tell you when the connection opens, when messages

arrive, when the connection closes, and when errors occur. You can interact with the

WebSocket instance to send messages or close the connection. The subsequent sections

explore each of these aspects of the WebSocket API.

The WebSocket Constructor

To establish a WebSocket connection to a server, you use the WebSocket interface to

instantiate a WebSocket object by pointing to a URL that represents the endpoint to which

you want to connect. The WebSocket Protocol defines two URI schemes, ws and wss for

unencrypted and encrypted traffic between the client and the server, respectively. The

ws (WebSocket) scheme is analogous to an HTTP URI scheme. The wss (WebSocket

Secure) URI scheme represents a WebSocket connection over Transport Layer Security

(TLS, also known as SSL), and uses the same security mechanism that HTTPS uses to

secure HTTP connections.

Note

■ We’ll discuss WebSocket security in depth in Chapter 7.

The WebSocket constructor takes one required argument, URL (the URL to which you

want to connect) and one optional argument, protocols (either a single protocol name

or an array of protocol names that the server must include in its response to establish the

connection). Examples of protocols you can use in the protocols argument are XMPP

(Extensible Messaging and Presence Protocol), SOAP (Simple Object Access Protocol), or

a custom protocol.

Listing 2-1 illustrates the one required argument in the WebSocket constructor,

which must be a fully qualified URL starting with the ws:// or wss:// scheme. In this

example, the fully qualified URL is ws://

www.websocket.org. If there is a syntax error in

the URL, the constructor will throw an exception.

CHAPTER 2 ■ THE WEBSOCKET API

Listing 2-1. Sample WebSocket Constructor

// Create new WebSocket connection

var ws = new WebSocket("

ws://www.websocket.org");

When connecting to a WebSocket server, you can optionally use the second

argument to list the protocols your application supports, namely for protocol negotiation.

To ensure that the client and the server are sending and receiving messages they

both understand, they must use the same protocol. The WebSocket constructor enables

you to define the protocol or protocols that your client can use to communicate with

a server. The server in turn selects the protocol to use; only one protocol can be used

between a client and a server. These protocols are used over the WebSocket Protocol. One

of the great benefits of WebSocket, as you’ll learn in Chapters 3 through 6, is the ability

to layer widely used protocols over WebSocket, which lets you do great things like take

traditional desktop applications to the Web.

Note

■ The WebSocket Protocol (RFC 6455) refers to protocols you can use with

WebSocket as “subprotocols,” even though they are higher-level, fully formed protocols.

Throughout this book, we’ll generally refer to protocols that you can use with WebSocket

simply as “protocols” to avoid confusion.

Before we get too far ahead of ourselves, let’s return to the WebSocket constructor in

the API. During the initial WebSocket connection handshake, which you’ll learn more

about in Chapter 3, the client sends a Sec-WebSocket-Protocol header with the protocol

name. The server chooses zero or one protocol and responds with a Sec-WebSocket-Protocol

header with the same name the client requested; otherwise, it closes the connection.

Protocol negotiation is useful for determining which protocol or version of a protocol

a given WebSocket server supports. An application might support multiple protocols and

use protocol negotiation to select which protocol to use with a particular server. Listing 2-2

shows the WebSocket constructor with support for a hypothetical protocol, “myProtocol”:

Listing 2-2. Sample WebSocket Constructor with Protocol Support

// Connecting to the server with one protocol called myProtocol

var ws = new WebSocket("

ws://echo.websocket.org", "myProtocol");

Note

■ In Listing 2-2, the hypothetical protocol “myProtocol” is a well-defined, perhaps

even registered and standardized, protocol name that both the client application and the

server can understand.

CHAPTER 2 ■ THE WEBSOCKET API

The WebSocket constructor can also include an array of protocol names that the

client supports, which lets the server decide which one to use. Listing 2-3 shows a sample

WebSocket constructor with a list of protocols it supports, represented as an array:

Listing 2-3. Sample WebSocket Constructor with Protocol Support

// Connecting to the server with multiple protocol choices

var echoSocket = new

WebSocket("

ws://echo.websocket.org", ["com.kaazing.echo",

"example.imaginary.protocol"])

echoSocket.onopen = function(e) {

// Check the protocol chosen by the server

console.log(echoSocket.protocol);

}

In Listing 2-3, because the WebSocket server at

ws://echo.websocket.org only

understands the com.kaazing.echo protocol and not example.imaginary.protocol, the

server chooses the com.kaazing.echo protocol when the WebSocket open event fires.

Using an array gives you flexibility in enabling your application to use different protocols

with different servers.

We’ll discuss the WebSocket Protocol in depth in the next chapter, but in essence,

there are three types of protocols you can indicate with the protocols argument:

Registered protocols: Standard protocols that have been •

officially registered according to RFC 6455

(The WebSocket Protocol) and with the IANA (Internet

Assigned Numbers Authority), the official governing body for

registered protocols. An example of a registered protocol is

Microsoft’s SOAP over WebSocket protocol. See

http://www.iana.org/assignments/websocket/websocket.xml

for more information.

Open protocols: Widely used and standardized protocols like •

XMPP and STOMP, which have not been registered as official

standard protocols. We will examine how to use these types of

protocols with WebSocket in the subsequent chapters.

Custom protocols: Protocols that you’ve written and want to use •

with WebSocket.

In this chapter, we focus on using the WebSocket API as you would for your own

custom protocol and examine using open protocols in the later chapters. Let’s take a look

at the events, objects, and methods individually and put them together into a working

example.

CHAPTER 2 ■ THE WEBSOCKET API

WebSocket Events

The WebSocket API is purely event driven. Your application code listens for events on

WebSocket objects in order to handle incoming data and changes in connection status.

The WebSocket Protocol is also event driven. Your client application does not need to poll

the server for updated data. Messages and events will arrive asynchronously as the server

sends them.

WebSocket programming follows an asynchronous programming model, which

means that as long as a WebSocket connection is open, your application simply listens

for events. Your client does not need to actively poll the server for more information. To

start listening for the events, you simply add callback functions to the WebSocket object.

Alternatively, you can use the addEventListener() DOM method to add event listeners

to your WebSocket objects.

A WebSocket object dispatches four different events:

Open •

Message •

Error •

Close •

As with all web APIs, you can listen for these events using on<eventname> handler

properties, as well as using the addEventListener(); method.

WebSocket Event: Open

Once the server responds to the WebSocket connection request, the open event fires and a

connection is established. The corresponding callback to the open event is called onopen.

Listing 2-4 illustrates how to handle the event when the WebSocket connection is

established.

Listing 2-4. Sample Open Event Handler

// Event handler for the WebSocket connection opening

ws.onopen = function(e) {

console.log("Connection open...");

};

By the time the open event fires, the protocol handshake has completed and the

WebSocket is ready to send and receive data. If your application receives an open event,

you can be sure that a WebSocket server successfully handled the connection request and

has agreed to communicate with your application.

WebSocket Event: Message

WebSocket messages contain the data from the server. You may also have heard of

WebSocket frames, which comprise WebSocket messages. We’ll discuss the concept of

messages and frames in more depth in Chapter 3. For the purposes of understanding

www.allitebooks.com

剩余199页未读，继续阅读

身份认证购VIP最低享 7 折!

30元优惠券

君子攸跻

粉丝: 1

HTML5 WebSocket权威指南：实时Web应用构建详解

The Definitive Guide to HTML5 WebSocket

TheDefinitiveGuideToHTML5Websocket.pdf 英文原版

The Definitive Guide to HTML5 WebSocket(权威指南)(免积分)

The Definitive Guide to HTML5 WebSocket 无水印原版pdf

HTML5 WebSocket权威指南 PDF电子书下载 带书签目录 高清完整版

HTML5 WebSocket权威指南深度解析

ECMAScript 5与HTML5权威指南：JavaScript完全解析（第6版）

The Definitive Guide to HTML5 无水印pdf

HTML5 WebSocket权威指南(带标签)

人脸识别_深度学习_CNN_表情分析系统_1741778057.zip

最新资源

HTML5 WebSocket权威指南 PDF电子书下载带书签目录高清完整版