Java网络编程基础与实践-优快云博客

本文链接：https://blog.youkuaiyun.com/wendy_gong/article/details/120278326

Java 网络编程

https://www.cnblogs.com/swordfall/p/10781281.html

https://www.runoob.com/w3cnote/summary-of-network.html

1 概述

计算机网络是通过传输介质、通信设施和网络通信协议，把分散在不同地点的计算机设备互连起来的，实现资源共享和数据传输的系统。网络编程就是编写程序使互联网的两个（或多个）设备（如计算机）之间进行数据传输。Java语言对网络编程提供了良好的支持。通过其提供的接口我们可以很方便地进行网络编程。

信件：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-qU4R1O0w-1631548808673)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20210906104548022.png)]

计算机网络

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

网络编程的目的

通信数据交换无限电台 --传播交流信息

想要达到这个效果需要

如何准确定位网络中的一台电脑 ip地址端口号定位到计算机上的某个资源
找到这个主机之后，如何传输数据

javaweb 网页编程 B/S架构

网络编程是通过协议进行通信，如TCP/IP,UDP等 C/S架构

1.2 网络通信的要素

双方的通信地址

IP地址及端口号

协议

TCP
UDP
HTTP
IP
SMTP等

TCP/IP 参考模型

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-7XEXI96t-1631548808681)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20210906152038984.png)]

参考博客：https://www.cnblogs.com/gdayq/p/5797645.html

小结：

网络编程由两个主要的问题
- 如何准确定位到网络上的一台或者多台主机
- 找到主机之后如何进行通信
网络编程中的要素
- IP 地址和端口号
- 网络通信协议 UDP TCP IP
Java中万物皆对象

1.3 IP

public class InetAddress extends Object implements Serializable

此类表示Internet协议（IP）地址

唯一定位网络上的一台计算机
127.0.0.1 本机localhost

localhost 、 127.0.0.1 与0.0.0.0的小区别可参见👉 https://www.jianshu.com/p/ad7cd1d5be45
IP地址分类
- IP地址分类
  - IPv4 0-255，4个字段，每个字段由8位二进制数组成及一个字节。总共由42亿~ 30亿在北美亚洲只有4亿 2011年已用尽 https://www.cnblogs.com/tunian/p/9632893.html
  - IPv6 由被划分为8个16位块的128位组成。然后将每个块转换为由冒号符号分隔的4位十六进制数字。参考👉 https://www.cnblogs.com/fengf233/p/10906444.html 以及 https://blog.youkuaiyun.com/kdb_viewer/article/details/83310093
- 公网（互联网）与私网（局域网）
  - 在IP地址3种主要类型里，各保留了3个区域作为私有地址，其地址范围如下：
    A类地址：10.0.0.0～10.255.255.255
    B类地址：172.16.0.0～172.31.255.255
    C类地址：192.168.0.0～192.168.255.255
域名：记忆IP问题
- IP www.jd.com 万网

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

public class TestInetAddress01 {
    public static void main(String[] args)  {
        try {
            //查询本机地址
            InetAddress name = InetAddress.getByName("127.0.0.1");
            System.out.println(name);
            InetAddress name3 = InetAddress.getByName("localhost");
            System.out.println(name3);
            InetAddress name4 = InetAddress.getLocalHost();
            System.out.println(name4);
            //查询网站IP地址
            InetAddress name2 = InetAddress.getByName("www.baidu.com");
            System.out.println(name2);
            System.out.println(name2.getAddress());
            System.out.println(name2.getHostName());
            System.out.println(name2.isAnyLocalAddress());
            System.out.println(name2.isLoopbackAddress());
            System.out.println(name2.getCanonicalHostName());
            System.out.println(name2.hashCode());
            System.out.println(name2.isLinkLocalAddress());
            System.out.println(name2.isMCGlobal());
        } catch (UnknownHostException e) {
            e.printStackTrace();
        }
    }
}

1.4 端口

此处端口指TCP/IP协议中的端口，一般用来区分计算机网络中不同的进程（IP地址用来区分网络中不同的计算机）

不同的进程有不同的端口号
一般端口号的范围位0-65535
TCP/UDP 65535*2 单个协议下端口号不能冲突任何TCP/IP实现所提供的服务都是1-1023之间的端口号

端口的分类

公有端口
- ssh服务器, 使用22端口；
- ftp服务器, 使用21端口；
- telnet服务器, 使用23端口；
- http服务器, 使用80端口；
- https服务器, 使用443端口。
程序注册端口 1024~49151，分配给用户或者程序
- tomcat 8080
- mysql 3306
- 9876: postgresql
- 6379: redis
- Oracle 1521

动态、私有端口 49152-65535

在IDEA中创建HTML，其端口号为 63342

netstat -ano
netstat -ano|findstr "5900"  #查看指定的端口
tasklist|findstr "3640"  #查看指定端口的进程
CTRL+shift+esc #打开任务管理器

import java.net.InetSocketAddress;

public class TestSocketInetAddress01 {
    public static void main(String[] args) {
        InetSocketAddress socketAddress = new InetSocketAddress("127.0.0.1", 8080);
        InetSocketAddress socketAddress2 = new InetSocketAddress("localhost", 8080);
        System.out.println(socketAddress);
        System.out.println(socketAddress2);
        System.out.println(socketAddress.getAddress());
        System.out.println(socketAddress.getHostName());
        System.out.println(socketAddress.getPort());
    }
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-LMecvzXq-1631548808683)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20210906200337772.png)]

1.5 通信协议

协议：即约定，比如我们交谈用到的普通话

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

问题：非常复杂

大事化小，，分层

TCP/IP协议簇

最主要的基于传输层的协议

TCP:传输控制协议（Transmission Control Protocol）是一种面向连接的、可靠的、基于字节流的传输层通信协议，由IETF的RFC 793 定义。
UDP: 用户数据报协议（User Datagram Protocol）。UDP 为应用程序提供了一种无需建立连接就可以发送封装的 IP 数据包的方法。RFC 768 描述了 UDP。

TCP UDP区别

TCP 打电话

连接、稳定

三次握手，四次挥手

最少需要三次，保持稳定连接
A:你愁啥？
B:愁你咋地？
A:干一场

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

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

UDP 发短信
1. 不连接、不稳定
2. 客户端服务端没有明确的界限
3. 不管服务端有没有准备好，都可以进行发送
4. DDOS 洪水攻击（饱和攻击）

1.6 TCP

1.6.1 实现聊天

IO流

客户端

连接服务器 Socket
发送消息

//io流的处理
import java.io.IOException;
import java.io.OutputStream;
import java.net.InetAddress;
import java.net.Socket;

public class TestClientDemo01 {
    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) {
            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();
                }
            }
        }
    }
}

服务端

建立服务的端口 ServerSocket
等待用户的连接 accept
接收用的消息

//io`流
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.net.ServerSocket;
import java.net.Socket;

public class TestServerDemo01 {
    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){
                String 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();
                }
            }
        }
    }
}

1.6.2 TCP上传文件

P7,IO流出问题\\和 / 的作用相同。\\是对\的转义，都可以在window平台中使用，但是因为java有时需要跨平台，linux只能识别 / ，直接用 / 比较好

src下的绝对路径可以，相对路径报错

客户端

package com.raylene.net.tcpfileupload;

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


public class TestClientDemo02 {
    public static void main(String[] args) throws IOException {

        Socket socket = null;
        OutputStream os = null;
        FileInputStream fis = null;
        //1. IP地址和端口号
        InetAddress serverIP = InetAddress.getByName("127.0.0.1");
        int port = 9009;
            //2. 创建一个socket连接，1和2也可合并
            socket = new Socket(serverIP,port);
            //3. 创建一个输出流，IO 流
            os = socket.getOutputStream();
            //4 读取文件
            fis = new FileInputStream(new File("G:/XJTU/studynote/javacode/JAVASE/src/mmm.jpg"));
            // 5 写出文件
            byte[] buffer = new byte[1024];
            int len;
            while((len=fis.read(buffer)) != -1){
                os.write(buffer,0,len);
            }
            //通知服务器，已经接受完毕啦
        socket.shutdownOutput();//我已经传输完了
            //确认服务器接收完毕，才可以断开连接
            InputStream is = socket.getInputStream();
            ByteArrayOutputStream baos = new ByteArrayOutputStream();
            byte[] buffer1 = new byte[1024];
            int len1;
            while((len1 = is.read(buffer1)) != -1) {
                baos.write(buffer1, 0, len1);
            }
        System.out.println(baos.toString());
            //关闭资源
            baos.close();
            is.close();
            fis.close();
            os.close();
            socket.close();
    }
}

服务器端

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

public class TestServerDemo02 {
    public static void main(String[] args) throws IOException {

        //1. 创建服务
        ServerSocket serverSocket = new ServerSocket(9009);
        //2.监听客户端
        Socket socket = serverSocket.accept();
        //3. 获得输入流
        InputStream is = socket.getInputStream();
        //4. 文件输出
        FileOutputStream fos = new FileOutputStream("G:/XJTU/studynote/javacode/JAVASE/src/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();
    }
}

1.6.3 Tomcat

服务器端

自定义 S
Tomcat 服务器 S 重点：Java后台开发用别人的服务器

客户端

自定义 C
浏览器 B

1.7 UDP

消息发送

服务端

import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.SocketException;
//需要等待客户端的连接，否则，消息发送失败，但可以单独运行
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());
        System.out.println(new String(packet.getData(),0,packet.getLength()));
        System.out.println(packet.getSocketAddress());
        System.out.println(packet.getPort());
        socket.close();
    }
}

客户端

import java.net.*;
import java.nio.charset.StandardCharsets;

//UDP不需要连接服务器  Data
public class UdpClientDemo01 {
    public static void main(String[] args) throws Exception {
        //1、建立一个socket连接
        DatagramSocket socket = new DatagramSocket();
        //2、建个包
        String msg = "你好，服务器！";
        DatagramPacket packet = new DatagramPacket(msg.getBytes(),0,msg.getBytes().length,InetAddress.getByName("localhost"),9090);
        //3、发送数据包
        socket.send(packet);
        //4、关闭流
        socket.close();
    }
}

聊天实现

发送端(客户端)

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

public class UdpSendDemo01 {
    public static void main(String[] args) throws Exception {
        //1.建立连接
        DatagramSocket socket = new DatagramSocket(8088);
        while (true){
            //准备数据，从控制台读取数据System.in
            BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
            String data = reader.readLine();
            byte[] datas = data.getBytes();
            //2. 建包，发送数据
            DatagramPacket packet = new DatagramPacket(datas,0,datas.length,new InetSocketAddress("localhost",6868));
            socket.send(packet);
            if(data.equals("bye")){
                break;
            }
        }
        socket.close();
    }
}

接收端(服务端)

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


public class UdpReceiveDemo01 {
    public static void main(String[] args) throws Exception {
        //1. 开发端口
        DatagramSocket socket = new DatagramSocket(6868);
        while(true){
            //2. 接收数据
            byte[] container = new byte[1024];
            DatagramPacket packet = new DatagramPacket(container,0,container.length);
            socket.receive(packet);//阻塞式接收
            //断开连接，bye
            byte[] data = packet.getData();
            String receivedata = new String(data, 0, packet.getLength());
            System.out.println(receivedata);
            if(receivedata.equals("bye")){
                break;
            }
        }
       socket.close();
    }
}

多线程在线咨询

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(int fromPort, String toIP, int toPort){
        this.fromPort = fromPort;
        this.toIP = toIP;
        this.toPort = toPort;
        try {
            //1.建立连接
            socket = new DatagramSocket(fromPort);
            //准备数据，从控制台读取数据System.in
            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();
                //2. 建包，发送数据
                DatagramPacket packet = new DatagramPacket(datas,0,datas.length,new InetSocketAddress(this.toIP,this.toPort));
                socket.send(packet);
                if(data.equals("bye")){
                    break;
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        socket.close();
    }
}

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

public class TalkReceive implements Runnable{
    //1. 开发端口
    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){
            //2. 接收数据
            byte[] container = new byte[1024];
            DatagramPacket packet = new DatagramPacket(container,0,container.length);
            try {
                socket.receive(packet);//阻塞式接收
            } catch (IOException e) {
                e.printStackTrace();
            }
            //断开连接，bye
            byte[] data = packet.getData();
            String receivedata = new String(data, 0, packet.getLength());
            System.out.println(msgfrom+": "+receivedata);
            if(receivedata.equals("bye")){
                break;
            }
        }
        socket.close();
    }
}

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

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

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-L0awupw7-1631548808690)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20210913205917768.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Urq5oD5d-1631548808691)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20210913205937417.png)]

1.8 URL

Uniform Resource Locator,统一资源定位器:定义互联网上的某个资源

域名系统（英文：Domain Name System，缩写DNS）是互联网的一项服务。它作为将域名和IP地址相互映射的一个分布式数据库，能够使人更方便地访问互联网。

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

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

public class TestDemo01 {
    public static void main(String[] args) throws IOException {
        //1.下载地址
        URL url = new URL("https://m801.music.126.net/20210913233956/a6a3d6a2742f2c8cb67cdfbcc3cefb9f/jdyyaac/obj/w5rDlsOJwrLDjj7CmsOj/5546003514/e409/aed6/f93a/e0f802f6dbe22026d98c0129ec474324.m4a");
        //2.连接到这个资源  HTTP
        HttpURLConnection urlConnection = (HttpURLConnection) url.openConnection();
        InputStream is = urlConnection.getInputStream();

        FileOutputStream fos = new FileOutputStream("missSpace.m4a");
        byte[] buffer = new byte[1024];
        int len;
        while ((len = is.read(buffer)) != -1){
            fos.write(buffer,0,len);//写出这个数据
        }
        fos.close();
        is.close();
        urlConnection.disconnect();

    }
}