Java:URL 编码为 JSON/Map&Lists

Question

在我们的 Java 应用程序中，我们想解析 URL 编码的字符串:

foo[bar]=value&foo[bar1][baz1]=1&foo[bar1][baz2]2&foo[bar2][]=3&foo[bar2][]=4

->

{foo: {bar: "value", bar1: {baz1: 1, baz2: 2}, bar2: [3,4]}}

我不介意解析结果是 JSON 还是 Map&Lists——我只需要得到一些合理的解析响应。

我找不到任何工具来执行此操作，实现并不简单，我当然不想重新发明轮子。

Answer 1

我不知道有任何现有的解决方案。有关输入结构的更多详细信息可能会有所帮助，但这里是基于一些或多或少受过教育的猜测的实现。

它的工作原理如下:

它在&处拆分输入字符串以获得tokens，然后在=处拆分以获得键值对

值 根据实用猜测转换为对象。如果它可以被解析成一个Long，就完成了。如果可以将其解析为 Double，则完成。否则，该值被假定为一个字符串。

key 有点复杂，虽然它的结构很简单。例如，它可以是

foo[bar]
foo[bar1][baz1]
foo[bar2][]

并且这些属性可以任意嵌套。因此，这些键也被标记化为字符串列表。这样的列表可能是

["foo", "bar"]
["foo", "bar1", "baz1"]
["foo", "bar", ""]

当此列表的最后一个元素为空字符串时，应将值放入 List 中。否则，应将其放入 Map 中。这是通过递归遍历这些标记、传递 值 并在必要时创建中间 Map 元素来完成的，直到可以做出关于最后一个元素的决定。无论最后一个元素是什么，值 都会插入到那里。

该实现不会进行任何健全性检查，因此请确保只为其提供有效输入。

import java.util.ArrayList;
import java.util.Arrays;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;

public class DecodeUrl
{
    public static void main(String[] args)
    {
        String s = "foo[bar]=value&foo[bar1][baz1]=1&foo[bar1][baz2]=2&foo[bar2][]=3&foo[bar2][]=4";
        Map<String, Object> result = decode(s);
        print(result, "");
    }

    private static void print(Map<?, ?> map, String indent)
    {
        for (Entry<?, ?> entry : map.entrySet())
        {
            Object key = entry.getKey();
            Object value = entry.getValue();
            if (value instanceof Map<?, ?>)
            {
                Map<?, ?> next = (Map<?, ?>) value;
                System.out.println(indent + key + " : ");
                print(next, indent + "  ");
            } 
            else
            {
                System.out.println(indent + key + " : " + value 
                    + " (type " + value.getClass().getSimpleName() + ")");
            }
        }
    }

    private static Map<String, Object> decode(String s)
    {
        Map<String, Object> result = new LinkedHashMap<String, Object>();
        String tokens[] = s.split("&");
        for (String token : tokens)
        {
            int equalsIndex = token.indexOf('=');
            String key = token.substring(0, equalsIndex);
            String valueString = token.substring(equalsIndex+1);
            Object value = processValue(valueString);
            add(result, tokenize(key), value);
        }
        return result;
    }


    private static void add(
        Map<String, Object> target, List<String> path, Object value)
    {
        if (path.size() == 2)
        {
            String parentName = path.get(0);
            String propertyName = path.get(1);
            if (propertyName.isEmpty())
            {
                List<Object> list = getList(target, parentName);;
                list.add(value);
            }
            else
            {
                Map<String, Object> map = getMap(target, parentName);
                map.put(propertyName, value);
            }
        }
        else
        {
            String propertyName = path.get(0);
            Map<String, Object> map = getMap(target, propertyName);
            target.put(propertyName, map);
            add(map, path.subList(1, path.size()), value);
        }
    }

    private static List<Object> getList(
        Map<String, Object> map, String name)
    {
        Object object = map.computeIfAbsent(name, 
            e -> new ArrayList<Object>());
        @SuppressWarnings("unchecked")
        List<Object> result = (List<Object>) object;
        return result;
    }


    private static Map<String, Object> getMap(
        Map<String, Object> map, String name)
    {
        Object object = map.computeIfAbsent(name, 
            e -> new LinkedHashMap<String, Object>());
        @SuppressWarnings("unchecked")
        Map<String, Object> result = (Map<String, Object>) object;
        return result;
    }


    private static List<String> tokenize(String key)
    {
        String s = key.replaceAll("\\[", ".");
        String t = s.replaceAll("\\]", "");
        return Arrays.asList(t.split("\\.", -1));
    }

    private static Object processValue(String valueString)
    {
        Long longValue = asLong(valueString);
        if (longValue != null)
        {
            return longValue;
        }
        Double doubleValue = asDouble(valueString);
        if (doubleValue != null)
        {
            return doubleValue;
        }
        return valueString;
    }

    private static Long asLong(String string)
    {
        try
        {
            return Long.parseLong(string);
        }
        catch (NumberFormatException e)
        {
            return null;
        }
    }

    private static Double asDouble(String string)
    {
        try
        {
            return Double.parseDouble(string);
        }
        catch (NumberFormatException e)
        {
            return null;
        }
    }
}

该示例解码问题中给出的输入，并打印结果:

foo : 
  bar : value (type String)
  bar1 : 
    baz1 : 1 (type Long)
    baz2 : 2 (type Long)
  bar2 : [3, 4] (type ArrayList)