上一篇：设计模式篇(Java)：工厂模式

六、原型模式

需求示例—>克隆羊

现在有一只羊tom，姓名为: tom, 年龄为：1，颜色为：白色，请编写程序创建和tom 羊属性完全相同的10只羊。

不使用设计模式（传统方式）实现：

/**
 * @author cVzhanshi
 * @create 2023-04-18 16:12
 */
@Data
@NoArgsConstructor
@AllArgsConstructor
public class Sheep {
    
    
    String name;

    Integer age;

    String color;
}

// ======================================================

/**
 * @author cVzhanshi
 * @create 2023-04-18 16:14
 */
@Slf4j
public class Client {
    
    
    public static void main(String[] args) {
    
    
        Sheep sheep = new Sheep("tom", 1, "白色");

        Sheep sheep1 = new Sheep(sheep.getName(), sheep.getAge(), sheep.getColor());
        Sheep sheep2 = new Sheep(sheep.getName(), sheep.getAge(), sheep.getColor());
        Sheep sheep3 = new Sheep(sheep.getName(), sheep.getAge(), sheep.getColor());

        log.info(sheep.toString());
        log.info(sheep1.toString());
        log.info(sheep2.toString());
        log.info(sheep3.toString());
    }
}

分析：

优点是比较好理解，简单易操作。
在创建新的对象时，总是需要重新获取原始对象的属性，如果创建的对象比较复杂时，效率较低
总是需要重新初始化对象，而不是动态地获得对象运行时的状态, 不够灵活。

优化思路：

Java中Object类是所有类的根类，Object类提供了一个clone()方法，该方法可以将一个Java对象复制一份，但是需要实现clone的Java类必须要实现一个接口Cloneable，该接口表示该类能够复制且具有复制的能力 => 原型模式

6.1 原型模式基本介绍

原型模式(Prototype模式)是指：用原型实例指定创建对象的种类，并且通过拷贝这些原型，创建新的对象
原型模式是一种创建型设计模式，允许一个对象再创建另外一个可定制的对象，无需知道如何创建的细节
工作原理是：通过将一个原型对象传给那个要发动创建的对象，这个要发动创建的对象通过请求原型对象拷贝它们自己来实施创建，即对象.clone()

代码演示：

扫描二维码关注公众号，回复： 15638731 查看本文章

/**
 * @author cVzhanshi
 * @create 2023-04-18 16:12
 */
@Data
@NoArgsConstructor
@AllArgsConstructor
public class Sheep implements Cloneable {
    
    
    String name;

    Integer age;

    String color;

    @Override
    public Sheep clone() {
    
    
        try {
    
    
            Sheep clone = (Sheep) super.clone();
            return clone;
        } catch (CloneNotSupportedException e) {
    
    
            throw new AssertionError();
        }
    }
}

/**
 * @author cVzhanshi
 * @create 2023-04-18 16:14
 */
@Slf4j
public class Client {
    
    
    public static void main(String[] args) {
    
    
        Sheep sheep = new Sheep("tom", 1, "白色");

        Sheep sheep1 = sheep.clone();
        Sheep sheep2 = sheep.clone();

        log.info(sheep.toString()); // tom
        log.info(sheep1.toString()); // tom
        log.info(sheep2.toString()); // tom

        log.info("{}", sheep);
        log.info("{}", sheep1);
        log.info("{}", sheep2);
        log.info("{}", sheep2 == sheep1);   // fasle
        log.info("{}", sheep1.equals(sheep));  // true  因为实体类用了@Data注解，其实是帮帮助我们重写了equals方法的

        sheep.setName("cvzhanshi");
        log.info(sheep.toString());  // cvzhanshi
        log.info(sheep1.toString()); // tom 
        log.info(sheep2.toString()); // tom
    }
}

6.2 jdk代码中的使用

其中spring源码创建bean的代码中就与使用

<bean id="id01" class="com.atguigu.spring.bean.Monster" scope="prototype"/>

其中的scope就可以选择prototype

获取bean的代码

ApplicationContext context = new ClassPathXmlApplicationContext("bean.xml");
context.getBean("id");



==> getBean（）;
@Override
public Object getBean(String name) throws BeansException {
    
    
    assertBeanFactoryActive();
    return getBeanFactory().getBean(name);
}    

==>getBeanFactory().getBean(name);
protected <T> T doGetBean(
    String name, @Nullable Class<T> requiredType, @Nullable Object[] args, boolean typeCheckOnly)
    throws BeansException {
    
    
    //    ...
    if (mbd.isSingleton()) {
    
     // 单例
       
    }

    else if (mbd.isPrototype()) {
    
      // 原型
        // It's a prototype -> create a new instance.  创建新的实例
        Object prototypeInstance = null;
        try {
    
    
            beforePrototypeCreation(beanName);
            prototypeInstance = createBean(beanName, mbd, args);
        }
        finally {
    
    
            afterPrototypeCreation(beanName);
        }
        beanInstance = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
    }

    else {
    
     // 其他
        
    }
    //    ...
}

6.3 浅拷贝和深拷贝

浅拷贝

对于数据类型是基本数据类型的成员变量，浅拷贝会直接进行值传递，也就是将该属性值复制一份给新的对象。
对于数据类型是引用数据类型的成员变量，比如说成员变量是某个数组、某个类的对象等，那么浅拷贝会进行引用传递，也就是只是将该成员变量的引用值（内存地址）复制一份给新的对象。因为实际上两个对象的该成员变量都指向同一个实例。在这种情况下，在一个对象中修改该成员变量会影响到另一个对象的该成员变量值。

上述示例使用的就是浅拷贝，浅拷贝默认使用的是clone()方法来实现的

深拷贝

复制对象的所有基本数据类型的成员变量值
为所有引用数据类型的成员变量申请存储空间，并复制每个引用数据类型成员变量所引用的对象，直到该对象可达的所有对象。也就是说，对象进行深拷贝要对整个对象进行拷贝

深拷贝实现方式1：重写clone方法来实现深拷贝

深拷贝实现方式2：通过对象序列化实现深拷贝

代码演示

重写clone方法来实现深拷贝，把对象里面的引用对象也重写clone

@Data
@NoArgsConstructor
@AllArgsConstructor
public class DeepProtoType implements Serializable, Cloneable {
      
      

    public String name; //String 属性
    public DeepCloneableTarget deepCloneableTarget;  // 引用类型 也需要重写


    @Override
    public DeepProtoType clone() {
      
      
        try {
      
      
            DeepProtoType clone = (DeepProtoType) super.clone();
            // 把重写的值赋值给对象
            clone.deepCloneableTarget = deepCloneableTarget.clone();
            return clone;
        } catch (CloneNotSupportedException e) {
      
      
            throw new AssertionError();
        }
    }
}


@Data
@AllArgsConstructor
@NoArgsConstructor
public class DeepCloneableTarget implements Serializable, Cloneable  {
      
      

    private String cloneName;

    private String cloneClass;


    @Override
    public DeepCloneableTarget clone() {
      
      
        try {
      
      
            return (DeepCloneableTarget) super.clone();
        } catch (CloneNotSupportedException e) {
      
      
            throw new AssertionError();
        }
    }
}

通过对象序列化实现深拷贝

@Data
@NoArgsConstructor
@AllArgsConstructor
public class DeepProtoType implements Serializable {
      
      

    public String name; //String 属性
    public DeepCloneableTarget deepCloneableTarget;  // 引用类型

    public DeepProtoType deepClone() {
      
      
        ObjectOutputStream oos = null;
        ByteArrayOutputStream bos = null;
        ByteArrayInputStream bis = null;
        ObjectInputStream ois = null;
        try {
      
      
            // 序列化
            bos = new ByteArrayOutputStream();
            oos = new ObjectOutputStream(bos);
            oos.writeObject(this);

            bis = new ByteArrayInputStream(bos.toByteArray());
            ois = new ObjectInputStream(bis);
            DeepProtoType deepProtoType = (DeepProtoType) ois.readObject();

            return deepProtoType;
        } catch (Exception e) {
      
      
            e.printStackTrace();
            return null;
        } finally {
      
      
            try {
      
      
                ois.close();
                bis.close();
                oos.close();
                bos.close();
            } catch (IOException e) {
      
      
                throw new RuntimeException(e);
            }
        }
    }
}

测试

@Slf4j
public class Client {
      
      
    public static void main(String[] args) {
      
      

        DeepProtoType deepProtoType = new DeepProtoType("宋江", new DeepCloneableTarget("大牛", "小牛"));

        //方式1 完成深拷贝

		DeepProtoType deepProtoType2 = deepProtoType.deepClone();

		log.info("p.name=" + deepProtoType.getName() + "p.deepCloneableTarget=" + deepProtoType.deepCloneableTarget.hashCode());
		log.info("p2.name=" + deepProtoType2.getName() + "p2.deepCloneableTarget=" + deepProtoType2.deepCloneableTarget.hashCode());

        deepProtoType.getDeepCloneableTarget().setCloneName("fsdf");
        log.info("p.name=" + deepProtoType.getDeepCloneableTarget() + "p.deepCloneableTarget=" + deepProtoType.deepCloneableTarget.hashCode());
        log.info("p2.name=" + deepProtoType2.getDeepCloneableTarget() + "p2.deepCloneableTarget=" + deepProtoType2.deepCloneableTarget.hashCode());
    }
}

测试可知深拷贝后的对象中的引用对象也是一片新的地址，修改原来的对象不影响拷贝的对象。

6.4 原型模式的注意事项和细节

创建新的对象比较复杂时，可以利用原型模式简化对象的创建过程，同时也能够提高效率
不用重新初始化对象，而是动态地获得对象运行时的状态
如果原始对象发生变化(增加或者减少属性)，其它克隆对象的也会发生相应的变化，无需修改代码
在实现深克隆的时候可能需要比较复杂的代码

缺点：需要为每一个类配备一个克隆方法，这对全新的类来说不是很难，但对已有的类进行改造时，需要修改其源代码，违背了ocp原则

设计模式篇(Java)：原型模式

六、原型模式

6.1 原型模式基本介绍

6.2 jdk代码中的使用

6.3 浅拷贝和深拷贝

6.4 原型模式的注意事项和细节

猜你喜欢