nio学习之netty入门（3）---发送对象

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接收客户端消息：angelababy18girlserver向client发送数据server 读取数据完毕..

客户端：

client 读取server数据..服务端数据为 :Thu Dec 22 10:32:34 CST 2016