Android 使用Mina框架


Android 使用Mina框架

下载mina框架:
将下载好的包解压出来,将dist/mina-core-2.0.16.jar和lib/slf4j-api-1.7.21.jar拷贝到工程目录中,进入Project Structure->Dependencies将这两个jar包添加为新的File Dependency。


开启一个子线程用于建立Mina长连接,建立重连机制
/**
 * Created by luohan on 2016/12/9.
 */
public class MinaThread extends Thread {
    private static String TAG = "[MinaThread]";
    //30秒后超时
    private static final int IDELTIMEOUT = 10;
    //15秒发送一次心跳包
    private static final int HEARTBEATRATE = 10;
    //服务器地址
    private static final String SERVER_ADDRESS = "192.168.3.20";
    private static final int SERVER_POST = 6001; 

    public  DataCallbackListener mc_dataCallbackListener;
    private ClientHandler clientHandler;
    private ConnectFuture connectFuture;
    private IoSession session;
    private IoConnector connector;
    OBDConnectionService target;

    public MinaThread(OBDConnectionService target) {
        this.target = target;
    }

    @Override
    public void run() {
        super.run();
        initialize();
        conntection();
        minaClose();
        if(target != null){
            target.disconnect();
        }
    }

    public void setupConnectFuture() {
        if(connectFuture == null) {
            connectFuture = connector.connect(new InetSocketAddress(SERVER_ADDRESS, SERVER_POST) ); 
        }
        return;
    }

    /**
     * 设置外部回调
     */
    public void initialize() {
        /* ClientHandler */
        if (clientHandler == null) {
            clientHandler = new ClientHandler();
            clientHandler.setDataCallbackListener(new ClientHandler.DataCallbackListener() {
                @Override
                public void data(Map<String, String> iboxData) {
                    if (mc_dataCallbackListener != null) {
                        mc_dataCallbackListener.data(iboxData);
                    }
                }
            });
        }
    }

    private void conntection() {
        if(connector == null) {
            connector = new NioSocketConnector();
            /* 添加过滤器 */
            connector.getFilterChain().addLast("logger", new LoggingFilter());
            connector.getFilterChain().addLast("codec", new ProtocolCodecFilter(new ClientCodecFactory()));
            /* ReadBufferSize */
            connector.getSessionConfig().setReadBufferSize(1024 * 10);
            /* 设置链接超时时间 */
            connector.setConnectTimeoutMillis(10 * 1000);
            /* timeout for read and write */
            connector.getSessionConfig().setIdleTime(IdleStatus.BOTH_IDLE, IDELTIMEOUT);
            //设置心跳工程
            KeepAliveMessageFactory heartBeatFactory = new KeepAliveMessageFactoryImpl();
             当读操作空闲时发送心跳
            KeepAliveFilter heartBeat = new KeepAliveFilter(heartBeatFactory);
            // 设置心跳包请求后超时无反馈情况下的处理机制,默认为关闭连接,在此处设置为输出日志提醒
            heartBeat.setRequestTimeoutHandler(KeepAliveRequestTimeoutHandler.LOG);
            /** 是否回发 */
            heartBeat.setForwardEvent(false);
            /** 发送频率 */
            heartBeat.setRequestInterval(HEARTBEATRATE);
            /** 设置心跳包请求后 等待反馈超时时间。 超过该时间后则调用KeepAliveRequestTimeoutHandler.CLOSE */
            heartBeat.setRequestTimeout(IDELTIMEOUT);
            //connector.getSessionConfig().setKeepAlive(true);
            connector.getFilterChain().addLast("heartbeat", heartBeat);

            //connector.getFilterChain().addLast("reconnect", new KeepAliveRequestTimeoutHandlerImpl()); //心跳超时后的处理,这里先默认处理

        }
        try{
            if(connectFuture == null) {
                connector.setHandler(clientHandler);
                setupConnectFuture();
            }
            Log.d(TAG,"开始于服务器建立连接...");
            connectFuture.awaitUninterruptibly(); //等待连接创建完成
            session = connectFuture.getSession(); //获得seccion
            //连接成功
            if (session != null && session.isConnected()) {
                target.connected();
                Log.d(TAG,"连接成功");
            } else {
                target.disconnect();
            }

        }catch (Exception e){
            Log.d(TAG, "客户端链接异常(在连接时直接抛出了异常):");
            Log.e(TAG, e.toString());
        }
        if (session != null && session.isConnected()) {
            session.getCloseFuture().awaitUninterruptibly();// 等待连接断开
            System.out.println("客户端断开");
        }
    }

    public void writeData(String order, String msg){
        if(session != null && session.isConnected()) {
            session.write(order);
            Log.d(TAG, "数据上报成功:" + msg);
            return;
        }
    }

    /**
     * 关闭Mina长连接 **
     */
    public void minaClose(){
        if (session != null) {
            session.close(false);
            session = null;
        }
        if (connectFuture != null && connectFuture.isConnected()) {
            connectFuture.cancel();
            connectFuture = null;
        }
        if (connector != null && !connector.isDisposed()) {
            //清空里面注册的所以过滤器
            connector.getFilterChain().clear();
            connector.dispose();
            connector = null;
        }

        Log.i(TAG, "MINA长连接已关闭...");
        Log.i(TAG, "MINA长连接已关闭...");
    }

    /* 接口 */
    public interface DataCallbackListener{
        public void data(Map<String, String> iboxData);
    }

    public void setDataCallbackListener(DataCallbackListener listener) {
        this.mc_dataCallbackListener = listener;
    }
}

ClientHandler、ClientDecoder、ClientEncoder是我自己写的数据处理类,用于做更细致的数据处理。从以上代码可以看出,我的做法是,一旦长连接断开,线程会终止并告知主线程,此时,需要在主线程重新开启新线程去建立Mina长连接。心跳检测是使用Mina自带的心跳工厂,而断线重连机制则是通过关闭和开启线程来实现的,你也可以继承IoServiceListener自己根据不同的状态做相关处理。

外部调用的部分代码:
private void connectionService(){
    closeMinaThread();
    if(minaThread == null) {
        minaThread = new MinaThread(this);
        minaThread.initialize();
        minaThread.setDataCallbackListener(minaCallbackListener);
        minaThread.start();
    }
}

private void closeMinaThread() {
    if(minaThread != null) {
        minaThread.interrupt();
        minaThread = null;
    }
}

private void sendOBDData(String order, String display) {
    if(minaThread!=null && isConnected)
        minaThread.writeData(order, display);
}

public void disconnect(){
    isConnected = false;
    closeMinaThread();
    repetition();
}
public void connected(){
    isConnected = true;
}

private void repetition() {
    stopCountdown();
    Log.e(TAG, "----------请求失败, 5s后重新连接--------");
    timer = new Timer();
    timer.schedule(new TimerTask() {
        @Override
        public void run() {
            connectionService();
        }
    }, 7000);
}

private void stopCountdown(){
    if(timer != null){
        timer.cancel();
        timer = null;
    }
}



  • 4
    点赞
  • 8
    收藏
    觉得还不错? 一键收藏
  • 3
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 3
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值