两种解决方案
- 前端查询字典数据然后前端转码
- 后端查询字典值，然后再转码返回给前段。
本文及时针对方案2 进行的改进
目标：
在需要返回给前段的字段上添加指定的注解例如：@DictDesc 则根据该字段定义的值结合注解配置生成 xxxDesc字段并自动赋值为注解属性值所对应的字典描述；
具体使用的技术涉及到jackson序列化与反序列化，其他JSON工具包也类型的效果;
字典注解定义
|
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
|
/** * 字典类型字段自动生成Desc描述字段 */@Inherited@Target(ElementType.FIELD)@Retention(RetentionPolicy.RUNTIME)@Documented@JacksonAnnotationsInside@JsonSerialize(using = DictDescSerializer.class)@JsonDeserialize(using = DictDescDeserializer.class)public @interface DictDesc { /** * 枚举类型的class * 取值：getValue, getCode, getStatus, name * 描述：getDesc * * @return 字典类型 */ Class<? extends Enum<? extends DictEnum>>[] enumType() default {}; /** * 字典类型分组 * * @return 字典类型 */ String[] dictType() default {}; /** * 字典转换失败时默认值 * * @return String 默认值 */ String defaultValue() default ""; /** * 是否抛出异常，默认不抛出异常，返回默认值 * * @return true 转换失败则抛出异常，false 异常返回默认值 */ boolean throwException() default false;} |
该注解中定义了解析该注解需要序列化器与返序列化器：
@JsonSerialize(using = DictDescSerializer.class)
@JsonDeserialize(using = DictDescDeserializer.class)
字典序列化与返序列化器的实现
|
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
|
import com.fasterxml.jackson.core.JacksonException;import com.fasterxml.jackson.core.JsonParser;import com.fasterxml.jackson.databind.BeanProperty;import com.fasterxml.jackson.databind.DeserializationContext;import com.fasterxml.jackson.databind.JsonDeserializer;import com.fasterxml.jackson.databind.JsonMappingException;import com.fasterxml.jackson.databind.deser.ContextualDeserializer;import com.aimilin.common.dict.annotation.DictDesc;import com.aimilin.common.dict.service.impl.DictDescSerializerUtils;import lombok.NoArgsConstructor;import lombok.extern.slf4j.Slf4j;import org.springframework.beans.BeanUtils;import org.springframework.core.convert.ConversionService;import org.springframework.core.convert.support.DefaultConversionService;import java.beans.PropertyDescriptor;import java.io.IOException;import java.lang.reflect.Method;import java.util.Objects;/** * 字典类型返序列化器 * * @author liujunguang1 * @version V1.0 * @date 2022/5/20 21:08 */@Slf4j@NoArgsConstructorpublic class DictDescDeserializer extends JsonDeserializer<Object> implements ContextualDeserializer { /** * 生成序列化字段后缀 */ private static final String LABEL_SUFFIX = "Desc"; /** * 参数类型 */ private Class<?> rawClass; /** * 默认转换器 */ private ConversionService converter; /** * 设置方法 */ private Method writeMethod; /** * 字典配置信息 */ private DictDesc dict; public DictDescDeserializer(DictDesc dict, BeanProperty property) { this.dict = dict; this.rawClass = property.getType().getRawClass(); this.converter = new DefaultConversionService(); Class<?> targetClass = property.getMember().getDeclaringClass(); String writeField = property.getName() + LABEL_SUFFIX; PropertyDescriptor propertyDescriptor = BeanUtils.getPropertyDescriptor(targetClass, writeField); this.writeMethod = Objects.isNull(propertyDescriptor) ? null : propertyDescriptor.getWriteMethod(); if (Objects.isNull(this.writeMethod)) { log.info("类：{}，字典属性：{}，没有写入方法：{}，不设置值！", targetClass.getName(), property.getName(), writeField); } } @Override public JsonDeserializer<?> createContextual(DeserializationContext ctxt, BeanProperty property) throws JsonMappingException { DictDesc dict = property.getAnnotation(DictDesc.class); if (dict != null) { return new DictDescDeserializer(dict, property); } return this; } @Override public Object deserialize(JsonParser p, DeserializationContext ctxt) throws IOException, JacksonException { Object result = this.getValue(p.getText()); this.setDictDesc(result, p.getCurrentName(), p.getCurrentValue()); return result; } /** * 将数据类型转换为目标类型 * * @param value 字符串值 * @return 目标类型值 * @throws IOException */ public Object getValue(String value) throws IOException { return converter.convert(value, this.rawClass); } /** * 设置字典会限制 * * @param result 字典value * @param currentName 当前属性名称 * @param currentValue 当前对象 */ private void setDictDesc(Object result, String currentName, Object currentValue) { try { if (this.writeMethod != null) { writeMethod.invoke(currentValue, DictDescSerializerUtils.getDesc(this.dict, currentName, result)); } } catch (Exception e) { log.error("类：{}，字典属性：{}，回显异常：{}", currentValue.getClass(), currentName, e.getMessage(), e); } }} |
|
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
|
import com.fasterxml.jackson.core.JsonGenerator;import com.fasterxml.jackson.databind.BeanProperty;import com.fasterxml.jackson.databind.JsonMappingException;import com.fasterxml.jackson.databind.JsonSerializer;import com.fasterxml.jackson.databind.SerializerProvider;import com.fasterxml.jackson.databind.ser.ContextualSerializer;import com.aimilin.common.dict.annotation.DictDesc;import com.aimilin.common.dict.service.impl.DictDescSerializerUtils;import lombok.NoArgsConstructor;import lombok.extern.slf4j.Slf4j;import java.io.IOException;/** * 字典序列化器 * * @author liujunguang1 * @version V1.0 * @date 2022/5/20 20:48 */@Slf4j@NoArgsConstructorpublic class DictDescSerializer extends JsonSerializer<Object> implements ContextualSerializer { /** * 生成序列化字段后缀 */ private static final String LABEL_SUFFIX = "Desc"; /** * 字典配置信息 */ private DictDesc dict; /** * 构造方法 * * @param dict 字典描述 */ public DictDescSerializer(DictDesc dict) { this.dict = dict; } @Override public JsonSerializer<?> createContextual(SerializerProvider prov, BeanProperty property) throws JsonMappingException { DictDesc dict = property.getAnnotation(DictDesc.class); if (dict != null) { return new DictDescSerializer(dict); } return this; } /** * Method that can be called to ask implementation to serialize * values of type this serializer handles. * * @param value Value to serialize; can <b>not</b> be null. * @param gen Generator used to output resulting Json content * @param provider Provider that can be used to get serializers for * serializing Objects value contains, if any. */ @Override public void serialize(Object value, JsonGenerator gen, SerializerProvider provider) throws IOException { provider.defaultSerializeValue(value, gen); if (dict != null) { String fieldName = gen.getOutputContext().getCurrentName(); // 添加转换之后的字段：xxxDesc gen.writeStringField(fieldName.concat(LABEL_SUFFIX), DictDescSerializerUtils.getDesc(dict, fieldName, value)); } }} |
字典序列化与反序列工具类
|
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
|
import cn.hutool.extra.spring.SpringUtil;import com.aimilin.common.core.pojo.system.SysDict;import com.aimilin.common.dict.annotation.DictDesc;import com.aimilin.common.dict.annotation.DictEnum;import com.aimilin.common.dict.exception.DictException;import com.aimilin.common.dict.exception.enums.DictExceptionEnum;import com.aimilin.common.dict.service.SysDictService;import lombok.extern.slf4j.Slf4j;import org.apache.commons.collections4.CollectionUtils;import org.apache.commons.lang3.ArrayUtils;import org.apache.commons.lang3.StringUtils;import java.lang.reflect.InvocationTargetException;import java.lang.reflect.Method;import java.util.Arrays;import java.util.List;import java.util.Objects;/** * 字典转换工具类 * * @author liujunguang1 * @version V1.0 * @date 2022/5/20 23:19 */@Slf4jpublic class DictDescSerializerUtils { /** * 获取字典信息 * * @param dict 字典对象 * @param value 字典值 * @return */ public static String getDesc(DictDesc dict, String field, Object value) { if (ArrayUtils.isEmpty(dict.dictType()) && ArrayUtils.isEmpty(dict.enumType())) { throw new DictException(DictExceptionEnum.REQUEST_DICT_TYPE, field); } try { if (value == null) { throw new DictException(DictExceptionEnum.REQUEST_NOT_NULL, field); } if (ArrayUtils.isNotEmpty(dict.enumType())) { return getEnumDesc(dict, field, value); } return getDictDesc(dict, field, value); } catch (Exception e) { log.error("字典转换异常, field:{}, enumType:{}, dictType:{}, 值：{}, 异常：{}", field, dict.enumType(), dict.dictType(), value, e.getMessage(), e); if (dict.throwException()) { throw e instanceof DictException ? (DictException) e : new DictException(DictExceptionEnum.DICT_EXCEPTION, e); } return dict.defaultValue(); } } /** * 获取枚举类型的描述信息 * * @param dict 字典 * @param value 值 * @return 枚举desc字段 */ public static String getEnumDesc(DictDesc dict, String field, Object value) throws NoSuchMethodException, InvocationTargetException, IllegalAccessException { for (Class<? extends Enum<? extends DictEnum>> dictEnum : dict.enumType()) { Method getCode = dictEnum.getMethod("getCode"); Method getMessage = dictEnum.getMethod("getMessage"); for (Enum<? extends DictEnum> e : dictEnum.getEnumConstants()) { if (value.equals(getCode.invoke(e))) { return Objects.toString(getMessage.invoke(e)); } } } throw new DictException(DictExceptionEnum.UNKNOWN_ENUM_DICT_VALUE, String.format("Field:%s, EnumType: %s, Value: %s", field, Arrays.toString(dict.enumType()), value)); } /** * 获取字典中的值 * * @param dict 字典注解 * @param value 属性值 * @return 字典名称 */ public static String getDictDesc(DictDesc dict, String field, Object value) { if (ArrayUtils.isEmpty(dict.dictType())) { throw new DictException(DictExceptionEnum.REQUEST_DICT_TYPE, field); } List<SysDict> sysDictList = SpringUtil.getBean(SysDictService.class).getDictByDictTypeCode(dict.dictType()); if (CollectionUtils.isEmpty(sysDictList)) { throw new DictException(DictExceptionEnum.NO_DICT_DATA, field, Arrays.toString(dict.dictType())); } for (SysDict sysDict : sysDictList) { if (StringUtils.equals(sysDict.getCode(), Objects.toString(value))) { return sysDict.getValue(); } } throw new DictException(DictExceptionEnum.UNKNOWN_DICT_VALUE, field, Arrays.toString(dict.dictType())); }} |
字典转换服务类
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
|
/** * 字典服务类 * * @author liujunguang1 * @version V1.0 * @date 2022/5/20 16:03 */public interface SysDictService { /** * 根据字典类型code获取字典列表 * * @param dictTypeCodes 字典类型code * @return List<SysDict> */ public List<SysDict> getDictByDictTypeCode(String... dictTypeCodes);} |
服务实现类：
|
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
|
/** * 系统字典服务实现类 * * @author liujunguang1 * @version V1.0 * @date 2022/5/20 16:13 */@Servicepublic class SysDictServiceImpl implements SysDictService { @Resource private SystemContextServiceApi systemContextServiceApi; @Resource private SysDictCache sysDictCache; /** * 根据字典类型编码获取字典数据 * * @param dictTypeCodes 字典类型编码值 * @return List<SysDict> */ @Override public List<SysDict> getDictByDictTypeCode(String... dictTypeCodes) { List<SysDict> dictTypeCache = sysDictCache.getDictTypeCache(dictTypeCodes); if (CollectionUtils.isNotEmpty(dictTypeCache)) { return dictTypeCache; } return systemContextServiceApi.getDictByDictTypeCode(dictTypeCodes).getData(); }} |
字典缓存服务
可以修改为使用本地缓存方式
|
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
|
/** * 字典缓存服务 * * @version V1.0 * @date 2022/5/19 12:13 */@Slf4j@Servicepublic class SysDictCache { @Resource private RedisService redisService; /** * 获取字典类型缓存 * * @param dictTypes 字典类型 * @return 字典列表 */ public List<SysDict> getDictTypeCache(String... dictTypes) { if (Objects.isNull(redisService)) { log.info("redisService 为空，不使用字典缓存"); return null; } List<List<SysDict>> dictValues = redisService.getMultiCacheMapValue(CommonConstant.DICT_CACHE_KEY, Arrays.asList(dictTypes)); if (CollectionUtils.isEmpty(dictValues)) { return null; } List<SysDict> result = new ArrayList<>(); dictValues.stream().filter(Objects::nonNull).forEach(result::addAll); log.debug("查询字典缓存，dictTypes:{}, 结果：{}", dictTypes, result); return result; } /** * 清空字典类型缓存 * * @param dictTypes 字典类型 */ public void cleanDictTypeCache(String... dictTypes) { if (Objects.isNull(redisService)) { return; } redisService.deleteCacheMapValue(CommonConstant.DICT_CACHE_KEY, dictTypes); log.info("清除字典缓存，dictTypes:{}", StringUtils.join(dictTypes)); } /** * 添加缓存 * * @param sysDictList 系统字典列表 */ public void putDictTypeCache(List<SysDict> sysDictList) { if (Objects.isNull(redisService) || CollectionUtils.isEmpty(sysDictList)) { return; } Map<String, List<SysDict>> collect = sysDictList.stream().collect(Collectors.groupingBy(SysDict::getTypeCode)); for (Map.Entry<String, List<SysDict>> entry : collect.entrySet()) { redisService.setCacheMapValue(CommonConstant.DICT_CACHE_KEY, entry.getKey(), entry.getValue()); log.info("设置字典缓存，dictType：{}，结果：{}", entry.getKey(), entry.getValue()); } }} |
到此这篇关于Java分析讲解序列化与字典功能的序列化的文章就介绍到这了,更多相关Java序列化内容请搜索服务器之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持服务器之家！
原文链接：https://lliujg.blog.csdn.net/article/details/125136181
