贴上两个自己写好的例子，以便备注，以下两个例子基于netty-3.5.7.Final.jar用Junit进行测试
第一个例子：简单的发送字符串，接收字符串“Hello, World”
package com.wujintao.netty;
import java.net.InetSocketAddress;
import java.util.concurrent.Executors;
import org.jboss.netty.bootstrap.ClientBootstrap;
import org.jboss.netty.bootstrap.ServerBootstrap;
import org.jboss.netty.channel.ChannelFuture;
import org.jboss.netty.channel.ChannelHandlerContext;
import org.jboss.netty.channel.ChannelPipeline;
import org.jboss.netty.channel.ChannelPipelineFactory;
import org.jboss.netty.channel.ChannelStateEvent;
import org.jboss.netty.channel.Channels;
import org.jboss.netty.channel.ExceptionEvent;
import org.jboss.netty.channel.MessageEvent;
import org.jboss.netty.channel.SimpleChannelHandler;
import org.jboss.netty.channel.socket.nio.NioClientSocketChannelFactory;
import org.jboss.netty.channel.socket.nio.NioServerSocketChannelFactory;
import org.jboss.netty.handler.codec.string.StringDecoder;
import org.jboss.netty.handler.codec.string.StringEncoder;
import org.junit.Test;
class HelloWorldServerHandler extends SimpleChannelHandler {
public void channelConnected(ChannelHandlerContext ctx, ChannelStateEvent e)
throws Exception {
e.getChannel().write("Hello, World");
}
public void exceptionCaught(ChannelHandlerContext ctx, ExceptionEvent e) {
System.out.println("Unexpected exception from downstream."
+ e.getCause());
e.getChannel().close();
}
}
class HelloWorldClientHandler extends SimpleChannelHandler {
public void messageReceived(ChannelHandlerContext ctx, MessageEvent e) {
String message = (String) e.getMessage();
System.out.println(message);
e.getChannel().close();
}
public void exceptionCaught(ChannelHandlerContext ctx, ExceptionEvent e) {
System.out.println("Unexpected exception from downstream."
+ e.getCause());
e.getChannel().close();
}
}
/**
* Netty VS MinaNetty基于Pipeline处理，Mina基于Filter过滤
* Netty的事件驱动模型具有更好的扩展性和易用性
* Https，SSL，PB，RSTP，Text &Binary等协议支持
* Netty中UDP传输有更好的支持官方测试Netty比Mina性能更好
* @author Administrator
*
*/
public class TestCase {
public void testServer() {
//初始化channel的辅助类，为具体子类提供公共数据结构
ServerBootstrap bootstrap = new ServerBootstrap(
new NioServerSocketChannelFactory(
Executors.newCachedThreadPool(),
Executors.newCachedThreadPool()));
bootstrap.setPipelineFactory(new ChannelPipelineFactory() {
public ChannelPipeline getPipeline() {
ChannelPipeline pipeline = Channels.pipeline();
pipeline.addLast("decoder", new StringDecoder());
pipeline.addLast("encoder", new StringEncoder());
pipeline.addLast("handler", new HelloWorldServerHandler());
return pipeline;
}
});
//创建服务器端channel的辅助类,接收connection请求
bootstrap.bind(new InetSocketAddress(8080));
}
public void testClient() {
//创建客户端channel的辅助类,发起connection请求
ClientBootstrap bootstrap = new ClientBootstrap(
new NioClientSocketChannelFactory(
Executors.newCachedThreadPool(),
Executors.newCachedThreadPool()));
//It means one same HelloWorldClientHandler instance is going to handle multiple Channels and consequently the data will be corrupted.
//基于上面这个描述，必须用到ChannelPipelineFactory每次创建一个pipeline
bootstrap.setPipelineFactory(new ChannelPipelineFactory() {
public ChannelPipeline getPipeline() {
ChannelPipeline pipeline = Channels.pipeline();
pipeline.addLast("decoder", new StringDecoder());
pipeline.addLast("encoder", new StringEncoder());
pipeline.addLast("handler", new HelloWorldClientHandler());
return pipeline;
}
});
//创建无连接传输channel的辅助类(UDP),包括client和server
ChannelFuture future = bootstrap.connect(new InetSocketAddress(
"localhost", 8080));
future.getChannel().getCloseFuture().awaitUninterruptibly();
bootstrap.releaseExternalResources();
}
@Test
public void testNetty(){
testServer();
testClient();
}
}
第二个例子，实际应用中会用到这个，发送POJO类Persons [name=周杰伦123, age=31, salary=10000.44]
package com.wujintao.netty;
import static org.jboss.netty.buffer.ChannelBuffers.dynamicBuffer;
import java.net.InetSocketAddress;
import java.util.concurrent.Executors;
import org.jboss.netty.bootstrap.ClientBootstrap;
import org.jboss.netty.bootstrap.ServerBootstrap;
import org.jboss.netty.buffer.ChannelBuffer;
import org.jboss.netty.channel.Channel;
import org.jboss.netty.channel.ChannelFactory;
import org.jboss.netty.channel.ChannelFuture;
import org.jboss.netty.channel.ChannelFutureListener;
import org.jboss.netty.channel.ChannelHandlerContext;
import org.jboss.netty.channel.ChannelPipeline;
import org.jboss.netty.channel.ChannelPipelineFactory;
import org.jboss.netty.channel.ChannelStateEvent;
import org.jboss.netty.channel.Channels;
import org.jboss.netty.channel.MessageEvent;
import org.jboss.netty.channel.SimpleChannelHandler;
import org.jboss.netty.channel.socket.nio.NioClientSocketChannelFactory;
import org.jboss.netty.channel.socket.nio.NioServerSocketChannelFactory;
import org.jboss.netty.handler.codec.frame.FrameDecoder;
import org.junit.Test;
/**
* 用POJO代替ChannelBuffer
*/
class TimeServerHandler3 extends SimpleChannelHandler {
@Override
public void channelConnected(ChannelHandlerContext ctx, ChannelStateEvent e)
throws Exception {
Persons person = new Persons("周杰伦123",31,10000.44);
ChannelFuture future = e.getChannel().write(person);
future.addListener(ChannelFutureListener.CLOSE);
}
}
class TimeClientHandler3 extends SimpleChannelHandler{
@Override
public void messageReceived(ChannelHandlerContext ctx, MessageEvent e)
throws Exception {
Persons person = (Persons)e.getMessage();
System.out.println(person);
e.getChannel().close();
}
}
/**
* FrameDecoder and ReplayingDecoder allow you to return an object of any type.
*
*/
class TimeDecoder extends FrameDecoder {
private final ChannelBuffer buffer = dynamicBuffer();
@Override
protected Object decode(ChannelHandlerContext ctx, Channel channel,
ChannelBuffer channelBuffer) throws Exception {
if(channelBuffer.readableBytes()<4) {
return null;
}
if (channelBuffer.readable()) {
// 读到,并写入buf
channelBuffer.readBytes(buffer, channelBuffer.readableBytes());
}
int namelength = buffer.readInt();
String name = new String(buffer.readBytes(namelength).array(),"GBK");
int age = buffer.readInt();
double salary = buffer.readDouble();
Persons person = new Persons(name,age,salary);
return person;
}
}
class TimeEncoder extends SimpleChannelHandler {
private final ChannelBuffer buffer = dynamicBuffer();
@Override
public void writeRequested(ChannelHandlerContext ctx, MessageEvent e)
throws Exception {
Persons person = (Persons)e.getMessage();
buffer.writeInt(person.getName().getBytes("GBK").length);
buffer.writeBytes(person.getName().getBytes("GBK"));
buffer.writeInt(person.getAge());
buffer.writeDouble(person.getSalary());
Channels.write(ctx, e.getFuture(), buffer);
}
}
class Persons{
private String name;
private int age;
private double salary;
public Persons(String name,int age,double salary){
this.name = name;
this.age = age;
this.salary = salary;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public double getSalary() {
return salary;
}
public void setSalary(double salary) {
this.salary = salary;
}
@Override
public String toString() {
return "Persons [name=" + name + ", age=" + age + ", salary=" + salary
+ "]";
}
}
public class TestCase5 {
public void testServer() {
ChannelFactory factory = new NioServerSocketChannelFactory(Executors.newCachedThreadPool(), Executors.newCachedThreadPool());
ServerBootstrap bootstrap = new ServerBootstrap(factory);
bootstrap.setPipelineFactory(new ChannelPipelineFactory() {
public ChannelPipeline getPipeline() throws Exception {
return Channels.pipeline(new TimeEncoder(), new TimeServerHandler3());
}
});
bootstrap.setOption("child.tcpNoDelay", true);
bootstrap.setOption("child.keepAlive", true);
bootstrap.bind(new InetSocketAddress("localhost",9999));
}
public void testClient(){
//创建客户端channel的辅助类,发起connection请求
ClientBootstrap bootstrap = new ClientBootstrap(
new NioClientSocketChannelFactory(
Executors.newCachedThreadPool(),
Executors.newCachedThreadPool()));
bootstrap.setPipelineFactory(new ChannelPipelineFactory() {
public ChannelPipeline getPipeline() {
ChannelPipeline pipeline = Channels.pipeline();
pipeline.addLast("decoder", new TimeDecoder());
pipeline.addLast("encoder", new TimeEncoder());
pipeline.addLast("handler", new TimeClientHandler3());
return pipeline;
}
});
//创建无连接传输channel的辅助类(UDP),包括client和server
ChannelFuture future = bootstrap.connect(new InetSocketAddress(
"localhost", 9999));
future.getChannel().getCloseFuture().awaitUninterruptibly();
bootstrap.releaseExternalResources();
}
@Test
public void testNetty() {
testServer();
testClient();
}
}
相关推荐
在本文中，我们将深入探讨Netty在实际应用中的实例——对象传递调用，以及如何解决TCP粘包问题。同时，我们还会讨论Java序列化方案在Netty中的编解码对比。 首先，让我们来看看TCP粘包问题。在TCP协议中，由于其...
当有新的连接建立时，Netty 将为每个连接创建一个新的 Channel 实例，并在该 Channel 上设置我们配置的 Pipeline。 4. **连接到服务器**：在客户端，我们使用 Bootstrap 连接到服务器的指定地址和端口。同样，...
总之，"android netty使用demo"提供了一个基础的Android Netty应用实例，展示了如何在Android环境中使用Netty实现长连接通信。然而，实际开发中，还需要考虑更多的细节和优化，以满足复杂的网络应用场景。
基于netty各种例子。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。...
这个“netty的入门经典例子的使用”很可能是为了引导初学者了解和掌握 Netty 的基本用法和核心概念。下面将详细阐述 Netty 的基础知识及其在实际应用中的关键点。 首先，Netty 提供了一个高度可定制的事件驱动的...
标题 "Netty 使用Disruptor机制的处理源代码" 暗示我们将探讨如何在 Netty 中集成并利用 Disruptor 来优化消息处理流程。Disruptor 的核心是其环形缓冲区（Ring Buffer），这个缓冲区能够在无锁或极少锁的情况下实现...
也就是说，Netty 是一个基于NIO的客户，服务器端编程框架，使用Netty 可以确保你快速和简单的开发出一个网络应用，例如实现了某种协议的客户，服务端应用。Netty相当简化和流线化了网络应用的编程开发过程，例如，...
Netty5完整例子,里面包含编码，解码，心跳处理等，代码可用。 例子的内容是：服务端启动,客户端启动,客户端连接服务器后服务器发一个Message的对象给客户端，客户端接受并打印Message里边的内容。编解码的处理为：...
"Netty 入门经典例子" Netty 是一个异步的、事件驱动的网络编程框架和工具，使用 Netty 可以快速开发出可维护的、high-performance 的协议服务及其客户端应用。Netty 相当简化和流线化了网络应用的编程开发过程，...
4. **Pipeline**：Netty 使用 ChannelPipeline 来处理进来的数据。Pipeline 是一系列处理器（ChannelHandler）的链，每个处理器可以处理特定类型的数据或事件，如解码、编码、业务逻辑处理等。 5. **...
在本“Netty 聊天例子”中，我们将深入探讨如何利用 Netty 构建一个简单的聊天应用，这对于初学者来说是一个很好的起点。 **Netty 基础** Netty 的核心组件包括 Channel、Bootstrap、Pipeline 和 EventLoopGroup。...
在"Netty实现WebSocket例子"中，我们将探讨如何使用Netty来搭建WebSocket服务器，并实现客户端与服务器之间的双向通信。首先，我们需要理解WebSocket的基本概念和工作原理。WebSocket协议是基于TCP的，它通过HTTP的...
这个压缩包“netty各种例子(基于netty各种例子。).zip”显然是一个包含Netty示例代码的资源包，可以帮助开发者更好地理解和使用Netty框架。 在Java世界中，Netty因其高效、易用和丰富的特性而被广泛应用于多种场景...
在IT行业中，Spring、Netty和MyBatis是三个非常重要的框架，它们分别在不同的领域发挥着关键作用。Spring是一个全面的Java应用框架，提供强大的依赖注入、AOP（面向切面编程）以及丰富的功能模块；Netty则是一个高...
总结起来，这个压缩包为学习和使用Netty提供了一套完整的资源。通过研究源码、阅读API文档和运行示例，开发者可以掌握Netty的精髓，提升网络编程能力，并在实际项目中发挥出Netty的强大性能。无论你是初学者还是经验...
在"SpringBoot_Netty实例"中，开发者尝试将这两个强大的工具结合在一起，以实现更高效、灵活的网络通信服务。SpringBoot的使用可以帮助我们快速构建基于Netty的应用，并且通过Spring的依赖注入和自动配置能力，使得...
通过在 IntelliJ IDEA（简称 IDEA）中运行这些例子，我们可以深入学习 Netty 的核心特性和使用方式。 1. **异步事件驱动模型** Netty 基于非阻塞 I/O 模型，利用 Java NIO (Non-blocking Input/Output) 库，实现了...
本篇文章将深入探讨Netty的原理，并通过实例帮助你快速入门和提高。 1. **Netty的基本概念** - **NIO（Non-blocking I/O）**：Netty是基于Java NIO构建的，NIO允许单线程处理多个通道，减少了线程创建和销毁的开销...
通过实践Netty 3.5的入门实例，你可以学习如何设置服务器、建立连接、定义消息处理流程，以及如何优雅地处理异常。这些基础将帮助你理解Netty的工作原理，为后续学习更高级的功能打下坚实基础。在实践中，你可能会...
这个压缩包文件"java Netty 框架例子源码.rar"很可能包含了一系列示例代码，帮助我们了解和学习如何在实际项目中使用 Netty。 Netty 的核心组件包括： 1. **Channel**：是 Netty 中的基本概念，代表一个打开的连接...