class RequestDecodeConfig {
    private static final Logger logger = LoggerFactory.getLogger(RequestDecodeConfig.class);
    public static final String CONFIG_NAME = "request-decode";
    public static final String ENABLED = "enabled";
    public static final String DECODERS = "decoders";
    private Map<String, Object> mappedConfig;
    private final Config config;

    boolean enabled;
    List<String> decoders;

    private RequestDecodeConfig(String configName) {
        config = Config.getInstance();
        mappedConfig = config.getJsonMapConfigNoCache(configName);
        setConfigData();
        setConfigList();
    }
    private RequestDecodeConfig() {
        this(CONFIG_NAME);
    }

    public static RequestDecodeConfig load(String configName) {
        return new RequestDecodeConfig(configName);
    }

    public static RequestDecodeConfig load() {
        return new RequestDecodeConfig();
    }

    public void reload() {
        mappedConfig = config.getJsonMapConfigNoCache(CONFIG_NAME);
        setConfigData();
        setConfigList();
    }

    public void reload(String configName) {
        mappedConfig = config.getJsonMapConfigNoCache(configName);
        setConfigData();
        setConfigList();
    }

    public boolean isEnabled() {
        return enabled;
    }

    public void setEnabled(boolean enabled) {
        this.enabled = enabled;
    }

    public List<String> getDecoders() {
        return decoders;
    }

    public void setDecoders(List<String> decoders) {
        this.decoders = decoders;
    }

    public Map<String, Object> getMappedConfig() {
        return mappedConfig;
    }

    Config getConfig() {
        return config;
    }

    private void setConfigData() {
        if (getMappedConfig() != null) {
            Object object = getMappedConfig().get(ENABLED);
            if(object != null) enabled = Config.loadBooleanValue(ENABLED, object);
        }
    }

    private void setConfigList() {<FILL_FUNCTION_BODY>}

}

        if (mappedConfig != null && mappedConfig.get(DECODERS) != null) {
            Object object = mappedConfig.get(DECODERS);
            decoders = new ArrayList<>();
            if(object instanceof String) {
                String s = (String)object;
                s = s.trim();
                if(logger.isTraceEnabled()) logger.trace("s = " + s);
                if(s.startsWith("[")) {
                    // json format
                    try {
                        decoders = Config.getInstance().getMapper().readValue(s, new TypeReference<List<String>>() {});
                    } catch (Exception e) {
                        throw new ConfigException("could not parse the decoders json with a list of strings.");
                    }
                } else {
                    // comma separated
                    decoders = Arrays.asList(s.split("\\s*,\\s*"));
                }
            } else if (object instanceof List) {
                List prefixes = (List)object;
                prefixes.forEach(item -> {
                    decoders.add((String)item);
                });
            } else {
                throw new ConfigException("decoders must be a string or a list of strings.");
            }
        }
    
<no_super_class>