App-Links

Wenn ein angeklickter Link oder eine programmgesteuerte Anforderung eine Web-URI-Absicht aufruft, versucht das Android-System nacheinander jede der folgenden Aktionen, bis die Anforderung erfolgreich ist:

  1. Öffnen Sie die vom Benutzer bevorzugte App, die den URI verarbeiten kann, sofern einer festgelegt wurde.
  2. Öffnen Sie die einzige verfügbare App, die den URI verarbeiten kann.
  3. Ermöglichen Sie dem Benutzer, eine App aus einem Dialogfeld auszuwählen.

Führen Sie die folgenden Schritte aus, um Links zu Ihren Inhalten zu erstellen und zu testen. Sie können auch den App Links-Assistenten in Android Studio verwenden, um Android App Links hinzuzufügen.

Fügen Sie Absichtsfilter für eingehende Links hinzu

Fügen Sie zum Erstellen eines Links zu Ihrem App-Inhalt einen Absichtsfilter hinzu, der die folgenden Elemente und Attributwerte in Ihrem Manifest enthält:

Geben Sie die Absichtsaktion ACTION_VIEW an, damit der Absichtsfilter über die Google-Suche erreicht werden kann. Fügen Sie ein oder mehrere Tags hinzu, von denen jedes ein URI-Format darstellt, das in die Aktivität aufgelöst wird. Das Tag muss mindestens das Attribut android: scheme enthalten.

Sie können weitere Attribute hinzufügen, um den von der Aktivität akzeptierten URI-Typ weiter zu verfeinern. Beispielsweise können Sie mehrere Aktivitäten ausführen, die ähnliche URIs akzeptieren, sich jedoch lediglich aufgrund des Pfadnamens unterscheiden. Verwenden Sie in diesem Fall das Attribut android: path oder dessen Varianten pathPattern oder pathPrefix, um zu unterscheiden, welche Aktivität das System für verschiedene URI-Pfade öffnen soll.

Fügen Sie die Kategorie BROWSABLE hinzu. Dies ist erforderlich, damit der Absichtsfilter über einen Webbrowser aufgerufen werden kann. Andernfalls kann das Klicken auf einen Link in einem Browser nicht in Ihre App aufgelöst werden.

Fügen Sie auch die Kategorie DEFAULT hinzu. Auf diese Weise kann Ihre App auf implizite Absichten reagieren. Ohne dies kann die Aktivität nur gestartet werden, wenn die Absicht den Namen Ihrer App-Komponente angibt.

Das folgende XML-Snippet zeigt, wie Sie in Ihrem Manifest einen Absichtsfilter für die Tiefenverknüpfung angeben können. Die URIs "example: // gizmos" und "http://www.example.com/gizmos" lösen beide diese Aktivität auf.

Beachten Sie, dass sich die beiden Absichtsfilter nur durch das Element unterscheiden. Obwohl es möglich ist, mehrere Elemente in denselben Filter aufzunehmen, ist es wichtig, dass Sie separate Filter erstellen, wenn Sie eindeutige URLs deklarieren möchten (z. B. eine bestimmte Kombination aus Schema und Host), da mehrere Elemente in demselben Intent-Filter tatsächlich zusammengeführt werden zusammen, um alle Variationen ihrer kombinierten Attribute zu berücksichtigen. Betrachten Sie beispielsweise Folgendes:

Es scheint, als ob dies nur https://www.example.com und app: //open.my.app unterstützt. Tatsächlich unterstützt es jedoch diese beiden Funktionen sowie die folgenden: app: //www.example.com und https://open.my.app.

Sobald Sie Ihrem App-Manifest Absichtsfilter mit URIs für Aktivitätsinhalte hinzugefügt haben, wählen Sie Andro> Absicht, die zur Laufzeit übereinstimmende URIs für Ihre App enthält.

Weitere Informationen zum Definieren von Absichtsfiltern finden Sie unter Zulassen, dass andere Apps Ihre Aktivität starten.

App-Links einrichten

Hinzufügen von App-Links zu vorhandenen Inhalten
Sie können Ihre vorhandenen Webinhalte für mobile Clients sichtbar machen, die App-Links unterstützen. Wenn Benutzer über unterstützte Clients auf Links zu vorhandenen Inhalten klicken, können sie die Inhalte in Ihre App anstelle einer Webansicht laden.

Implementierungen
Einige Bibliotheken, mit denen Sie App Links schnell implementieren können.

Beispiele Apps auf GitHub
Wir haben einige Beispiel-Apps bereitgestellt, mit denen Sie Ihre App ändern können, um App-Links zu unterstützen.

Best Practices
Erfahren Sie, wie Sie App-Links einrichten.

Liest Daten aus eingehenden Absichten

Sobald das System Ihre Aktivität über einen Absichtsfilter gestartet hat, können Sie mit data prov> Intent bestimmen, was Sie rendern müssen. Rufen Sie die Methoden getData () und getAction () auf, um die Daten und Aktionen abzurufen, die dem eingehenden Intent zugeordnet sind. Sie können diese Methoden jederzeit während des Lebenszyklus der Aktivität aufrufen, sollten dies jedoch im Allgemeinen während früher Rückrufe wie onCreate () oder onStart () tun.

Hier ist ein Ausschnitt, der zeigt, wie Daten von einem Intent abgerufen werden:

Einführung

In diesem Tutorial behandelt:

  • Erstellen einer Datenstruktur mit Lade- und Speichermethoden
  • Verwenden des net / http-Pakets zum Erstellen von Webanwendungen
  • HTML / Template-Paket zum Verarbeiten von HTML-Vorlagen verwenden
  • Verwenden des regulären Ausdruckspakets zum Validieren von Benutzereingaben
  • Verschlüsse verwenden

  • Programmiererfahrung
  • Verständnis grundlegender Webtechnologien (HTTP, HTML)
  • Einige Kenntnisse in der UNIX / DOS-Befehlszeile

Mobile Clients

Unterstützung für eingehende Links für iOS
Erfahren Sie, wie Sie Links zu Ihrer iOS-App unterstützen. Informieren Sie sich auch über die einzigartigen UX-Anforderungen für iOS und vordefinierte Widgets, mit denen Sie die App-übergreifende Navigation vereinfachen können.

Unterstützung eingehender Links für Android
Unterstützen Sie eingehende Links zu Ihrer Android-App.

Kotlin

Befolgen Sie diese bewährten Methoden, um die Benutzererfahrung zu verbessern:

  • Der Deep Link sollte Benutzer direkt zum Inhalt führen, ohne Aufforderungen, Interstitialseiten oder Anmeldungen. Stellen Sie sicher, dass Benutzer den App-Inhalt sehen können, auch wenn sie die App noch nie zuvor geöffnet haben. Es ist in Ordnung, Benutzer zu nachfolgenden Interaktionen oder zum Öffnen der App über den Launcher aufzufordern. Dies ist das gleiche Prinzip wie beim ersten Klick für Websites.
  • Befolgen Sie die in Navigation mit Zurück und Nach oben beschriebenen Gestaltungsanweisungen, damit Ihre App die Erwartungen der Benutzer hinsichtlich der Rückwärtsnavigation erfüllt, nachdem sie über einen Deep Link in Ihre App eingetreten sind.

Tooling installieren

In diesem Beitrag werde ich mich hauptsächlich auf Tools konzentrieren, die Teil des Befehls go sind. Ich werde jedoch einige erwähnen, die nicht zum Standard-Release von Go 1.12 gehören.

Um diese zu installieren, während Sie Go 1.12 verwenden, müssen Sie zunächst sicherstellen, dass Sie es sind draußen von einem Modul-fähigen Verzeichnis (ich wechsle normalerweise nur in / tmp). Dann können Sie den Befehl GO111MODULE = on go get verwenden, um das Tool zu installieren. Beispielsweise:

Dadurch werden das entsprechende Paket und die Abhängigkeiten heruntergeladen, die ausführbare Datei erstellt und Ihrem GOBIN-Verzeichnis hinzugefügt. Wenn Sie kein explizites GOBIN-Verzeichnis festgelegt haben, wird die ausführbare Datei zu Ihrem GOPATH / bin-Ordner hinzugefügt. In jedem Fall sollten Sie sicherstellen, dass sich das entsprechende Verzeichnis in Ihrem Systempfad befindet.

Hinweis: Dieser Vorgang ist etwas umständlich und wird hoffentlich in zukünftigen Versionen von Go verbessert. In Ausgabe 30515 wird die Diskussion darüber verfolgt.

Loslegen

Derzeit benötigen Sie einen FreeBSD-, Linux-, OS X- oder Windows-Computer, um Go ausführen zu können. Wir werden $ verwenden, um die Eingabeaufforderung darzustellen.

Erstellen Sie ein neues Verzeichnis für dieses Tutorial in Ihrem GOPATH und wechseln Sie zu diesem:

Erstellen Sie eine Datei mit dem Namen wiki.go, öffnen Sie sie in Ihrem bevorzugten Editor und fügen Sie die folgenden Zeilen hinzu:

Wir importieren die Pakete fmt und ioutil aus der Go-Standardbibliothek. Später, wenn wir zusätzliche Funktionen implementieren, werden wir dieser Importdeklaration weitere Pakete hinzufügen.

Navigationsprotokoll

Unterstützung für ausgehende Links zu anderen Apps
Erfahren Sie, wie Sie mithilfe der Facebook App Links Index-API und des App Links Navigation Protocol eine Verknüpfung zu anderen Apps herstellen.

Facebook App Links Index API
Facebook bietet einen Graph API-Endpunkt, um Daten nach URLs zu durchsuchen, die den App Links-Standard unterstützen.

Metadaten-Referenz
Eine vollständige Referenz für die Metadatentypen, die Sie Webseiten hinzufügen können, um App-Links zu unterstützen.

Testen Sie Ihre Deep Links

Sie können die Android Debug Bridge mit dem Activity Manager (am) -Tool verwenden, um zu testen, ob die von Ihnen angegebenen Intent-Filter-URIs für die Tiefenverknüpfung mit der richtigen App-Aktivität übereinstimmen. Sie können den Befehl adb für ein Gerät oder einen Emulator ausführen.

Die allgemeine Syntax zum Testen eines Intent-Filter-URI mit adb lautet:

Mit dem folgenden Befehl wird beispielsweise versucht, eine Zielanwendungsaktivität anzuzeigen, die dem angegebenen URI zugeordnet ist.

Die oben festgelegte Manifestdeklaration und der Intent-Handler definieren die Verbindung zwischen Ihrer App und einer Website und was mit eingehenden Links zu tun ist. Damit das System Ihre App jedoch als Standardhandler für eine Reihe von URIs behandelt, müssen Sie das System auffordern, diese Verbindung zu überprüfen. In der nächsten Lektion wird erläutert, wie diese Überprüfung implementiert wird.

Weitere Informationen zu Absichten und App-Links finden Sie in den folgenden Ressourcen:

Inhalts- und Codebeispiele auf dieser Seite unterliegen den in der Inhaltslizenz beschriebenen Lizenzen. Java ist eine eingetragene Marke von Oracle und / oder seinen verbundenen Unternehmen.

Umgebungsinformationen anzeigen

Mit dem Tool go env können Sie Informationen zu Ihrer aktuellen Go-Betriebsumgebung anzeigen. Dies kann besonders nützlich sein, wenn Sie an einem unbekannten Computer arbeiten.

Wenn es bestimmte Werte gibt, an denen Sie interessiert sind, können Sie sie als Argumente für go env übergeben. Beispielsweise:

So zeigen Sie die Dokumentation für alle go env-Variablen und -Werte an, die Sie ausführen können:

Datenstrukturen

Beginnen wir mit der Definition der Datenstrukturen. Ein Wiki besteht aus einer Reihe von miteinander verbundenen Seiten, von denen jede einen Titel und einen Hauptteil (den Seiteninhalt) hat. Hier definieren wir Seite als eine Struktur mit zwei Feldern, die den Titel und den Körper darstellen.

Das Typbyte bedeutet "ein Byte-Slice". (Weitere Informationen zu Slices finden Sie unter Slices: Verwendung und Interna.) Das Body-Element ist eher ein Byte als ein String, da dies der Typ ist, der von den io-Bibliotheken erwartet wird, die wir verwenden werden, wie Sie weiter unten sehen werden.

Die Seitenstruktur beschreibt, wie Seitendaten im Speicher abgelegt werden. Aber wie steht es mit der dauerhaften Speicherung? Wir können das beheben, indem wir eine Speichermethode auf Seite erstellen:

Die Signatur dieser Methode lautet: "Dies ist eine Methode mit dem Namen save, die als Empfänger p einen Zeiger auf Page verwendet. Sie akzeptiert keine Parameter und gibt einen Wert vom Typ error zurück."

Diese Methode speichert den Body der Seite in einer Textdatei. Der Einfachheit halber verwenden wir den Titel als Dateinamen.

Die save-Methode gibt einen Fehlerwert zurück, da dies der Rückgabetyp von WriteFile ist (eine Standardbibliotheksfunktion, die einen Byte-Slice in eine Datei schreibt). Die save-Methode gibt den Fehlerwert zurück, damit die Anwendung ihn verarbeiten kann, sollte beim Schreiben der Datei etwas schief gehen. Wenn alles in Ordnung ist, gibt Page.save () nil zurück (den Nullwert für Zeiger, Schnittstellen und einige andere Typen).

Das Oktal-Integer-Literal 0600, das als dritter Parameter an WriteFile übergeben wird, gibt an, dass die Datei nur für den aktuellen Benutzer mit Lese- / Schreibberechtigungen erstellt werden soll. (Weitere Informationen finden Sie in der Unix-Manpage open (2).)

Zusätzlich zum Speichern von Seiten möchten wir auch Seiten laden:

Die Funktion loadPage erstellt den Dateinamen aus dem title-Parameter, liest den Inhalt der Datei in einen neuen variablen Body und gibt einen Zeiger auf ein Seitenliteral zurück, das mit den richtigen title- und body-Werten erstellt wurde.

Funktionen können mehrere Werte zurückgeben. Die Standardbibliotheksfunktion io.ReadFile gibt Byte und Fehler zurück. In loadPage wird der Fehler noch nicht behandelt. Der durch das Unterstrichsymbol (_) dargestellte "leere Bezeichner" wird verwendet, um den Fehlerrückgabewert zu verwerfen (im Wesentlichen, um den Wert nichts zuzuweisen).

Aber was passiert, wenn ReadFile auf einen Fehler stößt? Beispielsweise ist die Datei möglicherweise nicht vorhanden. Wir sollten solche Fehler nicht ignorieren. Ändern wir die Funktion so, dass sie * Page und error zurückgibt.

Aufrufer dieser Funktion können nun den zweiten Parameter überprüfen. Wenn dieser Null ist, wurde eine Seite erfolgreich geladen. Wenn nicht, handelt es sich um einen Fehler, der vom Anrufer behandelt werden kann (Einzelheiten finden Sie in der Sprachspezifikation).

Zu diesem Zeitpunkt verfügen wir über eine einfache Datenstruktur und die Möglichkeit, Daten in eine Datei zu speichern und daraus zu laden. Schreiben wir eine Hauptfunktion, um zu testen, was wir geschrieben haben:

Nach dem Kompilieren und Ausführen dieses Codes wird eine Datei mit dem Namen TestPage.txt erstellt, die den Inhalt von p1 enthält. Die Datei würde dann in die Struktur p2 eingelesen und ihr Body-Element auf den Bildschirm gedruckt.

Sie können das Programm folgendermaßen kompilieren und ausführen:

(Wenn Sie Windows verwenden, müssen Sie "wiki" ohne "./" eingeben, um das Programm auszuführen.)

Über das Apps Center

Im Apps Center finden Sie eine Reihe von Anwendungen, die in Mein eBay integriert werden können und Sie bei Ihren eBay-Aktivitäten unterstützen.

Diese Anwendungen werden von Dritten und in einigen Fällen von eBay entwickelt. Anwendungen, die von zertifizierten eBay-Anbietern entwickelt wurden, sind mit dem Symbol für zertifizierte eBay-Anbieterdienste gekennzeichnet. Von eBay zertifizierte Anbieter zeichnen sich durch die Erstellung von Tools und Diensten für eBay-Nutzer aus.

Das Apps Center enthält Beschreibungen der Anwendungen sowie Details zu Preisen und Anforderungen.

Facebook Analytics

App-Links zu Ihrer App hinzufügen
Facebook macht es einfach zu sehen, wie Nutzer App-Links in Ihrer App verwenden. Indem Sie mit App Links Trends zu Verkehrs- und Nutzungsinformationen analysieren, können Sie den Wert von App Links erkennen und bessere Erfahrungen für Menschen schaffen.

Vorstellung des net / http-Pakets (ein Zwischenspiel)

Hier ist ein voll funktionsfähiges Beispiel eines einfachen Webservers:

Die Hauptfunktion beginnt mit einem Aufruf von http.HandleFunc, der das http-Paket anweist, alle Anforderungen an das Webstammverzeichnis ("/") mit dem Handler zu verarbeiten.

Anschließend wird http.ListenAndServe aufgerufen und angegeben, dass Port 8080 an einer beliebigen Schnittstelle abgehört werden soll (": 8080"). (Machen Sie sich vorerst keine Gedanken über den zweiten Parameter, nil.) Diese Funktion wird blockiert, bis das Programm beendet wird.

ListenAndServe gibt immer einen Fehler zurück, da er nur zurückgibt, wenn ein unerwarteter Fehler auftritt. Um diesen Fehler zu protokollieren, schließen wir den Funktionsaufruf mit log.Fatal ab.

Der Funktionshandler ist vom Typ http.HandlerFunc. Als Argumente werden ein http.ResponseWriter und eine http.Request verwendet.

Ein http.ResponseWriter-Wert stellt die Antwort des HTTP-Servers zusammen. Durch das Schreiben werden Daten an den HTTP-Client gesendet.

Eine http.Request ist eine Datenstruktur, die die HTTP-Clientanforderung darstellt. r.URL.Path ist die Pfadkomponente der Anforderungs-URL. Die nachfolgende 1: bedeutet "erstelle einen Unterabschnitt des Pfades vom 1. Zeichen bis zum Ende". Dadurch wird das führende "/" aus dem Pfadnamen entfernt.

Wenn Sie dieses Programm ausführen und auf die URL zugreifen:

Das Programm würde eine Seite präsentieren, die Folgendes enthält:

Eine Anwendung finden

Sie können die verfügbaren Anwendungen für eBay durchsuchen, um diejenigen zu finden, die Ihren geschäftlichen Anforderungen entsprechen.

Bewegen Sie den Mauszeiger über die Anwendungen Klicken Sie auf die Registerkarte, und klicken Sie dann auf die Anwendung verwalten Verknüpfung.

Klicken Sie auf Anwendungen verwalten Klicken Sie auf der Seite Gehe zu Apps Center Verknüpfung.

Im Apps Center Seite, erkunden Sie die Anwendungen durch entweder:

Auswählen einer Kategorie von Anwendungen, die Sie interessieren, aus der Liste unter Verkauf von Apps auf der linken Seite der Seite

Suche verwenden am oberen Rand der Seite, um Stichwörter einzugeben

Auswählen der vorgestellten Anwendung oder durchsuchen Sie die neuesten und am beliebtesten Listen von Anwendungen
Spitze: Wenn Sie Hilfe beim Suchen einer Anwendung benötigen, klicken Sie auf die Suchtipps Link rechts neben dem Suchfeld oben auf der Seite.

Lesen Sie die Beschreibung des Entwicklers zu Funktion und Preis der Anwendung und informieren Sie sich über den Entwickler.

Code ausführen

Während der Entwicklung ist das Go-Run-Tool eine praktische Möglichkeit, Ihren Code auszuprobieren. Es ist im Wesentlichen eine Verknüpfung, die Ihren Code kompiliert, eine ausführbare Binärdatei in Ihrem / tmp-Verzeichnis erstellt und diese Binärdatei dann in einem Schritt ausführt.

Hinweis: Ab Go 1.11 können Sie den Pfad eines Pakets übergeben, das ausgeführt werden soll, wie oben beschrieben. Dies bedeutet, dass Sie keine Problemumgehungen wie go run * .go Wildcard-Erweiterung mehr verwenden müssen, um mehrere Dateien auszuführen. Ich mag diese Verbesserung sehr!

Verwenden von net / http zum Bereitstellen von Wiki-Seiten

Um das net / http-Paket zu verwenden, muss es importiert werden:

Erstellen wir einen Handler, viewHandler, mit dem Benutzer eine Wiki-Seite anzeigen können. URLs mit dem Präfix "/ view /" werden verarbeitet.

Beachten Sie erneut die Verwendung von _, um den Fehlerrückgabewert von loadPage zu ignorieren. Dies wird hier der Einfachheit halber und allgemein als schlechte Praxis angesehen. Wir werden uns später darum kümmern.

Zunächst extrahiert diese Funktion den Seitentitel aus r.URL.Path, der Pfadkomponente der Anforderungs-URL. Der Pfad wird mit len ​​("/ view /") neu aufgeteilt, um die führende "/ view /" - Komponente des Anforderungspfads zu löschen. Dies liegt daran, dass der Pfad immer mit "/ view /" beginnt, was nicht Teil des Titels der Seite ist.

Die Funktion lädt dann die Seitendaten, formatiert die Seite mit einer Zeichenfolge aus einfachem HTML und schreibt sie in w, den http.ResponseWriter.

Um diesen Handler zu verwenden, schreiben wir unsere Hauptfunktion um, um http mit dem viewHandler zu initialisieren, um alle Anfragen unter dem Pfad / view / zu bearbeiten.

Lassen Sie uns einige Seitendaten (wie test.txt) erstellen, unseren Code kompilieren und versuchen, eine Wiki-Seite bereitzustellen.

Öffnen Sie die Datei test.txt in Ihrem Editor und speichern Sie die Zeichenfolge "Hallo Welt" (ohne Anführungszeichen) darin.

(Wenn Sie Windows verwenden, müssen Sie "wiki" ohne "./" eingeben, um das Programm auszuführen.)

Wenn dieser Webserver ausgeführt wird, sollte bei einem Besuch von http: // localhost: 8080 / view / test eine Seite mit dem Titel "test" mit den Worten "Hello world" angezeigt werden.

Eine Anwendung abonnieren

Wenn Sie eine Anwendung abonnieren, melden Sie sich beim Anwendungsentwickler an, obwohl wir das Abonnieren und die Verwendung der Anwendung erleichtern. Weitere Informationen zu Preisen und Zahlungen für Anwendungen.

Klicken Sie im Apps Center auf die gewünschte Anwendung.

Klicken Sie auf der Seite, die die Anwendung beschreibt, auf Pläne anzeigen Taste.

Wählen Sie Ihr Abonnement oder testen Sie eine kostenlose Testversion, bevor Sie sich anmelden.

Lesen und akzeptieren Sie die Nutzungsbedingungen und Datenschutzrichtlinien, und klicken Sie dann auf Weiter Taste.

Richten Sie Ihre automatischen Zahlungen mit PayPal ein.

Was ist, wenn ich die Entwickleranwendung bereits abonniert habe?

Möglicherweise haben Sie bereits eine Anwendung direkt beim Entwickler abonniert und möchten sie jetzt in Mein eBay verwenden.

Hier ist was zu tun:

Kündigen Sie die Anmeldung beim Entwickler und abonnieren Sie die Version in Mein eBay.

Wenn Sie die Version von Mein eBay abonnieren, müssen Sie Ihre Zahlungsmethode erneut angeben, Ihr Rechnungskonto ist jedoch weiterhin aktiv. Nachdem Sie die My eBay-Version erneut abonniert haben, wird auf Ihrem Abrechnungskonto sowohl der alte Auszug aus dem Entwicklerabonnement als auch der neue Auszug aus Ihrem eBay-Abonnement angezeigt.

Abrufen von Abhängigkeiten

Vorausgesetzt, Sie haben Module aktiviert, werden bei Verwendung von go run (oder go test oder go build) alle externen Abhängigkeiten automatisch (und rekursiv) heruntergeladen, um die Importanweisungen in Ihrem Code zu erfüllen. Standardmäßig wird die neueste mit Tags versehene Version der Abhängigkeit heruntergeladen. Wenn keine mit Tags versehenen Versionen verfügbar sind, wird die Abhängigkeit spätestens festgeschrieben.

Wenn Sie im Voraus wissen, dass Sie eine bestimmte Version einer Abhängigkeit benötigen (anstelle derjenigen, die Go standardmäßig abruft), können Sie go get mit der entsprechenden Versionsnummer oder dem Commit-Hash verwenden. Beispielsweise:

Wenn die Abhängigkeit, die abgerufen wird, eine go.mod-Datei hat, dann seine Abhängigkeiten wird nicht gelistet in Ihre go.mod Datei. Wenn im Gegensatz dazu die Abhängigkeit, die Sie herunterladen, keine go.mod-Datei enthält, handelt es sich um Abhängigkeiten werden in deiner go.mod-Datei mit einem // indirekten Kommentar daneben aufgeführt sein.

Das heißt, Ihre go.mod-Datei zeigt nicht unbedingt alle Abhängigkeiten für Ihr Projekt an einem Ort. Stattdessen können Sie sie alle mit dem Go-List-Tool wie folgt anzeigen:

Manchmal wundert man sich vielleicht warum ist Das eine abhängigkeit? Sie können dies mit dem Befehl go mod why beantworten, der Ihnen den kürzesten Weg von einem Paket in Ihrem Hauptmodul zu einer bestimmten Abhängigkeit anzeigt. Beispielsweise:

Hinweis: Der Befehl go mod why gibt für die meisten, aber nicht für alle Abhängigkeiten eine Antwort zurück. Problem 27900 verfolgt dies.

Wenn Sie die Abhängigkeiten für Ihre Anwendung analysieren oder visualisieren möchten, sollten Sie auch das Tool go mod graph ausprobieren. Hier finden Sie ein großartiges Tutorial und einen Beispielcode zum Generieren von Visualisierungen.

Zuletzt werden heruntergeladene Abhängigkeiten in der gespeichert Modul-Cache befindet sich unter GOPATH / pkg / mod. Wenn Sie jemals den Modul-Cache löschen müssen, können Sie das Tool go clean verwenden. Beachten Sie jedoch, dass dadurch die heruntergeladenen Abhängigkeiten für entfernt werden alle projekte auf Ihrer Maschine.

Seiten bearbeiten

Ein Wiki ist kein Wiki ohne die Möglichkeit, Seiten zu bearbeiten. Erstellen wir zwei neue Handler: einen mit dem Namen editHandler, um ein Formular zum Bearbeiten der Seite anzuzeigen, und einen mit dem Namen saveHandler, um die über das Formular eingegebenen Daten zu speichern.

Zuerst fügen wir sie main () hinzu:

Die Funktion editHandler lädt die Seite (oder erstellt, falls nicht vorhanden, eine leere Seitenstruktur) und zeigt ein HTML-Formular an.

Diese Funktion wird gut funktionieren, aber all das hartcodierte HTML ist hässlich. Natürlich gibt es einen besseren Weg.

Starten Sie Ihre Anwendung

Nachdem Sie eine Anwendung abonniert haben, können Sie sie über Mein eBay öffnen.

Bewegen Sie den Mauszeiger über die Anwendungen Registerkarte, und wählen Sie dann den Namen der Anwendung aus dem Dropdown-Menü.

Refactoring-Code

Wahrscheinlich kennen Sie sich mit dem Tool gofmt aus, um Ihren Code automatisch zu formatieren. Es unterstützt aber auch Regeln umschreiben mit deren Hilfe Sie Ihren Code umgestalten können. Ich werde es demonstrieren.

Angenommen, Sie haben den folgenden Code und möchten die Variable foo in Foo ändern, damit sie exportiert wird.

Dazu können Sie gofmt mit dem Flag -r verwenden, um eine Umschreiberegel zu implementieren, das Flag -d, um einen Unterschied der Änderungen anzuzeigen, und das Flag -w, um die Änderungen vorzunehmen an Ort und Stelle, wie so:

Beachten Sie, dass dies intelligenter ist als ein Suchen und Ersetzen? Die Variable foo wurde geändert, die Zeichenfolge "foo" in der Anweisung fmt.Println () wurde jedoch nicht geändert. Eine weitere zu beachtende Sache ist, dass der Befehl gofmt rekursiv arbeitet, sodass der obige Befehl für alle * .go-Dateien in Ihrem aktuellen Verzeichnis und Ihren Unterverzeichnissen ausgeführt wird.

Wenn Sie diese Funktionalität nutzen möchten, empfehle ich, Umschreiberegeln auszuführen ohne Zuerst das Flag -w und dann den Diff prüfen, um sicherzustellen, dass die Änderungen am Code Ihren Erwartungen entsprechen.

Schauen wir uns ein etwas komplizierteres Beispiel an. Angenommen, Sie möchten Ihren Code aktualisieren, um die neue Go 1.12-Funktion strings.ReplaceAll () anstelle von strings.Replace () zu verwenden. Um diese Änderung vorzunehmen, können Sie Folgendes ausführen:

In Umschreiberegeln fungieren einzelne Kleinbuchstaben als Platzhalter für beliebige Ausdrücke, und diese Ausdrücke werden in der Ersetzung eingesetzt.

Anzeigen der Go-Dokumentation

Sie können die Dokumentation für die Standardbibliothekspakete über Ihr Terminal mit dem Tool go doc anzeigen. Ich benutze dies oft während der Entwicklung, um schnell etwas zu überprüfen - wie den Namen oder die Unterschrift einer bestimmten Funktion. Ich finde es schneller als das Navigieren in der webbasierten Dokumentation und es ist auch offline immer verfügbar.

Sie können auch das Flag -src einfügen, um den relevanten Go-Quellcode anzuzeigen. Beispielsweise:

Das HTML / Template-Paket

Das HTML / Template-Paket ist Teil der Go-Standardbibliothek. Wir können HTML / Template verwenden, um den HTML-Code in einer separaten Datei zu speichern. Auf diese Weise können wir das Layout unserer Bearbeitungsseite ändern, ohne den zugrunde liegenden Go-Code zu ändern.

Zunächst müssen wir der Liste der Importe HTML / Template hinzufügen. Wir werden fmt auch nicht mehr benutzen, also müssen wir das entfernen.

Lassen Sie uns eine Vorlagendatei erstellen, die das HTML-Formular enthält. Öffnen Sie eine neue Datei mit dem Namen edit.html und fügen Sie die folgenden Zeilen hinzu:

Ändern Sie den editHandler, um die Vorlage anstelle des fest codierten HTML-Codes zu verwenden:

Die Funktion template.ParseFiles liest den Inhalt von edit.html und gibt eine * template.Template zurück.

Die Methode t.Execute führt die Vorlage aus und schreibt den generierten HTML-Code in den http.ResponseWriter. Die gepunkteten Bezeichner .Title und .Body beziehen sich auf p.Title und p.Body.

Vorlagenanweisungen sind in doppelte geschweifte Klammern eingeschlossen. Die Anweisung printf "% s" .Body ist ein Funktionsaufruf, der .Body als Zeichenfolge anstelle eines Bytestroms ausgibt, genau wie ein Aufruf von fmt.Printf. Das HTML / Template-Paket stellt sicher, dass nur sicheres und korrekt aussehendes HTML durch Template-Aktionen generiert wird. Beispielsweise wird automatisch ein Zeichen größer als (>) durch> ersetzt, um sicherzustellen, dass Benutzerdaten das HTML-Formular nicht beschädigen.

Da wir jetzt mit Vorlagen arbeiten, erstellen wir eine Vorlage für unseren viewHandler namens view.html:

Ändern Sie den viewHandler entsprechend:

Beachten Sie, dass wir in beiden Handlern fast genau denselben Vorlagencode verwendet haben. Entfernen wir diese Duplizierung, indem wir den Vorlagencode in eine eigene Funktion verschieben:

Und ändern Sie die Handler, um diese Funktion zu verwenden:

Wenn wir die Registrierung unseres nicht implementierten save-Handlers in main auskommentieren, können wir unser Programm erneut erstellen und testen. Klicken Sie hier, um den Code anzuzeigen, den wir bisher geschrieben haben.

Abmeldung von einer Bewerbung

Bevor Sie ein Abonnement kündigen, empfehlen wir, dass Sie sich an den Entwickler der Anwendung wenden, um Hilfe bei der Verwendung der Anwendung zu erhalten oder etwaige Fragen zu klären.

Bewegen Sie den Mauszeiger über die Anwendungen Klicken Sie auf die Registerkarte, und klicken Sie dann auf die Anwendung verwalten Klicken Sie auf den Link, um eine Liste aller Anwendungen anzuzeigen, die Sie abonniert haben.

Klicken Sie auf Andere Aktionen Klicken Sie auf Link, und wählen Sie dann Abbestellen aus.

Anwendungen, bei denen Sie sich kürzlich abgemeldet haben, werden unter Abgemeldete Anwendungen (letzte 60 Tage) aufgeführt.. Sie können sich erneut anmelden oder sich an den Anwendungsentwickler wenden, um Unterstützung zu erhalten.

Umgang mit nicht existierenden Seiten

Was passiert, wenn Sie / view / APageThatDoesntExist besuchen? Sie sehen eine Seite mit HTML. Dies liegt daran, dass der Fehlerrückgabewert von loadPage ignoriert wird und weiterhin versucht wird, die Vorlage ohne Daten auszufüllen. Wenn die angeforderte Seite nicht vorhanden ist, sollte sie den Client stattdessen zur Bearbeitungsseite umleiten, damit der Inhalt erstellt werden kann:

Die Funktion http.Redirect fügt der HTTP-Antwort den HTTP-Statuscode http.StatusFound (302) und einen Location-Header hinzu.

Kontaktaufnahme mit dem Entwickler

Wenn Sie Hilfe zu einer der Anwendungen im Apps Center benötigen, wenden Sie sich direkt an den Entwickler der Anwendung. Der Entwickler jeder Anwendung kennt die Anwendung am besten und ist einzigartig qualifiziert, Ihnen dabei zu helfen.

Bewegen Sie den Mauszeiger über die Anwendungen Registerkarte, und klicken Sie dann auf Anwendungen verwalten Verknüpfung.

Klicken Sie auf Start Taste.

Wählen Sie Kundensupport aus dem Menü Hilfe.

Hinweis: Sie können auch auf Support kontaktieren klicken Link von den anderen Aktionen Liste unter dem Start Taste.


Wenn Sie den Entwickler bereits kontaktiert haben

Wenn Sie sich an den Entwickler gewandt haben, noch keine Lösung gefunden haben und der Meinung sind, dass die Leistung der Anwendung zu hoch ist oder die Beschreibung der Anwendung nicht korrekt ist, setzen Sie sich mit uns in Verbindung, um die Anwendung zu melden. Wir überprüfen Ihren Bericht und ermitteln, welche Aktion angemessen ist.

Bewegen Sie den Mauszeiger über die Anwendungen Klicken Sie auf die Registerkarte, und klicken Sie dann auf die Anwendung verwalten Verknüpfung.

In den Ihre Anwendungen Klicken Sie im Abschnitt Andere Aktionen auf Link unter dem Start Schaltfläche für die Anwendung, die Sie melden möchten.

Klicken Sie auf Diese Anwendung melden aus dem Dropdown-Menü und füllen Sie das Formular aus. Beschreiben Sie das Problem und wählen Sie einen der Gründe aus, warum Sie die Anwendung melden:

Die Anwendung funktioniert nicht wie beschrieben

Die Anwendung verstößt gegen die Datenschutzbestimmungen

Klicken Sie auf Senden Taste.

Tests ausführen

Sie können das Tool go test verwenden, um Tests in Ihrem Projekt wie folgt auszuführen:

Normalerweise führe ich meine Tests mit aktiviertem Go Race Detector durch etwas der Datenrennen, die in der realen Nutzung auftreten können. Wie so:

Es ist wichtig zu beachten, dass die Aktivierung des Race Detectors die Gesamtlaufzeit Ihrer Tests verlängert. Wenn Sie Tests sehr häufig in einem TDD-Workflow ausführen, ziehen Sie es möglicherweise vor, diese nur für einen Testlauf vor dem Festschreiben zu speichern.

Seit 1.10 speichert Go die Testergebnisse auf Paketebene. Wenn sich ein Paket zwischen den Testläufen nicht geändert hat - und Sie dieselben, zwischenspeicherbaren Flags für den Test "go" verwenden -, wird das zwischengespeicherte Testergebnis mit einem "(zwischengespeichert)" daneben angezeigt. Dies ist äußerst hilfreich, um die Testlaufzeit für große Codebasen zu beschleunigen. Wenn Sie die vollständige Ausführung Ihrer Tests erzwingen möchten (und den Cache vermeiden möchten), können Sie das Flag -count = 1 verwenden oder alle zwischengespeicherten Testergebnisse mit dem Tool go clean löschen.

Hinweis: Zwischengespeicherte Testergebnisse werden neben zwischengespeicherten Build-Ergebnissen in Ihrem GOCACHE-Verzeichnis gespeichert. Überprüfen Sie go env GOCACHE, wenn Sie nicht sicher sind, wo sich dies auf Ihrem Computer befindet.

Mit dem Flag -run können Sie den Test auf die Ausführung bestimmter Tests (und Untertests) beschränken. Dies akzeptiert einen regulären Ausdruck und es werden nur Tests ausgeführt, deren Namen mit dem regulären Ausdruck übereinstimmen. Ich kombiniere dies gerne mit dem Flag -v, um den ausführlichen Modus zu aktivieren, damit die Namen der ausgeführten Tests und Untertests angezeigt werden. Dies ist eine nützliche Methode, um sicherzustellen, dass ich den regulären Ausdruck nicht vermasselt habe und die Tests, die ich erwarte, tatsächlich ausgeführt werden!

Ein paar weitere Flags, auf die Sie achten sollten, sind -short (mit denen Sie lang laufende Tests überspringen können) und -failfast (mit denen nach dem ersten Fehler keine weiteren Tests mehr ausgeführt werden). Beachten Sie, dass -failfast verhindert, dass Testergebnisse zwischengespeichert werden.

Seiten speichern

Die Funktion saveHandler übernimmt die Übermittlung der Formulare auf den Bearbeitungsseiten. Nachdem Sie die zugehörige Zeile in main dekommentiert haben, implementieren wir den Handler:

Der Seitentitel (in der URL angegeben) und das einzige Feld des Formulars, Body, werden auf einer neuen Seite gespeichert. Die save () -Methode wird dann aufgerufen, um die Daten in eine Datei zu schreiben, und der Client wird zur / view / -Seite umgeleitet.

Der von FormValue zurückgegebene Wert ist vom Typ string. Wir müssen diesen Wert in Byte konvertieren, bevor er in die Seitenstruktur passt. Wir verwenden Byte (Body), um die Konvertierung durchzuführen.

Profiling-Testabdeckung

Sie können die Coverage-Analyse aktivieren, wenn Sie Tests ausführen, indem Sie das Flag -cover verwenden. Dies zeigt den Prozentsatz des Codes an, der von den Tests in der Ausgabe für jedes Paket abgedeckt wird.

Sie können auch eine generieren Abdeckungsprofil Verwenden Sie das Flag -coverprofile und zeigen Sie es in Ihrem Webbrowser an, indem Sie den Befehl go tool cover -html wie folgt verwenden:

Auf diese Weise erhalten Sie eine navigierbare Liste aller Testdateien, wobei der von den Tests abgedeckte Code in Grün und der nicht abgedeckte Code in Rot angezeigt wird.

Wenn Sie möchten, können Sie einen Schritt weiter gehen und das Flag -covermode = count setzen, damit das Coverage-Profil die exakten Werte aufzeichnet Anzahl dass jede Anweisung während der Tests ausgeführt wird.

Bei der Anzeige im Browser werden Anweisungen, die häufiger ausgeführt werden, in einem gesättigten Grünton angezeigt.

Hinweis: Wenn Sie in einem Ihrer Tests den Befehl t.Parallel () verwenden, sollten Sie statt -covermode = count das Flag -covermode = atomic verwenden, um eine genaue Zählung sicherzustellen.

Wenn für die Anzeige eines Abdeckungsprofils kein Webbrowser verfügbar ist, können Sie mit dem folgenden Befehl eine Aufschlüsselung der Testabdeckung nach Funktion / Methode in Ihrem Terminal anzeigen:

Fehlerbehandlung

In unserem Programm gibt es mehrere Stellen, an denen Fehler ignoriert werden. Dies ist eine schlechte Praxis, nicht zuletzt, weil das Programm unbeabsichtigt reagiert, wenn ein Fehler auftritt. Eine bessere Lösung besteht darin, die Fehler zu behandeln und eine Fehlermeldung an den Benutzer zurückzugeben. Auf diese Weise funktioniert der Server genau so, wie wir es möchten, und der Benutzer kann benachrichtigt werden, wenn etwas schief geht.

Behandeln wir zunächst die Fehler in renderTemplate:

Die Funktion http.Error sendet einen angegebenen HTTP-Antwortcode (in diesem Fall "Internal Server Error") und eine Fehlermeldung. Die Entscheidung, dies in eine separate Funktion zu stellen, zahlt sich bereits aus.

Nun wollen wir saveHandler reparieren:

Alle Fehler, die während p.save () auftreten, werden dem Benutzer gemeldet.

Grundlegendes zu Ihrem Abonnementstatus

Der Status einer Anwendung gibt Auskunft darüber, ob Ihr Abonnement derzeit aktiv ist. Hier ist, was jeder Status bedeutet:

steht aus bedeutet, dass wir gerade Ihr Abonnement einrichten. Wenn Ihr Status länger als 15 Minuten ansteht, wenden Sie sich bitte an den Anwendungsentwickler.

Aktiv bedeutet, dass Ihr Abonnement fertig ist und Sie die Anwendung verwenden können. Bezahlte Abonnements mit einem aktiven Status erscheinen auf Ihrer monatlichen Rechnung.

Ausstehende Stornierung bedeutet, dass Sie die Kündigung Ihres Abonnements beantragt haben. Wenn Sie jedoch eine Anwendung abonnieren, die nicht anteilig ist, haben Sie Zugriff auf die Anwendung, bis Sie die Zeit aufgebraucht haben, die Sie für die Verwaltung benötigt haben anwendungen Seite. Hinweis: Wenn Sie eine Bewerbung sofort stornieren müssen, wenden Sie sich bitte direkt an den Entwickler. While your subscription is pending cancellation, the application's developer will continue to have access to your eBay data.

Cancelled means that you can no longer use the application, and that the application's developer no longer has access to your eBay data. Once a subscription is cancelled, the last charge for it will appear on your next billing statement.

Suspendiert means that you have been temporarily blocked from using the application. This usually means your payment wasn't successful or that there is some other problem with your account. Please contact the application developer to resolve the problem and reinstate your account. Suspended applications continue to be billed.

Click My eBay at the top of most eBay pages. You may be asked to sign in.

Place your pointer over the Applications tab, and click the Manage applications link. Your statu s will be indicated near the top of the page.

Stress Testing

You can use the go test -count command to run a test multiple times in succession, which can be useful if you want to check for sporadic or intermittent failures. Beispielsweise:

In this example, the TestFooBar test will be repeated 500 times in a row. But it's important to note that the test will be repeated in serial — even if it contains a t.Parallel() instruction. So if your test is doing something relatively slow, like making a round trip to a database, hard disk or the internet, running a large number of tests can take quite a long time.

In that case you might want to use the stress tool to repeat the same test multiple times in parallel stattdessen. You can install it like so:

To use the stress tool, you'll first need to compile a test binary for the specific package you want to test. You can do using the go test -c command. For example, to create a test binary for the package in your current directory:

In this example, the test binary will be outputted to /tmp/foo.test . You can then use the stress tool to execute a specific test in the test binary like so:

Note: In the example above I've used the -p flag to restrict the number of parallel processes used by stress to 4. Without this flag, the tool will default to using a number of processes equal to runtime.NumCPU() .

Template caching

There is an inefficiency in this code: renderTemplate calls ParseFiles every time a page is rendered. A better approach would be to call ParseFiles once at program initialization, parsing all templates into a single *Template . Then we can use the ExecuteTemplate method to render a specific template.

First we create a global variable named templates , and initialize it with ParseFiles .

The function template.Must is a convenience wrapper that panics when passed a non-nil error value, and otherwise returns the *Template unaltered. A panic is appropriate here, if the templates can't be loaded the only sensible thing to do is exit the program.

The ParseFiles function takes any number of string arguments that identify our template files, and parses those files into templates that are named after the base file name. If we were to add more templates to our program, we would add their names to the ParseFiles call's arguments.

We then modify the renderTemplate function to call the templates.ExecuteTemplate method with the name of the appropriate template:

Note that the template name is the template file name, so we must append ".html" to the tmpl argument.

Testing all Dependencies

Before you build an executable for release or deployment, or distribute your code publicly, you may want to run the go test all command:

This will run tests on all packages in your module and all dependencies — include testing test dependencies and the necessary standard library packages — and it can help validate that the exact versions of the dependencies being used are compatible with each other. This can take quite a long time to run, but the results cache well so any subsequent tests should be faster in the future. If you want, you could also use go test -short all to skip any long-running tests.

Validation

As you may have observed, this program has a serious security flaw: a user can supply an arbitrary path to be read/written on the server. To mitigate this, we can write a function to validate the title with a regular expression.

First, add "regexp" to the import list. Then we can create a global variable to store our validation expression:

The function regexp.MustCompile will parse and compile the regular expression, and return a regexp.Regexp . MustCompile is distinct from Compile in that it will panic if the expression compilation fails, while Compile returns an error as a second parameter.

Now, let's write a function that uses the validPath expression to validate path and extract the page title:

If the title is valid, it will be returned along with a nil error value. If the title is invalid, the function will write a "404 Not Found" error to the HTTP connection, and return an error to the handler. To create a new error, we have to import the errors package.

Let's put a call to getTitle in each of the handlers:

Introducing Function Literals and Closures

Catching the error condition in each handler introduces a lot of repeated code. What if we could wrap each of the handlers in a function that does this validation and error checking? Go's function literals provide a powerful means of abstracting functionality that can help us here.

First, we re-write the function definition of each of the handlers to accept a title string:

Now let's define a wrapper function that takes a function of the above type, and returns a function of type http.HandlerFunc (suitable to be passed to the function http.HandleFunc ):

The returned function is called a closure because it encloses values defined outside of it. In this case, the variable fn (the single argument to makeHandler ) is enclosed by the closure. The variable fn will be one of our save, edit, or view handlers.

Now we can take the code from getTitle and use it here (with some minor modifications):

The closure returned by makeHandler is a function that takes an http.ResponseWriter and http.Request (in other words, an http.HandlerFunc ). The closure extracts the title from the request path, and validates it with the TitleValidator regexp. If the title is invalid, an error will be written to the ResponseWriter using the http.NotFound function. If the title is valid, the enclosed handler function fn will be called with the ResponseWriter , Request , and title as arguments.

Now we can wrap the handler functions with makeHandler in main , before they are registered with the http package:

Finally we remove the calls to getTitle from the handler functions, making them much simpler:

Try it out!

Recompile the code, and run the app:

Visiting http://localhost:8080/view/ANewPage should present you with the page edit form. You should then be able to enter some text, click 'Save', and be redirected to the newly created page.

Formatting Code

Go provides two tools to automatically format your code according to the Go conventions: gofmt and go fmt . Using these helps keep your code consistent across your files and projects, and — if you use them before committing code — helps reduce noise when examining a diff between file versions.

I like to use the gofmt tool with the following flags:

In these commands, the -w flag instructs the tool to rewrite files in place, the -s instructs the tool to apply simplifications to the code where possible, and the -d flag instructs the tool to output diffs of the changes (because I'm curious to see what is changed). If you want to only display the names of changed files, instead of diffs, you can swap this for the -l flag instead.

Note: The gofmt command works recursively. If you pass it a directory like . or ./cmd/foo it'll format all .go files under the directory.

The other formatting tool — go fmt — tool is a wrapper which essentially calls gofmt -l -w on a specified file or directory. You can use it like this:

Performing Static Analysis

The go vet tool carries out static analysis of your code and warns you of things which might be wrong with your code but wouldn't be picked up by the compiler. Issues like unreachable code, unnecessary assignments and badly-formed build tags. You can use it like so:

Behind the scenes, go vet runs a bunch of different analyzers which are listed here and you can disable specific ones on a case-by-case basis. For example to disable the composite analyzer you can use:

There are a couple of experimental analyzers in golang.org/x/tools which you might want to try: nilness (which checks for redundant or impossible nil comparisons) and shadow (which check for possible unintended shadowing of variables). If you want to use these, you'll need to install and run them separately. For example, to install nilness you would run:

And you can then use it like so:

Note: when the -vettool flag is used it will only run the specified analyzer — all the other go vet analyzers won't be run.

As a side note, since Go 1.10 the go test tool automatically executes a small, high-confidence, subset of the go vet checks before running any tests. You can turn this behavior off when running tests like so:

Linting Code

You can use the golint tool to identify style mistakes in your code. Unlike go vet , this isn't concerned with correctness of the code, but helps you to align your code with the style conventions in Effective Go and the Go CodeReviewComments.

It's not part of the standard library, so you'll need to install it like so:

You can then run it as follows:

Tidying and Verifying your Dependencies

Before you commit any changes to your code I recommend running the following two commands to tidy and verify your dependencies:

The go mod tidy command will prune any unused dependencies from your go.mod and go.sum files, and update the files to include dependencies for all possible build tags/OS/architecture combinations (note: go run , go test , go build etc are ‘lazy' and will only fetch packages needed for the current build tags/OS/architecture). Running this before each commit will make it easier to determine which of your code changes were responsible for adding or removing which dependencies when looking at the version control history.

I also recommend using the go mod verify command to check that the dependencies on your computer haven't accidentally (or purposely) been changed since they were downloaded and that they match the cryptographic hashes in your go.sum file. Running this helps ensure that the dependencies being used are the exact ones that you expect, and any build for that commit will be reproducible at a later point.

Building an Executable

To compile a main package and create an executable binary you can use the go build tool. Typically I use it in conjunction with the -o flag, which let's you explicitly set the output directory and name of the binary like so:

In these examples, go build will kompilieren the specified package (and any dependent packages), then invoke the linker to generate an executable binary, and output this to /tmp/foo .

It's important to note that, as of Go 1.10, the go build tool caches build output in the build cache. This cached output will be reused again in future builds where appropriate, which can significantly speed up the overall build time. This new caching behavior means that the old maxim of “prefer go install to go build to improve caching” no longer applies.

If you're not sure where your build cache is, you can check by running the go env GOCACHE command:

Using the build cache comes with one important caveat — it does not detect changes to C libraries imported with cgo . So if your code imports a C library via cgo and you've made changes to it since the last build, you'll need to use the -a flag which forces all packages to be rebuilt. Alternatively, you could use go clean to purge the cache:

Note: Running go clean -cache will delete cached test results too.

If you're interested in what go build is doing behind the scenes, you might like to use the following commands:

Finally, if you run go build on a non- main package, it will be compiled in a temporary location and again, the result will be stored in the build cache. No executable is produced.

Still need help?

The Atlassian Community is here for you.

Application Links (sometimes called "app links") is a bundled app that allows you to set up links, share information, and provide access to certain resources or functionality across multiple Atlassian products. We recommend using OAuth authentication for application links because of the greater security inherent with that protocol. We no longer recommend the Trusted Applications and Basic authentication types.

Linking JIRA to other applications allows you to include information from these systems in JIRA projects and issues. For example, if you link JIRA to Confluence, you can include pointers to wiki pages when creating or editing issues. Another common use case is to link Bitbucket Server with JIRA, this allows you to view branches, commits and pull requests that correspond to your stories in JIRA. In addition to Atlassian applications, you can also link to external applications, for example, you might use a plugin that allows you to share ZenDesk or Salesforce data via an application link.

Cross-Compilation

This is one of my favorite features of Go.

By default go build will output a binary suitable for use on your current operating system and architecture. But it also supports cross-compilation, so you can generate a binary suitable for use on a different machine. This is particularly useful if you're developing on one operating system and deploying on another.

You can specify the operating system and architecture that you want to create the binary for by setting the GOOS and GOARCH environment variables respectively. Beispielsweise:

To see a list of all supported OS/architecture combinations you can run go tool dist list :

Hint: You can use Go's cross-compilation to create WebAssembly binaries.

For a bit more in-depth information about cross compilation I recommend reading this excellent post.

Create an application link

  1. Log in to JIRA as a user with 'JIRA Administrator' permissions.
  2. Wählen >Anwendungen. Wählen Application Links in the left menu.

Enter the URL of the application you want to link to, then click Create new link.

  • If you check The servers have the same set of users. then this link will be configured using OAuth (with impersonation) authentication.
  • If you are nicht an admin on both servers you won't be able to set up a 2-way (reciprocal) application link. If you want to go ahead and create a 1-way link anyway, clear the I am an administrator on both instances checkbox.

Use the wizard to finish configuring the link. If the application you are linking to does not have the Application Links plugin, you must supply additional information to set up a link with OAuth authentication.

When you complete the wizard, the Application Links plugin will create the link between your applications using the most secure authentication method that is supported between the two applications. See the Application Links User Guide for more information.

The new link will appear on the "Configure Application Links" page, where you can:

  • Edit the settings of the application link (for example, to change the authentication type of the link) using the Bearbeiten Symbol.
  • Specify the default instance if you have multiple links to the same type of application (for example, to multiple Jira servers) using the Make Primary link. See Making a primary link for links to the same application type for more information.

Using Compiler and Linker Flags

When building your executable you can use the -gcflags flag to change the behavior of the compiler and see more information about what it's doing. You can see a complete list of available compiler flags by running:

One flag that you might find interesting is -m , which triggers the printing of information about optimization decisions made during compilation. You can use it like this:

In the above example I used the -m flag twice to indicate that I want to print decision information two-levels deep. You can get simpler output by using just one.

Also, as of Go 1.10, compiler flags only apply to the specific packages passed to go build — which in the example above is the package in the current directory (represented by . ). If you want to print optimization decisions for all packages including dependencies can use this command instead:

As of Go 1.11, you should find it easier to debug optimized binaries than before. However, you can still use the flags -N to disable optimizations and -l to disable inlining if you need to. Beispielsweise:

You can see a list of available linker flags by running:

Probably the most well-known of these is the -X flag, which allows you to "burn in" a (string) value to a specific variable in your application. This is commonly used to add a version number or commit hash. Beispielsweise:

For more information about the -X flag and some sample code see this StackOverflow question and this post and this post.

You may also be interested in using the -s and -w flags to strip debugging information from the binary. This typically shaves about 25% off the final size. Beispielsweise:

Note: If binary size is something that you need to optimize for you might want to use upx to compress it. See this post for more information.

OAuth authentication

OAuth authentication redirects a user to log in to the remote application, after which tokens generated on their behalf are used to authorize requests made from the local application. The remote application handling the request uses the access permissions of the account with which the user logged in on that remote application.

Typical scenarios include:

  • You are setting up an application link between two applications that do not share the same set of users.
  • You want to continue using a link to an application that now allows public sign-on and the link was previously configured with a shared userbase. You can update your application link by changing OAuth (impersonation)zu OAuth when editing the application link.

Running and Comparing Benchmarks

A nice feature of Go is that it makes it easy to benchmark your code. If you're not familiar with the general process for writing benchmarks there are good guides here and here.

To run benchmarks you'll need to use the go test tool, with the -bench flag set to a regular expression that matches the benchmarks you want to execute. Beispielsweise:

I almost always run benchmarks using the -benchmem flag, which forces memory allocation statistics to be included in the output.

By default, each benchmark test will be run for a minimum of 1 second, once only. You can change this with the -benchtime and -count flags:

If the code that you're benchmarking uses concurrency, you can use the -cpu flag to see the performance impact of changing your GOMAXPROCS value (essentially, the number of OS threads that can execute your Go code simultaneously). For example, to run benchmarks with GOMAXPROCS set to 1, 4 and 8:

To compare changes between benchmarks you might want to use the benchcmp tool. This isn't part of the standard go command, so you'll need to install it like so:

You can then use it like this:

OAuth with impersonation

Atlassian OAuth with impersonation makes it easy for your users to benefit from the deep integrations between Atlasssian applications:

  • they're automatically authenticated on the other application and don't get asked to authorize requests.
  • they'll only see the information that they have permission to see.

Impersonating authentication makes requests on behalf of the user who is currently logged in.

Note that Atlassian OAuth with impersonation can only be used for application links between Atlassian applications. Furthermore, it should only be used when the two applications share the same userbase, typically managed with an external directory using LDAP.

A typical scenario is:

  • You've set up an application link but your users still have to authenticate regularly. This can occur when the application link has been configured to not share the same userbase. If those applications do share the same userbase, you can update your application link by selecting OAuth (impersonation)when editing the application link.

Linking to developer tools

When you create a new application link between JIRA and an instance of Bitbucket Server, FishEye, Crucible or Bamboo, 2-legged (2LO) and 3-legged OAuth (3LO) are enabled by default. 2LO is required for information from any of those applications to be included in the summaries in the Development panel, 3LO is used to ensure that a user has authenticated with the other applications before they get to see the information in any of the details dialogs.

An existing application link between JIRA and Bitbucket Server, FishEye, Crucible or Bamboo (that perhaps used Trusted Apps authentication) needs to have 2-legged authentication (2LO) enabled for both outgoing and incoming authentication, so that information from the application can be included in the Development panel summaries.

When updating an older application link to use OAuth, 3-legged authentication is applied by default, but you need to explicitly enable 2LO. Enable 2-legged authentication for the application link from within JIRA as follows:

  1. Go to the JIRA admin area and click Anwendungen.
  2. Klicken Bearbeiten for the app link with the other application.
  3. For both Outgoing Authentication und Incoming Authentication:
    1. Klicken OAuth
    2. Check Allow 2-legged OAuth.
    3. Klicken Update.

The application link update process will involve logging you into the other application for a short time to configure that end of the link, before returning you to JIRA.

Profiling and Tracing

Go makes it possible to create diagnostic Profile for CPU use, memory use, goroutine blocking and mutex contention. You can use these to dig a bit deeper and see exactly how your application is using (or waiting on) resources.

There are three ways to generate profiles:

  • If you have a web application you can import the net/http/pprof package. This will register some handlers with the http.DefaultServeMux which you can then use to generate and download profiles for your running application. This post provides a good explanation and some sample code.
  • For other types of applications, you can profile your running application using the pprof.StartCPUProfile() and pprof.WriteHeapProfile() functions. See the runtime/pprof documentation for sample code.
  • Or you can generate profiles while running benchmarks or tests by using the various -***profile flags like so:

Note: Using the -***profile flags when running benchmarks or tests will result in a test binary being outputted to your current directory. If you want to output this to an alternative location you should use the -o flag like so:

Whichever way you choose to create a profile, when profiling is enabled your Go program will stop about 100 times per second and take a snapshot at that moment in time. These samples are collected together to form a profile that you can analyze using the pprof tool.

My favourite way to inspect a profile is to use the go tool pprof -http command to open it in a web browser. Beispielsweise:

This will default to displaying a graph showing the execution tree for the sampled aspects of your application, which makes it possible to quickly get a feel for any resource usage 'hotspots'. In the graph above, we can see that the hotspots in terms of CPU usage are two system calls originating from ioutil.ReadFile() .

You can also navigate to other views of the profile including top usage by function and source code.

If the amount of information is overwhelming, you might want to use the --nodefraction flag to ignore nodes that account for less than a certain percentage of samples. For example to ignore nodes that use appear in less than 10% of samples you can run pprof like so:

This makes the graph a lot less 'noisy' and if you zoom in on this screenshot, it's now much clearer to see and understand where the CPU usage hotspots are.

Profiling and optimizing resource usage is big, nuanced, topic and I've barely scratched the surface here. If you're interested in knowing more then I encourage you to read the following blog posts:

Another tool that you can use to help diagnose issues is the runtime execution tracer. This gives you a view of how Go is creating and scheduling goroutines to run, when the garbage collector is running, and information about blocking syscall/network/sync operations.

Again, you can generate trace from your tests or benchmarks, or use net/http/pprof to create and download a trace for your web application. You can then use go tool trace to view the output in your web browser like so:

Important: This is currently only viewable in Chrome/Chromium.

For more information about Go's execution tracer and how to interpret the output please see Rhys Hiltner's dotGo 2016 talk and this excellent blog post.

Fehlerbehebung

Having trouble integrating your Atlassian products with application links?

We've developed a guide to troubleshooting application links, to help you out. Take a look at it if you need a hand getting around any errors or roadblocks with setting up application links.

Checking for Race Conditions

I talked earlier about enabling Go's race detector during tests by using go test -race . But you can also enable it for running programs when building a executable, like so:

It's critical to note that race-detector-enabled binaries will use more CPU and memory than normal, so you shouldn't use the -race flag when building binaries for production under normal circumstances.

But you may want to deploy a race-detector-enabled binary on one server within a pool of many. Or use it to help track down a suspected race-condition by using a load-test tool to throw traffic concurrently at a race-detector-enabled binary.

By default, if any races are detected while the binary is running a log will be written to stderr . You can change this by using the GORACE environment variable if necessary. For example, to run the binary located at /tmp/foo and output any race logs to /tmp/race.

Managing Dependencies

You can use the go list tool to check whether a specific dependency has a newer version available like so:

This will output the dependency name and version that you're currently using, followed by the latest version in square brackets , if a newer one exists. You can also use go list to check for updates to all dependencies (and sub-dependencies) like so:

You can upgrade (or downgrade) a dependency to the latest version, specific tagged-release or commit hash with the go get command like so:

If the dependency you're updating has a go.mod file, then based on the information in this go.mod file, updates to any sub-dependencies will also be downloaded if necessary. If you use the go get -u flag, the contents of the go.mod file will be ignored and all sub-dependencies will be upgraded to their latest minor/patch version… even if the go.mod specifies a different version.

After upgrading or downgrading any dependencies it's a good idea to tidy your modfiles. And you might also want to run the tests for all packages to help check for incompatibilities. Like so:

Occasionally you might want to use a local version of a dependency (for example, you need to use a local fork until a patch is merged upstream). To do this, you can use the go mod edit command to replace a dependency in your go.mod file with a local version. Beispielsweise:

This will add a replace rule to your go.mod file like so, and any future invocations of go run , go build etc will use the local version.

Once it's no longer necessary, you can remove the replace rule with the command:

You can use the same general technique to import packages that exist only on your own file system. This can be useful if you're working on multiple modules in development at the same time, one of which depends on the other.

Note: If you don't want to use the go mod edit command, you can edit your go.mod file manually to make these changes. Either way will work.

Upgrading to a New Go Release

The go fix tool was originally released back in 2011 (when regular changes were still being made to Go's API) to help users automatically update their old code to be compatible with the latest version of Go. Since then, Go's compatibility promise means if you're upgrading from one Go 1.x version to a newer 1.x version everything should Just Work and using go fix should generally be unnecessary.

However, there are a handful of very specific issues that it does deal with. You can see a summary of them by running go tool fix -help . If you decide that you want or need to run go fix after upgrading, you should you run the following command, then inspect a diff of the changes before you commit them.

Reporting Bugs

If you're confident that you've found an unreported issue with Go's standard library, tooling or documentation, you can use the go bug command to create a new Github issue.

This will open a browser window containing an issue pre-filled with your system information and reporting template.

Cheatsheet

Update 2019-04-19: @FedirFR has kindly made a cheatsheet based on this post. Sie können es hier herunterladen.

If you enjoyed this blog post, don't forget to check out my new book about how to build professional web applications with Go!

Follow me on Twitter @ajmedwards.

All code snippets in this post are free to use under the MIT Licence.

Schau das Video: App Links Assistant in Android Studio - Android Tool Time (Dezember 2019).