SSM相关原理概述

目录

SpringIOC&AOP

MyBatis

SpringMVC

SpringIOC&AOP

源码

new ClassPathXmlApplicationContext(String[] configLocations,boolean refresh,ApplicationContext   parent){
   
    //...;
    refresh();//创建主流程
    //...;
}

AbstractApplicationContext#refresh(){
   
    //...;
    // 创建BeanFactory,（DefaultListableBeanFactory）
    // 并解析spring配置文件，构建一个BeanDefinitionMap集合，Key是id，value是BeanDefinition(所有类的类名)
    //将结果给到finishBeanFactoryInitialization，创建单例bean 
    ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
    //...;
    finishBeanFactoryInitialization(beanFactory);//创建所有单例的bean
    //...;
}

AbstractApplicationContext#finishBeanFactoryInitialization(){
   
	//...;
	beanFactory.preInstantiateSingletons();//创建所有单例的bean
	//...;
}

DefaultListableBeanFactory#preInstantiateSingletons(){
   
    for (String beanName : beanNames) {
   //遍历所有的beanName,挨个创建对象
        if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
   //非抽象+单例+非延迟，则创建
            if (isFactoryBean(beanName)) {
   //判断是否为工厂bean
                FactoryBean  fb = getBean("&"+beanName);//获得工厂Bean对象本身								
                //....
                getBean(beanName);//创建实际对象,此中会通过工厂Bean获得
            }else{
   
                getBean(beanName);//普通bean，直接创建对象
            }
        }
    }
}

AbstractBeanFactory#getBean(){
   
	return doGetBean(...);
}

AbstractBeanFactory#doGetBean(){
   
    //....
    if (mbd.isSingleton()) {
   
        //注意:此处有回调 ObjectFactory#getObject()
        sharedInstance = getSingleton(beanName, new ObjectFactory<Object>() {
   //获得或创建单例的bean
            @Override
            public Object getObject() throws BeansException {
   
                try {
   
                    return createBean(beanName, mbd, args);//回调方法，创建bean
                }
                //...
            }
        }
    }

DefaultSingletonBeanRegistry#getSingleton(beanName,singletonFactory){
   
    synchronized (this.singletonObjects) {
   //枷锁，防止重复创建
        Object singletonObject = this.singletonObjects.get(beanName);//尝试获取，如果有则不再创建
        //....
        singletonObject = singletonFactory.getObject();//回调doGetBean中内部类的方法，创建单例bean
        //....
        addSingleton(beanName, singletonObject);//记录已创建的单例bean，下次不再创建
    }
}

//接：回调doGetBean中内部类“ObjectFactory”的getObject方法，创建单例bean
AbstractAutowireCapableBeanFactory#createBean(){
   
    //.....
    doCreateBean(beanName, mbdToUse, args);//创建单例bean
}

这里先执行createBeanInstance，得到bean 原始对象 然后将bean原始对象给到populateBean中，然后进行初始化操作 在初始化过程中，会判断是否有AOP，从而创建出对应的代理bean对象返回

AbstractAutowireCapableBeanFactory#doCreateBean(){
   
    //创建bean对象
    if (instanceWrapper == null) {
   
        instanceWrapper = createBeanInstance(beanName, mbd, args);
    }
    ...
    try {
   
       	//完成注入，前面获取的instanceWrapper是无参bean，这里可以将配置文件中有的参数注入进去
        populateBean(beanName, mbd, instanceWrapper);
        if (exposedObject != null) {
   
            //执行初始化过程
            exposedObject = initializeBean(beanName, exposedObject, mbd);
        }
    }
}

AbstractAutowireCapableBeanFactory#createBeanInstance(){
   
    //.....
    return instantiateBean(beanName, mbd);//使用无参构造创建bean
}

AbstractAutowireCapableBeanFactory#instantiateBean(){
   
    //.....
    beanInstance = getInstantiationStrategy().instantiate(mbd, beanName, parent);
}

SimpleInstantiationStrategy#instantiate(){
   
    //....
    constructorToUse =  clazz.getDeclaredConstructor((Class[]) null);//获得构造方法对象
    //....
    return BeanUtils.instantiateClass(constructorToUse);//反射构建无参bean
}

AbstractAutowireCapableBeanFactory#initializeBean(){
   
    //....
    if (mbd == null || !mbd.isSynthetic()) {
   
        // 后处理器的 前置过程
        wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
    }

    try {
   
        // 调用初始化方法
        invokeInitMethods(beanName, wrappedBean, mbd);
    }
    catch (Throwable ex) {
   
        throw new BeanCreationException(
            (mbd != null ? mbd.getResourceDescription() : null),
            beanName, "Invocation of init method failed", ex);
    }

    if (mbd == null || !mbd.isSynthetic()) {
   
        // 调用后处理器的 后置过程，这里创建代理类对象，而不再是原始bean对象
        wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
    }
}

AbstractAutowireCapableBeanFactory#applyBeanPostProcessorsAfterInitialization(){
   
    //....
    // 遍历所有后处理器，对bean做后处理
    for (BeanPostProcessor beanProcessor : getBeanPostProcessors()) {
   
        result = beanProcessor.postProcessAfterInitialization(result, beanName);
        if (result == null) {
   
            return result;
        }
    }
}

在后处理器后置过程中，会进行springAOP的相关操作。

// 工厂启动时，会注册一些 后处理器，其中就包含 AspectJAwareAdvisorAutoProxyCreator
AspectJAwareAdvisorAutoProxyCreator extends AbstractAdvisorAutoProxyCreator{
   
    ...
}
AbstractAdvisorAutoProxyCreator extends AbstractAutoProxyCreator {
   
    ...
}
// AbstractAutoProxyCreator是 AspectJAwareAdvisorAutoProxyCreator的父类
// 该父类中定义了 后处理器的功能实现，有父类发起动态代理的定制
AbstractAutoProxyCreator#postProcessAfterInitialization(Object bean, String beanName){
   
    if (!this.earlyProxyReferences.contains(cacheKey)) {
   
        // 开始动态定制代理
        return wrapIfNecessary(bean, beanName, cacheKey);
   	}
}
AbstractAutoProxyCreator#wrapIfNecessary(){
   
    ....
    Object proxy = createProxy(
					bean.getClass(), beanName, specificInterceptors, new SingletonTargetSource(bean));
}
AbstractAutoProxyCreator#createProxy(){
   
    ....
    return proxyFactory.getProxy(getProxyClassLoader(