WS - play.api.libs.ws.WS

Asynchronous API to to query web services, as an http client.

Usage example:

class MyService @Inject() (ws: WSClient) {
  ws.url("http://example.com/feed").get()
  ws.url("http://example.com/item").post("content")
}

When greater flexibility is needed, you can also create clients explicitly and pass them into WS:

import play.api.libs.ws._
import play.api.libs.ws.ahc._
import akka.stream.Materializer
import play.api.ApplicationLifecycle
import javax.inject.Inject
import scala.concurrent.Future

class MyService @Inject() (lifecycle: ApplicationLifecycle)(implicit mat: Materializer) {
  private val client = new AhcWSClient(new AhcConfigBuilder().build())
  client.url("http://example.com/feed").get()
  lifecycle.addStopHook(() =>
    // Make sure you close the client after use, otherwise you'll leak threads and connections
    client.close()
    Future.successful(())
  }
}

Or call the client directly:

import com.typesafe.config.ConfigFactory
import play.api.libs.ws._
import play.api.libs.ws.ahc._

val configuration = play.api.Configuration(ConfigFactory.parseString(
"""
  |play.ws.ssl.trustManager = ...
""".stripMargin))
val parser = new DefaultWSConfigParser(configuration, app.classloader)
val builder = new AhcConfigBuilder(parser.parse())
val secureClient: WSClient = new AhcWSClient(builder.build())
val response = secureClient.url("https://secure.com").get()
secureClient.close() // must explicitly manage lifecycle

The value returned is a Future[WSResponse], and you should use Play's asynchronous mechanisms to use this response.

Annotations: @deprecated
Deprecated: (Since version 2.5.0) Inject WSClient into your component
Source: WS.scala

Linear Supertypes

AnyRef, Any

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
final def asInstanceOf[T0]: T0

Definition Classes
Any
def clientUrl(url: String)(implicit client: WSClient): WSRequest

Prepares a new request using an implicit client.
Prepares a new request using an implicit client. The client must be in scope and configured, i.e.
```
implicit val sslClient = new play.api.libs.ws.ahc.AhcWSClient(sslBuilder.build())
WS.clientUrl("http://example.com/feed")
```
url
the URL to request
client
the client to use to make the request.
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
final def eq(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def equals(arg0: Any): Boolean

Definition Classes
AnyRef → Any
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
def hashCode(): Int

Definition Classes
AnyRef → Any
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
def toString(): String

Definition Classes
AnyRef → Any

def url(magnet: WSRequestMagnet): WSRequest

Prepares a new request using a provided magnet.

Prepares a new request using a provided magnet. This method gives you the ability to create your own URL implementations at the cost of some complexity.

object PairMagnet {
  implicit def fromPair(pair: Pair[WSClient, java.net.URL]) =
    new WSRequestHolderMagnet {
      def apply(): WSRequestHolder = {
        val (client, netUrl) = pair
        client.url(netUrl.toString)
      }
   }
}
import scala.language.implicitConversions
val client = WS.client
val exampleURL = new java.net.URL("http://example.com")
WS.url(client -> exampleURL).get()

magnet: a magnet pattern.

See also: The magnet pattern

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
@throws( ... )
def wsapi(implicit app: Application): WSAPI

Attributes
protected[play]

Deprecated Value Members

def client(implicit app: Application): WSClient

Retrieves or creates underlying HTTP client.
Retrieves or creates underlying HTTP client. Note that due to the Plugin architecture, an implicit application must be in scope. Most of the time you will want the current app:
```
val client = WS.client(app)
```
Annotations
@deprecated
Deprecated
(Since version 2.5.0) Inject WSClient into your component
def url(url: String)(implicit app: Application): WSRequest

Prepares a new request using an implicit application.
Prepares a new request using an implicit application. This creates a default client, which you can then use to construct a request.
```
WS.url("http://localhost/")(app).get()
```
url
the URL to request
app
the implicit application to use.

Annotations
@deprecated
Deprecated
(Since version 2.5.0) Inject WSClient into your component

WS

Related Doc: package ws

object WS

Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

final def asInstanceOf[T0]: T0

def clientUrl(url: String)(implicit client: WSClient): WSRequest

def clone(): AnyRef

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def finalize(): Unit

final def getClass(): Class[_]

def hashCode(): Int

final def isInstanceOf[T0]: Boolean

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

final def synchronized[T0](arg0: ⇒ T0): T0

def toString(): String

def url(magnet: WSRequestMagnet): WSRequest

final def wait(): Unit

final def wait(arg0: Long, arg1: Int): Unit

final def wait(arg0: Long): Unit

def wsapi(implicit app: Application): WSAPI

Deprecated Value Members

def client(implicit app: Application): WSClient

def url(url: String)(implicit app: Application): WSRequest

Inherited from AnyRef

Inherited from Any

Ungrouped