关于springboot项目配置中@Value的用法

1、常规用法以及不存在取默认值的用法

@Component
public class ConfigProperties {

    @Value("${auth.jwt.token}")
    private String token;

    @Value("${auth.jwt.expire}")
    private Long expire;

    @Value("${auth.jwt.no:10")
    private String no;
}

2、通过@Value获取list集合的用法

/**
 * 配置文件中英文逗号分隔，转列表
 */
@Value("${auth.jwt.whiteList}")
private List<Long> whiteList;

注意事项：集合的转换默认不支持以下形式

/**
 * yml数组，无法转换过来，只能根据 "auth.jwt.blackList[0]", "auth.jwt.blackList[1]" 来取对应的值
 */
@Value("${auth.jwt.blackList:10,11,12}")
private String[] blackList;

3、通过@Value实现配置转实体类的几种用法

        配置文件为：

auth:
  jwt:
    tt: token:tt_token; expire:1622616888888

        3.1、通过PropertyEditor来映射实体类对象

        a)、首先实体类对象中定义个对应的值处理方法，本例方法如下：

public static Jwt parse(String text, String source) {
        //按配置文件中的分隔符进行切分
        String[] kvs = StringUtils.split(text, ";");
        Map<String, String> map = new HashMap<>(8);
        for (String kv : kvs) {
            String[] items = StringUtils.split(kv, ":");
            //验证配置的key是否有对应的value值
            if (items.length != 2) {
                continue;
            }
            map.put(items[0].trim().toLowerCase(), items[1].trim());
        }
        //赋值给实体类对象
        Jwt jwt = new Jwt();
        jwt.setSource(source);
        jwt.setToken(map.get("token"));
        jwt.setExpire(Long.valueOf(map.getOrDefault("expire", "0")));
        return jwt;
    }

扩展：关于map转实体，可借助java的反射机制实现

        方法一：直接对实体类的 Field 循环赋值（仅对实体类中的字符串类型可以有效转换）

/**
     * @Author liaoyibin
     * @Description //TODO 根据map对象的key-value转为实体
     * @Date 11:54 2021/7/6
     * @Param [map, clazz]
     * @return T
     **/
    public <T> T select(Map<String, Object> map,Class<T> clazz) {
        try {
            Class<?> classZ = Class.forName(clazz.getName());
            //获取属性列表
            Field[] declaredFields = classZ.getDeclaredFields();
            //获取对象实例
            T o = (T) classZ.newInstance();
            for (Field field : declaredFields) {
                System.out.println(field.getName());
                if(map.containsKey(field.getName())){
                    Object s = map.get(field.getName());
                    //取消属性的访问权限控制，即使private属性也可以进行访问。
                    field.setAccessible(true);
                    field.set(o,s);
                }
            }
            System.out.println(o);
            return o;
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        }
        return null;
    }

        方法二：通过封装的工具类直接转换，支持基本数据类型。效果如下：

    回到正文，既然是使用PropertyEditor来实现转换，那么根据我们数据便需要继承PropertyEditorSupport类重写方法，在方法里调用我们数据转换方法。

public class JwtEditor extends PropertyEditorSupport {
    @Override
    public void setAsText(String text) throws IllegalArgumentException {
        setValue(Jwt.parse(text, "JwtEditor"));
    }
}

   然后将我们自定义的edit类注册到我们spring的容器中，文件所在路径与springboot启动类同路径模具图配置类如下：

@Configuration
public class AutoConfiguration {
    /**
     * 注册自定义的 propertyEditor
     *
     * @return
     */
    public CustomEditorConfigurer editorConfigurer() {
        CustomEditorConfigurer editorConfigurer = new CustomEditorConfigurer();
        editorConfigurer.setCustomEditors(Collections.singletonMap(Jwt.class, JwtEditor.class));
        return editorConfigurer;
    }
}

至此，已完成配置操作。可直接编译输出验证结果，有如下效果：

        3.2、通过实现Converter接口来达到配置映射实体的目的

与上面的区别便是通过实现接口来达到目的，以及注册配置的区别

public class JwtConverter implements Converter<String, Jwt> {
    @Override
    public Jwt convert(String s) {
        return Jwt.parse(s, "JwtConverter");
    }
}

 

@Bean("conversionService")
public ConversionServiceFactoryBean conversionService() {
    ConversionServiceFactoryBean factoryBean = new ConversionServiceFactoryBean();
    factoryBean.setConverters(Collections.singleton(new JwtConverter()));
    return factoryBean;
}

        3.3、相对以上两种更常用的方法是通过实现Formatter接口

public class JwtFormatter implements Formatter<Jwt> {
    @Override
    public Jwt parse(String text, Locale locale) throws ParseException {
        return Jwt.parse(text, "JwtFormatter");
    }

    @Override
    public String print(Jwt object, Locale locale) {
        return JSONObject.toJSONString(object);
    }
}

@Bean("conversionService")
public FormattingConversionServiceFactoryBean conversionService2() {
    FormattingConversionServiceFactoryBean factoryBean = new FormattingConversionServiceFactoryBean();
    factoryBean.setConverters(Collections.singleton(new JwtConverter()));
    factoryBean.setFormatters(Collections.singleton(new JwtFormatter()));
    return factoryBean;
}

注意事项：如果 Converter与Formatter同时存在时，后者优先级更高