網路編程2--畢向東java基礎教程視頻學習筆記

Day 2308 Udp接收端09 Udp鍵盤錄入數據方式10 Udp聊天11 TCP傳輸12 TCP傳輸213 TCP練習14 TCP複製文件08 Udp接收端需求：定義一個應用程式，用於接收udp協議傳輸的數據並處理。思路：1.定義UdpSocket服務。2.定義一個數據報包，因為要存儲接收到的...

Day 23

08 Udp接收端
09 Udp鍵盤錄入數據方式
10 Udp聊天
11 TCP傳輸
12 TCP傳輸2
13 TCP練習
14 TCP複製文件

08 Udp接收端

需求：
定義一個應用程式，用於接收udp協議傳輸的數據並處理。

思路：
1.定義UdpSocket服務。
2.定義一個數據報包，因為要存儲接收到的位元組數據，
而數據報包對象中有更多的功能可以提取位元組數據中不同的數據信息。
3.通過socket服務的receive方法將接收到的數據存入已經定義好的數據報包中。
4.通過數據報包對象的特有功能。將這些不同的數據取出，列印在控制臺上。
5.關閉資源。

 1 import java.net.*;
 2 public class UdpReceive 
 3 {
 4     public static void main(String[] args) 
 5     {
 6         try
 7         {
 8             //1.創建Udp Socket，建立端點
 9         DatagramSocket ds=new DatagramSocket(10000);
10 
11         //2.定義數據報包，用來存儲數據
12         byte[] buf=new byte[1024];
13         DatagramPacket dp=new DatagramPacket(buf,buf.length);
14 
15         //3.通過Socket服務的receive方法接收到的數據存入數據包
16         ds.receive(dp);
17 
18         //通過數據報包中的方法獲取其中的數據
19         String ip=dp.getAddress().getHostAddress();
20         String data=new String(dp.getData(),0,dp.getLength());
21         int port=dp.getPort();
22 
23         System.out.println(ip+"::"+data+"::"+port);
24         //關閉資源
25          ds.close();
26             
27         }
28         catch (Exception e)
29         {
30             e.printStackTrace();
31         }
32     
33     }
34 }

View Code

09 Udp鍵盤錄入數據方式

read和receive都是阻塞式方法，如果接收不到數據，就會等待。

java.net包和java.io包通常一起使用。

測試程式如下：

 1 public class UdpSend2 
 2 {
 3     public static void main(String[] args) throws IOException
 4     {
 5         DatagramSocket ds=new DatagramSocket(10001);
 6         BufferedReader bufr=
 7             new BufferedReader(new InputStreamReader(System.in));
 8         String line=null;
 9         while((line=bufr.readLine())!=null)
10         {
11             byte[] buf=line.getBytes();
12             
13             DatagramPacket dp=new DatagramPacket(buf,buf.length,InetAddress.getLocalHost(),10000);
14             ds.send(dp);
15         }
16         ds.close();
17     }
18 }

View Code

 1 import java.net.*;
 2 import java.io.*;
 3 public class UdpReceived2 
 4 {
 5     public static void main(String[] args) throws Exception
 6     {
 7         DatagramSocket ds=new DatagramSocket(10000);
 8         while(true)
 9         {
10             byte[] buf=new byte[1024];
11             DatagramPacket dp=new DatagramPacket(buf,buf.length);
12             ds.receive(dp);
13             String ip=dp.getAddress().getHostAddress();
14             String data=new String(buf,0,dp.getLength());
15             System.out.println(ip+"::"+data);
16         }
17         
18     }
19 }

View Code

10 Udp聊天

實現簡單的聊天功能，以ip地址辨別不同身份。

 1 /*
 2 聊天
 3 */
 4 import java.net.*;
 5 import java.io.*;
 6 class Send implements Runnable 
 7 {
 8     private DatagramSocket s;
 9     public Send(DatagramSocket s)
10     {
11         this.s=s;
12     }
13     public void run()
14     {
15         try
16         {
17             BufferedReader br=
18                 new BufferedReader(new InputStreamReader(System.in));
19             String line=null;
20             while((line=br.readLine())!=null)
21             {
22                 if("over".equals(line))
23                     break;
24                 byte[] buf=line.getBytes();
25                 DatagramPacket dp=
26                     new DatagramPacket(buf,buf.length,InetAddress.getByName("172.29.115.1"),10005);
27                 s.send(dp);
28 
29             }
30         }
31         catch (Exception e)
32         {
33             throw new RuntimeException("發送端失敗！");
34 
35         }
36     }
37 }
38 class Receive implements Runnable 
39 {
40     private DatagramSocket s;
41     public Receive(DatagramSocket s)
42     {
43         this.s=s;
44     }
45     public void run()
46     {
47         try
48         {
49             while(true)
50             {
51                 byte[] buf=new byte[1024];
52                 DatagramPacket dp=new DatagramPacket(buf,buf.length);
53                 s.receive(dp);
54                 String ip=dp.getAddress().getHostAddress();
55                 String data=new String(dp.getData(),0,dp.getLength());
56                 System.out.println(ip+"::"+data);
57 
58             }
59         }
60         catch (Exception e)
61         {
62             throw new RuntimeException("接受端失敗！");
63 
64         }
65     }
66 }
67 public class ChatDemo
68 {
69     public static void main(String[] args)throws Exception
70     {
71         DatagramSocket send=new DatagramSocket();
72         DatagramSocket rece=new DatagramSocket(10005);
73 
74         new Thread(new Send(send)).start();
75         new Thread(new Receive(rece)).start();
76     }
77 
78 }

View Code

11 TCP傳輸

TCP傳輸
Socket和ServerSocket
建立客戶端和伺服器端
建立連接後，通過Socket中的IO流進行數據傳輸
關閉Socket
同樣，伺服器端和客戶端是兩個獨立的應用程式。

 1 /*
 2 需求：給伺服器端發送一個文本數據
 3 步驟：
 4 1.創建Socket服務，並指定要連接的主機和埠
 5 */
 6 import java.net.*;
 7 import java.io.*;
 8 class  TcpClient
 9 {
10     public static void main(String[] args) 
11     {
12         try
13         {
14             //創建客戶端的Socket服務，指定目的主機和埠
15             Socket s=new Socket("127.0.0.1",10000);
16 
17             //為了發送數據，應該獲取Socket中的輸出流。
18             OutputStream out=s.getOutputStream();
19 
20             out.write("hahaha".getBytes());
21             s.close();
22 
23         }
24         catch (Exception e)
25         {
26             throw new RuntimeException("客戶端建立失敗！");
27         }
28         
29 
30     }
31 }
32 /*
33 需求：定義端點接收數據並列印在控制台。
34 服務端：
35 1.建立服務端的socket服務，ServerSocket（）；
36 並監聽一個埠
37 2.獲取連接過來的客戶端對象。
38 通過ServerSocket的accept方法。
39 沒有連接，就一直等待，所以這是一個阻塞式方法。
40 3.客戶端如果發送來數據，那麼服務端要使用對應的客戶端對象，並獲取到該客戶端
41 對象的讀取流來讀取發過來的數據。
42 4.關閉服務端。
43 */
44 class TcpServer 
45 {
46     public static void main(String[] args) 
47     {
48         try
49         {
50         ServerSocket ss=new ServerSocket(10000);
51         Socket s=ss.accept();
52         String ip=s.getInetAddress().getHostAddress();
53         
54         InputStream in=s.getInputStream();
55         byte[] buf=new byte[1024];
56         int len=in.read(buf);
57         System.out.print(ip+":");
58         System.out.println(new String(buf,0,len));
59 
60         s.close();
61             
62         }
63         catch (Exception e)
64         {
65             throw new RuntimeException("服務端建立失敗！");
66         }
67 
68         
69     }
70 }

View Code

12 TCP傳輸2

演示tcp的傳輸的客戶端和服務端的互訪
需求：客戶端給服務端發送數據，服務端收到後，給客戶端反饋信息。

客戶端：
1.建立socket服務。指定要連接主機和埠。
2.獲取socket流中的輸出流。將數據寫到該流中，通過網路發送給服務端。
3.獲取socket流中的輸入流，將伺服器反饋的數據獲取到，並列印。
4.關閉客戶端。

 1 import java.net.*;
 2 import java.io.*;
 3 class TcpClient2 
 4 {
 5     public static void main(String[] args) 
 6     {
 7         try
 8         {
 9             Socket s=new Socket("172.29.115.1",10000);
10         OutputStream os=s.getOutputStream();
11         os.write("你好啊，服務端！".getBytes());
12         
13         byte[] buf=new byte[1024];
14         InputStream is=s.getInputStream();
15         int len=is.read(buf);
16         System.out.println(new String(buf,0,len));
17         s.close();
18         }
19         catch (Exception e)
20         {
21             throw new RuntimeException("客戶端建立失敗！");
22         }
23 
24     }
25 }
26 class TcpServer2
27 {
28     public static void main(String[] args) 
29     {
30         try
31         {
32             ServerSocket ss=new ServerSocket(10000);
33             Socket s=ss.accept();
34 
35             InputStream is=s.getInputStream();
36             byte[] buf=new byte[1024];
37             int len=is.read(buf);
38             System.out.println(s.getInetAddress().getHostAddress()+"::"+new String(buf,0,len));
39 
40             OutputStream os=s.getOutputStream();
41             os.write("你也好，歡迎光臨！".getBytes());
42 
43             s.close();
44             ss.close();
45 
46             
47         }
48         catch (Exception e)
49         {
50             throw new RuntimeException("服務端建立失敗！");
51         }
52     }
53 }

View Code

13 TCP練習

需求：建立一個文本形式轉換伺服器。
客戶端給服務端發送文本，服務端會將文本轉換成大寫再返回給服務端。
而且，客戶端可以不斷地進行文本發送，當客戶端輸入over時，轉換結束。

分析：
客戶端：
既然是操作設備上的數據，那麼就可以使用io技術，並且按照io的操作規律來思考。
源：鍵盤錄入
目的：網路設備，網路輸出流
而且操作的是文本數據，可以選擇字元流。

步驟：
1.建立服務
2.獲取鍵盤錄入
3.將數據發送給服務端
4.接受服務端返回的大寫數據
5.結束，關閉資源。

 1 import java.net.*;
 2 import java.io.*;
 3 class  TransClient
 4 {
 5     public static void main(String[] args) throws Exception
 6     {
 7         //建立socket服務
 8         Socket s=new Socket("172.29.115.1",10000);
 9         //獲取鍵盤錄入
10         BufferedReader bufr=
11             new BufferedReader(new InputStreamReader(System.in));
12         //向服務端發送數據
13         BufferedWriter bufOut=
14             new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));
15         String line=null;
16         //接受服務端返回的數據
17         BufferedReader bufIn=
18             new BufferedReader(new InputStreamReader(s.getInputStream()));
19         while((line=bufr.readLine())!=null)
20         {
21             if("over".equals(line))
22                 break;
23             bufOut.write(line);
24             bufOut.newLine();
25             bufOut.flush();
26             
27             String str=bufIn.readLine();
28             System.out.println("server:"+str);
29 
30         }
31         bufr.close();
32         s.close();
33         
34 
35         
36         
37     }
38 }
39 class  TransServer
40 {
41     public static void main(String[] args) throws Exception
42     {
43         //建立服務
44         ServerSocket  ss=new ServerSocket(10000);
45         Socket s=ss.accept();
46         
47         //接受客戶端的數據
48         BufferedReader bufIn=new BufferedReader(new InputStreamReader(s.getInputStream()));
49 
50         //返回給客戶端大寫的文本
51         BufferedWriter bufOut=new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));
52 
53         String line=null;
54 
55         while((line=bufIn.readLine())!=null)
56         {
57             System.out.println(line);
58             bufOut.write(line.toUpperCase());
59             bufOut.newLine();
60             bufOut.flush();
61         }
62         
63         ss.close();
64 
65         
66     }
67 }

View Code

14 TCP複製文件

從客戶端向服務端上傳文件。

 1 import java.net.*;
 2 import java.io.*;
 3 class  TextClient
 4 {
 5     public static void main(String[] args) throws Exception
 6     {
 7         Socket s=new Socket("127.0.0.1",10006);
 8         BufferedReader bufr=
 9             new BufferedReader(new FileReader("ChatDemo.java"));
10         PrintWriter out=new PrintWriter(s.getOutputStream(),true);
11         String line=null;
12         while((line=bufr.readLine())!=null)
13         {
14             out.println(line);
15         }
16         s.shutdownOutput();
17         BufferedReader bufIn=new BufferedReader(new InputStreamReader(s.getInputStream()));
18         String  str=bufIn.readLine();
19         System.out.println("server:"+str);
20         bufr.close();
21         s.close();
22 
23         
24     }
25 }
26 class  TextServer
27 {
28     public static void main(String[] args) throws Exception
29     {
30         ServerSocket ss=new ServerSocket(10006);
31         Socket s=ss.accept();
32         System.out.println(s.getInetAddress().getHostAddress()+"....connected");
33         BufferedReader bufIn=
34             new BufferedReader(new InputStreamReader(s.getInputStream()));
35         PrintWriter out=new PrintWriter(new FileWriter("server.txt"),true);
36         String line=null;
37         while((line=bufIn.readLine())!=null)
38         {
39             out.println(line);
40 
41         }
42         PrintWriter pw=new PrintWriter(s.getOutputStream(),true);
43         pw.println("上傳成功！");
44 
45         s.close();
46         ss.close();
47         out.close();
48     
49     }
50 }

View Code