使用案例演示:
先开发了一个简单的Demo:
普通DTO类注解翻译的字段和翻译来源
在需要翻译的方法上注解@Translate
接口返回结果:
框架思路:
1、标记的注解需要通过AOP切面在调用的时候处理翻译
2、翻译的来源是Redis的缓存,需要有数据来源,应用启动之后就需要初始化
一、配置Redis
pom.xml的相关依赖:
<!-- https://mvnrepository.com/artifact/org.springframework.boot/spring-boot-starter-data-redis --> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-redis</artifactId> <version>${spring.boot.version}</version> </dependency> <!-- https://mvnrepository.com/artifact/org.springframework.boot/spring-boot-starter-aop --> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-aop</artifactId> <version>${spring.boot.version}</version> </dependency> <!-- https://mvnrepository.com/artifact/org.springframework.boot/spring-boot-starter --> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter</artifactId> <version>${spring.boot.version}</version> </dependency> <!-- https://mvnrepository.com/artifact/org.springframework.boot/spring-boot-starter-web --> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> <version>${spring.boot.version}</version> </dependency> <!-- https://mvnrepository.com/artifact/redis.clients/jedis --> <dependency> <groupId>redis.clients</groupId> <artifactId>jedis</artifactId> <version>4.3.1</version> </dependency> <!-- https://mvnrepository.com/artifact/mysql/mysql-connector-java --> <dependency> <groupId>mysql</groupId> <artifactId>mysql-connector-java</artifactId> <version>8.0.30</version> </dependency> <!-- https://mvnrepository.com/artifact/com.baomidou/mybatis-plus-boot-starter --> <dependency> <groupId>com.baomidou</groupId> <artifactId>mybatis-plus-boot-starter</artifactId> <version>3.5.2</version> </dependency> <dependency> <groupId>cn.hutool</groupId> <artifactId>hutool-all</artifactId> <version>5.8.4</version> </dependency> <properties> <maven.compiler.source>8</maven.compiler.source> <maven.compiler.target>8</maven.compiler.target> <spring.boot.version>2.3.10.RELEASE</spring.boot.version> <durid.version>1.2.14</durid.version> </properties>
Redis的yml配置:
spring: redis: host: 192.168.124.8 database: 0 timeout: 3000 password: 123456 jedis: pool: max-active: 29 max-wait: -1 max-idle: 10 min-idle: 0
RedisTemplate配置类:
package cn.cloud9.server.struct.redis; import cn.hutool.core.date.DateUtil; import com.alibaba.fastjson.parser.Feature; import com.alibaba.fastjson.serializer.SerializeConfig; import com.alibaba.fastjson.serializer.SerializeWriter; import com.alibaba.fastjson.serializer.SerializerFeature; import com.alibaba.fastjson.support.config.FastJsonConfig; import com.alibaba.fastjson.support.spring.FastJsonRedisSerializer; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; import org.springframework.context.annotation.Lazy; import org.springframework.data.redis.connection.RedisConnectionFactory; import org.springframework.data.redis.core.RedisTemplate; import org.springframework.data.redis.serializer.GenericToStringSerializer; import org.springframework.data.redis.serializer.RedisSerializer; import org.springframework.data.redis.serializer.StringRedisSerializer; import javax.annotation.Resource; import java.time.LocalDate; import java.time.LocalDateTime; import java.time.LocalTime; import java.time.format.DateTimeFormatter; import java.util.Date; /** * @author OnCloud9 * @description * @project tt-server * @date 2022年11月10日 下午 10:20 */ @Configuration public class RedisConfiguration { /** * 改用fastjson redis序列化,请删除redis数据后使用此序列化 * @param redisConnectionFactory * @return */ @Bean public RedisTemplate<String, ?> redisTemplate(@Lazy RedisConnectionFactory redisConnectionFactory) { RedisTemplate<String, ?> redisTemplate = new RedisTemplate<>(); redisTemplate.setConnectionFactory(redisConnectionFactory); GenericToStringSerializer<String> stringRedisSerializer = new GenericToStringSerializer<>(String.class); redisTemplate.setKeySerializer(stringRedisSerializer); redisTemplate.setHashKeySerializer(stringRedisSerializer); FastJsonRedisSerializer<?> fastJsonRedisSerializer = new FastJsonRedisSerializer<>(Object.class); FastJsonConfig fastJsonConfig = fastJsonRedisSerializer.getFastJsonConfig(); SerializeConfig serializeConfig = fastJsonConfig.getSerializeConfig(); /* 加入的LocalDateTime序列化,也可以不加(但是要用@JSONField(format = "yyyy-MM-dd HH:mm:ss"))格式化 */ serializeConfig.put(LocalDateTime.class, (serializer, object, fieldName, fieldType, features) -> { SerializeWriter out = serializer.out; if (object == null) { out.writeNull(); return; } out.writeString(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss").format((LocalDateTime) object)); }); serializeConfig.put(LocalDate.class, (serializer, object, fieldName, fieldType, features) -> { SerializeWriter out = serializer.out; if (object == null) { out.writeNull(); return; } out.writeString(DateTimeFormatter.ofPattern("yyyy-MM-dd").format((LocalDate) object)); }); serializeConfig.put(LocalTime.class, (serializer, object, fieldName, fieldType, features) -> { SerializeWriter out = serializer.out; if (object == null) { out.writeNull(); return; } out.writeString(DateTimeFormatter.ofPattern("HH:mm:ss").format((LocalTime) object)); }); serializeConfig.put(Date.class, (serializer, object, fieldName, fieldType, features) -> { SerializeWriter out = serializer.out; if (object == null) { out.writeNull(); return; } out.write("\"" + DateUtil.format(((Date)object),"yyyy-MM-dd HH:mm:ss") + "\""); }); fastJsonConfig.setSerializeConfig(serializeConfig); fastJsonConfig.setFeatures(Feature.SupportAutoType); fastJsonConfig.setSerializerFeatures(SerializerFeature.WriteClassName); redisTemplate.setValueSerializer(fastJsonRedisSerializer); redisTemplate.setHashValueSerializer(fastJsonRedisSerializer); redisTemplate.afterPropertiesSet(); return redisTemplate; } }
二、数据源来源获取
数据源配置:
spring: datasource: url: jdbc:mysql://192.168.124.8:3308/tt?serverTimeZone=Asia/Shanghai driver-class-name: com.mysql.cj.jdbc.Driver username: root password: 123456
创建字典表的DTO,Mapper
package cn.cloud9.server.struct.dict.dto; import com.alibaba.fastjson.annotation.JSONField; import com.baomidou.mybatisplus.annotation.IdType; import com.baomidou.mybatisplus.annotation.TableField; import com.baomidou.mybatisplus.annotation.TableId; import com.baomidou.mybatisplus.annotation.TableName; import lombok.Data; import java.time.LocalDateTime; /** * @author OnCloud9 * @description * @project tt-server * @date 2022年11月13日 下午 09:31 */ @Data @TableName("system_dict") public class DictDTO { @TableId(value = "DICT_ID", type = IdType.AUTO) private Integer dictId; @TableField("DICT_CODE") private Integer dictCode; @TableField("DICT_TYPE") private String dictType; @TableField("DICT_ALIAS") private String dictAlias; @TableField("DICT_NAME") private String dictName; @TableField("DICT_TYPE_NAME") private String dictTypeName; @TableField("DICT_TYPE_ALIAS") private String dictTypeAlias; @TableField("DICT_PARENT_ID") private String dictParentId; @JSONField(format = "yyyy-MM-dd HH:mm:ss") @TableField("GEN_TIME") private LocalDateTime genTime; }
Mapper配置一个自定义查询SQL的方法:
package cn.cloud9.server.struct.dict.mapper; import cn.cloud9.server.struct.dict.dto.DictDTO; import com.baomidou.mybatisplus.core.mapper.BaseMapper; import org.apache.ibatis.annotations.Param; import org.apache.ibatis.annotations.Select; import java.util.List; public interface DictMapper extends BaseMapper<DictDTO> { @Select("${SQL}") List<DictDTO> queryUsingCustomSql(@Param("SQL") String sql); }
一般来说是加载字典表放入缓存中,但是还有类似行政区域表,也是需要缓存放入的
字典表:
SELECT * FROM `system_dict`
非字典,但是也可以按照字典表结构存储的表:
SELECT `NAME` AS `DICT_CODE`, 'AB_WORD' AS `DICT_TYPE`, `MEANING` AS `DICT_NAME` FROM abridge_word
只要字段适配,同样可以按照字典装载
我们可以有若干个需要装载的表,那需要写在配置文件中解除硬编码控制:
package cn.cloud9.server.struct.dict.cache; import lombok.Data; import org.springframework.boot.context.properties.ConfigurationProperties; import org.springframework.context.annotation.Configuration; import java.util.Map; /** * 缓存配置读取类,用于读取需要Redis装载的缓存 * @author OnCloud9 * @description * @project tt-server * @date 2022年11月13日 下午 10:10 */ @Data @Configuration @ConfigurationProperties(prefix = "cache") public class CacheProperty { private Map<String, String> sqlMap; }
则yml的配置声明如下:
cache: sql-map: default: SELECT * FROM `system_dict` # ab-word: SELECT `NAME` AS `DICT_CODE`, 'AB_WORD' AS `DICT_TYPE`, `MEANING` AS `DICT_NAME` FROM abridge_word
在需要加载的时候可以遍历配置Bean的Map,依次SQL查询需要装载的数据
// 1、注入配置Bean 和 mapper @Resource private CacheProperty cacheProperty; @Resource private DictMapper dictMapper; // 2、方法中获取map交给mapper执行 /* 读取配置文件的缓存SQL */ final Map<String, String> sqlMap = cacheProperty.getSqlMap(); for (String sqlKey : sqlMap.keySet()) { final String sql = sqlMap.get(sqlKey); final List<DictDTO> dictList = baseMapper.queryUsingCustomSql(sql) }
三、缓存抽象与实现
缓存的功能抽象成接口,最主要的三个功能:
1、初始化
2、按字典编码获取翻译名称
3、按字典类别获取这个类别的集合
package cn.cloud9.server.struct.dict.cache; import cn.cloud9.server.struct.dict.dto.DictDTO; import java.util.List; /** * 缓存服务接口 * */ public interface CacheService { void initializeCacheDataToRedis(); String findNameFromRedis(String dictCode); List<DictDTO> findListFromRedis(String dictCate); }
存入的Redis的结构是采用Hash,即 Key + Hkey + Hvalue
Hvalue又分成了两种类型,String 和 List<DictDTO>
第一种,获取翻译名称的时候,存入需要定义一个根Key, 和组合的Hkey
规则是这样: 根Key写死在Bean中不变,组合的Hkey = 表名(配置SQL的Key键) + 分隔符 + 字典类别 + 分割符 + 字典编号,Hvalue 是字典名称
第二种,需要获取某一个类别的集合,用于下拉列表,或者在前台翻译
规则是这样: 根Key写死在Bean中不变,组合的Hkey = 表名(配置SQL的Key键) + 分隔符 + 字典类别, Hvalue 是这个类别的集合
了解上述规则后,这个缓存服务接口,交给DictService来实现:
package cn.cloud9.server.struct.dict.service; import cn.cloud9.server.struct.dict.cache.CacheProperty; import cn.cloud9.server.struct.dict.cache.CacheService; import cn.cloud9.server.struct.dict.dto.DictDTO; import cn.cloud9.server.struct.dict.mapper.DictMapper; import com.baomidou.mybatisplus.core.toolkit.Wrappers; import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl; import lombok.extern.slf4j.Slf4j; import org.apache.commons.collections.CollectionUtils; import org.springframework.data.redis.core.HashOperations; import org.springframework.data.redis.core.RedisTemplate; import org.springframework.data.redis.core.StringRedisTemplate; import org.springframework.stereotype.Service; import javax.annotation.Resource; import java.util.*; import java.util.concurrent.ConcurrentHashMap; /** * * 字典服务 * @author OnCloud9 * @description * @project tt-server * @date 2022年11月13日 下午 09:21 */ @Slf4j @Service public class DictService extends ServiceImpl<DictMapper, DictDTO> implements CacheService { public static final String KEY_LISTS = "REDIS-LISTS-CACHE"; public static final String KEY_MAP = "REDIS-MAPS-CACHE"; public static final String SEPARATOR = "@"; @Resource private CacheProperty cacheProperty; @Resource private StringRedisTemplate stringTemplate; @Resource private RedisTemplate<String, Map<String, String>> mapTemplate; /** * 缓存初始化处理 */ @Override public void initializeCacheDataToRedis() { final HashOperations<String, Object, Object> hashOps = mapTemplate.opsForHash(); /* 清空缓存 */ stringTemplate.delete(KEY_MAP); stringTemplate.delete(KEY_LISTS); /* 读取配置文件的缓存SQL */ final Map<String, String> sqlMap = cacheProperty.getSqlMap(); /* 准备缓存结构容器, 并装载数据 */ Map<String, String> mapTank = new ConcurrentHashMap<>(); Map<String, List<DictDTO>> listTank = new ConcurrentHashMap<>(); for (String sqlKey : sqlMap.keySet()) { final String sql = sqlMap.get(sqlKey); final List<DictDTO> dictList = baseMapper.queryUsingCustomSql(sql); for (DictDTO dict : dictList) { final Integer dictCode = dict.getDictCode(); final String dictName = dict.getDictName(); final String dictType = dict.getDictType(); /* 装载 key -> h-key -> h-value */ final String mapKey = sqlKey + SEPARATOR + dictType + SEPARATOR + dictCode; mapTank.put(mapKey, dictName); /* 装载 key -> h-key -> h-list */ final String listKey = sqlKey + SEPARATOR + dictType; List<DictDTO> cateList = listTank.get(listKey); if (CollectionUtils.isEmpty(cateList)) { cateList = new ArrayList<>(); listTank.put(listKey, cateList); } cateList.add(dict); } } /* 装填到Redis中 */ hashOps.putAll(KEY_MAP, mapTank); hashOps.putAll(KEY_LISTS, listTank); log.info("Redis 缓存装载完毕 ...... "); } /** * * @param dictCode 格式:sqlKey@字典类别@字典编码 * @return 字典名称 找不到为null */ @Override public String findNameFromRedis(String dictCode) { final HashOperations<String, Object, Object> hashOps = mapTemplate.opsForHash(); final Object o = hashOps.get(KEY_MAP, dictCode); final boolean isEmpty = Objects.isNull(o); return !isEmpty ? (String) o : ""; } /** * * @param dictCate 格式:sqlKey@字典类别 * @return 字典类别集合 找不到为空集合 */ @SuppressWarnings("unchecked") @Override public List<DictDTO> findListFromRedis(String dictCate) { final HashOperations<String, Object, Object> hashOps = mapTemplate.opsForHash(); final Object o = hashOps.get(KEY_LISTS, dictCate); final boolean isEmpty = Objects.isNull(o); return !isEmpty ? (List<DictDTO>) o : Collections.EMPTY_LIST; } }
四、解决初始化加载的问题
初始化的实现有了,Bean也有了,那怎么才能让应用一启动的时候就开始执行呢?
而且执行一次通常是类静态资源调用的做法,于是就用到了
import org.springframework.context.ApplicationContextAware;
所有Bean装入Spring完毕后会执行Aware,通过Aware可以获取容器上下文对象
通过上下文对象,根据类型和Bean名称,可以静态的获取对应的Bean,
有了DictServiceBean之后,就可以调用初始化了
package cn.cloud9.server.struct.spring; import org.jetbrains.annotations.NotNull; import org.springframework.beans.BeansException; import org.springframework.context.ApplicationContext; import org.springframework.context.ApplicationContextAware; import org.springframework.context.annotation.Lazy; import org.springframework.stereotype.Service; /** * Spring上下文持有器类,用于静态方式获取Bean实例 * @author OnCloud9 * @description * @project tt-server * @date 2022年11月13日 下午 11:04 */ @Service @Lazy(value = false) public class SpringContextHolder implements ApplicationContextAware { /** * spring上下文 */ private static ApplicationContext applicationContext; @Override public void setApplicationContext(@NotNull ApplicationContext applicationContext) throws BeansException { SpringContextHolder.applicationContext = applicationContext; } public static ApplicationContext getApplicationContext() { return applicationContext; } /** * 获取bean * @param name bean名称 * @param <T> * @return */ public static <T> T getBean(String name){ return (T) applicationContext.getBean(name); } /** * 获取bean * @param requiredType bean类型 * @param <T> * @return */ public static <T> T getBean(Class<T> requiredType){ return applicationContext.getBean(requiredType); } /** * 获取bean * @param name bean名称 * @param requiredType bean类型 * @param <T> * @return */ public static <T> T getBean(String name, Class<T> requiredType){ return applicationContext.getBean(name,requiredType); } }
五、管理缓存
初始化是可以复用的,涉及字典相关的数据一旦更新发生变化,Redis的缓存也需要同步
这里最简单的做法就是刷新处理,结合上面的Bean持有器类,可以这样实现:
package cn.cloud9.server.struct.dict.cache; import cn.cloud9.server.struct.spring.SpringContextHolder; /** * 缓存管理器类,用于刷新缓存 * @author OnCloud9 * @description * @project tt-server * @date 2022年11月13日 下午 11:08 */ public class CacheManager { public static void refreshCache() { final CacheService cacheService = SpringContextHolder.getBean("dictService", CacheService.class); new Thread(cacheService::initializeCacheDataToRedis).start(); } }
放在Boot主启动类完成后调用:
package cn.cloud9.server; import cn.cloud9.server.struct.dict.cache.CacheManager; import cn.cloud9.server.struct.validator.EnableFormValidator; import org.mybatis.spring.annotation.MapperScan; import org.springframework.boot.SpringApplication; import org.springframework.boot.autoconfigure.SpringBootApplication; /** * @author OnCloud9 * @description * @project tt-server * @date 2022年11月06日 下午 04:18 */ @MapperScan(basePackages = "cn.cloud9.server.*") @SpringBootApplication public class MainApplication { public static void main(String[] args) { SpringApplication.run(MainApplication.class, args); CacheManager.refreshCache(); } }
重启运行看看能不能触发加载
查看Redis是否按照规则存入了字典:
六、设计注解
两个问题:在哪里翻译? 翻译什么?
对应两个注解:@Translate @DictFrom
这里@Translate注解 加了类对象声明,好像不需要,先无视把
声明在方法上标记,用来给AOP定位目标方法
package cn.cloud9.server.struct.dict.annotation; import java.lang.annotation.*; /** * 标记此注解时翻译PO对象 */ @Target(ElementType.METHOD) @Retention(RetentionPolicy.RUNTIME) @Documented public @interface Translate { /** * 翻译的DTO类 */ Class<?> dtoClass(); }
@DictFrom,用来标记翻译字段
package cn.cloud9.server.struct.dict.annotation; import java.lang.annotation.*; @Target(ElementType.FIELD) @Retention(RetentionPolicy.RUNTIME) @Documented public @interface DictFrom { /* 翻译的来源表 */ String srcTable() default "default"; /* 翻译的指定类别 */ String srcCate(); /* 翻译的来源字段 */ String srcField(); /* 翻译的字段是否是多个的, 默认单个 */ boolean isMulti() default false; /* 如果是多个的,每个值的分隔符是? */ String separator() default ","; }
七、编写字典翻译切面:
因为是个Demo, 切面这里的作用就是判断类型,翻译单独交给反射工具类来完成了
暂时只考虑单个Bean, 集合接口和翻页对象三种,也没有考虑嵌套Bean的情况
package cn.cloud9.server.struct.dict.aspect; import cn.cloud9.server.struct.dict.annotation.Translate; import cn.cloud9.server.struct.dict.reflect.ReflectUtil; import cn.cloud9.server.test.model.DictAspectModel; import com.alibaba.fastjson.JSON; import com.baomidou.mybatisplus.core.metadata.IPage; import lombok.extern.slf4j.Slf4j; import org.apache.commons.collections.CollectionUtils; import org.aspectj.lang.JoinPoint; import org.aspectj.lang.Signature; import org.aspectj.lang.annotation.AfterReturning; import org.aspectj.lang.annotation.Aspect; import org.aspectj.lang.annotation.Pointcut; import org.aspectj.lang.reflect.MethodSignature; import org.springframework.stereotype.Component; import javax.annotation.Resource; import java.lang.reflect.Method; import java.util.Collection; import java.util.List; /** * @author OnCloud9 * @description * @project tt-server * @date 2022年11月12日 下午 10:02 */ @Slf4j @Aspect @Component public class DictAspect { @Resource private ReflectUtil reflectUtil; @Pointcut(value = "@annotation(translate)", argNames = "translate") public void doTranslate(Translate translate) { } @AfterReturning(pointcut = "doTranslate(translate)", returning = "result", argNames = "point,result,translate") public Object translation(final JoinPoint point, Object result, Translate translate) throws Throwable { Signature signature = point.getSignature(); MethodSignature methodSignature = (MethodSignature) signature; Method method = methodSignature.getMethod(); final Class<?> aClass = translate.dtoClass(); final boolean isCollection = result instanceof Collection; final boolean isPage = result instanceof IPage; final boolean isTargetClass = aClass.equals(result.getClass()); if (!isCollection && !isPage && !isTargetClass) return result; else if (isCollection) { List<Object> list = (List<Object>) result; if (CollectionUtils.isEmpty(list)) return result; for (Object row : list) reflectUtil.translateDTO(row, aClass); } else if (isPage) { IPage<Object> page = (IPage<Object>) result; if (CollectionUtils.isEmpty(page.getRecords())) return result; final List<Object> records = page.getRecords(); for (Object record : records) reflectUtil.translateDTO(record, aClass); } else if (isTargetClass) { reflectUtil.translateDTO(result, aClass); } return result; } }
八、反射工具类:
反射工具类为了优化反射操作,这里用了hutool的工具
package cn.cloud9.server.struct.dict.reflect; import cn.cloud9.server.struct.dict.annotation.DictFrom; import cn.cloud9.server.struct.dict.annotation.Translate; import cn.cloud9.server.struct.dict.service.DictService; import org.springframework.stereotype.Component; import javax.annotation.Resource; import java.lang.reflect.Field; import java.util.Objects; import cn.hutool.core.bean.BeanUtil; /** * @author OnCloud9 * @description * @project tt-server * @date 2022年11月13日 下午 08:28 */ @Component public class ReflectUtil { @Resource private DictService dictService; /** * * @param result * @param aClass */ public void translateDTO(Object result, Class<?> aClass) { /* 获取这个类下的所有字段 */ final Field[] declaredFields = aClass.getDeclaredFields(); for (Field field : declaredFields) { /* 获取类上的@Translate注解 */ final DictFrom dictFrom = field.getAnnotation(DictFrom.class); /* 如果没有此注解则跳过 */ if (Objects.isNull(dictFrom)) continue; /* 获取声明的字典来源信息 */ final String srcTable = dictFrom.srcTable(); final String srcCate = dictFrom.srcCate(); final String srcField = dictFrom.srcField(); final boolean isMulti = dictFrom.isMulti(); final String separator = dictFrom.separator(); /* 取出目标对象对应字段的值 */ final Object fieldValue = BeanUtil.getFieldValue(result, srcField); /* 如果没有值则跳过, 或者值类型不是字符串或者整形 */ if (Objects.isNull(fieldValue) ) continue; else if (!(fieldValue instanceof String) && !(fieldValue instanceof Integer)) continue; if (!isMulti) { /* 调用Redis资源开始翻译 */ final String key = srcTable + DictService.SEPARATOR + srcCate + DictService.SEPARATOR + String.valueOf(fieldValue); final String translateName = dictService.findNameFromRedis(key); /* 赋值翻译字段 */ BeanUtil.setFieldValue(result, field.getName(), translateName); } else { final String[] split = ((String)fieldValue).split(separator); final StringBuilder builder = new StringBuilder(); for (int i = 0; i < split.length; i++) { final String key = srcTable + DictService.SEPARATOR + srcCate + DictService.SEPARATOR + split[i].trim(); if (i == split.length - 1) { final String fromRedis = dictService.findNameFromRedis(key); builder.append(fromRedis); } else { final String fromRedis = dictService.findNameFromRedis(key); builder.append(fromRedis); builder.append(separator); } } /* 赋值翻译字段 (多个) */ BeanUtil.setFieldValue(result, field.getName(), builder.toString()); } } } }
标签:Java,String,Redis,server,org,import,cn,final,Springboot From: https://www.cnblogs.com/mindzone/p/16890632.html