Comment utiliser Spring AOP pour implémenter l'authentification d'interface dans SpringBoot

Programmation orientée aspect

La programmation orientée aspect peut extraire une logique qui n'a rien à voir avec l'entreprise mais qui doit être appelée conjointement par différents modules métier, et l'intégrer dans le code dans le forme d'aspects, réduisant ainsi le coût du système. Le couplage de code réduit le code en double.

Spring AOP implémente une programmation orientée aspect du programme via la précompilation et des proxys dynamiques pendant l'exécution

Le principe sous-jacent de la mise en œuvre d'AOP#🎜🎜 #

La couche inférieure d'AOP utilise des proxys dynamiques pour répondre aux exigences et générer des classes proxy pour les classes qui doivent être améliorées. Il existe deux façons de générer des classes proxy (c'est-à-dire la classe qui a besoin). à améliorer),

If :

• implémente l'interface et utilise le proxy dynamique JDK La classe proxy générée utilisera son interface et le fera. ne pas implémenter l'interface.

• En utilisant le proxy dynamique CGlib, la classe proxy générée intégrera la classe proxy

#🎜🎜 #Termes liés à l'AOP

• Point de connexion :

  Méthode dans la classe proxy (améliorée) #🎜🎜 #

Point d'entrée :
• La méthode qui doit réellement être améliorée

Notification :
• Le code logique à améliorer

  # 🎜🎜#

Pré-notification :
Exécuté avant l'exécution de la fonction principale
• # 🎜🎜#

  # 🎜🎜# Post notification : Exécuté après l'exécution de la fonction thème

• Notification Surround : Exécuté avant et après l'exécution de la fonction principale

• Notification d'exception : Exécuté lorsqu'une exception se produit dans l'exécution de la fonction thème

• #🎜🎜 #

  Avis final : La fonction principale sera exécutée que l'exécution soit réussie ou non

• Aspect : La combinaison des points d'entrée et des aspects, c'est-à-dire les méthodes améliorées et les fonctions améliorées forment des aspects

  # 🎜🎜#
Commentaires associés et expressions de point d'entrée

• # 🎜🎜#Remarque :

#🎜🎜 #

@Aspect :

Déclarer une classe comme aspect, rédiger des notifications et des points d'entrée#🎜 🎜#

@Avant : #🎜🎜 #Pré-notification correspondante

• @ AprèsRetour : correspond à la post-notification

• # 🎜🎜#

  @Autour :correspond à la notification environnante

  #🎜 🎜#
• @AfterThrowing :

  Notification d'exception correspondante#🎜 🎜#

@Après :
• Notification finale correspondante

@Pointcut :
• Déclarer un pointcut, le marquer sur une méthode peut rendre l'expression plus concise

Déclarer des pointscuts à l'aide d'expressions de pointcut
• # 🎜🎜#

  execution([modificateur d'autorisation][type de retour][Chemin complet de la classe].[Nom de la méthode][Type de liste de paramètres])

• execution(* com.xxx.ABC.add()), pour la classe ABC Améliorer la méthodeImplémenter l'authentification de l'interface

1. yml

Configurer le compte d'authentification de l'interface#🎜🎜 #

account:
  infos:
    - account: xinchao
      secret: admin

2. Lire la configuration du compte

@Data
public class SecretInfo {
    private String account;
    private String secret;
}

• 3. méthode d'authentification de l'interface

  @Configuration
  @ConfigurationProperties("account")
  public class SecretConfig {
      private List<SecretInfo> infos;
  
      private Map<String, SecretInfo> map;
  
      private Map<String, TokenInfo> tokenMap = new HashMap<>();
  
      public void setInfos(List<SecretInfo> infos) {
          this.infos = infos;
          map = infos.stream().collect(Collectors.toMap(SecretInfo::getAccount, Function.identity()));
      }
  
      public synchronized String getToken(String account, String secret) {
          SecretInfo info = map.get(account);
          if (info == null) {
              throw new BusinessException("无效账号");
          }
          if (!StringUtils.equals(info.getSecret(), secret)) {
              throw new BusinessException("无效密码");
          }
          TokenInfo tokenInfo = tokenMap.get(account);
          if (tokenInfo != null && tokenInfo.getToken() != null) {
              return tokenInfo.getToken();
          }
          tokenInfo = new TokenInfo();
          String uuid = UUID.randomUUID().toString();
          tokenInfo.setToken(uuid);
          tokenInfo.setCreateDate(LocalDateTime.now());
          tokenInfo.setExpireDate(LocalDateTime.now().plusHours(2));
          tokenMap.put(account,tokenInfo);
          return tokenInfo.getToken();
      }
  
      public boolean checkCaptcha(String captcha) {
          return tokenMap.values().stream().anyMatch(e->StringUtils.equals(e.getToken(),captcha));
      }
  }

  @Data
  public class TokenInfo {
      private LocalDateTime createDate;
      private LocalDateTime expireDate;
      private String token;
  
      public String getToken() {
          if (LocalDateTime.now().isBefore(expireDate)) {
              return token;
          }
          return null;
      }
  
      public boolean verification(String token) {
          return Objects.equals(this.token, token);
      }
  }

  4. Écrivez AOP

Tout d'abord, écrivez une annotation pour indiquer que l'authentification n'est pas requise

@Target({ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface CaptchaIgnoreAop {
}

@Slf4j
@Aspect
@Component
@Order(2)
public class CaptchaAop {

    @Value("${spring.profiles.active:dev}")
    private String env;

    @Autowired
    private SecretConfig config;

    @Pointcut("execution(public * com.herenit.phsswitch.controller.impl..*.*(..))" +
            "&&@annotation(org.springframework.web.bind.annotation.PostMapping)" +
            "&&!@annotation(com.herenit.phsswitch.aop.CaptchaIgnoreAop)")
    public void tokenAop() {
    }

    @Around("tokenAop()")
    public Object doBefore(ProceedingJoinPoint joinPoint) throws Throwable {
        Object[] args = joinPoint.getArgs();
        if (args.length == 0 || !(args[0] instanceof RequestWrapper)
                || "test,dev".contains(env)) {
            log.info("当前环境无需校验token");
            return joinPoint.proceed();
        }
        String captcha = ((RequestWrapper) joinPoint.getArgs()[0]).getCaptcha();
        if (!config.checkCaptcha(captcha)) {
            throw new BusinessException("captcha无效");
        }
        return joinPoint.proceed();
    }

}

# 🎜🎜#5. Écrivez un test d'interface

@PostMapping("/login")
@CaptchaIgnoreAop
public ResponseWrapper login(@RequestBody JSONObject userInfo) {
    String token = config.getToken(userInfo.getString("loginName")
            , userInfo.getString("password"));
    JSONObject result = new JSONObject();
    result.put("platformAccessToken", token);
    return ResponseWrapper.success(result);
}

L'utilisation de cette interface peut créer un jeton en mémoire et le renvoyer au frontend. Plus tard, nous pourrons transmettre ce jeton pour authentification lors du réglage d'autres interfaces. L'emplacement transmis est le champ captcha

public class RequestWrapper<T> implements Serializable {

    private static final long serialVersionUID = 8988706670118918321L;
    public RequestWrapper() {
        super();
    }

    private T args;

    private String captcha;

    private String funcode;

    public T getArgs() {
        return args;
    }

    public void setArgs(T args) {
        this.args = args;
    }

    public String getCaptcha() {
        return captcha;
    }

    public void setCaptcha(String captcha) {
        this.captcha = captcha;
    }

    public String getFuncode() {
        return funcode;
    }

    public void setFuncode(String funcode) {
        this.funcode = funcode;
    }
}

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!