Android 架构师之路9 设计模式之原型模式

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);
    }
}

推荐阅读更多精彩内容