Ecosyste.ms: Awesome
An open API service indexing awesome lists of open source software.
https://github.com/scalaj/scalaj-http
Simple scala wrapper for HttpURLConnection. OAuth included.
https://github.com/scalaj/scalaj-http
http oauth scala
Last synced: 3 months ago
JSON representation
Simple scala wrapper for HttpURLConnection. OAuth included.
- Host: GitHub
- URL: https://github.com/scalaj/scalaj-http
- Owner: scalaj
- License: apache-2.0
- Archived: true
- Created: 2010-08-23T20:05:19.000Z (about 14 years ago)
- Default Branch: master
- Last Pushed: 2022-04-03T21:19:24.000Z (over 2 years ago)
- Last Synced: 2024-06-21T14:28:12.934Z (5 months ago)
- Topics: http, oauth, scala
- Language: Scala
- Homepage:
- Size: 630 KB
- Stars: 974
- Watchers: 43
- Forks: 121
- Open Issues: 28
-
Metadata Files:
- Readme: README.md
- Changelog: CHANGELOG.md
- License: LICENSE.txt
Awesome Lists containing this project
README
[](https://maven-badges.herokuapp.com/maven-central/org.scalaj/scalaj-http_2.12)
[](https://javadoc.io/doc/org.scalaj/scalaj-http_2.12)
[](https://app.fossa.io/projects/git%2Bgithub.com%2Fscalaj%2Fscalaj-http?ref=badge_shield)
# THIS LIBRARY IS DEPRECATED
As of April 2022 there are many supported options for making HTTP calls in scala:
- [sttp](https://github.com/softwaremill/sttp) or [http4s](https://github.com/http4s/http4s) might be good scala first options
- The native [HttpClient](https://docs.oracle.com/en/java/javase/12/docs/api/java.net.http/java/net/http/HttpClient.html) library if you're using JDK 11+ and want minimal deps
If you've inherited a codebase that's using this library, I would suggest just copying the source code
(it's only four files, and no depedencies) and make whatever fixes/changes you want.
Good luck!
# Simplified Http
This is a fully featured http client for Scala which wraps [java.net.HttpURLConnection](https://docs.oracle.com/javase/8/docs/api/java/net/HttpURLConnection.html)
Features:
* Zero dependencies
* Cross compiled for Scala 2.10, 2.11, 2.12, and 2.13-M3
* OAuth v1 request signing
* Automatic support of gzip and deflate encodings from server
* Easy to add querystring or form params. URL encoding is handled for you.
* Multipart file uploads
Non-Features:
* Async execution
* The library is thread safe. HttpRequest and HttpResponse are immutable. So it should be easy to wrap in an execution framework of your choice.
Works in Google AppEngine and Android environments.
Big differences:
* Executing the request always returns a HttpResponse[T] instance that contains the response-code, headers, and body
* Exceptions are no longer thrown for 4xx and 5xx response codes. Yay!
* Http(url) is the starting point for every type of request (post, get, multi, etc)
* You can easily create your own singleton instance to set your own defaults (timeouts, proxies, etc)
* Sends "Accept-Encoding: gzip,deflate" request header and decompresses based on Content-Encoding (configurable)
* Redirects are no longer followed by default. Use .option(HttpOptions.followRedirects(true)) to change.
## Installation
### in your build.sbt
```scala
libraryDependencies += "org.scalaj" %% "scalaj-http" % "2.4.2"
```
### maven
```xml
org.scalaj
scalaj-http_${scala.version}
2.4.2
```
If you're including this in some other public library. Do your users a favor and change the fully qualified name
so they don't have version conflicts if they're using a different version of this library.
The easiest way to do that is just to copy the source into your project :)
## Usage
### Simple Get
```scala
import scalaj.http._
val response: HttpResponse[String] = Http("http://foo.com/search").param("q","monkeys").asString
response.body
response.code
response.headers
response.cookies
```
### Immutable Request
```Http(url)``` is just shorthand for a ```Http.apply``` which returns an immutable instance of ```HttpRequest```.
You can create a ```HttpRequest``` and reuse it:
```scala
val request: HttpRequest = Http("http://date.jsontest.com/")
val responseOne = request.asString
val responseTwo = request.asString
```
#### Additive Request
All the "modification" methods of a ```HttpRequest``` are actually returning a new instance. The param(s), option(s), header(s)
methods always add to their respective sets. So calling ```.headers(newHeaders)``` will return a ```HttpRequest``` instance
that has ```newHeaders``` appended to the previous ```req.headers```
### Simple form encoded POST
```scala
Http("http://foo.com/add").postForm(Seq("name" -> "jon", "age" -> "29")).asString
```
### OAuth v1 Dance and Request
*Note: the `.oauth(...)` call must be the last method called in the request construction*
```scala
import scalaj.http.{Http, Token}
val consumer = Token("key", "secret")
val response = Http("https://api.twitter.com/oauth/request_token").postForm(Seq("oauth_callback" -> "oob"))
.oauth(consumer).asToken
println("Go to https://api.twitter.com/oauth/authorize?oauth_token=" + response.body.key)
val verifier = Console.readLine("Enter verifier: ").trim
val accessToken = Http("https://api.twitter.com/oauth/access_token").postForm.
.oauth(consumer, response.body, verifier).asToken
println(Http("https://api.twitter.com/1.1/account/settings.json").oauth(consumer, accessToken.body).asString)
```
### Parsing the response
```scala
Http("http://foo.com").{asString, asBytes, asParams}
```
Those methods will return an ```HttpResponse[String | Array[Byte] | Seq[(String, String)]]``` respectively
## Advanced Usage Examples
### Parse the response InputStream directly
```scala
val response: HttpResponse[Map[String,String]] = Http("http://foo.com").execute(parser = {inputStream =>
Json.parse[Map[String,String]](inputStream)
})
```
### Post raw Array[Byte] or String data and get response code
```scala
Http(url).postData(data).header("content-type", "application/json").asString.code
```
### Post multipart/form-data
```scala
Http(url).postMulti(MultiPart("photo", "headshot.png", "image/png", fileBytes)).asString
```
You can also stream uploads and get a callback on progress:
```scala
Http(url).postMulti(MultiPart("photo", "headshot.png", "image/png", inputStream, bytesInStream,
lenWritten => {
println(s"Wrote $lenWritten bytes out of $bytesInStream total for headshot.png")
})).asString
```
### Stream a chunked transfer response (like an event stream)
```scala
Http("http://httpbin.org/stream/20").execute(is => {
scala.io.Source.fromInputStream(is).getLines().foreach(println)
})
```
_note that you may have to wrap in a while loop and set a long readTimeout to stay connected_
### Send https request to site with self-signed or otherwise shady certificate
```scala
Http("https://localhost/").option(HttpOptions.allowUnsafeSSL).asString
```
### Do a HEAD request
```scala
Http(url).method("HEAD").asString
```
### Custom connect and read timeouts
_These are set to 1000 and 5000 milliseconds respectively by default_
```scala
Http(url).timeout(connTimeoutMs = 1000, readTimeoutMs = 5000).asString
```
### Get request via a proxy
```scala
val response = Http(url).proxy(proxyHost, proxyPort).asString
```
### Other custom options
The ```.option()``` method takes a function of type ```HttpURLConnection => Unit``` so
you can manipulate the connection in whatever way you want before the request executes.
### Change the Charset
By default, the charset for all param encoding and string response parsing is UTF-8. You
can override with charset of your choice:
```scala
Http(url).charset("ISO-8859-1").asString
```
### Create your own HttpRequest builder
You don't have to use the default Http singleton. Create your own:
```scala
object MyHttp extends BaseHttp (
proxyConfig = None,
options = HttpConstants.defaultOptions,
charset = HttpConstants.utf8,
sendBufferSize = 4096,
userAgent = "scalaj-http/1.0",
compress = true
)
```
### Full API documentation
[scaladocs here](https://javadoc.io/doc/org.scalaj/scalaj-http_2.12)
## Dealing with annoying java library issues
#### Overriding the `Access-Control, Content-Length, Content-Transfer-Encoding, Host, Keep-Alive, Origin, Trailer, Transfer-Encoding, Upgrade, Via` headers
Some of the headers are locked by the java library for "security" reasons and the behavior is that the library will just silently fail to set them. You can workaround by doing one of the following:
* Start your JVM with this command line parameter: `-Dsun.net.http.allowRestrictedHeaders=true`
* or, do this first thing at runtime: `System.setProperty("sun.net.http.allowRestrictedHeaders", "true")`
## License
[](https://app.fossa.io/projects/git%2Bgithub.com%2Fscalaj%2Fscalaj-http?ref=badge_large)