学了这么久的网络编程，该有一份完整的笔记整理（终）

最新推荐文章于 2024-09-18 12:54:15 发布

码歌大大

最新推荐文章于 2024-09-18 12:54:15 发布

阅读量110

点赞数

文章标签：网络编程笔记整理

本文链接：https://blog.csdn.net/u014332333/article/details/86626890

版权

书接上文，上次我们整理到网络编程的UDP。今天我们继续，把有关网络编程的做一次完整的梳理。（温馨提示：案例多，篇幅长，适合想夯实基础，挑战高级）

TCP协议

特点：

面向有链接
数据传输安全
数据传输量大
效率低

案例1

服务端

1.package com. mage.net.tcp;  
2.  
3.import java.io.IOException;  
4.import java.io.InputStream;  
5.import java.io.InputStreamReader;  
6.import java.net.ServerSocket;  
7.import java.net.Socket;  
8.  
9./** 
10. * 通过tcp协议： 
11. *  编写服务端 
12. *  
13. * @author 老薛 
14. * @date 创建时间 猴年马月 
15. * @version 1.0 
16. */  
17.public class Server {  
18.    public static void main(String[] args) {  
19.          
20.        try {  
21.            //创建服务端serversocket对象  
22.            ServerSocket server = new ServerSocket(7777);
23.              
24.            //获取对用的客户端的socket对象  
25.            Socket client = server.accept();
26.              
27.            //获取客户端的输入流对象读取信息  
28.            InputStream is = client.getInputStream();  
29.              
30.            //读取信息  
31.            byte [] buf = new byte[1024];  
32.            int len = is.read(buf);  
33.              
34.            //输出  
35.            System.out.println(client.getInetAddress().getHostAddress()+"发送消息："+new String(buf,0,len));  
36.              
37.        } catch (IOException e) {  
38.            e.printStackTrace();  
39.        }  
40.          
41.          
42.    }  
43.      
44.}

客户端

1.package com. mage.net.tcp;  
2.  
3.import java.io.IOException;  
4.import java.io.OutputStream;  
5.import java.net.Socket;  
6.import java.net.UnknownHostException;  
7.  
8./** 
9. * 通过tcp协议链接 
10. *  编写客户端 
11. * @author 老薛
12. * @date 创建时间 猴年马月 
13. * @version 1.0 
14. */  
15.public class Client {  
16.    public static void main(String[] args) {  
17.          
18.        try {  
19.            //创建客户端socket对象  
20.            Socket client = new Socket("127.0.0.1", 7777);
21.              
22.            //编写发送信息  
23.            String str = "Tcp 协议报道";  
24.            //获取socket建立的流信息  
25.            OutputStream os = client.getOutputStream();  
26.            //发送信息  
27.            os.write(str.getBytes());  
28.            //关闭  
29.            os.close();  
30.            client.close();  
31.        } catch (UnknownHostException e) {  
32.            e.printStackTrace();  
33.        } catch (IOException e) {  
34.            e.printStackTrace();  
35.        }  
36.          
37.    }  
38.      
39.}

案例2:客户端上传文件到服务端

服务端：

1.package com. mage.net.tcp.update;  
2.  
3.import java.io.BufferedReader;  
4.import java.io.BufferedWriter;  
5.import java.io.FileWriter;  
6.import java.io.IOException;  
7.import java.io.InputStream;  
8.import java.io.InputStreamReader;  
9.import java.io.OutputStream;  
10.import java.io.OutputStreamWriter;  
11.import java.io.PrintWriter;  
12.import java.net.ServerSocket;  
13.import java.net.Socket;  
14.  
15./** 
16. * 通过tcp协议： 
17. *  编写服务端 
18. *  
19. * @author 老薛
20. * @date 创建时间 猴年马月 
21. * @version 1.0 
22. */  
23.public class Server {  
24.    public static void main(String[] args) {  
25.          
26.        try {  
27.            //创建服务端serversocket对象  
28.            ServerSocket server = new ServerSocket(7777);  
29.              
30.            //获取对用的客户端的socket对象  
31.            Socket client = server.accept();  
32.              
33.            //获取客户端的输入流对象读取信息  
34.            BufferedReader br = new BufferedReader(new InputStreamReader(client.getInputStream()));  
35.              
36.            //将文件写入  
37.            BufferedWriter pw = new BufferedWriter(new FileWriter("C:/Users/wawjy/Desktop/server.txt"));  
38.              
39.            //读取信息  
40.            String line = null;  
41.            while((line=br.readLine())!=null){  
42.                pw.write(line);  
43.                pw.write("\r\n");  
44.                pw.flush();  
45.            }  
46.              
47.            //输出  
48.            //给客户端发送信息  
49.            BufferedWriter pwSocket = new BufferedWriter(new OutputStreamWriter(client.getOutputStream()));  
50.            //发送信息  
51.            pwSocket.write("上传成功");  
52.              
53.            pwSocket.close();  
54.              
55.        } catch (IOException e) {  
56.            e.printStackTrace();  
57.        }  
58.          
59.          
60.    }  
61.      
62.}

客户端：

1.package com. mage.net.tcp.update;  
2.  
3.import java.io.BufferedReader;  
4.import java.io.BufferedWriter;  
5.import java.io.FileReader;  
6.import java.io.FileWriter;  
7.import java.io.IOException;  
8.import java.io.InputStream;  
9.import java.io.InputStreamReader;  
10.import java.io.OutputStream;  
11.import java.io.OutputStreamWriter;  
12.import java.io.PrintWriter;  
13.import java.net.Socket;  
14.import java.net.UnknownHostException;  
15.  
16./** 
17. * 通过tcp协议链接 
18. *  编写客户端 
19. * @author 老薛
20. * @date 创建时间 猴年马月 
21. * @version 1.0 
22. */  
23.public class Client {  
24.    public static void main(String[] args) {  
25.          
26.        try {  
27.            //创建客户端socket对象  
28.            Socket client = new Socket("127.0.0.1", 7777);  
29.              
30.              
31.            //获取socket建立的流信息  
32.            OutputStream os = client.getOutputStream();  
33.            //获取读取文件流  
34.            BufferedReader reader = new BufferedReader(  
35.                    new FileReader("C:/Users/wawjy/Desktop/client.txt"));  
36.              
37.            //通过socket的输出流写出  
38.            BufferedWriter pw = new BufferedWriter(new OutputStreamWriter(client.getOutputStream()));  
39.            String line = null;  
40.            while((line=reader.readLine())!=null){  
41.                pw.write(line);  
42.                pw.write("\r\n");  
43.                pw.flush();  
44.                System.out.println(line);  
45.            }  
46.              
47.            client.shutdownOutput();  
48.              
49.              
50.            //接收服务端的发送信息  
51.            //获取客户端的输入流对象读取信息  
52.            BufferedReader bufIn = new BufferedReader(new InputStreamReader(client.getInputStream()));  
53.              
54.            //读取信息  
55.            String msg = bufIn.readLine();  
56.              
57.            //输出  
58.            System.out.println(msg);  
59.              
60.            //关闭  
61.            bufIn.close();  
62.            os.close();  
63.            client.close();  
64.        } catch (UnknownHostException e) {  
65.            e.printStackTrace();  
66.        } catch (IOException e) {  
67.            e.printStackTrace();  
68.        }  
69.          
70.    }  
71.      
72.}

案例3:多线程图片上传

客户端

1.package com. mage.net.tcp;  
2.  
3.import java.io.File;  
4.import java.io.FileInputStream;  
5.import java.io.IOException;  
6.import java.io.InputStream;  
7.import java.io.OutputStream;  
8.import java.net.Socket;  
9.import java.net.UnknownHostException;  
10.  
11./** 
12. * 客户端： 
13. *  发送一个图片的路径 将该路径下的图片发送到服务端 
14. *  通过编译时指定参数的方式 指定图片上传路径 
15. * @author 老薛 
16. * @date 创建时间 猴年马月 
17. * @version 1.0 
18. */  
19.public class TcpPictureUploadClient {  
20.      
21.    public static void main(String[] args) throws UnknownHostException, IOException {  
22.          
23.        //1、对于传入的文件路径进行判定  
24.          
25.        //a、获取参数  
26.        File file = new File(args[0]);
27.          
28.        //b、判定文件是否存在  
29.        if(!(file.exists()&&file.isFile())){  
30.            System.out.println("输入的不是文件或者文件不存在");  
31.            return;  
32.        }  
33.          
34.        //c、查看文件的格式  
35.        if(!(file.getName().endsWith(".jpg"))){  
36.            System.out.println("图片格式有误 请重新选择");  
37.            return;  
38.        }  
39.          
40.        //d、文件上传的大小限制  
41.        if(file.length()>5*1024*1024){  
42.            System.out.println("文件上传太大");  
43.            return;  
44.        }
45.          
46.        //2、开始上传  
47.        //a、创建客户端socket对象  
48.        Socket client = new Socket("192.168.1.107",10006);  
49.          
50.        //b、获取图片输入流 读取图片信息  
51.        FileInputStream fis = new FileInputStream(file);  
52.        //c、获取输出流 从客户端发送到服务端  
53.        OutputStream os = client.getOutputStream();  
54.        //d、获取图片 并且发送  
55.        byte [] buf = new byte[5*1024*1024];  
56.        int len = 0;  
57.        while((len=fis.read(buf))!=-1){  
58.            os.write(buf,0,len);  
59.        }  
60.          
61.        //e、切断流信息  
62.        client.shutdownOutput();  
63.          
64.        //f、获取服务端发送的是否上传成功  
65.        InputStream is = client.getInputStream();  
66.        byte [] bufIn = new byte[1024];  
67.        int lenIn = is.read(bufIn);  
68.        System.out.println(new String(bufIn,0,lenIn));  
69.          
70.        //关闭流  
71.        fis.close();  
72.        client.close();  
73.    }  
74.}

服务端

1.package com. mage.net.tcp;  
2.  
3.import java.io.File;  
4.import java.io.FileOutputStream;  
5.import java.io.IOException;  
6.import java.io.InputStream;  
7.import java.io.OutputStream;  
8.import java.net.ServerSocket;  
9.import java.net.Socket;  
10.  
11./** 
12. * 服务端： 
13. *  一直接受客户端发送的上传信息 并且可以处理多个客户端同时上传 
14. *  如果相同的客户端上传了相同文件多次 在文件名称上予以显示 
15. * @author 老薛
16. * @date 创建时间 猴年马月 
17. * @version 1.0 
18. */  
19.public class TcpPictureUploadServer {  
20.      
21.    public static void main(String[] args) throws IOException {  
22.          
23.        //1、创建服务端socket对象  
24.        ServerSocket server = new ServerSocket(10006);  
25.        while(true){  
26.              
27.            //2、通过accept方法 获取不同客户端的socket对象  
28.            Socket client = server.accept();  
29.              
30.            new Thread(new UploadPicThread(client)).start();
31.        }  
32.          
33.    }  
34.      
35.      
36.}

多线程：

1.package com. mage.net.tcp;  
2.  
3.import java.io.File;  
4.import java.io.FileOutputStream;  
5.import java.io.InputStream;  
6.import java.io.OutputStream;  
7.import java.net.Socket;  
8.  
9./** 
10. * 服务端只能服务一个客户端 多个客户端同时访问  
11. * 第一个先完成 第二个才能继续操作 
12. * @author 老薛 
13. * @date 创建时间 猴年马月 
14. * @version 1.0 
15. */  
16.public class UploadPicThread implements Runnable{  
17.  
18.    private Socket client;  
19.    public UploadPicThread(Socket client) {  
20.        this.client = client;  
21.    }  
22.    @Override  
23.    public void run() {  
24.        int count = 1; 
25.        try{  
26.              
27.            //获取对应发送请求的客户端的ip地址  
28.            String ip = client.getLocalAddress().getHostAddress();  
29.              
30.            //创建file  
31.            File f = new File(ip+"("+count+")"+".jpg");  
32.              
33.              
34.            while(f.exists()){  
35.                f = new File(ip+"("+(count++)+")"+".jpg");  
36.            }  
37.              
38.            //3、获取处理上传图片的流对象  
39.            FileOutputStream fos = new FileOutputStream(f);
40.              
41.            //4、获取客户端的输入流对象 获取上传文件  
42.            InputStream is = client.getInputStream();  
43.            byte [] buf = new byte[5*1024*1024];  
44.            int len = 0;  
45.            while((len=is.read(buf))!=-1){  
46.                fos.write(buf, 0, len);  
47.            }  
48.              
49.            //5、给客户端返回成功结果  
50.            OutputStream os = client.getOutputStream();  
51.            os.write("上传成功".getBytes());  
52.            fos.close();  
53.            client.close();  
54.        }catch (Exception e) {  
55.            System.out.println("上传失败");  
56.        }  
57.    }  
58.      
59.      
60.}