Exemple d'analyse de Java implémentant des requêtes inter-domaines CORS

Cet article présente principalement la méthode d'implémentation de la requête inter-domaines CORS en Java. L'éditeur pense qu'elle est plutôt bonne, je vais donc la partager avec vous maintenant et la donner comme référence. Suivons l'éditeur et jetons un coup d'œil.

Problème

Lors du développement de projets utilisant le mode de séparation front-end et back-end, vous rencontrez souvent un tel problème - impossible d'obtenir des services sur tous les domaines Données de fin

Ceci est dû à la politique de même origine du navigateur et est pour des raisons de sécurité. Aujourd'hui, alors que le modèle de développement de séparation front-end et back-end est très populaire, les projets front-end et back-end sont souvent développés dans des environnements différents. À l'heure actuelle, il sera nécessaire de demander des données dans tous les domaines. les solutions incluent principalement les éléments suivants :

JSONP, iframe, mode proxy, CORS, etc.
Je ne parlerai pas ici des méthodes précédentes, il y a beaucoup d'informations sur Internet. Ici, je partagerai principalement la solution CORS. CORS signifie « partage de ressources inter-domaines ». Il permet au navigateur d'émettre des requêtes XMLHttpRequest vers des serveurs d'origine croisée, surmontant ainsi la limitation selon laquelle AJAX ne peut être utilisé qu'à partir de la même origine.

Le processus d'utilisation de CORS entre domaines est le même que le processus ajax ordinaire, sauf que le navigateur gérera automatiquement certaines choses pour nous lorsqu'il découvre qu'il s'agit d'une requête inter-domaines, donc tant que le serveur fournit un support. Il n'est pas nécessaire de faire quoi que ce soit de plus sur le front-end.

L'idée générale de mise en œuvre de

est la suivante : Tout d'abord, utilisez un filtre pour obtenir des informations sur l'objet de la requête, comme le champ Origine (qui indique. de quelle source provient la demande, y compris le protocole, le nom de domaine, le port), déterminez si la demande est légale grâce aux paramètres préconfigurés, puis définissez les informations d'en-tête de l'objet de réponse pour implémenter les demandes de ressources inter-domaines. Avant de présenter la méthode d'implémentation, comprenons d'abord les informations d'en-tête de réponse qui seront utilisées.

En-tête de réponse

Access-Control-Allow-Methods
est utilisé pour lister les méthodes HTTP autorisées par la requête CORS du navigateur, telles que : GET, POST , PUT, DELETE, OPTIONS

Access-Control-Allow-Credentials
indique s'il faut prendre en charge les cookies inter-domaines

Access-Control-Allow-Headers
chaîne séparée par des virgules , Indique tous les champs d'informations d'en-tête pris en charge par le serveur, tels que Content-Type et les champs personnalisés

Access-Control-Expose-Headers
est l'opposé de "Access-Control-Allow-Headers", indiquant qu'il n'est pas pris en charge. Le champ d'informations d'en-tête

Access-Control-Allow-Origin
autorise les informations sur la source de requête inter-domaines, y compris le protocole, le nom de domaine et le port * signifie que toutes les sources de requête sont autorisées. , et une seule source de requête peut être définie

Ce qui suit est une introduction à la façon dont le backend Java implémente cette approche.

Code

Depuis que j'utilise spring-boot récemment, je vais l'implémenter en fonction de spring-boot.

Créez d'abord un filtre CorsFilter, le code est le suivant :

...
@WebFilter(filterName = "corsFilter", urlPatterns = "/*",
    initParams = {@WebInitParam(name = "allowOrigin", value = "*"),
        @WebInitParam(name = "allowMethods", value = "GET,POST,PUT,DELETE,OPTIONS"),
        @WebInitParam(name = "allowCredentials", value = "true"),
        @WebInitParam(name = "allowHeaders", value = "Content-Type,X-Token")})
public class CorsFilter implements Filter {

  private String allowOrigin;
  private String allowMethods;
  private String allowCredentials;
  private String allowHeaders;
  private String exposeHeaders;

  @Override
  public void init(FilterConfig filterConfig) throws ServletException {
    allowOrigin = filterConfig.getInitParameter("allowOrigin");
    allowMethods = filterConfig.getInitParameter("allowMethods");
    allowCredentials = filterConfig.getInitParameter("allowCredentials");
    allowHeaders = filterConfig.getInitParameter("allowHeaders");
    exposeHeaders = filterConfig.getInitParameter("exposeHeaders");
  }

  @Override
  public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
    HttpServletRequest request = (HttpServletRequest) servletRequest;
    HttpServletResponse response = (HttpServletResponse) servletResponse;
    if (!StringUtils.isEmpty(allowOrigin)) {
      if(allowOrigin.equals("*")){
        response.setHeader("Access-Control-Allow-Origin", allowOrigin);
      }else{
        List<String> allowOriginList = Arrays.asList(allowOrigin.split(","));
        if (allowOriginList != null && allowOriginList.size() > 0) {
          String currentOrigin = request.getHeader("Origin");
          if (allowOriginList.contains(currentOrigin)) {
            response.setHeader("Access-Control-Allow-Origin", currentOrigin);
          }
        }
      }
    }
    if (!StringUtils.isEmpty(allowMethods)) {
      response.setHeader("Access-Control-Allow-Methods", allowMethods);
    }
    if (!StringUtils.isEmpty(allowCredentials)) {
      response.setHeader("Access-Control-Allow-Credentials", allowCredentials);
    }
    if (!StringUtils.isEmpty(allowHeaders)) {
      response.setHeader("Access-Control-Allow-Headers", allowHeaders);
    }
    if (!StringUtils.isEmpty(exposeHeaders)) {
      response.setHeader("Access-Control-Expose-Headers", exposeHeaders);
    }
    filterChain.doFilter(servletRequest, servletResponse);
  }

  @Override
  public void destroy() {

  }
}

Vous avez terminé. Le front-end peut maintenant obtenir l'arrière-plan. données dans tous les domaines, ce qui est meilleur que les autres. La méthode est beaucoup plus simple, le code n'est pas expliqué, il est simple et facile à comprendre, et c'est la même chose avec les autres méthodes de développement back-end. Le but ultime est de juger la demande. et définissez l'en-tête de réponse, et le front-end n'a rien à faire.

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!