mina传输对象

接触java的Mina框架已经有很多时间了，在网上也读过了很多的相关文章，发现Mina框架的确是一个值得拿来好好研究的东西，前些日子写了一个山寨QQ项目，其中的通信部分用到了java中自带的InputStream，OutputStream，Writer，Reader等等，感觉其中的很大的一个问题就是难以将事务处理的逻辑层与解析层分离开来，造成整个项目看起来比较臃肿，繁琐，不够模块化，接触Mina后发现mina在这方面做的很是恰到好处。

看到文章标题，你或许会有一些疑惑：

1、Mina框架传递对象是怎么回事

2、Mina传递对象可以用来做什么

3、Mina传递对象是怎么进行的

4、Mina传递对象过程中会遇到什么问题呢

在用原来的java的InputStream，OutputStream，Writer，Reader等进行通信的时候我们会将信息编码转化成字节流等进行信息传递，InputStream，OutputStream是基于字节流的，而Writer，Reader是基于字符的，我们都知道进行通信的服务器和客户端是事先必须定好通信协议，如果我们将你好吗？定义为是一条消息，视频定义为一条视频请求，如果客户端将这条消息和请求发送给了服务器，服务器要想得到消息和请求的真正内容（在这里分别是“你好吗？”和“视频”）并进行处理和应答就必须进行信息的解析，就要一条一条的进行判断：1、如果是信息是……格式的就将其看做是一条消息；2、如果是……格式的就将其看作是一条请求；3、如果是其他形式就将其视为无效信息，不予处理。当然这不失为一种办法可以进行信息的提取，但是我们会发现在这个过程中信息的发送、接受、解析、处理、应答等都是一条一条的，很是零散，比较难以统一，没有实现消息定义和解析处理过程的分离，这样写好了一个程序，如果日后想要进行改正其中的一条信息格式，就要在整个项目中Ctrl+F了，比较繁琐，还容易出错。

这是我们会自然的想到要用一种东西将各个格式的信息进行分类统一起来并方便进行一些必要的信息处理，为符合这些特点，我们会想到类这个东东恰恰满足了这些性质，我们可以将信息的格式中的内容定义为类的属性，而对这些属性的处理就可以用类中的方法来予以解决，这样就对信息进行了很好的包装。

这种思想有了，那就是在通信的时候直接进行形式上的对象传递（实际上在通信的时候都是最终以字节流的方式进行传递的），那么我们就要找一种工具进行这种形式的信息传递，对了，这种工具就是Mina框架，我们只看他其中的一个方法

public void messageReceived(IoSession session, Object message)，这是进行消息接收是能够被 触发的一个方法，参数session代表当前的会话对象，参数message代表接收的到的信息，这时您会发现message的类型是Object型，而类 Object 是类层次结构的根类，当然可以用对象型的作为message啦！前面提到通信的时候都是最终以字节流的方式进行传递的，这样就要进行：对象（客户端）->字节流（客户端）->发送->接收->字节流（服务器）->对象（服务器）的过程，呵呵不用担心，这些繁琐的过程，Mina都提供了很好的底层默认实现所以你只需稍稍敲点代码就行了。

光说不练还是不行，先上一个程序实例：

服务器端（1）：

Java代码

  1. package Mina.server;
  2. import java.io.IOException;
  3. import java.net.InetSocketAddress;
  4. import org.apache.mina.core.filterchain.DefaultIoFilterChainBuilder;
  5. import org.apache.mina.filter.codec.ProtocolCodecFilter;
  6. import org.apache.mina.filter.codec.serialization.ObjectSerializationCodecFactory;
  7. import org.apache.mina.transport.socket.SocketAcceptor;
  8. import org.apache.mina.transport.socket.nio.NioSocketAcceptor;
  9. public class MainServer {
  10. private static MainServer mainServer = null;
  11. private SocketAcceptor acceptor = new NioSocketAcceptor();
  12. private DefaultIoFilterChainBuilder chain = acceptor.getFilterChain();
  13. private int bindPort = 8888;
  14. public static MainServer getInstances() {
  15. if (null == mainServer) {
  16. mainServer = new MainServer();
  17. }
  18. return mainServer;
  19. }
  20. private MainServer() {
  21. chain.addLast("myChin", new ProtocolCodecFilter(
  22. new ObjectSerializationCodecFactory()));
  23. acceptor.setHandler(ServerHandler.getInstances());
  24. try {
  25. acceptor.bind(new InetSocketAddress(bindPort));
  26. } catch (IOException e) {
  27. e.printStackTrace();
  28. }
  29. }
  30. public static void main(String[] args) throws Exception {
  31. MainServer.getInstances();
  32. }
  33. }

服务器端（2）：

Java代码  

  1. package Mina.server;
  2. import org.apache.mina.core.filterchain.IoFilterAdapter;
  3. import org.apache.mina.core.service.IoHandler;
  4. import org.apache.mina.core.session.IdleStatus;
  5. import org.apache.mina.core.session.IoSession;
  6. import Mina.Object.UserInfo;
  7. public class ServerHandler extends IoFilterAdapter implements IoHandler {
  8. private static ServerHandler samplMinaServerHandler = null;
  9. public static ServerHandler getInstances() {
  10. if (null == samplMinaServerHandler) {
  11. samplMinaServerHandler = new ServerHandler();
  12. }
  13. return samplMinaServerHandler;
  14. }
  15. private ServerHandler() {
  16. }
  17. // 当连接后打开时触发此方法，一般此方法与 sessionCreated 会被同时触发
  18. public void sessionOpened(IoSession session) throws Exception {
  19. }
  20. public void sessionClosed(IoSession session) {
  21. }
  22. public void messageReceived(IoSession session, Object message)
  23. throws Exception {
  24. if (message instanceof UserInfo) {
  25. UserInfo text = (UserInfo) message;
  26. System.out.println("服务器接收到从客户端的姓名："+text.getName());
  27. System.out.println("服务器接收到从客户端的QQ："+text.getQQNum());
  28. }
  29. }
  30. public void exceptionCaught(IoSession arg0, Throwable arg1)
  31. throws Exception {
  32. }
  33. // 当消息传送到客户端后触发
  34. public void messageSent(IoSession arg0, Object arg1) throws Exception {
  35. }
  36. // 当一个新客户端连接后触发此方法.
  37. public void sessionCreated(IoSession arg0) throws Exception {
  38. }
  39. // 当连接空闲时触发此方法.
  40. public void sessionIdle(IoSession arg0, IdleStatus arg1) throws Exception {
  41. }
  42. }

客户端（1）：

Java代码

  1. package Mina.client;
  2. import java.net.InetSocketAddress;
  3. import org.apache.mina.core.filterchain.DefaultIoFilterChainBuilder;
  4. import org.apache.mina.core.future.ConnectFuture;
  5. import org.apache.mina.filter.codec.ProtocolCodecFilter;
  6. import org.apache.mina.filter.codec.serialization.ObjectSerializationCodecFactory;
  7. import org.apache.mina.transport.socket.nio.NioSocketConnector;
  8. public class MainClient {
  9. private static MainClient mainClient = null;
  10. NioSocketConnector connector = new NioSocketConnector();
  11. DefaultIoFilterChainBuilder chain = connector.getFilterChain();
  12. public static MainClient getInstances() {
  13. if (null == mainClient) {
  14. mainClient = new MainClient();
  15. }
  16. return mainClient;
  17. }
  18. private MainClient() {
  19. chain.addLast("myChin", new ProtocolCodecFilter(
  20. new ObjectSerializationCodecFactory()));
  21. connector.setHandler(ClientHandler.getInstances());
  22. connector.setConnectTimeout(30);
  23. ConnectFuture cf = connector.connect(new InetSocketAddress("localhost",
  24. 8888));
  25. }
  26. public static void main(String args[]) {
  27. MainClient.getInstances();
  28. }
  29. }

客户端（2）：

Java代码  

  1. package Mina.client;
  2. import org.apache.mina.core.service.IoHandlerAdapter;
  3. import org.apache.mina.core.session.IoSession;
  4. import Mina.Object.UserInfo;
  5. public class ClientHandler extends IoHandlerAdapter {
  6. private static ClientHandler samplMinaClientHandler = null;
  7. public static ClientHandler getInstances() {
  8. if (null == samplMinaClientHandler) {
  9. samplMinaClientHandler = new ClientHandler();
  10. }
  11. return samplMinaClientHandler;
  12. }
  13. private ClientHandler() {
  14. }
  15. public void sessionOpened(IoSession session) throws Exception {
  16. session.write("客户端与服务器的会话打开了……");
  17. UserInfo text=new UserInfo();
  18. text.setName("梅竹寒香");
  19. text.setQQNum("972341215");
  20. session.write(text);
  21. }
  22. public void sessionClosed(IoSession session) {
  23. }
  24. public void messageReceived(IoSession session, Object message)
  25. throws Exception {
  26. }
  27. public void messageSent(IoSession arg0, Object arg1) throws Exception {
  28. System.out.println("客户端已经向服务器发送了："+(String)arg1);
  29. }
  30. }

公共类：

Java代码  

  1. package Mina.Object;
  2. public class UserInfo implements java.io.Serializable{
  3. private String name;
  4. private String QQNum;
  5. public String getName() {
  6. return name;
  7. }
  8. public void setName(String name) {
  9. this.name = name;
  10. }
  11. public String getQQNum() {
  12. return QQNum;
  13. }
  14. public void setQQNum(String qQNum) {
  15. QQNum = qQNum;
  16. }
  17. }

如下建包即可：

以上就是对象的收发的简单示例，如果报错，或许会是一下原因：1、包的引进是否妥当 2、是否引入了mina的第三方包（网上有了很多的相关文章，在此就不在赘述了）

通过程序您会看到对象已经成功传递并进行了相关属性的输出，对于这个简单的程序我稍做些相关说明：

1、进行传递的对象所实例化的类要实现java.io.Serializable序列化接口

2、您会发现实例中的类尤其是相关的IoHandlerAdapter继承类都采用了单实例模式，为什么这样做呢，原因很简单，那就是要在整个通信过程中做到对象session的等实例的单一防止发生“所托非人”的现象

3、服务器接收到message在进行类判断时用了instanceof关键字

如果你看到上面的实例就觉得对象传递的学习已经成功了，那就错了，细心的博友看到这个包结构：

是不是有点问题呢。

例如客户端传了一个userinfo对象到服务器，在服务器端判断如果是userinfo对象后就打印出相关信息，我看源码文档其中有这样的建包方式

其中服务器和客户端共用了中间的Mina.Object包，这样在收到对象后就能通过instanceof关键字判断是不是useinfo对象，我看了一下，这个方法是可行的，现在的问题是，我们如果编写通讯软件的时候，肯定是服务器和客户端是要分开的，所以那个Mina.Object包是不能共享的，所以问题来了（1）、如果将userinfo放到客户端中，那么该怎么用instanceof进行判断是不是userinfo呢（这时你已经不能再引入服务器中的userinfo了）（2）、如果在客户端和服务器中都编写一个类定义一样的userinfo，可是他们这两个类是分属不同的包，所以是两个不同的类了，这样在用instanceof进行判断的时候也是行不通的；那么我们该用什么方法来进行判断接收到的类是不是userinfo对象呢？

这个问题把我纠结了很久，在网上面搜了好久也没有解决，最后想了想那个（2）或许可以改动改动就可以解决，问题的关键在于两个UserInfo分属于两个不同的包，如果可以将包名一致就好了，但是在一个工程里面不能同时建立两个命名一样的包，这样你就会发现何不建立两个工程呢一个是服务器，一个是客户端，这样都可以分别建立名字都是Object的包，这样可不可行呢，经过试验果然可以，这样就就解决了上面的问题工程图如下

好啦，有了这个工具，您会有什么想法呢？对象传递还可以做什么？那就是可以用它来进行图片，文件的传递啦，这个只是个小小的提示具体怎么实现，就要看各位博友怎么发挥啦！

时间： 2024-11-15 08:44:37

mina传输对象的相关文章

Mina使用总结(四)传输对象ObjectSerializationCodecFactory

用mina框架传输对象,对于开发者来说,直接传输对象,而不用自己编写相应的报文转换代码,将大大节省 开发时间. 即使用对象编码解码器 使用ObjectSerializationCodecFactory 服务端 MinaServer.java代码如下 package com.bypay.mina.server; import java.io.IOException; import java.net.InetSocketAddress; import java.net.SocketAddress;

巧用Android网络通信技术，在网络上直接传输对象

本文首发于CSDN博客,转载请注明出处:http://blog.csdn.net/guolin_blog/article/details/8967080 要做一个优秀的Android应用,使用到网络通信技术是必不可少的,很难想象一款没有网络交互的软件最终能发展得多成功.那么我们来看一下,一般Android应用程序里都是怎么实现网络交互的,这里拿一个Boook对象为例: 如上图所示,首先在手机端生成一个Book对象,里面包含书名.作者.价格等数据.为了要将这些数据发送到服务器端,我们要从Book对

Netty 4 传输对象

对于Netty在这里就不做过多介绍了,详情咨询http://netty.io/wiki/user-guide-for-4.x.html 我们在使用netty的过程中肯定会遇到传输对象的情况,Netty4通过ObjectEncoder和ObjectDecoder来支持. 首先我们定义一个User对象,一定要实现Serializable接口: import java.io.Serializable; /** * User: hupeng * Date: 14-6-3 * Time: 上午1:31 *

Netty JDK序列化编解码传输对象

JDK序列化不需要额外的类库,只需要实现Serializable即可,但是序列化之后的码流只有Java才能反序列化,所以它不是跨语言的,另外由于Java序列化后码流比较大,效率也不高,所以在RPC中很少使用,本文只是做学习之用. 编解码器: public class JdkDecoder extends MessageToMessageDecoder<ByteBuf> { @Override protected void decode(ChannelHandlerContext channel

dubbo中的那些“坑”(1) - 关于MINA传输协议的bug定位及修复

同事刘阳使用dubbo服务器中配置mina作为网络传输层,发现大并发情况下,解码发生如下异常 014-12-01 18:00:44,652 [DubboServerHandler-10.1.19.13:20880-thread-164] WARN  alibaba.dubbo.remoting.exchange.codec.ExchangeCodec (ExchangeCodec.java:596) -  [DUBBO] Fail to encode response: Response [id

Mina传递对象

利用Apache MINA来传递对象,这对了MINA来说非常容易,并且这也是Java网络编程中很常用的应用. 首先看两个用来传递的Java对象MyRequestObject和MyResponseObject,很简单只是实现了Serializable接口罢了. MyRequestObject.java package demo5.vo; import java.io.Serializable; public class MyRequestObject implements Serializable

使用Socket传输对象

在使用QT网络通信时一直是简单的发送数据--接收数据,常见的就是发送一个字符串/字节流,然后根据这个字符串/字节流提取出有用的信息. 这样在不是很复杂的通信中可以满足实际需要.但也有弊端,就是每次写网络通信时都是口头约定一个协议,让发送方与接收方都满足这个协议才可以进行正常通信. 这样如果我每次写这样的程序,我都要首先规定好一个的通讯协议,然后再编写相应的代码. 那么如何传输更复杂的数据呢,而且可以不用上述的口头协议? 在JAVA,C#中都有对对象序列化的概念,QT里也有,利用将对象序列化传输可

Netty4 服务器 客户端 传输对象

关键词:netty4  对象  序列化 废话少说,直接上代码了 Client.java ? 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 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 import io.netty.bootstrap.Bootstrap;

socket传输对象

server public class Server{ private static int port = 8888; private static ServerSocket serverSocket; private static Socket socket; public static void main(String args[]) throws IOException { serverSocket = new ServerSocket(port, 2); socket = serverS