BinaryData (Azure SDK for Java Reference Documentation)

java.lang.Object
- com.azure.core.util.BinaryData

public final class BinaryData
extends Object

This class is an abstraction for the many ways binary data can be represented.

BinaryData can be created from an InputStream, a Flux of ByteBuffer, a String, an Object, or a byte array.

Immutable data

BinaryData copies data on construction making it immutable. Various APIs are provided to get data out of BinaryData, they all start with the 'to' prefix, for example BinaryData.toBytes().

Create an instance from a byte array

 final byte[] data = "Some Data".getBytes(StandardCharsets.UTF_8);
 BinaryData binaryData = BinaryData.fromBytes(data);
 System.out.println(new String(binaryData.toBytes(), StandardCharsets.UTF_8));

Create an instance from a String

 final String data = "Some Data";
 // Following will use default character set as StandardCharsets.UTF_8
 BinaryData binaryData = BinaryData.fromString(data);
 System.out.println(binaryData.toString());

Create an instance from an InputStream

 final ByteArrayInputStream inputStream = new ByteArrayInputStream("Some Data".getBytes(StandardCharsets.UTF_8));
 BinaryData binaryData = BinaryData.fromStream(inputStream);
 System.out.println(binaryData.toString());

Create an instance from an Object

 class Person {
     {@literal @}JsonProperty
     private String name;
 
     {@literal @}JsonSetter
     public Person setName(String name) {
         this.name = name;
         return this;
     }
 
     {@literal @}JsonGetter
     public String getName() {
         return name;
     }
 }
 final Person data = new Person().setName("John");
 
 // Provide your custom serializer or use Azure provided serializers.
 // https://mvnrepository.com/artifact/com.azure/azure-core-serializer-json-jackson or
 // https://mvnrepository.com/artifact/com.azure/azure-core-serializer-json-gson
 BinaryData binaryData = BinaryData.fromObject(data);
 
 System.out.println(binaryData.toString());

See Also:: ObjectSerializer, JsonSerializer, More about serialization

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`static BinaryData`	`fromBytes(byte[] data)` Creates an instance of `BinaryData` from the given byte array.
`static Mono<BinaryData>`	`fromFlux(Flux<ByteBuffer> data)` Creates an instance of `BinaryData` from the given `Flux` of `ByteBuffer`.
`static BinaryData`	`fromObject(Object data)` Creates an instance of `BinaryData` by serializing the `Object` using the default `JsonSerializer`.
`static BinaryData`	`fromObject(Object data, ObjectSerializer serializer)` Creates an instance of `BinaryData` by serializing the `Object` using the passed `ObjectSerializer`.
`static Mono<BinaryData>`	`fromObjectAsync(Object data)` Creates an instance of `BinaryData` by serializing the `Object` using the default `JsonSerializer`.
`static Mono<BinaryData>`	`fromObjectAsync(Object data, ObjectSerializer serializer)` Creates an instance of `BinaryData` by serializing the `Object` using the passed `ObjectSerializer`.
`static BinaryData`	`fromStream(InputStream inputStream)` Creates an instance of `BinaryData` from the given `InputStream`.
`static Mono<BinaryData>`	`fromStreamAsync(InputStream inputStream)` Creates an instance of `BinaryData` from the given `InputStream`.
`static BinaryData`	`fromString(String data)` Creates an instance of `BinaryData` from the given `String`.
`ByteBuffer`	`toByteBuffer()` Returns a read-only `ByteBuffer` representation of this `BinaryData`.
`byte[]`	`toBytes()` Returns a byte array representation of this `BinaryData`.
`<T> T`	`toObject(Class<T> clazz)` Returns an `Object` representation of this `BinaryData` by deserializing its data using the default `JsonSerializer`.
`<T> T`	`toObject(Class<T> clazz, ObjectSerializer serializer)` Returns an `Object` representation of this `BinaryData` by deserializing its data using the passed `ObjectSerializer`.
`<T> T`	`toObject(TypeReference<T> typeReference)` Returns an `Object` representation of this `BinaryData` by deserializing its data using the default `JsonSerializer`.
`<T> T`	`toObject(TypeReference<T> typeReference, ObjectSerializer serializer)` Returns an `Object` representation of this `BinaryData` by deserializing its data using the passed `ObjectSerializer`.
`<T> Mono<T>`	`toObjectAsync(Class<T> clazz)` Returns an `Object` representation of this `BinaryData` by deserializing its data using the default `JsonSerializer`.
`<T> Mono<T>`	`toObjectAsync(Class<T> clazz, ObjectSerializer serializer)` Returns an `Object` representation of this `BinaryData` by deserializing its data using the passed `ObjectSerializer`.
`<T> Mono<T>`	`toObjectAsync(TypeReference<T> typeReference)` Returns an `Object` representation of this `BinaryData` by deserializing its data using the default `JsonSerializer`.
`<T> Mono<T>`	`toObjectAsync(TypeReference<T> typeReference, ObjectSerializer serializer)` Returns an `Object` representation of this `BinaryData` by deserializing its data using the passed `ObjectSerializer`.
`InputStream`	`toStream()` Returns an `InputStream` representation of this `BinaryData`.
`String`	`toString()` Returns a `String` representation of this `BinaryData` by converting its data using the UTF-8 character set.

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

Method Detail

fromStream
```
public static BinaryData fromStream(InputStream inputStream)
```
Creates an instance of BinaryData from the given InputStream.
If inputStream is null or empty an empty BinaryData is returned.
NOTE: The InputStream is not closed by this function.
Create an instance from an InputStream
```
 final ByteArrayInputStream inputStream = new ByteArrayInputStream("Some Data".getBytes(StandardCharsets.UTF_8));
 BinaryData binaryData = BinaryData.fromStream(inputStream);
 System.out.println(binaryData.toString());
 
```
Parameters:

inputStream - The InputStream that BinaryData will represent.

Returns:

A BinaryData representing the InputStream.

Throws:

UncheckedIOException - If any error happens while reading the InputStream.

fromStreamAsync

public static Mono<BinaryData> fromStreamAsync(InputStream inputStream)

Creates an instance of BinaryData from the given InputStream.

If inputStream is null or empty an empty BinaryData is returned.

NOTE: The InputStream is not closed by this function.

Create an instance from an InputStream

 final ByteArrayInputStream inputStream = new ByteArrayInputStream("Some Data".getBytes(StandardCharsets.UTF_8));
 
 Mono<BinaryData> binaryDataMono = BinaryData.fromStreamAsync(inputStream);
 
 Disposable subscriber = binaryDataMono
     .map(binaryData -> {
         System.out.println(binaryData.toString());
         return true;
     })
     .subscribe();
 
 // So that your program wait for above subscribe to complete.
 TimeUnit.SECONDS.sleep(5);
 subscriber.dispose();

Parameters:: inputStream - The InputStream that BinaryData will represent.
Returns:: A Mono of BinaryData representing the InputStream.
Throws:: UncheckedIOException - If any error happens while reading the InputStream.

fromFlux

public static Mono<BinaryData> fromFlux(Flux<ByteBuffer> data)

Creates an instance of BinaryData from the given Flux of ByteBuffer.

If the data is null an empty BinaryData will be returned.

Note: This will collect all bytes from the ByteBuffers resulting in hasRemaining to return false.

Create an instance from a Flux of ByteBuffer

 final byte[] data = "Some Data".getBytes(StandardCharsets.UTF_8);
 final Flux<ByteBuffer> dataFlux = Flux.just(ByteBuffer.wrap(data));
 
 Mono<BinaryData> binaryDataMono = BinaryData.fromFlux(dataFlux);
 
 Disposable subscriber = binaryDataMono
     .map(binaryData -> {
         System.out.println(binaryData.toString());
         return true;
     })
     .subscribe();
 
 // So that your program wait for above subscribe to complete.
 TimeUnit.SECONDS.sleep(5);
 subscriber.dispose();

Parameters:: data - The Flux of ByteBuffer that BinaryData will represent.
Returns:: A Mono of BinaryData representing the Flux of ByteBuffer.

fromString
```
public static BinaryData fromString(String data)
```
Creates an instance of BinaryData from the given String.
The String is converted into bytes using String.getBytes(Charset) passing StandardCharsets.UTF_8.
If the data is null or a zero length string an empty BinaryData will be returned.
Create an instance from a String
```
 final String data = "Some Data";
 // Following will use default character set as StandardCharsets.UTF_8
 BinaryData binaryData = BinaryData.fromString(data);
 System.out.println(binaryData.toString());
 
```
Parameters:

data - The String that BinaryData will represent.

Returns:

A BinaryData representing the String.

fromBytes
```
public static BinaryData fromBytes(byte[] data)
```
Creates an instance of BinaryData from the given byte array.
If the byte array is null or zero length an empty BinaryData will be returned.
Create an instance from a byte array
```
 final byte[] data = "Some Data".getBytes(StandardCharsets.UTF_8);
 BinaryData binaryData = BinaryData.fromBytes(data);
 System.out.println(new String(binaryData.toBytes(), StandardCharsets.UTF_8));
 
```
Parameters:

data - The byte array that BinaryData will represent.

Returns:

A BinaryData representing the byte array.

fromObject

public static BinaryData fromObject(Object data)

Creates an instance of BinaryData by serializing the Object using the default JsonSerializer.

If data is null an empty BinaryData will be returned.

Note: This method first looks for a JsonSerializerProvider implementation on the classpath. If no implementation is found, a default Jackson-based implementation will be used to serialize the object.

Creating an instance from an Object

 class Person {
     {@literal @}JsonProperty
     private String name;
 
     {@literal @}JsonSetter
     public Person setName(String name) {
         this.name = name;
         return this;
     }
 
     {@literal @}JsonGetter
     public String getName() {
         return name;
     }
 }
 final Person data = new Person().setName("John");
 
 // Provide your custom serializer or use Azure provided serializers.
 // https://mvnrepository.com/artifact/com.azure/azure-core-serializer-json-jackson or
 // https://mvnrepository.com/artifact/com.azure/azure-core-serializer-json-gson
 BinaryData binaryData = BinaryData.fromObject(data);
 
 System.out.println(binaryData.toString());

Parameters:: data - The object that will be JSON serialized that BinaryData will represent.
Returns:: A BinaryData representing the JSON serialized object.
See Also:: JsonSerializer

fromObjectAsync

public static Mono<BinaryData> fromObjectAsync(Object data)

Creates an instance of BinaryData by serializing the Object using the default JsonSerializer.

If data is null an empty BinaryData will be returned.

Creating an instance from an Object

 class Person {
     {@literal @}JsonProperty
     private String name;
 
     {@literal @}JsonSetter
     public Person setName(String name) {
         this.name = name;
         return this;
     }
 
     {@literal @}JsonGetter
     public String getName() {
         return name;
     }
 }
 final Person data = new Person().setName("John");
 
 // Provide your custom serializer or use Azure provided serializers.
 // https://mvnrepository.com/artifact/com.azure/azure-core-serializer-json-jackson or
 // https://mvnrepository.com/artifact/com.azure/azure-core-serializer-json-gson
 Disposable subscriber = BinaryData.fromObjectAsync(data)
     .subscribe(binaryData -> System.out.println(binaryData.toString()));
 
 // So that your program wait for above subscribe to complete.
 TimeUnit.SECONDS.sleep(5);
 subscriber.dispose();

Parameters:: data - The object that will be JSON serialized that BinaryData will represent.
Returns:: A Mono of BinaryData representing the JSON serialized object.
See Also:: JsonSerializer

fromObject

public static BinaryData fromObject(Object data,
                                    ObjectSerializer serializer)

Creates an instance of BinaryData by serializing the Object using the passed ObjectSerializer.

If data is null an empty BinaryData will be returned.

The passed ObjectSerializer can either be one of the implementations offered by the Azure SDKs or your own implementation.

Azure SDK implementations

Create an instance from an Object

 class Person {
     {@literal @}JsonProperty
     private String name;
 
     {@literal @}JsonSetter
     public Person setName(String name) {
         this.name = name;
         return this;
     }
 
     {@literal @}JsonGetter
     public String getName() {
         return name;
     }
 }
 final Person data = new Person().setName("John");
 
 // Provide your custom serializer or use Azure provided serializers.
 // https://mvnrepository.com/artifact/com.azure/azure-core-serializer-json-jackson or
 // https://mvnrepository.com/artifact/com.azure/azure-core-serializer-json-gson
 final ObjectSerializer serializer =
     new MyJsonSerializer(); // Replace this with your Serializer
 BinaryData binaryData = BinaryData.fromObject(data, serializer);
 
 System.out.println(binaryData.toString());

Parameters:: data - The object that will be serialized that BinaryData will represent.; serializer - The ObjectSerializer used to serialize object.
Returns:: A BinaryData representing the serialized object.
Throws:: NullPointerException - If serializer is null and data is not null.
See Also:: ObjectSerializer, JsonSerializer, More about serialization

fromObjectAsync

public static Mono<BinaryData> fromObjectAsync(Object data,
                                               ObjectSerializer serializer)

Creates an instance of BinaryData by serializing the Object using the passed ObjectSerializer.

If data is null an empty BinaryData will be returned.

The passed ObjectSerializer can either be one of the implementations offered by the Azure SDKs or your own implementation.

Azure SDK implementations

Create an instance from an Object

 class Person {
     {@literal @}JsonProperty
     private String name;
 
     {@literal @}JsonSetter
     public Person setName(String name) {
         this.name = name;
         return this;
     }
 
     {@literal @}JsonGetter
     public String getName() {
         return name;
     }
 }
 final Person data = new Person().setName("John");
 
 // Provide your custom serializer or use Azure provided serializers.
 // https://mvnrepository.com/artifact/com.azure/azure-core-serializer-json-jackson or
 // https://mvnrepository.com/artifact/com.azure/azure-core-serializer-json-gson
 final ObjectSerializer serializer =
     new MyJsonSerializer(); // Replace this with your Serializer
 Disposable subscriber = BinaryData.fromObjectAsync(data, serializer)
     .subscribe(binaryData -> System.out.println(binaryData.toString()));
 
 // So that your program wait for above subscribe to complete.
 TimeUnit.SECONDS.sleep(5);
 subscriber.dispose();

Parameters:: data - The object that will be serialized that BinaryData will represent.; serializer - The ObjectSerializer used to serialize object.
Returns:: A Mono of BinaryData representing the serialized object.
Throws:: NullPointerException - If serializer is null and data is not null.
See Also:: ObjectSerializer, JsonSerializer, More about serialization

toBytes
```
public byte[] toBytes()
```
Returns a byte array representation of this BinaryData.

Returns:

A byte array representing this BinaryData.

toString
```
public String toString()
```
Returns a String representation of this BinaryData by converting its data using the UTF-8 character set.

Overrides:

toString in class Object

Returns:

A String representing this BinaryData.

toObject

public <T> T toObject(Class<T> clazz)

Returns an Object representation of this BinaryData by deserializing its data using the default JsonSerializer.

The type, represented by Class, should be a non-generic class, for generic classes use BinaryData.toObject(TypeReference).

Get a non-generic Object from the BinaryData

 class Person {
     {@literal @}JsonProperty
     private String name;
 
     {@literal @}JsonSetter
     public Person setName(String name) {
         this.name = name;
         return this;
     }
 
     {@literal @}JsonGetter
     public String getName() {
         return name;
     }
 }
 final Person data = new Person().setName("John");
 
 // Ensure your classpath have the Serializer to serialize the object which implement implement
 // com.azure.core.util.serializer.JsonSerializer interface.
 // Or use Azure provided libraries for this.
 // https://mvnrepository.com/artifact/com.azure/azure-core-serializer-json-jackson or
 // https://mvnrepository.com/artifact/com.azure/azure-core-serializer-json-gson
 
 BinaryData binaryData = BinaryData.fromObject(data);
 
 Person person = binaryData.toObject(Person.class);
 System.out.println(person.getName());

Type Parameters:: T - Type of the deserialized Object.
Parameters:: clazz - The Class representing the Object's type.
Returns:: An Object representing the JSON deserialized BinaryData.
Throws:: NullPointerException - If clazz is null.
See Also:: JsonSerializer

toObject

public <T> T toObject(TypeReference<T> typeReference)

Returns an Object representation of this BinaryData by deserializing its data using the default JsonSerializer.

The type, represented by TypeReference, can either be a generic or non-generic type. If the type is generic create a sub-type of TypeReference, if the type is non-generic use TypeReference.createInstance(Class).

Get a non-generic Object from the BinaryData

 class Person {
     {@literal @}JsonProperty
     private String name;
 
     {@literal @}JsonSetter
     public Person setName(String name) {
         this.name = name;
         return this;
     }
 
     {@literal @}JsonGetter
     public String getName() {
         return name;
     }
 }
 final Person data = new Person().setName("John");
 
 // Ensure your classpath have the Serializer to serialize the object which implement implement
 // com.azure.core.util.serializer.JsonSerializer interface.
 // Or use Azure provided libraries for this.
 // https://mvnrepository.com/artifact/com.azure/azure-core-serializer-json-jackson or
 // https://mvnrepository.com/artifact/com.azure/azure-core-serializer-json-gson
 
 BinaryData binaryData = BinaryData.fromObject(data);
 
 Person person = binaryData.toObject(TypeReference.createInstance(Person.class));
 System.out.println(person.getName());

Get a generic Object from the BinaryData

 final Person person1 = new Person().setName("John");
 final Person person2 = new Person().setName("Jack");
 
 List<Person> personList = new ArrayList<>();
 personList.add(person1);
 personList.add(person2);
 
 // Ensure your classpath have the Serializer to serialize the object which implement implement
 // com.azure.core.util.serializer.JsonSerializer interface.
 // Or use Azure provided libraries for this.
 // https://mvnrepository.com/artifact/com.azure/azure-core-serializer-json-jackson or
 // https://mvnrepository.com/artifact/com.azure/azure-core-serializer-json-gson
 
 
 BinaryData binaryData = BinaryData.fromObject(personList);
 
 List<Person> persons = binaryData.toObject(new TypeReference<List<Person>>() { });
 persons.forEach(person -> System.out.println(person.getName()));

Type Parameters:: T - Type of the deserialized Object.
Parameters:: typeReference - The TypeReference representing the Object's type.
Returns:: An Object representing the JSON deserialized BinaryData.
Throws:: NullPointerException - If typeReference is null.
See Also:: JsonSerializer

toObject

public <T> T toObject(Class<T> clazz,
                      ObjectSerializer serializer)

Returns an Object representation of this BinaryData by deserializing its data using the passed ObjectSerializer.

The type, represented by Class, should be a non-generic class, for generic classes use BinaryData.toObject(TypeReference, ObjectSerializer).

The passed ObjectSerializer can either be one of the implementations offered by the Azure SDKs or your own implementation.

Azure SDK implementations

Get a non-generic Object from the BinaryData

 class Person {
     {@literal @}JsonProperty
     private String name;
 
     {@literal @}JsonSetter
     public Person setName(String name) {
         this.name = name;
         return this;
     }
 
     {@literal @}JsonGetter
     public String getName() {
         return name;
     }
 }
 final Person data = new Person().setName("John");
 
 // Provide your custom serializer or use Azure provided serializers.
 // https://mvnrepository.com/artifact/com.azure/azure-core-serializer-json-jackson or
 // https://mvnrepository.com/artifact/com.azure/azure-core-serializer-json-gson
 
 final ObjectSerializer serializer =
     new MyJsonSerializer(); // Replace this with your Serializer
 BinaryData binaryData = BinaryData.fromObject(data, serializer);
 
 Person person = binaryData.toObject(Person.class, serializer);
 System.out.println("Name : " + person.getName());

Type Parameters:: T - Type of the deserialized Object.
Parameters:: clazz - The Class representing the Object's type.; serializer - The ObjectSerializer used to deserialize object.
Returns:: An Object representing the deserialized BinaryData.
Throws:: NullPointerException - If clazz or serializer is null.
See Also:: ObjectSerializer, JsonSerializer, More about serialization

toObject

public <T> T toObject(TypeReference<T> typeReference,
                      ObjectSerializer serializer)

Returns an Object representation of this BinaryData by deserializing its data using the passed ObjectSerializer.

The passed ObjectSerializer can either be one of the implementations offered by the Azure SDKs or your own implementation.

Azure SDK implementations

Get a non-generic Object from the BinaryData

 class Person {
     {@literal @}JsonProperty
     private String name;
 
     {@literal @}JsonSetter
     public Person setName(String name) {
         this.name = name;
         return this;
     }
 
     {@literal @}JsonGetter
     public String getName() {
         return name;
     }
 }
 final Person data = new Person().setName("John");
 
 // Provide your custom serializer or use Azure provided serializers.
 // https://mvnrepository.com/artifact/com.azure/azure-core-serializer-json-jackson or
 // https://mvnrepository.com/artifact/com.azure/azure-core-serializer-json-gson
 
 final ObjectSerializer serializer =
     new MyJsonSerializer(); // Replace this with your Serializer
 BinaryData binaryData = BinaryData.fromObject(data, serializer);
 
 Person person = binaryData.toObject(TypeReference.createInstance(Person.class), serializer);
 System.out.println("Name : " + person.getName());

Get a generic Object from the BinaryData

 final Person person1 = new Person().setName("John");
 final Person person2 = new Person().setName("Jack");
 
 List<Person> personList = new ArrayList<>();
 personList.add(person1);
 personList.add(person2);
 
 final ObjectSerializer serializer =
     new MyJsonSerializer(); // Replace this with your Serializer
 BinaryData binaryData = BinaryData.fromObject(personList, serializer);
 
 // Retains the type of the list when deserializing
 List<Person> persons = binaryData.toObject(new TypeReference<List<Person>>() { }, serializer);
 persons.forEach(person -> System.out.println("Name : " + person.getName()));

Type Parameters:: T - Type of the deserialized Object.
Parameters:: typeReference - The TypeReference representing the Object's type.; serializer - The ObjectSerializer used to deserialize object.
Returns:: An Object representing the deserialized BinaryData.
Throws:: NullPointerException - If typeReference or serializer is null.
See Also:: ObjectSerializer, JsonSerializer, More about serialization

toObjectAsync

public <T> Mono<T> toObjectAsync(Class<T> clazz)

Returns an Object representation of this BinaryData by deserializing its data using the default JsonSerializer.

The type, represented by Class, should be a non-generic class, for generic classes use BinaryData.toObject(TypeReference).

Get a non-generic Object from the BinaryData

 class Person {
     {@literal @}JsonProperty
     private String name;
 
     {@literal @}JsonSetter
     public Person setName(String name) {
         this.name = name;
         return this;
     }
 
     {@literal @}JsonGetter
     public String getName() {
         return name;
     }
 }
 final Person data = new Person().setName("John");
 
 // Ensure your classpath have the Serializer to serialize the object which implement implement
 // com.azure.core.util.serializer.JsonSerializer interface.
 // Or use Azure provided libraries for this.
 // https://mvnrepository.com/artifact/com.azure/azure-core-serializer-json-jackson or
 // https://mvnrepository.com/artifact/com.azure/azure-core-serializer-json-gson
 
 BinaryData binaryData = BinaryData.fromObject(data);
 
 Disposable subscriber = binaryData.toObjectAsync(Person.class)
     .subscribe(person -> System.out.println(person.getName()));
 
 // So that your program wait for above subscribe to complete.
 TimeUnit.SECONDS.sleep(5);
 subscriber.dispose();

Type Parameters:: T - Type of the deserialized Object.
Parameters:: clazz - The Class representing the Object's type.
Returns:: A Mono of Object representing the JSON deserialized BinaryData.
Throws:: NullPointerException - If clazz is null.
See Also:: JsonSerializer

toObjectAsync

public <T> Mono<T> toObjectAsync(TypeReference<T> typeReference)

Returns an Object representation of this BinaryData by deserializing its data using the default JsonSerializer.

Get a non-generic Object from the BinaryData

 class Person {
     {@literal @}JsonProperty
     private String name;
 
     {@literal @}JsonSetter
     public Person setName(String name) {
         this.name = name;
         return this;
     }
 
     {@literal @}JsonGetter
     public String getName() {
         return name;
     }
 }
 final Person data = new Person().setName("John");
 
 // Ensure your classpath have the Serializer to serialize the object which implement implement
 // com.azure.core.util.serializer.JsonSerializer interface.
 // Or use Azure provided libraries for this.
 // https://mvnrepository.com/artifact/com.azure/azure-core-serializer-json-jackson or
 // https://mvnrepository.com/artifact/com.azure/azure-core-serializer-json-gson
 
 BinaryData binaryData = BinaryData.fromObject(data);
 
 Disposable subscriber = binaryData.toObjectAsync(TypeReference.createInstance(Person.class))
     .subscribe(person -> System.out.println(person.getName()));
 
 // So that your program wait for above subscribe to complete.
 TimeUnit.SECONDS.sleep(5);
 subscriber.dispose();

Get a generic Object from the BinaryData

 final Person person1 = new Person().setName("John");
 final Person person2 = new Person().setName("Jack");
 
 List<Person> personList = new ArrayList<>();
 personList.add(person1);
 personList.add(person2);
 
 BinaryData binaryData = BinaryData.fromObject(personList);
 
 Disposable subscriber = binaryData.toObjectAsync(new TypeReference<List<Person>>() { })
     .subscribe(persons -> persons.forEach(person -> System.out.println(person.getName())));
 
 // So that your program wait for above subscribe to complete.
 TimeUnit.SECONDS.sleep(5);
 subscriber.dispose();

Type Parameters:: T - Type of the deserialized Object.
Parameters:: typeReference - The TypeReference representing the Object's type.
Returns:: A Mono of Object representing the JSON deserialized BinaryData.
Throws:: NullPointerException - If typeReference is null.
See Also:: JsonSerializer

toObjectAsync

public <T> Mono<T> toObjectAsync(Class<T> clazz,
                                 ObjectSerializer serializer)

Returns an Object representation of this BinaryData by deserializing its data using the passed ObjectSerializer.

The type, represented by Class, should be a non-generic class, for generic classes use BinaryData.toObject(TypeReference, ObjectSerializer).

The passed ObjectSerializer can either be one of the implementations offered by the Azure SDKs or your own implementation.

Azure SDK implementations

Get a non-generic Object from the BinaryData

 class Person {
     {@literal @}JsonProperty
     private String name;
 
     {@literal @}JsonSetter
     public Person setName(String name) {
         this.name = name;
         return this;
     }
 
     {@literal @}JsonGetter
     public String getName() {
         return name;
     }
 }
 final Person data = new Person().setName("John");
 
 // Provide your custom serializer or use Azure provided serializers.
 // https://mvnrepository.com/artifact/com.azure/azure-core-serializer-json-jackson or
 // https://mvnrepository.com/artifact/com.azure/azure-core-serializer-json-gson
 
 final ObjectSerializer serializer =
     new MyJsonSerializer(); // Replace this with your Serializer
 BinaryData binaryData = BinaryData.fromObject(data, serializer);
 
 Disposable subscriber = binaryData.toObjectAsync(Person.class, serializer)
     .subscribe(person -> System.out.println(person.getName()));
 
 // So that your program wait for above subscribe to complete.
 TimeUnit.SECONDS.sleep(5);
 subscriber.dispose();

Type Parameters:: T - Type of the deserialized Object.
Parameters:: clazz - The Class representing the Object's type.; serializer - The ObjectSerializer used to deserialize object.
Returns:: A Mono of Object representing the deserialized BinaryData.
Throws:: NullPointerException - If clazz or serializer is null.
See Also:: ObjectSerializer, JsonSerializer, More about serialization

toObjectAsync

public <T> Mono<T> toObjectAsync(TypeReference<T> typeReference,
                                 ObjectSerializer serializer)

Returns an Object representation of this BinaryData by deserializing its data using the passed ObjectSerializer.

The passed ObjectSerializer can either be one of the implementations offered by the Azure SDKs or your own implementation.

Azure SDK implementations

Get a non-generic Object from the BinaryData

 class Person {
     {@literal @}JsonProperty
     private String name;
 
     {@literal @}JsonSetter
     public Person setName(String name) {
         this.name = name;
         return this;
     }
 
     {@literal @}JsonGetter
     public String getName() {
         return name;
     }
 }
 final Person data = new Person().setName("John");
 
 // Provide your custom serializer or use Azure provided serializers.
 // https://mvnrepository.com/artifact/com.azure/azure-core-serializer-json-jackson or
 // https://mvnrepository.com/artifact/com.azure/azure-core-serializer-json-gson
 
 final ObjectSerializer serializer =
     new MyJsonSerializer(); // Replace this with your Serializer
 BinaryData binaryData = BinaryData.fromObject(data, serializer);
 
 Disposable subscriber = binaryData
     .toObjectAsync(TypeReference.createInstance(Person.class), serializer)
     .subscribe(person -> System.out.println(person.getName()));
 
 // So that your program wait for above subscribe to complete.
 TimeUnit.SECONDS.sleep(5);
 subscriber.dispose();

Get a generic Object from the BinaryData

 final Person person1 = new Person().setName("John");
 final Person person2 = new Person().setName("Jack");
 
 List<Person> personList = new ArrayList<>();
 personList.add(person1);
 personList.add(person2);
 
 final ObjectSerializer serializer =
     new MyJsonSerializer(); // Replace this with your Serializer
 BinaryData binaryData = BinaryData.fromObject(personList, serializer);
 
 Disposable subscriber = binaryData
     .toObjectAsync(new TypeReference<List<Person>>() { }, serializer) // retains the generic type information
     .subscribe(persons -> persons.forEach(person -> System.out.println(person.getName())));
 
 // So that your program wait for above subscribe to complete.
 TimeUnit.SECONDS.sleep(5);
 subscriber.dispose();

Type Parameters:: T - Type of the deserialized Object.
Parameters:: typeReference - The TypeReference representing the Object's type.; serializer - The ObjectSerializer used to deserialize object.
Returns:: A Mono of Object representing the deserialized BinaryData.
Throws:: NullPointerException - If typeReference or serializer is null.
See Also:: ObjectSerializer, JsonSerializer, More about serialization

toStream

public InputStream toStream()

Returns an InputStream representation of this BinaryData.

Get an InputStream from the BinaryData

 final byte[] data = "Some Data".getBytes(StandardCharsets.UTF_8);
 BinaryData binaryData = BinaryData.fromStream(new ByteArrayInputStream(data));
 final byte[] bytes = new byte[data.length];
 binaryData.toStream().read(bytes, 0, data.length);
 System.out.println(new String(bytes));

Returns:: An InputStream representing the BinaryData.

toByteBuffer

public ByteBuffer toByteBuffer()

Returns a read-only ByteBuffer representation of this BinaryData.

Attempting to mutate the returned ByteBuffer will throw a ReadOnlyBufferException.

Get a read-only ByteBuffer from the BinaryData

 final byte[] data = "Some Data".getBytes(StandardCharsets.UTF_8);
 BinaryData binaryData = BinaryData.fromBytes(data);
 final byte[] bytes = new byte[data.length];
 binaryData.toByteBuffer().get(bytes, 0, data.length);
 System.out.println(new String(bytes));

Returns:: A read-only ByteBuffer representing the BinaryData.

Class BinaryData

Method Summary

Methods inherited from class java.lang.Object

Method Detail

fromStream

fromStreamAsync

fromFlux

fromString

fromBytes

fromObject

fromObjectAsync

fromObject

fromObjectAsync

toBytes

toString

toObject

toObject

toObject

toObject

toObjectAsync

toObjectAsync

toObjectAsync

toObjectAsync

toStream

toByteBuffer