netty初认识

Netty是什么？

本质：JBoss做的一个Jar包

目的：快速开发高性能、高可靠性的网络服务器和客户端程序

优点：提供异步的、事件驱动的网络应用程序框架和工具

通俗的说：一个好使的处理Socket的东东

如果没有Netty？

远古：java.net + java.io

近代：java.nio

其他：Mina，Grizzly

为什么不是Mina？

1、都是Trustin Lee的作品，Netty更晚；

2、Mina将内核和一些特性的联系过于紧密，使得用户在不需要这些特性的时候无法脱离，相比下性能会有所下降，Netty解决了这个设计问题；

3、Netty的文档更清晰，很多Mina的特性在Netty里都有；

4、Netty更新周期更短，新版本的发布比较快；

5、它们的架构差别不大，Mina靠apache生存，而Netty靠jboss，和jboss的结合度非常高，Netty有对google protocal buf的支持，有更完整的ioc容器支持(spring,guice,jbossmc和osgi)；

6、Netty比Mina使用起来更简单，Netty里你可以自定义的处理upstream events 或/和 downstream events，可以使用decoder和encoder来解码和编码发送内容；

7、Netty和Mina在处理UDP时有一些不同，Netty将UDP无连接的特性暴露出来；而Mina对UDP进行了高级层次的抽象，可以把UDP当成"面向连接"的协议，而要Netty做到这一点比较困难。

Netty的特性

设计

统一的API，适用于不同的协议（阻塞和非阻塞）

基于灵活、可扩展的事件驱动模型

高度可定制的线程模型

可靠的无连接数据Socket支持（UDP）

性能

更好的吞吐量，低延迟

更省资源

尽量减少不必要的内存拷贝

安全

完整的SSL/TLS和STARTTLS的支持

能在Applet与Android的限制环境运行良好

健壮性

不再因过快、过慢或超负载连接导致OutOfMemoryError

不再有在高速网络环境下NIO读写频率不一致的问题

易用

完善的JavaDoc，用户指南和样例

简洁简单

仅信赖于JDK1.5

看例子吧！

Server端：

Java代码  

  1. package me.hello.netty;
  2. import org.jboss.netty.bootstrap.ServerBootstrap;
  3. import org.jboss.netty.channel.*;
  4. import org.jboss.netty.channel.socket.nio.NioServerSocketChannelFactory;
  5. import org.jboss.netty.handler.codec.string.StringDecoder;
  6. import org.jboss.netty.handler.codec.string.StringEncoder;
  7. import java.net.InetSocketAddress;
  8. import java.util.concurrent.Executors;
  9. /**
  10. * God Bless You!
  11. * Author: Fangniude
  12. * Date: 2013-07-15
  13. */
  14. public class NettyServer {
  15. public static void main(String[] args) {
  16. ServerBootstrap bootstrap = new ServerBootstrap(new NioServerSocketChannelFactory(Executors.newCachedThreadPool(), Executors.newCachedThreadPool()));
  17. // Set up the default event pipeline.
  18. bootstrap.setPipelineFactory(new ChannelPipelineFactory() {
  19. @Override
  20. public ChannelPipeline getPipeline() throws Exception {
  21. return Channels.pipeline(new StringDecoder(), new StringEncoder(), new ServerHandler());
  22. }
  23. });
  24. // Bind and start to accept incoming connections.
  25. Channel bind = bootstrap.bind(new InetSocketAddress(8000));
  26. System.out.println("Server已经启动，监听端口: " + bind.getLocalAddress() + "， 等待客户端注册。。。");
  27. }
  28. private static class ServerHandler extends SimpleChannelHandler {
  29. @Override
  30. public void messageReceived(ChannelHandlerContext ctx, MessageEvent e) throws Exception {
  31. if (e.getMessage() instanceof String) {
  32. String message = (String) e.getMessage();
  33. System.out.println("Client发来:" + message);
  34. e.getChannel().write("Server已收到刚发送的:" + message);
  35. System.out.println("\n等待客户端输入。。。");
  36. }
  37. super.messageReceived(ctx, e);
  38. }
  39. @Override
  40. public void exceptionCaught(ChannelHandlerContext ctx, ExceptionEvent e) throws Exception {
  41. super.exceptionCaught(ctx, e);
  42. }
  43. @Override
  44. public void channelConnected(ChannelHandlerContext ctx, ChannelStateEvent e) throws Exception {
  45. System.out.println("有一个客户端注册上来了。。。");
  46. System.out.println("Client:" + e.getChannel().getRemoteAddress());
  47. System.out.println("Server:" + e.getChannel().getLocalAddress());
  48. System.out.println("\n等待客户端输入。。。");
  49. super.channelConnected(ctx, e);
  50. }
  51. }
  52. }

客户端：

Java代码  

  1. package me.hello.netty;
  2. import org.jboss.netty.bootstrap.ClientBootstrap;
  3. import org.jboss.netty.channel.*;
  4. import org.jboss.netty.channel.socket.nio.NioClientSocketChannelFactory;
  5. import org.jboss.netty.handler.codec.string.StringDecoder;
  6. import org.jboss.netty.handler.codec.string.StringEncoder;
  7. import java.io.BufferedReader;
  8. import java.io.InputStreamReader;
  9. import java.net.InetSocketAddress;
  10. import java.util.concurrent.Executors;
  11. /**
  12. * God Bless You!
  13. * Author: Fangniude
  14. * Date: 2013-07-15
  15. */
  16. public class NettyClient {
  17. public static void main(String[] args) {
  18. // Configure the client.
  19. ClientBootstrap bootstrap = new ClientBootstrap(new NioClientSocketChannelFactory(Executors.newCachedThreadPool(), Executors.newCachedThreadPool()));
  20. // Set up the default event pipeline.
  21. bootstrap.setPipelineFactory(new ChannelPipelineFactory() {
  22. @Override
  23. public ChannelPipeline getPipeline() throws Exception {
  24. return Channels.pipeline(new StringDecoder(), new StringEncoder(), new ClientHandler());
  25. }
  26. });
  27. // Start the connection attempt.
  28. ChannelFuture future = bootstrap.connect(new InetSocketAddress("localhost", 8000));
  29. // Wait until the connection is closed or the connection attempt fails.
  30. future.getChannel().getCloseFuture().awaitUninterruptibly();
  31. // Shut down thread pools to exit.
  32. bootstrap.releaseExternalResources();
  33. }
  34. private static class ClientHandler extends SimpleChannelHandler {
  35. private BufferedReader sin = new BufferedReader(new InputStreamReader(System.in));
  36. @Override
  37. public void messageReceived(ChannelHandlerContext ctx, MessageEvent e) throws Exception {
  38. if (e.getMessage() instanceof String) {
  39. String message = (String) e.getMessage();
  40. System.out.println(message);
  41. e.getChannel().write(sin.readLine());
  42. System.out.println("\n等待客户端输入。。。");
  43. }
  44. super.messageReceived(ctx, e);
  45. }
  46. @Override
  47. public void channelConnected(ChannelHandlerContext ctx, ChannelStateEvent e) throws Exception {
  48. System.out.println("已经与Server建立连接。。。。");
  49. System.out.println("\n请输入要发送的信息：");
  50. super.channelConnected(ctx, e);
  51. e.getChannel().write(sin.readLine());
  52. }
  53. }
  54. }

Netty整体架构

Netty组件

ChannelFactory

Boss

Worker

Channel

ChannelEvent

Pipeline

ChannelContext

Handler

Sink

Server端核心类

NioServerSocketChannelFactory

NioServerBossPool

NioWorkerPool

NioServerBoss

NioWorker

NioServerSocketChannel

NioAcceptedSocketChannel

DefaultChannelPipeline

NioServerSocketPipelineSink

Channels

ChannelFactory

Channel工厂，很重要的类

保存启动的相关参数

NioServerSocketChannelFactory

NioClientSocketChannelFactory

NioDatagramChannelFactory

这是Nio的，还有Oio和Local的

SelectorPool

Selector的线程池

NioServerBossPool 默认线程数：1

NioClientBossPool      1

NioWorkerPool      2 * Processor

NioDatagramWorkerPool

Selector

选择器，很核心的组件

NioServerBoss

NioClientBoss

NioWorker

NioDatagramWorker

Channel

通道

NioServerSocketChannel

NioClientSocketChannel

NioAcceptedSocketChannel

NioDatagramChannel

Sink

负责和底层的交互

如bind，Write，Close等

NioServerSocketPipelineSink

NioClientSocketPipelineSink

NioDatagramPipelineSink

Pipeline

负责维护所有的Handler

ChannelContext

一个Channel一个，是Handler和Pipeline的中间件

Handler

对Channel事件的处理器

ChannelPipeline


 

优秀的设计----事件驱动

优秀的设计----线程模型

注意事项

解码时的Position

Channel的关闭

更多Handler

Channel的关闭

用完的Channel，可以直接关闭；

1、ChannelFuture加Listener

2、writeComplete

一段时间没用，也可以关闭

TimeoutHandler

转自： http://lippeng.iteye.com/blog/1907279

时间： 2024-12-29 23:20:23

netty初认识的相关文章

Netty初体验

一.概述 Netty基于NIO的网络编程框架,是一个封装了NIO复杂的底层细节,可以拿来开发高并发的服务端和客户端的程序,简单直白你可以理解它就是一个好用的处理socket的东西就行啦. 二.Netty初体验 首先,创建maven工程添加Netty依赖,新建两个包,一个是客户端,一个服务端,先来看看服务端代码,这个是服务器类,主要的逻辑都在这里实现. public class Server { public static void main(String[] args) throws Excep

Netty入门之WebSocket初体验

说一说IO通信 BIO通信: BIO即同步阻塞模式一请求一应答的通信模型,该模型最大的问题就是缺乏弹性伸缩能力,当客户端并发访问量增加后,服务端的线程个数和客户端并发访问数呈1:1的正比关系,由于线程是JAVA虚拟机非常宝贵的系统资源,当线程数膨胀之后,系统的性能将急剧下降,随着并发访问量的继续增大,系统会发生线程堆栈溢出.创建新线程失败等问题,并最终导致进程宕机或者僵死,不能对外提供服务. BIO的服务端通信模型: 采用BIO通信模型的服务端,通常由一个独立的Acceptor线程负责监听客户端

Netty 中文用户手册（一）

序言 本指南对Netty 进行了介绍并指出其意义所在. 1. 问题 现在,我们使用适合一般用途的应用或组件来和彼此通信.例如,我们常常使用一个HTTP客户端从远程服务器获取信息或者通过web services进行远程方法的调用. 然而,一个适合普通目的的协议或其实现并不具备其规模上的扩展性.例如,我们无法使用一个普通的HTTP服务器进行大型文件,电邮信息的交互,或者处理金融信息和多人游戏数据那种要求准实时消息传递的应用场景.因此,这些都要求使用一个适用于特殊目的并经过高度优化的协议实现.例如,你

《Netty Zookeeper Redis 高并发实战》 图书简介

<Netty Zookeeper Redis 高并发实战> 图书简介 ## 重要的重复3遍: 本书 面试必备 + 面试必备 + 面试必备 购买链接 京东商城<Netty Zookeeper Redis 高并发实战 > <Netty Zookeeper Redis 高并发实战> 图书简介 机械工业出版社出版,尼恩编著的<Netty Zookeeper Redis 高并发实战>一书, 从操作系统底层的IO原理入手,同时提供高性能开发的实战案例,是一本高并发Jav

《Netty Redis Zookeeper 高并发实战》声明

疯狂创客圈 Java 高并发[ 亿级流量聊天室实战]实战系列 [博客园总入口 ] 这里, 对疯狂创客圈 <Netty Redis Zookeeper 高并发实战> 一书,对阅读不愉快的少量读者,进行一些必要说明. Why? 我们欢迎大家提出质量问题,对问题是直面和欢迎的,不是排斥的. 但是,也有部分少量的读者,将局部问题无限制放大,也是没有必要的. 一直都承认,一直都不回避:书籍有书籍的问题, 后续也持续改进. 尽管如此,还是有很多小伙伴,确实是{真实读者} . 确实带着目标:想籍<Ne

下载-深入浅出Netty源码剖析、Netty实战高性能分布式RPC、NIO+Netty5各种RPC架构实战演练三部曲视频教程

下载-深入浅出Netty源码剖析.Netty实战高性能分布式RPC.NIO+Netty5各种RPC架构实战演练三部曲视频教程 第一部分:入浅出Netty源码剖析 第二部分:Netty实战高性能分布式RPC 第三部分:NIO+Netty5各种RPC架构实战演练

Netty对Protocol Buffer多协议的支持（八）

Netty对Protocol Buffer多协议的支持(八) 一.背景 在上篇博文中笔者已经用代码演示了如何在netty中使用Protocol Buffer,然而细心的用户可能会发现一个明显的不足之处就是,我们的Handler只能处理一种特定的类型,而我们的项目中又不可能只有一种类型,那么这个问题该怎么解决了?多的不说,笔者直接上代码. 二.代码实现 2.1 message的编写 syntax = "proto2"; package com.rsy.netty.protobuf; op

Java Netty (1)

Netty是由JBOSS提供的一个java开源框架,本质上也是NIO,是对NIO的封装,比NIO更加高级,可以说发展的路线是IO->NIO->Netty. ServerBootstrap和ClientBootstrap是Netty中两个比较重要的类,分别用来进行服务器和客户端的初始化. 服务器: // ChannelFactory final ChannelFactory channelFactory = new NioServerSocketChannelFactory( // Boss线程

netty 解决TCP粘包与拆包问题(二)

TCP以流的方式进行数据传输,上层应用协议为了对消息的区分,采用了以下几种方法. 1.消息固定长度 2.第一篇讲的回车换行符形式 3.以特殊字符作为消息结束符的形式 4.通过消息头中定义长度字段来标识消息的总长度 一.采用指定分割符解决粘包与拆包问题 服务端 1 package com.ming.netty.nio.stickpack; 2 3 4 5 import java.net.InetSocketAddress; 6 7 import io.netty.bootstrap.ServerB