ResponseBody (OkHttp 3.14.0 API)

java.lang.Object
- okhttp3.ResponseBody

All Implemented Interfaces:

Closeable, AutoCloseable
```
public abstract class ResponseBody
extends Object
implements Closeable
```
A one-shot stream from the origin server to the client application with the raw bytes of the response body. Each response body is supported by an active connection to the webserver. This imposes both obligations and limits on the client application.
The response body must be closed.
Each response body is backed by a limited resource like a socket (live network responses) or an open file (for cached responses). Failing to close the response body will leak resources and may ultimately cause the application to slow down or crash.
Both this class and Response implement Closeable. Closing a response simply closes its response body. If you invoke Call.execute() or implement Callback.onResponse(okhttp3.Call, okhttp3.Response) you must close this body by calling any of the following methods:
- Response.close()
- Response.body().close()
- Response.body().source().close()
- Response.body().charStream().close()
- Response.body().byteStream().close()
- Response.body().bytes()
- Response.body().string()
There is no benefit to invoking multiple close() methods for the same response body.
For synchronous calls, the easiest way to make sure a response body is closed is with a try block. With this structure the compiler inserts an implicit finally clause that calls close() for you.
```
   

   Call call = client.newCall(request);
   try (Response response = call.execute()) {
     ... // Use the response.
   }
 
```
You can use a similar block for asynchronous calls:
```
   

   Call call = client.newCall(request);
   call.enqueue(new Callback() {
     public void onResponse(Call call, Response response) throws IOException {
       try (ResponseBody responseBody = response.body()) {
         ... // Use the response.
       }
     }

     public void onFailure(Call call, IOException e) {
       ... // Handle the failure.
     }
   });
 
```
These examples will not work if you're consuming the response body on another thread. In such cases the consuming thread must call close() when it has finished reading the response body.
The response body can be consumed only once.

This class may be used to stream very large responses. For example, it is possible to use this class to read a response that is larger than the entire memory allocated to the current process. It can even stream a response larger than the total storage on the current device, which is a common requirement for video streaming applications.
Because this class does not buffer the full response in memory, the application may not re-read the bytes of the response. Use this one shot to read the entire response into memory with bytes() or string(). Or stream the response with either source(), byteStream(), or charStream().

Constructor Summary

Constructors
Constructor and Description

ResponseBody()

Constructors
Constructor and Description
`ResponseBody()`

Method Summary

All Methods Static Methods Instance Methods Abstract Methods Concrete Methods
Modifier and Type	Method and Description
`byte[]`	`bytes()` Returns the response as a byte array.
`InputStream`	`byteStream()`
`Reader`	`charStream()` Returns the response as a character stream.
`void`	`close()`
`abstract long`	`contentLength()` Returns the number of bytes in that will returned by `bytes()`, or `byteStream()`, or -1 if unknown.
`abstract MediaType`	`contentType()`
`static ResponseBody`	`create(MediaType contentType, byte[] content)` Returns a new response body that transmits `content`.
`static ResponseBody`	`create(MediaType contentType, okio.ByteString content)` Returns a new response body that transmits `content`.
`static ResponseBody`	`create(MediaType contentType, long contentLength, okio.BufferedSource content)` Returns a new response body that transmits `content`.
`static ResponseBody`	`create(MediaType contentType, String content)` Returns a new response body that transmits `content`.
`abstract okio.BufferedSource`	`source()`
`String`	`string()` Returns the response as a string.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Constructor Detail
  - ResponseBody
```
public ResponseBody()
```
- Method Detail
  - contentType
```
@Nullable
public abstract MediaType contentType()
```
  - contentLength
```
public abstract long contentLength()
```
    Returns the number of bytes in that will returned by bytes(), or byteStream(), or -1 if unknown.
  - byteStream
```
public final InputStream byteStream()
```
  - source
```
public abstract okio.BufferedSource source()
```
  - bytes
```
public final byte[] bytes()
                   throws IOException
```
    Returns the response as a byte array.
    This method loads entire response body into memory. If the response body is very large this may trigger an OutOfMemoryError. Prefer to stream the response body if this is a possibility for your response.
    
    Throws:
    
    IOException
  - charStream
```
public final Reader charStream()
```
    Returns the response as a character stream.
    If the response starts with a Byte Order Mark (BOM), it is consumed and used to determine the charset of the response bytes.
    Otherwise if the response has a Content-Type header that specifies a charset, that is used to determine the charset of the response bytes.
    Otherwise the response bytes are decoded as UTF-8.
  - string
```
public final String string()
                    throws IOException
```
    Returns the response as a string.
    If the response starts with a Byte Order Mark (BOM), it is consumed and used to determine the charset of the response bytes.
    Otherwise if the response has a Content-Type header that specifies a charset, that is used to determine the charset of the response bytes.
    Otherwise the response bytes are decoded as UTF-8.
    This method loads entire response body into memory. If the response body is very large this may trigger an OutOfMemoryError. Prefer to stream the response body if this is a possibility for your response.
    
    Throws:
    
    IOException
  - close
```
public void close()
```
    Specified by:
    
    close in interface Closeable
    
    Specified by:
    
    close in interface AutoCloseable
  - create
```
public static ResponseBody create(@Nullable
                                  MediaType contentType,
                                  String content)
```
    Returns a new response body that transmits content. If contentType is non-null and lacks a charset, this will use UTF-8.
  - create
```
public static ResponseBody create(@Nullable
                                  MediaType contentType,
                                  byte[] content)
```
    Returns a new response body that transmits content.
  - create
```
public static ResponseBody create(@Nullable
                                  MediaType contentType,
                                  okio.ByteString content)
```
    Returns a new response body that transmits content.
  - create
```
public static ResponseBody create(@Nullable
                                  MediaType contentType,
                                  long contentLength,
                                  okio.BufferedSource content)
```
    Returns a new response body that transmits content.

Class ResponseBody

The response body must be closed.

The response body can be consumed only once.

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

ResponseBody

Method Detail

contentType

contentLength

byteStream

source

bytes

charStream

string

close

create

create

create

create