Jest to prosty przykład dynamicznego dodawania nowego zachowania do istniejącego obiektu lub wzorca dekoratora. Ze względu na naturę dynamicznych języków, takich jak Javascript, wzorzec ten staje się częścią samego języka.

// create a message object
var message = {
    text: "Lorem ipsum dolor sit amet, consectetur adipisicing elit..."
};

// add logging behavior to the message object dynamically
message.log = function() {
    console.log(this.text);
};

// use the newly added behavior to log text
​message.log();​ // Loren ipsum...​​​​​​​​​​​​​​​

Warto zauważyć, że model we/wy Java bazuje na wzorze dekoratora. Warstwę tego czytelnika na wierzchu tego czytelnika na wierzchu of...is prawdziwy przykład dekoratora.

Przykład-scenariusz-powiedzmy, że piszesz moduł szyfrujący. To szyfrowanie może zaszyfrować czysty plik za pomocą standardu szyfrowania DES - Data. Podobnie, w systemie możesz mieć szyfrowanie jako AES-Advance encryption standard. Możesz również mieć kombinację szyfrowania - najpierw DES, a następnie AES. Albo najpierw AES, potem DES.

Dyskusja - jak poradzisz sobie z tą sytuacją? Nie można dalej tworzyć obiektu takich kombinacji - na przykład-AES i DES - łącznie 4 kombinacje. W związku z tym musisz mieć 4 pojedyncze obiekty, które staną się złożone wraz ze wzrostem typu szyfrowania.

Rozwiązanie-budować kombinacje stosu w zależności od potrzeb - w czasie pracy. Kolejną zaletą tego podejścia stosu jest to, że można go łatwo rozluźnić.

Oto rozwiązanie-w C++.

Po pierwsze, potrzebujesz klasy bazowej-podstawowej jednostki stosu. Możesz myśleć jak podstawa stosu. W tym przykładzie jest jasne plik. Podążajmy zawsze za polimorfizmem. Stwórz najpierw klasę interfejsu tej podstawowej jednostki. W ten sposób można go wdrożyć, jak chcesz. Ponadto nie musisz myśleć o zależności, włączając w to tę podstawową jednostkę.

Oto Klasa interfejsu -

class IclearData
{
public:

    virtual std::string getData() = 0;
    virtual ~IclearData() = 0;
};

IclearData::~IclearData()
{
    std::cout<<"Destructor called of IclearData"<<std::endl;
}

Teraz zaimplementuj tę klasę interfejsu -

class clearData:public IclearData
{
private:

    std::string m_data;

    clearData();

    void setData(std::string data)
        {
            m_data = data;
        }

public:

    std::string getData()
    {
        return m_data;
    }

    clearData(std::string data)
    {
        setData(data);
    }

    ~clearData()
    {
        std::cout<<"Destructor of clear Data Invoked"<<std::endl;
    }

};

Teraz zróbmy klasę abstrakcyjną dekoratora-która może być rozszerzona o tworzenie dowolnego rodzaju smaków - tutaj smak jest typem szyfrowania. Ten dekorator klasa abstrakcyjna jest powiązana z klasą bazową. Tak więc dekorator "jest" rodzajem klasy interfejsu. Dlatego musisz użyć dziedziczenia.

class encryptionDecorator: public IclearData
{

protected:
    IclearData *p_mclearData;

    encryptionDecorator()
    {
      std::cout<<"Encryption Decorator Abstract class called"<<std::endl;
    }

public:

    std::string getData()
    {
        return p_mclearData->getData();
    }

    encryptionDecorator(IclearData *clearData)
    {
        p_mclearData = clearData;
    }

    virtual std::string showDecryptedData() = 0;

    virtual ~encryptionDecorator() = 0;

};

encryptionDecorator::~encryptionDecorator()
{
    std::cout<<"Encryption Decorator Destructor called"<<std::endl;
}

Teraz zróbmy klasę dekoratora betonu - Typ szyfrowania-AES -

const std::string aesEncrypt = "AES Encrypted ";

class aes: public encryptionDecorator
{

private:

    std::string m_aesData;

    aes();

public:

    aes(IclearData *pClearData): m_aesData(aesEncrypt)
    {
        p_mclearData = pClearData;
        m_aesData.append(p_mclearData->getData());
    }

    std::string getData()
        {
            return m_aesData;
        }

    std::string showDecryptedData(void)
    {
        m_aesData.erase(0,m_aesData.length());
        return m_aesData;
    }

};

Powiedzmy, że typem dekoratora jest DES-

Const std:: string desEncrypt = "des Encrypted";

class des: public encryptionDecorator
{

private:

    std::string m_desData;

    des();

public:

    des(IclearData *pClearData): m_desData(desEncrypt)
    {
        p_mclearData = pClearData;
        m_desData.append(p_mclearData->getData());
    }

    std::string getData(void)
        {
            return m_desData;
        }

    std::string showDecryptedData(void)
    {
        m_desData.erase(0,desEncrypt.length());
        return m_desData;
    }

};

Zróbmy kod klienta, aby użyć tej klasy dekoratora-

int main()
{
    IclearData *pData = new clearData("HELLO_CLEAR_DATA");

    std::cout<<pData->getData()<<std::endl;


    encryptionDecorator *pAesData = new aes(pData);

    std::cout<<pAesData->getData()<<std::endl;

    encryptionDecorator *pDesData = new des(pAesData);

    std::cout<<pDesData->getData()<<std::endl;

    /** unwind the decorator stack ***/
    std::cout<<pDesData->showDecryptedData()<<std::endl;

    delete pDesData;
    delete pAesData;
    delete pData;

    return 0;
}

Zobaczysz następujące wyniki -

HELLO_CLEAR_DATA
Encryption Decorator Abstract class called
AES Encrypted HELLO_CLEAR_DATA
Encryption Decorator Abstract class called
DES Encrypted AES Encrypted HELLO_CLEAR_DATA
AES Encrypted HELLO_CLEAR_DATA
Encryption Decorator Destructor called
Destructor called of IclearData
Encryption Decorator Destructor called
Destructor called of IclearData
Destructor of clear Data Invoked
Destructor called of IclearData

Oto Diagram UML-Klasa reprezentacji it. W przypadku, chcesz pominąć kod i skupić się na aspekcie projektowania.

Czym jest wzorzec projektowy dekoratora w Javie.

" dołączanie dodatkowych obowiązków do obiektu dynamicznie. Dekoratorzy zapewnij elastyczną alternatywę dla podklasowania w celu rozszerzenia funkcjonalności."

Program do zademonstrowania jak zaimplementować wzorzec projektowy dekoratora w Javie.

• Zobacz więcej na: http://www.hubberspot.com/2013/06/decorator-design-pattern-in-java.html#sthash.zKj0xLrR.dpuf

<!-- language-all: lang-html -->

package com.hubberspot.designpattern.structural.decorator;

public class Pizza {

public Pizza() {

}

public String description(){
    return "Pizza";
}

}



package com.hubberspot.designpattern.structural.decorator;

public abstract class PizzaToppings extends Pizza {

public abstract String description();

}

package com.hubberspot.designpattern.structural.decorator;

public class ChickenMasala extends PizzaToppings {

private Pizza pizza;

public ChickenMasala(Pizza pizza) {
    this.pizza = pizza;
}

@Override
public String description() {
    return pizza.description() + " with chicken masala, ";
}

}



package com.hubberspot.designpattern.structural.decorator;

public class MozzarellaCheese extends PizzaToppings {

private Pizza pizza;

public MozzarellaCheese(Pizza pizza) {
    this.pizza = pizza;
}

@Override
public String description() {
    return pizza.description() + "and mozzarella cheese.";
}
}



package com.hubberspot.designpattern.structural.decorator;

public class Onion extends PizzaToppings {

private Pizza pizza;

public Onion(Pizza pizza) {
    this.pizza = pizza;
}

@Override
public String description() {
    return pizza.description() + "onions, ";
}

}



package com.hubberspot.designpattern.structural.decorator;

public class TestDecorator {

public static void main(String[] args) {

    Pizza pizza = new Pizza();

    pizza = new ChickenMasala(pizza);
    pizza = new Onion(pizza);
    pizza = new MozzarellaCheese(pizza);

    System.out.println("You're getting " + pizza.description());

}

}

Wzór dekoratora pomaga zmienić lub skonfigurować funkcjonalność obiektu poprzez łączenie z innymi podobnymi podklasami tego obiektu.

Najlepszym przykładem mogą być Klasy InputStream i OutputStream w java.io pakiet

    File file=new File("target","test.txt");
    FileOutputStream fos=new FileOutputStream(file);
    BufferedOutputStream bos=new BufferedOutputStream(fos);
    ObjectOutputStream oos=new ObjectOutputStream(bos);


    oos.write(5);
    oos.writeBoolean(true);
    oos.writeBytes("decorator pattern was here.");


//... then close the streams of course.

W swojej pracy używałem szeroko wzorów dekoratorskich. Zrobiłem post na moim blogu o tym, jak z niego korzystać z logowaniem.

Dekorator:

1. Dodaj zachowanie do obiektu w czasie wykonywania . Dziedziczenie jest kluczem do osiągnięcia tej funkcjonalności, co jest zarówno zaletą, jak i wadą tego wzoru.
2. wzmacnia zachowanie interfejsu.
3. dekorator może być postrzegany jako zdegenerowany kompozyt z tylko jednym składnikiem. Jednak dekorator dodaje dodatkowe obowiązki - nie jest przeznaczony do agregacji obiektów.
4. Klasa dekoratora deklaruje relację składu do interfejsu LCD (najniższy mianownik klasy), A Ten element danych jest inicjowany w jego konstruktorze.
5. dekorator jest zaprojektowany, aby umożliwić dodawanie obowiązków do obiektów bez podkategorii

Decorator (Abstract) : jest to abstrakcyjna klasa / interfejs, która implementuje interfejs komponentu. Zawiera interfejs komponentu. W przypadku braku tej klasy, potrzebujesz wielu podklas Betonowychkoratory dla różnych kombinacji. Skład komponentu zmniejsza niezbedne podklasy.

JDK przykład:

BufferedInputStream bis = new BufferedInputStream(new FileInputStream(new File("a.txt")));
while(bis.available()>0)
{
        char c = (char)bis.read();
        System.out.println("Char: "+c);;
}

Spójrz na poniższe pytanie dotyczące diagramu UML i przykładów kodu.

Wzór dekoratora dla IO

Przydatne artykuły:

Journaldev

Wikipedia

prawdziwe słowo przykład wzoru dekoratora: vendingmachinedecorator zostało wyjaśnione @

Kiedy stosować wzór dekoratora?

Beverage beverage = new SugarDecorator(new LemonDecorator(new Tea("Assam Tea")));
beverage.decorateBeverage();

beverage = new SugarDecorator(new LemonDecorator(new Coffee("Cappuccino")));
beverage.decorateBeverage();

Wzór dekoratora osiąga jeden cel dynamiczne dodawanie obowiązków do dowolnego obiektu.

Java I / O Model jest oparty na wzorze dekoratora.

Wzorzec dekoratora pozwala dynamicznie dodawać zachowanie do obiektów.

Weźmy przykład, gdzie trzeba zbudować aplikację, która oblicza cenę różnych rodzajów hamburgerów. Musisz obsługiwać różne odmiany hamburgerów, takie jak "duży" lub "z serem", z których każdy ma cenę w stosunku do podstawowego hamburgera. Np. dodaj 10 $za burger z serem, dodaj dodatkowe 15 $za duży burger itp.

W tym przypadku można pokusić się o stworzenie podklasy do zajmij się tym. Możemy to wyrazić w Rubim jako:

class Burger
  def price
    50
  end
end

class BurgerWithCheese < Burger
  def price
    super + 15
  end
end

W powyższym przykładzie Klasa BurgerWithCheese dziedziczy po Hamburgerze i nadpisuje metodę ceny, aby dodać $15 do ceny zdefiniowanej w klasie super. Można również utworzyć klasę LargeBurger i określić cenę w stosunku do hamburgera. Ale musisz również zdefiniować nową klasę dla kombinacji "dużych " i"z serem".

class BurgerDecorator
  def initialize(burger)
    self.burger = burger
  end
end

class BurgerWithCheese < BurgerDecorator
  def price
    self.burger.price + 15
  end
end

burger = Burger.new
cheese_burger = BurgerWithCheese.new(burger)
cheese_burger.price   # => 65

W powyższym przykładzie stworzyliśmy klasę BurgerDecorator, z której Klasa BurgerWithCheese dziedziczy. Możemy również reprezentować "dużą" odmianę tworząc Klasa largeburgera. Teraz możemy zdefiniować duży burger z serem w czasie pracy jako:

b = LargeBurger.new(cheese_burger)
b.price  # => 50 + 15 + 20 = 85

Pamiętasz, jak użycie dziedziczenia do dodania wariacji "z frytkami" wiązałoby się z dodaniem 4 kolejnych podklas? Z dekoratorami stworzylibyśmy tylko jedną nową klasę, BurgerWithFries, aby obsłużyć nową odmianę i obsłużyć ją w czasie wykonywania. Każda nowa nieruchomość potrzebowałaby więcej dekoratorów, aby pokryć wszystkie permutacje.

PS. Jest to krótka wersja artykułu, o którym pisałem używając Wzór dekoratora w Ruby , który możesz przeczytać, jeśli chcesz poznać bardziej szczegółowe przykłady.

Jest przykład na Wikipedii o dekorowaniu okna paskiem przewijania:

Http://en.wikipedia.org/wiki/Decorator_pattern

Oto kolejny bardzo 'realny' przykład "członka zespołu, kierownika zespołu i menedżera", który ilustruje, że wzór dekoratora jest niezastąpiony przy prostym dziedziczeniu:

Https://zishanbilal.wordpress.com/2011/04/28/design-patterns-by-examples-decorator-pattern/

Dekorator Design Pattern : Ten wzorzec pomaga modyfikować właściwości obiektu w czasie wykonywania. Zapewnia różne smaki do obiektu i daje elastyczność wyboru składników, które chcemy użyć w tym smaku.

Przykład Prawdziwego Życia: Powiedzmy, że masz główne miejsce w kabinie w locie. Teraz możesz wybrać wiele udogodnień z siedziskiem. Każde udogodnienie ma swój własny koszt związany z nim. Teraz, jeśli użytkownik wybierze Wifi i premium food, będzie opłata za miejsce + wifi + jedzenie premium.

W tym przypadku wzór dekoratora może nam naprawdę pomóc. Odwiedź powyższy link, aby dowiedzieć się więcej o wzorze dekoratora i realizacji jednego prawdziwego przykładu.