javasocket编程

或许有点长

但是一步步教你

我想你也愿意看

7.2面向套接字编程

我们已经通过了解Socket的接口，知其所以然，下面我们就将通过具体的案例，来熟悉Socket

的具体工作方式

7.2.1使用套接字实现基于TCP协议的服务器和客户机程序

依据TCP协议，在C/S架构的通讯过程中，客户端和服务器的Socket动作如下：

客户端：

1.用服务器的IP地址和端口号实例化Socket对象。

2.调用connect方法，连接到服务器上。

3.将发送到服务器的IO流填充到IO对象里，比如BufferedReader/PrintWriter。

4.利用Socket提供的getInputStream和getOutputStream方法，通过IO流对象，向服务器发

送数据流。

5.通讯完成后，关闭打开的IO对象和Socket。

服务器：

1.在服务器，用一个端口来实例化一个ServerSocket对象。此时，服务器就可以这个端口

时刻监听从客户端发来的连接请求。

2.调用ServerSocket的accept方法，开始监听连接从端口上发来的连接请求。

3.利用accept方法返回的客户端的Socket对象，进行读写IO的操作

通讯完成后，关闭打开的流和Socket对象。

7.2.1.1开发客户端代码

根据上面描述的通讯流程，我们可以按如下的步骤设计服务器端的代码。

第一步，依次点击Eclipse环境里的“文件”|“新建”|“项目”选项，进入“新建项目”

的向导对话框，在其中选中“Java项目”，点击“下一步”按钮，在随后弹出的对话框里，

在其中的“项目名”一栏里，输入项目名“TCPSocket”，其它的选项目

选择系统默认值，再按“完成”按钮，结束创建Java项目的动作。

第二步，完成创建项目后，选中集成开发环境左侧的项目名“TCPSocket”，点击右键，

在随后弹出的菜单里依次选择“新建”!“类”的选项，创建服务器类的代码。

在随后弹出的“新建Java类”的对话框里，输入包名“tcp”，输入文件名“ServerCode”，

请注意大小写，在“修饰符”里选中“公用”，在“想要创建哪些方法存根”下，选中“public

staticvoidmain(String[]args)”单选框，同时把其它两项目取消掉，再按“完成”按钮，可

以生成代码。

第三步，在生成的代码里，编写引入Java包的代码，只有当我们引入这些包后，我们

才能调用这些包里提供的IO和Socket类的方法。

packagetcp;

edReader;

edWriter;

ption;

treamReader;

StreamWriter;

riter;

Socket;

;

第四步，编写服务器端的主体代码，如下所示。

publicclassServerCode

{

//设置端口号

publicstaticintportNo=3333;

publicstaticvoidmain(String[]args)throwsIOException

{

ServerSockets=newServerSocket(portNo);

n("TheServerisstart:"+s);

//阻塞,直到有客户端连接

Socketsocket=();

try

{

n("AccepttheClient:"+socket);

//设置IO句柄

BufferedReaderin=newBufferedReader(newInputStreamReader(socket

.getInputStream()));

PrintWriterout=newPrintWriter(newBufferedWriter(

newOutputStreamWriter(putStream())),true);

while(true)

{

Stringstr=ne();

if(("byebye"))

{

break;

}

n("InServerreveivedtheinfo:"+str);

n(str);

}

}

finally

{

n("closetheServersocketandtheio.");

();

();

}

}

}

这段代码的主要业务逻辑是：

1.在上述代码里的main函数前，我们设置了通讯所用到的端口号，为3333。

2.在main函数里，根据给定3333端口号，初始化一个ServerSocket对象s，该对

象用来承担服务器端监听连接和提供通讯服务的功能。

3.调用ServerSocket对象的accept方法，监听从客户端的连接请求。当完成调用

accept方法后，整段服务器端代码将回阻塞在这里，直到客户端发来connect请求。

4.当客户端发来connect请求，或是通过构造函数直接把客户端的Socket对象连

接到服务器端后，阻塞于此的代码将会继续运行。此时服务器端将会根据accept方法的执

行结果，用一个Socket对象来描述客户端的连接句柄。

5.创建两个名为in和out的对象，用来传输和接收通讯时的数据流。

6.创建一个while(true)的死循环，在这个循环里，通过ne()方法，读取从

客户端发送来的IO流（字符串），并打印出来。如果读到的字符串是“byebye”，那么退出

while循环。

7.在try…catch…finally语句段里，不论在try语句段里是否发生异常，并且不论

这些异常的种类，finally从句都将会被执行到。在finally从句里，将关闭描述客户端的连接

句柄socket对象和ServerSocket类型的s对象。

7.2.1.2开发客户端代码

我们可以按以下的步骤，开发客户端的代码。

第一，在TCPSocket项目下的tcp包下，创建一个名为的文件。在其中编写

引入Java包的代码，如下所示：

packagetcp;

edReader;

edWriter;

ption;

treamReader;

StreamWriter;

riter;

dress;

;

第二，编写客户端的主体代码，如下所示：

publicclassClientCode

{

staticStringclientName="Mike";

//端口号

publicstaticintportNo=3333;

publicstaticvoidmain(String[]args)throwsIOException

{

//设置连接地址类,连接本地

InetAddressaddr=ame("localhost");

//要对应服务器端的3333端口号

Socketsocket=newSocket(addr,portNo);

try

{

n("socket="+socket);

//设置IO句柄

BufferedReaderin=newBufferedReader(newInputStreamReader(socket

.getInputStream()));

PrintWriteout=newPrintWriter(BufferedWriter(new

OutputStreamWriter(putStream())),true);

n("HelloServer,Iam"+clientName);

Stringstr=ne();

n(str);

n("byebye");

}

finally

{

n("closetheClientsocketandtheio.");

();

}

}

}

上述客户端代码的主要业务逻辑是：

1.同样定义了通讯端口号，这里给出的端口号必须要和服务器端的一致。

2.在main函数里，根据地址信息“localhost”，创建一个InetAddress类型的对象

addr。这里，因为我们把客户端和服务器端的代码都放在本机运行，所以同样可以用

“127.0.0.1”字符串，来创建InetAddress对象。

3.根据addr和端口号信息，创建一个Socket类型对象，该对象用来同服务器端的

ServerSocket类型对象交互，共同完成C/S通讯流程。

4.同样地创建in和out两类IO句柄，用来向服务器端发送和接收数据流。

5.通过out对象，向服务器端发送"HelloServer,Iam…"的字符串。发送后，同样

可以用in句柄，接收从服务器端的消息。

6.利用out对象，发送”byebye”字符串，用以告之服务器端，本次通讯结束。

7.在finally从句里，关闭Socket对象，断开同服务器端的连接。

7.2.1.3运行效果演示

在上述两部分里，我们分别讲述了C/S通讯过程中服务器端和客户端代码的业务逻辑，下面

我们将在集成开发环境里，演示这里通讯流程。

第一步，选中代码，在eclipse的“运行”菜单里，选中“运行方式”|“1Java

应用程序”的菜单，开启服务器端的程序。

开启服务端程序后，会在eclipse环境下方的控制台里显示如下的内容：

TheServerisstart:ServerSocket[addr=0.0.0.0/0.0.0.0,port=0,localport=3333]

在这里，由于ServerSocket对象并没监听到客户端的请求，所以addr和后面的port值都是

初始值。

第二步，按同样的方法，打开程序，启动客户端。启动以后，将在客户端的

控制台里看到如下的信息：

socket=Socket[addr=localhost/127.0.0.1,port=3333,localport=1326]

HelloServer,IamMike

closetheClientsocketandtheio.

从中可以看到，在第一行里，显示客户端Socket对象连接的IP地址和端口号，在第二行里，

可以到到客户端向服务器端发送的字符串，而在第三行里，可以看到通讯结束后，客户端关

闭连接Socket和IO对象的提示语句。

第三步，在eclipse下方的控制台里，切换到ServerCode服务端的控制台提示信息里，我们

可以看到服务器端在接收到客户端连接请求后的响应信息。

响应的信息如下所示：

TheServerisstart:ServerSocket[addr=0.0.0.0/0.0.0.0,port=0,localport=3333]

AccepttheClient:Socket[addr=/127.0.0.1,port=1327,localport=3333]

InServerreveivedtheinfo:HelloServer,IamMike

closetheServersocketandtheio.

其中，第一行是启动服务器程序后显示的信息。在第二行里，显示从客户端发送的连接请求

的各项参数。在第三行里，显示了从客户端发送过来的字符串。在第四行里，显示了关闭服

务器端ServerSocket和IO对象的提示信息。从中我们可以看出在服务器端里accept阻塞和

继续运行的这个过程。

通过上述的操作，我们可以详细地观察到C/S通讯的全部流程，请大家务必要注意：一定要

先开启服务器端的程序再开启客户端，如果这个步骤做反的话，客户端程序会应找不到服务

器端而报异常。

7.2.2使用套接字连接多个客户机

在7.1的代码里，客户端和服务器之间只有一个通讯线程，所以它们之间只有一条Socket

信道。

如果我们在通过程序里引入多线程的机制，可让一个服务器端同时监听并接收多个客户端的

请求，并同步地为它们提供通讯服务。

基于多线程的通讯方式，将大大地提高服务器端的利用效率，并能使服务器端能具备完善的

服务功能。

7.2.2.1开发客户端代码

我们可以按以下的步骤开发基于多线程的服务器端的代码。

第一步，在3.2里创建的“TCPSocket”项目里，新建一个名为的代码文

件，创建文件的方式大家可以参照3.2部分的描述。首先编写package和import部分的代码，

用来打包和引入包文件，如下所示：

packagetcp;

.*;

.*;

第二步，由于我们在服务器端引入线程机制，所以我们要编写线程代码的主体执行类

ServerThreadCode，这个类的代码如下所示：

classServerThreadCodeextendsThread

{

//客户端的socket

privateSocketclientSocket;

//IO句柄

privateBufferedReadersin;

privatePrintWritersout;

//默认的构造函数

publicServerThreadCode()

{}

publicServerThreadCode(Sockets)throwsIOException

{

clientSocket=s;

//初始化sin和sout的句柄

sin=newBufferedReader(newInputStreamReader(clientSocket

.getInputStream()));

sout=newPrintWriter(newBufferedWriter(newOutputStreamWriter(

putStream())),true);

//开启线程

start();

}

//线程执行的主体函数

publicvoidrun()

{

try

{

//用循环来监听通讯内容

for(;;)

{

Stringstr=ne();

//如果接收到的是byebye，退出本次通讯

if(("byebye"))

{

break;

}

n("InServerreveivedtheinfo:"+str);

n(str);

}

n("closingtheserversocket!");

}

catch(IOExceptione)

{

tackTrace();

}

finally

{

n("closetheServersocketandtheio.");

try

{

();

}

catch(IOExceptione)

{

tackTrace();

}

}

}

}

这个类的业务逻辑说明如下：

1.这个类通过继承Thread类来实现线程的功能，也就是说，在其中的run方法里，

定义了该线程启动后要执行的业务动作。

2.这个类提供了两种类型的重载函数。在参数类型为Socket的构造函数里，通过

参数，初始化了本类里的Socket对象，同时实例化了两类IO对象。在此基础上，通过start

方法，启动定义在run方法内的本线程的业务逻辑。

3.在定义线程主体动作的run方法里，通过一个for(;;)类型的循环，根据IO句柄，

读取从Socket信道上传输过来的客户端发送的通讯信息。如果得到的信息为“byebye”，则

表明本次通讯结束，退出for循环。

从句将处理在try语句里遇到的IO错误等异常，而在finally从句里，将在

通讯结束后关闭客户端的Socket句柄。

上述的线程主体代码将会在ThreadServer类里被调用。

第三步，编写服务器端的主体类ThreadServer，代码如下所示：

publicclassThreadServer

{

//端口号

staticfinalintportNo=3333;

publicstaticvoidmain(String[]args)throwsIOException

{

//服务器端的socket

ServerSockets=newServerSocket(portNo);

n("TheServerisstart:"+s);

try

{

for(;;)

{

//阻塞,直到有客户端连接

Socketsocket=();

//通过构造函数，启动线程

newServerThreadCode(socket);

}

}

finally

{

();

}

}

}

这段代码的主要业务逻辑说明如下：

1.首先定义了通讯所用的端口号，为3333。

2.在main函数里，根据端口号，创建一个ServerSocket类型的服务器端的Socket，

用来同客户端通讯。

3.在for(;;)的循环里，调用accept方法，监听从客户端请求过来的socket，请注意

这里又是一个阻塞。当客户端有请求过来时，将通过ServerThreadCode的构造函数，创建一

个线程类，用来接收客户端发送来的字符串。在这里我们可以再一次观察ServerThreadCode

类，在其中，这个类通过构造函数里的start方法，开启run方法，而在run方法里，是通过

sin对象来接收字符串，通过sout对象来输出。

4.在finally从句里，关闭服务器端的Socket，从而结束本次通讯。

7.2.2.2开发客户端代码

我们可以按以下的步骤，编写的基于多线程的客户端代码。

第一步，在“TCPSocket”项目里，新建一个名为的代码文件。同样是编

写package和import部分的代码，用来打包和引入包文件，如下所示：

packagetcp;

.*;

.*;

第二步，编写线程执行主体的ClientThreadCode类，同样，这个类通过继承Thread来实现

线程的功能。

classClientThreadCodeextendsThread

{

//客户端的socket

privateSocketsocket;

//线程统计数，用来给线程编号

privatestaticintcnt=0;

privateintclientId=cnt++;

privateBufferedReaderin;

privatePrintWriterout;

//构造函数

publicClientThreadCode(InetAddressaddr)

{

try

{

socket=newSocket(addr,3333);

}

catch(IOExceptione)

{

tackTrace();

}

//实例化IO对象

try

{

in=newBufferedReader(

newInputStreamReader(utStream()));

out=newPrintWriter(

newBufferedWriter(newOutputStreamWriter(putStream())),

true);

//开启线程

start();

}

catch(IOExceptione)

{

//出现异常，关闭socket

try

{

();

}

catch(IOExceptione2)

{

tackTrace();

}

}

}

//线程主体方法

publicvoidrun()

{

try

{

n("HelloServer,Myidis"+clientId);

Stringstr=ne();

n(str);

n("byebye");

}

catch(IOExceptione)

{

tackTrace();

}

finally

{

try

{

();

}

catch(IOExceptione)

{

tackTrace();

}

}

}

}

这个类的主要业务逻辑是：

1.在构造函数里，通过参数类型为InetAddress类型参数和3333，初始化了本类

里的Socket对象，随后实例化了两类IO对象，并通过start方法，启动定义在run方法内的

本线程的业务逻辑。

2.在定义线程主体动作的run方法里，通过IO句柄，向Socket信道上传输本客户

端的ID号，发送完毕后，传输”byebye”字符串，向服务器端表示本线程的通讯结束。

3.同样地，catch从句将处理在try语句里遇到的IO错误等异常，而在finally从句

里，将在通讯结束后关闭客户端的Socket句柄。

第三步，编写客户端的主体代码，在这段代码里，将通过for循环，根据指定的待创建的线

程数量，通过ClientThreadCode的构造函数，创建若干个客户端线程，同步地和服务器端通

讯。

publicclassThreadClient

{

publicstaticvoidmain(String[]args)

throwsIOException,InterruptedException

{

intthreadNo=0;

InetAddressaddr=

ame("localhost");

for(threadNo=0;threadNo<3;threadNo++)

{

newClientThreadCode(addr);

}

}

}

这段代码执行以后，在客户端将会有3个通讯线程，每个线程首先将先向服务器端发送"Hello

Server,Myidis"的字符串，然后发送”byebye”，终止该线程的通讯。

7.2.2.3运行效果演示

接下来，我们来观察一下基于多线程的C/S架构的运行效果。

第一步，我们先要启动服务器端的ThreadServer代码，启动后，在控制台里会出现如下的提

示信息：

TheServerisstart:ServerSocket[addr=0.0.0.0/0.0.0.0,port=0,localport=3333]

上述的提示信息里，我们同样可以看到，服务器在开启服务后，会阻塞在accept这里，直

到有客户端请求过来。

第二步，我们在启动完服务器后，运行客户端的代码，运行后，我们观察

服务器端的控制台，会出现如下的信息：

TheServerisstart:ServerSocket[addr=0.0.0.0/0.0.0.0,port=0,localport=3333]

InServerreveivedtheinfo:HelloServer,Myidis0

InServerreveivedtheinfo:HelloServer,Myidis1

InServerreveivedtheinfo:HelloServer,Myidis2

closingtheserversocket!

closetheServersocketandtheio.

closingtheserversocket!

closetheServersocketandtheio.

closingtheserversocket!

closetheServersocketandtheio.

其中，第一行是原来就有，在后面的几行里，首先将会输出了从客户端过来的线程请求信息，

比如

InServerreveivedtheinfo:HelloServer,Myidis0

接下来则会显示关闭Server端的IO和Socket的提示信息。

这里，请大家注意，由于线程运行的不确定性，从第二行开始的打印输出语句的次序是不确

定的。但是，不论输出语句的次序如何变化，我们都可以从中看到，客户端有三个线程请求

过来，并且，服务器端在处理完请求后，会关闭Socker和IO。

第三步，当我们运行完的代码后，并切换到的控制台，

我们可以看到如下的输出：

HelloServer,Myidis0

HelloServer,Myidis2

HelloServer,Myidis1

这说明在客户端开启了3个线程，并利用这3个线程，向服务器端发送字符串。

而在服务器端，用accept方法分别监听到了这3个线程，并与之对应地也开了3个线程与

之通讯。

7.2.3UDP协议与传输数据报文

UDP协议一般应用在“群发信息”的场合，所以它更可以利用多线程的机制，实现多信息

的同步发送。

为了改善代码的架构，我们更可以把一些业务逻辑的动作抽象成方法，并封装成类，这样，

基于UDP功能的类就可以在其它应用项目里被轻易地重用。

7.2.3.1开发客户端代码

如果我们把客户端的所有代码都写在一个文件中，那么代码的功能很有可能都聚集在一个方

法力，代码的可维护性将会变得很差。

所以我们专门设计了ClientBean类，在其中封装了客户端通讯的一些功能方法，在此基础上，

通过文件，实现UDP客户端的功能。

另外，在这里以及以后的代码里，我们不再详细讲述用Eclipse开发和运行Java程序的方法，

而是重点讲述Java代码的业务逻辑和主要工作流程。

首先，我们可以按如下的步骤，设计ClientBean这个类。通过import语句，引入所用到的

类库，代码如下所示。

ption;

amPacket;

amSocket;

dress;

Exception;

nHostException;

第二，定义ClientBean所用到的变量，并给出针对这些变量操作的get和set类型的方法，

代码如下所示。

//描述UDP通讯的DatagramSocket对象

privateDatagramSocketds;

//用来封装通讯字符串

privatebytebuffer[];

//客户端的端口号

privateintclientport;

//服务器端的端口号

privateintserverport;

//通讯内容

privateStringcontent;

//描述通讯地址

privateInetAddressia;

//以下是各属性的Get和Set类型方法

publicbyte[]getBuffer()

{

returnbuffer;

}

publicvoidsetBuffer(byte[]buffer)

{

=buffer;

}

publicintgetClientport()

{

returnclientport;

}

publicvoidsetClientport(intclientport)

{

port=clientport;

}

publicStringgetContent()

{

returncontent;

}

publicvoidsetContent(Stringcontent)

{

t=content;

}

publicDatagramSocketgetDs()

{

returnds;

}

publicvoidsetDs(DatagramSocketds)

{

=ds;

}

publicInetAddressgetIa()

{

returnia;

}

publicvoidsetIa(InetAddressia)

{

=ia;

}

publicintgetServerport()

{

returnserverport;

}

publicvoidsetServerport(intserverport)

{

port=serverport;

}

在上述的代码里，我们定义了描述用来实现UDP通讯的DatagramSocket类型对象ds，描述

客户端和服务器端的端口号clientport和serverport，用于描述通讯信息的buffer和content

对象，其中，buffer对象是byte数组类型的，可通过UDP的数据报文传输，而content是

String类型的，在应用层面表示用户之间的通讯内容，另外还定义了InetAddress类型的ia

变量，用来封装通讯地址信息。

在随后定义的一系列get和set方法里，给出了设置和获取上述变量的方法。

第三，编写该类的构造函数，代码如下所示。

publicClientBean()throwsSocketException,UnknownHostException

{

buffer=newbyte[1024];

clientport=1985;

serverport=1986;

content="";

ds=newDatagramSocket(clientport);

ia=ame("localhost");

}

在这个构造函数里，我们给各变量赋予了初始值，其中分别设置了客户端和服务器端的端口

号分别为1985和1986，设置了通讯连接地址为本地，并根据客户端的端口号初始化了

DatagramSocket对象。

当程序员初始化ClientBean类时，这段构造函数会自动执行，完成设置通讯各参数等工作。

第四，编写向服务器端发送消息的sendToServer方法，代码如下所示。

publicvoidsendToServer()throwsIOException

{

buffer=es();

(newDatagramPacket(buffer,(),ia,serverport));

}

在这段代码里，根据String类型的表示通讯信息的content变量，初始化UDP数据报文，即

DatagramPacket对象，并通过调用DatagramSocket类型对象的send方法，发送该UDP报文。

纵观ClientBean类，我们可以发现在其中封装了诸如通讯端口、通讯内容和通讯报文等对象

以及以UDP方式发送信息的sendToServer方法。所以，在UDPClient类里，可以直接调用

其中的接口，方便地实现通讯功能。

其次，我们可以按如下的步骤，设计UDPClient这个类。

第一步，通过import语句，引入所用到的类库，代码如下所示。

edReader;

ption;

treamReader;

第二步，编写线程相关的代码。

由于我们要在UDP客户端里通过多线程的机制，同时开多个客户端，向服务器端发送通讯

内容，所以我们的UDPClient类必须要实现Runnable接口，并在其中覆盖掉Runnable接口

里的run方法。定义类和实现run方法的代码如下所示。

publicclassUDPClientimplementsRunnable

{

publicstaticStringcontent;

publicstaticClientBeanclient;

publicvoidrun()

{

try

{

tent(content);

Server();

}

catch(Exceptionex)

{

n(sage());

}

}//endofrun

//main方法

//…

}

在上述代码的run方法里，我们主要通过了ClientBean类里封装的方法，设置了content内

容，并通过了sentToServer方法，将content内容以数据报文的形式发送到服务器端。

一旦线程被开启，系统会自动执行定义在run方法里的动作。

第三步，编写主方法。在步骤(2)里的//main方法注释的位置，我们可以插入UDPClient类的

main方法代码，具体如下所示。

publicstaticvoidmain(Stringargs[])throwsIOException

{

BufferedReaderbr=newBufferedReader(newInputStreamReader());

client=newClientBean();

n("客户端启动...");

while(true)

{

//接收用户输入

content=ne();

//如果是end或空,退出循环

if(content==null||IgnoreCase("end")||IgnoreCase(""))

{

break;

}

//开启新线程，发送消息

newThread(newUDPClient()).start();

}

}

这段代码的主要业务逻辑是，首先初始化了BufferedReader类型的br对象，该对象可以接

收从键盘输入的字符串。随后启动一个while(true)的循环，在这个循环体里，接收用户从键

盘的输入，如果用户输入的字符串不是“end”，或不是为空，则开启一个UDPClient类型的

线程，并通过定义在run方法里的线程主体动作，发送接收到的消息。如果在循环体里，接

收到“end”或空字符，则通过break语句，退出循环。

从上述代码里，我们可以看出，对于每次UDP发送请求，UDPClient类都将会启动一个线

程来发送消息。

7.2.3.2开发客户端代码

同样，我们把服务器端所需要的一些通用方法以类的形式封装，而在UDP的服务器端，通

过调用封装在ServerBean类里的方法来完成信息的接收工作。

首先，我们可以按如下的步骤，设计ServerBean类的代码。

第一步，通过import语句，引入所用到的类库，代码如下所示。

ption;

amPacket;

amSocket;

dress;

Exception;

nHostException;

第二步，同样定义ServerBean类里用到的变量，并给出针对这些变量操作的get和set类型

的方法。由于这里的代码和ClientBean类里的非常相似，所以不再赘述，代码部分大家可以

参考光盘上。

第三步，编写该类的构造函数，在这个构造函数里，给该类里的一些重要属性赋了初值，代

码如下所示。

publicServerBean()throwsSocketException,UnknownHostException

{

buffer=newbyte[1024];

clientport=1985;

serverport=1986;

content="";

ds=newDatagramSocket(serverport);

ia=ame("localhost");

}

从中我们可以看到，在UDP的服务端里，为了同客户端对应，所以同样把clientport和

serverport值设置为1985和1986，同时初始化了DatagramSocket对象，并把服务器的地址

也设置成本地。

第四，编写实现监听客户端请求的listenClient方法，代码如下所示。

publicvoidlistenClient()throwsIOException

{

//在循环体里接收消息

while(true)

{

//初始化DatagramPacket类型的变量

DatagramPacketdp=newDatagramPacket(buffer,);

//接收消息，并把消息通过dp参数返回

e(dp);

content=newString(a(),0,gth());

//打印消息

print();

}

}

在这个方法里，构造了一个while(true)的循环，在这个循环体内部，调用了封装在

DatagramSocket类型里的receive方法，接收客户端发送过来的UDP报文，并通过print方

法，把报文内容打印出来。

而print方法的代码比较简单，只是通过输出语句，打印报文里的字符串。

publicvoidprint()

{

n(content);

}

而UDP通讯的服务器端代码相对简单，以下是UDPServer类的全部代码。

ption;

publicclassUDPServer

{

publicstaticvoidmain(Stringargs[])throwsIOException

{

n("服务器端启动...");

//初始化ServerBean对象

ServerBeanserver=newServerBean();

//开启监听程序

Client();

}

}

从上述代码里，我们可以看到，在UDP的服务器端里，主要通过ServerBean类里提供的

listenClient方法，监听从客户端发送过来的UDP报文，并通过解析得到其中包含的字符串，

随后输出。

7.3.2.3开发客户端代码

由于我们已经讲述过通过Eclipse查看代码运行结果的详细步骤，所以这里我们将直接通过

命令行的方式，通过javac和java等命令，查看基于多线程UDP通讯的演示效果。

1.首先我们把刚才编写好的四段java代码（即、、

和）放到D盘下的work目录下（如果没有则新建）。

2.点击“开始菜单”|“运行”选项，并在“运行程序”的对话框里输入”cmd”

命令，进入DOS命令界面，并进入到D:work这个目录里。

3.如果大家已经按照第一章的说明，成功地配置好关于java的path和classpath环

境变量，在这里可以直接运行javac*.java命令，编译这四个.java文件，编译后，会在D:work

目录下产生同四个java文件相对应的.class文件。

4.在这个命令窗口里运行javaUDPServer命令，通过运行UDPServer代码，开启

UDP服务器端程序，开启后，会出现如图7-3所示的信息。

图7-3启动UDP服务端后的效果

5.在出现上图的效果后，别关闭这个命令窗口，按步骤(2)里说明的流程，新开启

一个DOS命令窗口，并同样进入到D:work这个目录下。

6.在新窗口里输入javaUDPClient，开启UDP客户端程序。开启后，可通过键盘

向服务器端输入通讯字符串，这些字符串将会以数据报文的形式发送到服务器端。

在图7-4里，演示了UDP客户端向服务器端发送消息的效果。

图7-4UDP客户端发送消息的效果

每当我们在客户端发送一条消息，服务器端会收到并输出这条消息，从代码里我们可以得知，

每条消息是通过为之新开启的线程发送到服务器端的。

如果我们在客户端输入”end”或空字符串，客户端的UDPClient代码会退出。在图7-5里

演示了UDP服务器端接收并输出通讯字符串的效果。

图7-5UDP服务器端接收到消息的效果

7.由于代码里，我们通过一个while(true)的循环来监听客户端的请

求，所以当程序运行结束后，可通过Ctrl+C的快捷键的方式退出这段程序。