Pattern ng disenyo ng pabrika

Kamusta, Kaibigan! Ngayon ay patuloy kaming mag-aaral ng mga pattern ng disenyo sa iyo. Sa panayam na ito ay pag-uusapan natin ang tungkol sa Pabrika. Tatalakayin namin sa iyo kung anong problema ang malulutas gamit ang template na ito, at tingnan ang isang halimbawa kung paano tumutulong ang isang pabrika sa pagbubukas ng coffee shop. At bibigyan din kita ng 5 simpleng hakbang para gumawa ng factory. Upang maging kaparehas ng lahat at madaling maunawaan ang esensya, dapat ay pamilyar ka sa mga sumusunod na paksa:

• Mana sa Java
• Pagpapaliit at pagpapalawak ng mga uri ng sanggunian sa Java
• Pakikipag-ugnayan sa pagitan ng iba't ibang klase at bagay

Ano ang isang Pabrika?

Ang pattern ng disenyo ng Pabrika ay nagpapahintulot sa iyo na kontrolin ang paglikha ng mga bagay. Ang proseso ng paglikha ng isang bagong bagay ay hindi ganoon kasimple, ngunit hindi rin ito masyadong kumplikado. Alam nating lahat na upang lumikha ng isang bagong bagay kailangan nating gamitin ang new. At maaaring mukhang walang dapat pamahalaan dito, ngunit hindi ito ganoon. Maaaring magkaroon ng mga kahirapan kapag ang aming aplikasyon ay may partikular na klase na maraming inapo, at kinakailangan na lumikha ng isang halimbawa ng isang partikular na klase depende sa ilang kundisyon. Ang pabrika ay isang pattern ng disenyo na tumutulong sa paglutas ng problema sa paglikha ng iba't ibang mga bagay depende sa ilang mga kundisyon. Abstract, hindi ba? Lalabas ang higit pang pagtitiyak at kalinawan kapag tiningnan natin ang halimbawa sa ibaba.

Gumagawa kami ng iba't ibang uri ng kape

Sabihin nating gusto nating i-automate ang isang coffee shop. Kailangan nating matutunan kung paano maghanda ng iba't ibang uri ng kape. Upang gawin ito, sa aming aplikasyon ay lilikha kami ng klase ng kape at mga derivatives nito: Americano, cappuccino, espresso, latte - mga uri ng kape na aming ihahanda. Magsimula tayo sa pangkalahatang klase ng kape:

public class Coffee {
    public void grindCoffee(){
        // перемалываем кофе
    }
    public void makeCoffee(){
        // делаем кофе
    }
    public void pourIntoCup(){
        // наливаем в чашку
    }
}

Susunod, likhain natin ang mga tagapagmana nito:

public class Americano extends Coffee {}
public class Cappuccino extends Coffee {}
public class CaffeLatte extends Coffee {}
public class Espresso extends Coffee {}

Ang aming mga customer ay mag-o-order ng ilang uri ng kape, at ang impormasyong ito ay kailangang maipasa sa programa. Magagawa ito sa iba't ibang paraan, halimbawa gamit ang String. Ngunit ito ay pinakaangkop para sa mga layuning ito enum. Gumawa tayo enumat tukuyin dito ang mga uri ng kape kung saan tumatanggap tayo ng mga order:

public enum CoffeeType {
    ESPRESSO,
    AMERICANO,
    CAFFE_LATTE,
    CAPPUCCINO
}

Mahusay, ngayon ay isulat natin ang code para sa aming coffee shop:

public class CoffeeShop {

    public Coffee orderCoffee(CoffeeType type) {
        Coffee coffee = null;

        switch (type) {
            case AMERICANO:
                coffee = new Americano();
                break;
            case ESPRESSO:
                coffee = new Espresso();
                break;
            case CAPPUCCINO:
                coffee = new Cappucсino();
                break;
            case CAFFE_LATTE:
                coffee = new CaffeLatte();
                break;
        }

        coffee.grindCoffee();
        coffee.makeCoffee();
        coffee.pourIntoCup();

        System.out.println("Вот ваш кофе! Спасибо, приходите еще!");
        return coffee;
    }
}

Ang pamamaraan orderCoffeeay maaaring nahahati sa dalawang bahagi:

1. Paglikha ng isang partikular na halimbawa ng kape sa isang bloke switch-case. Ito ay kung saan ang ginagawa ng Pabrika ay ang paglikha ng isang tiyak na uri depende sa mga kondisyon.
2. Ang paghahanda mismo ay paggiling, pagluluto at pagbuhos sa isang tasa.

Ano ang mahalagang malaman kung kailangan mong gumawa ng mga pagbabago sa pamamaraan sa hinaharap:

1. Ang algorithm ng paghahanda mismo (paggiling, pagluluto at pagbuhos sa isang tasa) ay mananatiling hindi magbabago (hindi bababa sa inaasahan namin ito).
2. Ngunit maaaring magbago ang hanay ng kape. Siguro magsisimula na tayong gumawa ng mocha.. Mocha.. Mokkachi... God bless him, a new type of coffee.

Maaari na nating ipagpalagay na sa hinaharap, na may tiyak na antas ng posibilidad, kailangan nating gumawa ng mga pagbabago sa pamamaraan, sa block switch-case. Posible rin na sa ating coffee shop ang pamamaraan orderCoffeeay hindi lamang ang lugar kung saan tayo gumagawa ng iba't ibang uri ng kape. Samakatuwid, ang mga pagbabago ay kailangang gawin sa ilang mga lugar. Malamang naiintindihan mo na kung ano ang kinukuha ko. Kailangan nating mag-refactor. Ilipat ang bloke na responsable sa paggawa ng kape sa isang hiwalay na klase para sa dalawang dahilan:

1. Magagawa naming muling gamitin ang lohika ng paglikha ng kape sa ibang mga lugar.
2. Kung magbabago ang hanay, hindi namin kailangang i-edit ang code saanman kung saan gagamitin ang paggawa ng kape. Ito ay sapat na upang baguhin ang code sa isang lugar lamang.

Sa madaling salita, oras na para putulin ang pabrika.

Naglalagari kami ng aming unang pabrika

Para magawa ito, gumawa tayo ng bagong klase na magiging responsable lang sa paglikha ng mga kinakailangang pagkakataon ng mga klase ng kape:

public class SimpleCoffeeFactory {
    public Coffee createCoffee (CoffeeType type) {
        Coffee coffee = null;

        switch (type) {
            case AMERICANO:
                coffee = new Americano();
                break;
            case ESPRESSO:
                coffee = new Espresso();
                break;
            case CAPPUCCINO:
                coffee = new Cappucino();
                break;
            case CAFFE_LATTE:
                coffee = new CaffeLatte();
                break;
        }

        return coffee;
    }
}

Binabati kita! Ipinatupad lang namin ang pattern ng disenyo ng Pabrika sa pinakasimpleng anyo nito. Kahit na ang lahat ay maaaring maging mas simple kung ang pamamaraan ay ginawang createCoffeestatic. Ngunit pagkatapos ay mawawalan tayo ng dalawang posibilidad:

1. Magmana mula sa SimpleCoffeeFactoryat i-override ang createCoffee.
2. Ipatupad ang kinakailangang pagpapatupad ng pabrika sa aming mga klase.

Nagsasalita ng pagpapatupad. Kailangan nating bumalik sa coffee shop at ipatupad ang pagawaan ng paggawa ng kape.

Pagpapakilala ng isang pabrika sa isang coffee shop

Isulat muli natin ang aming klase sa coffee shop gamit ang isang pabrika:

public class CoffeeShop {

    private final SimpleCoffeeFactory coffeeFactory;

    public CoffeeShop(SimpleCoffeeFactory coffeeFactory) {
        this.coffeeFactory = coffeeFactory;
    }

    public Coffee orderCoffee(CoffeeType type) {
        Coffee coffee = coffeeFactory.createCoffee(type);
        coffee.grindCoffee();
        coffee.makeCoffee();
        coffee.pourIntoCup();

        System.out.println("Вот ваш кофе! Спасибо, приходите еще!");
        return coffee;
    }
}

Malaki. Ngayon subukan nating ilarawan nang eskematiko at maigsi ang istraktura ng pattern ng disenyo ng Pabrika.

5 hakbang sa pagbubukas ng sarili mong pabrika

Hakbang 1. Sa iyong programa mayroon kang isang klase na may ilang mga inapo, tulad ng sa larawan sa ibaba: Hakbang 2. Lumikha ka ng isang klase enumkung saan mo tutukuyin ang isang enum variable para sa bawat descendant na klase:

enum CatType {
    LION,
    TIGER,
    BARSIK
}

Hakbang 3. Itatayo mo ang iyong pabrika. Tawagan mo ito MyClassFactory, ang code ay nasa ibaba:

class CatFactory {}

Hakbang 4. Gumawa ka ng paraan sa iyong pabrika createMyClassna kumukuha ng variable - enum MyClassType. Code sa ibaba:

class CatFactory {
    public Cat createCat(CatType type) {

    }
}

Hakbang 5. Sumulat ka ng isang bloke sa katawan ng pamamaraan switch-casekung saan umuulit ka sa lahat ng mga halaga ng enum at lumikha ng isang halimbawa ng klase na naaayon sa enumhalaga:

class CatFactory {
        public Cat createCat(CatType type) {
            Cat cat = null;

            switch (type) {
                case LION:
                    cat =  new Barsik();
                    break;
                case TIGER:
                    cat = new Tiger();
                    break;
                case BARSIK:
                    cat =  new Lion();
                    break;
            }

            return cat;
        }
    }

Parang boss.

Paano magsanay

Ang pagbabasa ay mabuti, ang pagsulat ng code ay mas mahusay. Kung ang iyong pangalan ay may pantay na bilang ng mga titik, subukang gumawa ng sarili mong virtual pizzeria. Kung ang iyong pangalan ay may kakaibang bilang ng mga titik, subukang gumawa ng virtual na sushi bar. Kung anonymous ka, maswerte ka. Ngayon ay maaari kang magpahinga.