简单玩mina的socekt的服务端和客户端，自定义事务处理器&监听器&心跳监听

最新推荐文章于 2021-12-30 11:25:14 发布
最新推荐文章于 2021-12-30 11:25:14 发布
阅读量295 收藏 1
点赞数 1
分类专栏： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40539437/article/details/114649645
版权

1.项目结构

最好自己在翻一番源码，本人研究了2天netty但是没有研究明白发现这两款框架与很多相似之处，比如
netty的默认线程数为cpu核数*2，但是也自己可以根据构造传入线程数
mina的默认线程数为cpu核数+1,但是没找到从哪里可以传入线程数，有大佬可以回一下

netty主要针对的是channel
mina主要针对的是session

等等，这俩框架还在研究中，
mima有很多默认的实现，但是大多数支持重写
有什么问题可以讨论，我也多学习学习，我也可以把我研究netty的记录发出来

也可以看看官网api
http://mina.apache.org/mina-project/userguide/ch1-getting-started/ch1.4-first-steps.html
在这里插入图片描述

2.maven依赖

<dependencies>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-api</artifactId>
            <version>1.6.6</version>
            <type>jar.sha256</type>
        </dependency>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-log4j12</artifactId>
            <version>1.6.6</version>
        </dependency>
        <dependency>
            <groupId>org.rxtx</groupId>
            <artifactId>rxtx</artifactId>
            <version>2.1.7</version>
            <scope>provided</scope>
        </dependency>
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>1.2.17</version>
        </dependency>
        <dependency>
            <groupId>org.apache.mina</groupId>
            <artifactId>mina-core</artifactId>
            <version>2.0.7</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>3.8.1</version>
            <scope>test</scope>
        </dependency>
    </dependencies>

3.日志管理（必配）

log4j.properties

###set log levels -for more verbose logging change 'info' to 'debug'###
log4j.rootLogger=info,stdout,file
###direct log messages to stdout###
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.Target=System.out
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%d{ABSOLUTE} %5p %c{1}:%L - %m%n

###direct messages to file mylog.log ###
log4j.appender.file=org.apache.log4j.RollingFileAppender
log4j.appender.file.File=D://log//mina//mina.log

log4j.appender.file.MaxFileSize=10240KB
## Keep one backup file
log4j.appender.file.MaxBackupIndex=1

log4j.appender.file.layout=org.apache.log4j.PatternLayout
log4j.appender.file.layout.ConversionPattern=%p %t %c - %m%n

服务端

MyServer.java

package com.mina.test.firstdemo;

import org.apache.mina.core.future.CloseFuture;
import org.apache.mina.core.service.IoAcceptor;
import org.apache.mina.core.service.IoHandlerAdapter;
import org.apache.mina.core.service.IoService;
import org.apache.mina.core.service.IoServiceListener;
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.filter.codec.textline.LineDelimiter;
import org.apache.mina.filter.codec.textline.TextLineCodecFactory;
import org.apache.mina.filter.keepalive.KeepAliveFilter;
import org.apache.mina.filter.keepalive.KeepAliveMessageFactory;
import org.apache.mina.filter.keepalive.KeepAliveRequestTimeoutHandler;
import org.apache.mina.filter.logging.LoggingFilter;
import org.apache.mina.transport.socket.nio.NioSocketAcceptor;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.charset.Charset;

public class MyServer {

    private final static Logger log = LoggerFactory.getLogger(MyServer.class);

    public static void main(String[] args) throws IOException {

        /**  Io流接收者(socket服务端) 默认开启线程数为cpu盒数*2 */
        IoAcceptor acceptor = new NioSocketAcceptor();

        try {

            /** 设置缓冲区buffer大小 */
            acceptor.getSessionConfig().setReadBufferSize(2048);

            /** 读写通道10秒内无操作进入空闲状态*/
            acceptor.getSessionConfig().setIdleTime(IdleStatus.BOTH_IDLE, 10);

            /** 自定义服务器事务处理器*/
            acceptor.setHandler(new MyServerHandler());

            /** 自定义服务器监听器 */
            acceptor.addListener(new MyListener());

            /** 自定义心跳监听器*/

            KeepAliveFilter kaf = new KeepAliveFilter(new KeepAliveMessageFactoryImpl());

            /** 这个还没有搞懂*/
            kaf.setRequestTimeoutHandler(new MyKeepAliveRequestTimeoutHandler());

            /** 设置心跳监听执行时间 单位秒*/
            kaf.setRequestInterval(1);

            /** 把心跳监听器加入（注册）到 服务器里*/
            acceptor.getFilterChain().addLast("heart", kaf);

            /** 把日志加入（注册）到 服务器 不加会报错*/
            acceptor.getFilterChain().addLast("logger", new LoggingFilter());

            /** 设置服务器的 解码格式*/
            acceptor.getFilterChain().addLast("codec",
                    new ProtocolCodecFilter(
                            new TextLineCodecFactory(Charset.forName("UTF-8")
                                    , LineDelimiter.WINDOWS.getValue(),LineDelimiter.WINDOWS.getValue())));

            /** 服务器绑定ip 和 端口号 或者叫监听的端口*/
            acceptor.bind(new InetSocketAddress("127.0.0.1",6666));
            log.info("服务端已开启！！！！！！！！！！！！！！！");
        } catch (IOException e) {
            e.printStackTrace();

        }finally {

        }


    }

}


/**
 *@Description 事务处理器
 *@Author Mr.CongShuo
 *@Date 2021/3/10 0010
 *@Time 17:03
 */

class MyServerHandler extends IoHandlerAdapter {

    /** 定义日志*/
    private final static Logger log = LoggerFactory.getLogger(MyServerHandler.class);

    /** 定义客户端关闭编码*/
    private final static String QUIT = "quit";

    @Override
    public void messageReceived(IoSession session, Object message) throws Exception {

        String str = message.toString();

        log.info("this message received is [" + str + "]");
        if(QUIT.equals(str)) {
            session.close(true);
            return;
        }
    }

    /** 事务处理器 */
    public MyServerHandler() {

    }

    /** 客户端 连接监听 函数 当有客户端走了以后会在线程池里的selector 下的fdMap 注册 也就是session会话
     *
     *  创建新连接后，从I / O处理器线程调用。 因为应该从处理多个会话的I / O的同一线程中调用此方法，
     *  所以请实现此方法以执行消耗最少时间的任务，例如套接字参数和用户定义的会话属性初始化
     **/
    @Override
    public void sessionCreated(IoSession session) throws Exception {
        super.sessionCreated(session);
        System.out.println("==============" + Thread.currentThread().getName());
        System.out.println("客户端为： " +session.getId() + "进来了");

    }

    /**
     * 当建立完成后 会打开一个通道
     * @param session
     * @throws Exception
     */
    @Override
    public void sessionOpened(IoSession session) throws Exception {
        session.write("恭喜你来了");
    }

    /**
     * 客户端关闭会调用这个函数
     * @param session
     * @throws Exception
     */
    @Override
    public void sessionClosed(IoSession session) throws Exception {
        System.out.println("线程为：" + Thread.currentThread().getName() +" 的,sessionId为:" + session.getId() + "的客户端关闭了");
    }

    /**
     * 限制状态处理
     * @param session
     * @param status
     * @throws Exception
     */
    @Override
    public void sessionIdle(IoSession session, IdleStatus status) throws Exception {
        System.out.println("线程为：" + Thread.currentThread().getName() +" 的,sessionId为:" + session.getId() + "的客户端进入了闲置状态");
    }

    /**
     * 异常状态处理
     * @param session
     * @param cause
     * @throws Exception
     */
    @Override
    public void exceptionCaught(IoSession session, Throwable cause) throws Exception {
        System.out.println("线程为：" + Thread.currentThread().getName() +" 的,sessionId为:" + session.getId() + "的客户端处理发生了异常 " + cause.getMessage());
    }

    /***
     * 向客户端发送数据
     * @param session
     * @param message
     * @throws Exception
     */
    @Override
    public void messageSent(IoSession session, Object message) throws Exception {
        System.out.println("向 线程为：" + Thread.currentThread().getName() +" 的,sessionId为:" + session.getId() + "的客户端处理发送数据");

    }


}

/**
 *@Description 监听器
 *@Author Mr.CongShuo
 *@Date 2021/3/10 0010
 *@Time 17:03
 */

class MyListener implements IoServiceListener {

    @Override
    public void serviceActivated(IoService service) throws Exception {
        System.out.println("thread-name :" + Thread.currentThread().getName());
        System.out.println("我被激活了");
    }

    @Override
    public void serviceIdle(IoService service, IdleStatus idleStatus) throws Exception {
        System.out.println("thread-name :" + Thread.currentThread().getName());
        System.out.println("我现在没事干了");
    }

    @Override
    public void serviceDeactivated(IoService service) throws Exception {
        System.out.println("thread-name :" + Thread.currentThread().getName());
        System.out.println("我现在被停用了");
    }

    @Override
    public void sessionCreated(IoSession session) throws Exception {
        System.out.println("thread-name :" + Thread.currentThread().getName());
        System.out.println("建立新回话  有人已经进来了 准备唠嗑了");
    }

    /***
     * 当有客户端走了以后会在线程池里的selector 下的fdMap 删除 也就是注册到 线程池里的session会话
     * @param session
     * @throws Exception
     */
    @Override
    public void sessionDestroyed(IoSession session) throws Exception {
        System.out.println("thread-name :" + Thread.currentThread().getName());
        System.out.println("销毁回话  有人走了");
        long id = session.getId();
        CloseFuture closeFuture = session.close(true);
        boolean closed = closeFuture.isClosed();
        if(closed){
            System.out.println("客户端 sessionId为: " + id + " 关闭成功");
            closeFuture.setClosed();
        }else{
            System.out.println("客户端 sessionId为:" + id + "关闭失败");
        }

    }
}


/**
 *@Description 心跳包
 *@Author Mr.CongShuo
 *@Date 2021/3/10 0010
 *@Time 17:04
 */
class KeepAliveMessageFactoryImpl implements KeepAliveMessageFactory {

    @Override
    public boolean isRequest(IoSession session, Object message) {
        System.out.println("====isRequest=====");
        return false;
    }

    @Override
    public boolean isResponse(IoSession session, Object message) {
        System.out.println("======是否能相应客户端=======" +  (null == message   ? "" : message.toString()));
        return  session.isConnected();
    }

    @Override
    public Object getRequest(IoSession session) {
        System.out.println("======是否能请求到客户端======");
        return null;
    }

    @Override
    public Object getResponse(IoSession session, Object request) {
        System.out.println("=====getResponse=====");
        return null;
    }



}

class MyKeepAliveRequestTimeoutHandler implements  KeepAliveRequestTimeoutHandler{

    @Override
    public void keepAliveRequestTimedOut(KeepAliveFilter filter, IoSession session) throws Exception {
        System.out.println(session.getId() + "走了");
    }
}

客户端

package com.mina.test.firstdemo;

import org.apache.mina.core.future.ConnectFuture;
import org.apache.mina.core.service.IoConnector;
import org.apache.mina.core.service.IoHandlerAdapter;
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.filter.codec.textline.LineDelimiter;
import org.apache.mina.filter.codec.textline.TextLineCodecFactory;
import org.apache.mina.filter.logging.LoggingFilter;
import org.apache.mina.transport.socket.nio.NioSocketConnector;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.net.InetSocketAddress;
import java.nio.charset.Charset;
import java.util.Scanner;

public class MyClient {
    private final static Logger log = LoggerFactory.getLogger(MyClient.class);

    public static void main(String[] args) {
        IoConnector connector = new NioSocketConnector();
        try {
            connector.getSessionConfig().setReadBufferSize(2048);
            connector.getSessionConfig().setIdleTime(IdleStatus.BOTH_IDLE, 5);
            connector.setHandler(new MyClientHandler());
            connector.getFilterChain().addLast("logger", new LoggingFilter());
            connector.getFilterChain().addLast("codec",
                    new ProtocolCodecFilter(
                            new TextLineCodecFactory(Charset.forName("UTF-8")
                                    , LineDelimiter.WINDOWS.getValue(),LineDelimiter.WINDOWS.getValue())));
            ConnectFuture connectFuture = connector.connect(new InetSocketAddress("127.0.0.1", 6666));
            connectFuture.awaitUninterruptibly();
            log.info("服务端已开启！！！！！！！！！！！！！！！");
            IoSession session = connectFuture.getSession();
            Scanner sc = new Scanner(System.in);
            boolean quit = false;
            while (!quit) {
                String str = sc.next();
                if (str.equalsIgnoreCase("quit")) {
                    quit = true;
                }
                session.write(str);
            }

            if (session != null) {
                if (session.isConnected()) {
                    session.getCloseFuture().awaitUninterruptibly();
                }

                connector.dispose(true);
            }

        } catch (Exception e) {

            e.printStackTrace();

        }finally {

        }
    }

}

class MyClientHandler extends IoHandlerAdapter {
    /** 定义日志*/
    private final static Logger log = LoggerFactory.getLogger(MyClientHandler.class);
    @Override
    public void messageSent(IoSession arg0, Object message) throws Exception {
        System.out.println("客户端收到信息" + message.toString());
    }

    public MyClientHandler() {

    }

    @Override
    public void sessionCreated(IoSession session) throws Exception {

    }

    @Override
    public void sessionOpened(IoSession session) throws Exception {

    }

    @Override
    public void sessionClosed(IoSession session) throws Exception {

    }

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

    }

    @Override
    public void exceptionCaught(IoSession session, Throwable cause) throws Exception {

    }

    @Override
    public void messageReceived(IoSession session, Object message) throws Exception {
        String str = message.toString();

        log.info("this message received is [" + str + "]");
    }
}

还有功能没有研究到 可以探究

这个文章写得也挺好
https://blog.csdn.net/defonds/article/details/18315563

奋斗的小菜菜
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
MINA 服务端和客户端demo
03-09
在"MINA 服务端和客户端demo"中，我们有两个主要的部分：服务端（Server）和客户端（Client）。这两个部分都是基于MINA框架构建的，分别实现了服务器接收客户端连接、处理数据和客户端发起连接、发送数据的功能。 1...
mina框架中socket使用，有服务端和客户端。
03-18
5. **事件驱动模型**：MINA采用事件驱动模型，通过监听器和处理器来处理各种网络事件，如连接建立、数据接收、连接关闭等。这些处理器（如`ExceptionHandler`、`MessageReceivedHandler`等）可以自定义实现，以处理...
Apache MINA 快速入门指南
MRmaomaochong的专栏
01-05 1117
<br />题记：<br /> <br />    最近用到Socket套接字编程，在服务器监听方面还没有具体思路，朋友推荐了Apahce Mina，就在官方看了一下快速入门文档。原文是英文的，学习之余就将它翻译出来和大家共享！关于Mina的中文简介内容不多就摘抄了一些。<br /> <br />    “MINA是一个Socket的网络框架，但是它提供了方便的Protocol支持，通过它的Encoder和Decoder，你将你的应用可以方便的扩展并支持各种基于Socket的网络协议，比如HTTP服务器、F
Apache MINA 快速入门指南-时间服务器
wjp553650958的专栏
09-11 1578
最近用到Socket套接字编程，在服务器监听方面还没有具体思路，朋友推荐了Apahce Mina，就在官方看了一下快速入门文档。原文是英文的，学习之余就将它翻译出来和大家共享！关于Mina的中文简介内容不多就摘抄了一些。     “MINA是一个Socket的网络框架，但是它提供了方便的Protocol支持，通过它的Encoder和Decoder，你将你的应用可以方便的扩展并支持各种基于S
SpringMVC4.x+Mina+WebSocket+Hibernate4.x实现高并发网页及时通讯框架！（H5+BaiduMap-JSApi）
小南
02-01 3981
应用环境： 最近研究一个项目，一个地图应用，基于百度地图JS-API开发的。 需要和现有的旧项目对接，旧项目也是公司的，但是是十年左右的技术架构，原来受到技术和硬件的限制，采用Socket为主要的通讯方式。并且由于公司人力资源有限不可能对这个旧项目大刀阔斧的改动。所以博主建议的采用webservice为主要的通讯方式啥的，全是扯淡，不能实际实现。 然后博主想过用MQ，一则，没怎么用到过项目里
androidpn解析
hjh200507609的专栏
12-17 982
通信机制 Androidpn是韩国Sehwan No写的开源消息推送项目，很多大公司都用这个消息推送方式构建自己的消息推送服务，缺点是导致客户端比较耗电。通信机制分别由客户端和服务器完成。 客户端采用基于java的XMPP协议包asmack（该包依赖于openfire下的开源项目smack）。通过该协议包提供的XMPPConnetcion类与服务器建立持久连接，并通过该连接进行用户注册
解剖AndroidPN消息推送
哈利路亚的收藏夹
06-10 709
通信机制 Androidpn是韩国Sehwan No写的开源消息推送项目，很多大公司都用这个消息推送方式构建自己的消息推送服务，缺点是导致客户端比较耗电。通信机制分别由客户端和服务器完成。 客户端采用基于java的XMPP协议包asmack（该包依赖于openfire下的开源项目smack）。通过该协议包提供的XMPPConnetcion类与服务器建立持久连接，并通过该连接进行用户注册
androidpn推送
a468903507的专栏
03-21 1470
通信机制 Androidpn是韩国Sehwan No写的开源消息推送项目，很多大公司都用这个消息推送方式构建自己的消息推送服务，缺点是导致客户端比较耗电。通信机制分别由客户端和服务器完成。 客户端采用基于java的XMPP协议包asmack（该包依赖于openfire下的开源项目smack）。通过该协议包提供的XMPPConnetcion类与服务器建立持久连接，并通过该连接进行用户
mina2服务端客户端实例，保证能够正常运行
05-22
标题中提到的"mina2服务端客户端实例"是指使用Apache MINA 2版本创建的一个工作示例，该示例包含了服务端和客户端的完整代码，旨在帮助开发者理解如何在实际项目中运用MINA进行网络通信。通过导入Eclipse这样的集成...
Mina开发实例(服务端、客户端）DEMO
12-29
Apache Mina是一个高度可扩展的网络通信框架，它允许开发者创建高性能、高效率的服务端和客户端应用程序。在Java世界中，Mina以其简洁的API和灵活性而受到青睐，尤其适用于处理大量的并发连接，如TCP/IP和UDP协议。...
AndroidMina服务端和客户端的实现
04-01
总之，通过Apache Mina，我们可以轻松地在Android上实现服务端和客户端的网络通信，无论是简单的字符串传递还是复杂的对象交互，都能得到高效、稳定的支持。在实现过程中，理解数据编码与解码的过程、网络权限的设置...
Dubbo + Zookeeper （认知）
坚持就是胜利的博客
12-28 5229
之前讲到 eureka 可能有些同学 对这个没有了解那么 在这章做补充说明 1.Zookeeper:分布式应用程序的分布式协调服务 ZooKeeper是用于分布式应用程序的分布式，开放源代码协调服务。它公开了一组简单的原语，分布式应用程序可以基于这些原语来实现用于同步，配置维护以及 组和命名的更高级别的服务。他的设计易于编程，并使用了按照文件系统熟悉的目录数结构样式设置的数据模型。它以我们的ja...
Swagger-UI 之 简单使用
坚持就是胜利的博客
01-05 4936
Swagger-UI的简单使用 1.什么是Swagger-UI Swagger Swagger UI允许任何人（无论您是开发团队还是最终用户）都可以可视化API资源并与之交互，而无需任何实现逻辑。它是根据您的OpenAPI（以前称为Swagger）规范自动生成的，具有可视化文档，可简化后端实现和客户端使用。 下面让我们看看在项目中如何使用 这里用到的是spring Boot 导入maven 依赖 ...
Nacos 使用域名的方式访问 注意事项
坚持就是胜利的博客
12-30 4580
方式一 升级版本 2.2.1.RELEASE 以上 <dependency> <groupId>com.alibaba.cloud</groupId> <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId> </dependency> ​ <dependency> <groupId>com.alibaba.cloud
JWT 公钥 私钥 生成 代码
坚持就是胜利的博客
01-06 4282
这里用到的是MAVEN 工程 需要引入 依赖 <dependencies> <dependency> <groupId>joda-time</groupId> <artifactId>joda-time</artifactId> </...
curl 携带cookie 数据
坚持就是胜利的博客
01-20 3694
nginx + zuul + eureka之反向代理 流程
坚持就是胜利的博客
12-24 2337
我们tomcat一般在浏览器访问的地址之前都是 http://localhost:8080 或者 http://127.0.0.1:8080 那么这个localhost是谁给替换的呢，如果我们知道的话是不是可以替换成像www.baidu.com这样的域名呢 那么我们先来了解一下浏览器的本质，原来浏览器当得到一个域名的时候先去本地的C:\Windows\System32\drivers\etc\...
使用Mina客户端如何和服务端建立长连接
最新发布
04-14
1. 客户端调用Mina的IoConnector#connect()方法连接到服务端 2. 在IoConnector#connect()方法中，设置ConnectFutureListener监听连接结果 3. 如果连接成功，则在ConnectFutureListener#operationComplete()方法中，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值