2024.11.19 各项修正

feiyu02

2024-11-19 752e00503f672ddfe2066afb6c235721a3a912b5

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
package cn.flightfeather.supervision.bgtask
 
import org.slf4j.LoggerFactory
import org.springframework.beans.factory.annotation.Value
import org.springframework.stereotype.Component
import java.time.LocalDateTime
import java.time.LocalTime
import java.util.*
import java.util.concurrent.Executors
import java.util.concurrent.ScheduledExecutorService
import java.util.concurrent.TimeUnit
 
/**
 * 数据获取控制器
 */
@Component
class TaskController(
    fetchVOC: TaskFetchVOC,
    pushFume: TaskPushFume,
    ledgerCopy: TaskLedgerCopy,
    ledgerRemind: TaskLedgerRemind,
    taskJinAnLampEnterBaseInfo: TaskJinAnLampEnterBaseInfo,
    taskJinAnLampDeviceData: TaskJinAnLampDeviceData,
    taskJinAnConstructionSiteInfo: TaskJinAnConstructionSiteInfo,
    taskJinAnHourlyDustData: TaskJinAnHourlyDustData,
    taskAutoLedger:TaskAutoLedger,
    // 根据app不同，切换不同的定时任务
    @Value("\${mode}") mode: String,
) {
 
    companion object {
        private const val FETCH_PERIOD_MIN = 1L * 60
        private const val MAINTAIN_PERIOD_MIN = 5L * 60
        val LOGGER = LoggerFactory.getLogger(TaskController::class.java)
    }
 
    private val timeTask = mutableListOf<BaseTimingTask>()
    private var schedule = Executors.newScheduledThreadPool(1)
    private var maintainSchedule = Executors.newScheduledThreadPool(1)
    private var taskTime: Date = Date()
    private var maintainTime: Date = Date()
 
    init {
        LOGGER.info("添加定时任务")
        timeTask.clear()
        //飞羽环境，获取voc数据、推送油烟数据
        if (mode == "proapp") {
            timeTask.add(fetchVOC)
            timeTask.add(pushFume)
        } else if (mode == "pro") {
            //微信小程序（中小企业守法自助），台账复制、定时任务推送等
//        timeTask.add(ledgerCopy)
            timeTask.add(ledgerRemind)
            timeTask.add(taskJinAnLampEnterBaseInfo)
//        timeTask.add(taskJinAnLampDeviceData)
            timeTask.add(taskJinAnConstructionSiteInfo)
//            timeTask.add(taskJinAnHourlyDustData)
            timeTask.add(taskAutoLedger)
        }
        LOGGER.info("添加定时任务完成，任务总计${timeTask.size}个")
    }
 
    fun run() {
        fetchTask(true)
        maintainTask(true)
    }
 
    private fun fetchTask(isFirst: Boolean = false) {
        val cal = Calendar.getInstance()
        val time = LocalTime.now()
        val sec = time.second
        val delay = 60L - sec
//        var localtime = LocalDateTime.of(2021, 4, 16, 9, 0)
        if (!isFirst) {
            schedule = closeThread(schedule)
        }
        schedule.scheduleAtFixedRate({
            taskTime = Date()
            if (Date().time - maintainTime.time > (MAINTAIN_PERIOD_MIN + 1) * 60 * 1000) {
                maintainTask()
            }
 
            val localtime = LocalDateTime.now()
//            LOGGER.info("定时任务执行，定时任务数：${timeTask.size}")
            timeTask.forEach {
//                LOGGER.info("定时任务：${it.javaClass.name}")
                it.execute(localtime)
            }
//            localtime = localtime.plusMinutes(1)
        }, delay, FETCH_PERIOD_MIN, TimeUnit.SECONDS)
    }
 
    private fun maintainTask(isFirst: Boolean = false) {
        if (!isFirst) {
            maintainSchedule = closeThread(maintainSchedule)
        }
        maintainSchedule.scheduleAtFixedRate({
            maintainTime = Date()
            if (Date().time - taskTime.time > (FETCH_PERIOD_MIN + 1) * 60 * 1000) {
                fetchTask()
            }
        }, 0, MAINTAIN_PERIOD_MIN, TimeUnit.SECONDS)
    }
 
    private fun closeThread(s: ScheduledExecutorService): ScheduledExecutorService {
        try {
            s.shutdown()
            if (s.awaitTermination(10, TimeUnit.SECONDS)) {
                s.shutdownNow()
            }
        } catch (e: InterruptedException) {
            e.printStackTrace()
            s.shutdownNow()
        }
        return Executors.newScheduledThreadPool(1)
    }
}