קישורי אפליקציה

כאשר קישור או בקשה פרוגרמטית מופעלת כוונת URI באינטרנט, מערכת אנדרואיד מנסה כל אחת מהפעולות הבאות, בסדר רצוף, עד שהבקשה תצליח:

  1. פתח את האפליקציה המועדפת על המשתמש שיכולה להתמודד עם ה- URI, אם ייעוד כזה.
  2. פתח את האפליקציה הזמינה היחידה שיכולה להתמודד עם ה- URI.
  3. אפשר למשתמש לבחור יישום מתוך דיאלוג.

עקוב אחר הצעדים שלהלן כדי ליצור ולבדוק קישורים לתוכן שלך. אתה יכול גם להשתמש בעוזר קישורי האפליקציות ב- Android Studio כדי להוסיף קישורי אפליקציות לאנדרואיד.

הוסף מסנני כוונה לקישורים נכנסים

כדי ליצור קישור לתוכן האפליקציה שלך, הוסף מסנן כוונות המכיל אלמנטים אלה וערכי תכונה במניפסט שלך:

ציין את פעולת הכוונה ACTION_VIEW כך שניתן יהיה להגיע אל מסנן הכוונות מחיפוש Google. הוסף תגית אחת או יותר, שכל אחת מהן מייצגת פורמט URI אשר פותר לפעילות. לכל הפחות, התג צריך לכלול את התכונה של אנדרואיד: סכמה.

אתה יכול להוסיף תכונות נוספות כדי לחדד עוד יותר את סוג ה- URI שהפעילות מקבלת. לדוגמה, יתכנו פעילויות מרובות שמקבלות URIs דומים, אך נבדלות זו מזו פשוט על סמך שם הנתיב. במקרה זה, השתמש במאפיין Android: path או בנתיביו Pattern או pathPrefix כדי להבדיל איזו פעילות המערכת צריכה לפתוח לנתיבי URI שונים.

כלול את הקטגוריה BROWSABLE. זה נדרש על מנת שמסנן הכוונות יהיה נגיש מדפדפן אינטרנט. בלעדיו, לחיצה על קישור בדפדפן לא יכולה לפתור את האפליקציה שלך.

כלול גם את הקטגוריה DEFAULT. זה מאפשר לאפליקציה שלך להגיב לכוונות מרומזות. בלי זה, ניתן להתחיל בפעילות רק אם הכוונה מציינת את שם רכיב האפליקציה שלך.

קטע ה- XML ​​הבא מראה כיצד תוכל לציין מסנן כוונות במניפסט שלך לקישור עמוק. URIs "דוגמה: // gizmos" ו- "http://www.example.com/gizmos" שניהם פותרים לפעילות זו.

שימו לב ששני מסנני הכוונות נבדלים זה מזה בלבד. למרות שאפשר לכלול מספר אלמנטים באותו פילטר, חשוב שתיצור מסננים נפרדים כאשר הכוונה שלך היא להכריז על כתובות אתרים ייחודיות (כמו שילוב ספציפי של ערכה ומארח), מכיוון שמספר אלמנטים באותו מסנן כוונות מוזגים למעשה. יחד כדי להסביר את כל הווריאציות של התכונות המשולבות שלהם. לדוגמה, שקול את הדברים הבאים:

נראה כי הדבר תומך רק ב https://www.example.com ובאפליקציה: //open.my.app. עם זאת, הוא למעשה תומך בשניים האלה, ובנוסף אלה: app: //www.example.com ו- https://open.my.app.

לאחר שהוספת מסנני כוונות עם URI לתכני פעילות למניפסט האפליקציה שלך, Andro> Intent שיש לו URIs התואמים לאפליקציה שלך בזמן ריצה.

למידע נוסף על הגדרת מסנני כוונות, ראה אפשר לאפליקציות אחרות להתחיל את הפעילות שלך.

הגדרת קישורי אפליקציה

הוספת קישורי אפליקציה לתוכן הקיים שלך
אתה יכול לגלות את תוכן האינטרנט הקיים שלך בפני לקוחות ניידים התומכים בקישורי אפליקציות. כשאנשים לוחצים על קישורים לתוכן הקיים שלך דרך לקוחות נתמכים, הם יכולים לטעון את התוכן באפליקציה שלך במקום לצפייה באינטרנט.

יישומים
ספריות מסוימות שיעזרו לכם ליישם קישורי אפליקציה במהירות.

דוגמאות לאפליקציות ב- GitHub
סיפקנו כמה אפליקציות לדוגמא בהן תוכלו להשתמש כבסיס לשינוי האפליקציה שלכם כך שתתמוך בקישורי אפליקציות.

שיטות עבודה מומלצות
למד שיטות עבודה מומלצות להגדרת קישורי אפליקציות.

קרא נתונים מכוונות נכנסות

ברגע שהמערכת תתחיל את הפעילות שלך באמצעות מסנן כוונות, תוכל להשתמש ב prov prov> כוונה כדי לקבוע מה אתה צריך לספק. התקשר לשיטות getData () ו- getAction () לאחזור הנתונים והפעולה הקשורים לכוונה הנכנסת. ניתן להתקשר לשיטות אלה בכל עת במהלך מחזור החיים של הפעילות, אך בדרך כלל עליכם לעשות זאת במהלך התקשרות חוזרת מוקדמת כמו onCreate () או onStart ().

להלן קטע שמראה כיצד לאחזר נתונים מכוונה:

מבוא

מכוסה במדריך זה:

  • יצירת מבנה נתונים בשיטות עומס ושמירה
  • שימוש בחבילת net / http לבניית יישומי אינטרנט
  • שימוש בחבילת html / template לעיבוד תבניות HTML
  • שימוש בחבילת regexp כדי לאמת את קלט המשתמש
  • באמצעות סגרים

  • חווית תכנות
  • הבנת טכנולוגיות אינטרנט בסיסיות (HTTP, HTML)
  • קצת ידע בשורת הפקודה של UNIX / DOS

לקוחות ניידים

תמיכה בקישורים נכנסים ל- iOS
למד כיצד לתמוך בקישורים ליישום iOS שלך. למד גם על דרישות ה- UX הייחודיות ל- iOS ו- widgets מוגדרים מראש בהן תוכלו להשתמש כדי להקל על הניווט בין היישומים.

תמיכה בקישורים נכנסים לאנדרואיד
תומך בקישורים נכנסים לאפליקציית Android שלך.

קוטלין

עקוב אחר שיטות העבודה המומלצות הבאות כדי לשפר את חווית המשתמש:

  • הקישור העמוק אמור להביא משתמשים ישירות לתוכן, ללא כל הנחיות, דפי ביניים או כניסות. וודאו שמשתמשים יוכלו לראות את תוכן האפליקציה גם אם הם מעולם לא פתחו את היישום. זה בסדר לפנות למשתמשים על אינטראקציות עוקבות או כאשר הם פותחים את האפליקציה מהמשגר. זה אותו עיקרון כמו חוויית הקליק הראשון בחינם לאתרי אינטרנט.
  • עקוב אחר הנחיות התכנון המתוארות בניווט עם גיבוי ומעלה כך שהאפליקציה שלך תואמת את הציפיות של המשתמשים לניווט לאחור לאחר שהם נכנסים לאפליקציה שלך דרך קישור עמוק.

התקנת כלי

בפוסט זה אתמקד בעיקר בכלים שהם חלק מפקודת ה- go. אבל יש כמה שאציין שלא נמנים עם המהדורה הרגילה של Go 1.12.

כדי להתקין את אלה תוך שימוש ב- Go 1.12 תחילה עליך לוודא שאתה בחוץ של ספרייה מופעלת מודול (אני בדרך כלל רק מתחלף / tmp). אז אתה יכול להשתמש בפקודה GO111MODULE = בדרכים קבל להתקנת הכלי. לדוגמה:

זה יוריד את החבילה והתלות הרלוונטיות, יבנה את ההפעלה ותוסיף אותה לספריית GOBIN שלך. אם לא הגדרת במפורש ספריית GOBIN, ההפעלה תתווסף לתיקיית GOPATH / bin שלך. כך או כך, עליך לוודא שהספרייה המתאימה נמצאת בנתיב המערכת שלך.

הערה: תהליך זה מעט מגושם ובתקווה ישתפר בגירסאות עתידיות של Go. גיליון 30515 עוקב אחר הדיון בנושא.

מתחילים

נכון לעכשיו, אתה צריך מחשב FreeBSD, Linux, OS X או Windows כדי להפעיל את Go. אנו נשתמש ב- $ כדי לייצג את שורת הפקודה.

צרו מדריך חדש ללימוד זה בתוך ה- GOPATH שלכם והתקליטור אליו:

צור קובץ בשם wiki.go, פתח אותו בעורך המועדף עליך והוסף את השורות הבאות:

אנו מייבאים את חבילות ה- fmt והיוטיל מהספרייה הרגילה של Go. בהמשך, כשאנו מיישמים פונקציונליות נוספת, נוסיף חבילות נוספות להצהרת ייבוא ​​זו.

פרוטוקול ניווט

תמיכה בקישורים יוצאים לאפליקציות אחרות
למד כיצד לקשר ליישומים אחרים באמצעות ממשק ה- API של אינדקס קישורים לפייסבוק ובפרוטוקול הניווט של קישורי אפליקציות.

ממשק API של אינדקס קישורים לפייסבוק
פייסבוק מספקת נקודת קצה של גרפי API לחיפוש נתונים עבור כתובות אתרים התומכות בתקן קישורי האפליקציות.

הפניה למטא נתונים
התייחסות מלאה לסוגי המטא נתונים שאתה יכול להוסיף לדפי אינטרנט כדי לתמוך בקישורי אפליקציות.

בדוק את הקישורים העמוקים שלך

אתה יכול להשתמש ב- Android Debug Bridge עם כלי מנהל הפעילות (am) כדי לבדוק כי ה- URI של סינון הכוונות שציינת לצורך פיתרון של קישור עמוק לפעילות האפליקציה הנכונה. אתה יכול להריץ את הפקודה adb נגד מכשיר או אמולטור.

התחביר הכללי לבדיקת URI למסנן כוונות עם adb הוא:

לדוגמה, הפקודה שלמטה מנסה להציג פעילות אפליקציית יעד המשויכת ל- URI שצוין.

הכרזת המניפסט ומטרת הכוונות שהגדרת למעלה מגדירה את הקשר בין האפליקציה שלך לאתר ומה לעשות עם קישורים נכנסים. עם זאת, על מנת שהמערכת תתייחס לאפליקציה שלך כמטפל ברירת המחדל עבור קבוצת URI, עליך לבקש שהמערכת תאמת חיבור זה. השיעור הבא מסביר כיצד ליישם אימות זה.

למידע נוסף על כוונות וקישורי אפליקציות, עיין במשאבים הבאים:

דגימות תוכן וקוד בעמוד זה כפופות לרישיונות המתוארים ברישיון התוכן. Java היא סימן מסחרי רשום של אורקל ו / או שלוחותיה.

הצגת מידע על הסביבה

אתה יכול להשתמש בכלי go env כדי להציג מידע על סביבת ההפעלה הנוכחית שלך ב- Go. זה יכול להיות שימושי במיוחד אם אתה עובד על מכונה לא מוכרת.

אם יש ערכים ספציפיים שאתה מעוניין בהם, אתה יכול להעביר אותם כטיעונים לביצוע env. לדוגמה:

כדי להציג תיעוד עבור כל משתני ה- env ​​והערכים שאתה יכול להפעיל:

מבני מידע

נתחיל בהגדרת מבני הנתונים. וויקי מורכב מסדרת דפים קשורים זה בזה, שלכל אחד מהם יש כותרת וגוף (תוכן העמוד). כאן אנו מגדירים את Page כמבנה עם שני שדות המייצגים את הכותרת והגוף.

פירושו של בייט מסוג "פרוסת בתים". (ראה פרוסות: שימוש ופנימיות למידע נוסף על פרוסות.) אלמנט ה- Body הוא בייט ולא מחרוזת מכיוון שזהו הסוג שמצפה ספריות io בהן אנו משתמשים, כפי שתראה בהמשך.

מבנה העמודים מתאר כיצד נתוני העמודים יאוחסנו בזיכרון. אבל מה עם אחסון מתמשך? אנו יכולים לטפל בכך על ידי יצירת שיטת שמירה בדף:

על חתימה של שיטה זו נכתב: "זוהי שיטה בשם save שלוקח כמקלט p שלה, מצביע לדף. היא אינה מצליחה לקחת פרמטרים ומחזירה ערך של שגיאת סוג."

שיטה זו תשמור את גוף העמוד בקובץ טקסט. לשם הפשטות אנו נשתמש בכותרת כשם הקובץ.

שיטת השמירה מחזירה ערך שגיאה מכיוון שזהו סוג ההחזרה של WriteFile (פונקצית ספרייה רגילה שכותבת פרוסת בייט לקובץ). שיטת השמירה מחזירה את ערך השגיאה, כדי לאפשר ליישום להתמודד עם זה אם כל דבר ישתבש בזמן כתיבת הקובץ. אם הכל מסתדר, Page.save () יחזיר את האפס (ערך האפס עבור מצביעים, ממשקים וכמה סוגים אחרים).

ספרות 0600 שלם האותלי המילולי, שהועבר כפרמטר השלישי ל- WritFile, מציין שיש ליצור את הקובץ עם הרשאות קריאה לקריאה למשתמש הנוכחי בלבד. (ראה את עמוד האיש של יוניקס פתוח (2) לפרטים.)

בנוסף לשמירת דפים, נרצה לטעון גם דפים:

הפונקציה loadPage בונה את שם הקובץ מהפרמטר של הכותרת, קורא את תוכן הקובץ לגוף משתנה חדש ומחזיר מצביע לספר מילולי עמוד שנבנה עם הכותרת וערכי הגוף הנכונים.

פונקציות יכולות להחזיר ערכים מרובים. פונקציית הספרייה הסטנדרטית io.ReadFile מחזירה בתים ושגיאה. ב loadPage טרם מטופלים שגיאות, "המזהה הריק" המיוצג על ידי סמל הדגש (_) משמש לזריקת ערך החזרת השגיאה (למעשה, הקצאת הערך לכלום).

אך מה קורה אם ReadFile נתקל בשגיאה? לדוגמה, ייתכן שהקובץ לא קיים. אל לנו להתעלם משגיאות כאלה. בואו לשנות את הפונקציה כדי להחזיר * דף ושגיאה.

המתקשרים לפונקציה זו יכולים כעת לבדוק את הפרמטר השני, אם הוא אפסי אז הוא העמיס בהצלחה דף. אם לא, זו תהיה שגיאה שניתן להתמודד עם המתקשר (עיין בפרטי השפה לפרטים).

בשלב זה יש לנו מבנה נתונים פשוט והיכולת לשמור וקובץ לטעון אותו. בואו נכתוב פונקציה עיקרית כדי לבדוק את מה שכתבנו:

לאחר ההרכבה והביצוע של קוד זה, ייווצר קובץ בשם TestPage.txt המכיל את התוכן של p1. לאחר מכן נקרא הקובץ אל ה- p2 של מבנה, ואלמנט ה- Body שלו מודפס על המסך.

אתה יכול להרכיב ולהפעיל את התוכנית כך:

(אם אתה משתמש ב- Windows, עליך להקליד "wiki" ללא "./" כדי להפעיל את התוכנית.)

אודות מרכז האפליקציות

מרכז האפליקציות מציג מגוון יישומים הניתנים לשילוב ב- eBay שלי ועוזרים לכם בפעילויות ה- eBay שלכם.

יישומים אלה מפותחים על ידי צדדים שלישיים, ובמקרים מסוימים על ידי eBay. ליישומים שפותחו על ידי ספקים מוסמכים ב- eBay יש את הסמל שירותי ספקי eBay המאושרים. ספקים מוסמכים ב- eBay מצטיינים ביצירת כלים ושירותים למשתמשי eBay.

מרכז האפליקציות כולל תיאורים של היישומים ופרטים על תמחור ודרישות.

פייסבוק אנליטיקס

הוסף קישורי אפליקציה לאפליקציה שלך
פייסבוק מקלה לראות כיצד אנשים משתמשים בקישורי אפליקציה באפליקציה שלך. על ידי ניתוח מגמות לגבי מידע על תנועה ושימוש באמצעות קישורי אפליקציות, תוכלו לראות את הערך של קישורי אפליקציה וליצור חוויות טובות יותר לאנשים.

הצגת חבילת ה- net / http (הפוגה)

להלן דוגמה מלאה לעבוד על שרת אינטרנט פשוט:

הפונקציה הראשית מתחילה בשיחה אל http.HandleFunc, המורה לחבילת http לטפל בכל הבקשות לשורש האינטרנט ("/") באמצעות המטפל.

לאחר מכן הוא מתקשר ל- http.ListenAndServe, ומציין שהוא צריך להאזין ביציאה 8080 בכל ממשק (": 8080"). (אל תדאגו לפרמטר השני שלו, אפסי, לעת עתה.) פונקציה זו תחסום עד להפסקת התוכנית.

ListenAndServe מחזיר תמיד שגיאה מכיוון שהיא חוזרת רק כאשר מתרחשת שגיאה בלתי צפויה. על מנת לרשום את השגיאה הזו אנו עוטפים את שיחת הפונקציה באמצעות log.Fatal.

מטפל הפונקציות הוא מסוג http.HandlerFunc. זה לוקח http.ResponseWriter ו- http.Request כטיעונים שלו.

ערך http.ResponseWriter מרכיב את תגובת שרת ה- HTTP, על ידי כתיבה אליו אנו שולחים נתונים ללקוח HTTP.

Http.Request הוא מבנה נתונים המייצג את בקשת HTTP של הלקוח. r.URL.Path הוא רכיב הנתיב של כתובת האתר לבקשה. הנגרר 1: פירושו "צור פרוסת משנה של הנתיב מהדמות הראשונה עד הסוף." פעולה זו מורידה את המפתח "/" משם הנתיב.

אם אתה מפעיל תוכנית זו וגישה לכתובת האתר:

התוכנית תציג דף הכולל:

מציאת אפליקציה

אתה יכול לחקור את היישומים הזמינים עבור eBay כדי למצוא יישומים שמתאימים לצרכים העסקיים שלך.

מקם את המצביע מעל היישומים לחץ על הכרטיסיה ואז לחץ על נהל יישומים קישור.

על ניהול האפליקציות לחץ על הדף עבור אל מרכז האפליקציות קישור.

במרכז האפליקציות בדוק את היישומים על ידי:

בחירת קטגוריה של יישומים שמעניינים אותך מהרשימה תחת מכירת אפליקציות בצד שמאל של הדף

באמצעות חיפוש בראש הדף להזנת מילות מפתח

בחירת היישום המוצג או גלישה אחרונה והפופולרי ביותר רשימות של יישומים
טיפ: אם אתה זקוק לעזרה במציאת אפליקציה, לחץ על טיפים לחיפוש קישור מימין לתיבת החיפוש בראש העמוד.

עיין בתיאור המפתח של פונקציית היישום ותמחורו, ולמד אודות היזם.

קוד ריצה

במהלך הפיתוח כלי הריצה הוא דרך נוחה לנסות את הקוד שלך. זהו למעשה קיצור דרך שמרכיב את הקוד שלך, יוצר בינארי הניתן להפעלה בספריית / tmp שלך ואז מפעיל בינארי זה בצעד אחד.

הערה: החל מדרך 1.11 אתה יכול לעבור את הנתיב של חבילה לריצה, כמו שיש לנו למעלה. פירוש הדבר שאתה כבר לא צריך להשתמש בפתרון דרכים כגון go run * .go הרחבת תווים כלליים כדי להריץ קבצים מרובים. אני הכי אוהב את השיפור הזה!

באמצעות net / http לשרת דפי Wiki

כדי להשתמש בחבילת net / http, יש לייבא אותה:

בואו ליצור מטפל, viewHandler שיאפשר למשתמשים להציג דף wiki. זה יטפל בכתובות URL שהתחלפו עם "/ view /".

שוב, שימו לב לשימוש ב- _ להתעלמות מערך החזרת השגיאה מ- loadPage. זה נעשה כאן לשם פשטות ובדרך כלל נחשב לתרגול רע. אנו נטפל בזה בהמשך.

ראשית, פונקציה זו מחלצת את כותרת העמוד מ- r.URL.Path, רכיב הנתיב של כתובת האתר לבקשה. הנתיב נפרס מחדש עם len ("/ view /"): כדי להוריד את רכיב ה- "/ view /" המוביל של נתיב הבקשה. הסיבה לכך היא שהנתיב תמיד יתחיל ב- "/ view /", שאינו חלק מכותרת העמוד.

לאחר מכן הפונקציה טוענת את נתוני העמודים, מעצבת את הדף במחרוזת HTML פשוטה וכותבת אותם ל- w, http.ResponseWriter.

כדי להשתמש במטפל זה, אנו כותבים מחדש את הפונקציה העיקרית שלנו לאתחל http באמצעות viewHandler כדי לטפל בבקשות מתחת לנתיב / view /.

בואו ליצור כמה נתוני דפים (כ test.txt), נרכיב את הקוד שלנו וננסה להגיש דף wiki.

פתח את קובץ test.txt בעורך שלך ושמור בו את המחרוזת "Hello world" (ללא ציטוטים).

(אם אתה משתמש ב- Windows, עליך להקליד "wiki" ללא "./" כדי להפעיל את התוכנית.)

כששרת אינטרנט זו פועלת, ביקור בכתובת http: // localhost: 8080 / view / test צריך להציג דף שכותרתו "test" המכיל את המילים "Hello world".

מנוי לאפליקציה

כשאתה נרשם לאפליקציה אתה נרשם עם מפתח האפליקציות, אם כי אנו מקלים על המינוי והשימוש ביישום. למידע נוסף על תמחור ותשלומים עבור יישומים.

במרכז Apps, לחץ על היישום שאתה מעוניין בו.

בדף שמתאר את היישום, לחץ על הצג תוכניות כפתור.

בחר את תוכנית המנויים שלך, או נסה אפליקציה לתקופת ניסיון בחינם לפני שתירשם כמנוי.

סקור וקבל את כל תנאי השימוש ומדיניות הפרטיות ולחץ על המשך כפתור.

הגדר את התשלומים האוטומטיים שלך באמצעות PayPal.

מה אם כבר נרשמתי לאפליקציית המפתח?

ייתכן שכבר נרשמת ליישום ישירות אצל היזם, ועכשיו אתה רוצה להשתמש ביישום ב- eBay שלי.

הנה מה לעשות:

בטל את הרישום מהיישום עם היזם ואז הירשם לגירסה ב- eBay שלי.

בעת ההרשמה לגירסת ה- eBay שלי, עליך לציין שוב את אמצעי התשלום שלך, אך חשבון החיוב שלך עדיין יהיה פעיל. לאחר שתירשם כמנוי מחדש לגרסת ה- eBay שלי, חשבון החיוב שלך יציג הן את ההצהרה הישנה ממנוי המפתח והן את ההצהרה החדשה ממנוי ה- eBay שלך.

השגת תלות

בהנחה שהפעלת מודולים, כאשר אתה משתמש ב- run run (או ללכת לבדיקה או ללכת לבנות לצורך העניין) כל תלות חיצונית תוריד אוטומטית (וגם רקורסיבית) כדי למלא את הצהרות היבוא בקוד שלך. כברירת מחדל, המהדורה האחרונה המתויגת של התלות תורד, או אם אין מהדורות מתויגות זמינות, התלות בהתחייבות האחרונה.

אם אתה יודע מראש שאתה צריך גרסה מסוימת של תלות (במקום זו שגו תביא כברירת מחדל) תוכל להשתמש ב- go get עם מספר הגירסה הרלוונטי או לבצע hash. לדוגמה:

אם התלות המובאת כוללת קובץ go.mod, אז התלות שלה לא יופיע ברשימה שלך קובץ go.mod. לעומת זאת, אם התלות שאתה מוריד אין קובץ go.mod, הרי שתלות יהיה להיות רשום בקובץ go.mod שלך עם // הערה עקיפה לצידם.

אז זה אומר שקובץ go.mod שלך לא בהכרח מראה את כל התלות לפרויקט שלך במקום אחד. במקום זאת, אתה יכול להציג את כולם באמצעות כלי הרשימה ללכת כך:

לפעמים אתה עשוי לתהות למה זה תלות? אתה יכול לענות על זה באמצעות הפקודה mod mod מדוע, שתראה לך את הנתיב הקצר ביותר מחבילה במודול הראשי שלך לתלות נתונה. לדוגמה:

הערה: הפקודה mod mod תחזיר תשובה לרוב התלות, אך לא לכולן. גיליון 27900 עוקב אחר זה.

אם אתה מעוניין לנתח או לדמיין את התלות ביישום שלך, ייתכן שתרצה לבדוק גם את הכלי הגרף mod mod. יש כאן הדרכה נהדרת וקוד דוגמה ליצירת הדמיות כאן.

לבסוף, תלות שהורדת מאוחסנת ב- מטמון מודול ממוקם ב- GOPATH / pkg / mod. אם אי פעם תצטרך לנקות את מטמון המודול, תוכל להשתמש בכלי ללכת לנקות. אך שימו לב: זה יסיר את התלות שהורדת עבור כל הפרויקטים במחשב שלך.

עריכת דפים

Wiki אינו wiki ללא יכולת לערוך דפים. בואו ניצור שני מטפלים חדשים: האחד נקרא editHandler כדי להציג טופס 'עמוד עריכה', והשני בשם saveHandler כדי לשמור את הנתונים שהוזנו באמצעות הטופס.

ראשית, אנו מוסיפים אותם לעיקרית ():

הפונקציה editHandler טוענת את הדף (או אם הוא לא קיים, צור מבנה עמוד ריק) ומציג טופס HTML.

פונקציה זו תעבוד מצוין, אך כל ה- HTML המקודד הקשיח זה מכוער. כמובן שיש דרך טובה יותר.

הפעלת בקשתך

לאחר שנרשמתם לאפליקציה, תוכלו לפתוח אותה מ- eBay.

מקם את המצביע מעל היישומים לחץ על הכרטיסייה ואז בחר את שם היישום מהתפריט הנפתח.

קוד שיפוץ מחדש

רוב הסיכויים שאתה מכיר את השימוש בכלי gofmt כדי לעצב את הקוד שלך באופן אוטומטי. אבל זה גם תומך לשכתב כללים שתוכלו להשתמש בהן כדי לסייע מחדש בפקטור הקוד שלכם. אדגים.

נניח שיש לך את הקוד הבא ואתה רוצה לשנות את המשתנה foo ל- Foo כך שהוא ייצא.

לשם כך ניתן להשתמש ב- gofmt עם הדגל -r בכדי ליישם כלל שכתוב, בדגל -d להצגת הפרש של השינויים, ובדגל -w כדי לבצע את השינויים. במקום, ככה:

שימו לב כיצד זה חכם יותר ממציאת והחלפה? משתנה foo השתנה, אך מחרוזת "foo" בהצהרת fmt.Println () נותרה בעינה. דבר נוסף שצריך לשים לב הוא שהפקודה gofmt פועלת רקורסיבית, כך שהפקודה שלמעלה תפעל על כל קבצי ה- .go בספריה ובספריות המשנה הנוכחיות שלך.

אם ברצונך להשתמש בפונקציונליות זו, אני ממליץ להפעיל כללי שכתוב בלי ראשית את הדגל -w ובודק תחילה את ההבדל כדי לוודא שהשינויים בקוד הם מה שאתה מצפה.

בואו נסתכל על דוגמה קצת יותר מסובכת. נניח שאתה רוצה לעדכן את הקוד שלך כדי להשתמש בפונקציה החדשה Go 1.12 strings.ReplaceAll () במקום strings.Replace (). כדי לבצע שינוי זה תוכלו להפעיל:

בכללים לשכתב, תווים בעלי אותיות קטנות בודדות פועלות כקלפי בר המתאימים לביטויים שרירותיים, וביטויים אלה יוחלפו בתמורה.

הצגת תיעוד Go

באפשרותך להציג תיעוד עבור חבילות הספריה הרגילות דרך הטרמינל שלך באמצעות הכלי go doc. לעתים קרובות אני משתמש בזה במהלך הפיתוח כדי לבדוק משהו במהירות - כמו שם או חתימה של פונקציה ספציפית. אני מוצא את זה מהר יותר מאשר לנווט בתיעוד מבוסס האינטרנט והוא תמיד זמין גם במצב לא מקוון.

באפשרותך לכלול גם את דגל ה- -crc כדי להציג את קוד המקור הרלוונטי של Go. לדוגמה:

חבילת ה- html / התבנית

חבילת ה- html / template היא חלק מהספרייה הרגילה של Go. אנו יכולים להשתמש ב- html / template כדי לשמור את ה- HTML בקובץ נפרד, ומאפשר לנו לשנות את הפריסה של דף העריכה שלנו מבלי לשנות את קוד ה- Go הבסיסי.

ראשית, עלינו להוסיף html / template לרשימת היבוא. אנו גם לא נשתמש ב- fmt, אז עלינו להסיר את זה.

בואו ליצור קובץ תבנית המכיל את הטופס HTML. פתח קובץ חדש בשם edit.html והוסף את השורות הבאות:

שנה את EditHandler כדי להשתמש בתבנית, במקום HTML המקודד הקשיח:

תבנית הפונקציה. ParseFiles יקראו את תוכן edit.html ויחזיר תבנית * תבנית.

השיטה t.Execute מבצעת את התבנית, כותבת את ה- HTML שנוצר ל- http.ResponseWriter. המזהים המנוקדים .Title ו- .Body מתייחסים ל- p.Title ו- p.Body.

הנחיות התבנית מצורפות בכתפיות מתולתלות כפולות. ההוראות printf "% s". הוראת גוף היא קריאת פונקציה שיוצאת. גוף כמחרוזת במקום זרם בתים, זהה לקריאה ל- fmt.Printf. חבילת ה- html / template עוזרת להבטיח שרק HTML בטוח ונראה למראה נוצר על ידי פעולות תבנית. לדוגמה, הוא בורח אוטומטית מכל סימן גדול יותר (>), ומחליף אותו ב->, כדי לוודא שנתוני המשתמש אינם פוגעים ב- HTML בטופס.

מכיוון שאנו עובדים עכשיו עם תבניות, בואו ניצור תבנית לתצוגה שלנוHandler שנקרא view.html:

שנה את התצוגה הנדלרית בהתאם:

שימו לב שהשתמשנו כמעט באותו קוד תבניות אצל שני המטפלים. בואו נסיר את הכפילות הזו על ידי העברת קוד התבנית לפונקציה שלו:

ושנה את המטפלים שישתמשו בפונקציה זו:

אם נפרסם לרשום את רישום מטפל החסכון הבלתי ממומש שלנו, נוכל לבנות שוב ולבדוק את התוכנית שלנו. לחץ כאן לצפייה בקוד שכתבנו עד כה.

מבטל את הרישום ליישום

לפני שתבטל מנוי, אנו ממליצים ליצור קשר עם מפתח האפליקציה כדי לקבל עזרה בשימוש ביישום או לפתור כל שאלה שיש לך.

מקם את המצביע מעל היישומים לחץ על הכרטיסיה ואז לחץ על נהל יישומים קישור כדי לראות רשימה של כל היישומים אליהם נרשמת.

לחץ על הפעולות האחרות קישור ובחר בטל את הרישום.

יישומים שלאחרונה הצטרפתם למנויים רשומים תחת יישומים שלא הצטרפו למנויים (60 הימים האחרונים). תוכל להירשם שוב או ליצור קשר עם מפתח היישומים לקבלת סיוע.

טיפול בדפים שאינם קיימים

מה אם אתה מבקר / מציג / APageThatDoesntExist? תראה דף המכיל HTML. הסיבה לכך היא שהיא מתעלמת מערך החזרת השגיאות מ- loadPage וממשיכה לנסות ולמלא את התבנית ללא נתונים. במקום זאת, אם הדף המבוקש אינו קיים, עליו להפנות את הלקוח לדף העריכה כך שייווצר התוכן:

הפונקציה http.Redirect מוסיפה קוד סטטוס HTTP של http.StatusFound (302) וכותרת מיקום לתגובת HTTP.

פנייה למפתח

לעזרה בכל אחד מהיישומים במרכז Apps, פנה ישירות למפתח היישום. המפתח של כל אפליקציה מכיר את היישום בצורה הטובה ביותר והוא כשיר באופן ייחודי לעזור לכם בכך.

מקם את המצביע מעל היישומים לחץ על הכרטיסיה ולאחר מכן לחץ על נהל יישומים קישור.

לחץ על התחל כפתור.

בחר בתמיכת לקוחות מתפריט העזרה.

פתק: אתה יכול גם ללחוץ על התמיכה של צור קשר קישור מהפעולות האחרות ברשימה תחת התחל כפתור.


אם כבר יצרת קשר עם המפתח

אם יצרת קשר עם היזם, לא הגעת להחלטה, ומרגיש שביצועי האפליקציה הוגזמו מדי או שתיאור היישום לא היה מדויק, צור איתנו קשר כדי לדווח על היישום. אנו נבדוק את הדוח שלך ונקבע איזו פעולה מתאימה.

מקם את המצביע מעל היישומים לחץ על הכרטיסיה ואז לחץ על נהל יישומים קישור.

ביישומים שלך לחץ על הסעיף פעולות אחרות קישור תחת התחל כפתור ליישום שאתה רוצה לדווח עליו.

לחץ על דווח על יישום זה מהתפריט הנפתח ומלא את הטופס. תאר את הבעיה ובחר אחת מהסיבות שאתה מדווח על היישום:

היישום לא עובד כמתואר

היישום מפר את מדיניות הפרטיות

לחץ על שלח כפתור.

ביצוע בדיקות

אתה יכול להשתמש בכלי בדיקת ההפעלה כדי להריץ בדיקות בפרויקט שלך כך:

בדרך כלל אני מריץ את הבדיקות שלי עם גלאי המירוצים של Go מופעל, מה שיכול לעזור להרים כמה ממרוצי הנתונים שעלולים להתרחש בשימוש בחיים האמיתיים. ככה:

חשוב לציין כי הפעלת גלאי המירוץ תגדיל את זמן הריצה הכולל של הבדיקות שלך. כך שאם אתה מבצע בדיקות לעתים קרובות מאוד מזרימת עבודה של TDD, ייתכן שתעדיף לחסוך באמצעות זה לריצת מבחן שביצעה מראש בלבד.

מאז 1.10, Go שומר את תוצאות הבדיקה ברמת החבילה. אם חבילה לא השתנתה בין ריצות מבחן - ואתה משתמש באותם דגלים, שניתן לטפל בהם, למבחן מעבר - תוצאת הבדיקה במטמון תוצג עם "(מטמון)" לצידה. זה מועיל מאוד להאיץ את משך זמן הבדיקה לבסיסי קוד גדולים. אם אתה רוצה לאלץ את הבדיקות שלך לרוץ במלואן (ולהימנע מהמטמון) אתה יכול להשתמש בסמל -count = 1, או לנקות את כל תוצאות הבדיקה במטמון באמצעות הכלי 'go clean'.

הערה: תוצאות הבדיקה במטמון מאוחסנות לצד תוצאות בניית מטמון במטמון בספריית GOCACHE שלך. בדוק go env GOCACHE אם אינך בטוח איפה זה במכונה שלך.

אתה יכול להגביל את מבחן ההפעלה לביצוע בדיקות ספציפיות (ובדיקות משנה) על ידי שימוש בדגל -run. זה מקבל ביטוי רגיל, ורק בדיקות שיש להן שמות התואמים לביטוי הרגיל יופעלו. אני רוצה לשלב זאת עם דגל ה- v כדי לאפשר מצב מילולי, כך שמוצגים שמות של מבחני ריצה ומבחני משנה. זוהי דרך שימושית לוודא שלא דפקתי את ה- expexp מחדש ושהבדיקות שאני מצפה להן פועלות!

כמה דגלים נוספים שכדאי להיות מודעים אליהם הם -קצרה (שתוכלו להשתמש בהם כדי לדלג על מבחני ריצה ארוכים) ו- -Failfast (שיפסיקו לבצע בדיקות נוספות לאחר הכישלון הראשון). שים לב כי - כישלון מהיר ימנע את אחסון המטמון של תוצאות הבדיקה.

שמירת דפים

הפונקציה saveHandler תטפל בהגשת טפסים הממוקמים בדפי העריכה. לאחר ביטול הפרסום של הקו הקשור בעיקר, בואו ליישם את המטפל:

כותרת העמוד (המסופקת בכתובת האתר) ושדה היחיד של הטופס, גוף, נשמרים בעמוד חדש. לאחר מכן נקראת שיטת השמירה () לכתוב את הנתונים לקובץ, והלקוח מנותב אל / view / page.

הערך שהוחזר על ידי FormValue הוא מחרוזת מסוג. עלינו להמיר ערך זה לבייטי לפני שהוא ישתלב במבנה העמודים. אנו משתמשים בתים (body) כדי לבצע את ההמרה.

כיסוי מבחני פרופיל

ניתן לאפשר ניתוח כיסוי בעת הפעלת בדיקות באמצעות דגל הכיסוי. זה יציג את אחוז הקוד המכוסה על ידי הבדיקות בפלט עבור כל חבילה, בדומה לזה:

אתה יכול גם ליצור פרופיל כיסוי באמצעות הדגל -coverprofile והצג אותו בדפדפן האינטרנט שלך באמצעות הפקודה כיסוי הכלי -html כך:

זה ייתן לך רשימה ניתנת לניווט של כל קבצי הבדיקה, כאשר הקוד מכוסה על ידי הבדיקות המוצגות בירוק, וקוד שנחשף באדום.

אם אתה רוצה תוכל להתקדם צעד אחד קדימה ולהגדיר את דגל -covermode = count כדי להפוך את פרופיל הכיסוי לרשומת המדויק מספר פעמים שכל הצהרה מבוצעת במהלך הבדיקות.

כשמוצגים בדפדפן, הצהרות שמבוצעות בתדירות גבוהה יותר מוצגות בגוון ירוק רווי יותר, בדומה לזה:

הערה: אם אתה משתמש בפקודה t.Parallel () באחת מהבדיקות שלך, עליך להשתמש בסמל -covermode = atomic במקום -covermode = count במקום כדי להבטיח ספירה מדויקת.

לבסוף, אם אין ברשותך דפדפן אינטרנט לצפייה בפרופיל כיסוי, אתה יכול לראות פירוט של כיסוי הבדיקה לפי פונקציה / שיטה במסוף שלך עם הפקודה:

שגיאה בטיפול

ישנם כמה מקומות בתוכנית שלנו שבהם מתעלמים משגיאות. זהו תרגול רע, לא מעט משום שכאשר תתרחש שגיאה לתוכנית תהיה התנהגות לא מכוונת. פיתרון טוב יותר הוא לטפל בשגיאות ולהחזיר הודעת שגיאה למשתמש. ככה אם משהו ישתבש, השרת יתפקד בדיוק כמו שאנחנו רוצים וניתן לקבל הודעה על המשתמש.

ראשית, בואו נתמודד עם השגיאות ב- renderTemplate:

פונקציית ה- http.Error שולחת קוד תגובה HTTP מוגדר (במקרה זה "שגיאת שרת פנימית") והודעת שגיאה. ההחלטה להכניס זאת לפונקציה נפרדת כבר משתלמת.

עכשיו בוא נתקן את saveHandler:

כל שגיאה שתתרחש במהלך p.save () תדווח למשתמש.

הבנת סטטוס המנוי שלך

סטטוס של אפליקציה מגלה לך האם המנוי שלך פעיל כרגע. להלן המשמעות של כל סטטוס:

ממתין ל פירושו שאנחנו בתהליך הגדרת המנוי שלך. אם הסטטוס שלך נשאר תלוי ועומד למשך יותר מרבע שעה, צור קשר עם מפתח היישום.

פעיל פירושו שהמנוי שלכם מוכן ותוכלו להשתמש ביישום. מנויים בתשלום עם סטטוס פעיל יופיעו בחשבונית החודשית שלך.

בהמתנה לביטול פירושו שביקשת שנבטל את המנוי שלך. עם זאת, אם אתה נרשם ליישום שאינו משוער, תהיה לך גישה ליישום עד לניצול הזמן שאתה מנהל> ניהול יישומים עמוד. פתק: אם עליך לבטל בקשה מיידית, צור קשר ישירות עם היזם. 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.

מושעה 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. לדוגמה:

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 במקום זאת. 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 לקמפל 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. לדוגמה:

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. בחר >יישומים. בחר 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 לא 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 ערוך סמל.
  • 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. לדוגמה:

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. לדוגמה:

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. לדוגמה:

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)ל 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. לדוגמה:

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 יישומים.
  2. לחץ על ערוך for the app link with the other application.
  3. For both Outgoing Authentication ו Incoming Authentication:
    1. לחץ על OAuth
    2. Check Allow 2-legged OAuth.
    3. לחץ על עדכון.

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 פרופילים 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. לדוגמה:

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.

פתרון תקלות

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. לדוגמה:

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. You can download it here.

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.

צפו בסרטון: עכשיו אף אחד לא יוכל לעבוד עליכם - אפליקציה לבדיקת סמארטפונים TestM (פברואר 2020).