【网络编程】Java网络编程

⭐️写在前面的话⭐️

📒博客主页： 程序员好冰
🎉欢迎 【点赞👍 关注🔎 收藏⭐️ 留言📝】
📌本文由 程序员好冰 原创，优快云 首发！
📆入站时间： 🌴2022 年 07 月 13 日🌴
✉️ 是非不入松风耳，花落花开只读书。
💭推荐书籍：📚《Java编程思想》，📚《Java 核心技术卷》
💬参考在线编程网站：🌐牛客网🌐力扣
🍭 作者水平很有限，如果发现错误，一定要及时告知作者哦！感谢感谢！🍭

---

一、概述

包（packet）：1、对方的信息；2、对方的地址；3、自己的地址。

TCP:打电话—链接—接通—通话（双向）

UDP:发信息—发送—结束（单向）

1.1计算机网络

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

1.2 网络编程的目的

数据交换，即通信。

1.3 如何做

1. 如何准确地定位网络上的一台或者多台主机：IP、端口（port）、定位到计算机上的某个资源；
2. 找到了这个主机，如何进行传输数据（通信）；

1.4 网页编程和网络编程

• 网页编程—JavaWeb—B/S架构
• 网络编程—TCP/UDP—C/S架构

二、网络通信的两个要素

如何实现网络的通信：

需要通信双方的地址：IP + 端口号（port）；

需要统一的规则：网络通信协议。

2.1 TCP/IP参考模型

2.2 访问百度的域名

三、IP地址

IP可以唯一定位一台网络上的计算机

本机IP(localhost) : 127.0.0.1

3.1 IP地址分类

• IPv4、IPv6

  • IPv4
  • IPv6：使用ipconfig查看

• 公网IP（互联网）、私网IP（局域网）

  • 192.169.xxx.xxx 局域网

  五类地址划分

  

3.2 常用方法

package space;

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

public class InetAddressDemo {
    public static void main(String[] args) {
        try {
            //查询本机地址
            InetAddress byName = InetAddress.getByName("127.0.0.1");
            System.out.println(byName);

            InetAddress byName2 = InetAddress.getByName("localhost");
            System.out.println(byName2);

            InetAddress byName3 = InetAddress.getLocalHost();
            System.out.println(byName3);

            //查询网站IP地址
            InetAddress byName4 = InetAddress.getByName("www.baidu.com");
            System.out.println(byName4);

            //常用方法
            /*public byte[] getAddress()*/
            System.out.println(byName4.getAddress());
            //获得主机域名
            System.out.println(byName4.getHostName());
            //获取规范的IP名
            System.out.println(byName4.getCanonicalHostName());
            //IP地址
            System.out.println(byName4.getHostAddress());
        } catch (UnknownHostException e) {
            throw new RuntimeException(e);
        }
    }
}

四、端口

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

端口号的主要作用是表示一台计算机中的特定进程所提供的服务。

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

4.1 端口分类

TCP与UDP段结构中端口地址都是16比特，可以有在0—65535范围内的端口号。

按照端口号分类：

1. 公认端口：0~1023。它们紧密绑定于一些服务，通常这些端口的通讯明确表明了某种服务的协议，如：80端口对应与HTTP通信，21端口绑定与FTP服务，25端口绑定于SMTP服务，135端口绑定与RPC（远程过程调用）服务。
2. 注册端口：1024~49151。它们松散的绑定于一些服务，也就是说有许多服务绑定于这些端口，这些端口同样用于其他许多目的，如：许多系统处理端口从1024开始
3. **动态或私有端口：49152~65535。**理论上，不应为服务分配这些端口，通常机器从1024开始分配动态端口。例外：SUN的RPC端口从32768开始。

**按照协议类型分类：**按协议类型划分可分为TCP端口、UDP端口、IP端口、ICMP。

1. **TCP端口：**即传输控制协议端口，需要在客户端和服务器之间建立连接，这样可以提供可靠的数据传输。常见的包括FTP的21端口，Telnet的23端口，SMTP的25端口，HTTP的80端口。
2. **UDP端口：**即用户数据报协议端口，无需在客户端和服务器端建立连接，安全性得不到保障。常见的DNS的53端口，SNMP（简单网络管理协议）的161端口，QQ使用的8000和4000端口。
3. **保留端口：**UNIX有保留端口号的概念，只有超级用户特权的进程才允许给它自己分配一个保留端口号。这些端口号介于1~1023之间，一些应用程序将它作为客户与服务器认证的一部分。

端口使用的注意事项

1. 不要使用端口号小于1024的端口。
2. 端口号一般习惯为4位整数，在同一台计算机上端口号不能重复，否则，会产生端口号冲突。
3. 客户端端口号因存在时间很短暂又称临时端口号，大多数TCP/IP实现给临时端口号分配1024—5000之间的端口号。大于5000的端口号是为其他服务器预留的 。

4.2 常用端口号

• HTTP:80
• HTTPS:443
• FTP:21
• Telent:23
• Tomcat:8080
• MySQL:3306
• Oracle:1521

4.3 查看所有的端口

快捷键打开任务管理器：ctrl + shift + esc

netstat -ano #查看所有的端口
netstat -ano|findstr "51834" #查看指定的端口
tasklist|findstr "17648" #查看指定端口的进程

package space;

import java.net.InetAddress;
import java.net.InetSocketAddress;

public class InetSocketAddressDemo {

    public static void main(String[] args) {

        /*public InetSocketAddress(InetAddress addr, int port)*/
        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());
        
    }
}

五、通信协议

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

TCP：用户传输协议

UDP：用户数据报协议

5.1 TCP/IP协议簇

TCP/IP是一组协议的代名词，包括许多别的协议，组成了TCP/IP协议簇。其中比较重要的有SLIP协议、PPP协议、IP协议、ICMP协议、ARP协议、TCP协议、UDP协议、FTP协议、DNS协议、SMTP协议等。TCP/IP协议并不完全符合OSI的七层参考模型。

5.2 TCP和UDP对比

	TCP	UDP
抽象	打电话	发短信
连接	连接，稳定	不连接，不稳定
	三次握手 ，四次挥手
	客户端、服务端	没有明确的界限
	传输完成，释放连接，效率低	不管有没有准备好，都可以发
		导弹攻击，DDOS洪水攻击，饱和攻击

三次握手：（最少需要三次，保证稳定连接）

A：你瞅啥？
B：瞅你咋地？
A：干一场！

四次挥手：

A：我要走了。
B：你真的要走了吗？
B：你真的真的要走了吗？
A：我真的真的要走了。

六、TCP

1、TCP实现聊天

	客户端	服务器
1	通过Socket连接服务器	建立服务的的端口ServerSocket
2	使用IO流发送消息	等待用户的连接，使用accept
3		使用IO流接受用户的消息

客户端

package space.haobin01;

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) throws IOException {
        //客户端连接服务器

        //1.要知服务器的地址
        InetAddress serverIP = InetAddress.getByName("127.0.0.1");

        //2.端口号
        int port = 9999;

        //3.创建一个socket的连接
        /*public Socket(InetAddress address, int port)*/
        Socket socket = new Socket(serverIP,port);

        //4.发送消息 IO流
        OutputStream os = socket.getOutputStream();
        os.write("你好，欢迎使用TCP".getBytes());

        os.close();
        socket.close();
    }
}

服务器

package space.haobin01;

import java.io.ByteArrayInputStream;
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) throws IOException {


        //1.服务器本身应该有一个地址
        ServerSocket serverSocket = new ServerSocket(9999);

        //2.等待客户端连接过来
        Socket socket = serverSocket.accept();

        //3.读取客户端的消息
        InputStream is = socket.getInputStream();

        //通过管道流
        ByteArrayOutputStream 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());

        baos.close();
        is.close();
        socket.close();
        serverSocket.close();
    }
}

2、TCP实现文件上传

服务器

package space.haobin03;

import java.io.File;
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(new File("receive.jpg"));

        byte[] buffer = new byte[1024];
        int len;
        while((len=is.read(buffer))!=-1){
            fos.write(buffer,0,len);
        }

        //通知客户端我接受完毕了
        OutputStream os = socket.getOutputStream();
        os.write("我接受完毕了，你可以断开了".getBytes());

        //5.关闭资源
        fos.close();
        is.close();
        socket.close();
        serverSocket.close();

    }
}

客户端

package space.haobin03;

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

public class TCPClientDemo {
    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("dog.jpg"));

        //4.写出文件
        byte[] buffer = new byte[1024];
        int len;
        while((len=fis.read(buffer))!=-1){
            os.write(buffer,0,len);
        }

        //通知服务器，我已经传输完了
        socket.shutdownOutput();


        //确定服务器接受完毕，才能够断开连接
        InputStream inputStream = socket.getInputStream();
        //由于不知道传进来的是什么，所以使用管道流进行过滤
        ByteArrayOutputStream baos = new ByteArrayOutputStream();

        byte[] buffer2 = new byte[1024];
        int len2;
        while((len2=inputStream.read(buffer2))!=-1){
            baos.write(buffer2,0,len2);
        }

        System.out.println(baos.toString());

        //5.关闭资源(先写后关)
        baos.close();
        inputStream.close();
        fis.close();
        os.close();
        socket.close();
    }
}

注意：图片资源要放在根目录下

七、Tomcat初识

服务器：

• 自定义—S
• Tomcat服务器—S

客户端

• 自定义—S
• 浏览器—B

1、什么是Tomcat

Tomcat简单的说就是一个运行JAVA的网络服务器，底层是Socket的一个程序，它也是JSP和Serlvet的一个容器。

2、为什么我们需要用到Tomcat

如果你学过html，css，你会知道你写的页面只能自己访问，别人不能远程访问你写的页面，Tomcat就是提供能够让别人访问自己写的页面的一个程序

八、UDP

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

不需要连接服务器

客户端和服务器的身份可以互换

1、UDP消息发送

发送端

package space.haobin04;

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

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;

        /*public DatagramPacket(byte buf[], int offset, int length,
        InetAddress address, int port)*/
        DatagramPacket packet = new DatagramPacket(msg.getBytes(),0,msg.getBytes().length,localhost,port);
        //3.发送包
        socket.send(packet);

        //4.关闭资源
        socket.close();
    }
}

接收端

package space.haobin04;

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

public class UDPServerDemo01 {
    public static void main(String[] args) throws Exception {

        //没有服务的概念，但还是要等待客户端的连接

        //开放端口
        DatagramSocket socket = new DatagramSocket(9090);
        //接收数据
        byte[] buffer = new byte[1024];
        /*public DatagramPacket(byte buf[], int offset, int length)*/
        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();
    }
}

2、UDP聊天实现

2.1 单线程实现

发送方

package space.haobin05;

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

public class UDPSenderDemo {
    public static void main(String[] args) throws Exception {
        DatagramSocket socket = new DatagramSocket(8888);

        while(true){
            //准备数据,控制台读取 System.in

            BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
            String data = reader.readLine();
            byte[] datas = data.getBytes();
            DatagramPacket packet = new DatagramPacket(datas,0,datas.length,new InetSocketAddress("localhost",6666));

            socket.send(packet);

            if(data.equals("bye")){
                break;
            }
        }

        socket.close();
    }
}

接受方

package space.haobin05;

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

public class UDPReceiverDemo {
    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);//阻塞式接收包裹

            //断开连接
            byte[] data = packet.getData();
            String receiveDatas = new String(data, 0, data.length);
            System.out.println(receiveData.trim());
            if(receiveDatas.equals("bye")){
                break;
            }
        }
        socket.close();
    }
}

2.2 多线程优化

发送类

package space.haobin06;

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 {
            socket = new DatagramSocket(fromPort);
            reader = new BufferedReader(new InputStreamReader(System.in));
        } catch (SocketException e) {
            throw new RuntimeException(e);
        }
    }

    @Override
    public void run() {
        while(true){

            try {
                //准备数据,控制台读取 System.in
                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 (IOException e) {
                throw new RuntimeException(e);
            }
        }

        socket.close();
    }
}

接收类

package space.haobin06;

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

public class TalkReceive implements Runnable{
    DatagramSocket socket = null;
    DatagramPacket packet = 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) {
            throw new RuntimeException(e);
        }
    }

    @Override
    public void run() {

        try {
            while(true){
                //准备接收包裹
                byte[] container = new byte[1024];
                DatagramPacket packet = new DatagramPacket(container,0,container.length);

                socket.receive(packet);//阻塞式接收包裹

                //断开连接
                byte[] data = packet.getData();
                String receiveData = new String(data, 0, data.length);
                System.out.println(msgFrom+":"+receiveData.trim());
                if(receiveData.equals("bye")){
                    break;
                }
            }
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
        socket.close();
    }
}

学生端

package space.haobin06;

public class TalkStudent {
    public static void main(String[] args) {
        //发送:用哪个端口发，发个哪个IP地址(主机)，哪个端口
        new Thread(new TalkSend(7777,"localhost",9999)).start();
        //接受:用哪个端口接受，是接受谁的信息
        new Thread(new TalkReceive(8888,"老师")).start();
    }
}

老师端

package space.haobin06;

public class TalkTeacher {
    public static void main(String[] args) {
        //发送:用哪个端口发，发个哪个IP地址(主机)，哪个端口
        new Thread(new TalkSend(6666,"localhost",8888)).start();
        //接受:用哪个端口接受，是接受谁的信息
        new Thread(new TalkReceive(9999,"学生")).start();
    }
}

九、URL

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

DNS域名解析:将www.baidu.com解析为 14.119.104.189。

URL结构:

​ 协议://ip地址:端口号/具体项目名/对应资源

推荐文章:深入剖析网页地址URL的结构及元素 - 知乎 (zhihu.com)

1、URL初识

package space.haobin07;

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

public class URLDemo {
    public static void main(String[] args) throws MalformedURLException {

        /*public URL(String spec) throws MalformedURLException*/
        URL url = new URL("http://localhost:8080/helloworld/index.jsp?username=haobin&password=123456");

        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());//获得参数

    }
}

2、通过URL下载文件

将Tomcat项目下的文件下载到根目录下，前提：打开Tomcat，8080端口

通过URL下载文件，需要:

• 找到文件的地址
• 与这个URL地址建立连接
• 获得输入流
• 处理输出流（新建文件）

package space.haobin07;

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

public class URLDemo02 {
    public static void main(String[] args) throws Exception {

        //1.找到这个地址
        URL url = new URL("http://localhost:8080/haobin/SecurityFile.html");

        //2.连接到这个资源 HTTP
        HttpURLConnection urlConnection =(HttpURLConnection) url.openConnection();

        //3.获得流
        InputStream inputStream = urlConnection.getInputStream();
	
        //4.下载过来的文件的文件名+文件后缀
        FileOutputStream fos = new FileOutputStream("SecurityFile.html");

        byte[] buffer = new byte[1024];
        int len;
        while((len=inputStream.read(buffer))!=-1){
            fos.write(buffer,0,len);
        }
        fos.close();;
        inputStream.close();
        urlConnection.disconnect();//断开连接
    }
}

---

🚀先看后赞，养成习惯！🚀

🚀 先看后赞，养成习惯！🚀

🎈觉得文章写得不错的老铁们，点赞评论关注走一波！谢谢啦！🎈

---