`
joe_zhjiang
  • 浏览: 158390 次
  • 性别: Icon_minigender_1
  • 来自: 上海
社区版块
存档分类
最新评论

Mina NIO Socket

    博客分类：
  • mina
MinaSocketApachelog4j多线程 
阅读更多
Mina NIO Socket个人总结，其中包括重连机制，自定义解码器，需要加入的jar包log4j.jar,mina-core-2.0.1.jar,slf4j-api-1.4.2.jar,slf4j-log4j12-1.4.2.jar,也希望给接触者一些帮助。解码器感觉有点麻烦，各位指教。我的解码器"]"为一条消息的结束标记。后面附源码，如有更好方法请留言。
Server 

package com.joe.server;

import java.net.InetSocketAddress;

import org.apache.mina.filter.codec.ProtocolCodecFilter;
import org.apache.mina.filter.codec.demux.DemuxingProtocolCodecFactory;
import org.apache.mina.filter.executor.ExecutorFilter;
import org.apache.mina.filter.executor.OrderedThreadPoolExecutor;
import org.apache.mina.filter.logging.LoggingFilter;
import org.apache.mina.transport.socket.nio.NioSocketAcceptor;

import com.joe.codec.decoder.MyMessageDecoder;
import com.joe.codec.encoder.MyMessageEncoder;
import com.joe.handler.ServerIoHandler;

/**
 * @author joe
 */
public class MyServer {
    private NioSocketAcceptor   acceptor;
    /**
     * Constructor
     */
    public MyServer() {
        try {
            acceptor = new NioSocketAcceptor();
            acceptor.getFilterChain().addLast("threadPool",
                    new ExecutorFilter(new OrderedThreadPoolExecutor()));// 设置线程池，以支持多线程
            acceptor.getFilterChain().addLast("logger", new LoggingFilter());
            /**
             * 默认编码器,解码器,遇到\n默认消息结束
             * 当然可以加参数指定解码字符，但解码字符会被截掉
             * 例如:new TextLineCodecFactory(Charset.forName("UTF-8"),"]","]");
             * 则会认为"]"为一条消息结束，遇到"]"则截取
             * 比如服务器给你发送的消息是aaaa]aaaa]
             * 会收到两条消息：
             * 1、aaaa
             * 2、aaaa
             * 后面的"]"则去掉了
             */
//            acceptor.getFilterChain().addLast(
//                    "codec",
//                    new ProtocolCodecFilter(new TextLineCodecFactory(Charset
//                            .forName("UTF-8"))));// 指定编码过滤器
            DemuxingProtocolCodecFactory pcf = new DemuxingProtocolCodecFactory();
            //自定义编码器
            pcf.addMessageEncoder(String.class, new MyMessageEncoder());
            //自定义解码器
            pcf.addMessageDecoder(new MyMessageDecoder());
            ProtocolCodecFilter codec = new ProtocolCodecFilter(pcf);
            acceptor.getFilterChain().addLast("codec",codec);// 指定编码过滤器
            
            acceptor.setReuseAddress(true);
            acceptor.setHandler(new ServerIoHandler());// 指定业务逻辑处理器
            acceptor.setDefaultLocalAddress(new InetSocketAddress(8888));// 设置端口号
            acceptor.bind();// 启动监听
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    
    /**
     * @param args
     */
    public static void main(String[] args) {
        new MyServer();
    }
}


Server IoHandler 

package com.joe.handler;

import org.apache.mina.core.service.IoHandler;
import org.apache.mina.core.session.IdleStatus;
import org.apache.mina.core.session.IoSession;

public class ServerIoHandler implements IoHandler {

    public void exceptionCaught(IoSession session, Throwable pArg1)
            throws Exception {
        
    }

    public void messageReceived(IoSession session, Object obj) throws Exception {
        //收到的信息
        System.out.println(obj.toString());
    }

    public void messageSent(IoSession session, Object pArg1) throws Exception {
        
    }

    public void sessionClosed(IoSession session) throws Exception {
        
    }

    public void sessionCreated(IoSession session) throws Exception {
        
    }

    public void sessionIdle(IoSession session, IdleStatus pArg1) throws Exception {
        
    }

    public void sessionOpened(IoSession session) throws Exception {
        session.write("[Server: Client,I'm server.][Server: Client,I'm server.]");
    }

}


client 

package com.joe.client;

import java.net.InetSocketAddress;
import java.nio.charset.Charset;
import java.util.Date;
import java.util.Timer;
import java.util.TimerTask;

import org.apache.mina.core.filterchain.DefaultIoFilterChainBuilder;
import org.apache.mina.core.future.ConnectFuture;
import org.apache.mina.filter.codec.ProtocolCodecFilter;
import org.apache.mina.filter.codec.demux.DemuxingProtocolCodecFactory;
import org.apache.mina.filter.codec.textline.TextLineCodecFactory;
import org.apache.mina.filter.logging.LoggingFilter;
import org.apache.mina.transport.socket.nio.NioSocketConnector;

import com.joe.codec.decoder.MyMessageDecoder;
import com.joe.codec.encoder.MyMessageEncoder;
import com.joe.handler.ClientIoHandler;

/**
 * @author joe
 */
public class MyClient {
    private NioSocketConnector  connector;
    /**
     * Constructor
     */
    public MyClient() {
        connector = new NioSocketConnector();
        /**
         * 设置信息交换的IoHandler,负责接收和发送信息的处理
         */
        connector.setHandler(new ClientIoHandler());
        //配置过滤器
        DefaultIoFilterChainBuilder chain = connector.getFilterChain();
        //增加日志过滤器
        chain.addLast("logger", new LoggingFilter());
        //增加字符编码过滤器以及设置编码器和解码器
        //chain.addLast("codec", new ProtocolCodecFilter(new TextLineCodecFactory(Charset.forName("UTF-8"))));
        /**
         * 默认编码器,解码器,遇到\n默认消息结束
         * 当然可以加参数指定解码字符，但解码字符会被截掉
         * 例如:new TextLineCodecFactory(Charset.forName("UTF-8"),"]","]");
         * 则会认为"]"为一条消息结束，遇到"]"则截取
         * 比如服务器给你发送的消息是aaaa]aaaa]
         * 会收到两条消息：
         * 1、aaaa
         * 2、aaaa
         * 后面的"]"则去掉了
         */
//        acceptor.getFilterChain().addLast(
//                "codec",
//                new ProtocolCodecFilter(new TextLineCodecFactory(Charset
//                        .forName("UTF-8"))));// 指定编码过滤器
        DemuxingProtocolCodecFactory pcf = new DemuxingProtocolCodecFactory();
        //自定义编码器
        pcf.addMessageEncoder(String.class, new MyMessageEncoder());
        //自定义解码器
        pcf.addMessageDecoder(new MyMessageDecoder());
        ProtocolCodecFilter codec = new ProtocolCodecFilter(pcf);
        chain.addLast("codec",codec);// 指定编码过滤器
        //设置默认连接的地址和端口
        connector.setDefaultRemoteAddress(new InetSocketAddress("localhost", 8888));
        /**
         * 重连机制
         * 如果没有连接，则过30 * 1000毫秒客户端会尝试重新连接服务器
         * 如果连接，则下面的代码不会执行
         */
        new Timer().schedule(new TimerTask() {
            @Override
            public void run() {
                if (null != connector && !connector.isActive()) {
                    try {
                        //尝试连接默认的地址和端口
                        ConnectFuture connFuture = connector.connect();
                        connFuture.awaitUninterruptibly();
                    } catch (Exception e) {
                        // TODO: handle exception
                        e.printStackTrace();
                    }
                }
            }
        }, new Date(), 30 * 1000);
    }
    /**
     * @param args
     */
    public static void main(String[] args) {
        new MyClient();
    }

}


Client IoHandler 

package com.joe.handler;

import org.apache.mina.core.service.IoHandler;
import org.apache.mina.core.session.IdleStatus;
import org.apache.mina.core.session.IoSession;

public class ClientIoHandler implements IoHandler {

    public void exceptionCaught(IoSession session, Throwable throwable)
            throws Exception {
        
    }

    public void messageReceived(IoSession session, Object obj) throws Exception {
        //收到的内容
        System.out.println(obj.toString());
    }

    public void messageSent(IoSession session, Object obj) throws Exception {
        
    }

    public void sessionClosed(IoSession session) throws Exception {
        
    }

    public void sessionCreated(IoSession session) throws Exception {
        
    }

    public void sessionIdle(IoSession session, IdleStatus status) throws Exception {
        
    }

    public void sessionOpened(IoSession session) throws Exception {
        session.write("[Client: Server,I'm client.][Client: Server,I'm client.]");
    }

}


自定义编码器(MessageEncoder) 

package com.joe.codec.encoder;

import org.apache.mina.core.buffer.IoBuffer;
import org.apache.mina.core.session.IoSession;
import org.apache.mina.filter.codec.ProtocolEncoderOutput;
import org.apache.mina.filter.codec.demux.MessageEncoder;

/**
 * @author joe
 * @param <T>
 */
public class MyMessageEncoder implements MessageEncoder<String> {

    /**
     * 编码器未做任何处理
     * @param session 
     * @param msg 
     * @param out 
     * @throws Exception 
     */
    public void encode(IoSession session, String msg,
            ProtocolEncoderOutput out) throws Exception {
        IoBuffer buf = IoBuffer.allocate(msg.getBytes().length);
        buf.put(msg.getBytes());
        buf.flip();
        out.write(buf);
    }

}


自定义解码器(MessageDecoder) 

package com.joe.codec.decoder;

import org.apache.mina.core.buffer.IoBuffer;
import org.apache.mina.core.session.IoSession;
import org.apache.mina.filter.codec.ProtocolDecoderOutput;
import org.apache.mina.filter.codec.demux.MessageDecoder;
import org.apache.mina.filter.codec.demux.MessageDecoderResult;

/**
 * @author joe
 */
public class MyMessageDecoder implements MessageDecoder {
    //消息的开始
    private int flag = 0;
    //消息的长度
    private int length = 0;
    //消息的结尾
    private int flaglast = 0;
    //不是第一条消息
    private boolean notfirstmessage = false;
    
    public MessageDecoderResult decodable(IoSession session, IoBuffer in) {
        int rem = in.remaining();
        int fornumber;
        byte aa;
        if (notfirstmessage) {
            flag++;
            fornumber = rem + flag;
        } else {
            flag = 0;
            fornumber = rem + flag;
        }
        try {
            for (int i = flag; i < fornumber; i++) {
                aa = in.get(i);
                if (']' == aa) {
                    flaglast = flag;
                    flag = i;
                    length = flag - flaglast;
                    notfirstmessage = true;
                    return MessageDecoderResult.OK;
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        notfirstmessage = false;
        return MessageDecoderResult.NEED_DATA;
    }

    public MessageDecoderResult decode(IoSession session, IoBuffer in,
            ProtocolDecoderOutput out) throws Exception {
        try {
            if (length == 0 || length == 1) {
                in.get();
                out.write("");
                return MessageDecoderResult.OK;
            }
            length++;
            byte[] result = new byte[length];
            for (int i = 0; i < length; i++) {
                result[i] = in.get();
            }
            if (0 == in.remaining()) {
                notfirstmessage = false;
            }
            String cont = new String(result, "us-ascii");
            out.write(cont.trim());
            return MessageDecoderResult.OK;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return MessageDecoderResult.OK;
    }

    public void finishDecode(IoSession session, ProtocolDecoderOutput out)
            throws Exception {
    }

}
分享到：
| spring quartz
评论
4 楼 webking168 2013-06-15  
你好，我刚接触mina,谢谢你的分享。
有个问题请教一下：下面这两句分别放到代码里的哪个位置？
joe_zhjiang 写道
补充：心跳信息 
       //session空闲60秒给服务器发空闲的信息，即心跳信息
        connector.getSessionConfig().setIdleTime(IdleStatus.BOTH_IDLE, 60);

具体发送心跳信息的地方在IoHanlder的sessionIdle方法中 
       if(pStatus.equals(IdleStatus.BOTH_IDLE)){
	    pSession.write("心跳消息");
       }


3 楼 joe_zhjiang 2011-09-14  
bluky999 写道
写MINA主要的确实是解码器，呵

你的消息分割符']' 不是很理想，如果消息体中出现这个字符呢？不是就BUG了嘛

常用的消息报文设计有以下三种：
1 定长消息体： 比如一条消息就定义1024长，就算消息内容不够，也要多传空字节；
2 定界消息体： 类似你的做法，用一个特殊符号来标记起始或者结束，这种情况一般用不可见的字符，比如0x6a啊之类的；
3 定长消息头： 消息报文由消息头+消息体两部分组成，头部固定长度，里面包含了消息体的长度 。

不过也有冗余或混合设计的，比如 定长消息头+定界消息体 ，也很常见，只要方便处理即可。

谢谢，我只不过是根据我项目内的需求来写的，当然会有缺陷。
2 楼 bluky999 2011-09-09  
写MINA主要的确实是解码器，呵

你的消息分割符']' 不是很理想，如果消息体中出现这个字符呢？不是就BUG了嘛

常用的消息报文设计有以下三种：
1 定长消息体： 比如一条消息就定义1024长，就算消息内容不够，也要多传空字节；
2 定界消息体： 类似你的做法，用一个特殊符号来标记起始或者结束，这种情况一般用不可见的字符，比如0x6a啊之类的；
3 定长消息头： 消息报文由消息头+消息体两部分组成，头部固定长度，里面包含了消息体的长度 。

不过也有冗余或混合设计的，比如 定长消息头+定界消息体 ，也很常见，只要方便处理即可。
1 楼 joe_zhjiang 2010-11-08  
补充：心跳信息 
       //session空闲60秒给服务器发空闲的信息，即心跳信息
        connector.getSessionConfig().setIdleTime(IdleStatus.BOTH_IDLE, 60);

具体发送心跳信息的地方在IoHanlder的sessionIdle方法中 
       if(pStatus.equals(IdleStatus.BOTH_IDLE)){
	    pSession.write("心跳消息");
       }

发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    一般Socket客户端与Mina NIO Socket客户端对比示例

    本文将通过一个对比实例，探讨一般Socket客户端与Mina NIO (Non-blocking I/O) Socket客户端的差异和特点，帮助开发者理解这两种技术在实际应用中的选择。 首先，普通Socket客户端基于BIO（Blocking I/O）模型，它...

    apache mina socket实例

    mina简单示例，Apache Mina Server 是一个网络通信应用框架，也就是说，它主要是对基于TCP/IP、UDP/IP协议栈的通信...Mina 提供了事件驱动、异步（Mina 的异步IO 默认使用的是JAVA NIO 作为底层支持）操作的编程模型。

    Mina+Socket通信

    import org.apache.mina.transport.socket.nio.NioSocketAcceptor; public class MinaServer { public static void main(String[] args) throws Exception { IoAcceptor acceptor = new NioSocketAcceptor(); ...

    基于 MINA 的 TLS/SSL NIO Socket 实现（二）

    在本篇博文中，我们将深入探讨如何利用Apache MINA库实现基于TLS/SSL的NIO（非阻塞I/O）Socket通信。MINA是一个高度可扩展的网络应用框架，广泛用于构建高性能、高并发的网络应用程序，如服务器端的TCP和UDP服务。...

    Android-MinaSocket一款基于Mina的Socket长连接库

    1. **非阻塞I/O**：Mina采用NIO（Non-blocking I/O）模式，提高了并发性能，使得单个线程可以处理多个连接，减少了线程上下文切换的开销。 2. **事件驱动**：Mina使用事件驱动模型，当数据到达或发送时，会触发相应...

    mina 服务器socket客服端发消息

    本文将深入探讨如何使用Mina来实现一个服务器以及对应的Socket客户端，从而进行消息传递。 **Mina 框架介绍** Mina提供了一个高级抽象层，允许开发者用类似处理Java IO的方式处理NIO（非阻塞I/O）。它简化了网络...

    网络编程(socket、NIO、mina)---demo

    在这个"网络编程(socket、NIO、mina)---demo"的主题中，我们将深入探讨三个关键概念：Socket编程、非阻塞I/O（Non-blocking I/O，简称NIO）以及Apache Mina框架。这些技术广泛应用于构建高性能、高并发的网络应用...

    Ioserver java Nio socket 框架

    Ioserver java Nio socket 框架 是个不错的NIO 通讯框架，本来想学习mina框架，看了看mina的源码太头痛，本人觉得看懂了Ioserver 再看mina的框架，想多的学习 java NIO 的也可以下载 看看，很值得学习啊！！！

    niosocket及其开源框架MINA学习总结收集.pdf

    相比于传统的阻塞式socket，NIO降低了系统资源的消耗，MINA则进一步简化了NIO的使用，使得开发者能更专注于应用的业务逻辑。对于需要处理大量并发连接的网络应用，如聊天服务器、游戏服务器等，NIO 和 MINA 是理想的...

    Java springboot 整合mina 框架，nio通讯基础教程，mina框架基础教程.zip

    Java SpringBoot 整合Mina框架，涉及到的核心技术主要包括Java NIO（非阻塞I/O）、Mina框架以及SpringBoot的集成应用。本教程旨在帮助开发者深入理解和掌握这些技术，并提供了一个可直接使用的基础平台框架。 Java ...

    原创nio socket mina+javascript+flash实现commet长连接网页聊天室

    【标题】"原创nio socket mina+javascript+flash实现commet长连接网页聊天室"揭示了一个基于Java NIO（Non-blocking I/O）的Socket通信框架Mina与JavaScript、Flash技术结合，实现COMET（Comet是使服务器向浏览器推...

    MINA NIO 高性能异步并发网络通讯框架

    Sun NIO 要高出约 10%）。由于这一系列的重大改进，使得 2.0.x 成为十分令人期待的一个版本 我们在惊叹 MINA 可以带来多么大便利的同时，还不得不为其卓越的性能而骄傲，据称使用MINA开发服务器程序的性能已经...

    mina 包 socket 框架

    在本文中，我们将深入探讨Mina包如何作为Socket框架来使用，以及它在实际开发中的优势。 首先，Mina的核心是它的事件驱动模型，这允许它在多线程环境中高效处理并发连接。通过使用I/O多路复用技术如Java的Selector...

    apache mina socket

    在本文中，我们将深入探讨Apache Mina的核心概念、设计模式以及如何使用它来实现基于Socket的通信。 **Apache Mina的核心概念：** 1. **Event-Driven模型**：Mina采用了事件驱动模型，当网络事件（如数据接收、...

    mina框架中socket使用，有服务端和客户端。

    mina框架是Apache组织开发的一个网络通信框架，它基于Java NIO（非阻塞I/O）构建，用于简化网络编程，尤其是TCP和UDP协议的应用开发。本项目提供了服务端和客户端的示例，使得开发者能够更好地理解和应用MINA框架。 ...

    socket通信，mina长连接通信

    1. **MINA架构**：MINA基于NIO（非阻塞I/O），利用Selector进行多路复用，可以在单个线程中处理多个连接，提高系统效率。 2. **长连接**：与传统的Socket短连接不同，长连接保持在客户端和服务器之间长时间打开，...

    基于MINA构建简单高性能的NIO应用

    为了解决这一问题，可以采用Java NIO模型，并结合MINA框架来简化开发和提升性能。 MINA（Multipurpose Infrastructure for Network Applications）是一个开源的网络应用框架，为开发高性能、高可靠性的网络应用程序...

    socket mina测试框架

    - Mina采用NIO（Non-blocking I/O）模型，通过选择器（Selector）监控多个通道（Channel），当有读写事件发生时，选择器会通知相应的处理器，避免了线程阻塞，提高了系统资源利用率和整体性能。 2. **API设计**： ...

Magicbox
Global site tag (gtag.js) - Google Analytics