网络编程

最新推荐文章于 2024-11-16 17:49:09 发布

阅读量93

点赞数

文章标签： java

本文链接：https://blog.csdn.net/m0_62272971/article/details/127571934

版权

一.网络编程入门
二.UDP通信程序
三.TCP通信程序
四.NIO

一.网络编程入门

1.1网络编程概述

计算机网络

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

在网络通信协议下，不同计算机上运行的程序，可以进行数据传输

1.2 网络编程三要素【理解】

IP地址

要想让网络中的计算机能够互相通信，必须为每台计算机指定一个标识号，通过这个标识号来指定要接收数据的计算机和识别发送的计算机，而IP地址就是这个标识号。也就是设备的标识
端口

网络的通信，本质上是两个应用程序的通信。每台计算机都有很多的应用程序，那么在网络通信时，如何区分这些应用程序呢？如果说IP地址可以唯一标识网络中的设备，那么端口号就可以唯一标识设备中的应用程序了。也就是应用程序的标识
协议

通过计算机网络可以使多台计算机实现连接，位于同一个网络中的计算机在进行连接和通信时需要遵守一定的规则，这就好比在道路中行驶的汽车一定要遵守交通规则一样。在计算机网络中，这些连接和通信的规则被称为网络通信协议，它对数据的传输格式、传输速率、传输步骤等做了统一规定，通信双方必须同时遵守才能完成数据交换。常见的协议有UDP协议和TCP协议

1.3 IP地址【理解】

IP地址：是网络中设备的唯一标识
IP地址经常被写成十进制的形式，中间使用符号“.”分隔不同的字节。

IP地址分为两大类
- IPv4：是给每个连接在网络上的主机分配一个32bit地址。
- IPv6：IPv6重新定义地址空间，采用128位地址长度，每16个字节一组，分成8组十六进制数
DOS常用命令：
- ipconfig：查看本机IP地址
- ping IP地址：检查网络是否连通
特殊IP地址：
- 127.0.0.1：是回送地址，可以代表本机地址，一般用来测试使用

1.4 InetAddress【应用】

InetAddress：此类表示Internet协议（IP）地址
相关方法

方法名	说明
static InetAddress getByName(String host)	确定主机名称的IP地址。主机名称可以是机器名称，也可以是IP地址
String getHostName()	获取此IP地址的主机名
String getHostAddress()	返回文本显示中的IP地址字符串

package xuexi.java.guanka11WLBC;

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

public class Test1 {
    public static void main(String[] args) throws UnknownHostException {
        InetAddress byAddress = InetAddress.getByName("192.168.56.1");
        String name= byAddress.getHostName();
        String id=byAddress.getHostAddress();
        System.out.println(name);
        System.out.println(id);
    }
}

在这里插入图片描述

1.5 端口和协议【理解】

端口
- 设备上应用程序的唯一标识
端口号
- 用两个字节表示的整数，它的取值范围是0~65535。其中，0~1023之间的端口号用于一些知名的网络服务和应用，普通的应用程序需要使用1024以上的端口号。如果端口号被另外一个服务或应用所占用，会导致当前程序启动失败
协议
- 计算机网络中，连接和通信的规则被称为网络通信协议
UDP协议
- 用户数据报协议(User Datagram Protocol)
- UDP是无连接通信协议，即在数据传输时，数据的发送端和接收端不建立逻辑连接。
- UDP协议消耗系统资源小，通信效率高，通常用于音频、视频和普通数据的传输
- 使用UDP协议传送数据时，由于UDP的面向无连接性，不能保证数据的完整性，因此在传输重要数据时不建议使用UDP协议
TCP协议
- 传输控制协议 (Transmission Control Protocol)
- TCP协议是面向连接的通信协议，即传输数据之前，在发送端和接收端建立逻辑连接，然后再传输数据，它提供了两台计算机之间可靠无差错的数据传输。在TCP连接中必须要明确客户端与服务器端，由客户端向服务端发出连接请求，每次连接的创建都需要经过“三次握手”
- 三次握手：TCP协议中，在发送数据的准备阶段，客户端与服务器之间的三次交互，以保证连接的可靠
  
  第一次握手，客户端向服务器端发出连接请求，等待服务器确认
  
  第二次握手，服务器端向客户端回送一个响应，通知客户端收到了连接请求
  
  第三次握手，客户端再次向服务器端发送确认信息，确认连接
- 完成三次握手，连接建立后，客户端和服务器就可以开始进行数据传输了。由于这种面向连接的特性，TCP协议可以保证传输数据的安全，所以应用十分广泛。例如上传文件、下载文件、浏览网页等

二.UDP通信程序

2.1 UDP发送数据【应用】

Java中的UDP通信
- UDP协议是一种不可靠的网络协议，它在通信的两端各建立一个Socket对象，但是这两个Socket只是发送，接收数据的对象，因此对于基于UDP协议的通信双方而言，没有客户端和服务器的概念
- Java提供了DatagramSocket类作为基于UDP协议的Socket

构造方法

方法名	说明
DatagramSocket()	创建数据报套接字并将其绑定到本机地址上的任何可用端口
DatagramPacket(byte[] buf,int len,InetAddress add,int port)	创建数据包,发送长度为len的数据包到指定主机的指定端口

相关方法

方法名说明
void send(DatagramPacket p) 发送数据报包
void close() 关闭数据报套接字
void receive(DatagramPacket p) 从此套接字接受数据报包
发送数据的步骤
- 创建发送端的Socket对象(DatagramSocket)
- 创建数据，并把数据打包
- 调用DatagramSocket对象的方法发送数据
- 关闭发送端

方法名	说明
void send(DatagramPacket p)	发送数据报包
void close()	关闭数据报套接字
void receive(DatagramPacket p)	从此套接字接受数据报包

package xuexi.java.guanka11WLBC;

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

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

        //创建数据，并把数据打包,发送长度为len的数据包到指定主机的指定端口
        byte[] bys="hello世界".getBytes();
        DatagramPacket datagramPacket=new DatagramPacket(bys,bys.length, InetAddress.getByName("192.168.56.1"),10000);

        //调用DatagramSocket对象的方法发送数据
        datagramSocket.send(datagramPacket);

        //关闭发送端
        datagramSocket.close();

    }
}

2.2UDP接收数据【应用】

接收数据的步骤
- 创建接收端的Socket对象(DatagramSocket)
- 创建一个数据包，用于接收数据
- 调用DatagramSocket对象的方法接收数据
- 解析数据包，并把数据在控制台显示
- 关闭接收端
构造方法

方法名说明
DatagramPacket(byte[] buf, int len) 创建一个DatagramPacket用于接收长度为len的数据包
相关方法

方法名说明
byte[] getData() 返回数据缓冲区
int getLength() 返回要发送的数据的长度或接收的数据的长度

方法名	说明
DatagramPacket(byte[] buf, int len)	创建一个DatagramPacket用于接收长度为len的数据包

方法名	说明
byte[] getData()	返回数据缓冲区
int getLength()	返回要发送的数据的长度或接收的数据的长度

package xuexi.java.guanka11WLBC;

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

public class Test3 {
    public static void main(String[] args) throws IOException {
//        创建接收端的Socket对象(DatagramSocket)
        DatagramSocket datagramSocket=new DatagramSocket(10000);

//        创建一个数据包，用于接收数据
        byte[] bys=new byte[1024];
        DatagramPacket datagramPacket=new DatagramPacket(bys,bys.length);

//        调用DatagramSocket对象的方法接收数据
        datagramSocket.receive(datagramPacket);

//        解析数据包，并把数据在控制台显示
        System.out.println("数据是："+new String(datagramPacket.getData(),0,datagramPacket.getLength()));
//        关闭接收端
        datagramSocket.close();
    }
}

先启动接收端

再启动发送端
在这里插入图片描述
再看接收端

2.3UDP通信程序练习【应用】

案例需求

UDP发送数据：数据来自于键盘录入，直到输入的数据是886，发送数据结束

UDP接收数据：因为接收端不知道发送端什么时候停止发送，故采用死循环接收
代码实现

/*
    UDP发送数据：
        数据来自于键盘录入，直到输入的数据是886，发送数据结束
 */
public class SendDemo {
    public static void main(String[] args) throws IOException {
        //创建发送端的Socket对象(DatagramSocket)
        DatagramSocket ds = new DatagramSocket();
        //键盘录入数据
        Scanner sc = new Scanner(System.in);
        while (true) {
          	String s = sc.nextLine();
            //输入的数据是886，发送数据结束
            if ("886".equals(s)) {
                break;
            }
            //创建数据，并把数据打包
            byte[] bys = s.getBytes();
            DatagramPacket dp = new DatagramPacket(bys, bys.length, InetAddress.getByName("192.168.1.66"), 12345);

            //调用DatagramSocket对象的方法发送数据
            ds.send(dp);
        }
        //关闭发送端
        ds.close();
    }
}

/*
    UDP接收数据：
        因为接收端不知道发送端什么时候停止发送，故采用死循环接收
 */
public class ReceiveDemo {
    public static void main(String[] args) throws IOException {
        //创建接收端的Socket对象(DatagramSocket)
        DatagramSocket ds = new DatagramSocket(12345);
        while (true) {
            //创建一个数据包，用于接收数据
            byte[] bys = new byte[1024];
            DatagramPacket dp = new DatagramPacket(bys, bys.length);
            //调用DatagramSocket对象的方法接收数据
            ds.receive(dp);
            //解析数据包，并把数据在控制台显示
            System.out.println("数据是：" + new String(dp.getData(), 0, dp.getLength()));
        }
        //关闭接收端
//        ds.close();
    }
}

2.4UDP三种通讯方式【理解】

单播

单播用于两个主机之间的端对端通信
组播

组播用于对一组特定的主机进行通信
广播

广播用于一个主机对整个局域网上所有主机上的数据通信
广播用于一个主机对整个局域网上所有主机上的数据通信

注意：UDP实现单播的时候的代码与广播的代码基本是一样的，区别就在于单播的时候目的端的地址必须是单播地址，而广播的时候，目的端的地址必须是广播地址。

2.5UDP组播实现【理解】

实现步骤
- 发送端
  1. 创建发送端的Socket对象(DatagramSocket)
  2. 创建数据，并把数据打包(DatagramPacket)
  3. 调用DatagramSocket对象的方法发送数据(在单播中,这里是发给指定IP的电脑但是在组播当中,这里是发给组播地址)
  4. 释放资源
- 接收端
  1. 创建接收端Socket对象(MulticastSocket)
  2. 创建一个箱子,用于接收数据
  3. 把当前计算机绑定一个组播地址
  4. 将数据接收到箱子中
  5. 解析数据包,并打印数据
  6. 释放资源

// 发送端
public class ClinetDemo {
    public static void main(String[] args) throws IOException {
        // 1. 创建发送端的Socket对象(DatagramSocket)
        DatagramSocket ds = new DatagramSocket();
        String s = "hello 组播";
        byte[] bytes = s.getBytes();
        InetAddress address = InetAddress.getByName("224.0.1.0");
        int port = 10000;
        // 2. 创建数据，并把数据打包(DatagramPacket)
        DatagramPacket dp = new DatagramPacket(bytes,bytes.length,address,port);
        // 3. 调用DatagramSocket对象的方法发送数据(在单播中,这里是发给指定IP的电脑但是在组播当中,这里是发给组播地址)
        ds.send(dp);
        // 4. 释放资源
        ds.close();
    }
}
// 接收端
public class ServerDemo {
    public static void main(String[] args) throws IOException {
        // 1. 创建接收端Socket对象(MulticastSocket)
        MulticastSocket ms = new MulticastSocket(10000);
        // 2. 创建一个箱子,用于接收数据
        DatagramPacket dp = new DatagramPacket(new byte[1024],1024);
        // 3. 把当前计算机绑定一个组播地址,表示添加到这一组中.
        ms.joinGroup(InetAddress.getByName("224.0.1.0"));
        // 4. 将数据接收到箱子中
        ms.receive(dp);
        // 5. 解析数据包,并打印数据
        byte[] data = dp.getData();
        int length = dp.getLength();
        System.out.println(new String(data,0,length));
        // 6. 释放资源
        ms.close();
    }
}

2.6UDP广播实现【理解】

实现步骤
- 发送端
  1. 创建发送端Socket对象(DatagramSocket)
  2. 创建存储数据的箱子,将广播地址封装进去
  3. 发送数据
  4. 释放资源
- 接收端
  1. 创建接收端的Socket对象(DatagramSocket)
  2. 创建一个数据包，用于接收数据
  3. 调用DatagramSocket对象的方法接收数据
  4. 解析数据包，并把数据在控制台显示
  5. 关闭接收端

三.TCP通信程序

3.1TCP发送数据【应用】

Java中的TCP通信
- Java对基于TCP协议的的网络提供了良好的封装，使用Socket对象来代表两端的通信端口，并通过Socket产生IO流来进行网络通信。
- Java为客户端提供了Socket类，为服务器端提供了ServerSocket类

构造方法

方法名	说明
Socket(InetAddress address,int port)	创建流套接字并将其连接到指定IP指定端口号
Socket(String host, int port)	创建流套接字并将其连接到指定主机上的指定端口号

相关方法

方法名说明
InputStream getInputStream() 返回此套接字的输入流
OutputStream getOutputStream() 返回此套接字的输出流

方法名	说明
InputStream getInputStream()	返回此套接字的输入流
OutputStream getOutputStream()	返回此套接字的输出流

package xuexi.java.guanka11WLBC;

import java.io.IOException;
import java.io.OutputStream;
import java.net.Socket;

public class Test4 {
    public static void main(String[] args) throws IOException {
        //创建客户端的Socket对象(Socket)
        //Socket(String host, int port) 创建流套接字并将其连接到指定主机上的指定端口号
        Socket s = new Socket("127.0.0.1",10000);//127.0.0.1是回送地址，指本地机，一般用来测试使用。

        //获取输出流，写数据
        //OutputStream getOutputStream() 返回此套接字的输出流
        OutputStream os = s.getOutputStream();
        os.write("hello,tcp,我来了".getBytes());

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

3.2TCP接收数据【应用】

构造方法

方法名说明
ServletSocket(int port) 创建绑定到指定端口的服务器套接字
相关方法

方法名说明
Socket accept() 监听要连接到此的套接字并接受它
注意事项
1. accept方法是阻塞的,作用就是等待客户端连接
2. 客户端创建对象并连接服务器,此时是通过三次握手协议,保证跟服务器之间的连接
3. 针对客户端来讲,是往外写的,所以是输出流
  针对服务器来讲,是往里读的,所以是输入流
4. read方法也是阻塞的
5. 客户端在关流的时候,还多了一个往服务器写结束标记的动作
6. 最后一步断开连接,通过四次挥手协议保证连接终止
三次握手和四次挥手
- 三次握手
- 四次挥手

方法名	说明
ServletSocket(int port)	创建绑定到指定端口的服务器套接字

方法名	说明
Socket accept()	监听要连接到此的套接字并接受它

package xuexi.java.guanka11WLBC;

import java.io.IOException;
import java.io.InputStream;
import java.net.ServerSocket;
import java.net.Socket;

public class Test5 {
    public static void main(String[] args) throws IOException {
        //创建服务器端的Socket对象(ServerSocket)
        //ServerSocket(int port) 创建绑定到指定端口的服务器套接字
        ServerSocket ss = new ServerSocket(10000);

        //Socket accept() 侦听要连接到此套接字并接受它
        Socket s = ss.accept();

        //获取输入流，读数据，并把数据显示在控制台
        InputStream is = s.getInputStream();
        byte[] bys = new byte[1024];
        int len = is.read(bys);
        String data = new String(bys,0,len);
        System.out.println("数据是：" + data);

        //释放资源
        s.close();
        ss.close();
    }
}

3.4TCP程序文件上传练习【应用】

案例需求

客户端：数据来自于本地文件，接收服务器反馈

服务器：接收到的数据写入本地文件，给出反馈
案例分析
- 创建客户端对象，创建输入流对象指向文件，每读一次数据就给服务器输出一次数据，输出结束后使用shutdownOutput()方法告知服务端传输结束
- 创建服务器对象，创建输出流对象指向文件，每接受一次数据就使用输出流输出到文件中，传输结束后。使用输出流给客户端反馈信息
- 客户端接受服务端的回馈信息
相关方法

方法名说明
void shutdownInput() 将此套接字的输入流放置在“流的末尾”
void shutdownOutput() 禁止用此套接字的输出流

方法名	说明
void shutdownInput()	将此套接字的输入流放置在“流的末尾”
void shutdownOutput()	禁止用此套接字的输出流

// 客户端
public class ClientDemo {
    public static void main(String[] args) throws IOException {
        Socket socket = new Socket("127.0.0.1",10000);

        //是本地的流,用来读取本地文件的.
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream("socketmodule\\ClientDir\\1.jpg"));

        //写到服务器 --- 网络中的流
        OutputStream os = socket.getOutputStream();
        BufferedOutputStream bos = new BufferedOutputStream(os);

        int b;
        while((b = bis.read())!=-1){
            bos.write(b);//通过网络写到服务器中
        }
        bos.flush();
        //给服务器一个结束标记,告诉服务器文件已经传输完毕
        socket.shutdownOutput();

        BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
        String line;
        while((line = br.readLine()) !=null){
            System.out.println(line);
        }
        bis.close();
        socket.close();
    }
}
// 服务器
public class ServerDemo {
    public static void main(String[] args) throws IOException {
        ServerSocket ss = new ServerSocket(10000);

        Socket accept = ss.accept();

        //网络中的流,从客户端读取数据的
        BufferedInputStream bis = new BufferedInputStream(accept.getInputStream());
        //本地的IO流,把数据写到本地中,实现永久化存储
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("socketmodule\\ServerDir\\copy.jpg"));

        int b;
        while((b = bis.read()) !=-1){
            bos.write(b);
        }

        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(accept.getOutputStream()));
        bw.write("上传成功");
        bw.newLine();
        bw.flush();

        bos.close();
        accept.close();
        ss.close();
    }
}

四.NIO

4.1概述【理解】

BIO

Blocking IO,阻塞型IO
NIO

No Blocking IO,非阻塞型IO
阻塞IO的弊端

在等待的过程中,什么事也做不了
非阻塞IO的好处

不需要一直等待,当一切就绪了再去做

4.2NIO与BIO的区别【理解】

区别一

BIO是阻塞的，NIO是非阻塞的
区别二

BIO是面向流的，NIO是面向缓冲区的

BIO中数据传输是单向的，NIO中的缓冲区是双向的

4.3NIO三大模块【理解】

缓冲区

用来存储数据
通道

用来建立连接和传输数据
选择器

监视通道状态

4.4NIO创建缓冲区对象【应用】

方法介绍

方法名说明
static ByteBuffer allocate(长度) 创建byte类型的缓冲区
static ByteBuffer wrap(byte[] array) 创建一个有内容的byte类型缓冲区

方法名	说明
static ByteBuffer allocate(长度)	创建byte类型的缓冲区
static ByteBuffer wrap(byte[] array)	创建一个有内容的byte类型缓冲区

4.5NIO缓冲区添加数据【应用】

方法介绍

在这里插入图片描述

4.6NIO缓冲区获取数据【应用】

方法介绍

方法名	介绍
flip()	切换读写模式（写à读）
get()	读一个字节
get(byte[] dst)	读多个字节
get(int index)	读指定索引的字节
rewind()	将position设置为0，可以重复读
clear()	数据读写完毕（读->写）
array()	将缓冲区转换成字节数组返回

4.7 NIO通道客户端【应用】

客户端实现步骤
1. 打开通道
2. 指定IP和端口号
3. 写出数据
4. 释放资源

public class NIOClient {
    public static void main(String[] args) throws IOException {
        //1.打开通道
        SocketChannel socketChannel = SocketChannel.open();

        //2.指定IP和端口号
        socketChannel.connect(new InetSocketAddress("127.0.0.1",10000));

        //3.写出数据
        ByteBuffer byteBuffer = ByteBuffer.wrap("一点寒毛先制".getBytes());
        socketChannel.write(byteBuffer);

        //4.释放资源
        socketChannel.close();
    }
}

4.8 NIO通道服务端【应用】

NIO通道
- 服务端通道
  
  只负责建立建立，不负责传递数据
- 客户端通道
  
  建立建立并将数据传递给服务端
- 缓冲区
  
  客户端发送的数据都在缓冲区中
- 服务端通道内部创建出来的客户端通道
  
  相当于客户端通道的延伸用来传递数据
服务端实现步骤
1. 打开一个服务端通道
2. 绑定对应的端口号
3. 通道默认是阻塞的，需要设置为非阻塞
4. 此时没有门卫大爷，所以需要经常看一下有没有连接发过来没？
5. 如果有客户端来连接了,则在服务端通道内部,再创建一个客户端通道,相当于是客户端通道的延伸
6. 获取客户端传递过来的数据,并把数据放在byteBuffer1这个缓冲区中
7. 给客户端回写数据
8. 释放资源

4.9NIO选择器【理解】

概述
选择器可以监视通道的状态,多路复用
选择器对象
- Selector
  
  选择器对象
- SelectionKey
  
  绑定的key
- SelectableChannel
  
  能使用选择器的通道
  - SocketChannel
  - ServerSocketChannel

4.10NIO选择器改写服务端【应用】

实现步骤
1. 打开一个服务端通道(open)
2. 绑定对应的端口号
3. 通道默认是阻塞的，需要设置为非阻塞
4. 打开一个选择器（门卫大爷）
5. 将选择器绑定服务端通道，并监视服务端是否准备好
6. 如果有客户端来连接了，大爷会遍历所有的服务端通道，谁准备好了，就让谁来连接
  连接后，在服务端通道内部，再创建一个客户端延伸通道
7. 如果客户端把数据传递过来了，大爷会遍历所有的延伸通道，谁准备好了，谁去接收数据