Merge pull request #58 from hubertshelley/features/2.0/refactor_exception_handler

refactor: exception_handler重构

Author: hubertshelley

examples/exception_handler/src/main.rs

@@ -1,4 +1,6 @@
 use serde::{Deserialize, Serialize};
+
+use silent::middlewares::ExceptionHandler;
 use silent::prelude::*;
 
 #[derive(Deserialize, Serialize, Debug)]
@@ -10,13 +12,8 @@ struct Exception {
 fn main() {
     logger::fmt().with_max_level(Level::INFO).init();
     let route = Route::new("")
+        .root_hook(ExceptionHandler::new(|res, _| async move { res }))
         .get(|mut req| async move { req.params_parse::<Exception>() })
-        .route()
-        .set_exception_handler(|e, _| async move {
-            Exception {
-                code: e.status().as_u16(),
-                msg: e.to_string(),
-            }
-        });
+        .route();
     Server::new().run(route);
 }

silent/src/error/exception_handler_trait.rs

@@ -1,10 +1,5 @@
-mod exception_handler_trait;
-mod exception_handler_wrapper;
-
 use crate::headers::ContentType;
 use crate::{Response, StatusCode};
-pub(crate) use exception_handler_trait::ExceptionHandler;
-pub(crate) use exception_handler_wrapper::ExceptionHandlerWrapper;
 use serde::Serialize;
 use serde_json::Value;
 use std::backtrace::Backtrace;

silent/src/error/exception_handler_wrapper.rs

@@ -0,0 +1,46 @@
+use std::future::Future;
+use std::sync::Arc;
+
+use async_trait::async_trait;
+
+use crate::middleware::middleware_trait::Next;
+use crate::{Configs, MiddleWareHandler, Request, Response, Result};
+
+/// ExceptionHandler 中间件
+/// ```rust
+/// use silent::prelude::*;
+/// use silent::middlewares::{ExceptionHandler};
+/// // Define a custom error handler function
+/// let _ = ExceptionHandler::new(|res, _configs| async {res});
+#[derive(Default, Clone)]
+pub struct ExceptionHandler<F> {
+    handler: Arc<F>,
+}
+
+impl<F, Fut, T> ExceptionHandler<F>
+where
+    Fut: Future<Output = Result<T>> + Send + 'static,
+    F: Fn(Result<Response>, Configs) -> Fut + Send + Sync + 'static,
+    T: Into<Response>,
+{
+    pub fn new(handler: F) -> Self {
+        Self {
+            handler: Arc::new(handler),
+        }
+    }
+}
+
+#[async_trait]
+impl<F, Fut, T> MiddleWareHandler for ExceptionHandler<F>
+where
+    Fut: Future<Output = Result<T>> + Send + 'static,
+    F: Fn(Result<Response>, Configs) -> Fut + Send + Sync + 'static,
+    T: Into<Response>,
+{
+    async fn handle(&self, req: Request, next: &Next) -> Result<Response> {
+        let configs = req.configs();
+        self.handler.clone()(next.call(req).await, configs)
+            .await
+            .map(|r| r.into())
+    }
+}

silent/src/error/mod.rs

@@ -1,3 +1,5 @@
 mod cors;
+mod exception_handler;
 
 pub use cors::{Cors, CorsType};
+pub use exception_handler::ExceptionHandler;

silent/src/middleware/middlewares/exception_handler.rs

@@ -1,4 +1,3 @@
-use crate::error::{ExceptionHandler, ExceptionHandlerWrapper};
 #[cfg(feature = "grpc")]
 use crate::grpc::GrpcHandler;
 use crate::middleware::middleware_trait::Next;
@@ -20,7 +19,6 @@ use chrono::Utc;
 #[cfg(feature = "grpc")]
 use http::Method;
 use std::fmt;
-use std::future::Future;
 use std::sync::Arc;
 #[cfg(feature = "scheduler")]
 use tokio::sync::Mutex;
@@ -35,7 +33,6 @@ use tonic::server::NamedService;
 pub struct RootRoute {
     pub(crate) children: Vec<Route>,
     pub(crate) middlewares: Vec<Arc<dyn MiddleWareHandler>>,
-    pub(crate) exception_handler: Option<Arc<dyn ExceptionHandler>>,
     #[cfg(feature = "session")]
     pub(crate) session_set: bool,
     pub(crate) configs: Option<Configs>,
@@ -60,7 +57,6 @@ impl RootRoute {
         Self {
             children: vec![],
             middlewares: vec![],
-            exception_handler: None,
             #[cfg(feature = "session")]
             session_set: false,
             configs: None,
@@ -121,16 +117,6 @@ impl RootRoute {
             .iter_mut()
             .for_each(|r| r.middleware_hook_first(handler.clone()));
     }
-
-    pub fn set_exception_handler<F, T, Fut>(mut self, handler: F) -> Self
-    where
-        Fut: Future<Output = T> + Send + 'static,
-        F: Fn(SilentError, Configs) -> Fut + Send + Sync + 'static,
-        T: Into<Response>,
-    {
-        self.exception_handler = Some(ExceptionHandlerWrapper::new(handler).arc());
-        self
-    }
     pub(crate) fn set_configs(&mut self, configs: Option<Configs>) {
         self.configs = configs;
     }
@@ -140,7 +126,6 @@ impl RootRoute {
 impl Handler for RootRoute {
     async fn call(&self, mut req: Request) -> Result<Response, SilentError> {
         tracing::debug!("{:?}", req);
-        let exception_handler = self.exception_handler.clone();
         let configs = self.configs.clone().unwrap_or_default();
         req.configs = configs.clone();
         let method = req.method().clone();
@@ -193,10 +178,7 @@ impl Handler for RootRoute {
                     req_time.num_nanoseconds().unwrap_or(0) as f64 / 1000000.0,
                     e.to_string()
                 );
-                match exception_handler {
-                    Some(handler) => handler.call(e, configs.clone()).await,
-                    None => e.into(),
-                }
+                e.into()
             }
         })
     }