原型模式（Prototype Pattern） 是一种创建型设计模式，用于通过复制现有对象的原型来创建新的对象。这种模式的主要优点是可以在运行时动态地创建新的对象，而无需依赖于类的实例化。
动机
在某些情况下，我们需要在运行时动态地创建对象，但是这些对象的创建成本较高，或者需要考虑对象的生命周期等因素。为了满足这些要求，我们可以使用原型模式来复制现有对象，从而避免直接创建新对象的开销。
结构
原型模式的结构包括以下几个角色：
Prototype（原型）：定义一个接口或抽象类，用于声明克隆方法。
ConcretePrototype（具体原型）：实现 Prototype 接口或继承抽象原型，并提供具体的克隆逻辑。
实现
原型设计模式主要的目的就是复制现有的对象，对象的拷贝分为 浅拷贝 和 深拷贝。
浅拷贝：浅拷贝（Shallow Copy）是指创建一个新对象，这个对象有原始对象属性值的一份精确拷贝。如果属性是基本数据类型，那么拷贝的就是基本数据类型的值；如果属性是引用类型，那么拷贝的就是引用的地址。因此，如果在原始对象和拷贝对象中对引用类型的属性进行更改，这两个对象之间的互不影响。
深拷贝：深拷贝（Deep Copy）是指创建一个新对象，这个对象有原始对象属性值的完整副本。如果属性是基本数据类型，那么拷贝的就是基本数据类型的值；如果属性是引用类型，那么拷贝的就是引用的对象的一个全新的副本。因此，如果在原始对象和拷贝对象中对引用类型的属性进行更改，这两个对象之间互不影响。
浅拷贝的实现
以下是几个使用浅拷贝的场景：
原型模式：在创建一个新对象时，如果该对象和已有对象的属性相同，可以使用浅拷贝来复制已有对象的属性，而不必重新创建一个新对象。
缓存数据：当需要缓存某些数据时，可以使用浅拷贝来创建缓存对象。如果原始对象不再使用，可以直接将其赋值为 null，而不必担心缓存对象的引用被同时置为 null。
复制属性：当需要将一个对象的属性值复制到另一个对象时，可以使用浅拷贝。例如，将一个对象的属性值复制到一个 DTO（数据传输对象）中，以传递给其他系统或服务。
浅拷贝实现 - 直接赋值
import java.util.ArrayList;
import java.util.List;
class Song {
String title;
String artist;
Song(String title, String artist) {
this.title = title;
this.artist = artist;
}
}
@Data
public class Playlist {
private Long id;
private String name;
private List<Song> songs = new ArrayList<>();
public Playlist() {
}
public void add(Song song){
songs.add(song);
}
public Playlist(Playlist sourcePlayList) {
this.id = sourcePlayList.getId();
this.name = sourcePlayList.getName();
this.songs = sourcePlayList.getSongs();
}
public static void main(String[] args) {
Playlist playlist = new Playlist();
playlist.setId(1L);
playlist.setName("杰伦");
playlist.add(new Song("稻香","杰伦"));
playlist.add(new Song("迷迭香","杰伦"));
playlist.add(new Song("七里香","杰伦"));
// 浅拷贝后的最喜爱的专辑
Playlist favouriteList = new Playlist(playlist);
favouriteList.add(new Song("曹操","林俊杰"));
System.out.println(favouriteList);
}
}
浅拷贝实现 - 实现 Cloneable 接口
在 java 中，有提供一个 Cloneable 接口用于实现对象拷贝的支持
Cloneable：在 Java 中，Cloneable 是一个标记接口，用于表示一个类的对象是可以被克隆的。通过实现 Cloneable 接口，类表明它允许克隆其对象。然后，可以通过调用 clone () 方法来创建对象的副本。
所以我们的对象在实现了 Cloneable 接口后，通过对象调用 clone() 方法即可完成浅拷贝
package xyz.xiaolinz.demo.prototype.shallowcopy;
import java.io.Serializable;
/**
* demo2 - 浅拷贝实现，实现Cloneable接口，重写clone方法
*
* <p>1. 实现Cloneable接口 2. 重写clone方法 3. 重写clone方法时，调用父类的clone方法 4. 重写clone方法时，将返回值强转为当前类
*
* @author huangmuhong
* @date 2023/8/8
*/
public class PlayListCloneable extends PlayList implements Cloneable, Serializable {
public static void main(String[] args){
PlayListCloneable playListCloneable = new PlayListCloneable();
try {
PlayListCloneable clone = (PlayListCloneable) playListCloneable.clone();
System.out.println(playListCloneable == clone);
} catch (CloneNotSupportedException e) {
e.printStackTrace();
}
}
@Override
protected Object clone() throws CloneNotSupportedException {
return super.clone();
}
}
package xyz.xiaolinz.demo.prototype.shallowcopy;
/**
* @author huangmuhong
* @date 2023/8/8
*/
public class Song {
private final String title;
private final String artist;
public Song(String title, String artist) {
this.title = title;
this.artist = artist;
}
}
package xyz.xiaolinz.demo.prototype.shallowcopy;
import java.util.ArrayList;
import java.util.List;
import lombok.Data;
import lombok.NoArgsConstructor;
/**
*
* demo1 - 浅拷贝实现，通过直接赋值实现
*
* @author huangmuhong
* @date 2023/8/8
*/
@Data
@NoArgsConstructor
public class PlayList {
private Long id;
private String name;
private List<Song> songs = new ArrayList<>();
public PlayList(PlayList playList) {
this.id = playList.id;
this.name = playList.name;
this.songs = playList.songs;
}
public static void main(String[] args){
final var playList = new PlayList();
playList.setId(1L);
playList.setName("My Favorite");
playList.addSong(new Song("song1", "artist1"));
playList.addSong(new Song("song2", "artist2"));
playList.addSong(new Song("song3", "artist3"));
System.out.println(playList);
// 浅拷贝
final var playListCopy = new PlayList(playList);
playListCopy.setName("My Favorite Copy");
System.out.println(playListCopy);
}
public void addSong(Song song) {
songs.add(song);
}
}
深拷贝的实现
深拷贝的实现，通常有两个思路，一个是递归克隆，一个是使用序列化的手段。
深拷贝的实现 - 递归克隆
在需要克隆以及起组合、依赖的类都实现 Cloneable 接口，并在调用方的 clone 方法递归的循环去调用组合和依赖对象的 clone 方法
package xyz.xiaolinz.demo.prototype.deepcopy;
import lombok.Data;
/**
* 产品
*
* @author huangmuhong
* @date 2023/08/08
*/
@Data
public class Product implements Cloneable {
private String name;
private Double price;
private Integer stock;
@Override
protected Product clone() throws CloneNotSupportedException {
return ((Product) super.clone());
}
}
package xyz.xiaolinz.demo.prototype.deepcopy;
import lombok.Data;
/**
* 促销规则
*
* @author huangmuhong
* @date 2023/08/08
* @see Cloneable
*/
@Data
public class PromotionRule implements Cloneable {
private String type;
private Double discount;
private Product product;
@Override
protected PromotionRule clone() throws CloneNotSupportedException {
final var promotionRule = (PromotionRule) super.clone();
// 在这里，我们需要将product也进行深拷贝
promotionRule.setProduct(product.clone());
return promotionRule;
}
}
package xyz.xiaolinz.demo.prototype.deepcopy;
import java.util.Date;
import java.util.List;
import lombok.Data;
/**
* 促销活动
*
*
* @author huangmuhong
* @date 2023/08/08
*/
@Data
public class PromotionEvent implements Cloneable {
private String name;
private Date startDate;
private Date endDate;
private List<PromotionRule> rules;
@Override
protected PromotionEvent clone() throws CloneNotSupportedException {
final var clone = ((PromotionEvent) super.clone());
// Date 默认实现了 Cloneable，可以直接调用以实现拷贝
clone.setStartDate((Date) startDate.clone());
clone.setEndDate((Date) endDate.clone());
// rules 需要递归拷贝
if (rules != null) {
for (int i = 0; i < rules.size(); i++) {
rules.add(i,rules.get(i).clone());
}
}
return clone;
}
}
浅拷贝的实现 - 序列化方式
深拷贝的通用做法就是使用对象想对原型对象进行序列化，再对序列化后的二进制流执行反序列化操作，就可以得到一个完完全全相同的对象，这种序列化的方式有很多比如先转为 json，在转成内存模型的对象，也是可以的。
@Test
public void deepCopyTest2() throws CloneNotSupportedException, IOException, ClassNotFoundException {
User user = new User(12, "zhangsan");
user.setDog(new Dog(2));
// 将对象写到字节数组当中
ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
ObjectOutputStream objectOutputStream = new ObjectOutputStream(outputStream);
objectOutputStream.writeObject(user);
// 获取字节数组
byte[] bytes = outputStream.toByteArray();
// 用输入流读出来
ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(bytes);
ObjectInputStream objectInputStream = new ObjectInputStream(byteArrayInputStream);
Object object = objectInputStream.readObject();
User user1 = (User) object;
user.setAge(44);
user.getDog().setAge(11);
System.out.println(user);
System.out.println(user1);
}
评论区