java实现JT809协议数据对接客户端

最近使用JT809协议进行数据对接，遇到了不少问题，度娘谷歌都不好使，找不到很好的客户端实现代码的例子，只能苦逼的自己闷头弄，现在特意写篇帖子，希望能帮助一些人

说正经的：

背景：跟某公司做数据对接，将本公司的一些信息推送到接收端

要求：建立tcp链接，使用接收端提供的用户名密码等信息 先登录，登录成功后推送数据，数据采用JT809标准协议

实现语言：java

下面介绍具体实现，包涵完整代码

在这之前，最好先下载jt809协议，研究研究，网上就有，我找到的里面还有一些错误别，一度让我觉得是个盗版货

首先说下整体结构：一个tcp客户端，一个Decoder，一个心跳Handler，一个处理反馈的handler，一个消息对象

通过tcp客户端链接制定ip地址和端口，进行登陆，心跳handler负责在发送数据空闲时向目标服务器发送请求保持包；decoder负责解码组装对象，反馈handler负责处理收到的反馈信息，消息对象我就不多说了

下面看代码：

TCPclient：

由于时间紧迫，代码结构有些臃肿，我使用的tcpclient为两个，一个是基类，一个子类，其实这两个可以合并到一起，这里有心的朋友自己去和，下面来看下tcpclient基类的代码,其中有一些模块的引用因为涉及到公司信息，所以我删除掉了，大家参考的时候，引用自己编写的就可以了，

//包路径，自己填import java.net.InetSocketAddress;import java.util.concurrent.Executor;import java.util.concurrent.Executors;import org.jboss.netty.bootstrap.ClientBootstrap;import org.jboss.netty.buffer.ChannelBuffer;import org.jboss.netty.buffer.ChannelBuffers;import org.jboss.netty.channel.Channel;import org.jboss.netty.channel.ChannelFuture;import org.jboss.netty.channel.ChannelPipeline;import org.jboss.netty.channel.ChannelPipelineFactory;import org.jboss.netty.channel.Channels;import org.jboss.netty.channel.socket.nio.NioClientSocketChannelFactory;import org.jboss.netty.handler.logging.LoggingHandler;import org.jboss.netty.handler.timeout.IdleStateHandler;import org.jboss.netty.logging.InternalLogLevel;import org.jboss.netty.util.HashedWheelTimer;import org.slf4j.Logger;import org.slf4j.LoggerFactory;public class TcpClient{private static final Logger LOG = LoggerFactory.getLogger(TcpClient.class);private static final int DEFAULT_PORT = 9000;private long connectTimeoutMillis = 3000;private int port = DEFAULT_PORT;private boolean tcpNoDelay = false;private boolean reuseAddress = true;private boolean keepAlive = true;private int workerCount = 4;private ClientBootstrap bootstrap = null;private  static Channel channel = null;private Executor bossExecutor = Executors.newCachedThreadPool();private Executor workerExecutor = Executors.newCachedThreadPool();private static TcpClient instance = new TcpClient();private TcpClient() {init();}public static TcpClient getInstence(){return instance;}public void init() {bootstrap = new ClientBootstrap(new NioClientSocketChannelFactory(bossExecutor, workerExecutor, workerCount));bootstrap.setOption("tcpNoDelay", tcpNoDelay);bootstrap.setOption("connectTimeoutMillis", connectTimeoutMillis);bootstrap.setOption("reuseAddress", reuseAddress);bootstrap.setOption("keepAlive", keepAlive);}public Channel getChannel(String address, int port) {if (null == channel || !channel.isOpen()) {bootstrap.setOption("writeBufferHighWaterMark", 64 * 1024);bootstrap.setOption("writeBufferLowWaterMark", 32 * 1024);bootstrap.setPipelineFactory(new ChannelPipelineFactory(){@Overridepublic ChannelPipeline getPipeline() throws Exception {ChannelPipeline pipeline = Channels.pipeline();//pipeline.addLast("loging", new LoggingHandler(InternalLogLevel.ERROR)); 打印日志信息，上线稳定后可去掉pipeline.addLast("timeout", new IdleStateHandler(new HashedWheelTimer(), 10, 60, 0));//设置空闲心跳机制pipeline.addLast("heartbeat", new HeartBeatHandler());//心跳发送包处理handlerpipeline.addLast("decode", new Decoder());//解码pipeline.addLast("loginHandler", new RecevieHandler());//反馈数据处理return pipeline;}});ChannelFuture future = bootstrap.connect(new InetSocketAddress(address, port));future.awaitUninterruptibly();if (future.isSuccess()) {channel = future.getChannel();} else {throw new FrameworkRuntimeException(future.getCause());}}return channel;}public long getConnectTimeoutMillis() {return connectTimeoutMillis;}public void setConnectTimeoutMillis(long connectTimeoutMillis) {this.connectTimeoutMillis = connectTimeoutMillis;}public int getPort() {return port;}public void setPort(int port) {this.port = port;}public boolean isTcpNoDelay() {return tcpNoDelay;}public void setTcpNoDelay(boolean tcpNoDelay) {this.tcpNoDelay = tcpNoDelay;}public boolean isReuseAddress() {return reuseAddress;}public void setReuseAddress(boolean reuseAddress) {this.reuseAddress = reuseAddress;}public boolean isKeepAlive() {return keepAlive;}public void setKeepAlive(boolean keepAlive) {this.keepAlive = keepAlive;}public int getWorkerCount() {return workerCount;}public void setWorkerCount(int workerCount) {this.workerCount = workerCount;}}

上面的配置，用过netty都不会陌生，就不多说了，下面看下子类的实现

<pre name="code" class="java">//包路径，自己填

import java.nio.charset.Charset;import java.text.NumberFormat;import java.util.Calendar;import java.util.Date;import java.util.Properties;import org.apache.commons.lang3.StringUtils;import org.jboss.netty.buffer.ChannelBuffer;import org.jboss.netty.buffer.ChannelBuffers;import org.jboss.netty.channel.Channel;import org.slf4j.Logger;import org.slf4j.LoggerFactory;public class TcpClientFuJian{private static Logger LOG = LoggerFactory.getLogger(TcpClientFuJian.class);public static int PLANT_CODE;//公司介入码public static int ZUCHE_ID_FUJIAN;//公司用户名public static String ZUCHE_PWD_FUJIAN;//公司密码public static String LONGINSTATUS = "";public static String LOGINING = "logining";private static int LOGIN_FLAG = 0;private static String DOWN_LINK_IP = "127.0.0.1";//初始化基类private static TcpClient tcpClient = TcpClient.getInstence();//初始化private static TcpClientFuJian tcpClientFujian = new TcpClientFuJian();//初始化配置,这里时读取配置文件，使用的是公司内部的工具，各位自己实现就好，并不复杂private static Properties property = PropertiesReader.getProperties("aws2xiamen", true);//初始化channel,以便心跳机制及时登录private Channel channel = tcpClient.getChannel(Constants.TCP_ADDRESS, Constants.TCP_PORT);public static TcpClientFuJian getInstance(){//加在车辆数据;由于我们推送的车辆位置信息，所以这里初始化一部分制定的数据InitVehicleData.initVehicleMap();//获取本机IP对应的用户名密码,使用的是公司内部的工具，各位自己实现就好，并不复杂String localIp = IpUtils.getLocalIp();if(StringUtils.isNotBlank(localIp)){String properties = property.getProperty(localIp);if(StringUtils.isNotBlank(localIp)){String[] pros = properties.split(":");PLANT_CODE = Integer.parseInt(pros[0]);ZUCHE_ID = Integer.parseInt(pros[1]);ZUCHE_PWD = pros[2];}}else{LOG.error("获取本机IP异常");}return tcpClientFujian;}/** * 判断是否登录 * boolean * @return */public boolean isLogined(){
 return Constants.LOGIN_SUCCESS.equals(LONGINSTATUS); //Constants常量类，自己随便定义就好，LOGIN_STATAUS="0x00"
}/** * 登录接入平台 * boolean * @return */public boolean login2FuJianGov(){boolean success = false;if(!Constants.LOGIN_SUCCESS.equals(LONGINSTATUS) && !LOGINING.equals(LONGINSTATUS)){//开始登录 Message为数据对象，代码稍后给出Message msg = new Message(JT809Constants.UP_CONNECT_REQ);ChannelBuffer buffer = ChannelBuffers.buffer(46);buffer.writeInt(ZUCHE_ID);//4byte[] pwd = getBytesWithLengthAfter(8, ZUCHE_PWD.getBytes());buffer.writeBytes(pwd);//8byte[] ip = getBytesWithLengthAfter(32, DOWN_LINK_IP.getBytes());buffer.writeBytes(ip);//32buffer.writeShort((short)Constants.TCP_RESULT_PORT);//2msg.setMsgBody(buffer);channel = tcpClient.getChannel(Constants.TCP_ADDRESS, Constants.TCP_PORT);channel.write(buildMessage(msg));LONGINSTATUS = LOGINING;}return success;}public static ChannelBuffer buildMessage(Message msg){int bodyLength = 0 ;if(null != msg.getMsgBody()){bodyLength = msg.getMsgBody().readableBytes();}msg.setMsgGesscenterId(PLANT_CODE);ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(bodyLength + Message.MSG_FIX_LENGTH);ChannelBuffer headBuffer = ChannelBuffers.buffer(22);//---数据头headBuffer.writeInt(buffer.capacity() - 1);//4headBuffer.writeInt(msg.getMsgSn());//4headBuffer.writeShort((short)msg.getMsgId());//2headBuffer.writeInt(msg.getMsgGesscenterId());//4headBuffer.writeBytes(msg.getVersionFlag());//3headBuffer.writeByte(0);//1headBuffer.writeInt(10);//4buffer.writeBytes(headBuffer);//---数据体if(null != msg.getMsgBody()){buffer.writeBytes(msg.getMsgBody());}ChannelBuffer finalBuffer = ChannelBuffers.copiedBuffer(buffer);//--crc校验码byte[] b = ChannelBuffers.buffer(finalBuffer.readableBytes()).array();finalBuffer.getBytes(0, b);int crcValue = CRC16CCITT.crc16(b);finalBuffer.writeShort((short)crcValue);//2//转义byte[] bytes = ChannelBuffers.copiedBuffer(finalBuffer).array();ChannelBuffer headFormatedBuffer = ChannelBuffers.dynamicBuffer(finalBuffer.readableBytes());formatBuffer(bytes, headFormatedBuffer);ChannelBuffer buffera = ChannelBuffers.buffer(headFormatedBuffer.readableBytes() + 2);buffera.writeByte(Message.MSG_HEAD);buffera.writeBytes(headFormatedBuffer);buffera.writeByte(Message.MSG_TALL);return ChannelBuffers.copiedBuffer(buffera);}/** * 发送数据到接入平台 * boolean * @param awsVo 是上层程序得到的带发送的数据对象，可以看自己的需求，替换 * @return */public boolean sendMsg2FuJianGov(Idc2AwsGpsVo awsVo){boolean success = false;if(isLogined()){//已经登录成功，开始发送数据channel = tcpClient.getChannel(Constants.TCP_ADDRESS, Constants.TCP_PORT);if(null != channel && channel.isWritable()){Message msg = buildSendVO(awsVo);ChannelBuffer msgBuffer = buildMessage(msg);channel.write(msgBuffer);}else{LONGINSTATUS = "";}}else if(LOGIN_FLAG == 0){LOGIN_FLAG ++;login2FuJianGov();LOG.error("--------------第一次登录");}else{LOG.error("--------------等待登录");}return success;}/** * 转换VO * void * @param awsVo */private Message buildSendVO(Idc2AwsGpsVo awsVo){Message msg = new Message(JT809Constants.UP_EXG_MSG);ChannelBuffer buffer = ChannelBuffers.buffer(36);//是否加密buffer.writeByte((byte)0);//0未加密 // 1//日月年dmyyCalendar cal = Calendar.getInstance();cal.setTime(new Date());buffer.writeByte((byte)cal.get(Calendar.DATE));buffer.writeByte((byte)(cal.get(Calendar.MONTH) + 1));String hexYear = "0" + Integer.toHexString(cal.get(Calendar.YEAR));buffer.writeBytes(hexStringToByte(hexYear));//4//时分秒buffer.writeByte((byte)cal.get(Calendar.HOUR));buffer.writeByte((byte)cal.get(Calendar.MINUTE));buffer.writeByte((byte)cal.get(Calendar.SECOND));//3//经度，纬度buffer.writeInt(formatLonLat(awsVo.getLon()));//4buffer.writeInt(formatLonLat(awsVo.getLat()));//4//速度buffer.writeShort(awsVo.getSpeed().shortValue());//2//行驶记录速度buffer.writeShort(awsVo.getSpeed().shortValue());//2//车辆当前总里程数buffer.writeInt(awsVo.getMileage().intValue());//4//方向buffer.writeShort(awsVo.getDirection().shortValue());//2//海拔buffer.writeShort((short)0);//2//车辆状态buffer.writeInt(1);//4//报警状态buffer.writeInt(0);//0表示正常；1表示报警//4ChannelBuffer headBuffer = ChannelBuffers.buffer(buffer.capacity() + 28);headBuffer.writeBytes(getBytesWithLengthAfter(21 , awsVo.getVehicleNo().getBytes(Charset.forName("GBK"))));//21 车牌号headBuffer.writeByte((byte)1);//1 车牌颜色：注意不是车身颜色headBuffer.writeShort(JT809Constants.UP_EXG_MSG_REAL_LOCATION);//2 子业务码headBuffer.writeInt(buffer.capacity());//4headBuffer.writeBytes(buffer);msg.setMsgBody(headBuffer);return msg;}/** * 报文转义 * void * @param bytes * @param formatBuffer */private static void formatBuffer(byte[] bytes, ChannelBuffer formatBuffer){for (byte b : bytes) {switch(b){case 0x5b:byte[] formatByte0x5b = new byte[2];formatByte0x5b[0] = 0x5a;formatByte0x5b[1] = 0x01;formatBuffer.writeBytes(formatByte0x5b);break;case 0x5a:byte[] formatByte0x5a = new byte[2];formatByte0x5a[0] = 0x5a;formatByte0x5a[1] = 0x02;formatBuffer.writeBytes(formatByte0x5a);break;case 0x5d:byte[] formatByte0x5d = new byte[2];formatByte0x5d[0] = 0x5e;formatByte0x5d[1] = 0x01;formatBuffer.writeBytes(formatByte0x5d);break;case 0x5e:byte[] formatByte0x5e = new byte[2];formatByte0x5e[0] = 0x5e;formatByte0x5e[1] = 0x02;formatBuffer.writeBytes(formatByte0x5e);break;default: formatBuffer.writeByte(b);break;}}}/** * 16进制字符串转换成byte数组 * byte[] * @param hex */ public static byte[] hexStringToByte(String hex) { hex = hex.toUpperCase(); int len = (hex.length() / 2); byte[] result = new byte[len]; char[] achar = hex.toCharArray(); for (int i = 0; i < len; i++) { int pos = i * 2; result[i] = (byte) (toByte(achar[pos]) << 4 | toByte(achar[pos + 1])); } return result; } private static byte toByte(char c) { byte b = (byte) "0123456789ABCDEF".indexOf(c); return b; } /** * 格式化经纬度,保留六位小数 * int * @param needFormat * @return */ private int formatLonLat(Double needFormat){ NumberFormat numFormat = NumberFormat.getInstance();numFormat.setMaximumFractionDigits(6);numFormat.setGroupingUsed(false);String fristFromat = numFormat.format(needFormat);Double formatedDouble = Double.parseDouble(fristFromat);numFormat.setMaximumFractionDigits(0);String formatedValue = numFormat.format(formatedDouble * 1000000);return Integer.parseInt(formatedValue); ｝ /** * 补全位数不够的定长参数 有些定长参数，实际值长度不够，在后面补0x00 * byte[] * @param length * @param pwdByte * @return */private byte[] getBytesWithLengthAfter(int length, byte[] pwdByte){byte[] lengthByte = new byte[length];for(int i = 0; i < pwdByte.length; i ++){lengthByte[i] = pwdByte[i];}for (int i = 0; i < (length- pwdByte.length); i++) {lengthByte[pwdByte.length + i] = 0x00;}return lengthByte;}public static void main(String[] args) {TcpClientFuJian s = TcpClientFuJian.getInstance();Idc2AwsGpsVo awsVo = new Idc2AwsGpsVo();awsVo.setDirection(120);awsVo.setLon(117.2900911);awsVo.setLat(39.56362);awsVo.setSpeed(45D);awsVo.setMileage(10001D);awsVo.setVehicleNo("幽123D32");s.sendMsg2FuJianGov(awsVo);try {Thread.sleep(20*1000);} catch (InterruptedException e) {e.printStackTrace();}s.sendMsg2FuJianGov(awsVo);}}

这里其实也没有太多好说的，整体说一下，先按照协议拼接数据，拼接完成后，计算CRC，进行转义，由于协议规定开始标记为0x5b,结束标记为0x5d，数据中可能包涵这些标记，所以必须转移，具体转换规则，在协议中就能找到，有一点要注意，一定是先计算crc，再转一，将否则无法通过crc校验，我就是在这里吃了亏，耗了一天，再别人的指点下才解决，协议中crc计算使用的是crc16-ccitt标准，这里找了好多实现，每个计算结果都不一样，我也没有仔细研究，我用的是没问题的，代码如下

public class JT809Constants {public static int UP_CONNECT_REQ = 0x1001;//主链路登录请求消息public static int UP_CONNECT_RSP = 0x1002;//主链路登录应答消息public static int UP_CONNECT_RSP_SUCCESS = 0x00;//登录成功public static int UP_CONNECT_RSP_ERROR_01 = 0x01;//IP 地址不正确public static int UP_CONNECT_RSP_ERROR_02 = 0x02;//接入码不正确public static int UP_CONNECT_RSP_ERROR_03 = 0x03;//用户没注册public static int UP_CONNECT_RSP_ERROR_04 = 0x04;//密码错误public static int UP_CONNECT_RSP_ERROR_05 = 0x05;//资源紧张,稍后再连接(已经占 用);public static int UP_CONNECT_RSP_ERROR_06 = 0x06;//其他public static int UP_DICONNECE_REQ = 0x1003;//主链路注销请求消息public static int UP_DISCONNECT_RSP = 0x1004;//主链路注销应答消息public static int UP_LINKETEST_REQ = 0x1005;//主链路连接保持请求消息public static int UP_LINKTEST_RSP = 0x1006;//主链路连接保持应答消息public static int UP_DISCONNECT_INFORM = 0x1007;//主链路断开通知消息public static int UP_CLOSELINK_INFORM = 0x1008;//下级平台主动关闭链路通 知消息public static int DOWN_CONNECT_REQ = 0x9001;//从链路连接请求消息public static int DOWN_CONNECT_RSP = 0x9002;//从链路连接应答消息public static int DOWN_DISCONNECT_REQ = 0x9003;//从链路注销请求消息public static int UP_EXG_MSG = 0x1200;//主链路动态信息交换消息public static int UP_EXG_MSG_REAL_LOCATION = 0x1202;//实时上传车辆定位信息public static int UP_EXG_MSG_HISTORY_LOCATION = 0x1203;//车辆定位信息自动补报public static int DOWN_EXG_MSG = 0x9200;//从链路动态信息交换消息}import java.io.Serializable;import java.util.Arrays;import org.jboss.netty.buffer.ChannelBuffer;public class Message implements Serializable{private static final long serialVersionUID = 4398559115325723920L;public static final int MSG_HEAD = 0x5b;public static final int MSG_TALL = 0x5d;//报文中除数据体外，固定的数据长度public static final int MSG_FIX_LENGTH = 26;private static int internalMsgNo = 0;private long msgLength;private long encryptFlag=1;private int msgGesscenterId;private long encryptKey;private int crcCode;private int msgId;private int msgSn;private ChannelBuffer msgBody;private byte[] versionFlag = {0,0,1};//下行报文标识，值为1时，代表发送的数据；默认为0，代表接收的报文//private int downFlag = 0;public Message(){}public Message(int msgId){//下行报文需要填充报文序列号synchronized((Integer)internalMsgNo) {if(internalMsgNo == Integer.MAX_VALUE){internalMsgNo = 0;}}this.msgSn = ++internalMsgNo;this.msgId = msgId;//this.downFlag = 1;}public static int getInternalMsgNo() {return internalMsgNo;}public static void setInternalMsgNo(int internalMsgNo) {Message.internalMsgNo = internalMsgNo;}public long getMsgLength() {return msgLength;}public void setMsgLength(long msgLength) {this.msgLength = msgLength;}public long getEncryptFlag() {return encryptFlag;}public void setEncryptFlag(long encryptFlag) {this.encryptFlag = encryptFlag;}public int getMsgGesscenterId() {return msgGesscenterId;}public void setMsgGesscenterId(int msgGesscenterId) {this.msgGesscenterId = msgGesscenterId;}public void setMsgGesscenterId(long msgGesscenterId) {this.msgGesscenterId = (int)msgGesscenterId;}public long getEncryptKey() {return encryptKey;}public void setEncryptKey(long encryptKey) {this.encryptKey = encryptKey;}public int getCrcCode() {return crcCode;}public void setCrcCode(int crcCode) {this.crcCode = crcCode;}public int getMsgId() {return msgId;}public void setMsgId(int msgId) {this.msgId = msgId;}public int getMsgSn() {return msgSn;}public void setMsgSn(int msgSn) {this.msgSn = msgSn;}public ChannelBuffer getMsgBody() {return msgBody;}public void setMsgBody(ChannelBuffer msgBody) {this.msgBody = msgBody;}public byte[] getVersionFlag() {return versionFlag;}public void setVersionFlag(byte[] versionFlag) {this.versionFlag = versionFlag;}public static int getMsgHead() {return MSG_HEAD;}public static int getMsgTall() {return MSG_TALL;}public static int getMsgFixLength() {return MSG_FIX_LENGTH;}@Overridepublic String toString() {return "Message [msgLength=" + msgLength + ", encryptFlag=" + encryptFlag + ", msgGesscenterId="+ msgGesscenterId + ", encryptKey=" + encryptKey + ", crcCode=" + crcCode + ", msgId=" + msgId+ ", msgSn=" + msgSn + ", msgBody=" + msgBody + ", versionFlag=" + Arrays.toString(versionFlag) + "]";}}

下面是Decoder

import org.jboss.netty.buffer.ChannelBuffer;import org.jboss.netty.channel.Channel;import org.jboss.netty.channel.ChannelHandlerContext;import org.jboss.netty.handler.codec.frame.FrameDecoder;public class Decoder extends FrameDecoder {@Overrideprotected Object decode(ChannelHandlerContext ctx, Channel channel, ChannelBuffer buffer) throws Exception {int head = buffer.getByte(0);int tail = buffer.getByte(buffer.capacity() - 1);if( !(head == Message.MSG_HEAD && tail == Message.MSG_TALL)){return null;}buffer.skipBytes(1);Message msg = this.buildMessage(buffer);return msg;}private Message buildMessage(ChannelBuffer buffer){Message msg = new Message();msg.setMsgLength(buffer.readUnsignedInt());msg.setMsgSn(buffer.readInt());//4bytemsg.setMsgId(buffer.readUnsignedShort());//2bytemsg.setMsgGesscenterId(buffer.readUnsignedInt());//4bytemsg.setVersionFlag(buffer.readBytes(3).array());//3bytemsg.setEncryptFlag(buffer.readUnsignedByte());//1bytemsg.setEncryptKey(buffer.readUnsignedInt());//4byteif(buffer.readableBytes() >= 9){buffer.skipBytes(buffer.readableBytes() - 8);}ChannelBuffer bodyBytes = buffer.readBytes(buffer.readableBytes() -3); msg.setMsgBody(bodyBytes);msg.setCrcCode(buffer.readUnsignedShort());//2bytebuffer.skipBytes(1);return msg;}}

这个decoder值得说一下，有一些朋友应该能看出来

if(buffer.readableBytes() >= 9){buffer.skipBytes(buffer.readableBytes() - 8);}

这段代码很突兀，其实我也很郁闷，登陆的时候收到的反馈信息，信息长度竟然不是一样的，有的时候长度是32，有的时候长度是31，长度是32的时候，如果不跳过一位，那么解析出来的反馈状态码就是错误的

下面是recevieHandler，

import org.jboss.netty.buffer.ChannelBuffer;import org.jboss.netty.channel.ChannelHandlerContext;import org.jboss.netty.channel.MessageEvent;import org.jboss.netty.channel.SimpleChannelHandler;import org.slf4j.Logger;import org.slf4j.LoggerFactory;public class RecevieHandler extends SimpleChannelHandler{private static Logger LOG = LoggerFactory.getLogger(RecevieHandler.class);@Overridepublic void messageReceived(ChannelHandlerContext ctx, MessageEvent e){Message msg = (Message) e.getMessage();LOG.error("应答----------------" + "0x" + Integer.toHexString(msg.getMsgId()));if(msg.getMsgId() == JT809Constants.UP_CONNECT_RSP){ChannelBuffer msgBody = msg.getMsgBody();int result = msgBody.readByte();if(result == JT809Constants.UP_CONNECT_RSP_SUCCESS){TcpClientFuJian.LONGINSTATUS = Constants.LOGIN_SUCCESS;LOG.error("------------------登录成功");}else{LOG.error("------------------登录异常，请检查" + "0x0" + Integer.toHexString(result));}}}}

根据JT809协议，应该是一个主链路，一个从链路，从链路用来接收下发的消息，实际上不需要的，推送数据的，在主链路登录时会有反馈，从链路可以忽略，但是从链路的ip和端口，是必填参数，随便给就可以了，

上面经过decoder之后得到Message，receiveHandler就是来判断是否登陆，登陆成功的话，就可以发送数据

这里涉及登陆时机的问题，先看下心跳handler，我们再说登陆问题

HeartBeatHandler如下：

import org.apache.commons.lang3.StringUtils;import org.jboss.netty.channel.ChannelHandlerContext;import org.jboss.netty.handler.timeout.IdleState;import org.jboss.netty.handler.timeout.IdleStateAwareChannelHandler;import org.jboss.netty.handler.timeout.IdleStateEvent;import org.slf4j.Logger;import org.slf4j.LoggerFactory;import com.zuche.us.gpsidc2aws.constant.JT809Constants;import com.zuche.us.gpsidc2aws.tcpclient.vo.Message;public class HeartBeatHandler extends IdleStateAwareChannelHandler {private static Logger LOG = LoggerFactory.getLogger(HeartBeatHandler.class);@Overridepublic void channelIdle(ChannelHandlerContext ctx, IdleStateEvent e) throws Exception{if(StringUtils.isBlank(TcpClientFuJian.LONGINSTATUS) || TcpClientFuJian.LOGINING.equals(TcpClientFuJian.LONGINSTATUS)){TcpClientFuJian.getInstance().login2FuJianGov();LOG.error("利用空闲心跳去登录------ 开始登录");}if(e.getState() == IdleState.WRITER_IDLE){LOG.error("链路空闲，发送心跳!");Message msg = new Message(JT809Constants.UP_LINKETEST_REQ);e.getChannel().write(TcpClientFuJian.buildMessage(msg));super.channelIdle(ctx, e);}}}

心跳包中包含了登陆，这个怎么说呢，没想到什么好办法进行登陆失败重登陆情况，因为一个不小心，可能就会一直在登陆

所以在发送数据时如果发现没登陆，那么进行登陆，通过flag来判断，如果登陆过了，那就不管了，成功就发数据，失败就等着，等到心跳包发送心跳时去检测是否登陆成功了，没成功的话让心跳包去再登陆一次，这样省了不少代码，就是肯能比较混乱，这个看个人想法了

只要能实现就行，

最后时crc16工具类

public class CRC16CCITT {     public static int crc16(byte[] bytes){    int crc = 0xFFFF;    for (int j = 0; j < bytes.length ; j++) {        crc = ((crc  >>> 8) | (crc  << 8) )& 0xffff;        crc ^= (bytes[j] & 0xff);//byte to int, trunc sign        crc ^= ((crc & 0xff) >> 4);        crc ^= (crc << 12) & 0xffff;        crc ^= ((crc & 0xFF) << 5) & 0xffff;    }    crc &= 0xffff;        return crc;    }            }

我用的是直接计算的方式，还有一种查表法，这里就不说了，百度下应该能找到

到此，客户端实现就完成了

不过由于我们是多台服务器推送数据，所以必须建立多个tcp链接，接收端之前没这么收过数据，中间经历了一点儿小波折，后台接收端根据我们的服务器数量给开通了多个账号，

多个账号就涉及到哪台服务器用哪个账号的问题，所以就有了上面代码中的配置文件

文件内容很简单

ip=用户名：介入码：密码

例如:

127.0.0.1=101:101:666666

为每台服务器制定好所使用的账号;

另外车牌颜色，颜色的状态需要使用JT/T415-2006标准协议，这个挺难找的，我直接把颜色和状态码贴出来，方便大家参考

JT/T415-2006
1:蓝色
2:黄色
3:黑色
4:白色
9:其他

至此整个客户端完满，经过测试，完美上线，没有出现问题，有一点稍微注意下，代码中发送数据的时候，时间的小时的12进制的，看接收端的要求，可以改成24小时制的

修改方法很简单，将Calendar.HOUR 改成Calendar.HOUR_OF_DAY 就可以

本地开发的时候，可能不知道发送的数据对不对，这个对应的接收端应该都有解析工具，可以要来自己去校验

差不多了再进行联调

也可以自己模拟一个简单的接收端，来进行测试，这个代码晚上有现成的，这里就不多说了。

希望能帮助大家，如果又问题，可以随时联系我