黑马程序员-java学习笔记-网络编程

网络编程


网络模型
OSI参考模型
TCP/IP参考模型


 OSI            TCP/IP参考模型
应用层            应用层
表示层
会话层
传输层            传输层
网络层            网际层
数据链路层      主机至网络层
物理层




网络通讯要素
IP地址
  网络中设备的标识
  不易记忆，可用主机名
  本地回环地址：127.0.0.1 主机名：localhost
  
端口号
  用于标识进程的逻辑地址，不同进程的标识
  有效端口：0-65535，其中0-1024系统使用或保留端口


传输协议
  通讯的规则
  常见协议：TCP,UDP




1.找到对方IP
2.数据要发送到对方指定的应用程序上。为了标识这些应用程序，所以给这些网络应用程序都用数字进行标识。
  为了方便称呼这个数字，叫做端口。逻辑端口。
3.定义通讯规则。这个通讯规则成为协议。
  国际组织定义了通用协议TCP/IP


0-65535 端口号
0-1024  被系统保留


TCP和UDP 最常用的两种通讯协议


UDP：
  将数据及源和目的封装成数据包，不需建立连接
  每个数据报的大小限制在64K内
  因无连接，是不可靠协议
  不需建立连接，速度快
  （聊天，屏幕共享，视频会议。。。）
  毕老师总结：
  1.面向无连接
  2.数据会被封包，包体积有限制64K
  3.不可靠，面向无连接所以不可靠
  4.速度快


TCP
  建立连接，形成传输数据的通道
  在连接中进行大数据量传输
  通过三次握手完成连接，是可靠协议
  必须建立连接，效率稍低
  （下载。。。）


Socket
  Socket就是为网络服务提供的一种机制
  通信的两端都有Socket
  网络通信其实就是 Socket间的通信
  数据在两个Socket间通过IO传输




UDP传输
  DaatagramSocket与DatagramPacket
  建立发送端，接收端
  建立数据包
  调用Socket的发送接收方法
  关闭Socket


发送端与接收端是两个独立的运行程序


DatagramSocket 表示用来发送个接收数据包的套接字
DatagramPacket 数据报包。
数据报包用来实现无连接包投递服务。每条报文仅根据该包中包含的信息从一台机器路由到另一台机器。
从一台机器发送到另一台机器的多个包可能选择不同的路由，也可能按不同的顺序到达。不对包投递做出保证。


**********************
任何网络程序都有数据标识
**********************




接收端有一个阻塞式方法
ds.recive()  //wait() notify()


192.168.1.255广播地址




TCP传输
Socket和ServerSocket
建立客户端和服务器端
建立连接后，通过Socket中的IO流进行数据的传输
关闭Socket


同样，客户端与服务端是两个独立的应用程序


Socket：此类实现客户端套接字。套接字是两台机器间通信的端点

[java]  view plain copy

1. 示例1：  
2.   
3. import java.net.*;  
4.   
5. class IpDemo  
6. {  
7.     public static void main(String[] args) throws Exception  
8.     {  
9.         InetAddress i = InetAddress.getLocalHost();  
10.         System.out.println(i.toString());  
11.           
12.         System.out.println(i.getHostAddress()); //获取本机地址  
13.         System.out.println(i.getHostName());    //获取本机名称  
14.           
15.         InetAddress ia = InetAddress.getByName("www.baidu.com");  
16.         System.out.println(ia.getHostName());  
17.         System.out.println(ia.getHostAddress());  
18.   
19.           
20.     }  
21. }  

示例2：

[java]  view plain copy

1. import java.net.*;  
2.   
3. /* 
4. 需求：通过udp传输方式，将一段文字数据发送出去 
5. 思路： 
6.  1.建立udpSocket服务 
7.  2.提供数据，并将数据封装到数据包中 
8.  3.通过Socket服务的发送功能，将数据包发出去 
9.  4.关闭资源 
10. */  
11.   
12. class UdpSend  
13. {  
14.     public static void main(String[] args) throws Exception  
15.     {  
16.         //1.创建udp服务，通过DatagramSocket对象  
17.         DatagramSocket ds = new DatagramSocket(20000);  
18.           
19.         //2.确定数据，并将数据封装成数据包  
20.         byte[] buf = "陈宇， 我爱你！".getBytes();  
21.         DatagramPacket dp =   
22.             new DatagramPacket(buf,buf.length, InetAddress.getByName("192.168.1.254"),  10000);  
23.           
24.         //3.通过Socket服务，将已有的数据包发送出去。通过send方法  
25.         ds.send(dp);  
26.           
27.         //4.关闭资源  
28.         ds.close();   
29.     }  
30. }  
31.   
32. /* 
33. 需求： 
34. 定义一个应用程序，用于接收udp协议传输的数据病处理的。 
35.  
36. 定义udp接收端。 
37. 思路： 
38.  1.定义udpsocket服务。通常会监听一个端口，其实就是给这个接收网络应用程序定义数字标识。 
39.    方便于明确哪些数据过来该应用程序可以处理。 
40.  2.定义一个数据包，因为要存储接收到的字节数据，因为数据包对象中又更多功能可以提取字节数据中的不同数据信息。 
41.  3.通过socket服务的receive方法将受到的数据存入已定义好的数据包中 
42.  4.通过数据包对象的特有功能，将这些不同的数据取出。打印在控制台上。 
43.  5.关闭资源 
44. */  
45.   
46. class UdpRecive  
47. {  
48.     public static void main(String[] args)throws Exception  
49.     {  
50.         //1.创建udp socket，建立端点。  
51.         DatagramSocket ds = new DatagramSocket(10000);  
52.         while(true){  
53.         //2.定义数据包,用于存储数据  
54.         byte[] buf = new byte[1024];  
55.         DatagramPacket dp =   
56.             new DatagramPacket(buf, buf.length);  
57.   
58.         //3.通过服务的receive方法将受到数据存入数据包中  
59.         ds.receive(dp);//阻塞式方法  
60.   
61.         //4.通过数据包的方法获取其中的数据  
62.         String ip = dp.getAddress().getHostAddress();//获取地址  
63.           
64.         String data = new String(dp.getData(), 0, dp.getLength());//获取数据，转换为字符串  
65.   
66.         int port = dp.getPort();//获取端口  
67.           
68.         System.out.println(ip+"::"+data+"::"+port);  
69.         }  
70.         //5.关闭资源  
71.         //ds.close();  
72.     }  
73. }  

示例3：

[java]  view plain copy

1. import java.net.*;  
2. import java.io.*;  
3. class UdpSend2  
4. {  
5.     public static void main(String[] args) throws Exception  
6.     {  
7.         DatagramSocket ds = new DatagramSocket();  
8.           
9.         BufferedReader bufr = new BufferedReader(new InputStreamReader(System.in));  
10.           
11.         String line = null;  
12.           
13.         while((line = bufr.readLine())!=null)  
14.         {  
15.             if("886".equals(line))  
16.                 break;  
17.               
18.             byte[] buf = line.getBytes();  
19.   
20.             DatagramPacket dp = new DatagramPacket(buf, buf.length, InetAddress.getByName("192.168.1.255"), 10001);  
21.               
22.             ds.send(dp);  
23.   
24.       
25.         }   
26.   
27.         ds.close();  
28.     }  
29. }  
30.   
31.   
32. class UdpRecive2  
33. {  
34.     public static void main(String[] args) throws Exception  
35.     {  
36.         DatagramSocket ds = new DatagramSocket(10001);  
37.           
38.         while(true)  
39.         {  
40.             byte[] buf = new byte[1024];  
41.               
42.             DatagramPacket dp = new DatagramPacket(buf, buf.length);  
43.   
44.             ds.receive(dp);  
45.   
46.             String ip = dp.getAddress().getHostAddress();  
47.             String data = new String(dp.getData(), 0, dp.getLength());  
48.   
49.             System.out.println(ip+"::"+data);     
50.         }  
51.     }  
52. }  

示例4：

[java]  view plain copy

1. /* 
2. 编写一个聊天程序 
3. 有收数据的部分，和发数据的部分 
4. 这两部分需要同时执行 
5. 那就需要用到多线程技术 
6. 一个线程控制收，一个线程控制发 
7.  
8. 因为收和发动作是不一致的，所以要定义两个run方法 
9. 而且这两个方法要封装到不同的类中 
10. */  
11.   
12. import java.net.*;  
13. import java.io.*;  
14.   
15. class Send implements Runnable  
16. {  
17.     private DatagramSocket ds;  
18.     Send(DatagramSocket ds)  
19.     {  
20.         this.ds = ds;  
21.     }  
22.   
23.     public void run()  
24.     {  
25.         try  
26.         {  
27.             BufferedReader bufr = new BufferedReader(new InputStreamReader(System.in));  
28.               
29.             String line = null;  
30.               
31.             while((line = bufr.readLine())!=null)  
32.             {  
33.                 if("886".equals(line))  
34.                     break;  
35.   
36.                 byte[] buf = line.getBytes();  
37.   
38.                 DatagramPacket dp = new DatagramPacket(buf, buf.length, InetAddress.getByName("192.168.1.255"), 10001);  
39.                   
40.                 ds.send(dp);  
41.             }         
42.         }  
43.         catch (Exception e)  
44.         {  
45.             throw new RuntimeException("发送端失败!");  
46.         }  
47.     }  
48. }  
49.   
50. class Rece implements Runnable  
51. {  
52.     private DatagramSocket ds;  
53.     Rece(DatagramSocket ds)  
54.     {  
55.         this.ds = ds;  
56.     }  
57.   
58.     public void run()  
59.     {  
60.         try  
61.         {  
62.             while(true)  
63.             {  
64.                 byte[] buf = new byte[1024];  
65.   
66.                 DatagramPacket dp = new DatagramPacket(buf, buf.length);  
67.   
68.                 ds.receive(dp);  
69.   
70.                 String ip = dp.getAddress().getHostAddress();  
71.                   
72.                 String data = new String(dp.getData(), 0, dp.getLength());  
73.   
74.                 System.out.println(ip+"::"+data);  
75.             }  
76.         }  
77.         catch(Exception e)  
78.         {  
79.             throw new RuntimeException("接收端失败!");  
80.         }     
81.     }  
82. }  
83.   
84. class ChatDemo  
85. {  
86.     public static void main(String[] args) throws Exception  
87.     {  
88.         DatagramSocket sendSocket = new DatagramSocket();  
89.         DatagramSocket receSocket = new DatagramSocket(10001);  
90.   
91.         new Thread(new Send(sendSocket)).start();  
92.         new Thread(new Rece(receSocket)).start();  
93.     }  
94. }  

示例5：

[java]  view plain copy

1. /* 
2. 演示tcp的传输 
3.  
4. 1.tcp分客户端和服务端 
5. 2.客户端对应的对象是Socket 
6.   服务端对应的对象是ServerSocket 
7.  
8. */  
9.   
10.   
11. /* 
12. 客户端： 
13. 通过查阅Socket对象， 发现在该对象建立时就可以去连接指定主机 
14. 因为tcp是面向连接的。所以在建立Socket服务时，就要有服务端的存在，病连接成功。形成通路后在该通道进行数据的传输 
15.  
16.  
17. 需求：给服务端发送一个文本数据 
18.  
19.  
20. 步骤： 
21. 1.创建Socket服务，并指定要连接的主机和端口 
22.  
23. */  
24.   
25. import java.io.*;  
26. import java.net.*;  
27.   
28. class TcpClient  
29. {  
30.     public static void main(String[] args)throws Exception  
31.     {  
32.         //创建客户端的Socket服务，指定目的主机和端口  
33.         Socket s = new Socket("192.168.1.254", 10003);  
34.   
35.         //为了发送数据，应该获取socket流中的输出流  
36.         OutputStream out = s.getOutputStream();  
37.   
38.         out.write("tcp 陈宇".getBytes());  
39.   
40.         s.close();        
41.     }  
42. }  
43.   
44.   
45. /* 
46. 服务端 
47.  
48. 需求：定义端点接收数据并打印在控制台上 
49.  
50. 服务端 
51. 1.建立服务端socket服务。通过ServerSocket()；  
52.   并监听一个端口 
53. 2.获取连接过来的客户端对象。accept() 
54.   通过ServerSocket的accept方法，没有连接就会等待，所以这个方法是阻塞式的。 
55. 3.客户端如果发过来数据，那么服务端要使用对应的客户端对象，并获取到该客户端对象的读取流来读取发局偶来的数据 
56.   并打印在控制台 
57. 4.关闭服务端(可选) 
58. */  
59.   
60. class TcpServer  
61. {  
62.     public static void main(String[] args)throws Exception  
63.     {  
64.         //建立服务端socket服务。并监听一个端口  
65.         ServerSocket ss = new ServerSocket(10003);  
66.   
67.         //通过accept方法获取连接过来的客户端对象  
68.         Socket s = ss.accept();  
69.   
70.         String ip = s.getInetAddress().getHostAddress();  
71.         System.out.println(ip+"...........Connect");   
72.         //获取客户端发送过来的数据，那么要使用客户端对象的读取流来读取数据  
73.         InputStream in = s.getInputStream();//网络流  
74.   
75.         byte[] buf = new byte[1024];  
76.      
77.                 int len = in.read(buf);  
78.   
79.         System.out.println(new String(buf, 0, len));  
80.   
81.         //关闭客户端  
82.         s.close();  
83.   
84.         //关闭服务端  
85.         ss.close();  
86.   
87.         //System.out.println();           
88.           
89.     }  
90. }  

示例6：

[java]  view plain copy

1. import java.io.*;  
2. import java.net.*;  
3.   
4. /* 
5. 演示tcp的传输的客户端和服务端的互访 
6.  
7. 需求：客户端给服务端发送数据，服务端收到后，给客户端反馈信息 
8.  
9. */  
10.   
11. /* 
12. 客户端： 
13. 1.建立socket服务， 指定要连接的主机和端口 
14. 2.获取socket流中的输出流。将数据鞋到该流中。通过网络发送给服务端 
15. 3.获取socket流中的输入流，将服务端反馈的数据获取并打印 
16. 4.关闭客户端资源 
17. */  
18.   
19. class TcpClient2  
20. {  
21.     public static void main(String[] args) throws Exception  
22.     {  
23.         Socket s = new Socket("192.168.1.254",10004);  
24.           
25.         OutputStream out = s.getOutputStream();  
26.   
27.         out.write("陈宇， 我爱你".getBytes());  
28.   
29.   
30.         InputStream in = s.getInputStream();  
31.   
32.         byte[] buf = new byte[1024];  
33.   
34.         int len = 0;  
35.   
36.         len = in.read(buf);  
37.   
38.         System.out.println(new String(buf, 0, buf.length));  
39.   
40.         s.close();  
41.     }  
42. }  
43.   
44. class TcpServer2  
45. {  
46.     public static void main(String[] args)throws Exception  
47.     {  
48.         ServerSocket ss = new ServerSocket(10004);  
49.   
50.         Socket s = ss.accept();  
51.           
52.         String ip = s.getInetAddress().getHostAddress();  
53.   
54.         System.out.println(ip+"..............Connect");  
55.   
56.         InputStream in = s.getInputStream();  
57.   
58.         byte[] buf = new byte[1024];  
59.   
60.         int len = in.read(buf);  
61.   
62.         System.out.println(new String(buf, 0, len));      
63.   
64.         OutputStream out = s.getOutputStream();  
65.   
66.         Thread.sleep(10000);  
67.   
68.         out.write("我也爱你".getBytes());  
69.   
70.         ss.close();  
71.     }  
72. }  

示例7：

[java]  view plain copy

1. /* 
2. 需求：建立一个文本转换服务器 
3. 客户端给服务端发送文本，服务端会将文本转成大写再返回给客户端 
4. 而且客户端可以不断的进行文本转换，当客户端输入over时，转换结束 
5.  
6.  
7. 分析： 
8. 客户端： 
9. 既然是操作设备上的数据，那么就可以使用IO技术，并按照IO的操作规律来思考 
10. 源：键盘录入 
11. 目的：网络设备（网络输出流） 
12. 而且操作的是文本数据，可以选择字符流 
13.  
14.  
15.  
16.  
17. 步骤: 
18. 1.建立服务 
19. 2.获取键盘路人 
20. 3.将数据发给服务端 
21. 4.获取服务端返回的大写数据 
22. 5.结束，关闭资源 
23.  
24.  
25. 都是文本数据，可以使用字符流进行操作，同时提高效率，假如缓冲。 
26. */  
27.   
28.   
29. import java.io.*;  
30. import java.net.*;  
31. class TransClient  
32. {  
33. public static void main(String[] args)throws Exception  
34. {  
35. Socket s= new Socket("192.168.1.254", 10005);  
36.   
37. //定义读取键盘数据的流对象  
38. BufferedReader bufr = new BufferedReader(new InputStreamReader(System.in));  
39.   
40. //定义目的将数据写入到Socket输出流，发给服务端  
41. //BufferedWriter bufOut = new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));  
42.   
43. PrintWriter out = new PrintWriter(s.getOutputStream(), true);  
44.   
45.   
46. //定义一个Socket读取流，读取服务端返回的大写信息  
47. BufferedReader bufIn = new BufferedReader(new InputStreamReader(s.getInputStream()));  
48.   
49.   
50. String line = null;  
51.   
52.   
53. while((line = bufr.readLine())!= null)  
54. {  
55. if("over".equals(line))  
56. break;  
57. System.out.println(line);  
58. //bufOut.write(line);  
59. //bufOut.newLine();  
60. //bufOut.flush();  
61. out.println(line);  
62.   
63.   
64. String str = bufIn.readLine();  
65.   
66.   
67. System.out.println("server"+str);  
68. }  
69.   
70.   
71. bufr.close();  
72. s.close();  
73. }  
74.   
75.   
76. }  
77.   
78.   
79.   
80.   
81. /* 
82. 服务端： 
83. 源：socket读取流 
84. 目的：socket输出流 
85. 文本：装饰 
86.  
87.  
88. */  
89.   
90.   
91. class TransServer  
92. {  
93. public static void main(String[] args)throws Exception  
94. {  
95. ServerSocket ss= new ServerSocket(10005);  
96.   
97.   
98. Socket s = ss.accept();  
99.   
100.   
101. String ip = s.getInetAddress().getHostAddress();  
102.   
103.   
104. System.out.println(ip+"......Connect");  
105.   
106.   
107. //读取socket读取流中的数据  
108. BufferedReader bufIn = new BufferedReader(new InputStreamReader(s.getInputStream()));  
109.   
110. //目的socket输出流，将大写数据写入socket输出流，并发送给客户端  
111. //BufferedWriter bufOut = new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));  
112.   
113. PrintWriter out = new PrintWriter(s.getOutputStream(), true);  
114.   
115. String line= null;  
116.   
117.   
118. while((line = bufIn.readLine())!=null)  
119. {  
120. System.out.println(line);  
121. out.println(line.toUpperCase());  
122. //bufOut.write(line.toUpperCase());  
123. //bufOut.newLine();  
124. //bufOut.flush();  
125. }  
126. s.close();  
127. ss.close();  
128. }  
129.   
130. }  
131.   
132.   
133.   
134.   
135. /* 
136. 该例子出现的问题： 
137. 现象：客户端和服务端都在莫名的等待 
138. 这是为什么呢？ 
139. 因为客户端和服务端都有阻塞式的方法，这些方法没有读到结束标记，那么就会一直等 
140. 而导致两端都在等待