Sometimes you need to clone objects, and sometimes you can't
use their clone method, and sometimes serialization provides an
alternative. Here's an explanation of when you might need this
exotic and expensive technique, and how you can use it.

When do you need to clone?

The commonest time that you need to clone an object is when it
is a parameter or return value of one of your public methods.
If it is a parameter that you save somewhere, then you don't
want the caller to be able to modify it later. So you save a
copy of the object. Likewise, if you are returning an object
that is part of your class's internal state, you need to return
a copy instead so that callers can't accidentally or
deliberately change that internal state.

A second case when you might want to clone is when you need to
modify an object, but you don't know who else might have a
reference to it. So you make a copy and modify that.

[In both cases, if the object in question is of one of your
classes, you should ask yourself if it couldn't be
href="http://en.wikipedia.org/wiki/Immutable">immutable
instead. Immutability has many advantages regarding
performance, security, and thread-safety.]

Can't I just use Object.clone()?

Happily, java.lang.Object defines a
href="http://java.sun.com/javase/6/docs/api/java/lang/Object.html#clone()">clone()
method whose intent is exactly to produce a copy of the object
on which it is called. Unhappily, this method, which dates from
the very earliest days of the Java platform, has some design
flaws.

The first problem is that the method is protected. The idea,
presumably, is that subclasses have to explicitly agree to be
cloneable by overriding this protected method with a public
method. The various Collections classes all do this, for
example. (
href="http://java.sun.com/javase/6/docs/api/java/util/ArrayList.html#clone()">ArrayList,

href="http://java.sun.com/javase/6/docs/api/java/util/TreeSet.html#clone()">TreeSet,

href="http://java.sun.com/javase/6/docs/api/java/util/IdentityHashMap.html#clone()">IdentityHashMap,
etc.) The subclass also has to implement
href="http://java.sun.com/javase/6/docs/api/java/lang/Cloneable.html">Cloneable
for the default cloning mechanism in Object.clone() to work.

If you have an object that you know has a public clone()
method, but you don't know the type of the object at compile-time,
you are stuck. Say x is declared as an Object. You can't just
call x.clone(), because Object.clone() is protected. If Cloneable
defined a public clone() method, then you could use ((Cloneable)
x).clone(). But it doesn't. So you either have to enumerate all the classes that you think x could be...

Object copy;
if(x instanceofArrayList)
    copy =((ArrayList<?>) x).clone();
elseif(x instanceofIdentityHashMap)
    copy =((IdentityHashMap<?,?>) x).clone();
else
    ...

...or you have to resort to reflection...

Object copy;
try{
    Method clone = x.getClass().getMethod("clone");
    copy = clone.invoke(x);
}catch(Exception e){
    ...what?...
}

Both solutions are pretty nasty.

A second potential problem is that the default behaviour of
Object.clone() is to make a shallow copy of the object.
Most system classes that provide a clone() method do this too.
A shallow copy means that the copy object itself is different,
but if the original object referenced other objects, the copy
will reference those same objects, and not a copy of them. For
example, what does the following code print?

    HashMap<String,List<String>>cities=newHashMap<String,List<String>>();
    cities.put("France",Arrays.asList("Paris","Grenoble"));
    HashMap<String,List<String>>citiesClone=(HashMap) cities.clone();
    citiesClone.get("France").set(0,"Dublin");
    System.out.println(cities.get("France"));

Of course, it prints "[Dublin, Grenoble]". The original
cities object has been modified through its clone,
because the clone operation does not clone the list in each
entry.

Cloning through serialization

One solution to these problems is to clone using serialization.
Usually, serialization is used to send objects off somewhere (into
a file or over the network) so that somebody else can reconstruct
them later. But you can abuse it to reconstruct the object
yourself immediately. If the object is serializable at all, then
the reconstruction should be a faithful copy. In normal uses of
serialization, the original object is nowhere near; it could be on
the other side of the world at the far end of a network
connection. So you can be sure that changing the copy will have
no effect on the original.

Before going any further, I should caution that this technique
is not to be used lightly. First of all, serialization is
hugely expensive. It could easily be a hundred times more
expensive than the clone() method. Secondly, not all objects
are serializable
. Thirdly, making a class serializable is
tricky
and not all classes can be relied on to get it right.
(You can assume that system classes are correct, though.)

Class-loading subtleties

When an object is being deserialized, the platform has to be
able to find its class in order to construct an instance of that
class. Imagine that you're deserializing an object you received
over the network. If it's a com.example.Foo, the
serialization framework is going to have to find that class
somehow. How does it do it?

The answer is that it uses the ClassLoader of the code that is
doing the deserialization. So if I define a class
SerialClone that serializes and deserializes an
object, then by default the class of that object, and the
classes of other objects it references, need to be known to the
ClassLoader of SerialClone.

In simple cases, this will always be true. Every class of
interest is on the classpath, including SerialClone
and the class of any object it might be asked to copy.

In more complicated environments, with several ClassLoaders,
this default behaviour is not necessarily what you want. In a
web server, for example, typically every web app has its own
ClassLoader. If the web server wanted to serial-clone an object
it got from a web app, it would need to reconstruct the object
using the web app's ClassLoader. How could it do that?

The answer is that it can use class annotations. RMI
uses these to write information into the serial stream that
tells the remote partner where it can find the classes of
objects that are being sent. The information is the appropriate
URL to download the class from.

We don't need anything nearly as complicated as that. We
already have the class locally. We know the class when we're
serializing. We just need to figure out how to recover it when
deserializing.

The first time any class is referenced from an object being serialized, ObjectOutputStream calls its annotateClass method. Correspondingly, the first time a
class is referenced from an object being deserialized,
ObjectInputStream calls its
href="http://java.sun.com/javase/6/docs/api/java/io/ObjectInputStream.html#resolveClass(java.io.ObjectStreamClass)">
resolveClass method.

So we can create subclasses of ObjectOutputStream and
ObjectInputStream that override these methods. Our
annotateClass method will simply record the class in a list; it
won't actually write anything into the stream. The resolveClass
is called at the same point in deserialization as annotateClass
is called in serialization. So resolveClass can simply consume
the classes one by one from the list where annotateClass
recorded them.

Deep modifications in the cloned object

Another method that you can override in ObjectOutputStream is

href="http://java.sun.com/javase/6/docs/api/java/io/ObjectOutputStream.html#replaceObject(java.lang.Object)">replaceObject.
This allows you to replace one object with another. For
example, suppose you wanted to change the string "foo" into the
string "bar" everywhere it occurs within an object. Your
ObjectOutputStream subclass might look like this:

classMyObjectOutputStreamextendsObjectOutputStream{
    MyObjectOutputStream(OutputStreamout)throwsIOException{     super(out);
    enableReplaceObject(true);
    }     protectedObject replaceObject(Object obj)throwsIOException{
    if(obj.equals("foo"))
        return"bar";
    else
        returnsuper.replaceObject(obj);
    }
   
    ...
}

This will change "foo" into "bar" even if it occurs deep inside
the object being serialized, for example in any of the Strings in
a Map>. Don't forget
to call enableReplaceObject(true)
or nothing will
happen!

Of course the ability to make arbitrary changes to object
contents is potentially very dangerous. Proceed with caution.
For this reason, unprivileged code cannot override replaceObject
in this way; if there is a SecurityManager then you must have
href="http://java.sun.com/javase/6/docs/api/java/io/SerializablePermission.html">
SerializablePermission("enableSubstitution").

The code

Here's a basic class that clones using serialization. Once
again, only use this as a last resort, for all the reasons
mentioned above.

Usage is copy =SerialClone.clone(object).

package serialclone;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InvalidClassException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.ObjectStreamClass;
import java.io.OutputStream;
import java.util.LinkedList;
import java.util.Queue; publicclassSerialClone{
    publicstatic<T> T clone(T x){
try{
    return cloneX(x);
}catch(IOException e){
    thrownewIllegalArgumentException(e);
}catch(ClassNotFoundException e){
    thrownewIllegalArgumentException(e);
}
    }     privatestatic<T> T cloneX(T x)throwsIOException,ClassNotFoundException{
ByteArrayOutputStream bout =newByteArrayOutputStream();
CloneOutput cout =newCloneOutput(bout);
cout.writeObject(x);
byte[] bytes = bout.toByteArray(); ByteArrayInputStream bin =newByteArrayInputStream(bytes);
CloneInput cin =newCloneInput(bin, cout); @SuppressWarnings("unchecked")  // thanks to Bas de Bakker for the tip!
T clone =(T) cin.readObject();
return clone;
    }     privatestaticclassCloneOutputextendsObjectOutputStream{
Queue<Class<?>> classQueue =newLinkedList<Class<?>>(); CloneOutput(OutputStreamout)throwsIOException{
    super(out);
} @Override
protectedvoid annotateClass(Class<?> c){
    classQueue.add(c);
} @Override
protectedvoid annotateProxyClass(Class<?> c){
    classQueue.add(c);
}
    }     privatestaticclassCloneInputextendsObjectInputStream{
privatefinalCloneOutput output; CloneInput(InputStreamin,CloneOutput output)throwsIOException{
    super(in);
    this.output = output;
}     @Override
protectedClass<?> resolveClass(ObjectStreamClass osc)
throwsIOException,ClassNotFoundException{
    Class<?> c = output.classQueue.poll();
    String expected = osc.getName();
    String found =(c ==null)?null: c.getName();
    if(!expected.equals(found)){
thrownewInvalidClassException("Classes desynchronized: "+
"found "+ found +" when expecting "+ expected);
    }
    return c;
}     @Override
    protectedClass<?> resolveProxyClass(String[] interfaceNames)
throwsIOException,ClassNotFoundException{
        return output.classQueue.poll();
    }
    }
} From: https://weblogs.java.net/blog/emcmanus/archive/2007/04/cloning_java_ob.html

Cloning Java objects using serialization的更多相关文章

  1. Java序列化(Serialization)

    关于Java的序列化的文章在网上已经够多了,在这里写关于Java序列化的文章是对自己关于这方面的的一种总结,结合以前的开发经验与网上的资料,写了这篇文章,对自己是有着巩固记忆的作用,也希望能够对大家有 ...

  2. Effective Java 78 Consider serialization proxies instead of serialized instances

    Serialization proxy pattern private static nested class (has a single constructor whose parameter ty ...

  3. Unity学习笔记 - Assets, Objects and Serialization

    Assets和Objects Asset是存储在硬盘上的文件,保存在Unity项目的Assets文件夹内.比如:纹理贴图.材质和FBX都是Assets.一些Assets以Unity原生格式保存数据,例 ...

  4. learning java Objects.requireNonNull 当传入参数为null时,该方法返回参数本身

    System.out.println(Objects.hashCode(obj)); System.out.println(Objects.toString(obj)); System.out.pri ...

  5. java的Serialization 机制

    基本使用方法               Serialization是指把类或者基本的数据类型持久化(persistence)到数据流(Stream)中,包括文件.字节流.网络数据流.         ...

  6. Objects First with Java 读书笔记 (1)

    umm...这学期被发了助教Java的任务,为了避免误人子弟从零开始现学.课是英语教学,就不逐字翻译了,方便记. 参考书目:Objects First with Java - A Practical ...

  7. Java性能提示(全)

    http://www.onjava.com/pub/a/onjava/2001/05/30/optimization.htmlComparing the performance of LinkedLi ...

  8. 115 Java Interview Questions and Answers – The ULTIMATE List--reference

    In this tutorial we will discuss about different types of questions that can be used in a Java inter ...

  9. Java资源大全中文版(Awesome最新版)

    Awesome系列的Java资源整理.awesome-java 就是akullpp发起维护的Java资源列表,内容包括:构建工具.数据库.框架.模板.安全.代码分析.日志.第三方库.书籍.Java 站 ...

随机推荐

  1. 设计模式之适配器模式(Decorator)

    1.意图 动态地给一个对象添加一些额外的功能. 2.适用性 动态.透明的方式给单个对象添加职责. 如果不适合适用子类来进行扩展的时候,可以考虑适用装饰模式. 避免子类数目爆炸性增长. 3.结构 4.参 ...

  2. 线程-run和start

    import java.lang.Thread; class Machine extends Thread{ public void run() { int a ; for( a = 0 ; a &l ...

  3. Python : 熟悉又陌生的字符编码(转自Python 开发者)

    Python : 熟悉又陌生的字符编码 字符编码是计算机编程中不可回避的问题,不管你用 Python2 还是 Python3,亦或是 C++, Java 等,我都觉得非常有必要厘清计算机中的字符编码概 ...

  4. TensorFlow 深度学习笔记 Logistic Classification

    Logistic Classification Github工程地址:https://github.com/ahangchen/GDLnotes 欢迎star,有问题可以到Issue区讨论 官方教程地 ...

  5. python----面向对象:1类的定义

    1.python中定义类的格式如下: class className(baseClassName): def functionName(argslist): 2.定义一个person类:它有一个Nam ...

  6. 转:JavaScript函数式编程(一)

    转:JavaScript函数式编程(一) 一.引言 说到函数式编程,大家可能第一印象都是学院派的那些晦涩难懂的代码,充满了一大堆抽象的不知所云的符号,似乎只有大学里的计算机教授才会使用这些东西.在曾经 ...

  7. vimTAB宽度等设置

    10 set shiftwidth=4 11 set softtabstop=4 12 set textwidth=200 13 set nu 14 set autoindent 15 set noe ...

  8. 2014第11周一word样式

    今天摸索使用了word的样式替换功能感觉不错,简单记录下: 1.将某一个样式的标题统一替换为另一样式,之前一般是格式化一个个找到标题设置格式, 今天才发现可以选中标题->在浮动框上单击样式或开始 ...

  9. wamp 虚拟目录的设置(转载)

    现在先来配置虚拟主机:1.先打开apache的配置文件httpd.conf,并去掉#Include conf/extra/httpd-vhosts.conf前面的#!!2.打开apache的apach ...

  10. 蓝桥杯算法训练<二>

    一.最小乘积(基本型)[这个题需要认真阅读试题,内容量较大,刚开始的时候,由于练习系统上给出的输入输出的格式有问题,没看懂,最后在MikCu的博客上看到了正确的格式,参考了代码,最终得到正确的结果.为 ...