SpringBoot注入JSON格式数据

本是古典何须时尚 2022-10-08 05:58 142阅读 0赞

代码如下

@Retention(RetentionPolicy.RUNTIME)
    @Target({ElementType.FIELD})
    @Documented
    public @interface JsonValue {
        /**
         * key
         *
         * @return
         */
        String value();
    }

@Slf4j
    @Component
    public class JsonValueProcessor implements BeanFactoryAware, BeanPostProcessor, PriorityOrdered {
    
        private ConfigurableBeanFactory beanFactory;
    
        private static final Gson gson = new Gson();
    
        @Override
        public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
            this.beanFactory = (ConfigurableBeanFactory) beanFactory;
        }
    
        @Override
        public int getOrder() {
            //make it as late as possible
            return Ordered.LOWEST_PRECEDENCE;
        }
    
        @Override
        public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
            Class<?> clazz = bean.getClass();
            for (Field field : findAllField(clazz)) {
                processField(bean, beanName, field);
            }
            return bean;
        }
    
        /**
         * 属性赋值
         *
         * @param bean     对象
         * @param beanName 对象名
         * @param field    对象属性
         */
        private void processField(Object bean, String beanName, Field field) {
            JsonValue jsonValue = AnnotationUtils.getAnnotation(field, JsonValue.class);
            if (jsonValue == null) {
                return;
            }
            // 获取key对应的value
            String placeholder = jsonValue.value();
            Object propertyValue = resolvePropertyValue(beanFactory, beanName, placeholder);
            if (!(propertyValue instanceof String)) {
                return;
            }
            // 注入属性
            boolean accessible = field.isAccessible();
            field.setAccessible(true);
            ReflectionUtils.setField(field, bean, parseJsonValue((String) propertyValue, field.getGenericType()));
            field.setAccessible(accessible);
        }
    
    
        /**
         * Resolve placeholder property values, e.g.
         * <br />
         * <br />
         * "${somePropertyValue}" -> "the actual property value"
         */
        public Object resolvePropertyValue(ConfigurableBeanFactory beanFactory, String beanName, String placeholder) {
            // resolve string value
            String strVal = beanFactory.resolveEmbeddedValue(placeholder);
            BeanDefinition bd = (beanFactory.containsBean(beanName) ? beanFactory.getMergedBeanDefinition(beanName) : null);
            // resolve expressions like "#{systemProperties.myProp}"
            return evaluateBeanDefinitionString(beanFactory, strVal, bd);
        }
    
        /**
         * @param beanFactory
         * @param value
         * @param beanDefinition
         * @return
         */
        private Object evaluateBeanDefinitionString(ConfigurableBeanFactory beanFactory, String value, BeanDefinition beanDefinition) {
            if (beanFactory.getBeanExpressionResolver() == null) {
                return value;
            }
            Scope scope = (beanDefinition != null ? beanFactory.getRegisteredScope(beanDefinition.getScope()) : null);
            return beanFactory.getBeanExpressionResolver().evaluate(value, new BeanExpressionContext(beanFactory, scope));
        }
    
        /**
         * 字符串转对象
         *
         * @param json       json字符串
         * @param targetType 目标类型
         * @return Object
         */
        private Object parseJsonValue(String json, Type targetType) {
            try {
                return gson.fromJson(json, targetType);
            } catch (Throwable ex) {
                log.error("Parsing json '{}' to type {} failed!", json, targetType, ex);
                throw ex;
            }
        }
    
        /**
         * 得到目标类上所有定义的变量
         *
         * @param clazz 目标类
         * @return List<Field>
         */
        private List<Field> findAllField(Class<?> clazz) {
            List<Field> res = Lists.newArrayList();
            ReflectionUtils.doWithFields(clazz, field -> res.add(field));
            return res;
        }
    }

测试

##################### application.properties #####################
    jsonMap.injection={"k1":"v1","k2":"v2"}

@JsonValue("${jsonMap.injection}")
    private Map<String, String> jsonMapInjection;
    @Test
    public void testConfig() {
        System.out.println(jsonMapInjection);
    }

![20210620221835974.png][]

> [https://www.jb51.net/article/123012.htm][https_www.jb51.net_article_123012.htm]

[20210620221835974.png]: /images/20221005/40db832de8cb40aca5b57d4524f7f5ca.png
[https_www.jb51.net_article_123012.htm]: https://www.jb51.net/article/123012.htm