HTML5 WebSocket 实战指南

5星 · 超过95%的资源需积分: 10 70 浏览量更新于2024-07-22 1 收藏 3.89MB PDF 举报

"《HTML5 WebSocket完全指南》是一本深入探讨WebSocket编程的书籍，适合希望构建实时Web应用程序的读者。本书旨在教你如何利用WebSocket技术创建真正的实时网络应用，揭示了WebSocket在实现双向通信中的革命性作用。" WebSocket是HTML5的一项重要特性，它解决了传统HTTP协议在实时通信上的不足，提供了全双工、低延迟的通信机制，使得Web应用能够实现类似桌面应用的即时交互体验。书中详细介绍了WebSocket API的使用方法和协议规范，涵盖了从基础概念到高级应用的各个层面。第1章“WebSocket入门”引导读者了解WebSocket的基本概念，解释为什么我们需要WebSocket以及它与Ajax、Comet等技术相比的优势。这一章将阐述WebSocket如何开启持久连接，以及它如何改变Web开发模式。第2章“WebSocket API”深入探讨了WebSocket接口的使用，包括建立连接、发送和接收数据、处理错误以及关闭连接等操作。读者将学习如何在JavaScript中集成WebSocket，并理解相关事件和方法。第3章“WebSocket协议”详细解析了WebSocket协议的工作原理，包括握手过程、帧结构和错误处理。这部分内容对于理解WebSocket通信机制至关重要。第4章和第5章分别通过XMPP和STOMP展示了WebSocket在即时通讯和聊天应用中的应用。XMPP是一种开放的即时通讯协议，而STOMP是简单文本在线消息传递协议，这两者结合WebSocket可以构建高效、灵活的聊天和消息传递系统。第6章“VNC与远程帧缓冲协议”介绍了如何使用WebSocket实现远程桌面控制，这展示了WebSocket在更复杂应用场景中的潜力。第7章“WebSocket安全”讨论了WebSocket的安全问题，如跨站脚本攻击（XSS）、跨站请求伪造（CSRF）以及如何通过TLS/SSL保护连接安全。第8章“部署考虑”提供了关于在生产环境中部署WebSocket服务的建议，涵盖了负载均衡、性能优化和故障恢复等方面。附录A“检查WebSocket流量”指导读者如何使用工具来监控和调试WebSocket通信，这对于开发者调试和优化应用非常有用。附录B“WebSocket资源”列出了相关的学习资料、库和工具，帮助读者进一步扩展对WebSocket技术的理解和应用。本书不仅适合Web开发者，也适合对实时Web应用感兴趣的任何人。通过阅读，读者将能全面掌握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

剩余199页未读，继续阅读

miaoxiaodong78

粉丝: 0
资源: 1

HTML5 WebSocket 实战指南

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

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

Apress.The.Definitive.Guide.to.HTML5.2011

Netty Definitive Guide-权威指南-II

docidn.com_oreilly-java-performance-the-definitive-guide-

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

TheDefinitiveGuideToHTML5Websocket.pdf 英文原版

HTML5 WebSocket深度解析

HTML5 WebSocket技术详解

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

最新资源

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