Java：URL编码为JSON / Map＆Lists

问题描述 投票：2回答：3

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

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

java json url
3个回答
1
投票

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

它的工作原理如下：

它将输入字符串拆分为&以获取令牌，而令牌又在=处拆分以获取键值对

该值基于实用猜测转换为对象。如果它可以被解析为Long，那就完成了。如果它可以被解析为Double，那就完成了。否则，该值假定为字符串。

关键是更加繁琐，虽然其结构非常简单。例如，它可以是

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)
0
投票

你可以使用像apache http commons这样的东西获得一个List（https://hc.apache.org/httpcomponents-client-ga/httpclient/apidocs/org/apache/http/client/utils/URLEncodedUtils.html）

import org.apache.hc.client5.http.utils.URLEncodedUtils

String url = "https://www.url.com/page.html?a=1&b=2&c=3&c=3a";
List<NameValuePair> params = URLEncodedUtils.parse(new URI(url), "UTF-8");

params.forEach(System.out::println);
0
投票

如果你知道我希望使用oop的东西的结构。

例如，如果你的字符串

FOO [巴] =值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 = "";
    }
}
}

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

最新问题
© www.soinside.com 2019 - 2024. All rights reserved.