物联网云平台实验3(可选内容）

注：本文仅旨在以更简单的办法实现该实验，实现过程和老师不统一，包括代码和数据库结构属性都存在差异。

准备工作

1.确保你之前实验的设备表的表名和设备实体类名为Devices

2.新建数据库表Updatastream（PPT的表名为Updatastreams）

create table updatastream
(
    id        varchar(32)              not null comment '向上通道
ID'
        primary key,
    title     varchar(50)              not null comment '通
道名称',
    data_type int unsigned             not null comment '数据
类型',
    unit      varchar(40)              null comment '数据单位',
    mark      varchar(255)             null comment '备注',
    device_id varchar(32)              not null comment '设备编
号',
    direction int unsigned default '1' null comment '方
向',
    constraint title
        unique (title),
    constraint updatastream_ibfk_1
        foreign key (device_id) references devices (id)
)
    comment '向下通道表';

create index device_id
    on updatastream (device_id);

3.新建数据库表Downdatastream（PPT的表名为Downdatastreams）

create table downdatastream
(
    id        varchar(32)              not null comment '向下通道
ID'
        primary key,
    title     varchar(50)              not null comment '通道名称',
    data_type int unsigned             not null comment '数
据类型',
    unit      varchar(40)              null comment '数据单位',
    mark      varchar(255)             null comment '备注',
    device_id varchar(32)              not null comment '设备
编号',
    direction int unsigned default '2' null comment '方
向',
    constraint title
        unique (title)
)
    comment '向下通道表';

create index device_id
    on downdatastream (device_id);

4.在pojo包中新建实体类Updatastream和Downdatastream

@Data
@AllArgsConstructor
@NoArgsConstructor
@ApiModel
public class Updatastream implements Serializable {
    @ApiModelProperty
    private String id;
    @ApiModelProperty
    private String title;
    @ApiModelProperty
    private Integer dataType;
    private String unit;
    private String mark;
    //多对一
//    @ApiModelProperty(hidden = true)
    @TableField(exist = false)
    private Devices devices;
    private String deviceId;
    /**方向标识，向上为1，向下为2，非数据库字段*/
    private Integer direction;

}

@Data
@NoArgsConstructor
@AllArgsConstructor
public class Downdatastream implements Serializable {
    private String id;
    private String title;
    private Integer dataType;
    //多对一
    private String unit;
    private String mark;
    /**方向标识，向上为1，向下为2，非数据库字段*/
    private Integer direction;
    private String deviceId;
    @TableField(exist = false)
    private Devices device;
}

5.添加MybatisPlus依赖

<dependency>
    <groupId>com.baomidou</groupId>
    <artifactId>mybatis-plus-boot-starter</artifactId>
    <version>3.4.2</version>
</dependency>

6.在Mapper包下新建DevicesMapper、UpdatastreamMapper和DowndataStreamMapper

@Mapper
public interface DevicesMapper extends BaseMapper<Devices> {
}

@Mapper
public interface UpdatastreamMapper extends BaseMapper<Updatastream> {
}

@Mapper
public interface DowndatastreamMapper extends BaseMapper<Downdatastream> {
}

7.在Service包中新建UpdatastreamService接口和DowndatastreamService接口

public interface UpdatastreamService extends IService<Updatastream> {
    /*新增向上通道*/
    public Result save(String deviceId, Updatastream updatastream);
    public List<Updatastream> findByType(@Param("devId")String devId, @Param("data_type") Integer data_type);
    
}

public interface DowndatastreamService extends IService<Downdatastream> {
    public Result save(String device_id, Downdatastream downdatastream);//增加
    public List<Downdatastream> findByType(@Param("devId")String devId, @Param("data_type") Integer data_type);
}

8.在Service.Impl包下新建UpdatastreamServiceImpl和DowndatastreamServiceImpl实现类

@Service
public class UpdatastreamServiceImpl extends ServiceImpl<UpdatastreamMapper, Updatastream> implements UpdatastreamService {
    @Autowired
    private UpdatastreamService updatastreamService;
    @Autowired
    private DevicesService devicesService;
    @Override
    public Result save(String deviceId, Updatastream updatastream) {
        if (deviceId.isEmpty()) {
            return Result.error(ResultStatus.GET_ID_ERROR);
        }
//        Devices device = new Devices();
        device.setId(deviceId);
        LambdaQueryWrapper<Devices> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(Devices::getId, deviceId);
        Devices device = devicesService.getOne(queryWrapper);
        updatastream.setDevices(device);
        updatastream.setDeviceId(device.getId());
        updatastream.setId(UUIDUtil.getUUID());
//        updatastreamDao.save(updatastream);
        updatastreamService.save(updatastream);
        return Result.ok(ResultStatus.SAVE_SUCCESS, updatastream);
    }
    @Override
    public List<Updatastream> findByType(String devId, Integer data_type) {
        LambdaQueryWrapper<Updatastream> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(Updatastream::getDeviceId, devId);
        queryWrapper.eq(Updatastream::getDataType, data_type);
        return updatastreamService.list(queryWrapper);
    }
}

@Service
public class DowndatastreamServiceImpl2 extends ServiceImpl<DowndatastreamMapper, Downdatastream> implements DowndatastreamService {
    @Autowired
    private DowndatastreamService downdatastreamService;
    @Autowired
    private DevicesService devicesService;
    @Override
    public Result save(String device_id, Downdatastream downdatastream) {
        if( StringUtil.isEmpty(device_id)){
            return Result.error(ResultStatus.GET_ID_ERROR);
        }
//        Devices device = new Devices();
//        device.setId(device_id);
        LambdaQueryWrapper<Devices> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(Devices::getId,device_id);
        Devices device = devicesService.getOne(queryWrapper);
        downdatastream.setDevice(device);
        downdatastream.setDeviceId(device_id);
        downdatastream.setId(UUIDUtil.getUUID());
//        downdatastreamDao.save(downdatastream);
        downdatastreamService.save(downdatastream);
        return Result.ok(ResultStatus.SAVE_SUCCESS,downdatastream);
    }
    @Override
    public List<Downdatastream> findByType(String devId, Integer data_type) {
        LambdaQueryWrapper<Downdatastream> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(Downdatastream::getDeviceId, devId);
        queryWrapper.eq(Downdatastream::getDataType, data_type);
        return downdatastreamService.list(queryWrapper);
    }
}

9.打开你之前实验的DeviceService 在类名后添加 "extends IService<Devices>" 并添加一条方法声明

public interface DevicesService extends IService<Devices> {
    Result findDataStreamByType(Integer direct, Integer dataType);
}

10.打开DeviceServiceImpl 在类名后添加"extends ServiceImpl<DevicesMapper, Devices> implements DevicesService" 并实现该方法

@Service
public class DevicesServiceImpl extends ServiceImpl<DevicesMapper, Devices> implements DevicesService {
    @Autowired
    private UpdatastreamService updatastreamService;
    @Autowired
    private DowndatastreamService downdatastreamService;
    @Autowired
    private DevicesService devicesService;

    @Override
    public Result findDataStreamByType(Integer direct, Integer dataType) {
//        boolean isDirect0=false;
//        if(direct==0) isDirect0=true;
        if(direct==1)
       {
           List<Updatastream> updatastreams;
           LambdaQueryWrapper<Updatastream> queryWrapperUp = new LambdaQueryWrapper<>();
           if(dataType!=0)
               queryWrapperUp.eq(Updatastream::getDataType,dataType);
           updatastreams = updatastreamService.list(queryWrapperUp);
           for (Updatastream updatastream : updatastreams) {
               String deviceId = updatastream.getDeviceId();
               Devices device = devicesService.getById(deviceId);
               updatastream.setDevices(device);
           }
           return Result.success(updatastreams);
       }
        if(direct==2)
        {
            LambdaQueryWrapper<Downdatastream> queryWrapperDown = new LambdaQueryWrapper<>();
            List<Downdatastream> downdatastreams;
            if (dataType!=0)
                queryWrapperDown.eq(Downdatastream::getDataType,dataType);
            downdatastreams = downdatastreamService.list(queryWrapperDown);
            for (Downdatastream downdatastream : downdatastreams) {
                String deviceId = downdatastream.getDeviceId();
                Devices device = devicesService.getById(deviceId);
                downdatastream.setDevice(device);
            }
            return Result.success(downdatastreams);
        }
        return Result.error("方向输入错误");
    }
}

具体实现

创建通道

在Controller包下新建DataStreamLinkController

@RestController
@RequestMapping(value = "/datastream")
public class DataStreamLinkController {
//    @Autowired
//    private IDatastreamlinkService datastreamlinkService;
    @Autowired
    private DowndatastreamService downdatastreamService;
    @Autowired
    private UpdatastreamService updatastreamService;
    @PostMapping(value = "/{deviceId}/{title}/{data_type}/{direct}")
    public Result add(@PathVariable String deviceId, @PathVariable String title,
                      @PathVariable Integer data_type, @PathVariable Integer direct){
        Datastreamlink datastreamlink = new Datastreamlink();
        datastreamlink.setTitle(title);
        try {
//双向通道
//            if(direct == 0){
//                return datastreamlinkService.save(deviceId,title,data_type);
//            }
//向上通道
            if(direct == 1){
                Updatastream updatastream = new Updatastream();
                updatastream.setTitle(title);
                updatastream.setDataType(data_type);
                return updatastreamService.save(deviceId,updatastream);
            }
            if(direct == 2)
            {
                Downdatastream downdatastream = new Downdatastream();
                downdatastream.setTitle(title);
                downdatastream.setDataType(data_type);
                return downdatastreamService.save(deviceId,downdatastream);
            }
        }catch (Exception e){
            e.printStackTrace();
            return Result.error("SAVE_ERROR");
        }
        return Result.error("INPUT_PARAM_ERROR");
    }

}

可以进行测试了，测试方法参照老师PPT。

查询不同方向的通道

在DataStreamLinkController里添加该方法

  @GetMapping("/{device_pk}/{direct}/{data_type}")
    public Result findDataStreamByType(@PathVariable("device_pk") String device_pk,
                                       @PathVariable("direct") Integer direct,
                                       @PathVariable("data_type") Integer data_type){
        try{
            return devicesService.findDataStreamByType(device_pk,direct,data_type);
        }catch (Exception e){
            e.printStackTrace();
            return Result.error("SELECT_ERROR");
        }
    }

可以进行测试了，测试方法参照老师PPT。