Spring （一）

Spring是一个开源框架，是一个基于IOC和AOP来架构多层的JavaEE 架构,默认是单例模式

Spring模块分为以下几个部分

1.Core container(核心容器）

含有Core，Beans,Context,和Expression Language

2.Data Access

3.Web

4.AOP

4.Test

IOC

Inversion of Control

public class Girl {
//boy是在应用内部创建及维护的。
private Boy boy =new Boy();
public void kiss() {
System.out.println(boy.getBoyObject());
}
}

IOC（控制反转）：所谓控制反转就是应用本身不负责依赖对象的创建及维护，依赖对象的创建及维护是由外部容器负责的。这样控制权就由应用转移到了外部容器，控制权的转移就是所谓反转，目的是为了获得更好的扩展性和良好的可维护性。

<bean id="boy" class="cn.itcast.a_ioc.Boy"></bean>

DI

（依赖注入）：把依赖的对象交给外部容器负责创建，就是在运行期间，有外部容器动态的将依赖对象注入到组件中。

public class Girl {
	private Boy boy = null;
	public Boy getBoy() {
		return boy;
	}
	//由spring容器注入Boy对象
	public void setBoy(Boy boy) {
		this.boy = boy;
	}
	public Girl(){
		System.out.println("这是Girl的构造方法");
	}
	public void kiss(){
		System.out.println("Girl的kiss()方法");
		boy.displany();
	}
}
//把依赖的对象boy 交有外部容器动态创建并注入

<bean id="boy" class="cn.itcast.b_di.Boy"></bean>
<bean id="girl" class="cn.itcast.b_di.Girl">
<!--
property:用来指定Girl对象中的属性
* name：表示Girl类中属性的名称
* ref：将外部的Boy对象通过set方法注入给Girl对象
-->
<property name="boy" ref="boy"></property>
</bean>　

　 当spring容器启动后，因为spring容器可以管理bean对象的创建，销毁等生命周期，所以我们只需从容器直接获取Bean对象就行，而不用编写一句代码来创建bean对象。

<context:annotation-config/>

这个配置隐式注册了多个对注解进行解析处理的处理器
AutowiredAnnotationBeanPostProcessor，CommonAnnotationBeanPostProcessor，
PersistenceAnnotationBeanPostProcessor，RequiredAnnotationBeanPostProcessor

核心实现类

DefaultListableBeanFactory

DefaultListableBeanFactory是Spring注册及加载Bean的默认实现，主要是对bean注册后的处理

XmlBeanDefinitionReader

InputStreamSource

//通过Resource完成了对配置文件的封装
Resource resource = new ClassPathResource("beanFactoryTest.xml");

public InputStream getInputStream() throws IOException {
        InputStream is;
        if (this.clazz != null) {
            is = this.clazz.getResourceAsStream(this.path);
        } else if (this.classLoader != null) {
            is = this.classLoader.getResourceAsStream(this.path);
        } else {
            is = ClassLoader.getSystemResourceAsStream(this.path);
        }
        //省略部分代码
    }

接口 ApplicationContextInitializer

实现接口的initialize 方法初始化 配置 如reids apollo

XmlBeanFactory

XmlBeanFactory
public XmlBeanFactory(Resource resource, BeanFactory parentBeanFactory) throws BeansException {
        super(parentBeanFactory);
        this.reader = new XmlBeanDefinitionReader(this);
        this.reader.loadBeanDefinitions(resource);
    }
XmlBeanDefinitionReader->loadBeanDefinitions->doLoadBeanDefinitions->registerBeanDefinitions　

实例化bean

AbstractApplicationContext->getBean->doGetBean

 protected <T> T doGetBean(String name, @Nullable Class<T> requiredType, @Nullable Object[] args, boolean typeCheckOnly) throws BeansException {
	//    提取对应的bean名称
    String beanName = this.transformedBeanName(name);
	//检查缓存中或者实例工厂中是否有对应的实例（因为可能有循环依赖的情况，所有在创建bean是 如有有依赖上一个bean的则直接使用ObjectFactory
	//直接尝试从缓存中或者SingletonFactories的ObjectFactory中获取
        Object sharedInstance = this.getSingleton(beanName);
        Object bean;
        if (sharedInstance != null && args == null) {
            if (this.logger.isDebugEnabled()) {
                if (this.isSingletonCurrentlyInCreation(beanName)) {
                    this.logger.debug("Returning eagerly cached instance of singleton bean '" + beanName + "' that is not fully initialized yet - a consequence of a circular reference");
                } else {
                    this.logger.debug("Returning cached instance of singleton bean '" + beanName + "'");
                }
            }

			//返回对应的实例，返回实例本身或者指定方法返回的实例
            bean = this.getObjectForBeanInstance(sharedInstance, name, beanName, (RootBeanDefinition)null);
        } else {
		//检查是否有循环依赖，只有单例才会尝试解决循环依赖，其他直接报错
            if (this.isPrototypeCurrentlyInCreation(beanName)) {
                throw new BeanCurrentlyInCreationException(beanName);
            }

            BeanFactory parentBeanFactory = this.getParentBeanFactory();
			//beanDefinitionMap中(所以已经加载的类中如果不包含从parentBeanFactory中检测
            if (parentBeanFactory != null && !this.containsBeanDefinition(beanName)) {
                String nameToLookup = this.originalBeanName(name);
                if (parentBeanFactory instanceof AbstractBeanFactory) {
                    return ((AbstractBeanFactory)parentBeanFactory).doGetBean(nameToLookup, requiredType, args, typeCheckOnly);
                }
				//递归到BeanFactory中寻找
                if (args != null) {
                    return parentBeanFactory.getBean(nameToLookup, args);
                }

                return parentBeanFactory.getBean(nameToLookup, requiredType);
            }
				//记录不是做类型检查，记录要创建的bean
            if (!typeCheckOnly) {
                this.markBeanAsCreated(beanName);
            }

            try {
                RootBeanDefinition mbd = this.getMergedLocalBeanDefinition(beanName);
                this.checkMergedBeanDefinition(mbd, beanName, args);
                String[] dependsOn = mbd.getDependsOn();
                String[] var11;
				//若存在依赖则需要递归实例化依赖的 bean
                if (dependsOn != null) {
                    var11 = dependsOn;
                    int var12 = dependsOn.length;

                    for(int var13 = 0; var13 < var12; ++var13) {
                        String dep = var11[var13];
                        if (this.isDependent(beanName, dep)) {
                            throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
                        }
						//缓存依赖调用
                        this.registerDependentBean(dep, beanName);

                        try {
                            this.getBean(dep);
                        } catch (NoSuchBeanDefinitionException var24) {
                            throw new BeanCreationException(mbd.getResourceDescription(), beanName, "'" + beanName + "' depends on missing bean '" + dep + "'", var24);
                        }
                    }
                }
				// 依赖的bean实例完后，开始实例化mbd本身
                if (mbd.isSingleton()) {
                    sharedInstance = this.getSingleton(beanName, () -> {
                        try {
                            return this.createBean(beanName, mbd, args);
                        } catch (BeansException var5) {
                            this.destroySingleton(beanName);
                            throw var5;
                        }
                    });
                    bean = this.getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
                } else if (mbd.isPrototype()) {
                    var11 = null;
					// prototype 模式的创建（new）
                    Object prototypeInstance;
                    try {
                        this.beforePrototypeCreation(beanName);
                        prototypeInstance = this.createBean(beanName, mbd, args);
                    } finally {
                        this.afterPrototypeCreation(beanName);
                    }

                    bean = this.getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
                } else {
				  // 指定的 scope上实例化bean（添加@Scope注解的）
                    String scopeName = mbd.getScope();
                    Scope scope = (Scope)this.scopes.get(scopeName);
                    if (scope == null) {
                        throw new IllegalStateException("No Scope registered for scope name '" + scopeName + "'");
                    }

                    try {
                        Object scopedInstance = scope.get(beanName, () -> {
                            this.beforePrototypeCreation(beanName);

                            Object var4;
                            try {
                                var4 = this.createBean(beanName, mbd, args);
                            } finally {
                                this.afterPrototypeCreation(beanName);
                            }

                            return var4;
                        });
                        bean = this.getObjectForBeanInstance(scopedInstance, name, beanName, mbd);
                    } catch (IllegalStateException var23) {
                        throw new BeanCreationException(beanName, "Scope '" + scopeName + "' is not active for the current thread; consider defining a scoped proxy for this bean if you intend to refer to it from a singleton", var23);
                    }
                }
            } catch (BeansException var26) {
                this.cleanupAfterBeanCreationFailure(beanName);
                throw var26;
            }
        }
		//检查需要的类型是否符合bean的实际类型
        if (requiredType != null && !requiredType.isInstance(bean)) {
            try {
                T convertedBean = this.getTypeConverter().convertIfNecessary(bean, requiredType);
                if (convertedBean == null) {
                    throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
                } else {
                    return convertedBean;
                }
            } catch (TypeMismatchException var25) {
                if (this.logger.isDebugEnabled()) {
                    this.logger.debug("Failed to convert bean '" + name + "' to required type '" + ClassUtils.getQualifiedName(requiredType) + "'", var25);
                }

                throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
            }
        } else {
            return bean;
        }
    }

　　

注解

Autowired

//@Autowired @Qualifier("userDao1")
private IUserDao userDao;

Autowired标注在字段上
如果Autowired注解标注在字段上，会按照IUserDao的类型找，找不到抛出异常。
Autowired @Qualifier("userDao")标注在字段上
如果@Autowired @Qualifier("userDao")标注在字段上，按照名称userDao找，如果没有找到，此时会抛出异常。

Resource

Resource注解标注在字段上
如果@Resource注解标注在字段上， 此时先按照属性的名称找，找不到在根据属性类型找，都没找到就抛异常。
@Resource(name="userDao")标注在字段上，根据name找，找不到就抛异常。