Menggunakan Guice untuk suntikan pergantungan dalam pembangunan API Java

Sebagai bahasa pengaturcaraan berorientasikan objek, Java sering melibatkan pembangunan antara muka API untuk pelbagai pelanggan semasa pembangunan. Apabila kod anda berkembang, mengurus sejumlah besar kebergantungan boleh menjadi menyusahkan. Satu pilihan ialah menggunakan rangka kerja suntikan kebergantungan untuk mengurus kebergantungan dalam kod anda, yang mana Guice ialah rangka kerja suntikan kebergantungan yang sangat popular.

Artikel ini akan memperkenalkan penggunaan Guice dalam pembangunan API Java dan menyediakan beberapa amalan terbaik untuk anda mula menggunakan Guice untuk menjadikan kod anda lebih boleh diuji dan diselenggara.

Pengenalan

Guice ialah rangka kerja suntikan pergantungan ringan sumber terbuka yang membolehkan pembangunan dan ujian pantas disebabkan reka bentuknya yang ringkas. Rangka kerja Guice pertama kali dikeluarkan oleh Google dan telah menjadi rangka kerja suntikan pergantungan yang digunakan secara meluas dalam kalangan pengaturcara Java.

Guice menyediakan mekanisme untuk memisahkan kebergantungan. Melalui suntikan pergantungan, Guice menjadikan kod lebih modular dan boleh diuji. Dalam corak suntikan kebergantungan, objek tidak bertanggungjawab untuk mencipta objek yang mereka bergantung. Sebaliknya, bekas bertanggungjawab untuk penciptaan dan pengurusan objek ini, dan menyuntik kebergantungan yang diperlukan ke dalam objek. Dengan cara ini, objek tidak lagi perlu berurusan dengan penciptaan dan pengurusan objek lain yang mereka berinteraksi, menjadikan kod lebih mudah dan lebih fleksibel.

Menggunakan Guice

Apabila menggunakan Guice, kita perlu mencipta objek Injector terlebih dahulu. Penyuntik bertanggungjawab untuk menyelesaikan kebergantungan dan membina objek, menggunakan Modul untuk mendaftarkan semua kebergantungan untuk disuntik.

Dalam contoh di bawah, modul yang dipanggil MyModule dicipta yang mengikat kelas bergantung kepada pelaksanaan konkrit yang sepatutnya mereka gunakan.

public class MyModule extends AbstractModule {
    @Override
    protected void configure() {
        bind(MyInterface.class).to(MyImplementation.class);
    }
}

Dalam kod di atas, kami mengikat MyInterface kepada MyImplementation.

Kemudian, kita perlu mencipta Injector dan menambah MyModule padanya:

Injector injector = Guice.createInjector(new MyModule());

Sekarang, kita boleh menggunakan Injector untuk mendapatkan instance MyInterface:

rreee

Sebuah konkrit pelaksanaan MyInterface Terpulang kepada Guice, tetapi kami boleh memastikan bahawa hanya satu contoh sahaja wujud dalam aplikasi.

Amalan Terbaik

Anda harus sentiasa mengikuti amalan terbaik berikut apabila menggunakan Guice:

1 Gunakan antara muka

Guice melaksanakan suntikan pergantungan, jadi anda harus Beri perhatian kepada gandingan longgar kod semasa melaksanakan. Menggunakan antara muka ialah cara terbaik untuk mencapai gandingan longgar. Ini meningkatkan kebolehujian dan kebolehubahsuaian kod.

2. Mengikat kepada kelas pelaksanaan

Dalam banyak kes, anda ingin mengikat antara muka kepada pelaksanaan konkrit. Dalam kes ini, adalah lebih baik untuk mengikat kepada pelaksanaan konkrit daripada antara muka itu sendiri. Contohnya, dalam kod berikut:

MyInterface myInterface = injector.getInstance(MyInterface.class);

Dalam contoh di atas, kami mengikat antara muka Enjin kepada pelaksanaan konkritnya DieselEngine. Ini menyebabkan kami menggunakan enjin DieselEngine semasa mencipta objek Kereta, dan bukannya pelaksanaan lain.

3. Menggunakan Pembekal

Dalam sesetengah kes, kita perlu melakukan operasi tertentu sebelum membina objek. Dalam kes ini, lebih baik menggunakan Pembekal.

public interface Engine {
    void start();
    void stop();
}

public class Car {
    private Engine engine;
    
    @Inject
    public Car(Engine engine) {
        this.engine = engine;
    }
}

public class DieselEngine implements Engine {
    @Override
    public void start() {
        System.out.println("The diesel engine started.");
    }
    
    @Override
    public void stop() {
        System.out.println("The diesel engine stopped.");
    }
}

public class PetrolEngine implements Engine {
    @Override
    public void start() {
        System.out.println("The petrol engine started.");
    }
    
    @Override
    public void stop() {
        System.out.println("The petrol engine stopped.");
    }
}

public class MyModule extends AbstractModule {
    @Override
    protected void configure() {
        bind(Engine.class).to(DieselEngine.class);
    }
}

Dalam contoh di atas, kami mula-mula mentakrifkan kelas Konfigurasi yang boleh membaca dan mengembalikan sifat yang berkaitan dengannya. Kemudian, kami mencipta kelas MyProvider, yang mewarisi antara muka Penyedia dan bertanggungjawab untuk mendapatkan objek Konfigurasi daripada fail konfigurasi. Akhir sekali, kami mengikat kelas Konfigurasi kepada MyProvider untuk digunakan dalam aplikasi. Dalam kes ini, Guice memanggil kaedah get() untuk mendapatkan contoh baharu setiap kali Konfigurasi diperlukan.

Kesimpulan

Guice ialah rangka kerja suntikan pergantungan yang sangat berkuasa, menggunakannya boleh menjadikan kod lebih boleh diuji dan diselenggara. Artikel ini memperkenalkan penggunaan asas Guice dan menyediakan beberapa amalan terbaik untuk membantu pembangun menggunakan Guice dengan lebih baik. Saya harap artikel ini dapat membantu anda lebih memahami penggunaan Guice.

Atas ialah kandungan terperinci Menggunakan Guice untuk suntikan pergantungan dalam pembangunan API Java. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!