黑马程序员_学习笔记第22天——网络编程TCP/UDP

----------------------  ASP.Net+Android+IOS开发 、 href="http://edu.csdn.net"target="blank">.Net培训 、期待与您交流！ ----------------------

1、网络编程

1）找到对方IP

2）数据要求发送到对方指定的应用程序上，为了标识这些应用程序，所以给这些网络应用程序都用数字进行标识，为了方便称呼这个数字，叫做端口，逻辑端口。

3）定义通信规则，这个通讯规则成为协议，国际组织定义了通用协议TCP/IP。

2、网络模型：

1）OSI参考模型：7层

应用层

表示层

会话层

传输层（UDP、TCP）

网络层（IP地址）

数据链路层

物理层

2）TCP/IP参考模型：4层

应用层

传输层

网际层

主机至网络层

3、IP地址：InetAddress

本地回环地址：127.0.0.1

主机名：localhost

[java]  view plain copy

1. public static void main(String[] args) throws Exception{  
2.     InetAddress i = InetAddress.getLocalHost();  
3.     //获取主机名称+ip地址  
4. /       System.out.println(i.toString());  
5.     //获取主机地址  
6. /       System.out.println("address:"+i.getHostAddress());  
7.     //获取主机名称  
8. /       System.out.println("name:"+i.getHostName());  
9.       
10.     InetAddress ia = InetAddress.getByName("192.168.1.102");  
11.     System.out.println("address:"+ia.getHostAddress());  
12.     System.out.println("name:"+ia.getHostName());  
13. }  

4、端口名

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

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

5、传输协议

通讯的规则

常见协议：TCP,UDP

6、UDP

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

每个数据包的大小限制在64k内

因无连接，是不可靠协议

不需要建立连接，速度快

7、TCP

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

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

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

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

8、Socket

Socket就是为网络服务提供的一种机制。

通信的两端都有Socket

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

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

[java]  view plain copy

1. /* 
2. 需求：通过udp传输方式，将一段文字数据发送出去 
3. 思路： 
4. 1、建立udpsocket服务 
5. 2、提供数据，并将数据封装到数据包中 
6. 3、通过socket服务的发送功能，将数据包发出去 
7. 4、关闭资源 
8. */  
9. public class UdpsendDemo {  
10.   
11.     public static void main(String[] args)throws Exception {  
12.     //1、创建udp服务，通过DatagramSocket对象  
13.         DatagramSocket ds = new DatagramSocket(8888);  
14.         //2、确定数据，并封装成数据包  
15.         byte[] buf = "udp ge men lai le".getBytes();  
16.         DatagramPacket dp = new DatagramPacket(buf,buf.length,InetAddress.getByName("127.0.0.1"),10000);  
17.         //3、通过socket服务，将已有的数据包发送出去，通过send方法  
18.         ds.send(dp);  
19.         //4、关闭资源  
20.         ds.close();  
21.     }  
22. }  

[java]  view plain copy

1. /* 
2. 需求：定义一个应用程序，用于接收udp协议传输的数据并处理 
3. 思路： 
4. 1、定义udpsocket,通常会监听一个端口，其实就是给这个接收网络应用程序定义数字标识 
5. 2、定义一个数据包，因为要存储接收到的字节数据，因为数据包对象中有更多功能可以提取字节数据中的不同数据信息 
6. 3、通过socket服务的receive方法将收到的数据存入已定好的数据包中 
7. 4、通过数据包对象的特有功能，将这些不同的数据取出，并打印在控制台上 
8. 5、关闭资源 
9.  
10. */  
11. public class UdpReceiveDemo {  
12.   
13.     public static void main(String[] args) throws Exception{  
14.         //1、创建udp socket，建立端点  
15.         DatagramSocket ds = new DatagramSocket(10000);  
16.         //2、定义数据包，用于存储数据  
17.         byte[] buf = new byte[1024];  
18.         DatagramPacket dp = new DatagramPacket(buf,buf.length);  
19.         //3、通过服务的receive方法将收到数据存入数据包中  
20.         ds.receive(dp);  
21.         //4、通过数据包的方法获取其中的数据  
22.         String ip = dp.getAddress().getHostAddress();  
23.         String data = new String(dp.getData(),0,dp.getLength());  
24.         int port = dp.getPort();  
25.           
26.         System.out.println(ip+"::"+data+"::"+port);  
27.         //5、关闭资源  
28.         ds.close();  
29.     }  
30. }  

[java]  view plain copy

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

9、TCP传输

[java]  view plain copy

1. /* 
2. 演示tcp的传输的客户端和服务端的互访 
3. 需求：客户端服务端发送数据，服务端收到后，给客户端反馈信息 
4.  
5. 客户端： 
6. 1、建立socket服务，指定要连接主机和端口 
7. 2、获取socket流中的输出流，将数据写到该流中，通过网络发送给服务端 
8. 3、获取socket流中的输入流，将服务端反馈的数据获取到，并打印 
9. 4、关闭客户端资源 
10. */  
11. public class TcpClientDemo2 {  
12.   
13.     public static void main(String[] args)throws Exception {  
14.         Socket s = new Socket("192.168.1.102",10005);  
15.           
16.         OutputStream out = s.getOutputStream();  
17.         out.write("服务端，你好".getBytes());  
18.           
19.         InputStream in = s.getInputStream();  
20.         byte[] buf = new byte[1024];  
21.         int len = in.read(buf);  
22.         System.out.println(new String(buf,0,len));  
23.         s.close();  
24.           
25.     }  
26.   
27. }  

[java]  view plain copy

1. public class TcpServerDemo2 {  
2.   
3.     public static void main(String[] args)throws Exception {  
4.         ServerSocket ss = new ServerSocket(10005);  
5.         Socket s = ss.accept();  
6.         String ip = s.getInetAddress().getHostAddress();  
7.         System.out.println(ip+"....connected");  
8.         InputStream in = s.getInputStream();  
9.         byte[] buf = new byte[1024];  
10.         int len = in.read(buf);  
11.         System.out.println(new String(buf,0,len));  
12.         OutputStream out = s.getOutputStream();  
13.         out.write("shoudaole ".getBytes());  
14.         s.close();  
15.         ss.close();  
16.   
17.     }  
18.   
19. }  

[java]  view plain copy

1. public class TcpUploadClientTest {  
2.   
3.     public static void main(String[] args)throws Exception {  
4.         Socket s = new Socket("192.168.1.102",10007);  
5.         BufferedReader bufr = new BufferedReader(new FileReader(""));  
6.         PrintWriter out = new PrintWriter(s.getOutputStream(),true);  
7.         String line = null;  
8.         while((line= bufr.readLine())!=null) {  
9.             out.println(line);  
10.         }  
11.         s.shutdownOutput();//关闭客户端的输出流，相当于给流中加入一个结束标记-1  
12. //      out.println("over");  
13.         BufferedReader bufIn = new BufferedReader(new InputStreamReader(s.getInputStream()));  
14.         String str = bufIn.readLine();  
15.         System.out.println(str);  
16.         bufr.close();  
17.         s.close();  
18.     }  
19. }  

[java]  view plain copy

1. public class TcpUploadServerTest {  
2.   
3.     public static void main(String[] args)throws Exception {  
4.         ServerSocket ss = new ServerSocket(10007);  
5.         Socket s = ss.accept();  
6.         BufferedReader bufIn = new BufferedReader(new InputStreamReader(s.getInputStream()));  
7.         PrintWriter out = new PrintWriter(new FileWriter(""),true);  
8.         String line = null;  
9.         while((line=bufIn.readLine())!=null) {  
10. //          if("over".equals(line))  
11. //              break;  
12.             out.println(line);  
13.         }  
14.         PrintWriter pw = new PrintWriter(s.getOutputStream(),true);  
15.         pw.println("长传成功");  
16.         out.close();  
17.         s.close();  
18.         ss.close();  
19.     }  
20. }  

----------------------  ASP.Net+Android+IOS开发 、 href="http://edu.csdn.net"target="blank">.Net培训 、期待与您交流！ ----------------------详细请查看： http://edu.csdn.net