case class HttpRequest(url: String, method: String, connectFunc: HttpExec, params: Seq[(String, String)], headers: Seq[(String, String)], options: Seq[HttpOption], proxyConfig: Option[Proxy], charset: String, sendBufferSize: Int, urlBuilder: (HttpRequest) => String, compress: Boolean, digestCreds: Option[(String, String)]) extends Product with Serializable
Immutable builder for creating an http request
This is the workhorse of the scalaj-http library.
You shouldn't need to construct this manually. Use scalaj.http.Http.apply to get an instance
The params, headers and options methods are all additive. They will always add things to the request. If you want to replace those things completely, you can do something like
.copy(params=newparams)
- Alphabetic
- By Inheritance
- HttpRequest
- Serializable
- Product
- Equals
- AnyRef
- Any
- Hide All
- Show All
- Public
- Protected
Instance Constructors
- new HttpRequest(url: String, method: String, connectFunc: HttpExec, params: Seq[(String, String)], headers: Seq[(String, String)], options: Seq[HttpOption], proxyConfig: Option[Proxy], charset: String, sendBufferSize: Int, urlBuilder: (HttpRequest) => String, compress: Boolean, digestCreds: Option[(String, String)])
Value Members
- final def !=(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
- final def ##: Int
- Definition Classes
- AnyRef → Any
- final def ==(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
- def asBytes: HttpResponse[Array[Byte]]
Execute this request and parse http body as Array[Byte]
- final def asInstanceOf[T0]: T0
- Definition Classes
- Any
- def asParamMap: HttpResponse[Map[String, String]]
Execute this request and parse http body as query string key-value pairs
- def asParams: HttpResponse[Seq[(String, String)]]
Execute this request and parse http body as query string key-value pairs
- def asString: HttpResponse[String]
Execute this request and parse http body as String using server charset or configured charset
- def asToken: HttpResponse[Token]
Execute this request and parse http body as a querystring containing oauth_token and oauth_token_secret tupple
- def auth(user: String, password: String): HttpRequest
Add a standard basic authorization header
- def charset(cs: String): HttpRequest
Change the charset used to encode the request and decode the response.
Change the charset used to encode the request and decode the response. UTF-8 by default
- val charset: String
- def clone(): AnyRef
- Attributes
- protected[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.CloneNotSupportedException]) @native()
- def compress(c: Boolean): HttpRequest
Should HTTP compression be used If true, Accept-Encoding: gzip,deflate will be sent with request.
Should HTTP compression be used If true, Accept-Encoding: gzip,deflate will be sent with request. If the server response with Content-Encoding: (gzip|deflate) the client will automatically handle decompression
This is on by default
- c
should compress
- val compress: Boolean
- val connectFunc: HttpExec
- def cookie(ck: HttpCookie): HttpRequest
Add Cookie header to the request
- def cookie(name: String, value: String): HttpRequest
Add Cookie header to the request
- def cookies(cks: Seq[HttpCookie]): HttpRequest
Add multiple cookies to the request.
Add multiple cookies to the request. Usefull for round tripping cookies from HttpResponse.cookies
- def digestAuth(user: String, password: String): HttpRequest
Add digest authentication credentials
- val digestCreds: Option[(String, String)]
- final def eq(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
- def exec[T](parser: (Int, Map[String, IndexedSeq[String]], InputStream) => T): HttpResponse[T]
Executes this request
Executes this request
This is a power user method for parsing the response body. The parser function will be passed the response code, response headers and the InputStream
- T
the type returned by the input stream parser
- parser
function to process the response body InputStream
- def execute[T](parser: (InputStream) => T = (is: InputStream) => HttpConstants.readString(is, charset)): HttpResponse[T]
Executes this request
Executes this request
Keep in mind that if you're parsing the response to something other than String, you may hit parsing error if the server responds with a different content type for error cases.
- T
the type returned by the input stream parser
- parser
function to process the response body InputStream. Will be used for all response codes
- def finalize(): Unit
- Attributes
- protected[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.Throwable])
- final def getClass(): Class[_ <: AnyRef]
- Definition Classes
- AnyRef → Any
- Annotations
- @native()
- def header(key: String, value: String): HttpRequest
Add a http header to the request
- def headers(h: (String, String), rest: (String, String)*): HttpRequest
Add http headers to the request
- def headers(h: Seq[(String, String)]): HttpRequest
Add http headers to the request
- def headers(h: Map[String, String]): HttpRequest
Add http headers to the request
- val headers: Seq[(String, String)]
- final def isInstanceOf[T0]: Boolean
- Definition Classes
- Any
- def method(m: String): HttpRequest
Change the http request method.
Change the http request method. The library will allow you to set this to whatever you want. If you want to do a POST, just use the postData, postForm, or postMulti methods. If you want to setup your request as a form, data or multi request, but want to change the method type, call this method after the post method:
Http(url).postData(dataBytes).method("PUT").asString
- val method: String
- final def ne(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
- final def notify(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native()
- final def notifyAll(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native()
- def oauth(consumer: Token, token: Option[Token], verifier: Option[String]): HttpRequest
OAuth v1 sign the request with with both the consumer and client token and a verifier
- def oauth(consumer: Token, token: Token, verifier: String): HttpRequest
OAuth v1 sign the request with with both the consumer and client token and a verifier
- def oauth(consumer: Token, token: Token): HttpRequest
OAuth v1 sign the request with with both the consumer and client token
- def oauth(consumer: Token): HttpRequest
OAuth v1 sign the request with the consumer token
- def option(o: HttpOption): HttpRequest
Entry point for modifying the java.net.HttpURLConnection before the request is executed
- def options(o: HttpOption, rest: HttpOption*): HttpRequest
Entry point for modifying the java.net.HttpURLConnection before the request is executed
- def options(o: Seq[HttpOption]): HttpRequest
Entry point for modifying the java.net.HttpURLConnection before the request is executed
- val options: Seq[HttpOption]
- def param(key: String, value: String): HttpRequest
Add a param to the GET querystring or POST form request
- def params(p: (String, String), rest: (String, String)*): HttpRequest
Add params to the GET querystring or POST form request
- def params(p: Seq[(String, String)]): HttpRequest
Add params to the GET querystring or POST form request
- def params(p: Map[String, String]): HttpRequest
Add params to the GET querystring or POST form request
- val params: Seq[(String, String)]
- def postData(data: Array[Byte]): HttpRequest
Raw byte data POST request
- def postData(data: String): HttpRequest
Raw data POST request.
Raw data POST request. String bytes written out using configured charset
- def postForm(params: Seq[(String, String)]): HttpRequest
Standard form POST request and set some parameters.
Standard form POST request and set some parameters. Same as .postForm.params(params)
- def postForm: HttpRequest
Standard form POST request
- def postMulti(parts: MultiPart*): HttpRequest
Multipart POST request.
Multipart POST request.
This is probably what you want if you need to upload a mix of form data and binary data (like a photo)
- def productElementNames: Iterator[String]
- Definition Classes
- Product
- def proxy(proxy: Proxy): HttpRequest
Send request via a proxy
- def proxy(host: String, port: Int, proxyType: Type): HttpRequest
Send request via a proxy.
Send request via a proxy. You choose the type (HTTP or SOCKS)
- def proxy(host: String, port: Int): HttpRequest
Send request via a standard http proxy
- def proxyAuth(user: String, password: String): HttpRequest
Add a proxy basic authorization header
- val proxyConfig: Option[Proxy]
- def put(data: Array[Byte]): HttpRequest
Raw byte data PUT request
- def put(data: String): HttpRequest
Raw data PUT request.
Raw data PUT request. String bytes written out using configured charset
- def sendBufferSize(numBytes: Int): HttpRequest
The buffer size to use when sending Multipart posts
- val sendBufferSize: Int
- final def synchronized[T0](arg0: => T0): T0
- Definition Classes
- AnyRef
- def timeout(connTimeoutMs: Int, readTimeoutMs: Int): HttpRequest
The socket connection and read timeouts in milliseconds.
The socket connection and read timeouts in milliseconds. Defaults are 1000 and 5000 respectively
- val url: String
- val urlBuilder: (HttpRequest) => String
- final def wait(): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.InterruptedException])
- final def wait(arg0: Long, arg1: Int): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.InterruptedException])
- final def wait(arg0: Long): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.InterruptedException]) @native()
Simple http request library. Makes it easy to issue an http request and get a result.
Overview
The main entry point is the scalaj.http.Http singleton. Calling Http(url) will return an instance of scalaj.http.HttpRequest which you can use to build up your request. Execute the request by calling one of the asXXX methods and get a scalaj.http.HttpResponse which will contain the responseCode, body and response headers.
Usage Example