数学建模社区-数学中国

标题: 使用Sockets [打印本页]
作者: 韩冰    时间: 2005-1-26 01:19
标题: 使用Sockets

version 1.0 by zyqsj

+ @" D* D3 e# K8 F r6 |

6 X) U' B+ Q5 s, j

# H1 C3 T! ]3 u' \' E- F

) f8 H5 p4 G6 L6 Z6 \ c2 h- H+ Y

使用sockets Socket控件让你建立一个利用TCP/IP和有关的协议与其他系统进行

; i0 X4 X% N7 ?6 g# v# b, @

通信的应用。使用Sockets,你能够读和写通过它连接的其他机器，而不用担心实

6 T! n4 U z T6 z' D, U8 I: N

际的网络软件的相关细节。Sockets提供基于TCP/IP协议的连接。除此以外还能

1 b$ |: u. f( ^

很好的工作，在其他相关的协议，例如Xerox Network System (XNS),

( S v! N' i) E1 v" D5 D

Digital's DEC net, or Novell's IPX/SPX 家族。

+ F, h9 `. t9 K

C++ Builder提供你写网络服务器或客户应用程序去读和写其他的系统。一个服

. }- ?6 ]- X; R8 f

务或客户程序通常专注于一个单一的服务如超文本传送协议（HTTP)或文件传输

& q; ~4 ]' F& f- Q0 Z& G4 s8 i6 A

协议(FTP)。使用server sockets,一个应用程序可以提供这些服务中的一个去连

/ Y4 |2 d9 s( Y: C: U

接一个希望使用服务的客户程序。Client sockets允许一个应用使用这些服务中

1 |3 d7 ?: P2 e( l Q

的一个去连接提供这个服务的服务应用。

1 q1 B/ Z0 x. D

使用sockets去写应用程序，你必须理解下面这些知识：

- v1 k) M/ }- ^ q6 t6 e; |

一、服务工具

0 w' C# p1 N$ G

当你需要写网络服务或客户应用时，Sockets提供一种接合。对于许多服务，象

& P& s, a, t# x, r6 L. U x3 e! Q

2 o' u, E7 \. N4 {

HTTP 或 FTP,第三方服务商提供这些服务已经相当有效。有些甚至随着操作系统

, s) W) c0 U- D

捆绑而来，以便不用你自己写。然而，当你想更多的控制服务的实现，如想让你

! L. N1 I* C- K; O. Q

的应用程序与网络通信更加紧密，或当没有一个服务能提供你特殊需要的服务时

! X: N7 S6 l& }' z+ n

，你可能想建立你自己的服务或客户应用。例如，工作在分布式data sets时，

" n# s, D3 c" c; r

你可能想为数据库写一层与其他系统通信的应用。想使用Sockets实现一个服务

5 u2 L- E$ ]. K- z% |

，你必须理解：

. C$ k( |+ |* o0 o( I

3 |1 Y! w) z: n3 e- R: E

1.服务协议

* B$ r# U' ]) e8 _, m. h

在你写一个网络服务或客户程序前，你必须明白你的应用将提供或使用什么服务

3 X# X- T" X4 E& r( t% m

。你的网络应用必须支持许多服务的标准协议。如果你为标准的服务例如HTTP,

2 ~. n1 L( O. ]/ e4 f4 g7 v

FTP写网络应用，或even finger or time,你必须先理解与其他系统通信所使用

3 D4 |: t5 v* `7 T

的协议。特殊服务细节你必须看提供的或使用的文档。

+ s1 x/ ?4 ~& d8 S* v

如果你的应用程序提供一个新的服务与其他系统通信，第一步是为这个服务的

0 B4 D w5 F2 C. R/ g2 ?3 k

) I8 V: ]+ G9 Z$ R$ e) r2 {

服务端和客户端设计通信协议。什么信息将发送？如何整理这些信息？如何对这

. p& w0 ~ b$ X+ U

些信息进行编码？

7 [9 d; N7 W% P" `6 P; n# V) }3 M- J

8 \& O' u% N+ n. e6 b" t

应用程序通信

' N9 x. B2 z8 {% U; q: @" Y

经常的，你的网络服务端或客户端应用程序要提供一层在网络软件和一个应用之

- y! I5 g, x1 U0 c( H

间使用的服务。例如，一个HTTP服务站点在INternet与一个Web 服务应用之间为

8 h3 I# j' S7 `8 |. @( i# E D

HTTP请求信息提供内容和应答。

' Q" b9 ]% w& p9 o2 S3 r

在你的网络应用（或客户应用）和网络软件之间Sockets 提供一个接口。你必须

' M) B/ Y8 i/ l/ I' |$ u

提供一个接口，在你的应用程序与应用间使用。你可以拷贝第三方服务商提供的

! s5 x9 H+ p7 X _5 s9 b

标准API(例如ISAPI），或你可以设计和发布你自己的API.

# @4 |3 M4 Z7 b4 S3 m. f% C; Q; i

5 P: k. F7 a0 @- Z7 L; o

2.理解服务和端口

3 n, c6 L4 z0 S4 h/ V" p' ]

许多标准服务都有关联的、指定的端口号。当 执行服务时，你可以为服务考虑

4 A/ l& q5 R9 P$ \

一个端口号。如果你实现一个标准服务， Windows socket objects 提供一些方

3 R. j0 c* e! c5 y( D* |5 a

法让你为服务寻找端口号。如果提供一个新的服务，在基于Windows 95 或 NT机

W0 [' `4 Q# \

器上，你能够在文件Services中为你的服务指定一个相关联的端口号。设置

. w, [& K7 f* r( z$ ?

Services文件的更多信息请看微软 的Windows Sockets文档。

+ ]- i+ r2 ?, d' |/ B" G

/ W9 q3 D' `+ W( B8 p( u5 p

二、Socket连接的类型

) R$ ^5 l0 k, h8 f

Socket连接可以分成三个基本的类型，它们反映了如何开始连接和本地Socket

+ Z- t% v& G& U

连接是什么。这三个类型是：

6 I! ^0 r' G3 [ b

% { N' k# }6 s* |9 u D

1.客户端连接

e$ u0 W" O" C, i

客户端连接是一个本地系统的客户端socket与一个远程系统上的服务端Socket连

) A6 A ]1 L6 ]% _, V6 \

接。客户端连接由客户端Socket开始。首先，客户端Socket必须描述它想连接到

: Y2 q5 b3 U% }+ }/ U

的服务端Socket. 接着客户端socket查找服务端socket，当找到服务器时，就要

2 i, C1 F( |2 ]9 W+ ~

求连接。服务端socket可能不能完成正确的连接。服务器sockets维持一个客户

. P5 s) v! r) [7 ^

端请求队列，在他们有时间时完成连接。当服务端socket接受客户端连接，服务

, p2 K) ]* x! C# N' c

端socket

/ I; `4 C( P7 V; R! J- s

将向它想连接的客户socket发送一个完整的描述，客户端的连接完成。

2 Z4 J" f- k- ~

1 A( y [% o! I& D, Z

2.倾听连接

4 G8 y, F( y3 y( [

服务器 socket不会去定位客户端，代替的，他们形成被动的，"半连接"状态，

2 h* e8 A# A/ C0 Y

倾听来自客户端的请求。服务器 sockets形成一个队列，存放 它们听到的连接

9 `5 S- W2 C7 Z- o8 Y. N2 o8 `

请求。这个队列记录着客户端连接请求就象他们已连接进来一样。当服务器

3 O. H! o- T9 r5 U" d; h

sockets同意客户连接请求时，它形成一个新的socket去连接客户端，因此这个

+ z. W5 t. Y4 t; E: z$ v

倾听连接能保持开放状态允许其他客户端请求。

, t# {7 Q: e8 ^8 `: w, U

- d0 W9 v3 h# R9 [0 S2 r. b g

3.服务端连接

0 \' f2 Q2 M. s! f

当倾听socket同意一个客户端请求时，服务器端socket形成一个服务器连接。当

0 R4 g/ ?, W4 W+ T6 S! C# `' a5 i

服务器端同意连接时，向客户端发送一个服务端socket描述以完成连接，当客户

9 G& n3 P; o4 I" A

端socket收到这个描述时这个连接得到确认，连接完成。一但连接到客户端的

' x: X( R3 _ _4 J+ S, Z3 D1 L d9 m! n' \

Socket完成，服务端连接就不能识别从一个客户端来的连接。末端双方有同样的

+ o" C1 E, U0 H2 j* u2 A; w

能力去接收同样的事件类型。只有倾听（listening)连接是根本不同的，它只有

: h' X! B4 g1 R# |8 \* O0 k

一个单一的末端。

/ B: X2 T2 I- Z8 H" p: j

" O3 ]3 ~7 D0 y" F+ ]

三、sockets描述

- z5 j* P1 |& s2 x; U0 j

Sockets让你的网络应用软件通过网络与其他系统进行通信。在网络连接中每个

/ d$ o2 ~2 U, d+ V1 V

socket可以看成一个终端点。它有一个指定的地址。

, P A, P# Y. x

6 B/ c6 E5 n, J8 e4 \1 p

*这个系统正在运行

7 Z4 t7 N; I: ~1 h$ g9 Q, E9 f

*它理解的接口类型

5 \ `( A; S0 e; E ^" e0 f

*用来连接的端口

5 n! h% B8 j$ a& Q% b

一个完整的socket连接描述，你必须提供sockets 在连接两端的地址。在你开始

v+ t7 [$ r) L. D" c

一个socket连接前，你必须完整的描述你想得到的连接。有些信息可以从你的应

( a0 [ i5 d7 c& P+ d' G5 D% V

用

7 r8 T9 O% v- S

软件运行的系统平台上得到。例如，你不需要描述一个客户端socket的本地IP地

* p: A: e2 K6 c6 M! @

址--这个信息可以从操作系统上获得。你必须提供你工作所依靠的socket的类型

c0 F$ @6 i6 D2 O

的信息。客户端socket必须描述他们想连接的服务器。侦听服务器sockets必须

$ W1 V# S+ u3 B6 b

描述他们提供反应的服务器的端口。一个socket 连接终端的完整描述包括两部

/ l" w2 Y6 l/ Y) o

分：

! E& I' ]& ]* ?( D4 e. X

/ L0 J/ D- L* h

1.IP地址

) Z* ]/ Z* z% x- c1 d' B- L

主机是这样一个系统，它运行着包含有socket的应用程序。你必须描述主机给

$ Q _; p+ B* X! V. t: Z" `

socket，通过给出主机的IP地址来完成这个描述。IP地址是一个有四个数字（

/ Q# ]" ^1 j) p8 y0 { O" X5 _- R

byte)值的，在标准internet点付内的字符串。

- G- x- t8 f2 M0 g) m% ?- D% u

例如123.197.1.2

7 `2 k/ P4 l" u* l

一个简单的系统可以支持多于一个的IP地址。IP地址通常难于记忆并且容易打错

8 e' b& k- v3 r) L- v

。一个可供选择的方法是使用主机名。主机名就是IP地址的别名，它就是你常看

3 `. d! B' _" }' f5 ~) @8 Q

到的统一资源定位（URLs)。它是一个字符串，包括了域名和服务。

+ \: E! C1 a u' _6 g0 j

例如 http://www.wsite.com

( f `5 T* Y; D( s* ]

许多内部网提供给主机的名字对应的系统IP地址是internetIP地址。在

. D0 A9 n1 }% \; h

windows95 和NT机器上，如果一个主机名不能用，你可以在HOSTS文件中为你的

. R3 K2 ^# I9 d

本地IP地址（这个本地IP地址应该是指你想连接的主机IP地址--zyqsj)建立一个

1 a0 p; a2 W. w3 e+ Y

进入的名字。

$ @" y b* y- R1 M7 n

关于HOSTS文件的更多信息请看WINDOWS SOCKETS的文档。

# h& r. x+ {9 ]' I( D

服务器sockets不需要指定主机。本地IP地址可以从系统中读到。如果本地系统

0 ~- S0 _% S7 b/ Z3 B w+ @

支持多于一个的IP地址，服务器sockets将同时在所有的IP地址上侦听客户端请

1 ?# R4 X$ R' v. w$ |4 S1 [4 a: @; b

求。当一个服务器socket同意一个连接，客户端提供一个远程IP地址。客户

$ ]- q3 @" h5 L* [) l

sockets必须指定远程主机通过提供主机名或者IP地址。

) H$ T5 T- w2 _ w' k( b' c

' S) k" h) Q: x1 C3 T

在主机名和IP地址间作一个选择

& U3 L7 r! C8 f+ i8 e) g2 j

许多应用软件使用一个主机名去指定一个系统。主机名容易记住和容易检查排版

! O% v& i; b4 ~7 D1 [9 }' C# n2 W, _

错误。进一步讲，服务器能改变系统或与IP地址关联的特殊的主机名。使用一个

: z2 Y; L k1 i% b

主机名，能够允许客户端通过主机名描述找到抽象的站点，即使主机使用一个新

# I" A( I9 q- u: {# Q

的IP地址。

0 R4 @, R( p( x

如果主机名是未知的，客户socket必须指定服务器系统使用的IP地址。通过给一

3 J% u5 m5 o) E" \+ n `1 x

个IP地址来指定服务器将更快。当你提供主机名时，socket在定位服务器系统前

! E' N* R6 U, j6 g

，必须搜寻与这个主机名相关的IP地址。

: z. m6 n1 q- L; i# @

8 \3 P- e' m. v- x8 |

2.端口号

$ e) | r( a4 x) O' ?* n* t( h' Q/ A

虽然IP得地址提供了足够的信息去找到socket连接中位于另一端的系统，你通常

: u- J8 G# }! ^- W

还需要指定那个系统的端口号。没有端口号，一个系统在同一时间只能进行一个

/ u9 t% v9 m' ^ C' @; }

单一的连接。端口号是唯一标识那允许一个独立系统连接到支持同时多个连接的

) g% ~4 E+ P9 t1 h2 I# l

主机，每个连接都必须指定一个端口号。

/ F" K. g: C. j; M9 i

在网络应用中，对于服务器工具来说端口号是一个数字代码。有一个习惯就是侦

1 w. A- d B. k# A7 S' Z& O

听服务连接到他们自己固定的端口号上，以便他们能找到客户端sockets.服务器

9 F- H( F0 B% P5 Z* q4 B4 _

socket监听为他们提供服务的相关端口号。当他们允许给予一个客户端socket连

) ]: q+ |& e' c

接时，他们创建一个独立的socket连接，使用不同的专用的端口号。通过这个方

h& G7 n- U0 l" q+ p) u: i

法，能持续的监听相关服务的端口号。

/ e; `) [4 z# E( l0 l

客户端socket使用一个专用的本地端口号，就不用其他的socket去寻找它们。他

: l! m. {+ t2 C( ~: h

们指定他们想连接的服务器端socket的端口号，这样他们就能找到服务器应用程

/ k% l( E \5 x

序。常常的，这个端口号是通过命名想连接的服务来间接指定的。

/ Q# ?5 O" h7 u M

g) n0 y" M; t- }5 |% X

四、使用socket控件

+ a9 b( K4 H7 M. c1 q& F7 X+ T

C++Builder提供两个socket控件，客户端sockets和服务器sockets.他们允许你

7 M ]5 o; c. P" V+ y' F' ~

的网络应用构成连接其他的机器和允许你通过这个连接来读写信息。与每个

2 w+ q4 ~2 n( E8 U3 h! O" l

socket控件相关联的是windows socket对象，它们在终端的的作用是一个实际的

) C% j4 a1 h$ L

socket连接。socket控件使用windows socket对象去封装windows socket API

1 ^& r) ~# w2 i+ I

调用，所以你的应用不用去关心连接建立的细节或管理socket信息。

- u1 i, I/ ^9 a f

如果你想利用windows socket API调用或自定义连接细节，socket控件提供了便

( @5 I/ I" P }7 h& M5 U

利，你可以使用windows socket对象的properies,events和方法。

0 w1 E8 h* I$ T5 v9 ^4 n0 Z2 v

2 v3 r# I1 n; Y5 D5 I

1.使用客户端sockets

/ h. f5 V% j% B, Y( e5 w1 N4 ^7 J: z8 G

添加一个客户端socket控件（TClientSocket)到你的form或data module 使你的

; A8 j4 J4 z& o" d' A

应用成为一个TCP/IP客户。客户sockets允许你指定你想连接的服务器socket和

4 w* N3 d" f% d' r P

你希望服务器提供的服务。一但你描述你想得到的连接，你可以使用客户

; B) u" a: v! B0 ~0 W

socket控件去完成连接服务。

( n7 F: N. U: h, c0 m: t+ W- R0 j

每个客户socket控件使用独立的客户windows socket对象(TClientWinSocket)去

9 l6 I2 c0 p3 h, q3 E' N- E, e4 T/ ?/ O

应答连接中的客户终端。使用客户sockets去：

- S1 S/ n, g& f% Q* b: Y

5 {. K/ n- C0 G& m

A.指定想得到的服务

; ^( R5 ?5 s, N0 B d+ c$ O. h

客户socket控件有一个数字properties,允许你指定想连接的服务器系统和端口

' _5 o4 y2 _9 a( k- R

。你可以通过主机名来指定服务器系统，使用Host property。

. w0 n) O& B# R7 u

如果你不知道主机名，或者你关心找到服务器的速度，你可以指定服务器系统的

, J9 \5 E8 i& s) F5 o

IP地址，通过使用 Address property。你必须指定IP地址和主机名中的一个。

- X& L/ l+ S4 B' r

, t% `) @- y7 [, `. B* C6 `* Z1 V2 b( C

5 y* I. m/ x( k$ s. K1 Y

如果你两个都指定，客户socket控件将使用主机名。除服务器系统外，你必须指

% C! [4 w* b* z& r

定你的客户socket将连接的在服务器系统上的端口。你能够直接使用Port

& Q/ z! t+ n7 c! |

property来指定服务端口号。或者直接在Service property使用想得到的服务的

: A, s& g6 v& F' O4 x3 x, i

名字。如果你指定端口号和服务名，客户socket控件将使用服务名。

^( i+ A$ s$ U/ n2 L; s

( K5 `1 B2 p2 s2 Q! k' _' [* h

B.建立连接

7 H* h& C$ ^3 K" a3 t& d

一旦你在客户socket控件中完成了设置描述你想连接的服务器的属性，你就可以

" F, a! O O6 e9 s$ D

进行连接，通过调用Open方法。如果你想你的应用启动时自动建立连接，在设计

; p2 X. \5 j0 _

时设置Active property为true，通过使用Object Inspector来设置。

' j9 C2 u. @+ o. z

2 }# ?1 U6 D3 U# N; X' N8 s& b( I

C.取得关于连接的信息

1 O7 l# |! ]$ z" u3 Y

完成连接到服务器socket后，你可以使用与你的客户socket控件相关的客户

5 N( o& p4 ^: ^$ p+ H

windows socket object去取得关于连接的信息。使用Socket property去访问

* {- g. e- I1 p7 k2 ~* E

client windows socket object。windows socket object 有一个properties,

0 r" S- |3 W5 _% x: S3 ~

它能让你确定在连接的两端客户和服务器使用的地址和端口号。

4 Q2 ]$ ^2 [1 g3 \

当使用一个windows socket API调用时，你可以使用SocketHandle property区

~; o; ?3 x9 K5 Y' g$ `1 M

获得socket连接使用的handle。你可以使用Handle property去访问windows,以

6 d( E" ?" |) H% k. G$ }& y

便接收来自socket连接的信息。AsyncStyles property决定哪种信息类型是

0 q/ M7 k( }7 f7 C

windows handle要接收的。

( d# c& e1 l# p/ ~! T3 _. }% S0 j

- _& p" L- r; W

D.关闭连接

; s$ `' v3 g; |6 {

当你完成通讯想关闭socket 连接时，你能够通过调用Close方法来关闭连接。连

) b' {' U( q6 E6 v( W; s6 |6 b6 i

接可能要由服务器端来关闭。如果是这种情况，你将收到一个OnDisconnect 事

0 l( [+ E" b( ]& Q! R" Y

件的通知。

; A2 K3 k& p2 B& @& L4 {) \, W' V

6 E4 p1 J; p8 w8 V8 m6 I

2.使用服务器sockets

& E8 t+ |& V! w0 ^

添加一个服务端socket控件（TServerSocket)到你的form或data module使你的

" t& F; U3 ?6 y) h

应用成为一个TCP/IP服务器。服务器sockets允许你指定你想提供的服务或你想

# T: n% p& Q7 L0 g/ {, j! Q8 e

用来监听客户请求时使用的端口。你可以使用服务器socket控件去监听和允许客

- g, R: A; `) b; C/ \2 n2 h% V! z

户连接请求。每个服务器socket控件使用一个单一的服务器windows socket

% v, [: C' i X/ V; u' S6 u" J" w

Object(TServerWinSocket)去应答在服务器端监听到的连接。它通常使用一个服

$ u' v/ g" h! u( o

务器客户winodws socket Object(TServerClientWinSocket)应答在服务器端每

v8 `! O/ r& P" l9 g

个活动的，连接着得到允许服务的客户socket。使用服务器sockets去：

) c. l2 p0 J: \& B# H3 M5 C; y! k! k

0 ^& M- _; d; T4 ?, R6 d, D

A.指定端口

6 a- n. P' `! x# i! g2 I! i0 p

在你的服务器socket能够监听客户请求之前，你必须指定一个端口给你的监听服

; z$ @" v5 E* v

务。你可以使用Port property来指定这个端口。如果你的服务器应用提供一个

4 x% o" X$ s6 @$ O! m, f+ Q

标准的服务，这个服务使用一个习惯使用的相关联的端口。你能够使用

" ~ k l; c$ P/ _5 p9 s* A

Service property直接指定端口号。使用Service property是一个好的主意，能

6 M1 M) ^% p- o+ U1 |" |

够减少设置端口号时的错误。如果你既指定了Port property,又指定了

' p1 W9 e- E$ e/ g9 P& f3 w

Service property,服务socket将使用服务名。

. |8 [; S/ I o1 }- @. [

0 Z+ r o. s# |

B.监听客户请求

5 V1 F" `- n- v4 u' O1 I! M) u/ @

一旦你在server socket控件上设置好你的端口号，你就能够通过在运行时通过

, ]- u) O, D) w$ _7 g+ n

调用Open方法来监听一个连接。如果你希望你的应用程序能够在启动的时候自动

6 ]. p: Z3 D4 r F

监听连接，在设计的时候通过使用Object Inspector设置Active 属性为true。

" Z2 t) v: k3 l/ i' z6 q4 N: g

3 {' d1 M! X, N% t4 B v

' L) S% y4 p: c7 K4 g

C.连接到客户端。

( v! z3 h! Z$ F3 b, |

当监听服务socket控件接收到一个客户端连接请求时他们将自动接受这个请求。

, _4 W1 e- x3 I1 N c

当你没次收到通知时，OnClientConnetc事件将发生。

: G! P! U9 F" w W

7 B+ h, a$ V9 {" S& ^8 w* V

D.取得关于连接的信息

0 f i* D$ f; o L2 Q

一但你的服务器socket打开了监听连接，你能够使用与你服务器socket控件相关

" ^5 {# ?3 H# e7 E3 k; V

联的服务器windows socket object来取得关于连接的信息。使用Socket

7 M% ~) q- A$ L2 @ K0 ^

property去访问server windows socket object.windows socket object有一个

; W) l6 c# U" Z+ N: j5 s+ S6 q& G

属性能够让你找到关于所有活动的客户socket连接这些客户socket是你通过服务

% E) J, E5 g" H7 t' y; ]: B: H

器socket控件允许连接的。使用Handle属性去存取windows通过socket连接收到

! s/ P, H, j9 K5 {& B$ O

的信息。

! ^1 l4 E4 E: `$ l/ E; V

每个活动的，连接到客户应用是通过服务、客户windows socket bject

- i- t& i' C$ H

(TServerClientWinSocket)封装的。你能够通过server windows socket

8 o' D* C& K k' u) E- k/ F

object的连接属性来访问所有的这些。这些server client windows socket

9 J9 C+ q+ v6 J0 t! S% Y

object有些属性让你能够决定哪些地址和端口号给连接的两端--客户和服务器

# {# W$ O3 u2 a4 S# _, \5 {

socket使用。当你使用windows socket API调用时，可以使用SocketHandle属性

# ^9 r: z7 `/ c' k# T1 h

去获得socket连接使用的handle。你能够使用Handle属性去访问windows从

- V, S' @% P/ \1 a! z

socket连接处得来的信息。AsyncStyles属性决定windows handle将接收哪种类

( o3 a0 F2 b) [# h

型的信息。

4 q1 \+ P$ y. r$ c9 Z9 D, P

6 k `5 @2 X+ ]4 o9 j

E.关闭连接

* }. \4 m- W2 R& n1 ?4 z/ E6 F

当你决定关闭监听连接时，调用Close方法。这将关闭所有打开着的，连接到客

* @: t1 a. U: ?7 f" Y; K' X+ A

户应用的连接，取消任何尚未同意的连接，接着关闭监听连接以便你的服务

6 C9 i6 A0 ?1 f6 U

socket控件不在接受任何新的连接。当客户端关闭他们自己独立的连接到你的

( C7 r$ @+ K f$ ^* O

server socket的连接时，你可以在OnClientDisconnect事件中得到讯息。

. w4 h- J/ J, C4 P6 \/ z

% U L6 d2 M; |/ e/ K- ?" O

五、socket事件的应答

, a- e& A! X- Z% _

当使用sockets写应用程序时，大多数工作发生在socket控件的handler事件中.

7 c2 y; I. o8 ]$ w9 q- I; L

当通过socket连接开始读或写时,OnRead和OnWrite事件在non-blocking

t: Y, j6 x8 T9 ^% D3 u

client sockets中发生从而通知sockets.同样的,服务器sockets(blocking or

: D I: }4 S5 Y- ^! {9 X$ S

non-blocking)收到OnClientRead和OnClientWrite事件.

- x7 k8 k/ x4 G* y2 s

当服务器结束一个连接时,客户scokets收到一个OnDisconnect事件.当客户端结

; T) N, m n- M; G1 w

束一个连接时,服务器socket收到一个OnClientDisconnect事件.

8 [# A9 O0 N4 g/ b8 F! J6 _

另外,客户端Sockets和服务器端socket从连接中收到一个错误信息时,都将产生

0 o5 a( G6 m8 Y. d i2 K$ n) p

有个错误事件.

+ P, _5 Q" B! _6 m

0 l4 y2 o5 U- l6 X, V w8 m

错误事件:客户sockets和服务器sockets通常会产生一个OnError事件,当他们从

1 u1 w8 `1 E% c N. d/ A! i# e

连接中收到一个错误信息的时候.你能够写一个OnError事件处理去响应这些错误

) R! a* {+ l* m8 y* F' [9 B6 w; s

信息.这个OnError事件处理提供传送关于socket试图做什么的时候这个错误发生

. u, G) ^* N3 u$ m+ |. z* }2 m

的信息,以及错误信息提供的错误代码.你可以在OnError事件处理中对这个错误

2 ]9 l2 d6 V7 G8 ^. C$ v, k

作出响应,并且把错误代码改为0,以避免socket产生一个例外.

5 f+ Q. b7 F( q$ Q, F& Q. `

2 [5 q$ b3 U k

当开始和完成发生时,socket控件通常会收到一个事件号(number of events).如

0 s: U0 t& j6 s; \6 j

果你的应用程序需要改变socket开始操作的处理过程或通过连接开始读或写操作

* a7 W" J: X9 |+ M

时,你将写事件handlers去应答这些client events和server events.

' n! g$ ?5 G* R

+ H7 p4 a0 W5 T. d# ^

A.client events

5 Q, K. ?6 T. }7 }" F3 B

当一个客户socket打开一个连接时,以下事件发生:

. F2 G. Y3 C x4 i4 c) n

1.一个OnLookup事件最先发生,它试图去定位server socket.在这里你不能改变

8 z Y) n3 ]# X$ a) e% Q

Host,Address,Port,Service属性去改变你想定位的服务器.你能够使用Socket属

6 w% Y# x- L8 l

性去访问client windows socket object,并且使用它的SocketHandle属性去调

' F; S; ~6 `: m$ A3 J0 L7 W

用windows API,以便改变socket的客户属性.例如,如果你想在客户应用软件中设

) V) C" I$ O; }0 V

置端口号,你必须在server client连接前做这件事.

6 E; h# r2 l9 P# D" f

2.windows socket设置和初始化事件通知.

% I2 _8 p' X, {5 d- E

3.当找到server socket时一个OnConnecting事件发生.在这事件中,windows

; }9 R+ D: }# \: R ]

Socket object可以利用的是通过socket属性提供关于连接的另一端的服务

8 H& X6 J* X& h" U

socket的一些信息.这是获得实际使用来连接的端口和IP地址的第一个机会,它可

0 z" V+ u2 r) U d" m; ?" J

能不同于从监听socket处同意连接时得到的端口或IP地址.

( U$ ?# u2 u( ?9 \6 A

4.服务器同意连接请求,客户端socket完成连接.

9 n" m' v) n) y r* C3 ?* R

5.当一个连接得到确定后,一个OnConnect事件发生.如果你的socket立即开始通

" a7 g$ P/ U1 n" j0 |6 X

过连接读或写,就应写一个OnConnect事件Handler去作这件事.

; x% q3 D6 `) g/ j" R$ F, M

5 s+ m( Q$ e& M0 |; I0 @

B.服务器端事件(server events)

! `/ F" t/ k6 R0 u; t: x. _

服务器socket控件通过两中方式连接:监听连接和连接到客户应用.服务器

* g1 g+ |# j0 n" S4 ^

socket收到这两个连接的所有事件.

$ ^7 n9 Y2 e7 ^7 M5 E) x$ `9 }

' _7 O0 u# m3 |

监听时事件

' H# @: H3 Z, U+ ^1 ?

当构成监听连接前,OnListen事件发生.在这个时候你能够通过socket属性获得

7 I# v Z( Z* L. r3 p

server windows socket object.你能够使用它的SocketHandle属性去改变

' A8 [ W+ w3 X" e* D4 Z! D

socket,在socket打开监听之前.例如,如果你想限定监听服务使用的IP地址,你可

x; l; w7 `1 f/ |) g8 ~5 S, N) t

以在这个OnListen事件Handler中做.

' B7 c: y: W, O( w

2 G- C; i1 V+ e" q

与客户端连接的事件

w" t6 G; E, ~, F

当一个服务器socket同意一个客户连接请求时,接下来的事件发生:

5 M4 s& y7 D# s7 f* Q

1.服务器socket产生一个OnGetSocket事件,通过windows socket handle传送给

n. U1 Y# h$ _% p

连接的另一端的socket.如果你想提供自己定义的TServerClientWinSocket of

& v2 Q, r4 \2 s+ P9 \

descendant,你可以在OnGetSocket 事件 handler中建立,将被用来替代

3 A% w& \; k3 D1 w) }

TServerClientWinSocket.

0 M% r& D9 N C' X" @3 C2 x

2.一个OnAccept事件发生,传送新的TServerClientWinSocket对象给事件句柄.这

$ Z" H% h/ ]5 N/ Y; N) j

是第一个要点,当你使用TServerClientWinSocket的属性去获得被连接中服务的

. s) ?) ^% W/ L

那端的客户的信息时.

E5 V' c( z, b8 {# E; e: Q

3.如果服务类型是stThreadBlocking,一个OnGetThread事件发生.如果你想提供

) t3 ^% o9 J9 B& _( Y9 N

自己定义的TServerClientThread子类,你可以在OnGetThread事件句柄中建立一

+ o, D' ]% `" v( |

个,它将替代TServerClientThread.

& a& x) `0 O' j/ B; S# d

4.如果服务类型是stThreadBlocking,一个ONThreadStart事件发生当这个线程

( M3 h" `' L3 O2 A

(thread)开始执行时.如果你想执行任何初始化这个线程,或调用一些windows

/ V: V( O# P8 ^& ^! q% ?; j4 f

socket API在这线程开始通过连接读和写之前,应该使用OnThreadStart事件句柄

7 {! ~& _4 x9 I2 h: w) x- `& p' u g

.

- \5 u; Z6 c/ }1 R" F

5.当客户端完成一个连接时,一个OnClientConnect事件发生.如果是

1 c6 U5 v& O @& R: ]9 r

non-blocking服务,你可能想开始通过socket连接在这端进行读或写操作.

0 m' [2 w+ H) p! \5 m0 ]

5 K6 Z$ t0 ] `, x4 l5 \

六、通过socket连接进行读和写

D8 Q5 [ U' v3 F' R* R- r0 U" v3 C

通过socket连接到其他机器的原因是想通过这些连接来读和写信息.什么信息是

. I( j5 O6 A `! M- R

你要读和写的,或者当你想读和写时是依靠哪些socket连接的相关服务的.

. A9 a4 x* \* q0 Z& ]

通过sockets进行读和写可以是异步的,所以在你的网络应用中不需要阻塞其他代

( n; h6 s, {7 Z8 M) Z

码的执行.这是调用non-blocking connection.你也同样可以通过blocking

6 z, m$ |. ~" U( o, m) c

connection,这时你的下一行代码的执行必须等到读或写操作完成.

: S( P' e q" D0 y* i# F) `

* S* p( k8 i" b- ]

A.Non-blocking连接,读和写是异步的, 所以在你的网络应用中不需要阻塞其他

' w2 m R- c; Z

代码的执行.建立一个Non-blocking连接:

) j6 e9 S7 a7 m) M! [

1.在客户socket中设置ClientType属性为ctNonBlocking.

* g1 h4 M3 ?9 E. v

2.在服务器socket中设置ServerType属性为stNonBlocking.

" l0 H7 B- w k9 k' a( o" k

当连接是non-blocking时,连接的另一端企图读或写时读和写事件将把这个信息

2 A. e$ L6 U" d0 Z% A, @

通知你的socket.

! R8 i& ]' z' M0 t/ r

( R2 X( ]- q. u9 q: M

读和写操作事件

. P7 Q, e' k3 A j+ n) X1 @( L+ H

Non-blocking sockets想通过连接读或写时,它会产生一个读和写操作事件通知

4 Q+ _8 `# [" J1 ?$ U

你的socket.在客户端sockets,你可以在OnRead或OnWrite事件句柄中对这些事件

& ]' x! U4 _3 r0 _! [

做出反应.在服务器端Scokets,可以在OnClientRead或OnClientWrite事件句柄中

- ^% W/ ?* V. F* o! R$ N

对这些事件做出反应.与socket连接相关联的windows socket object在事件句柄

1 B, T8 l. ~" W0 m+ Y; Y) k- r+ r

的读或写中被当作一个参数.Windows socket object提供一个方法号(number of

6 |4 R U# ]2 S0 }5 i, B

methods)以允许你通过连接读或写.

3 N0 c' f: B, f7 {5 |+ ~

通过socket连接读,使用ReceiveBuf或ReceiveText方法.在使用ReceiveBuf方法

" v: C/ e+ o, f' [6 P

前,使用Receivelength方法去确定在连接的另一端socket准备发送的字节数

$ s7 q% P; o4 ^' t

(number of bytes).

' l5 L) _' x! P, w* C! B

通过socket连接写,使用SendBuf,SendStream,或SendText方法.如果你通过

& F0 U! \; c$ P7 e8 V

socket发送信息后不在需要socket连接,你可以使用SendStreamThenDrop方法.

7 y4 `1 }2 n$ _7 t0 z

SendStreamThenDrop在写完所有的信息后将关闭Socket连接,它能够从stream读

; q: F" H( T$ M+ V! Q+ q; V

信息.如果你使用SendStream或SendStreamThenDrop方法,不要释放Stream

, R1 \) o6 ^) s t

object, socket在连接结束后会自动释放这个Stream.

, t- V5 ^. q% ^

注意:SendStreamThenDrop将关闭一个独立的客户连接服务,而不是监听连接.

6 v% }8 _' o, v. _' b

: H( x8 z/ Z* |

B.Blocking connections

( [. i+ ~ ]) d4 R& |7 d7 Q

当你使用的连接是Blocking时,你的Socket必须通过连接发起读或写操作,胜过被

* B: k; [8 ~% R. f

动的等待从socket连接发来的通知. 当你的连接末端的读和写操作发生改变时使

) h7 D1 o" @8 {. G3 X. V) i

用Blocking socket.对于客户端sockets,设置ClientType属性为ctBlocking 以

7 ~0 J2 b6 z- `' ~* w( J/ q

便构成一个blocing connection.根据你的客户端应用想完成什么,你可能想建立

_9 j. h) s8 b, Z$ G/ E

一个执行线程去完成读或写操作,以便你的应用能够继续执行其他的线程,当它在

: I$ l; w3 x) ]0 b

等待通过连接读或写操作的完成.

' P4 c+ u: C9 _0 Q& O; P

对于服务器sockets,设置ServerType属性为stThreadBlocking以便构成一个

' w7 b( @1 m3 i( {

blocking connection.因为blocking connections在等待通过连接读或写信息完

8 I5 {- b2 z3 w; O3 j+ I6 v$ S

成时挂起了其他代码的执行,服务器socket控件通常产生一个新的执行线程给每

; Z0 n" ^+ k' ~ Z

一个客户连接,当ServerType设置为stThreadBlocking时.许多使用Blocking连接

3 J& i* w: m7 w! P* }

的应用都写使用线程(using threads.甚至如果你不使用线程,你可能也想使用

1 f( C1 l5 A$ `' R) W

(using) TWinSocketStream去读和写.

: ]3 A: \$ Z$ S; d7 L$ t. I

1)using threads

! R; a4 u/ E% h! m

当使用一个blocking connection进行读或写操作时,客户sockets不会自动产生

( P4 x V8 i5 a! s( ]

一个新线程.如果你的客户应用程序没有什么事做,直到读或写信息完成,那么这

$ o/ Z7 G1 ^- f( c2 r, V

正是你想要的.如果你的应用包括了一个用户界面,它还需要响应用户的操作,那

( {4 j0 A5 c- a4 O2 t

么,你可能想产生一个独立的线程去读写.当服务器sockets形成一个blocking连

. ?5 ]: W1 P9 d/ U: V7 x h h1 i

接时,他们常常产生独立的线程给每一个客户连接,所以没有客户需要等待直到其

( K4 O) u5 G8 O, N

他客户完成通过连接读或写操作.在默认情况下,服务器sockets使用

/ j" V1 r1 Y. D. W y

TServerClientThread对象去实现为每个连接执行不同的线程.

3 ~, K7 }* b0 R

TServerClientThread对象模拟发生在non-blocking连接中的OnClientRead和

4 c9 L' e( q+ N$ b r9 ]

OnClientWrite事件.可是,这些事件发生在监听socket上时,不是本地线程

: E7 b8 r- y0 @, J& U" g- g

(thread-local).如果客户请求频繁,你将想建立你自己的TServerClientThread

. @: ]' }7 N% x' l2 G ]; I

子类去提供一个安全线程(Thread-Safe)去完成读和写操作.

$ e( b- G% D' s0 h

当写客户线程或写服务器线程时,你能够使用TwinSocketStream去做实际的读写

# K' `( v/ x5 Y2 x/ M; e

操作.

/ q+ e7 z {5 @) C" l

A)写客户端线程

+ x% z5 M5 e, q4 @ N

为客户端连接写一个线程,定义一个新线程对象,使用新线程对象对话框.你的新

2 B+ r; u D% b. H& l) v

线程对象Execute方法的句柄的通过线程连接进行读写操作的细节,可以建立一个

) I$ ]8 Y9 h. [' x8 b" W! r

TWinSocketStream对象,然后使用它来读或写.

* r+ E# K+ r- m: q0 d- j/ X

使用你自己的线程,在OnConnect事件句柄中建立它.关于建立和运行线程的更多

+ U) Z: T a, a1 B7 a3 O ^# P

信息,请看Executing thread objects.

+ Q* a; h- s6 Q# w( J9 b! d* v

例子:这个例子显示一个应用的客户线程在连接确定后向服务器发出写请求.

' T! H: ~* E. B- w. M4 K! V

void __fastcall TMyClientThread::Execute()

# F5 y& V5 R7 c% c0 S8 x

{

4 [1 Q4 L* [, i- U; C) R

while (!Terminated && ClientSocket1->Active)

$ ~' |; e0 B; i8 F. z) g) I# w8 O

// make sure connection is active

" }( n0 ]2 J( T# P9 K

{

! ^- A+ t! S5 x9 }+ q) a

try

5 E( m1 p/ ~" U: |# Q/ f4 l7 G8 t

{

1 `1 X, w4 s4 ?1 Y+ W

TWinSocketStream *pStream = new TWinSocketStream(ClientSocket1.

: X' V1 M2 N f3 |! q/ f5 x

Socket,60000);

7 A! N7 u! F& g- ]7 G6 i3 z+ r+ t

try

5 e8 D7 Q: w* v. e2 \; _( c% f" T

{

& W' \$ o0 F8 r& K% j

char buffer[10];

0 L0 M3 w: z7 |6 B0 g

GetNextRequest(buffer);

/ n8 V1 _# y% w! s/ S. I

// GetNextRequest must be a thread-safe method

; k: ^2 x! }9 D

// write a request to the server

/ J1 x* P; g3 a4 }; H9 m$ B F

pStream->Write(buffer,strlen(buffer) + 1);

) o6 k$ \) a" Y( C0 s: s

// continue the communication (eg read a response)

- b X: B( h( n+ [0 K! U* ~

# V$ C6 T2 R/ R

}

) [* t1 s( Z; j3 r! A$ @( r

__finally

S) W ?( q+ q

: y2 B" n6 S& H; H5 j3 K

{

$ f4 {" E; f+ ^

delete pStream;

& t% S) i9 Y/ j6 K. v, S

}

6 l% s1 e5 K$ x1 l* X7 ?' {

}

- a6 l8 ?. L' q) Z, {4 f3 L

catch (Exception &E)

# J& c }( l- y9 {! g

{

) \4 \$ O$ z5 L4 v

if (!E.ClassNameIs("EAbort"))

9 ^* ]3 J5 l8 |$ p' ~) j" k& A! t

Synchronize(HandleThreadException());

0 X2 y3 w) {' |1 i8 _$ I* x

// you must write HandleThreadException

8 x8 b4 b0 @* W0 x! D! Z" w

}

; M6 Y% g4 |5 j+ s1 w

}

U2 q* \0 Q6 a

}

& f0 y) i! }9 ?- u& [

0 q }: a# M6 i6 b

B)写服务器线程

. v8 E/ \5 Z3 V

服务器连接线程由TServerClientThread派生.因为这个,不能使用新线程对象对

& P" a; f* k. {( S

话框.替代的,手动声明你的线程如下:

' |9 v! x) T1 I' @7 v

) `/ j( L4 U# P: b" H& [: L' ~/ ^

class PACKAGE TMyServerThread :

+ B j8 T; N D7 @

public ScktComp::TServerClientThread

! R% P9 r4 p& k6 w$ b/ q, |& F

{

; w! e' F$ r1 Z# W8 t- U! ~

public

1 H( z0 i# q5 Q* \% Y5 q

void __fastcall ClientExecute(void);

5 `$ G5 }9 b3 A( o, M; S) [, e

}

) Q; ?$ j7 ~7 Y6 w3 d1 c( b

! E3 d2 c# p% {* l8 {2 V$ Z ~4 A; E+ w

注意你将用重载ClientExcute方法替代Execute方法.执行ClientExecute方法必

9 }+ _/ m& j. D7 c% x0 K/ z9 L8 ]; t5 i, ~

须为客户端连接写一个同样的Execute方法线程.然而,当你从控件栏上放一个客

) v2 X; H7 K5 i. p% o E

户socket控件到你的应用上时来替代这个方法时.监听服务socket同意一个连接

) `$ `$ E5 W$ Z$ e9 H [6 f/ h

时,服务客户线程必须使用TServerClientWinSocket对象来建立.这可以利用共公

5 O% T4 e6 Z: b6 Q4 y4 K

共的CientSocket属性.另外,你能够使用HandleException这个protected性的方

$ n" K8 d) o- Q

法,胜过

8 ^- g4 D! c: `8 H( B: h1 R. M, Q" j

你自己写你的thread-safe例外操作.

8 K. \( w6 Y, M$ B6 b* X6 e3 ~

3 [3 [0 ^0 {$ d, ]$ {' x3 e

警告:Server sockets会缓存他们使用到的线程.确信ClientExecute方法执行一

4 ?" X1 t. {3 s

些必要的初始化操作,以便它们在最后执行时不致于产生不利的结果.

1 _9 b) u1 o0 P

! R, j3 c& u" O1 k- Q

当你使用你的线程时,在OnGetThread事件句柄中建立它.当建立线程,设置

9 B9 G5 G" s* g( |1 s0 z) ]

CreateSuspended参数为false.

% J4 w w! |% x) k: y! s- l

例子:这个例子显示一个为一个应用服务的线程,这个应用是在连接确定后由客户

$ r/ t# @7 b0 Z+ I2 I7 Y7 }! T& s& V

端来的读请求.

5 y7 q x$ i; L% `- c- j

- }+ T- `# F: b# B) X

void __fastcall TMyServerThread::ClientExecute()

! {9 ?# H& y V+ H

{

( D4 V# R! R0 s% c7 N

while (!Terminated && ClientSocket->Connected)

9 t, j( z# g5 u9 }/ o& L; ]: J; Y9 q3 b! C

// make sure connection is active

/ A+ w6 g* }( |$ S a6 [/ i

{

) o- T' `/ b) C8 Y) x6 E

try

3 Z! f7 c7 \& {2 m8 n0 a

{

) V' T* o, Z! h, y* V [

TWinSocketStream *pStream = new TWinSocketStream(ClientSocket,

. Y: K' T) F- ~9 l

60000);

5 S) A3 B- r2 W; [

try

( B& {* i. Q7 v+ \7 D5 O

{

0 p5 ^/ y& }! v# t9 b) b* `

char buffer[10];

! Y# `- Y. P P: B

memset(buffer, 0, sizeof(buffer));

* n2 _* m; E( v% }; O

if (pStream->WaitForData(60000))

4 }% h0 g% i( N! X. r* V2 C

// give the client 60 seconds to start writing

! g" K- R& H/ K0 k8 M

{

) |, I7 S! Y6 y

if (pStream->Read(buffer, sizeof(buffer) == 0)

4 k: r3 ~* W3 n, {$ @

( \$ B1 C5 G' u3 W3 A% Y

ClientSocket->Close();

+ G9 [5 [1 a, V7 f

// if can't read in 60 seconds, close the connection

' n; {# i8 y7 P+ B2 B

// now process the request

9 `# p2 w% y ]7 n

}

4 v) f) n' D# }+ r1 Y

else

" P- h s- x/ Z) u1 G' N4 K" k# c

ClientSocket->Close();

2 [" c9 o4 G) ^' a

}

3 z7 `6 I0 n- m" v- f+ s1 \

__finally

$ c! m8 ^. e% ~, q+ Y

: h6 S+ C+ n" a. l: K

{

e1 ~1 p8 C* q: [1 o% X

delete pStream;

( g8 }' f) ^, I/ S! I% ?1 W

}

+ \, D8 ^: Q3 o! I

}

% m1 P: B* ]! z! ]

catch (...)

7 d( z. C1 T6 i! u! i5 e) f/ z

{

) u6 V9 `& o* Q: ~" `

HandleException();

( N+ V- ^+ a0 w+ H

}

2 N2 x5 V; B) N9 [0 R L; I

}

$ A$ S, n9 `- t# g5 q; v- U

}

3 S! a' u0 l' k6 Y0 M

* H4 r. M$ c5 t X" [

C.使用TwinSocketStream

( Q$ }5 B# v2 t3 L$ H

当为一个blocking连接实现一个线程时,你必须确定在连接的另一端的socket是

" l# Y2 o8 v& ]; `

准备写还是读.Blocking连接不会通知socket当它准备好写或读操作的时候.想看

* `( f2 X4 y3 r, b7 {- H W. Y. e

看连接是否准备好,使用TWinSocketStream对象.TWinSocketStream提供一个方法

( T) a2 j* ?5 g3 e

去帮助调整读或写操作时间的选择.调用WaitForData方法去等待,直到socket另

/ }$ q4 k* N4 [* H% z( x* ^, G

一端的

7 s' {6 }4 S- c; q

准备好写操作.当读写操作使用TWinSocketStream时,如果读或写操作在指定的时

0 U7 z8 \( u/ {0 L

间期限内未能完成,Stream将发生超时.这个超时被当作一个结果,socket应用不

$ ?( e4 W3 H0 L7 l d0 q. N; g

会暂停,而是不断的通过一个dropped connection试图读或写.

v3 z' \5 F3 G

: Y- n& s$ _) U; \ ?! S

注意:你不能在non-blocking连接中使用TWinSocketStream





欢迎光临 数学建模社区-数学中国 (http://www.madio.net/) Powered by Discuz! X2.5