Pembangunan Bahagian Belakang Java: Membina API Reaktif dengan Akka HTTP

Pengaturcaraan reaktif menjadi semakin penting dalam pembangunan web hari ini. Akka HTTP ialah rangka kerja HTTP berprestasi tinggi berdasarkan Akka, sesuai untuk membina API gaya REST reaktif. Artikel ini akan memperkenalkan cara menggunakan HTTP Akka untuk membina API reaktif, sambil memberikan beberapa contoh praktikal. Mari mulakan!

1. Mengapa memilih Akka HTTP

Apabila membangunkan API reaktif, adalah sangat penting untuk memilih rangka kerja yang betul. Akka HTTP ialah pilihan yang sangat baik kerana ia mempunyai kelebihan berikut:

1.1 Responsif dan tidak menyekat

Akka HTTP ialah rangka kerja yang sangat reaktif yang membolehkan anda mengendalikan sejumlah besar permintaan , tanpa menyekat permohonan anda. Ia menggunakan model Actor, yang bermaksud anda boleh menggunakan operasi tak segerak untuk membalas permintaan dengan cepat sambil memastikan aplikasi anda sangat berskala.

1.2 Prestasi Tinggi

Memandangkan ia dibina pada rangka kerja Akka, Akka HTTP mampu memberikan prestasi yang lebih pantas. Ini kerana ia dapat memanfaatkan sepenuhnya berbilang CPU dan teras dan sesuai untuk situasi di mana konkurensi tinggi digunakan.

1.3 Mudah untuk digunakan dan dikonfigurasikan

Akka HTTP sangat mudah untuk dikonfigurasi dan digunakan. Ia menyediakan satu set alat yang berkuasa yang membolehkan anda mengkonfigurasi dan mengurus API anda dengan cepat. Anda juga boleh menulis kod anda dalam Scala atau Java.

2. Membina API reaktif

Seterusnya, kami akan menunjukkan cara membina API reaktif menggunakan Akka HTTP. Kami akan mencipta API mudah untuk mengurus senarai pengguna.

2.1 Pemasangan dan Import

Untuk menggunakan Akka HTTP anda perlu menambah kebergantungan berikut:

<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>

Sila pastikan anda mempunyai kebergantungan ini dalam projek Maven atau Gradle anda.

2.2 Cipta Penghala

Kini kami akan mencipta penghala yang menerima permintaan HTTP yang berbeza dan memberikan respons yang sepadan. Kami akan menggunakan kelas Laluan yang disediakan oleh Akka HTTP untuk menentukan penghala kami dan menyediakan peraturan penghalaan yang sepadan.

Dalam contoh ini, kami akan mencipta laluan /User dengan kaedah GET, POST, PUT dan DELETE. Kaedah GET akan mengembalikan senarai pengguna, kaedah POST akan mencipta pengguna baharu, kaedah PUT akan mengemas kini pengguna, dan kaedah DELETE akan memadamkan pengguna.

Berikut ialah kod untuk penghala kami:

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 Melaksanakan lapisan perkhidmatan

Seterusnya, kita perlu melaksanakan lapisan perkhidmatan pengguna. Lapisan perkhidmatan sebenarnya akan mengendalikan semua permintaan dan menggunakan lapisan storan (seperti pangkalan data) untuk mengurus data pengguna. Dalam contoh ini, kami akan menggunakan HashMap mudah untuk menyimpan data.

Berikut ialah kod untuk kelas UserService kami:

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 Memulakan Perkhidmatan

Sekarang kami telah menetapkan penghala dan lapisan perkhidmatan kami, kami perlu memulakan aplikasi kami . Untuk contoh ini, kami akan mencipta kaedah utama mudah yang akan memulakan pelayan HTTP Akka dan menyambung ke port yang ditentukan.

Berikut ialah kod untuk kelas permulaan kami:

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. API Uji

Kini kami telah berjaya mencipta API tindak balas berasaskan HTTP Akka dan boleh gunakan kaedah HTTP yang berbeza untuk mengurus senarai pengguna. Mari uji API kami menggunakan alat seperti Posman dan pastikan ia berfungsi dengan betul.

Kaedah GET: Dapatkan senarai pengguna

GET http://localhost:8080/users

Kaedah POST: Cipta pengguna baharu

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

Kaedah PUT: Kemas kini pengguna sedia ada

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

Kaedah PADAM: Padam Sedia Ada Pengguna

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

4. Ringkasan

Melalui artikel ini, kami telah mempelajari cara membina API reaktif menggunakan Akka HTTP. Kami belajar tentang faedah utama rangka kerja, cara membuat penghala dan lapisan perkhidmatan, dan cara memulakannya. Kami juga menyediakan beberapa contoh kaedah HTTP biasa supaya anda boleh menguji dan menggunakan API anda. Harap artikel ini membantu anda!

Atas ialah kandungan terperinci Pembangunan Bahagian Belakang Java: Membina API Reaktif dengan Akka HTTP. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!