SpringMVC Learning Series (9) Explication détaillée du code pour implémenter la vérification des autorisations basée sur les annotations

La gestion des autorisations est requise pour la plupart des systèmes afin de déterminer le contenu que les différents utilisateurs peuvent voir. Alors, comment implémenter la vérification des autorisations dans Spring MVC ? Bien entendu, nous pouvons continuer à utiliser le filtre dans la servlet pour y parvenir. Mais avec l'aide de l'intercepteur d'action de Spring MVC, nous pouvons implémenter une vérification des autorisations basée sur les annotations.

SpringMVC Learning Series (9) Explication détaillée du code pour implémenter la vérification des autorisations basée sur les annotations. Présentez d'abord l'intercepteur d'action :

HandlerInterceptor est l'interface d'intercepteur fournie par Spring MVC pour nous permettre d'implémenter notre propre logique de traitement. Le contenu de HandlerInterceptor est le suivant :

public interface HandlerInterceptor {  
    boolean preHandle(  
            HttpServletRequest request, HttpServletResponse response,   
            Object handler)   
            throws Exception;  
  
    void postHandle(  
            HttpServletRequest request, HttpServletResponse response,   
            Object handler, ModelAndView modelAndView)   
            throws Exception;  
  
    void afterCompletion(  
            HttpServletRequest request, HttpServletResponse response,   
            Object handler, Exception ex)  
            throws Exception;  
}

Vous pouvez voir que l'interface dispose de 3 méthodes, leurs significations sont les suivantes :

preHandle : exécuté avant d'exécuter la logique de traitement dans l'action, il renvoie boolean, ici si nous retournons true, nous continuerons à exécuter postHandle et afterCompletion, si nous renvoyons false, nous interromprons l'exécution.

postHandle : exécuté avant de revenir à la vue après avoir exécuté la logique dans l'action.

afterCompletion : exécuté après le retour de l'action à la vue.

L'adaptateur HandlerInterceptorAdapter est l'implémentation par défaut de Spring MVC de HandlerInterceptor afin de faciliter notre utilisation de HandlerInterceptor. Les trois méthodes à l'intérieur n'effectuent aucun traitement. La méthode preHandle renvoie directement true, de sorte que nous n'avons besoin d'en implémenter que trois après. hériter de HandlerInterceptorAdapter. Dans la méthode, nous n'avons besoin que de la méthode dont nous avons besoin, contrairement à l'héritage de HandlerInterceptor, qui doit être implémenté indépendamment du fait que trois méthodes soient nécessaires.

Bien sûr, avec l'aide de HandlerInterceptor, nous pouvons implémenter de nombreuses autres fonctions, telles que la journalisation, l'analyse du temps de traitement des demandes, etc., et la vérification des autorisations n'est que l'une d'entre elles.

SpringMVC Learning Series (9) Explication détaillée du code pour implémenter la vérification des autorisations basée sur les annotations. Complétons la fonction de vérification des autorisations d'annotation étape par étape.

Ajoutez d'abord un contrôleur de compte et une action de connexion et une vue pour simuler le passage à la page de connexion lorsqu'il n'y a pas d'autorisation. Le contenu est le suivant :

Dans le com.demo.web.controllers. package AccountController.java：

package com.demo.web.controllers;import org.springframework.stereotype.Controller;import org.springframework.web.bind.annotation.RequestMapping;import org.springframework.web.bind.annotation.RequestMethod;

@Controller
@RequestMapping(value = "/account")public class AccountController {
    
    @RequestMapping(value="/login", method = {RequestMethod.GET})    public String login(){        
        return "login";
    }
    
}

Affichez login.jsp sous le dossier vues :

nbsp;html PUBLIC "-//W3C//DTD HTML 4.0SpringMVC Learning Series (9) Explication détaillée du code pour implémenter la vérification des autorisations basée sur les annotations Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd"><meta><title>Insert title here</title>
    这里是登录界面

Créez un nouveau package com.demo.web.auth, ajoutez l'annotation personnalisée AuthPassport, le contenu est le suivant :

package com.demo.web.auth;import java.lang.annotation.Documented;import java.lang.annotation.ElementType;import java.lang.annotation.Inherited;import java.lang.annotation.Retention;import java.lang.annotation.RetentionPolicy;import java.lang.annotation.Target;

@Documented
@Inherited
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)public @interface AuthPassport {    boolean validate() default true;
}

Ajoutez votre propre implémentation d'intercepteur dont AuthInterceptor hérite HandlerInterceptorAdapter, le contenu est le suivant :

package com.demo.web.auth;import javax.servlet.http.HttpServletRequest;import javax.servlet.http.HttpServletResponse;import org.springframework.web.method.HandlerMethod;import org.springframework.web.servlet.handler.HandlerInterceptorAdapter;public class AuthInterceptor extends HandlerInterceptorAdapter {
    
    @Override    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {        
        if(handler.getClass().isAssignableFrom(HandlerMethod.class)){
            AuthPassport authPassport = ((HandlerMethod) handler).getMethodAnnotation(AuthPassport.class);            
            //没有声明需要权限,或者声明不验证权限
                if(authPassport == null || authPassport.validate() == false)                return true;            else{                
                //在这里实现自己的权限验证逻辑
                if(false)//如果验证成功返回true（这里直接写false来模拟验证失败的处理）
                    return true;                else//如果验证失败                {                    //返回到登录界面
                    response.sendRedirect("account/login");                    return false;
                }       
            }
        }        else
            return true;   
     }
}

Ajoutez le contenu suivant au springservlet-config.xml du projet de configuration :

<interceptors>  
    <!-- 国际化操作拦截器 如果采用基于（请求/Session/Cookie）则必需配置 --> 
    <bean learning series explication d du code pour impl la v des autorisations bas sur les annotations8n.localechangeinterceptor></bean>  
    <!-- 如果不定义 mvc:mapping path 将拦截所有的URL请求 -->
    <bean></bean></interceptors>

Dans ce De cette manière, le traitement AuthInterceptor sera appelé lorsque chaque méthode d'action est exécutée. Lorsque l'action est jugée avoir l'annotation AuthPassport que nous avons définie, la logique de vérification des autorisations à l'intérieur sera exécutée.

Exécutez le projet :

Vous pouvez voir que la méthode d'indexation de HelloworldController que nous avons définie dans springservlet-config.xml est exécutée.

<!-- 如果当前请求为“/”时，则转发到“/helloworld/index" --><view-controller></view-controller>

下面我们在HelloworldController的index方法上加上自定义注解AuthPassport：

@AuthPassport
@RequestMapping(value={"/index","/hello"})public ModelAndView index(){
    
    ModelAndView modelAndView = new ModelAndView();  
    modelAndView.addObject("message", "Hello World!");  
    modelAndView.setViewName("index");  
    return modelAndView;
}

重新运行项目：

可以看到正确执行了权限判断逻辑，这样我们只需要在我们在需要权限验证的action上加上这个注解就可以实现权限控制功能了。

 

注解式权限验证的内容到此结束。

 以上就是SpringMVC学习系列（9） 之 实现注解式权限验证的代码详解的内容，更多相关内容请关注PHP中文网（www.php.cn）！