liujie
2025-06-06 fe8c13f3191d1e49401623c350344eaeb3ff0d1a
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
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
package com.ruoyi.other.util;
 
import com.alibaba.fastjson2.JSON;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.ruoyi.other.api.domain.TSystemConfiguration;
import com.ruoyi.other.mapper.TSystemConfigurationMapper;
import com.ruoyi.other.vo.ScreenStorageConfigVO;
import lombok.Getter;
import lombok.Setter;
import lombok.Value;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Service;
 
import javax.annotation.Resource;
import java.math.BigDecimal;
import java.math.RoundingMode;
import java.time.LocalDate;
import java.time.LocalTime;
import java.util.List;
import java.util.Random;
 
 
/**
 * 定时任务:储能放电情况 光伏发电情况
 */
@Service
public class EnergyRefreshService {
    private final Random random = new Random();
    @Resource
    private TSystemConfigurationMapper systemConfigurationMapper;
 
    // 储能相关参数
    private final BigDecimal storageMaxMorning = new BigDecimal("115"); // 凌晨到8点储能最大值
    private final BigDecimal storageMaxAfternoon = new BigDecimal("115"); // 12点后储能最大值
    private final BigDecimal dischargeMaxMorning = new BigDecimal("90"); // 上午放电最大值
    private final BigDecimal dischargeMaxAfternoon = new BigDecimal("90"); // 下午放电最大值
 
    private final double minIncrement = 0.5; // 最小增量(储能/放电共用)
    private final double maxIncrement = 1.0; // 最大增量(储能/放电共用)
 
 
    // 定时任务方法 - 能量刷新
    @Scheduled(cron = "0 * * * * ?") // 每分钟执行一次(原15分钟改为1分钟)
    public synchronized void refreshValue() {
        LocalTime now = LocalTime.now();
        // 根据时间段执行不同逻辑
        if (isInStorageMorning(now)) { // 00:00-7:59 储能阶段
            handleStoragePhase(storageMaxMorning, BigDecimal.ZERO);
        } else if (isInDischargeMorning(now)) { // 10:00-11:59 上午放电阶段
            handleDischargePhase(dischargeMaxMorning);
        } else if (isInStorageAfternoon(now)) { // 12:00-16:59 下午储能阶段
            handleStoragePhase(storageMaxAfternoon, getTodayDischarge());
        } else if (isInDischargeAfternoon(now)) { // 17:00-21:59 下午放电阶段
            handleDischargePhase(dischargeMaxAfternoon);
        }
    }
 
    // 储能阶段处理逻辑
    public void handleStoragePhase(BigDecimal maxValue, BigDecimal dischargeValue) {
        BigDecimal todayStorage=getTodayStorage();//当前储能值
        BigDecimal availableSpace = maxValue.subtract(todayStorage.subtract(dischargeValue));//115-(储能-放能) 当前可上涨空间
 
        // 随机增量0.5—1.0
        BigDecimal increment = randomBigDecimal(minIncrement,maxIncrement);
        BigDecimal newStorage;
        if (availableSpace.compareTo(increment) >= 0 ) {
            //可用空间大于等于当前增量
             newStorage = todayStorage.add(increment)
                    .setScale(2, RoundingMode.HALF_UP);
        }else {
            //可用空间不足当前增量
            newStorage = maxValue.add(dischargeValue);//115 + 放能  (如:上午放90,下午就只能充90)
        }
        if (newStorage.compareTo(todayStorage)==0){
            //新增值等于当前储能值 说明已达到最大值,没必要更新了
            return;
        }
        updateStorageValue(newStorage);
        System.out.printf("储能阶段:当前时间 %s,今日储能:%.2f%n", LocalTime.now(), newStorage);
    }
    // 放电阶段处理逻辑
    private void handleDischargePhase(BigDecimal maxDischarge) {
        BigDecimal currentDischarge = getTodayDischarge();//当前放电量
        BigDecimal todayStorage = getTodayStorage();//储能量
        //今日储能-115,就是耗能(基数),在这个基数上加90
        BigDecimal baseDischarge = todayStorage.subtract(storageMaxAfternoon);
        BigDecimal newMaxDischarge = baseDischarge.add(maxDischarge);//上限 基数+90
 
        // 随机增量0.5—1.0
        BigDecimal increment = randomBigDecimal(minIncrement,maxIncrement);
        BigDecimal newDischarge = currentDischarge.add(increment);//当前值 + 增量
        if (newDischarge.compareTo(newMaxDischarge) >=0) {
            //超出 用最大值
            newDischarge = newMaxDischarge;
        }
 
        if (newDischarge.compareTo(currentDischarge)==0){
            //新增值等于当前值,说明已超出,没必要更新了
            return;
        }
        updateDischargeValue(newDischarge);
        System.out.printf("放电阶段:当前时间 %s,今日放电:%.2f%n", LocalTime.now(), newDischarge);
    }
 
    // 重置任务(每天凌晨0点)
    @Scheduled(cron = "0 0 0 * * ?")
    public void reset() {
        // 初始化今日储能和放电为0
        updateStorageValue(BigDecimal.ZERO);
        updateDischargeValue(BigDecimal.ZERO);
        System.out.println("每日重置完成:今日储能和放电已清零");
    }
 
    /**
     * 生成指定范围内的随机 BigDecimal(两位小数)
     * @param min 最小值(包含)
     * @param max 最大值(包含)
     * @return 随机 BigDecimal
     */
    private BigDecimal randomBigDecimal(double min, double max) {
        // 生成 [0, 1) 随机数
        double randomValue = random.nextDouble();
        // 计算范围内的随机值
        double range = max - min;
        double value = min + (randomValue * range);
 
        // 转换为两位小数的 BigDecimal
        return BigDecimal.valueOf(value).setScale(2, RoundingMode.HALF_UP);
    }
    // 更新今日储能值到数据库
    private void updateStorageValue(BigDecimal value) {
        updateConfigField("todayStorage", value);
    }
 
    // 更新今日放电值到数据库(原逻辑保留)
    private void updateDischargeValue(BigDecimal value) {
        updateConfigField("todayDischarge", value);
    }
 
    // 通用配置更新方法
    private void updateConfigField(String field, BigDecimal value) {
        TSystemConfiguration sysConfig = systemConfigurationMapper.selectOne(
                new LambdaQueryWrapper<TSystemConfiguration>()
                        .eq(TSystemConfiguration::getType, 3)
        );
        if (sysConfig != null) {
            ScreenStorageConfigVO configVO = JSON.parseObject(sysConfig.getContent(), ScreenStorageConfigVO.class);
            if ("todayStorage".equals(field)) {
                configVO.setTodayStorage(value);
            } else {
                configVO.setTodayDischarge(value);
            }
            sysConfig.setContent(JSON.toJSONString(configVO));
            systemConfigurationMapper.updateById(sysConfig);
        }
    }
    // 时间段判断方法
    private boolean isInStorageMorning(LocalTime time) {
        return time.isAfter(LocalTime.of(0, 0)) && time.isBefore(LocalTime.of(8, 0));
    }
 
    private boolean isInDischargeMorning(LocalTime time) {
        return time.isAfter(LocalTime.of(10, 0)) && time.isBefore(LocalTime.of(12, 0));
    }
 
    private boolean isInStorageAfternoon(LocalTime time) {
        return time.isAfter(LocalTime.of(12, 0)) && time.isBefore(LocalTime.of(17, 0));
    }
 
    private boolean isInDischargeAfternoon(LocalTime time) {
        return time.isAfter(LocalTime.of(17, 0)) && time.isBefore(LocalTime.of(22, 0));
    }
 
    public BigDecimal getTodayStorage() {
        TSystemConfiguration sysConfig = systemConfigurationMapper.selectOne(
                new LambdaQueryWrapper<TSystemConfiguration>()
                        .eq(TSystemConfiguration::getType, 3)
        );
        if (sysConfig != null) {
            ScreenStorageConfigVO configVO = JSON.parseObject(sysConfig.getContent(), ScreenStorageConfigVO.class);
            return configVO.getTodayStorage();
        }
        return BigDecimal.ZERO;
    }
 
    public BigDecimal getTodayDischarge() {
        TSystemConfiguration sysConfig = systemConfigurationMapper.selectOne(
                new LambdaQueryWrapper<TSystemConfiguration>()
                        .eq(TSystemConfiguration::getType, 3)
        );
        if (sysConfig != null) {
            ScreenStorageConfigVO configVO = JSON.parseObject(sysConfig.getContent(), ScreenStorageConfigVO.class);
            return configVO.getTodayDischarge();
        }
        return BigDecimal.ZERO;
    }
 
 
 
 
    public static BigDecimal refreshValueOne = new BigDecimal("0");
    /**
     *光伏发电和消纳
     */
    @Scheduled(cron = "0 */1 * * * ?")  // 每分钟点执行
    public void refreshValueOne() {
        // 判断时间是否在6:00到8:59
        LocalTime now = LocalTime.now();
        if (now.isAfter(LocalTime.of(6, 0)) && now.isBefore(LocalTime.of(8, 59))) {
            refreshValueOne = refreshValueOne.add(new BigDecimal("0.5"));
            List<TSystemConfiguration> sysConfigs = systemConfigurationMapper.selectList(new LambdaQueryWrapper<TSystemConfiguration>()
                    .in(TSystemConfiguration::getType,4,5));
            TSystemConfiguration sysConfig = sysConfigs.stream().filter(e -> e.getType() == 4).findFirst().orElse(null);
            sysConfig.setContent(refreshValueOne.toString());
            systemConfigurationMapper.updateById(sysConfig);
 
 
            TSystemConfiguration sysConfig1 = sysConfigs.stream().filter(e -> e.getType() == 5).findFirst().orElse(null);
            String string = new BigDecimal(sysConfig1.getContent()).add(new BigDecimal("0.5")).toString();
            sysConfig1.setContent(string);
            systemConfigurationMapper.updateById(sysConfig1);
            // 在6:00到8:59之间,不执行
            return;
        }
        // 9:00-16:59每分钟增加随机3 到 3.5
        if (now.isAfter(LocalTime.of(9, 0)) && now.isBefore(LocalTime.of(16, 59))) {
            refreshValueOne = refreshValueOne.add(new BigDecimal(3 + (3.5 - 3) * random.nextDouble())
                    .setScale(2, RoundingMode.HALF_UP));
            List<TSystemConfiguration> sysConfigs = systemConfigurationMapper.selectList(new LambdaQueryWrapper<TSystemConfiguration>()
                    .in(TSystemConfiguration::getType,4,5));
 
            TSystemConfiguration sysConfig = sysConfigs.stream().filter(e -> e.getType() == 4).findFirst().orElse(null);
            sysConfig.setContent(refreshValueOne.toString());
            systemConfigurationMapper.updateById(sysConfig);
 
 
            TSystemConfiguration sysConfig1 = sysConfigs.stream().filter(e -> e.getType() == 5).findFirst().orElse(null);
            String string = new BigDecimal(sysConfig1.getContent()).add(new BigDecimal(3 + (3.5 - 3) * random.nextDouble())).toString();
            sysConfig1.setContent(string);
            systemConfigurationMapper.updateById(sysConfig1);
            return;
        }
        //17:00-18:59 每分钟增加0.5
        if (now.isAfter(LocalTime.of(17, 0)) && now.isBefore(LocalTime.of(18, 59))) {
            refreshValueOne = refreshValueOne.add(new BigDecimal("0.5"));
            List<TSystemConfiguration> sysConfigs = systemConfigurationMapper.selectList(new LambdaQueryWrapper<TSystemConfiguration>()
                    .in(TSystemConfiguration::getType,4,5));
 
            TSystemConfiguration sysConfig = sysConfigs.stream().filter(e -> e.getType() == 4).findFirst().orElse(null);
            sysConfig.setContent(refreshValueOne.toString());
            systemConfigurationMapper.updateById(sysConfig);
 
 
            TSystemConfiguration sysConfig1 = sysConfigs.stream().filter(e -> e.getType() == 5).findFirst().orElse(null);
            String string = new BigDecimal(sysConfig1.getContent()).add(new BigDecimal("0.5")).toString();
            sysConfig1.setContent(string);
            systemConfigurationMapper.updateById(sysConfig1);
        }
    }
 
 
 
 
}