Menggunakan Feign untuk membuat panggilan HTTP dalam pembangunan API Java

Gunakan Feign untuk membuat panggilan HTTP dalam pembangunan API Java

Dalam pembangunan aplikasi Java, panggilan HTTP sering dibuat untuk mendapatkan data daripada perkhidmatan luaran atau memanggil API jauh. Pada masa ini, kami biasanya perlu memilih perpustakaan klien HTTP untuk mengendalikan permintaan ini. Dalam bidang ini, Feign sudah pasti pilihan yang baik.

Feign ialah perpustakaan klien HTTP pengisytiharan yang memudahkan panggilan API RESTful. Ia diilhamkan oleh gaya anotasi Retrofit. Dengan menggunakan Feign, pembangun boleh membuat permintaan HTTP dengan mudah tanpa mengetahui butiran pelaksanaan klien HTTP yang mendasari.

Dalam artikel ini, kami akan memperkenalkan penggunaan asas dan beberapa contoh cara menggunakan Feign untuk membuat panggilan HTTP. Sebelum kita mula, kita perlu mengimport perpustakaan Feign. Dalam projek Maven, kami boleh menambah kebergantungan berikut dalam fail pom.xml:

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-openfeign</artifactId>
    <version>2.2.2.RELEASE</version>
</dependency>

Seterusnya, kami akan menerangkan penggunaannya.

Penggunaan asas

Pertama, kita perlu menentukan antara muka perkhidmatan jauh. Antara muka ini harus mengandungi kaedah untuk setiap titik akhir HTTP yang ingin kami panggil. Untuk setiap kaedah, kami boleh menggunakan anotasi yang disediakan oleh Feign untuk menentukan pelbagai aspek permintaan HTTP yang ingin kami hantar, seperti URL, kaedah HTTP, badan permintaan, pengepala permintaan, dsb. Kod sampel adalah seperti berikut:

@FeignClient(name = "github", url = "https://api.github.com")
public interface GitHubApiClient {
    @RequestMapping(value = "/users/{username}", method = RequestMethod.GET)
    GitHubUser getUserByName(@PathVariable("username") String username);
}

Dalam contoh ini, kami mentakrifkan antara muka klien Feign GitHubApiClient, yang menggunakan anotasi @FeignClient untuk berinteraksi dengan perkhidmatan jauh bernama "github", dan URL perkhidmatan ialah https: //api.github.com. Terdapat kaedah getUserByName dalam antara muka. Pada kaedah ini, kami menggunakan anotasi @RequestMapping dan @PathVariable untuk menentukan URL dan parameter laluan permintaan HTTP GET yang ingin kami hantar.

Seterusnya, kami boleh menyuntik antara muka ke dalam kod kami dan membuat permintaan HTTP dengan memanggil kaedahnya. Kod sampel adalah seperti berikut:

@RestController
public class GitHubUserController {
    @Autowired
    private GitHubApiClient gitHubApiClient;

    @GetMapping("/users/{username}")
    public GitHubUser getUserByName(@PathVariable("username") String username) {
        return gitHubApiClient.getUserByName(username);
    }
}

Dalam contoh ini, kami menyuntik GitHubApiClient ke dalam GitHubUserController dan menggunakan antara muka ini dalam kaedah getUserByName untuk mendapatkan maklumat pengguna GitHub. Kaedah ini akan mengembalikan objek tindak balas yang dikembalikan oleh Feign. Dalam kes ini, kelas konkrit ialah GitHubUser.

Konfigurasi Feign Tersuai

Kadangkala, kita perlu menyesuaikan gelagat Feign. Sebagai contoh, kita mungkin perlu menambah pemintas permintaan, menukar tamat masa atau menukar tahap log. Dalam kes ini, kami boleh menambah konfigurasi yang sepadan untuk melaksanakan gelagat tersuai ini.

Untuk mengkonfigurasi Feign, kami boleh menggunakan anotasi @ConfigurationProperties dan @Bean yang disediakan oleh Spring Cloud untuk menentukan kelas konfigurasi kami. Berikut ialah contoh mengkonfigurasi Feign:

@ConfigurationProperties("feign.client.config.github")
public class GitHubFeignConfiguration {
    @Bean
    public RequestInterceptor requestInterceptor() {
        return new BasicAuthRequestInterceptor("username", "password");
    }
}

Dalam contoh ini, kami menambah pemintas permintaan menggunakan kelas BasicAuthRequestInterceptor Feign. Selain itu, kami menggunakan anotasi @ConfigurationProperties untuk memetakan konfigurasi tersuai kami dengan sifat dalam fail sifat.

Untuk menyambungkan konfigurasi ini dengan antara muka klien Feign kami, kami perlu menggunakan anotasi @Configuration dan @Import padanya. Kod sampel adalah seperti berikut:

@Configuration
@Import({GitHubFeignConfiguration.class})
public class GitHubApiConfiguration {
    @Bean
    public GitHubApiClient gitHubApiClient() {
        return Feign.builder()
                .decoder(new JacksonDecoder())
                .encoder(new JacksonEncoder())
                .contract(new SpringMvcContract())
                .target(GitHubApiClient.class, "https://api.github.com");
    }
}

Dalam contoh ini, kami menggunakan corak pembina Feign untuk mencipta objek GitHubApiClient. Pada kaedah bina(), kami mentakrifkan pengekod, penyahkod dan kontrak untuk objek klien Feign yang dikembalikan. Selain itu, kami menetapkan alamat sasaran jenis GitHubApiClient kepada https://api.github.com.

Ringkasan

Dalam artikel ini, kami memperkenalkan penggunaan perpustakaan klien Feign dan beberapa contoh. Dengan menggunakan Feign, kami boleh membuat panggilan HTTP dengan mudah dengan cara deklaratif. Dalam pembangunan harian, kami boleh menyesuaikan tingkah laku Feign mengikut keperluan perniagaan tertentu. Jika anda belum menggunakan Feign untuk pembangunan, anda juga boleh mencubanya. Saya percaya ia akan memberikan anda pengalaman pembangunan yang lebih mudah dan cekap.

Atas ialah kandungan terperinci Menggunakan Feign untuk membuat panggilan HTTP dalam pembangunan API Java. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!