Http在Java中发布字符串和二进制参数

我想在java中发布一个既有字符串参数又有二进制参数的表单，例如

name=sam&photo=

---

不幸的是，可用的文档仅包括单独上载字符串或二进制数据。如何将两者结合起来？

您需要发送mime类型“application/x-www-form-urlencoded”。字段必须是文本

字段名称和值是转义/编码的，例如，空格字符替换为

+”，保留字符使用URL编码转义。哦，这还不是全部。。。非字母数字字符替换为

%HH'，如%20中的空格

两个十六进制数字代表字符的ASCII码

如果Java能为您做些什么。。。。。哦，等等，它可以

但这是一门新课。它是从Java1.0开始出现的

检查URLEncoder，它是一个用于HTML表单编码的实用程序类

此类包含用于将字符串转换为application/x-www-form-urlencoded MIME格式的静态方法。通过查阅HTML规范（以下引用），您可以了解更多有关HTML表单编码的信息

URLEncoder处理以下内容：“字母数字字符“a”到“z”、“a”到“z”和“0”到“9”保持不变。特殊字符“.”、“-”、“*”和“”保持不变。空格字符“”转换为加号“+”。"

这是二进制的踢球者

“所有其他字符都是不安全的，首先使用某种编码方案将其转换为一个或多个字节。然后，每个字节由3个字符的字符串“%xy”表示，其中xy是字节的两位十六进制表示形式。建议使用的编码方案是UTF-8。但是，出于兼容性原因，如果未指定编码，则使用平台的默认编码。”

始终指定UTF-8

下面是HTTP规范

---

我刚刚给你加了这个

现在，您可以在一个方法调用中完成此操作。：）

---

：）

让我来为你解释一下。（顺便说一句，你可以在这里拿到。）

我在boon中添加了以下内容：

public static String postForm(final String url, final Map<String, ?> headers,
                                            final Map<String, Object> formData
)

以上是一个测试，表明它的工作，因为我了解规范

关键是它正在将“image”，新字节[]{1,2,3}转换为image\u0000=%01%02%03

顺便说一句，map只是一个创建map的实用方法（在底部列出）

http服务器只是一个回音

    return Exceptions.tryIt(String.class, new Exceptions.TrialWithReturn<String>() {
        @Override
        public String tryIt() throws Exception {
            URLConnection connection;
            connection = doPostFormData(url, headers, formData);
            return extractResponseString(connection);
        }
    });

这是重要的一点，其余的只是处理HTTP请求/头gak

这是manageContentTypeHeaders

    manageContentTypeHeaders ( "application/x-www-form-urlencoded",
            StandardCharsets.UTF_8.name (), connection );

...

private static void manageContentTypeHeaders(String contentType, String charset, URLConnection connection) {
    connection.setRequestProperty("Accept-Charset", charset == null ? StandardCharsets.UTF_8.displayName() : charset);
    if (contentType!=null && !contentType.isEmpty()) {
        connection.setRequestProperty("Content-Type", contentType);
    }
}

下面是管理标题

    manageHeaders(headers, connection);

...

private static void manageHeaders(Map<String, ?> headers, URLConnection connection) {
    if (headers != null) {
        for (Map.Entry<String, ?> entry : headers.entrySet()) {
            connection.setRequestProperty(entry.getKey(), entry.getValue().toString());
        }
    }
}

IO写入只执行以下操作： 爱娥，写

public static void write ( OutputStream out, String content, Charset charset ) {

    try ( OutputStream o = out ) {
        o.write ( content.getBytes ( charset ) );
    } catch ( Exception ex ) {
        Exceptions.handle ( ex );
    }

}

ByteBuf就像ByteBuffer一样，但更易于使用且速度非常快。我有基准测试：

我错过了什么

让我知道它是否适合你

--瑞克

map函数只是一些实用的方法，所以我可以简单地表示一个map，因为我发现我经常使用它们。它只有9或10个。除此之外，我还可以传递一个条目列表

public static <K, V> Map<K, V> map(K k0, V v0) {
    Map<K, V> map = new LinkedHashMap<>(10);
    map.put(k0, v0);
    return map;
}

public static <K, V> Map<K, V> map(K k0, V v0, K k1, V v1) {
    Map<K, V> map = new LinkedHashMap<>(10);
    map.put(k0, v0);
    map.put(k1, v1);
    return map;
}


public static <K, V> Map<K, V> map(K k0, V v0, K k1, V v1, K k2, V v2) {
    Map<K, V> map = new LinkedHashMap<>(10);
    map.put(k0, v0);
    map.put(k1, v1);
    map.put(k2, v2);
    return map;
}

public static <K, V> Map<K, V> map(K k0, V v0, K k1, V v1, K k2, V v2, K k3,
                                   V v3) {
    Map<K, V> map = new LinkedHashMap<>(10);
    map.put(k0, v0);
    map.put(k1, v1);
    map.put(k2, v2);
    map.put(k3, v3);
    return map;
}

public static <K, V> Map<K, V> map(K k0, V v0, K k1, V v1, K k2, V v2, K k3,
                                   V v3, K k4, V v4) {
    Map<K, V> map = new LinkedHashMap<>(10);
    map.put(k0, v0);
    map.put(k1, v1);
    map.put(k2, v2);
    map.put(k3, v3);
    map.put(k4, v4);
    return map;
}

public static <K, V> Map<K, V> map(K k0, V v0, K k1, V v1, K k2, V v2, K k3,
                                   V v3, K k4, V v4, K k5, V v5) {
    Map<K, V> map = new LinkedHashMap<>(10);
    map.put(k0, v0);
    map.put(k1, v1);
    map.put(k2, v2);
    map.put(k3, v3);
    map.put(k4, v4);
    map.put(k5, v5);
    return map;
}

public static <K, V> Map<K, V> map(K k0, V v0, K k1, V v1, K k2, V v2, K k3,
                                   V v3, K k4, V v4, K k5, V v5, K k6, V v6) {
    Map<K, V> map = new LinkedHashMap<>(10);
    map.put(k0, v0);
    map.put(k1, v1);
    map.put(k2, v2);
    map.put(k3, v3);
    map.put(k4, v4);
    map.put(k5, v5);
    map.put(k6, v6);
    return map;
}

public static <K, V> Map<K, V> map(K k0, V v0, K k1, V v1, K k2, V v2, K k3,
                                   V v3, K k4, V v4, K k5, V v5, K k6, V v6, K k7, V v7) {
    Map<K, V> map = new LinkedHashMap<>(10);
    map.put(k0, v0);
    map.put(k1, v1);
    map.put(k2, v2);
    map.put(k3, v3);
    map.put(k4, v4);
    map.put(k5, v5);
    map.put(k6, v6);
    map.put(k7, v7);
    return map;
}

public static <K, V> Map<K, V> map(K k0, V v0, K k1, V v1, K k2, V v2, K k3,
                                   V v3, K k4, V v4, K k5, V v5, K k6, V v6, K k7, V v7, K k8, V v8) {
    Map<K, V> map = new LinkedHashMap<>(10);
    map.put(k0, v0);
    map.put(k1, v1);
    map.put(k2, v2);
    map.put(k3, v3);
    map.put(k4, v4);
    map.put(k5, v5);
    map.put(k6, v6);
    map.put(k7, v7);
    map.put(k8, v8);
    return map;
}

public static <K, V> Map<K, V> map(K k0, V v0, K k1, V v1, K k2, V v2, K k3,
                                   V v3, K k4, V v4, K k5, V v5, K k6, V v6, K k7, V v7, K k8, V v8,
                                   K k9, V v9) {
    Map<K, V> map = new LinkedHashMap<>(10);
    map.put(k0, v0);
    map.put(k1, v1);
    map.put(k2, v2);
    map.put(k3, v3);
    map.put(k4, v4);
    map.put(k5, v5);
    map.put(k6, v6);
    map.put(k7, v7);
    map.put(k8, v8);
    map.put(k9, v9);
    return map;
}

公共静态地图（kk0，v0）{
Map Map=newlinkedhashmap（10）；
map.put（k0，v0）；
返回图；
}
公共静态地图（kk0，v0，kk1，v1）{
Map Map=newlinkedhashmap（10）；
map.put（k0，v0）；
map.put（k1，v1）；
返回图；
}
公共静态地图（kk0，v0，kk1，v1，kk2，v2）{
Map Map=newlinkedhashmap（10）；
map.put（k0，v0）；
map.put（k1，v1）；
地图放置（k2，v2）；
返回图；
}
公共静态地图（kk0，v0，kk1，v1，kk2，v2，kk3，
V（v3）{
Map Map=newlinkedhashmap（10）；
map.put（k0，v0）；
map.put（k1，v1）；
地图放置（k2，v2）；
map.put（k3，v3）；
返回图；
}
公共静态地图（kk0，v0，kk1，v1，kk2，v2，kk3，
v3，k4，v4）{
Map Map=newlinkedhashmap（10）；
map.put（k0，v0）；
map.put（k1，v1）；
地图放置（k2，v2）；
map.put（k3，v3）；
map.put（k4，v4）；
返回图；
}
公共静态地图（kk0，v0，kk1，v1，kk2，v2，kk3，
v3、k4、v4、k5、v5）{
Map Map=newlinkedhashmap（10）；
map.put（k0，v0）；
map.put（k1，v1）；
地图放置（k2，v2）；
map.put（k3，v3）；
map.put（k4，v4）；
map.put（k5，v5）；
返回图；
}
公共静态地图（kk0，v0，kk1，v1，kk2，v2，kk3，
v3、k4、v4、k5、v5、k6、v6）{
Map Map=newlinkedhashmap（10）；
map.put（k0，v0）；
map.put（k1，v1）；
地图放置（k2，v2）；
map.put（k3，v3）；
map.put（k4，v4）；
map.put（k5，v5）；
map.put（k6，v6）；
返回图；
}
公共静态地图（kk0，v0，kk1，v1，kk2，v2，kk3，
v3，KK4，v4，k5，v5，k6，v6，k7，v7）{
Map Map=newlinkedhashmap（10）；
map.put（k0，v0）；
map.put（k1，v1）；
地图放置（k2，v2）；
map.put（k3，v3）；
map.put（k4，v4）；
map.put（k5，v5）；
map.put（k6，v6）；
地图放置（k7，v7）；
返回图；
}
公共静态地图（kk0，v0，kk1，v1，kk2，v2，kk3，
v3、k4、v4、k5、v5、k6、v6、k7、v7、k8、v8）{
Map Map=newlinkedhashmap（10）；
map.put（k0，v0）；
map.put（k1，v1）；
地图放置（k2，v2）；
map.put（k3，v3）；
map.put（k4，v4）；
map.put（k5，v5）；
map.put（k6，v6）；
地图放置（k7，v7）；
map.put（k8，v8）；
返回图；
}
公共静态地图（kk0，v0，kk1，v1，kk2，v2，kk3，
v3，KK4，v4，k5，v5，k6，v6，k7，v7，k8，v8，
k9，v9）{
Map Map=newlinkedhashmap（10）；
map.put（k0，v0）；
map.put（k1，v1）；
地图放置（k2，v2）；
map.put（k3，v3）；
map.put（k4，v4）；
map.put（k5，v5）；
map.put（k6，v6）；
地图放置（k7，v7）；
map.put（k8，v8）；
地图放置（k9，v9）；
返回图；
}

亚太地区可能重复使用

/**
 * Turns a single nibble into an ascii HEX digit.
 *
 * @param nibble the nibble to encode.
 *
 * @return the encoded nibble (1/2 byte).
 */
protected static int encodeNibbleToHexAsciiCharByte( final int nibble ) {

    switch ( nibble ) {
        case 0x00:
        case 0x01:
        case 0x02:
        case 0x03:
        case 0x04:
        case 0x05:
        case 0x06:
        case 0x07:
        case 0x08:
        case 0x09:
            return nibble + 0x30; // 0x30('0') - 0x39('9')
        case 0x0A:
        case 0x0B:
        case 0x0C:
        case 0x0D:
        case 0x0E:
        case 0x0F:
            return nibble + 0x57; // 0x41('a') - 0x46('f')
        default:
            die("illegal nibble: " + nibble);
            return -1;
    }
}


/**
 * Turn a single bytes into two hex character representation.
 *
 * @param decoded the byte to encode.
 * @param encoded the array to which each encoded nibbles are now ascii hex representations.
 */
public static void encodeByteIntoTwoAsciiCharBytes(final int decoded, final byte[] encoded) {

    Objects.requireNonNull ( encoded );

    boolean ok = true;


    ok |= encoded.length == 2 || die("encoded array must be 2");


    encoded[0] = (byte) encodeNibbleToHexAsciiCharByte((decoded >> 4) & 0x0F);
    encoded[1] = (byte) encodeNibbleToHexAsciiCharByte(decoded & 0x0F);
}

    manageContentTypeHeaders ( "application/x-www-form-urlencoded",
            StandardCharsets.UTF_8.name (), connection );

...

private static void manageContentTypeHeaders(String contentType, String charset, URLConnection connection) {
    connection.setRequestProperty("Accept-Charset", charset == null ? StandardCharsets.UTF_8.displayName() : charset);
    if (contentType!=null && !contentType.isEmpty()) {
        connection.setRequestProperty("Content-Type", contentType);
    }
}

    manageHeaders(headers, connection);

...

private static void manageHeaders(Map<String, ?> headers, URLConnection connection) {
    if (headers != null) {
        for (Map.Entry<String, ?> entry : headers.entrySet()) {
            connection.setRequestProperty(entry.getKey(), entry.getValue().toString());
        }
    }
}

    int len = buf.len ();
    IO.write(connection.getOutputStream(),
            new String(buf.readForRecycle (), 0, len, StandardCharsets.UTF_8), IO.DEFAULT_CHARSET);

public static void write ( OutputStream out, String content, Charset charset ) {

    try ( OutputStream o = out ) {
        o.write ( content.getBytes ( charset ) );
    } catch ( Exception ex ) {
        Exceptions.handle ( ex );
    }

}

public static <K, V> Map<K, V> map(K k0, V v0) {
    Map<K, V> map = new LinkedHashMap<>(10);
    map.put(k0, v0);
    return map;
}

public static <K, V> Map<K, V> map(K k0, V v0, K k1, V v1) {
    Map<K, V> map = new LinkedHashMap<>(10);
    map.put(k0, v0);
    map.put(k1, v1);
    return map;
}


public static <K, V> Map<K, V> map(K k0, V v0, K k1, V v1, K k2, V v2) {
    Map<K, V> map = new LinkedHashMap<>(10);
    map.put(k0, v0);
    map.put(k1, v1);
    map.put(k2, v2);
    return map;
}

public static <K, V> Map<K, V> map(K k0, V v0, K k1, V v1, K k2, V v2, K k3,
                                   V v3) {
    Map<K, V> map = new LinkedHashMap<>(10);
    map.put(k0, v0);
    map.put(k1, v1);
    map.put(k2, v2);
    map.put(k3, v3);
    return map;
}

public static <K, V> Map<K, V> map(K k0, V v0, K k1, V v1, K k2, V v2, K k3,
                                   V v3, K k4, V v4) {
    Map<K, V> map = new LinkedHashMap<>(10);
    map.put(k0, v0);
    map.put(k1, v1);
    map.put(k2, v2);
    map.put(k3, v3);
    map.put(k4, v4);
    return map;
}

public static <K, V> Map<K, V> map(K k0, V v0, K k1, V v1, K k2, V v2, K k3,
                                   V v3, K k4, V v4, K k5, V v5) {
    Map<K, V> map = new LinkedHashMap<>(10);
    map.put(k0, v0);
    map.put(k1, v1);
    map.put(k2, v2);
    map.put(k3, v3);
    map.put(k4, v4);
    map.put(k5, v5);
    return map;
}

public static <K, V> Map<K, V> map(K k0, V v0, K k1, V v1, K k2, V v2, K k3,
                                   V v3, K k4, V v4, K k5, V v5, K k6, V v6) {
    Map<K, V> map = new LinkedHashMap<>(10);
    map.put(k0, v0);
    map.put(k1, v1);
    map.put(k2, v2);
    map.put(k3, v3);
    map.put(k4, v4);
    map.put(k5, v5);
    map.put(k6, v6);
    return map;
}

public static <K, V> Map<K, V> map(K k0, V v0, K k1, V v1, K k2, V v2, K k3,
                                   V v3, K k4, V v4, K k5, V v5, K k6, V v6, K k7, V v7) {
    Map<K, V> map = new LinkedHashMap<>(10);
    map.put(k0, v0);
    map.put(k1, v1);
    map.put(k2, v2);
    map.put(k3, v3);
    map.put(k4, v4);
    map.put(k5, v5);
    map.put(k6, v6);
    map.put(k7, v7);
    return map;
}

public static <K, V> Map<K, V> map(K k0, V v0, K k1, V v1, K k2, V v2, K k3,
                                   V v3, K k4, V v4, K k5, V v5, K k6, V v6, K k7, V v7, K k8, V v8) {
    Map<K, V> map = new LinkedHashMap<>(10);
    map.put(k0, v0);
    map.put(k1, v1);
    map.put(k2, v2);
    map.put(k3, v3);
    map.put(k4, v4);
    map.put(k5, v5);
    map.put(k6, v6);
    map.put(k7, v7);
    map.put(k8, v8);
    return map;
}

public static <K, V> Map<K, V> map(K k0, V v0, K k1, V v1, K k2, V v2, K k3,
                                   V v3, K k4, V v4, K k5, V v5, K k6, V v6, K k7, V v7, K k8, V v8,
                                   K k9, V v9) {
    Map<K, V> map = new LinkedHashMap<>(10);
    map.put(k0, v0);
    map.put(k1, v1);
    map.put(k2, v2);
    map.put(k3, v3);
    map.put(k4, v4);
    map.put(k5, v5);
    map.put(k6, v6);
    map.put(k7, v7);
    map.put(k8, v8);
    map.put(k9, v9);
    return map;
}