Java:JSON/Map的URL编码&；列表

在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&List——我只需要得到一些合理的解析响应

---

我找不到任何工具来实现这一点，实现并不简单，我当然不想重新发明轮子。

您可以使用类似apache http commons的工具来获取列表（）

import org.apache.hc.client5.http.utils.URLEncodedUtils
字符串url=”https://www.url.com/page.html?a=1&b=2&c=3&c=3a";
List params=URLEncodedUtils.parse（新的URI（url），“UTF-8”）；
参数forEach（System.out:：println）；

如果你知道这个东西的结构，我更愿意使用oop

例如，如果您的字符串

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

是foo对象的表示形式，您可以将其拆分几次，将其放入foo对象中，然后使用gson之类的包将对象转换为json

public class asdf {
public static void main(String[] args) {
    String urlString = args[0];
    System.out.println(urlString);
    String[] arguments = urlString.split("&");
    Foo foo = new Foo();
    for (String s : arguments) {
        String[] s2 = s.split("=");
        String[] s4 = s2[0].split("\\]\\[|\\[|\\]");
        switch (s4[1]) {
            case "bar":
                foo.bar = s2[1];
                break;
            case "bar1":
                foo.bar1.put(s4[2], Integer.parseInt(s2[1]));
                break;
            case "bar2":
                foo.bar2.add(Integer.parseInt(s2[1]));
                break;
            default:
                System.out.println(s4[1] + " is not a known part of foo");
                break;
        }
    }
    System.out.println(foo);
}


private static class Foo {
    String bar;
    Map<String, Integer> bar1;

    @Override
    public String toString() {
        return "Foo{" +
                "bar='" + bar + '\'' +
                ", bar1=" + bar1 +
                ", bar2=" + bar2 +
                '}';
    }

    ArrayList<Integer> bar2;

    private Foo() {
        bar1 = new HashMap();
        bar2 = new ArrayList<>();
        bar = "";
    }
}
}

公共类asdf{
公共静态void main（字符串[]args）{
字符串urlString=args[0]；
System.out.println（urlString）；
String[]参数=urlString.split（&）；
Foo-Foo=新的Foo（）；
for（字符串s：参数）{
字符串[]s2=s.split（“”）；
字符串[]s4=s2[0]。拆分（“\\]\\[\\\\[\\\\]”）；
开关（s4[1]）{
案例“酒吧”：
foo.bar=s2[1]；
打破
案例“bar1”：
foo.bar1.put（s4[2]，Integer.parseInt（s2[1]）；
打破
案例“bar2”：
foo.bar2.add（Integer.parseInt（s2[1]）；
打破
违约：
System.out.println（s4[1]+“不是foo的已知部分”）；
打破
}
}
系统输出打印项次（foo）；
}
私有静态类Foo{
弦杆；
地图1；
@凌驾
公共字符串toString（）{
返回“Foo{”+
“bar=”+bar+“\”+
“，bar1=“+bar1+
“，bar2=“+bar2+
'}';
}
ArrayList bar2；
私家富（）{
bar1=新的HashMap（）；
bar2=新的ArrayList（）；
bar=“”；
}
}
}

---

当然，这只有在你知道你在寻找什么的情况下才有效。

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

其工作原理如下：

它在

&

处拆分输入字符串以获得标记，然后在

=

处拆分这些标记以获得键值对

值根据实用猜测转换为对象。如果可以将其解析为

长

，则完成此操作。如果可以将其解析为

双精度

，则完成此操作。否则，假定值为字符串

键更精细一些，尽管它的结构非常简单

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

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

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

当此列表的最后一个元素是空字符串时，则应将值放入

列表

。否则，应将其放入

映射

。这是通过递归遍历这些标记、传递值并创建中间

映射

元素（如有必要）来完成的，直到决定e可以生成最后一个元素。无论最后一个元素是什么，值都会插入其中

该实现不支持任何健全性检查，因此请确保只向其提供有效的输入

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;
        }
    }
}

---

我需要一个通用的解决方案，仅仅得到一个列表是不够的。我不知道它的结构，我正在寻找一个通用的解决方案。这种（分层的！）结构的URL编码从何而来？这是以任何方式标准化的吗？（例如，是否有某种语法定义？）这是javascript编码任何JS对象的方式。当然这是标准的。@Vojtěch:javascript不编码这样的东西。

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)