设计模式与架构03 -- 原型模式，建造者模式

原型模式

• 原型模式：用一个已经创建的实例作为原型，通过复制该原型对象来创建一个和原型对象相同的对象；
• 原型模式的角色：
  • 抽象原型类：规定了具体原型对象必须实现的clone()方法；
  • 具体原型类：实现抽象原型类的clone()方法，它是可以被复制的对象；
• UML类图如下：

image.png

• 原型模式的克隆分为浅克隆与深克隆：
  • 浅克隆：创建一个新对象，新对象的属性与原来对象完全相同，
  • 深克隆：创建一个新对象，属性中引用的其他对象也会被克隆，不再指向原有对象地址；
• 在Java中的Object类中提供了clone()方法来实现克隆，Cloneable接口就是抽象原型类，而实现了Cloneable接口的子类就是具体原型类；
• 代码实现如下：

import androidx.annotation.NonNull;

public class Realizetype implements Cloneable{

    public Realizetype() {
        System.out.println("具体原型对象查创建成功");
    }

    @NonNull
    @Override
    public Realizetype clone() throws CloneNotSupportedException {
        System.out.println("具体原型对象复制成功");
        return (Realizetype) super.clone();
    }
}

import androidx.appcompat.app.AppCompatActivity;
import android.os.Bundle;
import com.example.sign.prototype.Realizetype;

public class MainActivity extends AppCompatActivity {
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        Realizetype realizetype = new Realizetype();
        try {
            Realizetype clone = realizetype.clone();
            System.out.println("原型与克隆是否是同一个对象" + (realizetype == clone));
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
    }
}

• 案例：三好学生的奖状，同一学校三好学生的奖状除了获奖人姓名不同，其他都相同，可以使用原型模式复制多个三好学生奖状，然后再修改奖状上的名字即可，UML类图如下：

image.png

• 代码实现如下：

import androidx.annotation.NonNull;

public class Citation implements Cloneable{
    private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public void show() {
        System.out.println(name + "同学: 在2021年12月1日 获取三号学生，特发此状");
    }

    @NonNull
    @Override
    public Citation clone() throws CloneNotSupportedException {
        return (Citation) super.clone();
    }
}

import androidx.appcompat.app.AppCompatActivity;
import android.os.Bundle;
import com.example.sign.prototype.Citation;

public class MainActivity extends AppCompatActivity {
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        Citation citation = new Citation();
        try {
            Citation c1 = citation.clone();
            c1.setName("张三");
            citation.setName("李四");
            citation.show();
            c1.show();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
    }
}

• 使用场景：
  • 对象创建非常复杂，可使用原型模式快捷创建对象；
  • 性能和安全要求比较高的；

扩展(深克隆)

• 将三好学生奖状类Citation的name 属性 修改为Student 类型的属性，代码如下：

public class Student {

    private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

import androidx.annotation.NonNull;

public class Citation implements Cloneable{
    private Student student;

    public Student getStudent() {
        return student;
    }

    public void setStudent(Student student) {
        this.student = student;
    }

    public void show() {
        System.out.println(student.getName() + "同学: 在2021年12月1日 获取三号学生，特发此状");
    }

    @NonNull
    @Override
    public Citation clone() throws CloneNotSupportedException {
        return (Citation) super.clone();
    }
}

import androidx.appcompat.app.AppCompatActivity;
import android.os.Bundle;
import com.example.sign.prototype.Citation;
import com.example.sign.prototype.Student;

public class MainActivity extends AppCompatActivity {
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        Citation citation = new Citation();
        Student student = new Student();
        student.setName("张三");
        citation.setStudent(student);

        try {
            Citation c1 = citation.clone();
            c1.getStudent().setName("李四");
            citation.show(); //李四
            c1.show(); //李四
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
    }
}

• citation与c1指向同一个对象；
• 下面通过序列化技术，实现对象的深克隆，代码如下：

import java.io.Serializable;

public class Student implements Serializable {

    private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

import androidx.annotation.NonNull;
import java.io.Serializable;

public class Citation implements Cloneable, Serializable {
    private Student student;

    public Student getStudent() {
        return student;
    }

    public void setStudent(Student student) {
        this.student = student;
    }

    public void show() {
        System.out.println(student.getName() + "同学: 在2021年12月1日 获取三号学生，特发此状");
    }

    @NonNull
    @Override
    public Citation clone() throws CloneNotSupportedException {
        return (Citation) super.clone();
    }
}

import androidx.appcompat.app.AppCompatActivity;
import android.os.Bundle;
import com.example.sign.prototype.Citation;
import com.example.sign.prototype.Student;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;

public class MainActivity extends AppCompatActivity {
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        Citation citation = new Citation();
        Student student = new Student();
        student.setName("张三");
        citation.setStudent(student);

        //创建输出流
        try {
            //将对象序列化到磁盘文件
            ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("User/liyanyan/desktop/a.txt"));
            //写对象
            oos.writeObject(citation);
            oos.close();
            ObjectInputStream ois = new ObjectInputStream(new FileInputStream("User/liyanyan/desktop/a.txt"));
            Citation citation1 = (Citation) ois.readObject();
            ois.close();
            Student student1 = citation1.getStudent();
            student1.setName("李四");
            citation.show(); //张三
            citation1.show(); //李四
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

• citation与citation1指向的是两个不同的对象，其中Citation类与Student类都必须实现Serializable接口；
• 上述的浅克隆，深克隆与iOS中浅拷贝，深拷贝的原理是相同的；

建造者模式

• 建造者模式：将一个复杂对象的构建与表示分离，使得同样的构建过程可以创建不同的表示；
• 实现了构建与装配的解耦，不同的构建器，相同的装配，可作出不同的对象，相同的构建器，不同的装配顺序也可作出不同的对象，也就实现了构建算法与装配算法之间的解耦，实现了更好的复用；
• 建造者模式可以将部件与其组装过程分开，一步一步创建一个复杂对象，客户只需要指定复杂对象的类型就可以得到该对象，而无需知道其内部的具体构造细节；
• 建造者模式中的角色：
  • 抽象建造者类(Builder)：定义了复杂对象各部件创建的接口；
  • 具体建造者类：实现了Builder中的接口，完成部件的创建，在构造完成之后，返回产品实例；
  • 产品类：需要的创建的复杂对象；
  • 指挥者类(Director)：调用具体建造者来创建复杂对象的各个部分，在指挥者类中，不涉及具体产品信息，只负责保证对象各部分完整创建或按某种顺序创建；
• 下面以创建自行车为案例，来阐述建造者模式，首先产品类是自行车这个复杂对象，其包含车架与车座，车架有碳纤维，铝合金，车座有真皮，橡胶，UML类图如下所示：

image.png

• 代码实现如下：

public class Bike {
    private String frame;
    private String seat;

    public String getFrame() {
        return frame;
    }

    public void setFrame(String frame) {
        this.frame = frame;
    }

    public String getSeat() {
        return seat;
    }

    public void setSeat(String seat) {
        this.seat = seat;
    }
}

//抽象建造者
public abstract class Builder {
    protected Bike bike = new Bike();

    public abstract void buildFrame();
    public abstract void buildSeat();

    public abstract Bike createBike();
}

public class MobleBuilder extends Builder{
    @Override
    public void buildFrame() {
        bike.setFrame("碳纤维车架");
    }

    @Override
    public void buildSeat() {
        bike.setSeat("真皮车座");
    }

    @Override
    public Bike createBike() {
        return bike;
    }
}

public class OfoBuilder extends Builder{
    @Override
    public void buildFrame() {
        bike.setFrame("铝合金车架");
    }

    @Override
    public void buildSeat() {
        bike.setSeat("橡胶车座");
    }

    @Override
    public Bike createBike() {
        return bike;
    }
}

//指挥者类 装配 
public class Director {
    private Builder builder;

    public Director(Builder builder) {
        this.builder = builder;
    }

    public Bike construct() {
        builder.buildFrame();
        builder.buildSeat();
        return builder.bike;
    }
}

import androidx.appcompat.app.AppCompatActivity;
import android.os.Bundle;
import com.example.sign.build.Bike;
import com.example.sign.build.Director;
import com.example.sign.build.MobleBuilder;

public class MainActivity extends AppCompatActivity {
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        Director director = new Director(new MobleBuilder());
        Bike bike = director.construct();
        System.out.println(bike.getFrame() + bike.getSeat());
    }
}

• 上述案例是Builder模式的常规用法，指挥者Director在建造者模式中具有很重要的作用，它用于指导具体构建者如何构建产品，控制先后次序，并向调用者返回完整的产品类，可以考虑将指挥者Director与抽象建造者类Builder进行合并，代码如下：

//抽象建造者
public abstract class Builder {
    protected Bike bike = new Bike();

    public abstract void buildFrame();
    public abstract void buildSeat();

    public abstract Bike createBike();
    
    public Bike construct() {
        this.buildFrame();
        this.buildSeat();
        return this.createBike();
    }
}

• 这样设计简化了系统结构，但加重了抽象建造者Builder的职责，若指挥者Director类逻辑过于复杂，建议还是将两者分开；