作家
登录

Apache MINA实战之对象传输

作者: 来源: 2012-06-12 14:32:12 阅读 我要评论

利用Apache MINA来传递对象,这对了MINA来说非常容易,并且这也是Java网络编程中很常用的应用。其实对于MINA传递对象来说,如果看过前一篇文章的话,只要在其中做少许改动就可以实现对象传递,但这里考虑到例子的完整性,还是给出了全部代码示例。

首先看两个用来传递的Java对象MyRequestObject和MyResponseObject,很简单只是实现了Serializable接口罢了。

  1. package com.google.code.garbagecan.minastudy.sample3;  
  2.  
  3. import java.io.Serializable;  
  4.  
  5. public class MyRequestObject implements Serializable {  
  6.  
  7.     private static final long serialVersionUID = 1L;  
  8.  
  9.     private String name;  
  10.       
  11.     private String value;  
  12.  
  13.     public MyRequestObject(String name, String value) {  
  14.         this.name = name;  
  15.         this.value = value;  
  16.     }  
  17.       
  18.     public String getName() {  
  19.         return name;  
  20.     }  
  21.  
  22.     public void setName(String name) {  
  23.         this.name = name;  
  24.     }  
  25.  
  26.     public String getValue() {  
  27.         return value;  
  28.     }  
  29.  
  30.     public void setValue(String value) {  
  31.         this.value = value;  
  32.     }  
  33.       
  34.     @Override 
  35.     public String toString() {  
  36.         StringBuffer sb = new StringBuffer();  
  37.         sb.append("Request [name: " + name  + ", value: " + value + "]");  
  38.         return sb.toString();  
  39.     }  
  40. }  
  41.  
  42. package com.google.code.garbagecan.minastudy.sample3;  
  43.  
  44. import java.io.Serializable;  
  45.  
  46. public class MyResponseObject implements Serializable {  
  47.  
  48.     private static final long serialVersionUID = 1L;  
  49.  
  50.     private String name;  
  51.       
  52.     private String value;  
  53.  
  54.     public MyResponseObject(String name, String value) {  
  55.         this.name = name;  
  56.         this.value = value;  
  57.     }  
  58.       
  59.     public String getName() {  
  60.         return name;  
  61.     }  
  62.  
  63.     public void setName(String name) {  
  64.         this.name = name;  
  65.     }  
  66.  
  67.     public String getValue() {  
  68.         return value;  
  69.     }  
  70.  
  71.     public void setValue(String value) {  
  72.         this.value = value;  
  73.     }  
  74.       
  75.     @Override 
  76.     public String toString() {  
  77.         StringBuffer sb = new StringBuffer();  
  78.         sb.append("Response [name: " + name  + ", value: " + value + "]");  
  79.         return sb.toString();  
  80.     }  
  81. }  

看看Server端的代码

  1. package com.google.code.garbagecan.minastudy.sample3;  
  2.  
  3. import java.io.IOException;  
  4. import java.net.InetSocketAddress;  
  5.  
  6. import org.apache.mina.core.service.IoAcceptor;  
  7. import org.apache.mina.core.service.IoHandlerAdapter;  
  8. import org.apache.mina.core.session.IdleStatus;  
  9. import org.apache.mina.core.session.IoSession;  
  10. import org.apache.mina.filter.codec.ProtocolCodecFilter;  
  11. import org.apache.mina.filter.codec.serialization.ObjectSerializationCodecFactory;  
  12. import org.apache.mina.filter.logging.LoggingFilter;  
  13. import org.apache.mina.transport.socket.nio.NioSocketAcceptor;  
  14. import org.slf4j.Logger;  
  15. import org.slf4j.LoggerFactory;  
  16.  
  17. public class MyServer {  
  18.       
  19.     private static final Logger logger = LoggerFactory.getLogger(MyServer.class);  
  20.       
  21.     public static void main(String[] args) {  
  22.         IoAcceptor acceptor = new NioSocketAcceptor();  
  23.  
  24.         acceptor.getFilterChain().addLast("logger"new LoggingFilter());  
  25.         acceptor.getFilterChain().addLast("codec"new ProtocolCodecFilter(new ObjectSerializationCodecFactory()));  
  26.  
  27.         acceptor.setHandler(new IoHandlerAdapter() {  
  28.               
  29.             @Override 
  30.             public void sessionCreated(IoSession session) throws Exception {  
  31.             }  
  32.               
  33.             @Override 
  34.             public void sessionOpened(IoSession session) throws Exception {  
  35.             }  
  36.  
  37.             @Override 
  38.             public void sessionClosed(IoSession session) throws Exception {  
  39.             }  
  40.  
  41.             @Override 
  42.             public void sessionIdle(IoSession session, IdleStatus status) throws Exception {  
  43.             }  
  44.  
  45.             @Override 
  46.             public void exceptionCaught(IoSession session, Throwable cause) throws Exception {  
  47.                 logger.error(cause.getMessage(), cause);  
  48.                 session.close(true);  
  49.             }  
  50.  
  51.             @Override 
  52.             public void messageReceived(IoSession session, Object message) throws Exception {  
  53.                 logger.info("Received " + message);  
  54.                 MyRequestObject myReqOjb = (MyRequestObject) message;  
  55.                 MyResponseObject myResObj = new MyResponseObject(myReqOjb.getName(), myReqOjb.getValue());  
  56.                 session.write(myResObj);  
  57.             }  
  58.  
  59.             @Override 
  60.             public void messageSent(IoSession session, Object message) throws Exception {  
  61.                 logger.info("Sent " + message);  
  62.             }  
  63.         });  
  64.           
  65.         try {  
  66.             acceptor.bind(new InetSocketAddress(10000));  
  67.         } catch (IOException ex) {  
  68.             logger.error(ex.getMessage(), ex);  
  69.         }  
  70.     }  

1. 首先创建I/O Service,这里使用的是NioSocketAcceptor类来创建了一个IoAcceptor实例。

2. 创建I/O Filter Chain,这里使用了两个个IoFilter,一个是LoggingFilter用来记录日志和打印事件消息,另一个是ProtocolCodecFilter实例用来编码数据,这里使用了ObjectSerializationCodecFactory类来序列化或反序列化数据成java对象。

3. 创建I/O Handler,这里主要看一下messageReceived方法,其总接收了MyRequestObject对象,然后又发送了一个MyResponseObject对象给Client端。

4. 最后就是让IoAcceptor类实例绑定端口实现监听。

看看Client端的代码

  1. package com.google.code.garbagecan.minastudy.sample3;  
  2.  
  3. import java.net.InetSocketAddress;  
  4.  
  5. import org.apache.mina.core.RuntimeIoException;  
  6. import org.apache.mina.core.future.ConnectFuture;  
  7. import org.apache.mina.core.service.IoConnector;  
  8. import org.apache.mina.core.service.IoHandlerAdapter;  
  9. import org.apache.mina.core.session.IdleStatus;  
  10. import org.apache.mina.core.session.IoSession;  
  11. import org.apache.mina.filter.codec.ProtocolCodecFilter;  
  12. import org.apache.mina.filter.codec.serialization.ObjectSerializationCodecFactory;  
  13. import org.apache.mina.filter.logging.LoggingFilter;  
  14. import org.apache.mina.transport.socket.nio.NioSocketConnector;  
  15. import org.slf4j.Logger;  
  16. import org.slf4j.LoggerFactory;  
  17.  
  18. public class MyClient {  
  19.       
  20.     private static final Logger logger = LoggerFactory.getLogger(MyClient.class);  
  21.       
  22.     public static void main(String[] args) {  
  23.         IoConnector connector = new NioSocketConnector();  
  24.         connector.setConnectTimeoutMillis(10 * 1000);  
  25.           
  26.         connector.getFilterChain().addLast("logger"new LoggingFilter());  
  27.         connector.getFilterChain().addLast("codec"new ProtocolCodecFilter(new ObjectSerializationCodecFactory()));  
  28.           
  29.         connector.setHandler(new IoHandlerAdapter() {  
  30.               
  31.             @Override 
  32.             public void sessionCreated(IoSession session) throws Exception {  
  33.             }  
  34.  
  35.             @Override 
  36.             public void sessionOpened(IoSession session) throws Exception {  
  37.                 MyRequestObject myObj = new MyRequestObject("my name""my value");  
  38.                 session.write(myObj);  
  39.             }  
  40.  
  41.             @Override 
  42.             public void sessionClosed(IoSession session) throws Exception {  
  43.             }  
  44.  
  45.             @Override 
  46.             public void sessionIdle(IoSession session, IdleStatus status) throws Exception {  
  47.             }  
  48.  
  49.             @Override 
  50.             public void exceptionCaught(IoSession session, Throwable cause) throws Exception {  
  51.                 logger.error(cause.getMessage(), cause);  
  52.                 session.close(true);  
  53.             }  
  54.  
  55.             @Override 
  56.             public void messageReceived(IoSession session, Object message) throws Exception {  
  57.                 MyResponseObject myResObj = (MyResponseObject) message;  
  58.                 logger.info("Received " + myResObj);  
  59.                 session.close(true);  
  60.             }  
  61.  
  62.             @Override 
  63.             public void messageSent(IoSession session, Object message) throws Exception {  
  64.                 logger.info("Sent " + message);  
  65.             }  
  66.         });  
  67.  
  68.         IoSession session = null;  
  69.         try {  
  70.             ConnectFuture future = connector.connect(new InetSocketAddress("localhost"10000));  
  71.             future.awaitUninterruptibly();  
  72.             session = future.getSession();  
  73.         } catch (RuntimeIoException e) {  
  74.             logger.error(e.getMessage(), e);  
  75.         }  
  76.  
  77.         session.getCloseFuture().awaitUninterruptibly();  
  78.         connector.dispose();  
  79.     }  

1. 首先创建I/O Service,这里使用的是NioSocketConnector类来创建了一个IoConnector实例,并设置连接超时为10秒。

2. 创建I/O Filter Chain,和服务器端同样设置了两个IoFilter,一个是LoggingFilter用来记录日志和打印事件消息,另一个是ProtocolCodecFilter实例用来编码数据,这里也使用了ObjectSerializationCodecFactory类来序列化或反序列化数据成java对象。

3. 创建I/O Handler,主要看一下sessionOpened方法,其中在会话建立事件中发送了MyRequestObject对象,然后在messageReceived方法中又接受了MyResponseObject对象。

4. 最后就是IoConnector实例类连接远端的Server。

下面测试一下上面的程序,首先运行MyServer类,然后运行MyClient类,就可以分别在各自的终端上看到事件日志以及发送/接收的对象了。

原文链接:http://blog.csdn.net/kongxx/article/details/7520599

【编辑推荐】

  1. Apache MINA实战之牛刀小试
  2. Java程序设计:图形与多媒体处理
  3. Java集合框架总结:TreeSet类的排序问题
  4. 详解Java类的生命周期
  5. Java理论与实践: Web层的状态复制

  推荐阅读

  Flex项目与SSH项目整合问题记录

开发项目重用是很重要的开发手段,正直开发一个SSH项目,其中有一功能可重用之前的整个Flex项目(通过BlazeDS与java端交互,所需服务和servlet等有spring和springMVC来管控)。其实Flex项目同其他项目整合原理很简单>>>详细阅读


本文标题:Apache MINA实战之对象传输

地址:http://www.17bianji.com/kaifa2/Java/390.html

关键词: 探索发现

乐购科技部分新闻及文章转载自互联网,供读者交流和学习,若有涉及作者版权等问题请及时与我们联系,以便更正、删除或按规定办理。感谢所有提供资讯的网站,欢迎各类媒体与乐购科技进行文章共享合作。

网友点评
自媒体专栏

评论

热度

精彩导读
栏目ID=71的表不存在(操作类型=0)