Comment créer mon propre filtre avec Spring MVC?

Alternative aux Filtres, vous pouvez utiliser HandlerInterceptor.

public class SessionManager implements HandlerInterceptor{

    //This method is called before the controller
    @Override
    public boolean preHandle(HttpServletRequest request,
            HttpServletResponse response, Object handler) throws Exception {

        String xHeader = request.getHeader("X-Auth-Token");
        boolean permission = getPermission(xHeader);
        if(permission) {
            return true;
        }
        else {
            response.setStatus(HttpStatus.UNAUTHORIZED.value());
            return false;
            //Above code will send a 401 with no response body.
            //If you need a 401 view, do a redirect instead of
            //returning false.
            //response.sendRedirect("/401"); //assuming you have a handler mapping for 401

        }
        return false;
    }

    @Override
    public void postHandle(HttpServletRequest request,
            HttpServletResponse response, Object handler,
            ModelAndView modelAndView) throws Exception {

    }

    @Override
    public void afterCompletion(HttpServletRequest request,
            HttpServletResponse response, Object handler, Exception ex)
            throws Exception {

    }
}

Puis ajouter l'intercepteur à votre webmvc config.

@EnableWebMvc
@Configuration
public class WebConfig extends WebMvcConfigurerAdapter {

    @Bean
    SessionManager getSessionManager() {
         return new SessionManager();
    }

    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(getSessionManager())
        .addPathPatterns("/**")
        .excludePathPatterns("/resources/**", "/login");
     //assuming you put your serve your static files with /resources/mapping
     //and the pre login page is served with /login mapping
    }

}

Printemps peut l'utilisation de filtres, mais ils vous recommandons d'utiliser leur version de filtres, connu comme un intercepteur

http://viralpatel.net/blogs/spring-mvc-interceptor-example/

Il y a une course rapide à travers de la façon dont ils travaillent. Ils sont presque identiques pour les filtres, mais conçu pour fonctionner à l'intérieur de la Spring MVC cycle de vie.

Vous pouvez également l'appliquer à l'aide d'un aspect avec une coupe transverse (pointcut) qui vise une certaine annotation. J'ai écrit une bibliothèque qui vous permet d'utiliser des annotations qui effectuent des vérifications d'autorisation basé sur un JWT jeton.

Vous pouvez trouver le projet avec l'ensemble de la documentation sur: https://github.com/nille85/jwt-aspect. J'ai utilisé cette méthode plusieurs fois afin d'obtenir un REPOS Backend qui est consommée par une single page application.

J'ai également documentée sur mon blog comment vous pouvez l'utiliser dans un Spring MVC de l'Application: http://www.nille.be/security/creating-authorization-server-using-jwts/

Ce qui suit est un extrait de l'exemple de projet sur https://github.com/nille85/auth-server

L'exemple en-dessous contient une méthode protégée getClient. L'annotation @Autoriser que l'aspect utilise vérifie si la valeur de la "aud jwt réclamation" correspond à la clientId paramètre qui est annoté avec @ClaimValue. Si elle correspond, la méthode peut être entré. Sinon une exception est levée.

@RestController
@RequestMapping(path = "/clients")
public class ClientController {
private final ClientService clientService;
@Autowired
public ClientController(final ClientService clientService) {
this.clientService = clientService;
}
@Authorize("hasClaim('aud','#clientid')")
@RequestMapping(value = "/{clientid}", method = RequestMethod.GET, produces = "application/json")
@ResponseStatus(value = HttpStatus.OK)
public @ResponseBody Client getClient(@PathVariable(value = "clientid") @ClaimValue(value = "clientid") final String clientId) {
return clientService.getClient(clientId);
}
@RequestMapping(value = "", method = RequestMethod.GET, produces = "application/json")
@ResponseStatus(value = HttpStatus.OK)
public @ResponseBody List<Client> getClients() {
return clientService.getClients();
}
@RequestMapping(path = "", method = RequestMethod.POST, produces = "application/json")
@ResponseStatus(value = HttpStatus.OK)
public @ResponseBody Client registerClient(@RequestBody RegisterClientCommand command) {
return clientService.register(command);
}
}

L'Aspect lui-même peut être configuré comme:

@Bean
public JWTAspect jwtAspect() {
JWTAspect aspect = new JWTAspect(payloadService());
return aspect;
}

La PayloadService ce qui est nécessaire peut par exemple être mis en œuvre comme:

public class PayloadRequestService implements PayloadService {
private final JWTVerifier verifier;
public PayloadRequestService(final JWTVerifier verifier){
this.verifier = verifier;
}
@Override
public Payload verify() {
ServletRequestAttributes t = (ServletRequestAttributes) RequestContextHolder.currentRequestAttributes();
HttpServletRequest request = t.getRequest();
final String jwtValue = request.getHeader("X-AUTH");
JWT jwt = new JWT(jwtValue);
Payload payload =verifier.verify(jwt);
return payload;
}
}

Votre approche semble correct.

Une fois que j'ai utilisé quelque chose de semblable à la suivante (Supprimé la plupart des lignes et gardé les choses simples).

public class MvcDispatcherServletInitializer  extends AbstractAnnotationConfigDispatcherServletInitializer {
@Override
public void onStartup(ServletContext servletContext) throws ServletException {
super.onStartup(servletContext);
EnumSet<DispatcherType> dispatcherTypes = EnumSet.of(DispatcherType.REQUEST, DispatcherType.FORWARD, DispatcherType.ERROR);
FilterRegistration.Dynamic monitoringFilter = servletContext.addFilter("monitoringFilter", MonitoringFilter.class);
monitoringFilter.addMappingForUrlPatterns(dispatcherTypes, false, "/api/admin/*");
}
@Override
protected Class<?>[] getRootConfigClasses() {
return new Class[] { WebMvcConfig.class };
}
@Override
protected Class<?>[] getServletConfigClasses() {
return null;
}
@Override
protected String[] getServletMappings() {
return new String[] { "/" };
}
}

Aussi vous avez besoin d'un filtre personnalisé ressemble à ci-dessous.

public class CustomXHeaderFilter implements Filter {
@Override
public void doFilter(ServletRequest req, ServletResponse res, FilterChain chain) throws IOException, ServletException {
HttpServletRequest request = (HttpServletRequest) req;
HttpServletResponse response = (HttpServletResponse) res;
String xHeader = request.getHeader("X-Auth-Token");
if(YOUR xHeader validation fails){
//Redirect to a view
//OR something similar
return;
}else{
//If the xHeader is OK, go through the chain as a proper request
chain.doFilter(request, response);
}
}
@Override
public void destroy() {
}
@Override
public void init(FilterConfig arg0) throws ServletException {
}
}

Espère que cette aide.

En outre, vous pouvez utiliser FilterRegistrationBean si vous le Printemps de Démarrage. Il fait la même chose (je crois) qui FilterRegistration.Dynamic n'.