Android Netty开发示例
本文涉及到其它的基础知识有：
- 对数据的字节处理
- 对数据进行CRC32校验
- 对数据的内容进行Blowfish加／解密
这部分内容不会在本文深入探究，在“代码片段讲解”部分会提到一二。
Netty是什么
Netty是一个高性能、异步事件驱动的NIO框架，它提供了对TCP、UDP和文件传输的支持，作为一个异步NIO框架，Netty的所有IO操作都是异步非阻塞的，通过Future-Listener机制，用户可以方便的主动获取或者通过通知机制获得IO操作结果。扩展阅读
代码片段讲解
package com.osanwen.nettydemo;
import io.netty.bootstrap.Bootstrap;
import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
import io.netty.channel.Channel;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelFutureListener;
import io.netty.channel.ChannelOption;
import io.netty.channel.EventLoopGroup;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.nio.NioSocketChannel;
import timber.log.Timber;
/**
* Netty客户端
* Created by LiuSaibao on 11/23/2016.
*/
public class NettyClient {
private static NettyClient nettyClient = new NettyClient();
private EventLoopGroup group;
private NettyListener listener;
private Channel channel;
private boolean isConnect = false;
private int reconnectNum = Integer.MAX_VALUE;
private long reconnectIntervalTime = 5000;
public static NettyClient getInstance(){
return nettyClient;
}
public synchronized NettyClient connect() {
if (!isConnect) {
group = new NioEventLoopGroup();
Bootstrap bootstrap = new Bootstrap().group(group)
.option(ChannelOption.SO_KEEPALIVE,true)
.channel(NioSocketChannel.class)
.handler(new NettyClientInitializer(listener));
try {
bootstrap.connect(Const.HOST, Const.TCP_PORT).addListener(new ChannelFutureListener() {
@Override
public void operationComplete(ChannelFuture channelFuture) throws Exception {
if (channelFuture.isSuccess()) {
isConnect = true;
channel = channelFuture.channel();
} else {
isConnect = false;
}
}
}).sync();
} catch (Exception e) {
Timber.e(e, e.getMessage());
listener.onServiceStatusConnectChanged(NettyListener.STATUS_CONNECT_ERROR);
reconnect();
}
}
return this;
}
public void disconnect() {
group.shutdownGracefully();
}
public void reconnect() {
if(reconnectNum >0 && !isConnect){
reconnectNum--;
try {
Thread.sleep(reconnectIntervalTime);
} catch (InterruptedException e) {}
Timber.e("重新连接");
disconnect();
connect();
}else{
disconnect();
}
}
public boolean sendMsgToServer(byte[] data, ChannelFutureListener listener) {
boolean flag = channel != null && isConnect;
if (flag) {
ByteBuf buf = Unpooled.copiedBuffer(data);
channel.writeAndFlush(buf).addListener(listener);
}
return flag;
}
public void setReconnectNum(int reconnectNum) {
this.reconnectNum = reconnectNum;
}
public void setReconnectIntervalTime(long reconnectIntervalTime) {
this.reconnectIntervalTime = reconnectIntervalTime;
}
public boolean getConnectStatus(){
return isConnect;
}
public void setConnectStatus(boolean status){
this.isConnect = status;
}
public void setListener(NettyListener listener) {
this.listener = listener;
}
}NettyClient类是对Netty进行封装，用于建立连接、断开连接、异常断开重连以及向服务器发送消息。
package com.osanwen.nettydemo;
import io.netty.buffer.ByteBuf;
/**
*
* Created by LiuSaibao on 11/23/2016.
*/
public interface NettyListener {
public final static byte STATUS_CONNECT_SUCCESS = 1;
public final static byte STATUS_CONNECT_CLOSED = 0;
public final static byte STATUS_CONNECT_ERROR = 0;
/**
* 对消息的处理
*/
void onMessageResponse(ByteBuf byteBuf);
/**
* 当服务状态发生变化时触发
*/
public void onServiceStatusConnectChanged(int statusCode);
}NettyListener类用于监听连接的状态和消息响应。
package com.osanwen.nettydemo;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelPipeline;
import io.netty.channel.socket.SocketChannel;
import io.netty.handler.logging.LogLevel;
import io.netty.handler.logging.LoggingHandler;
import io.netty.handler.ssl.SslContext;
import io.netty.handler.ssl.SslContextBuilder;
import io.netty.handler.ssl.util.InsecureTrustManagerFactory;
/**
*
* Created by LiuSaibao on 11/23/2016.
*/
public class NettyClientInitializer extends ChannelInitializer<SocketChannel> {
private NettyListener listener;
private int WRITE_WAIT_SECONDS = 10;
private int READ_WAIT_SECONDS = 13;
public NettyClientInitializer(NettyListener listener) {
this.listener = listener;
}
@Override
protected void initChannel(SocketChannel ch) throws Exception {
SslContext sslCtx = SslContextBuilder.forClient()
.trustManager(InsecureTrustManagerFactory.INSTANCE).build();
ChannelPipeline pipeline = ch.pipeline();
pipeline.addLast(sslCtx.newHandler(ch.alloc())); // 开启SSL
pipeline.addLast(new LoggingHandler(LogLevel.INFO)); // 开启日志，可以设置日志等级
// pipeline.addLast(new IdleStateHandler(30, 60, 100));
pipeline.addLast(new NettyClientHandler(listener));
}
}在Netty中，每个Channel被创建的时候都需要被关联一个对应的pipeline（通道），这种关联关系是永久的（整个程序运行的生命周期中）。ChannelPipeline可以理解成一个消息（ 或消息事件，ChanelEvent）流转的通道，在这个通道中可以被附上许多用来处理消息的handler，当消息在这个通道中流转的时候，如果有与这个消息类型相对应的handler，就会触发这个handler去执行相应的动作。扩展阅读
package com.osanwen.nettydemo;
import io.netty.buffer.ByteBuf;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.SimpleChannelInboundHandler;
/**
*
* Created by LiuSaibao on 11/23/2016.
*/
public class NettyClientHandler extends SimpleChannelInboundHandler<ByteBuf> {
private NettyListener listener;
public NettyClientHandler(NettyListener listener){
this.listener = listener;
}
@Override
public void channelActive(ChannelHandlerContext ctx) throws Exception {
NettyClient.getInstance().setConnectStatus(true);
listener.onServiceStatusConnectChanged(NettyListener.STATUS_CONNECT_SUCCESS);
}
@Override
public void channelInactive(ChannelHandlerContext ctx) throws Exception {
NettyClient.getInstance().setConnectStatus(false);
listener.onServiceStatusConnectChanged(NettyListener.STATUS_CONNECT_CLOSED);
NettyClient.getInstance().reconnect();
}
@Override
protected void channelRead0(ChannelHandlerContext channelHandlerContext, ByteBuf byteBuf) throws Exception {
listener.onMessageResponse(byteBuf);
}
/*@Override
public void userEventTriggered(ChannelHandlerContext ctx, Object evt) throws Exception {
if (evt instanceof IdleStateEvent) {
IdleStateEvent event = (IdleStateEvent) evt;
if (event.state() == IdleState.READER_IDLE){
ctx.close();
}else if (event.state() == IdleState.WRITER_IDLE){
try{
ctx.channel().writeAndFlush("Chilent-Ping\r\n");
} catch (Exception e){
Timber.e(e.getMessage());
}
}
}
super.userEventTriggered(ctx, evt);
}*/
}NettyClientHandler类注释掉了Netty提供心跳机制，稍后会在NettyService类中看到实现自定义的心跳。该类用于获取状态发生改变和消息响应。
package com.osanwen.nettydemo;
import android.app.Service;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.net.ConnectivityManager;
import android.net.NetworkInfo;
import android.os.IBinder;
import android.support.annotation.Nullable;
import android.support.v4.content.LocalBroadcastManager;
import org.json.JSONException;
import org.json.JSONObject;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
import io.netty.buffer.ByteBuf;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelFutureListener;
import timber.log.Timber;
/**
*
* Created by LiuSaibao on 11/17/2016.
*/
public class NettyService extends Service implements NettyListener {
private NetworkReceiver receiver;
private static String sessionId = null;
private ScheduledExecutorService mScheduledExecutorService;
private void shutdown() {
if (mScheduledExecutorService != null) {
mScheduledExecutorService.shutdown();
mScheduledExecutorService = null;
}
}
@Override
public void onCreate() {
super.onCreate();
receiver = new NetworkReceiver();
IntentFilter filter=new IntentFilter(ConnectivityManager.CONNECTIVITY_ACTION);
LocalBroadcastManager.getInstance(this).registerReceiver(receiver, filter);
// 自定义心跳，每隔20秒向服务器发送心跳包
mScheduledExecutorService = Executors.newSingleThreadScheduledExecutor();
mScheduledExecutorService.scheduleAtFixedRate(new Runnable() {
@Override
public void run() {
byte[] requestBody = {(byte) 0xFE, (byte)0xED, (byte)0xFE, 5};
NettyClient.getInstance().sendMsgToServer(requestBody, new ChannelFutureListener() { //3
@Override
public void operationComplete(ChannelFuture future) {
if (future.isSuccess()) { //4
Timber.d("Write heartbeat successful");
} else {
Timber.e("Write heartbeat error");
WriteLogUtil.writeLogByThread("heartbeat error");
}
}
});
}
}, 20, 20, TimeUnit.SECONDS);
}
@Override
public int onStartCommand(Intent intent, int flags, int startId) {
NettyClient.getInstance().setListener(this);
connect();
return START_NOT_STICKY;
}
@Override
public void onServiceStatusConnectChanged(int statusCode) { //连接状态监听
Timber.d("connect status:%d", statusCode);
if (statusCode == NettyListener.STATUS_CONNECT_SUCCESS) {
authenticData();
} else {
WriteLogUtil.writeLogByThread("tcp connect error");
}
}
/**
* 认证数据请求
*/
private void authenticData() {
AuthModel auth = new AuthModel();
auth.setI(102);
auth.setU("YAMSUCFS8G");
auth.setN("G4-一单元");
auth.setF("51");
auth.setT((int)(System.currentTimeMillis() / 1000));
byte[] content = RequestUtil.getEncryptBytes(auth);
byte[] requestHeader = RequestUtil.getRequestHeader(content, 1, 1001);
byte[] requestBody = RequestUtil.getRequestBody(requestHeader, content);
NettyClient.getInstance().sendMsgToServer(requestBody, new ChannelFutureListener() { //3
@Override
public void operationComplete(ChannelFuture future) {
if (future.isSuccess()) { //4
Timber.d("Write auth successful");
} else {
Timber.d("Write auth error");
WriteLogUtil.writeLogByThread("tcp auth error");
}
}
});
}
@Override
public void onMessageResponse(ByteBuf byteBuf) {
byte[] bytes = byteBuf.array();
Timber.d("tcp receive data:%s", ByteUtil.bytesToHex(bytes));
// 接收
if (0xED == ByteUtil.unsignedByteToInt(bytes[0])
&& 0xFE == ByteUtil.unsignedByteToInt(bytes[1])) {
if (1 == bytes[2]) {
int cardinal = (int)ByteUtil.unsigned4BytesToInt(bytes, 5);
int realLen = cardinal + 9;
int len = byteBuf.writerIndex();
// 接收到的数据有可能会粘包，只需要判断数据的长度大于或者等于真实的长度即可
if (len >= realLen) {
int word = ByteUtil.bytesToShort(ByteUtil.subBytes(bytes, 3, 2));
if (word == 1001) {
byte[] data = new byte[cardinal];
System.arraycopy(bytes, 9, data, 0, data.length);
Blowfish blowfish = new Blowfish();
String result = new String(blowfish.decryptByte(data));
try {
JSONObject jsonObject = new JSONObject(result);
sessionId = jsonObject.getString("s");
} catch (JSONException e) {
Timber.e(e, e.getMessage());
}
} else if (word == 2002) {
byte[] data = new byte[cardinal];
System.arraycopy(bytes, 9, data, 0, data.length);
Blowfish blowfish = new Blowfish();
String result = new String(blowfish.decryptByte(data));
Timber.d(result);
try {
JSONObject jsonObject = new JSONObject(result);
handle(word, jsonObject.getInt("i"), jsonObject.getInt("r"));
} catch (JSONException e) {
Timber.e(e, e.getMessage());
}
} else {
String log = "undefined request type";
Timber.e(log);
WriteLogUtil.writeLogByThread(log);
}
} else {
String log = String.format("request byte array content length inequality, realLen=%d, len=%d", realLen, len);
Timber.e(log);
WriteLogUtil.writeLogByThread(log);
}
} else if (5 == bytes[2]) {
Timber.e("heartbeat");
}
// 响应
} else if (0xFE == ByteUtil.unsignedByteToInt(bytes[0])
&& 0xED == ByteUtil.unsignedByteToInt(bytes[1])
&& 0xFE == ByteUtil.unsignedByteToInt(bytes[2])) {
if (1 == bytes[3]) {
// 忽略bytes[4],bytes[5]。作用是接口升级
int cardinal = (int)ByteUtil.unsigned4BytesToInt(bytes, 8);
int len = byteBuf.writerIndex();
// 前12个字节是请求头，后4个字节是校验值
int realLen = cardinal + 12 + 4;
// 返回的数据有可能会粘包，只需要判断数据的长度大于或者等于真实的长度即可
if (len >= realLen) {
int word = ByteUtil.bytesToShort(ByteUtil.subBytes(bytes, 6, 2));
if (word == 2001) {
byte[] data = new byte[cardinal];
System.arraycopy(bytes, 12, data, 0, data.length);
byte[] crc32 = new byte[4];
System.arraycopy(bytes, realLen - 4, crc32, 0, crc32.length);
// 对内容进行CRC校验
if (CRC32Util.getCRC32Long(data) == ByteUtil.unsigned4BytesToInt(crc32, 0)) {
Blowfish blowfish = new Blowfish();
String result = new String(blowfish.decryptByte(data));
try {
JSONObject jsonObject = new JSONObject(result);
int i = jsonObject.getInt("i");
if (sessionId == null) {
WriteLogUtil.writeLogByThread("sessionId is null");
authenticData();
handle(word, i, 0);
return;
}
byte[] session = sessionId.getBytes();
byte[] sign = "WiseUC@2016".getBytes();
byte[] content = new byte[session.length + sign.length];
System.arraycopy(session, 0, content, 0, session.length);
System.arraycopy(sign, 0, content, session.length, sign.length);
// 对Session ID进行CRC校验
if (jsonObject.getLong("c") == CRC32Util.getCRC32(content)) {
handle(word, i, 1);
} else {
String log = "open the door session id crc32 verification failure";
Timber.e(log);
WriteLogUtil.writeLogByThread(log);
}
} catch (JSONException e) {
Timber.e(e, e.getMessage());
}
} else {
String log = "open the door crc32 data verification failure";
Timber.e(log);
WriteLogUtil.writeLogByThread(log);
}
} else {
String log = "undefined response type";
Timber.e(log);
WriteLogUtil.writeLogByThread(log);
}
} else {
String log = String.format("response byte array content length inequality, realLen=%d, len=%d", realLen, len);
Timber.e(log);
WriteLogUtil.writeLogByThread(log);
}
} else if (5 == bytes[3]) {
Timber.e("heartbeat");
}
} else {
Timber.e("unknown");
WriteLogUtil.writeLogByThread("unknown");
}
}
private void handle(int t, int i, int f) {
// TODO 实现自己的业务逻辑
}
private void connect(){
if (!NettyClient.getInstance().getConnectStatus()) {
new Thread(new Runnable() {
@Override
public void run() {
NettyClient.getInstance().connect();//连接服务器
}
}).start();
}
}
@Override
public void onDestroy() {
super.onDestroy();
LocalBroadcastManager.getInstance(this).unregisterReceiver(receiver);
shutdown();
NettyClient.getInstance().setReconnectNum(0);
NettyClient.getInstance().disconnect();
}
@Nullable
@Override
public IBinder onBind(Intent intent) {
throw new UnsupportedOperationException("Not yet implemented");
}
public class NetworkReceiver extends BroadcastReceiver {
@Override
public void onReceive(Context context, Intent intent) {
ConnectivityManager cm = (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);
NetworkInfo activeNetwork = cm.getActiveNetworkInfo();
if (activeNetwork != null) { // connected to the internet
if (activeNetwork.getType() == ConnectivityManager.TYPE_WIFI
|| activeNetwork.getType() == ConnectivityManager.TYPE_MOBILE) {
connect();
}
}
}
}
}NettyService类实现了业务的处理逻辑。
基本数据类型对应二进制的位数
基本数据类型 | 二进制位数 |
boolean | 1 |
byte | 8 |
char | 16 |
short | 16 |
int | 32 |
long | 64 |
float | 32 |
double | 64 |
这张表大家都不会陌生，对于网络编程这块，都是对字节数组操作。例如：截取字节数组；将多个字节数组拼接到一个新的字节数组中传输。Java中的基本数据类型是没有无符号的，需要自己去封装，基本数据类型之间的转换就需要看这张表，将byte[]转换成short,int,long等其他类型是有区别，看对应二进制位数。
网络编程会出现粘包的情况，可以和服务端约定数据长度来解决粘包问题，示例就是使用这种方式解决粘包问题的。
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
