Springboot+Netty实现基于天翼物联网平台CTWing(AIOT)终端TCP协议(透传模式)-应用订阅端（北向应用）

之前实现了使用Springboot+Netty基于天翼物联网平台CTWing(AIOT)终端TCP协议(透传模式)-设备终端（南向设备），模拟设备发送的数据给到了AIOT平台，那么在第三方应用也需要去订阅AIOT平台的数据，以及对设备进行下发指令(消息)，订阅设备消息可以使用http，对整个产品进行设备消息订阅。

订阅方地址可以先用接口来接收json字符串，他的格式是json的（接收设备订阅的数据后，必须要有返回，否则AIOT平台会认为没有推送到位，还会推送直到触发禁制）

package boot.ctwing.tcp.app.controller;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.*;
import java.util.HashMap;
import java.util.Map;

/**
 * 	蚂蚁舞
 */
@Controller
@RequestMapping("/receive")
public class CtWingReceiveController {

	private final Logger log =  LoggerFactory.getLogger(this.getClass());

	@PostMapping(value = "/tcp-transfer/data", produces = "application/json;charset=UTF-8")
	@ResponseBody
	public Map<String, Object> receiveTcpTransferController(@RequestBody String str) {
		log.info(str);
		Map<String, Object> mapResult = new HashMap<>();
		mapResult.put("state", true);
		return mapResult;
	}

}

如果说不创建应用开发，只需要设备推送上来的数据，那么此刻就可以去启动模拟的设备，尝试发消息，北向应用也启动，这样的话就能订阅到从模拟设备发送过来的数据，下下行数据，需要先在应用开发-应用管理里面创建应用得到APP_KEY和APP_SECRET。

在这里我们能看到AIOT的接口文档和在线调试还有sdk下载，在这里我只需要下发指令的操作，那么就去找下发指令的文档信息，在线调试是最快调通下发的，我这里已经把它转换成程序了。

新建Springboot的maven项目，pom.xml文件导入依赖包（用到了swagger来测试下发数据）

    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.0.5.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>

    <groupId>boot.ctwing.tcp.app</groupId>
    <artifactId>boot-example-ctwing-tcp-app-2.0.5</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>boot-example-ctwing-tcp-app-2.0.5</name>
    <url>http://maven.apache.org</url>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <java.version>1.8</java.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>2.0.20</version>
            <scope>compile</scope>
        </dependency>
        <dependency>
            <groupId>cn.hutool</groupId>
            <artifactId>hutool-all</artifactId>
            <version>5.8.6</version>
        </dependency>
        <dependency>
            <groupId>org.apache.httpcomponents</groupId>
            <artifactId>httpclient</artifactId>
        </dependency>
        <dependency>
            <groupId>com.ctg.ag</groupId>
            <artifactId>ctg-ag-sdk-core</artifactId>
            <version>2.7.0-20221208.015855-5</version>
            <scope>system</scope>
            <systemPath>${project.basedir}/doc/lib/ctg-ag-sdk-core-2.7.0-20221208.015855-5.jar</systemPath>
        </dependency>
        <dependency>
            <groupId>com.ctg.ag</groupId>
            <artifactId>ag-sdk-biz-108549.tar.gz</artifactId>
            <version>20221221.143437-SNAPSHOT</version>
            <scope>system</scope>
            <systemPath>${project.basedir}/doc/lib/ag-sdk-biz-108549.tar.gz-20221221.143437-SNAPSHOT.jar</systemPath>
        </dependency>
        <dependency>
            <groupId>io.springfox</groupId>
            <artifactId>springfox-swagger2</artifactId>
            <version>2.9.2</version>
        </dependency>
        <dependency>
            <groupId>com.github.xiaoymin</groupId>
            <artifactId>swagger-bootstrap-ui</artifactId>
            <version>1.9.2</version>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <configuration>
                    <mainClass>boot.ctwing.tcp.app.BootCtWingTcpApp</mainClass>
                    <includeSystemScope>true</includeSystemScope><!--外部进行打包-->
                </configuration>
                <executions>
                    <execution>
                        <goals>
                            <goal>repackage</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>

Springboot启动类，Netty启动

package boot.ctwing.tcp.app;


import org.springframework.boot.CommandLineRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

/**
 *  蚂蚁舞
 */
@SpringBootApplication
public class BootCtWingTcpApp implements CommandLineRunner
{
    public static void main( String[] args ) throws Exception {
    	SpringApplication.run(BootCtWingTcpApp.class, args);
        System.out.println( "Hello World!" );

    }

    @Override
    public void run(String... args) throws Exception {

    }
}

SwaggerConfig配置

package boot.ctwing.tcp.app.config;

import com.google.common.base.Predicates;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import springfox.documentation.builders.ApiInfoBuilder;
import springfox.documentation.builders.PathSelectors;
import springfox.documentation.builders.RequestHandlerSelectors;
import springfox.documentation.service.ApiInfo;
import springfox.documentation.spi.DocumentationType;
import springfox.documentation.spring.web.plugins.Docket;
import springfox.documentation.swagger2.annotations.EnableSwagger2;

/**
 *  蚂蚁舞
 */
@Configuration
@EnableSwagger2
public class SwaggerConfig {

    @Bean
    public Docket createRestApi(){
        return new Docket(DocumentationType.SWAGGER_2).apiInfo(apiInfo()).select()
                .apis(RequestHandlerSelectors.any()).paths(PathSelectors.any())
                .paths(Predicates.not(PathSelectors.regex("/error.*")))
                .paths(PathSelectors.regex("/.*"))
                .build().apiInfo(apiInfo());
    }

    private ApiInfo apiInfo(){
        return new ApiInfoBuilder()
                .title("天翼物联网CtWing北向接收订阅数据端")
                .description("接收订阅数据端需要的下行测试接口")
                .version("0.01")
                .build();
    }

    /**
     * http://localhost:8178/doc.html  地址和端口根据实际项目查看
     */


}

CtWingConstant

package boot.ctwing.tcp.app.config;

/**
 *  蚂蚁舞
 */
public class CtWingConstant {

    //  产品Id
    public static final int PRODUCT_ID = 15506850;

    //  应用开发-应用管理-具体应用的App Key
    public static final String APP_KEY = "XXXXXXX";

    //  应用开发-应用管理-具体应用的App Secret
    public static final String APP_SECRET = "XXXXXXXX";

    //  产品信息里的Master-APIkey
    public static final String MASTER_KEY = "XXXXXXXXXXXXXXXXXXXX";



    //  数据订阅通知
    public static final String dataReport = "dataReport";

    //  设备上线下线订阅通知
    public static final String deviceOnlineOfflineReport = "deviceOnlineOfflineReport";

    //  指令下发结果订阅
    public static final String commandResponse = "commandResponse";

}

CtWingReceiveController

package boot.ctwing.tcp.app.controller;

import boot.ctwing.tcp.app.config.CtWingConstant;
import boot.ctwing.tcp.app.utils.CtWingUtils;
import com.alibaba.fastjson.JSONObject;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.*;

import java.util.Base64;
import java.util.HashMap;
import java.util.Map;

/**
 * 	蚂蚁舞
 */
@Controller
@RequestMapping("/receive")
public class CtWingReceiveController {

	private final Logger log =  LoggerFactory.getLogger(this.getClass());

	@PostMapping(value = "/tcp-transfer/data", produces = "application/json;charset=UTF-8")
	@ResponseBody
	public Map<String, Object> receiveTcpTransferController(@RequestBody String str) {
		log.info(str);
		JSONObject jsonObject = JSONObject.parseObject(str);
		String messageType = jsonObject.getString("messageType");
		switch (messageType){  // 这里只是例举了三种
			case CtWingConstant.dataReport:
				String APPdata = jsonObject.getJSONObject("payload").getString("APPdata");
				byte[] decoded2 = Base64.getDecoder().decode(APPdata);
				String hex2 = CtWingUtils.bytesToHexStr(decoded2);
				System.out.println(CtWingUtils.hexStrToStr(hex2));
				break;
			case CtWingConstant.deviceOnlineOfflineReport:
				String eventType = jsonObject.getString("eventType");
				System.out.println(eventType);
				break;
			case CtWingConstant.commandResponse:
				String taskId = jsonObject.getString("taskId");
				//JSONObject jsonResult = jsonObject.getJSONObject("result");
				System.out.println(taskId);
				break;
			default:
				break;
		}
		Map<String, Object> mapResult = new HashMap<>();
		mapResult.put("state", true);
		return mapResult;
	}

}

CtWingDownCmdController

package boot.ctwing.tcp.app.controller;

import boot.ctwing.tcp.app.config.CtWingConstant;
import boot.ctwing.tcp.app.utils.CtWingDownSendUtils_1;
import boot.ctwing.tcp.app.utils.CtWingDownSendUtils_2;
import boot.ctwing.tcp.app.utils.CtWingDownSendUtils_3;
import com.alibaba.fastjson.JSONObject;
import com.ctg.ag.sdk.biz.aep_device_command.CreateCommandResponse;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.*;

/**
 * 	蚂蚁舞 下行指令
 */
@Controller
@RequestMapping("/down")
public class CtWingDownCmdController {

	private final Logger log =  LoggerFactory.getLogger(this.getClass());

	@PostMapping(value = "/cmd_send_1")
	@ResponseBody
	public String cmd_send_1(@RequestParam(name="imei",required = true) String imei, @RequestParam(name="payload",required = true) String payload) throws Exception {
		JSONObject jsonContent = new JSONObject();
		jsonContent.put("dataType", 1);  // TCP和LWM2M协议透传的content内容, payload:指令内容,数据格式为十六进制时需要填十六进制字符串,
		jsonContent.put("payload",payload);	//	dataType:数据类型：1字符串，2十六进制

		JSONObject jsonObject = new JSONObject();
		jsonObject.put("content", jsonContent);	//	指令内容，必填，格式为Json
		jsonObject.put("deviceId", CtWingConstant.PRODUCT_ID+imei);  //	设备ID，（当指令级别为设备级时必填，为设备组级时则不填）
		jsonObject.put("operator", "myw");	//	操作者，必填
		jsonObject.put("productId", CtWingConstant.PRODUCT_ID);	//	产品ID，必填
		jsonObject.put("ttl", 0);	//	设备指令缓存时长，选填。单位：秒，取值范围：0-864000,不携带则默认值：7200 如不需缓存请填0
		jsonObject.put("level", 1);	//	指令级别，1或2为设备级别,3为设备组级别，选填。不填默认设备级

		CreateCommandResponse response = CtWingDownSendUtils_1.sendApi(jsonObject.toString());
		log.info(response.toString());
		return response.toString();
	}

	@PostMapping(value = "/cmd_send_2")
	@ResponseBody
	public String cmd_send_2(@RequestParam(name="imei",required = true) String imei, @RequestParam(name="payload",required = true) String payload) throws Exception {
		JSONObject jsonContent = new JSONObject();
		jsonContent.put("dataType", 1);  // TCP和LWM2M协议透传的content内容, payload:指令内容,数据格式为十六进制时需要填十六进制字符串,
		jsonContent.put("payload",payload);	//	dataType:数据类型：1字符串，2十六进制

		JSONObject jsonObject = new JSONObject();
		jsonObject.put("content", jsonContent);	//	指令内容，必填，格式为Json
		jsonObject.put("deviceId", CtWingConstant.PRODUCT_ID+imei);  //	设备ID，（当指令级别为设备级时必填，为设备组级时则不填）
		jsonObject.put("operator", "myw");	//	操作者，必填
		jsonObject.put("productId", CtWingConstant.PRODUCT_ID);	//	产品ID，必填
		jsonObject.put("ttl", 0);	//	设备指令缓存时长，选填。单位：秒，取值范围：0-864000,不携带则默认值：7200 如不需缓存请填0
		jsonObject.put("level", 1);	//	指令级别，1或2为设备级别,3为设备组级别，选填。不填默认设备级

		String str = CtWingDownSendUtils_2.httpPostExample(jsonObject.toString());
		log.info(str);
		return str;
	}

	@PostMapping(value = "/cmd_send_3")
	@ResponseBody
	public String cmd_send_3(@RequestParam(name="imei",required = true) String imei, @RequestParam(name="payload",required = true) String payload) throws Exception {
		JSONObject jsonContent = new JSONObject();
		jsonContent.put("dataType", 1);  // TCP和LWM2M协议透传的content内容, payload:指令内容,数据格式为十六进制时需要填十六进制字符串,
		jsonContent.put("payload",payload);	//	dataType:数据类型：1字符串，2十六进制

		JSONObject jsonObject = new JSONObject();
		jsonObject.put("content", jsonContent);	//	指令内容，必填，格式为Json
		jsonObject.put("deviceId", CtWingConstant.PRODUCT_ID+imei);  //	设备ID，（当指令级别为设备级时必填，为设备组级时则不填）
		jsonObject.put("operator", "myw");	//	操作者，必填
		jsonObject.put("productId", CtWingConstant.PRODUCT_ID);	//	产品ID，必填
		jsonObject.put("ttl", 0);	//	设备指令缓存时长，选填。单位：秒，取值范围：0-864000,不携带则默认值：7200 如不需缓存请填0
		jsonObject.put("level", 1);	//	指令级别，1或2为设备级别,3为设备组级别，选填。不填默认设备级

		String strResult = CtWingDownSendUtils_3.send_post(jsonObject.toString());
		log.info(strResult);
		return strResult;

	}


	@PostMapping(value = "/cmd_send_test")
	@ResponseBody
	public String cmd_send_test() throws Exception {
		JSONObject jsonContent = new JSONObject();
		jsonContent.put("dataType", 1);  // TCP和LWM2M协议透传的content内容, payload:指令内容,数据格式为十六进制时需要填十六进制字符串,
		jsonContent.put("payload","hello"); //	dataType:数据类型：1字符串，2十六进制

		JSONObject jsonObject = new JSONObject();
		jsonObject.put("content", jsonContent);	//	指令内容，必填，格式为Json
		jsonObject.put("deviceId", CtWingConstant.PRODUCT_ID+"869401041201815"); //	设备ID，（当指令级别为设备级时必填，为设备组级时则不填）
		jsonObject.put("operator", "myw");	//	操作者，必填
		jsonObject.put("productId", CtWingConstant.PRODUCT_ID);	//	产品ID，必填
		jsonObject.put("ttl", 0);	//	设备指令缓存时长，选填。单位：秒，取值范围：0-864000,不携带则默认值：7200 如不需缓存请填0
		jsonObject.put("level", 1);	//	指令级别，1或2为设备级别,3为设备组级别，选填。不填默认设备级

//		CreateCommandResponse response = CtWingDownSendUtils_1.sendApi(jsonObject.toString());
//		log.info(response.toString());
//		return response.toString();
//
//		String str = CtWingDownSendUtils_2.httpPostExample(jsonObject.toString());
//		log.info(str);
//		return str;

		String strResult = CtWingDownSendUtils_3.send_post(jsonObject.toString());
		log.info(strResult);
		return strResult;
	}





}

CtWingDownSendUtils_1

package boot.ctwing.tcp.app.utils;


import boot.ctwing.tcp.app.config.CtWingConstant;
import com.ctg.ag.sdk.biz.AepDeviceCommandClient;
import com.ctg.ag.sdk.biz.aep_device_command.CreateCommandRequest;
import com.ctg.ag.sdk.biz.aep_device_command.CreateCommandResponse;

/**
 *  蚂蚁舞
 */
public class CtWingDownSendUtils_1 {

    /**
     *  ctwing提供的sdk方式下发指令，方便快速，在后台创建应用后可获取sdk
     */
    public static CreateCommandResponse sendApi(String jsonStr) throws Exception {

        AepDeviceCommandClient client = AepDeviceCommandClient.newClient().appKey(CtWingConstant.APP_KEY).appSecret(CtWingConstant.APP_SECRET).build();

        CreateCommandRequest request = new CreateCommandRequest();
        // set your request params here
        request.setParamMasterKey(CtWingConstant.MASTER_KEY);	// single value
        request.setBody(jsonStr.getBytes());	//具体格式
        CreateCommandResponse commandResponse = client.CreateCommand(request);
        client.shutdown();
        return commandResponse;
    }




}

CtWingDownSendUtils_2

package boot.ctwing.tcp.app.utils;

import boot.ctwing.tcp.app.config.CtWingConstant;
import org.apache.commons.codec.binary.Base64;
import org.apache.http.Header;
import org.apache.http.HttpResponse;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.client.utils.URIBuilder;
import org.apache.http.entity.StringEntity;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClientBuilder;
import org.apache.http.util.EntityUtils;

import javax.crypto.Mac;
import javax.crypto.SecretKey;
import javax.crypto.spec.SecretKeySpec;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.text.SimpleDateFormat;
import java.util.*;

public class CtWingDownSendUtils_2 {


    //  官方提供的example
    public static String httpPostExample(String bodyString) throws Exception {
        String secret = CtWingConstant.APP_SECRET;//密钥，到控制台->应用管理打开应用可以找到此值
        String application = CtWingConstant.APP_KEY;//appKey，到控制台->应用管理打开应用可以找到此值
        String version = "20190712225145";//api版本，到文档中心->使能平台API文档打开要调用的api可以找到版本值
        String MasterKey = CtWingConstant.MASTER_KEY;//MasterKey，在产品中心打开对应的产品查看此值
        // 下面以增加设备的API为例【具体信息请以使能平台的API文档为准】。
        //请求BODY,到文档中心->使能平台API文档打开要调用的api中，在“请求BODY”中查看
        //String bodyString = "{\"deviceName\":\"testDevice\",\"deviceSn\":\"\",\"imei\":123456789012345,\"operator\":\"admin\",\"productId\":\"9392\"}";

        CloseableHttpClient httpClient = null;
        HttpResponse response = null;
        httpClient = HttpClientBuilder.create().build();
        long offset = getTimeOffset();// 获取时间偏移量，方法见前面
        // 构造请求的URL，具体参考文档中心->使能平台API文档中的请求地址和访问路径
        URIBuilder uriBuilder = new URIBuilder();
        uriBuilder.setScheme("https");
        uriBuilder.setHost("ag-api.ctwing.cn/aep_device_command"); //请求地址
        uriBuilder.setPath("/command"); //访问路径，可以在API文档中对应API中找到此访问路径
        // 在请求的URL中添加参数，具体参考文档中心->API文档中请求参数说明
        // (如果有MasterKey，将MasterKey加到head中，不加在此处)
        //uriBuilder.addParameter("productId", "9392");//如果没有其他参数，此行不要
        HttpPost httpPost = new HttpPost(uriBuilder.build());//构造post请求
        long timestamp = System.currentTimeMillis() + offset;// 获取时间戳
        Date date = new Date(timestamp);
        SimpleDateFormat dateFormat = new SimpleDateFormat("EEE, dd MMM yyyy HH:mm:ss z", Locale.US);
        dateFormat.setTimeZone(TimeZone.getTimeZone("GMT"));
        String dataString = dateFormat.format(date);// 生成格式化的日期字符串
        // head中添加公共参数
        httpPost.addHeader("MasterKey", MasterKey);// MasterKey加在此处head中
        httpPost.addHeader("application", application);
        httpPost.addHeader("timestamp", "" + timestamp);
        httpPost.addHeader("version", version);
        httpPost.addHeader("Content-Type", "application/json; charset=UTF-8");
        httpPost.addHeader("Date", dataString);
        // 下列注释的head暂时未用到
        // httpPost.addHeader("sdk", "GIT: a4fb7fca");
        // httpPost.addHeader("Accept", "gzip,deflate");
        // httpPost.addHeader("User-Agent", "Telecom API Gateway Java SDK");
        // 构造签名需要的参数,如果参数中有MasterKey，则添加来参与签名计算,
        // 其他参数根据实际API从URL中获取,如有其他参数,写法参考get示例
        Map<String, String> param = new HashMap<String, String>();
        param.put("MasterKey", MasterKey);
        // 添加签名
        httpPost.addHeader("signature", sign(param, timestamp, application, secret, bodyString.getBytes()));
        //请求添加body部分
        httpPost.setEntity(new StringEntity(bodyString,"utf-8"));
        try {
            // 发送请求
            response = httpClient.execute(httpPost);
            // 从response获取响应结果
            String result = new String(EntityUtils.toByteArray(response.getEntity()));
            httpClient.close();
            return result;
        } catch (IOException e) {
            e.printStackTrace();
        }
        return null;
    }

    /**
     * @param param    api 配置参数表
     * @param timestamp UNIX格式时间戳
     * @param application appKey,到应用管理打开应用可以找到此值
     * @param secret 密钥,到应用管理打开应用可以找到此值
     * @param body 请求body数据,如果是GET请求，此值写null
     * @return 签名数据
     */
    public static String sign(Map<String, String> param, long timestamp, String application, String secret, byte[] body) throws Exception {
        // 连接系统参数
        StringBuffer sb = new StringBuffer();
        sb.append("application").append(":").append(application).append("\n");
        sb.append("timestamp").append(":").append(timestamp).append("\n");
        // 连接请求参数
        if (param != null) {
            TreeSet<String> keys = new TreeSet<String>(param.keySet());
            for (String s : keys) {
                String val = param.get(s);
                sb.append(s).append(":").append(val == null ? "" : val).append("\n");
            }
        }
        //body数据写入需要签名的字符流中
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        baos.write(sb.toString().getBytes("utf-8"));
        if (body != null && body.length > 0) {
            baos.write(body);
            baos.write("\n".getBytes("utf-8"));
        }
        // 得到需要签名的字符串
        String string = baos.toString("utf-8");
        System.out.println("Sign string: " + string);
        // hmac-sha1编码
        byte[] bytes = null;
        SecretKey secretKey = new SecretKeySpec(secret.getBytes("utf-8"), "HmacSha1");
        Mac mac = Mac.getInstance(secretKey.getAlgorithm());
        mac.init(secretKey);
        bytes = mac.doFinal(string.getBytes("utf-8"));
        // base64编码
        // 得到需要提交的signature签名数据
        return new String(Base64.encodeBase64(bytes));
    }

    public static long getTimeOffset() {
        long offset = 0;
        HttpResponse response = null;
        //构造httpGet请求
        CloseableHttpClient httpClient = HttpClientBuilder.create().build();
        HttpGet httpTimeGet = new HttpGet("https://ag-api.ctwing.cn/echo");
        try {
            long start = System.currentTimeMillis();
            response = httpClient.execute(httpTimeGet);
            long end = System.currentTimeMillis();
            //时间戳在返回的响应的head的x-ag-timestamp中
            Header[] headers = response.getHeaders("x-ag-timestamp");
            if (headers.length > 0) {
                long serviceTime = Long.parseLong(headers[0].getValue());
                offset = serviceTime - (start + end) / 2L;
            }
            httpClient.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return offset;
    }



}

CtWingDownSendUtils_3

package boot.ctwing.tcp.app.utils;

import boot.ctwing.tcp.app.config.CtWingConstant;
import cn.hutool.http.HttpRequest;
import org.apache.commons.codec.binary.Base64;
import javax.crypto.Mac;
import javax.crypto.SecretKey;
import javax.crypto.spec.SecretKeySpec;
import java.io.ByteArrayOutputStream;
import java.nio.charset.StandardCharsets;
import java.text.SimpleDateFormat;
import java.util.*;

/**
 *  蚂蚁舞
 */
public class CtWingDownSendUtils_3 {

    //  使用hutool request
    private static final String url_time = "https://ag-api.ctwing.cn/echo";

    private static final String url_cmd = "http://ag-api.ctwing.cn/aep_device_command/command";

    public static String send_post(String data) throws Exception {
        long offset = getTimeOffset();// 获取时间偏移量
        long timestamp = System.currentTimeMillis() + offset;// 获取时间戳
        Date date = new Date(timestamp);
        SimpleDateFormat dateFormat = new SimpleDateFormat("EEE, dd MMM yyyy HH:mm:ss z", Locale.US);
        dateFormat.setTimeZone(TimeZone.getTimeZone("GMT"));
        String dataString = dateFormat.format(date);// 生成格式化的日期字符串

        Map<String, String> param = new HashMap<>();
        param.put("MasterKey", CtWingConstant.MASTER_KEY);

        String signature = sign(param, timestamp, CtWingConstant.APP_KEY, "if8hEBlPIs", data.getBytes());
        //System.out.println(signature);
        Map<String, String> headers = new HashMap<>();
        headers.put("Content-Type", "application/json; charset=UTF-8");
        headers.put("application", CtWingConstant.APP_KEY);
        headers.put("MasterKey", CtWingConstant.MASTER_KEY);// MasterKey加在此处head中
        headers.put("timestamp",timestamp+"");
        headers.put("signature", signature);
        headers.put("Date", dataString);
        headers.put("version", "20190712225145"); //版本  需要根据实际来确定
        return HttpRequest.post(url_cmd).headerMap(headers, true).body(data).timeout(6000).execute().body();
    }

    public static String sign(Map<String, String> param, long timestamp, String application, String secret, byte[] body) throws Exception {
        // 连接系统参数
        StringBuffer sb = new StringBuffer();
        sb.append("application").append(":").append(application).append("\n");
        sb.append("timestamp").append(":").append(timestamp).append("\n");
        // 连接请求参数
        if (param != null) {
            TreeSet<String> keys = new TreeSet<String>(param.keySet());
            for (String s : keys) {
                String val = param.get(s);
                sb.append(s).append(":").append(val == null ? "" : val).append("\n");
            }
        }
        //body数据写入需要签名的字符流中
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        baos.write(sb.toString().getBytes(StandardCharsets.UTF_8));
        if (body != null && body.length > 0) {
            baos.write(body);
            baos.write("\n".getBytes(StandardCharsets.UTF_8));
        }
        // 得到需要签名的字符串
        String string = baos.toString("utf-8");
        // hmac-sha1编码
        byte[] bytes = null;
        SecretKey secretKey = new SecretKeySpec(secret.getBytes(StandardCharsets.UTF_8), "HmacSha1");
        Mac mac = Mac.getInstance(secretKey.getAlgorithm());
        mac.init(secretKey);
        bytes = mac.doFinal(string.getBytes(StandardCharsets.UTF_8));
        // base64编码
        // 得到需要提交的signature签名数据
        return new String(Base64.encodeBase64(bytes));
    }

    public static long getTimeOffset() {
        long offset = 0;
        long start = System.currentTimeMillis();
        cn.hutool.http.HttpResponse res = HttpRequest.get(url_time).execute();
        long end = System.currentTimeMillis();
        //时间戳在返回的响应的head的x-ag-timestamp中
        String headers = res.header("x-ag-timestamp");
        if (headers.length() > 0) {
            long serviceTime = Long.parseLong(headers);
            offset = serviceTime - (start + end) / 2L;
        }
        return offset;
    }


}

CtWingUtils

package boot.ctwing.tcp.app.utils;

import java.nio.charset.StandardCharsets;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 *  蚂蚁舞
 */
public class CtWingUtils {

    private static final Logger log =  LoggerFactory.getLogger(CtWingUtils.class);

    private static final char[] HEXES = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'};

    public static String bytesToHexStr(byte[] bytes) {
        if (bytes == null || bytes.length == 0) {
            return null;
        }
        StringBuilder hex = new StringBuilder(bytes.length * 2);
        for (byte b : bytes) {
            hex.append(HEXES[(b >> 4) & 0x0F]);
            hex.append(HEXES[b & 0x0F]);
        }
        return hex.toString().toUpperCase();
    }

    public static byte[] hexStrToBytes(String hex) {
        if (hex == null || hex.length() == 0) {
            return null;
        }
        char[] hexChars = hex.toCharArray();
        byte[] bytes = new byte[hexChars.length / 2];   // 如果 hex 中的字符不是偶数个, 则忽略最后一个
        for (int i = 0; i < bytes.length; i++) {
            bytes[i] = (byte) Integer.parseInt("" + hexChars[i * 2] + hexChars[i * 2 + 1], 16);
        }
        return bytes;
    }

    public static String strToHexStr(String str) {
        StringBuilder sb = new StringBuilder();
        byte[] bs = str.getBytes();
        int bit;
        for (int i = 0; i < bs.length; i++) {
            bit = (bs[i] & 0x0f0) >> 4;
            sb.append(HEXES[bit]);
            bit = bs[i] & 0x0f;
            sb.append(HEXES[bit]);
        }
        return sb.toString().trim();
    }

    public static String hexStrToStr(String hexStr) {
        //能被16整除,肯定可以被2整除
        byte[] array = new byte[hexStr.length() / 2];
        try {
            for (int i = 0; i < array.length; i++) {
                array[i] = (byte) (0xff & Integer.parseInt(hexStr.substring(i * 2, i * 2 + 2), 16));
            }
            hexStr = new String(array, StandardCharsets.UTF_8);
        } catch (Exception e) {
            e.printStackTrace();
            return "";
        }
        return hexStr;
    }


}

代码目录结构

├─boot-example-ctwing-tcp-app-2.0.5
│  │  pom.xml
│  │  
│  ├─doc
│  │  │  108549_sdk.tar.gz
│  │  │  Readme.md
│  │  │  
│  │  ├─demo
│  │  │      AepCommandModbusDemo.java
│  │  │      AepDeviceCommandDemo.java
│  │  │      AepDeviceCommandLwmProfileDemo.java
│  │  │      AepDeviceControlDemo.java
│  │  │      AepDeviceEventDemo.java
│  │  │      AepDeviceGroupManagementDemo.java
│  │  │      AepDeviceManagementDemo.java
│  │  │      AepDeviceModelDemo.java
│  │  │      AepDeviceStatusDemo.java
│  │  │      AepEdgeGatewayDemo.java
│  │  │      AepFirmwareManagementDemo.java
│  │  │      AepModbusDeviceManagementDemo.java
│  │  │      AepMqSubDemo.java
│  │  │      AepNbDeviceManagementDemo.java
│  │  │      AepProductManagementDemo.java
│  │  │      AepPublicProductManagementDemo.java
│  │  │      AepRuleEngineDemo.java
│  │  │      AepSoftwareManagementDemo.java
│  │  │      AepSoftwareUpgradeManagementDemo.java
│  │  │      AepStandardManagementDemo.java
│  │  │      AepSubscribeNorthDemo.java
│  │  │      AepUpgradeManagementDemo.java
│  │  │      TenantAppStatisticsDemo.java
│  │  │      TenantDeviceStatisticsDemo.java
│  │  │      UsrDemo.java
│  │  │      
│  │  ├─doc
│  │  │      ApiDocument_AEPNB设备管理_aep_nb_device_management.md
│  │  │      ApiDocument_AEP事件上报_aep_device_event.md
│  │  │      ApiDocument_AEP产品管理_aep_product_management.md
│  │  │      ApiDocument_AEP公共产品管理_aep_public_product_management.md
│  │  │      ApiDocument_AEP分组管理_aep_device_group_management.md
│  │  │      ApiDocument_AEP升级包管理_aep_software_management.md
│  │  │      ApiDocument_AEP固件管理_aep_firmware_management.md
│  │  │      ApiDocument_AEP固件远程升级管理_aep_upgrade_management.md
│  │  │      ApiDocument_AEP指令下发_aep_device_command.md
│  │  │      ApiDocument_AEP指令下发_lwm2m有profile_aep_device_command_lwm_profile.md
│  │  │      ApiDocument_AEP指令下发_modbus_aep_command_modbus.md
│  │  │      ApiDocument_AEP数据查询_aep_device_status.md
│  │  │      ApiDocument_AEP标准物模型管理_aep_standard_management.md
│  │  │      ApiDocument_AEP物模型管理_aep_device_model.md
│  │  │      ApiDocument_AEP规则引擎_aep_rule_engine.md
│  │  │      ApiDocument_AEP订阅管理_aep_subscribe_north.md
│  │  │      ApiDocument_AEP设备管理_aep_device_management.md
│  │  │      ApiDocument_AEP设备管理_modbus_aep_modbus_device_management.md
│  │  │      ApiDocument_AEP软件升级管理_aep_software_upgrade_management.md
│  │  │      ApiDocument_AEP边缘网关接入_aep_edge_gateway.md
│  │  │      ApiDocument_AEP远程控制_aep_device_control.md
│  │  │      ApiDocument_MQ订阅推送管理_aep_mq_sub.md
│  │  │      ApiDocument_User_usr.md
│  │  │      ApiDocument_感知终端数据分析_tenant_device_statistics.md
│  │  │      ApiDocument_物联网应用数据分析_tenant_app_statistics.md
│  │  │      
│  │  ├─lib
│  │  │      ag-sdk-biz-108549.tar.gz-20221221.143437-SNAPSHOT.jar
│  │  │      ag-sdk-biz-108549.tar.gz-20221221.143437-SNAPSHOT.pom.xml
│  │  │      ctg-ag-sdk-core-2.7.0-20221208.015855-5.jar
│  │  │      ctg-ag-sdk-core-2.7.0-20221208.015855-5.pom.xml
│  │  │      
│  │  └─src
│  │          ag-sdk-biz-108549.tar.gz-20221221.143437-source.jar
│  │          
│  └─src
│      ├─main
│      │  ├─java
│      │  │  └─boot
│      │  │      └─ctwing
│      │  │          └─tcp
│      │  │              └─app
│      │  │                  │  BootCtWingTcpApp.java
│      │  │                  │  
│      │  │                  ├─config
│      │  │                  │      CtWingConstant.java
│      │  │                  │      SwaggerConfig.java
│      │  │                  │      
│      │  │                  ├─controller
│      │  │                  │      CtWingDownCmdController.java
│      │  │                  │      CtWingReceiveController.java
│      │  │                  │      
│      │  │                  └─utils
│      │  │                          CtWingDownSendUtils_1.java
│      │  │                          CtWingDownSendUtils_2.java
│      │  │                          CtWingDownSendUtils_3.java
│      │  │                          CtWingUtils.java
│      │  │                          
│      │  └─resources
│      │          application.properties
│      │          logback-spring.xml
│      │          
│      └─test
│          └─java
│              └─boot
│                  └─ctwing
│                      └─tcp
│                          └─app
│                                  BootCtWingTcpAppTest.java
│                                  Test.java
│

订阅需要部署在云服务器上或者其他方式，启动项目后，在启动模拟设备端的应用，操作上行下行交互，可以看到很不错的结果

在这里我用了三种方式视线指令的下发

第一种 AIOT提供的SDK 超好用

第二种 AIOT在官方文档提供的Demo 代码较多，方便理解，也可用

第三种使用Hutool工具的请求来实现，实际也是参考AIOT官方提供demo实现的

再看看AIOT平台的下发指令日志

订阅数据的json数据格式，这里记录一下

上下线消息通知

{"timestamp":1671885117746,"tenantId":"XXXXXX","protocol":"tcp","productId":"15506850","messageType":"deviceOnlineOfflineReport","ipv4Address":"39.144.17.238","iccid":"undefined","eventType":1,"deviceId":"15506850869401041201815"}


{"timestamp":1671886478951,"tenantId":"XXXXXX","protocol":"tcp","productId":"15506850","messageType":"deviceOnlineOfflineReport","eventType":0,"deviceId":"15506850869401041201815"}

数据上报通知

{"upPacketSN":-1,"upDataSN":-1,"topic":"ad","timestamp":1671885539011,"tenantId":"XXXXXX","serviceId":"","protocol":"tcp","productId":"15506850","payload":{"APPdata":"6JqC6JqB6Iie"},"messageType":"dataReport","deviceType":"","deviceId":"15506850869401041201815","assocAssetId":"","IMSI":"","IMEI":""}


{"upPacketSN":-1,"upDataSN":-1,"topic":"ad","timestamp":1671885567941,"tenantId":"XXXXXX","serviceId":"","protocol":"tcp","productId":"15506850","payload":{"APPdata":"bXl5aHR3MTIzNDU0NjU0Njc0ZXF3amRjcW93ZWljcW93aXhjbmRjeA=="},"messageType":"dataReport","deviceType":"","deviceId":"15506850869401041201815","assocAssetId":"","IMSI":"","IMEI":""}

指令下发后通知

{"timestamp":1671932803885,"tenantId":"XXXXXX","taskId":2,"result":{"resultDetail":"","resultCode":"SENT"},"protocol":"tcp","productId":"15506850","messageType":"commandResponse","deviceId":"15506850869401041201815"}