与IO、NIO、Netty相关的Java网络程序

最新推荐文章于 2024-09-13 21:40:38 发布
最新推荐文章于 2024-09-13 21:40:38 发布
阅读量867 收藏
点赞数
文章标签： java 网络 服务器
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wth1231232/article/details/122003516
版权

与IO、NIO、Netty相关的Java网络程序

一、IO实现TCP聊天程序

1、IO简介
①服务端阻塞点

server.accept();获取套接字的时候
inputStream.read(bytes);输入流读取数据的时候
传

②统socket是短连接，可以做短连接服务器，他无法做长连接，属于一问一答的模式，比如老的tomcat底层用的就是socket,用完就会关掉线程，因此不会出现线程一直被占用的情况，支持处理多个客户端连接。

单线程情况下只能有一个客户端（一个线程维护一个连接，也就是一个socket客户连接）线程一直被占用。
用线程池可以有多个客户端连接，但是非常消耗性能(用此案城池，就是老tomcat原理，只不过是用完后就释放)
2、 IO实现网络程序
①新建两个java项目（一个Server端，一个client端）

在这里插入图片描述
在这里插入图片描述
server端代码

package com.company;

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

public class Main {

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

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

client端代码

package com.company;

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

public class Main {

    public static void main(String[] args) throws IOException {
        //创建客户端的Socket对象
        //Socket (InetAddress adress,int port)创建流套接字并将其连接到指定IP地址的指定端口号
//		Socket s=new Socket(InetAddress.getByName("192.168.224.1"), 10000);
        //Socket (String host,int port)创建流套接字并将其连接到指定主机的指定端口号
        Socket s=new Socket("127.0.0.1", 50000);

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

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

运行结果
在这里插入图片描述
在这里插入图片描述

二、NIO实现TCP聊天程序

1、NIO简介
①NIO特点
  NIO单线程模型，采用selector管理的轮询查询模式，selector每隔一段时间都去看一下client端有没有产生需要处理的消息（客户端连接请求、客户端发送数据请求、客户端下载数据请求），也就是说selector会同时管理client端的连接和通道内client端的读、写请求。
  NIO单线程模型：采用selector管理的轮询查询模式，selector每隔一段时间都去看一下client端有没有产生需要处理的消息（客户端连接请求、客户端发送数据请求、客户端下载数据请求），也就是说selector会同时管理client端的连接和通道内client端的读、写请求。

②NIO与IO的主要区别
在这里插入图片描述
2、NIO实现网络程序
①创建两个java项目
步骤与前面一样
②代码部分
service端代码

package com.company;

import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;
import java.util.Iterator;
import java.util.Set;

public class Main {

    //网络通信IO操作，TCP协议，针对面向流的监听套接字的可选择通道（一般用于服务端）
    private ServerSocketChannel serverSocketChannel;
    private Selector selector;

    /*
     *开启服务端
     */
    public void start(Integer port) throws Exception {
        serverSocketChannel = ServerSocketChannel.open();
        selector = Selector.open();
        //绑定监听端口
        serverSocketChannel.socket().bind(new InetSocketAddress(port));
        //设置为非阻塞模式
        serverSocketChannel.configureBlocking(false);
        //注册到Selector上
        serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);
        startListener();
    }
    private void startListener() throws Exception {
        while (true) {
            // 如果客户端有请求select的方法返回值将不为零
            if (selector.select(1000) == 0) {
                System.out.println("current not exists task");
                continue;
            }
            // 如果有事件集合中就存在对应通道的key
            Set<SelectionKey> selectionKeys = selector.selectedKeys();
            Iterator<SelectionKey> iterator = selectionKeys.iterator();
            // 遍历所有的key找到其中事件类型为Accept的key
            while (iterator.hasNext()) {
                SelectionKey key = iterator.next();
                if (key.isAcceptable())
                    handleConnection();
                if (key.isReadable())
                    handleMsg(key);
                iterator.remove();
            }
        }
    }
    /**
     * 处理建立连接
     */
    private void handleConnection() throws Exception {
        SocketChannel socketChannel = serverSocketChannel.accept();
        socketChannel.configureBlocking(false);
        socketChannel.register(selector, SelectionKey.OP_READ, ByteBuffer.allocate(1024));
    }
    /*
     * 接收信息
     */
    private void handleMsg(SelectionKey key) throws Exception {
        SocketChannel channel = (SocketChannel) key.channel();
        ByteBuffer attachment = (ByteBuffer) key.attachment();
        channel.read(attachment);
        System.out.println("current msg: " + new String(attachment.array()));
    }

    public static void main(String[] args) throws Exception {
        Main myServer = new Main();
        myServer.start(8888);
    }
}

Client端代码

package com.company;

import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.SocketChannel;

public class Main {

    public static void main(String[] args) throws Exception {
        SocketChannel socketChannel = SocketChannel.open();
        socketChannel.configureBlocking(false);

        // 连接服务器
        if (!socketChannel.connect(new InetSocketAddress("127.0.0.1", 8888))) {
            while (!socketChannel.finishConnect()) {
                System.out.println("connecting...");
            }
        }
        //发送数据
        String str = "hello netty";
        ByteBuffer byteBuffer = ByteBuffer.wrap(str.getBytes());
        socketChannel.write(byteBuffer);
        System.in.read();
    }
}

运行结果
在这里插入图片描述
在这里插入图片描述

三、Netty实现TCP聊天程序

1、 Netty简介
①Netty定义

Netty 是一个基于NIO的客户、服务器端编程框架。
 
②Netty特点

使用Netty 可以确保你快速和简单的开发出一个网络应用。
Netty 是一个吸收了多种协议的实现经验，包括FTP，SMTP，HTTP，各种二进制，文本协议，并经过相当精心设计的项目。
Netty在保证程序易于开发的同时，还保证了应用的高性能，稳定性和伸缩性。
2、Netty实现网络程序
①新建两个java项目（一个Server端，一个client端）

与以上步骤相同

②相关包下载及添加
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
搜索输入io.netty:netty-all，等几分钟
在这里插入图片描述
在这里插入图片描述
添加包
在这里插入图片描述
在这里插入图片描述
Server端代码

import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.*;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioServerSocketChannel;
import io.netty.handler.codec.string.StringDecoder;
import io.netty.handler.codec.string.StringEncoder;

import java.net.InetSocketAddress;

/**
 *
 */
public class Server {

    private int port;

    public static void main(String[] args){
        new Server(18080).start();
    }

    public Server(int port) {
        this.port = port;
    }

    public void start() {
        /**
         * 创建两个EventLoopGroup，即两个线程池，boss线程池用于接收客户端的连接，
         * 一个线程监听一个端口，一般只会监听一个端口所以只需一个线程
         * work池用于处理网络连接数据读写或者后续的业务处理（可指定另外的线程处理业务，
         * work完成数据读写）
         */
        EventLoopGroup boss = new NioEventLoopGroup(1);
        EventLoopGroup work = new NioEventLoopGroup();
        try {
            /**
             * 实例化一个服务端启动类，
             * group（）指定线程组
             * channel（）指定用于接收客户端连接的类，对应java.nio.ServerSocketChannel
             * childHandler（）设置编码解码及处理连接的类
             */
            ServerBootstrap server = new ServerBootstrap()
                    .group(boss, work).channel(NioServerSocketChannel.class)
                    .localAddress(new InetSocketAddress(port))
                    .option(ChannelOption.SO_BACKLOG, 128)
                    .childOption(ChannelOption.SO_KEEPALIVE, true)
                    .childHandler(new ChannelInitializer<SocketChannel>() {
                        @Override
                        protected void initChannel(SocketChannel ch) throws Exception {
                            ch.pipeline()
                                    .addLast("decoder", new StringDecoder())
                                    .addLast("encoder", new StringEncoder())
                                    .addLast(new HelloWorldServerHandler());
                        }
                    });
            //绑定端口
            ChannelFuture future = server.bind().sync();
            System.out.println("server started and listen " + port);
            future.channel().closeFuture().sync();
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            boss.shutdownGracefully();
            work.shutdownGracefully();
        }
    }

    public static class HelloWorldServerHandler extends ChannelInboundHandlerAdapter {

        @Override
        public void channelActive(ChannelHandlerContext ctx) throws Exception {
            System.out.println("HelloWorldServerHandler active");
        }

        @Override
        public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
            System.out.println("server channelRead..");
            System.out.println(ctx.channel().remoteAddress()+"->Server :"+ msg.toString());
            ctx.write("server write"+msg);
            ctx.flush();
        }
    }
}

Client端代码

import io.netty.bootstrap.Bootstrap;
import io.netty.channel.*;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioSocketChannel;
import io.netty.handler.codec.string.StringDecoder;
import io.netty.handler.codec.string.StringEncoder;

/**
 *
 */
public class Client {
    private static final String HOST = "localhost";
    private static final int PORT= 18080;

    public static void main(String[] args){
        new Client().start(HOST, PORT);
    }

    public void start(String host, int port) {
        EventLoopGroup group = new NioEventLoopGroup();
        try {
            Bootstrap client = new Bootstrap().group(group).channel(NioSocketChannel.class)
                    .option(ChannelOption.TCP_NODELAY, true).handler(new ChannelInitializer<SocketChannel>() {
                        @Override
                        protected void initChannel(SocketChannel ch) throws Exception {
                            ch.pipeline()
                                    .addLast("decoder", new StringDecoder())
                                    .addLast("encoder", new StringEncoder())
                                    .addLast(new HelloWorldClientHandler());
                        }
                    });
            ChannelFuture future = client.connect(host, port).sync();
            future.channel().writeAndFlush("Hello Netty Server ,I am a netty client");
            future.channel().closeFuture().sync();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            group.shutdownGracefully();

        }

    }

    public static class HelloWorldClientHandler extends ChannelInboundHandlerAdapter {
        @Override
        public void channelActive(ChannelHandlerContext ctx) throws Exception {
            System.out.println("HelloWorldClientHandler Active");
        }

        @Override
        public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
            System.out.println("HelloWorldClientHandler read Message:"+msg);
        }
    }
}

运行结果
在这里插入图片描述
在这里插入图片描述

总结

对IO、NIO、Netty的一些基本概念有了一定了解，也成功实现基于TCP的C/S模式的聊天程序

wth1231232
关注
分别基于IO、NIO、Netty的Java网络程序
qq_45874317的博客
12-17 89
一、Netty入门 1、传统IO与NIO NIO即New IO，这个库是在JDK1.4中才引入的。NIO和IO有相同的作用和目的，但实现方式不同，NIO主要用到的是块，所以NIO的效率要比IO高很多。在Java API中提供了两套NIO，一套是针对标准输入输出NIO，另一套就是网络编程NIO。 1、传统IO特点 1.服务端阻塞点 server.accept();获取套接字的时候 inputStream.read(bytes);输入流读取数据的时候 2.传统socket是短连接，可以做短连接服务器
JAVA中的IO和NIO以及Netty
dedsec0x的博客
12-17 579
一、基础知识 (一)IO和NIO的概念 IO Java IO 也称为IO流，IO = 流，它的核心就是对文件的操作，对于字节、字符类型的输入和输出流。IO是指对数据流的输入和输出，也称为IO流，IO流主要分为两大类，字节流和字符流。字节流可以处理任何类型的数据，如图片，视频等，字符流只能处理字符类型的数据。IO流的本质是数据传输，并且流是单向的。 NIO JAVA NIO有两种解释：一种叫非阻塞IO（Non-blocking I/O），另一种也叫新的IO（New I/O），其实是同一个...
NIO与IO的区别
热门推荐
Mr孔先森
06-24 2万+
JAVA NIO vs IO 当我们学习了Java NIO和IO后，我们很快就会思考一个问题： 什么时候应该使用IO，什么时候我应该使用NIO 在下文中我会尝试用例子阐述java NIO 和IO的区别，以及它们对你的设计会有什么影响 Java NIO和IO的主要区别 IO NIO 面向Stream 面向Buffer 阻塞IO 非阻塞IO
NIO与传统IO的区别
观千剑而后识器，操千曲而后晓声。
05-04 1万+
感性认识：  传统的socket IO中，需要为每个连接创建一个线程，当并发的连接数量非常巨大时，线程所占用的栈内存和CPU线程切换的开销将非常巨大。使用NIO，不再需要为每个线程创建单独的线程，可以用一个含有限数量线程的线程池，甚至一个线程来为任意数量的连接服务。由于线程数量小于连接数量，所以每个线程进行IO操作时就不能阻塞，如果阻塞的话，有些连接就得不到处理，NIO提供了这种非阻塞的能力。 小
Java网络编程：IO，NIO与Netty
闫玉林的博客
06-16 519
新公司新项目，项目需要在硬件和软件平台进行信息传递，具体来说使用Netty。硬件和软件使用socket连接，硬件作为客户端，软件平台作为服务的，使用TCP/IP通信。接着这个机会把Java IO和Netty重新学习了一下，总结在这里，不准确或错误的地方，欢迎指出来。对于Java IO，可以分为同步与异步，也可以分为阻塞与非阻塞，下面对这些概念进行解释：reactor 模型：非阻塞同步网络模型，NIO使用的模型，事件分离器负责等待文件描述符或socket为读写操作准备就绪，然后将就绪事件传递给对应的处理器，最
基于IO、NIO、Netty的Java网络程序（实现服务端与客户端通信）
YouthBlood9的博客
12-17 2696
录一、IO Java网络聊天程序1.1 IO 介绍1.1.1 简介1.1.2 传统IO特点1.1.3 原理图1.2 IDEA新建Java项目1.3 代码1.4 运行结果二、NIO Java网络聊天程序2.1 NIO 介绍2.1.1 简介2.1.2 NIO的特点2.1.3 NIO的通信步骤2.1.4 原理图2.1.5 IO与NIO的主要区别2.2 新建项目2.3 代码2.4 运行结果三、Netty Java网络程序3.1 Netty 介绍3.1.1 简介3.1.2 特点3.1.3 Netty通信的步骤3.2
基于IO、NIO、Netty的Java网络程序（TCP的聊天程序）
weixin_46129506的博客
12-09 676
目录一、IO1.IO的特点2.基于IO的java网络程序二、NIO1.NIO的简介2.基于NIO的java程序三、Netty1.netty介绍2.基于Netty的java网络程序四、总结参考资料 一、IO 1.IO的特点 1.服务端阻塞点 server.accept();获取套接字的时候 inputStream.read(bytes);输入流读取数据的时候 2.传统socket是短连接，可以做短连接服务器，他无法做长连接，属于一问一答的模式，比如老的tomcat底层用的就是socket,用完就会关掉线程，因
基于IO/NIO/Netty的Client/Server的java程序实现
hh444565的博客
12-19 272
一、IO实现 （一）IO介绍 1.传送IO特点 （1）服务端阻塞点 server.accept();获取套接字的时候 inputStream.read(bytes);输入流读取数据的时候 （2）传统socket是短连接，可以做短连接服务器，他无法做长连接，属于一问一答的模式，比如老的tomcat底层用的就是socket,用完就会关掉线程，因此不会出现线程一直被占用的情况，支持处理多个客户端连接 单线程情况下只能有一个客户端（一个线程维护一个连接，也就是一个socket客户连接）线程一直被占用。 用...
spring事务详细讲解-深入浅出
小电玩
09-08 509
Spring 事务是本身就是对数据库的事务的支持，没有数据库的事务 Spring 是本身无法实现事务的。Spring只提供了统一事务管理接口，具体的实现还是由各数据库自己实现。在使用 Spring 事务时，可以通过注解或编程方式将需要进行事务管理的方法和代码块标记为事务性操作，当这些操作被执行时，Spring 会负责开启时根据当前环境中设置的隔离级别，调整数据库隔离级别。
Java多线程：深入探索与详细解析
m0_63550220的博客
09-08 1495
作为Java中的基本执行单元，线程是轻量级的进程，由线程ID、程序计数器、Java虚拟机栈、本地方法栈、和线程私有内存等部分组成。每个线程都有独立的执行路径，但共享进程的资源（如内存）。：进程是系统资源分配的基本单位，它包含了一个或多个线程以及这些线程运行所需的资源。在Java中，JVM（Java虚拟机）就是一个进程，而运行在JVM上的多个线程则共享JVM的内存空间。：并发指的是多个任务在同一时间段内交替执行，而并行则指的是多个任务在同一时刻真正同时执行。
自动生成不重复的订单id
ClaireCheney的博客
09-13 116
【代码】自动生成不重复的订单id。
Java集合：Stack详解
yang_brother的博客
09-10 561
Java 中的Stack类是一个后进先出（LIFO, Last In First Out）的数据结构，它继承自Vector类。尽管Stack是一个可用的类，但它被认为是遗留的，并且在新代码中不推荐使用。通常建议使用Deque或ArrayDeque作为替代。
币安/OK现货合约量化系统APP开发
I592O929783的博客
09-08 592
后端：考虑系统需要处理大量实时数据和高频交易的特点，选择高性能的编程语言和技术框架，如Python的Django或Flask框架，Java的Spring Boot等。用户交互界面：设计直观易用的用户交互界面，包括交易界面、策略配置界面、风险管理界面等，方便用户进行交易操作、策略配置和风险管理。市场数据接入：开发市场数据接入模块，从币安等交易所或数据服务商获取实时的市场数据，包括行情数据、订单簿数据、成交数据等。前端：选择适合开发复杂界面的前端框架，如React、Vue.js等，以提供用户友好的交互界面。
基于SpringBoot的考研资讯平台设计与实现
最新发布
linzhongshu的专栏
09-13 505
对于本次的系统开发来看，它主要是把我以前所学的知识进行了一次综合的应用。经过这次毕业设计的制作它主要是把我以前所学的理论知识应用到社会实践当中。通过这一次的考研资讯平台的设计与实现它能够有效把计算机知识与实际问题相互应用，通过计算机网络技术来解决学生生活当中的实际问题，从而提高我的编程能力。虽然在这次毕业设计当中我遇到了很多的问题和困难，但是通过不断的调试和老师的帮助让我圆满的完成了这次毕业设计。
MyBatis面试
Tony_yitao的博客
09-09 760
MyBatis面试
Linux服务器Java启动脚本
Jack魏
09-08 564
本文章介绍了如何在Linux服务器上执行Java并启动jar包，通常我们会使用nohup直接启动，但是还是需要手动停止然后再次启动，那如何更优雅的在服务器上启动jar包呢，让我们一起探讨一下吧。
springboot数据库连接由localhost改成IP以后访问报错500（2024/9/7
不起眼小菜菜的博客
09-07 360
步骤很详细，直接上教程……
Spring-di基本使用
2301_76862031的博客
09-09 1355
spirngDi环境搭建，使用流程，set注入，构造注入，对象注入，外部引入注入，内部创建注入，外部引入级联赋值注入，list集合注入，map集合注入，util注入
Java中项目名、包名、类名、接口名、方法名、类名命名规范（简单示范）
weixin_70495659的博客
09-08 294
【代码】Java中项目名、包名、类名、接口名、方法名、类名命名规范（简单示范）
Java NIO英文版：提升IO效率与Netty应用
1. **介绍**：首先，作者通过对比I/O与CPU时间的关系，阐述了Java NIO的重要性，指出Java 1.4的新I/O API不再受限于CPU密集型操作，从而使得程序不再受阻塞I/O的瓶颈。章节中还强调了学习本书能够帮助读者掌握如何...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值