更新试验计划接口；添加计划实时设备状态websocket

whyczh

2021-04-07 4992d0ea3fb6adaba4331fda37c43e8f0d00a458

更新试验计划接口；添加计划实时设备状态websocket

 src/main/java/com/whyc/controller/TestDataController.java

@@ -34,6 +34,12 @@
    @Autowired
    private DeviceInfService deviceInfService;

    @GetMapping("ws")
    @ApiOperation(value="查询webSocket",protocols = "ws",notes = "接口:ws://localhost:8090/websocket,发送消息为testPlanId")
    public Response doc(){
        return new Response().setMsg(1,"查看接口描述");
    }

    @GetMapping()
    @ApiOperation("获取历史数据")
    public Response getHistoryData(@RequestParam Integer testPlanId){

 src/main/java/com/whyc/pojo/TestPlan.java

@@ -40,8 +40,8 @@
    private String creator;//创建人
    private Integer state;//状态：0:未开始，1:进行中，2:已结束,3:作废；审核状态：2（已结束时）:未审核，6:已审核，8:已归档
    private String verifier;//审核人
    private Integer planCount;//计划次数
    private Integer testCount;//实际次数
    private int planCount;//计划次数
    private int testCount;//实际次数
    private String conclusion;//试验结论

    public TestPlan() {

 src/main/java/com/whyc/service/MotorStateService.java

@@ -68,6 +68,13 @@

    }

    public MotorState getByDeviceId(int deviceId){
        QueryWrapper<MotorState> wrapper = Wrappers.query();
        wrapper.eq("device_id",deviceId);
        MotorState motorState = motorStateMapper.selectOne(wrapper);
        return motorState;
    }

    public boolean delete(int deviceId){
        return motorStateMapper.deleteById(deviceId)>0;
    }

 src/main/java/com/whyc/service/TestPlanService.java

@@ -11,12 +11,14 @@
import com.whyc.mapper.TestPlanMapper;
import com.whyc.pojo.DeviceManage;
import com.whyc.pojo.TestPlan;
import io.swagger.models.auth.In;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import java.util.Date;
import java.util.List;
import java.util.Random;

@Service
@Slf4j
@@ -68,10 +70,24 @@
    }
    public Response stopPlan(Integer num){
        TestPlan testPlan = mapper.selectById(num);
        testPlan.setState(2);
        //获取计划重复次数
        int planCount = testPlan.getPlanCount();
        int testCount = testPlan.getTestCount();
        if (planCount!=0 && testCount==planCount){
            testPlan.setState(3);//已结束
            int k = (int)Math.random()*2;
            if (k==1){
                testPlan.setConclusion("通过");
            }else{
                testPlan.setConclusion("不通过");
            }
        }else {
            testPlan.setState(2);//已停止
        }
        mapper.updateById(testPlan);
        return new Response().setMsg(1,"停止成功");
    }

    public Response verifiedPlan(Integer num,String verifier){
        TestPlan testPlan = mapper.selectById(num);
        testPlan.setState(6);

 src/main/java/com/whyc/ws/TestDataWebSocket.java

New file
@@ -0,0 +1,125 @@
package com.whyc.ws;

import com.whyc.dto.Response;
import com.whyc.pojo.MotorState;
import com.whyc.pojo.TestPlan;
import com.whyc.service.MotorStateService;
import com.whyc.service.TestPlanService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import javax.websocket.*;
import javax.websocket.server.PathParam;
import javax.websocket.server.ServerEndpoint;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.CopyOnWriteArraySet;

@ServerEndpoint(value = "/websocket/{testPlanId}")
@Component
@Slf4j
public class TestDataWebSocket {
    private static MotorStateService motorStateService;
    private static TestPlanService testPlanService;

    @Autowired
    public void setMotorStateService(MotorStateService motorStateService){
        TestDataWebSocket.motorStateService = motorStateService;
    }
    @Autowired
    public void setTestPlanService(TestPlanService testPlanService){
        TestDataWebSocket.testPlanService = testPlanService;
    }


    /**
     *  与某个客户端的连接对话，需要通过它来给客户端发送消息
     */
    private Session session;

    /**
     * 标识当前连接客户端的参数  试验计划id
     */
    private Integer testPlanId;

    /**
     *  用于存所有的连接服务的客户端，这个对象存储是安全的
     */
    //private static ConcurrentHashMap<String,WebSocket> webSocketSet = new ConcurrentHashMap<>();

    private static CopyOnWriteArraySet<TestDataWebSocket> webSockets = new CopyOnWriteArraySet<>();
    @OnOpen
    public void onOpen(Session session,@PathParam("testPlanId") Integer testPlanId){
        System.out.println("试验计划实时数据websocket...");
        this.session = session;
        this.testPlanId = testPlanId;
        webSockets.add(this);
    }


    @OnMessage
    public void onMessage(Integer message,Session session) {
        try {
            this.sendMessage(message);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public void sendMessage(Integer testPlanId) throws IOException{
        Thread thread = new Thread("TestDataWebSocket"){
            @Override
            public void run() {
                while (true) {
                    try {
                        Response model = null;
                        //获取试验计划数据
                        TestPlan testPlan = testPlanService.getOneById(testPlanId);
                        //获取试验参试设备
                        String devices = testPlan.getDevices();
                        String[] devIds = devices.split(",");
                        List<MotorState> list = new ArrayList<>();
                        for (String deviceId:devIds) {
                            MotorState motorState = motorStateService.getByDeviceId(Integer.valueOf(deviceId));
                            list.add(motorState);
                        }
                        model.set(1,list);
                        if(session.isOpen()) {
                            session.getBasicRemote().sendObject(model);
                        }else{
                            break;
                        }
                        sleep(4000);
                    } catch (IOException | InterruptedException | EncodeException e) {
                        e.printStackTrace();
                    }
                }
            }
        };
        thread.start();
    }


    /**
     * 连接关闭调用的方法
     */
    @OnClose
    public void onClose() {
        System.out.println("closing");
        webSockets.remove(this);
    }

    /**
     * 发生错误时调用
     * @param session
     * @param error
     */
    @OnError
    public void onError(Session session, Throwable error){
        System.out.println("发生错误");
        error.printStackTrace();
    }

}