使用mina框架，开发基于tcp/ip协议的门禁设备

最新推荐文章于 2024-03-29 09:45:52 发布
最新推荐文章于 2024-03-29 09:45:52 发布
阅读量1.1k 收藏 1
点赞数
分类专栏： mina框架 文章标签： mina框架
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq1247/article/details/50523028
版权 
package com.tyhuanledi.device;

public interface DoorDevice {
    /**
     * 启动门
     * v1.0 zhc 2016年1月13日下午2:33:16
     * void
     */
    public void startUp();

    /**
     * 开门
     * v1.0 zhc 2016年1月13日下午2:37:26
     * @param ip
     * @param port
     * @param doorNo 门号
     * void
     */
    public void openDoor(String ip, int port, int doorNo);

    /**
     * 关门
     * v1.0 zhc 2016年1月13日下午2:37:40
     * @param ip
     * @param port
     * @param doorNo 门号
     * void
     */
    public void closeDoor(String ip, int port, int doorNo);
}
package com.tyhuanledi.device.impl;

import java.io.InputStream;
import java.net.InetSocketAddress;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.apache.mina.core.future.ConnectFuture;
import org.apache.mina.core.service.IoConnector;
import org.apache.mina.core.session.IdleStatus;
import org.apache.mina.core.session.IoSession;
import org.apache.mina.filter.codec.ProtocolCodecFilter;
import org.apache.mina.transport.socket.nio.NioSocketConnector;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import com.tyhuanledi.device.DoorDevice;
import com.tyhuanledi.device.codec.DoorDecoder;
import com.tyhuanledi.device.codec.DoorEncoder;
import com.tyhuanledi.device.entity.DoorCommand;
import com.tyhuanledi.device.filter.ReConnectionFilter;
import com.tyhuanledi.device.filter.SessionManagerFilter;
import com.tyhuanledi.device.handle.DoorHandle;
import com.tyhuanledi.device.manager.SessionManager;

public class DoorDevice implements DoorDevice {
    private Logger log = LoggerFactory.getLogger(DoorDevice.class);

    @Override
    public void startUp() {
        final IoConnector connector = new NioSocketConnector();// 创建客户端连接
        connector.setConnectTimeoutMillis(5 * 1000);// 设置连接超时5秒
        connector.getSessionConfig().setIdleTime(IdleStatus.BOTH_IDLE, 10 * 1000);// 设置读写空闲10秒
        connector.getFilterChain().addFirst("reconnection", new ReConnectionFilter());// 添加断线重连过滤器
        connector.getFilterChain().addAfter("reconnection", "sessionManager", new SessionManagerFilter());// 添加session管理过滤器
        connector.getFilterChain().addAfter("sessionManager", "codec",
                new ProtocolCodecFilter(new DoorEncoder(), new DoorDecoder()));// 添加编解码过滤器
        connector.setHandler(new DoorHandle());// 添加业务处理

        List<Map<String, Object>> list = getList();
        for(final Map<String, Object> map : list){
            try {
                new Thread(new Runnable() {
                    @Override
                    public void run() {
                        start(connector, map.get("ip").toString(), (Integer)map.get("port"));//启动设备
                    }
                }).start();

                Thread.sleep(1000);//睡眠1秒
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

    public void start(IoConnector connector, String ip, int port) {
        while (true) {
            try {
                log.debug("开始连接门禁【" + ip + ":" + port + "】。");
                ConnectFuture future = connector.connect(new InetSocketAddress(ip, port));// 开始连接
                future.awaitUninterruptibly();// 等待连接创建成功
                IoSession session = future.getSession();// 获取会话
                if (session.isConnected()) {//如果连接成功
                    log.debug("连接门禁【" + ip + ":" + port + "】成功。");
                    break;
                }
            } catch (Exception e) {
                try {
                    e.printStackTrace();
                    log.debug("连接门禁【" + ip + ":" + port + "】失败，5秒后重试。");
                    Thread.sleep(5000);
                } catch (InterruptedException e1) {
                    e1.printStackTrace();
                }
            }
        }
    }

    @Override
    public void openDoor(String ip, int port, int doorNo) {
        IoSession session = SessionManager.get(ip, port);
        session.write(DoorCommand.createOpenCommand(doorNo));
    }

    @Override
    public void closeDoor(String ip, int port, int doorNo) {
        IoSession session = SessionManager.get(ip, port);
        session.write(DoorCommand.createCloseCommand(doorNo));
    }

    public List<Map<String, Object>> getList(){
        List<Map<String, Object>> list = new ArrayList<Map<String, Object>>();
        Map<String, Object> map = new HashMap<String, Object>();
        map.put("ip", "192.168.8.31");
        map.put("port", 8000);
        map.put("doorNo", 1);
        list.add(map);

        Map<String, Object> map2 = new HashMap<String, Object>();
        map2.put("ip", "192.168.8.32");
        map2.put("port", 8000);
        map2.put("doorNo", 1);
        list.add(map2);
        return list;
    }

    public static void main(String[] args) {
        DoorDevice door = new DoorDevice();
        door.startUp();
        while (true) {
            try {
                InputStream in = System.in;
                int readKey = in.read();
                if (readKey == 49) {
                    door.openDoor("192.168.8.31", 8000, 1);
                }
                if (readKey == 50) {
                    door.closeDoor("192.168.8.31", 8000, 1);
                }
                if (readKey == 52) {
                    door.openDoor("192.168.8.32", 8000, 1);
                }
                if (readKey == 53) {
                    door.closeDoor("192.168.8.32", 8000, 1);
                } 
            }catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
}
package com.tyhuanledi.device.filter;

import java.net.InetSocketAddress;

import org.apache.mina.core.filterchain.IoFilterAdapter;
import org.apache.mina.core.session.IdleStatus;
import org.apache.mina.core.session.IoSession;
import org.apache.mina.transport.socket.nio.NioSocketConnector;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import com.tyhuanledi.device.impl.DoorDevice;

public class ReConnectionFilter extends IoFilterAdapter {
    private Logger log = LoggerFactory.getLogger(ReConnectionFilter.class);

    @Override
    public void exceptionCaught(NextFilter nextFilter, IoSession session, Throwable cause) throws Exception {
        InetSocketAddress address = (InetSocketAddress) session.getServiceAddress();
        String ip = address.getHostName();
        int port = address.getPort();
        session.close(true);
        log.debug("门禁【" + ip + ":" + port + "】连接异常，连接自动断开。");

        super.exceptionCaught(nextFilter, session, cause);
    }

    @Override
    public void sessionIdle(NextFilter nextFilter, IoSession session, IdleStatus status) throws Exception {
        InetSocketAddress address = (InetSocketAddress) session.getServiceAddress();
        String ip = address.getHostName();
        int port = address.getPort();
        session.close(true);

        NioSocketConnector connector = (NioSocketConnector) session.getService();
        int bothIdleTime = connector.getSessionConfig().getBothIdleTime();
        log.debug("连接门禁【" + ip + ":" + port + "】连接超时"+bothIdleTime+"秒，连接自动断开。");

        super.sessionIdle(nextFilter, session, status);
    }

    @Override
    public void sessionClosed(NextFilter nextFilter, IoSession session) throws Exception {
        super.sessionClosed(nextFilter, session);

        final NioSocketConnector connector = (NioSocketConnector) session.getService();
        InetSocketAddress address = (InetSocketAddress) session.getServiceAddress();
        final String ip = address.getHostName();
        final int port = address.getPort();
        log.debug("门禁【" + ip + ":" + port + "】连接被关闭，5秒后重新连接。");

        try {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    try {
                        Thread.sleep(5 * 1000);
                        new DoorDevice().start(connector, ip, port);//启动设备
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                }
            }).start();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}
package com.tyhuanledi.device.filter;

import java.net.InetSocketAddress;

import org.apache.mina.core.filterchain.IoFilterAdapter;
import org.apache.mina.core.session.IoSession;

import com.tyhuanledi.device.manager.SessionManager;

public class SessionManagerFilter extends IoFilterAdapter{
    @Override
    public void sessionCreated(NextFilter nextFilter, IoSession session) throws Exception {
        InetSocketAddress address = (InetSocketAddress) session.getServiceAddress();
        SessionManager.put(address.getHostName(), address.getPort(), session);
        super.sessionCreated(nextFilter, session);
    }

    @Override
    public void sessionClosed(NextFilter nextFilter, IoSession session) throws Exception {
        InetSocketAddress address = (InetSocketAddress) session.getServiceAddress();
        SessionManager.remove(address.getHostName(), address.getPort());
        super.sessionClosed(nextFilter, session);
    }
}
package com.tyhuanledi.device.codec;

import org.apache.mina.core.buffer.IoBuffer;
import org.apache.mina.core.session.IoSession;
import org.apache.mina.filter.codec.CumulativeProtocolDecoder;
import org.apache.mina.filter.codec.ProtocolDecoderOutput;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import com.tyhuanledi.device.entity.Door;
import com.tyhuanledi.device.entity.DoorCommand;

public class DoorDecoder extends CumulativeProtocolDecoder{
    private static final Logger log = LoggerFactory.getLogger(DoorDecoder.class);

    @Override
    protected boolean doDecode(IoSession session, IoBuffer in, ProtocolDecoderOutput out) throws Exception {
        //接受数据
        byte[] data = new byte[in.limit()];
        in.get(data);
//      log.debug("收到消息：" + ByteUtil.toHexStr(data));

        //校验数据
        boolean validate = DoorCommand.validate(data);
        if(!validate){
            log.debug("校验数据失败");
            Door Door = new Door();
            Door.setCommand((byte)0x00);
            return true;
        }

        //解析数据
        out.write(new Door(data));
        return true;
    }
}
package com.tyhuanledi.device.codec;

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

public class DoorEncoder extends ProtocolEncoderAdapter {
//  private static final Logger log = LoggerFactory.getLogger(DoorEncoder.class);

    @Override
    public void encode(IoSession session, Object message, ProtocolEncoderOutput out) throws Exception {
        byte[] data = (byte[]) message;
//      log.debug("发送消息：" + ByteUtil.toHexStr(data));
        IoBuffer buffer = IoBuffer.allocate(data.length);
        buffer.put(data);
        buffer.flip();
        out.write(buffer);
    }
}
package com.tyhuanledi.device.handle;

import java.net.InetSocketAddress;

import org.apache.mina.core.service.IoHandlerAdapter;
import org.apache.mina.core.session.IoSession;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import com.tyhuanledi.device.entity.Door;
import com.tyhuanledi.device.entity.DoorCommand;

public class DoorHandle extends IoHandlerAdapter{
    private Logger log = LoggerFactory.getLogger(DoorHandle.class);

    @Override
    public void messageReceived(IoSession session, Object message) throws Exception {
        Door door = (Door) message;
        InetSocketAddress address = (InetSocketAddress) session.getServiceAddress();
        String ip = address.getHostName();
        int port = address.getPort();

        //如果是心跳指令
        if(door.getCommand() == DoorCommand.HEART){
            session.write(DoorCommand.createHeartCommand());
            return;
        }

        //如果是开门指令
        if(door.getCommand() == DoorCommand.OPEN){
            if(door.getData()[0] == DoorCommand.OPEN_SUCC){
                log.debug("门禁【" + ip + ":" + port + "】开门成功。");
                return;
            }

            log.debug("门禁【" + ip + ":" + port + "】开门失败。");
        }

        //如果是关门指令
        if(door.getCommand() == DoorCommand.CLOSE){
            if(door.getData()[0] == DoorCommand.OPEN_SUCC){
                log.debug("门禁【" + ip + ":" + port + "】关门成功。");
                return;
            }

            log.debug("门禁【" + ip + ":" + port + "】关门失败。");
        }
    }
}
package com.tyhuanledi.device.manager;

import java.util.HashMap;
import java.util.Map;

import org.apache.mina.core.session.IoSession;

public class SessionManager {
    private static final Map<String, IoSession> map = new HashMap<String, IoSession>();

    public static void put(String ip, int port, IoSession session) {
        map.put(ip + port, session);
    }

    public static void remove(String ip, int port) {
        map.remove(ip + port);
    }

    public static IoSession get(String ip, int port) {
        return map.get(ip + port);
    }
}
package com.tyhuanledi.device.entity;

import java.util.Arrays;

import com.tyhuanledi.util.ByteUtil;

public class Door {
    byte stx = 0x02;// 开始位 0x02
    byte rand = 0x00;// 随机数 保留
    byte command;// 指令
    byte address = 0x00;// 控制器地址 保留
    byte door;// 门编号 1-4
    byte lengthL; // 数据长度低位
    byte lengthH; // 数据长度高位
    byte[] data;//
    byte cs;// 校验
    byte etx = 0x03;// 结束 0x03

    public Door() {

    }
    public Door(byte[] data) {
        command = data[2];
        address = data[4];
        lengthL = data[5];
        lengthH = data[6];
        int dataLen = ByteUtil.getLength(lengthL, lengthH);
        if (dataLen > 0) {
            this.data = Arrays.copyOfRange(data, 7, 7 + dataLen);
        }
        cs = data[data.length - 2];
        etx = data[data.length - 1];
    }

    public byte getStx() {
        return stx;
    }

    public void setStx(byte stx) {
        this.stx = stx;
    }

    public byte getRand() {
        return rand;
    }

    public void setRand(byte rand) {
        this.rand = rand;
    }

    public byte getCommand() {
        return command;
    }

    public void setCommand(byte command) {
        this.command = command;
    }

    public byte getAddress() {
        return address;
    }

    public void setAddress(byte address) {
        this.address = address;
    }

    public byte getDoor() {
        return door;
    }

    public void setDoor(byte door) {
        this.door = door;
    }

    public byte getLengthL() {
        return lengthL;
    }

    public void setLengthL(byte lengthL) {
        this.lengthL = lengthL;
    }

    public byte getLengthH() {
        return lengthH;
    }

    public void setLengthH(byte lengthH) {
        this.lengthH = lengthH;
    }

    public byte[] getData() {
        return data;
    }

    public void setData(byte[] data) {
        this.data = data;
    }

    public byte getCs() {
        return cs;
    }

    public void setCs(byte cs) {
        this.cs = cs;
    }

    public byte getEtx() {
        return etx;
    }

    public void setEtx(byte etx) {
        this.etx = etx;
    }
}
package com.tyhuanledi.device.entity;

import java.util.Arrays;

import com.tyhuanledi.util.ByteUtil;

public class DoorCommand {
    public static final byte HEART = 0x56;//心跳命令
    public static final byte OPEN = 0x2C;//开门命令
    public static final byte OPEN_SUCC = 0x06;//开门成功
    public static final byte CLOSE = 0x2E;//关门命令

    public static byte[] buildCommand(byte command, int doorNo, byte[] data) {
        if(data == null){
            data = new byte[0];
        }

        byte[] message = new byte[9 + data.length];
        message[0] = 0x02;
        message[1] = 0x00;
        message[2] = command;
        message[3] = 0x00;
        message[4] = (byte) doorNo;
        message[5] = ByteUtil.getLower(data.length);
        message[6] = ByteUtil.getHigh(data.length);
        if(data != null && data.length > 0){
            System.arraycopy(message, 7, data, 0, data.length);
        }
        message[message.length - 2] = getCs(Arrays.copyOfRange(message, 0, message.length - 2));
        message[message.length - 1] = 0x03;
        return message;
    }

    public static byte getCs(byte[] data){
        byte cs = 0;
        for(byte b : data){
            cs ^= b;
        }
        return cs;
    }

    public static byte[] createHeartCommand() {
        return buildCommand(HEART, 1, null);
    }

    public static Object createOpenCommand(int doorNo) {
        return buildCommand(OPEN, doorNo, null);
    }

    public static Object createCloseCommand(int doorNo) {
        return buildCommand(CLOSE, doorNo, null);
    }

    public static boolean validate(byte[] data){
        byte checkCode = getCs(Arrays.copyOfRange(data, 0, data.length - 2));
        byte checkCode1 = data[data.length - 2];
        return checkCode == checkCode1;
    }

}
package com.tyhuanledi.util;

public class ByteUtil {

    /**
     * 获取高地位长度 v1.0 zhc 2016年1月13日下午3:30:01
     * 
     * @param lengthH
     * @param LengthL
     * @return int
     */
    public static int getLength(byte lengthH, byte LengthL) {
        return lengthH << 8 | LengthL;
    }

    /**
     * 获取高位 v1.0 zhc 2016年1月13日下午4:08:31
     * 
     * @param length
     * @return byte
     */
    public static byte getLower(int num) {
        return (byte) (num >> 8);
    }

    /**
     * 获取低位 v1.0 zhc 2016年1月13日下午4:11:14
     * 
     * @param length
     * @return byte
     */
    public static byte getHigh(int num) {
        return (byte) (num & 0xff00);
    }

    public static String toHexStr(byte[] data) {
        final String HEX = "0123456789ABCDEF";
        StringBuilder sb = new StringBuilder(data.length * 2);
        for (byte b : data) {
            if(sb.length() > 0){
                sb.append(",");
            }
            sb.append(HEX.charAt((b >> 4) & 0x0f));
            sb.append(HEX.charAt(b & 0x0f));

        }

        return sb.toString();
    }
}

jar包：
log4j-1.2.17.jar
mina-core-2.0.9.jar
slf4j-api-1.7.12.jar
slf4j-log4j12-1.7.12.jar

配置文件：
log4j.properties

qq1247
关注
专栏目录
mina框架使用总结.doc
09-19
MINA 框架是基于 Java 的 NIO 包的封装，提供了一个简单、灵活、可扩展的网络应用程序开发框架。它封装了许多底层的细节，使开发者可以集中精力到业务逻辑上来。 2. MINA 框架的优点 MINA 框架的优点在于它提供了...
mina框架详解
ljx8928358的专栏
07-18 5万+
Apache Mina Server 是一个网络通信应用框架，也就是说，它主要是对基于TCP/IP、UDP/IP协议栈的通信框架（当然，也可以提供JAVA 对象的序列化服务、虚拟机管道通信服务等），Mina 可以帮助我们快速开发高性能、高扩展性的网络通信应用，Mina 提供了事件驱动、异步（Mina 的异步IO 默认使用的是JAVA NIO 作为底层支持）操作的编程模型。Mina 主要有1.x 和
Android项目中使用mina处理TCP/IP 通信
Lewis的专栏
10-29 3116
在最近的项目中使用Mina处理TCP/IP通信，感觉框架还是很强大，可以大大的提高开发效率，非常推荐大家在项目中使用。 在Android项目中使用Mina需要导入一下两个lib:
Mina学习笔记(2) HelloWorld(TCP/IP)
spt_dream的博客
02-10 424
这里来写一个简单的基于 TCP/IP 协议的c-s 实例 1、引入相关jar包，只需引入mina-core.jar 和 log4j 及相关实现包即可 这里是mina所需jar包及其下载地址 MINA 2.x CoreJDK 1.5 or greaterSLF4J 1.3.0 or greater Log4J 1.2 users: slf4j-api.jar, slf4j-log4j
使用Apache Mina构建TCP长连接：一个高效、可靠的网络通信框架
gitblog_00059的博客
03-29 332
使用Apache Mina构建TCP长连接：一个高效、可靠的网络通信框架 项目地址:https://gitcode.com/sddyljsx/tcp-long-connection-based-on-apache-mina 在现代软件开发中，尤其是对于需要实时数据传输的应用，例如在线游戏、物联网(IoT)设备或者金融交易系统，TCP长连接是一种非常重要的技术。本文将向您推荐一个基于Apache M...
Apache mina 获取远程客户端IP
10-30 5319
项目用mina做，有个需求需要获取远程客户端的ip        于是我找了找。发现session有个方法可以获得。        session.getRemoteAddress().toString();        只是得到的dd是ip+端口号，如：/59.64.40.137:5410        很奇怪得不到ip，不过得到这个也行了，把里面的ip自己截出来就行了
基于Android开发MINA框架使用详解
12-15
MINA是一个用Java编写的高性能、异步I/O框架，适用于多种传输协议，如TCP/IP和UDP/IP。在Android平台上，MINA可以简化网络通信的实现，帮助开发者专注于业务逻辑，而不是底层通信细节。 本教程将深入探讨如何在...
详解 微信小程序开发框架（MINA）
10-16
微信小程序开发框架MINA是一项革命性的技术，旨在简化开发者在微信平台上的开发流程，使其能够在无需下载安装的情况下，开发出可提供原生App体验的服务。MINA框架的设计理念是易于学习和使用，同时保持高效率，它将...
TCP通讯框架资源包，mina 通讯框架
07-11
Mina不仅支持TCP/IP协议，还支持UDP/IP和其他多种协议，能够帮助开发者快速构建高性能、高并发的网络服务。 Mina的核心特性包括： 1. **非阻塞I/O**：Mina采用了NIO（Non-blocking I/O）模型，允许同时处理大量...
基于spring的Mina框架
05-08
简单的基于spring的mina 框架，可以用来做tcp网络连接。
Mina获取客户端IP地址问题
海涛的博客
04-23 1万+
使用Mina做Socket通信时，服务器端获取客户端IP地址，其实很简单，代码如下： @Override public void messageReceived(IoSession session, Object message) throws Exception { String clientIP = ((InetSocketAddress)session.getRemoteA
实用简介：MQTT协议及其在物联网中的应用
happytofly的博客
05-11 8660
原文链接：A Brief, but Practical Introduction to the MQTT Protocol and its Application to IoT 作者：Ben Howes 译者：孙薇 责编：周建丁（zhoujd@csdn.net） MQTT （Message Queuing Telemetry Transport，消息队列遥测传输） 是一种...
Java获取客户端ip和端口
A_Runner的博客
09-04 8503
“青枫江上秋帆远，白帝城边古木疏” 如果你的方法参数里面直接有request，像下面这样： @RequestMapping(&quot;/test.json&quot;) @ResponseBody public Map&amp;lt;String,Object&amp;gt; getIpAndLoginname(HttpServletRequest request, HttpServletRespo...
智能家居简单实现---使用ESP8266简单实现和APP通讯
热门推荐
LayneYao的博客
11-14 15万+
前段时间，公司利用 ESP8266 这个WiFi模块，做了好多小产品。从手机 APP 直连这个 ESP8266 进行通讯，再到实现远程控制。中间实现过程磕磕碰碰，虽然这方面已经做得非常成熟，但是网上的资料少之又少。现在把实现方式展示出来，同时也算是做一个笔记。 首先这里要实现的是Android端的APP直连ESP8266进行双向通讯。 如果想了解Android端的APP远程连接与ESP8266...
基于SpringBoot仿天猫购物系统.zip(毕设&课设&实训&大作业&竞赛&项目)
最新发布
09-20
项目工程资源经过严格测试可直接运行成功且功能正常的情况才上传，可轻松复刻，拿到资料包后可轻松复现出一样的项目，本人系统开发经验充足（全领域），有任何使用问题欢迎随时与我联系，我会及时为您解惑，提供帮助。 【资源内容】：包含完整源码+工程文件+说明（如有）等。答辩评审平均分达到96分，放心下载使用！可轻松复现，设计报告也可借鉴此项目，该资源内项目代码都经过测试运行成功，功能ok的情况下才上传的。 【提供帮助】：有任何使用问题欢迎随时与我联系，我会及时解答解惑，提供帮助 【附带帮助】：若还需要相关开发工具、学习资料等，我会提供帮助，提供资料，鼓励学习进步 【项目价值】：可用在相关项目设计中，皆可应用在项目、毕业设计、课程设计、期末/期中/大作业、工程实训、大创等学科竞赛比赛、初期项目立项、学习/练手等方面，可借鉴此优质项目实现复刻，设计报告也可借鉴此项目，也可基于此项目来扩展开发出更多功能 下载后请首先打开README文件（如有），项目工程可直接复现复刻，如果基础还行，也可在此程序基础上进行修改，以实现其它功能。供开源学习/技术交流/学习参考，勿用于商业用途。质量优质，放心下载使用。
Mina2.0框架：TCP/IP协议下NIO编程详解与源码解析
该框架是Apache提供的一个高性能和高扩展性的网络应用基础设施，用于简化基于TCP/IP和其他传输协议的异步应用程序设计。Mina的核心组件包括IoService接口、IoFilter接口和IoHandler接口，它们分别负责基础的IO操作、...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值