אתה צופה בתיעוד של 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
.
הפונקציה Print()
מודל האובייקט של JavaScript כולל פונקציית print()
שניתן להשתמש בה כדי ליצור פלט של נתוני ניפוי באגים אל הכלי Edge Trace. מידע נוסף זמין במאמר ניפוי באגים באמצעות הצהרות ב-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');
מאפייני אובייקט הקשר
הנכס 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['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 המלאה של הבקשה מורכבת מהמאפיינים הבאים:
בעת קבלת
|
דוגמאות: 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 ylSkZIjbdWybfs4fUQe9BqP0LH5ZJavaScript הבא: 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 |
גוף ההודעה (מטען ייעודי) של בקשת ה-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, נוצרים שני אובייקטים של הודעות תגובה: מוכנס (התגובה מהשירות לקצה העורפי) ויוצא (התגובה נשלחת ללקוח).
אובייקט ההקשר כולל אובייקטים צאצאים שמייצגים את הודעות התגובה האלה: 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, על ידי
ציון שמות הרכיבים והמאפיינים. לא ניתן להעביר את ההיררכיה באמצעות התחביר השני.
ניפוי באגים באמצעות הצהרות הדפסה ב-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 לא הצליח להתחבר לשרת. קודי מצב HTTP4xx
ו-5xx
מניבים את הערכיםisError()
false
, כאשר החיבור הושלם וקוד תגובה חוקי הוחזר. אם הפונקציהisError()
מחזירה את הערךtrue
, קריאה ל-getResponse()
מחזירה את קוד ה-JavaScriptundefined
.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.
נושאים קשורים
- המדיניות בנושא JavaScript
- מודל אובייקטים של JavaScript
- לקבלת הוראות והוראות בסיסיות, עיינו במאמר שרתי proxy של תכנות של ממשקי API באמצעות JavaScript.
- לצפייה בדוגמאות של קוד JavaScript פעיל, תוכלו לעיין בדוגמאות של Apigee Edge ב-GitHub.
מאמרים של קהילת Apigee
המאמרים הקשורים האלה זמינים בקהילת Apigee: