Java-Backend-Entwicklung: Erstellen reaktiver APIs mit Akka HTTP

In der heutigen Webentwicklung wird reaktive Programmierung immer wichtiger. Akka HTTP ist ein leistungsstarkes HTTP-Framework, das auf Akka basiert und sich zum Erstellen reaktiver APIs im REST-Stil eignet. In diesem Artikel wird erläutert, wie Sie mit Akka HTTP eine reaktive API erstellen, und es werden einige praktische Beispiele bereitgestellt. Fangen wir an!

1. Warum Akka HTTP wählen?

Bei der Entwicklung reaktiver APIs ist es sehr wichtig, das richtige Framework auszuwählen. Akka HTTP ist eine sehr gute Wahl, da es die folgenden Vorteile bietet:

1.1 Reaktionsfreudig und nicht blockierend

Akka HTTP ist ein sehr reaktives Framework, mit dem Sie eine große Anzahl von Anfragen bearbeiten können, ohne Ihr Anwendungsprogramm zu blockieren. Es nutzt das Actor-Modell, was bedeutet, dass Sie asynchrone Vorgänge verwenden können, um schnell auf Anfragen zu reagieren und gleichzeitig Ihre Anwendung hoch skalierbar zu halten.

1.2 Hohe Leistung

Da es auf dem Akka-Framework basiert, kann Akka HTTP eine schnellere Leistung bieten. Dies liegt daran, dass es mehrere CPUs und Kerne voll ausnutzen kann und sich für Situationen eignet, in denen eine hohe Parallelität verwendet wird.

1.3 Einfach zu verwenden und zu konfigurieren

Akka HTTP ist sehr einfach zu konfigurieren und zu verwenden. Es bietet eine Reihe leistungsstarker Tools, mit denen Sie Ihre API schnell konfigurieren und verwalten können. Sie können Ihren Code auch in Scala oder Java schreiben.

2. Erstellen einer reaktiven API

Als nächstes zeigen wir, wie man mit Akka HTTP eine reaktive API erstellt. Wir erstellen eine einfache API zum Verwalten einer Benutzerliste.

2.1 Installation und Import

Um Akka HTTP zu verwenden, müssen Sie die folgenden Abhängigkeiten hinzufügen:

<dependency>
  <groupId>com.typesafe.akka</groupId>
  <artifactId>akka-actor_2.12</artifactId>
  <version>2.5.26</version>
</dependency>

<dependency>
  <groupId>com.typesafe.akka</groupId>
  <artifactId>akka-http_2.12</artifactId>
  <version>10.1.10</version>
</dependency>

Bitte stellen Sie sicher, dass Sie diese Abhängigkeiten in Ihrem Maven- oder Gradle-Projekt haben.

2.2 Router erstellen

Jetzt erstellen wir einen Router, der verschiedene HTTP-Anfragen empfängt und entsprechende Antworten bereitstellt. Wir werden die von Akka HTTP bereitgestellte Route-Klasse verwenden, um unseren Router zu definieren und die entsprechenden Routing-Regeln bereitzustellen.

In diesem Beispiel erstellen wir einen /User-Pfad mit den Methoden GET, POST, PUT und DELETE. Die GET-Methode gibt eine Liste von Benutzern zurück, die POST-Methode erstellt einen neuen Benutzer, die PUT-Methode aktualisiert Benutzer und die DELETE-Methode löscht Benutzer.

Das Folgende ist der Code für unseren Router:

import akka.http.javadsl.server.Route;
import akka.http.javadsl.server.AllDirectives;

public class UserRouter extends AllDirectives {
  
  private final UserService userService;
  
  public UserRouter(UserService userService) {
    this.userService = userService;
  }
  
  public Route createRoute() {
    return route(
      pathPrefix("users", () -> route(
        get(() -> complete(userService.getUsers())),
        post(() -> entity(
          Jackson.unmarshaller(User.class), user -> complete(
            StatusCodes.CREATED, userService.createUser(user)
          )
        )),
        put(() -> entity(
          Jackson.unmarshaller(User.class), user -> complete(
            userService.updateUser(user)
          )
        )),
        delete(() -> parameter(
          "id", id -> complete(
            userService.deleteUser(Long.parseLong(id))
          )
        ))
      ))
    );
  }
  
}

2.3 Implementierung der Serviceschicht

Als nächstes müssen wir die Benutzerserviceschicht implementieren. Die Serviceschicht verarbeitet tatsächlich alle Anfragen und verwendet eine Speicherschicht (z. B. eine Datenbank) zur Verwaltung der Benutzerdaten. In diesem Beispiel verwenden wir eine einfache HashMap zum Speichern von Daten.

Hier ist der Code für unsere UserService-Klasse:

import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.atomic.AtomicLong;

public class UserService {

  private final Map<Long, User> users = new HashMap<>();
  private final AtomicLong counter = new AtomicLong();

  public User createUser(User user) {
    long id = counter.incrementAndGet();
    user.setId(id);
    users.put(id, user);
    return user;
  }

  public User updateUser(User user) {
    users.put(user.getId(), user);
    return user;
  }

  public User deleteUser(long id) {
    return users.remove(id);
  }

  public List<User> getUsers() {
    return new ArrayList<>(users.values());
  }

}

2.4 Starten des Dienstes

Da wir nun unseren Router und die Serviceschicht definiert haben, müssen wir unsere Anwendung starten. Für dieses Beispiel erstellen wir eine einfache Hauptmethode, die den Akka-HTTP-Server startet und eine Verbindung zum angegebenen Port herstellt.

Hier ist der Code für unsere Startup-Klasse:

import akka.actor.ActorSystem;
import akka.stream.ActorMaterializer;
import akka.http.javadsl.server.HttpApp;

public class Main extends HttpApp {

  private final UserService userService = new UserService();
  private final UserRouter userRouter = new UserRouter(userService);

  public static void main(String[] args) {
    Main main = new Main();
    main.startServer("localhost", 8080, ActorSystem.create(), ActorMaterializer.create());
  }

  @Override
  protected Route routes() {
    return userRouter.createRoute();
  }
  
}

3. Testen der API

Jetzt haben wir erfolgreich eine reaktive API basierend auf Akka HTTP erstellt und können eine Liste von Benutzern mithilfe verschiedener HTTP-Methoden verwalten. Testen wir unsere API mit einem Tool wie Postman und stellen wir sicher, dass sie ordnungsgemäß funktioniert.

GET-Methode: Benutzerliste abrufen

GET http://localhost:8080/users

POST-Methode: Neuen Benutzer erstellen

POST http://localhost:8080/users
Body: 
{
  "name": "John Smith",
  "email": "john.smith@example.com"
}

PUT-Methode: Vorhandenen Benutzer aktualisieren

PUT http://localhost:8080/users
Body: 
{
  "id": 1,
  "name": "John Smith",
  "email": "john.smith@example.com"
}

DELETE-Methode: Vorhandenen Benutzer löschen

DELETE http://localhost:8080/users?id=1

4. Zusammenfassung

Durch diesen Artikel haben wir gelernt wie man reaktive APIs mit Akka HTTP erstellt. Wir haben die Hauptvorteile des Frameworks kennengelernt, erfahren, wie man Router und Service-Layer erstellt und wie man sie startet. Wir stellen auch einige Beispiele für gängige HTTP-Methoden bereit, damit Sie Ihre API testen und verwenden können. Ich hoffe, dieser Artikel hilft Ihnen!

Das obige ist der detaillierte Inhalt vonJava-Backend-Entwicklung: Erstellen reaktiver APIs mit Akka HTTP. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!