Apa itu Simple Factory?

Kilang yang ringkas bukan corak rekaan. Ia hanya memisahkan penciptaan objek daripada kod klien. Dalam erti kata lain, kilang Simple merangkum instantiasi objek dengan mengalihkan logik instantiasi ke kelas yang berasingan.

Kilang mudah sering dikelirukan dengan Corak Kilang. Kami akan mengkaji kilang Mudah untuk menjelaskan perbezaan mereka. Selain itu, mempelajari kilang Mudah membantu kami memahami corak Kilang dengan mudah.

Apakah masalah yang boleh diselesaikan oleh kilang mudah?

Pengaturcaraan kepada pelaksanaan konkrit harus dielakkan kerana ia menjadikan aplikasi sangat sukar untuk diselenggara. Ia sentiasa lebih baik untuk memprogramkan antara muka. Jika anda membuat contoh kelas konkrit dalam kod pelanggan, maka kilang Simple amat berguna kerana kilang Mudah boleh memisahkan penciptaan objek daripada pelanggan. Ini menjadikan aplikasi kami lebih meluas dan boleh diselenggara.

Masalah

Kami sedang membangunkan sistem untuk kedai Burger. Sistem perlu mencipta pelbagai burger seperti burger daging lembu, burger ayam dan sebagainya.

Percubaan pertama kami adalah seperti ini:

// Client orders a burger
Burger orderBurger(String type) {
    Burger burger;

    if (type.equals("beef")) {
        burger = new BeefBurger();
    } else if (type.equals("chicken")) {
        burger = new ChickenBurger();
    } else if (type.equals("fish")) {
        burger = new FishBurger();
    }

    burger.prepareBun();
    burger.grillPatty();
    burger.addToppings();
    burger.wrap();

    return burger;
}

Masalahnya, kami mengekod kepada pelaksanaan bukan untuk antara muka. di mana? Kami menggunakan pernyataan if dan membuat instantiate kelas konkrit berdasarkan jenis burger.
Mengapa ia menjadi masalah? Kod pelanggan kami digandingkan rapat dengan penciptaan objek, menyebabkan kurang fleksibiliti!! Katakan jika kita tidak menjual burger ikan lagi, dan mula menjual burger sayuran. Kami perlu melawati kod pelanggan kami dan mengubah suainya. Maksudnya, ia tidak ditutup untuk pengubahsuaian.

Penyelesaian

Untuk menyelesaikan masalah, kami boleh mencipta kelas berasingan yang akan bertanggungjawab hanya untuk penciptaan objek. Kemudian kod pelanggan kami tidak perlu risau tentang penciptaan objek dan boleh bergantung pada abstraksi. Teknik ini dikenali sebagai "Encapsulate what varies". Kami menjangkakan kod tentang membuat seketika objek konkrit akan ditukar dengan kerap, manakala proses prepareBun(), grillPatty(), addToppings(), wrap() berkemungkinan kekal sama antara semua burger pada masa hadapan.
Kelebihan kilang Simple ialah ia boleh digunakan semula oleh kelas lain. Kami mungkin mempunyai kelas pelanggan lain seperti BurgerRestaurant, BurgerCateringShop yang akan menggunakan kaedah SimpleBurgerFactory.createBurger().

1. Pelanggan
   Pelanggan membuat instantiate objek burger tertentu melalui SimpleBurgerFactory. Perhatikan dari perspektif pelanggan, kita tidak tahu burger konkrit mana yang akan dicipta, iaitu logik penciptaan objek kini dipisahkan daripada pelanggan.

2. SimpleBurgerFactory
   Kelas ini merangkumi apa yang berbeza yang dalam kes ini, logik penciptaan objek! createBurger() diisytiharkan sebagai kaedah statik kerana pelanggan ingin menggunakan kelas ini untuk membuat instantiate objek (sudah tentu kita tidak boleh mempunyai contoh sebelum membuat instantiat!). createBurger() menerima BurgerType enum untuk menentukan jenis burger yang perlu dibuat.

3. Burger
   Kelas abstrak ini menyediakan antara muka biasa antara semua burger dan mentakrifkan gelagat lalai.

4. Subkelas burger
   Berikut adalah produk konkrit kami. Mereka boleh melaksanakan tingkah laku tertentu dengan mengatasi kaedah selagi mereka melanjutkan kelas Burger.

Struktur

Kod

// Client orders a burger
Burger orderBurger(String type) {
    Burger burger;

    if (type.equals("beef")) {
        burger = new BeefBurger();
    } else if (type.equals("chicken")) {
        burger = new ChickenBurger();
    } else if (type.equals("fish")) {
        burger = new FishBurger();
    }

    burger.prepareBun();
    burger.grillPatty();
    burger.addToppings();
    burger.wrap();

    return burger;
}

public enum BurgerType {
    BEEF,
    CHICKEN,
    FISH,
    VEGGIE
}

// Abstract Product
public abstract class Burger {

    public BurgerType burgerType;
    public List<String> toppings = new ArrayList<>();

    public void prepareBun() {
        System.out.println("Preparing a bun");
    }

    public void grillPatty() {
        if (burgerType == null) {
            throw new IllegalStateException("pattyType is undefined");
        }
        System.out.println("Grill a " + burgerType + " patty");
    }

    public void addToppings() {
        for (String item : toppings) {
            System.out.println("Add " + item);
        }
    }

    public void wrap() {
        System.out.println("Wrap a burger up");
    }
}

// Concrete product
public class BeefBurger extends Burger {

    public BeefBurger() {
        burgerType = BurgerType.BEEF;
        List<String> items = List.of("lettuce", "pickle slices", "tomato slice", "BBQ sauce");
        toppings.addAll(items);
    }
}

// Concrete product
public class VeggieBurger extends Burger {

    public VeggieBurger() {
        burgerType = BurgerType.VEGGIE;
        List<String> items = List.of("smoked paprika", "garlic chips", "crushed walnuts", "veggie sauce");
        toppings.addAll(items);
    }

    // Concrete product can implement specific behavior that differs from other products
    @Override
    public void wrap() {
        System.out.println("Wrapping paper shouldn't print any meats but vegetables");
    }
}

// Simple factory, responsible for instantiating an object
public class SimpleBurgerFactory {

    public static Burger createBurger(BurgerType type) {
        return switch (type) {
            case BEEF -> new BeefBurger();
            case CHICKEN -> new ChickenBurger();
            case FISH -> new FishBurger();
            case VEGGIE -> new VeggieBurger();
            default -> throw new IllegalArgumentException("unknown burger type");
        };
    }
}

Output:

public class Client {

    public static void main(String[] args) {
        Burger burger = orderBurger(BurgerType.VEGGIE);
        System.out.println(burger); // Check if the object is actually veggie burger
    }

    public static Burger orderBurger(BurgerType type) {
        // Factory is responsible for object creation
        Burger burger = SimpleBurgerFactory.createBurger(type);

        burger.prepareBun();
        burger.grillPatty();
        burger.addToppings();
        burger.wrap();

        return burger;
    }
}

Perangkap

• Kod membuat keputusan untuk instantiasi objek boleh menjadi lebih kompleks kadangkala. Dalam kes sedemikian, kami juga boleh mempertimbangkan untuk menggunakan kaedah Kilang.

Perbandingan dengan Corak Kilang

• Di kilang Simple, biasanya terdapat satu kelas kilang untuk menentukan jenis produk yang hendak dibuat, manakala corak Kilang mungkin memperkenalkan beberapa kilang.
• Kilang ringkas sering menggunakan kaedah statik untuk mencipta objek, yang menjadikannya mudah untuk dipanggil tetapi sukar untuk dilanjutkan. Sebaliknya, kaedah Kilang menggunakan kaedah abstrak dalam kelas super, yang bertindak sebagai antara muka untuk semua kilang dan subkelas akan menyediakan pelaksanaan konkrit untuk instantiasi objek.

Anda boleh menyemak semua pelaksanaan corak reka bentuk di sini.
Repositori GitHub

P.S.
Saya baru menulis blog teknologi, jika anda mempunyai nasihat untuk menambah baik penulisan saya, atau mempunyai sebarang perkara yang mengelirukan, sila tinggalkan komen!
Terima kasih kerana membaca :)

Atas ialah kandungan terperinci Kilang Mudah. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!