WS - play.api.libs.ws.WS

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

Usage example:

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:

implicit val client = new NingWSClient(builder.build())
WS.url("http://example.com/feed").get()

Or call the client directly:

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

val configuration = play.api.Configuration(ConfigFactory.parseString(
"""
  |ws.ssl.trustManager = ...
""".stripMargin))
val parser = new DefaultWSConfigParser(configuration, Play.current.classloader)
val builder = new NingAsyncHttpClientConfigBuilder(parser.parse())
val secureClient: WSClient = new NingWSClient(builder.build())
val response = secureClient.url("https://secure.com").get()

Note that the resolution of URL is done through the magnet pattern defined in WSRequestMagnet.

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

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 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:
```
import play.api.Play.current
val client = WS.client
```
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.ning.NingWSClient(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

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.
```
import play.api.Play.current
WS.url("http://localhost/").get()
```
url
the URL to request
app
the implicit application to use.
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]

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 client(implicit app: Application): WSClient

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

def url(url: String)(implicit app: Application): 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

Inherited from AnyRef

Inherited from Any

Ungrouped