网络编程与协议

最新推荐文章于 2024-03-27 12:55:24 发布

张*

最新推荐文章于 2024-03-27 12:55:24 发布

阅读量266

点赞数 1

分类专栏： java 文章标签：网络编程

本文链接：https://blog.csdn.net/qq_40393135/article/details/91042043

版权

java 专栏收录该内容

28 篇文章 0 订阅

订阅专栏

网络编程是指编写运行在多个设备的程序，这些设备通过网络连接在一起。

java.net包中的API包含有类和接口，于低层次的通信细节，可以直接使用这些类和接口来解决问题，并不关注通信细节；

1、TCP协议与UDP协议

java.net包中常见的两种通信协议：

TCP（Transmission Control Protocol ）

传输控制协议，是专门设计用于在不可靠的、端到端的字节流通信协议。它是一种面向连接的协议，TCP协议是字节流而不是报文流；

UDP（User Data Protocol）

用户数据报协议，一个无连接的协议。提供了应用程序之间要发送的数据的数据包；

特点：

非面向连接，传输不可靠，可能丢失
发送不管对方是否准备好，接收方收到也不确认
可以广播发送
非常简单的协议，开销小

通信方式

协议

可靠性

数据量

是否需要连接

应用

流式通信

TCP

可靠，有序，无差错

无重复，不会丢失数据

大量数据

需要连接

http，Telnet，ftp服务

数据报通信

UDP

不可靠

会丢失数据

少量数据

无连接，

每个数据报包含源地址和目标地址

时间服务，

ping服务

2.Socket编程

套接字使用TCP提供了两台计算机之间的通信机制，客户端创建一个套接字，并尝试连接服务器的套接字。

当连接创建时，服务器会创建一个Socket对象，并且 java.net.ServerSocket 类为服务器程序提供了一种来监听客户端，并与他们建立连接的机制。

同步和异步：同步和异步是针对应用程序和内核的交互而言的，同步指的是用户进程触发IO 操作并等待或者轮询的去查看IO 操作是否就绪，而异步是指用户进程触发IO 操作以后便开始做自己的事情，而当IO 操作已经完成的时候会得到IO 完成的通知。

以银行取款为例：

同步：自己亲自出马持银行卡到银行取钱（使用同步 IO 时，Java 自己处理IO 读写）；

异步：委托朋友拿银行卡到银行取钱，然后给你（使用异步IO 时，Java 将 IO 读写委托给OS 处理，需要将数据缓冲区地址和大小传给OS(银行卡和密码)，OS 需要支持异步IO操作API）；

阻塞和非阻塞：阻塞和非阻塞是针对于进程在访问数据的时候，根据IO操作的就绪状态来采取的不同方式，说白了是一种读取或者写入操作方法的实现方式，阻塞方式下读取或者写入函数将一直等待，而非阻塞方式下，读取或者写入方法会立即返回一个状态值。

以银行取款为例：

阻塞： ATM排队取款，你只能等待（使用阻塞IO时，Java调用会一直阻塞到读写完成才返回）；

非阻塞 ：柜台取款，取个号，然后坐在椅子上做其它事，等号广播会通知你办理，没到号你就不能去，你可以不断问大堂经理排到了没有，大堂经理如果说还没到你就不能去（使用非阻塞IO时，如果不能读写Java调用会马上返回，当IO事件分发器通知可读写时再继续进行读写，不断循环直到读写完成）

1.BIO 编程

Blocking IO：同步阻塞的编程方式。

BIO编程方式通常是在JDK1.4版本之前常用的编程方式。编程实现过程为：首先在服务端启动一个ServerSocket来监听网络请求，客户端启动Socket发起网络请求，默认情况下ServerSocket回建立一个线程来处理此请求，如果服务端没有线程可用，客户端则会阻塞等待或遭到拒绝。

且建立好的连接，在通讯过程中，是同步的。在并发处理效率上比较低。大致结构如下：

同步并阻塞，服务器实现模式为一个连接一个线程，即客户端有连接请求时服务器端就需要启动一个线程进行处理，如果这个连接不做任何事情会造成不必要的线程开销，当然可以通过线程池机制改善。

BIO方式适用于连接数目比较小且固定的架构，这种方式对服务器资源要求比较高，并发局限于应用中，JDK1.4以前的唯一选择，但程序直观简单易理解。

使用线程池机制改善后的BIO模型图如下:

2.NIO 编程：Unblocking IO（New IO）：同步非阻塞的编程方式。

NIO本身是基于事件驱动思想来完成的，其主要想解决的是BIO的大并发问题，NIO基于Reactor，当socket有流可读或可写入socket时，操作系统会相应的通知引用程序进行处理，应用再将流读取到缓冲区或写入操作系统。也就是说，这个时候，已经不是一个连接就要对应一个处理线程了，而是有效的请求，对应一个线程，当连接没有数据时，是没有工作线程来处理的。

NIO的最重要的地方是当一个连接创建后，不需要对应一个线程，这个连接会被注册到多路复用器上面，所以所有的连接只需要一个线程就可以搞定，当这个线程中的多路复用器进行轮询的时候，发现连接上有请求的话，才开启一个线程进行处理，也就是一个请求一个线程模式。

在NIO的处理方式中，当一个请求来的话，开启线程进行处理，可能会等待后端应用的资源(JDBC连接等)，其实这个线程就被阻塞了，当并发上来的话，还是会有BIO一样的问题

3.AIO编程：Asynchronous IO：异步非阻塞的编程方式。

与NIO不同，当进行读写操作时，只须直接调用API的read或write方法即可。这两种方法均为异步的，对于读操作而言，当有流可读取时，操作系统会将可读的流传入read方法的缓冲区，并通知应用程序；对于写操作而言，当操作系统将write方法传递的流写入完毕时，操作系统主动通知应用程序。即可以理解为，read/write方法都是异步的，完成后会主动调用回调函数。在JDK1.7中，这部分内容被称作NIO.2，主要在java.nio.channels包下增加了下面四个异步通道：AsynchronousSocketChannel、AsynchronousServerSocketChannel、AsynchronousFileChannel、AsynchronousDatagramChannel

TCP套接字实现步骤：

1.服务器步骤：

创建套接字
绑定套接字
设置套接字为监听模式，进入被动接收连接请求状态
接收请求，建立连接
读写数据
终止连接

2.客户端步骤：

创建套接字
与远程服务器建立连接
读写数据
终止连接

1.一对一的Socket通信

基于连接的客户端与服务端的流程图：

代码编译如下：

//服务端
package com.zhang.demo4;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;

public class Server {
    public static void main(String[] args) {
        try {
            ServerSocket server=null;
            //创建一个ServerSocket在端口4444监听客户请求
            try {
                server = new ServerSocket(4444);
            } catch (IOException e) {
                //输出错误信息
                System.out.println("error:"+e);
                System.exit(-1);
            }
            Socket client=null;
            //使用accept()阻塞等待客户请求，有客户请求
            try {
                client = server.accept();
                //到来则产生一个socket对象
            } catch (IOException e) {
                System.out.println("接收请求失败");
                System.exit(-1);
            }

            //由socket对象得到输入流，并构造相应的BufferedReader对象
            BufferedReader reader = new BufferedReader(new InputStreamReader(client.getInputStream()));
            //由socket对象得到输出流，并构造相应的PrintWriter对象
            PrintWriter writer = new PrintWriter(client.getOutputStream());
            
            //由系统标准输入设备构造BufferedReader对象
            BufferedReader reader1 = new BufferedReader(new InputStreamReader(System.in));
            //输出客户端读入的字符串
            System.out.println("Client发送的消息为："+reader.readLine());
            //从标准输入读入一个字符串
            String inputString = reader1.readLine();
            //如果该字符串为quit则终止循环
            while (inputString!=null&&!inputString.trim().equals("quit")){
                //向客户端输出该字符串
               writer.println(inputString);
               //刷新输出流
                writer.flush();
                //显示读入的字符串
                System.out.println("Server发出的消息为："+inputString);
                System.out.println("Client发出的消息为："+reader.readLine());
                //从系统标准输入读入一个字符串
                String readLine = reader1.readLine();
            }
            reader.close();
            writer.close();
            reader1.close();
            server.close();
            client.close();
            System.out.println("聊天结束！");
        } catch (IOException e) {
            e.printStackTrace();
        }

    }
}




//客户端
package com.zhang.demo4;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.Socket;

public class Client {
    public static void main(String[] args) {
        try {
            //向4444端口发出请求
            Socket server = new Socket("127.0.0.1", 4444);
            System.out.println("请输入信息：");
            //由系统标准输入设备构造相应的BufferedReader对象
            BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
            //由socket对象得到输出流，并构造相应的PrintWriter对象
            PrintWriter writer = new PrintWriter(server.getOutputStream());

            //由socket对象得到输入流，并构造相应的BufferedReader对象
            BufferedReader reader1 = new BufferedReader(new InputStreamReader(server.getInputStream()));

            //从标准输入读入一个字符串
            String inputString = reader.readLine();
            //如果该字符串为quit则终止循环
            while (inputString!=null&&!inputString.trim().equals("quit")){
                //向客户端输出该字符串
                writer.println(inputString);
                //刷新输出流
                writer.flush();
                //显示读入的字符串
                System.out.println("Client发出的消息为："+inputString);
                System.out.println("Server发出的消息为："+reader1.readLine());
                //从系统标准输入读入一个字符串
                String readLine = reader.readLine();
            }
            reader.close();
            writer.close();
            server.close();
            reader1.close();
            System.out.println("聊天结束！");
        } catch (IOException e) {
            e.printStackTrace();
        }

    }

}

以上代码编译运行结果为：

客户端结果：

请输入信息：
你好，我是客户端
Client发出的消息为：你好，我是客户端
Server发出的消息为：客户端，你好

服务端结果：

Client发送的消息为：你好，我是客户端
客户端，你好
Server发出的消息为：客户端，你好

2.一对多的Socket通信

在实际的应用中，都是有多个可客户端同时向服务器发出请求，因此在服务器上往往会运行一个常驻程序，用它来接收来自多个客户端的请求，并提供相应的服务。这个功能是使用多线程对服务器进行改造就可以实现。

服务器总是在指定的窗口上监听是否有客户请求，一旦监听到有客户请求，服务器就会启动一个专门的服务线程来响应该客户端的请求，而服务器本身则会在启动完线程之后就会进入监听状态等待下一个客户的请求到来；

并发服务器的原理：客户端向服务器发出请求，服务器在接受请求之后，立即调用一个线程来实现服务器与客户端之间的交互，主线程则返回去继续监听端口，等待下一个客户的连接请求，前一个线程在完成相应的交互之后会自动退出，连接也会自动关闭；

在java中，具体实现并发服务器的基本方法是：在服务器的程序中首先创建单个ServerSocket，并调用accept（）来等候一个新连接，等到accept（）返回，就取得获得结果的Socket，并用他来建立一个线程，只为那个特定的客户提供服务；然后在调用accept（），等候下一个新的连接请求；

package com.zhang.demo4;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;

public class MoreServer {
    //客户端计数
    static int num=1;

    public static void main(String[] args) {
        ServerSocket server=null;
        Socket client=null;
        while (true){
            //创建一个ServerSocket在端口4444监听客户请求
            try {
                server = new ServerSocket(4444);
            } catch (IOException e) {
                //输出错误信息
                System.out.println("error:"+e);
                System.exit(-1);
            }
            //使用accept()阻塞等待客户请求，有客户请求
            try {
               client = server.accept();
                //到来则产生一个socket对象
            } catch (IOException e) {
                System.out.println("接收请求失败");
                System.exit(-1);
            }
            System.out.println("Client["+MoreServer.num+"]登录");
            ServerThread thread1 = new ServerThread(client);
            Thread thread = new Thread(thread1);
            thread.start();
            //监听到客户请求，据客户计数创建服务线程并启动
            try {
                server.close();
            } catch (IOException e1) {
                System.out.println("关闭失败");
            }
            num++;
        }
    }
}
class ServerThread implements Runnable{
    private Socket client ;
    public ServerThread(Socket client) {
        //初始化client变量
        this.client=client;
    }

    @Override
    public void run() {
        //线程主题
        try {
            //实现数据传输
            //由socket对象得到输入流，并构造相应的BufferedReader对象
            BufferedReader reader = new BufferedReader(new InputStreamReader(client.getInputStream()));
            //由socket对象得到输出流，并构造相应的PrintWriter对象
            PrintWriter writer = new PrintWriter(client.getOutputStream());

            //由系统标准输入设备构造BufferedReader对象
            BufferedReader reader1 = new BufferedReader(new InputStreamReader(System.in));
            //输出客户端读入的字符串
            System.out.println("Client："+reader.readLine());
            //从标准输入读入一个字符串
            String inputString = reader1.readLine();
            //如果该字符串为quit则终止循环
            while (inputString!=null&&!inputString.trim().equals("quit")){
                //向客户端输出该字符串
                writer.println(inputString);
                //刷新输出流
                writer.flush();
                //显示读入的字符串
                System.out.println("Server发出的消息为："+inputString);
                System.out.println("Client发出的消息为："+reader.readLine());
                //从系统标准输入读入一个字符串
                String readLine = reader1.readLine();
            }
            reader.close();
            writer.close();
            reader1.close();
            client.close();
            System.out.println("聊天结束！");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

以上为服务端的代码，客户端代码和上面一对一的Socket通信中的客户端代码是一样的，该程序可以实现一个服务器与多个客户端之间的通信。

以上代码编译运行的结果如下：

1号客户端结果：

请输入信息：
你好，我是一号客户端
Client发出的消息为：你好，我是一号客户端
Server发出的消息为：1号客户端，你好

2号客户端结果：

请输入信息：
你好，我是二号客户端
Client发出的消息为：你好，我是二号客户端
Server发出的消息为：二号客户端，你好

服务器结果：

Client[1]登录
Client：你好，我是一号客户端
1号客户端，你好
Server发出的消息为：1号客户端，你好
Client[2]登录
Client：你好，我是二号客户端
二号客户端，你好
Server发出的消息为：二号客户端，你好

张*

关注

1
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
网络编程与协议

网络编程是指编写运行在多个设备的程序，这些设备通过网络连接在一起。java.net包中的API包含有类和接口，于低层次的通信细节，可以直接使用这些类和接口来解决问题，并不关注通信细节；1、TCP协议与UDP协议java.net包中常见的两种通信协议：TCP（Transmission Control Protocol ）传输控制协议，是专门设计用于在不可靠的、端到端的字节流通信...
复制链接

扫一扫