Mina長連線框架實現Android客戶端與伺服器端通訊

阿新 • • 發佈：2019-02-14

一、概述

Apache Mina Server 是一個網路通訊應用框架，也就是說，它主要是對基於TCP/IP、UDP/IP協議棧的通訊框架（當然，也可以提供JAVA 物件的序列化服務、虛擬機器管道通訊服務等），Mina 可以幫助我們快速開發高效能、高擴充套件性的網路通訊應用，Mina 提供了事件驅動、非同步（Mina 的非同步IO 預設使用的是JAVA NIO 作為底層支援）操作的程式設計模型。

二、伺服器端程式碼

MinaService.java

package com.czhappy.mina;

import java.net.InetSocketAddress;
import java.util.Date;

import org.apache.mina.core.service.IoAcceptor;
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.serialization.ObjectSerializationCodecFactory;
import org.apache.mina.filter.logging.LoggingFilter;
import org.apache.mina.transport.socket.nio.NioSocketAcceptor;

public class MinaService {

	public static void main(String[] args) {
		IoAcceptor acceptor = new NioSocketAcceptor();
		//新增日誌過濾器
		acceptor.getFilterChain().addLast("logger", new LoggingFilter());
		acceptor.getFilterChain().addLast("codec", new ProtocolCodecFilter(new ObjectSerializationCodecFactory()));
		acceptor.setHandler(new DemoServerHandler());
		acceptor.getSessionConfig().setReadBufferSize(2048);
		acceptor.getSessionConfig().setIdleTime(IdleStatus.BOTH_IDLE, 10);
		try {
			acceptor.bind(new InetSocketAddress(9226));
		} catch (Exception e) {
			e.printStackTrace();
		}
		System.out.println("啟動服務");
	}
	
	/**  
	 * @ClassName: DemoServerHandler  
	 * @Description: 負責session物件的建立和監聽以及訊息的建立和接收監聽
	 * @author chenzheng
	 * @date 2016-12-9 下午3:57:11  
	 */
	private static class DemoServerHandler extends IoHandlerAdapter{
		
		//伺服器與客戶端建立連線
		@Override
		public void sessionCreated(IoSession session) throws Exception {
			System.out.println("伺服器與客戶端建立連線...");
			super.sessionCreated(session);
		}

		
		@Override
		public void sessionOpened(IoSession session) throws Exception {
			System.out.println("伺服器與客戶端連線開啟...");
			super.sessionOpened(session);
		}
		
		//訊息的接收處理
		@Override
		public void messageReceived(IoSession session, Object message)
				throws Exception {
			// TODO Auto-generated method stub
			super.messageReceived(session, message);
			String str = message.toString();
			Date date = new Date();
			session.write(date.toString());
			System.out.println("接收到的資料："+str);
			
		}
		
		@Override
		public void messageSent(IoSession session, Object message)
				throws Exception {
			// TODO Auto-generated method stub
			super.messageSent(session, message);
		}
		
		@Override
		public void sessionClosed(IoSession session) throws Exception {
			// TODO Auto-generated method stub
			super.sessionClosed(session);
		}
	}
}

三、Android客戶端程式碼

ConnectionConfig.java

package com.czhappy.minaclient;

import android.content.Context;

/**
 * Description:構建者模式
 * User: chenzheng
 * Date: 2016/12/9 0009
 * Time: 16:37
 */
public class ConnectionConfig {

    private Context context;
    private String ip;
    private int port;
    private int readBufferSize;
    private long connectionTimeout;

    public Context getContext() {
        return context;
    }

    public String getIp() {
        return ip;
    }

    public int getPort() {
        return port;
    }

    public int getReadBufferSize() {
        return readBufferSize;
    }

    public long getConnectionTimeout() {
        return connectionTimeout;
    }

    public static class Builder{
        private Context context;
        private String ip = "192.168.168.20";
        private int port = 9226;
        private int readBufferSize = 10240;
        private long connectionTimeout = 10000;

        public Builder(Context context){
            this.context = context;
        }

        public Builder setIp(String ip){
            this.ip = ip;
            return this;
        }

        public Builder setPort(int port){
            this.port = port;
            return this;
        }

        public Builder setReadBufferSize(int readBufferSize){
            this.readBufferSize = readBufferSize;
            return this;
        }

        public Builder setConnectionTimeout(long connectionTimeout){
            this.connectionTimeout = connectionTimeout;
            return this;
        }

        private void applyConfig(ConnectionConfig config){

            config.context = this.context;
            config.ip = this.ip;
            config.port = this.port;
            config.readBufferSize = this.readBufferSize;
            config.connectionTimeout = this.connectionTimeout;
        }

        public ConnectionConfig builder(){
            ConnectionConfig config = new ConnectionConfig();
            applyConfig(config);
            return config;
        }
    }
}

ConnectionManager.java

package com.czhappy.minaclient;

import android.content.Context;
import android.content.Intent;
import android.support.v4.content.LocalBroadcastManager;
import android.util.Log;

import org.apache.mina.core.future.ConnectFuture;
import org.apache.mina.core.service.IoHandlerAdapter;
import org.apache.mina.core.session.IoSession;
import org.apache.mina.filter.codec.ProtocolCodecFilter;
import org.apache.mina.filter.codec.serialization.ObjectSerializationCodecFactory;
import org.apache.mina.filter.logging.LoggingFilter;
import org.apache.mina.transport.socket.nio.NioSocketConnector;

import java.lang.ref.WeakReference;
import java.net.InetSocketAddress;

/**
 * Description:
 * User: chenzheng
 * Date: 2016/12/9 0009
 * Time: 16:21
 */
public class ConnectionManager {

    private static final String BROADCAST_ACTION = "com.commonlibrary.mina.broadcast";
    private static final String MESSAGE = "message";
    private ConnectionConfig mConfig;
    private WeakReference<Context> mContext;

    private NioSocketConnector mConnection;
    private IoSession mSession;
    private InetSocketAddress mAddress;

    public ConnectionManager(ConnectionConfig config){

        this.mConfig = config;
        this.mContext = new WeakReference<Context>(config.getContext());
        init();
    }

    private void init() {
        mAddress = new InetSocketAddress(mConfig.getIp(), mConfig.getPort());
        mConnection = new NioSocketConnector();
        mConnection.getSessionConfig().setReadBufferSize(mConfig.getReadBufferSize());
        mConnection.getFilterChain().addLast("logging", new LoggingFilter());
        mConnection.getFilterChain().addLast("codec", new ProtocolCodecFilter(new ObjectSerializationCodecFactory()));
        mConnection.setHandler(new DefaultHandler(mContext.get()));
        mConnection.setDefaultRemoteAddress(mAddress);
    }

    /**
     * 與伺服器連線
     * @return
     */
    public boolean connnect(){
        Log.e("tag", "準備連線");
        try{
            ConnectFuture future = mConnection.connect();
            future.awaitUninterruptibly();
            mSession = future.getSession();

            SessionManager.getInstance().setSeesion(mSession);

        }catch (Exception e){
            e.printStackTrace();
            Log.e("tag", "連線失敗");
            return false;
        }

        return mSession == null ? false : true;
    }

    /**
     * 斷開連線
     */
    public void disContect(){
        mConnection.dispose();
        mConnection=null;
        mSession=null;
        mAddress=null;
        mContext = null;
        Log.e("tag", "斷開連線");
    }

    private static class DefaultHandler extends IoHandlerAdapter{

        private Context mContext;
        private DefaultHandler(Context context){
            this.mContext = context;

        }

        @Override
        public void sessionOpened(IoSession session) throws Exception {
            super.sessionOpened(session);
        }

        @Override
        public void messageReceived(IoSession session, Object message) throws Exception {
            Log.e("tag", "接收到伺服器端訊息："+message.toString());
            if(mContext!=null){
                Intent intent = new Intent(BROADCAST_ACTION);
                intent.putExtra(MESSAGE, message.toString());
                LocalBroadcastManager.getInstance(mContext).sendBroadcast(intent);
            }
        }
    }
}

MinaService.java

package com.czhappy.minaclient;

import android.app.Service;
import android.content.Context;
import android.content.Intent;
import android.os.HandlerThread;
import android.os.IBinder;
import android.support.annotation.Nullable;
import android.util.Log;

/**
 * Description:
 * User: chenzheng
 * Date: 2016/12/9 0009
 * Time: 17:17
 */
public class MinaService extends Service{

    private ConnectionThread thread;


    @Override
    public void onCreate() {
        super.onCreate();
        thread = new ConnectionThread("mina", getApplicationContext());
        thread.start();
        Log.e("tag", "啟動執行緒嘗試連線");
    }

    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        return super.onStartCommand(intent, flags, startId);
    }

    @Override
    public void onDestroy() {
        super.onDestroy();
        thread.disConnect();
        thread=null;

    }

    @Nullable
    @Override
    public IBinder onBind(Intent intent) {
        return null;
    }

    class ConnectionThread extends HandlerThread{

        private Context context;
        boolean isConnection;
        ConnectionManager mManager;
        public ConnectionThread(String name, Context context){
            super(name);
            this.context = context;

            ConnectionConfig config = new ConnectionConfig.Builder(context)
                    .setIp("192.168.168.20")
                    .setPort(9226)
                    .setReadBufferSize(10240)
                    .setConnectionTimeout(10000).builder();

            mManager = new ConnectionManager(config);
        }

        @Override
        protected void onLooperPrepared() {
            while(true){
                isConnection = mManager.connnect();
                if(isConnection){
                    Log.e("tag", "連線成功");
                    break;
                }
                try {
                    Log.e("tag", "嘗試重新連線");
                    Thread.sleep(3000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }

        public void disConnect(){
            mManager.disContect();
        }
    }
}

SessionManager.java

package com.czhappy.minaclient;

import android.util.Log;

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

/**
 * Description:
 * User: chenzheng
 * Date: 2016/12/9 0009
 * Time: 17:50
 */
public class SessionManager {

    private static SessionManager mInstance=null;

    private IoSession mSession;
    public static SessionManager getInstance(){
        if(mInstance==null){
            synchronized (SessionManager.class){
                if(mInstance==null){
                    mInstance = new SessionManager();
                }
            }
        }
        return mInstance;
    }

    private SessionManager(){}

    public void setSeesion(IoSession session){
        this.mSession = session;
    }

    public void writeToServer(Object msg){
        if(mSession!=null){
            Log.e("tag", "客戶端準備傳送訊息");
            mSession.write(msg);
        }
    }

    public void closeSession(){
        if(mSession!=null){
            mSession.closeOnFlush();
        }
    }

    public void removeSession(){
        this.mSession=null;
    }
}

MinaTestActivity.java

package com.czhappy.minaclient;

import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.os.Bundle;
import android.support.v4.content.LocalBroadcastManager;
import android.support.v7.app.AppCompatActivity;
import android.util.Log;
import android.view.View;
import android.widget.TextView;

/**
 * Description:
 * User: chenzheng
 * Date: 2016/12/9 0009
 * Time: 18:01
 */
public class MinaTestActivity extends AppCompatActivity implements View.OnClickListener{

    private TextView start_service_tv, send_tv, receive_tv;

    private MessageBroadcastReceiver receiver;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_mina_test);

        initView();
        registerBroadcast();

    }

    private void registerBroadcast() {
        receiver = new MessageBroadcastReceiver();
        IntentFilter filter = new IntentFilter("com.commonlibrary.mina.broadcast");
        LocalBroadcastManager.getInstance(this).registerReceiver(receiver, filter);
    }

    private void initView() {
        receive_tv = (TextView) this.findViewById(R.id.receive_tv);
        start_service_tv = (TextView) this.findViewById(R.id.start_service_tv);
        start_service_tv.setOnClickListener(this);
        send_tv = (TextView) this.findViewById(R.id.send_tv);
        send_tv.setOnClickListener(this);

    }

    @Override
    public void onClick(View v) {
        switch(v.getId()){
            case R.id.start_service_tv:
                Log.e("tag", "點選啟動服務");
                Intent intent = new Intent(this, MinaService.class);
                startService(intent);
                break;
            case R.id.send_tv:
                Log.e("tag", "點擊發送訊息");
                SessionManager.getInstance().writeToServer("hello123");
                break;
        }
    }

    private void unregisterBroadcast(){
        LocalBroadcastManager.getInstance(this).unregisterReceiver(receiver);
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        stopService(new Intent(this, MinaService.class));
        unregisterBroadcast();

    }

    private class MessageBroadcastReceiver extends BroadcastReceiver{
        @Override
        public void onReceive(Context context, Intent intent) {

            receive_tv.setText(intent.getStringExtra("message"));
        }
    }
}

四、執行結果

1.點選啟動服務，觀察客戶端是否與伺服器端連線成功；

2.點擊發送訊息，觀察訊息是否傳送成功，如果失敗判斷失敗在哪一步。

客戶端執行結果：

伺服器端執行結果：

五、原始碼下載

Mina長連線框架實現Android客戶端與伺服器端通訊

一、概述 Apache Mina Server 是一個網路通訊應用框架，也就是說，它主要是對基於TCP/IP、UDP/IP協議棧的通訊框架（當然，也可以提供JAVA 物件的序列化服務、虛擬機器管道通訊服務等），Mina 可以幫助我們快速開發高效能、高擴充套件

Android通過WebSocket建立一個長連線（帶心跳檢測）從伺服器端接收訊息

最近公司要做一款內部使用的工具類app，方便銷售部門打電話（其實就是在後臺有好多使用者資料，之前銷售部門同事撥打電話，需要自己從銷售後臺檢視使用者手機號等資訊，然後自己拿自己手機撥號，然後打出去。現在想實現銷售的同事，點選銷售後臺的按鈕，自己的手機直接撥號的功能）。為此

APP（Android版）客戶端與伺服器端時間校準

APP開發人員經常會遇見一個bug就是，APP顯示的時間不準，或者說APP時間與伺服器時間不一致，會導致資料請求、資料顯示等各種問題。這時候我們就需要一種機制來解決時間不一致的問題。解決方案如下： 1.伺服器端永遠使用UTC時間，包括引數和返回值，不要使用Date格式，而是使用UT

客戶端與伺服器端建立連線的過程

一、概述學習計算機其實就是在通曉原理的基礎上藉助實踐驗證想法。王陽明的“知行合一”用在計算機上，也是十分的貼切。這裡先說明兩個概念 Socket、TCP。 “交流”讓智人走上食物鏈的頂端。計算機網路的發展讓交流變得更加便利，同時也促進交流技術的發展。如果有兩個網友想送

android客戶端與伺服器端互動如何保持session

最近在開發專案的過程中，遇到android與web伺服器要在同一session下通訊的問題。在解決問題前先回顧下Session與Cookie： Cookie和Session都為了用來儲存狀態資訊，都是儲存客戶端狀態的機制，它們都是為了解決HTTP無狀態的問題而所做

Android 客戶端與伺服器端進行資料互動（一、登入伺服器端）

概要安卓APP要實現很多功能（比如登入註冊、發表評論等）時都必須要使用到網路資料互動。所以在學習了這部分內容後，就將其以最常見的登入過程為例整理出來，也方便跟我一樣的新手能迅速學習上手。預期效果圖如下，輸入手機號和密碼，點選Login按鈕，上傳資料到伺

Java Socket通訊客戶端與伺服器端的連線和資訊傳輸

一.建立客戶端和伺服器端的連線。方法分2步： 1.在客戶端建立Socket物件，用來發送連線請求 2.在伺服器端穿件ServerSocket物件，用來接收請求。 //客戶端 public clas

Android客戶端與伺服器端的json資料互動（很詳細）

Android客戶端與伺服器端的json資料互動，主要是通過json形式的資料互動，就是json的寫入和解析。先看效果圖，我最討厭講東西，一個圖沒有的。算了，看來我不是寫部落格的材料，寫不下去了，要排版之類的麻煩，大家還是直接去下載原始碼，裡面有大量的注

Android客戶端與伺服器進行通訊

在Android開發中，經常使用到與後臺進行互動，後臺人員給你一個URL，Android使用HttpURLConnection得到後臺返回的資料。這些任務是開發中經常遇到的。這裡，我們自己搭建一個簡易的後臺，來實現Android客戶端與後臺的互動。首先，後臺

linux下socket實現多個客戶端與伺服器的通訊

學習完《UNIX環境高階程式設計》套接字一章的內容之後，自己實現了單個客戶端與伺服器的通訊程式，後面想想要是多個客戶端如何與伺服器通訊呢？這就有了這篇文章。伺服器端程式： #include<stdio.h> #include <stdlib.h&g

Android 客戶端與伺服器端進行資料互動（二、登入客戶端）

概要 Android客戶端分為User，HttpUtil，HttpCallbackListener，MainActivity四個部分。User model與服務端的一樣，一方面是用於本地使用者資訊的儲存model，另一方面也是為了保證構造URL時使用的key一

Android客戶端與伺服器端互動方式總結

一、HttpClient 方式： //第一步：建立一個客戶端例項 HttpClient httpClient = new DefaultHttpClient(); //第二步：建立Http請求 HttpPost httpRequest = new Http

Java NIO學習筆記(四) 使用JDK 1.7 NIO2.0 實現客戶端與伺服器的通訊

JDK1.7 提供了全新的非同步NIO模式。稱為：NIO2.0或AIO。該模式引入了新的非同步通道的概念，並提供了非同步檔案通道和非同步套接字通道的實現。非同步通道提供兩種方式獲取獲取操作結果。分別是：通過java.util.concurrent

2017.8.22 用python實現簡單基於TCP/IP的客戶端與伺服器端

伺服器端 import socket serversocket=socket.socket(socket.AF_INET,socket.SOCK_STREAM) serversocket.bind((

Android客戶端與伺服器端的資料通訊中文亂碼問題

做了一個小的專案用到了客戶端與伺服器端通訊，然而隨之而來的問題就有了。那就是中文亂碼問題，由伺服器端向客戶端或者客戶端向伺服器端傳送資料時，中文變為問號---？？？？？---。

Android客戶端與伺服器端RSA加密通訊加密字元不一致相關問題

RSA非對稱加密演算法，適用於資料量較小的情況，比如一般的用法： 1、生成RSA金鑰對，公鑰發給客戶端使用，私鑰由伺服器使用； 2、客戶端用公鑰加密所有發出的資料，也用公鑰解密所有收到的資料； 3、伺服器用私鑰加密所有發出的資料，也用私鑰解密所有收到的資料；但Andro

Android客戶端與伺服器端簡單互動

客戶端程式碼： /** * 功能：通過Get向伺服器請求Json資料 * 說明：1.字串（一般用{}表示）與陣列（一般用[]表示）的解析方式是不一樣的，具體如下： * (1)如果返回的是Json字串，則使用JSONObject j

Socket-tcp協議客戶端與伺服器端互聯

客戶端 using System; using System.Collections.Generic; using System.Linq; using System.Net; using System.Net.Sockets; using System.Text; using System.T

zookeeper叢集的客戶端與伺服器端

zookeeper服務端命令：啟動命令：sh zkServer.sh start 停止命令：sh zkServer.sh stop zookeeper客戶端命令：啟動命令：sh zkCli.sh 連線其他客戶端：sh zkCli.sh -server ip:port

php 客戶端與伺服器端安全與破解

一般的加密和授權：轉發伺服器（代理伺服器）解決方案:hhvm編譯程式碼放扒取： js類 1：防止滑鼠右鍵事件，在html->body <body oncontextmenu=self.event.returnValue=false> 或

Mina長連線框架實現Android客戶端與伺服器端通訊

相關推薦