spring bean parse

BeanDefinitionParserDelegate

解析<bean id="" name=""  name中的內(nèi)容可以用“，”，“：”，“  ”作為分隔符

如果id為空，就將name中的第一個(gè)值賦給id

Entry-->BeanEntry

public final class ParseState {

    /**
     * Tab character used when rendering the tree-style representation.
     */
    private static final char TAB = '\t';

    /**
     * Internal {@link Stack} storage.
     */
    private final Stack<Entry> state;


    /**
     * Create a new {@code ParseState} with an empty {@link Stack}.
     */
    public ParseState() {
        this.state = new Stack<Entry>();
    }

    /**
     * Create a new {@code ParseState} whose {@link Stack} is a {@link Object#clone clone}
     * of that of the passed in {@code ParseState}.
     */
    @SuppressWarnings("unchecked")
    private ParseState(ParseState other) {
        this.state = (Stack<Entry>) other.state.clone();
    }


    /**
     * Add a new {@link Entry} to the {@link Stack}.
     */
    public void push(Entry entry) {
        this.state.push(entry);
    }

    /**
     * Remove an {@link Entry} from the {@link Stack}.
     */
    public void pop() {
        this.state.pop();
    }

    /**
     * Return the {@link Entry} currently at the top of the {@link Stack} or
     * {@code null} if the {@link Stack} is empty.
     */
    public Entry peek() {
        return this.state.empty() ? null : this.state.peek();
    }

    /**
     * Create a new instance of {@link ParseState} which is an independent snapshot
     * of this instance.
     */
    public ParseState snapshot() {
        return new ParseState(this);
    }


    /**
     * Returns a tree-style representation of the current {@code ParseState}.
     */
    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder();
        for (int x = 0; x < this.state.size(); x++) {
            if (x > 0) {
                sb.append('\n');
                for (int y = 0; y < x; y++) {
                    sb.append(TAB);
                }
                sb.append("-> ");
            }
            sb.append(this.state.get(x));
        }
        return sb.toString();
    }


    /**
     * Marker interface for entries into the {@link ParseState}.
     */
    public interface Entry {

    }

}

public class BeanEntry implements ParseState.Entry {

    private String beanDefinitionName;


    /**
     * Creates a new instance of {@link BeanEntry} class.
     * @param beanDefinitionName the name of the associated bean definition
     */
    public BeanEntry(String beanDefinitionName) {
        this.beanDefinitionName = beanDefinitionName;
    }


    @Override
    public String toString() {
        return "Bean '" + this.beanDefinitionName + "'";
    }

}

BeanDefinition的實(shí)例：GenericBeanDefinition bd = new GenericBeanDefinition();

AbstractBeanDefinition-->BeanMetadataAttributeAccessor

public class BeanMetadataAttributeAccessor extends AttributeAccessorSupport implements BeanMetadataElement {

    private Object source;

    ........

}

public abstract class AttributeAccessorSupport implements AttributeAccessor, Serializable {

    /** Map with String keys and Object values */
    private final Map<String, Object> attributes = new LinkedHashMap<String, Object>(0);

....

}

BeanMetadataAttribute attribute :

public class BeanMetadataAttribute implements BeanMetadataElement {

    private final String name;

    private final Object value;

    private Object source;

}

LookupOverride:

public class LookupOverride extends MethodOverride {

    private final String beanName;

    private Method method;
.......}

public abstract class MethodOverride implements BeanMetadataElement {

    private final String methodName;

    private boolean overloaded = true;

    private Object source;

...........}

public class MethodOverrides {

    private final Set<MethodOverride> overrides = new LinkedHashSet<MethodOverride>(0);

......}

ReplaceOverride：

    public class ReplaceOverride extends MethodOverride {

    private final String methodReplacerBeanName;

    private List<String> typeIdentifiers = new LinkedList<String>();

     。。。。。}

   constructor-arg：只有一個(gè)子元素（must not contain more than one sub-element）

       is only allowed to contain either 'ref' attribute OR 'value' attribute OR sub-element

ref作為屬性，則轉(zhuǎn)換成RuntimeBeanReference

public class RuntimeBeanReference implements BeanReference {

    private final String beanName;

    private final boolean toParent;

    private Object source;

。。。。}

如果value作為屬性則轉(zhuǎn)換成:

    public class TypedStringValue implements BeanMetadataElement {

    private String value;

    private volatile Object targetType;

    private Object source;

    private String specifiedTypeName;

    private volatile boolean dynamic;

   。。。。。}

構(gòu)造函數(shù)解析存放的對(duì)象：

    public class ConstructorArgumentValues {

    private final Map<Integer, ValueHolder> indexedArgumentValues = new LinkedHashMap<Integer, ValueHolder>(0);

    private final List<ValueHolder> genericArgumentValues = new LinkedList<ValueHolder>();

。。。。}

對(duì)應(yīng)<constructor index....   利用indexedArgumentValues 存放

沒有index的利用genericArgumentValues存放

Property解析:

    public class PropertyValue extends BeanMetadataAttributeAccessor implements Serializable {

    private final String name;

    private final Object value;

    private Object source;

    private boolean optional = false;

    private boolean converted = false;

    private Object convertedValue;

    /** Package-visible field that indicates whether conversion is necessary */
    volatile Boolean conversionNecessary;

    /** Package-visible field for caching the resolved property path tokens */
    transient volatile Object resolvedTokens;

.......}

其中PropertyValue 中的value保存的類型就是ManagedList

public abstract class AbstractBeanDefinition extends BeanMetadataAttributeAccessor
        implements BeanDefinition, Cloneable {

.........

private MutablePropertyValues propertyValues;

.........

} 作為存儲(chǔ)默認(rèn)元素的屬性

Qualifier子元素的解析:

    public class AutowireCandidateQualifier extends BeanMetadataAttributeAccessor {

    public static String VALUE_KEY = "value";

    private final String typeName;

     ......

    }

    public class BeanMetadataAttributeAccessor extends AttributeAccessorSupport implements BeanMetadataElement {

    private Object source;

   ..............

   }

   public abstract class AttributeAccessorSupport implements AttributeAccessor, Serializable {

    /** Map with String keys and Object values */
    private final Map<String, Object> attributes = new LinkedHashMap<String, Object>(0);

    ........

   }