lxw
2023-07-29 d1675cea759f0090c43860efabdeb9448d25c41d
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
package com.whyc.webSocket;
 
import com.whyc.config.WebSocketConfig;
import com.whyc.dto.Response;
import com.whyc.pojo.UserInf;
import com.whyc.service.BattdischargePlanService;
import com.whyc.service.FaultUploadService;
import com.whyc.service.KPIService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
 
import javax.servlet.http.HttpSession;
import javax.websocket.*;
import javax.websocket.server.ServerEndpoint;
import java.util.HashMap;
import java.util.Map;
 
@Component
@ServerEndpoint(value = "/taskMLeader", encoders = WebSocketEncoder.class, configurator = WebSocketConfig.class)
public class taskMLeaderWebSocket {
    private Session session;
 
    private Thread thread;
 
    private volatile boolean runFlag = true;
 
    private volatile Map<String, Thread> threadMap = new HashMap<>();
 
    private volatile Map<Long, Boolean> threadFlagMap = new HashMap<>();
 
    private static final int executeTime = 5000;
 
    private static FaultUploadService faultUploadService;
 
    private static BattdischargePlanService battdischargePlanService;
 
    private static KPIService kpiService;
 
    private HttpSession httpSession;
 
    @Autowired
    public void setFaultUploadService(FaultUploadService faultUploadService) {
        taskMLeaderWebSocket.faultUploadService = faultUploadService;
    }
 
    @Autowired
    public void setBattdischargePlanService(BattdischargePlanService battdischargePlanService) {
        taskMLeaderWebSocket.battdischargePlanService = battdischargePlanService;
    }
 
    @Autowired
    public void setKPIService(KPIService kpiService) {
        taskMLeaderWebSocket.kpiService = kpiService;
    }
 
    @OnOpen
    public void onOpen(Session session, EndpointConfig config) {
        this.session = session;
        this.httpSession = (HttpSession) config.getUserProperties().get("httpSession");
    }
 
    @OnMessage
    public void onMessage(Session session, String message) {
        UserInf user = (UserInf) this.httpSession.getAttribute("user");
        final int userId = user.getUId().intValue();
        //final int userId = 1041;
        Integer limitN = Integer.valueOf(message);
        thread = new Thread("Thread_RealTime") {
            @Override
            public void run() {
                while (runFlag && !isInterrupted()) {
                    Thread thread = currentThread();
                    threadFlagMap.put(thread.getId(), true);
                    try {
                        Map<String, Response> map = getTaskMAdmin(userId, limitN);
                        if (session.isOpen()) {
                            //推送信息
                            synchronized (session) {
                                session.getBasicRemote().sendObject(new Response().set(1, map));
                            }
                            threadFlagMap.put(thread.getId(), false);
                        }
                        sleep(executeTime);
                    } catch (Exception e) {
                        interrupt();
                    }
                }
            }
        };
        thread.start();
        threadFlagMap.put(thread.getId(), true);
        //停止老的socket线程
        Thread threadBefore = threadMap.get(session.getId());
        if (threadBefore != null && threadBefore.isAlive()) {
            while (threadFlagMap.get(threadBefore.getId())) {
            }
            threadBefore.interrupt();
        }
        //将线程存储,便于调用定位
        threadMap.put(session.getId(), this.thread);
    }
 
    //获取管理员的数据
    public Map getTaskMAdmin(int userId, int limitN) {
        Map<String, Object> res = new HashMap<>();
        //本月
        Response monRes = faultUploadService.groupNameCount(1, userId);
        res.put("monRes", monRes);
        //本季度
        Response quarterRes = faultUploadService.groupNameCount(2, userId);
        res.put("quarterRes", quarterRes);
        //本年
        Response yearRes = faultUploadService.groupNameCount(3, userId);
        res.put("yearRes", yearRes);
 
        //隐患故障上报进度-最近一周及最近一月-管理
        //最近一周
        Response lastPeriodWeekRes = faultUploadService.getListOfLastPeriod(1, userId);
        res.put("lastPeriodWeekRes", lastPeriodWeekRes);
        //最近一月
        Response lastPeriodMonRes = faultUploadService.getListOfLastPeriod(2, userId);
        res.put("lastPeriodMonRes", lastPeriodMonRes);
 
        //隐患故障上报类型统计(需要本月、本季度、本年数据)
        //本月
        Response typeMonRes = faultUploadService.getTypeCount(1, userId);
        res.put("typeMonRes", typeMonRes);
        //本季度
        Response typeQuaRes = faultUploadService.getTypeCount(2, userId);
        res.put("typeQuaRes", typeQuaRes);
        //本年
        Response typeYearRes = faultUploadService.getTypeCount(3, userId);
        res.put("typeYearRes", typeYearRes);
 
        //年度放电任务统计
        Response disPlanRes = battdischargePlanService.getPlanCountWithTotal(userId);
        res.put("disPlanRes", disPlanRes);
 
        //年度统计-班组 排名
        Response statisticRes = kpiService.getAnnualStatisticByGroupName(limitN, userId);
        res.put("statisticRes", statisticRes);
 
        //年度统计-班组和用户
        Response allStaicRes = kpiService.getAnnualStatisticByGroupNameAndUser(userId);
        res.put("allStaicRes", allStaicRes);
 
        //年度工作考核明细
        Response detailRes = kpiService.getAnnualDetail(limitN, userId);
        res.put("detailRes", detailRes);
 
        return res;
    }
 
    @OnClose
    public void onClose(CloseReason closeReason) {
        System.err.println("closeReason = " + closeReason);
        runFlag = false;
        if (thread != null && thread.isAlive()) {
            thread.interrupt();
        }
        threadMap.remove(session.getId());
    }
 
    @OnError
    public void onError(Throwable error) {
        error.printStackTrace();
        if (thread != null && thread.isAlive()) {
            thread.interrupt();
        }
        threadMap.remove(session.getId());
    }
}