nio与netty

最新推荐文章于 2023-06-04 19:22:54 发布
最新推荐文章于 2023-06-04 19:22:54 发布
阅读量165 收藏
点赞数
分类专栏： 性能优化
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Young_____Hu/article/details/84334204
版权

IO分为三种

  1. BIO(传统IO) 同步阻塞IO
  2. NIO同步非阻塞IO
  3. AIO异步非阻塞IO（涉及linux网络底层，太难，这里不讨论）

阻塞和非阻塞区别：
传统IO是阻塞的，因为read(),write()方法就是阻塞的，此时必须等读完了或者写完了才能进行后面的操作。NIO是非阻塞的，才用多路复用技术，把read()和write()单独给了一个线程，由操作系统完成，所以操作系统读完了或者写完了只需要给我们代码发个消息，代码直接去拿结果，中间不用等待，可以做自己的事。

原生NIO代码

package cn.nio;

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.SelectableChannel;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;
import java.util.Iterator;

public class NIOService {
	
	private Selector selector;
	
	public void initService() throws IOException{
		ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
		serverSocketChannel.configureBlocking(false);
		serverSocketChannel.bind(new InetSocketAddress(12345));
		this.selector = Selector.open();
		serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);
		System.out.println("【星际联邦】：开启服务成功");
	}
	
	public void listenService() throws IOException{
		while(true){
			selector.select();
			Iterator<SelectionKey> iterator = this.selector.selectedKeys().iterator();
			while(iterator.hasNext()){
				SelectionKey selectionKey = iterator.next();
				iterator.remove();
				if (selectionKey.isAcceptable()) {
					ServerSocketChannel server = (ServerSocketChannel) selectionKey.channel();
					SocketChannel channel = server.accept();
					channel.configureBlocking(false);
					channel.write(ByteBuffer.wrap("【星际联邦】：您已成功连接星际联邦。".getBytes("UTF-8")));
					channel.register(this.selector, SelectionKey.OP_READ);
				}else if (selectionKey.isReadable()) {
					SocketChannel channel =(SocketChannel) selectionKey.channel();
					ByteBuffer byteBuffer = ByteBuffer.allocate(4096);
					channel.read(byteBuffer);
					byte[] data = byteBuffer.array();
					String message = new String(data).trim();
					System.out.println("【星际联邦】：接受到消息"+message);
					ByteBuffer responseBuffer = ByteBuffer.wrap(new String("【星际联邦】：星际联邦已派企业号前往").getBytes("UTF-8"));
					channel.write(responseBuffer);
				}
			}
		}
	}

}


public class StartService {

	public static void main(String[] args) {
		NIOService service = new NIOService();
		try {
			service.initService();
			service.listenService();
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
	
}

package cn.nio;

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.SocketChannel;
import java.util.Iterator;

public class NIOClient {
	
	private Selector selector;
	
	public void initClient() throws IOException{
		SocketChannel channel = SocketChannel.open();
		channel.configureBlocking(false);
		selector = Selector.open();
		channel.connect(new InetSocketAddress("127.0.0.1", 12345));
		channel.register(selector,SelectionKey.OP_CONNECT);
		System.out.println("客户端启动成功");
	}
	
	public void listenClient() throws IOException{
		while(true){
			selector.select();
			Iterator<SelectionKey> iterator = selector.selectedKeys().iterator();
			while(iterator.hasNext()){
				SelectionKey key = iterator.next();
				iterator.remove();
				if (key.isConnectable()) {
					SocketChannel socketChannel = (SocketChannel) key.channel();
					if (socketChannel.isConnectionPending()) {
						socketChannel.finishConnect();
					}
					socketChannel.configureBlocking(false);
					socketChannel.write(ByteBuffer.wrap(new String("hello word").getBytes("UTF-8")));
					socketChannel.register(selector, SelectionKey.OP_READ);
				}else if (key.isReadable()) {
					SocketChannel socketChannel = (SocketChannel) key.channel();
					ByteBuffer byteBuffer = ByteBuffer.allocate(4096);
					socketChannel.read(byteBuffer);
					byte[] date = byteBuffer.array();
					String message = new String(date).trim();
					System.out.println("【客户端收到的消息为】:"+message);
					//ByteBuffer outBuffer = ByteBuffer.wrap(message.getBytes("utf-8"));
					//socketChannel.write(outBuffer);// 将消息回送给客户端
				}
			}
		}
	}
}


package cn.nio;

import java.io.IOException;

public class StartClinet {

	public static void main(String[] args) {
		NIOClient client = new NIOClient();
		try {
			client.initClient();
			client.listenClient();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		
	}
	
}

由于每次需要写这么多代码，于是一般使用第三方框架netty
netty注重点不在连接，而在我们的处理逻辑，逻辑一般写在handler

package day01.netty;

import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.Channel;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.nio.NioServerSocketChannel;

public class EchoService {

	public void initService() {
		NioEventLoopGroup nioEventLoopGroup = null;
		try {
			//server端引导类
			ServerBootstrap serverBootstrap = new ServerBootstrap();
			//连接池数据,netty自动弄的连接池
			nioEventLoopGroup = new NioEventLoopGroup();
			//装配bootstap
			serverBootstrap.group(nioEventLoopGroup)
			//通道类型为NioServerSocketChannel
			.channel(NioServerSocketChannel.class)
			//监听端口号
			.localAddress(12345)
					.childHandler(new ChannelInitializer<Channel>() {
						@Override
						protected void initChannel(Channel channel) throws Exception {
							//全是模板代码，主要是这里绑定handler
							channel.pipeline().addLast(new EchoServiceHandler());
						}
					});
			// 最后绑定服务器等待直到绑定完成，调用sync()方法会阻塞直到服务器完成绑定,然后服务器等待通道关闭，因为使用sync()，所以关闭操作也会被阻塞。
			ChannelFuture channelFuture = serverBootstrap.bind().sync();
			System.out.println("netty服务端启动成功");
			channelFuture.channel().closeFuture().sync();
		} catch (Exception e) {
			e.printStackTrace();
		}finally {
			try {
				nioEventLoopGroup.shutdownGracefully().sync();
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
	}

	
	public static void main(String[] args) {
		EchoService echoService = new EchoService();
		echoService.initService();
	}
}


package day01.netty;

import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandlerAdapter;

public class EchoServiceHandler extends ChannelInboundHandlerAdapter {

	/**
	 * 服务端获取请求的时候被调用
	 */
	@Override
	public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
		ByteBuf buf = (ByteBuf)msg;
        byte[] req = new byte[buf.readableBytes()];
        buf.readBytes(req);
        String content = new String(req,"UTF-8");
        System.out.println("netty服务端接受到的消息是："+content);
        String rsp = "我是netty服务端，我已收到"+content;//响应内容
        ByteBuf rspBuf = Unpooled.copiedBuffer(rsp.getBytes());
        ctx.write(rspBuf);//响应给客户端
	}
	
	/**
	 * channelRead方法完成之后调用
	 */
	@Override
	public void channelReadComplete(ChannelHandlerContext ctx) throws Exception {
		ctx.flush();//flush之后才是真的发送了
		System.out.println("netty服务端响应成功");
	}
	
	/**
	 * 发生异常时候被调用
	 */
	@Override
	public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
		cause.printStackTrace();
		ctx.close();
	}
}


package day01.netty;

import java.net.InetSocketAddress;

import io.netty.bootstrap.Bootstrap;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioSocketChannel;

public class EchoClient {

	private String ip;
	private Integer port;

	public EchoClient() {
		super();
	}

	public EchoClient(String ip, Integer port) {
		super();
		this.ip = ip;
		this.port = port;
	}

	public String getIp() {
		return ip;
	}

	public void setIp(String ip) {
		this.ip = ip;
	}

	public Integer getPort() {
		return port;
	}

	public void setPort(Integer port) {
		this.port = port;
	}

	public void initClient() throws Exception {
		Bootstrap bootstrap = new Bootstrap();
		NioEventLoopGroup nioEventLoopGroup = new NioEventLoopGroup();
		bootstrap.group(nioEventLoopGroup).channel(NioSocketChannel.class).remoteAddress(new InetSocketAddress(ip, port)).handler(new ChannelInitializer<SocketChannel>() {//业务处理类
			@Override
			protected void initChannel(SocketChannel ch)
					throws Exception {
				ch.pipeline().addLast(new EchoClientHandler());//注册handler
			}
		});
		ChannelFuture channelFuture = bootstrap.connect().sync();
		channelFuture.channel().closeFuture().sync();
		nioEventLoopGroup.shutdownGracefully().sync();
	}

	
	public static void main(String[] args) throws Exception {
		EchoClient client = new EchoClient("127.0.0.1", 12345);
		client.initClient();
	}
}


package day01.netty;

import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.SimpleChannelInboundHandler;

public class EchoClientHandler extends SimpleChannelInboundHandler<ByteBuf>{

	/**
	 * 客户端连接服务器后被调用
	 * 发送请求
	 */
	@Override
	public void channelActive(ChannelHandlerContext ctx) throws Exception {
		byte[] req = "hello word".getBytes();//消息
		ByteBuf buf = Unpooled.buffer(req.length);//把消息放入缓冲里面
		buf.writeBytes(req);//发送消息
		ctx.writeAndFlush(buf);//flush之后才是发送过去了
		System.out.println("netty客户端发送请求成功hello word");
	}
	
	/**
	 * 服务端给客户端发消息时被调用
	 * 获得响应
	 */
	@Override
	protected void channelRead0(ChannelHandlerContext chx, ByteBuf msg) throws Exception {
		ByteBuf buf = (ByteBuf) msg;
		byte[] req = new byte[buf.readableBytes()];
		buf.readBytes(req);
		String rsp = new String(req, "UTF-8");
		System.out.println("netty客户端获得响应，内容是："+rsp);
	}

	/**
	 * 发生异常后被调用
	 */
	@Override
	public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
		cause.printStackTrace();
		ctx.close();
	}

}
Young_____Hu
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Netty与NIO
编程小白养成手记
10-15 2573
BIO，NIO，Netty简介，BIO，AIO，NIO的区别，NIO的Buffer缓冲区，通道，以及处理java.nio.BufferOverflowException异常！欢迎指出错误！
NIO与netty原理
weixin_45566322的博客
08-30 537
计算机组成原理 App是无法直接操作驱动等内核程序的，需要调用内核程序时，必须向内核进行系统调用。 系统调用与函数调用不是同一个东西。 由于保护模式的存在，我们的程序是无法直接函数调用内核程序，而是通过系统调用。 系统调用，本质就是通过中断执行。 程序中断的过程： 程序中，仿佛函数调用似的调用内核程序，（本质上会产生中断） 系统调用产生中断，中断将内核程序的中断向量（0~255）存入CPU的寄存器 CPU同时会开启一个守护线程，守护我们的程序，以将中断的结果返回 CPU根据中断向量，在
NIO和Netty
10年IT大头兵
05-17 99
BIO 阻塞式 流 数组 NIO 非阻塞式 Channel Buffer 1.4之后 文件IO 缓冲区 Buffer 非阻塞的好处，一个线程就可以应付多个客户端， 核心API 4个 Selector选择器 SelectionKey 注册关系 ServerSocketChannel SocketChannel 网络io通道 ...
NIO 与 Netty
m0_50180963的博客
04-30 1168
NIO 什么是 NIO NIO全称Non Blocking IO，同步非阻塞IO框架。服务器实现模式为一个线程可以处理多个请求(连接)，客户端发送的连接请求都会注册到多路复用器selector上，多路复用器轮询到连接有IO请求就进行处理 为什么用 NIO 常见的网络服务中，如果每一个客户端都维持一个与登陆服务器的连接。那么服务器将维护多个和客户端的连接以出来和客户端的contnect 、read、write ，特别是对于长链接的服务，有多少个c端，就需要在s端维护同等的IO连接。这对服务器来说
java网络编程—NIO与Netty(一)
张硕的博客
07-30 2144
接下来一周，系统的总结NIO、IO、以及主流通信框架Netty等相关知识： java网络编程—NIO与Netty(四) java网络编程—NIO与Netty(三) java网络编程—NIO与Netty(二) java网络编程—NIO与Netty(一)对阻塞与非阻塞,同步与异步的理解 同步和异步关注的是消息通信机制 同步：发出一个调用时，等待直到，调用结果的完成后返回。
详细介绍 NIO与Netty编程-实战讲义详细pdf.7z
03-09
**NIO（非阻塞I/O）与Netty编程**是现代Java网络应用开发中的重要技术，它们在处理高并发、低延迟的网络通信场景中起着关键作用。本讲义详细介绍了这两种技术，旨在帮助开发者更好地理解和运用它们。 ### 一、BIO...
深入Hotspot源码与Linux内核理解NIO与Netty线程模型.rar
最新发布
03-20
《深入Hotspot源码与Linux内核理解NIO与Netty线程模型》这份资料主要探讨了Java的Hotspot虚拟机源码、Linux内核、非阻塞I/O（NIO）以及Netty框架的线程模型。这些知识点在构建高性能、高并发的网络应用中至关重要。 ...
NIO+Netty5视频教程与Netty源码剖析视频教程
11-20
《NIO+Netty5视频教程与Netty源码剖析视频教程》是一份全面解析网络编程框架Netty的教育资源，旨在帮助学习者深入...通过结合视频教程和文本资料，学习者可以更系统地吸收和巩固Netty与NIO的知识，提升自己的专业技能。
NIO 与 Netty 编程
u014069688的博客
08-16 373
BIO 编程 BIO 有的称之为 basic(基本) IO,有的称之为 block(阻塞) IO， 主要应用于文件 IO 和网络 IO，这里不再说文件 IO, 大家对此都非常熟悉， 本次课程主要讲解网络 IO。 在 JDK1.4 之前， 我们建立网络连接的时候只能采用 BIO， 需要先在服务端启动一个ServerSocket， 然后在客户端启动 Socket 来对服务端进行通信， 默认情况下服务端...
深入NIO与Netty（一）
jin19940227的博客
11-11 199
前言： 最近公司安排我做一个设备日志加密的需求，story大致是：一台具有syslog上报日志功能的网络设备，在每执行一条指令之后会上报日志到我们的日志服务器，而我们的工作，是负责在服务器端收集日志，并且设备与服务器要实现加密日志传输，其实就是通过SSL加密。期间调试花费了一个多月的时间，耗时这么长时间的主要原因：之间对于IO这块内容基本空白；服务器是netty写的，部门里的人都没有用过；完善加...
netty系列之:NIO和netty详解
程序那些事
03-09 5680
文章目录简介NIO常用用法NIO和EventLoopGroupNioEventLoopGroupSelectorProviderSelectStrategyFactoryRejectedExecutionHandlerEventLoopTaskQueueFactoryNioEventLoop总结 简介 netty为什么快呢？这是因为netty底层使用了JAVA的NIO技术，并在其基础上进行了性能的优化，虽然netty不是单纯的JAVA nio，但是netty的底层还是基于的是nio技术。 nio是JDK1.
什么是NIO，什么是Netty
islautao的博客
06-04 908
本文简单介绍了NIO和Netty的概念、特点和区别，并给出了一些示例和插图。希望对你有所帮助。
【Java网络编程】：Netty实现OIO和NIO
hxcaifly的博客
12-27 691
承接上文：https://blog.csdn.net/hxcaifly/article/details/85274664 前言 单纯地使用Java JDK来实现网络NIO是一件开发成本非常高的事情。然而，Netty 为它所有的传输实现提供了一个通用API，这使得这种转换比你直接使用JDK所能够达到的简单得多。所产生的代码不会被实现的细节所污染，而你也不需要在你的整个代码库上进行广泛的重构。简而...
异步非阻塞框架 netty 与 nio
ws - 兮的博客空间
09-23 1265
第一次深入了解nio，都会感觉非常的难理解阻塞与非阻塞，同步和异步阻塞，非阻塞，下面来看看吧 一、nio 和 netty 是什么? 1、Java NIO(New IO)是一个可以替代标准Java IO API的IO API（从Java 1.4开始) 2、 Netty 是一个基于 JAVA NIO 类库的异步通信框架，它的架构特点是：异步非阻塞、基于事件驱动、高性能、高可靠性和高可定制性。 3、主要...
对NIO和netty的理解和使用
奥迪的博客
03-11 534
对NIO的理解和使用 1、BIO 是一种阻塞IO，监听阻塞(active)，read阻塞。程序不往下执行 可进行多线程解决，但问题会出现空转，性能消耗问题 2、NIO 非阻塞IO，这个java中的实现和redis中的底层实现基本一致，liunx上主要采用了epoll模型，调用了 create ctl wait 系统指令 注册表到执行表中借助于liunx操作系统中中断程序完成 selector 字面意思之所以与select类似，因为早期版本1.4之前，java中NIO底层native调用的C代码中调用的
Netty系列(一)：IO与NIO
西部落酋长的博客
04-11 1108
介绍 这篇文章来介绍下IO与NIO的区别总结，相信好多人都碰到过IO，也听过NIO，不过对于NIO不太熟识，所有抽空了补录了一些，来记录自己的学习之路。 一、IO编程 来描述下我们的场景，客户端每隔一段时间发送一个"你好"给服务端，服务端收到并打印出来。 客户端 package com.guo.io; import java.io.IOException; import java.net.Soc...
深入剖析Hotspot与Linux内核：NIO与Netty线程模型详解
本文档深入探讨了Hotspot虚拟机源码与Linux内核在理解非阻塞I/O (NIO) 和高性能网络通信框架Netty中的线程模型。首先，我们回顾了Java中的三种主要网络编程IO模型：阻塞I/O (BIO), 非阻塞I/O (NIO), 和异步I/O (AIO)...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值