Java 基础 11. Java 网络编程

2022-01-21 本文已影响0人 yjtuuige

1. 概述

邮件：

计算机网络：是指将 地理位置不同 的，具有独立功能的，多台计算机及其外部设备，通过通信线路连接起来，在网络操作系统，网络管理软件，及 网络通信协议 的管理和协调下，实现资源共享 和信息传递的计算机系统。
网络编程的目的：无线电台，传播交流信息，数据交换，通信。
想要达到这个效果需要什么：
1. 如何准确的定位网络上的一台主机：192.168.16.124：端口，定位上这个计算机上的某个资源。
2. 找到了这个主机，如何传输数据呢？
JavaWeb：网页编程、B/S架构
网络编程：TCP/IP 、C/S

2. 网络通信要素

如何实现网络的通信?

通信双方的地址：
- ip：192.168.16.124
- 端口：5900
规则：网络通信的协议：TCP/IP

小结：

网络编程中有两个主要的问题：
- 如何让准确的定位到网络上的一台或多台主机；
- 找到主机之后如何通信；
网络编程中的要素：
- IP和端口号：IP
- 网络通信协议：UDP、TCP
万物皆对象

3. IP

IP 地址：InetAddress

唯一定位一台网络上的计算机
127.0.0.1：本机 localhost
IP 地址的分类
- IPV4： 127.0.0.1 ,4个字节组成。0~255， 42亿~；30亿都在北美，亚洲4亿。2011年就用尽；
- IPV6： fe80::f0e0:7383:ad8e:f32f%3 ，128位。8个无符号整数。

2406:da18:ddf5:4000:67d5:b226:cad7:125b

公网（互联网）— 私网（局域网）
- ABCD地址
- 192.168.xx.xx，专门给组织内部使用。
域名：记忆 IP 问题！
- IP：www.baidu.com

package com.xxx.net.demo01;

import java.net.InetAddress;
import java.net.UnknownHostException;

/**
 * 测试 IP
 */
public class TestInetAddress {
    public static void main(String[] args) {
        try {
            // 查询本机地址
            InetAddress inetAddress1 = InetAddress.getByName("127.0.0.1");
            System.out.println(inetAddress1);
            InetAddress inetAddress3 = InetAddress.getByName("localhost");
            System.out.println(inetAddress3);
            InetAddress inetAddress4 = InetAddress.getLocalHost();
            System.out.println(inetAddress4);
            // 查询网站地址
            InetAddress inetAddress2 = InetAddress.getByName("www.baidu.com");
            System.out.println(inetAddress2);
            // 常用方法
            // System.out.println(inetAddress2.getAddress());   // 返回的是一个字节数组  无用
            System.out.println(inetAddress2.getCanonicalHostName());    // 规范的名字
            System.out.println(inetAddress2.getHostAddress());  // IP
            System.out.println(inetAddress2.getHostName()); // 域名，或者自己电脑的名字
        } catch (UnknownHostException e) {
            e.printStackTrace();
        }
    }
}

4. 端口

端口表示计算机上一个程序的进程；
不同的进程，有不同的端口号，用来区分软件；
被规定 0~65535；
TCP，UDP：65535*2 个端口， tcp：80，udp：80 单个协议下，端口号不能冲突；
端口分类
- 共有端口 0~1023 内置的进程使用
  - HTTP：80
  - HTTP：443 如访问 https：//www.baidu.com:443 访问的还是百度
  - FTP：21
  - TELENT：23
- 程序注册端口：1014~49151，分配给用户和程序
  - Tomcat：8080
  - MySql：3306
  - Oracle：1521
- 动态、私有端口：49152~65535

netstat -ano # 查看所有的端口
netstat -nao|findstr "7808" # 查看指定的端口
tasklist|findstr "8696"  # 查看指定端口的进程
Ctrl + Shift + Esc  # 任务管理器，快捷键

修改本机映射地址

package com.xxx.net.demo01;

import java.net.InetSocketAddress;

/**
 * InetSocketAddress
 */
public class TestInetSocketAddress {
    public static void main(String[] args) {
        InetSocketAddress socketAddress = new InetSocketAddress("127.0.0.1", 8080);
        InetSocketAddress socketAddress1 = new InetSocketAddress("localhost", 8080);
        System.out.println(socketAddress);
        System.out.println(socketAddress1);

        System.out.println(socketAddress.getAddress());
        System.out.println(socketAddress.getHostName());    // 地址
        System.out.println(socketAddress.getPort());    // 端口
    }
}

5. 通信协议

协议：约定，就好比中国人交流说的是普通话
网络通信协议： 速率，传输码率，代码结构，传输控制…
问题：非常的复杂
大事化小：分层
TCP/IP 协议簇：实际上是一组协议

重要：

TCP：用户传输协议
UDP：用户 数据报 协议

出名的协议：

TCP：用户传输协议
IP：网络互联协议

TCP UDP 对比

TCP：类似，打电话

连接，稳定

三次握手，四次挥手

最少需要三次，保证稳定连接！
// 三次握手
A：你瞅啥？
B：瞅你咋地？
A：干一场
// 四次挥手
A：我要分手了
B：我知道你要分手了
B：你真的要分手吗？
A：我真的要分手了

客户端、服务器
传输完成，释放连接，效率低

UDP：类似，发短信
- 不连接，不稳定
- 客户端、服务端：没有明确的界限
- 不管有没有准备好，都可以发给你
- DDOS：洪水攻击！发垃圾包，堵塞线路（饱和攻击）

6. TCP

先启动服务端，再启动客户端！！！！

客户端
1. 连接服务器：Socket
2. 发送消息

package com.xxx.net.demo01;

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

/**
 * 客户端
 * Socket：客户端与服务器连接的插槽
 */
public class TcpClientDemo01 {
    public static void main(String[] args) {
        Socket socket = null;
        OutputStream os = null;
        try {
            // 1.要知道服务器的地址，端口号
            InetAddress serverIP = InetAddress.getByName("127.0.0.1");
            int port = 9999;
            // 2.创建一个 Socket 连接
            socket = new Socket(serverIP, port);
            // 3.发送消息：IO 流
            os = socket.getOutputStream();
            os.write("客户端发送消息...".getBytes());
        } catch (Exception e) { // 异常的作用域提升到最大，方便捕获 Socket 的异常
            e.printStackTrace();
        } finally {
            // 关闭资源：从内向外
            if (os != null) {
                try {
                    os.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (socket != null) {
                try {
                    socket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

服务器端
1. 建立服务的端口：ServerSocket
2. 等待的用户的连接：accept()
3. 接收用户的消息

package com.xxx.net.demo01;

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

/**
 * 服务端
 * Socket：服务器与客户端连接的插槽
 */
public class TcpServerDemo01 {
    public static void main(String[] args) {
        // 提升变量作用域，便于在 finally 中操作
        ServerSocket serverSocket = null;
        Socket socket = null;
        InputStream is = null;
        ByteArrayOutputStream baos = null;
        try {
            // 1.创建一个地址
            serverSocket = new ServerSocket(9999);
            while (true) {
                // 2.等待客户端连接过来 accept() 监听
                // 连接成功后，Socket 与客户端为同一对象
                socket = serverSocket.accept();
                // 3.读取客户端的消息
                is = socket.getInputStream();
                // 管道流
                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());
            }
            /*
            // 此方式，会有中文乱码
            byte[] buffer = new byte[1024];
            int len = 0;
            while ((len = is.read(buffer)) != -1) {
                String s = new String(buffer, 0, len);
                System.out.println(s);
            }
            */
        } 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();
                }
            }
        }
    }
}

文件上传

客户端

package com.xxx.net.demo01;

import java.io.ByteArrayOutputStream;
import java.io.FileInputStream;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.InetAddress;
import java.net.Socket;

/**
 * 客户端：文件上传
 */
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("001.jpg");
        // 4.写出文件
        byte[] buffer = new byte[1024];
        int len;
        while ((len = fis.read(buffer)) != -1) {
            os.write(buffer, 0, len);
        }
        // 5.通知服务器，已经结束
        // shutdownOutput() 传输完毕
        socket.shutdownOutput();
        // 确定服务器接收完毕，才能断开连接
        InputStream inputStream = socket.getInputStream();
        // 管道流 String byte[]
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        byte[] buffer2 = new byte[1024];
        int len2;
        while ((len2 = inputStream.read(buffer2)) != -1) {
            baos.write(buffer2, 0, len2);
        }
        // 6.关闭资源
        baos.close();
        inputStream.close();
        fis.close();
        os.close();
        socket.close();
    }
}

服务端

package com.xxx.net.demo01;

import java.io.FileOutputStream;
import java.io.InputStream;
import java.io.OutputStream;
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("receive.jpg");
        byte[] buffer = new byte[1024];
        int len;
        while ((len = is.read(buffer)) != -1) {
            fos.write(buffer, 0, len);
        }
        // 5.通知客户端，接收完毕 socket.shutdownInput();
        OutputStream os = socket.getOutputStream();
        os.write("服务器接收完毕，可以断开连接".getBytes());
        // 6.关闭资源
        os.close();
        fos.close();
        is.close();
        socket.close();
        serverSocket.close();
    }
}

初识 Tomcat

Tomcat 乱码：conf\logging.properties 把 UTF-8 改为 GBK
启动文件：bin -> startup.bat linux：bin -> startup.sh
服务端
- 自定义 S
- Tomcat 服务器 S ：Java 后台开发
客户端
- 自定义 C
- 浏览器 B

7.UDP

发短信：不用连接，需要知道对方的地址

发送消息

实例 1：发送端，不需要连接服务器

package com.xxx.net.demo03;

import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;

/**
 * UDP：发送端
 * 不需要连接服务器
 */
public class UdpClientDemo01 {
    public static void main(String[] args) throws Exception {
        // 1.建立一个 Socket
        DatagramSocket socket = new DatagramSocket();
        // 2.建个包
        String msg = "你好，服务器！";
        // 发送给谁
        InetAddress localhost = InetAddress.getByName("localhost");
        int port = 9090;
        // 参数：数据、数据起始位、数据结束位、IP地址、端口号
        DatagramPacket packet = new DatagramPacket(msg.getBytes(),
                0, msg.getBytes().length, localhost, port);
        // 3.发送包
        socket.send(packet);
        // 4.关闭流
        socket.close();
    }
}

实例 2：接收端，需要等待发送端发送数据

package com.xxx.net.demo03;

import java.net.DatagramPacket;
import java.net.DatagramSocket;

/**
 * UDP：接收端
 * 需要等待发送端发送数据
 */
public class UdpServerDemo01 {
    public static void main(String[] args) throws Exception {
        // 1.开放端口
        DatagramSocket socket = new DatagramSocket(9090);
        // 2.接收数据包
        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()));
        // 3.关闭连接
        socket.close();
    }
}

循环发送消息

实例：发送端

package com.xxx.net.chat;

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

/**
 * UDP：发送端
 */
public class UdpSenderDemo01 {
    public static void main(String[] args) throws Exception {
        // 1.建立一个 Socket
        DatagramSocket socket = new DatagramSocket(8888);
        // 2.建个包
        // 准备数据：控制台读取 System.in
        BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
        while (true) {
            // data 不可读，需转换成字节
            String data = reader.readLine();
            // data 转为字节
            byte[] datas = data.getBytes();
            DatagramPacket packet = new DatagramPacket(datas, 0,
                    datas.length, new InetSocketAddress("localhost", 6666));
            // 3.发送包
            socket.send(packet);
            if (data.equals("bye")) {
                break;
            }
        }
        // 4.关闭
        reader.close();
        socket.close();
    }
}

实例：接收端

package com.xxx.net.chat;

import java.net.DatagramPacket;
import java.net.DatagramSocket;

/**
 * UDP：接收端
 */
public class UdpReceiveDemo01 {
    public static void main(String[] args) throws Exception {
        DatagramSocket socket = new DatagramSocket(6666);
        while (true) {
            // 准备接收包
            byte[] container = new byte[1024];
            DatagramPacket packet = new DatagramPacket(container, 0, container.length);
            // 阻塞式接收包
            socket.receive(packet);
            //  data 得到数组
            byte[] data = packet.getData();
            // 注意：这里也可以打印出接收数据，但会多出很多空格，因为打印了数组 1024B 的字节
            // String receiveData = new String(data);
            // packet.getLength() 得到实际数据长度，而非数组总长度 byte[1024]
            String receiveData = new String(data, 0, packet.getLength());
            System.out.println(receiveData);
            // 断开连接 bye
            if (receiveData.equals("bye")) {
                break;
            }
        }
        // 关闭资源
        socket.close();
    }
}

在线咨询：两个人都可以是发送方，也可以是接收方(配合多线程)

发送端线程

package com.xxx.net.chat;

import java.io.BufferedReader;
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(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 (SocketException 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(this.toIP, this.toPort));
                socket.send(packet);
                if (data.equals("bye")) {
                    break;
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        // 4.关闭
        socket.close();
    }
}

接收端线程

package com.xxx.net.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);
                // data 得到实际数据的数组
                byte[] data = packet.getData();
                // 注意：packet.getLength() 得到数组内实际数据的长度，而非数组的总长度 byte[1024]
                String receiveData = new String(data, 0, packet.getLength());
                System.out.println(msgFrom + ":" + receiveData);
                // 断开连接 bye
                if (receiveData.equals("bye")) {
                    break;
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        // 关闭资源
        socket.close();
    }
}

教师端

package com.xxx.net.chat;

/**
 * 老师端
 */
public class TalkTeacher {
    public static void main(String[] args) {
        // 开启两个线程
        new Thread(new TalkSend(5555, "localhost", 8888)).start();
        new Thread(new TalkReceive(9999, "学生")).start();
    }
}

学生端

package com.xxx.net.chat;

/**
 * 学生端
 */
public class TalkStudent {
    public static void main(String[] args) {
        // 开启两个线程
        new Thread(new TalkSend(7777, "localhost", 9999)).start();
        new Thread(new TalkReceive(8888, "老师")).start();
    }
}

8.URL

https://www.baidu.com
统一资源定位符：定位互联网上的某一个资源
DNS域名解析 www.baidu.com —> xxx.xxx.xxx.xxx

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

实例 1：

package com.xxx.net.demo04;

import java.net.MalformedURLException;
import java.net.URL;

/**
 * URL
 */
public class URLDemo01 {
    public static void main(String[] args) throws MalformedURLException {
        URL url = new URL("http://localhost:8080/hello/index.jsp?" +
                "username=liu&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()); // 参数
    }
}

下载网页上的文件
1. 启动 Tomcat 服务器；
2. 在 Tomcat 中放好文件；
3. 进行相关测试。
实例：

package com.xxx.net.demo04;

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

/**
 * 下载网页上的文件
 */
public class URLDown {
    public static void main(String[] args) throws Exception {
        // 1.下载地址
        URL url = new URL("http://localhost:8080/hello/test.txt");
        // 2.连接到这个资源 Http
        HttpURLConnection urlConnection = (HttpURLConnection) url.openConnection();
        InputStream inputStream = urlConnection.getInputStream();
        FileOutputStream fs = new FileOutputStream("11.txt");
        byte[] buffer = new byte[1024];
        int len;
        while ((len = inputStream.read(buffer)) != -1) {
            // 写出这个数据
            fs.write(buffer, 0, len);
        }
        fs.close();
        inputStream.close();
        // 断开连接
        urlConnection.disconnect();
    }
}

Java 基础 11. Java 网络编程

1. 概述

2. 网络通信要素

3. IP

4. 端口

5. 通信协议

6. TCP

7.UDP

8.URL

猜你喜欢

热点阅读