精华内容
下载资源
问答
  • Mina

    2019-08-07 18:31:12
    1)MINA概念 一个简易用的基于TCP/IP通信的java框架 2)一个简单的网络程序需要的最少jar包 3)开发一个Mina应用过程 创建连接,设定过滤规则,编写自己的消息处理器 4)MINA实例 package ...

    1)MINA概念

             一个简易用的基于TCP/IP通信的java框架

    2)一个简单的网络程序需要的最少jar包

                          

                           

    3)开发一个Mina应用过程

                     创建连接,设定过滤规则,编写自己的消息处理器

    4)MINA实例

    package com.vince.mina;
    import org.apache.mina.core.filterchain.DefaultIoFilterChainBuilder;
    import org.apache.mina.filter.codec.ProtocolCodecFilter;
    import org.apache.mina.filter.codec.textline.TextLineCodecFactory;
    import org.apache.mina.transport.socket.SocketAcceptor;
    import org.apache.mina.transport.socket.nio.NioSocketAcceptor;
    import java.io.IOException;
    import java.net.InetSocketAddress;
    
    public class Server {
        public static void main(String[] args) {
            //创建一个非阻塞的server端socket 用NIO
            SocketAcceptor acceptor = new NioSocketAcceptor();//创建接收数据的过滤器
            DefaultIoFilterChainBuilder chain = acceptor.getFilterChain();
    
            //设定这个过滤器,将一行一行(/r/n)的读取数据
           chain.addLast("myChin",new ProtocolCodecFilter(new TextLineCodecFactory()));
    
            //设定服务器端的信息处理器
            acceptor.setHandler(new MinaServerHandler());
            //服务器端的端口号
            int port = 9999;
            try {
                //绑定端口,启动服务器(不会阻塞,立即返回)
                acceptor.bind(new InetSocketAddress(port));
            } catch (IOException e) {
                e.printStackTrace();
            }
            System.out.println("Mina Server running,listenter on:" + port);
        }
    }
    

    package com.vince.mina;
    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.textline.TextLineCodecFactory;
    import org.apache.mina.transport.socket.nio.NioSocketConnector;
    import java.net.InetSocketAddress;
    import java.util.Scanner;
    
    public class Client {
        public static void main(String[] args) {
           //创建连接
            NioSocketConnector connector = new NioSocketConnector();
            DefaultIoFilterChainBuilder chain = connector.getFilterChain();
    
            //设定这个过滤器,将一行一行(/r/n)的读取数据
           chain.addLast("myChin",new ProtocolCodecFilter(new TextLineCodecFactory()));
    
           //设定客户端的信息处理器
            connector.setHandler(new MinaClientHandler());
            connector.setConnectTimeoutMillis(10000);
    
           //连接服务器
            ConnectFuture cf = connector.connect(new InetSocketAddress("localhost", 9999));
    
            //等待连接成功
            cf.awaitUninterruptibly();
            Scanner input = new Scanner(System.in);
    
            while (true){
                System.out.println("请输入:");
                String info = input.nextLine();
    
                //发送消息
                cf.getSession().write(info);
             }
        }
    }
    

    package com.vince.mina;
    import org.apache.mina.core.service.IoHandlerAdapter;
    import org.apache.mina.core.session.IoSession;
    
    /**
     * 服务器端的消息处理器
     */
    
    public class MinaServerHandler extends IoHandlerAdapter {
        //一次会话被打开
        @Override
        public void sessionOpened(IoSession session) throws Exception {
            super.sessionOpened(session);
            System.out.println("welcome client" + session.getRemoteAddress());
        }
       //会话关闭
        @Override
        public void sessionClosed(IoSession session) throws Exception {
            super.sessionClosed(session);
            System.out.println("client closed");
        }
       //接收消息
        @Override
        public void messageReceived(IoSession session, Object message) throws Exception {
            super.messageReceived(session, message);
            //接收到的消息对象
            String msg = (String) message;
            System.out.println("收到客户端发来的消息:" + msg);
    
           //向客户端发送消息对象
            session.write(msg);
        }
    }
    

    package com.vince.mina;
    import org.apache.mina.core.service.IoHandlerAdapter;
    import org.apache.mina.core.session.IoSession;
    
    public class MinaClientHandler extends IoHandlerAdapter {
        //当一个客户端连接进入时
        @Override
        public void sessionOpened(IoSession session) throws Exception {
            super.sessionOpened(session);
            System.out.println("sessionOpened:" + session.getRemoteAddress());
            //向服务端发送消息对象
            session.write("我来了......");
        }
      //当一个客户端关闭时
        @Override
        public void sessionClosed(IoSession session) throws Exception {
            super.sessionClosed(session);
            System.out.println("sessionClosed");
        }
       //当客户端发送的消息到达时
        @Override
        public void messageReceived(IoSession session, Object message) throws Exception {
            super.messageReceived(session, message);
            //我们已经设定了服务器解析消息的规则是一行一行读取,这里就可以转为String
              String msg = (String) message;
            System.out.println("服务器发来的收到消息:" + msg);
         }
    }
    

           

           

    5)使用Mina直接传输对象

    package com.vince.mina;
    import java.io.Serializable;
    
    /**
     * 使用Mina直接传输对象
     */
    public class Message implements Serializable {
        private String from;//发送者
        private String to;//接收者
        private String type;//信息类型
        private String info;//消息
    
        public String getFrom() {
            return from;
        }
    
        public void setFrom(String from) {
            this.from = from;
        }
    
        public String getTo() {
            return to;
        }
    
        public void setTo(String to) {
            this.to = to;
        }
    
        public String getType() {
            return type;
        }
    
        public void setType(String type) {
            this.type = type;
        }
    
        public String getInfo() {
            return info;
        }
    
        public void setInfo(String info) {
            this.info = info;
        }
    
        public Message(String from, String to, String type, String info) {
            this.from = from;
            this.to = to;
            this.type = type;
            this.info = info;
        }
    
        public Message() {
        }
    
        @Override
        public String toString() {
            return "Message{" +
                    "from='" + from + '\'' +
                    ", to='" + to + '\'' +
                    ", type='" + type + '\'' +
                    ", info='" + info + '\'' +
                    '}';
        }
    }
    

    package com.vince.mina;
    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.serialization.ObjectSerializationCodecFactory;
    import org.apache.mina.transport.socket.nio.NioSocketConnector;
    import java.net.InetSocketAddress;
    import java.util.Scanner;
    
    public class Client {
        public static void main(String[] args) {
           //创建连接
            NioSocketConnector connector = new NioSocketConnector();
            DefaultIoFilterChainBuilder chain = connector.getFilterChain();
    
            //设置过滤器以对象为单位读取数据
            chain.addLast("objectFilter",new ProtocolCodecFilter(new ObjectSerializationCodecFactory()));
    
            //设定客户端的信息处理器
            connector.setHandler(new MinaClientHandler());
            connector.setConnectTimeoutMillis(10000);
          //连接服务器
            ConnectFuture cf = connector.connect(new InetSocketAddress("localhost", 9999));
            //等待连接成功
            cf.awaitUninterruptibly();
            Scanner input = new Scanner(System.in);
    
            while (true){
               //以对象的方式传输数据
                Message msg = new Message();
                System.out.println("from:");
                msg.setFrom(input.nextLine());
                System.out.println("to:");
                msg.setTo(input.nextLine());
                System.out.println("info:");
                msg.setInfo(input.nextLine());
                msg.setType("send");
    
                cf.getSession().write(msg);
            }
        }
    }
    

    package com.vince.mina;
    import org.apache.mina.core.service.IoHandlerAdapter;
    import org.apache.mina.core.session.IoSession;
    
    public class MinaClientHandler extends IoHandlerAdapter {
        //当一个客户端连接进入时
        @Override
        public void sessionOpened(IoSession session) throws Exception {
            super.sessionOpened(session);
            System.out.println("sessionOpened:" + session.getRemoteAddress());
            //向服务端发送消息对象
            session.write("我来了......");
        }
    
      //当一个客户端关闭时
        @Override
        public void sessionClosed(IoSession session) throws Exception {
            super.sessionClosed(session);
            System.out.println("sessionClosed");
        }
    
       //当客户端发送的消息到达时
        @Override
        public void messageReceived(IoSession session, Object message) throws Exception {
            super.messageReceived(session, message);
            
            //我们已经收到服务器解析信息的规则,一个Message对象为单位传输
              Message msg =(Message) message;
             System.out.println("服务器发来的收到消息:" + msg);
        }
    }
    

    package com.vince.mina;
    import org.apache.mina.core.filterchain.DefaultIoFilterChainBuilder;
    import org.apache.mina.filter.codec.ProtocolCodecFilter;
    import org.apache.mina.filter.codec.serialization.ObjectSerializationCodecFactory;
    import org.apache.mina.transport.socket.SocketAcceptor;
    import org.apache.mina.transport.socket.nio.NioSocketAcceptor;
    import java.io.IOException;
    import java.net.InetSocketAddress;
    
    public class Server {
        public static void main(String[] args) {
            //创建一个非阻塞的server端socket 用NIO
            SocketAcceptor acceptor = new NioSocketAcceptor();//创建接收数据的过滤器
            DefaultIoFilterChainBuilder chain = acceptor.getFilterChain();
    
           //设置过滤器以对象为单位读取数据
            chain.addLast("objectFilter",new ProtocolCodecFilter(new ObjectSerializationCodecFactory()));
    
            //设定服务器端的信息处理器
            acceptor.setHandler(new MinaServerHandler());
            //服务器端的端口号
            int port = 9999;
            try {
                //绑定端口,启动服务器(不会阻塞,立即返回)
                acceptor.bind(new InetSocketAddress(port));
            } catch (IOException e) {
                e.printStackTrace();
            }
            System.out.println("Mina Server running,listenter on:" + port);
        }
    }
    

    package com.vince.mina;
    import org.apache.mina.core.service.IoHandlerAdapter;
    import org.apache.mina.core.session.IoSession;
    
    /**
     * 服务器端的消息处理器
     */
    
    public class MinaServerHandler extends IoHandlerAdapter {
        //一次会话被打开
        @Override
        public void sessionOpened(IoSession session) throws Exception {
            super.sessionOpened(session);
            System.out.println("welcome client" + session.getRemoteAddress());
        }
       //会话关闭
        @Override
        public void sessionClosed(IoSession session) throws Exception {
            super.sessionClosed(session);
            System.out.println("client closed");
        }
       //接收消息
        @Override
        public void messageReceived(IoSession session, Object message) throws Exception {
            super.messageReceived(session, message);
     
            //我们已经收到服务器解析信息的规则,一个Message对象为单位传输
               Message msg =(Message) message;
              System.out.println("收到客户端发来的消息:" + msg);
                msg.setInfo("吃大盘鸡!!!!!!");
    
            //向客户端发送消息对象
            session.write(msg);
        }
    }
    

     

     

    展开全文
  • mina

    2016-02-26 14:42:03
    Apache Mina是一个能够帮助用户开发高性能和高伸缩性网络应用程序的框架。它通过Java nio技术基于TCP/IP和UDP/IP协议提供了抽象的、事件驱动的、异步的API。 Mina包的简介: org.apache.mina.core.buffer 用于...

    Apache Mina是一个能够帮助用户开发高性能和高伸缩性网络应用程序的框架。它通过Java nio技术基于TCP/IP和UDP/IP协议提供了抽象的、事件驱动的、异步的API。

    Mina包的简介:

    org.apache.mina.core.buffer 用于缓冲区的IoBuffer
    org.apache.mina.core.service
    org.apache.mina.transport.*
    用于提供连接的service
    org.apache.mina.core.session 用于提供两端状态的session
    org.apache.mina.core.filterchain
    org.apache.mina.filter.*
    用于拦截所有IO事件和请求的filter chain和各类拦截器(在IoService和IoHandler之间)
    org.apache.mina.handler.* 用于处理IO事件的handler
    org.apache.mina.core.future 用于实现异步IO操作的 future
    org.apache.mina.core.polling 用于实现IO轮询的的polling
    org.apache.mina.proxy.* 用于实现代理的proxy

    先介绍Mina几个重要接口:

    先介绍Mina几个重要接口:

    • IoServiece :这个接口在一个线程上负责套接字的建立,拥有自己的 Selector,监听是否有连接被建立。
    • IoProcessor :这个接口在另一个线程上负责检查是否有数据在通道上读写,也就是说它也拥有自己的 Selector,这是与我们使用 JAVA NIO 编码时的一个不同之处,通常在 JAVA NIO 编码中,我们都是使用一个 Selector,也就是不区分 IoService与 IoProcessor 两个功能接口。另外,IoProcessor 负责调用注册在 IoService 上的过滤器,并在过滤器链之后调用 IoHandler。  
    • IoAccepter :相当于网络应用程序中的服务器端
    • IoConnector :相当于客户端
    • IoSession :当前客户端到服务器端的一个连接实例
    • IoHandler :这个接口负责编写业务逻辑,也就是接收、发送数据的地方。这也是实际开发过程中需要用户自己编写的部分代码。
    • IoFilter :过滤器用于悬接通讯层接口与业务层接口,这个接口定义一组拦截器,这些拦截器可以包括日志输出、黑名单过滤、数据的编码(write 方向)与解码(read 方向)等功能,其中数据的 encode与 decode是最为重要的、也是你在使用 Mina时最主要关注的地方。

    MIINA架构图

    在图中的模块链中,IoService 便是应用程序的入口,相当于我们前面代码中的 IoAccepter,IoAccepter 便是 IoService 的一个扩展接口。IoService 接口可以用来添加多个 IoFilter,这些 IoFilter 符合责任链模式并由 IoProcessor 线程负责调用。而 IoAccepter 在 ioService 接口的基础上还提供绑定某个通讯端口以及取消绑定的接口。

    IoAcceptor acceptor = new SocketAcceptor();

    上面代码中,相当于我们使用了 Socket 通讯方式作为服务的接入,当前版本的 MINA 还提供了除 SocketAccepter 外的基于数据报文通讯的 DatagramAccepter 以及基于管道通讯的 VmPipeAccepter。另外还包括串口通讯接入方式,目前基于串口通讯的接入方式已经在最新测试版的 MINA 中提供。你也可以自行实现 IoService 接口来使用自己的通讯方式。

    而在上图中最右端也就是 IoHandler,这便是业务处理模块。在业务处理类中不需要去关心实际的通讯细节,只管处理客户端传输过来的信息即可。编写 Handler 类就是使用 MINA 开发网络应用程序的重心所在,相当于 MINA 已经帮你处理了所有的通讯方面的细节问题。为了简化 Handler 类,MINA 提供了 IoHandlerAdapter 类,此类仅仅是实现了 IoHandler 接口,但并不做任何处理。

    一个 IoHandler 接口中具有如下一些方法(摘自 MINA 的 API 文档):

    • void exceptionCaught(IoSession session, Throwable cause)
      当接口中其他方法抛出异常未被捕获时触发此方法
    • void messageReceived(IoSession session, Object message)
      当接收到客户端的请求信息后触发此方法
    • void messageSent(IoSession session, Object message)
      当信息已经传送给客户端后触发此方法
    • void sessionClosed(IoSession session)
      当连接被关闭时触发,例如客户端程序意外退出等等
    • void sessionCreated(IoSession session)
      当一个新客户端连接后触发此方法
    • void sessionIdle(IoSession session, IdleStatus status)
      当连接空闲时触发此方法
    • void sessionOpened(IoSession session)
      当连接后打开时触发此方法,一般此方法与 sessionCreated 会被同时触发

    前面我们提到 IoService 是负责底层通讯接入,而 IoHandler 是负责业务处理的。那么 MINA 架构图中的 IoFilter 作何用途呢?答案是你想作何用途都可以。但是有一个用途却是必须的,那就是作为 IoService 和 IoHandler 之间的桥梁。IoHandler 接口中最重要的一个方法是 messageReceived,这个方法的第二个参数是一个 Object 型的消息,总所周知,Object 是所有 Java 对象的基础,那到底谁来决定这个消息到底是什么类型呢?答案也就在这个 IoFilter 中。在前面使用的例子中,我们添加了一个 IoFilter 是 new ProtocolCodecFilter(new TextLineCodecFactory()),这个过滤器的作用是将来自客户端输入的信息转换成一行行的文本后传递给 IoHandler,因此我们可以在 messageReceived 中直接将 msg 对象强制转换成 String 对象。

    而如果我们不提供任何过滤器的话,那么在 messageReceived 方法中的第二个参数类型就是一个 byte 的缓冲区,对应的类是 org.apache.mina.core.buffer.IoBuffer。虽然你也可以将解析客户端信息放在 IoHandler 中来做,但这并不是推荐的做法,使原来清晰的模型又模糊起来,变得 IoHandler 不只是业务处理,还得充当协议解析的任务。

    MINA自身带有一些常用的过滤器,例如LoggingFilter(日志记录)、BlackListFilter(黑名单过滤)、CompressionFilter(压缩)、SSLFilter(SSL加密)等。

     

    简单地来讲,就分为三层:

    1. I/O Service :负责处理I/O。
    2. I/O Filter Chain :负责编码处理,字节到数据结构或数据结构到字节的转换等,即非业务逻辑的操作。
    3. I/O Handle :负责处理业务逻辑。

    客户端的通信过程:

    1. 通过SocketConnector同服务器端建立连接。
    2. 链接建立之后I/O的读写交给了I/O Processor线程,I/O Processor是多线程的。
    3. 通过I/O Processor读取的数据经过IoFilterChain里所有配置的IoFilter,IoFilter进行消息的过滤,格式的转换,在这个层面可以制定一些自定义的协议。
    4. 最后IoFilter将数据交给Handler进行业务处理,完成了整个读取的过程。
    5. 写入过程也是类似,只是刚好倒过来,通过IoSession.write写出数据,然后Handler进行写入的业务处理,处理完成后交给IoFilterChain,进行消息过滤和协议的转换,最后通过I/O Processor将数据写出到socket通道。

    IoFilterChain作为消息过滤链

    1. 读取的时候是从低级协议到高级协议的过程,一般来说从byte字节逐渐转换成业务对象的过程。
    2. 写入的时候一般是从业务对象到字节byte的过程。

     客户端通信过程   IoSession贯穿整个通信过程的始终 

    创建服务器

    复制代码
    import java.io.IOException;
    import java.net.InetSocketAddress;
    import java.nio.charset.Charset;
    import org.apache.mina.core.service.IoAcceptor;
    import org.apache.mina.core.session.IdleStatus;
    import org.apache.mina.filter.codec.ProtocolCodecFilter;
    import org.apache.mina.filter.codec.textline.TextLineCodecFactory;
    import org.apache.mina.filter.logging.LoggingFilter;
    import org.apache.mina.transport.socket.nio.NioSocketAcceptor;
    
    public class MinaTimeServer {
        // 定义监听端口
        private static final int PORT = 6488;
    
        public static void main(String[] args) throws IOException {
            // 创建服务端监控线程
            IoAcceptor acceptor = new NioSocketAcceptor();
            acceptor.getSessionConfig().setReadBufferSize(2048);
            acceptor.getSessionConfig().setIdleTime(IdleStatus.BOTH_IDLE, 10);
            // 设置日志记录器
            acceptor.getFilterChain().addLast("logger", new LoggingFilter());
            // 设置编码过滤器
            acceptor.getFilterChain().addLast(
                "codec",
                new ProtocolCodecFilter(new TextLineCodecFactory(Charset.forName("UTF-8"))));
            // 指定业务逻辑处理器
            acceptor.setHandler(new TimeServerHandler());
            // 设置端口号
            acceptor.bind(new InetSocketAddress(PORT));
            // 启动监听线程
            acceptor.bind();
        }
    }
    复制代码
    复制代码
    import org.apache.mina.core.service.IoHandlerAdapter;
    import org.apache.mina.core.session.IdleStatus;
    import org.apache.mina.core.session.IoSession;
    
    /**
     * 服务器端业务逻辑
     */
    public class TimeServerHandler extends IoHandlerAdapter {
    
        /**
         * 连接创建事件
         */
        @Override
        public void sessionCreated(IoSession session){
            // 显示客户端的ip和端口
            System.out.println(session.getRemoteAddress().toString());
        }
        
        @Override
        public void exceptionCaught(IoSession session, Throwable cause) throws Exception {
            cause.printStackTrace();
        }
        
        /**
         * 消息接收事件
         */
        @Override
        public void messageReceived(IoSession session, Object message) throws Exception {
            String strMsg = message.toString();
            if (strMsg.trim().equalsIgnoreCase("quit")) {
                session.close(true);
                return;
            }
            // 返回消息字符串
            session.write("Hi Client!");
            // 打印客户端传来的消息内容
            System.out.println("Message written : " + strMsg);
        }
    
        @Override
        public void sessionIdle(IoSession session, IdleStatus status) throws Exception {
            System.out.println("IDLE" + session.getIdleCount(status));
        }
        
    }
    复制代码

    客户端

    复制代码
    import java.net.InetSocketAddress;
    import java.nio.charset.Charset;
    import org.apache.mina.core.future.ConnectFuture;
    import org.apache.mina.filter.codec.ProtocolCodecFilter;
    import org.apache.mina.filter.codec.textline.TextLineCodecFactory;
    import org.apache.mina.filter.logging.LoggingFilter;
    import org.apache.mina.transport.socket.nio.NioSocketConnector;
    
    public class MinaTimeClient {
        
        public static void main(String[] args){
            // 创建客户端连接器.
            NioSocketConnector connector = new NioSocketConnector();
            connector.getFilterChain().addLast("logger", new LoggingFilter());
            connector.getFilterChain().addLast("codec", 
                    new ProtocolCodecFilter(new TextLineCodecFactory(Charset.forName("UTF-8"))));
            
            // 设置连接超时检查时间
            connector.setConnectTimeoutCheckInterval(30);
            connector.setHandler(new TimeClientHandler());
            
            // 建立连接
            ConnectFuture cf = connector.connect(new InetSocketAddress("192.168.2.109", 6488));
            // 等待连接创建完成
            cf.awaitUninterruptibly();
            
            cf.getSession().write("Hi Server!");
            cf.getSession().write("quit");
            
            // 等待连接断开
            cf.getSession().getCloseFuture().awaitUninterruptibly();
            // 释放连接
            connector.dispose();
        }
    }
    复制代码
    复制代码
    import org.apache.mina.core.service.IoHandlerAdapter;
    import org.apache.mina.core.session.IoSession;
    
    public class TimeClientHandler extends IoHandlerAdapter {
    
        public void messageReceived(IoSession session, Object message) throws Exception {
            String content = message.toString();
            System.out.println("client receive a message is : " + content);
        }
    
        public void messageSent(IoSession session, Object message) throws Exception {
            System.out.println("messageSent -> :" + message);
        }
        
    }
    复制代码

     

     

     

     

     

     

    展开全文
  • MINA

    2013-06-15 14:48:42
    在开mina的官方网站中看到有这么一条使用建议。    http://mina.apache.org/faq.html#FAQ-WhatdoesMINAmean%253F 1.关于使用mina版本的问题。在mina1.0版本中使用的是jdk1.4,对于ssl支持不怎么好,而如果需要...
    在开mina的官方网站中看到有这么一条使用建议。
    

     

         http://mina.apache.org/faq.html#FAQ-WhatdoesMINAmean%253F

    1.关于使用mina版本的问题。在mina1.0版本中使用的是jdk1.4,对于ssl支持不怎么好,而如果需要使用ssl的话,官方是推荐使用mina2.0以上版本的。
    在传统的socket通信过程中,实现方式大概如下,在服务端先建立一个socket连接时候,在建立连接的同时会创建一个新线程来管理使用这个socket连接,这种方式一般在我以前都是这样用的。但这种方式只适用于连接数少的时候,如果连接过多的话,线程会很多,会出现系统资源数不足,让连接等待排队现象。

    第二种方式就是采用nio非阻塞式通讯模式

    1NIO 设计背后的基石:反应器模式,用于事件多路分离和分派的体系结构模式。
    反应器模式的核心功能如下:
    将事件多路分用
    将事件分派到各自相应的事件处理程序

    NIO 的非阻塞 I/O 机制是围绕 选择器和 通道构建的。 Channel 类表示服务器和客户机之间的
    一种通信机制。Selector 类是 Channel 的多路复用器。 Selector 类将传入客户机请求多路分
    用并将它们分派到各自的请求处理程序。
    通道(Channel 类):表示服务器和客户机之间的一种通信机制。
    选择器(Selector类):是 Channel 的多路复用器。Selector 类将传入的客户机请求多路分用并将它们
    分派到各自的请求处理程序。

    简单的来说:

    NIO是一个基于事件的IO架构,最基本的思想就是:有事件我通知你,你再去做你的事情.
    而且NIO的主线程只有一个,不像传统的模型,需要多个线程以应对客户端请求,也减轻
    了JVM的工作量。
    当Channel注册至Selector以后,经典的调用方法如下:

            while (somecondition) {
                int n = selector.select(TIMEOUT);
                if (n == 0)
                    continue;
                for (Iterator iter = selector.selectedKeys().iterator(); iter
                        .hasNext();) {
                    if (key.isAcceptable())
                        doAcceptable(key);
                    if (key.isConnectable())
                        doConnectable(key);
                    if (key.isValid() && key.isReadable())
                        doReadable(key);
                    if (key.isValid() && key.isWritable())
                        doWritable(key);
                    iter.remove();
                }
            }
    nio中取得事件通知,就是在selector的select事件中完成的。在selector事件时有一个线程
    向操作系统询问,selector中注册的Channel&&Selecti的键值对的各种事件是否有发生,
    如果有则添加到selector的selectedKeys属性Set中去,并返回本次有多少个感兴趣的事情发生。
    如果发现这个值>0,表示有事件发生,马上迭代selectedKeys中的Selecti,
    根据Key中的表示的事件,来做相应的处理。
    实际上,这段说明表明了异步socket的核心,即异步socket不过是将多个socket的调度(或者还有他们的线程调度)
    全部交给操作系统自己去完成,异步的核心Selector,不过是将这些调度收集、分发而已。
    3:Socket网络框架 MINA
    MINA是一个网络应用框架,在不牺牲性能和可扩展性的前提下用于解决如下问题:
    1:快速开发自己的英勇。
    2:高可维护性,高可复用性:网络I/O编码,消息的编/解码,业务逻辑互相分离。
    3:相对容易的进行单元测试。

     

    3.1 IoFilters:
    IoFilter为MINA的功能扩展提供了接口。它拦截所有的IO事件进行事件的预处理和后处理(AOP)。我们可以把它想象成
    Servlet的filters。
    IoFilter能够实现以下几种目的:
    事件日志
    性能检测
    数据转换(e.g. SSL support),codec
    防火墙…等等

    3.2 codec: ProtocolCodecFactory
    MINA提供了方便的Protocol支持。如上说讲,codec在IoFilters中设置。
    通过它的Encoder和Decoder,可以方便的扩展并支持各种基于Socket的网络协议,比如HTTP服务器、FTP服务器、Telnet服务器等等。

    要实现自己的编码/解码器(codec)只需要实现interface: ProtocolCodecFactory即可.
    在MINA 1.0版本,MINA已经实现了几个常用的(codec factory):

    DemuxingProtocolCodecFactory,
    NettyCodecFactory,
    ObjectSerializationCodecFactory,
    TextLineCodecFactory

    其中:
    TextLineCodecFactory:
    A ProtocolCodecFactory that performs encoding and decoding between a text line data and a Java
    string object. This codec is useful especially when you work with a text-based protocols such as SMTP and IMAP.

    ObjectSerializationCodecFactory:
    A ProtocolCodecFactory that serializes and deserializes Java objects. This codec is very useful when
    you have to prototype your application rapidly without any specific codec.

    DemuxingProtocolCodecFactory:
    A composite ProtocolCodecFactory that consists of multiple MessageEncoders and MessageDecoders. ProtocolEncoder
    and ProtocolDecoder this factory returns demultiplex incoming messages and buffers to appropriate MessageEncoders
    and MessageDecoders.

    NettyCodecFactory:
    A MINA ProtocolCodecFactory that provides encoder and decoder for Netty2 Messages and MessageRecognizers.

    3.3 business logic: IoHandler

    MINA中,所有的业务逻辑都有实现了IoHandler的class完成
    interfaceHandles:
    all protocol events fired by MINA. There are 6 event handler methods, and they are all invoked by MINA automatically.
    当事件发生时,将触发IoHandler中的方法:
    sessionCreated, sessionOpened, sessionClosed, sessionIdle, exceptionCaught, messageReceived, messageSent
    MINA 1.O中,IoHandler的实现类:
    ChainedIoHandler, DemuxingIoHandler, IoHandlerAdapter, SingleSessionIoHandlerDelegate, StreamIoHandler
    具体细节可参考javadoc。

    3.4 MINA的高级主题:线程模式
    MINA通过它灵活的filter机制来提供多种线程模型。
    没有线程池过滤器被使用时MINA运行在一个单线程模式。
    如果添加了一个IoThreadPoolFilter到IoAcceptor,将得到一个leader-follower模式的线程池。
    如果再添加一个ProtocolThreadPoolFilter,server将有两个线程池;
    一个(IoThreadPoolFilter)被用于对message对象进行转换,另外一个(ProtocolThreadPoolFilter)被用于处理业务逻辑。
    SimpleServiceRegistry加上IoThreadPoolFilter和ProtocolThreadPoolFilter的缺省实现即可适用于需
    要高伸缩性的应用。如果想使用自己的线程模型,请参考SimpleServiceRegistry的源代码,并且自己

    初始化Acceptor。

    IoThreadPoolFilter threadPool = new IoThreadPoolFilter();threadPool.start();
    IoAcceptor acceptor = new SocketAcceptor();
    acceptor.getFilterChain().addLast( "threadPool", threadPool);
    ProtocolThreadPoolFilter threadPool2 = new ProtocolThreadPoolFilter();
    threadPool2.start();
    ProtocolAcceptor acceptor2 = new IoProtocolAcceptor( acceptor );
    acceptor2.getFilterChain().addLast( "threadPool", threadPool2 );
    ...
    threadPool2.stop();
    threadPool.stop();


    采用MINA进行socket开发,一般步骤如下:
    1:
    server:
    IoAcceptor acceptor = new SocketAcceptor(); //建立client接收器
    or client:
    SocketConnector connector = new SocketConnector(); //建立一个连接器
    2:server的属性配置:
            SocketAcceptorConfig cfg = new SocketAcceptorConfig();
            cfg.setReuseAddress(true);
            cfg.getFilterChain().addLast(
                        "codec",
                        new ProtocolCodecFilter( new ObjectSerializationCodecFactory() ) ); //对象序列化 codec factory
            cfg.getFilterChain().addLast( "logger", new LoggingFilter() );
    3:绑定address和business logic
    server:
            acceptor.bind(
                    new InetSocketAddress( SERVER_PORT ),
                    new ServerSessionHandler( ), cfg ); // 绑定address和handler

    client:
            connector.connect(new InetSocketAddress( HOSTNAME, PORT ),
                            new ClientSessionHandler(msg), cfg );

    下面的这个简单的example演示client和server传递object的过程:
    Message.java
    public class Message implements Serializable {

        private int type;
        private int status;
        private String msgBody;
       
        public Message(int type, int status, String msgBody)
        {
            this.type = type;
            this.status = status;
            this.msgBody = msgBody;
        }

        public String getMsgBody() {
            return msgBody;
        }

        public void setMsgBody(String msgBody) {
            this.msgBody = msgBody;
        }

        public int getStatus() {
            return status;
        }

        public void setStatus(int status) {
            this.status = status;
        }

        public int getType() {
            return type;
        }

        public void setType(int type) {
            this.type = type;
        }
    }

    Client.java
    public class Client
    {
        private static final String HOSTNAME = "localhost";
        private static final int PORT = 8080;
        private static final int CONNECT_TIMEOUT = 30; // seconds


        public static void main( String[] args ) throws Throwable
        {
            SocketConnector connector = new SocketConnector();       
            // Configure the service.
            SocketConnectorConfig cfg = new SocketConnectorConfig();
            cfg.setConnectTimeout( CONNECT_TIMEOUT );
              cfg.getFilterChain().addLast(
                        "codec",
                        new ProtocolCodecFilter( new ObjectSerializationCodecFactory() ) );

            cfg.getFilterChain().addLast( "logger", new LoggingFilter() );
           
            IoSession session;
            Message msg = new Message(0,1,"hello");
            connector.connect(new InetSocketAddress( HOSTNAME, PORT ),
                            new ClientSessionHandler(msg), cfg );

        }
    }

    ClientSessionHandler.java
    public class ClientSessionHandler extends IoHandlerAdapter
    {
        private Object msg;
       
        public ClientSessionHandler(Object msg)
        {
            this.msg = msg;
        }


        public void sessionOpened( IoSession session )
        {
            session.write(this.msg);
        }

        public void messageReceived( IoSession session, Object message )
        {
            System.out.println("in messageReceived!");
            Message rm = (Message ) message;       
            SessionLog.debug(session, rm.getMsgBody());
            System.out.println("message is: " + rm.getMsgBody());
            session.write(rm);
        }

        public void exceptionCaught( IoSession session, Throwable cause )
        {
            session.close();
        }
    }

    Server.java
    public class Server
    {
        private static final int SERVER_PORT = 8080;

        public static void main( String[] args ) throws Throwable
        {
            IoAcceptor acceptor = new SocketAcceptor();
           
            // Prepare the service configuration.
            SocketAcceptorConfig cfg = new SocketAcceptorConfig();
            cfg.setReuseAddress( true );

            cfg.getFilterChain().addLast(
                        "codec",
                        new ProtocolCodecFilter( new ObjectSerializationCodecFactory() ) );
            cfg.getFilterChain().addLast( "logger", new LoggingFilter() );

            acceptor.bind(
                    new InetSocketAddress( SERVER_PORT ),
                    new ServerSessionHandler( ), cfg );

            System.out.println( "The server Listening on port " + SERVER_PORT );
        }
    }

    ServerSessionHandler.java
    public class ServerSessionHandler extends IoHandlerAdapter
    {
        public void sessionOpened( IoSession session )
        {
            // set idle time to 60 seconds
            session.setIdleTime( IdleStatus.BOTH_IDLE, 60 );
            session.setAttribute("times",new Integer(0));
        }

        public void messageReceived( IoSession session, Object message )
        {
            System.out.println("in messageReceived");
            int times = ((Integer)(session.getAttribute("times"))).intValue();
            System.out.println("tiems = " + times);
            // communicate 30 times,then close the session.
            if (times < 30)
            {
                times++;
                session.setAttribute("times", new Integer(times));          
             Message msg;
             msg = (Message) message;
             msg.setMsgBody("in server side: " + msg.getMsgBody());
             System.out.println("begin send msg: " + msg.getMsgBody());
             session.write(msg);
            }
            else
            {
                session.close();
            }
        }

        public void sessionIdle( IoSession session, IdleStatus status )
        {
            SessionLog.info( session, "Disconnecting the idle." );
            // disconnect an idle client
            session.close();
        }

        public void exceptionCaught( IoSession session, Throwable cause )
        {
            // close the connection on exceptional situation
            session.close();
        }
    }
    MINA自己附带的Demo已经很好的说明了它的运用。
    值得一提的是它的SumUp:客户端发送几个数字,服务端求和后并返回结果。这个简单的程序演示了如何自己实现CODEC。

    补充提示:
    下载并运行MINA的demo程序还颇非周折:
    运行MINA demo appli擦tion:
    1:在JDK5
    产生错误:
    Exception in thread "main" java.lang.NoClassDefFoundError: edu/emory/mathcs/backport/java/util/concurrent/Executor
    at org.apache.mina.example.reverser.Main.main(Main.java:44)

    察看mina的QA email:
    http://www.mail-archive.com/mina-dev@directory.apache.org/msg02252.html

    原来需要下载:backport-util-concurrent.jar并加入classpath
    http://dcl.mathcs.emory.edu/util/backport-util-concurrent/

    继续运行还是报错:
    Exception in thread "main" java.lang.NoClassDefFoundError: org/slf4j/LoggerFactory

    原来MINA采用了slf4j项目作为log,继续下载
    slf4j-simple.jar等,并加入classpath:
    http://www.slf4j.org/download.html

    展开全文
  • MINa

    2011-12-07 21:40:00
    使用 Apache MINA 开发高性能网络应用程序 刘 冬 (javayou@gmail.com), 开发工程师, 广州市摩网信息技术有限公司 简介:本文将通过一个简单的问候程序 HelloServer 来介绍 MINA 的基础架构的同时演示如何...

    使用 Apache MINA 开发高性能网络应用程序

     

    刘 冬 (javayou@gmail.com), 开发工程师, 广州市摩网信息技术有限公司

    简介: 本文将通过一个简单的问候程序 HelloServer 来介绍 MINA 的基础架构的同时演示如何使用 MINA 开发网络应用程序。

    本文的标签:  mina

    发布日期: 2007 年 12 月 24 日
    访问情况 : 13835 次浏览
    评论: 0 (查看 | 添加评论 - 登录)

    平均分 4 星 共 30 个评分 平均分 (30个评分)
    为本文评分

    Apache MINA(Multipurpose Infrastructure for Network Applications) 是 Apache 组织一个较新的项目,它为开发高性能和高可用性的网络应用程序提供了非常便利的框架。当前发行的 MINA 版本支持基于 Java NIO 技术的 TCP/UDP 应用程序开发、串口通讯程序(只在最新的预览版中提供),MINA 所支持的功能也在进一步的扩展中。

    目前正在使用 MINA 的软件包括有:Apache Directory Project、AsyncWeb、AMQP(Advanced Message Queuing Protocol)、RED5 Server(Macromedia Flash Media RTMP)、ObjectRADIUS、Openfire 等等。

    本文将通过一个简单的问候程序 HelloServer 来介绍 MINA 的基础架构的同时演示如何使用MINA 开发网络应用程序。

    环境准备

    1. 首先到官方网站下载最新的 MINA 版本,地址是:http://mina.apache.org/downloads.html。 下载之前先介绍一下 MINA 的两个版本:1.0.x 适合运行环境为 JDK1.4,1.1.x 适合 JDK1.5 的版本,两者的编译环境都需要 JDK1.5。JDK1.5 已经是非常普遍了,本文中使用 1.1.5 版本的 MINA,编译和运行所需的文件是 mina-core-1.1.5.jar。
    2. 下载 MINA 的依赖包 slf4j。MINA 使用此项目作为日志信息的输出,而 MINA 本身并不附带此项目包,请到http://www.slf4j.org/download.html 地址下载 slf4j 包,slf4j 项目解压后有很多的文件,本例中只需要其中的 slf4j-api-1.4.3.jar 和 slf4j-simple-1.4.3.jar 这两个 jar 文件。如果没有这两个文件就会导致启动例子程序的时候报 org/slf4j/LoggerFactory 类没找到的错误。
    3. 当然要求机器上必须装有 1.5 或者更新版本的 JDK。
    4. 最好你应该选择一个顺手的 Java 开发环境例如 Eclipse 或者 NetBeans 之类的,可以更方便的编码和调试,虽然我们的最低要求只是一个简单的文本编辑器而已。

    编写代码并执行

    1. 编写代码 HelloServer.java 如下
    package demo.mina.echo;
    
    import java.io.IOException;
    import java.net.InetSocketAddress;
    
    import org.apache.mina.common.*;
    import org.apache.mina.transport.socket.nio.*;
    import org.apache.mina.filter.codec.ProtocolCodecFilter;
    import org.apache.mina.filter.codec.textline.TextLineCodecFactory;
    
    /**
     * HelloServer演示程序
     * @author liudong ( http://www.dlog.cn/javayou )
     */
    public class HelloServer {
    
        private static final int PORT = 8080;
    /**
     * @param args
     * @throws IOException 
     */
    public static void main(String[] args) throws IOException {
            IoAcceptor acceptor = new SocketAcceptor();        
            IoAcceptorConfig config = new SocketAcceptorConfig();
            DefaultIoFilterChainBuilder chain = config.getFilterChain();
            //使用字符串编码
            chain.addLast("codec", 
    new ProtocolCodecFilter(new TextLineCodecFactory()));
            //启动HelloServer
            acceptor.bind(new InetSocketAddress(PORT), new HelloHandler(), config);
            System.out.println("HelloServer started on port " + PORT);
    	}
    }
    
    /**
     * HelloServer的处理逻辑
     * @author liudong
     */
    class HelloHandler extends IoHandlerAdapter {
    /**
     * 当有异常发生时触发
     */
    @Override
        public void exceptionCaught(IoSession ssn, Throwable cause) {
            cause.printStackTrace();
            ssn.close();
        }
    
    /**
     * 有新连接时触发
     */
    @Override
    public void sessionOpened(IoSession ssn) throws Exception {
        System.out.println("session open for " + ssn.getRemoteAddress());
    	}
    
    /**
     * 连接被关闭时触发
     */
    @Override
    public void sessionClosed(IoSession ssn) throws Exception {
        System.out.println("session closed from " + ssn.getRemoteAddress());
    	}
    
    /**
     * 收到来自客户端的消息
     */
    public void messageReceived(IoSession ssn, Object msg) throws Exception {    
        String ip = ssn.getRemoteAddress().toString();
    System.out.println("===> Message From " + ip +" : " + msg);    
        ssn.write("Hello " + msg);
        }
    }
    

     

    1. 编译执行

    先不用试着去读懂每一行代码的具体意思,用你顺手的编译器编译 HelloServer.java,如果报错请确认是否已将前面提到的三个 jar 文件添加至类路径中。如果一切顺利接着就可以启动HelloServer 程序,启动后提示:HelloServer started on port 8080 表示启动成功,如果启动失败,问题无外乎是类没找到或者端口占用。如果端口被占用的话,换一个罗,修改 PORT 常量值后再次编译并启动。

    1. 测试服务器

    打开命令行窗口,输入 telnet localhost 8080 后,输入您的英文名或者其他一些乱七八糟的字符后回车再去看看刚启动的服务程序有何反应。我的反应如下:

    HelloServer started on port 8080
    session open for /127.0.0.1:3023
    ===> Message From /127.0.0.1:3023 :hello
    ===> Message From /127.0.0.1:3023 :hello
    ===> Message From /127.0.0.1:3023 :liudong
    ===> Message From /127.0.0.1:3023 :Winter Lau
    

     

    好了,一切正常,恭喜你的第一个使用 MINA 开发的网络程序已经成功运行了。

    MINA 基本类的描述

    在介绍架构之前先认识几个接口:

    IoAccepter 相当于网络应用程序中的服务器端

    IoConnector 相当于客户端

    IoSession 当前客户端到服务器端的一个连接实例

    IoHandler 业务处理逻辑

    IoFilter 过滤器用于悬接通讯层接口与业务层接口

    MINA 的基础架构

    下图是 MINA 的架构图,


    图 1:MINA 的架构图

    在图中的模块链中,IoService 便是应用程序的入口,相当于我们前面代码中的 IoAccepter,IoAccepter 便是 IoService 的一个扩展接口。IoService 接口可以用来添加多个 IoFilter,这些 IoFilter 符合责任链模式并由 IoProcessor 线程负责调用。而 IoAccepter 在 ioService 接口的基础上还提供绑定某个通讯端口以及取消绑定的接口。在上面的例子中,我们是这样使用 IoAccepter 的:

    IoAcceptor acceptor = new SocketAcceptor();
    

     

    相当于我们使用了 Socket 通讯方式作为服务的接入,当前版本的 MINA 还提供了除 SocketAccepter 外的基于数据报文通讯的 DatagramAccepter 以及基于管道通讯的 VmPipeAccepter。另外还包括串口通讯接入方式,目前基于串口通讯的接入方式已经在最新测试版的 MINA 中提供。你也可以自行实现 IoService 接口来使用自己的通讯方式。

    而在上图中最右端也就是 IoHandler,这便是业务处理模块。相当于前面例子中的 HelloHandler 类。在业务处理类中不需要去关心实际的通讯细节,只管处理客户端传输过来的信息即可。编写 Handler 类就是使用 MINA 开发网络应用程序的重心所在,相当于 MINA 已经帮你处理了所有的通讯方面的细节问题。为了简化 Handler 类,MINA 提供了 IoHandlerAdapter 类,此类仅仅是实现了 IoHandler 接口,但并不做任何处理。

    一个 IoHandler 接口中具有如下一些方法(摘自 MINA 的 API 文档):

    void exceptionCaught(IoSession session, Throwable cause)
                       当接口中其他方法抛出异常未被捕获时触发此方法
    void messageReceived(IoSession session, Object message)
                       当接收到客户端的请求信息后触发此方法.
    void messageSent(IoSession session, Object message)
                       当信息已经传送给客户端后触发此方法.
    void sessionClosed(IoSession session)
                       当连接被关闭时触发,例如客户端程序意外退出等等.
    void sessionCreated(IoSession session)
                       当一个新客户端连接后触发此方法.
    void sessionIdle(IoSession session, IdleStatus status)
                       当连接空闲时触发此方法.
    void sessionOpened(IoSession session)
                       当连接后打开时触发此方法,一般此方法与 sessionCreated 会被同时触发

     

    前面我们提到 IoService 是负责底层通讯接入,而 IoHandler 是负责业务处理的。那么 MINA 架构图中的 IoFilter 作何用途呢?答案是你想作何用途都可以。但是有一个用途却是必须的,那就是作为 IoService 和 IoHandler 之间的桥梁。IoHandler 接口中最重要的一个方法是 messageReceived,这个方法的第二个参数是一个 Object 型的消息,总所周知,Object 是所有 Java 对象的基础,那到底谁来决定这个消息到底是什么类型呢?答案也就在这个 IoFilter 中。在前面使用的例子中,我们添加了一个 IoFilter 是 new ProtocolCodecFilter(new TextLineCodecFactory()),这个过滤器的作用是将来自客户端输入的信息转换成一行行的文本后传递给 IoHandler,因此我们可以在 messageReceived 中直接将 msg 对象强制转换成 String 对象。

    而如果我们不提供任何过滤器的话,那么在 messageReceived 方法中的第二个参数类型就是一个 byte 的缓冲区,对应的类是 org.apache.mina.common.ByteBuffer。虽然你也可以将解析客户端信息放在 IoHandler 中来做,但这并不是推荐的做法,使原来清晰的模型又模糊起来,变得 IoHandler 不只是业务处理,还得充当协议解析的任务。

    MINA自身带有一些常用的过滤器,例如LoggingFilter(日志记录)、BlackListFilter(黑名单过滤)、CompressionFilter(压缩)、SSLFilter(SSL加密)等。

    其他

    MINA 不仅仅是用来开发网络服务器端应用程序,它一样可以使用 IoConnector 来连接到各种各样的网络服务程序。

    通过本文中 HelloServer 这个例子,我们在惊叹 MINA 可以带来多么大便利的同时,还不得不为其卓越的性能而骄傲,据称使用MINA开发服务器程序的性能已经逼近使用 C/C++ 语言开发的网络服务。作为 MINA 的入门文章,性能问题不在本文讨论范围内。

    另外在 MINA 压缩包中附带有不少比 HelloServer 要好得多的例子,通过这些例子可以进一步的了解并掌握 MINA。

     

    参考资料

    转载于:https://www.cnblogs.com/avenxia/archive/2011/12/07/2279928.html

    展开全文
  • mina实例1mina实例1

    2016-06-27 10:53:11
    mina
  • mina连接,mina心跳连接,mina断线重连。其中客户端可直接用在android上。根据各方参考资料,经过自己的理解弄出来的。CSDN的资源分太难得了。
  • mina:Apache MINA的镜像
  • mina的使用初步入门mina的使用初步入门mina的使用初步入门
  • mina 心跳

    2017-02-24 15:14:19
    mina 心跳
  • mina-oauth:MINA OAuth-源码

    2021-05-03 06:51:50
    mina-oauth 微信小程序OAuth接口 功能列表 OAuth授权 获取基本信息 Installation $ npm install mina-oauth (yarn add mina-oauth) Usage 初始化 引入OAuth并实例化 const OAuth = require('mina-oauth'); const ...
  • Mina docs Mina API

    2009-09-25 13:41:29
    Mina docs Mina API Mina docs Mina API
  • MinaClient

    2017-07-07 18:01:12
    MinaDemo,Mina客户端在android上的实现,里面还包含了一点MPAndroidChar的代码,忘记整理了。
  • mina的高级使用,mina文件图片传送,
  • mina 源码

    2017-08-03 16:05:40
    apache-mina-2.0.4 源码 下载
  • mina2 源码 mina

    2011-05-09 14:31:28
    不错的MINA2源码呵,带有MINA2的原实例
  • mina_slack mina_slack 是一个 gem,它添加了使用 [Mina] ( ) 向 [Slack] ( ) 发送通知的任务。 安装 gem install mina_slack 使用示例 require 'mina_slack/tasks' ... # Required mina_slack options set :...
  • MINA_API+MINA_DOC+mina

    2012-05-14 14:14:31
    里面包含mina2.0的api(英文)和mina自学手册,还有mina的开发指导
  • apache mina

    2017-09-26 14:51:54
    Mina 2.0.16 简介 代码实例 Mina 是Apache开发的一个开源的网络通信框架,基于java NIO实现。 建立server与client之间的会话连接,对会话消息进行过滤; 非阻塞消息会话机制; 通过自定义的通信协议进行编解码消息。
  • 独角兽的 Mina 任务,将通过 init.d 创建和管理独角兽进程 用于处理任务。 这个 gem 提供了几个 mina 任务: mina unicorn:setup # Create necessary folders, configs and upload to server mina unicorn:...
  • 用于部署的Mina任务。 此版本的gem与Mina 1.x兼容, 安装 # Gemfile gem 'mina-rpush' , require : false 用法 # config/deploy.rb require 'mina/rpush' task deploy : :environment do deploy do ... on :...
  • Mina :: Unicorn 用处理的任务 此gem提供了几个Mina任务: mina unicorn:start # Start unicorn mina unicorn:stop # Stop unicorn mina unicorn:restart # Restart unicorn (with zero-downtime) 安装 将此行添加...
  • 米娜·纳金斯(Mina Nginx) 使用处理任务。 此gem提供了几个Mina任务: mina nginx:install # Install template config to host repo for easy overrides mina nginx:setup # Install config file to the server...
  • 两个mina开发文档,含有所有的mina的简单开发案例与教程
  • mina-webpack Mina单文件组件符合Webpack 开始使用 我们建议您开始使用 : npm i -g sao sao mina my-app cd my-app npm start 并查看如何与一起使用 包含包装 mina-entry-webpack-plugin wxs加载器 手动...
  • mina example

    2011-05-06 20:36:35
    mina example mina example mina example mina example

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 9,709
精华内容 3,883
关键字:

MINA