Java网络socket编程详解

或许有点长
但是一步步教你
我想你也愿意看
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 static void main(String[] args )”单选框,同时把其它两项目取消掉,再按“完成”按钮,可以生成代码。

    第三步,在生成的代码里,编写引入Java包的代码,只有当我们引入这些包后,我们才能调用这些包里提供的IO和Socket类的方法。

package tcp;

import java.io.BufferedReader;

import java.io.BufferedWriter;

import java.io.IOException;

import java.io.InputStreamReader;

import java.io.OutputStreamWriter;

import java.io.PrintWriter;

import java.net.ServerSocket;

import java.net.Socket;

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

  
public class ServerCode 

{

       
// 设置端口号

       
public static int portNo = 3333;

       
public static void main(String[] args) throws IOException 

{

              ServerSocket s 
= new ServerSocket(portNo);

              System.out.println(
"The Server is start: " + s);

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

        Socket socket 
= s.accept();

              
try 

{              

                     System.out.println(
"Accept the Client: " + socket);                   

                     
//设置IO句柄

                     BufferedReader in 
= new BufferedReader(new InputStreamReader(socket

                                   .getInputStream()));

                     PrintWriter out 
= new PrintWriter(new BufferedWriter(

                    
new OutputStreamWriter(socket.getOutputStream())), true);                    

                     
while (true)

{

                            String str 
= in.readLine();

                            
if (str.equals("byebye"))

                {

                                   
break;

                            }

                            System.out.println(
"In Server reveived the info: " + str);

                            out.println(str);

                     }

              } 

        
finally 

{

                     System.out.println(
"close the Server socket and the io.");

                     socket.close();

                     s.close();

              }

    }

}

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

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

2.         在main函数里,根据给定3333端口号,初始化一个ServerSocket对象s,该对象用来承担服务器端监听连接和提供通讯服务的功能。

3.         调用ServerSocket对象的accept方法,监听从客户端的连接请求。当完成调用accept方法后,整段服务器端代码将回阻塞在这里,直到客户端发来connect请求。

4.         当客户端发来connect请求,或是通过构造函数直接把客户端的Socket对象连接到服务器端后,阻塞于此的代码将会继续运行。此时服务器端将会根据accept方法的执行结果,用一个Socket对象来描述客户端的连接句柄。

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

6.         创建一个while(true)的死循环,在这个循环里,通过in.readLine()方法,读取从客户端发送来的IO流(字符串),并打印出来。如果读到的字符串是“byebye”,那么退出while循环。

7.         在try…catch…finally语句段里,不论在try语句段里是否发生异常,并且不论这些异常的种类,finally从句都将会被执行到。在finally从句里,将关闭描述客户端的连接句柄socket对象和ServerSocket类型的s对象。

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

第一,在TCPSocket项目下的tcp包下,创建一个名为ClientCode.java的文件。在其中编写引入Java包的代码,如下所示:

    
package tcp;

import java.io.BufferedReader;

import java.io.BufferedWriter;

import java.io.IOException;

import java.io.InputStreamReader;

import java.io.OutputStreamWriter;

import java.io.PrintWriter;

import java.net.InetAddress;

import java.net.Socket;

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

 
public class ClientCode

 {

       
static String clientName = "Mike";

       
//端口号

public static int portNo = 3333;

       
public static void main(String[] args) throws IOException

{

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

              InetAddress addr 
= InetAddress.getByName("localhost");        

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

              Socket socket 
= new Socket(addr, portNo);

              
try

{

            System.out.println(
"socket = " + socket);

                     
// 设置IO句柄

                     BufferedReader in 
= new BufferedReader(new InputStreamReader(socket

                                   .getInputStream()));

                     PrintWriter out 
= new PrintWriter(new BufferedWriter(

                                   
new OutputStreamWriter(socket.getOutputStream())), true);

                     out.println(
"Hello Server,I am " + clientName);

                     String str 
= in.readLine();

                     System.out.println(str);

                     out.println(
"byebye");

              }

finally 

{

                     System.out.println(
"close the Client socket and the io.");

                     socket.close();

        }

       }

}

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

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

2.         在main函数里,根据地址信息“localhost”,创建一个InetAddress类型的对象addr。这里,因为我们把客户端和服务器端的代码都放在本机运行,所以同样可以用“127.0.0.1”字符串,来创建InetAddress对象。

3.         根据addr和端口号信息,创建一个Socket类型对象,该对象用来同服务器端的ServerSocket类型对象交互,共同完成C/S通讯流程。

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

5.         通过out对象,向服务器端发送"Hello Server,I am …"的字符串。发送后,同样可以用in句柄,接收从服务器端的消息。

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

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

7.2.1.3 运行效果演示
在上述两部分里,我们分别讲述了C
/S通讯过程中服务器端和客户端代码的业务逻辑,下面我们将在集成开发环境里,演示这里通讯流程。

第一步,选中ServerCode.java代码,在eclipse的“运行”菜单里,选中“运行方式”
|1 Java应用程序”的菜单,开启服务器端的程序。

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

The Server is start: ServerSocket[addr
=0.0.0.0/0.0.0.0,port=0,localport=3333]

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

第二步,按同样的方法,打开ClientCode.java程序,启动客户端。启动以后,将在客户端的控制台里看到如下的信息:

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

Hello Server,I am Mike

close the Client socket and the io.

从中可以看到,在第一行里,显示客户端Socket对象连接的IP地址和端口号,在第二行里,可以到到客户端向服务器端发送的字符串,而在第三行里,可以看到通讯结束后,客户端关闭连接Socket和IO对象的提示语句。

第三步,在eclipse下方的控制台里,切换到ServerCode服务端的控制台提示信息里,我们可以看到服务器端在接收到客户端连接请求后的响应信息。

  响应的信息如下所示:

The Server is start: ServerSocket[addr
=0.0.0.0/0.0.0.0,port=0,localport=3333]

Accept the Client: Socket[addr
=/127.0.0.1,port=1327,localport=3333]

In Server reveived the info: Hello Server,I am Mike

close the Server socket and the io.

其中,第一行是启动服务器程序后显示的信息。在第二行里,显示从客户端发送的连接请求的各项参数。在第三行里,显示了从客户端发送过来的字符串。在第四行里,显示了关闭服务器端ServerSocket和IO对象的提示信息。从中我们可以看出在服务器端里accept阻塞和继续运行的这个过程。

通过上述的操作,我们可以详细地观察到C
/S通讯的全部流程,请大家务必要注意:一定要先开启服务器端的程序再开启客户端,如果这个步骤做反的话,客户端程序会应找不到服务器端而报异常。

7.2.2使用套接字连接多个客户机    
在7.1的代码里,客户端和服务器之间只有一个通讯线程,所以它们之间只有一条Socket信道。

如果我们在通过程序里引入多线程的机制,可让一个服务器端同时监听并接收多个客户端的请求,并同步地为它们提供通讯服务。

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

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

第一步,在3.2里创建的“TCPSocket”项目里,新建一个名为ThreadServer.java的代码文件,创建文件的方式大家可以参照3.2部分的描述。首先编写package和import部分的代码,用来打包和引入包文件,如下所示:

package tcp;

import java.io.*;

import java.net.*;

第二步,由于我们在服务器端引入线程机制,所以我们要编写线程代码的主体执行类ServerThreadCode,这个类的代码如下所示:

class ServerThreadCode extends Thread 

{

       
//客户端的socket

       
private Socket clientSocket;

       
//IO句柄

       
private BufferedReader sin;

       
private PrintWriter sout;    

       
//默认的构造函数

       
public ServerThreadCode()

       {}  

       
public ServerThreadCode(Socket s) throws IOException 

       {

              clientSocket 
= s;            

              
//初始化sin和sout的句柄

              sin 
= new BufferedReader(new InputStreamReader(clientSocket

                            .getInputStream()));

        sout 
= new PrintWriter(new BufferedWriter(new OutputStreamWriter(

                            clientSocket.getOutputStream())), 
true);             

              
//开启线程

              start(); 

       }

       
//线程执行的主体函数

       
public void run() 

       {

              
try 

              {

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

                     
for(;;) 

                     {

                String str 
= sin.readLine();

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

                            
if (str.equals("byebye"))

                            {     

                                   
break;

                            }     

                            System.out.println(
"In Server reveived the info: " + str);

                            sout.println(str);

                     }

                     System.out.println(
"closing the server socket!");

              } 

        
catch (IOException e) 

              {

                     e.printStackTrace();

              } 

              
finally 

              {

                     System.out.println(
"close the Server socket and the io.");

                     
try 

            {

                            clientSocket.close();

                     } 

                     
catch (IOException e) 

                     {

                            e.printStackTrace();

                     }

              }

       }

}

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

1.         这个类通过继承Thread类来实现线程的功能,也就是说,在其中的run方法里,定义了该线程启动后要执行的业务动作。

2.         这个类提供了两种类型的重载函数。在参数类型为Socket的构造函数里, 通过参数,初始化了本类里的Socket对象,同时实例化了两类IO对象。在此基础上,通过start方法,启动定义在run方法内的本线程的业务逻辑。

3.         在定义线程主体动作的run方法里,通过一个for(;;)类型的循环,根据IO句柄,读取从Socket信道上传输过来的客户端发送的通讯信息。如果得到的信息为“byebye”,则表明本次通讯结束,退出for循环。

4.         catch从句将处理在try语句里遇到的IO错误等异常,而在finally从句里,将在通讯结束后关闭客户端的Socket句柄。

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

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

public class ThreadServer 

{

       
//端口号

       
static final int portNo = 3333;

       
public static void main(String[] args) throws IOException 

       {

              
//服务器端的socket

              ServerSocket s 
= new ServerSocket(portNo);

              System.out.println(
"The Server is start: " + s);      

              
try 

              {

                     
for(;;)                          

                     {

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

                            Socket socket 
= s.accept();

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

                        
new ServerThreadCode(socket);

                     }

              }

           
finally 

              {

                     s.close();

              }

       }

}

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

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”项目里,新建一个名为ThreadClient.java的代码文件。同样是编写package和import部分的代码,用来打包和引入包文件,如下所示:

package tcp;

import java.net.*;

import java.io.*;

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

class ClientThreadCode extends Thread 

{

  
//客户端的socket

  
private Socket socket;    

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

  
private static int cnt = 0;

  
private int clientId = cnt++;

  
private BufferedReader in;

  
private PrintWriter out;

  
//构造函数

  
public ClientThreadCode(InetAddress addr) 

  {

    
try 

    {

      socket 
= new Socket(addr, 3333);

    }

    
catch(IOException e) 

    {

          e.printStackTrace();

    }

    
//实例化IO对象

try 

    {    

      in 
= new BufferedReader(

             
new InputStreamReader(socket.getInputStream()));    

       out 
= new PrintWriter(

               
new BufferedWriter(new OutputStreamWriter(socket.getOutputStream())), true);

        
//开启线程

        start();

     } 

     
catch(IOException e) 

     {

        
//出现异常,关闭socket 

          
try 

          {

            socket.close();

        } 

          
catch(IOException e2) 

          {

              e2.printStackTrace();       

          }

     }

  }  

  
//线程主体方法

public void run() 

  {

    
try 

    {

      out.println(
"Hello Server,My id is " + clientId );

      String str 
= in.readLine();

      System.out.println(str);

      out.println(
"byebye");

    } 

    
catch(IOException e) 

    {

       e.printStackTrace();  

    }

    
finally 

    {

      
try 

      {

        socket.close();

      } 

      
catch(IOException e) 

      {

              e.printStackTrace();

      }    

    }

  }

}

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

1.         在构造函数里, 通过参数类型为InetAddress类型参数和3333,初始化了本类里的Socket对象,随后实例化了两类IO对象,并通过start方法,启动定义在run方法内的本线程的业务逻辑。

2.         在定义线程主体动作的run方法里,通过IO句柄,向Socket信道上传输本客户端的ID号,发送完毕后,传输”byebye”字符串,向服务器端表示本线程的通讯结束。

3.         同样地,catch从句将处理在try语句里遇到的IO错误等异常,而在finally从句里,将在通讯结束后关闭客户端的Socket句柄。

第三步,编写客户端的主体代码,在这段代码里,将通过for循环,根据指定的待创建的线程数量,通过ClientThreadCode的构造函数,创建若干个客户端线程,同步地和服务器端通讯。

public class ThreadClient 

{

  
public static void main(String[] args) 

      
throws IOException, InterruptedException 

  {

    
int threadNo = 0;

       InetAddress addr 
= 

       InetAddress.getByName(
"localhost");

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

    {

       
new ClientThreadCode(addr);

    }

  }

}

这段代码执行以后,在客户端将会有3个通讯线程,每个线程首先将先向服务器端发送
"Hello Server,My id is "的字符串,然后发送”byebye”,终止该线程的通讯。

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

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

The Server is start: ServerSocket[addr
=0.0.0.0/0.0.0.0,port=0,localport=3333]

上述的提示信息里,我们同样可以看到,服务器在开启服务后,会阻塞在accept这里,直到有客户端请求过来。

第二步,我们在启动完服务器后,运行客户端的ThreadClient.java代码,运行后,我们观察服务器端的控制台,会出现如下的信息:

The Server is start: ServerSocket[addr
=0.0.0.0/0.0.0.0,port=0,localport=3333]

In Server reveived the info: Hello Server,My id is 
0

In Server reveived the info: Hello Server,My id is 
1

In Server reveived the info: Hello Server,My id is 
2

closing the server socket
!

close the Server socket and the io.

closing the server socket
!

close the Server socket and the io.

closing the server socket
!

close the Server socket and the io.

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

In Server reveived the info: Hello Server,My id is 
0

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

这里,请大家注意,由于线程运行的不确定性,从第二行开始的打印输出语句的次序是不确定的。但是,不论输出语句的次序如何变化,我们都可以从中看到,客户端有三个线程请求过来,并且,服务器端在处理完请求后,会关闭Socker和IO。

第三步,当我们运行完ThreadClient.java的代码后,并切换到ThreadClient.java的控制台,我们可以看到如下的输出:

Hello Server,My id is 
0

Hello Server,My id is 
2

Hello Server,My id is 
1

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

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

7.2.3 UDP协议与传输数据报文    
UDP协议一般应用在 “群发信息”的场合,所以它更可以利用多线程的机制,实现多信息的同步发送。

为了改善代码的架构,我们更可以把一些业务逻辑的动作抽象成方法,并封装成类,这样,基于UDP功能的类就可以在其它应用项目里被轻易地重用。

7.2.3.1 开发客户端代码
如果我们把客户端的所有代码都写在一个文件中,那么代码的功能很有可能都聚集在一个方法力,代码的可维护性将会变得很差。

所以我们专门设计了ClientBean类,在其中封装了客户端通讯的一些功能方法,在此基础上,通过UDPClient.java文件,实现UDP客户端的功能。

另外,在这里以及以后的代码里,我们不再详细讲述用Eclipse开发和运行Java程序的方法,而是重点讲述Java代码的业务逻辑和主要工作流程。

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

import java.io.IOException;

import java.net.DatagramPacket;

import java.net.DatagramSocket;

import java.net.InetAddress;

import java.net.SocketException;

import java.net.UnknownHostException;

第二,定义ClientBean所用到的变量,并给出针对这些变量操作的get和set类型的方法,代码如下所示。

//描述UDP通讯的DatagramSocket对象

private  DatagramSocket ds;

//用来封装通讯字符串

private  byte buffer[];

//客户端的端口号

private  int clientport ;

//服务器端的端口号

private  int serverport;

//通讯内容

private  String content;

//描述通讯地址

private  InetAddress ia;

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

public byte[] getBuffer() 

{

       
return buffer;

}

public void setBuffer(byte[] buffer)

{

       
this.buffer = buffer;

}

public int getClientport()

{

return clientport;

}

public void setClientport(int clientport) 

{

       
this.clientport = clientport;

}

public String getContent() 

{

       
return content;

}

public void setContent(String content)

{

       
this.content = content;

}

public DatagramSocket getDs() 

{

       
return ds;

}

public void setDs(DatagramSocket ds)

{

       
this.ds = ds;

}

public InetAddress getIa() 

{

       
return ia;

}

public void setIa(InetAddress ia) 

{

       
this.ia = ia;

}

public int getServerport() 

{

       
return serverport;

}

public void setServerport(int serverport) 

{

    
this.serverport = serverport;

}

在上述的代码里,我们定义了描述用来实现UDP通讯的DatagramSocket类型对象ds,描述客户端和服务器端的端口号clientport和serverport,用于描述通讯信息的buffer和content对象,其中,buffer对象是byte数组类型的,可通过UDP的数据报文传输,而content是String类型的,在应用层面表示用户之间的通讯内容,另外还定义了InetAddress类型的ia变量,用来封装通讯地址信息。

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

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

public ClientBean() throws SocketException, UnknownHostException

{

       buffer 
= new byte[1024];

       clientport 
= 1985;

       serverport 
= 1986;

       content 
= "";

       ds 
= new DatagramSocket(clientport);

       ia 
= InetAddress.getByName("localhost");

}

在这个构造函数里,我们给各变量赋予了初始值,其中分别设置了客户端和服务器端的端口号分别为1985和1985,设置了通讯连接地址为本地,并根据客户端的端口号初始化了DatagramSocket对象。

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

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

public void sendToServer() throws IOException

{

       buffer 
= content.getBytes();

       ds.send(
new DatagramPacket(buffer,content.length(),ia,serverport));

}

在这段代码里,根据String类型的表示通讯信息的content变量,初始化UDP数据报文,即DatagramPacket对象,并通过调用DatagramSocket类型对象的send方法,发送该UDP报文。

纵观ClientBean类,我们可以发现在其中封装了诸如通讯端口、通讯内容和通讯报文等对象以及以UDP方式发送信息的sendToServer方法。所以,在UDPClient类里,可以直接调用其中的接口,方便地实现通讯功能。

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

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

import java.io.BufferedReader;

import java.io.IOException;

import java.io.InputStreamReader;

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

由于我们要在UDP客户端里通过多线程的机制,同时开多个客户端,向服务器端发送通讯内容,所以我们的UDPClient类必须要实现Runnable接口,并在其中覆盖掉Runnable接口里的run方法。定义类和实现run方法的代码如下所示。

public class UDPClient implements Runnable

{

public static String content;

public static ClientBean client;

public void run()

{

       
try

{

              client.setContent(content);

              client.sendToServer();

       }

catch(Exception ex)

{

              System.err.println(ex.getMessage());

       }

}
//end of run

//main 方法

  
//

 }

在上述代码的run方法里,我们主要通过了ClientBean类里封装的方法,设置了content内容,并通过了sentToServer方法,将content内容以数据报文的形式发送到服务器端。

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

第三步,编写主方法。在步骤(
2)里的//main方法注释的位置,我们可以插入UDPClient类的main方法代码,具体如下所示。

public static void main(String args[]) throws IOException

{

       BufferedReader br 
= new BufferedReader(new InputStreamReader(System.in));

       client 
= new ClientBean();

       System.out.println(
"客户端启动");

       
while(true)

{

              
//接收用户输入

content 
= br.readLine();

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

if(content==null||content.equalsIgnoreCase("end")||content.equalsIgnoreCase(""))

{

                     
break;

              }

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

new Thread(new UDPClient()).start();

       }            

}

这段代码的主要业务逻辑是,首先初始化了BufferedReader类型的br对象,该对象可以接收从键盘输入的字符串。随后启动一个while(
true)的循环,在这个循环体里,接收用户从键盘的输入,如果用户输入的字符串不是“end”,或不是为空,则开启一个UDPClient类型的线程,并通过定义在run方法里的线程主体动作,发送接收到的消息。如果在循环体里,接收到“end”或空字符,则通过break语句,退出循环。

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

7.2.3.2 开发客户端代码
同样,我们把服务器端所需要的一些通用方法以类的形式封装,而在UDP的服务器端,通过调用封装在ServerBean类里的方法来完成信息的接收工作。

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

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

import java.io.IOException;

import java.net.DatagramPacket;

import java.net.DatagramSocket;

import java.net.InetAddress;

import java.net.SocketException;

import java.net.UnknownHostException;

第二步,同样定义ServerBean类里用到的变量,并给出针对这些变量操作的get和set类型的方法。由于这里的代码和ClientBean类里的非常相似,所以不再赘述,代码部分大家可以参考光盘上。

第三步,编写该类的构造函数,在这个构造函数里,给该类里的一些重要属性赋了初值,代码如下所示。

public ServerBean() throws SocketException, UnknownHostException

{

       buffer 
= new byte[1024];

       clientport 
= 1985;

       serverport 
= 1986;

       content 
= "";

       ds 
= new DatagramSocket(serverport);

       ia 
= InetAddress.getByName("localhost");

}

从中我们可以看到,在UDP的服务端里,为了同客户端对应,所以同样把clientport和serverport值设置为1985和1986,同时初始化了DatagramSocket对象,并把服务器的地址也设置成本地。

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

public void listenClient() throws IOException

{

       
//在循环体里接收消息

while(true)

{

        
//初始化DatagramPacket类型的变量

DatagramPacket dp 
= new DatagramPacket(buffer,buffer.length);

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

ds.receive(dp);

              content 
= new String(dp.getData(),0,dp.getLength());

              
//打印消息

print();

       }

}

在这个方法里,构造了一个while(
true)的循环,在这个循环体内部,调用了封装在DatagramSocket类型里的receive方法,接收客户端发送过来的UDP报文,并通过print方法,把报文内容打印出来。

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

public void print()

{

       System.out.println(content);

}

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

import java.io.IOException;

public class UDPServer

{

       
public static void main(String args[]) throws IOException

{

              System.out.println(
"服务器端启动");

              
//初始化ServerBean对象

ServerBean server 
= new ServerBean();

              
//开启监听程序

server.listenClient();

       }

}

从上述代码里,我们可以看到,在UDP的服务器端里,主要通过ServerBean类里提供的listenClient方法,监听从客户端发送过来的UDP报文,并通过解析得到其中包含的字符串,随后输出。

7.3.2.3 开发客户端代码
由于我们已经讲述过通过Eclipse查看代码运行结果的详细步骤,所以这里我们将直接通过命令行的方式,通过javac和java等命令,查看基于多线程UDP通讯的演示效果。

1.         首先我们把刚才编写好的四段java代码(即ClientBean.java、UDPClient.java、ServerBean.java和UDPServer.java)放到D盘下的work目录下(如果没有则新建)。

2.         点击“开始菜单”|“运行”选项,并在“运行程序”的对话框里输入”cmd”命令,进入DOS命令界面,并进入到D:\work这个目录里。

3.         如果大家已经按照第一章的说明,成功地配置好关于java的path和classpath环境变量,在这里可以直接运行javac *.java命令,编译这四个.java文件,编译后,会在D:\work目录下产生同四个java文件相对应的.class文件。

4.         在这个命令窗口里运行java UDPServer命令,通过运行UDPServer代码,开启UDP服务器端程序,开启后,会出现如图7-3所示的信息。



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

5.         在出现上图的效果后,别关闭这个命令窗口,按步骤(2)里说明的流程,新开启一个DOS命令窗口,并同样进入到D:\work这个目录下。

6.         在新窗口里输入java UDPClient,开启UDP客户端程序。开启后,可通过键盘向服务器端输入通讯字符串,这些字符串将会以数据报文的形式发送到服务器端。

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



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

每当我们在客户端发送一条消息,服务器端会收到并输出这条消息,从代码里我们可以得知,每条消息是通过为之新开启的线程发送到服务器端的。

如果我们在客户端输入”end”或空字符串,客户端的UDPClient代码会退出。在图7
-5里演示了UDP服务器端接收并输出通讯字符串的效果。



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

7.         由于UDPServer.java代码里,我们通过一个while(true)的循环来监听客户端的请求,所以当程序运行结束后,可通过Ctrl+C的快捷键的方式退出这段程序。

转载于:https://www.cnblogs.com/yl2755/archive/2012/04/10/2440773.html

你可能感兴趣的:(java,网络,开发工具)