网络编程学习记录

1.1概述

• 打电话 --连接-- 接了---通话 TCP

• 发短信 --发送了就完事了-- 接收 UDP

计算机网络部分：

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

网络编程的目的：

无线电台…传播交流信息，数据交换。通信

想要达到这个效果需要什么：

1. 如何准确的定位网络上的一台主机 192.168.16.124：端口，定位到这个计算机上的某个资源
2. 找到了这个主机，如何传输数据呢？

相关技术：

javaweb：网页编程

网络编程：TCP/IP

1.2网络通信的要素

通信双方地址：

• ip
• 端口号
• 192.168.16,124:5900

规则：网络通信的协议

TCP/IP参考模型

小结：

1. 网络编程中有两个主要的问题

   • 如何准确的定位到网络上的一台或者多台主机
   • 找到主机之后如何进行通信

2. 网络编程中的要素

   • IP 和 端口号 IP，
   • 网络通信协议 udp，tcp

3. 万物皆对象

1.3 IP

ip地址：InetAddress

• 唯一定位一台网络上计算机

• 127.0.0.1 ：本机 localhost

• ip地址的分类

  • ipv4 / ipv6

    • IPV4 127.0.0.1 ，4个字节组成。，0255，42亿 ；30亿都在北美，亚洲4亿。2011年就用尽；

    • IPV6 :128位。8个无符号整数！

      2001: 0bb2: aaaa: 0015:0000:0000:1aaa: 1312！

  • 公网（互联网）-私网（局域网）

    • ABCD类地址
    • 192.168.xx.xx,专门给组织内部使用的

• 域名：记忆IP问题！

  • IP： www.vip.com

public class TestInetAddress {
    public static void main(String[] args) throws UnknownHostException {
        //获取本机地址
        InetAddress byName = InetAddress.getByName("127.0.0.1");
        System.out.println(byName);
        InetAddress byName3 = InetAddress.getByName("localhost");
        System.out.println(byName3);
        InetAddress byName4 = InetAddress.getLocalHost();
        System.out.println(byName4);
        System.out.println();
        //获取网络IP 地址
        InetAddress byName2 = InetAddress.getByName("www.baidu.com");
        System.out.println(byName2);
        System.out.println();
        //常用方法
        System.out.println(byName2.getAddress());
        System.out.println(byName2.getCanonicalHostName());//规范名字
        System.out.println(byName2.getHostAddress());//ip
        System.out.println(byName2.getHostName());//域名或者自己电脑的名字

    }
}
结果：
D:\develop-tools\JDK\jdk-17.0.2\bin\java.exe "-javaagent:D:\develop-tools\IDEA\IntelliJ IDEA 2025.1.1.1\lib\idea_rt.jar=52080" -Dfile.encoding=UTF-8 -classpath D:\code\JAVA\IDEA\study1\out\production\study1;D:\code\JAVA\IDEA\study1\src\com\lib\commons-io-2.21.0.jar com.zhang.网络编程.TestInetAddress
/127.0.0.1
localhost/127.0.0.1
LAPTOP-2TL0LUEN/192.168.56.1

www.baidu.com/153.3.238.28

[B@2d98a335
153.3.238.28
153.3.238.28
www.baidu.com

1.4端口

端口表示计算机上的一个程序的进程；

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

• 被规定 0~65535

• TCP,UDP ： 65535 * 2 tcp: 80, udp: 80吗，单个协议下，端口号不能冲突

• 端口分类

  • 公有端口 0~1023

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

  • 程序注册端口：1024~49151,分配用户或者程序

    • Tomcat : 8080
    • MySQL : 3306
    • Oracle : 1521

  • 动态、私有：49152~ 65535

netstat -ano #查看所有的端口
netstat -ano|findstr "5900" #查看指定的端口
tasklist|findstr "8696" #查看指定端口的进程
ctrl+ shift + ESC

1.5 通信协议

协议： 约定，就好比我们现在说的是普通话。

网络通信协议： 速率，传输码率，代码结构，传输控制……

问题： 非常的复杂？

大事化小： 分层！

TCP/IP协议簇： 实际上是一组协议

重要：

• TCP ： 用户传输协议

• UDP ：用户数据报协议

  出名的协议：

• TCP：

• IP ： 网络互连协议

TCP udp 对比

TCP：打电话

• 连接，稳定

• 三次握手 四次挥手

1. A: 你瞅啥？

1. B: 瞅你咋地？

1. A: 干一场！

6

A: 我要走了

B: 我真的要走了吗？

B: 你真的真的要走了吗？

A: 我的真的要走了

• 客户端、服务端

• 传输完成，释放连接，效率低

UDP：发短信

• 不连接，不稳定

• 客户端、服务端：没有明确的界限

• 不管有没有准备好，都可以发给你..

1.6 TCP

客户端

1. 连接服务器 Socket
2. 发送消息

服务器

1. 建立服务的端口 ServerSocket
2. 等待用户的链接 accept
3. 接收用的消息

客户端
public class TcpClientDemo01 {
    public static void main(String[] args) {
        Socket socket=null;
        OutputStream stream=null;
        try {
            //需要得到地址与端口
            InetAddress address = InetAddress.getByName("127.0.0.1");
            int port = 9998;
            //创建一个socket连接
           socket = new Socket(address,port);
            //发送IO流
           stream = socket.getOutputStream();
            stream.write("hello MyServer".getBytes());
            stream.flush();  // 强制刷新缓冲区
// 先不关闭，等待几秒
            Thread.sleep(3000);
            socket.shutdownOutput();
        } catch (Exception e) {
            throw new RuntimeException(e);
        }finally {
            if(socket!=null){
                try {
                    socket.close();
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            if(stream!=null){
                try {
                    stream.close();
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
        }
    }
}
`
```

public class TcpServerDemo02 {
    public static void main(String[] args) {
        ServerSocket ServerSocket=null;
        Socket socket=null;
        InputStream is=null;
        ByteArrayOutputStream baos=null;
        try {
            //需要有一个地址 Socket：套接字，网络上两个程序之间进行双向通信的端点
            ServerSocket = new ServerSocket(9998);

            //等待客户端的消息，accept监听并接受客户端的连接请求。该方法会阻塞当前线程，
            // 直到有客户端连接进来，然后返回一个代表该连接的 Socket对象。
            // 这个Socket对象就是客户端发来的那个
            socket = ServerSocket.accept();
            System.out.println("客户端已连接，客户端IP: " + socket.getInetAddress());
            is = socket.getInputStream();
            //管道流，ByteArrayOutputStream是一个内存中的字节缓冲区，
            // 特别适合在网络编程、文件处理等场景中收集和暂存字节数据，最后一次性转换为需要的格式（字符串、字节数组等）
            baos = new ByteArrayOutputStream();

            //len = is.read(buffer)循环是一次次循环把1024单位的数据一边给管道流baos存数据，
            // 一边给len来判断是否还有数据
            //用buffer（缓冲）来1024单位的存数据是因为防止一次性加载大文件导致内存溢出，
            // 减少I/O操作次数，批量读取提高效率
            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) {
            throw new RuntimeException(e);
        }finally {
            //// 使用后不关闭...
            //// 结果：端口9999一直被占用，其他程序无法使用
            //// 重启应用才能释放，或者等系统自动回收（可能很久）
        //为什么每个都要try-catch？
        //原因1：关闭时也可能出错
        //原因2：确保所有资源都尝试关闭
            //try-with-resources 是 Java 7 引入的语法糖，把资源定义在try后面的（）中，然后在{}中使用，
            //详见下面的文件上传
            // 它会在编译时自动生成正确的资源关闭代码，包括正确的异常处理、关闭顺序和null检查。
            // 这是现代Java资源管理的标准做法，
            // 现代简化写法（Java 7+）没有在finally里显式close任何资源，这是新Java的特性自动关闭
            //下面是传统写法
            if (is != null) {
                try {
                    is.close();
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            if (baos != null) {
                try {
                    baos.close();
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            if (socket != null) {
                try {
                    socket.close();
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            if (ServerSocket != null) {
                try {
                    ServerSocket.close();
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
        }
    }
}
```

文件上传

public class TcpClientDemo02 {
    public static void main(String[] args) {


        try (Socket socket=new Socket(InetAddress.getByName("127.0.0.1"),9999);
             //2，创建一个输出流
             OutputStream out = socket.getOutputStream();
             //3，读取文件
             FileInputStream fileInputStream = new FileInputStream(new File("img.png"));){
            //1,创建一个Socket连接

            //4，写出文件,发送给服务端
            byte[] buf = new byte[1024];
            int len = 0;
            while((len=fileInputStream.read(buf))!=-1){
                out.write(buf, 0, len);
            }
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
}
```
```
public class TcpServerDemo02_1 {
    public static void main(String[] args) {
        try (//1,创建服务
             ServerSocket serverSocket= new ServerSocket(9999);
             //2，监听用户的连接
             Socket socket = serverSocket.accept();
             //3，从连接得到输入流
             InputStream stream = socket.getInputStream();
             //4，文件输出，把缓存的数据放入文件输出流
             FileOutputStream fileOutputStream = new FileOutputStream(new File("receive.png"));){

            byte[] buffer = new byte[1024];
            int len = 0;
            while ((len = stream.read(buffer)) != -1) {
                fileOutputStream.write(buffer, 0, len);
            }
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
}
```
```

Tomcat

服务端

• 自定义 S
• Tomcat服务器 S

客户端

• 自定义 C
• 浏览器 B

1.7 UDP

发短信，不需要连接

//不需要连接服务器
public class UdpClientDemo01 {
    public static void main(String[] args) throws Exception {
        //建立一个Socket
//        Socket (TCP)：面向连接、可靠、流式、有状态。像打电话，需要接通，保证对话完整。
//        DatagramSocket (UDP)：无连接、不可靠、数据报式、无状态。像寄明信片，直接寄出，不管对方是否收到。
//        简单记：
//        要可靠、完整的数据 → 用 Socket (TCP)
//                要快速、实时、可容忍丢失 → 用 DatagramSocket (UDP)
//                大量简单查询 → 用 UDP
//        重要数据传输 → 用 TCP
        DatagramSocket socket = new DatagramSocket();
        //建一个数据包
        String msg="hello MyServer!";
        //发送给谁
        InetAddress address = InetAddress.getByName("127.0.0.1");
        int port=9090;
        //数据，数据的长度，发送目标
//        DatagramPacket是 Java UDP 编程中的核心类，代表一个UDP数据报。它封装了要发送或接收的数据、目标地址、端口等信息。
        DatagramPacket packet = new DatagramPacket(msg.getBytes(), msg.getBytes().length, address, port);
        socket.send(packet);
        socket.close();
    }
}

```
public class UdpServerDemo01 {
    public static void main(String[] args) throws Exception {
//        这是 DatagramSocket 的两种使用场景：配置端口号的是服务端/接收端，不配置的是客户端/发送端。
        DatagramSocket socket = new DatagramSocket(9090);
        byte[] buf = new byte[1024];
        DatagramPacket packet = new DatagramPacket(buf, buf.length);
        socket.receive(packet);//类似于tcp的accept，阻塞等待
        //为什么要指定起始？
//        就像读一本书，getData()是整本书，getOffset()是开始读的页码，
//        getLength()是要读的页数。你肯定不会从封面开始读整本书，而是从某个章节开始读几页。
        System.out.println("接受到：" + new String(packet.getData(),0,packet.getLength())+"来自"+packet.getAddress()+",端口"+packet.getPort());
        socket.close();
    }
}

循环发送与连接

public class UdpSender01 {
    public static void main(String[] args) throws Exception {
        DatagramSocket socket = new DatagramSocket(8080);
        while (true) {
            String data = new BufferedReader(new InputStreamReader(System.in)).readLine();
            byte[] buf = data.getBytes();
            DatagramPacket packet = new DatagramPacket(buf,0,buf.length, InetAddress.getByName("127.0.0.1"), 6666);
            socket.send(packet);
            if (data.equals("bye")) {
                break;
            }
        }

        socket.close();
    }
}
```
public class UdpSender02 {
    public static void main(String[] args) throws Exception {
        DatagramSocket socket = new DatagramSocket(6666);
        while (true) {
            byte[] buf2 = new byte[1024];
            DatagramPacket packet2 = new DatagramPacket(buf2, buf2.length);
            socket.receive(packet2);
            String msg = new String(packet2.getData(), 0, packet2.getLength());
            System.out.println("接受到：" + msg+"来自"+packet2.getAddress()+",端口"+packet2.getPort());
            if (msg.equals("bye")) {
                break;
            }

        }

        socket.close();
    }
}
```
```
```

每个人都是发送方也是接收方

public class UdpSender01 {
    public static void main(String[] args) throws Exception {
        DatagramSocket socket=null;
        new ReceiveThread(socket,8081).start();
        new SendThread(socket,8082,6666).start();
    }
}
    class SendThread extends Thread {
        DatagramSocket socket;
        int MyPort;
        int toPort;
        public SendThread(DatagramSocket socket, int MyPort, int toPort) {
            this.socket = socket;
            this.MyPort = MyPort;
            this.toPort = toPort;

        }
        @Override
        public void run() {
            super.run();
            try {
                socket=new DatagramSocket(MyPort);
                while (true) {
                    String data = new BufferedReader(new InputStreamReader(System.in)).readLine();
                    byte[] buf = data.getBytes();
                    DatagramPacket packet = new DatagramPacket(buf,0,buf.length, InetAddress.getByName("127.0.0.1"), toPort);
                    socket.send(packet);
                    if (data.equals("bye")) {
                        break;
                    }
                }
            } catch (Exception e) {
                throw new RuntimeException(e);
            }finally {
                socket.close();
            }

        }
    }
    class ReceiveThread extends Thread {
        DatagramSocket socket;
        int MyPort;
        public ReceiveThread(DatagramSocket socket, int MyPort) {
            this.socket = socket;
            this.MyPort = MyPort;
        }
        @Override
        public void run() {
            super.run();

            try {
                socket=new DatagramSocket(MyPort);
                while (true) {
                    byte[] buf2 = new byte[1024];
                    DatagramPacket packet2 = new DatagramPacket(buf2, buf2.length);
                    socket.receive(packet2);
                    String msg = new String(packet2.getData(), 0, packet2.getLength());
                    System.out.println("接受到：" + msg+"       来自端口"+packet2.getPort());
                    if (msg.equals("bye")) {
                        break;
                    }

                }
            } catch (Exception e) {
                throw new RuntimeException(e);
            }finally {
                socket.close();
            }

        }
    }
    ```
public class UdpSender02 {
    public static void main(String[] args) throws Exception {
        DatagramSocket socket = null;
        new ReceiveThread(socket,6666).start();
        new SendThread(socket,6667,8081).start();
    }
}
```
```
```

1.8 URL

www.baidu.com/

统一资源定位符：定位资源的，定位互联网上的某一个资源

DNS 域名解析 www.baidu.com xxx.x..x..x

协议：//ip地址：端口/项目名/资源

public class URLDemo01 {
    public static void main(String[] args) throws MalformedURLException {
        URL url = new URL("http://localhost:8080/helloworld/index.jsp?username=kuangshen&password=123");
        System.out.println(url.getProtocol()); //协议
        System.out.println(url.getHost()); //主机ip
        System.out.println(url.getPort()); //端口
        System.out.println(url.getPath()); //文件
        System.out.println(url.getFile()); //全路径
        System.out.println(url.getQuery()); //参数
    }
}

D:\develop-tools\JDK\jdk-17.0.2\bin\java.exe "-javaagent:D:\develop-tools\IDEA\IntelliJ IDEA 2025.1.1.1\lib\idea_rt.jar=53791" -Dfile.encoding=UTF-8 -classpath D:\code\JAVA\IDEA\study1\out\production\study1;D:\code\JAVA\IDEA\study1\src\com\lib\commons-io-2.21.0.jar com.zhang.网络编程.URLDemo01
http
localhost
8080
/helloworld/index.jsp
/helloworld/index.jsp?username=kuangshen&password=123
username=kuangshen&password=123

Process finished with exit code 0

网络资源下载

public class URlDown {
    public static void main(String[] args) throws Exception {
        //这是网易云一个音乐资源地址
        URL url = new URL("https://m804.music.126.net/20260307223906/b8b79a53cf8104e1d69be419039c8661/jdyyaac/obj/w5rDlsOJwrLDjj7CmsOj/12203537925/19e4/d4a5/9bca/fb0b1bba558830f1784d5be84cd06d0c.m4a?vuutv=h1eSVDom5yDPDmtZ79mjdUXA1rYzmbLGtmk6BFukaap4hjIor/ngPkfk90Kca3hjhNEqVLapL85neRjIu+s5dTgUPQiUKaasf3YWgcYpV04=&authSecret=0000019cc8a5f83f1d030a3b21081912&cdntag=bWFyaz1vc193ZWIscXVhbGl0eV9leGhpZ2g");

//2. 连接到这个资源 HTTP
          //(直接URLConnection也可以)
        HttpURLConnection urlConnection = (HttpURLConnection) url.openConnection();

        InputStream inputStream = urlConnection.getInputStream();

        FileOutputStream fos = new FileOutputStream("d0c.m4a");

        byte[] buffer = new byte[1024];
        int len;
        while ((len = inputStream.read(buffer)) != -1) {
            fos.write(buffer,  0, len); //写出这个数据
        }

        fos.close();
        inputStream.close();
        urlConnection.disconnect(); //断开连接
    }
}
```
```