Retrofit中的原型模式
Retrofit中用到的原型模式我看到的有两个地方：
@Override
public OkHttpCall<T> clone() {
return new OkHttpCall<>(serviceMethod, args);
}
static final class ExecutorCallbackCall<T> implements Call<T> {
// 省略代码
@SuppressWarnings("CloneDoesntCallSuperClone") // Performing deep clone.
@Override
public Call<T> clone() {
return new ExecutorCallbackCall<>(callbackExecutor, delegate.clone());
}
}
首先这里为什么要用原型模式而不是直接new 新对象呢？
1、原型模式和new对象相比，原型模式是在内存中二进制的copy，性能要比new快
2、当大量需要对象时候，用原型模式比较省内存和性能
3、OkHttpCall和ExecutorCallbackCall都是在网络请求中必须要用的，可想而知当有大量网络请求的时候，如果每一次请求都要new对象是很耗内存和性能的.
不过以后项目中如果要用的话需要注意原型模式的缺点：
使用原型模式复制对象需要注意深拷贝与浅拷贝的问题。Object类的clone方法只会拷贝对象中的基本的数据类型，对于数组、容器对象、引用对象等都不会拷贝，这就是浅拷贝。如果要实现深拷贝，必须将原型模式中的数组、容器对象、引用对象等另行拷贝
项目中的原型模式
下面说的这个场景应该大家都遇到过，首先APP基本都有登录页面，登录成功以后肯定会获取大量的用户信息，这个用户信息一般都是在个人中心才能修改，对其他页面应该是只读的，怎么实现呢？？？，把User对象中属性的set方法设置为包级私有的。
public class User{
private UserInfo userInfo;
private String userId;
public UserInfo getInfo() {
return info;
}
void setInfo(UserInfo info) {
this.userInfo= info;
}
public String getUserId() {
return userId;
}
void setUserId(String userId) {
this.userId = userId;
}
}
大家看到User里面set方法都是包级私有的，这个User应该放到和个人中心设置一个包下面，这样Use属性对外就是只读的了。
但是，但是，但是，UserInfo是一个对象，User中的get方法拿到UserInfo以后还是可以更改UserInfo内部信息的，其实个人认为用原型模式是最好的！！！所以需要对UserInfo进行深Copy,这里就涉及到了原型模式中的深copy了.
public class Info {
private String a;
private int num;
public Info(String a, int num) {
this.a = a;
this.num = num;
}
public String getA() {
return a;
}
public void setA(String a) {
this.a = a;
}
public int getNum() {
return num;
}
public void setNum(int num) {
this.num = num;
}
@Override
public String toString() {
return "Info{" +
"a='" + a + '\'' +
", num=" + num +
'}';
}
}
public class UserInfo implements Cloneable{
private ArrayList<Info> list;
private String name;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public List<Info> getList() {
return list;
}
public void setList(ArrayList<Info> list) {
this.list = list;
}
@Override
public String toString() {
return "User{" +
"list=" + list +
", name='" + name + '\'' +
'}';
}
@Override
public UserInfo clone() {
UserInfo user = null;
try {
user = (UserInfo) super.clone();
user.list = (ArrayList<Info>)this.list.clone();
}catch (CloneNotSupportedException e){
e.printStackTrace();
}
return user;
}
}
User#getUserInfo
public UserInfo getInfo() {
return info.clone();
}
大家看到了UserInfo里面有一个属性是List类型，这个也需要深copy，但是这里注意List是每月clone方法的，只有他的子类ArrayList才有clone方法，所以如果不影响的话可以List改为ArrayList，按照上面那样完成深copy，如果项目要求只能用List属性，那就只能用遍历List逐项copy了.
public User clone() {
User user = null;
List<Info> copy = new ArrayList<>();
try {
user = (User) super.clone();
Iterator iterator = list.iterator();
while (iterator.hasNext()){
copy.add(iterator.next().clone());
}
user.list = copy;
}catch (CloneNotSupportedException e){
e.printStackTrace();
}
return user;
}
可以看到原型模式的第二种作用就是：数据保护
------------------------------------分割线-----------------------------------
大牛肯定发现问题了，问题在User#getUserInfo中
User#getUserInfo
public UserInfo getInfo() {
return info.clone();
}
如果这样的话，代码中有1000次调用getInfo()就会产生1000个临时变量，这种方法虽然保护了数据，但是代价有点大肯定不允许发生的！！！，但是怎么做呢？？？还是简单的从包级限制入手吧
user.getInfo().setName("11111")
问题出现在这里，那就不让他们访问到set方法，把所有的set方法改为包级私有的.
user.getInfo().getList().add(xxx)
上面的问题就用一个API搞定
Collections.unmodifiableList()
返回的List的是不可改变的!!!!，最后UserInfo代码如下：
public class UserInfo {
private ArrayList<Info> list;
private String name;
public String getName() {
return name;
}
void setName(String name) {
this.name = name;
}
public List<Info> getList() {
return Collections.unmodifiableList(list);
}
void setList(ArrayList<Info> list) {
this.list = list;
}
}
