Android實現Socket長連線 , OkSocket框架簡單使用

阿新 • • 發佈：2018-11-10

一個Android輕量級Socket通訊框架,既OkHttp後又一力作.
框架開源地址: https://github.com/xuuhaoo/OkSocket

OkSocket簡介

Android OkSocket是一款基於阻塞式傳統Socket的一款Socket客戶端整體解決方案.您可以使用它進行簡單的基於Tcp協議的Socket通訊,當然,也可以進行大資料量複雜的Socket通訊,
支援單工,雙工通訊.

Maven配置

OkSocket 目前僅支援 JCenter 倉庫

allprojects {
    repositories {
        jcenter()
    }
}

在Module的build.gradle檔案中新增依賴配置

dependencies {
    compile 'com.tonystark.android:socket:1.0.0'
}

引數配置

在AndroidManifest.xml中新增許可權:

<uses-permission android:name="android.permission.INTERNET"/>
<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE"/>

混淆配置

請避免混淆OkSocket，在Proguard混淆檔案中增加以下配置：

-dontwarn com.xuhao.android.libsocket.**
-keep class com.xuhao.android.socket.impl.abilities.** { *; }
-keep class com.xuhao.android.socket.impl.exceptions.** { *; }
-keep class com.xuhao.android.socket.impl.EnvironmentalManager { *; }
-keep class com.xuhao.android.socket.impl.BlockConnectionManager { *; }
-keep class com.xuhao.android.socket.impl.UnBlockConnectionManager { *; }
-keep class com.xuhao.android.socket.impl.SocketActionHandler { *; }
-keep class com.xuhao.android.socket.impl.PulseManager { *; }
-keep class com.xuhao.android.socket.impl.ManagerHolder { *; }
-keep class com.xuhao.android.socket.interfaces.** { *; }
-keep class com.xuhao.android.socket.sdk.** { *; }
# 列舉類不能被混淆
-keepclassmembers enum * {
    public static **[] values();
    public static ** valueOf(java.lang.String);
}
-keep class com.xuhao.android.socket.sdk.OkSocketOptions$* {
    *;
}

OkSocket初始化

將以下程式碼複製到專案Application類onCreate()中，OkSocket會為自動檢測環境並完成配置：

public class MyApplication extends Application {
    @Override
    public void onCreate() {
        super.onCreate();
        //在主程序初始化一次,多程序時需要區分主程序.
        OkSocket.initialize(this);
        //如果需要開啟Socket除錯日誌,請配置
        //OkSocket.initialize(this,true);
    }
}

呼叫演示

測試伺服器

該伺服器是專門為初學者除錯 OkSocket 庫部屬的一臺測試伺服器,初學者可以將專案中的 app 安裝到手機上,點選 Connect 按鈕即可,該伺服器僅為熟悉通訊方式和解析方式使用.該伺服器不支援心跳返回,不能作為商用伺服器.伺服器程式碼在 SocketServerDemo 資料夾中,請注意參考閱讀.
IP: 104.238.184.237
Port: 8080
您也可以選擇下載 JAR 檔案到本地,執行在您的本地進行除錯 Download JAR
下載後使用下面的程式碼將其執行起來java -jar SocketServerDemo.jar

簡單的長連線

OkSocket 會預設對每一個 Open 的新通道做快取管理,僅在第一次呼叫 Open 方法時建立 ConnectionManager 管理器,之後呼叫者可以通過獲取到該ConnectionManager的引用,繼續呼叫相關方法
ConnectionManager 主要負責該地址的套接字連線斷開發送訊息等操作.

//連線引數設定(IP,埠號),這也是一個連線的唯一標識,不同連線,該引數中的兩個值至少有其一不一樣
ConnectionInfo info = new ConnectionInfo("104.238.184.237", 8080);
//呼叫OkSocket,開啟這次連線的通道,呼叫通道的連線方法進行連線.
OkSocket.open(info).connect();

有回撥的長連線

註冊該通道的監聽器,每個 Connection 通道中的監聽器互相隔離,因此如果一個專案連線了多個 Socket 連線需要在每個 Connection 註冊自己的連線監聽器,連線監聽器是該 OkSocket 與使用者互動的唯一途徑

//連線引數設定(IP,埠號),這也是一個連線的唯一標識,不同連線,該引數中的兩個值至少有其一不一樣
ConnectionInfo info = new ConnectionInfo("104.238.184.237", 8080);
//呼叫OkSocket,開啟這次連線的通道,拿到通道Manager
IConnectionManager manager = OkSocket.open(info);
//註冊Socket行為監聽器,SocketActionAdapter是回撥的Simple類,其他回撥方法請參閱類文件
manager.registerReceiver(new SocketActionAdapter(){
    @Override
    public void onSocketConnectionSuccess(Context context, ConnectionInfo info, String action) {
     Toast.makeText(context, "連線成功", LENGTH_SHORT).show();
    }
});
//呼叫通道進行連線
manager.connect();

可配置的長連線

獲得 OkSocketOptions 的行為屬於比較高階的 OkSocket 呼叫方法,每個 Connection 將會對應一個 OkSocketOptions,如果第一次呼叫 Open 時未指定 OkSocketOptions,OkSocket將會使用預設的配置物件,預設配置請見文件下方的高階呼叫說明

//連線引數設定(IP,埠號),這也是一個連線的唯一標識,不同連線,該引數中的兩個值至少有其一不一樣
ConnectionInfo info = new ConnectionInfo("104.238.184.237", 8080);
//呼叫OkSocket,開啟這次連線的通道,拿到通道Manager
IConnectionManager manager = OkSocket.open(info);
//獲得當前連線通道的參配物件
OkSocketOptions options= manager.getOption();
//基於當前參配物件構建一個參配建造者類
OkSocketOptions.Builder builder = new OkSocketOptions.Builder(options);
//修改參配設定(其他參配請參閱類文件)
builder.setSinglePackageBytes(size);
//建造一個新的參配物件並且付給通道
manager.option(builder.build());
//呼叫通道進行連線
manager.connect();

如何進行資料傳送

//類A:
//...定義將要傳送的資料結構體...
public class TestSendData implements ISendable {
    private String str = "";

    public TestSendData() {
        JSONObject jsonObject = new JSONObject();
        try {
            jsonObject.put("cmd", 14);
            jsonObject.put("data", "{x:2,y:1}");
            str = jsonObject.toString();
        } catch (JSONException e) {
            e.printStackTrace();
        }
    }

    @Override
    public byte[] parse() {
        //根據伺服器的解析規則,構建byte陣列
        byte[] body = str.getBytes(Charset.defaultCharset());
        ByteBuffer bb = ByteBuffer.allocate(4 + body.length);
        bb.order(ByteOrder.BIG_ENDIAN);
        bb.putInt(body.length);
        bb.put(body);
        return bb.array();
    }
}

//類B:
private IConnectionManager mManager;
//...省略連線及設定回撥的程式碼...
@Override
public void onSocketConnectionSuccess(Context context, ConnectionInfo info, String action) {
     //連線成功其他操作...
     //鏈式程式設計呼叫
     OkSocket.open(info)
        .send(new TestSendData());
     
     //此處也可將ConnectManager儲存成成員變數使用.
     mManager = OkSocket.open(info);
     if(mManager != null){
        mManager.send(new TestSendData());
     }
     //以上兩種方法選擇其一,成員變數的方式請注意判空
}

如何接收資料

OkSocket客戶端接收伺服器資料是要求一定格式的,客戶端的OkSocketOptions提供了介面來修改預設的伺服器返回的包頭解析規則.請看下圖為預設的包頭包體解析規則

資料結構示意圖
如上圖包頭中的內容為4個位元組長度的int型,該int值標識了包體資料區的長度,這就是預設的頭解析,如果需要自定義頭請按照如下方法.

//設定自定義解析頭
OkSocketOptions.Builder okOptionsBuilder = new OkSocketOptions.Builder(mOkOptions);
okOptionsBuilder.setHeaderProtocol(new IHeaderProtocol() {
    @Override
    public int getHeaderLength() {
        //返回自定義的包頭長度,框架會解析該長度的包頭
        return 0;
    }

    @Override
    public int getBodyLength(byte[] header, ByteOrder byteOrder) {
        //從header(包頭資料)中解析出包體的長度,byteOrder是你在參配中配置的位元組序,可以使用ByteBuffer比較方便解析
        return 0;
    }
});
//將新的修改後的參配設定給連線管理器
mManager.option(okOptionsBuilder.build());


//...正確設定解析頭之後...
@Override
public void onSocketReadResponse(Context context, ConnectionInfo info, String action, OriginalData data) {
    //遵循以上規則,這個回撥才可以正常收到伺服器返回的資料,資料在OriginalData中,為byte[]陣列,該陣列資料已經處理過位元組序問題,直接放入ByteBuffer中即可使用
}

如何保持心跳

//類A:
//...定義心跳管理器需要的心跳資料型別...
public class PulseData implements IPulseSendable {
    private String str = "pulse";

    @Override
    public byte[] parse() {
        byte[] body = str.getBytes(Charset.defaultCharset());
        ByteBuffer bb = ByteBuffer.allocate(4 + body.length);
        bb.order(ByteOrder.BIG_ENDIAN);
        bb.putInt(body.length);
        bb.put(body);
        return bb.array();
    }
}

//類B:
private IConnectionManager mManager;
private PulseData mPulseData = new PulseData;
//...省略連線及設定回撥的程式碼...
@Override
public void onSocketConnectionSuccess(Context context, ConnectionInfo info, String action) {
     //連線成功其他操作...
     //鏈式程式設計呼叫,給心跳管理器設定心跳資料,一個連線只有一個心跳管理器,因此資料只用設定一次,如果斷開請再次設定.
     OkSocket.open(info)
        .getPulseManager()
        .setPulseSendable(mPulseData)
        .pulse();//開始心跳,開始心跳後,心跳管理器會自動進行心跳觸發
                
     //此處也可將ConnectManager儲存成成員變數使用.
     mManager = OkSocket.open(info);
     if(mManager != null){
        PulseManager pulseManager = mManager.getPulseManager();
        //給心跳管理器設定心跳資料,一個連線只有一個心跳管理器,因此資料只用設定一次,如果斷開請再次設定.
        pulseManager.setPulseSendable(mPulseData);
        //開始心跳,開始心跳後,心跳管理器會自動進行心跳觸發
        pulseManager.pulse();
     }
     //以上兩種方法選擇其一,成員變數的方式請注意判空
}

心跳接收到了之後需要進行喂狗

因為我們的客戶端需要知道伺服器收到了此次心跳,因此伺服器在收到心跳後需要進行應答,我們收到此次心跳應答後,需要進行本地的喂狗操作,否則當超過一定次數的心跳傳送,未得到喂狗操作後,狗將會將此次連線斷開重連.

//定義成員變數
private IConnectionManager mManager;
//當客戶端收到訊息後
@Override
public void onSocketReadResponse(Context context, ConnectionInfo info, String action, OriginalData data) {
    if(mManager != null && 是心跳返回包){//是否是心跳返回包,需要解析伺服器返回的資料才可知道
        //喂狗操作
        mManager.getPulseManager().feed();
    }
}

如何手動觸發一次心跳,在任何時間

//定義成員變數
private IConnectionManager mManager;
//...在任意地方...
mManager = OkSocket.open(info);
if(mManager != null){
    PulseManager pulseManager = mManager.getPulseManager();
    //手動觸發一次心跳(主要用於一些需要手動控制觸發時機的場景)
    pulseManager.trigger();
}

OkSocket參配選項及回撥說明

OkSocketOptions
- Socket通訊模式mIOThreadMode
- 連線是否管理儲存isConnectionHolden
- 寫入位元組序mWriteOrder
- 讀取位元組序mReadByteOrder
- 頭位元組協議mHeaderProtocol
- 傳送單個數據包的總長度mSendSinglePackageBytes
- 單次讀取的快取位元組長度mReadSingleTimeBufferBytes
- 脈搏頻率間隔毫秒數mPulseFrequency
- 脈搏最大丟失次數(狗的失喂次數)mPulseFeedLoseTimes
- 後臺存活時間(分鐘)mBackgroundLiveMinute
- 連線超時時間(秒)mConnectTimeoutSecond
- 最大讀取資料的兆數(MB)mMaxReadDataMB
- 重新連線管理器mReconnectionManager
ISocketActionListener
- Socket讀寫執行緒啟動後回撥onSocketIOThreadStart
- Socket讀寫執行緒關閉後回撥onSocketIOThreadShutdown
- Socket連線狀態由連線->斷開回調onSocketDisconnection
- Socket連線成功回撥onSocketConnectionSuccess
- Socket連線失敗回撥onSocketConnectionFailed
- Socket從伺服器讀取到位元組回撥onSocketReadResponse
- Socket寫給伺服器位元組後回撥onSocketWriteResponse
- 傳送心跳後的回撥onPulseSend

示例程式碼(已傳至碼雲)

public class MainActivity extends BaseActivity {

	private static final String TAG = MainActivity.class.getSimpleName();
	private final String CONN_NO = "未連線",CONNECTING="連線中",CONN_FAIL="連線失敗",CONN_OK="已連線";
	@BindView(R.id.bt_start)
	Button btStart;
	@BindView(R.id.bt_send)
	Button btSend;
	@BindView(R.id.tv_log)
	TextView tvLog;
	@BindView(R.id.tv_count)
	TextView tvCount;
	@BindView(R.id.tv_conn_status)
	TextView tvConnStatus;
	@BindView(R.id.tv_reconn_count)
	TextView tvReconnCount;
	@BindView(R.id.et_ip)
	TextView etIP;
	@BindView(R.id.et_port)
	TextView etPort;
	@BindView(R.id.et_time)
	TextView etTime;
	private IConnectionManager manager;
	private String data = " %s,%s,%s,%s"; //"071 135790246811222,2018-7-9 18:06:20,98,-72,bs[460:0:28730:20736:34]"
	private String deviceImei;
	private int counts = 0; //傳送資料次數
	private int reconnCounts = 0; //重連次數
	private ConnectionInfo connInfo;
	private Timer dataTimer;
	private boolean isSendData = false;
	private String nmeaLogPath;

	@Override
	protected void onCreate(Bundle savedInstanceState) {
		super.onCreate(savedInstanceState);
		setContentView(R.layout.activity_main);
		ButterKnife.bind(this);
		if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
			requestPermission();
		} else {
			init();
		}
	}

	private void init() {
		tvLog.setText(counts+"");
		tvConnStatus.setText(CONN_NO);
		File dir = new File(Constants.LOG);
		if(!dir.exists()){
			dir.mkdirs();
		}
		String timeName = DateUtil.getCurrentDate(DateUtil.dateFormatYMDHMS);
		nmeaLogPath = Constants.LOG + File.separator + timeName + ".txt";
		//資料回顯
		String sim_ip = PFUtils.getPrefString(MainActivity.this, "sim_ip", "139.196.255.699");
		int sim_port = PFUtils.getPrefInt(MainActivity.this, "sim_port", 9999);
		int sim_time = PFUtils.getPrefInt(MainActivity.this, "sim_time", 1000);
		etIP.setText(sim_ip);
		etPort.setText(sim_port+"");
		etTime.setText(sim_time+"");
	}

	public void sendData() {
		if (manager != null) {
			isSendData = true;
			String format = String.format(data, deviceImei, DateUtil.getCurrentDate(DateUtil.dateFormatYMDHMS), counts + "", PhoneUtil.getMobileSignal(MainActivity.this));
			int dataLen = format.length() + 3;
			String len;
			if(dataLen < 10){
				len = "00" + dataLen;
			}else if(dataLen <100){
				len = "0"+ dataLen;
			}else{
				len = ""+ dataLen;
			}
			String data = len + format;
			manager.send(new SendData(data));
		} else {
			showTipsDialog("Please Connect To Server!");
		}
	}

	@OnClick(R.id.bt_send)
	public void onViewClicked2() {
		Timer timer = new Timer(true);
		timer.schedule(new TimerTask() {
			@Override
			public void run() {
				PhoneUtil.getBsSignal(MainActivity.this);
			}
		},100,1000);

		if (manager != null) {
			String time = etTime.getText().toString().trim();
			if(TextUtils.isEmpty(time)){
				showTipsDialog("IP和Port不能為空");
				return;
			}
			int timeInt = Integer.parseInt(time);
			if(timeInt <= 0){
				showTipsDialog("請輸入大於0的整數");
				return;
			}
			PFUtils.setPrefInt(MainActivity.this,"sim_time",timeInt);
			if(!isSendData){
				dataTimer = new Timer();
				dataTimer.schedule(new TimerTask() {
					@Override
					public void run() {
						sendData();
					}
				},100,timeInt);
			}else{
				showTipsDialog("data sending!");
			}
		}else{
			showTipsDialog("Please Connect To Server!");
		}
	}

	@OnClick(R.id.bt_start)
	public void onViewClicked() {
		String trimIp = etIP.getText().toString().trim();
		String trimPort = etPort.getText().toString().trim();
		if(TextUtils.isEmpty(trimIp) || TextUtils.isEmpty(trimPort)){
			showTipsDialog("IP和Port不能為空");
			return;
		}
		int port = Integer.parseInt(trimPort);
		PFUtils.setPrefString(MainActivity.this,"sim_ip",trimIp);
		PFUtils.setPrefInt(MainActivity.this,"sim_port",port);
		//連線引數設定(IP,埠號),這也是一個連線的唯一標識,不同連線,該引數中的兩個值至少有其一不一樣
		connInfo = new ConnectionInfo(trimIp, port);
		deviceImei = PhoneUtil.getDeviceImei(MainActivity.this);
		//呼叫OkSocket,開啟這次連線的通道,拿到通道Manager
		manager = OkSocket.open(connInfo);
		//註冊Socket行為監聽器,SocketActionAdapter是回撥的Simple類,其他回撥方法請參閱類文件
		manager.registerReceiver(mSocketAdapter);
		manager.connect(); //呼叫通道進行連線
	}

	SocketActionAdapter mSocketAdapter = new SocketActionAdapter() {
		@Override
		public void onSocketIOThreadStart(Context context, String action) {
			super.onSocketIOThreadStart(context, action);
			MLog.e(TAG, "onSocketIOThreadStart:" + action);
			saveLog(action);
		}

		@Override
		public void onSocketIOThreadShutdown(Context context, String action, Exception e) {
			super.onSocketIOThreadShutdown(context, action, e);
			MLog.e(TAG, "onSocketIOThreadShutdown:" + action+" Error:"+e.getMessage());
			saveLog(action);
		}

		@Override
		public void onSocketDisconnection(Context context, ConnectionInfo info, String action, Exception e) {
			super.onSocketDisconnection(context, info, action, e);
			MLog.e(TAG, "onSocketDisconnection:" + action+" Error:"+e.getMessage());
			tvConnStatus.setText(CONN_NO);
			saveLog(action);
		}

		@Override
		public void onSocketConnectionSuccess(Context context, ConnectionInfo info, String action) {
			super.onSocketConnectionSuccess(context, info, action);
			MLog.e(TAG, "onSocketConnectionSuccess:" + action);
			Toast.makeText(context, "連線成功", Toast.LENGTH_SHORT).show();
			tvConnStatus.setText(CONN_OK);
			saveLog(action);
		}

		@Override
		public void onSocketConnectionFailed(Context context, ConnectionInfo info, String action, Exception e) {
			super.onSocketConnectionFailed(context, info, action, e);
			MLog.e(TAG, "onSocketConnectionFailed:" + action+" Error:"+e.getMessage());
			saveLog(action);
			reconnCounts++;
			tvConnStatus.setText(CONN_FAIL);
			tvReconnCount.setText(reconnCounts+"");
		}

		@Override
		public void onSocketReadResponse(Context context, ConnectionInfo info, String action, OriginalData data) {
			super.onSocketReadResponse(context, info, action, data);
			MLog.e(TAG, "onSocketReadResponse:" + action);
			saveLog(action);
		}

		@Override
		public void onSocketWriteResponse(Context context, ConnectionInfo info, String action, ISendable data) {
			super.onSocketWriteResponse(context, info, action, data);
			saveLog("onSocketWriteResponse:"+action);
			MLog.e(TAG, "onSocketWriteResponse:資料傳送成功" + data.toString());
			tvCount.setText(counts+"");
			tvLog.setText(counts+" ->"+data.toString());
			counts++;
			saveLog(data.toString());
		}

		@Override
		public void onPulseSend(Context context, ConnectionInfo info, IPulseSendable data) {
			super.onPulseSend(context, info, data);
			MLog.e(TAG, "onPulseSend:" + data.toString());
		}
	};

	private void saveLog(String info){
		try {
			String timeName = DateUtil.getCurrentDate(DateUtil.dateFormatYMDHMS);
			FileWriter fw = new FileWriter(nmeaLogPath , true);
			BufferedWriter bw = new BufferedWriter(fw);
			bw.write("["+timeName+"] "+info+"\n");
			bw.close();
			fw.close();
		} catch (IOException e) {
			e.printStackTrace();
		}
	}


	@Override
	protected void onDestroy() {
		super.onDestroy();
		if(manager != null) manager.disconnect();
		if(dataTimer != null)dataTimer.cancel();
	}

	@Override
	public boolean onKeyDown(int keyCode, KeyEvent event) {
		if (keyCode == KeyEvent.KEYCODE_BACK && event.getAction() == KeyEvent.ACTION_DOWN) {
			new SweetAlertDialog(this, SweetAlertDialog.WARNING_TYPE)
					.setTitleText("確定退出嗎?")
					.setCancelText("取消")
					.setConfirmText("確定")
					.showCancelButton(true)
					.setCancelClickListener(null)
					.setConfirmClickListener(sDialog ->{
						if(manager != null) manager.disconnect();
						if(dataTimer != null)dataTimer.cancel();
						MXApp.getInstance().exit();
					})
					.show();
			return true;
		}
		return super.onKeyDown(keyCode, event);
	}

	private void requestPermission() {
		PermissionUtils.permission(PermissionConstants.PHONE, PermissionConstants.STORAGE, PermissionConstants.LOCATION)
				.rationale(shouldRequest -> DialogHelper.showRationaleDialog(shouldRequest, MainActivity.this))
				.callback(new PermissionUtils.FullCallback() {
					@Override
					public void onGranted(List<String> permissionsGranted) {
						init();
					}

					@Override
					public void onDenied(List<String> permissionsDeniedForever, List<String> permissionsDenied) {
						if (!permissionsDeniedForever.isEmpty()) {
							DialogHelper.showOpenAppSettingDialog(MainActivity.this);
						} else {
							MXApp.getInstance().exit();
						}
					}
				})
				.request();
	}

}

Android實現Socket長連線 , OkSocket框架簡單使用

一個Android輕量級Socket通訊框架,既OkHttp後又一力作. 框架開源地址: https://github.com/xuuhaoo/OkSocket OkSocket簡介 Android OkSocket是一款基於阻塞式傳統Socket的一款Socket客戶端整體解決方案.您

Socket長連線Android端心跳機制實現

1. 把socket連結和心跳功能都放在一個Service中，為什麼要放在Service中？一般我們這種socket幾乎是跟app的生命週期一樣長，甚至更長。不管在不在Service中去完成操作，我們都得開非同步執行緒，雖然Service並不是

基於netty框架的socket長連線負載均衡解決方案

前言物聯網如今是一個大的趨勢，但是概念還比較新穎。大家對這一塊的技術積累也比較匱乏，藉此前段時間摩拜單車出現了大規模癱瘓的現象。我們今天來討論一下物聯網專案的開發方式。關於tcp/ip 相關的知識點 socket通訊的單機瓶頸物聯網的專案socket使用方式

Socket-長連線(心跳包)的實現

#import "GCDSocketManager.h" // 但是我用的自己電腦做測試，所以用的這個IP地址 #define SocketHost @"127.0.0.1" // 埠是隨意寫的 #define SocketPort 9999 @interface GCDSocketMana

基礎知識概念（1）：Socket 長連線和短連線的概念

1.短連線連線->傳輸資料->關閉連線 HTTP是無狀態的，瀏覽器和伺服器每進行一次HTTP操作，就建立一次連線，但任務結束後就中斷連線。短連線是指SOCKET建立連線後，傳送後或接收完資料後，就馬上斷開連線。 2.長連線

Socket長連線和短連線的區別

TCP/IP TCP/IP是個協議組，可分為三個層次：網路層、傳輸層和應用層。在網路層有IP協議、ICMP協議、ARP協議、RARP協議和BOOTP協議。在傳輸層中有TCP協議與UDP協議。在應用層有:TCP包括FTP、HTTP、TELNET、SMTP等協議 UDP包括DNS

Android架構之長連線技術

本文首發於小專欄《Android 架構之長連線技術》，更多Android架構文章歡迎關注《億級Android架構》上一篇文章《Android 架構之網路框架（上）》中，我們談過了網路框架OkHttp、網路加速方案如HttpDNS、資料壓縮與序列化等技術點。本文我們結合騰訊Mars框架和美團Sha

netty實現TCP長連線

所用jar包 netty-all-4.1.30.Final.jar 密碼：rzwe NettyConfig.java，存放連線的客戶端 1 import io.netty.channel.group.ChannelGroup; 2 import io.netty.channel.gr

Spring+Stomp+ActiveMq實現websocket長連線

stomp.js+spring+sockjs+activemq實現websocket長連線，使用java配置。 pom.xml（只列出除了spring基本依賴意外的依賴，spring-version為4.3.3.RELEASE）： <dependency> <gro

Socket長連線，位元組傳送

LogKit.error("IP連線"); Socket socket = new Socket("192.168.1.172", 5001); OutputStream outputStream = socket.getOutputStream(

Python實現遠端mysql連線並進行簡單資料庫操作

1.linux伺服器安裝mysql： apt-get install mysql-server #Root使用者安裝mysql以及相關服務 apt-get install mysql-client apt-get install libmysqlclient-dev

使用 .NET 實現 Ajax 長連線

Ajax的長連線，或者有些人所說的Comet，就是指以XMLHttpRequest的方式連線伺服器，連線後伺服器並非即時寫入相應並返回。伺服器會保持連線並等待一個需要通知客戶端的事件，該事件發生後馬上將資料寫入響應，這時候客戶端就以相當“實時”的方式接收到事件通知。具體的

[Android]騰訊Tinker熱修復框架簡單使用

前言目前我們所知的熱修復方案有阿里的AndFix、美團的Robust以及QZone的超級補丁方案，還有本篇的Tinker，如何在我們的自開發的軟體上選用合適的方案呢？先看看各家的框架效能對比，在作參考。總體來說：AndFix作為native解決方案，首先面臨的是穩定性與相容性

微信小程式實現websocket長連線以及斷開連線之後自動重連

app.js let socketMsgQueue = [] let isLoading = false App({ globalData: { userInfo: null, localSocket: {}, callback: function () {} },

Android實現形形色色的進度條很簡單的實現

原文地址：http://blog.csdn.net/lmj623565791/article/details/43371299 1、概述最近需要用進度條，秉著不重複造輪子的原則，上github上搜索了一番，看了幾個覺得比較好看的ProgressBar

Android和伺服器長連線

轉載這種功能實際上就是資料同步，同時要考慮手機本身、電量、網路流量等等限制因素，所以通常在移動端上有一下兩個解決方案:　　1.一種是定時去server查詢資料，通常是使用HTTP協議來訪問web伺服器，稱Polling（輪詢）；　　2.還有一種是移動端和伺服器建立長連線，

Java socket 長連線與短連結

長連線是一旦一個客戶端登陸上伺服器，其與伺服器之間的連線就不關閉，不管他們之間進行了多少次交易，直到客戶端退出登陸或網路出現故障。這種技術在聯機交易系統實現有利於提高效率。短連線是客

Android實現一個apk連線兩個ble裝置

宣告：程式碼基於網上某個小工程改的，如果涉及侵權，請聯絡本人，立馬刪除。曾經做過一個小玩意，嘗試把兩個ble微控制器裝置都連在一個apk上，同時通訊。網上可以找到類似的，但我找到的程式碼不夠完整，還是自己折騰出來的，希望能幫到有需要的人。思想簡單，一個Bluetooth

socket長連線

1.服務端需要為每一個客戶端開啟一個執行緒 2.客戶端需要一直給服務端傳送心跳包，如果不發了，就說明連線被斷開了，客戶端也關閉連線，結束執行緒。3.當客戶端被動關閉連線（斷網，訊號不好等情況藉助第二種

Android實現app長時間未操作時自動退出app

這裡要考慮3個問題，第一個是鎖屏問題，第二個是app被切換至後臺的問題，第三個是螢幕鎖定和解除時app在後臺時的問題一，監聽螢幕解鎖，鎖定 public class ScreenObserver { private static String TAG = "ScreenObserver";

Android實現Socket長連線 , OkSocket框架簡單使用

OkSocket簡介

Maven配置

引數配置

混淆配置

OkSocket初始化

呼叫演示

OkSocket參配選項及回撥說明

示例程式碼(已傳至碼雲)

相關推薦