מודל אובייקט JavaScript

כרגע מוצג התיעוד של Apigee Edge.
כניסה למסמכי התיעוד של Apigee X.
מידע

נושא זה עוסק במודל האובייקטים של JavaScript ב-Apigee Edge. חשוב להבין את המודל הזה אם מתכוונים להשתמש במדיניות JavaScript כדי להוסיף JavaScript בהתאמה אישית לשרת proxy של API.

מידע על מודל האובייקטים של JavaScript ב-Edge

במודל ה-JavaScript של Apigee Edge מוגדרים אובייקטים עם מאפיינים משויכים שזמינים לקוד JavaScript המופעל בתהליך של שרת proxy של Apigee Edge. צריך להשתמש במדיניות JavaScript כדי לצרף את הקוד המותאם אישית הזה לתהליך proxy של API.

לאובייקטים שמוגדרים במודל הזה יש היקף בתוך התהליך של שרת ה-proxy של ה-API. המשמעות היא שאובייקטים ומאפיינים מסוימים זמינים רק בנקודות ספציפיות בזרימה. כשה-JavaScript מופעל, נוצר היקף להפעלה. בהיקף הזה נוצרות ההפניות הבאות לאובייקטים:

  • הקשר: אובייקט שמספק גישה להקשר של ההודעה
  • request: קיצור דרך שמאפשר גישה לאובייקט הבקשה
  • תגובה: קיצור דרך שמאפשר גישה לאובייקט הבקשה
  • crypto: מספק פונקציות גיבוב (hash) שונות
  • print: פונקציה שפולטת פלט
  • מאפיינים: מאפשרים גישת קריאה למאפייני התצורה במדיניות

אובייקט ההקשר

לאובייקט context יש היקף גלובלי. היא זמינה בכל מקום בתהליך של שרת ה-proxy של ה-API. יש לו ארבעה אובייקטים צאצאים: proxyRequest, proxyResponse, targetRequest, targetResponse. האובייקטים הצאצאים האלה מתייחסים לבקשה ולתגובה ברקע, בהתאם לבקשה ולתגובה דרך שרת ה-proxy או לבקשה ולתגובה של היעד. לדוגמה, אם מדיניות JavaScript מופעלת בחלק הזרימה של נקודת הקצה של שרת ה-proxy, האובייקטים context.proxyRequest ו-context.proxyResponse נמצאים בהיקף. אם JavaScript פועל בתהליך יעד, האובייקטים context.targetRequest ו-context.targetResponse נכללים בהיקף.

לאובייקט context יש גם מאפיינים ושיטות, שמתוארים בפירוט בנושא הזה. לדוגמה, בדוגמה הבאה של קוד JavaScript, נעשה שימוש במאפיין context.flow וקורא ל-methods של get/setVariable() ב- context.

if (context.flow=="PROXY_REQ_FLOW") {
     var username = context.getVariable("request.formparam.user");
     context.setVariable("USER.name", username);
}

השיטות האלה פועלות ישירות עם משתני זרימה. ערך המאפיין context.flow הוא היקף הזרימה הנוכחי. בתהליך הבקשה של שרת ה-proxy, היא מוגדרת לערך הקבוע PROXY_REQ_FLOW. אם בתהליך היעד של התגובה, הערך מוגדר ל-TARGET_RESP_FLOW. הקבוע הזה שימושי לביצוע קוד ספציפי להיקף. רכיב getter מאפשר לכם לקבל משתני זרימה, והרכיב המגדיר מאפשר להגדיר משתני זרימה. המשתנים האלה זמינים בדרך כלל בתהליך של שרת ה-proxy, ואפשר להשתמש בהם בכללי מדיניות אחרים.

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

אובייקט הקריפטו

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

הבקשה והתגובה אובייקטים

האובייקטים request ו-response הם אזכורים בקיצור של הבקשה והתגובה ברקע, בבקשה ובתגובה לשרת ה-proxy או לבקשה ולתגובה של היעד. האובייקטים שהמשתנים האלה מפנים אליהם תלויים בהקשר שבו מופעלת מדיניות ה-JavaScript. אם קוד ה-JavaScript פועל בזרימה של נקודת קצה של שרת proxy, משתני הבקשה והתגובה מתייחסים ל-context.proxyRequest ול-context.proxyResponse. אם קוד ה-JavaScript פועל בתהליך יעד, המשתנים יתייחסו ל-context.targetRequest ול-context.targetResponse.

מודל האובייקט של JavaScript כולל פונקציית print() שאפשר להשתמש בה כדי להפיק מידע על תוצאות ניפוי הבאגים באמצעות הכלי Edge Trace. למידע נוסף, אפשר לעיין בקטע ניפוי באגים באמצעות הצהרות ב-JavaScript Print().

אובייקט המאפיינים

כשמשתמשים ברכיב בהגדרת המדיניות, קוד ה-JavaScript יכול לגשת לערכים של המאפיינים האלה באמצעות המשתנה properties.

לדוגמה, אם תצורת ה-JavaScript כוללת:

<Javascript name='JS-1' >
  <Properties>
    <Property name="number">8675309</Property>
    <Property name="firstname">Jenny</Property>
  </Properties>
  <ResourceURL>jsc://my-code.js</ResourceURL>
</Javascript>

ואז בmy-code.js אפשר:

  print(properties.firstname);  // prints Jenny
  print(properties.number);  // 8675309

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

לדוגמה, השדה הבא מציין את 'שם המשתנה' ואת סגנון הפלט שה-JavaScript צריך לפלוט בו מידע:

<Javascript name='JS-2' >
  <Properties>
    <Property name="output">my_output_variable</Property>
    <Property name="prettyPrint">true</Property>
  </Properties>
  <ResourceURL>jsc://emit-results.js</ResourceURL>
</Javascript>
לאחר מכן, ב-emit-results.js הקוד יוכל לעשות זאת:
var result = { prop1: "something", prop2 : "something else" } ;
if (properties.prettyPrint == "true") {
  context.setVariable(properties.output, JSON.stringify(result, null, 2));
}
else {
  context.setVariable(properties.output, JSON.stringify(result));
}

הפניה לאובייקט קריפטו

אובייקט הקריפטו מאפשר לבצע פונקציות גיבוב (hashing) קריפטוגרפיות בסיסיות ב-JavaScript.

לאובייקט הקריפטו יש היקף גלובלי. הוא זמין בכל מקום בתהליך ה-API של שרת ה-proxy. ב-Crypto אפשר לעבוד עם אובייקטי גיבוב (hash) האלה:

  • SHA-1
  • SHA256
  • SHA512
  • MD5

עבודה עם אובייקטים מסוג SHA-1

אפשר ליצור אובייקטים מסוג SHA-1, לעדכן אותם ולהמיר אותם לערכי הקסדצימליים ו-base64.

יצירת אובייקט SHA-1 חדש

var _sha1 = crypto.getSHA1();

עדכון אובייקט SHA-1

תחביר

_sha1.update(value);

פרמטרים

  • value - (מחרוזת) כל ערך מחרוזת.

דוגמה

מעדכנים אובייקט SHA-1:

_sha1.update("salt_value");

_sha1.update("some text");

החזרת אובייקט SHA-1 כמחרוזת הקסדצימלית

var _hashed_token = _sha1.digest();

החזרת אובייקט SHA-1 כמחרוזת base64

var _hashed_token = _sha1.digest64();

עבודה עם אובייקטים מסוג SHA-256

אפשר ליצור אובייקטים מסוג SHA-256, לעדכן אותם ולהמיר אותם לערכים הקסדצימליים ו-base64.

יצירת אובייקט SHA-256 חדש

var _sha256 = crypto.getSHA256();

עדכון אובייקט SHA-256

תחביר

_sha256.update(value);

פרמטרים

  • value - (מחרוזת) כל ערך מחרוזת.

דוגמה

מעדכנים אובייקט SHA-256:

_sha256.update("salt_value");

_sha256.update("some text");

החזרת אובייקט SHA-256 כמחרוזת הקסדצימלית

var _hashed_token = _sha256.digest();

החזרת אובייקט SHA-256 כמחרוזת base64

var _hashed_token = _sha256.digest64();

עבודה עם אובייקטים מסוג SHA-512

אפשר ליצור אובייקטים מסוג SHA-512, לעדכן אותם ולהמיר אותם לערכי הקסדצימליים ו-base64.

יצירת אובייקט SHA-512 חדש

var _sha512 = crypto.getSHA512();

עדכון אובייקט SHA-512

תחביר

_sha512.update(value);

פרמטרים

  • value - (מחרוזת) כל ערך מחרוזת.

דוגמה

מעדכנים אובייקט SHA-512:

_sha512.update("salt_value");

_sha512.update("some text");

החזרת אובייקט SHA-512 כמחרוזת הקסדצימלית

var _hashed_token = _sha512.digest();

החזרת אובייקט SHA-512 כמחרוזת base64

var _hashed_token = _sha512.digest64();

עבודה עם אובייקטים של MD5

אפשר ליצור אובייקטים מסוג MD5, לעדכן אותם ולהמיר אותם לערכים הקסדצימליים ו-base64.

יצירה של אובייקט MD5 חדש

var _md5 = crypto.getMD5();

עדכון של אובייקט MD5

תחביר

_md5.update(value);

פרמטרים

  • value - (מחרוזת) כל ערך מחרוזת.

דוגמה

מעדכנים אובייקט MD5:

_md5.update("salt_value");

_md5.update("some text");

החזרת אובייקט MD5 כמחרוזת הקסדצימלית

var _hashed_token = _md5.digest();

החזרת אובייקט MD5 כמחרוזת base64

var _hashed_token = _md5.digest64();

תמיכה בתאריך/שעה של הצפנה

אובייקט הקריפטו תומך בתבניות עיצוב תאריך/שעה.

crypto.dateFormat()

מחזירה תאריך בפורמט מחרוזת.

תחביר

crypto.dateFormat(format, [timezone], [time])

פרמטרים

  • format - (מחרוזת) ההטמעה הבסיסית של הפרמטר הזה היא java.text.SimpleDateFormat. לדוגמה: 'yyyy-MM-DD HH:mm:ss.SSS'
  • timezone - (מחרוזת, אופציונלי) ההטמעה הבסיסית של הפרמטר הזה היא java.util.TimeZone. הפרמטר הזה הוא sameDefault: UTC
  • time - (מספר, אופציונלי) ערך חותמת זמן של Unix לעיצוב. ברירת מחדל: השעה הנוכחית

דוגמאות

הורדת השעה הנוכחית, הקטנה של אלפיות השנייה:

var _now = crypto.dateFormat('yyyy-MM-DD HH:mm:ss.SSS');

מה השעה לפי שעון החוף המערבי בארה"ב?

var _pst = crypto.dateFormat('yyyy-MM-DD HH:mm:ss.SSS','PST');

קבל את הערך של עשר שניות מעכשיו:

var _timeNow = Number(context.getVariable('system.timestamp'));
var ten_seconds = crypto.dateFormat('yyyy-MM-DD HH:mm:ss.SSS','PST', _timeNow + 10 * 1000);

דוגמאות נוספות. עיין גם בתיעוד java.text.SimpleDateFormat.

var _pst = crypto.dateFormat('M');
var _pst = crypto.dateFormat('EEE, d MMM yyyy HH:mm:ss Z');
var _pst = crypto.dateFormat("yyyy-MM-dd'T'HH:mm:ss.SSSZ");

שימוש ב-getHash() כדי לקבל כל אחד מאובייקטי הגיבוב הנתמכים

דוגמאות

var _hash1 = crypto.getHash('MD5');

var _hash2 = crypto.getHash('SHA-1');

var _hash3 = crypto.getHash('SHA-256');

var _hash4 = crypto.getHash('SHA-512');

טעימה עם מטבע וירטואלי

try {
    // get values to use with hash functions
    var salt = context.getVariable("salt") || 'SomeHardCodedSalt';
    var host = context.getVariable("request.header.Host");
    var unhashed_token = "";

    var _timeNow = Number(context.getVariable('system.timestamp'));
    var now = crypto.dateFormat('yyyy-MM-DD HH:mm:ss.SSS','PST', _timeNow);
    unhashed_token = "|" + now + "|" + host

    // generate a hash with the unhashedToken:
    var sha512 = crypto.getSHA512();
    sha512.update(salt);
    sha512.update(unhashed_token);

    // convert to base64
    var base64_token = sha512.digest64();

    // set headers
    context.setVariable("request.header.now", now);
    context.setVariable("request.header.token", base64_token);

} catch(e) {
    throw 'Error in Javascript';
}

הפניה לאובייקט הקשר

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

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

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

סיכום אובייקט הקשר

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

שם תיאור תכונות
context wrapper של צינור עיבוד ההודעות להקשר של צינור עיבוד ההודעות ותהליכי הבקשה והתגובה שמופעלים על ידי ProxyEndpoint ו-TargetEndpoint. זרימה, פעילות באתר
context.proxyRequest אובייקט שמייצג את הודעת הבקשה הנכנסת ל-ProxyEndpoint (מהאפליקציה המבקשת לשרת ה-API) כותרות, פרמטרים של שאילתות, שיטה, גוף, כתובת URL
context.targetRequest אובייקט שמייצג את הודעת הבקשה היוצאת מ-TargetEndpoint (משרת ה-proxy של ה-API לשירות הקצה העורפי). כותרות, פרמטרים של שאילתות, שיטה, גוף, כתובת URL
context.targetResponse אובייקט שמייצג את הודעת התגובה הנכנסת ליעד (מהשירות לקצה העורפי אל שרת ה-API של ה-API) כותרות, תוכן, סטטוס
context.proxyResponse אובייקט שמייצג את הודעת התגובה של שרת ה-proxy היוצא (משרת ה-API של ה-API לאפליקציה המבקשת) כותרות, תוכן, סטטוס
context.flow השם של הזרימה הנוכחית. מידע נוסף זמין בקטע context.flow שבהמשך.
context.session מפה של צמדים של שם/ערך שאפשר להשתמש בהם כדי להעביר אובייקטים בין שני שלבים שונים המבוצעים באותו הקשר. לדוגמה: context.session['key'] = 123 כדי לדעת מתי ומתי אין להשתמש באובייקט הזה, אפשר לעיין ב דיון של קהילת Apigee.

שיטות לאובייקט הקשר

context.getVariable()

מאחזרת את הערך של משתנה מותאם אישית או מוגדר מראש.

תחביר

context.getVariable("variable-name");

דוגמה

כדי למצוא את הערך של השנה הנוכחית:

var year = context.getVariable('system.time.year');

context.setVariable()

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

תחביר

context.setVariable("variable-name", value);

דוגמה

תרחיש נפוץ להגדרת משתנה הוא מקרים שבהם שרת proxy ל-API חייב לכתוב באופן דינמי את כתובת ה-URL של היעד. קוד ה-JavaScript הבא מקבל את הערך של משתנה שנקרא USER.name, מצרף את הערך כפרמטר של שאילתה לכתובת ה-URL http://mocktarget.apigee.net?user=, ולאחר מכן מגדיר את target.url שהוגדר מראש לערך הזה.

context.setVariable("target.url", "http://mocktarget.apigee.net/user?user="+context.getVariable("USER.name"));

context.removeVariable()

מסירה משתנה מההקשר.

תחביר

context.removeVariable('variable-name');

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

context.flow

המאפיין flow הוא מחרוזת שמזהה את הזרימה הנוכחית של שרת ה-proxy של ה-API. המאפיין הזה משמש לציון הזרימה שאליה מצורף ה-JavaScript. הערכים הנתמכים הם:

  • PROXY_REQ_FLOW
  • PROXY_RESP_FLOW
  • TARGET_REQ_FLOW
  • TARGET_RESP_FLOW

כל שם זרימה כולל את ה-PreFlow, את PostFlow, ואת כל התהליכים המותנים שמוגדרים ב-ProxyEndpoints או TargetEndpoints.

המאפיין האופציונלי הזה שימושי כאשר JavaScript נפוץ מופעל ביותר מתהליך אחד, אבל ההתנהגות שלו עשויה להשתנות בהתאם לזרימה שבה הוא מופעל. יש להשתמש בנכס Flu עבור מודולים של JavaScript, שמיועדים לשימוש חוזר בכמה שרתי proxy של API, שבהם הקוד נדרש כדי לבדוק את תהליך העבודה הנוכחי לפני הפעלת הלוגיקה.

דוגמה

הגדרת כותרת HTTP בתהליך היעד של הבקשה בלבד:

if (context.flow=="TARGET_REQ_FLOW") {
     context.targetRequest.headers['TARGET-HEADER-X']='foo';
}

הגדרת התוכן רק ב-ProxyResponseflow:

if (context.flow=="PROXY_RESP_FLOW") {
     context.proxyResponse.content='bar';
}

context.session

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

דוגמה

מגדירים ערך בסשן:

context.session['key']  = 123;

כדי לקבל את הערך מהסשן:

var value = context.session['key']; // 123

צאצאים של אובייקט הקשר

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

  • context.proxyRequest: הודעת הבקשה הנכנסת שהתקבלה מהלקוח ששלח את הבקשה.
  • context.targetRequest: הודעת הבקשה היוצאת שנשלחה לשירות הקצה העורפי.
  • context.proxyResponse: הודעת התגובה היוצאת הוחזרה ללקוח ששלח את הבקשה.
  • context.targetResponse: הודעת הבקשה הנכנסת שהתקבלה מהשירות לקצה העורפי.

בקטעים הבאים מתוארות השיטות והתכונות של האובייקטים האלה:

הקשר.*בקשת אובייקטים צאצאים

בכל טרנזקציית HTTP, האובייקטים מופעלים בשרת proxy ל-API, נוצרים שני אובייקטים של הודעת בקשה: אחד inbound (הבקשה מהלקוח) והשני inbound (הבקשה שנוצרת על ידי שרת ה-API של ה-API ונשלחת ליעד של הקצה העורפי).

באובייקט context יש אובייקטים צאצאים שמייצגים את הודעות הבקשה הבאות: context.proxyRequest ו-context.targetRequest. האובייקטים האלה מאפשרים לגשת למאפיינים בתוך זרימת הבקשה שחלים עליהם כאשר קוד ה-JavaScript מופעל.

הערה: אפשר גם להשתמש באובייקט הקיצור דרך request כדי לגשת למאפיינים האלה בתהליך הבקשה. האובייקט request מתייחס אל context.proxyRequest או אל context.targetRequest, בהתאם לנקודה שבה מבוצע קוד ה-JavaScript.

הקשר.*בקשת מאפיינים של אובייקט צאצא

שם הנכס תיאור
url

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

כתובת ה-URL המלאה של הבקשה מורכבת מהמאפיינים הבאים:

  • פרוטוקול: הפרוטוקול של כתובת ה-URL (לדוגמה: HTTP או HTTPS)
  • יציאה: היציאה (לדוגמה, :80, :443)
  • host: המארח של כתובת ה-URL (לדוגמה, www.example.com)
  • נתיב: הנתיב של ה-URI (לדוגמה, /v1/mocktarget)

בעת הקבלה של url, כתובת אתר מוחזרת בפורמט הבא:

protocol://host:port/path?queryParams

דוגמאות:

context.targetRequest.url = 'http://www.example.com/path?q1=1'
context.targetRequest.protocol ='https';
headers

כותרות של בקשת HTTP כמיפוי של String => List

דוגמאות:

לבקשת ה-HTTP הזו:

POST /v1/blogs HTTP/1.1
Host: api.example.com
Content-Type: application/json
Authorization: Bearer ylSkZIjbdWybfs4fUQe9BqP0LH5Z
קוד ה-JavaScript הבא:
context.proxyRequest.headers['Content-Type'];
context.proxyRequest.headers['Authorization'];

יחזירו את הערכים הבאים

application/json
Bearer ylSkZIjbdWybfs4fUQe9BqP0LH5Z
queryParams

הפרמטרים של שאילתה בהודעת הבקשה כמיפוי של String => List.

דוגמאות:

"?city=PaloAlto&city=NewYork"

יכולים לגשת בתור:

context.proxyRequest.queryParams['city'];  // == 'PaloAlto'
context.proxyRequest.queryParams['city'][0]     // == 'PaloAlto'
context.proxyRequest.queryParams['city'][1];    // == 'NewYork'
context.proxyRequest.queryParams['city'].length(); // == 2
method

פועל ה-HTTP (GET, POST, PUT, DELETE, PATCH וכן הלאה) שמשויך לבקשה

דוגמאות:

לגבי הבקשה הזו:

POST /v1/blogs HTTP/1.1
Host: api.example.com
Content-Type: application/json
Authorization: Bearer ylSkZIjbdWybfs4fUQe9BqP0LH5Z

קוד ה-JavaScript הבא:

context.proxyRequest.method;

תחזיר את הערך הבא

POST
body

גוף ההודעה (payload) של בקשת ה-HTTP.

גוף הבקשה כולל את החברים הבאים:

  • context.targetRequest.body.asXML;
  • context.targetRequest.body.asJSON;
  • context.targetRequest.body.asForm;

דוגמאות:

לגוף XML:

<customer number='1'>
<name>Fred<name/>
<customer/>

כדי לגשת לרכיבים של אובייקט ה-XML באופן הבא:

var name = context.targetRequest.body.asXML.name;

כדי לגשת למאפייני XML, צריך להשתמש בסימון @.

var number = context.targetRequest.body.asXML.@number;

בגוף של בקשת JSON:

{
"a":  1 ,
"b" : "2"
}
var a = context.proxyRequest.body.asJSON.a;    // == 1
var b = context.proxyRequest.body.asJSON.b;    // == 2

כדי לקרוא פרמטרים של טופס:

"vehicle=Car&vehicle=Truck"
v0 = context.proxyRequest.body.asForm['vehicle'][0];
v1 = context.proxyRequest.body.asForm['vehicle'][1];

הקשר.*אובייקטי צאצא של תגובה

בכל טרנזקציית HTTP, האובייקטים מופעלים בשרת proxy של API, נוצרים שני אובייקטים של הודעות תגובה: אחד inbound (התגובה מהשירות לקצה העורפי) והשני inbound (התגובה שנשלחת בחזרה ללקוח).

באובייקט ההקשר יש אובייקטים צאצאים שמייצגים את הודעות התגובה הבאות: context.proxyResponse ו-context.targetResponse. האובייקטים האלה מאפשרים לגשת למאפיינים בתוך זרימת התגובה שחלים עליה כאשר קוד ה-JavaScript מופעל.

הערה: אפשר גם להשתמש באובייקט הקיצור דרך response כדי לגשת למאפיינים האלה מתהליך התגובה. האובייקט response מתייחס אל context.proxyResponse או אל context.targetResponse, בהתאם לנקודה שבה מבוצע קוד ה-JavaScript.

הקשר.*מאפייני אובייקט תגובה

שם הנכס תיאור
headers

כותרות ה-HTTP של הודעת התגובה כמיפוי של String => List.

דוגמה:

var cookie = context.targetResponse.headers['Set-Cookie'];
status

קוד הסטטוס עם הודעת הסטטוס כנכס. גם קוד הסטטוס וגם הודעת הסטטוס זמינים כמאפיינים.

דוגמה:

var status = context.targetResponse.status.code;   // 200
var msg = context.targetResponse.status.message;   // "OK"
content

גוף ה-HTTP (תוכן המטען הייעודי) של הודעת התגובה.

תוכן התגובה כולל את החברים הבאים:

context.targetResponse.content.asXML;
context.targetResponse.content.asJSON;

שימוש בסימון .asXML

יש דרך נוחה לעבור על מסמך XML באמצעות הסימון .asXML. בקטע הזה מוסבר איך להשתמש בסימון הזה ומה ההבדל בין request.content לבין context.proxyRequest.content.

לדוגמה:

request.content.asXML

או

context.proxyRequest.content.asXML

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

דוגמה

msg.content:

<?xml version="1.0" encoding="UTF-8"?>
<yahoo:error xmlns:yahoo="http://yahooapis.com/v1/base.rng" xml:lang="en-US">
   <yahoo:description>Please provide valid credentials. OAuth oauth_problem="unable_to_determine_oauth_type", realm="yahooapis.com"
   </yahoo:description>
</yahoo:error>
<!-- mg023.mail.gq1.yahoo.com uncompressed/chunked Sat Dec 14 01:23:35 UTC 2013 -->

msg.content.asXML:

<?xml version="1.0" encoding="UTF-8"?>
<yahoo:error xmlns:yahoo="http://yahooapis.com/v1/base.rng" xml:lang="en-US">
   <yahoo:description>Please provide valid credentials. OAuth oauth_problem="unable_to_determine_oauth_type", realm="yahooapis.com"
   </yahoo:description>
</yahoo:error>

בנוסף, אפשר להשתמש בטופס .asXML כדי לחצות את היררכיית ה-XML על ידי ציון שמות הרכיבים והמאפיינים. לא ניתן לחצות את ההיררכיה באמצעות התחביר האחר.

ניפוי באגים באמצעות הצהרות image() של JavaScript

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

if (context.flow=="PROXY_REQ_FLOW") {
     print("In proxy request flow");
     var username = context.getVariable("request.queryparam.user");
     print("Got query param: " + username);
     context.setVariable("USER.name", username);
     print("Set query param: " + context.getVariable("USER.name"));
}


if (context.flow=="TARGET_REQ_FLOW") {
     print("In target request flow");
     var username = context.getVariable("USER.name");
     var url = "http://mocktarget.apigee.net/user?"
     context.setVariable("target.url", url + "user=" + username);
     print("callout to URL: ", context.getVariable("target.url"));
}

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

יצירת יתרונות מרכזיים של JavaScript עם httpClient

אפשר להשתמש ב-httpClient כדי לשלוח בקשות HTTP אסינכרוניות ומקבילות לכל כתובת URL מתוך קוד JavaScript מותאם אישית המופעל בתהליך של שרת proxy ל-API. האובייקט httpClient חשוף באמצעות מודל ה-JavaScript של Apigee Edge.

מידע על httpClient

האובייקט httpClient חשוף לקוד JavaScript בהתאמה אישית שפועל ב-Apigee Edge דרך מודל האובייקט של JavaScript. כדי לצרף JavaScript מותאם אישית לשרת proxy של API, משתמשים במדיניות JavaScript. כשהמדיניות פועלת, קוד ה-JavaScript בהתאמה אישית מופעל.

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

הנה דפוס שימוש בסיסי. יצירת אובייקט של בקשה, הקצאת כתובת URL (לדוגמה, לשירות לקצה העורפי שאליו ברצונך להפעיל) קריאה ל-httpClient.send באמצעות אובייקט הבקשה הזה.

var myRequest = new Request();
myRequest.url = "http://www.example.com";
var exchangeObj = httpClient.send(myRequest);

הפניה של httpClient

לקוח ה-HTTP חושף שתי שיטות: get() ו-send().

httpClient.get()

שיטה נוחה לבקשות GET HTTP פשוטות, ללא תמיכה בכותרות HTTP.

שימוש

var exchangeObj = httpClient.get(url);

החזרות

השיטה מחזירה אובייקט exchange. לאובייקט הזה אין מאפיינים, והוא חושף את השיטות הבאות:

  • isError(): (בוליאני) מחזיר true אם ה-httpClient לא הצליח להתחבר לשרת. קודי מצב HTTP 4xx ו-5xx גורמים לתוצאה של isError() false, מכיוון שהחיבור הושלם והוחזר קוד תגובה חוקי. אם isError() מחזירה true, אז קריאה אל getResponse() מחזירה את קוד ה-JavaScript undefined.
  • isSuccess(): (בוליאני) מחזיר true אם השליחה הושלמה והצליחה.
  • isComplete(): (בוליאני) מחזיר true אם הבקשה הושלמה.
  • waitForComplete(): השהיית השרשור עד להשלמת הבקשה (בהצלחה או בשגיאה).
  • getResponse(): (אובייקט) מחזיר את אובייקט התגובה אם httpClient.send() היה שלם ומוצלח. לאובייקט שמוחזר יש שיטות ומאפיינים זהים לאובייקט ההקשר.proxyResponse. להצגת סיכום של אובייקטים לפי הקשר.
  • getError(): (מחרוזת) אם הקריאה ל-httpClient.send() הובילה לשגיאה, הודעת השגיאה מוחזרת כמחרוזת.

דוגמה

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

// Add the required the headers for making a specific API request
var headers = {'X-SOME-HEADER' : 'some value' };
// Make a GET API request along with headers
var myRequest = new Request("http://www.example.com","GET",headers);

// Define the callback function and process the response from the GET API request
function onComplete(response,error) {
 // Check if the HTTP request was successful
    if (response) {
      context.setVariable('example.status', response.status);
     } else {
      context.setVariable('example.error', 'Woops: ' + error);
     }
}

// Specify the callback Function as an argument
httpClient.get(myRequest, onComplete);

שימוש במדיניות JavaScript

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

נושאים קשורים

מאמרים מקהילת Apigee

אפשר למצוא את המאמרים הקשורים הבאים ב-Apigee Community: