Beispielanalyse von Java, das domänenübergreifende CORS-Anfragen implementiert

In diesem Artikel wird hauptsächlich die Implementierungsmethode der domänenübergreifenden CORS-Anfrage in Java vorgestellt. Der Herausgeber findet sie recht gut, daher werde ich sie jetzt mit Ihnen teilen und als Referenz verwenden. Folgen wir dem Editor und werfen wir einen Blick darauf.

Problem

Bei der Entwicklung von Projekten im Front-End- und Back-End-Trennmodus tritt häufig ein solches Problem auf: Dienste über Domänen hinweg können nicht abgerufen werden. Enddaten

Dies wird durch die Same-Origin-Richtlinie des Browsers verursacht und dient der Sicherheit. Heutzutage, da das Front-End- und Back-End-Entwicklungsmodell sehr beliebt ist, werden Front-End- und Back-End-Projekte häufig in unterschiedlichen Umgebungen entwickelt. Derzeit besteht die Notwendigkeit, Daten domänenübergreifend anzufordern Zu den Lösungen gehören hauptsächlich die folgenden:

JSONP, Iframe, Proxy-Modus, CORS usw.
Ich werde hier nicht auf die vorherigen Methoden eingehen, es gibt viele Informationen im Internet. Hier werde ich hauptsächlich die CORS-Lösung vorstellen. CORS steht für „Cross-Domain Resource Sharing“. Es ermöglicht dem Browser, XMLHttpRequest-Anfragen an Cross-Origin-Server zu senden und so die Einschränkung zu überwinden, dass AJAX nur vom gleichen Ursprung verwendet werden kann.

Der Prozess der domänenübergreifenden Verwendung von CORS ist derselbe wie beim normalen Ajax-Prozess, mit der Ausnahme, dass der Browser einige Dinge automatisch für uns erledigt, wenn er feststellt, dass es sich um eine domänenübergreifende Anfrage handelt Der Server bietet Unterstützung. Es ist nicht erforderlich, am Frontend etwas Besonderes zu tun.

Die allgemeine Idee der Implementierung von

lautet wie folgt: Verwenden Sie zunächst einen Filter, um Informationen über das Anforderungsobjekt abzurufen, z. B. das Feld „Ursprung“. Von welcher Quelle die Anforderung stammt, einschließlich Protokoll, Domänenname und Port), bestimmen Sie anhand der vorkonfigurierten Parameter, ob die Anforderung zulässig ist, und legen Sie dann die Header-Informationen des Antwortobjekts fest, um domänenübergreifende Ressourcenanforderungen zu implementieren. Bevor wir die Implementierungsmethode vorstellen, wollen wir zunächst die verwendeten Antwortheaderinformationen verstehen.

Antwortheader

Access-Control-Allow-Methods
wird verwendet, um die HTTP-Methoden aufzulisten, die von der CORS-Anfrage des Browsers zugelassen werden, wie zum Beispiel: GET, POST , PUT, DELETE, OPTIONS

Access-Control-Allow-Credentials
gibt an, ob domänenübergreifende Cookies unterstützt werden sollen

Access-Control-Allow-Headers
durch Kommas getrennte Zeichenfolge , Zeigt alle vom Server unterstützten Header-Informationsfelder an, z. B. Content-Type und benutzerdefinierte Felder.

Access-Control-Expose-Headers
ist das Gegenteil von „Access-Control-Allow-Headers“ und zeigt an dass es nicht unterstützt wird. Das Header-Informationsfeld

Access-Control-Allow-Origin
ermöglicht domänenübergreifende Anforderungsquelleninformationen, einschließlich Protokoll, Domänenname und Port *, was bedeutet, dass alle Anforderungsquellen zulässig sind , und es kann nur eine Anforderungsquelle festgelegt werden

Im Folgenden finden Sie eine Einführung in die Implementierung dieses Ansatzes durch das Java-Backend.

Code

Da ich kürzlich Spring-Boot verwende, werde ich ihn basierend auf Spring-Boot implementieren.

Erstellen Sie zunächst einen CorsFilter-Filter. Der Code lautet wie folgt:

...
@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() {

  }
}

Jetzt kann das Frontend den Hintergrund abrufen Daten über Domänen hinweg, was besser ist als andere. Die Methode ist viel einfacher, der Code wird nicht erklärt, sie ist einfach und leicht zu verstehen, und das Gleiche gilt für andere Back-End-Entwicklungsmethoden. Das ultimative Ziel besteht darin, die Anfrage zu beurteilen und legen Sie den Antwortheader fest, und das Frontend muss nichts tun.

Das obige ist der detaillierte Inhalt vonBeispielanalyse von Java, das domänenübergreifende CORS-Anfragen implementiert. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!