Bagaimana untuk memisahkan Kaedah Kilang daripada Ketergantungan Berlebihan menggunakan Suntikan Ketergantungan dan Corak Strategi?

Urus pergantungan berlebihan dalam kaedah kilang menggunakan suntikan pergantungan dan penyongsangan kawalan

Menyepadukan corak Kaedah Kilang dalam seni bina perisian adalah amalan biasa tetapi boleh menjadi mencabar apabila berurusan dengan sejumlah besar kebergantungan. Artikel ini meneroka alternatif yang mengatasi had ini sambil mematuhi prinsip Suntikan Ketergantungan (DI) dan Penyongsangan Kawalan (IoC).

Masalah dengan kaedah kilang tradisional

Pelaksanaan kaedah kilang tradisional biasanya menggunakan penyataan kes suis untuk mengendalikan pelbagai jenis kereta, setiap satu memerlukan set kebergantungan sendiri. Pendekatan ini boleh menjadi sukar dan sukar untuk dikekalkan apabila berurusan dengan sejumlah besar jenis kereta, kerana ia menyebabkan pertindihan dan menjadikan penambahan jenis kereta baharu lebih sukar.

Mod Strategi dan Kilang Bebas

Penyelesaian yang lebih cekap terletak pada penggunaan corak Strategi dengan kilang yang berdiri sendiri. Dengan menggantikan logik kes suis dengan objek strategi, kami boleh merungkai penciptaan kilang dan isu suntikan pergantungan. Ini membolehkan setiap kilang bertanggungjawab untuk mencipta jenis kereta tertentu dan hanya memasukkan kebergantungan yang diperlukan untuk jenis itu.

Objek strategi bertindak sebagai penyelaras, menentukan kilang mana yang patut digunakan berdasarkan jenis kereta. Dengan menggunakan DI, objek strategi boleh menyuntik semua kilang yang diperlukan, membolehkannya mencipta sebarang jenis kereta tanpa terus bergantung pada kilang kereta tertentu.

Contoh pelaksanaan

Berikut ialah contoh pelaksanaan pendekatan ini:

<code>// 定义工厂和策略组件的接口
public interface ICarFactory
{
    ICar CreateCar();
    bool AppliesTo(Type type);
}

public interface ICarStrategy
{
    ICar CreateCar(Type type);
}

// 为每种类型的汽车实现工厂
public class Car1Factory : ICarFactory
{
    private readonly IDep1 dep1;
    private readonly IDep2 dep2;
    private readonly IDep3 dep3;

    // 将依赖项注入工厂构造函数
    public Car1Factory(IDep1 dep1, IDep2 dep2, IDep3 dep3)
    {
        ...
    }

    public ICar CreateCar()
    {
        return new Car1(dep1, dep2, dep3);
    }

    public bool AppliesTo(Type type)
    {
        return typeof(Car1).Equals(type);
    }
}

// 实现策略类
public class CarStrategy : ICarStrategy
{
    private readonly ICarFactory[] carFactories;

    // 将所有可用的工厂注入策略构造函数
    public CarStrategy(ICarFactory[] carFactories)
    {
        this.carFactories = carFactories;
    }

    public ICar CreateCar(Type type)
    {
        var factory = carFactories.FirstOrDefault(f => f.AppliesTo(type));
        if (factory == null)
            throw new InvalidOperationException("未找到指定类型的工厂");

        return factory.CreateCar();
    }
}

// 用法：创建策略对象并使用它来创建不同类型的汽车
var strategy = new CarStrategy(new ICarFactory[] 
{
    new Car1Factory(...),
    new Car2Factory(...)
});

var car1 = strategy.CreateCar(typeof(Car1));
var car2 = strategy.CreateCar(typeof(Car2));</code>

Kelebihan

Kaedah ini mempunyai kelebihan berikut:

• Kurangkan pertindihan: Tidak memerlukan penyataan kes suis dan kebergantungan pendua di seluruh kilang.
• Fleksibel: Jenis kereta baharu boleh ditambah dengan mudah dengan mendaftarkan kilang baharu dengan polisi.
• Kebolehujian: Kilang yang berasingan membenarkan ujian unit tanpa perlu mencipta konteks olok-olok untuk semua kebergantungan.
• Pengasingan kebimbangan: Mengasingkan penciptaan kilang daripada suntikan pergantungan, meningkatkan kebolehselenggaraan kod.

Dengan memanfaatkan Corak Strategi dan DI, kami melaksanakan penyelesaian yang ringkas dan berskala untuk menguruskan kebergantungan berlebihan dalam kaedah kilang sambil mematuhi prinsip suntikan kebergantungan dan penyongsangan kawalan.

Atas ialah kandungan terperinci Bagaimana untuk memisahkan Kaedah Kilang daripada Ketergantungan Berlebihan menggunakan Suntikan Ketergantungan dan Corak Strategi?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!