כרגע מוצג התיעוד של 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
.
הפונקציה Print()
מודל האובייקט של JavaScript כולל פונקציית print()
שאפשר להשתמש בה כדי להפיק מידע על תוצאות ניפוי הבאגים באמצעות הכלי Edge Trace. למידע נוסף, אפשר לעיין בקטע ניפוי באגים באמצעות הצהרות ב-JavaScript Print().
אובייקט המאפיינים
כשמשתמשים ברכיב 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');
מאפיינים של אובייקט הקשר
המאפיין 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['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 המלאה של הבקשה מורכבת מהמאפיינים הבאים:
בעת הקבלה של
|
דוגמאות: context.targetRequest.url = 'http://www.example.com/path?q1=1' context.targetRequest.protocol ='https'; |
|
headers |
כותרות של בקשת HTTP כמיפוי של |
דוגמאות: לבקשת ה-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 |
הפרמטרים של שאילתה בהודעת הבקשה כמיפוי של |
דוגמאות: "?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 ( |
דוגמאות: לגבי הבקשה הזו: 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. גוף הבקשה כולל את החברים הבאים:
|
דוגמאות: לגוף 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 של הודעת התגובה כמיפוי של |
דוגמה: 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 לא הצליח להתחבר לשרת. קודי מצב HTTP4xx
ו-5xx
גורמים לתוצאה שלisError()
false
, מכיוון שהחיבור הושלם והוחזר קוד תגובה חוקי. אםisError()
מחזירהtrue
, אז קריאה אלgetResponse()
מחזירה את קוד ה-JavaScriptundefined
.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.
נושאים קשורים
- מדיניות JavaScript
- מודל אובייקט JavaScript
- לקבלת דוגמאות בסיסיות והוראות, ראו שרתי proxy של API לתכנות עם JavaScript.
- כדי לראות דוגמאות של קוד JavaScript שפועל באופן תקין, אפשר לעיין בדוגמאות של Apigee Edge ב-GitHub.
מאמרים מקהילת Apigee
אפשר למצוא את המאמרים הקשורים הבאים ב-Apigee Community: