feat: enhance proxy management with caching and refresh logic

src-tauri/Cargo.lock

@@ -1070,6 +1070,7 @@ dependencies = [
  "base64 0.22.1",
  "boa_engine",
  "chrono",
+ "dashmap 6.1.0",
  "deelevate",
  "delay_timer",
  "dirs 6.0.0",

src-tauri/Cargo.toml

@@ -82,6 +82,7 @@ sha2 = "0.10.9"
 hex = "0.4.3"
 scopeguard = "1.2.0"
 tauri-plugin-notification = "2.3.0"
+dashmap = "6.1.0"
 
 [target.'cfg(windows)'.dependencies]
 runas = "=1.2.0"

src-tauri/src/cmd/proxy.rs

@@ -1,99 +1,43 @@
 use super::CmdResult;
-use crate::{core::handle, module::mihomo::MihomoManager, state::proxy::CmdProxyState};
-use std::{
-    sync::Mutex,
-    time::{Duration, Instant},
-};
-use tauri::Manager;
+use crate::module::mihomo::MihomoManager;
+use std::time::Duration;
 
-const PROVIDERS_REFRESH_INTERVAL: Duration = Duration::from_secs(3);
-const PROXIES_REFRESH_INTERVAL: Duration = Duration::from_secs(1);
+use crate::state::proxy::ProxyRequestCache;
+
+const PROXIES_REFRESH_INTERVAL: Duration = Duration::from_secs(60);
+const PROVIDERS_REFRESH_INTERVAL: Duration = Duration::from_secs(60);
 
 #[tauri::command]
 pub async fn get_proxies() -> CmdResult<serde_json::Value> {
     let manager = MihomoManager::global();
-
-    let app_handle = handle::Handle::global().app_handle().unwrap();
-    let cmd_proxy_state = app_handle.state::<Mutex<CmdProxyState>>();
-
-    let should_refresh = {
-        let mut state = cmd_proxy_state.lock().unwrap();
-        let now = Instant::now();
-        if now.duration_since(state.last_refresh_time) > PROXIES_REFRESH_INTERVAL {
-            state.need_refresh = true;
-            state.last_refresh_time = now;
-        }
-        state.need_refresh
-    };
-
-    if should_refresh {
-        let proxies = manager.get_refresh_proxies().await?;
-        {
-            let mut state = cmd_proxy_state.lock().unwrap();
-            state.proxies = Box::new(proxies);
-            state.need_refresh = false;
-        }
-        log::debug!(target: "app", "proxies刷新成功");
-    }
-
-    let proxies = {
-        let state = cmd_proxy_state.lock().unwrap();
-        state.proxies.clone()
-    };
-    Ok(*proxies)
+    let cache = ProxyRequestCache::global();
+    let key = ProxyRequestCache::make_key("proxies", "default");
+    let value = cache
+        .get_or_fetch(key, PROXIES_REFRESH_INTERVAL, || async {
+            manager.get_refresh_proxies().await.expect("fetch failed")
+        })
+        .await;
+    Ok((*value).clone())
 }
 
 /// 强制刷新代理缓存用于profile切换
 #[tauri::command]
 pub async fn force_refresh_proxies() -> CmdResult<serde_json::Value> {
-    let manager = MihomoManager::global();
-    let app_handle = handle::Handle::global().app_handle().unwrap();
-    let cmd_proxy_state = app_handle.state::<Mutex<CmdProxyState>>();
-
-    log::debug!(target: "app", "强制刷新代理缓存");
-
-    let proxies = manager.get_refresh_proxies().await?;
-
-    {
-        let mut state = cmd_proxy_state.lock().unwrap();
-        state.proxies = Box::new(proxies.clone());
-        state.need_refresh = false;
-        state.last_refresh_time = Instant::now();
-    }
-
-    log::debug!(target: "app", "强制刷新代理缓存完成");
-    Ok(proxies)
+    let cache = ProxyRequestCache::global();
+    let key = ProxyRequestCache::make_key("proxies", "default");
+    cache.map.remove(&key);
+    get_proxies().await
 }
 
 #[tauri::command]
 pub async fn get_providers_proxies() -> CmdResult<serde_json::Value> {
-    let app_handle = handle::Handle::global().app_handle().unwrap();
-    let cmd_proxy_state = app_handle.state::<Mutex<CmdProxyState>>();
-
-    let should_refresh = {
-        let mut state = cmd_proxy_state.lock().unwrap();
-        let now = Instant::now();
-        if now.duration_since(state.last_refresh_time) > PROVIDERS_REFRESH_INTERVAL {
-            state.need_refresh = true;
-            state.last_refresh_time = now;
-        }
-        state.need_refresh
-    };
-
-    if should_refresh {
-        let manager = MihomoManager::global();
-        let providers = manager.get_providers_proxies().await?;
-        {
-            let mut state = cmd_proxy_state.lock().unwrap();
-            state.providers_proxies = Box::new(providers);
-            state.need_refresh = false;
-        }
-        log::debug!(target: "app", "providers_proxies刷新成功");
-    }
-
-    let providers_proxies = {
-        let state = cmd_proxy_state.lock().unwrap();
-        state.providers_proxies.clone()
-    };
-    Ok(*providers_proxies)
+    let manager = MihomoManager::global();
+    let cache = ProxyRequestCache::global();
+    let key = ProxyRequestCache::make_key("providers", "default");
+    let value = cache
+        .get_or_fetch(key, PROVIDERS_REFRESH_INTERVAL, || async {
+            manager.get_providers_proxies().await.expect("fetch failed")
+        })
+        .await;
+    Ok((*value).clone())
 }

src-tauri/src/lib.rs

@@ -213,7 +213,6 @@ pub fn run() {
                 logging!(error, Type::Setup, true, "初始化资源失败: {}", e);
             }
 
-            app.manage(Mutex::new(state::proxy::CmdProxyState::default()));
             app.manage(Mutex::new(state::lightweight::LightWeightState::default()));
 
             logging!(info, Type::Setup, true, "初始化完成，继续执行");

src-tauri/src/state/proxy.rs

@@ -1,19 +1,65 @@
+use std::time::{Duration, Instant};
+pub struct CacheEntry {
+    pub value: Arc<Value>,
+    pub expires_at: Instant,
+}
+use dashmap::DashMap;
 use serde_json::Value;
+use std::sync::Arc;
+use tokio::sync::OnceCell;
 
-pub struct CmdProxyState {
-    pub last_refresh_time: std::time::Instant,
-    pub need_refresh: bool,
-    pub proxies: Box<Value>,
-    pub providers_proxies: Box<Value>,
+pub struct ProxyRequestCache {
+    pub map: DashMap<String, Arc<OnceCell<CacheEntry>>>,
 }
 
-impl Default for CmdProxyState {
-    fn default() -> Self {
-        Self {
-            last_refresh_time: std::time::Instant::now(),
-            need_refresh: true,
-            proxies: Box::new(Value::Null),
-            providers_proxies: Box::new(Value::Null),
+impl ProxyRequestCache {
+    pub fn global() -> &'static Self {
+        static INSTANCE: once_cell::sync::OnceCell<ProxyRequestCache> =
+            once_cell::sync::OnceCell::new();
+        INSTANCE.get_or_init(|| ProxyRequestCache {
+            map: DashMap::new(),
+        })
+    }
+
+    pub fn make_key(prefix: &str, id: &str) -> String {
+        format!("{}:{}", prefix, id)
+    }
+
+    pub async fn get_or_fetch<F, Fut>(&self, key: String, ttl: Duration, fetch_fn: F) -> Arc<Value>
+    where
+        F: Fn() -> Fut,
+        Fut: std::future::Future<Output = Value>,
+    {
+        let now = Instant::now();
+        let key_cloned = key.clone();
+        let cell = self
+            .map
+            .entry(key)
+            .or_insert_with(|| Arc::new(OnceCell::new()))
+            .clone();
+
+        if let Some(entry) = cell.get() {
+            if entry.expires_at > now {
+                return Arc::clone(&entry.value);
+            }
         }
+
+        if let Some(entry) = cell.get() {
+            if entry.expires_at <= now {
+                self.map
+                    .remove_if(&key_cloned, |_, v| Arc::ptr_eq(v, &cell));
+                let new_cell = Arc::new(OnceCell::new());
+                self.map.insert(key_cloned.clone(), new_cell.clone());
+                return Box::pin(self.get_or_fetch(key_cloned, ttl, fetch_fn)).await;
+            }
+        }
+
+        let value = fetch_fn().await;
+        let entry = CacheEntry {
+            value: Arc::new(value),
+            expires_at: Instant::now() + ttl,
+        };
+        let _ = cell.set(entry);
+        Arc::clone(&cell.get().unwrap().value)
     }
 }