Bercakap secara ringkas tentang prinsip suntikan pergantungan dalam VSCode

Artikel ini akan memberi anda analisis ringkas tentang prinsip suntikan kebergantungan dalam VSCode. Bagaimana untuk melakukan suntikan pergantungan? Semoga ia membantu semua orang!

Team sudah lama melaksanakan "Dependency Injection" tetapi setiap kali saya menggunakannya, ada banyak konsep yang saya selalu tidak faham : id perkhidmatan, simbol penerangan perkhidmatan, penghias perkhidmatan, dsb.

Mungkin kerana saya tidak memahami prinsipnya, dan rasanya “maya” apabila menggunakannya Baru-baru ini, saya cuba menjelaskan prinsip dengan membaca kod sumber Kod VS dan artikel yang dikongsi oleh pasukan. pemimpin. Inilah yang saya lakukan Pengenalan ringkas kepada logik teras.

Apakah yang dilakukan oleh suntikan pergantungan

Andaikan situasi berikut:

• Modul perkhidmatan A, bergantung pada perkhidmatan B

• Modul perkhidmatan B;

• Ciri modul fungsi, bergantung pada perkhidmatan A dan B

Mengikut kaedah penulisan biasa, ia adalah:

class B {}

class A {
    constructor() {
        // 在 A 的构造器中 new B
        this.b = new B();
    }
}

class Feature {
    constructor() {
        this.a = new A();
        this.b = new B();
    }
}

// 使用时
const feature = new Feature();

Kodnya mudah dan jelas, tetapi terdapat beberapa masalah sebagai contoh: jika A dan B Ciri itu bergantung kepada keperluan untuk sama contoh, kaedah penulisan di atas akan memulakan dua kejadian B. [Pembelajaran yang disyorkan:

Tutorial vscode, Pengajaran pengaturcaraan]

Pengubahsuaian mudah:

class A {
    constructor(b: B) {
        this.b = b;
    }
}

class Feature {
    constructor(a, b) {
        this.a = a;
        this.b = b;
    }
}

// 使用时
const b = new B();
const a = new A(b);
const feature = new Feature(a, b);

Apabila modul dimulakan, pertama Cipta luaran modul yang bergantung padanya dan menghantarnya ke dalam modul fungsi dalam bentuk parameter. Cara penulisan ini ialah "

Suntikan Ketergantungan".

Masalah dengan cara penulisan ini sekarang ialah dalam bentuk pemindahan parameter manual, susunan baharu mesti dipastikan secara manual, iaitu contoh a dan b mesti diperoleh sebelum baharu boleh dilaksanakan. Ciri.

Apabila kebergantungan menjadi rumit, kemungkinan besar modul asas yang tidak terkira banyaknya diperlukan sebelum mencipta modul berfungsi, dan kerumitannya akan menjadi sangat tinggi. Rasanya serupa dengan ini:

Bayangkan corak: terdapat pengawal modul atau "pengurus perkhidmatan" untuk menguruskan kebergantungan ini:

class Feature {
    // 声明这个模块依赖 idA, idB
    idA
    idB
}

// 告知「服务管理器」，怎么找对应的模块
services[idA] = A;
services[idB] = B;

// 使用时
const feature = services.createInstance(Feature);

Bukankah perkhidmatan ini membawa proses "manual" sebelumnya?

Apabila menciptaInstance(Ciri), analisa modul yang digantung oleh Ciri:

• Jika modul bergantung masih belum mencipta tika, buat contoh perkhidmatan secara rekursif dan akhirnya kembali

• Jika modul yang bergantung padanya sudah mempunyai contoh, kembalikan contoh itu; ;

  VSCode melaksanakan "sistem suntikan kebergantungan" seperti itu.

• 
  Bagaimana cara melakukan suntikan pergantungan?

Untuk melaksanakan set fungsi sedemikian, kira-kira anda memerlukan:

Bagaimanakah kelas mengisytiharkan id perkhidmatan yang bergantung padanya, iaitu, diberikan kelas, bagaimana orang luar tahu perkhidmatan apa yang dia harapkan?

• Bagaimana untuk menguruskan perkhidmatan pengurusan?

• Bagaimana untuk mencipta modul?

• Yang berikut akan melaksanakan model paling mudah, meliputi proses utama.

Tambah maklumat pergantungan

Bagaimana untuk menjenamakan kelas dan mengisytiharkan perkhidmatan yang bergantung padanya?

Abstrak masalah sekali lagi: Bagaimana untuk menambah maklumat tambahan pada kelas?

Malah, setiap kelas ialah Fungsi di bawah es5, dan setiap Fungsi hanyalah Objek dalam analisis akhir Selagi anda menambah beberapa medan pada Objek untuk mengenal pasti ID perkhidmatan yang diperlukan, anda boleh melengkapkan apa yang anda perlukan.

Ini boleh dilakukan dengan mudah dengan menulis "Penghias Parameter":
Dengan cara ini, ia boleh diperolehi melalui Feature (yang akan dipanggil ctor constructor kemudian) serviceId.

Pengurusan perkhidmatan

// 参数装饰器 
const decorator = (
    target: Object, // 被装饰的目标，这里为 Feature
    propertyName: string, 
    index: number // 参数的位置索引
) => {
    target['deps'] = [{        index,        id: 'idA',    }];
}
class Feature {
    name = 'feature';
    a: any;
    constructor(
        // 参数装饰器
        @decorator a: any,
    ) {
        this.a = a;
    }
}
console.log('Feature.deps', Feature['deps']);
// [{ id: 'idA', index: 0 }]

Gunakan Peta untuk pengurusan, satu id sepadan dengan satu ktor perkhidmatan.

Rajah skematik adalah seperti berikut:

class A {
    name = 'a';
}

// 服务集
class ServiceCollection {
    // 服务集合
    // key 为服务标识
    // value 为 服务ctor
    private entries = new Map<string, any>();

    set(id: string, ctor: any) {
        this.entries.set(id, ctor);   
    }

    get(id: string): any {
        return this.entries.get(id);
    }
}

const services = new ServiceCollection();

// 声明服务 A id 为 idA
services.set(&#39;idA&#39;, A);

Kini, anda boleh mencari pembina perkhidmatan bergantung melalui Ciri

Penciptaan modul

// 通过 Feature 找到所依赖的 A
const serviceId = Feature['deps'][0].id; // idA
console.log(
    'Feature.deps', 
    services.get(serviceId) // A
);

Idea khusus ialah:

Jika modul bergantung masih belum mencipta contoh, buat contoh perkhidmatan secara rekursif . Akhirnya kembali;

• Jika modul yang bergantung padanya sudah mempunyai contoh, kembalikan contoh; parameter untuk melengkapkan permulaan;

• Berikut ialah demo mudah, dengan hanya satu lapisan kebergantungan (iaitu, perkhidmatan bergantung tidak bergantung pada perkhidmatan lain). tiada keupayaan rekursi:

Pada ketika ini, proses teras suntikan pergantungan telah dilaksanakan Apabila anda ingin menggunakan Ciri, anda hanya perlu memanggil createInstance, tidak kira sama ada perkhidmatan itu bergantung on telah dimulakan.

• Ringkasan

  Artikel ini hanya melaksanakan model "suntikan kebergantungan" peringkat demo dan hanya melaksanakan:

  • Apa yang diperlukan untuk perisytiharan modul Ketergantungan; anda boleh Kembangkan beberapa fungsi lanjutan:

  • Penciptaan modul (rekursif): VSCode menggunakan tindanan + graf untuk melakukan ini, dan algoritmanya tidak rumit;

    Pengumpulan kebergantungan: boleh digunakan untuk menganalisis kebergantungan setiap modul dan boleh mengesan sama ada terdapat "kebergantungan kitaran"

  • Kemusnahan modul: apabila modul dimusnahkan, ia secara rekursif memusnahkan semua perkara yang bergantung padanya 🎜>

  Kebergantungan tak segerak: Cara melaksanakan logik penciptaan apabila proses penciptaan perkhidmatan bergantung adalah tak segerak; 🎜> Lihat kod artikel ini di sini.

  Fungsi lengkap
  • Rujuk kod yang ditulis oleh VSCode untuk keseluruhan sistem suntikan pergantungan Untuk maklumat lanjut, lihat di sini.
    Bahan rujukan
  • Lokasi kod sumber Kod VS: src/vs/platform/instantiation/common

    Artikel ini menggunakan idea kod, dan penamaan juga sangat konsisten (kepala anjing manual

  Untuk pengetahuan lanjut tentang VSCode, sila lawati:
  • tutorial vscode

    !

Atas ialah kandungan terperinci Bercakap secara ringkas tentang prinsip suntikan pergantungan dalam VSCode. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!