Share via

Hulp voor architectuur via pushmeldingen van het bedrijf

  • Artikel

Ondernemingen gaan tegenwoordig geleidelijk verder met het maken van mobiele toepassingen voor hun eindgebruikers (extern) of voor de werknemers (intern). Ze hebben bestaande back-endsystemen, zoals mainframes of sommige LoB-toepassingen, die moeten worden geïntegreerd in de architectuur van de mobiele toepassing. In deze handleiding wordt beschreven hoe u deze integratie het beste kunt doen, waarbij mogelijke oplossingen voor veelvoorkomende scenario's worden aanbevolen.

Een frequente vereiste is het verzenden van pushmeldingen naar de gebruikers via hun mobiele toepassing wanneer er interesse is in de back-endsystemen. Een bankklant die de bank-app op een i Telefoon heeft, wil bijvoorbeeld een melding ontvangen wanneer een debiteur boven een bepaald bedrag van het account of een intranetscenario wordt gedaan waarbij een werknemer van de financiële afdeling die een app voor budgetgoedkeuring heeft op een Windows-Telefoon een melding wil ontvangen wanneer de goedkeuringsaanvraag wordt ontvangen.

De verwerking van de bankrekening of goedkeuring wordt waarschijnlijk uitgevoerd in een back-endsysteem, dat een push naar de gebruiker moet initiëren. Er kunnen meerdere dergelijke back-endsystemen zijn, die allemaal dezelfde soort logica moeten bouwen om te pushen wanneer een gebeurtenis een melding activeert. De complexiteit hier ligt bij het integreren van verschillende back-endsystemen in combinatie met één pushsysteem waarbij de eindgebruikers zich mogelijk hebben geabonneerd op verschillende meldingen en er zelfs meerdere mobiele toepassingen zijn. Bijvoorbeeld: mobiele intranet-apps waarbij één mobiele toepassing mogelijk meldingen wil ontvangen van meerdere dergelijke back-endsystemen. De back-endsystemen weten niet of moeten weten van push-semantiek/-technologie, dus een veelvoorkomende oplossing hier is traditioneel een onderdeel introduceren, dat de back-endsystemen pollt op gebeurtenissen die van belang zijn en verantwoordelijk is voor het verzenden van de pushberichten naar de client.

Een betere oplossing is het gebruik van het Azure Service Bus-onderwerp-/abonnementsmodel, waardoor de complexiteit wordt verminderd terwijl de oplossing schaalbaar wordt.

Hier volgt de algemene architectuur van de oplossing (gegeneraliseerd met meerdere mobiele apps, maar even toepasselijk wanneer er slechts één mobiele app is)

Architectuur

Diagram of the enterprise architecture showing the flow through Events, Subscriptions, and Push Messages.

Het belangrijkste onderdeel in dit architectuurdiagram is Azure Service Bus, dat een programmeermodel voor onderwerpen/abonnementen biedt (meer informatie hierover in Service Bus Pub/Subprogrammering). De ontvanger, die in dit geval de mobiele back-end is (meestal Azure Mobile Service, die een push naar de mobiele apps initieert), ontvangt geen berichten rechtstreeks van de back-endsystemen, maar in plaats daarvan een tussenliggende abstractielaag die wordt geleverd door Azure Service Bus, waarmee mobiele back-end berichten van een of meer back-endsystemen kan ontvangen. Er moet een Service Bus-onderwerp worden gemaakt voor elk van de back-endsystemen, bijvoorbeeld Account, HR, Finance, wat in feite 'onderwerpen' van belang is, waarmee berichten worden gestart die als pushmelding moeten worden verzonden. De back-endsystemen verzenden berichten naar deze onderwerpen. Een mobiele back-end kan zich abonneren op een of meer dergelijke onderwerpen door een Service Bus-abonnement te maken. Het geeft de mobiele back-end de recht om een melding te ontvangen van het bijbehorende back-endsysteem. Mobiele back-end blijft luisteren naar berichten in hun abonnementen en zodra er een bericht binnenkomt, keert het terug en verzendt deze als melding naar de Notification Hub. Notification Hubs leveren het bericht vervolgens uiteindelijk aan de mobiele app. Hier volgt de lijst met belangrijke onderdelen:

  1. Back-endsystemen (LoB/Legacy-systemen)
    • Service Bus-onderwerp maken
    • Bericht verzenden
  2. Mobiele back-end
    • Serviceabonnement maken
    • Ontvangt een bericht (van het back-endsysteem)
    • Meldingen verzenden naar clients (via Azure Notification Hub)
  3. Mobiele toepassing
    • Ontvangt en geeft een melding weer

Vergoedingen

  1. Door de ontkoppeling tussen de ontvanger (mobiele app/service via Notification Hub) en afzender (back-endsystemen) kunnen extra back-endsystemen worden geïntegreerd met minimale wijzigingen.
  2. Het maakt ook het scenario mogelijk dat meerdere mobiele apps gebeurtenissen kunnen ontvangen van een of meer back-endsystemen.

Voorbeeld

Vereisten

Voltooi de volgende zelfstudies om vertrouwd te raken met de concepten en algemene stappen voor het maken en configureren:

  1. Service Bus Pub/Subprogrammering : in deze zelfstudie worden de details uitgelegd van het werken met Service Bus-onderwerpen/-abonnementen, het maken van een naamruimte voor onderwerpen/abonnementen, het verzenden en ontvangen van berichten van hen.
  2. Notification Hubs - Universele windows-zelfstudie : in deze zelfstudie wordt uitgelegd hoe u een Windows Store-app instelt en Notification Hubs gebruikt om meldingen te registreren en vervolgens te ontvangen.

Voorbeeldcode

De volledige voorbeeldcode is beschikbaar in Notification Hub Samples. Het is onderverdeeld in drie onderdelen:

  1. EnterprisePushBackendSystem

    a. Dit project maakt gebruik van het NuGet-pakket Azure.Messaging.ServiceBus en is gebaseerd op Service Bus Pub/Subprogrammering.

    b. Deze toepassing is een eenvoudige C#-console-app om een LoB-systeem te simuleren, waardoor het bericht wordt bezorgd bij de mobiele app.

    static async Task Main(string[] args)
{
    string connectionString =
        ConfigurationManager.AppSettings.Get("Azure.ServiceBus.ConnectionString");

    // Create the topic
    await CreateTopicAsync(connectionString);

    // Send message
    await SendMessageAsync(connectionString);
}

    c. CreateTopicAsync wordt gebruikt om het Service Bus-onderwerp te maken.

    public static async Task CreateTopicAsync(string connectionString)
{
    // Create the topic if it does not exist already
    ServiceBusAdministrationClient client = new ServiceBusAdministrationClient(connectionString);

    if (!await client.TopicExistsAsync(topicName))
    {
        await client.CreateTopicAsync(topicName);
    }
}

    d. SendMessageAsync wordt gebruikt om de berichten naar dit Service Bus-onderwerp te verzenden. Met deze code wordt eenvoudigweg een set willekeurige berichten naar het onderwerp verzonden voor het doel van het voorbeeld. Normaal gesproken is er een back-endsysteem waarmee berichten worden verzonden wanneer er een gebeurtenis plaatsvindt.

    public static sync Task SendMessageAsync(string connectionString)
{
    await using var client = new ServiceBusClient(connectionString);
    ServiceBusSender sender = client.CreateSender(topicName);

    // Sends random messages every 10 seconds to the topic
    string[] messages =
    {
        "Employee Id '{0}' has joined.",
        "Employee Id '{0}' has left.",
        "Employee Id '{0}' has switched to a different team."
    };

    while (true)
    {
        Random rnd = new Random();
        string employeeId = rnd.Next(10000, 99999).ToString();
        string notification = String.Format(messages[rnd.Next(0,messages.Length)], employeeId);

        // Send Notification
        ServiceBusMessage message = new ServiceBusMessage(notification);
        await sender.SendMessageAsync(message);

        Console.WriteLine("{0} Message sent - '{1}'", DateTime.Now, notification);

        System.Threading.Thread.Sleep(new TimeSpan(0, 0, 10));
    }
}

  2. ReceiveAndSendNotification

    a. Dit project maakt gebruik van de Pakketten Azure.Messaging.ServiceBus en Microsoft.Web.WebJobs.Publish NuGet en is gebaseerd op Service Bus Pub/Subprogrammering.

    b. De volgende console-app wordt uitgevoerd als een Azure-webtaak , omdat deze continu moet worden uitgevoerd om te luisteren naar berichten van de LoB-/back-endsystemen. Deze toepassing maakt deel uit van uw mobiele back-end.

    static async Task Main(string[] args)
{
    string connectionString =
             ConfigurationManager.AppSettings.Get("Azure.ServiceBus.ConnectionString");

    // Create the subscription that receives messages
    await CreateSubscriptionAsync(connectionString);

    // Receive message
    await ReceiveMessageAndSendNotificationAsync(connectionString);
}

    c. CreateSubscriptionAsync wordt gebruikt om een Service Bus-abonnement te maken voor het onderwerp waarin het back-endsysteem berichten verzendt. Afhankelijk van het bedrijfsscenario maakt dit onderdeel een of meer abonnementen op bijbehorende onderwerpen (sommige ontvangen mogelijk berichten van het HR-systeem, sommige van het systeem Financiën, enzovoort)

    static async Task CreateSubscriptionAsync(string connectionString)
{
    // Create the subscription if it does not exist already
    ServiceBusAdministrationClient client = new ServiceBusAdministrationClient(connectionString);

    if (!await client.SubscriptionExistsAsync(topicName, subscriptionName))
    {
        await client.CreateSubscriptionAsync(topicName, subscriptionName);
    }
}

    d. ReceiveMessageAndSendNotificationAsync wordt gebruikt om het bericht van het onderwerp te lezen met behulp van het abonnement en als de leesbewerking is geslaagd, wordt er een melding gemaakt (in het voorbeeldscenario wordt een systeemeigen pop-upmelding van Windows) verzonden naar de mobiele toepassing met behulp van Azure Notification Hubs.

    static async Task ReceiveMessageAndSendNotificationAsync(string connectionString)
{
    // Initialize the Notification Hub
    string hubConnectionString = ConfigurationManager.AppSettings.Get
            ("Microsoft.NotificationHub.ConnectionString");
    hub = NotificationHubClient.CreateClientFromConnectionString
            (hubConnectionString, "enterprisepushservicehub");

    ServiceBusClient Client = new ServiceBusClient(connectionString);
    ServiceBusReceiver receiver = Client.CreateReceiver(topicName, subscriptionName);

    // Continuously process messages received from the subscription
    while (true)
    {
        ServiceBusReceivedMessage message = await receiver.ReceiveMessageAsync();
        var toastMessage = @"<toast><visual><binding template=""ToastText01""><text id=""1"">{messagepayload}</text></binding></visual></toast>";

        if (message != null)
        {
            try
            {
                Console.WriteLine(message.MessageId);
                Console.WriteLine(message.SequenceNumber);
                string messageBody = message.Body.ToString();
                Console.WriteLine("Body: " + messageBody + "\n");

                toastMessage = toastMessage.Replace("{messagepayload}", messageBody);
                SendNotificationAsync(toastMessage);

                // Remove message from subscription
                await receiver.CompleteMessageAsync(message);
            }
            catch (Exception)
            {
                // Indicate a problem, unlock message in subscription
                await receiver.AbandonMessageAsync(message);
            }
        }
    }
}
static async void SendNotificationAsync(string message)
{
    await hub.SendWindowsNativeNotificationAsync(message);
}

    e. Als u deze app wilt publiceren als een webtaak, klikt u met de rechtermuisknop op de oplossing in Visual Studio en selecteert u Publiceren als webtaak

    Screenshot of the right-click options being displayed with Publish as Azure WebJob outlined in red.

    f. Selecteer uw publicatieprofiel en maak een nieuwe Azure-website als deze nog niet bestaat, die als host fungeert voor deze webtaak en zodra u de website hebt, publiceert u deze.

    Screenshot showing the workflow to create a site on Azure.

    g. Configureer de taak om continu uit te voeren, zodat wanneer u zich aanmeldt bij Azure Portal , er ongeveer als volgt uitziet:

    Screenshot of the Azure Portal with the enterprise push backend webjobs displayed and the Name, Schedule, and Logs values outlined in red.

  3. EnterprisePushMobileApp

    a. Deze toepassing is een Windows Store-toepassing die pop-upmeldingen ontvangt van de webtaak die wordt uitgevoerd als onderdeel van uw mobiele back-end en deze weer te geven. Deze code is gebaseerd op Notification Hubs - Universele windows-zelfstudie.

    b. Zorg ervoor dat uw toepassing is ingeschakeld voor het ontvangen van pop-upmeldingen.

    c. Zorg ervoor dat de volgende Notification Hubs-registratiecode wordt aangeroepen bij het opstarten van de app (nadat u de HubName en DefaultListenSharedAccessSignature waarden hebt vervangen:

    private async void InitNotificationsAsync()
{
    var channel = await PushNotificationChannelManager.CreatePushNotificationChannelForApplicationAsync();

    var hub = new NotificationHub("[HubName]", "[DefaultListenSharedAccessSignature]");
    var result = await hub.RegisterNativeAsync(channel.Uri);

    // Displays the registration ID so you know it was successful
    if (result.RegistrationId != null)
    {
        var dialog = new MessageDialog("Registration successful: " + result.RegistrationId);
        dialog.Commands.Add(new UICommand("OK"));
        await dialog.ShowAsync();
    }
}

Het voorbeeld uitvoeren

  1. Zorg ervoor dat uw webtaak correct wordt uitgevoerd en is gepland om continu te worden uitgevoerd.

  2. Voer de EnterprisePushMobileApp uit, waarmee de Windows Store-app wordt gestart.

  3. Voer de EnterprisePushBackendSystem-consoletoepassing uit, waarmee de LoB-back-end wordt gesimuleerd en berichten worden verzonden. Er worden pop-upmeldingen weergegeven zoals in de volgende afbeelding:

    Screenshot of a console running the Enterprise Push Backend System app and the message that is sent by the app.

  4. De berichten werden oorspronkelijk verzonden naar Service Bus-onderwerpen, die werden bewaakt door Service Bus-abonnementen in uw webtaak. Zodra een bericht is ontvangen, is er een melding gemaakt en verzonden naar de mobiele app. U kunt de webtaaklogboeken bekijken om de verwerking te bevestigen wanneer u naar de koppeling Logboeken in Azure Portal gaat voor uw webtaak:

    Screenshot of the Continuous WebJob Details dialog box with the message that is sent outlined in red.