JAVA源码解析(10)-java.beans.Encoder、java.beans.MetaData、java.beans.ExceptionListener

作者处于学习阶段，如有不对请指正。

来自API的解释：Encoder 是这样的类，它可用于创建根据其公共 API 对 JavaBeans 集合状态进行编码的文件或流。Encoder 结合其持久委托，负责将对象图形拆分成一系列可用于创建它的 Statements 和 Expression。子类通常使用某种可读形式（比如 Java 源代码或 XML）提供这些表达式的语法。

一个个方法来解析：

  protected void writeObject(Object o) {
        if (o == this) {
            return;
        }
        PersistenceDelegate info = getPersistenceDelegate(o == null ? null : o.getClass());
        info.writeObject(o, this);
    }

  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;
    }

MetaData.getPersistenceDelegate方法:

  public synchronized static PersistenceDelegate getPersistenceDelegate(Class type) {
        if (type == null) {
            return nullPersistenceDelegate;
        }
        if (Enum.class.isAssignableFrom(type)) {
            return enumPersistenceDelegate;
        }
        if (null != XMLEncoder.primitiveTypeFor(type)) {
            return primitivePersistenceDelegate;
        }
        // The persistence delegate for arrays is non-trivial; instantiate it lazily.
        if (type.isArray()) {
            if (arrayPersistenceDelegate == null) {
                arrayPersistenceDelegate = new ArrayPersistenceDelegate();
            }
            return arrayPersistenceDelegate;
        }
        // Handle proxies lazily for backward compatibility with 1.2.
        try {
            if (java.lang.reflect.Proxy.isProxyClass(type)) {
                if (proxyPersistenceDelegate == null) {
                    proxyPersistenceDelegate = new ProxyPersistenceDelegate();
                }
                return proxyPersistenceDelegate;
            }
        }
        catch(Exception e) {}
        // else if (type.getDeclaringClass() != null) {
        //     return new DefaultPersistenceDelegate(new String[]{"this$0"});
        // }

        String typeName = type.getName();
        PersistenceDelegate pd = (PersistenceDelegate)getBeanAttribute(type, "persistenceDelegate");
        if (pd == null) {
            pd = internalPersistenceDelegates.get(typeName);
            if (pd != null) {
                return pd;
            }
            internalPersistenceDelegates.put(typeName, defaultPersistenceDelegate);
            try {
                String name =  type.getName();
                Class c = Class.forName("java.beans.MetaData$" + name.replace('.', '_')
                                        + "_PersistenceDelegate");
                pd = (PersistenceDelegate)c.newInstance();
                internalPersistenceDelegates.put(typeName, pd);
            }
            catch (ClassNotFoundException e) {
                String[] properties = getConstructorProperties(type);
                if (properties != null) {
                    pd = new DefaultPersistenceDelegate(properties);
                    internalPersistenceDelegates.put(typeName, pd);
                }
            }
            catch (Exception e) {
                System.err.println("Internal error: " + e);
            }
        }

        return (pd != null) ? pd : defaultPersistenceDelegate;
    }

writeObject这个方法简而言之就是write对象出去，write之前会先找相应类型的持久化代理类，而找代理类时如果没有被PersistenceDelegateFinder缓存过那么则会去MetaData寻找，其中会返回空持久化委托（null）、枚举持久化委托（Enum）、原生持久化委托（Boolean、Byte、Character、Short、Integer、Long、Float、Double、Void）、数组持久化委托（Array）、代理持久化委托（实现了Proxy接口）。

如果找不到则会去Introspector以及FeatureDescriptor寻找相应类型的”persistenceDelegate”属性值，如果找不到，则会在本身的internalPersistenceDelegates寻找，而internalPersistenceDelegates有默认值，这些值会在类初始化的时候被放入：

internalPersistenceDelegates.put("java.net.URI",
    new PrimitivePersistenceDelegate());    internalPersistenceDelegates.put("javax.swing.plaf.BorderUIResource$MatteBorderUIResource",
    new javax_swing_border_MatteBorder_PersistenceDelegate());
internalPersistenceDelegates.put("javax.swing.plaf.FontUIResource",
    new java_awt_Font_PersistenceDelegate());
internalPersistenceDelegates.put("javax.swing.KeyStroke",
    new java_awt_AWTKeyStroke_PersistenceDelegate());
internalPersistenceDelegates.put("java.sql.Date",
    new java_util_Date_PersistenceDelegate());
internalPersistenceDelegates.put("java.sql.Time",
    new java_util_Date_PersistenceDelegate());
internalPersistenceDelegates.put("java.util.JumboEnumSet",
    new java_util_EnumSet_PersistenceDelegate());
internalPersistenceDelegates.put("java.util.RegularEnumSet",
    new java_util_EnumSet_PersistenceDelegate());
    }

如果在internalPersistenceDelegates中找不到相应的类对应的持久化委托，则会返回一个defaultPersistenceDelegate，同时将其加入internalPersistenceDelegates作为缓存。

有一个简单的方法，就是获取Expression的值：

    Object getValue(Expression exp) {
        try {
            return (exp == null) ? null : exp.getValue();
        }
        catch (Exception e) {
            getExceptionListener().exceptionThrown(e);
            throw new RuntimeException("failed to evaluate: " + exp.toString());
        }
    }

在Encoder中，有一个方法是用来获取持久化委托类的：

    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;
    }

这个方法和前面说writeObject方法的时候很像，在此也不多做赘述。
　
　

    public void setPersistenceDelegate(Class<?> type, PersistenceDelegate delegate) {
        this.finder.register(type, delegate);
    }

这个方法则是往finder中写入缓存的
　

在Encoder中，还有两个方法：setExceptionListener、getExceptionListener，对应的变量是exceptionListener，其作用是用于在产生异常的时候能够从exceptionListener抛出去，一起来看下ExceptionListener这个接口：

   /**
     * This method is called when a recoverable exception has
     * been caught.
     *
     * @param e The exception that was caught.
     *
     */
    public void exceptionThrown(Exception e);

接口中只有一个方法，就是抛异常的意思，来看下其唯一的实现类：

  static ExceptionListener defaultExceptionListener = new ExceptionListener() {
        public void exceptionThrown(Exception e) {
            System.err.println(e);
            // e.printStackTrace();
            System.err.println("Continuing ...");
        }
    };

意思很简单，不做赘述

在MetaData中，internalPersistenceDelegates是其中的一员，其余的方法也都是各种持久化委托的定义，除此之外，没有更多的东西可以说

其余的方法没有必要再多说，有问题可以留言