黑马程序员-Java基础：网络编程

最新推荐文章于 2022-04-08 10:37:22 发布

BlackHorseKevin

最新推荐文章于 2022-04-08 10:37:22 发布

阅读量654

点赞数

文章标签：网络编程 java

本文链接：https://blog.csdn.net/BlackHorseKevin/article/details/47724505

版权

——Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ ——

网络编程

一、概述
这里的网络编程实质上是指用Java语言实现计算机间数据的信息传递和资源共享。

二、网络参考模型
网络参考模型有两种：
1.OSI(Open System Interconnection 开放系统互连)参考模型
2.TCP/IP 参考模型
这里写图片描述
各层描述：

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

应用软件之间的通信：
这里写图片描述

三、网络编程的三要素
1.IP地址：InetAddress
网络中设备的标识。
组成：32位二进制数，由于不容易记忆，通过点分十进制表示IP地址
例如：192.168.0.1
常用DOS命令：
ipconfig 查看本机ip地址
ping 后面跟ip地址。测试本机与指定的ip地址间的通信是否有问题
分类：
A类 1.0.0.1—127.255.255.254
10.X.X.X是私有地址(私有地址就是在互联网上不使用，而被用在局域网络中的地址)
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

特殊的IP地址:
127.0.0.1 回环地址(表示本机)
x.x.x.255 广播地址
x.x.x.0 网络地址

2.端口号
用于标识进程（应用程序）的逻辑地址，不同进程的标识。
有效端口：0~65535，其中0~1024系统使用或保留端口。
P.S.当一台计算机A向另一台计算机B发送QQ信息时，首先路由器通过数据包中的IP地址定位该信息发送到哪一台机器。然后计算机B接收到数据包后，通过此数据包中的端口号定位到发送给本机的QQ应用程序。

3.传输协议
网络设备之间通信的规则，常见协议：UDP、TCP。
UDP：
<1>将数据及源和目的封装成数据包中，不需要建立连接。
<2>每个数据报的大小在限制在64k内。
<3>因无连接，是不可靠协议。
<4>不需要建立连接，速度快。
应用案例：QQ、FeiQ聊天、在线视频用的都是UDP传输协议。

TCP：
<1>建立连接，形成传输数据的通道。
<2>在连接中进行大数据量传输。
<3>通过三次握手完成连接，是可靠协议。
<4>必须建立连接，效率会稍低。
应用案例：FTP，File Transfer Protocol（文件传输协议）。

InetAddress类的使用示例：

/*
 * InetAddress是Java中用于表示IP地址的类，通过调用:
 * InetAddress getByName(String hostName)方法来
 * 获取IP地址对象
 * 参数hostName为主机名或主机的IP地址
 */

public class InetAddressDemo {
    public static void main(String[] args) throws UnknownHostException {
        // 获取本机IP地址对象
        InetAddress ip = InetAddress.getByName("kaven-PC");

        // 测试常用方法
        // 获取主机地址
        String hostAddress = ip.getHostAddress();
        // 获取主机名
        String hostName = ip.getHostName();
        InetAddress localhost = ip.getLocalHost();

        System.out.println(hostName + ":" + hostAddress);
        System.out.println(localhost);
    }
}

运行结果：
这里写图片描述

四、UDP协议：发送端&接收端
1.Socket机制：
Socket就是为网络服务提供的一种机制。
<1>通信的两端都有Socket。
<2>网络通信实际上就是Socket间的通信。
<3>数据在两个Socket间通过IO传输。
DatagramSocket类：用来发送和接收数据包的套接字类
DatagramPacket类：用于将需要传输的数据打包成数据报包的类

3.UDP传输数据过程：
<1>建立发送端与接收端Socket，在接收端Socket指定接收数据的端口号
<2>建立数据包，在发送端数据包中指定接收端IP和端口
<3>调用Socket的发送和接收方法
<4>关闭Socket
P.S.：发送端与接收端是两个独立运行的程序
UDP发送端代码：

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

        // 创建数据，并把数据打包
        // DatagramPacket(byte[] buf, int length, InetAddress address, int port)
        // 创建数据
        byte[] bys = "hello,udp,我来了".getBytes();
        // 长度
        int length = bys.length;
        // IP地址对象
        InetAddress address = InetAddress.getByName("192.168.12.92");
        // 端口
        int port = 10086;
        DatagramPacket dp = new DatagramPacket(bys, length, address, port);

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

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

UDP接收端代码：

/*
 * 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();
    }
}

运行结果：
这里写图片描述

P.S : 由于UDP协议传输数据，只管发送数据，而不管接收端是否能够接收到数据。因此，应该首先启动接收端程序，再启动发送端程序。

一个控制台聊天程序：
发送端：

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

/*
 * 发送端程序：用于发送信息
 */
public class SendMessage implements Runnable {
    /*
     * 发送端成员变量： socket对象 目的地ip地址 通信端口号
     */
    private DatagramSocket socket;
    private InetAddress ip;
    private int port;

    public SendMessage(DatagramSocket socket, InetAddress ip, int port) {
        super();
        this.socket = socket;
        this.ip = ip;
        this.port = port;
    }

    @Override
    public void run() {
        // 缓冲输入流用于读取用户输入
        Reader in = new InputStreamReader(System.in);
        BufferedReader reader = new BufferedReader(in);
        while (true) {
            try {
                // 读取用户输入，并打包数据
                String line = reader.readLine();
                int length = line.getBytes().length;
                DatagramPacket dp = new DatagramPacket(line.getBytes(), length, ip, port);
                // 发送数据报包
                socket.send(dp);
                // 如果输入886，结束循环
                if("886".equals(line)){
                    break;
                }

            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        // 关闭资源
        try {
            reader.close();
            socket.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

接收端：

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

/*
 * 接收端程序：用于接收信息
 */
public class ReceiveMessage implements Runnable {
    /*
     * 接收端成员变量： 接收端socket对象
     */
    private DatagramSocket socket;

    public ReceiveMessage(DatagramSocket socket) {
        super();
        this.socket = socket;
    }

    @Override
    public void run() {
        while (true) {
            // 接收数据并打印到控制台
            DatagramPacket dp = new DatagramPacket(new byte[1024], 0, 1024);
            try {
                socket.receive(dp);
            } catch (IOException e) {
                e.printStackTrace();
            }
            String data = new String(dp.getData(), 0, dp.getLength());
            System.out.println(dp.getAddress().getHostName() + "-" + dp.getPort() + " : " + data);

        }
    }

}

客户端：

import java.io.IOException;
import java.net.DatagramSocket;
import java.net.InetAddress;

public class Client1 {
    public static void main(String[] args) throws IOException {
        SendMessage sm = new SendMessage(new DatagramSocket(), InetAddress.getByName("kaven-PC"), 10010);
        ReceiveMessage rm = new ReceiveMessage(new DatagramSocket(10011));

        Thread t1 = new Thread(sm);
        Thread t2 = new Thread(rm);

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

import java.io.IOException;
import java.net.DatagramSocket;
import java.net.InetAddress;

public class Client2 {
    public static void main(String[] args) throws IOException {
        SendMessage sm = new SendMessage(new DatagramSocket(), InetAddress.getByName("kaven-PC"), 10011);
        ReceiveMessage rm = new ReceiveMessage(new DatagramSocket(10010));

        Thread t1 = new Thread(sm);
        Thread t2 = new Thread(rm);

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

运行结果：
这里写图片描述

五、TCP协议：客户端&服务器端
客户端服务器端信息传递图解：
这里写图片描述
客户端（Client）首先与服务端（Server）建立连接，形成通道（其实就是IO流），然后，数据就可以在通道之间进行传输，并且单个Server端可以同时与多个Client端建立连接。

1.TCP传输步骤
<1>Socket和ServerSocket，建立客户端和服务器端
<2>建立连接后，通过Socket中的IO流进行数据的传输
<3>关闭socket
同样，客户端与服务器端是两个独立的应用程序。

2.TCP服务器端
<1>:建立服务器端的socket服务，需要一个端口
<2>:服务端没有直接流的操作,而是通过accept方法获取客户端对象，在通过获取到的客户端对象的流和客户端进行通信
<3>:通过客户端的获取流对象的方法,读取数据或者写入数据
<4>:如果服务完成,需要关闭客户端,然后关闭服务器，但是,一般会关闭客户端,不会关闭服务器,因为服务端是一直提供服务的

3.TCP客户端
<1>:建立客户端的Socket服务,并明确要连接的服务器。
<2>:如果连接建立成功,就表明,已经建立了数据传输的通道.就可以在该通道通过IO进行数据的读取和写入.该通道称为Socket流,Socket流中既有读取流,也有写入流.
<3>:通过Socket对象的方法,可以获取这两个流
<4>:通过流的对象可以对数据进行传输
<5>:如果传输数据完毕,关闭资源

P.S.：在TCP传输数据中，一定要先启动服务器端程序，再启动客户端程序，因为客户端Socket对象一旦创建就会与服务器端进行连接。

TCP上传文件案例：
服务器端

/*
 * 1:建立服务器端的socket服务，需要一个端口
 * 2:服务端没有直接流的操作,而是通过accept方法获取客户端对象，在通过获取到的客户端对象的流和客户端进行通信
 * 3:通过客户端的获取流对象的方法,读取数据或者写入数据
 * 4:如果服务完成,需要关闭客户端,然后关闭服务器，但是,一般会关闭客户端,不会关闭服务器,因为服务端是一直提供服务的
 */
public class Server {
    public static void main(String[] args) throws IOException {
        // 1:建立服务器端的socket服务，需要一个端口
        ServerSocket ss = new ServerSocket(10086);
        // 2:通过accept方法获取客户端对象
        Socket socket = ss.accept();
        // 3:通过客户端的获取流对象的方法,读取数据或者写入数据
        InputStream inputStream = socket.getInputStream();
        OutputStream outputStream = new FileOutputStream("output.txt");
        BufferedInputStream bis = new BufferedInputStream(inputStream);
        BufferedOutputStream bos = new BufferedOutputStream(outputStream);

        byte[] bytes = new byte[1024];
        int len = 0;
        while((len = bis.read(bytes)) != -1) {
            bos.write(bytes, 0, len);
        }

        socket.close();
        bos.close();
    }
}

客户端

public class Client {
    public static void main(String[] args) throws IOException {
        // 1.建立客户端的Socket服务,并明确要连接的服务器。
        Socket s = new Socket("kaven-PC", 10086);
        // 2.从文件读取数据，通过socket流传输到服务器
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream("input.txt"));
        BufferedOutputStream bos = new BufferedOutputStream(s.getOutputStream());
        // 3.传输数据
        byte[] bytes = new byte[1024];
        int len;
        while((len = bis.read(bytes)) != -1) {
            bos.write(bytes, 0, len);
//          bos.flush();
        }

        bos.close();
        bis.close();
    }
}

运行结果：
运行之前：
这里写图片描述
运行之后：

文件对比：

P.S:
TCP上传下载文件的本质其实就是IO流中文件的复制，只不过这次是通过Socket对象将本地数据传输到服务器端，同样也可以从服务器端获取数据下载到客户端。

BlackHorseKevin

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
1
评论
黑马程序员-Java基础：网络编程

——Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ ——网络编程一、概述这里的网络编程实质上是指用Java语言实现计算机间数据的信息传递和资源共享。二、网络参考模型网络参考模型有两种： 1.OSI(Open System Interconnection 开放系统互连)参考模型 2.TCP/IP 参考模型各层描述：1. 物理层：主要定义物理设备标准，如网
复制链接

扫一扫