Netty與Marshalling結合發送對象—Netty學習二

時間 2019-11-19

標籤 netty marshalling 結合發送對象學習欄目 Netty 简体版

原文原文鏈接

以前的博客是Netty簡單的學習，咱們能夠傳遞一個字符串，那麼若是咱們想要在Netty中傳遞一個對象該怎麼辦呢？那麼這個時候咱們能夠結合Marshalling來傳遞。java

首先須要導入兩個Marshalling的依賴包web

jboss-marshalling-1.3.0.CR9.jar服務器

jboss-marshalling-serial-1.3.0.CR9.jaride

注意：我開始學習的時候只導入了第一個jar包，沒有導入第二個，結果是不報錯，可是客戶端和服務端之間傳遞不了消息。因此兩個包必定要都導入才行。工具

MarshallingCodeCFactory工具類oop

public class MarshallingCodeCFactory {    
    
    public static MarshallingDecoder buildMarshallingDecoder() {    
        final MarshallerFactory factory = Marshalling.getProvidedMarshallerFactory("serial");    
        final MarshallingConfiguration configuration = new MarshallingConfiguration();    
        configuration.setVersion(5);    
        UnmarshallerProvider provider = new DefaultUnmarshallerProvider(factory, configuration);    
        MarshallingDecoder decoder = new MarshallingDecoder(provider, 1024*1024);    
        return decoder;    
    }    
    
    public static MarshallingEncoder buildMarshallingEncoder() {    
        final MarshallerFactory factory = Marshalling.getProvidedMarshallerFactory("serial");    
        final MarshallingConfiguration configuration = new MarshallingConfiguration();    
        configuration.setVersion(5);    
        MarshallerProvider provider = new DefaultMarshallerProvider(factory, configuration);    
        MarshallingEncoder encoder = new MarshallingEncoder(provider);    
        return encoder;    
    }    
}

server端學習

public class Server {  
      
    public static void main(String[] args) throws InterruptedException {  
        //1.第一個線程組是用於接收Client端鏈接的    
        EventLoopGroup bossGroup = new NioEventLoopGroup();     
        //2.第二個線程組是用於實際的業務處理的    
        EventLoopGroup workerGroup = new NioEventLoopGroup();    
        ServerBootstrap b = new ServerBootstrap();    
        b.group(bossGroup, workerGroup);//綁定兩個線程池    
        b.channel(NioServerSocketChannel.class);//指定NIO的模式，若是是客戶端就是NioSocketChannel    
        b.option(ChannelOption.SO_BACKLOG, 1024);//TCP的緩衝區設置    
        b.option(ChannelOption.SO_SNDBUF, 32*1024);//設置發送緩衝的大小    
        b.option(ChannelOption.SO_RCVBUF, 32*1024);//設置接收緩衝區大小    
        b.option(ChannelOption.SO_KEEPALIVE, true);//保持連續    
        b.childHandler(new ChannelInitializer<SocketChannel>() {    
            protected void initChannel(SocketChannel ch) throws Exception {  
                //設置Marshalling的編碼和解碼  
                ch.pipeline().addLast(MarshallingCodeCFactory.buildMarshallingDecoder());  
                ch.pipeline().addLast(MarshallingCodeCFactory.buildMarshallingEncoder());  
                ch.pipeline().addLast(new ServertHandler());  
            }  
        });  
        ChannelFuture future = b.bind(8765).sync();//綁定端口    
        future.channel().closeFuture().sync();//等待關閉(程序阻塞在這裏等待客戶端請求)    
        bossGroup.shutdownGracefully();//關閉線程    
        workerGroup.shutdownGracefully();//關閉線程   
    }  
  
}

ServerHandler處理類ui

public class ServertHandler extends ChannelHandlerAdapter {  
  
    @Override  
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause)  
            throws Exception {  
        cause.printStackTrace();  
    }  
  
    @Override  
    public void channelRead(ChannelHandlerContext ctx, Object msg)  
            throws Exception {  
        Send send = (Send) msg;  
        System.out.println("client發送："+send);  
          
        Receive receive = new Receive();  
        receive.setId(send.getId());  
        receive.setMessage(send.getMessage());  
        receive.setName(send.getName());  
        ctx.writeAndFlush(receive);  
    }  
      
}

因爲咱們已經在Server端和Client端定義了傳遞的類型又Marshalling工廠處理，因此此時咱們接收的時候直接轉成發送的對象類型就好了。this

Client端編碼

public class Client {  
  
    public static void main(String[] args) throws InterruptedException {  
        EventLoopGroup worker = new NioEventLoopGroup();  
        Bootstrap b = new Bootstrap();  
        b.group(worker)  
        .channel(NioSocketChannel.class)  
        .handler(new ChannelInitializer<SocketChannel>() {  
            @Override  
            protected void initChannel(SocketChannel sc) throws Exception {  
                //ByteBuf buf = Unpooled.copiedBuffer("$_".getBytes());   
                //sc.pipeline().addLast(new DelimiterBasedFrameDecoder(1024,buf));  
                //sc.pipeline().addLast(new StringDecoder());  
                sc.pipeline().addLast(MarshallingCodeCFactory.buildMarshallingDecoder());  
                sc.pipeline().addLast(MarshallingCodeCFactory.buildMarshallingEncoder());  
                sc.pipeline().addLast(new ClientHandler());  
            }  
        });  
        ChannelFuture f=b.connect("127.0.0.1",8765).sync();  
        for(int i=1;i<=5;i++){  
            Send send = new Send();  
            send.setId(i);  
            send.setMessage("message"+i);  
            send.setName("name"+i);  
            f.channel().writeAndFlush(send);  
        }  
        f.channel().closeFuture().sync();  
        worker.shutdownGracefully();  
    }  
}

ClientHandler端

public class ClientHandler extends ChannelHandlerAdapter{  
      @Override  
        public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause)  
                throws Exception {  
            cause.printStackTrace();  
            ctx.close();  
        }  
  
        @Override  
        public void channelRead(ChannelHandlerContext ctx, Object msg)  
                throws Exception {  
            Receive receive = (Receive) msg;  
            System.out.println("server反饋："+receive);  
        }  
}

send類

public class Send implements Serializable {  
  
    /** 
     * serialVersionUID:TODO（用一句話描述這個變量表示什麼） 
     *  
     * @since 1.0.0 
     */  
  
    private static final long serialVersionUID = 1L;  
  
    private Integer id;  
    private String name;  
    private String message;  
  
    public Integer getId() {  
        return id;  
    }  
  
    public void setId(Integer id) {  
        this.id = id;  
    }  
  
    public String getName() {  
        return name;  
    }  
  
    public void setName(String name) {  
        this.name = name;  
    }  
  
    public String getMessage() {  
        return message;  
    }  
  
    public void setMessage(String message) {  
        this.message = message;  
    }  
  
    @Override  
    public String toString() {  
        return "Send [id=" + id + ", name=" + name + ", message=" + message + "]";  
    }  
  
}

Receive類

public class Receive implements Serializable{  
  
    /** 
     * serialVersionUID:TODO（用一句話描述這個變量表示什麼） 
     * @since 1.0.0 
     */  
      
    private static final long serialVersionUID = 1L;  
    private Integer id;  
    private String name;  
    private String message;  
    private byte[] sss;  
      
    public byte[] getSss() {  
        return sss;  
    }  
    public void setSss(byte[] sss) {  
        this.sss = sss;  
    }  
    public Integer getId() {  
        return id;  
    }  
    public void setId(Integer id) {  
        this.id = id;  
    }  
    public String getName() {  
        return name;  
    }  
    public void setName(String name) {  
        this.name = name;  
    }  
    public String getMessage() {  
        return message;  
    }  
    public void setMessage(String message) {  
        this.message = message;  
    }  
    @Override  
    public String toString() {  
        return "Receive [id=" + id + ", name=" + name + ", message=" + message + ", sss=" + Arrays.toString(sss) + "]";  
    }  
      
}

注意：send類和receive這兩個類，咱們再真實環境開發的時候服務器和客戶端每每是兩個web應用程序，在這裏咱們要注意服務端和客戶端之間的兩個類類名和包名在兩端要徹底相同。