Comment utiliser des expressions personnalisées dans la sécurité du printemps @Préauthorize/@PostAuthorize annotations

1) vous devez d'abord réimposer MethodSecurityExpressionRoot qui contient des fonctionnalités supplémentaires spécifiques à la méthode. L'implémentation originale de la sécurité du ressort est package private Et il n'est donc pas possible de l'étendre. Je suggère de vérifier le code source pour la classe donnée.

public class CustomMethodSecurityExpressionRoot extends SecurityExpressionRoot implements MethodSecurityExpressionOperations {

    // copy everything from the original Spring Security MethodSecurityExpressionRoot

    // add your custom methods

    public boolean isAdmin() {
        // do whatever you need to do, e.g. delegate to other components

        // hint: you can here directly access Authentication object 
        // via inherited authentication field
    }

    public boolean isOwner(Long id) {
        // do whatever you need to do, e.g. delegate to other components
    }
}

2) Ensuite vous devez implémenter custom MethodSecurityExpressionHandler qui utilisera leCustomMethodSecurityExpressionRoot.

public class CustomMethodSecurityExpressionHandler extends DefaultMethodSecurityExpressionHandler {

    private final AuthenticationTrustResolver trustResolver = new AuthenticationTrustResolverImpl();

    @Override
    public void setReturnObject(Object returnObject, EvaluationContext ctx) {
        ((MethodSecurityExpressionRoot) ctx.getRootObject().getValue()).setReturnObject(returnObject);
    }

    @Override
    protected MethodSecurityExpressionOperations createSecurityExpressionRoot(Authentication authentication,
        MethodInvocation invocation) {
        final CustomMethodSecurityExpressionRoot root = new CustomMethodSecurityExpressionRoot(authentication);
        root.setThis(invocation.getThis());
        root.setPermissionEvaluator(getPermissionEvaluator());
        root.setTrustResolver(this.trustResolver);
        root.setRoleHierarchy(getRoleHierarchy());

        return root;
    }
}

3) Définissez l'expression handler bean dans votre contexte, par exemple via XML vous pouvez le faire comme suit

<bean id="methodSecurityExpressionHandler"
    class="my.package.CustomMethodSecurityExpressionHandler">
    <property name="roleHierarchy" ref="roleHierarchy" />
    <property name="permissionEvaluator" ref="permissionEvaluator" />
</bean>

4) Enregistrer le handler défini ci-dessus

<security:global-method-security pre-post-annotations="enabled">
    <security:expression-handler ref="methodSecurityExpressionHandler"/>
</security:global-method-security>

5) alors utilisez juste les expressions définies dans votre @PreAuthorize et/ou @PostAuthorize annotations

@PreAuthorize("isAdmin() or isOwner(#id)")
public void deleteGame(@PathVariable int id, @ModelAttribute currentGame) {
    // do whatever needed
}

et encore une chose. Il n'est pas très courant d'utiliser la sécurité au niveau de la méthode pour sécuriser les méthodes du contrôleur, mais plutôt pour sécuriser les méthodes avec une logique opérationnelle (A. K. A. vos méthodes de la couche de service). Alors vous pourriez utiliser quelque chose comme le dessous.

public interface GameService {

    // rest omitted

    @PreAuthorize("principal.admin or #game.owner = principal.username")
    public void delete(@P("game") Game game);
}

Mais gardez à l'esprit que c'est juste un exemple. Il s'attend à ce que le directeur actuel ait isAdmin() méthode et que le jeu a getOwner() méthode de retour du nom d'utilisateur du propriétaire.