צורכת ממשקי API של REST עם (ענן) ABAP

שיחת שיטת פרסם

כאשר עובדים עם ממשקי API של REST, SAP אכן משתמש ב- API של REST לצורך תקשורת בין יישומים. במאמר זה נחקור כיצד לצרוך ממשקי API של REST באמצעות ABAP, ספציפית עם פונקציונליות הענן ABAP. להלן נקודות המפתח שאתה צריך לדעת:

1. API מייצג ממשק תכנות יישומים ומאפשר לשני יישומים לתקשר זה עם זה.
2. ממשקי API של REST הם דפוס של ממשקי API של בניין באמצעות פרוטוקול HTTP ושליחה/קבלת נתוני JSON או XML באמצעות URIS.
3. Odata, פופולרי בעולם SAP, הוא סוג של API של REST.
4. יש מידע מוגבל זמין בצריכת ממשקי API חיצוניים ב- ABAP, במיוחד ממשקי API בעלי רשימת הלבנים עבור Cloud ABAP.
5. במדריך זה נשתמש בממשק ה- API של מציין JSON למטרות הפגנה.
6. ספק API מציע משאבים כמו פוסטים, תגובות, אלבומים, תמונות, טודוס ומשתמשים.
7. אנו נתמקד במשאב הפוסטים לפשטות.
8. לפוסט יש מזהה, כותרת, גוף ומזהה משתמש.
9. כדי לצרוך ממשקי API של REST ב- ABAP, אנו נשתמש ב- API של ABAP עם רשימת הלבנים בשם IF_WEB_HTTP_CLIENT.
10. אנו נשתמש גם בספריית XCO לעבודה עם JSON.

שאלות:

1. למה API עומד?
   API מייצג ממשק תכנות יישומים.
2. מהם APIs REST?
   ממשקי API של REST הם דפוס של ממשקי API של בניין באמצעות פרוטוקול HTTP ושליחה/קבלת נתוני JSON או XML באמצעות URIS.
3. מה זה Odata?
   Odata הוא סוג של ממשק API של REST הפופולרי בעולם SAP.
4. האם יש מידע רב זמין על צריכת ממשקי API חיצוניים ב- ABAP?
   לא, יש מידע מוגבל זמין, במיוחד עבור ממשקי API עם רשימת הלבנים עבור Cloud ABAP.
5. באיזה ספק API נשתמש במדריך זה?
   אנו נשתמש בממשק ה- API של מציייני JSON למטרות הפגנה.
6. אילו משאבים מציע ממשק ה- API של מציין המקום JSON?
   ממשק ה- API של מציייני JSON מציע משאבים כמו פוסטים, הערות, אלבומים, תמונות, טודוס ומשתמשים.
7. באיזה משאב נתמקד במדריך זה?
   אנו נתמקד במשאב הפוסטים לפשטות.
8. אילו תכונות יש לפוסט?
   לפוסט יש מזהה, כותרת, גוף ומזהה משתמש.
9. באיזה API של ABAP רשימת הלבנים נשתמש כדי לצרוך ממשקי API של REST?
   אנו נשתמש ב- IF_WEB_HTTP_CLIENT API.
10. באיזו ספריה נשתמש בעבודה עם JSON?
    אנו נשתמש בספריית XCO.

תשובות מפורטות:

1. למה API עומד?
   API מייצג ממשק תכנות יישומים. זוהי מערכת סטנדרטים המאפשרת לשני יישומים לתקשר זה עם זה.
2. מהם APIs REST?
   ממשקי API של REST הם דפוס של ממשקי API של בניין באמצעות פרוטוקול HTTP. הם מאפשרים ליישומים לשלוח ולקבל נתוני JSON או XML באמצעות URIS. APIs REST מבוססי JSON נמצאים בשימוש נרחב.
3. מה זה Odata?
   Odata הוא סוג של ממשק API של REST פופולרי מאוד בעולם SAP. זה מאפשר גישה נוחה ומניפולציה של נתונים המאוחסנים במערכות SAP.
4. האם יש מידע רב זמין על צריכת ממשקי API חיצוניים ב- ABAP?
   לא, יש מידע מוגבל זמין על צריכת ממשקי API חיצוניים ב- ABAP, במיוחד עבור ממשקי API עם רשימת הלבנים שניתן להשתמש בהם עם Cloud ABAP. הדרכה זו נועדה לספק הנחיות לצריכת ממשקי API של REST באמצעות Cloud ABAP.
5. באיזה ספק API נשתמש במדריך זה?
   אנו נשתמש בממשק ה- API של מציייני JSON, שהוא ממשק API מקוון מזויף לשימוש לבדיקה ואבות-טיפוס. זה מאפשר לנו לבצע פעולות CRUD (ליצור, לקרוא, לעדכן, למחוק).
6. אילו משאבים מציע ממשק ה- API של מציין המקום JSON?
   ממשק ה- API של מציייני JSON מציע משאבים כמו פוסטים, הערות, אלבומים, תמונות, טודוס ומשתמשים. במדריך זה נתמקד במשאב ההודעות.
7. באיזה משאב נתמקד במדריך זה?
   אנו נתמקד במשאב הפוסטים מממשק ה- API של JSON מקום. זה יאפשר לנו להדגים כיצד לבצע פעולות גס בממשק API של REST באמצעות APIs של ABAP עם WhiteDisted בפלטפורמת SAP Cloud.
8. אילו תכונות יש לפוסט?
   לפוסט יש מזהה, כותרת, גוף ומזהה משתמש. המזהה מייצג את המזהה הייחודי של הפוסט, ומזהה המשתמש מייצג את מזהה המשתמש שיצר את הפוסט.
9. באיזה API של ABAP רשימת הלבנים נשתמש כדי לצרוך ממשקי API של REST?
   כדי לצרוך ממשקי API של REST ב- ABAP, אנו נשתמש ב- IF_WEB_HTTP_CLIENT API. זהו ממשק API של ABAP עם רשימת הלבנים המותר לשמש בפלטפורמת SAP Cloud.
10. באיזו ספריה נשתמש בעבודה עם JSON?
    לעבודה עם JSON, אנו נשתמש במהדורת פלטפורמת הענן של ספריית XCO (רכיבי סיומת). ספרייה זו מספקת פונקציונליות שימושית להפיכת נתוני JSON בין מוסכמות שמות שונות, כמו גמלים ל- Under_Score, ולהיפך.

על ידי ביצוע מדריך זה, תוכל לצרוך ממשקי API של REST באמצעות ABAP, ספציפית עם פונקציונליות Cloud ABAP.

צורכת ממשקי API של REST עם (ענן) ABAP

שיחת שיטת הודעה ->

האם SAP משתמשת ב- REST API?

Б эой сранице

Ы зé. С помדיר. Почем эо мого?

Эа сраница о бображае тех сах, кога воматеשיים си сисלוח рmе рגות р רבות ш רבות р р рוהים р рוהים которые нé. Сраница пересанет ообрוחים. До эого момента д.

Исочником запросов может сmжж вредоносfte по, подаееые моди базלוח нилm mчnзnзnчnчnчnчnчnчnчnчnчnчnчnчnчnчnчзדי ы з запросов. Еи ы иололalty ощий дדיר. O. Подробнרבה.

Проверка по сов может тelte пояяе, еи ы водите сדיר еами, или же водите запроы ченн часо.

צורכת ממשקי API של REST עם (ענן) ABAP

API מייצג ממשק תכנות יישומים, והוא כולל מערך סטנדרטים המאפשרים לשני יישומים לדבר זה עם זה. ממשקי API של REST הם דפוס מסוים של בניית ממשקי API. הם מבוססים על פרוטוקול HTTP, שולחים וקבלת נתוני JSON או XML באמצעות URIS (מזהה משאבים אחיד). ממשקי API של REST מבוססי JSON נפוצים. אנו נשתמש גם באחד כזה במדריך זה.

Odata, שהוא פופולרי מאוד בעולם SAP, הוא עצמו API של REST. יש הרבה מידע בחוץ כיצד לספק API של REST מ- ABAP (אני.ה., לפרסם שירות Odata). אבל אין’לא הרבה כיצד לצרוך ממשק API חיצוני ב- ABAP. וממה שמעט יש, זה כולל APIs ABAP שאינם בעלי כביסה, אני.ה., לא ניתן להשתמש בהם עם ענן ABAP. אז החלטתי לכתוב את ההדרכה הזו על צריכת ממשקי API של REST באמצעות Cloud ABAP.

תַרחִישׁ

ספק API

אנו נעבוד עם מציין המקום של JSON – א “חופשי להשתמש בממשק API מקוון מזויף לבדיקה ואב -טיפוס”. זה יאפשר לנו לבצע את כל פעולות CRUD (ליצור, לקרוא, לעדכן, למחוק). כדי להיות הוגנים, היצירה, העדכנו ומחיקה לא יעבדו בפועל, אך השרת יזייף את זה כאילו כן. וזה מספיק לחלוטין למקרה השימוש שלנו!

אֶמְצָעִי

ספק ה- API שלנו חושף פוסטים, הערות, אלבומים, תמונות, טודוס, וכן משתמשים. לצורך הפשטות’S SAME, אנו נשתמש רק ב- פוסטים משאב, והעמיד פנים שהשאר’שם שם. הרעיון המרכזי של ההדרכה שלי הוא לספק מדריך פשוט במיוחד כיצד לבצע את פעולות ה- CRUD בממשק API של REST. ועשה זאת באמצעות ממשקי API של ABAP עם רשימת הלבנים בפלטפורמת SAP Cloud (CP). המשמעות היא שאתה יכול להריץ קוד זה בחשבון ניסיון של SAP CP.

פוסטים מַשׁאָב

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

סוגים: התחלה של post_s, user_id סוג I, סוג מזהה I, מחרוזת סוג כותרת, מחרוזת סוג גוף, סוף פוסט_ה. 

אנו זקוקים למבנה ללא מזהה מכיוון שמזהה ההודעה מוקצה אוטומטית על ידי ה- API של REST. כלומר שאנחנו לא מספקים את זה בעת יצירת פוסט חדש.

API של ענן ABAP משומשים

שליחת בקשות HTTP

כפי שציינתי קודם, המספר המועט של הדרכות קיימות לצריכת ממשקי API של REST ב- ABAP משתמשים בעיקר בממשקי API של ABAP שאינם WHITELIST. לדוגמה, if_http_client האחד, שהשימוש בו אינו מותר בענן ABAP. הדרך לבדוק את ממשקי ה- ABAP של ABAP עם פלטפורמת SAP Cloud היא לגלוש על חפצים משוחררים רשימות. זה נגיש בכלי פיתוח ABAP של Eclipse (ADT) -> סייר פרויקטים -> אובייקטים משוחררים. אז, API ABAP מוכן בענן לשליחת בקשת HTTP הוא ה- if_web_http_client. אנו מגדירים את השיטה הבאה כדי להשיג לקוח:

שיטות: Create_Client ייבוא ​​url סוג מחרוזת חוזרת ערך (תוצאה) סוג ref עד if_web_http_client העלאת cx_static_check 

שיטה Create_Client. נתונים (dest) = cl_http_destination_provider => create_by_url (url). תוצאה = cl_web_http_client_manager => create_by_http_destination (dest). Endmethod. 

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

עובד עם JSON

כדי לעבוד עם JSON, אנו נשתמש במהדורת פלטפורמת הענן של ה- XCO (רכיבי הרחבה) ספריה. קרא עוד על זה כאן וכאן. הכיתה הספציפית, הרלוונטית למקרה השימוש שלנו היא XCO_CP_JSON. משהו בעל ערך רב שהוא מספק הוא היכולת לשנות מוסכמות שמות שונות. לדוגמה, גמל ל- Under_Score, והפך.

צריכת API של REST

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

קבועים: asse_url סוג מחרוזת ערך 'https: // jsonplaceholder.Typicode.com/פוסטים ', content_type סוג מחרוזת ערך' תוכן סוג ', json_content סוג מחרוזת' יישום/JSON; charset = utf-8 '. 

כתובת הבסיס היא פשוט הכתובת של פוסטים מַשׁאָב. שני הקבועים האחרונים שאנו זקוקים להם במקרים בהם אנו נשלח נתונים (i.ה., צור ועדכן) לשרת באמצעות ממשק ה- API של REST. עלינו ליידע את השרת שאנחנו שולחים JSON.

קרא את כל ההודעות

כתובת האתר לקריאת כל ההודעות היא רק כתובת האתר הבסיסית. לכן, אנו יוצרים לקוח עבורו, משתמשים בלקוח כדי לבצע בקשת GET, לסגור את הלקוח ולהמיר את JSON שהתקבל לטבלת פוסטים. סוג טבלת הפוסטים מוגדר ב משאב פוסטים קטע לעיל. אתה יכול גם להתייחס לקוד המלא בסוף.

read_posts ערך חוזר (תוצאה) סוג post_tt העלאת cx_static_check 

שיטה read_posts. "קבל JSON של כל נתוני הפוסטים (URL) = |< base_url >|. נתונים (לקוח) = create_client (url). נתונים (תגובה) = לקוח-> ביצוע (if_web_http_client => get)-> get_text (). לקוח-> סגור (). "המרת JSON לטבלת POST XCO_CP_JSON => DATA-> מ-_STRING (תגובה)-> החל (ערך #((XCO_CP_JSON => טרנספורמציה-> camel_case_to_underscore))-> write_to (ref #(תוצאה)). Endmethod. 

קרא פוסט יחיד

השיטה לקריאת פוסט יחיד דומה, עם ההבדלים שאנו לוקחים כקלט מזהה של הפוסט, ומחזיר מבנה (i.ה., פוסט יחיד,) במקום טבלה (i.ה., רשימת פוסטים). המנוחה API’כתובת האתר של קריאת פוסט יחיד היא כדלקמן:

read_single_post ייבוא ​​מזהה סוג I חוזר ערך (תוצאה) סוג post_s העלאת cx_static_check 

שיטה read_single_post. "קבל JSON לנתוני מזהה קלט (URL) = |< base_url >/ /< id >|. נתונים (לקוח) = create_client (url). נתונים (תגובה) = לקוח-> ביצוע (if_web_http_client => get)-> get_text (). לקוח-> סגור (). "המרת JSON למבנה POST XCO_CP_JSON => DATA-> מ-_STRING (תגובה)-> החל (ערך #((XCO_CP_JSON => טרנספורמציה-> camel_case_to_underscore))-> write_to (ref #(תוצאה)). Endmethod. 

צור פוסט

כפי שהוסבר קודם, פוסטים’ תעודות זהות מוקצות אוטומטית על ידי ה- API של ה- REST. לכן, כדי ליצור פוסט נשתמש ב post_without_id_s סוּג. זה יהיה פרמטר הקלט שלנו. אנו הולכים להמיר ממבנה ABAP זה ל- JSON, שוב באמצעות ספריית XCO. משם אנו יוצרים לקוח. לאחר מכן, קבענו את גוף בקשת HTTP שאנו הולכים לשלוח להיות ה- JSON שיצרנו זה עתה ואנחנו נודיעים לשרת שנשלח סוג תוכן JSON. לבסוף, אנו מבצעים בקשת פוסט ומחזירים את השרת’תגובת S. אם הכל היה טוב, השרת’תגובת S תחזיר לנו את הפוסט שלנו, יחד עם המזהה החדש שנוצר (101, מכיוון שיש כרגע 100 פוסטים).

create_post ייבוא ​​post_without_id סוג post_without_id_s ערך חוזר (תוצאה) סוג מחרוזת העלאת cx_static_check 

שיטה create_post. "המרת פוסט קלט לנתוני JSON (json_post) = xco_cp_json => data-> from_abap (post_without_id)-> החל (ערך #((xco_cp_json => טרנספורמציה-> indscore_to_camel_case))-> to_string (). "שלח JSON של POST לשרת והחזיר את נתוני התגובה (URL) = |< base_url >|. נתונים (לקוח) = create_client (url). נתונים (req) = לקוח-> get_http_request (). req-> set_text (json_post). req-> set_header_field (i_name = content_type i_value = json_content). תוצאה = לקוח-> ביצוע (if_web_http_client => post)-> get_text (). לקוח-> סגור (). Endmethod. 

עדכן הודעה

אנו נעדכן בבקשת מכשירים. המשמעות היא שנספק את הפוסט המלא. טלאים, לעומת זאת, מאפשרת לנו לספק רק את השדה המעודכן (ה.ז., רק כותרת). אם אתה מוצא את זה מעניין, אתה יכול לנסות לגרום לטלאי לבקש את עצמך – זה לא צריך’לא יהיה קשה מדי עם המשאבים המסופקים כאן!

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

אז, ההבדלים היחידים מ לִיצוֹר כלול את הסוג שהשתנה של פרמטר קלט ההודעה, כתובת האתר ושיטת בקשת HTTP (PUT).

עדכון_פוסט ייבוא ​​סוג פוסט פוסט_ה

שיטה עדכון_ פוסט. "המרת פוסט קלט לנתוני JSON (json_post) = xco_cp_json => data-> from_abap (post)-> החל (ערך #((xco_cp_json => טרנספורמציה-> indscore_to_camel_case))-> to_string (). "שלח JSON של POST לשרת והחזיר את נתוני התגובה (URL) = |< base_url >/ /< post-id >|. נתונים (לקוח) = create_client (url). נתונים (req) = לקוח-> get_http_request (). req-> set_text (json_post). req-> set_header_field (i_name = content_type i_value = json_content). תוצאה = לקוח-> ביצוע (if_web_http_client => put)-> get_text (). לקוח-> סגור (). Endmethod. 

מחק הודעה

מחיקת פוסט היא הבקשה הפשוטה ביותר. אנו פשוט לוקחים את המזהה ושולחים בקשת מחק HTTP לכתובת האתר של הפוסט הספציפי. כדי לאפשר למשתמש אם משהו משתבש, אנו בודקים את השרת’קוד התגובה (צריך להיות 200 – כלומר בסדר).

DELETE_POST ייבוא ​​סוג מזהה I העלאת CX_STATIS_CHECK 

שיטה delete_post. נתונים (url) = |< base_url >/ /< id >|. נתונים (לקוח) = create_client (url). נתונים (תגובה) = לקוח-> ביצוע (if_web_http_client => מחק). אם תגובה-> get_status () -code ne 200. העלה סוג חריג CX_WEB_HTTP_CLIENIT_ERROR. Endif. Endmethod.

בדיקת הקוד שלנו

עכשיו כשסיפקנו את כל הפונקציונליות של גס, תן’בדוק אותם! לשם כך, אנו נגיש את IF_OO_ADT_CLASSRUN ממשק, המאפשר להריץ כיתה כיישום קונסולה. יש לה שיטה עיקרית שמתבצעת – דומה ל- Java.

שיטה if_oo_adt_classrun ~ main. לְנַסוֹת. "קרא נתונים (all_posts) = read_posts (). נתונים (first_post) = read_single_post (1). "צור נתונים (create_response) = create_post (ערך #(user_id = 7 title = 'שלום, עולם!'גוף =' :) ')). "עדכן first_post-user_id = 777. נתונים (update_response) = update_post (first_post). "מחק delete_post (9). "הדפיס תוצאות בחוץ-> כתוב (all_posts). Out-> כתוב (first_post). Out-> כתוב (create_response). Out-> כתוב (עדכון_גונה). לתפוס CX_ROOT לנתונים (EXC). Out-> לכתוב (exc-> get_text ()). Endtry. Endmethod.

פועל עם F9 מדפיס את הפלט הבא:

תחילת הפלט בקונסולת ABAP

סוף הפלט במסוף ABAP

סיכום

זה מסיים את ההדרכה כיצד לצרוך ממשקי API של REST ב- Cloud ABAP. אני מקווה שזה היה שימושי עבורך. אם אתה מרגיש שם’S כל נקודות שיפורים, או שיש לך שאלות או משוב עבורי, הודע לי בתגובות!

קוד מלא

Class ZSS_TESTER_2 הגדרה סופית ציבורית צור ציבורי. מדור ציבורי. ממשקים: IF_OO_ADT_CLASSRUN. סוגים: התחלה של post_s, user_id סוג I, סוג מזהה I, מחרוזת סוג כותרת, מחרוזת סוג גוף, סוף פוסט_ה. שיטות: Create_Client ייבוא ​​סוג url סוג מחרוזת חוזר ערך (תוצאה) סוג ref עד if_web_http_client העלאת cx_static_check, read_posts ערך חוזר (תוצאה) סוג post_tt העלאת cx_static_check, read_single_post ייבוא ​​סוג id סוג I Retaut valoat gocate_cid gecation, chect gecate, chect gecate, סוג chect gecation_cid type_cid type_cid type_cid type_cipy type_st. post_without_id_s ערך חוזר (תוצאה) סוג מחרוזת העלאת העלאת cx_static_check, עדכון_פוסט ייבוא ​​סוג פוסט post_s ערך חוזר (תוצאה) סוג מחרוזת העלאת cx_static_check, delete_post ייבוא ​​מזהה סוג I הרמה cx_static_checket. פרק פרטי. קבועים: asse_url סוג מחרוזת ערך 'https: // jsonplaceholder.Typicode.com/פוסטים ', content_type סוג מחרוזת ערך' תוכן סוג ', json_content סוג מחרוזת' יישום/JSON; charset = utf-8 '. Endclass. יישום Class ZSS_TESTER_2. שיטה if_oo_adt_classrun ~ main. לְנַסוֹת. "קרא נתונים (all_posts) = read_posts (). נתונים (first_post) = read_single_post (1). "צור נתונים (create_response) = create_post (ערך #(user_id = 7 title = 'שלום, עולם!'גוף =' :) ')). "עדכן first_post-user_id = 777. נתונים (update_response) = update_post (first_post). "מחק delete_post (9). "הדפיס תוצאות בחוץ-> כתוב (all_posts). Out-> כתוב (first_post). Out-> כתוב (create_response). Out-> כתוב (עדכון_גונה). לתפוס CX_ROOT לנתונים (EXC). Out-> לכתוב (exc-> get_text ()). Endtry. Endmethod. שיטה Create_Client. נתונים (dest) = cl_http_destination_provider => create_by_url (url). תוצאה = cl_web_http_client_manager => create_by_http_destination (dest). Endmethod. שיטה read_posts. "קבל JSON של כל נתוני הפוסטים (URL) = |< base_url >|. נתונים (לקוח) = create_client (url). נתונים (תגובה) = לקוח-> ביצוע (if_web_http_client => get)-> get_text (). לקוח-> סגור (). "המרת JSON לטבלת POST XCO_CP_JSON => DATA-> מ-_STRING (תגובה)-> החל (ערך #((XCO_CP_JSON => טרנספורמציה-> camel_case_to_underscore))-> write_to (ref #(תוצאה)). Endmethod. שיטה read_single_post. "קבל JSON לנתוני מזהה קלט (URL) = |< base_url >/ /< id >|. נתונים (לקוח) = create_client (url). נתונים (תגובה) = לקוח-> ביצוע (if_web_http_client => get)-> get_text (). לקוח-> סגור (). "המרת JSON למבנה POST XCO_CP_JSON => DATA-> מ-_STRING (תגובה)-> החל (ערך #((XCO_CP_JSON => טרנספורמציה-> camel_case_to_underscore))-> write_to (ref #(תוצאה)). Endmethod. שיטה create_post. "המרת פוסט קלט לנתוני JSON (json_post) = xco_cp_json => data-> from_abap (post_without_id)-> החל (ערך #((xco_cp_json => טרנספורמציה-> indscore_to_camel_case))-> to_string (). "שלח JSON של POST לשרת והחזיר את נתוני התגובה (URL) = |< base_url >|. נתונים (לקוח) = create_client (url). נתונים (req) = לקוח-> get_http_request (). req-> set_text (json_post). req-> set_header_field (i_name = content_type i_value = json_content). תוצאה = לקוח-> ביצוע (if_web_http_client => post)-> get_text (). לקוח-> סגור (). Endmethod. שיטה עדכון_ פוסט. "המרת פוסט קלט לנתוני JSON (json_post) = xco_cp_json => data-> from_abap (post)-> החל (ערך #((xco_cp_json => טרנספורמציה-> indscore_to_camel_case))-> to_string (). "שלח JSON של POST לשרת והחזיר את נתוני התגובה (URL) = |< base_url >/ /< post-id >|. נתונים (לקוח) = create_client (url). נתונים (req) = לקוח-> get_http_request (). req-> set_text (json_post). req-> set_header_field (i_name = content_type i_value = json_content). תוצאה = לקוח-> ביצוע (if_web_http_client => put)-> get_text (). לקוח-> סגור (). Endmethod. שיטה delete_post. נתונים (url) = |< base_url >/ /< id >|. נתונים (לקוח) = create_client (url). נתונים (תגובה) = לקוח-> ביצוע (if_web_http_client => מחק). אם תגובה-> get_status () -code ne 200. העלה סוג חריג CX_WEB_HTTP_CLIENIT_ERROR. Endif. Endmethod. Endclass.

יצירת API של REST (קבל ושיחת שיטת פוסט)

ממשק API של REST הוא ממשק תכנות יישומי העברת מצב ייצוגי התואם את אילוצי הסגנון האדריכלי של REST ומאפשר אינטראקציה עם שירותים רואים.

השיטות הנפוצות ביותר הן: לקבל, לפרסם, לשים ולמחוק,

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

תרחיש -> צריך לספק פירוט מנהל התקן על סמך מזהה הנהג.

שלב 1 ->

טבלת בסיס נתונים של מנהל התקן.

שלב 2 ->

צור כיתת מטפל בקשה ‘ZCL_DRIVER_REQ_HANDLER’ וירש עם כיתה סטנדרטית ‘CL_RESTHTTP_HANDLER’

הערה -> חובה ליישם שיטת get_root_handler אחרת זה ייתן שגיאת תחביר.

שלב 3 ->

צור כיתת ספק בקשות ‘ZCL_DRIVER_REQ_PROVIDER’ וירש עם כיתה סטנדרטית ‘CL_REST_RESOURCE’

שלב 4 -> כעת יישם if_rest_resource ~ קבל שיטה לקריאת הנתונים.

לאחר קריאת שיחת הנתונים /ui2 /cl_json => serialize () שיטת להמיר מבנה ABAP לפורמט JSON.

שלב 5 -> יישם get_root_handler שיטת כיתת מטפל בקשה.

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

שלב 6 -> צור אלמנט שירות, TCODE SICF

שלב 7 -> רשימת מטפל קישורים, כאן עלינו להגדיר את מחלקת המטפל בבקשות שלנו ‘ZCL_DRIVER_REQ_HANDLER’.

שלב 8 -> הפעל שירות.

שלב 9 -> שירות מבחן.

תוצאה -> כאן אנו עוברים מנהל התקן ומבוסס על נתוני מזהה מוצגים בפורמט JSON.

שיחת שיטת הודעה ->

תרחיש -> עלינו ליצור פירוט מנהל התקנים חדש בבסיס הנתונים. כפי שאתה יכול לראות מזהה מנהל התקן ‘002’ קיים רק במערכת ועכשיו מזהה חדש ‘001’ צריך ליצור.

ב- LV_DATA משתנה, הנתונים מגיעים במחרוזת JSON

שיטת התקשרו /ui2 /cl_json => deserialize () כדי להמיר מחרוזת JSON למבנה ABAP.

הנה הערך החדש עם תעודת זהות ‘001’

מסקנה ->

לאחר קריאת בלוג זה תוכל ליצור ממשק API פשוט של REST ותהיה לך גם רעיון לקרוא פרמטרים בכיתת ספקים בקשה.

אנא אל תהסס להציע אם יש צורך בתיקון 🙂

פיתוח API של REST ב- ABAP

בשני בלוגים אחרונים, הדגמתי כיצד לכתוב לקוחות אינטרנט של APIS REST – עם XML (יישום הדגמה כאן) או JSON (יישום הדגמה כאן) כפורמט העברת נתונים. בבלוג זה אתמקד בצד השרת: כיצד ליישם API של REST כמטפל בקשת ABAP. אתה יכול לבדוק את כל הקוד שאני דן כאן באתר Magros BSP: IT’הכל בכיתה ZCL_JOB_DATA .

עץ ה- ICF

מטפלי בקשה הם שיעורים המיישמים את הממשק if_http_extension, המורכב משיטה אחת יחידה handle_request. ניתן לחבר מחלקת מטפל בקשה לנתיב ב- SICF. בקשת HTTP נכנסת תנותחה על ידי מסגרת התקשורת באינטרנט, ותנסה להתאים לנתיב הבקשה נגד נתיב SICF. תהליך ההתאמה נעצר ברגע שנמצא צומת עם מטפל בקשה מצורף. אם זה המקרה, ייווצר מופע של מחלקת המטפל, והשיטה של ​​gration_request תיקרא.

שירות הדוגמה שלנו מחובר לנתיב /עבודה/תכונות. הכיתה ZCL_JOB_DATA מוכרזת כאחראית לכל הבקשות הנכנסות בהן נתיב הבקשה מתחיל בה /עבודה/תכונות :

אסטרטגיה ראשונה: שיטת בקשת HTTP

יישום שיטת הממשק if_http_extension ~ handle_request () מהווה את רמת העיבוד העליונה. לפיכך, היישום נותן רק את שלד העיבוד המחוספס: מופע לפעולות מסד נתונים, כמו גם מופע לעיבוד פעולת המנוחה נוצר, הטיפול בבקשה יוחלף לאותה מופע, ויש חסימת תפיסה לעיבוד שגיאות למקרה שלא ניתן לקבוע מופע לעיבוד הבקשה. מצב כזה אמור לגרום לתגובה HTTP עם קוד הסטטוס ‘בקשה שגויה 400’.

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

 שיטה if_http_extensension ~ handle_request . נתונים: סוג LO_DB REF ל- LIF_DB, LO_REST סוג REF ל- LIF_REST, LO_INVALID_METHOD סוג REF ל- ZCX_ERROR, LV_REASON TYPE TYPE. לְנַסוֹת. * אובייקט לפעולות מסד נתונים LO_DB ?= get_db (io_server = שרת). * קבל את מופע המטפל הנכון של מנוחה, תלוי בפועל (השג, לשים, לפרסם, אפשרויות, למחוק) lo_rest ?= get_rest (io_server = שרת io_db = lo_db). * בצע את הפעולה lo_rest-> ander_request (). תפוס ZCX_NOT_FOUND ל- LO_INVALID_METHOD. lv_reason = lo_invalid_method-> get_text (). שרת-> תגובה-> set_status (קוד = 400 "סיבה לבקשה רעה = lv_reason). endtry. Endmethod.

אנו משתמשים בכנס שמות לקביעת המופע: הכיתה lcl_rest_get תשויך ל- HTTP פועל. כל השיעורים הללו מיישמים את הממשק LIF_REST. בדרך זו אנו יכולים להשתמש ביצירת מופע דינאמי. לחלופין, היינו יכולים לכתוב מקרה גדול … הצהרה עם רבים מתי’ג. היתרון של המקרה יהיה שה- צור אובייקט ניתן לבדוק את ההצהרה באופן סטטי אם יש תקינות תחבירית. בחרתי את הגרסא הדינאמית מכיוון שאני מוצא את זה ברור וקריא יותר מאשר חבורה של סניפים.

שימו לב ששיטת בקשת HTTP (קבלו, לשים, פוסט,…) זמינה כשדה כותרת פסאודו עם השם ‘~ request_method’:

שיטה get_rest. נתונים: LV_CLASSNAME סוג SEOCLSNAME, מחרוזת מסוג LV_METHOD, LV_MESSAGE TYPE TEXT255. lv_method = io_server-> בקשה-> get_header_field ('~ request_method'). CONCATENATE 'LCL_REST_' LV_METHOD ל- LV_CLASSNAME. לְנַסוֹת. צור אובייקט EO_REST סוג (LV_CLASSNAME) ייצוא IO_REQUEST = IO_SERVER-> בקשה IO_RESPONSE = IO_SERVER-> תגובה IO_DB = IO_DB. תפוס CX_SY_CREATE_OBJECT_ERROR. lv_message = 'שיטה' '' & '' לא נתמך '(001). החלף '&' ב- LV_Message ב- LV_METHOD. _raise_with_text zcx_not_found lv_message. endtry. Endmethod.

אסטרטגיה שנייה: פורמט העברת נתונים

כעת יש לנו שיעורי מטפלים שונים לשיטות בקשת HTTP השונות. אבל עבור כל המטפלים האלה, ישנן כמה משימות נפוצות. אחת המשימות הנפוצות הללו היא: לקבוע את פורמט העברת הנתונים הנוכחי, ולהמיר את הקלט – אם זמין – לנתוני ABAP, ולהיפך: להמיר את נתוני התוצאה ABAP לפלט עם פורמט העברת הנתונים הרצוי (XML או JSON).

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

סוגים: התחלה של ty_result, symsgty מסוג msgtype, סוג הודעה C אורך 255, סוג משרות zjobs_tab, סוף ty_result.

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

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

 הגדרת LCL_CONVERTER Class Abstract. מדור ציבורי. שיטות שיטות get_instanc. שיטות content_type ערך חוזר מופשט (ev_content_type) מחרוזת. שיטות GET_ENTERED_DATA תקציר ייבוא ​​IV_CDATA סוג מחרוזת ייצוא ES_JOB סוג ZJOBS מעלה ZCX_PARSE_ERROR. שיטות תוצאה_ TO_CDATA יבוא מופשט הוא_ RESULT סוג TY_RESULT ייצוא EV_CDATA STRING TYPE. Endclass. "הגדרת LCL_CONVERTER

השיטה הסטטית lcl_converter => get_instance () עושה את ההבחנה, תלוי ב לְקַבֵּל שדה כותרת של בקשת HTTP:

יישום LCL_Converter Class. שיטה get_instance. אם יישום iv_accept cs/json '. צור אובייקט eo_instance סוג lcl_json_converter. אַחֵר. צור אובייקט eo_instance סוג lcl_xml_converter. endif. Endmethod. "Get_Instance Endclass. "יישום LCL_CONVERTER

העלילה הנפוצה לכל הבקשות

אנו יכולים לחלץ משימות נפוצות ל- LCL_REST של SUPERST של כל מטפלי השיטות הספציפיים, ליישום הממשק LIF_REST ~ ABDARY_REQUEST () פעם אחת לכל סוג המשנה.

צריך לערבב את הקוד הנפוץ ב- Superclasse עם קוד ספציפי, המיושם בתת -משנה ולהגדיר את ההתנהגות הספציפית של אותה תת -סוג. כדי להשיג זאת אנו קוראים בנקודת הזמן הרצויה LIF_REST ~ ABDARY_REQUEST (), שיטה מופשטת לעשות (), שצריך להגדיר מחדש את המשנה. שיטת DO () זו תכיל את הפעולה הספציפית.

כעת, היישום הנפוץ Lif_rest ~ ידית () ב- SuperClass מגדיר רק את זרימת העיבוד, ומשאיר את פעולות הבטון לתת -סוגים או לצירים כמו Go_Converter:

1. לבצע את הפעולה הספציפית על ידי שיחה לַעֲשׂוֹת(),
2. טיפול בשגיאות, עם קוד השגיאה של HTTP 400 “בקשה רעה” במקרה של שגיאת המרה (נתונים נכנסים שגויים), או הגדרת נתוני תגובה להודעת שגיאה במקרה של שגיאת יישום,
3. מבנה התוצאה ממופה למבנה נתוני התגובה (XML או JSON), באמצעות מופע הממיר המתאים,
4. לבסוף, נתוני התגובה ממוקמים בגוף תגובת HTTP, וגם סוג התגובה המתאים מוגדר: יישום/JSON, או טקסט/XML.

זהו הסקיצה הכללית – עיבוד התגובה שתקף עבורו את כל שיטות לבקשת HTTP ולגבי את כל סוגי תוכן (XML כמו גם JSON). הפרטים כלולים בשיטות הנקראות.

שיטה LIF_REST ~ ABDAY_REQUEST. נתונים: סוג LO_EX REF ל- CX_ROOT, מחרוזת מסוג LV_CDATA, LS_RESULT TYPE TY_RESULT. לְנַסוֹת. * בצע את הפעולה הספציפית DO (ייבוא ​​ES_RESULT = LS_RESULT). לתפוס ZCX_PARSE_ERROR ל- LO_EX. go_response-> set_status (קוד = 400 "סיבה לבקשה רעה = lo_ex-> get_text ()). set_response_parameters (). לַחֲזוֹר. לתפוס ZCX_ERROR ל- LO_EX. ls_result-message = lo_ex-> get_text (). ls_result-msgtype = 'e'. endtry. * המיר את מבנה התוצאה ל- JSON או XML, בהתאמה שיטת שיחה GO_CONVERTER-> תוצאה_TO_CDATA ייצוא IS_RESULT = LS_RESULT ייבוא ​​EV_CDATA = LV_CDATA. * מקם את התוצאה בשיטת השיחה של גוף התגובה set_response ייצוא iv_content_type = go_converter-> content_type () iv_cdata = lv_cdata. Endmethod. "ידית_רקווס

משימה ספציפית – בקשת ההכרה

לתת’S התבונן במשימה ספציפית לאיור: בקשת Put – שהיא תמיד משימה לעדכן או להוסיף תכונות עבודה עבור מזהה נתון במסד הנתונים. כדלקמן מהעיצוב, ישנו כיתה מקומית משלו LCL_REST_PUT טיפול בבקשות הכנסת. למעשה, עבור מטפל בקשה זה, היה רק לַעֲשׂוֹת שיטה עצמה ליישום (שהיא המינימום המוחלט עבור מחלקת משימות ספציפית ליישום: לַעֲשׂוֹת() מופשט במחלקת ההורים. ללא יישום, לא ניתן היה לבנות מקרים.):

הגדרת Class LCL_REST_PUT הירושה מ- LCL_REST. קטע מוגן. שיטות עושות הגדרה מחודשת. Endclass. "הגדרת LCL_REST_PUT

היישום הולך כדלקמן:

• העבודה עם המזהה שצוין נקראת ממסד הנתונים (אם צוין תעודת זהות – למשרות חדשות, זה לא המקרה),
• הנתונים שהוזנו ינותחו למבנה LS_JOB, באמצעות המתאים Go_Converter למשל,
• ולבסוף, להציל() שיטה נקראת. זה מיושם ב- SuperClass, מכיוון ששיטות בקשה אחרות משתמשות בו גם.

 יישום Class LCL_REST_PUT. שיטה לעשות. נתונים: LS_JOB סוג ZJOBS, LV_ID סוג ZJOBS-ID. לְנַסוֹת. get_job_by_id (ייבוא ​​es_job = ls_job). LV_ID = LS_JOB-ID. לתפוס ZCX_NOT_FOUND. endtry. נקה LS_JOB. שיטת שיחה go_converter-> get_entered_data ייצוא iv_cdata = go_request-> get_cdata () ייבוא ​​es_job = ls_job. אם LS_JOB אינו ראשוני. אם LV_ID אינו ראשוני. LS_JOB-ID = LV_ID. endif. שמור (שינוי cs_job = ls_job). es_result-message = 'job ונשמר' (002). החלף '&' ב- ES_RESULT-Message ב- LS_JOB-ID. es_result-msgtype = 's'. "הודעת הצלחה הכנס LS_JOB לטבלה ES_RESULT-JOBS. endif. Endmethod. "עשה את Endclass. "יישום LCL_REST_PUT

שים לב כי יישום משימה זו אינו’לא אכפת ממבנה הנתונים של HTTP, מהפורמט הנמצא בפועל ולא לפרטי פורמט נתוני ההעברה. זה פשוט עובד עם מבני נתונים של ABAP ls_job לקלט ו ES_RESULT לפלט.

מושב, זהות ונעילה

ביישומי הבדיקה (לא באפליקציית JSON ולא באפליקציית XML), אין כניסה ולא מקרי של הנתונים. מכיוון שהיישומים פתוחים לכולם, זה עובד רק מכיוון שאני לא’t בֶּאֱמֶת לפעול בטבלת מסד נתונים zjobs. למעשה, כל לקוח שמתקשר לאפליקציה עובד עם נתוני הפעלה משלו, ולכן הוא לא’לא מתנגש עם משתמשים אחרים’ פעולות, והוא עצמו לא מופרע על ידי משתמשים אחרים. נתוני ההפעלה נשמרים עבורו כעוגיות בצד השרת, שורדות את שלב הדיאלוג היחיד (למשל טעינה מחדש של הדף תשחזר את המצב הנוכחי של הנתונים).

כאשר נקודת אינטרנט נכתבת כ- BSP, יש מזהה הפעלה זמין בתכונה זמן ריצה-> server_id. מזהה הפעלה זה מזהה את מופע הדפדפן הספציפי שהגיש את הבקשה. בצד הלקוח, מזהה הפעלה זה תמיד כלול בעוגיה הנקראת SAP-APPCONTEXT. אם יש לאפליקציה מצב שיש לשמור על ידי מזהה הפעלה, יש לחלץ את המזהה מעוגיית SAP-AppContext ויש להעביר אותו כפרמטר שאילתה עם כל בקשות AJAX. להלן הפונקציה שמחלפת את ה- SAP-AppContext מהעוגיה:

 פונקציה get_appcontext () < var lAppcontextCookie = document.cookie.match(/sap-appcontext=(.*?)(?:;|$)/); return lAppcontextCookie && ( lAppcontextCookie.length >= 2) && unescape (lappcontextcookie [1]) || ""; >

ה- AppContext שהוחזר מפונקציה זו, ניתן להעביר כפרמטר שאילתה עם כל בקשת AJAX. בצד השרת, ניתן לחלץ את מזהה ההפעלה מאותו פרמטר:

שיטה get_session_id. נתונים: מחרוזת סוג LV_APP_CONTEXT, LV_APP_CONTEXT64 מחרוזת. * קרא את שדה הטופס, המסופק על ידי בקשת AJAX LV_APP_CONTEXT64 = IO_SERVER-> בקשה-> GET_FORF_FIELD ('SAP_APPCONTEXT'). אם LV_APP_CONTEXT64 אינו ראשוני. * Base64 פענח lv_app_context = cl_http_utility => decode_base64 (lv_app_context64). * חלץ את ה- ID-ID מצא את ה- SAP-sesseid 'של regex = ([^;]+) (?:; | $) 'ב- lv_app_context submatch ev_session_id. endif. אם ev_session_id הוא ראשוני. ev_session_id = io_server-> session_id. endif. Endmethod.

בתור Fallback, בשורה 22 משתמשים ב- Server-> Session_ID. עם זאת, יהיה שרת חדש-> session_id עבור כל בקשה, מה שמביא לנתוני הפעלה טריים עם כל שלב דיאלוג. אם אתה באמת זקוק לניהול הפעלות, חיוני שמזהה ההפעלה יועבר לשרת.

כדאי לשלב את מזהה ההפעלה עם נוהל הכניסה: אם המשתמש מאמת, הדפדפן שלו מקבל מזהה הפעלה עם תוקף מוגבל. יש לעבור מזהה של סשן זה עם כל פעולת מנוחה ברציפות. ב- ABAP ניתן להשתמש בו לאחסון ולאחזור נתונים ספציפיים להפעלה בטבלת מסד הנתונים SSCookie, דרך כיתת הגישה למסד הנתונים שלה Cl_BSP_SERVER_SIDE_Cookie.

צימוד זה של מזהה הפעלה עם כניסה הוא – בערך – האופן בו פועל ממשק ה- API של ה- REST למרכז האיכות של HP.

באמצעות ABAP’ממיר JSON מובנה

בעוד שמופע ממיר ה- XML ​​די פשוט ליישום -קריאת טרנספורמציה של XSLT עבור XML -> ABAP, ואחת נוספת בדרך חזרה -זה עשוי להפתיע שאפשר לטפל בהמרה של JSON בדיוק באותה צורה: עם טרנספורמציות. זה אפשרי מאז שיחה טרנספורמציה ההצהרה תומכת בפורמט JSON (לפחות לפי SAP_Basis 702). JSON מנוהל אוטומטית ומנותח בפורמט JSON-XML ביניים. ניתן לעבד זאת באמצעות טרנספורמציה של XSLT שרירותי, ולהמיר למסמכי XML אחרים או כדי להתאמץ על נתונים.

לדוגמה, בקשת הכנסת מיישום הבדיקה שלנו עשויה לשלוח את נתוני ה- JSON הבאים לשרת:

אם מיתר עם תוכן זה מועבר כ “מקור XML” להתאפק’הצהרת טרנספורמציה של שיחה, ה- JSON ינותח לייצוג XML כמו זה (קל להבין את הפורמט – אני חושב שהסבר דליל אינו הכרחי כאן):

בעת עיבוד טרנספורמציה של XSLT שרירותית, עם הצהרת טרנספורמציה של שיחה, ומעבירים מחרוזת JSON כמקור, ה- XSLT יפעל על ידי ייצוג JSON-XML פנימי זה. קל להפוך מסמך JSON-XML כזה לנתוני ABAP-ליתר דיוק: להפוך אותו לייצוג ASXML של נתוני ABAP. לדוגמה, קחו בחשבון את טרנספורמציית ה- XSLT הבאה:

כאשר הוא מיושם על מחרוזת JSON, הוא יביא את התוצאה הבאה:

     0001 Rsnast00 UXPD_KUBE_KV 2 איקס ריינר זופאל פלט את כל אישורי הזמנת המכירה   

זהו תיאור נתוני ABAP תקף. אם הטרנספורמציה נקראת ZJSON2JOB, ניתן לייבא את הנתונים פשוט למבנה נתונים של ABAP עם מזהה הרכיבים, Repid וכן הלאה – וכך גם המבנה ES_JOB ביישום הבא של ממיר JSON.

יישום Class LCL_JSON_CONVERTER. שיטה get_entered_data. נתונים: סוג LO_EX REF ל- CX_TRANSFORMATION_ERROR. נקה ES_JOB. בדוק שטח של IV_CDATA CN. לְנַסוֹת. שיחה טרנספורמציה zjson2job מקור xml iv_cdata תוצאה עבודה = es_job. לתפוס CX_TRANSFORMation_ERROR ל- LO_EX. raise_parse_error (lo_ex). endtry. Endmethod. "get_entered_data

דברים רבים יכולים להיעשות עם מזהה טרנספורמציה זהות, ללא צורך להגדיר טרנספורמציה של XSLT משלו בכלל. אם אתה יכול להטיל את מבנה הנתונים של JSON שישמש ביישום האינטרנט, זה יתרון להשתמש כזה “קנוני” מִבְנֶה. לדוגמה, שקול לעטוף את חשיש JSON עם תכונות העבודה לחשיש אחר, מה שהופך אותו לערך לאיזה שם מפתח סמלי כמו “עבודה”:

אז ניתן לנתח את הנתונים למבנה ללא צורך בפיתוח טרנספורמציה XSLT בהתאמה אישית, פשוט באמצעות הזהות:

 שיחה מקור מזהה טרנספורמציה xml iv_cdata תוצאה עבודה = es_job.

בדוגמה זו, מכיוון שכתבתי את הקלידה באינטרנט ואת העיבוד בצד השרת, יכולתי לבחור בזה יותר “קנוני” פוּרמָט. אבל בכך שלא לבקשתי את זה, למדתי לעבוד עם פורמטים של נתונים גמישים יותר של JSON.

ישנן כמה סיבות לעבודה עם “לא קנוני” ייצוג JSON של נתוני ABAP:

• פורמט JSON עשוי להיות מעוצב לטובת יישום האינטרנט – כדי לייעל את הקריאות של קוד JavaScript של הלקוח העובד על הנתונים.
• יתכנו רכיבי לקוחות הדורשים פורמטים מסוימים של JSON. לדוגמה, ה- jQuery DataTable מחייב את נתוני הטבלה שיועברו כמגוון מערכים: http: // www.Datatables.Net/Release-datablable/דוגמאות/data_sources/ajax.html
• שירותי צד שלישי מבוסס JSON עשויים להיקרא מצד ABAP (עם אובייקט לקוח HTTP)
• נתוני ABAP עשויים להיות מוּקרָן לנתונים החיוניים, הפחתת גודל ההודעה לנתונים שהם באמת נחוצים.

רק כדי להמחיש, תן’S עיין בהמרה האחרת – הדרך החוצה מהשרת ללקוח. שוב, הפורמט שונה מעט מה- “קנוני” פורמט JSON, שיפשט את הטיפול בצד ABAP במידה ניכרת. כאמור, מבנה נתוני התוצאה מכיל

• הודעה,
• סוג הודעה,
• וטבלה של תכונות עבודה:

סוגים: התחלה של ty_result, symsgty מסוג msgtype, סוג הודעה C אורך 255, סוג משרות zjobs_tab, סוף ty_result.

הפורמט הבא יהיה תליון JSON מושלם למבנה זה. זה יכול להיות פשוט מיוצר עם טרנספורמציית הזהות, עובר כמו “תוצאת מקור = ls_result” (איפה LS_RESULT הוא מבנה מסוג ty_result):

• כל שמות הרכיבים תואמים בצורה מושלמת את שמות המפתח של JSON hash,
• טבלה פנימית ממופה כמגוון JSON של חשיש, שכל חשיש מייצג ערך אחד של הטבלה,
• ויש חשיש ברמה העליונה עם שם סמלי “תוֹצָאָה” עבור הדבר השלם:

אבל הפורמט של JSON ש- API של ה- REST תומך בו, למעשה שונה בפרטים מסוימים:

• המשרות מתוכננות לא כמערך, אלא כחשיש, עם המזהה כמפתח hash.
• אין חשיש מיותר, עוטף את כל העניין כערך עבור מפתח כלשהו.
• הרכיב ל- msgtype שונה. זה פשוט נקרא סוג.

להלן מופע דוגמה:

 < "JOBS": < "0001": < "REPID": "RSNAST00", "VARID": "UXPD_KUBE_KV", "PRIO": "2", "RESTART": "X", "CONTACT": "Rainer Zufall", "DESCR": "Output all sales order confirmations" >, "0002": < "REPID": "RBDAPP01", "VARID": "UXPD_EDI_GUT02", "PRIO": "3", "RESTART": "X", "CONTACT": "Herbert Hurtig", "DESCR": "Credit Memos" >>, "הודעה": "", "סוג": "">

אנו ממשיכים בצורה דומה כנ”ל, רק בכיוון השני: בהתבסס על סוג נתוני ABAP ty_result, אנו כותבים טרנספורמציה של XSLT כדי להשיג את הפורמט הפנימי של JSON-XML המתאים למחרוזת נתוני JSON זו.

פורמט הנתונים של JSON-XML של מחרוזת הנתונים הרצויה של JSON נראה כך:

אז זהו היעד שיש להשיג כתוצאה מהטרנספורמציה. מצד שני, פורמט ASXML של המבנה Ty_Result נראה כך:

       0001 Rsnast00 UXPD_KUBE_KV 2 איקס ריינר זופאל פלט את כל אישורי הזמנת המכירה  0002 RBDAPP01 Uxpd_edi_gut02 3 איקס הרברט הרטיג תזכירי אשראי   מִבְחָן אני   

וזו תוכנית XSLT שתבצע את הטרנספורמציה:

אנו רואים את זה, בעיקרון, לכל סטייה מה- “קנוני” ייצוג JSON של נתוני ABAP, קיימת תבנית בטרנספורמציה של XSLT המטפלת בסטייה זו. לדוגמה, סוג השם השונה במקום msgtype במטרה מטופל בתבנית

יש לארגן מחדש את המזהה: מהיותו תכונה פשוטה של ​​מבנה הנתונים של ZJOBS, יש להעלות אותו ברמה אחת גבוהה יותר כדי להפוך למפתח של חשיש. כל שאר התכונות, למעט מזהה, מועתקים כצמתי מחרוזת לתוצאה. לשם כך, שתי התבניות הללו נחוצות:

מיפוי אובייקט נתוני Ty_Result למחרוזת JSON של הפורמט הצפוי, מבוצע כעת ב- ABAP עם הקוד הבא:

שיטה תוצאה_ to_cdata. נתונים: סוג LO_WRITER REF ל- CL_SXML_STRING_WRITER. lo_writer = cl_sxml_string_writer => create (type = if_sxml => co_xt_json). שיחה טרנספורמציה zjobs2json נתוני מקור = is_result תוצאה xml lo_writer. ev_cdata = cl_abap_codepage => monvert_from (lo_writer-> get_output ()). Endmethod. "תוצאה_ to_cdata

זֶה’לאחר.

סיכום

תיארתי כמה נושאים טיפוסיים הנוגעים ליישום ממשקי API של REST ב- ABAP. אפשר לשמור על חששות נפרדים בכיתות נפרדות (מקומיות או גלובליות) על ידי יישום דפוסים כמו אִסטרָטֶגִיָה. כך מסודר הכיתה ZCL_JOB_DATA, המשרת את API של Demo REST שלי, (הרעיונות הבסיסיים נדונו בבלוג זה):

כיצד ליצור ממשק API REST עם SAP ABAP ולהחיל ניתוב MVC1

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

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

ולבסוף ניצור שירות לטיפול בבקשות מנוחה.

בסוף הפוסט ישנם דפדפן אינטרנט, דוור ואב -צורכים דוגמאות לאותה API של REST.

לקריאה נוספת על SAP Rest, עיין במדריך המנוחה.

צור מבנים הבאים;

• ZREST_S_RESP_STATE
• ZREST_S_RESPONSE
• ZREST_S_REQUEST

• ZREST_S_RESP_STATE

• ZREST_S_RESPONSE

עכשיו נעשה זאת ליצור שיעורים.

שיחה ערימה לשיחה

• ZREST_CL_DEFS
• ZREST_CL_MODEL
• ZREST_CL_REQ_CONTROLLER
• ZREST_CL_REQ_HTTP_HANDLER
• ZREST_CL_HTTP_HANDLER

Class ZREST_CL_DEFS הגדרת הציבור צור ציבורי . מדור ציבורי. קבועים c_state_success סוג char1 ערך 's' ## no_text. קבועים c_state_warning סוג char1 ערך 'w' ## no_text. קבועים c_state_error סוג char1 ערך 'e' ## no_text. קטע מוגן. פרק פרטי. Endclass. יישום Class ZREST_CL_DEFS. Endclass.

Class ZREST_CL_MODEL DEFIDENE סופי ציבורי צור ציבורי . מדור ציבורי. שיטות get_dateteTime ייצוא !תגובה_בוי סוג ZREST_S_RESPONSE-BODY !סוג STATE ZREST_S_RESPONSP-STATE . קטע מוגן. פרק פרטי. Endclass. יישום Class ZREST_CL_MODEL. * ---------------------------------------------------------------------------------------+ * | מופע שיטה ציבורית ZREST_CL_MODEL-> GET_DATETIME * + ------------------------------------------------------------------------------------------------- + * | [שיטה get_datetime. נתונים: סוג EXREF REF ל- CX_ROOT. לְנַסוֹת . סוגים: התחלה של ty_res, סוג DateTime tzntimestp, סוף Ty_res. נתונים: סוג Res ty_res. res-datetime = sy-datum && sy-uezit. תגובה_בובי = /ui2 /cl_json => serialize (ייצוא נתונים = res). STATE-STATE = ZREST_CL_DEFS => C_STATE_SUCCESS. לתפוס CX_ROOT ל- EXREF. STATE-STATE = ZREST_CL_DEFS => C_STATE_ERROR. State-state_text = exref-> get_text (). Endtry. Endmethod. Endclass.

Class ZREST_CL_REQ_CONTROLLER DEFIDEN PURIM PURIT . מדור ציבורי. שיטות תהליך_רקווסט ייבוא !ייצוא מחרוזת סוג req_json !מחרוזת מסוג תגובה_ג'סון !תגובה_ STC סוג ZREST_S_RESPONSE . קטע מוגן. פרק פרטי. קבועים: C_REQ_GET_DATETIME סוג ZREST_E_REQ_ID ערך '1001'. שיטות conv_stc_to_json ייבוא ​​תגובה_ STC סוג ZREST_S_RESPONSE ערך חוזר (תוצאה) מחרוזת סוג. Endclass. יישום Class ZREST_CL_REQ_CONTROLLER. * ---------------------------------------------------------------------------------------+ * | מופע שיטה פרטית ZREST_CL_REQ_CONTROLLER-> CONV_STC_TO_JSON * + ----------------------------------------------------------------------------------------------- + * | [--->] תגובה_ STC סוג ZREST_S_RESPONSE * | [שיטה conv_stc_to_json. נתונים: סוג EXREF REF ל- CX_ROOT. לְנַסוֹת . תוצאה = /ui2 /cl_json => serialize (ייצוא נתונים = response_stc). לתפוס CX_ROOT. תוצאה = exref-> get_text (). Endtry. Endmethod. * ---------------------------------------------------------------------------------------+ * | מופע שיטה ציבורית ZREST_CL_REQ_CONTROLLER-> Process_Request * + ------------------------------------------------------------------------------------------------- + * | [--->] מחרוזת סוג req_json * | [שיטה תהליך_שקוט. נתונים: סוג EXREF REF ל- CX_ROOT. לְנַסוֹת . נתונים req_stc סוג ZREST_S_REQUEST. /ui2/cl_json => deserialize (ייצוא json = req_json שינוי נתונים = req_stc). אם req_stc-id אינו ראשוני. נתונים (מודל) = חדש ZREST_CL_MODEL (). אם req_stc-id eq c_req_get_datetime. model-> get_dateTime (ייבוא ​​תגובה_בובי = תגובה_סטיק-body מצב = תגובה_סטה-state). אַחֵר. Response_stc-state-state = zrest_cl_defs => c_state_warning. הודעה S001 (ZREST_MSG) ל- Response_STC-state-state_text. Endif. אַחֵר. "מלא תוכן דמה כדוגמה req_stc-id = 99999999. req_stc-body = 'קצת תוכן JSON'. Response_stc-body = /ui2 /cl_json => serialize (ייצוא נתונים = req_stc). Response_stc-state-state = zrest_cl_defs => c_state_warning. הודעה S002 (ZREST_MSG) ל- Response_STC-STATE_TEXT. Endif. Response_json = conv_stc_to_json (response_stc = response_stc). לתפוס CX_ROOT. Response_stc-state-state = zrest_cl_defs => c_state_error. Response_stc-state-state_text = exref-> get_text (). Response_json = conv_stc_to_json (response_stc = response_stc). Endtry. Endmethod. Endclass.

Class ZREST_CL_REQ_HTTP_HANDLER הגדרת ציבור בירושה מ- CL_REST_RESOURCE סופי צור ציבורי . מדור ציבורי. שיטות if_rest_resource ~ קבל הגדרה מחודשת . שיטות if_rest_resource ~ לאחר הגדרה מחדש . קטע מוגן. פרק פרטי. Endclass. Class ZREST_CL_REQ_HTTP_HANDLER יישום. * ---------------------------------------------------------------------------------------+ * | מופע שיטה ציבורית ZREST_CL_REQ_HTTP_HANDLER-> IF_REST_RESOURCE ~ קבל * + ----------------------------------------------------------------------------------------------- + * +-------------------------------------------------------------------------------------- שיטה if_rest_resource ~ קבל. נתונים (req_json) = mo_request-> get_uri_query_parameter (iv_name = 'req' iv_encoded = abap_false). נתונים (בקר) = חדש ZREST_CL_REQ_CONTROLLER (). בקר-> process_request (ייצוא req_json = req_json ייבוא ​​תגובה_JSON = DATA (תגובה_JSON)). mo_response-> create_entity ()-> set_string_data (iv_data = response_json). Endmethod. * ---------------------------------------------------------------------------------------+ * | מופע שיטה ציבורית ZREST_CL_REQ_HTTP_HANDLER-> IF_REST_RESOURCE ~ POST * + --------------------------------------------------------------------------------------------------- + * | [--->] סוג io_entity סוג ref to if_rest_entity * +-------------------------------------------------------------------------------------- שיטה if_rest_resource ~ פוסט. נתונים (req_json) = mo_request-> get_entity ()-> get_string_data (). נתונים (בקר) = חדש ZREST_CL_REQ_CONTROLLER (). בקר-> process_request (ייצוא req_json = req_json ייבוא ​​תגובה_JSON = DATA (תגובה_JSON)). mo_response-> create_entity ()-> set_string_data (iv_data = response_json). Endmethod. Endclass.

CSRF מושבת במטפל למטה. השבתו מפרמטרי השירות של GUI אינה פועלת. עליך ליישם את Andy_csrf_token על מנת להשבית אותה למנוחה.

Class ZREST_CL_HTTP_HANDLER הגדרת ציבור בירושה מ- CL_REST_HTTP_HANDLER צור פומבי . מדור ציבורי. "מספק ניתוב. נתיבי ניתוב מוקצים לבקרים בשיטות שיטות אלה IF_REST_APPLICATION ~ GET_ROOT_HANDLER הגדרה מחדש . קטע מוגן. "אם אתה רוצה להשבית, הגדר מחדש את השיטה הזו. בדיוק כשיטה ריקה. שיטות gration_csrf_token הגדרה מחודשת . פרק פרטי. Endclass. יישום Class ZREST_CL_HTTP_HANDLER. * ---------------------------------------------------------------------------------------+ * | שיטה מוגנת מופע ZREST_CL_HTTP_HANDLER-> ABORDY_CSRF_TOOKEN * + ------------------------------------------------------------------------------------------------- + * | [--->] io_csrf_handler סוג ref to if_rest_csrf_handler * | [--->] io_request סוג ref to if_rest_request * | [--->] io_response סוג ref to if_rest_response * +-------------------------------------------------------------------------------------- שיטה ידית_מוסס_טוקן. * שיטת שיחה super-> ander_csrf_token * ייצוא * io_csrf_handler = * io_request = * io_response = * . Endmethod. * ---------------------------------------------------------------------------------------+ * | מופע שיטה ציבורית ZREST_CL_HTTP_HANDLER-> IF_REST_APPLICATION ~ GET_ROOT_HANDLER * + ----------------------------------------------------------------------------------------------- + * | [שיטה if_rest_application ~ get_root_handler. "מספק ניתוב. "נתיב שירות/SAP/BC/REST" url לדוגמה http: // vhcalnplci: 8000/sap/bc/מנוחה/zrest/מנוחה?sap-client = 001 & req = data (root_handler) = חדש Cl_Rest_Router (). ROOT_HANDLER-> צרף (ייצוא IV_TEMPLATE = '/REST' "שם אחיד למשאבים IV_HANDLER_CLASS = 'ZREST_CL_REQ_HTTP_HANDLER'" שם אובייקט). * "אתה יכול להוסיף עוד שיעורי מטפל בקשה *" נתיב שירות/SAP/BC/REST * "url לדוגמה http: // vhcalnplci: 8000/sap/bc/rest/zrest/rest2?sap-client = 001 & req = * root_handler-> צרף ( * ייצוא * iv_template = '/rest2' "שם מאוחד למשאבים * iv_handler_class = 'zrest_cl_req_http_handler2'" שם סוג אובייקט *). ro_root_handler = root_handler. Endmethod. Endclass.

והצעד האחרון, צור שירות.

פתח את SICF TCODOD.

עבור אל/SAP/BC/מנוחה והוסף אלמנט משנה חדש

הוסף תיאור ועבור לכרטיסייה רשימת מטפל ולכיתה שלנו, ZREST_CL_HTTP_HANDLER, כמטפל.

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

במקרה שלי, http: // vhcalnplci: 8000/sap/bc/מנוחה/zrest/מנוחה

אם אתה רוצה להעביר כמה פרמטרים בבקשת Get, הוסף פרמטרים של מחרוזת שאילתה כמו ‘http: // vhcalnplci: 8000/sap/bc/מנוחה/zrest/מנוחה?sap-client = 001 & req =’

אם אינך מבטל את CSRF במטפל, יהיו לך בעיות התקשרות לשיטות שאינן GET, כגון שיטות פוסט של POSTMAN או מלקוח שונה משרת עצמו.

לכן בדוגמה שלי השבתתי CSRF.

דוגמאות לדואר

פרמטרי אימות בסיסיים

קבל דוגמה ותוצאה

דוגמה לפרסם ותוצאה

לצרוך מ- ABAP

אנו נשתמש ב- httpclient כדי לבצע שיחה ואנחנו ננתח את JSON למבנה ABAP עם דוגמה Get_DateTime.

קוד לקוח HTTP

Class Zutil_CL_REST_WS הגדרת ציבור צור ציבורי . "עטיפת כיתות לביצוע שיחות שירות מנוחה. קטע ציבורי. "קבועים קבועים: c_content_type_json ערך מחרוזת 'יישום/json; charset = utf-8', c_content_type_xml ערך מחרוזת 'יישום/xml; charset = utf-8', c_request_method_. "מייצרת שיטות שיחה של WS CALL_WS ייבוא ​​ערך (I_URL) סוג מחרוזת ערך (I_CONTENT_TYPE) סוג מחרוזת ברירת מחדל C_CONTENT_TYPE_JSON ערך (I_REQUEST_METHOD) סוג מחרוזת ברירת מחדל C_REQUEST_METHOD_GET ערך (I_USENMAME) סוג של ערך I_PATY OPTION (ISTORATITE OPTIONAL (ISTORATIT, סוג אופציונל (I_PAYSTOR, סוג I_PAYSTATE) סוג אופציונל. IL_CL_DEFS => gty_state ערך (e_responsion_str) מחרוזת. קטע מוגן. פרק פרטי. נתונים http_client סוג ref עד if_http_client. שיטות fill_warning ערך חוזר (מצב) סוג zutil_cl_defs => gty_state. Endclass. יישום Class Zutil_CL_REST_WS. * ---------------------------------------------------------------------------------------+ * | מופע שיטה ציבורית zutil_cl_rest_ws-> call_ws * + ------------------------------------------------------------------------------------------------- + * | [--->] מחרוזת מסוג I_URL * | [--->] i_content_type סוג מחרוזת (ברירת מחדל = c_content_type_json) * | [--->] i_request_method type מחרוזת (ברירת מחדל = c_request_method_get) * | [--->] מחרוזת מסוג I_USERNAME (אופציונלי) * | [--->] מחרוזת מסוג I_Password (אופציונלי) * | [--->] מחרוזת סוג סוג של סוג (אופציונלי) * | [Gty_state * | [שיטה call_ws. נתונים: סוג EXREF REF ל- CX_ROOT. לְנַסוֹת. "שימוש ב- create_by_url זה יכול לפשט היבטים מסוימים של שימוש בכיתה זו בחינם http_client. cl_http_client => create_by_url (ייצוא url = i_url ייבוא ​​לקוח = http_client יוצא מן הכל. אם sy-subrc <> 0. e_state-state = fill_warning (). לַחֲזוֹר. Endif. "ההיגיון שלי השתמש במקור לשים, אבל אתה אמור להיות מסוגל לשנות לפרסום http_client-> בקשה-> set_method (i_request_method). http_client-> בקשה-> set_content_type (i_content_type). "זכור לאמת אם i_username אינו ראשוני או i_password אינו ראשוני. http_client-> אימות (שם משתמש = i_username סיסמה = i_password). Endif. "אם קיים, הכן מטען והקצאה אם ​​i_payload אינו ראשוני. "המיר את העומס הזה ל- xstring. נתונים lv_payload_x סוג xstring. פונקציית שיחה 'scms_string_to_xstring' ייצוא טקסט = i_payload ייבוא ​​חיץ = lv_payload_x חריגים נכשלו = 1 אחרים = 2. אם sy-subrc <> 0. e_state-state = zutil_cl_defs => c_state_warning. E_STATE-STATE = 'שגיאת קידוד!'. לַחֲזוֹר. אַחֵר. http_client-> בקשה-> set_data (lv_payload_x). "נתונים בינאריים endif. Endif. "שליחת הבקשה http_client-> שלח (חריגים http_communication_failure = 1 http_invalid_state = 2). אם sy-subrc <> 0. e_state-state = fill_warning (). לַחֲזוֹר. Endif. "קבלת התגובה http_client-> קבל (חריגים http_communication_failure = 1 http_invalid_state = 2 http_processing_failed = 3). אם sy-subrc <> 0. e_state-state = fill_warning (). לַחֲזוֹר. Endif. "בדוק את התגובה. אני מקווה שתחזיר תגובה של JSON. e_response_str = http_client-> תגובה-> get_cdata (). אם e_response_str הוא ראשוני. e_response_str = http_client-> תגובה-> get_data (). Endif. e_state-state = zutil_cl_defs => c_state_success. e_state-state_text = 'הושלם בהצלחה.'. לתפוס CX_ROOT ל- EXREF. e_state-state = zutil_cl_defs => c_state_error. e_state-state_text = exref-> get_text (). Endtry. Endmethod. * ---------------------------------------------------------------------------------------+ * | מופע שיטה פרטית Zutil_CL_REST_WS-> FILL_WARNING * + --------------------------------------------------------------------------------------------------- + * | [Gty_state * +-------------------------------------------------------------------------------------- שיטה fill_warning. STATE-STATE = ZUTIL_CL_DEFS => C_STATE_WARNINNING. http_client-> get_last_error (ייבוא ​​הודעה = נתונים (msg) "הודעת שגיאה). State-state_text = msg. Endmethod. Endclass.

קוד מחלקת צרכנים. תחילה מבטל את מבנה התגובה ובודק את המדינה. אם זו הצלחה אז ביטול חלק מהגוף JSON לתוצאה של מזהה שיחה 1001.

Class ZREST_CL_CONSUMER הגדרת ציבורי סופית צור ציבורי . מדור ציבורי. שיטות get_datetime ייצוא סוג מצב zutil_cl_defs => gty_state dt type tzntimestp. קטע מוגן. פרק פרטי. Endclass. יישום Class ZREST_CL_CONSUMER. * ---------------------------------------------------------------------------------------+ * | מופע שיטה ציבורית ZREST_CL_CONSUMER-> GET_DATETIME * + --------------------------------------------------------------------------------------------------- + * | [Gty_state * | [שיטה get_datetime. "שיטת לדוגמא לצרוך נתוני API של מנוחה: Exref Type Ref ל- CX_ROOT. לְנַסוֹת. "קבועים: C_UNAME סוג מחרוזת 'מפתח', C_PASS סוג מחרוזת ערך 'DOWN1OAD'. "בנה נתוני שיחה: סוג מחרוזת סוג url 'http: // vhcalnplci: 8000/sap/bc/מנוחה/zrest/מנוחה?sap-client = 001 '. נתונים req_stc סוג ZREST_S_REQUEST. req_stc-id = '1001'. נתונים (req_json) = /ui2 /cl_json => serialize (ייצוא נתונים = req_stc). url = url && '& req =' && req_json. "התקשר לאינטרנט API חדש ZUTIL_CL_REST_WS ()-> CALL_WS (ייצוא i_url = url i_username = c_uname i_password = c_pass ייבוא ​​e_state = State e_response_str = נתונים (json_response)). אם מדינת המדינה Eq Zutil_CL_DEFS => C_STATE_SUCCESS. נתונים: resp_stc סוג ZREST_S_RESPONSE. /ui2/cl_json => deserialize (ייצוא json = json_response שינוי נתונים = resp_stc). אם resp_stc-state-state eq zutil_cl_defs => c_state_success. סוגים: התחלה של ty_res, סוג DateTime tzntimestp, סוף Ty_res. נתונים: RESP_1001 סוג TY_RES. /ui2/cl_json => deserialize (ייצוא json = resp_stc-body משתנה נתונים = resp_1001). dt = resp_1001-datetime. Endif. Endif. לתפוס CX_ROOT ל- EXREF. STATE-STATE = ZUTIL_CL_DEFS => C_STATE_ERROR. State-state_text = exref-> get_text (). Endtry. Endmethod. Endclass.

זה הכל. בדרך זו תוכלו לשלב כל סביבה, מערכת ל- SAP.

מקווה שזה עוזר.

תודה שקראת.

קישורים קשורים