Analyse du code source de l'intercepteur SpringBoot

1. Qu'est-ce qu'un intercepteur ? L'intercepteur (Interceptor) en Java est un objet qui intercepte dynamiquement les appels d'action. Il fournit un mécanisme qui permet aux développeurs d'exécuter un morceau de code avant et après l'exécution d'une action, ou dans une action. Empêche son exécution avant l'exécution et fournit également un moyen d'extraire des parties réutilisables du code dans l'action. En AOP, les intercepteurs sont utilisés pour intercepter une méthode ou un champ avant d'y accéder, puis ajouter certaines opérations avant ou après.

L'action ci-dessus fait généralement référence à l'interface de notre couche Contrôleur.

2. Intercepteur personnalisé

Généralement, la personnalisation d'un intercepteur est divisée en trois étapes

(1) Écrire un intercepteur pour implémenter l'interface HandlerInterceptor.

(2) L'intercepteur est enregistré dans le conteneur.

(3) Configurez les règles d'interception.

2.1 Écriture d'un intercepteur

Nous créons un nouveau projet SpringBoot, puis personnalisons un intercepteur LoginInterceptor pour intercepter certaines requêtes à l'état non journalisé. À partir du JDK 1.8, les méthodes d'interface avec le mot-clé default peuvent avoir des implémentations par défaut, donc pour implémenter une interface, il vous suffit d'implémenter la méthode sans ce mot-clé.

import lombok.extern.slf4j.Slf4j;
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

/**
 * 登录拦截器
 */
@Slf4j
public class LoginInterceptor implements HandlerInterceptor {
    /**
     * 目标方法执行之前执行
     * @param request
     * @param response
     * @param handler
     * @return
     * @throws Exception
     */
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        // 获取请求路径
        String requestUrl = request.getRequestURI();
        log.info("请求的路径是: {}", requestUrl);

        String username = request.getParameter("username");
        if (username != null) {
            // 放行
            return true;
        }

        request.setAttribute("msg", "请先登录");
        // 携带msg跳转到登录页
        request.getRequestDispatcher("/").forward(request, response);
        return false;
    }

    /**
     * 目标方法完成以后执行
     * @param request
     * @param response
     * @param handler
     * @param modelAndView
     * @throws Exception
     */
    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        log.info("postHandle执行");
    }

    /**
     * 页面渲染以后执行
     * @param request
     * @param response
     * @param handler
     * @param ex
     * @throws Exception
     */
    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        log.info("afterCompletion执行");
    }
}

2.2 Enregistrez et configurez les intercepteurs

Dans SpringBoot, lorsque nous devons personnaliser la configuration, il nous suffit d'implémenter la classe WebMvcConfigurer et de remplacer la méthode correspondante. Ici, nous devons configurer l'intercepteur, il suffit donc de réécrire sa méthode addInterceptors.

import com.codeliu.interceptor.LoginInterceptor;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

// 表示这是一个配置类
@Configuration
public class WebMvcConfig implements WebMvcConfigurer {
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(new LoginInterceptor())
                .addPathPatterns("/**")  // 拦截所有路径
                .excludePathPatterns("/","/login","/css/**","/fonts/**","/images/**","/js/**");  // 不拦截这些路径
    }
}

Notez que si nous configurons pour intercepter tous les chemins, nous devons exclure les ressources statiques, sinon les styles d'image seront interceptés.

Grâce aux étapes ci-dessus, nous avons implémenté un intercepteur ajouté au système. Commencez simplement la vérification.

3. Principe de l'intercepteur

Nous utilisons la méthode de débogage du point d'arrêt pour voir comment la requête du navigateur est traitée du début au backend. Définissez un point d'arrêt dans la méthode doDispatch de DispatcherServlet. Il s'agit du point d'entrée de la requête. Une fois que le navigateur a envoyé la requête, elle est transmise et traitée par cette méthode.

Démarrez l'application en mode débogage, accédez à n'importe quelle interface et suivez le processus de code

3.1 Trouvez le gestionnaire qui peut gérer la requête et tous les intercepteurs du gestionnaire

Ici, nous avons trouvé le HandlerExecutionChain et la chaîne d'intercepteurs, qui a trois intercepteurs Interceptor, notre personnalisé

et les deux intercepteurs par défaut du système.

LoginInterceptor3.2 Exécuter la méthode preHandle de l'intercepteur

Dans la méthode doDispatch, il y a les deux lignes de code suivantes

// 执行拦截器的preHandle方法，如果返回为fasle，则直接return，不执行目标方法
if (!mappedHandler.applyPreHandle(processedRequest, response)) {
    return;
}

// 反射执行目标方法
mv = ha.handle(processedRequest, response, mappedHandler.getHandler());

Nous entrons dans la méthode applyPreHandle pour voir la logique de la méthode

/**
 * Apply preHandle methods of registered interceptors.
 * @return {@code true} if the execution chain should proceed with the
 * next interceptor or the handler itself. Else, DispatcherServlet assumes
 * that this interceptor has already dealt with the response itself.
 */
boolean applyPreHandle(HttpServletRequest request, HttpServletResponse response) throws Exception {
    // 遍历拦截器
    for (int i = 0; i < this.interceptorList.size(); i++) {
        HandlerInterceptor interceptor = this.interceptorList.get(i);
        // 执行当前拦截器的preHandle方法
        if (!interceptor.preHandle(request, response, this.handler)) {
            // 如果preHandle方法返回为false，则执行当前拦截器的afterCompletion方法
            triggerAfterCompletion(request, response, null);
            return false;
        }
        // 记录当前拦截器的下标
        this.interceptorIndex = i;
    }
    return true;
}

Grâce au code ci-dessus, nous savons si l'intercepteur actuel Si la méthode preHandle renvoie true, la méthode preHandle de l'intercepteur suivant continuera à être exécutée, sinon la méthode afterCompletion de l'intercepteur sera exécutée.

Ensuite, regardons la logique de la méthode triggerAfterCompletion.

/**
 * Trigger afterCompletion callbacks on the mapped HandlerInterceptors.
 * Will just invoke afterCompletion for all interceptors whose preHandle invocation
 * has successfully completed and returned true.
 */
void triggerAfterCompletion(HttpServletRequest request, HttpServletResponse response, @Nullable Exception ex) {
    // 反向遍历拦截器
    for (int i = this.interceptorIndex; i >= 0; i--) {
        HandlerInterceptor interceptor = this.interceptorList.get(i);
        try {
            // 执行当前拦截器的afterCompletion方法
            interceptor.afterCompletion(request, response, this.handler, ex);
        }
        catch (Throwable ex2) {
            logger.error("HandlerInterceptor.afterCompletion threw exception", ex2);
        }
    }
}

Grâce au code ci-dessus, nous savons que la méthode afterCompletion de l'intercepteur est exécutée à l'envers.

3.3 Exécuter la méthode cible

Si toutes les méthodes preHandle de l'intercepteur ci-dessus renvoient vrai, alors il n'y aura pas de retour direct dans la méthode doDispatch, mais la méthode cible continuera à être exécutée. Si la méthode preHandle d'un intercepteur renvoie false, alors après avoir exécuté la méthode afterCompletion de l'intercepteur (l'intercepteur qui a exécuté la méthode preHandle), la méthode doDispatch reviendra directement et la méthode cible ne sera pas exécutée.

Exécutez la méthode cible via le code suivant

// Actually invoke the handler.
mv = ha.handle(processedRequest, response, mappedHandler.getHandler());

Je ne regarderai pas l'exécution interne spécifique, mais regarderai la logique après l'exécution.

3.4 Exécuter la méthode postHandle de l'intercepteur

Une fois la méthode cible exécutée, le code descend

mappedHandler.applyPostHandle(processedRequest, response, mv);

Voir la logique de applyPostHandle

/**
 * Apply postHandle methods of registered interceptors.
 */
void applyPostHandle(HttpServletRequest request, HttpServletResponse response, @Nullable ModelAndView mv)
    throws Exception {
	// 反向遍历
    for (int i = this.interceptorList.size() - 1; i >= 0; i--) {
        HandlerInterceptor interceptor = this.interceptorList.get(i);
        // 执行当前拦截器的postHandle方法
        interceptor.postHandle(request, response, this.handler, mv);
    }
}

Exécuter la méthode postHandle de l'intercepteur dans l'ordre inverse

3.5 Exécuter afterCompletion méthode de l'intercepteur

Continuez Descendez

processDispatchResult(processedRequest, response, mappedHandler, mv, dispatchException);

et entrez cette méthode. Cette méthode traitera les résultats de l'exécution et restituera la page à la fin de cette méthode, exécutez le code suivant

3.6 Gestion des exceptions

. Si une exception est levée lors de l'exécution de la méthode doDispatch, les exceptions, dans le module catch, déclencheront l'exécution de la méthode afterCompletion

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!