Pola Desain GoF - mana yang benar-benar Anda gunakan? [Tutup]

Saya mencoba mendidik kolega saya di bidang pola desain. Beberapa pola Gang of Four asli sedikit esoteris, jadi saya ingin tahu apakah ada sub-kelompok pola "esensial" yang harus diketahui oleh semua programmer. Saat saya melihat daftar, saya pikir saya mungkin telah menggunakan -

• Pabrik Abstrak
• Metode Pabrik
• Singleton
• Jembatan
• Tatapan
• Perintah

Yang mana yang sebenarnya Anda gunakan dalam praktik, dan untuk apa Anda menggunakannya?

Tautan untuk mereka yang menginginkan daftar pola

Berikut daftar yang saya gunakan atau lihat dalam praktik:

Singleton - Objek aplikasi dalam ASP.Net menjadi contoh utama dari ini.

Adaptor - Menyambung ke basis data biasanya dapat melibatkan kelas Adaptor setidaknya di area saya. Net stuff.

Factory - General untuk menghasilkan objek meskipun saya melihat ini lebih banyak di beberapa ASP klasik yang lebih tua pada hari itu.

Strategi - Saya memiliki aplikasi yang untuk setiap jenis perangkat saya memiliki struktur yang sama untuk kelas yang saya akan pertimbangkan sebagai implementasi dari pola ini.

Fasad - Dalam beberapa hal ini mirip dengan pola Adaptor dalam hal menjadi sesuatu yang biasanya menyatukan beberapa sistem.

Para penulis menyusun pola dari desain yang diamati yang mereka temukan dalam aplikasi nyata. Tidak ada satu orang pun yang akan menggunakan semuanya, tetapi semuanya digunakan.

Dekorator .

EDIT : Di hampir setiap proyek yang melampaui tahap 'sepele', satu berakhir dengan antarmuka IAction (detail mungkin berbeda):

// Programming Language does not matter
interface IAction {
     bool operateOn(Foo* target);
     string getDisplayName(); // useful for debugging and logging
};

Satu jam berikutnya saya habiskan untuk menulis banyak kelas kecil, hampir sepele yang menerapkan IAction. Ketika digabungkan, mereka sangat kuat dan fleksibel.

Misalnya a LogAction(tulis untuk mencatat dan melakukan IAction), NullAction(tidak melakukan apa pun dan mengembalikan true), ActionList(melakukan daftar IActions, dan mengembalikan ANDing dari bools). Dalam beberapa kasus AndAction(mengembalikan DAN-ing dari dua tindakan, bisa hubung pendek atau tidak), OrAction, NotActionmasuk akal juga.

Meskipun secara teknis dari contoh di atas hanya LogAction adalah Dekorator (yang lain tidak beroperasi tepat 1 IAction), saya masih menganggap ini generalisasi dari pola Dekorator ketika saya membuat Daftar Tindakan LogActions of IActions.

Saya berasumsi Anda bermaksud membatasi pertanyaan untuk penggunaan pola dalam kode / proyek sendiri (tidak ada perpustakaan kelas dan kerangka kerja pihak ke-3).

Seperti yang dilakukan orang lain, saya juga paling sering menggunakan pola Pabrik . Kemudian

• Singleton : tidak begitu banyak saat ini, tetapi masih kadang-kadang diperlukan, biasanya untuk data konfigurasi global
• Strategi dan Metode Templat : cukup sering, misalnya untuk mewakili berbagai jenis perhitungan dalam aplikasi kami
• Builder : untuk menyusun hasil transaksi dengan sistem mainframe menjadi objek keluaran (dalam beberapa kasus termasuk banyak parsing teks dan membuat hierarki objek besar)
• Perintah : Saya menerapkannya hanya sekali bertahun-tahun yang lalu, tetapi saat ini di proyek Java kami, saya menggunakan Callables setiap saat, yang saya percaya pada dasarnya adalah Perintah

Saya telah menggunakan banyak yang lain yang telah disebutkan (Singleton, Factory, Builder, Command, Strategy, dll ...)

Satu yang belum saya lihat disebutkan adalah Flyweight, yang cenderung saya gunakan banyak. Saya telah memberikan contoh implementasi di bawah ini:

/**
 * Flyweight class representing OCR digits.
 * 
 * @author matt
 *
 */
public class Digit {
    /** Static flyweight map containing Digits which have been encountered. **/
    private static Map digits = new HashMap();

    /** The block of text representing Digit. **/
    private String blockRep = null;

    /** A map representing acceptable blocks of characters and the string representation of their
     * numerical equivalents.
     */
    public static final Map VALID_DIGITS;

    /** Enum of valid digits. **/
    public static enum DigitRep {
        ZERO    (   " _ \n" +
                    "| |\n" +
                    "|_|"       ),

        ONE (       "   \n" +
                    "  |\n" +
                    "  |"       ),

        TWO (       " _ \n" +
                    " _|\n" +
                    "|_ "       ),

        THREE   (   " _ \n" +
                    " _|\n" +
                    " _|"       ),

        FOUR    (   "   \n" +
                    "|_|\n" +
                    "  |"       ),

        FIVE    (   " _ \n" +
                    "|_ \n" +
                    " _|"       ),

        SIX     (   " _ \n" +
                    "|_ \n" +
                    "|_|"       ),

        SEVEN   (   " _ \n" +
                    "  |\n" +
                    "  |"       ),

        EIGHT   (   " _ \n" +
                    "|_|\n" +
                    "|_|"       ),

        NINE    (   " _ \n" +
                    "|_|\n" +
                    " _|"       );

        private String blockRep;

        DigitRep(String blockRep) {
            this.blockRep = blockRep;
        }

        @Override
        public String toString() {
            return blockRep;
        }
    }

    static {
        /* Initialize the map of acceptable character blocks. */
        Map tmpMap = new HashMap();
        tmpMap.put( DigitRep.ZERO.toString(),   "0");
        tmpMap.put( DigitRep.ONE.toString(),    "1");
        tmpMap.put( DigitRep.TWO.toString(),    "2");
        tmpMap.put( DigitRep.THREE.toString(),  "3");
        tmpMap.put( DigitRep.FOUR.toString(),   "4");
        tmpMap.put( DigitRep.FIVE.toString(),   "5");
        tmpMap.put( DigitRep.SIX.toString(),    "6");
        tmpMap.put( DigitRep.SEVEN.toString(),  "7");
        tmpMap.put( DigitRep.EIGHT.toString(),  "8");
        tmpMap.put( DigitRep.NINE.toString(),   "9");       
        VALID_DIGITS = Collections.unmodifiableMap(tmpMap);
    }

    /**
     * Private constructor to enforce flyweight/factory pattern.
     * 
     * @param blockRep
     */
    private Digit(String blockRep) {
        this.blockRep = blockRep;
    }

    /**
     * Flyweight factory method to create a Digit object from the "block"
     * representation of the digit.
     * @param blockRep The "block" representation of a digit.  Should look
     * something like:
     * " _ \n"
     * "|_|\n"
     * "|_|"
     * @return A flyweight Digit object representing the digit.
     */
    public static synchronized Digit getDigit(String blockRep) {
        Digit digit = digits.get(blockRep);
        if(digit == null) {
            digit = new Digit(blockRep);
            digits.put(blockRep, digit);
        }

        return digit;
    }

    /**
     * Determines whether or not the digit is valid.
     * @return true if the digit is valid, else false.
     */
    public boolean isValid() {
        return VALID_DIGITS.containsKey(blockRep);
    }

    /**
     * Accessor method to get the block representation of this digit.
     * 
     * @return
     */
    public String getBlockRep() {
        return blockRep;
    }

    @Override
    public String toString() {
        return VALID_DIGITS.containsKey(blockRep) ? VALID_DIGITS.get(blockRep) : "?";
    }
}

Sebagian besar pola Gang of Four asli masih digunakan sampai sekarang, tetapi ada yang sekarang populer yang tidak ada dalam buku ini.

Temukan referensi untuk Desain Patters dalam bahasa yang Anda gunakan. Mereka cenderung lebih konkret dan menggunakan fitur bahasa tertentu untuk menerapkan pola dengan cara yang lebih ringkas dan elegan.

Tiga sumber yang bagus untuk Pola Desain:

Buku "Head First Design Patterns" - bahasa pilihan adalah Java, tetapi relevan untuk semua bahasa. dofactory Design Patterns - penjelasan pola desain .net yang hebat dan gratis dengan kode. PluralSight - Design Patterns Library - yang ini berbayar, tetapi terlalu bagus untuk tidak memasukkannya ke dalam daftar.

Nah jika Anda menggunakan perpustakaan umum seperti ACE, Anda akhirnya menggunakan lebih dari yang Anda pikir Anda gunakan. Saya menggunakan Observer / Observable ekstensif :-)

Saya menggunakan Builder setidaknya sekali (proses konverter yang sama dapat membangun output HTML atau Excel).

Saya sering menggunakan Metode Templat (untuk tugas yang berhubungan dengan JDBC, atau pengontrol Swing abstrak).

Suatu kali saya harus mengembangkan banyak fitur baru menjadi aplikasi berbasis formulir, yang berantakan. Saya hanya bisa maju setelah saya refactored hal-hal yang ada ke solusi berbasis pola Negara. (Yah, sebagian besar).

Saya juga sering menggunakan Perintah (Aksi Swing), dan Pengamat juga.

Suatu kali saya menggunakan solusi seperti Mememento untuk mendeteksi perubahan dalam bentuk Swing. Bentuk akan membuat cerita bersambung keadaannya apa yang saya bandingkan (sama dengan ()) dengan keadaan sebelumnya.

Saya percaya saya memiliki sebagian besar dari mereka sepanjang karier saya. satu-satunya yang saya yakin belum saya gunakan adalah Pola Adaptor yang diimplementasikan dengan banyak pewarisan pada buku ini karena saya bukan penggemar berat pewarisan berganda.

Saya menyukai Dekorator. Satu-satunya yang saya tambahkan ke yang disebutkan adalah Proxy.