第十二章网络程序设计

第十二章网络程序设计

11

浙江工业大学计算机学院赵小敏[email protected]://211.155.231.249:8009

22

主要内容

统一资源定位地址 (URL)

基于 TCP 的网络程序设计基于 UDP 的网络程序设计基于 SSL 的网络程序设计

33

Internet 地址

在 Internet 上的计算机通过 IP (Internet Protocol) 地址标识示例 : 216.239.53.100

域名 : www.google.com

类 java.net.InetAddress 用来表示 Internet 地址，它有两个子类，分别是 java.net.Inet4Address 和 java.net.Inet6

Address

44

创建类 InetAddress 的实例对象

类 InetAddress 并不具有 public 的构造方法但可以通过下列方法构造 :

static InetAddress getByAddress(byte[ ] addr)

static InetAddress getByName(String host)

static InetAddress getLocalHost()

例 1 ：网络地址的例程1. import java.net.InetAddress;2. import java.net.UnknownHostException;3. public class InetAddressDemo{4. public static void main(String args[]){5. String s = "www.zjut.edu.cn";6. InetAddress zjut= null;

7. try{ 8. zjut = InetAddress.getByName(s);9. }10. catch (UnknownHostException e){ 11. System.err.println(e);12. }13. if (ts!=null){14. System.out.println("The IP address of zjut is "15. + zjut.getHostAddress( ));16. System.out.println("The host name of zjut is "17. + zjut.getHostName( ));18. }19. else System.out.println("Cannot access " + s);20. }21. }

66

URL

类 URL 是网络资源定位器 (Uniform Resou

rce Locator), 指向网页 (World Wide Web)

上的一个资源。这里的资源可以是文件 / 目录，也可以是一些

复杂的对象，如数据库或搜索引擎 (search e

ngine) 。

77

URL 的格式 (Protocol)(Host)[:Port][File][#Reference]

示例 http://www.ncsa.uiuc.edu:8080/demoweb/urlprimer.html#I

NSTALL

http://211.155.231.249:8009/java

http://localhost:8080/index.html#bottom

ftp://166.111.233.143/java/

mailto:[email protected]

88

端口号 : Port 端口号 (Port)

范围 : 0-65535 (16 bits) 。小于 1024: 用来对应特定的服务 ( 例如 : telnet, S

MTP, ftp 等等 ) 。服务端与客户端必须采用相同的端口号。

99

类 : java.net.URL 类 java.net.URL 的实例对象表示具体的 URL 。 public final class URL 。类 java.net.URL 的中构造方法 :

public URL(String u) throws MalformedURLException

public URL(String protocol, String host, String file) thro

ws MalformedURLException

public URL(String protocol, String host, int port, String

file) throws MalformedURLException

1010

剖析 URL 类 java.net.URL 具有五个成员方法，可以用

来获取 URL 的五个部分 :

public String getProtocol( )

public String getHost( )

public int getPort( )

public String getFile( )

public String getRef( )

1. import java.net.*;2. import java.io.*;

3. public class ParseURL {4. public static void main(String[] args) throws Exception {5. 6. URL aURL = new

URL("http://java.sun.com:80/docs/books/"7. + "tutorial/index.html#DOWNLOADING");8. System.out.println("protocol = " + aURL.getProtocol());9. System.out.println("host = " + aURL.getHost());10. System.out.println("filename = " + aURL.getFile());11. System.out.println("port = " + aURL.getPort()); 12. System.out.println("ref = " + aURL.getRef());13. }14. }

输出结果：protocol = httphost = java.sun.comfilename = /docs/books/tutorial/index.htmlport = 80ref = DOWNLOADING

例 2 ：解析 URL 的例程

从 URL 读取 WWW 网络资源

当我们得到一个 URL 对象后，就可以通过它读取指定的 WWW 资源。这时我们将使用URL 的方法 openStream() ，其定义为：　 InputStream openStream();

方法 openSteam() 与指定的 URL 建立连接并返回 InputStream 类的对象以从这一连接中读取数据。

读取网络资源数据的一般步骤

① 创建类 URL 的实力对象，使其指向给定的网络资源；

② 通过类 URL 的成员方法 openStream 建立 URL连接，并返回输入流对象的引用，以便读取数据；

③ 可选步骤，通过 java.io.BufferedInputStream 或java.io.BufferedReader 封装输入流；

④ 读取数据，并进行数据处理；⑤ 关闭数据流。

1. import java.io.*;

2. import java.net.*;3. public class URLReader {4. public static void main(String[] args) throws Exception { 5. URL tirc = new URL("http://www.yahoo.com/"); 6. BufferedReader in = new BufferedReader(new

InputStreamReader(tirc.openStream()));

7. String inputLine; 8. File outfile = new File("test.html"); 9. PrintWriter out = new PrintWriter(new FileWriter(outfile));10. while ((inputLine = in.readLine()) != null) {11. // 从输入流中不断读取数据直到读完为止12. out.println(inputLine); // 把读入的数据写入 test.html13. }14. in.close(); // 关闭输入流15. out.close();16. }17. }

例 3 ：获取网络资源的例程

1515

主要内容



1616

传输控制协议 TCP 传输控制协议 TCP (Transfer Control Protoc

ol) 是一种基于连接的协议，可以在两台计算机之间提供可靠的数据传输。基于连接的协议，可提供可靠的数据传输服务器端与客户端通过 TCP 协议进行通讯连接通道的两端称为套接字 (Socket)

1717

基于 TCP 的网络数据通信模型

服务器端

ServerSocket(port#)

ServerSocket.accept()

OutputStream

InputStream

Socket.close()

客户端

Socket(host, port#)

OutputStream

InputStream

Socket.close()

1818

类 java.net.Socket

类 java.net.Socket 允许如下的四种基本操作1. 连接到远程的机器

2. 发送数据

3. 接收数据

4. 关闭连接

1919

类 java.net.Socket 中的成员方法构造方法 getInputStream(): 返回该 socket 所对应的

输入流 getOutputStream(): 返回该 socket 所对应的

输出流

2020

创建类 Socket 的实例对象构造方法

Socket()

Socket(InetAddress address, int port)

Socket(InetAddress address, int port, InetAddress localAddr, int localPort)

Socket(String host, int port)

Socket(String host, int port, InetAddress localAddr, int localPort)

示例 : Socket javaSite = new Socket("java.sun.com", 80);

类 java.net.ServerSocket

ServerSocket 类的主要方法(1) Socket accept() throws IOException

等待客户连接，该方法将阻塞当前系统服务线程，直到连接成功。该方法返回一个套接字类对象，通过该套接字，新的服务子线程与连接的客户进行通信。

(2) Void close() throws IOException

　　　　　关闭套接字

怎样用 socket 进行客户与服务器通信

Socket 是两个实体之间进行通信的有效端点。通过Socket 可以获得源 IP 地址和源端口、终点 IP 地址和终点端口。用户可以将多个 socket 连入同一个端口，以便对于单个端口可以有多个连接。

通过 Socket 客户 / 服务器编程可以创建一个能被许多人使用的分布式程序，并且所有客户均可以用统一的前端进行工作，并与服务器进行通信。

与服务器通信必须具备三个条件

服务器程序客户程序连接它们的 Socket 程序

ServerSocket 类

它的实例使服务器能够检测到指定端口的信息 accept() 方法可以使服务器检测到指定端口的

活动服务器还负责检测要求与它连接的客户。

Socket 类

getInputStream() 和 getOutStream() 方法来发送和捕捉数据。

try{

// 传递给它一个整数作为服务器指定可以使用的给定端口　　 ServerSocket myServerSocket=new ServerSocket(80);

　　 Socket mySocket=myServerSocket.accept(); // 检测端口的活动　　 }catch(Exception e){ }

　 Accept() 方法直到接收到用户的连接请求，才继续执行中断的执行程序。一旦客户的连接成功， mySocket 就代表该连接，并且可以发送和接收数据。

最后，我们看一看客户是怎样请求连接的。其连接方法如下：

try{

　 Socket mySocket=new Socket("www.yahoo.com",80);

}catch(Exception e ){ }

Socket 类

(一 )TCP 协议通信的服务器方实现(1) 假设服务器工作在端口 8000 上，ServerSocket svrsoc ＝ ServerSocket(8000)Socket soc ＝ svrsoc.accept();// 监视端口 8000

的连接请求(2) 打开与 soc 绑定的输入 / 输出流：In=new BufferedReader(new

InputStreamRead(soc.getInputStream()));// 在套接字 soc 上绑定的输入流基础上构造

BufferedReader 对象

TCP 协议通信的服务器方实现（续）out=new PrintWrite(new bufferedWrite(new

OutputStreamWrite(soc.getOutputStream())),true);

// 在套接字 soc 上绑定的输出流基础上构造PrintWrite 对象

服务器使用 in 和 out 两个实例从客户接收输入信息和向客户程序发信息，同样，在客户端也应该建立这两个对象，用来与服务器程序进行双向通信。

(一 ) TCP 协议通信的服务器方实现（续）(3) 获取客户机的 IP 地址，并在服务器窗口中

显示客户机的地址信息：clientIP=soc.getInetAddress();

System.out.println(“Client’s IP address:”+clientIP);

(4) 读入一行客户的输入，并回显该行 String str ＝ in.readLine();

while(!str.equals(“quit”));{

System.out.println(“Client said:”+str);

str=in.readLine();

}

(一 ) TCP 协议通信的服务器方实现（续）(5) 不断循环以上代码，直到客户输入“ quit” 为

止。System.out.println(“Client want to leave.”);

finall{

in.close();

out.close();

soc.close();

svrsoc.close();

}

(二 ) TCP 协议通信的客户方实现

(1) 创建一个指向固定主机的固定端口的 Socket ： Socket soc ＝ new Socket(“localhost”,8000);

(2) 从 Socket 对象中获取与其绑定的输入和输出流

In=new BufferedReader(new InputStreamRead(soc.getInputStream()));

out=new PrintWrite(new bufferedWrite(new OutputStreamWrite(soc.getOutputStream())),true);

(二 ) TCP 协议通信的客户方实现(续 )

(3) 建立输入 / 输出流后，从服务器读取发来的” welcome!” 信息，显示在窗口：

Strin=in.readLine();

System.out.println(“Server said:”+strin);

(二 ) TCP 协议通信的客户方实现(续 )(4) 客户向服务器发送的数据流从键盘获取byte bmsg[]=new byte[200];

System.in.read(bmsg); // 从键盘读入 bmsg

String msg=new String(bmsg,0); //byte 型转 String型

Msg=msg.trim(); // 删除 msg 两边的空格

(二 ) TCP 协议通信的客户方实现(续 )

(5) 当键盘输入不是“ quit” 时，将键盘输入的数据写入输出流中，并发送出去，然后继续从键盘获取输入数据，不断循环，直到输入“ quit” 时，先将其传送给服务器，然后关闭输入 / 输出流和 Socket:

out.println(strout);In.close();out.close();soc.close();System.exit(0);

一个简单的客户端 /服务器程序1. import java.net.*; 2. import java.io.*; 3. import java.lang.*;

4. public class myserver{ 5. public static void main(String args[]){ 6. ServerSocket server; 7. Socket socket; 8. String s; 9. InputStream Is; 10. OutputStream Os; 11. DataInputStream DIS; 12. PrintStream PS;

13. try{ 14. server=new ServerSocket(4321); 15. socket=server.accept();16. System.out.println("server ok"); 17. System.out.println("************************************************"); 18. System.out.println("");

19. Is=socket.getInputStream(); 20. Os=socket.getOutputStream(); 21. DIS=new DataInputStream(Is); 22. PS=new PrintStream(Os); 23. DataInputStream in=new DataInputStream(System.in); 24. while(true){ 25. System.out.println(""); 26. System.out.println("please wait client's message..."); 27. System.out.println(""); 28. s=DIS.readLine(); 29. System.out.println("client said:"+s); 30. if(s.trim().equals("BYE"))break; 31. System.out.print("you say:"); 32. s=in.readLine(); 33. PS.println(s); 34. if(s.trim().equals("BYE"))break; 35. } 36. DIS.close(); 37. PS.close(); 38. Is.close(); 39. Os.close(); 40. socket.close(); 41. } catch(Exception e){ 42. System.out.println("Error:"+e); 43. } //catch44. } //main45. } //public class

1. import java.net.*; 2. import java.io.*; 3. import java.lang.*;

4. public class myclient{ 5. public static void main(String args[]){ 6. if (args.length<1){7. System.out.println("Please input the Server Name or IP!"); 8. System.out.println("see also: myclient 127.0.0.1"); 9. System.exit(1); } //if

10. Socket socket; 11. String s=“[email protected]"; 12. String len; 13. InputStream Is; 14. OutputStream Os; 15. DataInputStream DIS; 16. PrintStream PS; 17. try{ 18. socket=new Socket(args[0],4321);

19. System.out.println("client ok"); 20. System.out.println("************************************************"); 21. System.out.println("");

22. Is=socket.getInputStream(); 23. Os=socket.getOutputStream(); 24. DIS=new DataInputStream(Is); 25. PS=new PrintStream(Os); 26. DataInputStream in=new DataInputStream(System.in); 27. while(true){ 28. System.out.print("you say:"); 29. s=in.readLine(); 30. PS.println(s); 31. if(s.trim().equals("BYE"))break; //32. else 33. { 34. System.out.println(""); 35. System.out.println("please wait server's message..."); 36. System.out.println(""); 37. } 38. s=DIS.readLine(); //´39. System.out.println("server said:"+s); 40. if(s.trim().equals("BYE"))break; } 41. DIS.close(); //42. PS.close(); //43. Is.close(); //44. Os.close(); // 45. socket.close(); //46. } catch(Exception e){ 47. System.out.println("Error:"+e); 48. } 49. } 50. }

(三 )支持多客户的 client/server 程序设计在实际应用中，往往是在服务器上运行一个永久的程

序，它可以接收来自其他多个客户端的请求，提供相应的服务。

利用多线程实现多客户机制 : 服务器总是在指定的端口上监听是否有客户请求，一旦监听到客户请求，服务器就会启动一个专门的服务线程来响应该客户的请求，而服务器本身在启动完线程之后马上又进入监听状态，等待下一个客户的到来。

实现程序包括服务器端主程序、服务器端通信的线程程序和客户端程序

支持多客户的 C/S 程序步骤

1 、服务器端主程序(1) 创建 ServerSocket 对象；(2) 循环侦听客户端的请求，若监听到客户请求，

根据得到的 Socket 对象和客户端连接数创建服务线程，并启动该线程；

(3) 关闭 ServerSocket 对象。

服务器端程序1. import java.io.*;2. import java.net.*;

3. public class MultiTalkServer{4. static int clientnum=0;// 静态成员变量，记录当前客户的个数5. public static void main(String args[ ]) {6. ServerSocket serverSocket=null;7. boolean listening=true;8. try{9. serverSocket=new ServerSocket(4700); 10. System.out.println("Server is running...");11. // 创建一个 ServerSocket 在端口 4700 监听客户请求12. }catch(IOException e) {13. System.out.println("Could not listen on port:4700."); 14. System.exit(-1); // 退出15. }

服务器端程序 (续 )16. try{17. while(listening){// 永远循环监听18. new ServerThread(serverSocket.accept(),+

+clientnum).start();19. // 监听到客户请求，根据得到的 Socket 对象和20. // 客户计数创建服务线程，并启动之21. System.out.println("Client-"+(clientnum)+" is

connected...");22. }23. serverSocket.close(); // 关闭 ServerSocket24. }catch(IOException e){25. System.out.println(" 连接客户端失败 "); 26. }27. }28. }

支持多客户的 C/S 程序步骤 (续 )

2 、服务器端通信的线程程序(1) 定义一个线程类(2) 通过构造方法将服务器端程序传递的 Socket

对象和客户端连接数赋值给相应的变量(3) 线程体 run 方法：通过得到的 Socket 对象获

取输入输出流对象，通过循环与客户端发送和接收数据。若循环结束，关闭 Socket 对象和输入输出流对象

服务器端通信的线程程序1. import java.io.*;2. import java.net.*;3. public class ServerThread extends Thread{4. Socket socket=null; // 保存与本线程相关的 Socket 对象5. int clientnum; // 保存本进程的客户计数6. public ServerThread(Socket socket,int num) { // 构造函数7. this.socket=socket;//初始化 socket 变量8. clientnum=num+1;//初始化 clientnum 变量9. }10. public void run() {// 线程主体11. try{12. String line;13. // 由 Socket 对象得到输入流，并构造相应的 BufferedReader 对象14. BufferedReader is=new BufferedReader(new

InputStreamReader(socket.getInputStream()));15. // 由 Socket 对象得到输出流，并构造 PrintWriter 对象16. PrintWriter os=new PrintWriter(socket.getOutputStream());17. //由系统标准输入设备构造 BufferedReader 对象18. BufferedReader sin=new BufferedReader(new InputStreamReader(System.in));

⑲ // 在标准输出上打印从客户端读入的字符串⑳ System.out.println("Client-"+ clientnum +":" +is.readLine());㉑ // 从标准输入读入一字符串㉒ line=sin.readLine();

㉓ while(!line.equals("bye")){ // 如果该字符串为 "bye" ，则停止循环㉔ os.println(line); // 向客户端输出该字符串㉕ os.flush(); //刷新输出流，使 Client 马上收到该字符串㉖ System.out.println("Server:"+line); ㉗㉘ // 从 Client 读入一字符串，并打印到标准输出上㉙ System.out.println("Client-"+ clientnum +":" +is.readLine());㉚ line=sin.readLine(); // 从系统标准输入读入一字符串㉛ } //继续循环

㉜ os.close(); // 关闭 Socket 输出流㉝ is.close(); // 关闭 Socket 输入流㉞ socket.close(); // 关闭 Socket㉟ }catch(Exception e){㊱ System.out.println("Error:"+e); ㊲ }㊳ } ㊴ }

支持多客户的 C/S 程序步骤 (续 )

3 、客户端程序(1) 创建与服务器连接的 socket 对象(2) 通过 Socket 对象获取输入输出流对象，通

过循环与客户端发送和接收数据。若循环结束，关闭 Socket 对象和输入输出流对象。

客户端程序1. import java.io.*;2. import java.net.*;3. public class TalkClient {4. public static void main(String args[]) {

5. try{6. // 向本机的 4700 端口发出客户请求7. Socket socket=new Socket("127.0.0.1",4700); 8. System.out.println("已连接服务器 , 请发消息给服务器处理 ...");

9. //由系统标准输入设备构造 BufferedReader 对象10. BufferedReader sin=new BufferedReader(new

InputStreamReader(System.in));11. // 由 Socket 对象得到输出流，并构造 PrintWriter 对象12. PrintWriter os=new PrintWriter(socket.getOutputStream());13. // 由 Socket 对象得到输入流，并构造相应的 BufferedReader 对象14. BufferedReader is=new BufferedReader(new

InputStreamReader(socket.getInputStream()));

客户端程序 (续 )1. String readline;2. readline=sin.readLine(); // 从系统标准输入读入一字符串3. while(!readline.equals("bye")){ //若输入字符串为 "bye"则停止循环4. //将从系统标准输入读入的字符串输出到 Server5. os.println(readline); 6. //刷新输出流，使 Server 马上收到该字符串7. os.flush(); 8. // 在系统标准输出上打印读入的字符串9. System.out.println("Client:"+readline);

10. // 从 Server 读入一字符串，并打印到标准输出上11. System.out.println("Server:"+is.readLine()); 12. // 从系统标准输入读入一字符串13. readline=sin.readLine(); 14. } //继续循环

15. os.close(); // 关闭 Socket 输出流16. is.close(); // 关闭 Socket 输入流17. socket.close(); // 关闭 Socket18. }catch(Exception e) {19. System.out.println("Error"+e); // 出错，则打印出错信息20. }21. }22. }

课后思考？服务器端如何控制客户端的连接数量？服务器端如何广播信息给客户端？如何实现图形用户界面的 C/S 聊天系统？

5050

主要内容



5151

基于 UDP 的网络程序设计 UDP(User Datagram Protocol) 是一种简单

的不可靠的无连接的网络数据传输协议。 UDP 不保证数据包会顺利到达指定的主机，

也不保证数据包会按照发送顺序到达指定的主机。

基于 UDP 传输的数据传输过程：传输的数据首先封装在数据报包 (DatagramPacket),然后通过数据报套接字 (DatagramSocket) 的发送与接收。

5252

数据报包 java.net.DatagramPacket 构造方法

public DatagramPacket(byte[ ] buf, int length)

// 主要用于接收数据public DatagramPacket(byte[ ] buf, int length, InetAddres

s address, int port)

// 主要用来发送数据成员方法

public InetAddress getAddress( )

public int getPort( )

public byte[ ] getData()

public int getLength()

5353

数据报套接字 java.net.DatagramSocket 构造方法protected DatagramSocket(int port)

// 绑定到特定端口接收广播的数据包成员方法

public void send(DatagramPacket p) throws IOException

public void receive(DatagramPacket p) throws IOException

public void close()

基于 UDP 协议的网络编程步骤服务器端的步骤如下 :1. 定义数据成员 DatagramSocket socket; DatagramPacket packet; InetAddress address;( 用来存放接收方的地址 ) int port; ;( 用来存放接收方的端口号 )2. 创建数据报文 Socket 对象 try { socket=new DatagramSocket(1111); }catch(java.net.SocketException e) { } socket 绑定到一个本地的可用端口 , 等待接收客户的请

求 .

基于 UDP 协议的网络编程步骤3. 分配并填写数据缓冲区 ( 一个字节类型的数组 )

byte[] Buf=new byte[256];

　　　　存放从客户端接收的请求信息 .

4. 创建一个 DatagramPacket 对象 packet=new DatagramPacket(buf, 256);

　　　用来从 socket 接收数据 , 它只有两个参数 5. 服务器阻塞，等待客户端发送数据过来 socket.receive(packet);

　　　在客户的请求报道来之前一直等待

基于 UDP 协议的网络编程步骤6. 从接收的包中得到地址和端口号 InetAddress address=packet.getAddress(); int port=packet.getPort();7. 将数据送入缓冲区或来自文件 ,或键盘输入8. 建立报文包 , 用来从 socket 上发送信息 packet=new DatagramPacket (buf,buf.length, address,port);

9. 发送数据包： socket.send(packet); 10. 10. 关闭 socket ： socket.close();

基于 UDP 协议的网络编程步骤客户端的步骤如下 :1. 定义数据成员 int port; InetAddress address; DatagramSocket socket; DatagramPacket packet; byte[ ] sendBuf=new byte[256];2. 创建 DatagramSocket 对象 socket=new DatagramSocket();

基于 UDP 协议的 Java 网络编程步骤3. 向服务器发出请求报文 address=InetAddress.getByName(args[0]); port=parseInt(args[1]); packet=new DatagramPacket(sendBuf,256,address,port); socket.send(packet);

　　　　这个包本身带有客户端的信息4. 客户机等待应答 packet=new DatagramPacket(sendBuf,256);

socket.receive(packet);( 如果没有收到就一直等待 ,因此实用程序要设置时间限度 )

基于 UDP 协议的 Java 网络编程步骤5. 处理接收到的数据 String received=new String(packet.getData(),0);

System.out.println(received);

数据报套接字首先是强调发送方和接收方的区别 , 同时也指出服务器和客户之间的不同 :一个客户机必须事先知道服务器的地址和端口 , 以便进行连接一个服务器从它接收到的数据报文中读取客户端的地址和端口 .

基于 UDP 的网络程序模型建立数据报 socket;

建立一个报文包 packet

等待请求报文

建立数据报 socket

建立一个请求包

发出请求

获得对方地址

构成信息包

发送出去

创建接收包

等待接收

一个 UDP 协议的 C/S 例子

UDPServer.java UDPClient.java

6262

主要内容



6363

基于 SSL 的网络程序设计

密钥和证书管理工具 keytool

基于 SSL 的服务器端和客户端程序自定义安全提供程序和密钥管理器

作业

1 、使用 socket编写一个服务器端程序，服务器端程序在端口 8888 监听，如果它接到客户端发来的“ hello” 请求时会回应一个“ hello” ，对客户端的其他请求不响应。

2 、修改支持多客户的 client/server 程序，设定客户的最大连接数是 10 ，若超出 10则服务器给出信息“客户已达到最大连接数，请等待…”。要求用 GUI 实现。

Documents

第十二章 网络程序设计

第十二章网络程序设计