So implementieren Sie die einheitliche Verarbeitungsfunktion von SpringBoot

Bei der Verarbeitung von Netzwerkanforderungen müssen einige Funktionen einheitlich extrahiert und verarbeitet werden, getrennt vom Geschäft.

Anmeldeüberprüfung

Sie können den Interceptor Interceptor von Spring MVC verwenden, um die HandlerInterceptor-Schnittstelle zu implementieren. Nach der Implementierung dieser Schnittstelle wird die Anfrage abgefangen, bevor sie an den Controller gesendet wird.

Die Implementierung des Interceptors ist in die folgenden zwei Schritte unterteilt:

• Erstellen Sie einen benutzerdefinierten Interceptor und implementieren Sie die preHandle-Methode (Vorverarbeitung vor Ausführung der spezifischen Methode) der HandlerInterceptor-Schnittstelle.

• Fügen Sie benutzerdefinierte Interceptoren zur addInterceptors-Methode von WebMvcConfigurer hinzu.

Wir verwenden die Sitzung als Beispiel für die Anmeldeüberprüfung. Die Implementierung lautet wie folgt:

package com.demo;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;
import org.springframework.web.servlet.HandlerInterceptor;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;
/**
 * 登录拦截器
 */
@Component
@Slf4j
public class LoginInterceptor implements HandlerInterceptor {
    /**
     * 为 false 则不能继续往下执行；为 true 则可以。
     */ 
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        // 判断session的信息是否合法
        HttpSession session = request.getSession(false);
        if (session != null && session.getAttribute("userinfo") != null) {
            return true;
        }
        log.error("当前用户没有访问权限");
        response.setStatus(401);
        return false;
    }
}

Registrieren Sie den geschriebenen ⾃Definitions-Interceptor über WebMvcConfigurer, um den Interceptor wirksam zu machen

Wenn kein Objekt injiziert wird, können die Parameter von addInterceptor() auch direkt ein neues Objekt erstellen:

package com.demo;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.ResourceHandlerRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
@Configuration
public class MyConfig implements WebMvcConfigurer {
    @Autowired
    private LoginInterceptor loginInterceptor;
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(loginInterceptor)
                .addPathPatterns("/**") // 拦截所有请求
                .excludePathPatterns("/user/login"); // 排除不拦截的 url
    }
}

Prinzip

Alle Controller-Ausführungen werden über den Spring MVC-Scheduler DispatcherServlet implementiert, und alle Methoden führen die doDispatch-Planung aus DispatcherServlet-Methode, der doDispatch-Quellcode lautet wie folgt:

@Configuration // 一定不要忘记
public class MyConfig implements WebMvcConfigurer {
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(new LoginInterceptor())
                .addPathPatterns("/**") // 拦截所有请求
                .excludePathPatterns("/user/login"); // 排除不拦截的 url
    }
}

Aus dem obigen Quellcode können wir ersehen, dass vor Beginn der Ausführung des Controllers zuerst die Vorverarbeitungsmethode applyPreHandle aufgerufen wird. Der Implementierungsquellcode der applyPreHandle-Methode lautet wie folgt folgt:

protected void doDispatch(HttpServletRequest request, HttpServletResponse
        response) throws Exception {
    HttpServletRequest processedRequest = request;
    HandlerExecutionChain mappedHandler = null;
    boolean multipartRequestParsed = false;
    WebAsyncManager asyncManager = WebAsyncUtils.getAsyncManager(request);
    try {
        try {
            ModelAndView mv = null;
            Object dispatchException = null;
            try {
                // ...  忽略不重要的代码
                // 调⽤预处理
                if (!mappedHandler.applyPreHandle(processedRequest, respon
                        se)) {
                    return;
                }
                // 执⾏ Controller 中的业务
                mv = ha.handle(processedRequest, response, mappedHandler.g
                        etHandler());
               // ...  忽略不重要的代码
            } catch (Exception var20) {
                dispatchException = var20;
            } catch (Throwable var21) {
                dispatchException = new NestedServletException("Handler di
                        spatch failed", var21);
            }
            this.processDispatchResult(processedRequest, response, mappedH
                    andler, mv, (Exception)dispatchException);
        } catch (Exception var22) {
            this.triggerAfterCompletion(processedRequest, response, mapped
                    Handler, var22);
        } catch (Throwable var23) {
            this.triggerAfterCompletion(processedRequest, response, mapped
                    Handler, new NestedServletException("Handler processing failed", var23));
        }
    } finally {
        if (asyncManager.isConcurrentHandlingStarted()) {
            if (mappedHandler != null) {
                mappedHandler.applyAfterConcurrentHandlingStarted(processe
                        dRequest, response);
            }
        } else if (multipartRequestParsed) {
            this.cleanupMultipart(processedRequest);
        }
    }
}

Ausnahmebehandlung

Request Die zeitbasierte Ausnahmebehandlung ist ebenfalls ein häufiges Objekt der einheitlichen Verarbeitung.

Die einheitliche Ausnahmebehandlung wird mithilfe von @ControllerAdvice + @ExceptionHandler implementiert. @ControllerAdvice stellt die Controller-Benachrichtigungsklasse dar, und @ExceptionHandler ist der Ausnahmehandler. Die Kombination der beiden bedeutet, dass eine bestimmte Benachrichtigung ausgeführt wird, wenn eine Ausnahme auftritt Um ein bestimmtes Methodenereignis auszuführen, lautet der spezifische Implementierungscode wie folgt:

rrree

Wenn zu diesem Zeitpunkt eine Ausnahme auftritt, wird der Code weiterhin ausgeführt, aber die benutzerdefinierten Ausnahmeinformationen werden an die Vorderseite zurückgegeben Ende!

Prinzip

@ControllerAdvice ist der AOP von Spring, der alle Attribute des Controllers ausschneidet, einschließlich der Einstiegspunkte und der Facettenlogik, die eingebunden werden muss. Er arbeitet mit @ExceptionHandler zusammen, um bestimmte Arten von Ausnahmen zu erfassen, die im Controller ausgelöst werden Um verschiedene Arten von Ausnahmebehandlungszwecken zu erreichen.

Rückgabedatenstruktur

Die einheitliche Rückgabedatenstruktur kann mithilfe der @ControllerAdvice + ResponseBodyAdvice-Schnittstelle implementiert werden. Der spezifische Implementierungscode lautet wie folgt:

boolean applyPreHandle(HttpServletRequest request, HttpServletResponse response) throws Exception {
    for(int i = 0; i < this.interceptorList.size(); this.interceptorIndex
            = i++) {
        // 获取项⽬中使⽤的拦截器 HandlerInterceptor
        HandlerInterceptor interceptor = (HandlerInterceptor)this.intercep
        torList.get(i);
        if (!interceptor.preHandle(request, response, this.handler)) {
            this.triggerAfterCompletion(request, response, (Exception)null
            );
            return false;
        }
    }
    return true;
}

Das obige ist der detaillierte Inhalt vonSo implementieren Sie die einheitliche Verarbeitungsfunktion von SpringBoot. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!