redis、xml接口

pom.xml

@@ -53,6 +53,15 @@
             <artifactId>guava</artifactId>
             <version>20.0</version>
         </dependency>
+        <!-- Redis -->
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-data-redis</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>org.apache.commons</groupId>
+            <artifactId>commons-pool2</artifactId>
+        </dependency>
     </dependencies>
 
 

src/main/java/com/gzlh/config/RedisConfig.java

@@ -0,0 +1,81 @@
+package com.gzlh.config;
+
+import com.fasterxml.jackson.annotation.JsonAutoDetect.Visibility;
+import com.fasterxml.jackson.annotation.JsonInclude;
+import com.fasterxml.jackson.annotation.PropertyAccessor;
+import com.fasterxml.jackson.databind.DeserializationFeature;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import org.springframework.cache.CacheManager;
+import org.springframework.cache.annotation.CachingConfigurerSupport;
+import org.springframework.cache.annotation.EnableCaching;
+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.lettuce.LettuceConnectionFactory;
+import org.springframework.data.redis.core.RedisTemplate;
+import org.springframework.data.redis.serializer.*;
+
+import java.time.Duration;
+
+import static java.util.Collections.singletonMap;
+
+@Configuration
+@EnableCaching // 开启缓存支持
+public class RedisConfig extends CachingConfigurerSupport {
+	private static final String TEST_DEMO_CACHE = "test:demo";
+
+	/**
+	 * RedisTemplate配置
+	 *
+	 * @param lettuceConnectionFactory
+	 * @return
+	 */
+	@Bean
+	public RedisTemplate<String, Object> redisTemplate(LettuceConnectionFactory lettuceConnectionFactory) {
+		// 设置序列化
+		Jackson2JsonRedisSerializer<Object> jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer<Object>(Object.class);
+		ObjectMapper om = new ObjectMapper();
+		om.setVisibility(PropertyAccessor.ALL, Visibility.ANY);
+		om.setSerializationInclusion(JsonInclude.Include.NON_NULL);
+		om.disable(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES);
+		jackson2JsonRedisSerializer.setObjectMapper(om);
+		// 配置redisTemplate
+		RedisTemplate<String, Object> redisTemplate = new RedisTemplate<String, Object>();
+		redisTemplate.setConnectionFactory(lettuceConnectionFactory);
+		RedisSerializer<?> stringSerializer = new StringRedisSerializer();
+		redisTemplate.setKeySerializer(stringSerializer);// key序列化
+		redisTemplate.setValueSerializer(jackson2JsonRedisSerializer);// value序列化
+		redisTemplate.setHashKeySerializer(stringSerializer);// Hash key序列化
+		redisTemplate.setHashValueSerializer(jackson2JsonRedisSerializer);// Hash value序列化
+		redisTemplate.afterPropertiesSet();
+		return redisTemplate;
+	}
+
+	/**
+	 * 缓存配置管理器
+	 *
+	 * @param factory
+	 * @return
+	 */
+	@Bean
+	public CacheManager cacheManager(LettuceConnectionFactory factory) {
+        // 配置序列化（缓存默认有效期 6小时）
+        RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig().entryTtl(Duration.ofHours(6));
+        RedisCacheConfiguration redisCacheConfiguration = config.serializeKeysWith(RedisSerializationContext.SerializationPair.fromSerializer(new StringRedisSerializer()))
+                												.serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(new GenericJackson2JsonRedisSerializer()));
+
+		// 以锁写入的方式创建RedisCacheWriter对象
+		//RedisCacheWriter writer = RedisCacheWriter.lockingRedisCacheWriter(factory);
+		// 创建默认缓存配置对象
+		/* 默认配置，设置缓存有效期 1小时*/
+		//RedisCacheConfiguration defaultCacheConfig = RedisCacheConfiguration.defaultCacheConfig().entryTtl(Duration.ofHours(1));
+		/* 自定义配置test:demo 的超时时间为 5分钟*/
+		RedisCacheManager cacheManager = RedisCacheManager.builder(RedisCacheWriter.lockingRedisCacheWriter(factory)).cacheDefaults(redisCacheConfiguration)
+				.withInitialCacheConfigurations(singletonMap(TEST_DEMO_CACHE, RedisCacheConfiguration.defaultCacheConfig().entryTtl(Duration.ofMinutes(5)).disableCachingNullValues()))
+				.transactionAware().build();
+		return cacheManager;
+	}
+
+}

src/main/java/com/gzlh/controller/TestController.java

@@ -0,0 +1,78 @@
+package com.gzlh.controller;
+
+import cn.hutool.core.bean.BeanUtil;
+import cn.hutool.core.util.XmlUtil;
+import cn.hutool.extra.spring.SpringUtil;
+import com.gzlh.event.EventBus;
+import com.gzlh.utils.FileUtils;
+import com.gzlh.utils.RedisUtil;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.util.StringUtils;
+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 javax.annotation.Resource;
+import java.io.*;
+import java.net.Socket;
+import java.net.URL;
+import java.net.URLConnection;
+import java.util.*;
+
+
+@RestController
+@RequestMapping("/test")
+public class TestController {
+    @Value("${file.root-path}")
+    private String path;
+    @Value("${application.channel-name}")
+    private String channel;
+    @Autowired
+    private RedisUtil redisUtil;
+
+    @PostMapping("/t")
+    public void test(
+            @RequestBody String xmlStr
+//            HttpServletRequest request
+    ) throws IOException {
+//        String xmlStr = IOUtils.toString(request.getInputStream(), request.getCharacterEncoding());
+
+        Map<String, Object> StringObjectMap = new HashMap<>();
+
+        XmlUtil.xmlToMap(xmlStr, StringObjectMap);
+
+        Map<String, Object> ic = BeanUtil.beanToMap(StringObjectMap.get("IC"));
+        Map<String, Object> weight =BeanUtil.beanToMap(StringObjectMap.get("WEIGHT"));
+        Map<String, Object> car = BeanUtil.beanToMap(StringObjectMap.get("CAR"));
+        Map<String, Object> conta =BeanUtil.beanToMap(StringObjectMap.get("CONTA"));
+        Map<String, Object> seal = BeanUtil.beanToMap(StringObjectMap.get("SEAL"));
+
+
+        Map<String, String> cacheMap = new HashMap<>();
+        cacheMap.put("carEcNo", (String) car.get("CAR_EC_NO"));
+        cacheMap.put("contaIdF", !StringUtils.isEmpty((String) car.get("CONTA_ID_F"))?(String) car.get("CONTA_ID_F"):"");
+        cacheMap.put("contaIdB", !StringUtils.isEmpty((String) car.get("CONTA_ID_B"))?(String) car.get("CONTA_ID_B"):"");
+        redisUtil.set(channel,cacheMap);
+//        System.out.println(redisUtil.hasKey(channel));
+
+        Calendar calendar = Calendar.getInstance();
+        String savePath=path+"/"+ calendar.get(Calendar.YEAR)+"-" + (calendar.get(Calendar.MONTH)+1);
+
+        Map<String, String> picMap = new HashMap<>();
+        for (Map.Entry<String, Object> entry : conta.entrySet()) {
+            if(entry.getKey().contains("PIC")&& !StringUtils.isEmpty((String) entry.getValue())){
+                String filePath = FileUtils.downLoad((String) entry.getValue(),savePath);
+                String base64 = FileUtils.getBase64FromImg(filePath);
+                picMap.put(entry.getKey(),base64);
+            }
+        }
+
+        EventBus eventBus = SpringUtil.getBean(EventBus.class);
+        eventBus.start("WEIGHBRIDGE.READ");
+
+    }
+
+
+}

src/main/java/com/gzlh/utils/FileUtils.java

@@ -0,0 +1,91 @@
+package com.gzlh.utils;
+
+import org.springframework.beans.factory.annotation.Value;
+
+import java.io.*;
+import java.net.URL;
+import java.net.URLConnection;
+import java.util.Arrays;
+import java.util.Base64;
+import java.util.Calendar;
+
+public class FileUtils {
+
+
+    public static String downLoad(String urlString,String savePath) throws IOException {
+        InputStream in = null;
+        OutputStream out=null;
+
+        try {
+            URL url = new URL(urlString);
+            URLConnection connection = url.openConnection();
+            in = connection.getInputStream();
+//            Calendar calendar = Calendar.getInstance();
+//            String savePath=path+"/"+ calendar.get(Calendar.YEAR)+"-" + (calendar.get(Calendar.MONTH)+1);
+            File folder = new File(savePath);
+            if (!folder.exists()) {
+                folder.mkdirs();
+            }
+            String fileName = new File(url.getFile()).getName();
+            out = new FileOutputStream(savePath+"/"+fileName);
+
+            byte[] buffer = new byte[1024];
+            int bytesRead;
+            while ((bytesRead = in.read(buffer)) != -1) {
+                out.write(buffer, 0, bytesRead);
+            }
+            System.out.println("文件下载完成！");
+            return savePath+"/"+fileName;
+        } catch (Exception e) {
+            throw e;
+        }finally {
+            if (in != null) {
+                in.close();
+            }
+            if (out != null){
+                out.close();
+            }
+        }
+
+    }
+
+
+    public static String getBase64FromImg(String filePath) throws IOException {
+        FileInputStream in = null;
+        try {
+            File file = new File(filePath);
+            // base64图片前缀
+            String pre = "data:image/jpg;base64,";
+            // 读取图片
+            in = new FileInputStream(file);
+            // 读取字节长度
+            int len = 0;
+            // baseByte数组的容量
+            int capacity = 0;
+            byte[] baseByte= new byte[0];
+            byte [] bytes = new byte[1024];
+            while ((len = in.read(bytes)) != -1){
+                // 对原数组进行拷贝扩容
+                baseByte= Arrays.copyOf(baseByte, len + capacity);
+                // 将新数据拷贝到新扩容的数组
+                System.arraycopy(bytes, 0, baseByte, capacity, len);
+                // 数据容量增加
+                capacity += len;
+            }
+            // 获取base64编码器
+            Base64.Encoder encoder = Base64.getEncoder();
+            // 将字节数组转换base64
+            String encodeToString = encoder.encodeToString(baseByte);
+//            System.out.println("======>>>>>>：" + pre + encodeToString);
+            return pre + encodeToString;
+        } catch (IOException e) {
+            throw e;
+        } finally {
+            if (in != null) {
+                in.close();
+            }
+        }
+
+    }
+
+}

src/main/java/com/gzlh/utils/RedisUtil.java

@@ -0,0 +1,575 @@
+package com.gzlh.utils;
+
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.data.redis.core.RedisTemplate;
+import org.springframework.stereotype.Component;
+import org.springframework.util.CollectionUtils;
+
+import javax.annotation.Resource;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.concurrent.TimeUnit;
+
+/**
+ * redis 工具类
+ * @Author Scott
+ *
+ */
+@Component
+@Slf4j
+public class RedisUtil {
+
+	@Resource
+	private RedisTemplate<String, Object> redisTemplate;
+
+	/**
+	 * 指定缓存失效时间
+	 *
+	 * @param key  键
+	 * @param time 时间(秒)
+	 * @return
+	 */
+	public boolean expire(String key, long time) {
+		try {
+			if (time > 0) {
+				redisTemplate.expire(key, time, TimeUnit.SECONDS);
+			}
+			return true;
+		} catch (Exception e) {
+			log.error("系统异常",e);
+			return false;
+		}
+	}
+
+	/**
+	 * 根据key 获取过期时间
+	 *
+	 * @param key 键 不能为null
+	 * @return 时间(秒) 返回0代表为永久有效
+	 */
+	public long getExpire(String key) {
+		return redisTemplate.getExpire(key, TimeUnit.SECONDS);
+	}
+
+	/**
+	 * 判断key是否存在
+	 *
+	 * @param key 键
+	 * @return true 存在 false不存在
+	 */
+	public boolean hasKey(String key) {
+		try {
+			return redisTemplate.hasKey(key);
+		} catch (Exception e) {
+			log.error("系统异常",e);
+			return false;
+		}
+	}
+
+	/**
+	 * 删除缓存
+	 *
+	 * @param key 可以传一个值 或多个
+	 */
+	@SuppressWarnings("unchecked")
+	public void del(String... key) {
+		if (key != null && key.length > 0) {
+			if (key.length == 1) {
+				redisTemplate.delete(key[0]);
+			} else {
+				redisTemplate.delete(CollectionUtils.arrayToList(key));
+			}
+		}
+	}
+
+	// ============================String=============================
+	/**
+	 * 普通缓存获取
+	 *
+	 * @param key 键
+	 * @return 值
+	 */
+	public Object get(String key) {
+		return key == null ? null : redisTemplate.opsForValue().get(key);
+	}
+
+	public String get(String key, long start, long end){
+		return key == null ? null : redisTemplate.opsForValue().get(key,start,end);
+	}
+
+	/**
+	 * 普通缓存放入
+	 *
+	 * @param key   键
+	 * @param value 值
+	 * @return true成功 false失败
+	 */
+	public boolean set(String key, Object value) {
+		try {
+			redisTemplate.opsForValue().set(key, value);
+			return true;
+		} catch (Exception e) {
+			log.error("系统异常",e);
+			return false;
+		}
+
+	}
+
+	/**
+	 * 普通缓存放入并设置时间
+	 *
+	 * @param key   键
+	 * @param value 值
+	 * @param time  时间(秒) time要大于0 如果time小于等于0 将设置无限期
+	 * @return true成功 false 失败
+	 */
+	public boolean set(String key, Object value, long time) {
+		try {
+			if (time > 0) {
+				redisTemplate.opsForValue().set(key, value, time, TimeUnit.SECONDS);
+			} else {
+				set(key, value);
+			}
+			return true;
+		} catch (Exception e) {
+			log.error("系统异常",e);
+			return false;
+		}
+	}
+
+	/**
+	 * 递增
+	 *
+	 * @param key 键
+	 * @param delta  要增加几(大于0)
+	 * @return
+	 */
+	public long incr(String key, long delta) {
+		if (delta < 0) {
+			throw new RuntimeException("递增因子必须大于0");
+		}
+		return redisTemplate.opsForValue().increment(key, delta);
+	}
+
+	/**
+	 * 递减
+	 *
+	 * @param key 键
+	 * @param delta  要减少几(小于0)
+	 * @return
+	 */
+	public long decr(String key, long delta) {
+		if (delta < 0) {
+			throw new RuntimeException("递减因子必须大于0");
+		}
+		return redisTemplate.opsForValue().increment(key, -delta);
+	}
+
+	// ================================Map=================================
+	/**
+	 * HashGet
+	 *
+	 * @param key  键 不能为null
+	 * @param item 项 不能为null
+	 * @return 值
+	 */
+	public Object hget(String key, String item) {
+		return redisTemplate.opsForHash().get(key, item);
+	}
+
+	/**
+	 * 获取hashKey对应的所有键值
+	 *
+	 * @param key 键
+	 * @return 对应的多个键值
+	 */
+	public Map<Object, Object> hmget(String key) {
+		return redisTemplate.opsForHash().entries(key);
+	}
+
+	/**
+	 * HashSet
+	 *
+	 * @param key 键
+	 * @param map 对应多个键值
+	 * @return true 成功 false 失败
+	 */
+	public boolean hmset(String key, Map<String, Object> map) {
+		try {
+			redisTemplate.opsForHash().putAll(key, map);
+			return true;
+		} catch (Exception e) {
+			log.error("系统异常",e);
+			return false;
+		}
+	}
+
+	/**
+	 * HashSet 并设置时间
+	 *
+	 * @param key  键
+	 * @param map  对应多个键值
+	 * @param time 时间(秒)
+	 * @return true成功 false失败
+	 */
+	public boolean hmset(String key, Map<String, Object> map, long time) {
+		try {
+			redisTemplate.opsForHash().putAll(key, map);
+			if (time > 0) {
+				expire(key, time);
+			}
+			return true;
+		} catch (Exception e) {
+			log.error("系统异常",e);
+			return false;
+		}
+	}
+
+	/**
+	 * 向一张hash表中放入数据,如果不存在将创建
+	 *
+	 * @param key   键
+	 * @param item  项
+	 * @param value 值
+	 * @return true 成功 false失败
+	 */
+	public boolean hset(String key, String item, Object value) {
+		try {
+			redisTemplate.opsForHash().put(key, item, value);
+			return true;
+		} catch (Exception e) {
+			log.error("系统异常",e);
+			return false;
+		}
+	}
+
+	/**
+	 * 向一张hash表中放入数据,如果不存在将创建
+	 *
+	 * @param key   键
+	 * @param item  项
+	 * @param value 值
+	 * @param time  时间(秒) 注意:如果已存在的hash表有时间,这里将会替换原有的时间
+	 * @return true 成功 false失败
+	 */
+	public boolean hset(String key, String item, Object value, long time) {
+		try {
+			redisTemplate.opsForHash().put(key, item, value);
+			if (time > 0) {
+				expire(key, time);
+			}
+			return true;
+		} catch (Exception e) {
+			log.error("系统异常",e);
+			return false;
+		}
+	}
+
+	/**
+	 * 删除hash表中的值
+	 *
+	 * @param key  键 不能为null
+	 * @param item 项 可以使多个 不能为null
+	 */
+	public void hdel(String key, Object... item) {
+		redisTemplate.opsForHash().delete(key, item);
+	}
+
+	/**
+	 * 判断hash表中是否有该项的值
+	 *
+	 * @param key  键 不能为null
+	 * @param item 项 不能为null
+	 * @return true 存在 false不存在
+	 */
+	public boolean hHasKey(String key, String item) {
+		return redisTemplate.opsForHash().hasKey(key, item);
+	}
+
+	/**
+	 * hash递增 如果不存在,就会创建一个 并把新增后的值返回
+	 *
+	 * @param key  键
+	 * @param item 项
+	 * @param by   要增加几(大于0)
+	 * @return
+	 */
+	public double hincr(String key, String item, double by) {
+		return redisTemplate.opsForHash().increment(key, item, by);
+	}
+
+	/**
+	 * hash递减
+	 *
+	 * @param key  键
+	 * @param item 项
+	 * @param by   要减少记(小于0)
+	 * @return
+	 */
+	public double hdecr(String key, String item, double by) {
+		return redisTemplate.opsForHash().increment(key, item, -by);
+	}
+
+	// ============================set=============================
+	/**
+	 * 根据key获取Set中的所有值
+	 *
+	 * @param key 键
+	 * @return
+	 */
+	public Set<Object> sGet(String key) {
+		try {
+			return redisTemplate.opsForSet().members(key);
+		} catch (Exception e) {
+			log.error("系统异常",e);
+			return null;
+		}
+	}
+
+	/**
+	 * 根据value从一个set中查询,是否存在
+	 *
+	 * @param key   键
+	 * @param value 值
+	 * @return true 存在 false不存在
+	 */
+	public boolean sHasKey(String key, Object value) {
+		try {
+			return redisTemplate.opsForSet().isMember(key, value);
+		} catch (Exception e) {
+			log.error("系统异常",e);
+			return false;
+		}
+	}
+
+	/**
+	 * 将数据放入set缓存
+	 *
+	 * @param key    键
+	 * @param values 值 可以是多个
+	 * @return 成功个数
+	 */
+	public long sSet(String key, Object... values) {
+		try {
+			return redisTemplate.opsForSet().add(key, values);
+		} catch (Exception e) {
+			log.error("系统异常",e);
+			return 0;
+		}
+	}
+
+	/**
+	 * 将set数据放入缓存
+	 *
+	 * @param key    键
+	 * @param time   时间(秒)
+	 * @param values 值 可以是多个
+	 * @return 成功个数
+	 */
+	public long sSetAndTime(String key, long time, Object... values) {
+		try {
+			Long count = redisTemplate.opsForSet().add(key, values);
+			if (time > 0) {
+				expire(key, time);
+			}
+			return count;
+		} catch (Exception e) {
+			log.error("系统异常",e);
+			return 0;
+		}
+	}
+
+	/**
+	 * 获取set缓存的长度
+	 *
+	 * @param key 键
+	 * @return
+	 */
+	public long sGetSetSize(String key) {
+		try {
+			return redisTemplate.opsForSet().size(key);
+		} catch (Exception e) {
+			log.error("系统异常",e);
+			return 0;
+		}
+	}
+
+	/**
+	 * 移除值为value的
+	 *
+	 * @param key    键
+	 * @param values 值 可以是多个
+	 * @return 移除的个数
+	 */
+	public long setRemove(String key, Object... values) {
+		try {
+			Long count = redisTemplate.opsForSet().remove(key, values);
+			return count;
+		} catch (Exception e) {
+			log.error("系统异常",e);
+			return 0;
+		}
+	}
+	// ===============================list=================================
+
+	/**
+	 * 获取list缓存的内容
+	 *
+	 * @param key   键
+	 * @param start 开始
+	 * @param end   结束 0 到 -1代表所有值
+	 * @return
+	 */
+	public List<Object> lGet(String key, long start, long end) {
+		try {
+			return redisTemplate.opsForList().range(key, start, end);
+		} catch (Exception e) {
+			log.error("系统异常",e);
+			return null;
+		}
+	}
+
+	/**
+	 * 获取list缓存的长度
+	 *
+	 * @param key 键
+	 * @return
+	 */
+	public long lGetListSize(String key) {
+		try {
+			return redisTemplate.opsForList().size(key);
+		} catch (Exception e) {
+			log.error("系统异常",e);
+			return 0;
+		}
+	}
+
+	/**
+	 * 通过索引 获取list中的值
+	 *
+	 * @param key   键
+	 * @param index 索引 index>=0时， 0 表头，1 第二个元素，依次类推；index<0时，-1，表尾，-2倒数第二个元素，依次类推
+	 * @return
+	 */
+	public Object lGetIndex(String key, long index) {
+		try {
+			return redisTemplate.opsForList().index(key, index);
+		} catch (Exception e) {
+			log.error("系统异常",e);
+			return null;
+		}
+	}
+
+	/**
+	 * 将list放入缓存
+	 *
+	 * @param key   键
+	 * @param value 值
+	 * @return
+	 */
+	public boolean lSet(String key, Object value) {
+		try {
+			redisTemplate.opsForList().rightPush(key, value);
+			return true;
+		} catch (Exception e) {
+			log.error("系统异常",e);
+			return false;
+		}
+	}
+
+	/**
+	 * 将list放入缓存
+	 *
+	 * @param key   键
+	 * @param value 值
+	 * @param time  时间(秒)
+	 * @return
+	 */
+	public boolean lSet(String key, Object value, long time) {
+		try {
+			redisTemplate.opsForList().rightPush(key, value);
+			if (time > 0) {
+				expire(key, time);
+			}
+			return true;
+		} catch (Exception e) {
+			log.error("系统异常",e);
+			return false;
+		}
+	}
+
+	/**
+	 * 将list放入缓存
+	 *
+	 * @param key   键
+	 * @param value 值
+	 * @return
+	 */
+	public boolean lSet(String key, List<Object> value) {
+		try {
+			redisTemplate.opsForList().rightPushAll(key, value);
+			return true;
+		} catch (Exception e) {
+			log.error("系统异常",e);
+			return false;
+		}
+	}
+
+	/**
+	 * 将list放入缓存
+	 *
+	 * @param key   键
+	 * @param value 值
+	 * @param time  时间(秒)
+	 * @return
+	 */
+	public boolean lSet(String key, List<Object> value, long time) {
+		try {
+			redisTemplate.opsForList().rightPushAll(key, value);
+			if (time > 0) {
+				expire(key, time);
+			}
+			return true;
+		} catch (Exception e) {
+			log.error("系统异常",e);
+			return false;
+		}
+	}
+
+	/**
+	 * 根据索引修改list中的某条数据
+	 *
+	 * @param key   键
+	 * @param index 索引
+	 * @param value 值
+	 * @return
+	 */
+	public boolean lUpdateIndex(String key, long index, Object value) {
+		try {
+			redisTemplate.opsForList().set(key, index, value);
+			return true;
+		} catch (Exception e) {
+			log.error("系统异常",e);
+			return false;
+		}
+	}
+
+	/**
+	 * 移除N个值为value
+	 *
+	 * @param key   键
+	 * @param count 移除多少个
+	 * @param value 值
+	 * @return 移除的个数
+	 */
+	public long lRemove(String key, long count, Object value) {
+		try {
+			Long remove = redisTemplate.opsForList().remove(key, count, value);
+			return remove;
+		} catch (Exception e) {
+			log.error("系统异常",e);
+			return 0;
+		}
+	}
+}

src/main/resources/application.yml

@@ -27,3 +27,29 @@ gate:
 file:
   root-path: D:\\upfile\\
 
+socket:
+  port: 8080
+
+Spring:
+  # redis 配置
+  redis:
+    # 地址
+    host: localhost
+    # 端口，默认为6379
+    port: 6379
+    # 数据库索引
+    database: 0
+    # 密码
+    password:
+    # 连接超时时间
+    timeout: 60s
+    lettuce:
+      pool:
+        # 连接池中的最小空闲连接
+        min-idle: 0
+        # 连接池中的最大空闲连接
+        max-idle: 8
+        # 连接池的最大数据库连接数
+        max-active: 8
+        # #连接池最大阻塞等待时间（使用负值表示没有限制）
+        max-wait: -1ms