盒子
盒子
文章目录
  1. 1. 原型模式的定义
  2. 2. 原型模式的实现
    1. 2.1 屌丝程序员小明
      1. 源码
      2. 解析
      3. 源码2
      4. 解析2
  3. 3. 浅拷贝和深拷贝
    1. 3.1 装逼程序员小民
      1. 源码
      2. 解析

Android 设计模式:(四)原型模式

前言
本文是对《Adroid 源码设计模式解析与实战》 何红辉、关爱民 著 人民邮电出版社所做的读书笔记。文章是对本书的一些列学习笔记,如若有侵犯到作者权益,还望作者能联系我,我会及时下架。
这本书不错,有兴趣的同学可以买原书看看。
感兴趣的朋友欢迎加入学习小组QQ群: 193765960

版权归作者所有,如有转发,请注明文章出处:https://xiaodanchen.github.io/archives/

1. 原型模式的定义

原型模式:对一个对象,通过克隆生成其副本,而不是通过new 的方式重新生成。
使用场景:

  • 类初始化需要消耗非常多的资源,包括数据、硬件资源等。通过克隆的方式,可以避免这些消耗。
  • 通过new 产生一个对象需要非常繁琐的数据准备或者访问权限,这时可以使用原型模式。
  • 一个对象需要提供给其他对象访问,而且各个调用者可能都需要修改其数据时,可以用原型模式拷贝多个对象供调用者使用,即保护性拷贝。
  • 一个对象,如果要求在某些对象中不允许对其修改,则可以使用原型模式,对其进行保护性拷贝,这样,无论对备份怎么修改都不会影响原型数据。

2. 原型模式的实现

在开发中,我们有时会满足一些需求,就是有的对象中的数据只允许客户端读取,而不允许修改。例如,用户登录信息,只允许在用户登录模块修改,在其他模块比如登录校验、个人信息显示等模块,用户数信息不允许修改。让我们看看该如何实现:

2.1 屌丝程序员小明

源码

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
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
/**
* 用户实体类
*/
public class User{
public int age;
public String name;
public String phone;
public Address address;
}
/**
* 用户地址类
*/
public class Address{
public String city;//城市
public String district;//区
public String street;//街道
public Address(String city,String district,String street){
this.city = city;
this.district = district;
this.street = street;
}
}
/**
* 登录接口
*/
public interface Login{
void login();
}
/**
* 登录实现
*/
public class LoginImpl implements Login{
@Override
public void login(){
User user = new User();
//登录服务器获取用户信息,将信息赋值给user
user.age = 22;
user.name = "xiaoming"
user.address = new Address("北京市","海淀区","花园东路");
...
//用户信息获取到后,将用户信息设置到Session中(单例模式)
LoginSession.getLoginSession().setLoginedUser(user);
}
}
/**
* 登录Session:单例模式
*/
public class LoginSession{
private static LoginSession instance = null;
//已登录用户
private User sUser;
private LoginSession(){}
//懒汉模式
public static LoginSession getLoginSession(){
if(null == instance){
instance = new LoginSession();
}
renturn instance;
}
//设置已登录的用户信息:包级私有函数
//public:所有类可见。
//pirvate:只有同一类内部的方法可见,在有就是内部类也可以访问到。
//默认(friendly):包内可见。
//protected:继承可见。
void setLoginedUser(User user){
sUser = user;
}
public User getLoginedUser(){
return sUser;
}
@Override
public void login(){
User user = new User();
//登录服务器获取用户信息,将信息赋值给user
user.age = 22;
user.name = "xiaoming"
...
//用户信息获取到后,将用户信息设置到Session中(单例模式)
LoginSession.getLoginSession().setLoginedUser(user);
}
}

解析

用户登录时从服务器获取用户信息,通过setLoginedUser方法设置给LoginSession。由于setLoginedUser的访问权限是包级别的,因此外部模块无法访问,在一定程度上满足了不允许其他模块修改的要求,小明很高兴。
可是,小明有一个比他还菜的同事大力协同开发,大力果然出奇迹啊:

1
2
3
4
5
//在用户信息功能模块,
//获取登录用户信息
User user = LoginSession.getLoginSession().getLoginedUser();
//测试:更新用户地址信息
user.address = new Address("北京市","朝阳区","大望路");

联调时发现,用户显示的信息和服务器获取的信息不一致,小民很郁闷,他本来打的好算盘是只允许LoginSession包下才能通过setLoginedUser设定修改用户信息,然而并没有其他人调用setLoginedUser方法,追查了好久终于发现大力这个猪队友干的好事。如何才能保证服务器获取到的数据在其他模块下不会被更改呢?但是屌丝到爆的小明对这个问题束手无策了。
无奈之下,小明找到了小民,小民嘴角一勾,“小CASE!使用clone获取副本”

源码2

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
/**
* 用户实体类
*/
public class User implements Cloneable{
...
@Override
public User clone(){
User user = null;
try{
user = (User)super.clone();
}catch(CloneNotSupportedException e){
e.printStackTrace();
}
return user;
}
}
//修改LoginSession的getLoginedUser方法
public User getLoginedUser(){
return sUser.clone();
}

解析2

小明采用了原型模式,让User实现了克隆功能,在不允许修个user的地方,使用其副本,即保护性拷贝。
经测试发现,浅拷贝并没有彻底的解决问题。比如:

1
2
3
4
5
6
7
//在用户信息功能模块,
//获取登录用户信息
User user = LoginSession.getLoginSession().getLoginedUser();
//测试:更新用户地址信息
user.address.city = ("北京市");
user.address.district = ("朝阳区");
user.address.street = ("大望路");

小明这次彻底懵逼了,不得已又找到了小民,小民看过小明的代码,笑了笑:“方向没错,只不过你使用了浅拷贝,要想解决你的问题,你应该使用深拷贝,”“

3. 浅拷贝和深拷贝

深拷贝(深复制)和浅拷贝(浅复制)是两个比较通用的概念,尤其在C++语言中,若不弄懂,则会在delete的时候出问题,但是我们在这幸好用的是Java。虽然java自动管理对象的回收,但对于深拷贝(深复制)和浅拷贝(浅复制),我们还是要给予足够的重视,因为有时这两个概念往往会给我们带来不小的困惑。

浅拷贝是指拷贝对象时仅仅拷贝对象本身(包括对象中的基本变量),而不拷贝对象包含的引用指向的对象。深拷贝不仅拷贝对象本身,而且拷贝对象包含的引用指向的所有对象。举例来说更加清楚:对象A1中包含对B1的引用,B1中包含对C1的引用。浅拷贝A1得到A2,A2 中依然包含对B1的引用,B1中依然包含对C1的引用。深拷贝则是对浅拷贝的递归,深拷贝A1得到A2,A2中包含对B2(B1的copy)的引用,B2 中包含对C2(C1的copy)的引用。

3.1 装逼程序员小民

源码

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
29
30
31
32
33
34
35
36
37
38
39
/**
* 用户实体类
*/
public class User implements Cloneable{
...
@Override
public User clone(){
User user = null;
try{
user = (User)super.clone();
}catch(CloneNotSupportedException e){
e.printStackTrace();
}
user.address = (Address)address.clone();
return user;
}
}
/**
* 用户实体类
*/
public class Address implements Cloneable{
...
@Override
public Address clone(){
Address address = null;
try{
address = (Address)super.clone();
}catch(CloneNotSupportedException e){
e.printStackTrace();
}
return address;
}
}
//修改LoginSession的getLoginedUser方法
public User getLoginedUser(){
return sUser.clone();
}

解析

深拷贝不仅拷贝对象本身,而且拷贝对象包含的引用指向的所有对象。

扫描加群
好好学习,天天向上!