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

אתם צופים במסמכי התיעוד של Apigee Edge.
כדאי לעיין במסמכי התיעוד של Apigee X. מידע

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

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

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

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

• ‫context: אובייקט שמספק גישה להקשר של ההודעה
• ‫request: קיצור דרך שמאפשר גישה לאובייקט הבקשה
• תשובה: קיצור דרך שמאפשר גישה לאובייקט הבקשה
• ‫crypto: מספקת פונקציות גיבוב שונות
• ‫print: פונקציה להפקת פלט
• ‫properties: מאפשר גישת קריאה למאפייני ההגדרה במדיניות

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

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

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

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

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

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

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

הפונקציה print()‎

מודל האובייקטים של 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>

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));
}

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

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

לאובייקט הקריפטו יש היקף גלובלי. הוא זמין בכל מקום בתהליך של proxy ל-API. הספרייה 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. הפרמטר הזה זהה לפרמטר Default: 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 object methods
• מאפיינים של אובייקט ההקשר
• context object children

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

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

אפשר לעיין בהפניה למשתני זרימה ובמדיניות Extract Variables.

context object summary

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

שיטות של אובייקט context

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 הוא מחרוזת שמזהה את התהליך הנוכחי של ה-API proxy. המאפיין הזה משמש לציון ה-Flow שאליו מצורף ה-JavaScript. הערכים הנתמכים הם:

• PROXY_REQ_FLOW
• PROXY_RESP_FLOW
• TARGET_REQ_FLOW
• TARGET_RESP_FLOW

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

דוגמה

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

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

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

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

context.session

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

דוגמה

הגדרת ערך בסשן:

context.session['key']  = 123;

קבלת הערך מהסשן:

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

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

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

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

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

• context.*Request child objects
• context.*Response child objects

context.*Request child objects

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

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

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

context.*Request child object properties

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

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

context.proxyRequest.headers['Content-Type'];
context.proxyRequest.headers['Authorization'];

application/json
Bearer ylSkZIjbdWybfs4fUQe9BqP0LH5Z

"?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

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

context.proxyRequest.method;

POST

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

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

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

{
"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];

context.*Response child objects

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

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

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

context.*Response object properties

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

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

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

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

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

ניפוי באגים באמצעות הצהרות print()‎ של 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"));
}

כדי לראות את הפלט, בוחרים באפשרות Output from all transactions (פלט מכל העסקאות) בתחתית חלון Trace. אפשר גם למצוא פלט במאפיין 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 שימושי לפיתוח שירותים מורכבים או שילובים. לדוגמה, אפשר לאחד כמה קריאות ל-backend לשיטת API אחת. האובייקט הזה משמש בדרך כלל כחלופה למדיניות ServiceCallout.

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

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

חומר עזר בנושא httpClient

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

httpClient.get()

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

שימוש

var exchangeObj = httpClient.get(url);

החזרות

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

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

דוגמה

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

// 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
• דוגמאות והוראות בסיסיות מופיעות במאמר תכנות של פרוקסי API באמצעות JavaScript.
• דוגמאות קוד של JavaScript שעובדות זמינות בדוגמאות של Apigee Edge ב-GitHub.

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

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

• איך מטפלים בכותרות עם כמה ערכים ב-JavaScript?
• The Book of Apigee Edge Antipatterns