网站备案域名更改公司,小说网站的会员充值是怎么做的,哈尔滨做网站需要多少钱,微信网站后台4. 原型设计模式
4.1 浅拷贝
在Java编程中#xff0c;浅拷贝是指在复制对象时#xff0c;只复制对象的基本数据类型的值和引用类型的地址#xff0c;不复制引用类型指向的对象本身。浅拷贝可以用于一些简单的场景#xff0c;例如对象的基本属性不包含其他对象的引用类型浅拷贝是指在复制对象时只复制对象的基本数据类型的值和引用类型的地址不复制引用类型指向的对象本身。浅拷贝可以用于一些简单的场景例如对象的基本属性不包含其他对象的引用类型或者不需要修改对象引用类型所指向的对象。
以下是几个使用浅拷贝的场景
原型模式在创建一个新对象时如果该对象和已有对象的属性相同可以使用 浅拷贝来复制已有对象的属性而不必重新创建一个新对象。缓存数据当需要缓存某些数据时可以使用浅拷贝来创建缓存对象。如果原始 对象不再使用可以直接将其赋值为null而不必担心缓存对象的引用被同时置 为null。复制属性当需要将一个对象的属性值复制到另一个对象时可以使用浅拷贝。 例如将一个对象的属性值复制到一个DTO数据传输对象中以传递给其他 系统或服务。
4.1.1 直接赋值实现
我们举一个很简单的例子使用浅拷贝来复制一个音乐播放列表以便为用户创建一个新的播放列表同时保留原始播放列表的内容。
/*** 类描述歌曲类** Author crysw* Version 1.0* Date 2023/11/27 22:31*/
public class Song {private String title;private String artist;public Song(String title, String artist) {this.title title;this.artist artist;}Overridepublic String toString() {return Song{ title title \ , artist artist \ };}
}/*** 类描述播放列表** Author crysw* Version 1.0* Date 2023/11/27 22:33*/
Data
public class Playlist {private Long id;private String name;private ListSong songs new ArrayList();public Playlist() {}public void add(Song song) {songs.add(song);}/*** 浅拷贝source的属性值给当前对象** param source*/public Playlist(Playlist source) {this.id source.getId();this.name source.getName();this.songs source.getSongs();}
}测试直接赋值实现的浅拷贝
/*** 类描述原型设计模式测试案例** Author crysw* Version 1.0* Date 2023/11/27 22:35*/
Slf4j
public class PrototypePatternTest {/*** 测试自定义浅拷贝*/Testpublic void test() {Playlist playlist new Playlist();playlist.setId(1L);playlist.setName(周杰伦);playlist.add(new Song(稻香, 周杰伦));playlist.add(new Song(迷迭香, 周杰伦));playlist.add(new Song(七里香, 周杰伦));log.info(before copy,playlist:{}, playlist);// 浅拷贝Playlist favouriteList new Playlist(playlist);log.info(before copy,favouriteList:{}, playlist);favouriteList.add(new Song(曹操, 林俊杰));// favouriteList添加了一首song因为favouriteList#songs就是指向的playlist#songs所以当favouriteList#songs发生改变playlist#songs也会随之改变log.info(after copy,playlist:{}, playlist);log.info(after copy,favouriteList:{}, favouriteList);}
}我们创建了一个原始播放列表然后使用浅拷贝创建了一个新的播放列表。注意我们只复制了歌曲列表的引用而不是歌曲列表本身。这意味着当我们向新播放列表添加歌曲时原始播放列表的歌曲列表也会受到影响。
4.1.2 clone方法实现
java中给我们提供了Cloneable接口可以帮助我们很简单的实现浅拷贝
/*** 类描述播放列表, Cloneable接口实现浅拷贝, 需要重写clone()方法** Author crysw* Version 1.0* Date 2023/11/27 22:33*/
Data
public class Playlist2 implements Serializable, Cloneable {private Long id;private String name;private ListSong songs new ArrayList();public Playlist2() {}public void add(Song song) {songs.add(song);}/*** 浅拷贝** return* throws CloneNotSupportedException*/Overridepublic Object clone() throws CloneNotSupportedException {return super.clone();}
}clone方法实现浅拷贝的测试用例
/*** 测试Cloneable接口实现的浅拷贝** throws CloneNotSupportedException*/
Test
public void test2() throws CloneNotSupportedException {Playlist2 playlist new Playlist2();playlist.setId(1L);playlist.setName(周杰伦);playlist.add(new Song(稻香, 周杰伦));playlist.add(new Song(迷迭香, 周杰伦));playlist.add(new Song(七里香, 周杰伦));log.info(before copy,playlist:{}, playlist);// 浅拷贝Playlist2 favouriteList (Playlist2) playlist.clone();log.info(before copy,favouriteList:{}, playlist);favouriteList.add(new Song(曹操, 林俊杰));// favouriteList添加了一首song因为favouriteList#songs就是指向的playlist#songs所以当favouriteList#songs发生改变playlist#songs也会随之改变log.info(after copy,playlist:{}, playlist);log.info(after copy,favouriteList:{}, favouriteList);
}在选择使用深拷贝还是浅拷贝时我们需要根据具体场景来决定。如果对象的属性包含引用类型对象且需要修改这些对象的属性时应该使用深拷贝如果对象的属性不包含引用类型对象或不需要修改这些对象的属性时可以使用浅拷贝。
4.2 深拷贝
4.2.1 递归克隆
在电商领域一个典型的场景是创建复杂的商品促销活动假设我们有Product、PromotionRule、PromotionEvent类。
Product包含商品的基本信息如名称价格库存等PromotionRule包含促销规则的详细信息如折扣优惠券等PromotionEvent包含促销活动的基本信息如名称、开始时间、结束时间以及该活动相关的所有促销规则。
为了实现这个案例我们首先需要定义一些实体类每个实体类都要实现Cloneable接口
Product类
/*** 类描述产品类实现Cloneable接口用来拷贝** Author crysw* Version 1.0* Date 2023/11/29 23:22*/
Data
AllArgsConstructor
NoArgsConstructor
public class Product implements Cloneable, Serializable {/*** 商品名称*/private String name;/*** 价格*/private double price;/*** 库存*/private int stock;/*** 重写clone方法** return* throws CloneNotSupportedException*/Overrideprotected Product clone() {try {return (Product) super.clone();} catch (CloneNotSupportedException e) {e.printStackTrace();return null;}}
}PromotionRulel类
/*** 类描述促销规则类也实现cloneable接口用来拷贝** Author crysw* Version 1.0* Date 2023/11/29 23:25*/
Data
NoArgsConstructor
AllArgsConstructor
public class PromotionRule implements Cloneable, Serializable {/*** 促销类型*/private String type;/*** 优惠折扣*/private double discount;/*** 促销产品*/private Product product;/*** 重写clone方法** return*/Overrideprotected PromotionRule clone() {try {PromotionRule promotionRule (PromotionRule) super.clone();// Product是引用类型需要进行深拷贝Product cloneProduct product.clone();promotionRule.setProduct(cloneProduct);return promotionRule;} catch (CloneNotSupportedException e) {e.printStackTrace();return null;}}
}PromotionEvent类
/*** 类描述促销活动类实现cloneable接口进行拷贝用** Author crysw* Version 1.0* Date 2023/11/29 23:29*/
Data
AllArgsConstructor
NoArgsConstructor
public class PromotionEvent implements Cloneable {/*** 促销活动名称*/private String name;/*** 促销开始日期*/private String startDate;/*** 促销结束日期*/private String endDate;/*** 促销规则*/private ListPromotionRule rules;Overridepublic PromotionEvent clone() {try {PromotionEvent promotionEvent (PromotionEvent) super.clone();// 引用类型需要进行深拷贝ListPromotionRule cloneRules new ArrayList();for (PromotionRule rule : this.rules) {PromotionRule cloneRule rule.clone();cloneRules.add(cloneRule);}promotionEvent.setRules(cloneRules);return promotionEvent;} catch (CloneNotSupportedException e) {e.printStackTrace();return null;}}
}已经为每个实体类实现了深拷贝方法。假设我们需要为不同的商品创建相似的促销活动我们可以使用深拷贝来实现
/*** 类描述原型设计模式测试案例** Author crysw* Version 1.0* Date 2023/11/27 22:35*/
Slf4j
public class PrototypePatternTest {/*** 测试基于Cloneable实现的深拷贝*/Testpublic void test3() throws ParseException {// 创建原始促销活动PromotionEvent originalEvent createSamplePromotionEvent();log.info(before,originalEvent:{}, originalEvent);// 创建新的促销活动(克隆对象PromotionEvent newEvent originalEvent.clone();newEvent.setName(新的促销活动);// 现在newEvent是originalEvent的一个深拷贝副本我们可以对它进行修改而不会影响originalEvent// 修改新促销活动的日期newEvent.setStartDate(addDays(newEvent.getStartDate(), 7));newEvent.setEndDate(addDays(newEvent.getEndDate(), 7));log.info(after,originalEvent:{}, originalEvent);log.info(newEvent:{}, newEvent);// 修改新促销活动的部分规则ListPromotionRule newRules newEvent.getRules();newRules.get(0).setDiscount(newRules.get(0).getDiscount() * 1.1);// 现在我们已经成功地复制了一个与原始活动相似但具有不同日期和部分规则的新促销活动。// 可以将新活动应用于其他商品而原始活动保持不变。}private PromotionEvent createSamplePromotionEvent() throws ParseException {// 创建示例促销活动ListPromotionRule rules Arrays.asList(new PromotionRule(折扣, 0.9, new Product(p1, 33.3, 20)),new PromotionRule(满减, 50, new Product(p1, 33.3, 20)));SimpleDateFormat sdf new SimpleDateFormat(yyyy-MM-dd);PromotionEvent event new PromotionEvent(原始促销活动,sdf.format(new Date()),addDays(new Date(), 7),rules);return event;}private String addDays(String date, int days) throws ParseException {SimpleDateFormat sdf new SimpleDateFormat(yyyy-MM-dd);Calendar calendar Calendar.getInstance();calendar.setTime(sdf.parse(date));calendar.add(Calendar.DATE, days);return sdf.format(calendar.getTime());}private String addDays(Date date, int days) throws ParseException {SimpleDateFormat sdf new SimpleDateFormat(yyyy-MM-dd);Calendar calendar Calendar.getInstance();calendar.setTime(date);calendar.add(Calendar.DATE, days);return sdf.format(calendar.getTime());}
}4.2.2 序列化
对原型对象进行序列化再对序列化后的二进制流执行反序列化操作就可以得到一个完完全全相同的对象这种序列化的方式有很多比如先转为json在转成内存模型的对象也是可以的。
/*** 测试基于序列化实现的深拷贝*/
Test
public void test4() throws Exception {PromotionRule promotionRule new PromotionRule(折扣, 0.9, new Product(p1, 33.3, 20));log.info(before,promotionRule:{}, promotionRule);// 将对象写道字节数组当中ByteArrayOutputStream outputStream new ByteArrayOutputStream();ObjectOutputStream objectOutputStream new ObjectOutputStream(outputStream);objectOutputStream.writeObject(promotionRule);// 获取字节数组byte[] bytes outputStream.toByteArray();// 用输入流读取ByteArrayInputStream inputStream new ByteArrayInputStream(bytes);ObjectInputStream objectInputStream new ObjectInputStream(inputStream);PromotionRule clonePromotionRule (PromotionRule) objectInputStream.readObject();// 修改克隆对象的属性对原对象没有影响clonePromotionRule.setDiscount(0.88);clonePromotionRule.setType(满减);log.info(after,promotionRule:{}, promotionRule);log.info(clonePromotionRule:{}, clonePromotionRule);// 修改原来对象的属性对深克隆的新对象没有影响promotionRule.setType(大优惠);promotionRule.setDiscount(0.99);log.info(after2,promotionRule:{}, promotionRule);log.info(after,clonePromotionRule:{}, clonePromotionRule);
}4.3 应用场景
深拷贝在ERP系统中使用非常多。假设我们有一个订单管理系统其中包含订单、商品和客户等实体类。我们需要将一张订单复制到另一张新订单中包括订单上的商品以及客户信息但是新订单的其他信息需要重新填写例如订单号、订单日期等等。
首先定义实体类
/*** 类描述客户** Author crysw* Version 1.0* Date 2023/12/3 21:47*/
Data
AllArgsConstructor
NoArgsConstructor
public class Customer implements Cloneable {private String customerId;private String customerName;private String address;Overridepublic Customer clone() {try {return (Customer) super.clone();} catch (CloneNotSupportedException e) {return null;}}
}Data
AllArgsConstructor
NoArgsConstructor
public class Product implements Cloneable, Serializable {/*** 商品名称*/private String name;/*** 价格*/private double price;/*** 库存*/private int stock;/*** 重写clone方法** return* throws CloneNotSupportedException*/Overridepublic Product clone() {try {return (Product) super.clone();} catch (CloneNotSupportedException e) {e.printStackTrace();return null;}}
}/*** 类描述订单** Author crysw* Version 1.0* Date 2023/12/3 21:46*/
Data
AllArgsConstructor
NoArgsConstructor
public class Order implements Cloneable {private String orderId;private Date orderDate;private Customer customer;private ListProduct products;/*** 重写clone方法** return* throws CloneNotSupportedException*/Overrideprotected Order clone() {try {Order cloneOrder (Order) super.clone();// 引用类型使用深拷贝cloneOrder.setOrderDate((Date) orderDate.clone());cloneOrder.setCustomer(customer.clone());ListProduct cloneProducts new ArrayList();for (Product product : products) {Product cloneProduct product.clone();cloneProducts.add(cloneProduct);}cloneOrder.setProducts(cloneProducts);return cloneOrder;} catch (CloneNotSupportedException e) {return null;}}
}已经为每个实体类实现了深拷贝方法接下来我们可以在复制订单时使用深拷贝
Test
public void test5() {// 创建原始订单Order originalOrder createSampleOrder();// 创建新订单Order newOrder originalOrder.clone();newOrder.setOrderId(新订单号);newOrder.setOrderDate(new Date());newOrder.setCustomer(new Customer(002, 新客户名称, 新客户地址));log.info(originalOrder:{}, originalOrder);log.info(newOrder:{}, newOrder);
}private static Order createSampleOrder() {// 创建示例订单Customer customer new Customer(001, 客户名称, 客户地址);ListProduct products Arrays.asList(new Product(p1, 33.1, 10),new Product(p2, 33.2, 20),new Product(p3, 33.3, 30));Order order new Order(订单号, new Date(), customer, products);return order;
}在这个例子中我们创建了一个原始订单并通过深拷贝创建了一个新的订单。然后我们修改了新订单的部分信息例如订单号、订单日期以及客户信息但是保留了原始订单上的商品信息。这样我们就可以快速创建一个新订单并且可以选择保留或修改原始订单上的商品信息。同时原始订单保持不变不受新订单的影响。
4.4 源码应用
4.4.1 JDK应用
在JDK中原型设计模式主要应用于那些需要提供对象拷贝功能的类。以下是一些JDK中使用原型设计模式的示例 java.lang.Cloneable接口Cloneable接口是一个标记接口表示一个类的实例可以被克隆。实现了Cloneable接口的类可以通过重写Object类中的clone() 方法来提供对象复制功能。这种方式允许通过复制现有对象来创建新实例而不是通过构造函数。
public class MyClass implements Cloneable {// ...Overridepublic MyClass clone() {try {return (MyClass) super.clone();} catch (CloneNotSupportedException e) {throw new AssertionError(); // Cant happen}}
}Date类实现了Cloneable接口提供了一个clone() 方法来创建Date对象的副本。可以通过复制现有Date对象来创建新的Date实 例而不是通过构造函数。
Date original new Date();
Date copied (Date) original.clone();在JDK中原型设计模式的应用并不非常广泛。然而在需要快速创建具有相似属性的新对象时原型设计模式提供CopyOnWriteArrayList, 在我们对集合进行set修改时它通过克隆技术对原数据进行了克隆原始版本对象不受影响。
public Object clone() {try {SuppressWarnings(unchecked)CopyOnWriteArrayListE clone (CopyOnWriteArrayListE) super.clone();clone.resetLock();return clone;} catch (CloneNotSupportedException e) {// this shouldnt happen, since we are Cloneablethrow new InternalError();}
}public E set(int index, E element) {final ReentrantLock lock this.lock;lock.lock();try {Object[] elements getArray();E oldValue get(elements, index);if (oldValue ! element) {int len elements.length;Object[] newElements Arrays.copyOf(elements, len);newElements[index] element;setArray(newElements);} else {// Not quite a no-op; ensures volatile write semanticssetArray(elements);}return oldValue;} finally {lock.unlock();}
}4.4.2 Spring应用
在Java的常用框架SSMSpring、Spring MVC和MyBatis中原型设计模式主要应用在Spring框架的Bean管理上。
在Spring框架中Bean的生命周期可以是单例Singleton或原型Prototype。当Bean的作用域被定义为原型时Spring容器会为每个请求创建一个新的Bean实例而不是在整个应用程序生命周期内共享一个实例。这就是原型设计模式在Spring框架中的应用。例如在Spring的XML配置文件中可以将一个Bean的作用域设置为原型
bean idmyBean classcom.example.MyBean scopeprototype/或者在基于注解的配置中使用Scope 注解
Configuration
public class AppConfig {BeanScope(prototype)public MyBean myBean() {return new MyBean();}
}这样每次从Spring容器中获取myBean 时都会创建一个新的实例。原型设计模式允许在需要独立实例的场景中有效地管理对象的生命周期提高性能和资源利用率。Spring中的原型不是使用深拷贝实现的而是创建的新对象。
