awsIot服务端集成 springboot

左手的ㄟ右手 2022-09-14 11:20 259阅读 0赞

最近公司需求需要做物联网功能的东西，最后选择了aws的iot技术，由于第一次做，只能硬着头皮看这aws上的英文文档。

首先我是先百度了下发现初始化awsiot客户端全是用AWS SDK for Java1.x，然而官方却推荐AWS SDK for Java2.x，最后只能靠自己了。。。

代码如下  
首先初始化awsIot客户端

package com.example.awsmqtt.config;
    
    import org.springframework.beans.factory.annotation.Value;
    import org.springframework.stereotype.Component;
    import software.amazon.awssdk.auth.credentials.AwsBasicCredentials;
    import software.amazon.awssdk.auth.credentials.AwsCredentials;
    import software.amazon.awssdk.auth.credentials.AwsCredentialsProvider;
    
    @Component
    public class CredentialsProvider implements AwsCredentialsProvider {
    
    	//你的亚马逊账户访问密钥ID
        @Value("${aws.accessKey}")
        private String ACCESS_KEY;
        //你的亚马逊账户访问密钥内容
        @Value("${aws.secretAccessKey}")
        private String SECRET_ACCESS_KEY;
    
        @Override
        public AwsCredentials resolveCredentials() {
            return AwsBasicCredentials.create(ACCESS_KEY, SECRET_ACCESS_KEY);
        }
    }

package com.example.awsmqtt.config;
    
    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    import software.amazon.awssdk.regions.Region;
    import software.amazon.awssdk.services.iot.IotClient;
    
    /**
     * @Author TZQ
     * @Date 2021/9/29 8:40
     * @Version 1.0
     */
    @Configuration
    public class AwsIotConfig {
    
        @Autowired
        private CredentialsProvider credentialsProvider;
    
    
        private static Logger logger = LoggerFactory.getLogger(AwsIotConfig.class);
    
        /**
         * 创建iot服务连接
         */
        @Bean
        public IotClient createIotService() {
            IotClient awsIot = null;
            try {
                awsIot = IotClient.builder().region(Region.US_EAST_1).credentialsProvider(credentialsProvider).build();
            } catch (Exception e) {
                logger.error("IotServiceUtil.createIotService aws-iot创建连接异常", e);
            }
            return awsIot;
        }
    
    }

此时iot客户端已经建立成功，然后写了一个工具类专门封装了awsiot的功能

package com.example.awsmqtt.util;
    
    import cn.hutool.core.io.FileUtil;
    import cn.hutool.core.io.file.FileWriter;
    import cn.hutool.core.util.ZipUtil;
    import com.example.awsmqtt.config.AwsIotConfig;
    import com.example.awsmqtt.dto.CreateKeysAndCertificateResultDTO;
    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    import org.springframework.beans.factory.annotation.Value;
    import org.springframework.stereotype.Component;
    import software.amazon.awssdk.services.iot.IotClient;
    import software.amazon.awssdk.services.iot.model.*;
    
    import javax.annotation.Resource;
    import java.io.File;
    import java.io.FileNotFoundException;
    
    /**
     * @Author TZQ
     * @Date 2021/9/29 10:58
     * @Version 1.0
     */
    @Component
    public class AwsIotUtil {
    
        @Resource
        private IotClient awsIot;
    
        private static Logger logger = LoggerFactory.getLogger(AwsIotConfig.class);
    
        @Value("certificateFilePath")
        private String certificateFilePath;
    
        /**
         * 创建事物
         */
        public void createIotThing(String thingName) {
            CreateThingRequest thingRequest = CreateThingRequest.builder().thingName(thingName).build();
            CreateThingResponse createThingResponse = awsIot.createThing(thingRequest);
            if (null == createThingResponse) {
                logger.error("createThing 进行iot创建事物未收到返回结果");
                throw new RuntimeException("createThing failed");
            }
        }
    
        /**
         * 创建证书
         */
        public CreateKeysAndCertificateResponse createCertificate() {
            CreateKeysAndCertificateRequest createKeysAndCertificateRequest = CreateKeysAndCertificateRequest.builder().setAsActive(true).build();
            CreateKeysAndCertificateResponse certificateResult = awsIot.createKeysAndCertificate(createKeysAndCertificateRequest);
            if (null == certificateResult) {
                logger.error("createCertificate 进行iot创建证书未收到返回结果");
                throw new RuntimeException("createCertificate failed");
            }
            return certificateResult;
    
        }
    
        /**
         * 创建策略
         * @param thingName
         */
        public void createPolicy(String thingName){
            String policyDocument="{\n" +
                    "  \"Version\": \"2012-10-17\",\n" +
                    "  \"Statement\": [\n" +
                    "    {\n" +
                    "      \"Effect\": \"Allow\",\n" +
                    "      \"Action\": [\n" +
                    "        \"iot:Publish\",\n" +
                    "        \"iot:Receive\",\n" +
                    "        \"iot:RetainPublish\"\n" +
                    "      ],\n" +
                    "      \"Resource\": \"*\"\n" +
                    "    },\n" +
                    "    {\n" +
                    "      \"Effect\": \"Allow\",\n" +
                    "      \"Action\": [\n" +
                    "        \"iot:Subscribe\"\n" +
                    "      ],\n" +
                    "      \"Resource\": \"*\"\n" +
                    "    },\n" +
                    "    {\n" +
                    "      \"Effect\": \"Allow\",\n" +
                    "      \"Action\": [\n" +
                    "        \"iot:Connect\"\n" +
                    "      ],\n" +
                    "      \"Resource\": \"*\"\n" +
                    "    }\n" +
                    "  ]\n" +
                    "}";
            CreatePolicyRequest createPolicyRequest = CreatePolicyRequest.builder().policyName(thingName).policyDocument(policyDocument).build();
            CreatePolicyResponse createPolicyResult = awsIot.createPolicy(createPolicyRequest);
            if (null == createPolicyResult) {
                logger.error("createPolicy 进行iot创建策略未收到返回结果");
                throw new RuntimeException("createPolicy failed");
            }
        }
    
    
        /**
         * 关联策略
         * @param thingName
         * @param certificateArn
         */
        public  void attachPolicy(String thingName,String certificateArn){
            AttachPolicyRequest attachPolicyRequest = AttachPolicyRequest.builder().policyName(thingName).target(certificateArn).build();
            AttachPolicyResponse attachPolicyResponse = awsIot.attachPolicy(attachPolicyRequest);
            if (null == attachPolicyResponse) {
                logger.error("attachPolicy 进行iot关联策略未收到返回结果");
                throw new RuntimeException("attachPolicy failed");
            }
        }
    
    
    
        /**
         * 关联证书
         *
         * @param certificateArn
         * @param thingName
         * @return
         */
        public boolean certificateAttachThing(String certificateArn, String thingName) {
            try {
                //获取iot服务客户端
                if (null == awsIot) {
                    logger.error("certificateAttachThing 获取iot服务出现异常");
                    return false;
                }
                // 附加事物
                // thingName是创thing时指定的。
                // certificateArn是创建证书返回的，标识唯一。
                AttachThingPrincipalRequest thingPrincipalRequest = AttachThingPrincipalRequest.builder().thingName(thingName).principal(certificateArn).build();
                AttachThingPrincipalResponse attachThingPrincipalResponse = awsIot.attachThingPrincipal(thingPrincipalRequest);
                if (null == attachThingPrincipalResponse) {
                    logger.error("certificateAttachThing 进行证书附加事物未收到返回结果");
                    return false;
                }
                //附加成功
                return true;
            } catch (Exception e) {
                logger.error("certificateAttachThing", e);
            }
            return false;
        }
    }

创建事物

package com.example.awsmqtt.controller;
    
    import cn.hutool.json.JSONUtil;
    import com.example.awsmqtt.dto.CreateKeysAndCertificateResultDTO;
    import com.example.awsmqtt.dto.KeyPairDTO;
    import com.example.awsmqtt.util.AwsIotUtil;
    import com.example.awsmqtt.util.FileUtil;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.data.redis.core.StringRedisTemplate;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.RestController;
    import software.amazon.awssdk.services.iot.model.CreateKeysAndCertificateResponse;
    import software.amazon.awssdk.services.iot.model.DescribeEndpointResponse;
    
    import javax.annotation.Resource;
    import javax.servlet.http.HttpServletResponse;
    import java.io.File;
    import java.io.FileNotFoundException;
    
    /**
     * @Author TZQ
     * @Date 2021/9/29 11:06
     * @Version 1.0
     */
    @RestController
    @RequestMapping("awsIot")
    public class AwsIotController {
    
        @Resource
        private AwsIotUtil awsIotUtil;
    
        @Autowired
        private StringRedisTemplate stringRedisTemplate;
    
        /**
         * 创建完整物品
         *
         * @param thingName 事物名称
         */
        @RequestMapping("/createThing")
        public String createThing(String thingName) {
        	//创建物品
            awsIotUtil.createIotThing(thingName);
            //创建证书
            CreateKeysAndCertificateResponse certificate = awsIotUtil.createCertificate();
            String certificateArn = certificate.certificateArn();
            String certificateId = certificate.certificateId();
            String certificatePem = certificate.certificatePem();
            //创建策略
            awsIotUtil.createPolicy(thingName + "-Policy");
            //将策略与证书关联
            awsIotUtil.attachPolicy(thingName + "-Policy",certificateArn );
            //将证书与物品关联
            awsIotUtil.certificateAttachThing(certificateArn, thingName);
            return "OK";
        }
       }

![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5oiR5piv55yf55qE6I-cKOOEkm_jhJIp_size_20_color_FFFFFF_t_70_g_se_x_16]  
![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5oiR5piv55yf55qE6I-cKOOEkm_jhJIp_size_20_color_FFFFFF_t_70_g_se_x_16 1]  
![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5oiR5piv55yf55qE6I-cKOOEkm_jhJIp_size_20_color_FFFFFF_t_70_g_se_x_16 2]  
成功创建完整物品

[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5oiR5piv55yf55qE6I-cKOOEkm_jhJIp_size_20_color_FFFFFF_t_70_g_se_x_16]: /images/20220828/adcc04a034a14d1795ccaf2993f9d32a.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5oiR5piv55yf55qE6I-cKOOEkm_jhJIp_size_20_color_FFFFFF_t_70_g_se_x_16 1]: /images/20220828/c0e54ae1c3cc4be9805a94c1d123a92e.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5oiR5piv55yf55qE6I-cKOOEkm_jhJIp_size_20_color_FFFFFF_t_70_g_se_x_16 2]: /images/20220828/d57d3034283b4a9893dcbfd2c553dbe0.png