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
- Serializable
- Product
- Equals
- AnyRef
- Any
- Hide All
- Show All
- Public
- All
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[java.lang]
- Definition Classes
- AnyRef
- Annotations
- @native() @throws( ... )
-
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 = ...): 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[java.lang]
- Definition Classes
- AnyRef
- Annotations
- @throws( classOf[java.lang.Throwable] )
-
final
def
getClass(): Class[_]
- 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
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( ... )
-
final
def
wait(arg0: Long, arg1: Int): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws( ... )
-
final
def
wait(arg0: Long): Unit
- Definition Classes
- AnyRef
- Annotations
- @native() @throws( ... )
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