Hinweis
Für den Zugriff auf diese Seite ist eine Autorisierung erforderlich. Sie können versuchen, sich anzumelden oder das Verzeichnis zu wechseln.
Für den Zugriff auf diese Seite ist eine Autorisierung erforderlich. Sie können versuchen, das Verzeichnis zu wechseln.
Unternehmen bewegen sich heute allmählich zur Erstellung mobiler Anwendungen für ihre Endbenutzer (extern) oder für die Mitarbeiter (intern). Sie verfügen über vorhandene Back-End-Systeme, sei es Mainframes oder einige LoB-Anwendungen, die in die mobile Anwendungsarchitektur integriert werden müssen. In diesem Leitfaden wird erläutert, wie Sie diese Integration am besten tun können, um mögliche Lösungen für häufige Szenarien zu empfehlen.
Eine häufige Anforderung ist das Senden von Pushbenachrichtigungen an die Benutzer über ihre mobile Anwendung, wenn ein Ereignis von Interesse in den Back-End-Systemen auftritt. Beispielsweise möchte ein Bankkunde, der über die Banking-App der Bank auf einem iPhone verfügt, benachrichtigt werden, wenn eine Lastschrift über einem bestimmten Betrag aus dem Konto oder einem Intranetszenario erfolgt, in dem ein Mitarbeiter der Finanzabteilung, der über eine Budgetgenehmigungs-App auf einem Windows Phone verfügt, benachrichtigt werden soll, wenn die Genehmigungsanforderung empfangen wird.
Die Verarbeitung des Bankkontos oder der Genehmigung erfolgt wahrscheinlich in einem Back-End-System, das einen Push an den Benutzer initiieren muss. Es kann mehrere solche Back-End-Systeme geben, die alle dieselbe Art von Logik erstellen müssen, um zu pushen, wenn ein Ereignis eine Benachrichtigung auslöst. Die Komplexität liegt hier in der Integration mehrerer Back-End-Systeme mit einem einzigen Pushsystem, bei dem die Endbenutzer möglicherweise verschiedene Benachrichtigungen abonniert haben, und es kann sogar mehrere mobile Anwendungen geben. Beispielsweise Intranet-Apps für Mobilgeräte, bei denen eine mobile Anwendung Benachrichtigungen von mehreren derartigen Back-End-Systemen erhalten möchte. Die Backend-Systeme sind nicht mit der Push-Semantik/Technologie vertraut und müssen dies auch nicht sein. Daher bestand eine bewährte Lösung traditionell darin, eine Komponente einzuführen, die die Backend-Systeme auf relevante Ereignisse überprüft und dafür zuständig ist, die Push-Nachrichten an den Client zu senden.
Eine bessere Lösung ist die Verwendung von Azure Service Bus - Topic/Subscription-Modell, wodurch die Komplexität reduziert und die Lösung skalierbar wird.
Hier ist die allgemeine Architektur der Lösung (generalisiert mit mehreren mobilen Apps, gilt jedoch gleichermaßen, wenn nur eine mobile App vorhanden ist)
Architektur
Der Schlüssel zu diesem Architekturdiagramm ist Azure Service Bus, der ein Programmiermodell für Themen/Abonnements bereitstellt (mehr dazu bei der Service Bus Pub/Sub-Programmierung). Der Empfänger, der in diesem Fall das mobile Back-End ist (in der Regel Azure Mobile Service, der einen Push an die mobilen Apps initiiert), empfängt keine Nachrichten direkt von den Back-End-Systemen, sondern eine zwischengeschaltete Abstraktionsebene, die von Azure Service Bus bereitgestellt wird, wodurch mobiles Back-End Nachrichten von einem oder mehreren Back-End-Systemen empfangen kann. Für jedes Backend-System muss ein Service Bus-Thema erstellt werden, z. B. "Account", "HR", "Finance", die im Grunde 'interessante Themen' sind, wodurch Nachrichten initiiert werden, die als Push-Benachrichtigungen gesendet werden. Die Back-End-Systeme senden Nachrichten an diese Themen. Ein mobiles Back-End kann ein oder mehrere solche Themen abonnieren, indem ein Service Bus-Abonnement erstellt wird. Es berechtigt das mobile Back-End, eine Benachrichtigung vom entsprechenden Back-End-System zu erhalten. Das Mobil-Back-End lauscht weiterhin auf Nachrichten in seinen Abonnements, und sobald eine Nachricht eingetroffen ist, sendet es diese als Benachrichtigung an seinen Benachrichtigungshub. Benachrichtigungshubs übermitteln die Nachricht schließlich an die mobile App. Hier ist die Liste der wichtigsten Komponenten:
- Back-End-Systeme (LoB/Legacy-Systeme)
- Erstellt Service Bus-Themen
- Nachricht senden
- Mobil-Back-End
- Erstellt ein Dienstabonnement
- Nachricht empfangen (vom Back-End-System)
- Sendet Benachrichtigungen an Clients (über den Azure Notification Hub)
- Mobile Anwendung
- Empfangen und Anzeigen von Benachrichtigungen
Vorteile
- Die Entkopplung zwischen dem Empfänger (mobiler App/Dienst über Notification Hub) und Absender (Back-End-Systeme) ermöglicht die Integration zusätzlicher Back-End-Systeme mit minimaler Änderung.
- Es ermöglicht auch das Szenario, bei dem mehrere mobile Apps Ereignisse von einem oder mehreren Backend-Systemen empfangen können.
Beispiel
Voraussetzungen
Führen Sie die folgenden Lernprogramme aus, um sich mit den Konzepten sowie allgemeinen Erstellungs- und Konfigurationsschritten vertraut zu machen:
- Service Bus Pub/Sub-Programmierung – In diesem Lernprogramm werden die Details zum Arbeiten mit Service Bus Topics/Abonnements erläutert, wie Sie einen Namespace erstellen, der Themen/Abonnements enthält, wie Sie Nachrichten von ihnen senden und empfangen können.
- Benachrichtigungshubs – Lernprogramm für universelle Windows-Geräte – In diesem Lernprogramm wird erläutert, wie Sie eine Windows Store-App einrichten und Benachrichtigungshubs verwenden, um Benachrichtigungen zu registrieren und dann zu empfangen.
Beispielcode
Der vollständige Beispielcode ist unter Notification Hub Samples verfügbar. Sie ist in drei Komponenten unterteilt:
EnterprisePushBackendSystem
a) Dieses Projekt verwendet das Azure.Messaging.ServiceBus NuGet-Paket und basiert auf der Service Bus Pub/Sub-Programmierung.
b. Diese Anwendung ist eine einfache C#-Konsolen-App, um ein LoB-System zu simulieren, das die Nachricht initiiert, die an die mobile App übermittelt werden soll.
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.
CreateTopicAsyncwird verwendet, um das Thema Service Bus zu erstellen.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.
SendMessageAsyncwird verwendet, um die Nachrichten an dieses Service Bus-Thema zu senden. Dieser Code sendet einfach eine Reihe zufälliger Nachrichten für den Zweck des Beispiels regelmäßig an das Thema. Normalerweise gibt es ein Back-End-System, das Nachrichten sendet, wenn ein Ereignis auftritt.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)); } }EmpfangenUndSendenBenachrichtigung
a) Dieses Projekt verwendet die Pakete Azure.Messaging.ServiceBus und Microsoft.Web.WebJobs.Publish NuGet und basiert auf der Service Bus Pub/Sub-Programmierung.
b. Die folgende Konsolen-App wird als Azure WebJob ausgeführt, da sie kontinuierlich ausgeführt werden muss, um Nachrichten aus den LoB/Back-End-Systemen zu überwachen. Diese Anwendung ist Teil Ihres Mobilen 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.
CreateSubscriptionAsyncwird verwendet, um ein Service Bus-Abonnement für das Thema zu erstellen, in dem das Back-End-System Nachrichten sendet. Je nach Geschäftsszenario erstellt diese Komponente ein oder mehrere Abonnements für entsprechende Themen (z. B. erhalten einige Nachrichten aus dem HR-System, einige aus dem Finanzsystem usw.)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.
ReceiveMessageAndSendNotificationAsyncwird verwendet, um die Nachricht über das dazugehörige Abonnement aus dem Thema zu lesen und, wenn der Lesevorgang erfolgreich war, eine Benachrichtigung zu erstellen (im Beispielszenario eine native Windows-Popupbenachrichtigung), die über Azure Notification Hubs an die mobile Anwendung gesendet werden soll.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. Zum Veröffentlichen dieser App als WebJob klicken Sie mit der rechten Maustaste auf die Projektmappe in Visual Studio, und wählen Sie "Als WebJob veröffentlichen" aus.
f. Wählen Sie Ihr Veröffentlichungsprofil aus, und erstellen Sie eine neue Azure WebSite, falls sie noch nicht vorhanden ist, die diesen WebJob hosten und sobald Sie die Website haben, dann veröffentlichen.
Screenshot des Dialogfelds „Web veröffentlichen“ mit ausgewählter Option „Microsoft Azure-Websites“. Ein grüner Pfeil zeigt auf das Dialogfeld „Vorhandene Website auswählen“, in dem die Option „Neu“ rot umrandet ist. Ein weiterer grüner Pfeil zeigt auf das Dialogfeld „Website in Microsoft Azure erstellen“, in dem die Optionen „Websitename“ und „Erstellen“ rot umrandet sind.
g. Konfigurieren Sie den Auftrag so, dass er fortlaufend ausgeführt wird, damit beim Anmelden beim Azure-Portal folgendes angezeigt werden sollte:
EnterprisePushMobileApp
a) Diese Anwendung ist eine Windows Store-Anwendung, die Toast-Benachrichtigungen von dem WebJob empfängt, der als Teil Ihres mobilen Back-ends ausgeführt wird, und sie anzeigt. Dieser Code basiert auf Benachrichtigungshubs – Universelles Windows-Lernprogramm.
b. Stellen Sie sicher, dass Ihre Anwendung aktiviert ist, um Toast-Benachrichtigungen zu empfangen.
c. Stellen Sie sicher, dass der folgende Registrierungscode für Benachrichtigungshubs beim Start der App aufgerufen wird (nachdem Sie die
HubNameundDefaultListenSharedAccessSignatureWerte ersetzt haben):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(); } }
Ausführen des Beispiels
Stellen Sie sicher, dass Ihr WebJob erfolgreich läuft und kontinuierlich ausgeführt wird.
Führen Sie die EnterprisePushMobileApp aus, die die Windows Store-App startet.
Führen Sie die EnterprisePushBackendSystem-Konsolenanwendung aus, die das LoB-Back-End simuliert und den Nachrichtenversand startet. Sie sollten Toast-Benachrichtigungen sehen, die wie die in der folgenden Abbildung erscheinen.
Die Nachrichten wurden ursprünglich an Service Bus-Themen gesendet, die von Service Bus-Abonnements in Ihrem WebJob überwacht wurden. Nachdem eine Nachricht empfangen wurde, wurde eine Benachrichtigung erstellt und an die mobile App gesendet. Sie können die WebJob-Protokolle durchsuchen, um die Verarbeitung zu bestätigen, wenn Sie zum Link "Protokolle" im Azure-Portal für Ihren Webauftrag wechseln: