คำถามติดแท็ก api-design

ปิด คำถามนี้จะต้องมีมากขึ้นมุ่งเน้น ไม่ยอมรับคำตอบในขณะนี้ ปิดให้บริการใน6 ปีที่ผ่านมา ล็อคแล้ว คำถามและคำตอบของคำถามนี้ถูกล็อคเนื่องจากคำถามอยู่นอกหัวข้อ แต่มีความสำคัญทางประวัติศาสตร์ ขณะนี้ไม่ยอมรับคำตอบหรือการโต้ตอบใหม่ มันเกี่ยวกับ API ที่ยอดเยี่ยมอะไรที่ทำให้มันยอดเยี่ยม ฉันคิดว่าการปฏิบัติตาม "ทำสิ่งหนึ่งสิ่งใดและทำได้ดี" มนต์เป็นสัญญาณที่ดีและการทำแผนที่ที่ดีกับโดเมนปัญหานั้นเป็นสิ่งสำคัญ แต่ API ที่ดีมีอะไรที่เหมือนกัน?

15 api-design 

ฉันพัฒนาแอพพลิเคชั่นซึ่งจะรองรับผู้ใช้หลายคน สิ่งที่ฉันไม่สามารถคิดออกวิธีการตรวจสอบลูกค้า / ผู้ใช้ ฉันกำลังสร้างแอพอย่างhttp://quickblox.com/ที่ฉันจะให้ข้อมูลประจำตัวแก่ผู้ใช้ของฉันและพวกเขาจะใช้แอปเหล่านี้เพื่อสร้างแอปพลิเคชั่นNที่พวกเขาไม่สามารถใส่ชื่อผู้ใช้และรหัสผ่านเพื่อรับรองความถูกต้อง สมมติว่ามันเป็นไปตาม(เหมือน QuickBlox) 1. ผู้ใช้สร้างบัญชีในเว็บไซต์ของฉัน 2. ผู้ใช้สามารถสร้างคีย์ N API และข้อมูลรับรองความลับ (สำหรับหลายแอพ) 3. ผู้ใช้จะใช้ข้อมูลรับรองเหล่านี้ในแอปพลิเคชัน (Android, iOS, Javascript ฯลฯ ... ) เพื่อพูดคุยกับ REST API ของฉัน (REST API มีการเข้าถึงแบบอ่านและเขียน) ความกังวลของฉัน? ผู้ใช้จะใส่ข้อมูลประจำตัว (คีย์ API และคีย์หลั่ง) ในแอปพลิเคชันที่พวกเขาสร้างจะเกิดอะไรขึ้นถ้ามีคนรับคีย์เหล่านี้และพยายามเลียนแบบผู้ใช้ (โดยการแยกข้อมูล APK หรือดูโค้ด JavaScript โดยตรง ฉันผิดตรงไหนเหรอ? ฉันสับสนในการออกแบบกลไกผู้ใช้สามระดับนี้

14 design-patterns  architecture  api-design  authentication  enterprise-architecture 

ฉันออกแบบ REST API ของการบริการและติดอยู่กับวิธีที่เหมาะสมในการซ้อนทรัพยากร ทรัพยากร: คู่ค้าตั๋วการตั้งค่า การเชื่อมต่อระหว่างทรัพยากร: พันธมิตรมีตั๋วหลายใบ พันธมิตรมีการตั้งค่า ตรรกะ Bussines: คุณสามารถแสดงรายชื่อพันธมิตรทั้งหมดเป็นผู้ใช้ที่ไม่ระบุชื่อ คุณสามารถเพิ่มตั๋วใหม่ให้กับพันธมิตรที่ระบุในฐานะผู้ใช้ที่ไม่ระบุชื่อ พันธมิตรเท่านั้นที่สามารถแสดงตั๋วของเขา พันธมิตรเท่านั้นที่สามารถแก้ไขตั๋วของเขาได้ พันธมิตรเท่านั้นที่สามารถแสดงรายการการตั้งค่า พันธมิตรเท่านั้นที่สามารถแก้ไขการตั้งค่า สิ่งที่ฉันทำจนถึงตอนนี้: แหล่งข้อมูลพันธมิตร GET / คู่ค้า - แสดงรายชื่อพันธมิตรทั้งหมด GET / คู่ค้า /: id - แสดงรายละเอียดของพันธมิตรที่ระบุโดย: พารามิเตอร์ id GET / คู่ค้า /: partner_id / ตั๋ว - รายการตั๋วของพันธมิตร GET / คู่ค้า /: คู่ค้า / ตั๋ว /: …

14 api  rest  api-design 

ซูคือการออกแบบห้องสมุด Magician.jsJavaScript, Linchpin มันเป็นฟังก์ชั่นที่ดึงRabbitออกมาจากการโต้แย้งผ่าน เธอรู้ว่าผู้ใช้อาจต้องการที่จะดึงกระต่ายออกจากStringการNumberเป็นบางทีแม้กระทั่งFunction HTMLElementเมื่อคำนึงถึงสิ่งนี้เธอสามารถออกแบบ API ของเธอได้ดังนี้: อินเตอร์เฟซที่เข้มงวด Magician.pullRabbitOutOfString = function(str) //... Magician.pullRabbitOutOfHTMLElement = function(htmlEl) //... แต่ละฟังก์ชั่นในตัวอย่างด้านบนจะรู้วิธีจัดการอาร์กิวเมนต์ประเภทที่ระบุในชื่อฟังก์ชัน / ชื่อพารามิเตอร์ หรือเธอสามารถออกแบบได้เช่น: อินเทอร์เฟซ "เฉพาะกิจ" Magician.pullRabbit = function(anything) //... pullRabbitจะต้องพิจารณาถึงความหลากหลายของประเภทที่คาดหวังที่แตกต่างกันซึ่งการanythingโต้แย้งอาจเป็นประเภทที่ไม่คาดคิด (แน่นอน): Magician.pullRabbit = function(anything) { if (anything === undefined) { return new Rabbit(); // out of thin air } else if (isString(anything)) …

14 javascript  api  api-design 

ขึ้นอยู่กับสิ่งที่ผู้ชายคนนี้พูดว่า: http://toddfredrich.com/ids-in-rest-api.html สมมติว่าเขาถูกต้องเกี่ยวกับการใช้ UUID เพื่อระบุทรัพยากร api จากนั้นฉันก็พบปัญหาในการพยายามใช้มันในลักษณะนี้คือ: class FooEntity { final String id = null; //auto-generated by my backend (mongodb), not shared final UUID uid = UUID.randomUUID(); //the resource id } (ระหว่างไคลเอนต์และเซิร์ฟเวอร์ถูกส่งและรับ DTO ไม่ใช่เอนทิตีฐานข้อมูล) ปัญหาตอนนี้คือidมันไม่มีประโยชน์อย่างที่ฉันไม่ได้ใช้อีกต่อไป ไคลเอนต์ทำการร้องขอด้วยuidเหตุใดฉันจึงรำคาญที่จะจัดการ 2 id ของ จากนั้นเราจะกลับไปสู่จุดเริ่มต้นเดียวกัน หากฉันตั้งค่า UUID เป็นคีย์หลัก ( _id) ฉันจะเปิดเผย ID เบื้องหลังให้กับสาธารณะ นอกจากนั้นยังมีหัวข้อประสิทธิภาพ ฉันอ่านว่าการจัดทำดัชนีโดย …

14 database  api-design  mongodb 

เรามี ASP.NET Web API ที่ให้บริการ REST API สำหรับแอปพลิเคชันหน้าเดียวของเรา เราใช้ DTOs / POCO เพื่อส่งผ่านข้อมูลผ่าน API นี้ ปัญหาคือตอนนี้ DTO เหล่านี้เริ่มใหญ่ขึ้นตามกาลเวลาดังนั้นตอนนี้เราต้องการที่จะปรับโครงสร้าง DTO อีกครั้ง ฉันกำลังมองหา "วิธีปฏิบัติที่ดีที่สุด" วิธีการออกแบบ DTO: ขณะนี้เรามี DTO ขนาดเล็กที่ประกอบด้วยเฉพาะเขตข้อมูลประเภทค่าเช่น: public class UserDto { public int Id { get; set; } public string Name { get; set; } } DTO อื่น ๆ ใช้ …

13 rest  api-design  web-api  dto  poco 

ฉันทำการค้นคว้าเกี่ยวกับการออกแบบบริการเว็บสงบและฉันได้มาถึงสิ่งที่ฉันคิดว่าเป็นจุดตัดสินใจที่สำคัญดังนั้นฉันคิดว่าฉันจะเสนอมันต่อชุมชนเพื่อรับคำแนะนำ เพื่อให้สอดคล้องกับหลักการของสถาปัตยกรรม RESTful ฉันต้องการนำเสนอ API ที่สามารถค้นพบได้ดังนั้นฉันจะสนับสนุนคำกริยา HTTP ต่างๆอย่างเต็มที่เท่าที่จะทำได้ ความยากของฉันมาพร้อมกับตัวเลือกในการแสดงทรัพยากรเหล่านั้น คุณเห็นไหมว่ามันจะเป็นเรื่องง่ายสำหรับผมที่จะสร้าง API ของตัวเองซึ่งจะครอบคลุมถึงการนำเสนอผลการค้นหาและการเชื่อมโยงไปยังแหล่งข้อมูลอื่น ๆ ฉันได้อ่านเกี่ยวกับ Atom Publishing Protocol ( RFC 5023 ) และวิธีการที่ODataส่งเสริมการใช้งาน แต่ดูเหมือนว่าจะเพิ่มระดับการเพิ่มความเป็นนามธรรมให้กับ API ที่ค่อนข้างง่าย (ปัจจุบัน) ดังนั้นคำถามของฉันคือนักพัฒนาควรเลือก AtomPub เป็นตัวเลือกในการแสดงของพวกเขาเมื่อใด? และถ้าไม่ใช่แนวทางที่แนะนำในปัจจุบันคืออะไร?

13 web-services  rest  api-design 

ฉันกำลังอ่านหนังสือหลักการพึ่งพาวิธีปฏิบัติและรูปแบบการพึ่งพาหนังสือและฉันอ่านเกี่ยวกับแนวคิดของสิ่งที่เป็นนามธรรมซึ่งอธิบายไว้ในหนังสือ วันนี้ฉันกำลังสร้างฐานรหัส C # ขึ้นใหม่โดยใช้การฉีดอ้างอิงเพื่อให้มีการใช้การโทรแบบ async แทนการบล็อก การทำเช่นนี้ฉันกำลังพิจารณาอินเทอร์เฟซบางตัวที่เป็นนามธรรมในรหัสฐานของฉันและต้องได้รับการออกแบบใหม่เพื่อให้สามารถใช้การโทรแบบ async ได้ เป็นตัวอย่างให้พิจารณาอินเตอร์เฟสต่อไปนี้ที่แสดงถึงที่เก็บสำหรับผู้ใช้แอ็พพลิเคชัน: public interface IUserRepository { Task<IEnumerable<User>> GetAllAsync(); } ตามคำนิยามของหนังสือสิ่งที่เป็นนามธรรมคือสิ่งที่เป็นนามธรรมที่ได้รับการออกแบบมาโดยเฉพาะในใจนามธรรมเพื่อให้รายละเอียดของการดำเนินการ "รั่ว" ผ่านสิ่งที่เป็นนามธรรมเอง คำถามของฉันมีดังต่อไปนี้: เราสามารถพิจารณาอินเทอร์เฟซที่ออกแบบโดยคำนึงถึง async เช่น IUserRepository เป็นตัวอย่างของ Leaky Abstraction ได้หรือไม่? แน่นอนว่าการใช้งานที่เป็นไปไม่ได้ทั้งหมดมีบางอย่างที่เกี่ยวข้องกับ asynchrony: มีเพียงการติดตั้งแบบไม่ใช้กระบวนการ (เช่นการใช้ SQL) แต่การเก็บข้อมูลในหน่วยความจำไม่จำเป็นต้องใช้แบบอะซิงโครนัส ยากถ้าอินเทอร์เฟซถูกเปิดเผยเมธอด async ตัวอย่างเช่นคุณอาจต้องส่งคืนสิ่งที่ต้องการเช่น Task.CompletedTask หรือ Task.FromResult (ผู้ใช้) ในการประยุกต์ใช้เมธอด) คุณคิดยังไงเกี่ยวกับที่ ?

13 c#  object-oriented  api-design  interfaces  dependency-injection 

ฉันสลับไปมา ~ 5 ครั้งแล้ว ปลายทาง REST นี้ที่/api/tags/จะใช้ภายใน (ไม่มีลูกค้าภายนอก) ฉันเป็นคนเดียวที่ทำงานกับมัน ฉันกำลังตัดสินใจระหว่างตัวแทนสองคนนี้: แบน { "types":[ { "id":1, "text":"Utility" }, { "id":7, "text":"Lease Terms" }, ], "tags":[ { "id":8, "text":"Water", "type":1 }, { "id":9, "text":"Electricity", "type":1 }, { "id":5, "text":"Minimum 12 month lease", "type":7 }, { "id":17, "text":"lease negotiable/flexible", "type":7 }, ] } …

12 rest  api-design  json 

ฉันกำลังออกแบบ RESTful API และประสบกับปัญหาชื่อเรื่องซึ่งได้รับการปรับปรุงใหม่เพื่อความชัดเจน: ฉันควรจะล้มเหลวอย่างรวดเร็วหากลูกค้าส่งพารามิเตอร์ที่ไม่รู้จัก? ตัวอย่างเช่น, http://example.com/api/foo?bar=true&paula=bean ในด้านบนbarเป็นพารามิเตอร์ที่ถูกต้อง แต่paulaไม่ได้ระบุไว้โดย API ฉันควร เตือนให้ลูกค้าทราบถึงข้อผิดพลาด ล้มเหลวอย่างรวดเร็ว ไม่ต้องสนใจมัน ถ้าฉันเตือนไคลเอนต์ฉันสามารถออกคำเตือนสำหรับพารามิเตอร์แรกเท่านั้นเนื่องจากพวกเขาสามารถส่งได้ใกล้จำนวนไม่สิ้นสุดและเซิร์ฟเวอร์น่าจะมีสิ่งที่ต้องทำดีกว่า ในทำนองเดียวกันเมื่อล้มเหลวมันจะระบุพารามิเตอร์ที่ไม่ถูกต้องครั้งแรกเป็นปัญหาเท่านั้น ฉันชอบความล้มเหลวมากกว่าการออกคำเตือนเพื่อบังคับให้โปรแกรมเมอร์ดำเนินการเนื่องจากอาจเพิกเฉยต่อปัญหาและทำให้สิ้นเปลืองทรัพยากรหรือทำให้การขนส่งสินค้าเกิดปัญหาโดยไม่ตั้งใจ การไม่ทำสิ่งใดที่เลวร้ายยิ่งไปกว่านั้นในแง่นั้น ข้อโต้แย้งของฉันสมเหตุสมผลหรือไม่ มีวิธีปฏิบัติที่เป็นที่ยอมรับในเรื่องดังกล่าวหรือไม่?

12 rest  api-design 

ฉันกำลังทำงานบนพอร์ตจาก Python ถึง Rust และพบกับโค้ดบางอย่างที่ไม่สามารถแสดงออกได้อย่างเป็นธรรมชาติใน Rust ตามที่ทำได้ใน Python กรณีนี้มีการใช้พารามิเตอร์เริ่มต้น: class Foo: def __init__(self, a="Hello"): self._a = a ในสนิมคุณอาจใช้สิ่งนี้โดยใช้เครื่องมือสร้าง: struct FooBuilder { a: &'static str, } struct Foo { _a: &'static str } impl FooBuilder { fn new() -> FooBuilder { FooBuilder { a: "Hello", } } fn change_a(self, new_a: &'static …

12 api-design  porting 

ฉันอยู่ในขั้นตอนการออกแบบ HTTP API หวังว่าจะทำให้ RESTful ที่สุดเท่าที่จะทำได้ มีการกระทำบางอย่างที่ฟังก์ชันการทำงานกระจายไปทั่วทรัพยากรบางอย่างและบางครั้งจำเป็นต้องเลิกทำ ฉันคิดกับตัวเองเสียงนี้ดูเหมือนรูปแบบคำสั่ง แต่ฉันจะสร้างแบบจำลองเป็นทรัพยากรได้อย่างไร ฉันจะแนะนำทรัพยากรใหม่ชื่อ XXAction เช่น DepositAction ซึ่งจะถูกสร้างขึ้นผ่านบางสิ่งเช่นนี้ POST /card/{card-id}/account/{account-id}/Deposit AmountToDeposit=100, different parameters... สิ่งนี้จะสร้าง DepositAction ใหม่และเปิดใช้งานวิธีการ Do / Execute ในกรณีนี้การส่งคืนสถานะ HTTP ที่สร้าง 201 หมายถึงการดำเนินการถูกดำเนินการสำเร็จ หลังจากนั้นหากลูกค้าต้องการดูรายละเอียดการกระทำที่เขาสามารถทำได้ GET /action/{action-id} ควรปิดกั้นการอัปเดต / วางเพราะฉันไม่เกี่ยวข้องที่นี่ และเพื่อเลิกทำการกระทำฉันคิดถึงการใช้ DELETE /action/{action-id} ซึ่งจริงๆแล้วจะเรียกวิธีการเลิกทำของวัตถุที่เกี่ยวข้องและเปลี่ยนสถานะเป็น สมมติว่าฉันมีความสุขกับสิ่งเดียวที่ต้องเลิกทำฉันไม่จำเป็นต้องทำซ้ำ วิธีนี้ใช้ได้หรือไม่ มีข้อผิดพลาดใด ๆ เหตุผลที่จะไม่ใช้มัน? สิ่งนี้เป็นที่เข้าใจจาก POV ของลูกค้าหรือไม่

12 design-patterns  api  rest  api-design  http 

ฉันกำลังมองหาแหล่งข้อมูลที่ดีสำหรับการเรียนรู้เกี่ยวกับการออกแบบ API ที่ดีสำหรับไลบรารี C ++, การดูออบเจกต์ร่วม / dll เป็นต้นมีทรัพยากรมากมายในการเขียน API ที่ดี, คลาสที่ดี, เทมเพลตและอื่น ๆ ในระดับซอร์ส วางสิ่งต่าง ๆ เข้าด้วยกันใน libs และ executables ที่ใช้ร่วมกัน หนังสือเช่นการออกแบบซอฟต์แวร์ C ++ ขนาดใหญ่โดย John Lakos มีความน่าสนใจ แต่ล้าสมัยอย่างมาก สิ่งที่ฉันกำลังมองหาคือคำแนะนำเช่นในการจัดการแม่แบบ ด้วยเทมเพลตใน API ของฉันฉันมักจะจบลงด้วยรหัสห้องสมุดในแฟ้มที่ปฏิบัติการได้ของฉัน (หรือไลบรารีอื่น ๆ ) ดังนั้นถ้าฉันแก้ไขข้อบกพร่องที่นั่นฉันไม่สามารถเปิดไลบรารีใหม่ได้ แต่ต้องคอมไพล์ใหม่และแจกจ่ายลูกค้าทั้งหมดของรหัสนั้น (และใช่ฉันรู้วิธีแก้ปัญหาบางอย่างเช่นพยายามสร้างอินสแตนซ์ที่พบบ่อยที่สุดในห้องสมุดเป็นต้น) ฉันกำลังมองหาคำเตือนและข้อควรระวังอื่น ๆ เพื่อรักษาความเข้ากันได้ของไบนารีในขณะที่ทำงานกับไลบรารี C ++ มีเว็บไซต์หรือหนังสือที่ดีในเรื่องดังกล่าวหรือไม่?

12 c++  libraries  api-design  dll 

ตัวอย่างเช่นฉันมีเอนทิตี: ลูกค้า, รายงาน ลูกค้าอาจมีหลายรายงานและฉันคิดว่าจุดสิ้นสุดสำหรับการจัดการรายงานเดียวควรซ้อนกันเช่นนี้ /clients/{client_id}/reports/{report_id} สำหรับรายงานทั้งหมดของลูกค้าหนึ่งรายคาดว่าจะเป็น enpoint: /clients/{client_id}/reports แต่ควรมองหาจุดสิ้นสุดเพื่อให้ได้รับรายงานทั้งหมดของลูกค้าทั้งหมดเพื่อให้ API มีความสอดคล้องและได้รับการออกแบบมาเป็นอย่างดี แนวทางของฉัน: (ฉันเห็นมันในบาง google api) ใช้ "-" แทนและแยกเป็น "ทั้งหมด": /clients/-/reports สิ่งนี้คงรูปแบบจุดปลายเหมือนกัน แต่ดูผิดปกติเล็กน้อยไม่พบ rfc ใด ๆ ที่แนะนำวิธีนี้ สร้างจุดปลายแยกเฉพาะสำหรับรายงานทั้งหมด: /reports แต่เพื่อรับรายงานลูกค้าก็ยัง: /clients/{client_id}/reports Refactor endpoints เพื่อทำให้ "client" ไม่ใช่ parent แต่เป็นเพียงพารามิเตอร์ตัวกรอง: /reports?client={client_id} - รายงานลูกค้าหนึ่งราย /reports - รายงานของลูกค้าทั้งหมด ในกรณีของการเพิ่มจุดปลายใหม่สำหรับการโพสต์รายงานสำหรับลูกค้าที่เฉพาะเจาะจงมันอาจดูน่าเกลียดเพราะมันจะเป็นคำขอ POST กับพารามิเตอร์ใน URL มีคำแนะนำอื่น ๆ เกี่ยวกับความคิดหรือไม่?

12 rest  api  api-design 

ฉันเห็นคำถามมากมายเกี่ยวกับการเข้าถึงคีย์ JSON ที่ใช้ยัติภังค์ (กรณีเคบับ) แต่ตอนนี้ฉันพบว่าตัวเองสงสัยว่าฉันควรติดกับ camelCase หรือ snake_case ในกุญแจของฉัน ฉันรู้ว่ายัติภังค์สามารถสร้างการแมปที่ซับซ้อนได้เมื่อทำการย้ายระหว่างภาษา ฉันเคยเห็นไลบรารี่ของ JSON ที่ทำการ deserialize แปลงคีย์เหล่านั้นเป็นรูปแบบ camelCase ตัวอย่าง: var something = { "some-value": 'thing' } Vs var something = { "someValue": 'thing', "some_other_value": 'thing_two' }

12 javascript  api  api-design  json  web-api