`
chaijuntao
  • 浏览: 24757 次
  • 性别: Icon_minigender_1
  • 来自: 杭州
社区版块
存档分类
最新评论

netty学习【三】：发送对象

 
阅读更多

1、项目结构：

看下项目的结构：
这里写图片描述

2、项目源码：

2.1、服务器端：

EchoServer.java

package send_object.server;

import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.Channel;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.EventLoopGroup;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.nio.NioServerSocketChannel;
import send_object.coder.PersonDecoder;

/**
 * • 配置服务器功能，如线程、端口 • 实现服务器处理程序，它包含业务逻辑，决定当有一个请求连接或接收数据时该做什么
 *
 */
public class EchoServer {

    private final int port;

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

    public void start() throws Exception {
        EventLoopGroup eventLoopGroup = null;
        try {
            //创建ServerBootstrap实例来引导绑定和启动服务器
            ServerBootstrap serverBootstrap = new ServerBootstrap();
            //创建NioEventLoopGroup对象来处理事件，如接受新连接、接收数据、写数据等等
            eventLoopGroup = new NioEventLoopGroup();
            //指定通道类型为NioServerSocketChannel，一种异步模式，OIO阻塞模式为OioServerSocketChannel
            //设置InetSocketAddress让服务器监听某个端口已等待客户端连接。
            serverBootstrap.group(eventLoopGroup).channel(NioServerSocketChannel.class).localAddress("localhost",port)
            .childHandler(new ChannelInitializer<Channel>() {
                //设置childHandler执行所有的连接请求
                @Override
                protected void initChannel(Channel ch) throws Exception {
                    //注册解码的handler
                    ch.pipeline().addLast(new PersonDecoder());  //IN1  反序列化
                    //添加一个入站的handler到ChannelPipeline  
                    ch.pipeline().addLast(new EchoServerHandler());   //IN2
                }
                    });
            // 最后绑定服务器等待直到绑定完成，调用sync()方法会阻塞直到服务器完成绑定,然后服务器等待通道关闭，因为使用sync()，所以关闭操作也会被阻塞。
            ChannelFuture channelFuture = serverBootstrap.bind().sync();
            System.out.println("开始监听，端口为：" + channelFuture.channel().localAddress());
            channelFuture.channel().closeFuture().sync();
        } finally {
            eventLoopGroup.shutdownGracefully().sync();
        }
    }

    public static void main(String[] args) throws Exception {
        new EchoServer(20000).start();
    }
}
 

EchoServerHandler.java

package send_object.server;

import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandlerAdapter;
import send_object.bean.Person;

import java.util.Date;

public class EchoServerHandler extends ChannelInboundHandlerAdapter {

    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg)
            throws Exception {
        System.out.println("接收客户端消息：");
        Person person = (Person) msg;
        System.out.println(person.getName());
        System.out.println(person.getAge());
        System.out.println(person.getSex());

        //向客户端写数据
        System.out.println("server向client发送数据");
        String currentTime = new Date(System.currentTimeMillis()).toString();
        ByteBuf resp = Unpooled.copiedBuffer(currentTime.getBytes());
        ctx.write(resp);
    }

    @Override
    public void channelReadComplete(ChannelHandlerContext ctx) throws Exception {
        System.out.println("server 读取数据完毕..");

        ctx.flush();//刷新后才将数据发出到SocketChannel
    }

    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause)
            throws Exception {
        cause.printStackTrace();
        ctx.close();
    }

}
 

2.2、客户端：

EchoClient.java

package send_object.client;

import io.netty.bootstrap.Bootstrap;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.EventLoopGroup;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioSocketChannel;
import send_object.coder.PersonEncoder;

import java.net.InetSocketAddress;


/**
 * • 连接服务器 • 写数据到服务器 • 等待接受服务器返回相同的数据 • 关闭连接
 * 
 * @author wilson
 *
 */
public class EchoClient {

    private final String host;
    private final int port;

    public EchoClient(String host, int port) {
        this.host = host;
        this.port = port;
    }

    public void start() throws Exception {
        EventLoopGroup nioEventLoopGroup = null;
        try {
            // 创建Bootstrap对象用来引导启动客户端
            Bootstrap bootstrap = new Bootstrap();
            // 创建EventLoopGroup对象并设置到Bootstrap中，EventLoopGroup可以理解为是一个线程池，这个线程池用来处理连接、接受数据、发送数据
            nioEventLoopGroup = new NioEventLoopGroup();
            // 创建InetSocketAddress并设置到Bootstrap中，InetSocketAddress是指定连接的服务器地址
            bootstrap.group(nioEventLoopGroup)//
                    .channel(NioSocketChannel.class)//
                    .remoteAddress(new InetSocketAddress(host, port))//
                    .handler(new ChannelInitializer<SocketChannel>() {//
                                // 添加一个ChannelHandler，客户端成功连接服务器后就会被执行
                                @Override
                                protected void initChannel(SocketChannel ch)
                                        throws Exception {
                                    // 注册编码的handler
                                    ch.pipeline().addLast(new PersonEncoder());  //out
                                    //注册处理消息的handler
                                    ch.pipeline().addLast(new EchoClientHandler());   //in
                                }
                            });
            // • 调用Bootstrap.connect()来连接服务器
            ChannelFuture f = bootstrap.connect().sync();
            // • 最后关闭EventLoopGroup来释放资源
            f.channel().closeFuture().sync();
        } finally {
            nioEventLoopGroup.shutdownGracefully().sync();
        }
    }

    public static void main(String[] args) throws Exception {
        new EchoClient("localhost", 20000).start();
    }
}
 

EchoClientHandler.java

package send_object.client;

import io.netty.buffer.ByteBuf;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.SimpleChannelInboundHandler;
import send_object.bean.Person;

public class EchoClientHandler extends SimpleChannelInboundHandler<ByteBuf> {
    // 客户端连接服务器后被调用
    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {
         Person person = new Person();
            person.setName("angelababy");
            person.setSex("girl");
            person.setAge(18);
            ctx.write(person);
            ctx.flush();
    }

    // • 从服务器接收到数据后调用
    @Override
    protected void channelRead0(ChannelHandlerContext ctx, ByteBuf msg)
            throws Exception {
        System.out.println("client 读取server数据..");
        // 服务端返回消息后
//      ByteBuf buf = (ByteBuf) msg;
//      byte[] req = new byte[buf.readableBytes()];
//      buf.readBytes(req);
        byte[] req = new byte[msg.readableBytes()];
        msg.readBytes(req);
        String body = new String(req, "UTF-8");
        System.out.println("服务端数据为 :" + body);
    }

    // • 发生异常时被调用
    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause)
            throws Exception {
        System.out.println("client exceptionCaught..");
        // 释放资源
        ctx.close();
    }
}
 

2.3、其他：

Person.java

package send_object.bean;

import java.io.Serializable;

public class Person implements Serializable {
    private static final long serialVersionUID = 1L;
    private String name;
    private String sex;
    private int age;

    public String toString() {
        return "name:" + name + " sex:" + sex + " age:" + age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}
 

PersonDecoder.java

package send_object.coder;

import io.netty.buffer.ByteBuf;
import io.netty.channel.ChannelHandlerContext;
import io.netty.handler.codec.ByteToMessageDecoder;
import send_object.utils.ByteBufToBytes;
import send_object.utils.ByteObjConverter;

import java.util.List;


 /**
  * 反序列化
  * 将Byte[]转换为Object
  * @author wilson
  *
  */
public class PersonDecoder extends ByteToMessageDecoder {
    @Override
    protected void decode(ChannelHandlerContext ctx, ByteBuf in, List<Object> out) throws Exception {
        //工具类：将ByteBuf转换为byte[]
        ByteBufToBytes read = new ByteBufToBytes();
        byte[] bytes = read.read(in);
        //工具类：将byte[]转换为object
        Object obj = ByteObjConverter.byteToObject(bytes);
        out.add(obj);
    }

}
 

PersonEncoder.java

package send_object.coder;

import io.netty.buffer.ByteBuf;
import io.netty.channel.ChannelHandlerContext;
import io.netty.handler.codec.MessageToByteEncoder;
import send_object.bean.Person;
import send_object.utils.ByteObjConverter;

/**
  * 序列化
  * 将object转换成Byte[]
  * @author wilson
  *
  */
public class PersonEncoder extends MessageToByteEncoder<Person> {

    @Override
    protected void encode(ChannelHandlerContext ctx, Person msg, ByteBuf out) throws Exception {
        //工具类：将object转换为byte[]
        byte[] datas = ByteObjConverter.objectToByte(msg);
        out.writeBytes(datas);
        ctx.flush();
    }
}
 

ByteBufToBytes.java

package send_object.utils;

import io.netty.buffer.ByteBuf;

public class ByteBufToBytes {
    /**
     * 将ByteBuf转换为byte[]
     * @param datas
     * @return
     */
    public byte[] read(ByteBuf datas) {
        byte[] bytes = new byte[datas.readableBytes()];// 创建byte[]
        datas.readBytes(bytes);// 将ByteBuf转换为byte[]
        return bytes;
    }
}
 

ByteObjConverter.java

package send_object.utils;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;

public class ByteObjConverter {
    /**
     * 使用IO的inputstream流将byte[]转换为object
     * @param bytes
     * @return
     */
    public static Object byteToObject(byte[] bytes) {
        Object obj = null;
        ByteArrayInputStream bi = new ByteArrayInputStream(bytes);
        ObjectInputStream oi = null;
        try {
            oi = new ObjectInputStream(bi);
            obj = oi.readObject();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                bi.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                oi.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return obj;
    }
    /**
     * 使用IO的outputstream流将object转换为byte[]
     * @param obj
     * @return
     */
    public static byte[] objectToByte(Object obj) {
        byte[] bytes = null;
        ByteArrayOutputStream bo = new ByteArrayOutputStream();
        ObjectOutputStream oo = null;
        try {
            oo = new ObjectOutputStream(bo);
            oo.writeObject(obj);
            bytes = bo.toByteArray();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                bo.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                oo.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return bytes;
    }
}
 

3、最后结果：

服务器端：

开始监听，端口为：/127.0.0.1:20000
接收客户端消息：
angelababy
18
girl
server向client发送数据
server 读取数据完毕..

 客户端：

client 读取server数据..
服务端数据为 :Thu Dec 22 10:32:34 CST 2016
分享到：
netty学习【二】：netty中handler的执行 ...
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    Netty入门与实战：仿写微信IM即时通讯系统

    通过以上内容的学习，我们可以了解到如何使用Netty实现一个类似于微信的即时通讯系统，包括单聊和群聊功能。这不仅能够帮助我们深入理解Netty框架的使用方法，还能提升我们在网络编程方面的能力。

    Java Netty基于对象数据传输Demo

    在传输对象时，Netty通常会将对象转换为字节数组，利用`ChannelHandlerContext`的`writeAndFlush()`方法进行网络发送。收到数据后，再反序列化回原来的对象。 首先，我们需要了解Netty的管道（Pipeline）机制。管道...

    netty-test:阶段六Netty学习

    标签"Java"确认了这是基于Java语言的Netty学习，意味着我们将讨论Java相关的编程概念，如面向对象设计，多线程，以及Java NIO（非阻塞I/O）等。 根据压缩包子文件的文件名称列表"netty-test-master"，我们可以推测...

    netty-client:netty client学习

    Netty 客户端的学习过程中，你还会接触到许多其他概念，如 ByteBuf（用于高效地处理网络数据），以及各种编解码器（如 LengthFieldBasedFrameDecoder、ProtobufVarint32FrameDecoder 等）以适应不同协议的需求。...

    java netty学习资料

    这个学习资料包“java netty学习资料”很可能是为了帮助开发者理解和掌握Netty的核心概念和实践应用。 在Netty中，定义消息协议通讯是构建网络应用的关键步骤。Netty提供了一种灵活的方式来定义自定义的编解码器，...

    netty对象传输gzipdemo

    4. **发送和接收对象**: 使用`ChannelHandlerContext`的writeAndFlush方法发送对象，接收到的数据会被自动解码并传递给相应的处理器。 在这个示例中，"thinglin.netty"可能是一个包含Netty项目源代码的文件，包括了...

    netty-test:netty学习使用

    这个"netty-test"项目显然是一个用于学习和实践 Netty 的示例工程，通过创建一个简单的服务器和客户端来展示 Netty 的基本用法。 在描述中提到的两个关键类，`com.hwy.ServerRun` 和 `com.hwy.ClientRun`，分别代表...

    netty-book:netty权威指南示例代码

    《Netty权威指南》是一本深入探讨Java网络编程...通过学习和实践这些示例，开发者能够熟练掌握Netty的使用，开发出高效、可靠的网络应用。无论是初学者还是有经验的开发者，都能从中受益匪浅，提升自己的网络编程技能。

    netty-demo:学习netty时的例子, 各种demo

    5. **编解码器示例**：在 Netty 中，自定义编解码器是常见的需求，用于将原始字节流转换为业务对象，或者反之。 通过研究这些示例，你可以逐步理解 Netty 如何处理网络事件、如何组织 Pipeline 以及如何编写自定义 ...

    netty的视频90集

    通过这90集的视频学习，观众将全面掌握Netty框架的使用和原理，包括其设计模式、最佳实践以及实际项目中的应用。对于提升Java网络编程能力，深入理解NIO，以及构建高性能的网络应用具有极大的帮助。

    netty-mysql:异步mysql客户端的另一种方法

    Netty 是一个高性能、异步事件驱动的网络应用程序框架，用于快速开发可维护的高性能协议服务器和客户端。在本文中，我们将深入...在实际项目中，可以结合 `netty-mysql-master` 代码库中的示例来学习和实践这一技术。

    netty-study：学习netty相关知识，实现简单rpc，websocket

    这个"Netty-study"项目显然旨在帮助学习者深入理解 Netty 的工作原理，以及如何利用它来实现简单RPC（远程过程调用）和WebSocket通信。 在Java世界中，Netty因其高效、易用和灵活性而备受青睐。它提供了丰富的网络...

    Unity与Netty进行ProtoBuf通信__

    发送数据时，先序列化对象，然后通过连接发送序列化后的字节数组。在服务器端，Netty将接收到这些字节，反序列化为Java对象。 5. **在Netty中处理ProtoBuf数据**：在Netty服务器端，你需要创建一个自定义的`...

    zoro-netty-tomcat:基于 netty 手写tomcat实例

    通过这个项目，我们可以学习到如何利用Netty构建高性能、异步非阻塞的网络应用，以及理解Tomcat的工作原理。 首先，我们来了解Netty。Netty是一个开源的、高性能、异步事件驱动的网络应用程序框架，它主要用于快速...

    Netty初探：掌握高性能网络通信框架，提升Java网络编程技能

    学习Netty，你需要掌握以下关键概念： 1. Channel：网络连接的抽象，用于读写数据。 2. ChannelPipeline：事件处理器链，处理连接上的事件。 3. ChannelHandlerContext：上下文对象，提供与Channel和Pipeline交互的...

    Netty4.0学习笔记系列之六：多种通讯协议支持

    在本篇Netty4.0学习笔记系列之六中，我们将深入探讨Netty框架如何支持多种通讯协议，以及它在实现高效、灵活的网络通信中的关键特性。Netty是一个高性能、异步事件驱动的网络应用框架，适用于开发服务器和客户端的...

    netty4-demos.zip

    Netty 是一个高性能、异步事件驱动的网络应用...这个项目不仅包含了网络编程的基本概念，还涵盖了文件操作、数据编码解码、多线程和并发控制等多个方面的知识，对于学习和理解Netty以及WebSocket的实战应用非常有价值。

    netty学习资料(java源代码实例).zip

    这个“netty学习资料(java源代码实例).zip”压缩包包含的资源显然是为了帮助Java开发者深入理解并实践Netty框架。在Netty的学习过程中，源代码实例是极其宝贵的，因为它们能让你直观地看到如何在实际应用中运用Netty...

    【项目实战】Netty源码剖析&NIO;+Netty5各种RPC架构实战演练三部曲视频教程（未加密）

    ### Netty源码剖析与NIO及Netty5各种RPC架构实战演练三部曲知识点解析 #### 一、Netty概述 Netty是一款基于Java NIO的高性能服务器端编程框架，用于快速开发可维护的网络应用程序。它简化了网络编程的复杂性，使...

Magicbox
Global site tag (gtag.js) - Google Analytics