服务器之家:专注于服务器技术及软件下载分享
分类导航

PHP教程|ASP.NET教程|Java教程|ASP教程|编程技术|正则表达式|C/C++|IOS|C#|Swift|Android|VB|R语言|JavaScript|易语言|vb.net|

服务器之家 - 编程语言 - Java教程 - Netty学习教程之Netty与Marshalling结合发送对象

Netty学习教程之Netty与Marshalling结合发送对象

2020-10-21 21:37荒野的尘埃 Java教程

Netty是由JBOSS提供的一个Java开源框架,之前已经给大家简单介绍了一些基础与使用,下面这篇文章主要给大家介绍了关于Netty与Marshalling结合发送对象的相关资料,需要的朋友可以参考借鉴,下面来一起看看吧。

前言

之前的一篇文章Netty简单的学习,我们可以传递一个字符串,那么如果我们想要在Netty中传递一个对象该怎么办呢 ?

那么这个时候我们可以结合Marshalling来传递。

方法如下:

首先需要导入两个Marshalling的依赖包

?
1
2
jboss-marshalling-1.3.0.CR9.jar
jboss-marshalling-serial-1.3.0.CR9.jar

注意:我开始学习的时候只导入了第一个jar包,没有导入第二个,结果是不报错,但是客户端和服务端之间传递不了消息。所以两个包一定要都导入才行。

MarshallingCodeCFactory工具类

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
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端

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
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处理类

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
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工厂处理,所以此时我们接收的时候直接转成发送的对象类型就行了。

Client端

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
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端

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
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类

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
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类

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
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应用程序,在这里我们要注意服务端和客户端之间的两个类类名和包名在两端要完全相同。

总结

以上就是这篇文章的全部内容了,希望本文的内容对大家的学习或者工作能带来一定的帮助,如果有疑问大家可以留言交流,谢谢大家对服务器之家的支持。

原文链接:http://blog.csdn.net/a347911/article/details/53739769

延伸 · 阅读

精彩推荐