netty对象序列化传输机制（序）

来源：互联网发布：存活的数据叫删失数据编辑：程序博客网时间：2024/06/05 08:37

4.4.    对象传输的另一种实现机制
这种机制主要是为了应对其中一方不采用netty框架传输对象。
实现方案：采用通用的ObjectInputStream和ObjectOutputStream将对象转换成byte数组，然后传输（即实际传输的是byte数组）。
此种方式下无需设定编解码器就可传递对象，通过调试助手等终端也可以传输对象

(1)  UDPServerPipelineFactory.java

ChannelPipeline pipeline = Channels.pipeline(

              this.EXECUTION_UP_HANDLER,
              this.EXECUTION_DOWN_HANDLER,
              new UDPServerHandler());
       return pipeline;
(2)  UDPServerHandler.java

@Override
    public void messageReceived(ChannelHandlerContext ctx, MessageEvent e)
           throws Exception {
       ChannelBuffer cb = (ChannelBuffer) e.getMessage();
       Object obj = Utils.bytes2Obj(cb.array());
       Plan plan = (Plan)obj;
       LOGGER.info(plan);
       plan.setStatus(" server received");
       byte[] b = Utils.obj2Byte(plan);
       ChannelBuffer backBuffer = ChannelBuffers.buffer(b.length);
       backBuffer.writeBytes(b);
       e.getChannel().write(backBuffer,e.getRemoteAddress());
    }

(3)  UDPClient.java

Plan plan = new Plan();
       plan.setAuthor("linfenliang");
       plan.setContent("something about sequence");
       plan.setDate("2012-11-07");
       plan.setStatus("client send ");
       byte[] b = Utils.obj2Byte(plan);
       System.out.println(Utils.bytesToHex(b));
       Channel channel = MoreClient.initChannel();
       ChannelBuffer cb = ChannelBuffers.buffer(b.length);
       cb.writeBytes(b);
       channel.write(cb);

(4)  UdpClientPipelineFactory.java
@Override
    public ChannelPipeline getPipeline() throws Exception {
       ChannelPipeline pipeline = Channels.pipeline(
                         this.EXECUTION_UP_HANDLER,
              this.EXECUTION_DOWN_HANDLER,
              new UdpClientHandler());
       return pipeline;

    }
(5)  Utils.java

/**
     * 输入流关闭
     *
     * @author linfenliang
     * @date 2012-7-4
     * @version V1.0.0
     * @param inStream
     *            void
     /
    public static void closeInStreamQuietly(InputStream inStream) {
       if (inStream != null) {
           try {
              inStream.close();
           } catch (IOException e) {
              LOGGER*.error("quiet close, no deal:"+e);
           } finally {
              inStream = null;
           }
       }
    }

    /**
     * 输出流关闭
     *
     * @author linfenliang
     * @date 2012-7-4
     * @version V1.0.0
     * @param outStream
     *            void
     /
    public static void closeOutStreamQuietly(OutputStream outStream) {
       if (outStream != null) {
           try {
              outStream.flush();
              outStream.close();
           } catch (IOException e) {
              LOGGER*.error("quiet close, no deal:"+e);
           } finally {
              outStream = null;
           }
       }
    }

    /**
     * Object对象转byte数组
     *
     * @author linfenliang
     * @date 2012-11-8
     * @version V1.0.0
     * @param obj
     * @return byte[]
     /
    public static byte[] obj2Byte(Object obj) {
       byte[] bytes = null;
       ByteArrayOutputStream bo = null;
       ObjectOutputStream oo = null;

       try {
           bo = new ByteArrayOutputStream();
           oo = new ObjectOutputStream(bo);
           oo.writeObject(obj);
           bytes = bo.toByteArray();
       } catch (Exception e) {
           LOGGER.error("Object对象转byte数组异常:"+e);
       } finally {
           closeOutStreamQuietly(bo);
           closeOutStreamQuietly*(oo);
       }
       return bytes;
    }

    /**
     * byte数组转对象
     *
     * @author linfenliang
     * @date 2012-11-8
     * @version V1.0.0
     * @param bytes
     * @return Object
     /
    public static Object bytes2Obj(byte[] bytes) {
       Object obj = null;
       ByteArrayInputStream bi = null;
       ObjectInputStream oi = null;

       try {
           bi = new ByteArrayInputStream(bytes);
           oi = new ObjectInputStream(bi);
           obj = oi.readObject();
       } catch (Exception e) {
           LOGGER.error("byte数组转对象异常:"+e);
       } finally {
           closeInStreamQuietly(bi);
           closeInStreamQuietly*(oi);
       }
       return obj;
    }

0 0