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

אתה צופה בתיעוד של Apigee Edge.
הצג תיעוד של Apigee X.

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

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

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

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

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

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

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

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

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

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

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

האובייקט של המאפיין

כשמשתמשים ברכיב בתצורת המדיניות, קוד 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));
}

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

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

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

  • SHA-1
  • SHA256
  • SHA512
  • MD5

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

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

יצירת אובייקט 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, לעדכן אותם ולהמיר אותם לערכי hex ו-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, לעדכן אותם ולהמיר אותם לערכי hex ו-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. פרמטר זה זהה לברירת המחדל: 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 אובייקט שמייצג את הודעת הבקשה הנכנסת לשרת proxy כותרות, פרמטרים של שאילתה, שיטה, גוף, כתובת אתר
context.targetRequest אובייקט שמייצג את הודעת הבקשה היוצאת מ-TargetEndpoint (משרת ה-API של ה-API לשירות לקצה העורפי). כותרות, פרמטרים של שאילתה, שיטה, גוף, כתובת אתר
context.targetResponse אובייקט שמייצג את הודעת התגובה של היעד הנכנס (מהשירות לקצה העורפי לשרת proxy של ה-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 חייב לכתוב באופן דינמי את כתובת האתר של היעד. קוד ה-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 נפוץ מופעל בכמה זרימה, אבל עשוי להשתנות בהתאם להתנהגות בהתאם לזרימה שבה הוא מופעל. שימוש במאפיין Flow במודולים של JavaScript שמיועדים לשימוש חוזר בשרתי proxy מרובים של API, שבהם הקוד נדרש כדי לבדוק את תהליך הזרימה הנוכחי לפני שמפעילים את הלוגיקה.

דוגמה

הגדרת כותרת HTTP רק ב-targetRequest Flow:

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

מגדירים את התוכן רק ב-proxyResponse:

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) (הבקשה מהלקוח) ו-outbound אחד (הבקשה שנוצרה על ידי שרת ה-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

גוף ההודעה (מטען ייעודי) של בקשת ה-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, נוצרים שני אובייקטים של הודעות תגובה: מוכנס (התגובה מהשירות לקצה העורפי) ויוצא (התגובה נשלחת ללקוח).

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

ניפוי באגים באמצעות הצהרות הדפסה ב-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"));
}

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

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

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

הפניה של לקוח

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

httpClient.get()

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

שימוש

var exchangeObj = httpClient.get(url);

החזרות

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

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

דוגמה

שליחת אובייקט 'Request' מוגדר במלואו שמכיל את המאפיינים של בקשת ה-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: