Azure Java 1.0

import com.azure.storage.blob.BlobServiceClient;
import com.azure.storage.blob.BlobContainerClient;
import com.azure.storage.blob.specialized.BlockBlobClient;

public class BasicExample {

    public static void main(String[] args) throws IOException {

        StorageSharedKeyCredential credential = new StorageSharedKeyCredential(accountName, accountKey);

        String endpoint = String.format(Locale.ROOT, "https://%s.blob.core.windows.net", accountName);

        BlobServiceClient storageClient = new BlobServiceClientBuilder().endpoint(endpoint).credential(credential).buildClient();

        BlobContainerClient blobContainerClient = storageClient.getBlobContainerClient("mycontainer");

        blobContainerClient.create();

        BlockBlobClient blobClient = blobContainerClient.getBlobClient("HelloWorld.txt").getBlockBlobClient();

        blobClient.upload(dataStream, data.length());
    }
}

package com.foo.test;

import com.azure.messaging.servicebus.ServiceBusSenderClient;
import com.azure.messaging.servicebus.ServiceBusReceiverClient;
import com.azure.messaging.servicebus.ServiceBusClientBuilder;
import com.azure.messaging.servicebus.ServiceBusMessage;

import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;
import java.util.Arrays;
import java.util.List;

//
// https://docs.microsoft.com/fr-fr/azure/service-bus-messaging/service-bus-java-how-to-use-queues
//
public class SendReceive {
    
	static String connectionString = "<NAMESPACE CONNECTION STRING>";
	static String queueName = "<QUEUE NAME>";	
		
	static void sendMessage() {
		
		// create a Service Bus Sender client for the queue 
		ServiceBusSenderClient senderClient = new ServiceBusClientBuilder()
				.connectionString(connectionString)
				.sender()
				.queueName(queueName)				
				.buildClient();

		// send one message to the queue
		senderClient.sendMessage(new ServiceBusMessage("Hello, World!"));
		System.out.println("Sent a single message to the queue: " + queueName);
		
	}
	
	static void receiveMessages() {
		
		 ServiceBusReceiverClient receiverClient = new ServiceBusClientBuilder()
			     .connectionString(connectionString)
			     .receiver()
			     .queueName(queueName)
			     .buildClient();

			 // Use the receiver and finally close it.
		 receiverClient.receiveMessages(1);
		 receiverClient.close();
	}   
	
	public static void main(String[] args) throws InterruptedException {    	
    	sendMessage();		
		receiveMessages();
	} 
}

@FunctionName("RetrieveDailySubscriptions")
public void retrieveDailySubscriptions(...

 	@FunctionName("RetrieveDailySubscriptions")
    public void retrieveDailySubscriptions(
        @TimerTrigger(
            name = "timer",
            schedule = "0 0 0 * * *") String timerInfo,       
        @ServiceBusQueueOutput(name = "sb",
            queueName = "%PaymentQueue%",
            connection = "ServiceBusConnectionStr") OutputBinding<Subscription[]> subscriptionOutput,
        final ExecutionContext context) {
        subscriptionOutput.setValue(subscriptions);
    }

 	@FunctionName("ProcessSubscriptionPayment")
    public void processSubscriptionPayment(
        @ServiceBusQueueTrigger(
            name = "sb",
            queueName = "%PaymentQueue%",
            connection = "ServiceBusConnectionStr") Subscription subscription,     
        final ExecutionContext context) {
      
    }

    @FunctionName("ServiceBusTopicOutput")
    public void serviceBusTopicOutput(
        @HttpTrigger(name = "req", methods = {HttpMethod.GET, HttpMethod.POST}, authLevel = AuthorizationLevel.ANONYMOUS) HttpRequestMessage<Optional<String>> request,
        @ServiceBusTopicOutput(name = "message", topicName = "%SBTopicName%", subscriptionName = "%SBTopicSubName%", connection = "AzureWebJobsServiceBus") OutputBinding<String> output,
        final ExecutionContext context
    ) {
        String message = request.getBody().orElse("default message");
        output.setValue(message);
        context.getLogger().info("Java Service Bus Topic output function got a message: " + message);
    }

	@FunctionName("StartHelloCities")
    public HttpResponseMessage startHelloCities(
            @HttpTrigger(name = "req", methods = {HttpMethod.POST}) HttpRequestMessage<Optional<String>> req,
            @DurableClientInput(name = "durableContext", taskHub = "%MyTaskHub%") DurableClientContext durableContext,
            final ExecutionContext context) {

        DurableTaskClient client = durableContext.getClient();
        String instanceId = client.scheduleNewOrchestrationInstance("HelloCities");
        context.getLogger().info("Created new Java orchestration with instance ID = " + instanceId);
        return durableContext.createCheckStatusResponse(req, instanceId);
    }

    /**
     * This is the orchestrator function, which can schedule activity functions, create durable timers,
     * or wait for external events in a way that's completely fault-tolerant. The OrchestrationRunner.loadAndRun()
     * static method is used to take the function input and execute the orchestrator logic.
     */
    @FunctionName("HelloCities")
    public String helloCitiesOrchestrator(@DurableOrchestrationTrigger(name = "runtimeState") String runtimeState) {
        return OrchestrationRunner.loadAndRun(runtimeState, ctx -> {
            String result = "";
            result += ctx.callActivity("SayHello", "Tokyo", String.class).await() + ", ";
            result += ctx.callActivity("SayHello", "London", String.class).await() + ", ";
            result += ctx.callActivity("SayHello", "Seattle", String.class).await();
            return result;
        });
    }

    /**
     * This is the activity function that gets invoked by the orchestrator function.
     */
    @FunctionName("SayHello")
    public String sayHello(@DurableActivityTrigger(name = "name") String name) {
        return String.format("Hello %s!", name);
    }

	@FunctionName("HttpStart")
	public HttpResponseMessage httpStart(
	        @HttpTrigger(name = "req", route = "orchestrators/{functionName}") HttpRequestMessage<?> req,
	        @DurableClientInput(name = "durableContext") DurableClientContext durableContext,
	        @BindingName("functionName") String functionName,
	        final ExecutionContext context) {

	    DurableTaskClient client = durableContext.getClient();
	    String instanceId = client.scheduleNewOrchestrationInstance(functionName);
	    context.getLogger().info("Created new Java orchestration with instance ID = " + instanceId);
	    return durableContext.createCheckStatusResponse(req, instanceId);
	}

	@FunctionName("blobprocessor")
	public void run(
	  @BlobTrigger(name = "file",
	               dataType = "binary",
	               path = "myblob/{name}",
	               connection = "MyStorageAccountAppSetting") byte[] content,
	  @BindingName("name") String filename,
	  final ExecutionContext context
	) {
	  context.getLogger().info("Name: " + filename + " Size: " + content.length + " bytes");
	}

      @FunctionName("getBlobSizeHttp")
	  @StorageAccount("Storage_Account_Connection_String")
	  public HttpResponseMessage blobSize(	    
	    @BlobInput(
	      name = "file", 
	      dataType = "binary", 
	      path = "samples-workitems/{Query.file}") 
	    byte[] content,
	    final ExecutionContext context) {
	      
	  }

	  @FunctionName("copyBlobHttp")
	  @StorageAccount("Storage_Account_Connection_String")
	  public HttpResponseMessage copyBlobHttp(	 
	    @BlobOutput(
	      name = "target", 
	      path = "myblob/{Query.file}-CopyViaHttp")
	    OutputBinding<String> outputItem,
	    final ExecutionContext context) {
	    
	  }

	@FunctionName("CosmosTriggerAndOutput")
    public void CosmosTriggerAndOutput(
        @CosmosDBTrigger(name = "itemIn", databaseName = "familydb", collectionName = "familycoll", leaseCollectionName = "leases", connectionStringSetting = "AzureWebJobsCosmosDBConnectionString", createLeaseCollectionIfNotExists = true) Object inputItem,       
        final ExecutionContext context) {

        context.getLogger().info("Java Cosmos DB trigger function executed. Received document: " + inputItem);
      
    }

	@FunctionName("CosmosDBInputId")
    public HttpResponseMessage CosmosDBInputId(@HttpTrigger(name = "req", methods = { HttpMethod.GET,
        HttpMethod.POST }, authLevel = AuthorizationLevel.ANONYMOUS) HttpRequestMessage<Optional<String>> request,
                                               @CosmosDBInput(name = "item", databaseName = "familydb", collectionName = "familycoll", connectionStringSetting = "AzureWebJobsCosmosDBConnectionString", id = "{docId}") String item,
                                               final ExecutionContext context) {

        context.getLogger().info("Java HTTP trigger processed a request.");

        if (item != null) {
            return request.createResponseBuilder(HttpStatus.OK).body("Received Document" + item).build();
        } else {
            return request.createResponseBuilder(HttpStatus.INTERNAL_SERVER_ERROR)
                .body("Did not find expected item in ItemsCollectionIn").build();
    	}
   } 

	@FunctionName("CosmosDBInputQueryPOJOArray")
    public HttpResponseMessage CosmosDBInputQueryPOJOArray(@HttpTrigger(name = "req", methods = { HttpMethod.GET,
        HttpMethod.POST }, authLevel = AuthorizationLevel.ANONYMOUS) HttpRequestMessage<Optional<String>> request,                                                        
                                                           @CosmosDBOutput(name = "itemsOut", databaseName = "%CosmosDBDatabaseName%", collectionName = "familycoll", connectionStringSetting = "AzureWebJobsCosmosDBConnectionString") OutputBinding<Document[]> itemsOut,
                                                           final ExecutionContext context) {
        context.getLogger().info("Java HTTP trigger processed a request.");

       
    }

	@FunctionName("EventHubReceiver")
    @StorageAccount("bloboutput")
    public void run(
            @EventHubTrigger(name = "message",
                eventHubName = "%eventhub%",
                consumerGroup = "%consumergroup%",
                connection = "eventhubconnection",
                cardinality = Cardinality.ONE)
            String message,

            final ExecutionContext context,

            @BindingName("Properties") Map<String, Object> properties,
            @BindingName("SystemProperties") Map<String, Object> systemProperties,
            @BindingName("PartitionContext") Map<String, Object> partitionContext,
            @BindingName("EnqueuedTimeUtc") Object enqueuedTimeUtc,

            @BlobOutput(
                name = "outputItem",
                path = "iotevents/{datetime:yy}/{datetime:MM}/{datetime:dd}/{datetime:HH}/" +
                       "{datetime:mm}/{PartitionContext.PartitionId}/{SystemProperties.SequenceNumber}.json")
            OutputBinding<String> outputItem) {

        var et = ZonedDateTime.parse(enqueuedTimeUtc + "Z"); // needed as the UTC time presented does not have a TZ
                                                             // indicator
        context.getLogger().info("Event hub message received: " + message + ", properties: " + properties);
        context.getLogger().info("Properties: " + properties);
        context.getLogger().info("System Properties: " + systemProperties);
        context.getLogger().info("partitionContext: " + partitionContext);
        context.getLogger().info("EnqueuedTimeUtc: " + et);

        outputItem.setValue(message);
    }
    
    @FunctionName("sendTime")
    @EventHubOutput(name = "event", eventHubName = "samples-workitems", connection = "AzureEventHubConnection")
    public String sendTime(
       @TimerTrigger(name = "sendTimeTrigger", schedule = "0 */5 * * * *") String timerInfo)  {
         return LocalDateTime.now().toString();
    }

public class Sender {
    private static final String connectionString = "<Event Hubs namespace connection string>";
    private static final String eventHubName = "<Event hub name>";

    public static void main(String[] args) {
        publishEvents();
    }
    
    /**
     * Code sample for publishing events.
     * @throws IllegalArgumentException if the EventData is bigger than the max batch size.
     */
    public static void publishEvents() {
        // create a producer client
        EventHubProducerClient producer = new EventHubClientBuilder()
            .connectionString(connectionString, eventHubName)
            .buildProducerClient();

        // sample events in an array
        List<EventData> allEvents = Arrays.asList(new EventData("Foo"), new EventData("Bar"));

        // create a batch
        EventDataBatch eventDataBatch = producer.createBatch();

        for (EventData eventData : allEvents) {
            // try to add the event from the array to the batch
            if (!eventDataBatch.tryAdd(eventData)) {
                // if the batch is full, send it and then create a new batch
                producer.send(eventDataBatch);
                eventDataBatch = producer.createBatch();

                // Try to add that event that couldn't fit before.
                if (!eventDataBatch.tryAdd(eventData)) {
                    throw new IllegalArgumentException("Event is too large for an empty batch. Max size: "
                        + eventDataBatch.getMaxSizeInBytes());
                }
            }
        }
        // send the last batch of remaining events
        if (eventDataBatch.getCount() > 0) {
            producer.send(eventDataBatch);
        }
        producer.close();
    }
}

public class Receiver {
	private static final String connectionString = "<Event Hubs namespace connection string>";
	private static final String eventHubName = "<Event hub name>";
	private static final String storageConnectionString = "<Storage connection string>";
	private static final String storageContainerName = "<Storage container name>";
	
	public static void main(String[] args) throws Exception {
	    // Create a blob container client that you use later to build an event processor client to receive and process events
	    BlobContainerAsyncClient blobContainerAsyncClient = new BlobContainerClientBuilder()
	        .connectionString(storageConnectionString)
	        .containerName(storageContainerName)
	        .buildAsyncClient();

	    // Create a builder object that you will use later to build an event processor client to receive and process events and errors.
	    EventProcessorClientBuilder eventProcessorClientBuilder = new EventProcessorClientBuilder()
	        .connectionString(connectionString, eventHubName)
	        .consumerGroup(EventHubClientBuilder.DEFAULT_CONSUMER_GROUP_NAME)
	        .processEvent(PARTITION_PROCESSOR)
	        .processError(ERROR_HANDLER)
	        .checkpointStore(new BlobCheckpointStore(blobContainerAsyncClient));

	    // Use the builder object to create an event processor client
	    EventProcessorClient eventProcessorClient = eventProcessorClientBuilder.buildEventProcessorClient();

	    System.out.println("Starting event processor");
	    eventProcessorClient.start();

	    System.out.println("Press enter to stop.");
	    System.in.read();

	    System.out.println("Stopping event processor");
	    eventProcessorClient.stop();
	    System.out.println("Event processor stopped.");

	    System.out.println("Exiting process");
	}
	
	public static final Consumer<EventContext> PARTITION_PROCESSOR = eventContext -> {
	    PartitionContext partitionContext = eventContext.getPartitionContext();
	    EventData eventData = eventContext.getEventData();

	    System.out.printf("Processing event from partition %s with sequence number %d with body: %s%n",
	        partitionContext.getPartitionId(), eventData.getSequenceNumber(), eventData.getBodyAsString());

	    // Every 10 events received, it will update the checkpoint stored in Azure Blob Storage.
	    if (eventData.getSequenceNumber() % 10 == 0) {
	        eventContext.updateCheckpoint();
	    }
	};

	public static final Consumer<ErrorContext> ERROR_HANDLER = errorContext -> {
	    System.out.printf("Error occurred in partition processor for partition %s, %s.%n",
	        errorContext.getPartitionContext().getPartitionId(),
	        errorContext.getThrowable());
	};
}

	public static void main(String[] args) throws Exception {	
		HubConnection hubConnection = HubConnectionBuilder.create("/chatHub")
                .build();       
		...
        //This is a blocking call
        hubConnection.start().blockingAwait();

        while (!input.equals("leave")){
            input = reader.nextLine();
            hubConnection.send("SendMessage", input);
        }
		
		hubConnection.stop();
	}