ฉาก
งานที่กำหนดเวลามักจำเป็นในการพัฒนา สำหรับห้างสรรพสินค้างานที่กำหนดเวลามีจำนวนมากโดยเฉพาะอย่างยิ่งเช่นคูปองหมดอายุการหมดเวลาสั่งซื้อการปิดเวลาการชำระเงิน WeChat เป็นเวลา 2 ชั่วโมงโดยไม่ต้องจ่ายเงินเพื่อปิดการสั่งซื้อ ฯลฯ ซึ่งทั้งหมดต้องใช้เวลา อย่างไรก็ตามมีปัญหากับงานเวลาด้วยตัวเอง โดยทั่วไปแล้วเราสอบถามฐานข้อมูลผ่านการสำรวจเวลาเพื่อพิจารณาว่ามีงานที่ต้องดำเนินการหรือไม่ กล่าวคือไม่ว่าจะเกิดอะไรขึ้นเราต้องสอบถามฐานข้อมูลก่อน งานบางอย่างมีข้อกำหนดสูงสำหรับความแม่นยำเวลาและจำเป็นต้องสอบถามเพียงครั้งเดียว ไม่สำคัญว่าระบบจะเล็กหรือไม่ หากระบบมีขนาดใหญ่และมีข้อมูลมากมายนี่ไม่สมจริงมากนักดังนั้นจึงจำเป็นต้องมีวิธีการอื่น ๆ แน่นอนว่ามีหลายวิธีในการดำเนินการเช่นคิวการใช้งานเวลาการใช้งาน Redis, คิวการหน่วงเวลา JDK ตามคิวลำดับความสำคัญรอบเวลา ฯลฯ เพราะเราใช้ RabbitMQ ในโครงการของเราตามหลักการของการพัฒนาและการบำรุงรักษาที่ง่าย หากคุณไม่ทราบว่า RabbitMQ คืออะไรหรือ Springboot รวม RabbitMQ คุณสามารถตรวจสอบบทความก่อนหน้าของฉัน Spring Boot RabbitMQ ได้
Rabbitmq คิวการหน่วงเวลา
RabbitMQ เองไม่มีคิวการหน่วงเวลาและสามารถนำไปใช้ได้ผ่านลักษณะของคิวของ RabbitMQ เท่านั้น หาก RabbitMQ ต้องการใช้คิวการหน่วงเวลาคุณจะต้องใช้ Switch Dead-Letter ของ RabbitMQ (Exchange) และ TIME TIME TIME (TIME TO LIVE)
สวิตช์จดหมายตาย
ข้อความจะป้อนสวิตช์ตัวอักษรที่ตายแล้วหากตรงตามเงื่อนไขต่อไปนี้ โปรดจำไว้ว่านี่คือสวิตช์แทนคิว สวิตช์สามารถสอดคล้องกับคิวมากมาย
สวิตช์ตัวอักษรที่ตายแล้วเป็นสวิตช์ธรรมดา แต่เนื่องจากเราทิ้งข้อความที่หมดอายุจึงเรียกว่าสวิตช์ตัวอักษรที่ตายแล้ว ไม่ได้หมายความว่าสวิตช์ตัวอักษรที่ตายแล้วเป็นสวิตช์ที่เฉพาะเจาะจง
ข้อความ TTL (เวลารอดชีวิตจากข้อความ)
TTL ของข้อความคือเวลาการอยู่รอดของข้อความ RabbitMQ สามารถตั้งค่า TTL สำหรับคิวและข้อความแยกกัน การตั้งค่าคิวหมายความว่าคิวไม่มีเวลาเก็บรักษาที่เชื่อมต่อกับผู้บริโภคและคุณยังสามารถทำการตั้งค่าแยกต่างหากสำหรับแต่ละข้อความ หลังจากเวลานี้เราคิดว่าข่าวนั้นตายไปแล้วและเรียกว่าจดหมายแห่งความตาย หากมีการตั้งค่าคิวและตั้งค่าข้อความแล้วข้อความเล็ก ๆ จะถูกนำมาใช้ ดังนั้นหากข้อความถูกส่งไปยังคิวที่แตกต่างกันเวลาของการตายของข้อความนี้อาจแตกต่างกัน (การตั้งค่าคิวที่แตกต่างกัน) ที่นี่เราพูดถึง TTL ของข้อความเดียวเพราะเป็นกุญแจสำคัญในการใช้งานล่าช้า
Byte [] MessageBodyBytes = "สวัสดีโลก!". getBytes (); คุณสมบัติ amqp.basicproperties = ใหม่ amqp.basicproperties (); Properties.Setexpiration ("60000"); channel.basicpublish ("My-exchange", "คิวคีย์", คุณสมบัติ, ข้อความ BodyBytes);คุณสามารถตั้งค่าเวลาได้โดยการตั้งค่าฟิลด์หมดอายุของข้อความหรือคุณสมบัติ X-Message-TTL ซึ่งทั้งสองอย่างนี้มีเอฟเฟกต์เดียวกัน เป็นเพียงว่าฟิลด์การหมดอายุเป็นพารามิเตอร์สตริงดังนั้นคุณต้องเขียนสตริงประเภท int: เมื่อข้อความด้านบนถูกโยนลงไปในคิว 60 วินาทีผ่านไปถ้ามันไม่ได้ใช้มันจะตาย ผู้บริโภคจะไม่ถูกบริโภค ข่าวเบื้องหลังข่าวนี้ไม่ได้ "ตาย" และถูกบริโภคโดยผู้บริโภค จดหมายที่ตายแล้วจะไม่ถูกลบและปล่อยออกมาในคิวพวกเขาจะถูกนับเป็นจำนวนข้อความในคิว
แผนภูมิกระบวนการไหล
สร้างสวิตช์และคิว
สร้างสวิตช์ตัวอักษรที่ตายแล้ว
ดังที่แสดงในรูปมันคือการสร้างสวิตช์ธรรมดา เพื่อความแตกต่างที่ง่ายชื่อของสวิตช์คือความล่าช้า
สร้างคิวข้อความหมดอายุอัตโนมัติ
ฟังก์ชั่นหลักของคิวนี้คือการทำให้ข้อความหมดอายุเป็นประจำ ตัวอย่างเช่นหากเราต้องการปิดการสั่งซื้อใน 2 ชั่วโมงเราต้องใส่ข้อความลงในคิวนี้และตั้งเวลาหมดอายุข้อความเป็น 2 ชั่วโมง
สร้างคิวที่หมดอายุโดยอัตโนมัติชื่อ delay_queue1 แน่นอนพารามิเตอร์ในรูปภาพจะไม่หมดอายุข้อความโดยอัตโนมัติเนื่องจากเราไม่ได้ตั้งค่าพารามิเตอร์ X-Message-TTL หากข้อความในคิวทั้งหมดเหมือนกันคุณสามารถตั้งค่าได้ เพื่อความยืดหยุ่นไม่ได้ตั้งค่า อีกสองพารามิเตอร์ x-dead-letter-exchange แสดงถึงสวิตช์ที่ข้อความจะป้อนหลังจากข้อความหมดอายุ การกำหนดค่าที่นี่คือความล่าช้านั่นคือสวิตช์ตัวอักษรที่ตายแล้ว X-dead-letter-routing-key คือการกำหนดค่าการกำหนดเส้นทางคีย์ของสวิตช์ตัวอักษรที่ตายแล้วหลังจากที่ข้อความหมดอายุ เช่นเดียวกับการส่งคีย์เส้นทางของข้อความ ตามคีย์นี้ข้อความจะถูกวางไว้ในคิวอื่น
สร้างคิวการประมวลผลข้อความ
คิวนี้เป็นคิวที่ประมวลผลข้อความอย่างแท้จริงและข้อความทั้งหมดที่เข้าสู่คิวนี้จะถูกประมวลผล
ชื่อของคิวข้อความคือ delay_queue2
คิวข้อความถูกผูกไว้เพื่อสลับ
ป้อนหน้ารายละเอียดสวิตช์และผูกคิวสองคิวที่สร้างขึ้น (ล่าช้า คิว 1 และล่าช้า คิว 2) ไปยังสวิตช์
คีย์การกำหนดเส้นทางของคิวข้อความหมดอายุอัตโนมัติถูกตั้งค่าให้ล่าช้า
ผูกคิวล่าช้า 2
คีย์ของ การหน่วงเวลา คิว 2 ควรตั้งค่าเพื่อสร้างพารามิเตอร์คิว X-Dead-Routing-Key-Routing-Key-Routing-key โดยอัตโนมัติดังนั้นเมื่อข้อความหมดอายุข้อความสามารถวางไว้ในคิว Delay_queue2 โดยอัตโนมัติ
หน้าการจัดการที่ถูกผูกไว้ดังแสดงในรูป:
แน่นอนว่าการเชื่อมโยงนี้สามารถนำไปใช้โดยใช้รหัสเพียงเพื่อการแสดงออกที่ใช้งานง่ายดังนั้นแพลตฟอร์มการจัดการที่ใช้ในบทความนี้ใช้ในการใช้งาน
ส่งข้อความ
String msg = "hello word"; MessageProperties MessageProperties = New MessageProperties (); MessageProperties.setexpiration ("6000"); MessageProperties.setCorrelationId (uuid.randomuuid (). toString (). getBytes ()); ข้อความข้อความ = ข้อความใหม่ (msg.getBytes (), MessageProperties); Rabbittemplate.ConvertandSend ("ล่าช้า", "ล่าช้า", ข้อความ);รหัสหลักคือ
MessageProperties.setexpiration ("6000");ตั้งค่าข้อความให้หมดอายุหลังจาก 6 วินาที
หมายเหตุ: เนื่องจากข้อความจะหมดอายุโดยอัตโนมัติคุณจะต้องไม่ตั้งค่าการฟังของ delay_queue1 และข้อความในคิวนี้ไม่สามารถยอมรับได้ มิฉะนั้นเมื่อส่งข้อความจะไม่มีการหมดอายุ
รับข้อความ
เพียงกำหนดค่า delay_queue2 เพื่อรับฟังข้อความ
แพ็คเกจ wang.raye.rabbitmq.demo1; นำเข้า org.springframework.amqp.core.acknowledGemode; นำเข้า org.springframework.amqp.core.binding; นำเข้า org.springframework.amqp.core.binding; นำเข้า org.springframework.amqp.core.bindingbuilder; นำเข้า org.springframework.amqp.core.directExchange; นำเข้า org.springframework.amqp.core.message; นำเข้า org.springframework.amqp.core.queue; นำเข้า org.springframework.amqp.rabbit.connection.cachingconnectionfactory; นำเข้า org.springframework.amqp.rabbit.connection.connectionfactory; นำเข้า org.springframework.amqp.rabbit.core.channelawaremessagelistener; นำเข้า org.springframework.amqp.rabbit.listener.simplemessagelistenercontainer; นำเข้า org.springframework.beans.factory.annotation.autowired; นำเข้า org.springframework.context.annotation.bean; นำเข้า org.springframework.context.annotation.configuration; @configurationPublic คลาส delayqueue { / ** ชื่อของสวิตช์ข้อความ* / การแลกเปลี่ยนสตริงสุดท้ายคงที่สาธารณะ = "ล่าช้า"; / ** คิวคิว 1*/ สตริงสุดท้ายคงที่การกำหนดเส้นทางการกำหนดเส้นทาง 1 = "ล่าช้า"; / ** คิวคีย์ 2*/ สตริงสุดท้ายคงที่การกำหนดเส้นทางการกำหนดเส้นทางคีย์ 2 = "delay_key"; / *** ข้อมูลลิงค์การกำหนดค่า* @return*/ @Bean Public ConnectionFactory ConnectionFactory () {CachingConnectionFactory ConnectionFactory = ใหม่ CachingConnectionFactory ("120.76.237.8", 5672); ConnectionFactory.setUserName ("Kberp"); ConnectionFactory.SetPassword ("Kberp"); ConnectionFactory.SetVirtualHost ("/"); ConnectionFactory.SetPublisherConfirms (จริง); // return connectionFactory จะต้องตั้งค่า; } / *** กำหนดค่าสวิตช์ข้อความ* กำหนดค่า fanoutexchange สำหรับผู้บริโภค: แจกจ่ายข้อความไปยังคิวที่ถูกผูกไว้ทั้งหมดโดยไม่ต้องมีแนวคิดของการจัดเส้นทางส่วนหัวของ Keyexchange: จับคู่ DirectExchange โดยการเพิ่มคีย์-ค่าคีย์: แจกจ่าย queue ที่ระบุ } / ** * กำหนดค่าคิวข้อความ 2 * กำหนดค่า * / @bean สาธารณะคิวคิว () {ส่งคืนคิวใหม่ ("delay_queue2", จริง); // อ้างถาวร}/*** ผูกคิวข้อความ 2 พร้อมสวิตช์* กำหนดค่าสำหรับผู้บริโภค* @return*/@bean @autowired การเชื่อมโยงสาธารณะที่มีผลผูกพัน () {ส่งคืน bindingbuilder.bind (คิว ()) } / *** ยอมรับผู้ฟังข้อความผู้ฟังนี้จะรับข้อความจากคิวข้อความ 1* กำหนดค่าสำหรับผู้บริโภค* @return* / @bean @autowired Public SimpleMessageListenercontainer MessageContainer2 container.setqueues (คิว ()); container.setexposelistenerChannel (จริง); container.setMaxConcurrentConsumers (1); container.setCurrentConsumers (1); container.setackNowLEDGEMODE (ACKNOWLEDGEMODE.MANUAL); // ตั้งค่าโหมดการยืนยันด้วยตนเองยืนยันคอนเทนเนอร์ SetMessAgelistener (ช่องใหม่ channelawareMessageListener () {โมฆะสาธารณะ onMessage (ข้อความข้อความ, com.rabbitmq.client.channel channel) โยนข้อยกเว้น {byte [] body = message.getbody (); channel.basicack (message.getMessageProperties (). getDeliveryTag (), false); ส่งคืนคอนเทนเนอร์; -เพียงจัดการงานที่ต้องดำเนินการอย่างสม่ำเสมอระหว่างการฟังข้อความ เนื่องจาก RabbitMQ สามารถส่งข้อความได้คุณสามารถส่งรหัสคุณสมบัติงานเช่นการปิดการสั่งซื้อและส่งรหัสคำสั่งซื้อซึ่งหลีกเลี่ยงความจำเป็นในการสอบถามคำสั่งซื้อที่ต้องปิดและเพิ่มภาระใน MySQL ท้ายที่สุดเมื่อปริมาณการสั่งซื้อมีขนาดใหญ่การสืบค้นเองก็เป็นสิ่งที่แพงมาก
สรุป
การใช้งานเวลาตาม RabbitMQ คือการกำหนดเวลาหมดอายุสำหรับข้อความใส่ลงในคิวที่ไม่ได้อ่านเพื่อให้ข้อความจะถูกถ่ายโอนไปยังคิวอื่นโดยอัตโนมัติหลังจากหมดอายุและตรวจสอบผู้ฟังข้อความคิวนี้เพื่อจัดการการดำเนินงานเฉพาะ
ข้างต้นเป็นเนื้อหาทั้งหมดของบทความนี้ ฉันหวังว่ามันจะเป็นประโยชน์ต่อการเรียนรู้ของทุกคนและฉันหวังว่าทุกคนจะสนับสนุน wulin.com มากขึ้น