時候，我們會希望網頁自動跳轉，應用場景包括：

• 提交表單后自動轉到另外一個頁面，
• 頁面地址變了，希望訪問老地址時能自動轉到新地址，等等。

下面總結下如何在前端頁面中控制跳轉的方法：

利用html的refresh

<meta http-equiv="refresh" content="0;url=index.html"> 

其中0表示0秒以后跳轉，可以自行設定時間。

利用js的href屬性

window.location.href='index.html';

如果要設定延遲時間，則加上setTimeout

setTimeout("javascript：location.href='index.html'", 5000);

利用js的navigate方式

window.navigate("index.html");

自動刷新頁面

在上述方式中，如果跳轉的頁面就是本頁面，那么就是自動刷新頁面的功能。

或者使用reload

location.reload()

跳轉到上一頁，下一頁的方式

window.history.go(-1);

其中 -1 表示上一頁，如果沒有負號的就是表示下一頁

如果不是1而是 2,3,4......n 則表示前進或者后退 n 頁

后退還可以用

window.history.back();

兩者的區別是：

go(-1):返回上一頁，原頁面表單中的內容會丟失；

back():返回上一頁，原頁表表單中的內容會保留。

前進則對應的是：

history.forward()：

此外，還有一個參數 history.length 記錄了頁面前進的序號，如果等于0表示第一頁

怎么選擇

至此，自動跳轉頁面、刷新頁面、前后切換的方法都齊了！方法多了就有了選擇恐懼癥？

基本原則：

單純的頁面跳轉建議就用html的refresh方法，無需js代碼，很簡潔。

如果比較復雜，涉及js代碼的業務功能，再加上跳轉功能的，就用js的各種方法。

此外還要考慮頁面是否刷新的問題，希望刷新就用go，否則用back/forward

錄

• 應用場景
• 消息延遲推送的實現
• 測試結果

應用場景

目前常見的應用軟件都有消息的延遲推送的影子，應用也極為廣泛，例如：

• 淘寶七天自動確認收貨。在我們簽收商品后，物流系統會在七天后延時發送一個消息給支付系統，通知支付系統將款打給商家，這個過程持續七天，就是使用了消息中間件的延遲推送功能。
• 12306 購票支付確認頁面。我們在選好票點擊確定跳轉的頁面中往往都會有倒計時，代表著 30 分鐘內訂單不確認的話將會自動取消訂單。其實在下訂單那一刻開始購票業務系統就會發送一個延時消息給訂單系統，延時30分鐘，告訴訂單系統訂單未完成，如果我們在30分鐘內完成了訂單，則可以通過邏輯代碼判斷來忽略掉收到的消息。

在上面兩種場景中，如果我們使用下面兩種傳統解決方案無疑大大降低了系統的整體性能和吞吐量：

• 使用 redis 給訂單設置過期時間，最后通過判斷 redis 中是否還有該訂單來決定訂單是否已經完成。這種解決方案相較于消息的延遲推送性能較低，因為我們知道 redis 都是存儲于內存中，我們遇到惡意下單或者刷單的將會給內存帶來巨大壓力。
• 使用傳統的數據庫輪詢來判斷數據庫表中訂單的狀態，這無疑增加了IO次數，性能極低。
• 使用 jvm 原生的 DelayQueue ，也是大量占用內存，而且沒有持久化策略，系統宕機或者重啟都會丟失訂單信息。

消息延遲推送的實現

在 RabbitMQ 3.6.x 之前我們一般采用死信隊列+TTL過期時間來實現延遲隊列，我們這里不做過多介紹，可以參考之前文章來了解：TTL、死信隊列

在 RabbitMQ 3.6.x 開始，RabbitMQ 官方提供了延遲隊列的插件，可以下載放置到 RabbitMQ 根目錄下的 plugins 下。延遲隊列插件下載

首先我們創建交換機和消息隊列，application.properties 中配置與上一篇文章相同。

import org.springframework.amqp.core.*;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import java.util.HashMap;
import java.util.Map;
@Configuration
public class MQConfig {
 public static final String LAZY_EXCHANGE="Ex.LazyExchange";
 public static final String LAZY_QUEUE="MQ.LazyQueue";
 public static final String LAZY_KEY="lazy.#";
 @Bean
 public TopicExchange lazyExchange(){
 //Map<String, Object> pros=new HashMap<>();
 //設置交換機支持延遲消息推送
 //pros.put("x-delayed-message", "topic");
 TopicExchange exchange=new TopicExchange(LAZY_EXCHANGE, true, false, pros);
 exchange.setDelayed(true);
 return exchange;
 }
 @Bean
 public Queue lazyQueue(){
 return new Queue(LAZY_QUEUE, true);
 }
 @Bean
 public Binding lazyBinding(){
 return BindingBuilder.bind(lazyQueue()).to(lazyExchange()).with(LAZY_KEY);
 }
}

我們在 Exchange 的聲明中可以設置exchange.setDelayed(true)來開啟延遲隊列，也可以設置為以下內容傳入交換機聲明的方法中，因為第一種方式的底層就是通過這種方式來實現的。

 //Map<String, Object> pros=new HashMap<>();
 //設置交換機支持延遲消息推送
 //pros.put("x-delayed-message", "topic");
 TopicExchange exchange=new TopicExchange(LAZY_EXCHANGE, true, false, pros);

發送消息時我們需要指定延遲推送的時間，我們這里在發送消息的方法中傳入參數 new MessagePostProcessor() 是為了獲得 Message對象，因為需要借助 Message對象的api 來設置延遲時間。

import com.anqi.mq.config.MQConfig;
import org.springframework.amqp.AmqpException;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.core.MessageDeliveryMode;
import org.springframework.amqp.core.MessagePostProcessor;
import org.springframework.amqp.rabbit.connection.CorrelationData;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import java.util.Date;
@Component
public class MQSender {
 @Autowired
 private RabbitTemplate rabbitTemplate;
 //confirmCallback returnCallback 代碼省略，請參照上一篇
 
 public void sendLazy(Object message){
 rabbitTemplate.setMandatory(true);
 rabbitTemplate.setConfirmCallback(confirmCallback);
 rabbitTemplate.setReturnCallback(returnCallback);
 //id + 時間戳 全局唯一
 CorrelationData correlationData=new CorrelationData("12345678909"+new Date());
 //發送消息時指定 header 延遲時間
 rabbitTemplate.convertAndSend(MQConfig.LAZY_EXCHANGE, "lazy.boot", message,
 new MessagePostProcessor() {
 @Override
 public Message postProcessMessage(Message message) throws AmqpException {
 //設置消息持久化
 message.getMessageProperties().setDeliveryMode(MessageDeliveryMode.PERSISTENT);
 //message.getMessageProperties().setHeader("x-delay", "6000");
 message.getMessageProperties().setDelay(6000);
 return message;
 }
 }, correlationData);
 }
}

我們可以觀察 setDelay(Integer i)底層代碼，也是在 header 中設置 s-delay。等同于我們手動設置 header

message.getMessageProperties().setHeader("x-delay", "6000");
/**
 * Set the x-delay header.
 * @param delay the delay.
 * @since 1.6
 */
public void setDelay(Integer delay) {
 if (delay==null || delay < 0) {
 this.headers.remove(X_DELAY);
 }
 else {
 this.headers.put(X_DELAY, delay);
 }
}
消費端進行消費
import com.rabbitmq.client.Channel;
import org.springframework.amqp.rabbit.annotation.*;
import org.springframework.amqp.support.AmqpHeaders;
import org.springframework.stereotype.Component;
import java.io.IOException;
import java.util.Map;
@Component
public class MQReceiver {
 @RabbitListener(queues="MQ.LazyQueue")
 @RabbitHandler
 public void onLazyMessage(Message msg, Channel channel) throws IOException{
 long deliveryTag=msg.getMessageProperties().getDeliveryTag();
 channel.basicAck(deliveryTag, true);
 System.out.println("lazy receive " + new String(msg.getBody()));
 }

測試結果

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;
@SpringBootTest
@RunWith(SpringRunner.class)
public class MQSenderTest {
 @Autowired
 private MQSender mqSender;
 @Test
 public void sendLazy() throws Exception {
 String msg="hello spring boot";
 mqSender.sendLazy(msg + ":");
 }
}

果然在 6 秒后收到了消息 lazy receive hello spring boot:

轉載請注明出處，謝謝。https://www.cnblogs.com/haixiang/p/10966985.html