Android开发学习笔记之设计模式——原型模式&建造者模式

Android开发学习笔记之设计模式——原型模式&建造者模式

原型模式

概述

在开发过程中，我们经常会遇到这样的问题，如果我们想要创建一个非常复杂的对象，那我们可能需要进行相当多的处理，尤其是数据类，通常都存在很多成员变量，而其中很多变量还是需要通过I/O操作获取的，此时创建一个新的对象的成本就显得很高了。此时，我们或许会想，如果存在一种方法可以复制原有的对象就好了，而这就是原型模式。

原型模式就是用一个已经创建的实例作为原型，通过复制该原型对象来创建一个和原型相同或相似的新对象。在这里，原型实例指定了要创建的对象的种类。用这种方式创建对象非常高效，根本无须知道对象创建的细节。

原型模式将克隆过程委派给被克隆的实际对象。 模式为所有支持克隆的对象声明了一个通用接口， 该接口让你能够克隆对象， 同时又无需将代码和对象所属类耦合。 通常情况下， 这样的接口中仅包含一个 克隆方法。所有的类对 克隆方法的实现都非常相似。 该方法会创建一个当前类的对象， 然后将原始对象所有的成员变量值复制到新建的类中。 你甚至可以复制私有成员变量， 因为绝大部分编程语言都允许对象访问其同类对象的私有成员变量。

在一些语言如java中，其实本身已经对原型模式进行了实现，在Java中，我们只要实现Cloneable接口，重写clone方法即可实现原型模式。

在Java以及很多其它实现了原型模式的语言中，都存在深拷贝和浅拷贝的区别：

• 浅拷贝：拷贝的对象中的非基本类型成员变量与原型对象是同一个引用；
• 深拷贝：拷贝的对象中的非基本类型成员变量与原型对象也会被克隆，不是同一个引用；

Java的clone就属于浅拷贝，如下：

public class Test {

    public static void main(String[] args) {
        User user1 = new User(12, "Tom");
        try {
            User user2 = (User) user1.clone();
            System.out.println("user2====>"+user2);
            System.out.println("user1 == user2 ====>"+(user1 == user2));
            System.out.println("user1.name == user2.name ===>"+ (user1.name == user2.name));
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
    }

}

class User implements Cloneable{

    int age = 0;
    String name = "";

    public User(int age, String name){
        this.age = age;
        this.name = name;
    }

    @Override
    public String toString() {
        return "User{" +
                "age=" + age +
                ", name='" + name + '\'' +
                '}';
    }

    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}

其结果如下：

user2====>User{age=12, name='Tom'}
user1 == user2 ====>false
user1.name == user2.name ===>true

我们发现，user2成功复制了user1中的所有成员变量，且二者不是同一个引用对象但其name为同一对象，即clone()是一个浅拷贝方法。如果，我们需要进行深拷贝，我们需要对其clone方法进行修改，如下：

@Override
    protected Object clone() throws CloneNotSupportedException {
        User user = (User) super.clone();
        user.name = name+"";
        return user;
    }

此时，name就不再是同一个对象了，从而实现了深拷贝，当然这是因为name是一个字符串对象，如果是其它数据类型，那么我们需要对其每个非基本类型的成员变量进行clone()，这样才能实现深拷贝。

应用场景

• 当一个对象的创建相当复杂，需要一系列的数据准备操作，或是需要消耗较多资源时，可以使用原型模式，提高性能，节省资源。
• 如果你需要复制一些对象， 同时又希望代码独立于这些对象所属的具体类， 可以使用原型模式。通过原型模式创建对象，我们无需对其所属类有任何了解，也不用知道其需要什么参数。
• 一个对象需要提供给其他对象访问，而且各个调用者可能都需要修改其值时，可以考虑使用原型模式拷贝多个对象供调用者使用。
• 原型模式可以与工厂方法模式结合，创建一系列的原型对象用于复制创建对象。

优缺点

优点：

• 使用原型模式可以直接克隆对象， 而无需与它们所属的具体类相耦合。
• 通过原型模式，可以用继承以外的方式来处理复杂对象的不同配置。
• 使用原型模式，可以更方便地创建复制对象，同时也能够减少性能消耗。

缺点：

• 深克隆包含循环引用的复杂对象可能会非常麻烦，需要对每个成员变量都实现深克隆。
• 使用原型模式地类都需要实现其对应地克隆方法。

实现

原型模式的实现主要包括以下两部分：

• 抽象原型类：规定了具体原型对象必须实现的克隆方法的接口。
• 具体原型类：实现了克隆方法的类。

具体如下图所示：

在kotlin中也对原型模式进行了实现，其数据类都可以通过copy()方法**（浅拷贝）**来复制对象。不过，这只是针对数据类的，我们也可以自己实现一个原型模式。比如，在开发中，我们可能会创建几个相同的按钮，我们可以通过原型方法来实现，如下，首先创建抽象原型类，如下：

/**
 * 抽象原型
 */
interface Prototype {
    /**
     * 克隆方法
     * @return 返回一个克隆对象
     */
    fun clone(): Prototype
}

然后创建具体原型类Button，如下：

/**
 * 具体原型
 */
class Button(
    val width : Int,
    val height : Int,
    var color : String
) : Prototype{

    constructor(button: Button) : this(button.width, button.height, button.color)

    /**
     * 原型克隆方法
     */
    override fun clone(): Prototype {
        return Button(this)
    }

    override fun toString(): String {
        return "width:$width, height:$height, color:$color"
    }

}

我们只需要实现抽象原型Prototype，然后重写clone()方法即可，而对于clone()方法的重写，通常我们可以添加一个构造参数为原型类本身的构造方法，然后创建一个所有成员变量相同的对象即可，外部访问者只需要调用clone方法即可克隆一个对象。简单来说，就是将原型对象中的变量复制了一份然后以此创建了一个新的对象。结果如下：

fun main() {
    val button = Button(1,2,"red")
    val clone = button.clone()
    println("button ===>${button}, clone ===>${clone}")
    println("button===clone ===> ${(button===clone)}")
}

//输出
button ===>width:1, height:2, color:red, clone ===>width:1, height:2, color:red
button===clone ===> false

建造者模式

概述

假设存在一个复杂对象，该对象存在大量的属性，同时每个成员变量也有可能是个复杂对象，且有的成员变量可能不需要，此时，如果我们需要创建一个该对象，那么就会相当复杂。比如，存在一个房子的对象，每个房子会存在门、窗户，有的房子还会存在后院、篱笆、游泳池等，然后每个属性都有可能不同，比如门有木门、铁门等。此时，如果我们直接通过new等方式直接创建一个对象，那么就会非常麻烦，而且不简洁。此时，我们就需要使用到建造者模式了。

建造者模式是一种创建型设计模式，又叫生成器模式， 使你能够分步骤创建复杂对象。 该模式允许你使用相同的创建代码生成不同类型和形式的对象。它是将一个复杂的对象分解为多个简单的对象，然后一步一步构建而成。它将变与不变相分离，即产品的组成部分是不变的，但每一部分是可以灵活选择的。

应用场景

• 当创建的对象存在大量的可选参数时，我们可以使用建造者模式，避免大量的重载构造方法。
• 隔离复杂对象的创建和使用，并使得相同的创建过程可以创建不同的产品。
• 当需要生成的产品对象的属性相互依赖，需要指定其生成顺序时，我们可以使用建造者模式。

优缺点

优点：

• 在建造者模式中， 客户端不必知道产品内部组成的细节，将产品本身与产品的创建过程解耦，使得相同的创建过程可以创建不同的产品对象。
• 每一个具体建造者都相对独立，而与其他的具体建造者无关，因此可以很方便地替换具体建造者或增加新的具体建造者， 用户使用不同的具体建造者即可得到不同的产品对象。
• 可以更加精细地控制产品的创建过程 。将复杂产品的创建步骤分解在不同的方法中，使得创建过程更加清晰，也更方便使用程序来控制创建过程。
• 增加新的具体建造者无须修改原有类库的代码，指挥者类针对抽象建造者类编程，系统扩展方便，符合“开闭原则”。

缺点：

• 由于该模式需要新增多个类， 因此代码整体复杂程度会有所增加。
• 建造者模式所创建的产品一般具有较多的共同点，其组成部分相似，如果产品之间的差异性很大，则不适合使用建造者模式，因此其使用范围受到一定的限制。
• 如果产品的内部变化复杂，可能会导致需要定义很多具体建造者类来实现这种变化，导致系统变得很庞大。

实现

建造者模式的实现主要可以分为以下几个部分：

• 抽象建造者：接口声明在所有类型生成器中通用的产品构造步骤。（可省略）
• 具体建造者：提供构造过程的不同实现。 具体生成器也可以构造不遵循通用接口的产品。
• 指挥者：定义调用构造步骤的顺序， 这样你就可以创建和复用特定的产品配置。（可省略）
• 产品类：需要最终创建的复杂对象。

具体如下图：

建造者模式在Android开发中实际上是非常常见的，一般在我们创建了一些复杂的自定义View时，我们就会使用建造者模式来创建对象。当然，一般情况下，我们使用的建造者模式并没有这么复杂，我们可能只存在一个Builder，且其创建方法是固定的，此时，我们就可以省略抽象建造者和指挥者。比如，我们可能创建了一个通用的自定义的Dialog，这个dialog可能存在标题、内容、按钮文字、是否显示标题、按钮颜色等等一系列的属性，在不同的情况下，我们可能会使用不同的样式，这时，我们就可以使用建造者模式，创建一个Builder用于创建Dialog，为各个属性都设置好默认值，如果不需要使用到这个属性就使用默认值。如下：

/**
 * 产品
 */
class CommonDialog(
        private var title: String?, 
        private var content: String?, 
        private var showTitle: Boolean, 
        private var onConfirmListener: (() -> Unit)?, 
        private var onCancelListener: (() -> Unit)?) {

    init {
        // 产品的实际构造，根据参数构造不同样式的dialog
    }
    
    fun show(){
        // 显示dialog
    }


    /**
     * 建造者
     */
    class Builder(){
        /**
         * 产品一系列属性
         */
        private var title : String? = null
        private var content : String? = null
        private var showTitle : Boolean = true
        private var onConfirmListener : (()->Unit)? = null
        private var onCancelListener : (()->Unit)? = null

        /**
         * 构造产品属性的一系列方法，通常我们会返回建造者本身对象，以便链式调用
         */
        fun setTitle(title : String) : Builder{
            this.title = title
            return this
        }

        fun setContent(content : String) : Builder{
            this.content = content
            return this
        }

        fun showTitle(showTitle : Boolean) : Builder{
            this.showTitle = showTitle
            return this
        }

        fun setOnConfirmListener(onConfirmListener : ()->Unit) : Builder{
            this.onConfirmListener = onConfirmListener
            return this
        }

        fun setOnCancelListener(onCancelListener : ()->Unit) : Builder{
            this.onCancelListener = onCancelListener
            return this
        }

        /**
         * 建造方法
         */
        fun build() : CommonDialog{
            return CommonDialog(title, content, showTitle, onConfirmListener, onCancelListener)
        }
    }

}

我们可以看到，通过建造者模式，我们可以轻易控制各个属性存在与否，而不用重载大量的构造方法，同时，在上述的代码中，我们可以看到，每个参数的set方法，我们都返回了Builder对象本身，如此一来在构造时我们就可以通过链式调用的方法来返回一个Dialog对象，如下：

CommonDialog.Builder()
        .setTitle("标题")
        .setContent("这个一个dialog")
        .showTitle(true)
        .setOnCancelListener { println("取消") }
        .setOnConfirmListener { println("确定") }
        .build()
        .show()

这种创建方式会使代码更加整洁，而且一目了然，对于不需要的参数，我们只需要不调用其set方法即可。