Day17,18 网络编程:通信协议(TCP,UDP),IP,端口

最新推荐文章于 2024-08-01 22:14:24 发布
最新推荐文章于 2024-08-01 22:14:24 发布
阅读量556 收藏
点赞数
分类专栏： JavaSE 文章标签： 网络 java socket
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_37207539/article/details/108682355
版权

网络编程

1.1、概述

地球村：

对地球的一种比喻说法。现代科技的迅速发展，缩小了地球上的时空距离，国际交往日益频繁便利，因而整个地球就如同是茫茫宇宙中的一个小村落。

计算机网络：

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

网络编程的目的：

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

想要达到的效果需要什么：

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

javaweb:网页编程 BS

网络编程：TCP/IP CS

1.2、网络通信的要素

如何实现网络通信？

需要知道通信双方地址：

  • ip 192.168.1.1
  • 端口号
  • 192.168.16.24:5900

规则：网络通信协议

TCP/IP 参考模型

在这里插入图片描述

小结：

  1. 网络编程中有两个主要问题
    • 如何准确定位到网络上的一台或者多台主机
    • 找到主机之后如何进行通信
  2. 网络编程中的要素
    • ip和端口号 ip
    • 网络通信协议 udp，tcp
  3. 万物皆对象

1.3、IP

ip地址：InetAddress

  • 唯一定位一台计算机

  • 127.0.01:本机localhost

  • ip地址分类

    • ipv4/ipv6地址分类

      • IPV4 127.0.0.1 ,4个字节组成,1个字节8位。0-255，42亿~；30亿都在北美，亚洲4亿，2011年就用尽了。
      • IPV6 fe80::e574:5dfc:4204:8875%11,16个字节，128位。8个无符号整数。
      2001：0bb2:aaa:0015:0000:0000:1aaa:1312
每个数字都是16进制，一个十六进制数可以写成4个二进制数（就是占4位）。共32个数字*4位=128

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

      • ABCD类地址

      • 192.168.xx.xx ,专门给组织内部使用的。

  • 域名：记忆IP问题！

    • IP:www.vip.com 万网
import java.net.UnknownHostException;

public class TestInetAddress {
    public static void main(String[] args) {
        try {
            //查询本地地址
            InetAddress byName = InetAddress.getByName("127.0.0.1");
            System.out.println(byName);
            //查询网站ip地址
            InetAddress byName1 = InetAddress.getByName("www.baidu.com");
            System.out.println(byName1);
            //常用方法
            System.out.println(byName1.getAddress());
            System.out.println(byName1.getCanonicalHostName());//规范的名字
            System.out.println(byName1.getHostAddress());//ip
            System.out.println(byName1.getHostName());//域名，或者自己的电脑的额名字
        } catch (UnknownHostException e) {
            e.printStackTrace();
        }
    }

}

1.4、端口

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

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

  • 端口被规定范围：0~65535

  • TCP,UDP:这两个都有65535这么多端口，即65535*2。tcp:80,udp:80.单个协议下，端口号不能冲突。

  • 端口分类

    • 公有端口0-1023

      • HTTP默认端口：80
      • HHTPS默认端口:443
      • FTP:21
      • Telent:23

    • 程序注册端口：1024~49151，非陪用户或者程序

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

    • 动态、私有：49152-65535

      netstat -ano 命令：可以查看本机开放的全部端口。
      • LISTENING时表示处于侦听状态，就是说该端口是开放的，等待连接，但还没有被连接。就像
        你房子的门已经敞开的，但还没有人进来。
      • ESTABLISHED的意思是建立连接。表示两台机器正在通信。
      • CLOSE_WAIT 对方主动关闭连接或者网络 异常导致连接中断。
      • TIME_WAIT 我方主动调用close()断开连接，收到对方确认后状态变为TIME_WAIT。
      netstat -ano|findstr "5900":查看5900端口详情。
tasklist|findsr "8696" :查看指定端口的进程。（或者电脑任务管理器里面的PID栏查看）

      public class TestInetSocktaddress {
    public static void main(String[] args) {
        InetSocketAddress inetSocketAddress = new InetSocketAddress("127.0.0.1", 8080);
        InetSocketAddress inetSocketAddress2 = new InetSocketAddress("localhost", 8080);
        System.out.println(inetSocketAddress);
        System.out.println(inetSocketAddress2);
        System.out.println(inetSocketAddress.getAddress());
        System.out.println(inetSocketAddress.getHostName());//hosts文件可以配置映射地址
        System.out.println(inetSocketAddress.getPort());//端口
    }
}

在这里插入图片描述

1.5、通信协议

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

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

**问题：**非常的复杂

大事化小：分层！

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

重要：

  • TCP:用户传输协议。
  • UDP:用户数据报协议。

出名的协议：

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

TCP和UDP对比：

TCP:打电话

  • 连接，稳定
  • 三次握手，四次挥手。
最少需要三次，保证稳定连接！
A:你瞅啥？
B:瞅你咋地？
A:干一场！

四次挥手：
A:我要走了
B:你真的要走了吗？
B:你真的真的要走了吗？
A:我真的要走了！

在这里插入图片描述
在这里插入图片描述

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

UDP:发短信

  • 不连接，不稳定。
  • 客户端、服务端：没有明确的界限。
  • 不管有没有准备好，都可以发给你。
  • 导弹攻击
  • DDOS:洪水攻击！（饱和攻击）

1.6、TCP

客户端

  1. 连接服务器 Socket
  2. 发送消息
//客户端
public class TcpClientDemo01 {
    public static void main(String[] args) {
        Socket socket=null;
        OutputStream outputStream=null;
        try {
            //1.要知道服务器的地址、端口号
            InetAddress serverIp=InetAddress.getByName("127.0.0.1");
            int port=9999;
            //2.创建一个socket连接
             socket = new Socket(serverIp,port);
            //3.发送消息 IO流
             outputStream = socket.getOutputStream();
            outputStream.write("你好，欢迎学习java".getBytes());

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

服务器

  1. 建立服务端口ServerSocket
  2. 等待用户的连接accept
  3. 接收消息
//服务端
public class TcpServerDemo01 {
    public static void main(String[] args) {

        ServerSocket serverSocket = null;
        Socket socket = null;
        InputStream inputStream = null;
        ByteArrayOutputStream baos = null;
        try {
            //1.我得有一个地址
            serverSocket = new ServerSocket(9999);
            while (true){
                //2.等待客户端连接过来
                socket = serverSocket.accept();
                //3.读取客户端的消息
                inputStream = socket.getInputStream();
                //管道流
                baos = new ByteArrayOutputStream();
                byte[] buffer = new byte[1024];
                int len;
                while ((len = inputStream.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 (inputStream != null) {
                try {
                    inputStream.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();
                }
            }
        }
    }
}

文件上传

//服务端
public class TcpServerDemo02 {
    public static void main(String[] args) {
        ServerSocket serverSocket = null;
        Socket socket = null;
        InputStream inputStream = null;
        FileOutputStream baos = null;
        OutputStream outputStream = null;
        try {
            //1.创建服务
            serverSocket = new ServerSocket(9000);

            //2.监听客户端连接//阻塞式监听，会一直等待客户端连接
            socket = serverSocket.accept();
            //3.读取客户端的消息//获取输入流
            inputStream = socket.getInputStream();
            //4.文件输出，利用管道流
            baos = new FileOutputStream(new File("jyw123.jpg"));
            byte[] buffer = new byte[1024];
            int len;
            //每次读取一个字节
            while ((len = inputStream.read(buffer)) != -1) {
                baos.write(buffer, 0, len);
            }

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


        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //关闭资源
            if (outputStream != null) {
                try {
                    outputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (baos != null) {
                try {
                    baos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (inputStream != null) {
                try {
                    inputStream.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();
                }
            }


        }
    }
}

//客户端
public class TcpClientDemo02 {
    public static void main(String[] args) {
        //1。创建一个Socket连接
        Socket socket = null;
        try {
            socket = new Socket(InetAddress.getByName("127.0.0.1"),9000);
            //2.创建一个输出流
            OutputStream outputStream = socket.getOutputStream();
            //3.文件流
            FileInputStream fileInputStream = new FileInputStream(new File("F:\\worksapce\\wlbc-study\\src\\123.jpg"));
            //4.写出文件
            byte[] buffer = new byte[1024];
            int len;
            // read (byte[] b) 方法， 从输入流中读取一定数量的字节，并将其存储在缓冲区数组 b 中。以整数形式返回实际读取的字节数。
            while ((len=fileInputStream.read(buffer))!=-1){
                outputStream.write(buffer,0,len);
            }

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

            //确定服务器接收完毕，才能断开连接
            InputStream inputStream = socket.getInputStream();
            //String byte[]
            ByteArrayOutputStream baos = new ByteArrayOutputStream();
            byte[] buffer2 = new byte[2014];
            int len2;
            while ((len2=inputStream.read(buffer2))!=-1){
                baos.write(buffer2,0,len2);
            }
            System.out.println(baos.toString());
            //5.关闭资源
            baos.close();
            fileInputStream.close();
            outputStream.close();
            socket.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Tomcat

服务端

  • 自定义S
  • Tomcat服务器S

客户端

  • 自定义 C
  • 浏览器 B

1.7、UDP

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

发送消息：

public class UdpClientDemo1 {
    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;
        //下面的参数解释：数据，数据长度起始，要发送给谁
        DatagramPacket packet = new DatagramPacket(msg.getBytes(), 0, msg.getBytes().length, localhost, port);

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

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

接收消息

//还是要等待客户端的连接！
public class UdpServerDemo1 {
    public static void main(String[] args) throws Exception {
        //开放端口
        DatagramSocket socket = new DatagramSocket(9090);

        //接收数据包
        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();

    }
}

循环发送消息

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

        DatagramSocket socket = new DatagramSocket(8888);

        //准备数据：读取控制台Ststem.in
        BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
        while (true) {
            String data = reader.readLine();
            byte[] dates = data.getBytes();
            DatagramPacket packet = new DatagramPacket(dates, 0, dates.length, new InetSocketAddress("localhost", 6666));
            System.out.println(dates.length);//bye:3
            System.out.println(packet.getLength());//bye:3

            socket.send(packet);

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

循环接收消息

public class UdpReceiveDemo01 {
    public static void main(String[] args) throws Exception {
        DatagramSocket socket = new DatagramSocket(6666);
        while (true) {
            //准备接收包裹，放到container里面
            byte[] container = new byte[1024];
            System.out.println(container.length);//1024
            DatagramPacket packet = new DatagramPacket(container, 0, container.length);
            System.out.println(packet.getLength());//1024
            socket.receive(packet);//阻塞式接收包裹。上面是1024，下面是3，说明receive方法将他改变了
            System.out.println(packet.getLength());//3

            //断开连接byte
            byte[] data = packet.getData();//1024
            //String receiveData = new String(data, 0, data.length);//1024
            String receiveData = new String(data, 0, packet.getLength());
            //我不需要固定数组container那么长（1024），我只需要packet里面数据长度(3),这样写后面的equals判断不需要写trim（）

            System.out.println(packet.getLength());//收到的是长度是3
            System.out.println(data.length);//1024
            System.out.println(receiveData.length());//3
            System.out.println(receiveData);
            if (receiveData.trim().equals("bye")) {
                break;
            }
        }
        socket.close();
    }
}

在线咨询：两个人都可以发送方，也都可以是接收方！

多线程互相聊天

发送类工具

//发送线程
public class TalkSend implements Runnable{
    DatagramSocket socket =null;
    BufferedReader reader =null;
    private String toIp;
    private int fromPort;
    private int toPort;

    public TalkSend(int fromPort,String toIp,  int toPort) {
        this.toIp = toIp;
        this.fromPort = fromPort;
        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();
                DatagramPacket packet = new DatagramPacket(data.getBytes(), 0, data.getBytes().length, new InetSocketAddress(this.toIp, this.toPort));
                socket.send(packet);
                if (data.equals("bye")) {
                    break;
                }
            } catch (Exception e) {
                e.printStackTrace();
            }

        }
        socket.close();
    }
}

接受类工具

//接收线程
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 {
                //准备接收包裹，放到container里面
                byte[] container = new byte[1024];
                DatagramPacket packet = new DatagramPacket(container, 0, container.length);
                socket.receive(packet);//阻塞式接收包裹。上面是1024，下面是3，说明receive方法将他改变了
                //断开连接byte
                String receiveData = new String(packet.getData(), 0, packet.getLength());
                System.out.println(msgFrom+"："+receiveData);
                if (receiveData.trim().equals("bye")) {
                    break;
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        socket.close();
    }
}

学生端启动类

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

老师类启动端

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

1.8、URL

https://www.baidu.com/

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

DNS域名解析：将https://www.baidu.com/解析成xxx.x…x…x

本质是把域名解析成ip

基本上5部分组成：
协议：//IP地址：端口/项目名/对应资源

public class URLDown {
    public static void main(String[] args) throws Exception {
        //1.下载地址
        URL url = new URL("https://m10.music.126.net/20200919161055/7963703b1af08b9d00a2e6ce2ba6c981/yyaac/obj/wonDkMOGw6XDiTHCmMOi/3918591949/c8a1/cba7/c6ea/5a3677569928db9f736580e5a2107f55.m4a");
        HttpsURLConnection httpURLConnection=(HttpsURLConnection)url.openConnection();

        InputStream inputStream = httpURLConnection.getInputStream();

        FileOutputStream fileOutputStream = new FileOutputStream("f.m4a");

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

        fileOutputStream.close();
        inputStream.close();
        httpURLConnection.disconnect();//断开连接

    }
}
蒋亚文
关注
专栏目录
网络编程个人归纳
路人也是身边人的博客
03-03 343
前言 最近又学习了基础的网络编程，主要是学习并使用UDP和TCP来编写Demo，做一下归纳总结，方便以后温习。 正文 定位资源 首先网络编程第一步，定位资源： 定位一台机器： 使用IP 定位一个软件： 使用端口Port 定位软件上的一个资源：使用URL IP //得到本机InetAddress对象 InetAddress addr = InetAddress.getLocalHost(...
day31 网络通信udp,ip地址,端口port
abc____123的博客
05-31 1587
网络通信概述1. 什么是网络说明网络就是一种辅助双方或者多方能够连接在一起的工具如果没有网络可想单机的世界是多么的孤单单机游戏（不能和远在他乡的朋友一起玩）2. 使用网络的目的就是为了联通多方然后进行通信用的，即把数据从一方传递给另外一方前面的学习编写的程序都是单机的，即不能和其他电脑上的程序进行通信为了让在不同的电脑上运行的软件，之间能够互相传递数据，就需要借助网络的功能小总结使用网络能够把多方...
18 网络编程(UDP,TCP协议编程)
Baldteen_的博客
07-20 360
18 网络编程(UDP,TCP协议编程) 网络编程 概述 概念 : ​ 计算机网络是通过传输介质 , 通信设施和网络通信协议 , 把分散在不同地点的计算机设备不连起来 , 实现资源共享和数据传输的系统 . 网络边喝茶能就是编写程序使联网的两个 ( 或多个 ) 设备 ( 例如计算机 ) 之间进行数据传输 . Java语言对网络编程提供了良好的支持 , 通过其提供的接口我们可以很方便的进行网络编程 . 网络模型 OSI 世界上第一个网络体系结构由IBM公司提出 ( 1974年 , SNA ) , 以后其他公
【网络】UDP协议——传输层、端口号、UDP协议、UDP协议端格式、UDP的特点、UDP的缓冲区、UDP使用注意事项
最新发布
Crocodile1006的博客
08-01 1629
Linux网络、传输层、端口号、UDP协议、UDP协议端格式、UDP的特点、UDP的缓冲区、UDP使用注意事项、基于UDP的应用层协议
网络编程_开篇
weixin_43003240的博客
02-24 268
我们身边每台电脑、每部手机、每个手持设备都叫网络上的一个节点。 比如说电脑，每个人都有一台电脑，电脑跟电脑之间组成一个网络，多台电脑之间组成一个网络，根据不同的区域我们分为大网络、小网络，也就是我们所谓的局域网、公网或者互联网。 电脑是如何交流的？通过地址！所以在这就有一个概念叫【IP地址】，每一台电脑都有自己的IP地址，当然这个IP地址是先从公网再到内网一 一作区分的，用IP地址去定位一台电脑、...
UDP搜索IP与端口
qq_30347133的博客
05-17 410
1.服务端代码： package server; import clink.net.qiu.clink.utils.ByteUtils; import constants.UDPConstants; import java.net.DatagramPacket; import java.net.DatagramSocket; import java.nio.ByteBuffer; import java.util.UUID; public class ServerProvider {
7.IP地址分类与TCP/UDP端口
weixin_40535588的博客
04-11 768
要想使网络设备或者主机能够连接到 Internet，必须为网络设备配置 IP 地址。由于在 Internet 上 IP 地址是全世界唯一的，IP 地址可以标识一个主机。目前应用范围最广泛的因 特网地址使用的是 IPv4（IP 第 4 版本）的 IP 地址，长为 32 位，由 4 组十进制数组成，每 组数值的范围为 0～255，中间用点号（“.”）隔开，称之为四组“点分二进制”。例如，IP ...
L6网络编程--TCP、IP协议原理（day7）
楚子航
08-03 563
使用过程： 详见：包括IP和TCPTCP包头格式详解_xiongping_的博客-CSDN博客_tcp包头结构https://blog.csdn.net/xiongping_/article/details/47746953版本4 bit首部长度4 bit服务类型（TOS）8 bit总长度（字节数）16 bit标识16 bit标志3 bit片偏移13 bit生成时间（TTL）8 bit协议8 bit首部检验和16 bit源IP地址32 bit目的IP地址32 bit选项（可选）数据4bit的版本字段表示I
day072：UDP协议发送数据、接收数据（DatagramSocket、DatagramPacket）；TCP协议发送数据、接收数据（Socket、ServerSocket）
ZuoQi的博客
11-22 813
UDP协议发送数据、接收数据（DatagramSocket、DatagramPacket）；TCP协议发送数据、接收数据。
黑马毕向东Java课程笔记（day23-01——23-14)）：网络编程：网络模型、IP地址、UDP/TCP协议及其应用、相关练习
LKJgdut的博客
10-17 306
font color=black size=3 face=“微软雅黑”> 1、网络编程简介（这一部分见视频23-01的介绍）   首先，网络的模型如下：（这部分参考计算机网络） OSI参考模型 TCP/IP参考模型   其次，网络通讯要素包含： IP地址 端口号 传输协议   具体的传输过程如下： 1、找到对方IP地址； 2、数据要发送到对方指定的应用程序上。 为了标识这些应用程序，所以...
网络安全学习笔记--Day1 TCP/IP协议：（千峰网络安全视频笔记）
CongM_JueD的博客
08-27 1611
TCP/IP协议
常用端口与udp协议
分享学习的知识，记录我的技术成长道路
08-30 2170
udp是全双工的，即可以在sendto的同时调用recvfrom，应用层我们调用的recv,read,write,sendto等函数，与其说是收发函数不如说是拷贝函数，其实都是在缓冲区中完成拷贝。udp具有接收缓冲区，但是这个接收缓冲区不能保证收到的udp报的顺序和发送udp报的顺序一致，如果缓冲区满了，再到达的udp数据就会被丢弃；0-1023：知名端口号，HTTP，FTP，SSH等这些广为使用的应用层协议，他们的端口号都是固定的。面向数据报：不能够灵活的控制读写数据的次数和数量。......
详解HHTPS-图解HTTP
不吃鱼的猫
12-08 5万+
最近看了图解HTTP一书，记录一下，面试常问的HTTPS。后续会不断修正。。。加油，小白。 在 HTTP 协议中有可能存在信息窃听或身份伪装等安全问题。使用 HTTPS 通信机制可以有效地防止这些问题。以下就先聊HTTP的缺点然后看HTTPS如何克服这些缺点。 1.HTTP 的缺点 通信使用明文（不加密），内容可能会被窃听 不验证通信方的身份，因此有可能遭遇伪装 无法证明报文的...
[Python]校园网(网页认证)开机/断网自动连接
runepic的博客
12-09 4881
针对网页认证方式的校园网，实现登录的自动化。
网络传输知识：HTTPS协议详解
Max_138015的博客
08-11 447
背景： HTTP协议由于是明文传送，所以存在三大风险： 1、被窃听的风险：第三方可以截获并查看你的内容 2、被篡改的危险：第三方可以截获并修改你的内容 3、被冒充的风险：第三方可以伪装成通信方与你通信 HTTP因为存在以上三大安全风险，所以才有了HTTPS的出现。HTTPS涉及到了很多概念，比如SSL/TLS，数字证书、数字签名、加密、认证、公钥和私钥等。 对称加密 采用单钥密码系统的加密算法，同一个秘钥可以同时用作信息的加密和解密，这种加密方法就成为对称加密，也称为单秘钥加密。对称加密的秘钥只有一个，加
windows cmd下http和https代理设置以及取消
weixin_30349597的博客
04-23 5669
1.设置代理 set http_proxy=http://192.168.1.1:8080 set http_proxy=http://proxy.domain.com:port set https_proxy=https://192.168.1.1:8080 如果有用户名和密码 set http_proxy_user=jake set http_proxy_pass=abcd 2....
深入理解http（三）----http进阶hhtps
weixin_30628801的博客
06-14 2804
一、https概述 https=http+SSL/TSL 在http中，没有加密机制，所有的内容都以明文的形式传输，在网络上“裸奔”，这是极其不安全的，为了解决这个问题，可以通过SSL（Secure Socket Layer安全套接层）或者TSL(Transport Layer Security安全车传输协议)的组合使用，达到加密http的通信内容，这个时候，http就变成了http...
网络基础知识
junjun123147的博客
02-17 1884
ISO（国际标准化组织）规定了OSI七层参考模型（开放式系统互联）的概念来描述网络通信的协议标准。 系统互连也指让不同的系统设备进行互相连接和彼此通信。例如我们的手机与电脑之间的连接也叫系统互联。 OSI把网络通信分成七个层级，每一层实现不同的功能，层层递进又相互连接。 不同的层级也会存在拉帮结派的现象。例如应用层，表示层，会话层这三层被统称为控制层面。传输层，网络层，数据链路层，物理层这四层被统称为数据层面。在我自己看来，控制层面主要负责控制网络通信的运行，数据层面主要负责数据的一个封装和发送。
TCP端口号范围及分类
热门推荐
CodingStart
09-20 6万+
端口号的范围是从1～65535 端口的概念：  在网络技术中，端口（Port）大致有两种意思：一是物理意义上的端口，比如，ADSL Modem、集线器、交换机、路由器用于连接其他网络设备的接口，如RJ-45端口、SC端口等等。二是逻辑意义上的端口，一般是指TCP/IP协议中的端口，端口号的范围从0到65535，比如用于浏览网页服务的80端口，用于FTP服务的21端口等等。 我们这里将
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值