[add] redis处理

signal-optimize-service/src/main/java/net/wanji/opt/common/RedisConfig.java

+package net.wanji.opt.common;
+
+import com.fasterxml.jackson.annotation.JsonAutoDetect;
+import com.fasterxml.jackson.annotation.JsonTypeInfo;
+import com.fasterxml.jackson.annotation.PropertyAccessor;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.databind.jsontype.impl.LaissezFaireSubTypeValidator;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
+import org.springframework.cache.CacheManager;
+import org.springframework.cache.annotation.CachingConfigurerSupport;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.data.redis.cache.RedisCacheConfiguration;
+import org.springframework.data.redis.cache.RedisCacheManager;
+import org.springframework.data.redis.cache.RedisCacheWriter;
+import org.springframework.data.redis.connection.RedisConnectionFactory;
+import org.springframework.data.redis.core.RedisTemplate;
+import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
+import org.springframework.data.redis.serializer.StringRedisSerializer;
+import redis.clients.jedis.JedisPool;
+import redis.clients.jedis.JedisPoolConfig;
+
+@Configuration
+@EnableAutoConfiguration
+public class RedisConfig extends CachingConfigurerSupport {
+
+    @Value("${spring.redis.host}")
+    private String host;
+
+    @Value("${spring.redis.port}")
+    private int port;
+
+    @Value("${spring.redis.password}")
+    private String password;
+
+    @Value("${spring.redis.database}")
+    private int database;
+
+    @Value("${spring.redis.timeout}")
+    private int timeout;
+
+    @Value("${spring.redis.jedis.pool.max-idle}")
+    private int maxIdle;
+
+    @Value("${spring.redis.jedis.pool.max-active}")
+    private int maxTotal;
+
+    @Value("${spring.redis.jedis.pool.min-idle}")
+    private int minIdle;
+
+    @Value("${spring.redis.jedis.pool.max-wait}")
+    private long maxWaitMillis;
+
+    /**
+     * 获取Jedis连接工厂
+     * <p>用于创建Jedis对象</p>
+     * @return JedisPool
+     */
+    @Bean
+    public JedisPool redisPoolFactory() {
+        JedisPoolConfig jedisPoolConfig = new JedisPoolConfig();
+        jedisPoolConfig.setMaxTotal(maxTotal);
+        jedisPoolConfig.setMaxIdle(maxIdle);
+        jedisPoolConfig.setMaxWaitMillis(maxWaitMillis);
+        jedisPoolConfig.setMinIdle(minIdle);
+        jedisPoolConfig.setTestOnBorrow(false);
+        jedisPoolConfig.setTestOnReturn(false);
+        return new JedisPool(jedisPoolConfig, host, port,timeout, password, database);
+    }
+
+
+    @Bean
+    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory connectionFactory) {
+        RedisTemplate<String, Object> template = new RedisTemplate<>();
+        template.setConnectionFactory(connectionFactory);
+
+        // 使用 Jackson2JsonRedisSerializer 替代默认的 JDK 序列化器
+        Jackson2JsonRedisSerializer<Object> serializer = new Jackson2JsonRedisSerializer<>(Object.class);
+        ObjectMapper objectMapper = new ObjectMapper();
+        objectMapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
+        objectMapper.activateDefaultTyping(LaissezFaireSubTypeValidator.instance,
+                ObjectMapper.DefaultTyping.NON_FINAL, JsonTypeInfo.As.WRAPPER_ARRAY);
+        serializer.setObjectMapper(objectMapper);
+
+        template.setKeySerializer(new StringRedisSerializer()); // 设置 Key 的序列化器
+        template.setValueSerializer(serializer); // 设置 Value 的序列化器
+        template.setHashKeySerializer(new StringRedisSerializer());
+        template.setHashValueSerializer(serializer);
+
+        template.afterPropertiesSet();
+        return template;
+    }
+
+    /**
+     * 选择redis作为默认缓存工具
+     * @param redisConnectionFactory
+     * @return
+     */
+    @Bean
+    public CacheManager cacheManager(RedisConnectionFactory redisConnectionFactory) {
+        RedisCacheConfiguration redisCacheConfiguration = RedisCacheConfiguration.defaultCacheConfig();
+        return RedisCacheManager
+                .builder(RedisCacheWriter.nonLockingRedisCacheWriter(redisConnectionFactory))
+                .cacheDefaults(redisCacheConfiguration).build();
+    }
+}
\ No newline at end of file

signal-optimize-service/src/main/java/net/wanji/opt/common/RedisUtils.java

@@ -2,13 +2,22 @@ package net.wanji.opt.common;
 
 import com.fasterxml.jackson.databind.ObjectMapper;
 import lombok.extern.slf4j.Slf4j;
+import net.wanji.common.enums.DateStyle;
 import net.wanji.opt.dto.CrossEventDTO;
+import org.springframework.data.redis.connection.DataType;
 import org.springframework.data.redis.core.RedisTemplate;
+import org.springframework.data.redis.core.ValueOperations;
 import org.springframework.data.redis.core.ZSetOperations;
+import org.springframework.data.redis.support.atomic.RedisAtomicLong;
 import org.springframework.stereotype.Component;
 
 import javax.annotation.Resource;
+import java.text.DecimalFormat;
+import java.util.Calendar;
+import java.util.Date;
+import java.util.Map;
 import java.util.Set;
+import java.util.concurrent.TimeUnit;
 
 /**
  * @description: redis工具类
@@ -20,34 +29,11 @@ import java.util.Set;
 @Slf4j
 public class RedisUtils {
 
-    @Resource
-    private RedisTemplate<String, Object> redis7Template;
-
     /**
-     * 7号库获取最大 score zset 元素
+     * 注入redisTemplate
      */
-    public Object getMaxScoreElement(String redisKey) throws Exception {
-        try {
-            ObjectMapper objectMapper = new ObjectMapper();
-            ZSetOperations<String, Object> zSetOps = redis7Template.opsForZSet();
-            Set<Object> result = zSetOps.reverseRange(redisKey, 0, -1);
-
-            if (result != null && !result.isEmpty()) {
-                for (Object o : result) {
-                    CrossEventDTO dto = objectMapper.readValue(o.toString(), CrossEventDTO.class);
-                    String msgType = dto.getMsgType();
-                    if (msgType.startsWith("50")) {
-                        return o;
-                    }
-                }
-            }
-            log.error("redis获取数据key:{}, 获取value：{}", redisKey, result);
-        } catch (Exception e) {
-            //throw new RuntimeException(e);
-        }
-        return null;
-    }
-
+    @Resource
+    private RedisTemplate<String, Object> redisTemplate;
 
     /**
      * @description: 判断是否存在Key
@@ -55,7 +41,7 @@ public class RedisUtils {
      * @return boolean true:有 false:无
      */
     public boolean hasKey(String key) {
-        return redis7Template.hasKey(key);
+        return redisTemplate.hasKey(key);
     }
 
     /**
@@ -64,7 +50,38 @@ public class RedisUtils {
      * @param value 添加redis的value
      */
     public void set(String key, String value) {
-        redis7Template.opsForValue().set(key, value);
+        redisTemplate.opsForValue().set(key, value);
+    }
+
+    /**
+     * @description: 添加对象
+     * @param key redis的Key
+     * @param object 添加redis的value
+     */
+    public void set(String key, Object object) {
+        redisTemplate.opsForValue().set(key, object);
+    }
+
+    /**
+     * @description: 添加带生命周期的对象
+     * @param key redis的Key
+     * @param object 添加redis的value
+     * @param seconds 失效时间
+     */
+    public void setAndExpire(String key, Object object, int seconds) {
+        redisTemplate.opsForValue().set(key, object);
+        redisTemplate.expire(key, seconds, TimeUnit.SECONDS);
+    }
+
+    /**
+     * @description: 添加带生命周期的对象
+     * @param key redis的Key
+     * @param value 添加redis的value
+     * @param seconds 失效时间
+     */
+    public void setAndExpire(String key, String value, int seconds) {
+        redisTemplate.opsForValue().set(key, value);
+        redisTemplate.expire(key, seconds, TimeUnit.SECONDS);
     }
 
     /**
@@ -73,6 +90,280 @@ public class RedisUtils {
      * @return Object 返回对象
      */
     public Object get(String key) {
-        return redis7Template.opsForValue().get(key);
+        return redisTemplate.opsForValue().get(key);
+    }
+
+    /**
+     * @description: 存入redis的hash
+     * @param key redis的Key
+     * @param field 字段值
+     * @param value 存入的值
+     */
+    public void setHash(String key, String field, String value) {
+        redisTemplate.opsForHash().put(key, field, value);
+    }
+
+    /**
+     * @description: 存入redis的hash
+     * @param key redis的Key
+     * @param field 字段值
+     * @param value 存入的值
+     */
+    public void setHash(String key, String field, Object value) {
+        redisTemplate.opsForHash().put(key, field, value);
+    }
+
+    /**
+     * @description: 根据key和字段值获取内容值
+     * @param key redis的Key
+     * @param field 字段值
+     * @return String 返回字符串
+     */
+    public String getHash(String key, String field) {
+        return (String)redisTemplate.opsForHash().get(key, field);
+    }
+
+    /**
+     * @description: 根据field删除值
+     * @param key redis的Key
+     * @param field 字段值
+     */
+    public void delHashMap(String key, String field) {
+        redisTemplate.boundHashOps(key).delete(field);
+    }
+
+    /**
+     * @description: 存入hash集合
+     * @param key redis的Key
+     * @param hashmap 存入的Map集合
+     */
+    public void setHashMap(String key, Map<String, Object> hashmap){
+        redisTemplate.opsForHash().putAll(key, hashmap);
+    }
+
+    /**
+     * @description: 取出hash集合
+     * @param key redis的Key
+     * @return Map<Object, Object> 返回Map集合
+     */
+    public Map<Object, Object> getHashMap(String key) {
+        return redisTemplate.opsForHash().entries(key);
+    }
+
+    /**
+     * @description: 存入redis的Set
+     * @param key redis的Key
+     * @param object 对象
+     */
+    public void setSet(String key,Object object){
+        redisTemplate.opsForSet().add(key, object);
+    }
+
+    /**
+     * @description: 获取redis的Set
+     * @param key redis的Key
+     * @return Set<Object> Set集合
+     */
+    public Set<Object> getSet(String key){
+        return redisTemplate.opsForSet().members(key);
+    }
+
+    /**
+     * @discription: 查看值是否是set成员
+     * @param key set的key
+     * @param value set的成员
+     * @return 是否是set成员
+     */
+    public Boolean isSetMember(String key, Object value) {
+        return redisTemplate.opsForSet().isMember(key, value);
+    }
+
+    /**
+     * @description:设置key的过期时间，endTime格式：yyyy-MM-dd hh:mm:ss
+     * @param key redis的Key
+     * @param endTime 结束时间
+     */
+    public void setExpire(String key, Date endTime) {
+        long seconds = endTime.getTime() - System.currentTimeMillis();
+        redisTemplate.expire(key, (int) (seconds / 1000), TimeUnit.SECONDS);
+    }
+
+    /**
+     * @description: 设置key的过期时间
+     * @param key redis的Key
+     * @param time 过期时间（秒）
+     */
+    public void setExpire(String key, int time) {
+        redisTemplate.expire(key, time, TimeUnit.SECONDS);
     }
+
+    /**
+     * <p>Discription:获取key的过期时间
+     * @param key redis的Key
+     * @return 过期时间（秒）
+     */
+    public Long getExpire(String key) {
+        return redisTemplate.getExpire(key, TimeUnit.SECONDS);
+    }
+
+
+    /**
+     * @description: 在redis消息队列队尾插入数据
+     * @param key redis的Key
+     * @param object 添加的对象
+     */
+    public void tailPush(String key, Object object){
+        redisTemplate.opsForList().rightPush(key, object);
+    }
+
+    /**
+     * @description: 在redis消息队列对头插入数据
+     * @param key redis的Key
+     * @param object 添加的对象
+     */
+    public void headPush(String key,Object object){
+        redisTemplate.opsForList().leftPush(key, object);
+    }
+
+    /**
+     * @description: 在redis消息队列队尾删除数据
+     * @param key redis的Key
+     * @return Object 删除的对象
+     */
+    public Object tailPop(String key){
+        return redisTemplate.opsForList().rightPop(key);
+    }
+
+    /**
+     * @description: 在redis消息队列队头删除数据
+     * @param key redis的Key
+     * @return Object 删除的对象
+     */
+    public Object headPop(String key){
+        return redisTemplate.opsForList().leftPop(key);
+    }
+
+    /**
+     * @description: 删除redis的值
+     * @param key redis的Key
+     */
+    public void del(String key) {
+        if (hasKey(key)) {
+            redisTemplate.delete(key);
+        }
+    }
+
+    /**
+     * @description: 清理redis缓存
+     */
+    public void flushDB(){
+        redisTemplate.getConnectionFactory().getConnection().flushDb();
+    }
+
+    /**
+     * @description: 根据类型生成版本号
+     * @param type 类型key区分
+     * @return 版本号
+     * @author wanji
+     * @date 2019/5/5 19:26
+     */
+
+    /**
+     * 自增ID
+     * @param key 建
+     * @param liveTime 过期时间
+     * @return 自增结果
+     */
+    public Long getIncr(String key, long liveTime) {
+        RedisAtomicLong entityIdCounter = new RedisAtomicLong(key, redisTemplate.getConnectionFactory());
+        Long increment = entityIdCounter.getAndIncrement();
+
+        if ((null == increment || increment.longValue() == 0) && liveTime > 0) {//初始设置过期时间
+            entityIdCounter.expire(liveTime, TimeUnit.MILLISECONDS);//单位毫秒
+        }
+        return increment;
+    }
+
+    /**
+     * 获取全部Redis的key
+     * @return
+     */
+    public Set<String> keys() {
+        return redisTemplate.keys("*");
+    }
+
+    /**
+     * 获取key的类型
+     * @return
+     */
+    public DataType keyType(String key) {
+        return redisTemplate.type(key);
+    }
+
+    /**
+     * 获取全局ID范围
+     *
+     * @param key 建
+     * @param increment ID范围
+     * @return
+     */
+    public Long getGlobalIdRange(String key, long increment) {
+        ValueOperations<String, Object> ops = redisTemplate.opsForValue();
+        Long newIdRangeStart = ops.increment(key, increment);
+        // The range of IDs that are now reserved are from newIdRangeStart - increment + 1 to newIdRangeStart.
+        return newIdRangeStart - increment + 1;
+    }
+
+    /**
+     * 带过期时间存入 zset
+     * @param ttlInMillis 存活时间毫秒数
+     */
+    public void addToSortedSetWithExpiry(String key, String value, long ttlInMillis) {
+        long score = new Date().getTime() + ttlInMillis;
+        redisTemplate.opsForZSet().add(key, value, score);
+    }
+
+    /**
+     * 获取某个 zset 所有元素
+     *
+     * @return
+     */
+    public Set<Object> getZsetAll(String key) {
+        return redisTemplate.opsForZSet().range(key, 0, -1);
+    }
+
+    /**
+     * 按 score 范围获取 zset 元素
+     *
+     * @return
+     */
+    public Set<Object> getZsetRange(String key, long start, long end) {
+        return redisTemplate.opsForZSet().rangeByScore(key, start, end);
+    }
+
+    /**
+     * 7号库获取最大 score zset 元素
+     */
+    public Object getMaxScoreElement(String redisKey) throws Exception {
+        try {
+            ObjectMapper objectMapper = new ObjectMapper();
+            ZSetOperations<String, Object> zSetOps = redisTemplate.opsForZSet();
+            Set<Object> result = zSetOps.reverseRange(redisKey, 0, -1);
+
+            if (result != null && !result.isEmpty()) {
+                for (Object o : result) {
+                    CrossEventDTO dto = objectMapper.readValue(o.toString(), CrossEventDTO.class);
+                    String msgType = dto.getMsgType();
+                    if (msgType.startsWith("50")) {
+                        return o;
+                    }
+                }
+            }
+            log.error("redis获取数据key:{}, 获取value：{}", redisKey, result);
+        } catch (Exception e) {
+            //throw new RuntimeException(e);
+        }
+        return null;
+    }
+
 }

signal-optimize-service/src/main/java/net/wanji/opt/kafka/ConsumerHandler.java

@@ -45,7 +45,7 @@ public class ConsumerHandler implements KafkaListenerErrorHandler {
     private final HoloForeignDeviceMapper holoForeignDeviceMapper;
 
     @Transactional
-    @KafkaListener(topics = {"cross_real_time_lane_data"})
+    // @KafkaListener(topics = {"cross_real_time_lane_data"})
     public void receiveCrossRealTimeLaneData(ConsumerRecord<Object, Object> record, Acknowledgment acknowledgment) throws Exception {
         try {
             String crossRealTimeLaneData = String.valueOf(record.value());
@@ -81,7 +81,7 @@ public class ConsumerHandler implements KafkaListenerErrorHandler {
     }
 
     @Transactional
-    @KafkaListener(topics = {"cross_real_time_data"})
+    // @KafkaListener(topics = {"cross_real_time_data"})
     public void receiveCrossRealTimeData(ConsumerRecord<Object, Object> record, Acknowledgment acknowledgment) throws Exception {
         try {
             String crossRealTimeData = String.valueOf(record.value());
@@ -130,7 +130,7 @@ public class ConsumerHandler implements KafkaListenerErrorHandler {
     }
 
     @Transactional
-    @KafkaListener(topics = {"cross_real_time_dir_data"})
+    // @KafkaListener(topics = {"cross_real_time_dir_data"})
     public void receiveCrossRealTimeDirData(ConsumerRecord<Object, Object> record, Acknowledgment acknowledgment) throws Exception {
         try {
             String crossRealTimeDirData = String.valueOf(record.value());
@@ -155,7 +155,7 @@ public class ConsumerHandler implements KafkaListenerErrorHandler {
     }
 
     @Transactional
-    @KafkaListener(topics = {"cross_real_time_turn_data"})
+    // @KafkaListener(topics = {"cross_real_time_turn_data"})
     public void receiveCrossRealTimeTurnData(ConsumerRecord<Object, Object> record, Acknowledgment acknowledgment) throws Exception {
         try {
             String crossRealTimeTurnData = String.valueOf(record.value());

signal-optimize-service/src/main/java/net/wanji/opt/synthesis/controller/StrategyGreenBeltController.java

@@ -11,10 +11,7 @@ import net.wanji.opt.common.RedisUtils;
 import net.wanji.opt.service.GreenBeltInfoService;
 import net.wanji.opt.vo.GreenBeltChartVO;
 import net.wanji.opt.vo.GreenBeltInfoVO;
-import org.springframework.web.bind.annotation.PostMapping;
-import org.springframework.web.bind.annotation.RequestBody;
-import org.springframework.web.bind.annotation.RequestMapping;
-import org.springframework.web.bind.annotation.RestController;
+import org.springframework.web.bind.annotation.*;
 
 import javax.annotation.Resource;
 import javax.ws.rs.core.MediaType;
@@ -36,19 +33,12 @@ public class StrategyGreenBeltController {
 
     @ApiOperation(value = "绿波时序图数据查询", notes = "绿波时序图数据查询", response = JsonViewObject.class,
             produces = MediaType.APPLICATION_JSON, consumes = MediaType.APPLICATION_JSON)
-    @PostMapping(value = "/greenBletData",
-            produces = MediaType.APPLICATION_JSON, consumes = MediaType.APPLICATION_JSON)
+    @GetMapping(value = "/greenBletData")
     @ApiResponses({
             @ApiResponse(code = 200, message = "OK", response = GreenBeltInfoVO.class),
     })
-    public JsonViewObject greenBletData(@RequestBody String greenId) throws Exception {
-
-        // todo 测试
-        GreenBeltInfoVO greenBeltInfoVO1 = greenBeltInfoService.convertData(null);
-        greenBeltInfoService.save(greenBeltInfoVO1);
+    public JsonViewObject greenBletData(String greenId) throws Exception {
         String key = Constants.GREEN_ID_OPT_KEY.concat(greenId);
-        redisUtils.set(key, JacksonUtils.getInstance().writeValueAsString(greenBeltInfoVO1));
-
         Object obj = redisUtils.get(key);
         JsonViewObject jsonViewObject = JsonViewObject.newInstance();
         GreenBeltInfoVO greenBeltInfoVO = JacksonUtils.getInstance().readValue(String.valueOf(obj), GreenBeltInfoVO.class);
@@ -57,16 +47,15 @@ public class StrategyGreenBeltController {
 
     @ApiOperation(value = "绿波时序图图形查询", notes = "绿波时序图图形查询", response = JsonViewObject.class,
             produces = MediaType.APPLICATION_JSON, consumes = MediaType.APPLICATION_JSON)
-    @PostMapping(value = "/greenBeltChart",
-            produces = MediaType.APPLICATION_JSON, consumes = MediaType.APPLICATION_JSON)
+    @GetMapping(value = "/greenBeltChart")
     @ApiResponses({
             @ApiResponse(code = 200, message = "OK", response = GreenBeltInfoVO.class),
     })
-    public JsonViewObject greenBeltChart(@RequestBody String greenId) throws Exception {
+    public JsonViewObject greenBeltChart(String greenId) throws Exception {
         String key = Constants.GREEN_ID_OPT_CHART_KEY.concat(greenId);
         Object obj = redisUtils.get(key);
         JsonViewObject jsonViewObject = JsonViewObject.newInstance();
-        GreenBeltChartVO greenBeltChartVO = JacksonUtils.getInstance().readValue(String.valueOf(obj), GreenBeltChartVO.class);
+        GreenBeltChartVO greenBeltChartVO = JacksonUtils.getInstance().readValue((String)obj, GreenBeltChartVO.class);
         return jsonViewObject.success(greenBeltChartVO);
     }
 }

signal-optimize-service/src/main/java/net/wanji/opt/task/InducesMonitorTask.java

-package net.wanji.opt.task;
-
-public class inducesMonitorTask {
-}

signal-optimize-service/src/main/java/net/wanji/opt/vo/GreenBeltChartVO.java

 package net.wanji.opt.vo;
 
 import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
+import com.fasterxml.jackson.annotation.JsonProperty;
 import io.swagger.annotations.ApiModel;
 import io.swagger.annotations.ApiModelProperty;
+import lombok.AllArgsConstructor;
 import lombok.Data;
+import lombok.NoArgsConstructor;
+import net.wanji.common.utils.tool.JacksonUtils;
 
 import java.util.List;
 import java.util.Map;
@@ -15,13 +19,26 @@ import java.util.Map;
 @Data
 @ApiModel(value = "GreenBeltChartVO", description = "绿波时序图返回实体")
 @JsonIgnoreProperties(ignoreUnknown = true)
+@AllArgsConstructor
+@NoArgsConstructor
 public class GreenBeltChartVO {
+    private static final long serialVersionUID = 1L;
     @ApiModelProperty("绿波路口红灯范围")
-    Map<String, List<Double[]>> crossRedTimesMap;
+    @JsonProperty("crossRedTimesMap")
+    Map<String, List<List<Double>>> crossRedTimesMap;
+    @ApiModelProperty("反向绿波路口红灯范围")
+    @JsonProperty("backCrossRedTimesMap")
+    Map<String, List<List<Double>>> backCrossRedTimesMap;
     @ApiModelProperty("绿波路口绿波开始时间")
+    @JsonProperty("greenStartMap")
     Map<String, Double> greenStartMap;
+    @ApiModelProperty("反向绿波路口绿波开始时间")
+    Map<String, Double> BackGreenStartMap;
+    @JsonProperty("distanceMap")
     @ApiModelProperty("绿波路口距离下一个路口距离")
     Map<String, Double> distanceMap;
     @ApiModelProperty("绿波带宽")
     private Double greenWidthTime;
+    @ApiModelProperty("反向绿波带宽")
+    private Double BackGreenWidthTime;
 }

signal-optimize-service/src/main/resources/bootstrap-docker.yaml

@@ -2,7 +2,7 @@ spring:
   cloud:
     nacos:
       config:
-        server-addr: 173.17.0.1:8848
+        server-addr: 37.12.182.29:8848
         file-extension: yaml
         group: signal
         namespace: signal