展开目录 返回顶部 到达底部

设计模式(3)-原型模式与浅拷贝和深拷贝

Author: Date: 2020-09-05  9:53:14 Category: 设计模式 Words:1,969 Times:7min User:

概念

在有些系统中，存在大量相同或相似对象的创建问题，如果用传统的构造函数来创建对象，会比较复杂且耗时耗资源，
用原型模式生成对象就很高效，就像孙悟空拔下猴毛轻轻一吹就变出很多孙悟空一样简单。

原型模式定义：用一个已经创建的实例作为原型，通过复制该原型对象来创建一个和原型相同或相似的新对象

模拟需求

现在有一辆车，他的名字叫做哈啰单车，它的价格是2元/1小时，请编写程序创建多辆哈啰单车

简单分析后涉及到以下几个类：

  • 车辆类 Vehicle.java
  • 测试类 Client.java

传统方式

先来看下最容易理解的方式：

1
2
3
4
5
6
7
public class Vehicle {

    private String name;
    private double price;

    /**getter&setter&toString.......*/
}
1
2
3
4
5
6
7
8
9
10
public class Client {
    public static void main(String[] args) {
        Vehicle vehicle = new Vehicle("哈啰单车", 2.0);
        Vehicle vehicle1 = new Vehicle(vehicle.getName(),vehicle.getPrice());
        Vehicle vehicle2 = new Vehicle(vehicle.getName(),vehicle.getPrice());
        System.out.println(vehicle.hashCode());
        System.out.println(vehicle1.hashCode());
        System.out.println(vehicle2.hashCode());
    }
}

执行测试类代码可以看到创建了另外3个属性相同但引用完全不同的哈啰单车

执行结果如下：

1
2
3
1836019240
325040804
1173230247

原型模式

上面的对象复制方式是比较容易理解的，但是如果要复制很多对象时，每次都要get/set ，工作量必然很大

那有没有其他的复制方式吗？当然有了，设计模式中有一种原型模式的设计理念

原型模式的概念我们上文也有提到：用一个已经创建的实例作为原型，通过复制该原型对象来创建一个和原型相同或相似的新对象

原型模式是一种创建型设计模式，创建方无需了解创建的细节，原型模式所涉及到的角色和类图如下

  • 抽象原型类Prototype：抽象原型类，声明一个克隆自己的方法
  • 具体的原型实现类ConcretePrototype：具体的原型类，实现克隆自己的方法
  • 客户类Client：客户调用方，克隆对象

原型模式

原型模式示例

对于模式场景中，要求复制多个不同的对象的需求，使用原型模式则有了新的解决方案如下

Java中Object类提供一个clone方法。该方法可以将一个Java对象复制一份。
如果某一个要使用clone方法，必须先实现Cloneable接口，Cloneable接口表示该类能够复制并且具有复制能力

涉及到的类和角色如下：

  • 抽象原型类：Cloneable接口，声明了clone方法
  • 具体原型类：Vehicle类，有自己的对象属性，并且实现了clone方法
  • Client：调用测试

只需要将上面的代码加以修改即可：

1
2
3
4
5
6
7
8
9
10
11
12
public class Vehicle implements Cloneable {

    private String name;
    private double price;

    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
    
    /**getter&setter&toString.......*/
}
1
2
3
4
5
6
7
8
9
10
11
public class Client {
    public static void main(String[] args) throws CloneNotSupportedException {
        Vehicle vehicle = new Vehicle("哈啰单车", 2.0);
        //使用clone方法进行对象复制
        Vehicle vehicle1 = (Vehicle) vehicle.clone();
        Vehicle vehicle2 = (Vehicle) vehicle.clone();
        System.out.println(vehicle.hashCode());
        System.out.println(vehicle1.hashCode());
        System.out.println(vehicle2.hashCode());
    }
}

依旧执行测试方法，来看看通过clone方法是否复制出了不同的对象

执行结果：

1
2
3
1836019240
325040804
1173230247

通过上面的一个小场景，对原型模式进行了简单的演示。但是上面的原型模式在一些特殊情况下可能就会出现问题

模拟需求2

现在有一车辆类，他有名称、单价、所属公司三个属性；所属公司对象包含了公司名称属性，请编写程序创建多辆美团单车，单价为2元/小时，所属公司为美团点评

简单分析后涉及到以下几个类：

  • 车辆类 Vehicle.java
  • 公司类 Company.java
  • 测试类 Client.java

在上文原型模式的代码中加上Company类的代码和Vehicle类的公司属性后如下

1
2
3
4
5
public class Company {
    private String name;

    /**getter&setter&toString.......*/
}
1
2
3
4
5
6
7
8
9
10
11
12
13
public class Vehicle implements Cloneable {

    private String name;
    private double price;
    private Company company;

    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
    
    /**getter&setter&toString.......*/
}

Client代码如下

1
2
3
4
5
6
7
8
9
10
11
public class Client {
    public static void main(String[] args) throws CloneNotSupportedException {
        Vehicle vehicle = new Vehicle("美团单车", 2.0, new Company("美团点评"));

        Vehicle vehicle1 = (Vehicle) vehicle.clone();
        Vehicle vehicle2 = (Vehicle) vehicle.clone();
        System.out.println("vehicle.hashCode(): "+vehicle.hashCode()+" company.hashCode(): "+ vehicle.getCompany().hashCode());
        System.out.println("vehicle1.hashCode(): "+vehicle1.hashCode()+" company.hashCode(): "+ vehicle1.getCompany().hashCode());
        System.out.println("vehicle2.hashCode(): "+vehicle2.hashCode()+" company.hashCode(): "+ vehicle2.getCompany().hashCode());
    }
}

观察克隆对象后的输出结果，你就会发现问题所在

1
2
3
vehicle.hashCode(): 1836019240 company.hashCode(): 325040804
vehicle1.hashCode(): 1173230247 company.hashCode(): 325040804
vehicle2.hashCode(): 856419764 company.hashCode(): 325040804

三个车辆对象的hashCode都不相同，说明有被成功克隆，但是其中的公司属性（对象类型）的hashCode并没有被同步克隆，内容中只有一份Company对象

相当于这次的克隆，内存中创建了三个不同车辆（Vehicle）对象，但是公司（Company）对象只有一个，被三个车辆对象所引用。

理论上，在创建了第一个车辆对象后，连续克隆两次后，内存中应该有3个车辆对象和3个公司对象。

这里就出现了原型模式中会存在的

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

# 浅拷贝&深拷贝

关于浅拷贝的描述：

- 数据类型为基本类型的成员变量，在调用默认clone方法后，会进行浅拷贝，即将该属性的值复制一份给新的对象
- 数据类型为引用类型的成员变量，比如一个数组、一个对象，在调用默认的clone方法后，只会将成员变量的引用地址指向新的对象，而不会克隆新的成员变量对象

这种现象即为`浅拷贝`，上面的几个例子严格来说都属于浅拷贝，因为都没有去考虑成员变量为引用类型时的对象克隆

`深拷贝`自然是解决了浅拷贝的缺陷，对整个对象进行完全深度的对象复制，包括对象的引用类型和基本类型成员变量

# 深拷贝应用

针对模拟需求2，使用深拷贝的方式进行代码实现

实现思路：Company和Vehicle都实现Cloneable接口，重写Vehicle的clone方法

```java
public class Company  implements Cloneable {
    private String name;
    
    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
    /**getter&setter&toString.......*/
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public class Vehicle implements Cloneable {

    private String name;
    private double price;
    private Company company;

    @Override
    protected Object clone() throws CloneNotSupportedException {
        Vehicle vehicle = (Vehicle) super.clone();
        vehicle.setCompany((Company) this.company.clone());
        return vehicle;
    }
    
    /**getter&setter&toString.......*/
}

Client代码无需变动，执行Client进行测试，结果如下：

1
2
3
vehicle.hashCode(): 1836019240 company.hashCode(): 325040804
vehicle1.hashCode(): 1173230247 company.hashCode(): 856419764
vehicle2.hashCode(): 621009875 company.hashCode(): 1265094477

可以看到三个对象的对象成员属性明显都是不同的，说明做到了深拷贝

常见的原型模式的运用

Spring中配置bean的时候，scope属性可以配置一个prototype值，该值指定该bean的创建是使用原型模式

1
2
//示例：
    <bean id="userDaoImpl"  scope="prototype" class="com.larscheng.www.dao.impl.UserDaoImpl"/>

当通过getBean方法获取bean时，可以看到源码中对于scope属性进行了处理

结语

  • 当我们要创建新的对象过于复杂时，可以考虑使用原型模式来进行创建
  • 使用原型模式时，需要考虑到浅拷贝和深拷贝
---------- 😏本文结束  感谢您的阅读😏 ----------
标签: 设计模式
返回    /   首页
评论