長平狐 Java程序員從笨鳥到菜鳥之（三十四）大話設計模式（五）建立者模式和原型模式

時間 2019-11-13

標籤長平 java 程序員菜鳥三十四大話設計模式建立者原型欄目 Java 简体版

原文原文鏈接

建立者模式是建立型模式中最負責的一個設計模式了，建立者負責構建一個對象的各個部分，而且完成組裝的過程.構建模式主要用來針對複雜產品生產，分離部件構建細節，以達到良好的伸縮性。把構造對象實例的邏輯移到了類的外部，在這個類外部定義了這個類的構造邏輯。它把一個複雜對象的構過程從對象的表示中分離出來。其直接效果是將一個複雜的對象簡化爲一個比較簡單的對象。它強調的是產品的構造過程。

在軟件系統中，有時候面臨着「一個複雜對象」的建立工做，其一般由各個部分的子對象用必定的算法構成；因爲需求的變化，這個複雜對象的各個部分常常面臨着劇烈的變化，可是將它們組合在一塊兒的算法確相對穩定。如何應對這種變化？如何提供一種「封裝機制」來隔離出「複雜對象的各個部分」的變化，從而保持系統中的「穩定構建算法」不隨着需求改變而改變？這就是要說的建造者模式。 java

意圖：將一個複雜對象的構建與其表示相分離，使得一樣的構建過程能夠建立不一樣的表示。算法

類圖： 設計模式

  抽象建造者（Builder）：給出一個抽象接口，以規範產品對象的各個組成成分的建造。這個接口規定要實現複雜對象的哪些部分的建立，並不涉及具體的對象部件的建立。
    具體建造者（Concrete Builder）：實現Builder接口，針對不一樣的商業邏輯，具體化複雜對象的各部分的建立。在建造過程完成後，提供產品的實例。
    指導者（Director）：調用具體建造者來建立複雜對象的各個部分，在指導者中不涉及具體產品的信息，只負責保證對象各部分完整建立或按某種順序建立。
    產品（Product）：要建立的複雜對象。 ide

適用範圍： ui

1.須要生成的產品對象有複雜的內部結構。 this

2.須要生成的產品對象的屬性相互依賴，建造者模式能夠強迫生成順序。 spa

3.在對象建立過程當中會使用到系統中的一些其餘對象，這些對象在產品對象的建立過程當中不易獲得。 .net

效果： prototype

1.建造者模式的使用時的產品的內部表象能夠獨立的變化。使用建造者模式可使客戶端沒必要知道產品內部組成的細節。設計

2.每個Builder都相對獨立，而與其餘的Builder無關。

3.模式所建造的最終產品易於控制。

下面咱們來看一下經典建立者模式的一個實現形式，而後針對這個經典模式後面提出幾個改進方案，咱們這裏以上面講述的服裝的過程做爲例子來講明下建立者模式的原理和思想，但願你們也能靈活的運用到實際的項目中去。達到學以至用的目的。

咱們來看看具體的代碼實現：

源碼打印？

package builder;
public class Product {
ArrayList<String> parts = new ArrayList<String>();
public void add(String part)
{
parts.add(part);
}
public void show()
{
System.out.println("產品建立------------");
for(String part : parts)
{
System.out.println(part);
}
}
}
public abstract class Builder {
public abstract void BuildPartA();
public abstract void BuildPartB();
public abstract Product getResult();
}
public class ConcreteBuilder1 extends Builder{
private Product product = new Product();
@Override
public void BuildPartA() {
product.add("部件A");
}
@Override
public void BuildPartB() {
product.add("部件B");
}
@Override
public Product getResult() {
return product;
}
}
public class ConcreteBuilder2 extends Builder{
private Product product = new Product();
@Override
public void BuildPartA() {
product.add("部件x");
}
@Override
public void BuildPartB() {
product.add("部件y");
}
@Override
public Product getResult() {
return product;
}
}
public class Director {
public void Construct(Builder builder)
{
builder.BuildPartA();
builder.BuildPartB();
}
}
public class TestBuilder {
public static void main(String[] args) {
Director director = new Director();
Builder b1 = new ConcreteBuilder1();
Builder b2 = new ConcreteBuilder2();
director.Construct(b1);
Product p1 = b1.getResult();
p1.show();
director.Construct(b2);
Product p2 = b2.getResult();
p2.show();
}
}

經過上面的代碼，咱們給出了經典建立者模式的核心代碼形式，那麼針對上面無疑有如下的幾個缺點：

1、Ibuilder接口必須定義完整的組裝流程，一旦定義就不能隨意的動態修改。

2、Builder與具體的對象之間有必定的依賴關係，固然這裏能夠經過接口來解耦來實現靈活性。

3、Builder必須知道具體的流程。

那麼針對上面的幾個問題，咱們如何來解決呢？我想前面的建立型模式已經給我了足夠的經驗，仍是經過配置文件或者其餘的形式來提供靈活性。

原型模式

用原型實例指定建立對象的種類，而且經過拷貝這些原型建立新的對象。 Prototype原型模式是一種建立型設計模式，Prototype模式容許一個對象再建立另一個可定製的對象，根本無需知道任何如何建立的細節,工做原理是:經過將一個原型對象傳給那個要發動建立的對象，這個要發動建立的對象經過請求原型對象拷貝它們本身來實施建立。它主要面對的問題是：「某些結構複雜的對象」的建立工做；因爲需求的變化，這些對象常常面臨着劇烈的變化，可是他們卻擁有比較穩定一致的接口。

原型模式最大的特色是克隆一個現有的對象，這個克隆的結果有2種，一種是是淺複製，另外一種是深複製，這裏咱們也會探討下深複製和淺複製的原理，這樣可能更方便你們理解這個原型模式的使用。咱們都知道，建立型模式通常是用來建立一個新的對象，而後咱們使用這個對象完成一些對象的操做，咱們經過原型模式能夠快速的建立一個對象而不須要提供專門的new()操做就能夠快速完成對象的建立，這無疑是一種很是有效的方式，快速的建立一個新的對象。

原型模式的原理圖：

原型模式的主要思想是基於現有的對象克隆一個新的對象出來，通常是有對象的內部提供克隆的方法，經過該方法返回一個對象的副本，這種建立對象的方式，相比咱們以前說的幾類建立型模式仍是有區別的，以前的講述的工廠模式與抽象工廠都是經過工廠封裝具體的new操做的過程，返回一個新的對象，有的時候咱們經過這樣的建立工廠建立對象不值得，特別是如下的幾個場景的時候，可能使用原型模式更簡單也效率更高。

主要運用場合：

1、若是說咱們的對象類型不是剛開始就能肯定，而是這個類型是在運行期肯定的話，那麼咱們經過這個類型的對象克隆出一個新的類型更容易。

二、有的時候咱們可能在實際的項目中須要一個對象在某個狀態下的副本，這個前提很重要，這點怎麼理解呢，例若有的時候咱們須要對比一個對象通過處理後的狀態和處理前的狀態是否發生過改變，可能咱們就須要在執行某段處理以前，克隆這個對象此時狀態的副本，而後等執行後的狀態進行相應的對比，這樣的應用在項目中也是常常會出現的。

三、當咱們在處理一些對象比較簡單，而且對象之間的區別很小，可能只是很固定的幾個屬性不一樣的時候，可能咱們使用原型模式更合適

深複製和淺複製：

⑴淺複製（淺克隆）
被複制對象的全部變量都含有與原來的對象相同的值，而全部的對其餘對象的引用仍然指向原來的對象。換言之，淺複製僅僅複製所考慮的對象，而不復制它所引用的對象。
⑵深複製（深克隆）
被複制對象的全部變量都含有與原來的對象相同的值，除去那些引用其餘對象的變量。那些引用其餘對象的變量將指向被複制過的新對象，而再也不是原有的那些被引用的對象。換言之，深複製把要複製的對象所引用的對象都複製了一遍。

下面舉一個實例來實現如下原型模式：

源碼打印？

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
class Prototype implements Cloneable,Serializable{
private String str;
private Temp temp;
public Object clone()throws CloneNotSupportedException{ //淺克隆
Prototype prototype=(Prototype)super.clone();
return prototype;
}
public Object deepClone()throws IOException,ClassNotFoundException{ //深克隆
ByteArrayOutputStream bo=new ByteArrayOutputStream();
ObjectOutputStream oo=new ObjectOutputStream(bo);
oo.writeObject(this);
ByteArrayInputStream bi=new ByteArrayInputStream(bo.toByteArray());
ObjectInputStream oi=new ObjectInputStream(bi);
return oi.readObject();
}
public String getStr() {
return str;
}
public void setStr(String str) {
this.str = str;
}
public Temp getTemp() {
return temp;
}
public void setTemp(Temp temp) {
this.temp = temp;
}
}
class Temp implements Serializable{
}
public class Test {
public static void main(String[] args)throws CloneNotSupportedException,ClassNotFoundException ,IOException{
Prototype pt=new Prototype();
Temp temp=new Temp();
pt.setTemp(temp);
pt.setStr("Hello World");
System.out.println("使用淺克隆方法進行建立對象");
Prototype pt1=(Prototype)pt.clone();
System.out.println("=============================");
System.out.println("比較pt和pt1的str的值：");
System.out.println(pt.getStr());
System.out.println(pt1.getStr());
System.out.println("修改pt1對象中str的值後，比較pt和pt1的str的值：");
pt1.setStr("你好，世界");
System.out.println(pt.getStr());
System.out.println(pt1.getStr());
System.out.println("============================");
System.out.println("比較pt和pt1中temp對象的值");
System.out.println(pt.getTemp());
System.out.println(pt1.getTemp());
System.out.println("使用深克隆方法進行建立對象");
System.out.println("============================");
pt1=(Prototype)pt.deepClone();
System.out.println(pt.getTemp());
System.out.println(pt1.getTemp());
}
}

輸出結果:
使用淺克隆方法進行建立對象
=============================
比較pt和pt1的str的值：
Hello World
Hello World
修改pt1對象中str的值後，比較pt和pt1的str的值：
Hello World
你好，世界
============================
比較pt和pt1中temp對象的值
Temp@affc70
Temp@affc70
使用深克隆方法進行建立對象
============================
Temp@affc70
Temp@15d56d5