คำอธิบายโดยละเอียดเกี่ยวกับการฝึกซ้อมฤดูใบไม้ผลิของกรอบการลองใหม่

Spring retry เป็นฟังก์ชั่นพลังงานที่เป็นอิสระจากชุดฤดูใบไม้ผลิซึ่งส่วนใหญ่ใช้การลองใหม่และฟิวส์ มีข้อ จำกัด สถานการณ์สำหรับการลองใหม่และไม่ใช่ทุกสถานการณ์ที่เหมาะสำหรับการลองใหม่เช่นการตรวจสอบพารามิเตอร์ที่ผิดกฎหมายการดำเนินการเขียน ฯลฯ (คุณต้องพิจารณาว่าการเขียนนั้นเป็น idempotent) ไม่เหมาะสำหรับการลองใหม่ การหมดเวลาการโทรระยะไกลหรือการหยุดชะงักของเครือข่ายสามารถลองใหม่ได้อีกครั้ง ในกรอบการกำกับดูแล Microservice มักจะมีการกำหนดค่าการลองใหม่และการหมดเวลาของตัวเอง ตัวอย่างเช่น Dubbo สามารถตั้งค่า retries = 1, timeout = 500 การโทรล้มเหลวและลองอีกครั้งเพียงครั้งเดียวและการโทรล้มเหลวหากไม่กลับมาหลังจากผ่านไปมากกว่า 500ms ในฤดูใบไม้ผลิลองใหม่คุณสามารถระบุประเภทของข้อยกเว้นที่ต้องลองใหม่และตั้งค่าช่วงเวลาสำหรับการลองใหม่และหากการลองใหม่ล้มเหลวไม่ว่าจะลองดำเนินการต่อหรือฟิวส์ต่อไป

การออกแบบและการดำเนินการ

RetryOperations กำหนด API ใหม่ RetryTemplate เป็นการใช้งานโหมดเทมเพลตของ API ซึ่งใช้การลองใหม่และทำลายวงจร API ที่ให้ไว้มีดังนี้:

 อินเทอร์เฟซสาธารณะ retryoperations {<t, e ขยายได้> t execute (retryCallback <t, e> retryCallback) โยน e; } // API อื่น ๆ ถูกละไว้

RetryCallback กำหนดการดำเนินการที่ต้องดำเนินการ หลังจากกำหนดการดำเนินการมันเป็นคำถามของวิธีการลองใหม่ RetryTemplate ดำเนินการตรรกะของวิธีการลองใหม่โดยการกำหนดกลยุทธ์การลองใหม่ที่แตกต่างกัน กลยุทธ์การลองใหม่เริ่มต้นนั้น SimpleRetryPlicy ซึ่งหมายความว่าจะลองใหม่ 3 ครั้ง หากการลองใหม่ประสบความสำเร็จคุณจะไม่ลองอีกครั้ง แล้วถ้าการลอง 3 ฟุตล้มเหลวล่ะ? กระบวนการสิ้นสุดหรือส่งคืนผลลัพธ์จากล่างขึ้นบน ในการส่งคืนผลลัพธ์จากล่างขึ้นบนคุณจะต้องกำหนดค่า RecoveyCallBack จากชื่อคุณจะเห็นว่านี่เป็นอินเทอร์เฟซการโทรกลับจากล่างขึ้นบนซึ่งเป็นตรรกะของการดำเนินการหลังจากการลองใหม่ล้มเหลว นอกเหนือจาก SimpleRetryPolicy ยังมีกลยุทธ์การลองใหม่อื่น ๆ มาดูอินเทอร์เฟซ RetryPolicy :

 ส่วนต่อประสานสาธารณะ RetryPolicy ขยาย serializable {boolean canretry (บริบท retryContext); retryContext เปิด (RetryContext Parent); เป็นโมฆะปิด (บริบท retryContext); เป็นโมฆะ registerthrowable (บริบท retrycontext, throwable throwable);}

canRetry เรียกว่าทุกครั้งที่คุณลองอีกครั้ง เงื่อนไขการตัดสินว่าคุณสามารถลองอีกครั้งต่อไปได้หรือไม่
เรียกว่าก่อนที่จะเริ่มต้นใหม่ open บริบทการลองใหม่จะถูกสร้างขึ้นไปยัง RetryContext และจะบันทึกสแต็กลองอีกครั้ง
registerThrowable เรียกว่าทุกครั้งที่มีการลองใหม่ (มีข้อยกเว้นและจะดำเนินการต่อไปอีกครั้ง)

ใช้ตัวอย่าง SimpleRetryPolicy เป็นตัวอย่าง เมื่อจำนวนการลองใหม่ถึง 3 (เริ่มต้น 3 ครั้ง) ให้หยุดการลองใหม่และจำนวนการลองใหม่จะถูกบันทึกไว้ในบริบทของการลองใหม่

ให้การใช้กลยุทธ์การลองใหม่ต่อไปนี้:

1. NeverretryPolicy: อนุญาตให้โทรกลับได้เท่านั้น
2. AlwaysRetryPolicy: อนุญาตให้ลองไม่สิ้นสุดจนกว่าจะประสบความสำเร็จ ตรรกะที่ไม่เหมาะสมในวิธีนี้จะนำไปสู่การวนซ้ำ
3. SimpleRetryPolicy: นโยบายการลองใหม่จำนวนสูงสุดของเวลาลองอีกครั้งคือ 3 ครั้งโดยค่าเริ่มต้นนโยบายที่ใช้โดย retryTemplate โดยค่าเริ่มต้น
4. TIMEOUTRETRYPOLICY: นโยบายการลองใช้เวลาหมดเวลาการหมดเวลาเริ่มต้นคือ 1 วินาทีและอนุญาตให้ลองอีกครั้งภายในเวลาหมดเวลาที่กำหนด
5. ExceptionClassifierRetryPolicy: ตั้งค่ากลยุทธ์การลองใหม่สำหรับข้อยกเว้นที่แตกต่างกันคล้ายกับการรวมกันของกลยุทธ์การลองใหม่ความแตกต่างคือการลองใหม่สำหรับข้อยกเว้นที่แตกต่างกันเท่านั้น
6. CircuitBreakERRETRYPOLICY: นโยบายการลองใหม่ด้วยฟังก์ชั่นเบรกเกอร์, 3 พารามิเตอร์จำเป็นต้องตั้งค่า opentimeout, resettimeout และมอบหมาย
7. CompositeretryPolicy: มีวิธีการรวมกันสองวิธี กลยุทธ์การลองใหม่ในแง่ดีหมายถึงตราบใดที่มีกลยุทธ์ที่ช่วยให้การลองใหม่และกลยุทธ์การลองใหม่ในแง่ร้ายหมายถึงตราบใดที่มีกลยุทธ์ที่ไม่อนุญาตให้ลองลองใหม่ แต่ไม่ว่าวิธีการรวมกันใดแต่ละกลยุทธ์ในการรวมกันจะถูกดำเนินการ

ลองใช้กลยุทธ์ทางเลือกอีกครั้งหมายถึงว่าการลองใหม่แต่ละครั้งจะลองใหม่ทันทีหรือรอสักครู่ก่อนที่จะลองอีกครั้ง โดยค่าเริ่มต้นคุณจะต้องระบุนโยบาย backoff BackoffRetryPolicy หากคุณต้องการกำหนดค่าระยะเวลารอและลองอีกครั้ง BackoffretryPolicy มีการนำไปใช้ดังต่อไปนี้:

1. NoBackoffpolicy: ไม่มีกลยุทธ์อัลกอริทึม backoff ลองทันทีหลังจากการลองใหม่แต่ละครั้ง
2. คงที่ backoffpolicy: นโยบายการสำรองเวลาคงที่ จำเป็นต้องตั้งค่าพารามิเตอร์และ backoffperiod ผู้นอนหลับระบุนโยบายการรอคอย ค่าเริ่มต้นคือ thread.sleep นั่นคือด้ายสลีป backoffperiod ระบุเวลานอนและค่าเริ่มต้นคือ 1 วินาที
3. UniformRandomBackOffPolicy: นโยบายการย้อนกลับแบบสุ่ม, Sleeper, MinBackoffPeriod และ MaxBackoffPeriod นโยบายนี้ใช้เวลานอนแบบสุ่มระหว่าง [MinBackOffPeriod, MaxBackOffPeriod, MinBackoffPeriod, เริ่มต้น 500 มิลลิวินาที
4. ExponentialBackOffPolicy: นโยบาย backoff แบบเอ็กซ์โปเนนเชียล, พารามิเตอร์ Sleeper, InitialInterval, MaxInterval และตัวคูณต้องตั้งค่า InitialInterval ระบุเวลานอนเริ่มต้นเริ่มต้น 100 มิลลิวินาที MaxInterval ระบุเวลาการนอนหลับสูงสุดเริ่มต้น 30 วินาทีตัวคูณระบุตัวคูณนั่นคือเวลานอนต่อไปคือเวลานอนหลับปัจจุบัน*ทวีคูณ
5. ExponentialRandomBackOffPolicy: กลยุทธ์ backoff แบบเอ็กซ์โปเนนเชียลแบบสุ่มแนะนำตัวคูณแบบสุ่มสามารถรับรู้ตัวคูณแบบสุ่ม backoff แบบสุ่ม

retry retry stateful หรือ retry ไร้สัญชาติ

การลองใหม่ที่เรียกว่าไม่มีสัญลักษณ์หมายถึงการลองใหม่ในบริบทของเธรด มิฉะนั้นหากลองทำซ้ำในบริบทของเธรดจะเป็นการลองอีกครั้ง SimpleRetryPolicy ก่อนหน้านี้คือการลองใหม่ที่ไร้สัญชาติเพราะลองเสร็จสิ้นในลูป แล้วจะเกิดอะไรขึ้นหลังจากนั้นหรือจำเป็นต้องลองใหม่ในรัฐ? โดยปกติจะมีสองสถานการณ์: การทำธุรกรรมย้อนกลับและเบรกเกอร์

DataAccessException นั้นยอดเยี่ยม ไม่สามารถลองใหม่ได้ แต่หากมีการโยนข้อยกเว้นอื่น ๆ คุณสามารถลองอีกครั้ง

ฟิวส์หมายถึงการไม่จัดการใหม่ในลูปปัจจุบัน แต่ไปยังโหมดการลองใหม่ทั่วโลก (ไม่ใช่บริบทเธรด) เบรกเกอร์จะกระโดดออกจากวงและข้อมูลสแต็กของบริบทเธรดจะหายไปอย่างหลีกเลี่ยงไม่ได้ จากนั้นจำเป็นอย่างยิ่งที่จะต้องบันทึกข้อมูลนี้ใน "โหมดทั่วโลก" การใช้งานปัจจุบันถูกวางไว้ในแคช (การใช้งานแผนที่) คุณสามารถลองอีกครั้งหลังจากได้รับจากแคชในครั้งต่อไป

เริ่มต้นอย่างรวดเร็ว

ใช้ @EnableRetry ในคลาสที่ต้องดำเนินการลองใหม่หาก proxyTargetClass=true ถูกตั้งค่านี้ใช้ CGLIB Dynamic Proxy:

 @configuration@enableRetry (proxyTargetClass = true) @componentpublic คลาส retryExamples {}

ลองใหม่ตามจำนวนกลยุทธ์การลองใช้ใหม่สูงสุดหากการลองซ้ำซ้ำ 3 ครั้งและข้อยกเว้นยังคงถูกโยนลงไปการลองใหม่จะหยุดลงและการเรียกกลับจากล่างขึ้นบนจะถูกดำเนินการ ดังนั้นผลลัพธ์ผลลัพธ์สุดท้ายคือ Integer.MAX_VALUE :

 โมฆะส่วนตัว retryExample3 () โยนข้อยกเว้น {retryTemplate retryTemplate = ใหม่ retryTemplate (); simpleeretryPolicy simpleeretryPolicy = new SimpleRetryPolicy (); SimpleeretryPolicy.SetMaxAttempts (3); retrytemplate.setretrypolicy (simpleeretrypolicy); integer result = retryTemplate.execute (ใหม่ retryCallback <จำนวนเต็ม, ข้อยกเว้น> () {int i = 0; // retry การดำเนินการ @Override จำนวนเต็มสาธารณะ dowithRetry (retryContext retryContext) RecoveryCallback <Integer> () {// การเรียกกลับ base @Override การกู้คืนสาธารณะ (retryContext retryContext) โยนข้อยกเว้น {log.info ("หลังจากลองใหม่: {}, วิธีการกู้คืนที่เรียกว่า!" log.info ("ผลลัพธ์สุดท้าย: {}", ผลลัพธ์); } int ส่วนตัว len (int i) โยนข้อยกเว้น {ถ้า (i <10) โยนข้อยกเว้นใหม่ (i + "le 10"); กลับฉัน; -

ต่อไปนี้อธิบายถึงวิธีการใช้โหมดนโยบาย Circuit Breaker retry (CircuitBreakerRetryPolicy) ต้องตั้งค่าพารามิเตอร์สามตัวต่อไปนี้:

1. ผู้แทน: ผ่านการ retrypolicy (การดำเนินการ retrypolicy แต่ละครั้งมีการดำเนินการตามนโยบายของตัวเอง) เป็นกลยุทธ์ที่กำหนดอย่างแท้จริงว่าจะลองใหม่หรือไม่ เมื่อการลองใหม่ล้มเหลวนโยบายเบรกเกอร์จะถูกดำเนินการ
2. Opentimeout: OpenWindow กำหนดเวลาหมดเวลาสำหรับวงจรฟิวส์ที่จะเปิด เมื่อ opentimeout เกิน opentimeout วงจรฟิวส์จะกลายเป็นสถานะกึ่งเปิด (ตราบใดที่การลองใหม่ประสบความสำเร็จวงจรจะถูกปิด)
3. RESETTIMEOUT: หมดเวลากำหนดเวลาหมดเวลาสำหรับการรีเซ็ตฟิวส์ reclosing

การเปิดและปิดการตัดสินของวงจร:

1. เมื่อลองล้มเหลวอีกครั้งและฟิวส์จะเปิดหน้าต่างเวลา [0, OpenWindow) จะถูกหลอมรวมทันที
2. เมื่อลองล้มเหลวและหมดเวลาเกินกว่าวงจรฟิวส์จะปิดอีกครั้ง
3. เมื่อฟิวส์เปิดครึ่ง [OpenWindow, หมดเวลา] บริบทจะถูกรีเซ็ตตราบใดที่การลองใหม่ประสบความสำเร็จและปิดเบรกเกอร์

รหัสทดสอบมีดังนี้:

 เทมเพลต retryTemplate = ใหม่ retrytemplate (); CircuitBreakerRetryPolicy RetryPolicy = ใหม่ CircuitBreakerRetryPolicy (ใหม่ SimpleRetryPolicy (3)); retrypolicy.setopentimeout (5,000); retrypolicy.setResetTimeOut (20000); template.setRetryPolicy (retrypolicy); สำหรับ (int i = 0; i <10; i ++) {//thread.sleep(100); ลอง {object key = "วงจร"; บูลีน isforcerefresh = false; retrystate state = ใหม่ defaultretrystate (คีย์, isforcerefresh); String result = template.execute (ใหม่ retryCallback <String, runtimeException> () {@Override สตริงสาธารณะ dowithRetry (บริบท retryContext) โยน runtimeException {log.info ("retry count: {}", บริบท {@Override สตริงสาธารณะกู้คืน (บริบท retryContext) โยนข้อยกเว้น {return "default";}}, สถานะ); log.info ("ผลลัพธ์: {}", ผลลัพธ์); } catch (exception e) {system.out.println (e); -

เนื่องจากตั้งค่า isForceRefresh = false ค่าของ key = "circuit" (นั่นคือ retryContext) จะได้รับจากแคช ดังนั้นเมื่อการลองใหม่ล้มเหลวและ this.time < this.openWindow จะถูกหลอมรวมคุณยังคงสามารถใช้งานใหม่ในโหมดทั่วโลก ( RetryContext ที่ได้รับเหมือนกัน)

การพัฒนาคำอธิบายประกอบ

หากการเขียน RetryTemplate ทุกครั้งที่คุณมีข้อกำหนดการลองใหม่จะป่องเกินไปการใช้คำอธิบายประกอบสามารถทำให้การพัฒนาง่ายขึ้นและลดรหัสที่ซ้ำกันอย่างมาก นี่คือการลองกลยุทธ์การลองใหม่สูงสุดที่ใช้โดยใช้คำอธิบายประกอบ:

 @Retryable (value = sqldataException.class, backoff = @backoff (value = 0l)) บริการสตริงสาธารณะ 3 () พ่น sqldataexception {log.info ("Service3 Open"); โยน sqldataexception ใหม่ (); } @Recover Public String กู้คืน (SQLDATAException NE) {return "sqldataException กู้คืน"; -

คำอธิบายประกอบ ได้แก่ :

@enableretry

@retryable

@ฟื้นตัว

@backoff

@circuitbreaker

@Enableretry: ลองอีกครั้งได้ไหม เมื่อคุณสมบัติ proxytargetClass เป็นจริง (ค่าเริ่มต้นเท็จ) ให้ใช้ cGlib proxy

@Retryable: วิธีการที่ต้องมีคำอธิบายประกอบใหม่

1. รวมถึงการระบุคลาสข้อยกเว้นที่จะประมวลผล ค่าเริ่มต้นว่างเปล่า
2. ไม่รวมระบุข้อยกเว้นที่ไม่จำเป็นต้องจัดการ ค่าเริ่มต้นว่างเปล่า
3. Vaue ระบุข้อยกเว้นในการลองใหม่ ค่าเริ่มต้นว่างเปล่า
4. Maxattempts จำนวนสูงสุดของการลองใหม่ เริ่มต้น 3 ครั้ง
5. Backoff ลองใช้นโยบายการรอคอยอีกครั้ง ใช้ @backoff Annotation โดยค่าเริ่มต้น

@backoff: ลองใช้กลยุทธ์ทางเลือก (ลองตอนนี้หรือรอสักครู่ก่อนที่จะลองอีกครั้ง)

1. เมื่อไม่มีการตั้งค่าพารามิเตอร์การกำหนดค่า backOffPolicy จะถูกใช้โดยค่าเริ่มต้น ลองใหม่และรอ 1,000ms
2. เมื่อตั้งค่าเฉพาะคุณสมบัติการหน่วงเวลา () ให้ใช้ reamiedbackoffpolicy เพื่อลองและรอจำนวนมิลลิวินาทีที่ระบุ
3. เมื่อตั้งค่าความล่าช้า () และคุณสมบัติ maxdealy () ลองอีกครั้งและรอการกระจายที่เป็นเนื้อเดียวกันระหว่างสองค่านี้
4. ใช้ exponentialbackOffPolicy เมื่อใช้คุณสมบัติ delay (), maxdealy () และตัวคูณ () คุณสมบัติ
5. เมื่อคุณสมบัติตัวคูณ () ถูกตั้งค่าไม่เท่ากับ 0 และคุณสมบัติการสุ่ม () ถูกตั้งค่าให้ใช้ exponentialRandomBackOffpolicy

@Recover: สำหรับใช้กับวิธีการ ใช้เป็นวิธี "รับประกัน" เมื่อ @retryable ล้มเหลว วิธีการแสดงความคิดเห็น @Recover ต้องสอดคล้องกับวิธีการ "ลายเซ็น" ของคำอธิบายประกอบ @Retryable พารามิเตอร์รายการแรกเป็นข้อยกเว้นที่จะลองใหม่ พารามิเตอร์อื่น ๆ สอดคล้องกับ @Retryable ค่าส่งคืนจะต้องเหมือนกันมิฉะนั้นจะไม่สามารถดำเนินการได้!

@CircuitBreaker: ใช้สำหรับวิธีการใช้โหมดการทำลายวงจร

1. รวมถึงการระบุคลาสข้อยกเว้นที่จะประมวลผล ค่าเริ่มต้นว่างเปล่า
2. ไม่รวมระบุข้อยกเว้นที่ไม่จำเป็นต้องจัดการ ค่าเริ่มต้นว่างเปล่า
3. Vaue ระบุข้อยกเว้นในการลองใหม่ ค่าเริ่มต้นว่างเปล่า
4. Maxattempts จำนวนสูงสุดของการลองใหม่ เริ่มต้น 3 ครั้ง
5. Opentimeout กำหนดเวลาการหมดเวลาสำหรับการเปิดฟิวส์ค่าเริ่มต้น 5s เมื่อ opentimeout เกิน opentimeout วงจรฟิวส์จะกลายเป็นสถานะกึ่งเปิด (ตราบใดที่การลองใหม่ประสบความสำเร็จวงจรจะถูกปิด)
6. RESETTIMEOUT กำหนดค่าเวลาหมดเวลาสำหรับฟิวส์ reclosing ค่าเริ่มต้น 20s ถ้าเบรกเกอร์ปิดหลังจากเวลานี้

สำหรับตัวอย่างเพิ่มเติมยินดีต้อนรับสู่ GitHub ของฉัน (https://github.com/happyxiaofan/springboot-learning-example) ดาว ขอบคุณ

ข้างต้นเป็นเนื้อหาทั้งหมดของบทความนี้ ฉันหวังว่ามันจะเป็นประโยชน์ต่อการเรียนรู้ของทุกคนและฉันหวังว่าทุกคนจะสนับสนุน wulin.com มากขึ้น