debug查看ioc容器结构

@Test
    public void getHero(){
        //创建一个容器，并和配置文件关联（一个容器关联一个配置文件）
        ApplicationContext ioc = new ClassPathXmlApplicationContext("beans.xml");
        //Object hero0 = ioc.getBean("hero01");//这样获取默认是object，但是编译类型还是Hero，可以强转一下
        Hero hero0 = (Hero) ioc.getBean("hero01");//这样获取默认是object，但是编译类型还是Hero，可以强转一下
        Hero hero01 = ioc.getBean("hero01", Hero.class);//这种方法制定了class类对象，所以不用转
    }

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

    <!--解读：
    1.beans.xml中可以配置多个bean（一个bean标签表示一个Java对象），这里配置一个hero对象的JavaBean
    2.class属性写类的全路径 => 用于spring底层反射创建对象
    3.<bean class="com.recorder.spring.bean.Hero" id="hero01">
    id表示该bean对象在spring容器中的id，可以通过id获取容器中的对象
    4.<property name="id" value="1"></property> value用于给对象的实行赋值
    -->
    <bean class="com.recorder.spring.bean.Hero" id="hero01">

        <property name="id" value="1"></property>
        <property name="name" value="李白"></property>
        <property name="skill" value="青莲剑歌"></property>

    </bean>

</beans>

这里的ioc是一个重量级的对象，创建比较耗费资源，一般创建一个就可以。

ioc下面的beanFactory就是bean工厂，下面的beanDefinitionMap（类型是ConcurrentHashMap）是一个比较重要的属性

它将我们在beans.xml文件中配置的各个bean的信息保存到了下面的table属性中（只是保留了定义信息，还没有创建成对象），

在debug中可以看到table是一个初始512大小（超过会自动扩容）的ConcurrentHashMap$Node的匿名内部类类型的数组，使用这个内部类是因为方便保存所需要的（对象）信息

不如我们先看一下这个内部类

static class Node<K,V> implements Map.Entry<K,V> {
        final int hash;
        final K key;
        volatile V val;
        volatile Node<K,V> next;

        Node(int hash, K key, V val, Node<K,V> next) {
            this.hash = hash;
            this.key = key;
            this.val = val;
            this.next = next;
        }

        public final K getKey()       { return key; }
        public final V getValue()     { return val; }
        public final int hashCode()   { return key.hashCode() ^ val.hashCode(); }
        public final String toString(){ return key + "=" + val; }
        public final V setValue(V value) {
            throw new UnsupportedOperationException();
        }

        public final boolean equals(Object o) {
            Object k, v, u; Map.Entry<?,?> e;
            return ((o instanceof Map.Entry) &&
                    (k = (e = (Map.Entry<?,?>)o).getKey()) != null &&
                    (v = e.getValue()) != null &&
                    (k == key || k.equals(key)) &&
                    (v == (u = val) || v.equals(u)));
        }

        /**
         * Virtualized support for map.get(); overridden in subclasses.
         */
        Node<K,V> find(int h, Object k) {
            Node<K,V> e = this;
            if (k != null) {
                do {
                    K ek;
                    if (e.hash == h &&
                        ((ek = e.key) == k || (ek != null && k.equals(ek))))
                        return e;
                } while ((e = e.next) != null);
            }
            return null;
        }
    }