Other HTTP libraries exist that fill that gap allowing extensive customisation including potentially
invalid requests.

Example Limitations

* Does not allow GET with a body.
* Cache is not an interface with alternative implementations.

Get a URL
---------

This program downloads a URL and prints its contents as a string. [Full source][get_example].

```java

                    // cache
                    putResultDataBody(dataMap, fessConfig.getIndexFieldCache(), new String(InputStreamUtil.getBytes(is), charSet));
                    putResultDataBody(dataMap, fessConfig.getIndexFieldHasCache(), Constants.TRUE);
                } catch (final Exception e) {
                    logger.warn("Failed to write cache: sessionId={}, responseData={}", sessionId, responseData, e);

)

// startWithConds - map which indicates if a given condition supports starts-with policy operator
var startsWithConds = map[string]bool{
	"$acl":                     true,
	"$bucket":                  false,
	"$cache-control":           true,
	"$content-type":            true,
	"$content-disposition":     true,
	"$content-encoding":        true,
	"$expires":                 true,
	"$key":                     true,

        this.credentialsProvider = credentialsProvider;
    }

    /**
     * Sets the authentication cache.
     *
     * @param authCache The authentication cache
     */
    public void setAuthCache(final AuthCache authCache) {
        this.authCache = authCache;
    }

    /**
     * Sets the HTTP route planner.
     *

	},
	cli.StringFlag{
		Name:   "interface",
		Usage:  "bind to right VRF device for MinIO services",
		Hidden: true,
		EnvVar: "MINIO_INTERFACE",
	},
	cli.DurationFlag{
		Name:   "dns-cache-ttl",
		Usage:  "custom DNS cache TTL",
		Hidden: true,
		Value: func() time.Duration {
			if orchestrated {
				return 30 * time.Second
			}
			return 10 * time.Minute
		}(),
		EnvVar: "MINIO_DNS_CACHE_TTL",
	},

            }

            Map<String, Artifact> map = new HashMap<>();
            for (Artifact artifact : resolvedArtifacts) {
                /**
                 * MNG-6300: resolvedArtifacts can be cache result; this ensures reactor files are always up-to-date
                 * During lifecycle the Artifact.getFile() can change from target/classes to the actual jar.

                    .desc("Do not display transfer progress when downloading or uploading")
                    .get());
            options.addOption(Option.builder(CACHE_ARTIFACT_NOT_FOUND)
                    .longOpt("cache-artifact-not-found")
                    .hasArg()
                    .desc(
                            "Defines caching behaviour for 'not found' artifacts. Supported values are 'true' (default), 'false'.")

	"acl",
	"cors",
	"delete",
	"encryption",
	"legal-hold",
	"lifecycle",
	"location",
	"logging",
	"notification",
	"partNumber",
	"policy",
	"requestPayment",
	"response-cache-control",
	"response-content-disposition",
	"response-content-encoding",
	"response-content-language",
	"response-content-type",
	"response-expires",
	"retention",
	"select",
	"select-type",
	"tagging",

        lenient().when(mockDcerpcBinding.getEndpoint()).thenReturn(TEST_ENDPOINT);
        lenient().when(mockContext.getBufferCache()).thenReturn(mockBufferCache);

        // Setup buffer cache to return buffers for sendrecv operations
        lenient().when(mockBufferCache.getBuffer()).thenReturn(new byte[8192]);
    }

    /**
     * Helper method to create a DcerpcPipeHandle with injected mocks

      } catch (e: IOException) {
        carrier.noNewExchanges()
        responseBodyComplete(TRAILERS_RESPONSE_BODY_TRUNCATED)
        throw e
      }

    /**
     * Closes the cache entry and makes the socket available for reuse. This should be invoked when
     * the end of the body has been reached.
     */
    fun responseBodyComplete(trailers: Headers) {
      if (state == STATE_CLOSED) return