Android 架构师之路 目录

前言

原型模式（Prototype Pattern）是用于创建重复的对象，同时又能保证性能。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。
这种模式是实现了一个原型接口，该接口用于创建当前对象的克隆。当直接创建对象的代价比较大时，则采用这种模式。例如，一个对象需要在一个高代价的数据库操作之后被创建。我们可以缓存该对象，在下一个请求时返回它的克隆，在需要的时候更新数据库，以此来减少数据库调用。

1、原型模式特征

1.1 原型模式UML图

原型模式UML图

1.2 角色划分

• Prototype：（克隆接口）要求是抽象（抽象类、接口）
• ConcretePrototype：被复制的对象。此角色需要实现抽象的原型角色所要求的接口。
• Client：客户端类向原型管理器提出创建对象的请求。

1.3 使用场景

1、资源优化场景。
2、类初始化需要消化非常多的资源，这个资源包括数据、硬件资源等。
3、性能和安全要求的场景。
4、通过 new 产生一个对象需要非常繁琐的数据准备或访问权限，则可以使用原型模式。
5、一个对象多个修改者的场景。
6、一个对象需要提供给其他对象访问，而且各个调用者可能都需要修改其值时，可以考虑使用原型模式拷贝多个对象供调用者使用。
7、在实际项目中，原型模式很少单独出现，一般是和工厂方法模式一起出现，通过 clone 的方法创建一个对象，然后由工厂方法提供给调用者。原型模式已经与 Java 融为浑然一体，大家可以随手拿来使用。

2、代码实现

2.1 非原型模式

OrderService

/**
 * Created by Xionghu on 2017/7/5.
 * Desc:
 */

public class OrderService {
    /**
     * 订单拆分
     *
     * 需求：订单数量超过了100，我就拆分？
     *
     * @param order
     * @return
     */
    public static List<IOrder> getOrder(IOrder order){
        List<IOrder> orderList = new ArrayList<IOrder>();
        //订单数量大于100就要进行拆分
        IOrder newOrder = null;
        while (order.getOrderNumber() > 100)
        {
            if(order instanceof PersonalOrder)
            {
                PersonalOrder personalOrder = (PersonalOrder) order;
                PersonalOrder newPersonalOrder = new PersonalOrder();
                newPersonalOrder.setOrderName(personalOrder.getOrderName());
                newPersonalOrder.setOrderUserName(personalOrder.getOrderUserName());
               // newPersonalOrder.setOrderNumber(100);
                newOrder = newPersonalOrder;
                //例如：在android当中，我们经常使用Intent，一般情况都会new Intent();
            }else if(order instanceof EnterpriseOrder){
                EnterpriseOrder enterpriseOrder = (EnterpriseOrder) order;
                EnterpriseOrder newEnterpriseOrder = new EnterpriseOrder();
                newEnterpriseOrder.setOrderName(enterpriseOrder.getOrderName());
                newEnterpriseOrder.setOrderCompany(enterpriseOrder
                        .getOrderCompany());
                newOrder = newEnterpriseOrder;
            }
            //拆分
            newOrder.setOrderNumber(100);
            orderList.add(newOrder);
            //改变原来的订单数量
            order.setOrderNumber(order.getOrderNumber()-100);
        }
        orderList.add(order);

        return orderList;
    }

}

注意：将来随着不断版本迭代，订单种类会不断增加，这样写导致if 、else if语句也随之增加

造成可读性差、耦合度高的问题

2.2 原型模式写法

OrderService

public class OrderService {
    /**
     * 订单拆分
     *
     * 需求：订单数量超过了100，我就拆分？
     *
     * @param order
     * @return
     */
    public static List<IOrder> getOrder(IOrder order){
        List<IOrder> orderList = new ArrayList<IOrder>();
        //订单数量大于100就要进行拆分
        IOrder newOrder = null;
        while (order.getOrderNumber() > 100)
        {
            newOrder = (IOrder)order.orderClone();
            //拆分
            newOrder.setOrderNumber(100);
            orderList.add(newOrder);
            //改变原来的订单数量
            order.setOrderNumber(order.getOrderNumber()-100);
        }
        orderList.add(order);

        return orderList;
    }

}

通过 newOrder = (IOrder)order.orderClone();直接获取到order的返回类型 ， 结构很清晰

Prototype(IOrder )

public interface IOrderClonable {
    public IOrderClonable orderClone();
}

public interface IOrder extends IOrderClonable {
    /**
     * 设置订单数量
     * @param number
     * @return
     */
    public void setOrderNumber(int number);

    /**
     * 获取订单数量
     * @return
     */
    public int getOrderNumber();
}

ConcretePrototype

public class PersonalOrder implements IOrder {
    private String orderName;
    private String orderUserName;
    private int orderNumber;

    @Override
    public int getOrderNumber() {
        return orderNumber;
    }

    @Override
    public void setOrderNumber(int number) {
        this.orderNumber = number;
    }

    public String getOrderName() {
        return orderName;
    }

    public void setOrderName(String orderName) {
        this.orderName = orderName;
    }
    public String getOrderUserName() {
        return orderUserName;
    }

    public void setOrderUserName(String orderUserName) {
        this.orderUserName = orderUserName;
    }

    @Override
    public String toString() {
        return "PersonalOrder{" +
                "orderName='" + orderName + '\'' +
                ", orderUserName='" + orderUserName + '\'' +
                ", orderNumber=" + orderNumber +
                '}';
    }

    @Override
    public IOrderClonable orderClone() {
        PersonalOrder personalOrder = new PersonalOrder();
        personalOrder.setOrderName(orderName);
        personalOrder.setOrderUserName(orderUserName);
        return personalOrder;
    }
}

/**
 * 企业订单
 * Created by Xionghu on 2017/7/5.
 * Desc:
 */

public class EnterpriseOrder implements IOrder {
    private String orderName;
    private String orderCompany;
    private int orderNumber;

    public String getOrderName() {
        return orderName;
    }

    public void setOrderName(String orderName) {
        this.orderName = orderName;
    }

    public String getOrderCompany() {
        return orderCompany;
    }

    public void setOrderCompany(String orderCompany) {
        this.orderCompany = orderCompany;
    }

    @Override
    public int getOrderNumber() {
        return orderNumber;
    }

    @Override
    public void setOrderNumber(int number) {
        this.orderNumber = number;
    }

    @Override
    public String toString() {
        return "EnterpriseOrder{" +
                "orderName='" + orderName + '\'' +
                ", orderCompany='" + orderCompany + '\'' +
                ", orderNumber=" + orderNumber +
                '}';
    }
    @Override
    public IOrder orderClone() {
        EnterpriseOrder enterpriceOrder = new EnterpriseOrder();
        enterpriceOrder.setOrderCompany(orderCompany);
        enterpriceOrder.setOrderName(orderName);
        return enterpriceOrder;
    }
}

public class OrderTest {
    public static void main(String[] args) {
        PersonalOrder personalOrder = new PersonalOrder();
        personalOrder.setOrderName("手机");
        personalOrder.setOrderUserName("kpioneer");
        personalOrder.setOrderNumber(999);


        EnterpriseOrder enterpriseOrder = new EnterpriseOrder();
        enterpriseOrder.setOrderName("电脑");
        enterpriseOrder.setOrderCompany("haocai");
        enterpriseOrder.setOrderNumber(666);
        //将来随着不断版本迭代，订单种类会不断增加

        // 获取拆分后的订单
        // 结果是拆分为10个订单
        List<IOrder> order = OrderService.getOrder(enterpriseOrder);
        for (IOrder iOrder : order) {
            System.out.println("订单信息:" + iOrder.toString());
        }
    }
}

结果输出：

订单信息:EnterpriseOrder{orderName='电脑', orderCompany='haocai', orderNumber=100}
订单信息:EnterpriseOrder{orderName='电脑', orderCompany='haocai', orderNumber=100}
订单信息:EnterpriseOrder{orderName='电脑', orderCompany='haocai', orderNumber=100}
订单信息:EnterpriseOrder{orderName='电脑', orderCompany='haocai', orderNumber=100}
订单信息:EnterpriseOrder{orderName='电脑', orderCompany='haocai', orderNumber=100}
订单信息:EnterpriseOrder{orderName='电脑', orderCompany='haocai', orderNumber=100}
订单信息:EnterpriseOrder{orderName='电脑', orderCompany='haocai', orderNumber=66}

3、Android中源码使用

原型模式中的拷贝分为"浅拷贝"和"深拷贝":
浅拷贝: 对值类型的成员变量进行值的复制,对引用类型的成员变量只复制引用,不复制引用的对象.
深拷贝: 对值类型的成员变量进行值的复制,对引用类型的成员变量也进行引用对象的复制.

clone源码

  protected Object clone() throws CloneNotSupportedException {
        if (!(this instanceof Cloneable)) {
            throw new CloneNotSupportedException("Class " + getClass().getName() +
                                                 " doesn't implement Cloneable");
        }

        return internalClone();
    }

    /*
     * Native helper method for cloning.
     */
    private native Object internalClone();

Java 默认的克隆是浅度克隆

    ArrayList<String>list1= new ArrayList<>();
    ArrayList<String>list2 = (ArrayList<String>) list1.clone();

    public Object clone() {
        try {
            ArrayList<?> v = (ArrayList<?>) super.clone();
            v.elementData = Arrays.copyOf(elementData, size);
            v.modCount = 0;
            return v;
        } catch (CloneNotSupportedException e) {
            // this shouldn't happen, since we are Cloneable
            throw new InternalError(e);
        }
    }

3.1 Java提供原型模式使用

Prototype(AbsOrder )

 public abstract class AbsOrder  implements Cloneable {
    @Override
    protected AbsOrder clone() throws CloneNotSupportedException {
        return (AbsOrder) super.clone();
    }

    /**
     * 设置订单数量
     * @param number
     * @return
     */
    public abstract void setOrderNumber(int number);

    /**
     * 获取订单数量
     * @return
     */
    public abstract int getOrderNumber();
}

OrderService

public class OrderService {
    /**
     * 订单拆分
     *
     * 需求：订单数量超过了100，我就拆分？
     *
     * @param order
     * @return
     */
    public static List<AbsOrder> getOrder(AbsOrder order) throws CloneNotSupportedException {
        List<AbsOrder> orderList = new ArrayList<AbsOrder>();
        //订单数量大于100就要进行拆分
        AbsOrder newOrder = null;
        while (order.getOrderNumber() > 100)
        {
            newOrder= order.clone();

            //拆分
            newOrder.setOrderNumber(100);
            orderList.add(newOrder);
            //改变原来的订单数量
            order.setOrderNumber(order.getOrderNumber()-100);
        }
        orderList.add(order);

        return orderList;
    }

}

ConcretePrototype

public class EnterpriseOrder extends AbsOrder {
    private String orderName;
    private String orderCompany;
    private int orderNumber;

    public String getOrderName() {
        return orderName;
    }

    public void setOrderName(String orderName) {
        this.orderName = orderName;
    }

    public String getOrderCompany() {
        return orderCompany;
    }

    public void setOrderCompany(String orderCompany) {
        this.orderCompany = orderCompany;
    }

    @Override
    public int getOrderNumber() {
        return orderNumber;
    }

    @Override
    public void setOrderNumber(int number) {
        this.orderNumber = number;
    }

    @Override
    public String toString() {
        return "EnterpriseOrder{" +
                "orderName='" + orderName + '\'' +
                ", orderCompany='" + orderCompany + '\'' +
                ", orderNumber=" + orderNumber +
                '}';
    }
    @Override
    protected AbsOrder clone() throws CloneNotSupportedException {
        return (AbsOrder) super.clone();
    }
}

3.2 Android中使用

public class OneActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        Intent intent = getIntent();
        intent.getStringExtra("name");

        //启动一个新的Activity
        // intent.clone()自动帮我们clone Extra参数（name）
        Intent intent2 = (Intent) intent.clone();
        intent2.setClass(this,TwoActivity.class);
        startActivity(intent2);
    }
}