Java网络编程你是GG还是MM

39次阅读

共计 8181 个字符，预计需要花费 21 分钟才能阅读完成。

第六阶段 网络编程

每一台计算机通过网络连接起来，达到了数据互动的效果，而网络编程所解决的问题就是如何让程序与程序之间实现数据的通讯与互动

在吗？你是 GG 还是 MM？

(一) 网络模型概述

(1) 两大模型

网络模型一般是指:

  • OSI（Open System Interconnection 开放系统互连）参考模型
  • TCP/IP 参考模型

(2) 网络模型七层概述

  1. 物理层 ：主要定义物理设备标准，如网线的接口类型、光纤的接口类型、各种传输介质的传输速率等。它的 主要作用是传输比特流 （就是由 1、0 转化为电流强弱来进行传输, 到达目的地后在转化为 1、0，也就是我们常说的数模转换与模数转换）。 这一层的数据叫做比特。
  2. 数据链路层 ：主要将从物理层接收的数据进行MAC 地址（网卡的地址）的封装与解封装。常把 这一层的数据叫做帧。在这一层工作的设备是交换机，数据通过交换机来传输。
  3. 网络层 ：主要 将从下层接收到的数据进行 IP 地址 （例 192.168.0.1) 的封装与解封装。在这一层工作的设备是路由器，常把 这一层的数据叫做数据包。
  4. 传输层 ：定义了一些传输数据的协议和端口号（WWW 端口 80 等），如：TCP（传输控制协议，传输效率低，可靠性强，用于传输可靠性要求高，数据量大的数据），UDP（用户数据报协议，与 TCP 特性恰恰相反，用于传输可靠性要求不高，数据量小的数据，如 QQ 微信聊天数据就是通过这种方式传输的）。主要是 将从下层接收的数据进行分段和传输 ， 到达目的地址后再进行重组 。常常把 这一层数据叫做段。
  5. 会话层 ：通过传输层（端口号：传输端口与接收端口）建立数据传输的通路。主要 在你的系统之间发起会话或者接受会话请求（设备之间需要互相认识可以是 IP 也可以是 MAC 或者是主机名）
  6. 表示层 ：主要是 进行对接收的数据进行解释、加密与解密、压缩与解压缩 等（也就是把计算机能够识别的东西转换成人能够能识别的东西（如图片、声音等）。
  7. 应用层：主要是一些终端的应用，比如说 FTP（各种文件下载），WEB（IE 浏览），QQ 之类的（可以把它理解成我们在电脑屏幕上可以看到的东西．就是终端应用）。

(二) 网络编程三要素

(1) IP 地址

A：IP 地址概述：IP 地址是网络中计算机的唯一标识 **

我们应该或多或少都有见过 IP 地址的格式 xxx.xxx.xxx.xxx 大致应该是类似这样的，但是计算机不是只能识别二进制的数据，但是很显然，我们的 IP 地址确实不是二进制的，这是什么原因呢？

我们先随便拿一个 IP 地址举个例子看看

IP：192.168.1.100

换算：11000000 10101000 00000001 01100100

但是如果我们日后需要用到这个 IP 地址的时候，记忆起来就比较麻烦 ，所以，为了方便表示 IP 地址，我们就 把 IP 地址的每一个字节上的数据换算成十进制，然后用 ‘ . ‘ 分开来表示：” 点分十进制 ”

B：IP 地址的组成：网络号段 + 主机号段

A 类：第一号段为网络号段 + 后三段的主机号段，一个网络号：256256256 = 16777216

B 类：前二号段为网络号段 + 后二段的主机号段，一个网络号：256*256 = 65536

C 类：前三号段为网络号段 + 后一段的主机号段，一个网络号：256

C：IP 地址的分类

A 类

1.0.0.1---127.255.255.254    
(1)10.X.X.X 是私有地址(私有地址就是在互联网上不使用，而被用在局域网络中的地址)               
(2)127.X.X.X 是保留地址，用做循环测试用的

B 类

128.0.0.1---191.255.255.254    
172.16.0.0---172.31.255.255 是私有地址
169.254.X.X 是保留地址

C 类

192.0.0.1---223.255.255.254    192.168.X.X 是私有地址

D 类

224.0.0.1---239.255.255.254

E 类

240.0.0.1---247.255.255.254

两个 DOS 命令

ipconfig 查看本机 ip 地址

ping 后面跟 ip 地址, 测试本机与指定的 ip 地址间的通信是否有问题

特殊 IP 地址

127.0.0.1 回环地址(表示本机)// 也就是说，ping 本机的 IP 地址相当于 ping 127.0.0.1

x.x.x.255 广播地址

x.x.x.0 网络地址

InetAddress 的成员方法

// 根据主机名或者 IP 地址的字符串表示得到 IP 地址对象
public static InetAddress getByName(String host):
import java.net.InetAddress;
import java.net.UnknownHostException;

public class InetAddressDemo {public static void main(String[] args) throws UnknownHostException {InetAddress address = InetAddress.getByName("192.168.24.1");

        // 获取两个东西：主机名，IP 地址
        String name = address.getHostName();
        String ip = address.getHostAddress();

        System.out.println(name + "---" + ip);
    }
}

// 运行结果
LAPTOP-5T03DV1G---192.168.24.1

(2) 端口

  • 物理端口 网卡口

  • 逻辑端口 我们指的就是逻辑端口

    • 每个网络程序都会至少有一个逻辑端口
    • 用于标识进程的逻辑地址，不同进程的标识
    • 有效端口：0~65535，其中 0~1024 系统使用或保留端口。

(3) 协议

TCP：传输控制协议，传输效率低，可靠性强，用于传输可靠性要求高，数据量大的数据

UDP：用户数据报协议，与 TCP 特性恰恰相反，用于传输可靠性要求不高，数据量小的数据，如 QQ 微信聊天数据就是通过这种方式传输的

简单总结：

TCP：建立数据通道, 无限制, 效率低, 可靠

UDP：数据打包, 有限制, 不连接, 效率高, 不可靠

(三) 控制台简单聊天案例

(1) UDP 版本 V1.0

import java.io.IOException;
import java.net.*;

/*  UDP 协议发送数据：*     A: 创建发送端 Socket 对象
 *     B: 创建数据，并把数据打包
 *     C: 调用 Socket 对象的发送方法发送数据包
 *     D: 释放资源
 */
public class SendDemo {public static void main(String[] args) throws IOException {
        // 创建 socket 对象
        DatagramSocket ds = new DatagramSocket();

        // 创建数据，并把数据打包
        //DatagramPacket(byte[] buf, int length, InetAddress address, int port)
        byte[] bys = "Hello,BWH!".getBytes();// 把字符串转换成字符数组
        int length = bys.length;
        InetAddress address = InetAddress.getByName("192.168.24.1");
        int port = 10086; // 自拟
        DatagramPacket dp = new DatagramPacket(bys, length, address, port);

        // 调用 Socket 对象的方法发送数据包
        //public void send(DatagramPacket p)
        ds.send(dp);

        // 释放资源
        ds.close(); // 底层依赖 IO 流，所以要释放资源}
}
import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.net.SocketException;

/*
 *  UDP 协议接收数据：*      A: 创建接收端 Socket 对象
 *      B: 创建一个数据包(接收容器)
 *      C: 调用 Socket 对象的接收方法接收数据
 *      D: 解析数据包，并显示在控制台
 *      E: 释放资源
 */
public class ReceiveDemo {public static void main(String[] args) throws IOException {
        // 创建接收端 Socket 对象
        // DatagramSocket(int port)
        DatagramSocket ds = new DatagramSocket(10086);

        // 创建一个数据包(接收容器)
        // DatagramPacket(byte[] buf, int length)
        byte[] bys = new byte[1024];
        int length = bys.length;
        DatagramPacket dp = new DatagramPacket(bys, length);

        // 调用 Socket 对象的接收方法接收数据
        // public void receive(DatagramPacket p)
        ds.receive(dp);

        // 解析数据包，并显示在控制台
        // 获取对方的 ip
        // public InetAddress getAddress()
        InetAddress address = dp.getAddress();
        String ip = address.getHostAddress();

        // public byte[] getData(): 获取数据缓冲区
        // public int getLength(): 获取数据的实际长度
        byte[] bys2 = dp.getData();
        int len = dp.getLength();
        String s = new String(bys2, 0, len);
        System.out.println(ip + ":" + s);

        // 释放资源
        ds.close();}
}

(2) UDP 版本 V2.0

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;


public class SendDemo {public static void main(String[] args) throws IOException {
        // 创建发送端的 Socket 对象
        DatagramSocket ds = new DatagramSocket();

        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        String line = null;
        while ((line = br.readLine()) != null) {if ("886".equals(line)) {break;}
            // 创建数据并打包
            byte[] bys = line.getBytes();
            DatagramPacket dp = new DatagramPacket(bys, bys.length, InetAddress.getByName("192.168.24.1"), 10086);
            // 发送数据
            ds.send(dp);
        }
        // 释放资源
        ds.close();}
}
import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;

public class ReceiveDemo {public static void main(String[] args) throws IOException {
        // 创建接受端的 Socket 对象
        DatagramSocket ds = new DatagramSocket(10086);
        while (true) {
            // 创建一个包裹
            byte[] bys = new byte[1024];
            DatagramPacket dp = new DatagramPacket(bys, bys.length);

            // 接收数据
            ds.receive(dp);

            // 解析数据
            String ip = dp.getAddress().getHostAddress();
            String s = new String(dp.getData(), 0, dp.getLength());
            System.out.println(ip + ":" + s);
        }
        // 释放资源, 但是接收端是服务器应该一直开启
        //ds.close();}
}

(3) UDP 版本 V3.0

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;

public class SendThread implements Runnable {
    private DatagramSocket ds;

    public SendThread(DatagramSocket ds) {this.ds = ds;}

    @Override
    public void run() {
        try {BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
            String line = null;
            while ((line = br.readLine()) != null) {if ("886".equals(line)) {break;}
                // 创建数据并打包
                byte[] bys = line.getBytes();
                DatagramPacket dp = new DatagramPacket(bys, bys.length, InetAddress.getByName("192.168.24.1"), 10086);
                // 发送数据
                ds.send(dp);
            }
            // 释放资源
            ds.close();} catch (IOException e) {e.printStackTrace();
        }
    }
}
import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;

public class ReceiveThread implements Runnable {
    private DatagramSocket ds;

    public ReceiveThread(DatagramSocket ds) {this.ds = ds;}

    @Override
    public void run() {
        try {while (true) {
                // 创建一个包裹
                byte[] bys = new byte[1024];
                DatagramPacket dp = new DatagramPacket(bys, bys.length);

                // 接收数据
                ds.receive(dp);

                // 解析数据
                String ip = dp.getAddress().getHostAddress();
                String s = new String(dp.getData(), 0, dp.getLength());
                System.out.println("from" + ip + "data is :" + s);
            }
        } catch (IOException e) {e.printStackTrace();
        }
    }
}
import java.net.DatagramSocket;
import java.net.SocketException;

public class ChatRoom {public static void main(String[] args) throws SocketException {DatagramSocket dsSend = new DatagramSocket();
        DatagramSocket dsReceive = new DatagramSocket(10086);

        SendThread st = new SendThread(dsSend);
        ReceiveThread rt = new ReceiveThread(dsReceive);

        Thread t1 = new Thread(st);
        Thread t2 = new Thread(rt);

        t1.start();
        t2.start();}
}

(4) TCP 版本

package cn.bwh_06_TCP2;

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

public class Clietn {public static void main(String[] args) throws IOException {Socket s = new Socket("192.168.24.1", 22222);

        // 键盘录入对象
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

        // 把通道内的流包装一下
        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));
        
        String line = null;
        while ((line = br.readLine()) != null) {if ("886".equals(line)) {break;}
            bw.write(line);
            bw.newLine();
            bw.flush();}

        s.close();}
}
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.ServerSocket;
import java.net.Socket;

public class Server {public static void main(String[] args) throws IOException {ServerSocket ss = new ServerSocket(22222);
        Socket s = ss.accept();

        BufferedReader br = new BufferedReader(new InputStreamReader(s.getInputStream()));
        String line = null;
        while ((line = br.readLine()) != null) {System.out.println(line);
        }

        s.close();}
}

(三) 其他功能

(1) 客户端键盘录入服务器写到文本文件

// 封装通道内的数据
BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));

// 封装文本文件
BufferedWriter bw = new BufferedWriter(new FileWriter("a.txt"));

(2) 客户端读取文本文件服务器控制台输出

// 封装文本文件
BufferedReader br = new BufferedReader(new FileReader("Demo.java"));

// 封装通道内的数据
BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));

String line = null;
        while ((line = br.readLine()) != null) {bw.write(line);
            bw.newLine();
            bw.flush();}

结尾：

如果内容中有什么不足，或者错误的地方，欢迎大家给我留言提出意见, 蟹蟹大家！^_^

如果能帮到你的话，那就来关注我吧！（系列文章均会在公众号第一时间更新）

在这里的我们素不相识，却都在为了自己的梦而努力 ❤

一个坚持推送原创 Java 技术的公众号：理想二旬不止

正文完
发表至： java
2019-07-20
 0
关于java:JAVA并发编程线程中断机制与interrupt
编解码技术
关于java:涨姿势了原来这才是多线程正确实现方式
关于java:JVM系列6GC与调优4