【设计模式】原型模式：如何快速的克隆出一个对象

最新推荐文章于 2024-11-09 21:44:05 发布
最新推荐文章于 2024-11-09 21:44:05 发布
阅读量1k 收藏
点赞数 1
分类专栏： 程序员 文章标签： 面试 java 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_64205605/article/details/121442451
版权

BlogStats blogStats = entry.getValue();

if(blogStats.getStatus() == 0){

changeDatas.put(id,blogStats);

}

}

return changeDatas;

}

public static void main(String[] args) {

print(mapCache);

//获取修改的数据

Map<Integer, BlogStats> changeData = getChangeData();

//更新内存数据

update(changeData);

//将修改的博客状态改为1并写回数据库，这段省略

System.out.println(“更新过后=====================”);

print(mapCache);

}

private static void print( Map<Integer, BlogStats> map ){

for(Map.Entry<Integer, BlogStats> entry : map.entrySet()){

System.out.println(“key:”+entry.getKey()+" value:"+entry.getValue());

}

}

}

这是改造之后的代码，解释一下上面的代码，

第一：我不在往数据库中获取所有的博客数据，而是通过一个字段status表示这条记录是否更新过，只查询需要更新的博客信息即可。

第二：再修改的时候需要判断再数据库中查询出来的数据是否在内存中存在，如果存在，执行修改操作，如果不存在，执行添加操作。

按照上面的思路，我们的运行结果应该是博客id在0-7的信息无变化，博客id在8-9被修改，博客id等于10的被新增，那结果是不是这样呢？我们直接来看运行结果

key:0 value:BlogStats(id=0, title=java是世界上最好的语言0, likeNum=0, viewNum=0, commentNum=0, status=1)

key:1 value:BlogStats(id=1, title=java是世界上最好的语言1, likeNum=1, viewNum=1, commentNum=1, status=1)

key:2 value:BlogStats(id=2, title=java是世界上最好的语言2, likeNum=2, viewNum=2, commentNum=2, status=1)

key:3 value:BlogStats(id=3, title=java是世界上最好的语言3, likeNum=3, viewNum=3, commentNum=3, status=1)

key:4 value:BlogStats(id=4, title=java是世界上最好的语言4, likeNum=4, viewNum=4, commentNum=4, status=1)

key:5 value:BlogStats(id=5, title=java是世界上最好的语言5, likeNum=5, viewNum=5, commentNum=5, status=1)

key:6 value:BlogStats(id=6, title=java是世界上最好的语言6, likeNum=6, viewNum=6, commentNum=6, status=1)

key:7 value:BlogStats(id=7, title=java是世界上最好的语言7, likeNum=7, viewNum=7, commentNum=7, status=1)

key:8 value:BlogStats(id=8, title=java是世界上最好的语言8, likeNum=8, viewNum=8, commentNum=8, status=1)

key:9 value:BlogStats(id=9, title=java是世界上最好的语言9, likeNum=9, viewNum=9, commentNum=9, status=1)

更新过后=====================

key:0 value:BlogStats(id=0, title=java是世界上最好的语言0, likeNum=0, viewNum=0, commentNum=0, status=1)

key:1 value:BlogStats(id=1, title=java是世界上最好的语言1, likeNum=1, viewNum=1, commentNum=1, status=1)

key:2 value:BlogStats(id=2, title=java是世界上最好的语言2, likeNum=2, viewNum=2, commentNum=2, status=1)

key:3 value:BlogStats(id=3, title=java是世界上最好的语言3, likeNum=3, viewNum=3, commentNum=3, status=1)

key:4 value:BlogStats(id=4, title=java是世界上最好的语言4, likeNum=4, viewNum=4, commentNum=4, status=1)

key:5 value:BlogStats(id=5, title=java是世界上最好的语言5, likeNum=5, viewNum=5, commentNum=5, status=1)

key:6 value:BlogStats(id=6, title=java是世界上最好的语言6, likeNum=6, viewNum=6, commentNum=6, status=1)

key:7 value:BlogStats(id=7, title=java是世界上最好的语言7, likeNum=7, viewNum=7, commentNum=7, status=1)

key:8 value:BlogStats(id=8, title=java是世界上最好的语言8, likeNum=10, viewNum=10, commentNum=10, status=1)

key:9 value:BlogStats(id=9, title=java是世界上最好的语言9, likeNum=11, viewNum=11, commentNum=11, status=1)

key:10 value:BlogStats(id=10, title=java是世界上最好的语言10, likeNum=12, viewNum=12, commentNum=12, status=1)

Process finished with exit code 0

从打印的结果来看，id在0-7的没有发生改变，8-9发生了改变，并且新增了一条id为10的新数据，所以这次的改造时成功的，现在已经优化的很好的，但还没有使用到设计模式中的原型模式，那我们还有必要使用吗？

我们之前的操作是直接基于成员变量mapCache，但是我们现在需求稍微做了一下改动，我现在希望，我们需要一次性计算好结果在替换掉成员变量mapCache，而不是一次一次的替换

【一线大厂Java面试题解析+后端开发学习笔记+最新架构讲解视频+实战项目源码讲义】

浏览器打开：qq.cn.hn/FTf 开源分享

，所以这个时候上面的这种方法就不行了，out了，那我们应该怎么办呢？很多人都想到了

  • 第一步：从数据库中获取到status = 1 的所有数据，也就是已经更新过的数据，这个数据和内存中的一样。

  • 第二步：查询出status=0的所有数据，也就是没有更新过的数据。

  • 第三步：新建一个map用于计算修改后的结果。

  • 第四步：将新建的map替换掉成员变量mapCache。

这样基本上就大功告成了，但是你发现一个问题没有，那就是在第一步的时候会耗费大量的时间，为什么这么说呢？如果数据量过大，HashMap的存储是需要进行hash的计算以及还有可能发生的hash碰撞，所以对象的创建会耗费大量的时间，我们的内存中又存在着一份和我们数据库中差不多的数据，为什么我们不使用它来进行操作呢？这个时候你可能疑惑了，不是说不能对他进行修改吗，要等所有数据修改完成之后一次性替换吗？这个时候原型模式就要上场了。

原型模式两大数据拷贝

=========================================================================

不知道大家有没有听过这句话，new出来的在堆里，引用的在栈中，那我们一起来看看Java的两种拷贝模式，浅拷贝和深拷贝。

浅拷贝

浅拷贝就是拷贝指向对象的指针（java中的引用地址），意思就是说：拷贝出来的目标对象的指针和源对象的指针指向的内存空间是同一块空间，浅拷贝只是一种简单的拷贝，让几个对象公用一个内存，然而当内存销毁的时候，指向这个内存空间的所有指针需要重新定义，不然会造成野指针错误。

我们来画个图说明一下，算了，不画了，实在找不到比较好的画图工具，画的太难看了，还不如直接讲，如果有好的画图工具，可以评论告诉我哦，十分感谢。

通俗一点来说，浅拷贝就是拷贝数据的引用地址，并没有拷贝真正的数据，也就是说，拷贝出来的对象和原始对象共享一套数据，也就是说拷贝的数据发生改变，原数据也会发生改变，原数据发生改变，拷贝的数据也会发生改变，因为他们共享一套数据。

下面我们使用浅拷贝来实现一下我们上面的demo，由于Map是没有clone()方法的，所以我需要将之前的Map改成HashMap，请看demo

package com.ymy.test;

import com.ymy.entity.BlogStats;

import java.util.HashMap;

import java.util.Map;

public class PrototypeDesignPattern {

/**

  • 内存中存放的数据

  • key：博客id

  • value：博客信息

*/

private static HashMap<Integer, BlogStats> mapCache = new HashMap<Integer, BlogStats>();

/**

  • 数据库存放的数据

  • key：博客id

  • value：博客信息

*/

private static HashMap<Integer, BlogStats> mapMysql = new HashMap<Integer, BlogStats>();

/**

  • 最近一次的修改时间

*/

private static Long updateTime = 1585882804208L;

static {

BlogStats blogStats = null;

//初始化内存中java的博客信息

for(int i = 0; i< 10 ;++i){

blogStats = BlogStats.builder()

.id(i)

.title(“java是世界上最好的语言”+i)

.likeNum(i)

.viewNum(i)

.commentNum(i)

.status(1)

.build();

mapCache.put(i,blogStats);

}

//初始化数据库中java的博客信息

for(int i = 0; i<= 10 ;++i){

blogStats = BlogStats.builder()

.id(i)

.title(“java是世界上最好的语言”+i)

.likeNum(i+2)

.viewNum(i+2)

.commentNum(i+2)

.status(i >= 8 ? 0 : 1)

.build();

mapMysql.put(i,blogStats);

}

}

/**

  • 每天定时更新

*/

private static void update(Map<Integer, BlogStats> changeData){

//这是浅拷贝

HashMap<Integer,BlogStats> oldData = (HashMap<Integer, BlogStats>) mapCache.clone();

for(Map.Entry<Integer, BlogStats> entry : changeData.entrySet()){

Integer id = entry.getKey();

BlogStats blogStats = entry.getValue();

blogStats.setStatus(1);

if(oldData.containsKey(id)){

BlogStats bs = oldData.get(id);

bs.setLikeNum(blogStats.getLikeNum());

bs.setViewNum(blogStats.getViewNum());

bs.setCommentNum(blogStats.getCommentNum());

}else{

oldData.put(id,blogStats);

}

}

System.out.println(“克隆的HashMap最终结果如下=====================”);

print(oldData);

System.out.println(“克隆对象修改完成之后，原数据如下================”);

print(mapCache);

mapCache = oldData;

}

/**

  • 根据更新的状态获取到最新需要修改的数据

  • 由于这里仅仅只是模拟，所以这里我就随便造几条数据，你们主要看思想即可

  • @return

*/

public static Map<Integer,BlogStats> getChangeData(){

//在数据库中查询还没有更新过的数据

//由于我是模拟，所以我直接伪造了几条数据充当需要修改的数据，还请见谅

Map<Integer,BlogStats> changeDatas= new HashMap<Integer,BlogStats>();

for(Map.Entry<Integer, BlogStats> entry : mapMysql.entrySet()){

Integer id = entry.getKey();

BlogStats blogStats = entry.getValue();

if(blogStats.getStatus() == 0){

changeDatas.put(id,blogStats);

}

}

return changeDatas;

}

public static void main(String[] args) {

System.out.println(“内存中最开始存在的数据”);

print(mapCache);

//获取修改的数据

Map<Integer, BlogStats> changeData = getChangeData();

//更新内存数据

update(changeData);

//将修改的博客状态改为1并写回数据库，这段省略

System.out.println(“更新过后内存中的数据=====================”);

print(mapCache);

}

private static void print( Map<Integer, BlogStats> map ){

for(Map.Entry<Integer, BlogStats> entry : map.entrySet()){

System.out.println(“key:”+entry.getKey()+" value:"+entry.getValue());

}

}

}

这里面做的修改就是使用了一个局部变量oldData接收mapCache克隆结果，然后对克隆的结果做修改，代码中使用的mapCache.clone()属于浅拷贝，之前说过浅拷贝的数据是共享的，那我们对拷贝过后的数据进行修改，那原数据会不会受到影响呢？我们一起看打印结果

内存中最开始存在的数据

key:0 value:BlogStats(id=0, title=java是世界上最好的语言0, likeNum=0, viewNum=0, commentNum=0, status=1)

key:1 value:BlogStats(id=1, title=java是世界上最好的语言1, likeNum=1, viewNum=1, commentNum=1, status=1)

key:2 value:BlogStats(id=2, title=java是世界上最好的语言2, likeNum=2, viewNum=2, commentNum=2, status=1)

key:3 value:BlogStats(id=3, title=java是世界上最好的语言3, likeNum=3, viewNum=3, commentNum=3, status=1)

key:4 value:BlogStats(id=4, title=java是世界上最好的语言4, likeNum=4, viewNum=4, commentNum=4, status=1)

key:5 value:BlogStats(id=5, title=java是世界上最好的语言5, likeNum=5, viewNum=5, commentNum=5, status=1)

key:6 value:BlogStats(id=6, title=java是世界上最好的语言6, likeNum=6, viewNum=6, commentNum=6, status=1)

key:7 value:BlogStats(id=7, title=java是世界上最好的语言7, likeNum=7, viewNum=7, commentNum=7, status=1)

key:8 value:BlogStats(id=8, title=java是世界上最好的语言8, likeNum=8, viewNum=8, commentNum=8, status=1)

key:9 value:BlogStats(id=9, title=java是世界上最好的语言9, likeNum=9, viewNum=9, commentNum=9, status=1)

克隆的HashMap最终结果如下=====================

key:0 value:BlogStats(id=0, title=java是世界上最好的语言0, likeNum=0, viewNum=0, commentNum=0, status=1)

key:1 value:BlogStats(id=1, title=java是世界上最好的语言1, likeNum=1, viewNum=1, commentNum=1, status=1)

key:2 value:BlogStats(id=2, title=java是世界上最好的语言2, likeNum=2, viewNum=2, commentNum=2, status=1)

key:3 value:BlogStats(id=3, title=java是世界上最好的语言3, likeNum=3, viewNum=3, commentNum=3, status=1)

key:4 value:BlogStats(id=4, title=java是世界上最好的语言4, likeNum=4, viewNum=4, commentNum=4, status=1)

key:5 value:BlogStats(id=5, title=java是世界上最好的语言5, likeNum=5, viewNum=5, commentNum=5, status=1)

key:6 value:BlogStats(id=6, title=java是世界上最好的语言6, likeNum=6, viewNum=6, commentNum=6, status=1)

key:7 value:BlogStats(id=7, title=java是世界上最好的语言7, likeNum=7, viewNum=7, commentNum=7, status=1)

key:8 value:BlogStats(id=8, title=java是世界上最好的语言8, likeNum=10, viewNum=10, commentNum=10, status=1)

key:9 value:BlogStats(id=9, title=java是世界上最好的语言9, likeNum=11, viewNum=11, commentNum=11, status=1)

key:10 value:BlogStats(id=10, title=java是世界上最好的语言10, likeNum=12, viewNum=12, commentNum=12, status=1)

克隆对象修改完成之后，原数据如下================

key:0 value:BlogStats(id=0, title=java是世界上最好的语言0, likeNum=0, viewNum=0, commentNum=0, status=1)

key:1 value:BlogStats(id=1, title=java是世界上最好的语言1, likeNum=1, viewNum=1, commentNum=1, status=1)

key:2 value:BlogStats(id=2, title=java是世界上最好的语言2, likeNum=2, viewNum=2, commentNum=2, status=1)

key:3 value:BlogStats(id=3, title=java是世界上最好的语言3, likeNum=3, viewNum=3, commentNum=3, status=1)

key:4 value:BlogStats(id=4, title=java是世界上最好的语言4, likeNum=4, viewNum=4, commentNum=4, status=1)

key:5 value:BlogStats(id=5, title=java是世界上最好的语言5, likeNum=5, viewNum=5, commentNum=5, status=1)

key:6 value:BlogStats(id=6, title=java是世界上最好的语言6, likeNum=6, viewNum=6, commentNum=6, status=1)

key:7 value:BlogStats(id=7, title=java是世界上最好的语言7, likeNum=7, viewNum=7, commentNum=7, status=1)

key:8 value:BlogStats(id=8, title=java是世界上最好的语言8, likeNum=10, viewNum=10, commentNum=10, status=1)

key:9 value:BlogStats(id=9, title=java是世界上最好的语言9, likeNum=11, viewNum=11, commentNum=11, status=1)

更新过后内存中的数据=====================

key:0 value:BlogStats(id=0, title=java是世界上最好的语言0, likeNum=0, viewNum=0, commentNum=0, status=1)

key:1 value:BlogStats(id=1, title=java是世界上最好的语言1, likeNum=1, viewNum=1, commentNum=1, status=1)

key:2 value:BlogStats(id=2, title=java是世界上最好的语言2, likeNum=2, viewNum=2, commentNum=2, status=1)

key:3 value:BlogStats(id=3, title=java是世界上最好的语言3, likeNum=3, viewNum=3, commentNum=3, status=1)

key:4 value:BlogStats(id=4, title=java是世界上最好的语言4, likeNum=4, viewNum=4, commentNum=4, status=1)

key:5 value:BlogStats(id=5, title=java是世界上最好的语言5, likeNum=5, viewNum=5, commentNum=5, status=1)

key:6 value:BlogStats(id=6, title=java是世界上最好的语言6, likeNum=6, viewNum=6, commentNum=6, status=1)

key:7 value:BlogStats(id=7, title=java是世界上最好的语言7, likeNum=7, viewNum=7, commentNum=7, status=1)

key:8 value:BlogStats(id=8, title=java是世界上最好的语言8, likeNum=10, viewNum=10, commentNum=10, status=1)

key:9 value:BlogStats(id=9, title=java是世界上最好的语言9, likeNum=11, viewNum=11, commentNum=11, status=1)

key:10 value:BlogStats(id=10, title=java是世界上最好的语言10, likeNum=12, viewNum=12, commentNum=12, status=1)

Process finished with exit code 0

我们来看：克隆的HashMap最终结果如下=====================

在这里插入图片描述

修改了两行，新增了一行，从上面的打印结果可以看出原数据也发生了相应的变化

在这里插入图片描述

虽然克隆对象中新增的对象没有在原对象中增加，但是修改的属性在原对象中也发生了改变，使用浅拷贝的同学一定要注意这一点。

所以浅拷贝就不能实现我们的需求了，前面还有一个深拷贝还没有说，那它能不能满足我们的要求 呢？

深拷贝

一个引用对象一般来说由两个部分组成：一个具名的Handle，也就是我们所说的声明（如变量）和一个内部（不具名）的对象，也就是具名Handle的内部对象。它在Manged Heap（托管堆）中分配，一般由新增引用对象的New方法是进行创建。深拷贝是指源对象与拷贝对象互相独立，其中任何一个对象的改动都不会对另外一个对象造成影响。举个例子，一个人名叫张三，后来用他克隆（假设法律允许）了另外一个人，叫李四，不管是张三缺胳膊少腿还是李四缺胳膊少腿都不会影响另外一个人。比较典型的就是Value（值）对象，如预定义类型Int32，Double，以及结构（struct），枚举（Enum）等。

根据介绍来说，深度拷贝是可以满足我们需求的，那我们因该如何实现深拷贝呢？

序列化

序列化很好理解，就是将对象序列化，然后再反序列化，这两步之后就会得到一个全新的对象。

核心代码

/**

  • 深拷贝

  • @param obj

  • @return

*/

private static Object deepColne(Object obj) {

try {

ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();

ObjectOutputStream objectOutputStream = new ObjectOutputStream(byteArrayOutputStream);

objectOutputStream.writeObject(obj);

ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(byteArrayOutputStream.toByteArray());

ObjectInputStream objectInputStream = new ObjectInputStream(byteArrayInputStream);

return objectInputStream.readObject();

} catch (IOException e) {

e.printStackTrace();

} catch (ClassNotFoundException e) {

e.printStackTrace();

}

return null;

}

这个就是通过序列化再反序列化的核心代码，然后再看一下完整demo

package com.ymy.test;

import com.ymy.entity.BlogStats;

import java.io.*;

import java.util.HashMap;

import java.util.Map;

public class PrototypeDesignPattern {

/**

  • 内存中存放的数据

  • key：博客id

  • value：博客信息

*/

private static HashMap<Integer, BlogStats> mapCache = new HashMap<Integer, BlogStats>();

/**

  • 数据库存放的数据

  • key：博客id

  • value：博客信息

*/

private static HashMap<Integer, BlogStats> mapMysql = new HashMap<Integer, BlogStats>();

/**

  • 最近一次的修改时间

*/

private static Long updateTime = 1585882804208L;

static {

BlogStats blogStats = null;

//初始化内存中java的博客信息

for (int i = 0; i < 10; ++i) {

blogStats = BlogStats.builder()

.id(i)

.title(“java是世界上最好的语言” + i)

.likeNum(i)

.viewNum(i)

.commentNum(i)

.status(1)

.build();

mapCache.put(i, blogStats);

}

//初始化数据库中java的博客信息

for (int i = 0; i <= 10; ++i) {

blogStats = BlogStats.builder()

.id(i)

.title(“java是世界上最好的语言” + i)

.likeNum(i + 2)

.viewNum(i + 2)

.commentNum(i + 2)

.status(i >= 8 ? 0 : 1)

.build();

mapMysql.put(i, blogStats);

}

}

/**

  • 每天定时更新

*/

private static void update(Map<Integer, BlogStats> changeData) {

//这是浅拷贝

HashMap<Integer, BlogStats> oldData = (HashMap<Integer, BlogStats>) deepColne(mapCache);

for (Map.Entry<Integer, BlogStats> entry : changeData.entrySet()) {

Integer id = entry.getKey();

BlogStats blogStats = entry.getValue();

blogStats.setStatus(1);

if (oldData.containsKey(id)) {

BlogStats bs = oldData.get(id);

bs.setLikeNum(blogStats.getLikeNum());

bs.setViewNum(blogStats.getViewNum());

bs.setCommentNum(blogStats.getCommentNum());

} else {

oldData.put(id, blogStats);

}

}

System.out.println(“克隆的HashMap最终结果如下=====================”);

print(oldData);

System.out.println(“克隆对象修改完成之后，原数据如下================”);

print(mapCache);

mapCache = oldData;

}

/**

  • 根据更新的状态获取到最新需要修改的数据

  • 由于这里仅仅只是模拟，所以这里我就随便造几条数据，你们主要看思想即可

  • @return

*/

public static Map<Integer, BlogStats> getChangeData() {

//在数据库中查询还没有更新过的数据

//由于我是模拟，所以我直接伪造了几条数据充当需要修改的数据，还请见谅

Map<Integer, BlogStats> changeDatas = new HashMap<Integer, BlogStats>();

for (Map.Entry<Integer, BlogStats> entry : mapMysql.entrySet()) {

Integer id = entry.getKey();

BlogStats blogStats = entry.getValue();

if (blogStats.getStatus() == 0) {

changeDatas.put(id, blogStats);

}

}

return changeDatas;

}

public static void main(String[] args) {

System.out.println(“内存中最开始存在的数据”);

print(mapCache);

//获取修改的数据

Map<Integer, BlogStats> changeData = getChangeData();

//更新内存数据

update(changeData);

//将修改的博客状态改为1并写回数据库，这段省略

System.out.println(“更新过后内存中的数据=====================”);

print(mapCache);

}

/**

  • 深拷贝

  • @param obj

  • @return

*/

private static Object deepColne(Object obj) {

try {

ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();

ObjectOutputStream objectOutputStream = new ObjectOutputStream(byteArrayOutputStream);

objectOutputStream.writeObject(obj);

ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(byteArrayOutputStream.toByteArray());

ObjectInputStream objectInputStream = new ObjectInputStream(byteArrayInputStream);

return objectInputStream.readObject();

} catch (IOException e) {

e.printStackTrace();

} catch (ClassNotFoundException e) {

e.printStackTrace();

}

return null;

}

private static void print(Map<Integer, BlogStats> map) {

for (Map.Entry<Integer, BlogStats> entry : map.entrySet()) {

System.out.println(“key:” + entry.getKey() + " value:" + entry.getValue());

}

}

}

与浅拷贝相比，改动的地方并不多，只有克隆的地方发生了修改，其他地方不变

内存中最开始存在的数据

key:0 value:BlogStats(id=0, title=java是世界上最好的语言0, likeNum=0, viewNum=0, commentNum=0, status=1)

key:1 value:BlogStats(id=1, title=java是世界上最好的语言1, likeNum=1, viewNum=1, commentNum=1, status=1)

key:2 value:BlogStats(id=2, title=java是世界上最好的语言2, likeNum=2, viewNum=2, commentNum=2, status=1)

key:3 value:BlogStats(id=3, title=java是世界上最好的语言3, likeNum=3, viewNum=3, commentNum=3, status=1)

key:4 value:BlogStats(id=4, title=java是世界上最好的语言4, likeNum=4, viewNum=4, commentNum=4, status=1)

key:5 value:BlogStats(id=5, title=java是世界上最好的语言5, likeNum=5, viewNum=5, commentNum=5, status=1)

key:6 value:BlogStats(id=6, title=java是世界上最好的语言6, likeNum=6, viewNum=6, commentNum=6, status=1)

key:7 value:BlogStats(id=7, title=java是世界上最好的语言7, likeNum=7, viewNum=7, commentNum=7, status=1)

key:8 value:BlogStats(id=8, title=java是世界上最好的语言8, likeNum=8, viewNum=8, commentNum=8, status=1)

key:9 value:BlogStats(id=9, title=java是世界上最好的语言9, likeNum=9, viewNum=9, commentNum=9, status=1)

克隆的HashMap最终结果如下=====================

key:0 value:BlogStats(id=0, title=java是世界上最好的语言0, likeNum=0, viewNum=0, commentNum=0, status=1)

key:1 value:BlogStats(id=1, title=java是世界上最好的语言1, likeNum=1, viewNum=1, commentNum=1, status=1)

key:2 value:BlogStats(id=2, title=java是世界上最好的语言2, likeNum=2, viewNum=2, commentNum=2, status=1)

key:3 value:BlogStats(id=3, title=java是世界上最好的语言3, likeNum=3, viewNum=3, commentNum=3, status=1)

key:4 value:BlogStats(id=4, title=java是世界上最好的语言4, likeNum=4, viewNum=4, commentNum=4, status=1)

key:5 value:BlogStats(id=5, title=java是世界上最好的语言5, likeNum=5, viewNum=5, commentNum=5, status=1)

key:6 value:BlogStats(id=6, title=java是世界上最好的语言6, likeNum=6, viewNum=6, commentNum=6, status=1)

key:7 value:BlogStats(id=7, title=java是世界上最好的语言7, likeNum=7, viewNum=7, commentNum=7, status=1)

key:8 value:BlogStats(id=8, title=java是世界上最好的语言8, likeNum=10, viewNum=10, commentNum=10, status=1)

key:9 value:BlogStats(id=9, title=java是世界上最好的语言9, likeNum=11, viewNum=11, commentNum=11, status=1)

key:10 value:BlogStats(id=10, title=java是世界上最好的语言10, likeNum=12, viewNum=12, commentNum=12, status=1)

克隆对象修改完成之后，原数据如下================

key:0 value:BlogStats(id=0, title=java是世界上最好的语言0, likeNum=0, viewNum=0, commentNum=0, status=1)

key:1 value:BlogStats(id=1, title=java是世界上最好的语言1, likeNum=1, viewNum=1, commentNum=1, status=1)

key:2 value:BlogStats(id=2, title=java是世界上最好的语言2, likeNum=2, viewNum=2, commentNum=2, status=1)

key:3 value:BlogStats(id=3, title=java是世界上最好的语言3, likeNum=3, viewNum=3, commentNum=3, status=1)

key:4 value:BlogStats(id=4, title=java是世界上最好的语言4, likeNum=4, viewNum=4, commentNum=4, status=1)

key:5 value:BlogStats(id=5, title=java是世界上最好的语言5, likeNum=5, viewNum=5, commentNum=5, status=1)

key:6 value:BlogStats(id=6, title=java是世界上最好的语言6, likeNum=6, viewNum=6, commentNum=6, status=1)

key:7 value:BlogStats(id=7, title=java是世界上最好的语言7, likeNum=7, viewNum=7, commentNum=7, status=1)

key:8 value:BlogStats(id=8, title=java是世界上最好的语言8, likeNum=8, viewNum=8, commentNum=8, status=1)

key:9 value:BlogStats(id=9, title=java是世界上最好的语言9, likeNum=9, viewNum=9, commentNum=9, status=1)

更新过后内存中的数据=====================

key:0 value:BlogStats(id=0, title=java是世界上最好的语言0, likeNum=0, viewNum=0, commentNum=0, status=1)

key:1 value:BlogStats(id=1, title=java是世界上最好的语言1, likeNum=1, viewNum=1, commentNum=1, status=1)

key:2 value:BlogStats(id=2, title=java是世界上最好的语言2, likeNum=2, viewNum=2, commentNum=2, status=1)

key:3 value:BlogStats(id=3, title=java是世界上最好的语言3, likeNum=3, viewNum=3, commentNum=3, status=1)

key:4 value:BlogStats(id=4, title=java是世界上最好的语言4, likeNum=4, viewNum=4, commentNum=4, status=1)

key:5 value:BlogStats(id=5, title=java是世界上最好的语言5, likeNum=5, viewNum=5, commentNum=5, status=1)

key:6 value:BlogStats(id=6, title=java是世界上最好的语言6, likeNum=6, viewNum=6, commentNum=6, status=1)

key:7 value:BlogStats(id=7, title=java是世界上最好的语言7, likeNum=7, viewNum=7, commentNum=7, status=1)

key:8 value:BlogStats(id=8, title=java是世界上最好的语言8, likeNum=10, viewNum=10, commentNum=10, status=1)

key:9 value:BlogStats(id=9, title=java是世界上最好的语言9, likeNum=11, viewNum=11, commentNum=11, status=1)

key:10 value:BlogStats(id=10, title=java是世界上最好的语言10, likeNum=12, viewNum=12, commentNum=12, status=1)

Process finished with exit code 0

这个时候我们发现，即使拷贝的数据发生了变化，原始数据还是原来的数据，这就是深度拷贝，深度拷贝有一个比较致命的缺点，那就是拷贝的时间太长，因为它不仅需要拷贝引用，同时还需要拷贝数据，相对于浅拷贝而言效率太差，当然深拷贝的实现方式不止这一种，还有很多，我在这里就不做过多的展示了。

这里有一点需要特别注意，深度拷贝的对象需要实现序列化，也就是：

在这里插入图片描述

否则会导致程序报错。

既然浅拷贝会导致数据共享，深拷贝印象对象创建的效率，那我们有没有一种这种的方案来解决上面的这个问题呢？可以先想一想，不要着急看下面，因为下面肯定有答案，没有的话我也肯定不会让你们想的。

浅拷贝+深拷贝

对于上面的需求来说，我们需要修改发生改变的博客信息，但是需要修改的数据并不是很多，可能只有几条，也有可能只有几十条，再几十万数据中修改几条使用深拷贝就有点过粪了，所以这里我们采用一种比较折中的方式：浅拷贝+深拷贝。

如何实现呢？我们首先将所有的数据心境浅拷贝，然后遇到需要修改的数据再进行深拷贝即可。

改造代码

package com.ymy.test;

import com.ymy.entity.BlogStats;

import java.io.*;

import java.util.HashMap;

import java.util.Map;

public class PrototypeDesignPattern {

/**

  • 内存中存放的数据

  • key：博客id

  • value：博客信息

*/

private static HashMap<Integer, BlogStats> mapCache = new HashMap<Integer, BlogStats>();

/**

  • 数据库存放的数据

  • key：博客id

  • value：博客信息

*/

private static HashMap<Integer, BlogStats> mapMysql = new HashMap<Integer, BlogStats>();

/**

  • 最近一次的修改时间

*/

private static Long updateTime = 1585882804208L;

static {

BlogStats blogStats = null;

//初始化内存中java的博客信息

for (int i = 0; i < 10; ++i) {

blogStats = BlogStats.builder()

.id(i)

.title(“java是世界上最好的语言” + i)

.likeNum(i)

.viewNum(i)

.commentNum(i)

.status(1)

.build();

mapCache.put(i, blogStats);

}

//初始化数据库中java的博客信息

for (int i = 0; i <= 10; ++i) {

blogStats = BlogStats.builder()

.id(i)

.title(“java是世界上最好的语言” + i)

.likeNum(i + 2)

.viewNum(i + 2)

.commentNum(i + 2)

.status(i >= 8 ? 0 : 1)

.build();

mapMysql.put(i, blogStats);

}

}

/**

  • 每天定时更新

*/

private static void update(Map<Integer, BlogStats> changeData) {

//这是浅拷贝

HashMap<Integer, BlogStats> oldData = (HashMap<Integer, BlogStats>) mapCache.clone();

for (Map.Entry<Integer, BlogStats> entry : changeData.entrySet()) {

Integer id = entry.getKey();

BlogStats blogStats = entry.getValue();

blogStats.setStatus(1);

if (oldData.containsKey(id)) {

//我们先删除数据，因为浅拷贝对删除/新增是不会改变原数据的属性的

oldData.remove(id);

}

//这里再重新赋值

oldData.put(id,blogStats);

}

System.out.println(“克隆的HashMap最终结果如下=====================”);

print(oldData);

System.out.println(“克隆对象修改完成之后，原数据如下================”);

print(mapCache);

mapCache = oldData;

}

/**

  • 根据更新的状态获取到最新需要修改的数据

  • 由于这里仅仅只是模拟，所以这里我就随便造几条数据，你们主要看思想即可

  • @return

*/

public static Map<Integer, BlogStats> getChangeData() {

//在数据库中查询还没有更新过的数据

//由于我是模拟，所以我直接伪造了几条数据充当需要修改的数据，还请见谅

Map<Integer, BlogStats> changeDatas = new HashMap<Integer, BlogStats>();

for (Map.Entry<Integer, BlogStats> entry : mapMysql.entrySet()) {

Integer id = entry.getKey();

BlogStats blogStats = entry.getValue();

if (blogStats.getStatus() == 0) {

changeDatas.put(id, blogStats);

}

}

return changeDatas;

}

public static void main(String[] args) {

System.out.println(“内存中最开始存在的数据”);

print(mapCache);

//获取修改的数据

Map<Integer, BlogStats> changeData = getChangeData();

//更新内存数据

update(changeData);

//将修改的博客状态改为1并写回数据库，这段省略

System.out.println(“更新过后内存中的数据=====================”);

print(mapCache);

}

/**

  • 深拷贝

  • @param obj

  • @return

*/

private static Object deepColne(Object obj) {

try {

ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();

ObjectOutputStream objectOutputStream = new ObjectOutputStream(byteArrayOutputStream);

objectOutputStream.writeObject(obj);

ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(byteArrayOutputStream.toByteArray());

ObjectInputStream objectInputStream = new ObjectInputStream(byteArrayInputStream);

return objectInputStream.readObject();

} catch (IOException e) {

Huawei开源分享
关注
专栏目录
设计模式：快速理解原型模式和应用
张彦峰的博客
05-12 166万+
一、原型模式的定义与理解 （一）基本定义 （二）基本理解分析 （三）在Spring中的具体体现 二、具体简单实现方式 (一)实现原型类具备的三个条件 （二）具体举例 三、深拷贝、浅拷贝与原型模式的解决方案 （一）理解复制的含义，去除原有的误解 （二）浅拷贝及其带来的问题 1.新建一个上司类作为员工类的某个属性 2.测试浅拷贝带来的问题 （三）通过深拷贝来解决问题 四、原型模式的应用场景分析
Python 原型模式：对象克隆的智慧
liuhailong0511的博客
09-29 710
除了使用copy模块，我们也可以在类中自定义克隆方法。这种方式在需要对克隆过程进行更多控制时非常有用，例如在克隆过程中对某些属性进行特殊处理或者根据不同的条件创建不同类型的克隆。# 假设我们对property1进行特殊处理Python 中的原型模式为对象的创建提供了一种高效且灵活的方式。通过克隆现有对象，它在对象创建成本高、需要创建相似对象或者动态创建对象等场景下具有独特的优势。
介绍原型模式：快速构建和复制对象的设计模式
ALex_zry的博客
08-17 494
原型模式是一种快速构建和复制对象的设计模式。通过克隆现有对象来创建新对象，原型模式提供了一种高效且灵活的对象创建方式。它适用于需要频繁创建和复制对象的场景，并能够动态地改变对象的状态。然而，在使用原型模式时，需要注意管理和维护复杂对象关系的困难性。如有任何问题或疑问，请随时与我们联系。推荐一个零声学院免费教程，个人觉得老师讲得不错， 服务器课程。
设计模式 - 原型模式 - 浅克隆和深克隆
烟溪彭于晏的博客
07-19 425
原型（Prototype）模式的定义如下用一个已经创建的实例作为原型，通过复制该原型对象来创建一个和原型相同或相似的新对象。在这里，原型实例指定了要创建的对象的种类。用这种方式创建对象非常高效，根本无须知道对象创建的细节。例如，Windows操作系统的安装通常较耗时，如果复制就快了很多。在生活中复制的例子非常多，这里不一一列举了。Java自带的原型模式基于内存二进制流的复制，在性能上比直接new一个对象更加优良。需要为每一个类都配置一个clone方法。...
C++设计模式：原型模式
ajbb093的博客
04-07 1217
在本案例中，如果对史莱姆的原型进行克隆，也就是分裂成不同的对象，而不同的史莱姆型号会对应着不同的技能，假设大型史莱姆是撞击，普通史莱姆是喷射，小型史莱姆是自爆，则简单地进行深克隆以及浅克隆可能会引起异常。因此，对此的解决办法便是原型模式结合状态模式使用，状态模式是指在软件构建过程中，某些对象的状态如果发生改变，其行为也会随之发生变化，使用状态模式将能允许一个对象在其内部状态发生改变时改变它的行为，从而使对象看起来似乎修改了其行为。，普通史莱姆转换成小型史莱姆，其中四只转换后的小型史莱姆共享血量（
原型模式——对象的克隆
码说芯语的博客
07-27 992
一起走进原型模式的世界吧！
【原型模式】设计模式系列：高效克隆的艺术(深入解析)
欢迎来到我的技术空间！我是一名经验丰富的Java开发工程师，热衷于分享我在软件开发领域的知识和心得。在这个博客里，您会发现一系列关于Java编程的文章，包括最佳实践、技术趋势、代码优化技巧以及一些有趣的项目案例。无论是初学者还是有经验的开发者，都能在这里找
08-07 1085
本文深入探讨了原型模式的设计理念及其在软件开发中的应用，包括如何选择使用原型模式、避免克隆过程中的异常，以及处理不可克隆的对象等常见问题。此外，还总结了原型模式的关键点，并推荐了一些学习资源，最后展望了该模式在未来的发展趋势。无论是初学者还是有经验的开发者，都能从中获得实用的见解和技术指导。
原型模式：浅克隆与深克隆
weixin_41388663的博客
07-09 501
原型模式1、什么是原型模式2、原型模式的优点3、原型模式的缺点4、原型模式的实现5、原型模式的应用场景6、实例（1）浅克隆（2）深克隆 1、什么是原型模式 用一个已经创建的实例作为原型，通过复制该原型对象来创建一个和原型相同或相似的新对象。 2、原型模式的优点 （1）Java 自带的原型模式基于内存二进制流的复制，在性能上比直接 new 一个对象更加优良。 （2）可以使用深克隆方式保存对象的状态，使用原型模式将对象复制一份，并将其状态保存起来， 简化了创建对象的过程，以便在需要的时候使用（例如恢复到历史某一
C++设计模式——原型 （克隆）模式
Mr.Sugarcane
11-29 772
Prototype模式的结构和实现都很简单，其关键就是（C++中）拷贝构造函数的实现方式，这也是C++实现技术层面上的事情。由于在示例代码中不涉及到深层拷贝（主要指有指针、复合对象的情况），因此我们通过编译器提供的默认的拷贝构造函数（按位拷贝）的方式进行实现。说明的是这一切只是为了实现简单起见，也因为本篇的重点不在拷贝构造函数的实现技术，而在Prototype模式本身的思想。Prototype。
Java 设计模式-原型模式
精神小牛马
07-24 879
java 设计模式-原型模式
java设计模式【之】原型模式、深拷贝与浅拷贝【源码】【场景：克隆羊】
03-31
java设计模式【之】原型模式、深拷贝与浅拷贝【源码】【场景：克隆羊】 * 原型模式(Prototype) * 实现方式： * 需要被克隆的 class类， 重写Object中的clone()方法，并实现Cloneable接口（否则报错 ...
C#设计模式之原型模式实例：大师兄太调皮，竟然变身二师兄
06-25
客户类（Client）：让一个原型对象克隆自身从而创建一个新的对象，只需要直接实例化或通过工厂方法等方式创建一个原型对象，再通过调用该对象的克隆方法即可得到多个相同的对象。 实例背景： 悟空七十二变，变身二...
.NET设计模式（6）：原型模式（PrototypePattern）
01-30
另一个例子则是艺术创作中的模型制作，艺术家首先会制作一个小样（原型），然后根据小样的比例放大制作出最终的作品。 #### 原型模式解说 接下来，我们将通过一个具体的示例——调色板应用，来深入理解原型模式的...
微服务架构面试内容整理-Sleuth
不务正业的猿
11-07 418
当请求在服务之间传播时，Sleuth 会将 Trace ID 和 Span ID 作为请求头的一部分传递，从而实现对整个请求路径的追踪。在微服务架构中，服务之间的请求链路往往很复杂，Sleuth 可以帮助开发者追踪请求在多个服务中的流转情况。当请求跨多个微服务传播时，每个服务的日志中都会包含相同的 Trace ID，帮助开发者跟踪整个请求的流转。Sleuth 能够对请求进行跟踪，为每个请求生成唯一的追踪 ID（Trace ID），并在服务之间传播。
【IC每日一题：IC验证面试常问-3】
li_kin的博客
11-07 744
IC验证常问问题
摩尔线程嵌入式面试题及参考答案（2万字长文）
大模型大数据攻城狮的专栏
11-06 379
说一下你对 drm 框架的理解。 DRM（Direct Rendering Manager）是 Linux 系统中用于管理图形显示设备的一个重要框架。 从架构层面来讲，它处于内核空间，主要目的是为用户空间的图形应用程序提供一个统一的接口来访问图形硬件。DRM 包括内核态的驱动模块和用户态的库。内核态的驱动负责和硬件进行交互，比如对显存的管理、硬件寄存器的配置等。用户态的库则方便应用程序利用内核态提供的功能进行图形渲染等操作。 在图形显示的具体流程中，DRM 可以控制显示设备的分辨率、刷
前端基础面试题·第四篇——Vue（其三）
最新发布
2301_76380626的博客
11-09 576
Vue中组件定义式可以为其添加一个name属性，这个属性是组件的别名。当时组件被渲染时，Vue DevTools 会显示组件的名称，方便开发者调试，增强调试体验。当组件需要在内部调用渲染自己本身时，需要通过name属性来指定组件名称，否则Vue会报错。给组件命名后，我们可以通过全局注册，在全应用范围内使用该组件。方便了组件的使用，提高了组件复用性。使用keep-alive包裹动态组件时，可以通过include和exclude属性来指定哪些组件需要缓存，哪些组件不需要缓存。
spring相关的面试题
qq_45089709的博客
11-07 827
Spring 框架是 Java 开发中最常用的框架之一，因此在面试中经常会被问到与 Spring 相关的问题。以下是一些常见的 Spring 面试题及其答案。
14：00面试，14：06就出来了，问的问题有点变态。。。
qq_48811377的博客
11-07 1072
整份文档一共有将近 200 页，全部为大家展示出来肯定是不太现实的，为了不影响大家的阅读体验就只展示了部分内容，还望大家海涵，希望能帮助到您面试前的复习且找到一个好的工作，也节省大家在网上搜索资料的时间来学习！
Android原型模式详解：高效克隆与实例应用
"本文深入讲解了Android编程中的原型模式，这是一种创建型设计模式，旨在通过复制已有对象来创建新对象。原型模式适用于初始化资源消耗大或构造过程复杂的场景，如避免重复的数据准备和提高效率。文章提到了使用...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值