JAVA源码解析(8)-java.beans.PersistenceDelegate

作者出于学习阶段，如有不正确的地方请指正。

PersistenceDelegate是一个抽象类，包含了四个方法，没有什么可以详细说明的地方，具体的东西都在子类当中，当前类中的writeObject方法也只是一个持久化的入口。

以下是API的解释：

writeObject
public void writeObject(Object oldInstance,Encoder out)
writeObject 是持久性的一个入口点，由传统委托模式中的 Encoder 使用。尽管此方法不是最终方法，但在普通环境下不必为其创建子类。
此实现首先检查流是否已经遇到此对象。接着调用 mutatesTo 方法查看是否可以将从流中返回的候选者转变成 oldInstance 的精确副本。如果可以，则调用 initialize 方法执行初始化。如果不可以，则从流中移除该候选者，并调用 instantiate 方法为此对象创建一个新候选者。

参数：
oldInstance - 将由此表达式创建的实例。
out - 将在其中写入此表达式的流。
mutatesTo
protected boolean mutatesTo(Object oldInstance,Object newInstance)
如果 oldInstance 的等效 副本可以可以通过应用 newInstance 的一系列语句来创建，则返回 true。在此方法的规范中，等效是指修改后的实例其公共 API 中相关方法的行为与 oldInstance 没有区别。[注：在这里使用短语相关 方法而不是使用所有 方法只是因为，为了保证完全正确，类似 hashCode 和 toString 这样的方法阻止大多数类实际产生其实例的无区别副本]。
如果两个实例的类是相同的，则默认行为返回 true。

参数：
oldInstance - 要复制的实例。
newInstance - 要修改的实例。
返回：
如果通过对 oldInstance 进行一系列的修改能够创建 newInstance 的等效副本，则返回 true。
instantiate
protected abstract Expression instantiate(Object oldInstance,Encoder out)
返回其值为 oldInstance 的表达式。此方法用于描述应该用来创建给定对象的构造方法或工厂方法。例如，用于 Field 类的持久委托的 instantiate 方法可以定义如下：
 Field f = (Field)oldInstance;
 return new Expression(f, f.getDeclaringClass(), "getField", new Object[]{f.getName()});

注意，这里声明了所返回表达式的值，因此该表达式的值（由 getValue 返回）将等于 oldInstance。
参数：
oldInstance - 将由此表达式创建的实例。
out - 将在其中写入此表达式的流。
返回：
值为 oldInstance 的表达式。
initialize
protected void initialize(Class<?> type,Object oldInstance,Object newInstance,Encoder out)
产生一系列对 newInstance 有副作用的语句，使得新实例等于 oldInstance。在此方法的规范中，等效是指在该方法返回之后，修改后的实例其公共 API 中所有方法的行为都与 newInstance 没有区别。
该实现通常通过产生一系列涉及 oldInstance 及其公共可用状态的 "what happened" 语句来达到此目的。这些语句使用其 writeExpression 方法发送到输出流中，在输入流读取期间，在模拟输入流状态的复制环境中返回涉及元素的表达式。每个返回的语句都将使用新环境中所存在对象代替旧环境中的所有实例。特别是这些语句目标的引用，开始它们是 oldInstance 的引用，返回时成为 newInstance 的引用。执行这些语句会以新环境中对象的一系列修改的形式，实现两个对象状态的递增调整。到 initialize 方法返回时，则无法通过使用公共 API 来区别两个实例。最重要的是，用来使这些对象看起来相同的步骤顺序将被输出流记录，当刷新流时，将形成实际的输出。

默认实现调用该类型超类的 initialize 方法。

参数：
oldInstance - 要复制的实例。
newInstance - 要修改的实例。
out - 保存所有应该写入的初始化语句的流。

在这里有一个方法需要讲一下：initialize

    protected void initialize(Class<?> type,
                              Object oldInstance, Object newInstance,
                              Encoder out)
    {
        Class<?> superType = type.getSuperclass();
        PersistenceDelegate info = out.getPersistenceDelegate(superType);
        info.initialize(superType, oldInstance, newInstance, out);
    }

首先会从Encoder中获取传入type父类的持久化委托类，然后对其进行初始化处理，而在Encoder类中，getPersistenceDelegate类实现如下：

 public PersistenceDelegate getPersistenceDelegate(Class<?> type) {
        PersistenceDelegate pd = this.finder.find(type);
        if (pd == null) {
            pd = MetaData.getPersistenceDelegate(type);
            if (pd != null) {
                this.finder.register(type, pd);
            }
        }
        return pd;
    }

意思就是，会先从PersistenceDelegateFinder（finder）中寻找到当前类型的委托类，找不到，那么从MetaData中寻找，如果能找到则去finder中注册，这种思想目前也是很常见，继续往下走，看看finder中的getPersistenceDelegate方法

 public PersistenceDelegate find(Class<?> var1) {
        Map var3 = this.registry;
        PersistenceDelegate var2;
        synchronized(this.registry) {
            var2 = (PersistenceDelegate)this.registry.get(var1);
        }

        return var2 != null?var2:(PersistenceDelegate)super.find(var1);
    }

当知道这个registry是一个HashMap后，整个这个方法就很明了了。

其余的就没有太多可以说的地方了