网络编程

发表于 | 更新于:
终日思不如须臾所学也

1. 计算机网络

计算机网络是指将地理位置不同的具有独立功能的多台计算机及其外部设备，通过通信线路连接起来，在网络操作系统，网络管理软件及网络通信协议的管理和协调下，目的是为了实现资源共享和信息传递的计算机系统。

1.1 需要准备

  • 通信双方地址和端口号：IP地址：端口号

  • 规则：Java Web :网页编程 （B/S）网络编程:TCP/IP （C/S）

  • 协议：TCP/IP OSI七层模型

    对应的协议

    对应的设备

1.2 IP地址（InetAddress）

  • 唯一定位一台网络上计算机
  • 127.0.0.1：本机 localhost
  • 分类：IPV4 IPV6，公网，私网（局域网）
  • 域名：记忆IP问题

1.3 端口

  • 不同的进程有不同的端口号，用来区分软件；

  • 被规定0-65535

  • TCP,UDP:65535*2 tcp:80 udp:80,但单个协议端口不能重复

  • 分类：

    公有端口：0-1023

    • HTTP : 80
    • HTTPS:443
    • FTP:21
    • Telnet:23

    程序注册端口：1024-49151，分配用户或者程序

    • Tomcat：8080
    • MySQL：3306
    • Redis：6379
    • Oracle:1521
    • 动态，私有端口：49152-65535
1
2
3
4
5
6
#查看所有端口
netstat -ano
#查看指定端口
netstat -ano|findstr "5040"
#查找指定端口进程
tasklist|findstr "4444"
  • 使用Ctrl+Shfit+ESC打开任务管理器

1.4 通信协议

  • 网络通信协议：速率，传输码率，代码结构，传输控制…
  • TCP:用户传输协议：打电话，客户端、服务端，传输完成，释放连接，效率低；
    • 三次挥手，四次握手
  • UDP：用户数据报协议：发短信，不连接，不稳定，导弹，DDOS（饱和攻击）

2. TCP

ServerSocket类常用方法
方法 类型 说明
public ServerSocket(int var1) throws IOException 构造 开辟一个指定的端口监听，一般使用5000以上
public Socket accept() throws IOException 普通 服务器端接收客户端请求，通过Socket返回
public void close() throws IOException 普通 关闭服务器端
Socket类常用方法
方法 类型 说明
public Socket(String var1, int var2) throws UnknownHostException, IOException 构造 指定要连接的主机和端口
public OutputStream getOutputStream() throws IOException 普通 取得指定客户端的输出对象，使用的时候肯定使用PrintStream装饰操作
public InputStream getInputStream() throws IOException 普通 从指定客户端读取对象，使用Scanner操作

2.1 客户端

自定义叫C（customize），浏览器叫B

  • 连接服务器

  • 发送消息

  • Echo程序模型栗子：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
package com.xxy.test;

import java.io.IOException;
import java.io.OutputStream;
import java.net.InetAddress;
import java.net.Socket;
import java.net.UnknownHostException;

//客户端
public class TcpClientDemo01 {
    public static void main(String[] args) {
        Socket socket = null;
        OutputStream os = null;
        try {
            //1. 知道服务器的地址IP
            InetAddress serverIp = InetAddress.getByName("127.0.0.1");
            //2.端口号
            int port = 9999;
            //3.创建一个socket连接
             socket = new Socket(serverIp,port);
            //4. 发送消息IO
             os = socket.getOutputStream();
            os.write("hello".getBytes());



        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (socket != null) {
                try {
                    socket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (os != null) {
                try {
                    os.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }

        }

    }
}

2.2 服务端

自定义叫S，Tomocat叫S

  • 建立服务端口（进程）

  • 等待用户的连接（accept）

  • 接受用户的信息

  • 栗子

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
package com.xxy.test;

import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.net.ServerSocket;
import java.net.Socket;

//服务端
public class TcpServerDemo01 {
    public static void main(String[] args) {
        ServerSocket serverSocket = null;
        Socket socket = null;
        InputStream is = null;
        ByteArrayOutputStream baos = null;
        try {
            //1. 服务器地址
             serverSocket = new ServerSocket(9999);
             while (true) {
                 //2. 与客户端进行连接
                 socket = serverSocket.accept();
                 //3.读取客户端的消息
                 is = socket.getInputStream();
           /* byte[] buffer = new byte[1024];
            int len;
            while ((len = is.read(buffer)) != -1) {
                 msg = new String(buffer,0,len);
            }
            System.out.println(msg);*/
                 //管道流
                 baos = new ByteArrayOutputStream();
                 byte[] buffer = new byte[1024];
                 int len;
                 while ((len = is.read(buffer)) != -1) {
                     baos.write(buffer, 0, len);
                 }
                 System.out.println(baos.toString());
             }

        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (baos != null) {
                try {
                    baos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (is != null) {
                try {
                    is.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
           if (socket != null) {
               try {
                   socket.close();
               } catch (IOException e) {
                   e.printStackTrace();
               }
           }
            if (serverSocket != null) {
                try {
                    serverSocket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }

        }
    }

}

3. 文件上传

  • 栗子：
  • 客户端：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
package com.xxy.test1;

import java.io.*;
import java.net.InetAddress;
import java.net.Socket;
import java.net.UnknownHostException;
import java.util.Scanner;

public class TcpClientDemo02 {
    public static void main(String[] args) throws Exception {
        //1.创建一个Socket连接
        Socket socket = new Socket(InetAddress.getByName("127.0.0.1"),9000);
        //2. 创建一个输出流
        OutputStream os  = socket.getOutputStream();
        //3. 读取文件
       FileInputStream fis =  new FileInputStream(new File("hello.jpg"));
       //4. 写出文件
        byte[] buffer = new byte[1024];
        int len;
        while ((len = fis.read(buffer)) != -1) {
            os.write(buffer,0,len);
        }

        //通知服务器，我已经传输完了
        socket.shutdownOutput();
        //5.确定服务器接收完毕，才能断开连接
        InputStream is  = socket.getInputStream();
        //6. String byte[]
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        byte[] buffer1 = new byte[1024];
        int len1;
        while ((len1 = is.read(buffer1)) != -1) {
            baos.write(buffer1,0,len1);
        }
        //5.关闭资源
        baos.close();
        is.close();
        os.close();
        fis.close();
        socket.close();
    }
}

服务端：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
package com.xxy.test1;

import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;

public class TcpServerDemo02 {
    public static void main(String[] args) throws Exception {
        //1.创建服务
        ServerSocket serverSocket = new ServerSocket(9000);
        //2. 监听客户端的连接,阻塞式监听，一直等待客户端连接
        Socket socket = serverSocket.accept();
        //3. 获取输入流
        InputStream is  = socket.getInputStream();
        //4. 文件输出
        FileOutputStream fos = new FileOutputStream(new File("receive.jpg"));
        byte[] buffer = new byte[1024];
        int len;
        while ((len = is.read(buffer)) != -1) {
            fos.write(buffer,0,len);
        }
        //5.通知客户端接收完毕了
        OutputStream os  = socket.getOutputStream();
        os.write("我接受完毕了，可以断开了".getBytes());
        //6. 关闭资源
        os.close();
        fos.close();
        is.close();
        socket.close();
        serverSocket.close();
    }
}

4. Tomcat

服务端

  • 自定义【S】
  • Tomcat【S】

客户端

  • 自定义【C】
  • 浏览器【B】

5.UDP

DatagramPacket常用方法
方法 类型 说明
public DatagramPacket(byte[] var1, int var2) 构造 实例化DatagramPacket对象时指定接收数据长度
public DatagramPacket(byte[] var1, int var2, int var3, InetAddress var4, int var5) 构造 实例化DatagramPacket对象时指定接收数据长度、数据的长度、目标地址及端口
public synchronized byte[] getData() 普通 返回接受的数据
public synchronized int getLength() 普通 返回要发送或接收数据的长度
DatagramSocket的常用方法
方法 类型 说明
public DatagramSocket(int var1) throws SocketException 构造 实例化DatagramSocket对象，并指定监听的端口
ublic void send(DatagramPacket var1) throws IOException 普通 发送数据报
public synchronized void receive(DatagramPacket var1) throws IOException 普通 接收数据报
  • 栗子
  • 客户端
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
package com.xxy.test3;

import java.io.IOException;
import java.net.*;

//不需要连接服务器
public class UdpClientDemo01 {
    public static void main(String[] args) throws IOException {
        //1.建立一个Socket
        DatagramSocket socket  = new DatagramSocket();
        //2. 建个包
        String msg = "你好啊";
        InetAddress localhost  = InetAddress.getByName("localhost");
        int port = 9000;

        //数据，数据的长度，发给谁
        DatagramPacket packet = new DatagramPacket(msg.getBytes(),0,msg.getBytes().length,localhost,port);

        //发送包
        socket.send(packet);

        socket.close();
    }
}

  • 服务端
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
package com.xxy.test3;

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.SocketException;

public class UdpServerDemo01 {
    public static void main(String[] args) throws IOException {
        //开放端口
        DatagramSocket socket = new DatagramSocket(9000);
        //接收数据包
        byte[] buffer = new byte[1024];
        DatagramPacket packet = new DatagramPacket(buffer,0,buffer.length);
        //阻塞接收
        socket.receive(packet);
        System.out.println(packet.getAddress().getHostAddress());
        System.out.println(new String(packet.getData(),0,packet.getLength()));

        socket.close();


    }
}

6. 循环发送消息

  • 栗子
  • 发送端
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
package com.xxy.chat;

import java.awt.image.BufferedImage;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetSocketAddress;
import java.net.SocketException;

public class UdpSenderDemo01 {
    public static void main(String[] args) throws IOException {
        DatagramSocket socket = new DatagramSocket(9000);
        //准备数据，控制台输入输出
        BufferedReader reader  = new BufferedReader(new InputStreamReader(System.in));
        while (true) {
            String data = reader.readLine();
            byte[] datas = data.getBytes();
            DatagramPacket packet = new DatagramPacket(datas, 0, datas.length, new InetSocketAddress("localhost", 9001));

            socket.send(packet);
            if (data.equals("bye")) {
                break;
            }
        }
        socket.close();

    }
}

  • 接收端
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
package com.xxy.chat;

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.SocketException;

public class UdpReceiveDemo01 {
    public static void main(String[] args) throws IOException {
        DatagramSocket socket = new DatagramSocket(9001);
        while (true) {
            //准备接受包裹
            byte[] container = new byte[1024];
            DatagramPacket packet = new DatagramPacket(container, 0, container.length);
            //阻塞式接收包裹
            socket.receive(packet);
            //断开连接--byebye
            byte[] data = packet.getData();
            String receiveData = new String(data, 0, data.length);
            System.out.println(receiveData);
            if (receiveData.trim().equals("bye")) {
                break;
            }

        }
        socket.close();
    }
}

7. 在线聊天

  • 栗子

  • 发送端

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
package com.xxy.chat;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetSocketAddress;
import java.net.SocketException;

public class TalkSend implements Runnable {
    DatagramSocket socket = null;
    BufferedReader reader = null;

    private int fromPort;
    private String toIP;
    private int toPort;

    public TalkSend() {
    }

    public TalkSend(int fromPort, String toIP, int toPort) {
        this.fromPort = fromPort;
        this.toIP = toIP;
        this.toPort = toPort;

        try {
            socket = new DatagramSocket(fromPort);
            reader = new BufferedReader(new InputStreamReader(System.in));
        } catch (Exception e) {
            e.printStackTrace();
        }
    }



    @Override
    public void run() {

        while (true) {
            try {
                String data = reader.readLine();
                byte[] datas = data.getBytes();
                DatagramPacket packet = new DatagramPacket(datas, 0, datas.length, new InetSocketAddress("localhost", 9001));

                socket.send(packet);
                if (data.equals("bye")) {
                    break;
                }
            } catch (IOException e) {
                e.printStackTrace();
            }

        }
        socket.close();
    }
    
}

  • 接收端
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
package com.xxy.chat;

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.SocketException;

public class TalkReceive implements Runnable {
    DatagramSocket socket = null;
    private int port;
    private String msgFrom;
    public TalkReceive(int port,String msgFrom) {
        this.port = port;
        this.msgFrom = msgFrom;
        try {
            socket = new DatagramSocket(port);
        } catch (SocketException e) {
            e.printStackTrace();
        }
    }

    @Override
    public void run() {

        while (true) {
            try {
                //准备接受包裹
                byte[] container = new byte[1024];
                DatagramPacket packet = new DatagramPacket(container, 0, container.length);
                //阻塞式接收包裹
                socket.receive(packet);
                //断开连接--byebye
                byte[] data = packet.getData();
                String receiveData = new String(data, 0, data.length);
                System.out.println(msgFrom + ":" + receiveData);
                if (receiveData.trim().equals("bye")) {
                    break;
                }
            } catch (IOException e) {
                e.printStackTrace();
            }

        }
        socket.close();
    }
}

  • 老师线程1
1
2
3
4
5
6
7
8
9
package com.xxy.chat;

public class TalkTeacher {
    public static void main(String[] args) {
        new Thread(new TalkSend(9003,"localhost",9002)).start();
        new Thread(new TalkReceive(9001,"学生")).start();
    }
}

  • 学生线程
1
2
3
4
5
6
7
8
9
package com.xxy.chat;

public class TalkStudent {
    public static void main(String[] args) {
        new Thread(new TalkSend(9000,"localhost",9001)).start();
        new Thread(new TalkReceive(9002,"老师")).start();
    }
}

8. URL（统一资源定位符）

协议：（DNS域名解析）ip地址：端口/项目名/资源

  • 下载
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
package com.xxy.test4;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.net.HttpURLConnection;
import java.net.MalformedURLException;
import java.net.URL;

public class UrlDown {
    public static void main(String[] args) throws Exception {
        //1.下载地址
        URL url = new URL("");
        //2.连接到这个资源 HTTP
        HttpURLConnection urlConnection = (HttpURLConnection) url.openConnection();

        InputStream inputStream = urlConnection.getInputStream();
        //资源名字
        FileOutputStream fos = new FileOutputStream("");
        byte[] buffer = new byte[1024];
        int len;
        while ((len = inputStream.read(buffer)) != -1) {
            fos.write(buffer,0,len);//写出这个数据
        }
        fos.close();
        inputStream.close();
        urlConnection.disconnect();

    }
}

9. 总结

网络编程和IO流一般都在一起，重点是熟悉，如果还有其他的内容欢迎大家补充。