网络编程:就是用来实现网络互连的不同计算机上运行的程序间可以进行数据交换。

26.02 网络模型概述和图解

计算机网络之间以何种规则进行通信，就是网络模型研究问题。

网络模型一般是指

OSI（Open System Interconnection开放系统互连）参考模型

TCP/IP参考模型

OSI参考模型七层简述:

1.物理层:主要定义物理设备标准，如网线的接口类型、光纤的接口类型、各种传输介质的传输速率等。它的主要作用是传输比特流（就是由1、0转化为电流强弱来进行传输,到达目的地后在转化为1、0，也就是我们常说的数模转换与模数转换）。这一层的数据叫做比特。

2.数据链路层:主要将从物理层接收的数据进行MAC地址（网卡的地址）的封装与解封装。常把这一层的数据叫做帧。在这一层工作的设备是交换机，数据通过交换机来传输。

3.网络层:主要将从下层接收到的数据进行IP地址（例192.168.0.1)的封装与解封装。在这一层工作的设备是路由器，常把这一层的数据叫做数据包。

4.传输层:定义了一些传输数据的协议和端口号（WWW端口80等），如:TCP（传输控制协议，传输效率低，可靠性强，用于传输可靠性要求高，数据量大的数据），UDP（用户数据报协议，与TCP特性恰恰相反，用于传输可靠性要求不高，数据量小的数据，如QQ聊天数据就是通过这种方式传输的）。主要是将从下层接收的数据进行分段和传输，到达目的地址后再进行重组。常常把这一层数据叫做段。

5.会话层:通过传输层（端口号:传输端口与接收端口）建立数据传输的通路。主要在你的系统之间发起会话或者接受会话请求（设备之间需要互相认识可以是IP也可以是MAC或者是主机名）

6.表示层:主要是进行对接收的数据进行解释、加密与解密、压缩与解压缩等（也就是把计算机能够识别的东西转换成人能够能识别的东西（如图片、声音等）。

7.应用层:主要是一些终端的应用，比如说FTP（各种文件下载），WEB（IE浏览），QQ之类的（可以把它理解成我们在电脑屏幕上可以看到的东西．就是终端应用）。

26.03 网络编程三要素概述

网络通信三要素

1.IP地址: InetAddress网络中设备的标识，不易记忆，可用主机名

2.端口号: 用于标识进程的逻辑地址，不同进程的标识

3.传输协议: 通讯的规则常见协议:TCP，UDP

26.04 网络编程三要素之IP概述1

IP地址:InetAddress

1.网络中设备的标识

2.不易记忆，可用主机名

3.本地回环地址:127.0.0.1 主机名:localhost

IP地址的组成

IP地址 = 网络号码+主机地址

A类IP地址:第一段号码为网络号码，剩下的三段号码为本地计算机的号码

B类IP地址:前二段号码为网络号码，剩下的二段号码为本地计算机的号码

C类IP地址:前三段号码为网络号码，剩下的一段号码为本地计算机的号码

A类 1.0.0.1---127.255.255.254

(1)10.X.X.X是私有地址(私有地址就是在互联网上不使用，而被用在局域网络中的地址)

(2)127.X.X.X是保留地址，用做循环测试用的。

B类 128.0.0.1---191.255.255.254

172.16.0.0---172.31.255.255是私有地址。169.254.X.X是保留地址。

C类 192.0.0.1---223.255.255.254

192.168.X.X是私有地址

D类 224.0.0.1---239.255.255.254

E类 240.0.0.1---247.255.255.254

DOS命令 ipconfig:查看本机IP地址

xxx.xxx.xxx.0 网络地址

xxx.xxx.xxx.255 广播地址

127.0.0.1 回环地址,可用于测试本机的网络是否有问题. ping 127.0.0.1

26.05 InetAddress类的概述和使用

为了方便我们对IP地址的获取和操作，java提供了一个类InetAddress 供我们使用

InetAddress:此类表示互联网协议 (IP) 地址。IP 地址是 IP 使用的 32 位或 128 位无符号数字，它是一种低级协议，UDP 和 TCP 协议都是在它的基础上构建的。

方法:

1.public static InetAddress[] getAllByName(String host)throws UnknownHostException

在给定主机名的情况下，根据系统上配置的名称服务返回其 IP 地址所组成的数组。

2.public String getHostName()

获取此 IP 地址的主机名。

3.public String getHostAddress()

返回 IP 地址字符串（以文本表现形式）。

例:

1 InetAddress address = InetAddress.getByName("192.168.1.88");
2 // 获取此 IP 地址的主机名
3 String name = address.getHostName();
4 // 返回 IP 地址字符串（以文本表现形式）。
5 String ip = address.getHostAddress();
6 System.out.println("主机名:"+name);
7 System.out.println("IP:"+ip);

26.06 网络编程三要素之端口

物理端口网卡口

逻辑端口

1:每个网络程序都会至少有一个逻辑端口

2:用于标识进程的逻辑地址，不同进程的标识

3:有效端口:0~65535，其中0~1024系统使用或保留端口

26.07 网络编程三要素之协议

协议:通讯的规则，常见协议:TCP，UDP

UDP:

1.将数据源和目的封装成数据包中，不需要建立连接

2.每个数据报的大小在限制在64k

3.因无连接，是不可靠协议

4.不需要建立连接，速度快

TCP:

1.建立连接，形成传输数据的通道

2.在连接中进行大数据量传输

3.通过三次握手完成连接，是可靠协议

4.必须建立连接，效率会稍低

26.08 Socket通信原理

Socket套接字:网络上具有唯一标识的IP地址和端口号组合在一起才能构成唯一能识别的标识符套接字

Socket原理机制:

1.通信的两端都有Socket

2.网络通信其实就是Socket间的通信

3.数据在两个Socket间通过IO传输

26.09 UDP协议发送数据

DatagramSocket:此类表示用来发送和接收数据报包的套接字。数据报套接字是包投递服务的发送或接收点。

DatagramPacket:此类表示数据报包。数据报包用来实现无连接包投递服务。

发送端步骤:

1:建立udp的socket服务

2:将要发送的数据封装成数据包

3:通过udp的socket服务,将数据包发送出

4:关闭资源

例:

 1 public class Send 
 2 {
 3     public static void main(String[] args) throws IOException 
 4     {
 5         // 创建发送端Socket对象
 6         DatagramSocket ds = new DatagramSocket();
 7 
 8         // 创建数据
 9         byte[] bys = "hello,udp,我来了".getBytes();
10         // 长度
11         int length = bys.length;
12         // IP地址对象
13         InetAddress address = InetAddress.getByName("192.168.12.92");
14         // 端口
15         int port = 10086;
16         
17         //将数据打包，包含内容、长度、IP地址、端口号
18         DatagramPacket dp = new DatagramPacket(bys, length, address, port);
19 
20         // 发送数据包
21         ds.send(dp);
22 
23         // 释放资源
24         ds.close();
25     }
26 }

26.10 UDP协议接收数据

接收端步骤:

1:建立udp的socket服务.

2:通过receive方法接收数据

3:将收到的数据存储到数据包对象中

4:通过数据包对象的功能来完成对接收到数据进行解析

5:可以对资源进行关闭

例:

 1 public class Receive 
 2 {
 3     public static void main(String[] args) throws IOException 
 4     {
 5         // 创建接收端Socket对象
 6         DatagramSocket ds = new DatagramSocket(10000);
 7 
 8         // 创建一个数据包(接收容器)
 9         byte[] bys = new byte[1024];
10         int length = bys.length;
11         DatagramPacket dp = new DatagramPacket(bys, length);
12 
13         // 调用Socket对象的接收方法接收数据
14         ds.receive(dp); // 阻塞式
15 
16         // 解析数据包
17         // 获取对方的ip
18         InetAddress address = dp.getAddress();
19         String ip = address.getHostAddress();
20         // 获取数据缓冲区
21         byte[] bys2 = dp.getData();
22         // 获取数据的实际长度
23         int len = dp.getLength();
24         String s = new String(bys2, 0, len);
25         System.out.println("ip:"+ip);
26         System.out.println("传递的数据:"+ s);
27         // 释放资源
28         ds.close();
29     }
30 }

26.11 UDP协议发送和接收数据代码优化

例:

 1 public class Send 
 2 {
 3     public static void main(String[] args) throws IOException 
 4     {
 5         // 创建发送端的Socket对象
 6         DatagramSocket ds = new DatagramSocket();
 7 
 8         // 创建数据并打包
 9         byte[] bys = "helloworld".getBytes();
10         DatagramPacket dp = new DatagramPacket(bys, bys.length,
11                 InetAddress.getByName("192.168.1.99"), 10001);
12 
13         // 发送数据
14         ds.send(dp);
15 
16         // 释放资源
17         ds.close();
18     }
19 }
20 
21 --------------------------------------------------------------
22 public class Receive 
23 {
24     public static void main(String[] args) throws IOException 
25     {
26         // 创建接收端的Socket对象
27         DatagramSocket ds = new DatagramSocket(10001);
28 
29         // 创建一个包裹
30         byte[] bys = new byte[1024];
31         DatagramPacket dp = new DatagramPacket(bys, bys.length);
32 
33         // 接收数据
34         ds.receive(dp);
35 
36         // 解析数据
37         String ip = dp.getAddress().getHostAddress();
38         String s = new String(dp.getData(), 0, dp.getLength());
39         System.out.println("ip:" + ip);
40         System.out.println("数据:" + s);
41 
42         // 释放资源
43         ds.close();
44     }
45 }

26.12 发送端的数据来自于键盘录入案例

从键盘录入数据进行发送，如果输入的是886那么客户端就结束输入数据。

 1 public class Send 
 2 {
 3     public static void main(String[] args) throws IOException 
 4     {
 5         // 创建发送端的Socket对象
 6         DatagramSocket ds = new DatagramSocket();
 7 
 8         // 封装键盘录入数据
 9         BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
10         String line = null;
11         while ((line = br.readLine()) != null) 
12         {
13             if ("886".equals(line)) 
14             {
15                 break;
16             }
17 
18             // 创建数据并打包
19             byte[] bys = line.getBytes();
20             DatagramPacket dp = new DatagramPacket(bys, bys.length,
21                     InetAddress.getByName("192.168.1.99"), 10001);
22             //192.168.1.255为广播地址
23 
24             // 发送数据
25             ds.send(dp);
26         }
27 
28         // 释放资源
29         ds.close();
30     }
31 }
32 --------------------------------------------------------------
33 public class Receive 
34 {
35     public static void main(String[] args) throws IOException 
36     {
37         // 创建接收端的Socket对象
38         DatagramSocket ds = new DatagramSocket(10001);
39 
40         while (true) 
41         {
42             // 创建一个包裹
43             byte[] bys = new byte[1024];
44             DatagramPacket dp = new DatagramPacket(bys, bys.length);
45 
46             // 接收数据
47             ds.receive(dp);
48 
49             // 解析数据
50             String ip = dp.getAddress().getHostAddress();
51             String s = new String(dp.getData(), 0, dp.getLength());
52             System.out.println("from " + ip + " data is : " + s);
53         }
54 
55         // 释放资源
56         // 接收端应该一直开着等待接收数据，是不需要关闭
57         // ds.close();
58     }
59 }

26.13 多线程实现聊天室程序

 1 public class Practice 
 2 {
 3     public static void main(String[] args) throws IOException
 4     {
 5         DatagramSocket dsSend = new DatagramSocket();
 6         DatagramSocket dsReceive = new DatagramSocket(10001);
 7 
 8         Send st = new Send(dsSend);
 9         Receive rt = new Receive(dsReceive);
10 
11         Thread t1 = new Thread(st);
12         Thread t2 = new Thread(rt);
13 
14         t1.start();
15         t2.start();
16     }
17 }
18 --------------------------------------------------------------
19 发送端:
20 public class Send implements Runnable
21 {
22     private DatagramSocket ds;
23 
24     public Send(DatagramSocket ds) 
25     {
26         this.ds = ds;
27     }
28 
29     @Override
30     public void run() 
31     {
32         try 
33         {
34             // 封装键盘录入数据
35             BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
36             String line = null;
37             while ((line = br.readLine()) != null) 
38             {
39                 if ("886".equals(line)) 
40                 {
41                     break;
42                 }
43 
44                 // 创建数据并打包
45                 byte[] bys = line.getBytes();
46                 DatagramPacket dp = new DatagramPacket(bys, bys.length,InetAddress.getByName("192.168.1.255"), 10001);
47 
48                 // 发送数据
49                 ds.send(dp);
50             }
51 
52             // 释放资源
53             ds.close();
54         } 
55         catch (IOException e)
56         {
57             e.printStackTrace();
58         }
59     }
60 }
61 --------------------------------------------------------------
62 接收端:
63 public class Receive implements Runnable
64 {
65     private DatagramSocket ds;
66 
67     public Receive(DatagramSocket ds)
68     {
69         this.ds = ds;
70     }
71 
72     @Override
73     public void run() 
74     {
75         try 
76         {
77             while (true) 
78             {
79                 // 创建一个包裹
80                 byte[] bys = new byte[1024];
81                 DatagramPacket dp = new DatagramPacket(bys, bys.length);
82 
83                 // 接收数据
84                 ds.receive(dp);
85 
86                 // 解析数据
87                 String ip = dp.getAddress().getHostAddress();
88                 String s = new String(dp.getData(), 0, dp.getLength());
89                 System.out.println("来自" + ip + "的数据: " + s);
90             }
91         } 
92         catch (IOException e)
93         {
94             e.printStackTrace();
95         }
96     }
97 }

26.14 TCP协议发送数据

TCP协议发送数据:

A:创建发送端的Socket对象，这一步如果成功，就说明连接已经建立成功了

B:获取输出流，写数据

C:释放资源

TCP协议一定要先开服务器。否则报错:java.net.ConnectException: Connection refused: connect

public Socket(String host,int port) throws UnknownHostException,IOException

创建一个流套接字并将其连接到指定主机上的指定端口号。

例:

 1 public class Client 
 2 {
 3     public static void main(String[] args) throws IOException 
 4     {
 5         // 创建发送端的Socket对象
 6         // Socket(InetAddress address, int port)
 7         // Socket(String host, int port)
 8         // Socket s = new Socket(InetAddress.getByName("192.168.1.88"), 10002);
 9         Socket s = new Socket("192.168.1.88", 10002);
10 
11         // 获取输出流，写数据
12         // public OutputStream getOutputStream()
13         OutputStream os = s.getOutputStream();
14         os.write("hello,tcp".getBytes());
15 
16         // 释放资源
17         s.close();
18     }
19 }

26.15 TCP协议接收数据

TCP协议接收数据:

A:创建接收端的Socket对象

B:监听客户端连接。返回一个对应的Socket对象

C:获取输入流，读取数据显示在控制台

D:释放资源

例:

 1 public class Server 
 2 {
 3     public static void main(String[] args) throws IOException
 4     {
 5         // 创建接收端的Socket对象
 6         // ServerSocket(int port)
 7         ServerSocket ss = new ServerSocket(10002);
 8     
 9         // 监听客户端连接。返回一个对应的Socket对象
10         // public Socket accept()
11         Socket s = ss.accept(); // 侦听并接受到此套接字的连接。此方法在连接传入之前一直阻塞。
12     
13         // 获取输入流，读取数据显示在控制台
14         InputStream is = s.getInputStream();
15     
16         byte[] bys = new byte[1024];
17         int len = is.read(bys); // 阻塞式方法
18         String str = new String(bys, 0, len);
19     
20         String ip = s.getInetAddress().getHostAddress();
21     
22         System.out.println(ip + "---" + str);
23     
24         // 释放资源
25         s.close();
26         // ss.close(); //这个不应该关闭
27     }
28 }

26.16 服务器给客户端一个反馈案例

 1 //服务端
 2 public class Server 
 3 {
 4     public static void main(String[] args) throws IOException
 5     {
 6         // 创建服务器Socket对象
 7         ServerSocket ss = new ServerSocket(10002);
 8 
 9         // 监听客户端的连接
10         Socket s = ss.accept(); // 阻塞
11 
12         // 获取输入流
13         InputStream is = s.getInputStream();
14         byte[] bys = new byte[1024];
15         int len = is.read(bys); // 阻塞
16         String server = new String(bys, 0, len);
17         System.out.println("server:" + server);
18 
19         // 获取输出流
20         OutputStream os = s.getOutputStream();
21         os.write("数据已经收到".getBytes());
22 
23         // 释放资源
24         s.close();
25         // ss.close();
26     }
27 }
28 --------------------------------------------------------------
29 //客户端
30 public class Client 
31 {
32     public static void main(String[] args) throws IOException 
33     {
34         // 创建客户端Socket对象
35         Socket s = new Socket("192.168.1.88", 10002);
36 
37         // 获取输出流
38         OutputStream os = s.getOutputStream();
39         os.write("hello".getBytes());
40 
41         // 获取输入流
42         InputStream is = s.getInputStream();
43         byte[] bys = new byte[1024];
44         int len = is.read(bys);// 阻塞
45         String client = new String(bys, 0, len);
46         System.out.println("client:" + client);
47 
48         // 释放资源
49         s.close();
50     }
51 }

26.17 客户端键盘录入服务器控制台输出

 1 //服务端
 2 public class Server 
 3 {
 4     public static void main(String[] args) throws IOException
 5     {
 6         // 创建服务器Socket对象
 7         ServerSocket ss = new ServerSocket(10003);
 8 
 9         // 监听客户端连接
10         Socket s = ss.accept();
11 
12         // 包装通道内容的流
13         BufferedReader br = new BufferedReader(new InputStreamReader(
14                 s.getInputStream()));
15         String line = null;
16         while ((line = br.readLine()) != null) 
17         {
18             System.out.println(line);
19         }
20 
21         // br.close();
22         s.close();
23         // ss.close();
24     }
25 }
26 --------------------------------------------------------------
27 //客户端
28 public class Client 
29 {
30     public static void main(String[] args) throws IOException 
31     {
32         // 创建客户端Socket对象
33         Socket s = new Socket("192.168.1.88", 10003);
34 
35         // 键盘录入数据
36         BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
37         // 把通道内的流给包装一下
38         BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(
39                 s.getOutputStream()));
40 
41         String line = null;
42         while ((line = br.readLine()) != null) 
43         {
44             // 键盘录入数据要自定义结束标记
45             if ("886".equals(line)) 
46             {
47                 break;
48             }
49             bw.write(line);
50             bw.newLine();
51             bw.flush();
52         }
53 
54         // 释放资源
55         // bw.close();
56         // br.close();
57         s.close();
58     }
59 }

26.18 TCP上传文本文件并给出反馈

 1 //服务端
 2 public class Server 
 3 {
 4     public static void main(String[] args) throws IOException
 5     {
 6         // 创建服务器端的Socket对象
 7         ServerSocket ss = new ServerSocket(10003);
 8 
 9         // 监听客户端连接
10         Socket s = ss.accept();// 阻塞
11 
12         // 封装通道内的流
13         BufferedReader br = new BufferedReader(new InputStreamReader(
14                 s.getInputStream()));
15         // 封装文本文件
16         BufferedWriter bw = new BufferedWriter(new FileWriter("Copy.java"));
17 
18         String line = null;
19         while ((line = br.readLine()) != null) 
20         { 
21             // 阻塞
22             // if("over".equals(line)){
23             // break;
24             // }
25             bw.write(line);
26             bw.newLine();
27             bw.flush();
28         }
29 
30         // 给出反馈
31         BufferedWriter bwServer = new BufferedWriter(new OutputStreamWriter(
32                 s.getOutputStream()));
33         bwServer.write("文件上传成功");
34         bwServer.newLine();
35         bwServer.flush();
36 
37         // 释放资源
38         bw.close();
39         s.close();
40     }
41 }
42 --------------------------------------------------------------
43 //客户端
44 public class Client 
45 {
46     public static void main(String[] args) throws IOException 
47     {
48         // 创建客户端Socket对象
49         Socket s = new Socket("192.168.1.99", 10003);
50 
51         // 封装文本文件
52         BufferedReader br = new BufferedReader(new FileReader(
53                 "InetAddressDemo.java"));
54         // 封装通道内流
55         BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(
56                 s.getOutputStream()));
57 
58         String line = null;
59         while ((line = br.readLine()) != null) 
60         { // 阻塞
61             bw.write(line);
62             bw.newLine();
63             bw.flush();
64         }
65         
66         //自定义一个结束标记
67 //                bw.write("over");
68 //                bw.newLine();
69 //                bw.flush();
70         
71         //Socket提供了一个终止，它会通知服务器没有数据过来了
72         s.shutdownOutput();
73 
74         // 接收反馈
75         BufferedReader brClient = new BufferedReader(new InputStreamReader(
76                 s.getInputStream()));
77         String client = brClient.readLine(); // 阻塞
78         System.out.println(client);
79 
80         // 释放资源
81         br.close();
82         s.close();
83     }
84 }

26.19 TCP协议上传图片并给出反馈

 1 //服务端
 2 public class Server 
 3 {
 4     public static void main(String[] args) throws IOException
 5     {
 6         // 创建服务器Socket对象
 7         ServerSocket ss = new ServerSocket(10004);
 8 
 9         // 监听客户端连接
10         Socket s = ss.accept();
11 
12         // 封装通道内流
13         BufferedInputStream bis = new BufferedInputStream(s.getInputStream());
14         // 封装图片文件
15         BufferedOutputStream bos = new BufferedOutputStream(
16                 new FileOutputStream("D:\bj.jpg"));
17 
18         byte[] bys = new byte[1024];
19         int len = 0;
20         while ((len = bis.read(bys)) != -1) 
21         {
22             bos.write(bys, 0, len);
23             bos.flush();
24         }
25 
26         // 给一个反馈
27         OutputStream os = s.getOutputStream();
28         os.write("图片上传成功".getBytes());
29 
30         bos.close();
31         s.close();
32     }
33 }
34 --------------------------------------------------------------
35 //客户端
36 public class Client 
37 {
38     public static void main(String[] args) throws IOException 
39     {
40         // 创建客户端Socket对象
41         Socket s = new Socket("192.168.1.88", 10004);
42 
43         // 封装图片文件
44         BufferedInputStream bis = new BufferedInputStream(new FileInputStream(
45                 "D:\001.jpg"));
46         // 封装通道内的流
47         BufferedOutputStream bos = new BufferedOutputStream(s.getOutputStream());
48 
49         byte[] bys = new byte[1024];
50         int len = 0;
51         while ((len = bis.read(bys)) != -1) 
52         {
53             bos.write(bys, 0, len);
54             bos.flush();
55         }
56         
57         s.shutdownOutput();
58 
59         // 读取反馈
60         InputStream is = s.getInputStream();
61         byte[] bys2 = new byte[1024];
62         int len2 = is.read(bys2);
63         String client = new String(bys2, 0, len2);
64         System.out.println(client);
65 
66         // 释放资源
67         bis.close();
68         s.close();
69     }
70 }

26.20 多线程改进多个客户端上传文件案例

  1 //用户线程
  2 public class UserThread implements Runnable
  3 {
  4     private Socket s;
  5 
  6     public UserThread(Socket s)
  7     {
  8         this.s = s;
  9     }
 10 
 11     @Override
 12     public void run() 
 13     {
 14         try 
 15         {
 16             // 封装通道内的流
 17             BufferedReader br = new BufferedReader(new InputStreamReader(
 18                     s.getInputStream()));
 19             // 封装文本文件
 20             // BufferedWriter bw = new BufferedWriter(new
 21             // FileWriter("Copy.java"));
 22 
 23             // 为了防止名称冲突
 24             String newName = System.currentTimeMillis() + ".java";
 25             BufferedWriter bw = new BufferedWriter(new FileWriter(newName));
 26 
 27             String line = null;
 28             while ((line = br.readLine()) != null) 
 29             { // 阻塞
 30                 bw.write(line);
 31                 bw.newLine();
 32                 bw.flush();
 33             }
 34 
 35             // 给出反馈
 36             BufferedWriter bwServer = new BufferedWriter(
 37                     new OutputStreamWriter(s.getOutputStream()));
 38             bwServer.write("文件上传成功");
 39             bwServer.newLine();
 40             bwServer.flush();
 41 
 42             // 释放资源
 43             bw.close();
 44             s.close();
 45         } 
 46         catch (IOException e) 
 47         {
 48             e.printStackTrace();
 49         }
 50     }
 51 }
 52 --------------------------------------------------------------
 53 //服务端
 54 public class Server 
 55 {
 56     public static void main(String[] args) throws IOException
 57     {
 58         // 创建服务器Socket对象
 59         ServerSocket ss = new ServerSocket(10005);
 60 
 61         while (true) 
 62         {
 63             Socket s = ss.accept();
 64             new Thread(new UserThread(s)).start();
 65         }
 66     }
 67 }
 68 --------------------------------------------------------------
 69 //客户端
 70 public class Client 
 71 {
 72     public static void main(String[] args) throws IOException 
 73     {
 74         // 创建客户端Socket对象
 75         Socket s = new Socket("192.168.1.99", 10005);
 76 
 77         // 封装文本文件
 78         // BufferedReader br = new BufferedReader(new FileReader(
 79         // "InetAddressDemo.java"));
 80         BufferedReader br = new BufferedReader(new FileReader(
 81                 "ReceiveDemo.java"));
 82         // 封装通道内流
 83         BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(
 84                 s.getOutputStream()));
 85 
 86         String line = null;
 87         while ((line = br.readLine()) != null) 
 88         { // 阻塞
 89             bw.write(line);
 90             bw.newLine();
 91             bw.flush();
 92         }
 93 
 94         // Socket提供了一个终止，它会通知服务器你别等了，我没有数据过来了
 95         s.shutdownOutput();
 96 
 97         // 接收反馈
 98         BufferedReader brClient = new BufferedReader(new InputStreamReader(
 99                 s.getInputStream()));
100         String client = brClient.readLine(); // 阻塞
101         System.out.println(client);
102 
103         // 释放资源
104         br.close();
105         s.close();
106     }
107 }