demo	https://gitee.com/easybao/aop.git

spring DI运行时序

AbstractApplicationContext类的 refresh()方法

1: prepareBeanFactory(beanFactory); 这个方法是对beanFactory进行前期准备, 可以看到 beanFactory.registerResolvableDependency(BeanFactory.class, beanFactory);  设置了BeanFactory,因为获取实例是从 BeanFactory中获取

2: finishBeanFactoryInitialization(beanFactory); 这个是实例化所有剩余的非懒加载的实例对象, 对象的DI就是这一步完成的,------>beanFactory.preInstantiateSingletons();

    ---->DefaultListableBeanFactory的preInstantiateSingletons()方法,这里可以看到获取到所有的beanName,--->getBean(String name) --->AbstractBeanFactory类的doGetBean()

    ---->createBean(beanName, mbd, args)--->AbstractAutowireCapableBeanFactory类的createBean(),一看这个类名字就知道是自动注入,@Autowire相关--->doCreateBean(beanName, mbdToUse, args);

		2.1--->createBeanInstance(beanName, mbd, args);,  先创建实例

			2.1.1--->autowireConstructor(beanName, mbd, null, null); 这个是有autowire注解的属性实例化,

			2.1.2--->instantiateBean(beanName, mbd); 这是无参构造对象实例化--->beanInstance = getInstantiationStrategy().instantiate(mbd, beanName, parent);--->SimpleInstantiationStrategy类的 instantiate()方法,在这里可以看到, 如果有方法重写就使用反射,如果有没方法重写就使用CGLIB代理来创建实例

		2.2--->populateBean(beanName, mbd, instanceWrapper); 属性注入--->可以看到autowireByName(beanName, mbd, bw, newPvs); 根据name注入, autowireByType(beanName, mbd, bw, newPvs);根据类型注入

		2.3--->initializeBean(beanName, exposedObject, mbd); 回调函数, 就是如果一个类继承或实现了各种aware接口,就回调自身给此类的属性赋值	

https://www.cnblogs.com/liuyk-code/p/9886033.html

spring IOC AOP运行时时序    https://github.com/pmgysel/aop-demo.git  这个项目的依赖, 是个springboot关联包, 另外依赖了aspectjweaver , spring-boot-starter-aop 这二个依赖包,只需要一个就可以

https://www.cnblogs.com/51life/p/9243021.html, 这里分析的是xml形式的aop

https://gitee.com/easybao/aop.git

AbstractApplicationContext类的 refresh()--->

	1 obtainFreshBeanFactory();-->refreshBeanFactory();--->AbstractRefreshableApplicationContext类的loadBeanDefinitions(beanFactory);--->AbstractXmlApplicationContext类的loadBeanDefinitions(beanDefinitionReader);--->AbstractBeanDefinitionReader类的this.loadBeanDefinitions((Resource)resource);

	   --->XmlBeanDefinitionReader类的this.doLoadBeanDefinitions(inputSource, encodedResource.getResource());

		--->1.1 this.doLoadDocument(inputSource, resource); 这是解析xml文件成document

		--->1.2 this.registerBeanDefinitions(doc, resource); ,这是将beandefinition注册到容器中,  IOC AOP的对象实例化就是在此步--->registerBeanDefinitions(doc, this.createReaderContext(resource));---.DefaultBeanDefinitionDocumentReader类的doRegisterBeanDefinitions(doc.getDocumentElement());--->parseBeanDefinitions(root, this.delegate);

			--->1.2.1 this.parseDefaultElement(ele, delegate); 这里是解析默认的标签,比如 bean,import,alias,beans, 解析成beanDefinition,之后注册到 Map<String, BeanDefinition> beanDefinitionMap 中, 这里是 IOC的实现

			--->1.2.2 delegate.parseCustomElement(ele);  这里是解析 定制的标签,比如 Pointcut, Aspectj, Advisor, 因为这些标签,aop在xml中是必须要配置的--->BeanDefinitionParserDelegate类的handler.parse(ele, new ParserContext(this.readerContext, this, containingBd));--->NamespaceHandlerSupport类的parser.parse(element, parserContext)--->ConfigBeanDefinitionParser类的parse() 这里可以看到解析各种标签的方法--->parseAspect(elt, parserContext);

				--->1.2.2.1 parseAdvice(aspectName, i, aspectElement, (Element) node, parserContext, beanDefinitions, beanReferences); 这是解析切面类方法--->

				--->1.2.2.2 parsePointcut(pointcutElement, parserContext)  这是解析具体切入点的方法--->ConfigBeanDefinitionParser类的 registerBeanDefinition(pointcutBeanName, pointcutDefinition);--->DefaultListableBeanFactory类的this.beanDefinitionMap.put(beanName, beanDefinition);

	2,  接下来是代理对象生成,注入容器的过程 InternalAutoProxyCreator, 这个是生产代理对象的后置处理器. xml情况下用来生成 AspectJAwareAdvisorAutoProxyCreator 对象的, 注解情况下用来生成 AnnotationAwareAspectJAutoProxyCreator 对象, 生成是在registerBeanPostProcessors(beanFactory);生成的

	registerBeanPostProcessors(beanFactory);--->for (String ppName : orderedPostProcessorNames) , 这行代码打断点,可以看到orderedPostProcessors 就是InternalAutoProxyCreator集合,--->BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);--->这里的pp, 就是AnnotationAwareAspectJAutoProxyCreator, 或者AspectJAwareAdvisorAutoProxyCreator, 

	3: beanDefinition实例化过程, 也就是DI, AOP实例化过程

	finishBeanFactoryInitialization(beanFactory); 这是实例化所有剩余 非懒加载的对象--->beanFactory.preInstantiateSingletons();实例化之前--->DefaultListableBeanFactory类的 this.getBean(beanName);--->AbstractBeanFactory类的doGetBean()--->this.createBean(beanName, mbd, args);--->AbstractAutowireCapableBeanFactory 类的this.doCreateBean(beanName, mbdToUse, args);

		3.1 this.createBeanInstance(beanName, mbd, args); 创建bean实例

		3.2 this.populateBean(beanName, mbd, instanceWrapper); bean实例属性注入

			3.2.1 this.autowireByName(beanName, mbd, bw, newPvs); 注入@Autoware注解的属性, 根据name注入

			3.2.2 this.autowireByType(beanName, mbd, bw, newPvs);注入@Autoware注解的属性, 根据bean类型注入

		3.3 this.initializeBean(beanName, exposedObject, mbd); 这个方法中可以看到回调了各种aware方法,这是一个回调方法,如果一个类A实现或继承了各种aware接口, 比如BeanFactoryAware, ApplicationContextAware, BeanNameAware等, 都是将这些aware类自身作为属性赋值给这个类A,  这个类总可以看到,先是调用了各种aware接口,对自身进行赋值,然后this.invokeInitMethods(beanName, wrappedBean, mbd); ,调用了初始化方法,

		       --->wrappedBean = this.applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName); 代理对象的生成在这个方法中进行的--->>AbstractAutowireCapableBeanFactory 类的processor.postProcessAfterInitialization(result, beanName);--->AbstractAutoProxyCreator类的wrapIfNecessary(bean, beanName, cacheKey);

			3.3.1 --->getAdvicesAndAdvisorsForBean(bean.getClass(), beanName, null);,这个方法是: 如果有切面类就生成代理--->AbstractAdvisorAutoProxyCreator类的findEligibleAdvisors(beanClass, beanName);这个是查找所有的可用合格通知器

			3.3.2 --->createProxy(bean.getClass(), beanName, specificInterceptors, new SingletonTargetSource(bean)); 生成代理对象,生成代理对象之后,还会设置拦截器,，当代理对象调用目标方法时，就会触发这些拦截器--->proxyFactory.copyFrom(this); 这里打断点, this指的就是AnnotationAwareAspectJAutoProxyCreator 或者 AspectJAwareAdvisorAutoProxyCreator --->proxyFactory.getProxy(getProxyClassLoader());--->ProxyFactory类的createAopProxy().getProxy(classLoader);--->AopProxy接口的getProxy(), 这里可以看到JDK代理, CGLIB代理, 然后将代理对象添加到 Map<Object, Class<?>> proxyTypes  容器总

				3.3.2.1--->JdkDynamicAopProxy. getProxy()

					增强织入过程,拦截器如何起作用,起作用过程

					3.3.2.1.1--->Proxy.newProxyInstance(classLoader, this.proxiedInterfaces, this); 这里的this 指的是调用本类的invoke()--->target = targetSource.getTarget();这是获取目标对象--->this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass); 这是获取拦截器链

						3.3.2.1.1.1--->这里是chain为空,就直接调用目标方法 AopUtils.invokeJoinpointUsingReflection(target, method, argsToUse); --->AopUtils.invokeJoinpointUsingReflection(target, method, argsToUse);---> method.invoke(target, args);

						3.3.2.1.1.2--->chain不为空,沿着拦截链前行执行--->invocation.proceed();---.ReflectiveMethodInvocation类的proceed(),  这个方法是递归, 不停的取出切面类,和 自定义的切面类是否匹配,如果匹配就开始调用, dm.interceptor.invoke(this);

								如果是一个拦截器,就直接调用 ((MethodInterceptor) interceptorOrInterceptionAdvice).invoke(this);--->invoke(MethodInvocation mi)

									--->MethodBeforeAdviceInterceptor类的invoke(MethodInvocation mi) --->this.advice.before(mi.getMethod(), mi.getArguments(), mi.getThis()); 这就是一个前置增强的方法,  mi.proceed();这是下一个拦截器调用

									--->AspectJAfterAdvice类的invoke(MethodInvocation mi) 这是一个后置通知的增强方法

									--->AspectJAroundAdvice 类的invoke(MethodInvocation mi) 这是一个环绕通知的增强方法

				3.3.2.2--->CglibAopProxy. getProxy()

        3.4--->this.registerDisposableBeanIfNecessary(beanName, bean, mbd); 将bean实例存入容器中--->this.registerDisposableBean(beanName, new DisposableBeanAdapter(bean, beanName, mbd, this.getBeanPostProcessors(), acc));--->this.disposableBeans.put(beanName, bean);--->Map<String, Object> disposableBeans = new LinkedHashMap();

https://www.cnblogs.com/liuyk-code/p/9886033.html

注解版spring ioc 源码解读,这里只解读 spring 通过包扫描,将包下的类转换为 beandefinition,注册到容器的过程, 实例化的过程和 xml是一样的 都是通过finishBeanFactoryInitialization(beanFactory);

https://github.com/shiyujun/spring-framework

注解有一个很重要的类: AnnotationConfigApplicationContext类, 从这个类开始解读

ApplicationContext context = new AnnotationConfigApplicationContext("cn.shiyujun.config"); --->

	1--->this();---> 这里可以看到 新建了二个对象,  一个scanner扫描器,  一个reader阅读器

        	2--->this.scan(basePackages); 这里主要分析sacn这个方法, 看看是怎样的扫描包,将包下的类转换为beandefinition ,并注册到容器中的--->this.scanner.scan(basePackages);--->this.doScan(basePackages);--->

		            2.1--->Set<BeanDefinition> candidates = this.findCandidateComponents(basePackage);  这个方法是获取到 basePackage包下的所有的 beandefinition set集合

		            2.2--->this.checkCandidate(beanName, candidate ),  这个方法至此已经获取到了 beanName, 和 beanDefinition,

		            2.3--->this.registerBeanDefinition(definitionHolder, this.registry);--->BeanDefinitionReaderUtils.registerBeanDefinition(definitionHolder, registry);--->registry.registerBeanDefinition(beanName, definitionHolder.getBeanDefinition());--->DefaultListableBeanFactory类的registerBeanDefinition()方法--->this.beanDefinitionMap.put(beanName, beanDefinition);  注册到容器中

       	3--->this.refresh();

spring MVC运行时序

https://blog.csdn.net/win7system/article/details/90674757

spring MVC是一个前端框架, 用来处理请求,, DispatcherServlet 继承了Servlet, 主要分析servlet的 init()方法, 和 service()方法;

Servlet类的 init(ServletConfig config)--->GenericServlet类的this.init();--->HttpServletBean类的init()--->initServletBean();--->FrameworkServlet类的 this.webApplicationContext = initWebApplicationContext();

	1 --->这里可以看到先获取ConfigurableWebApplicationContext  cwac, 如果这个cwac对象没有激活,就--->configureAndRefreshWebApplicationContext(cwac);, 一般项目启动之后, cwac这个对象就已经是激活了,因为项目启动时候,会容器配置刷新,也就是refersh()方法,--->wac.refresh(); 这里又到了 容器刷新的步骤

	2--->onRefresh(wac);--->DispatcherServlet类的 initStrategies(context);  这个方法中关键看二个方法

		2.1--->initHandlerMappings(context); 初始化处理器映射器--->Map<String, HandlerMapping> matchingBeans =BeanFactoryUtils.beansOfTypeIncludingAncestors(context, HandlerMapping.class, true, false); 这个方法就是从BeanFactory工厂中获取HandlerMapping集合,  这里还有个兜底策略,如果获取到的HandlerMapping集合为空, 就会获取从默认的配置文件( DispatcherServlet.properties )中获取 getDefaultStrategies(context, HandlerMapping.class);

			获取到的map中第一个就是RequestMappingHandlerMapping, 主要是这个类的初始化, 这个类的作用是能将 请求路径 和  controller中的方法 形成映射关系, 这样当请求过来的时候, 就能根据请求路径找到对应的方法,

			RequestMappingHandlerMapping, 可以看到这个类是有实现InitializingBean接口, 所以afterPropertiesSet() 就是他的一个初始化方法.      他是什么时候初始化的呢?  这个类的初始化是 项目启动的时候就已将走afterPropertiesSet()这个方法了,

			RequestMappingHandlerMapping类的 afterPropertiesSet()--->super.afterPropertiesSet();--->AbstractHandlerMethodMapping 类的 initHandlerMethods();--->processCandidateBean(beanName);--->detectHandlerMethods(beanName);

                2.1.1--->getMappingForMethod(method, userType); 仔细看这个方法是将,类上requestMapping的路径 和方法上的路径组合起来 ---->

			    2.1.2--->registerHandlerMethod(handler, invocableMethod, mapping);这个方法作用是组装了二个map,: Map<T, HandlerMethod> mappingLookup , key是:RequestMappingInfo对象(可以知道请求路径(requestmapping的路径+ 方法上的路径))  value是HandlerMethod对象(对象中有 类的全限定名,和对应的方法名)  ,

										                 另一个map是: MultiValueMap<String, T> urlLookup  ,key是请求路径url , value是RequestMappingInfo对象  这个map是 一对多的关系   因为有的请求是rest风格的,请求路径相同, 根据get,put,delete,来访问不同的方法,   通过这二个map,就可以准确的将请求路径和 方法对应起来

		2.2--->initHandlerAdapters(context); 初始化处理器适配器 RequestMappingHandlerAdapter  和处理器映射器集合获取方式相同,也是从BeanFactory中获取, 如果获取不到,就从默认的配置文件中获取

                2.2.1---> RequestMappingHandlerAdapter 这个类是有实现	InitializingBean接口, 所以afterPropertiesSet() 就是他的一个初始化方法 项目启动的时候就会触发这个方法.他的初始化会 加载各种解析器

	至此 WebApplicationContext 初始化完毕. 	项目启动之后,第一个请求,会触发初始化,之后都不会重复初始化,而是走 service()方法

Servlet类的 service(ServletRequest req, ServletResponse res)--->HttpServlet类的 service(request, response);--->FrameworkServlet类的doGet()--->processRequest(request, response);=--->doService(request, response);--->DispatcherServlet类的doService()--->doDispatch(request, response);

	1.1--->mappedHandler = getHandler(processedRequest); 这个方法是获取处理器链 HandlerExecutionChain (包含了,一个handler处理器, 一个interceptorList,拦截器list)

	1.2--->HandlerAdapter ha = getHandlerAdapter(mappedHandler.getHandler());  这是获取请求映射处理器适配器, RequestMappingHandlerAdapter  根据handler 筛选对应的处理器适配器ha

	1.3--->mv = ha.handle(processedRequest, response, mappedHandler.getHandler());获取到对应的处理器适配器之后,由该适配器来处理请求--->AbstractHandlerMethodAdapter类的 handleInternal(request, response, (HandlerMethod) handler);---.RequestMappingHandlerAdapter类的 mav = invokeHandlerMethod(request, response, handlerMethod); 这个是执行对应controller中的方法,返回mav----->invocableMethod.invokeAndHandle(webRequest, mavContainer);到这里后,就是调用controller中的方法, 会跳转到方法中执行,

    1.4--->之后将 mv 执行结果交给视图解析器,进行渲染后返回到前端

spring 事务原理:   https://www.cnblogs.com/dennyzhangdd/p/9602673.html,

编程式事务管理： 编程式事务管理使用TransactionTemplate可实现更细粒度的事务控制。

申明式事务管理： 基于Spring AOP实现。其本质是对方法前后进行拦截，然后在目标方法开始之前创建或者加入一个事务，在执行完目标方法之后根据执行情况提交或者回滚事务。

主要有三个接口来提供事务:

TransactionDefinition

PlatformTransactionManager

TransactionStatus

https://www.cnblogs.com/dennyzhangdd/p/9602673.html

spring事务原理: 总结就是动态代理, 在执行核心逻辑之前, 获取事务,然后执行业务逻辑, 如果失败就回滚,成功就提交事务

@SpringBootApplication--->有三个注解

	1--->@EnableAutoConfiguration--->@Import(AutoConfigurationImportSelector.class)--->AutoConfigurationImportSelector类的selectImports()--->getAutoConfigurationEntry(annotationMetadata);--->getCandidateConfigurations(annotationMetadata, attributes);--->SpringFactoriesLoader.loadFactoryNames(getSpringFactoriesLoaderFactoryClass(),

				getBeanClassLoader());这个方法就是从配置文件中读取配置list, 读取各种bean的全限定类名  META-INF文件夹下/spring.factories配置文件, 可以看到有个类 TransactionAutoConfiguration---> 打开这个类之后,可以看到@Configuration 和@Bean 这二个注解配合使用就是将java的bean初始化,   @ConditionalOnClass(PlatformTransactionManager.class) 这里可以看到需要PlatformTransactionManager这个接口(有三个方法; getTransaction(), commit(), rollback())----->有个内部类: EnableTransactionManagementConfiguration--->内部类中可看到有JDK代理,CGLIB代理,默认是cglib代理, 有个注解@EnableTransactionManagement--->点进去看到需要这个@Import(TransactionManagementConfigurationSelector.class)--->new String[] {AutoProxyRegistrar.class.getName(),ProxyTransactionManagementConfiguration.class.getName()};

			1.1--->AutoProxyRegistrar这个类--->registerBeanDefinitions()--->AopConfigUtils.registerAutoProxyCreatorIfNecessary(registry);--->AopConfigUtils类的registerAutoProxyCreatorIfNecessary(registry, null)--->registerOrEscalateApcAsRequired()--->registry.containsBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME) 这里可以看到 org.springframework.aop.config. internalAutoProxyCreator 创建了一个internalAutoProxyCreator ,--->beanDefinition 注入到Map<String, BeanDefinition> beanDefinitionMap容器中--->之后是生成代理(默认是CGLIB代理),  需要看finishBeanFactoryInitialization(beanFactory);方法----> 这里省略,因为aop源码解读这里已经讲过了

			1.2--->ProxyTransactionManagementConfiguration 这是一个配置类, 定义了事务增强器

				1.2.1--->transactionAdvisor 事务增强器

				1.2.2--->transactionAttributeSource 事务属性资源

				1.2.3--->transactionInterceptor()  事务拦截器--->TransactionInterceptor类 继承了TransactionAspectSupport类的invokeWithinTransaction() 方法--> 这里可以看到有个if--else  前者是针对注解(声明式事务 ), 后者是针对xml(编程式事务) --->这里看声明式事务

					1.2.3.1--->createTransactionIfNecessary(tm, txAttr, joinpointIdentification); 创建事务--->status = tm.getTransaction(txAttr); 这里是获取事务, prepareTransactionInfo(tm, txAttr, joinpointIdentification, status);--->txInfo.bindToThread();然后将事务和当前线程绑定

					1.2.3.2--->invocation.proceedWithInvocation(); 这是回调方法,执行正常业务逻辑

					1.2.3.3--->completeTransactionAfterThrowing(txInfo, ex); 这是有异常时候回滚--->txInfo.getTransactionManager().rollback(txInfo.getTransactionStatus());--->PlatfromTransactionManager接口的rollback()--->processRollback(defStatus, false);--->doRollback(status);--->DataSourceTransactionmabager类的doRollback()---> con.rollback();这里就到 jdbc的 rollback()方法了

					1.2.3.4--->commitTransactionAfterReturning(txInfo); 提交事务--->txInfo.getTransactionManager().commit(txInfo.getTransactionStatus());--->AbstractPlatformTransactionmanager类的commit()--->processCommit(defStatus);--->doCommit(status);---> >DataSourceTransactionmabager类的 con.commit();

	2--->@ComponentScan

	3--->@Configuration

事务总结: SpringBootApplication注解点进去可看到  注解EnableAutoConfiguration , 点进去可看到导入一个配置类: AutoConfigurationImportSelector配置类, 这个配置类会将 spring.factorys配置文件中的各个配置类都加载进来,其中就包括 TransactionAutoConfiguration 这个配置类,  这个配置类中会被包扫描,然后变成beanDefinition 添加到容器中,供实例化时候使用

说一说spring事务原理:

spring事务主要有三个类: platformTransactionManager, transactionDefinition, transactionstatus,

 springBootApplication这个注解点进去后可以看到有个 自动装配的注解:enableautoconfiguration, 这个注解会自动加载 spring.factories的很多配置类,并初始化,有关事务的是: TransactionAutoConfiguration,  这是一个配置类, 配置了事务拦截器,拦截目标方法, 在目标方法之前获取事务,并将事务和当前线程绑定,  然后执行目标方法, 如果成功就提交事务, 如果失败就回滚事务

事务传播机制 : 7种

https://zhuanlan.zhihu.com/p/148504094

REQUIRED:  支持当前事务, 当前存在事务就加入当前事务, 如果没有事务就新建一个事务

SUPPORTS: 当前存在事务就加入当前事务, 当前没有事务就非事务执行

MANDATORY:  一定需要事务,当前存在事务就加入当前事务, 当前不存在事务就抛异常

REQUIRES_NEW:  创建新事务, 如果当前存在事务,就挂起当前事务, 新建一个事务

NOT_SUPPORTED: 不支持事务, 始终以非事务执行, 如果当前存在事务就挂起当前事务

NEVER: 始终不使用事务,如果当前存在事务,就抛异常

NESTED: 嵌套事务: 如果当前存在事务就 嵌套在当前事务中执行, 如果当前不存在事务,就开启一个事务,  相当于一个子事务,  且父事务回滚,子事务也跟着回滚

Mybatis源码解读: 很简单 https://gitee.com/easybao/mybatis-sources_reader.git

1---> InputStream is = Resources.getResourceAsStream("SqlMapConfig.xml");  加载配置文件, 将配置文件变成输入流

2--->SqlSessionFactory sessionFactory = new SqlSessionFactoryBuilder().build(is); 获取DefaultSqlSessionFactory --->build(inputStream, null, null);

	2.1--->XMLConfigBuilder parser = new XMLConfigBuilder(inputStream, environment, properties); //获取xml解析器

	2.2--->parser.parse()--->parseConfiguration(parser.evalNode("/configuration"));--->这里可以看到解析各种标签

	2.3--->DefaultSqlSessionFactory 返回这个对象

3--->sqlSession = sessionFactory.openSession();开启一个会话--->>DefaultSqlSessionFactory 类的 openSessionFromDataSource(configuration.getDefaultExecutorType(), null, false);--->这里可以看到: 先获取上下文环境, 然后根据上下文环境新建一个事务,--->之后新建一个执行器executor---> --->      return new DefaultSqlSession(configuration, executor, autoCommit);-->最后返回这个对象DefaultSqlSession

4--->mapper = sqlSession.getMapper(UserMapper.class); 创建代理对象--->DefaultSqlSession 类的configuration.<T>getMapper(type, this);--->mapperRegistry.getMapper(type, sqlSession);

--->mapperProxyFactory.newInstance(sqlSession);--->MapperProxyFactory类的newInstance(mapperProxy);--->Proxy.newProxyInstance(mapperInterface.getClassLoader(), new Class[] { mapperInterface }, mapperProxy); 注意看这个方法, 他回调的invoke方法在 mapperProxy类中--->MapperProxy类的invoke(Object proxy, Method method, Object[] args) throws Throwable {)

--->mapperMethod.execute(sqlSession, args); 这是执行sql语句的方法--->点进来方法后可以看到各种 update, insert, select, delete的处理方法, 这里选择select --->executeForMany(sqlSession, args);--->sqlSession.<E>selectList(command.getName(), param, rowBounds);--->DefaultSqlSession类的selectList()--->executor.query(ms, wrapCollection(parameter), rowBounds, Executor.NO_RESULT_HANDLER);

--->BaseExecutor类的query(ms, parameter, rowBounds, resultHandler, key, boundSql);--->queryFromDatabase(ms, parameter, rowBounds, resultHandler, key, boundSql);--->doQuery(ms, parameter, rowBounds, resultHandler, boundSql);--->SimpleExecutor类的doQuery()--->这里可以看到获取了prepareStatement--->handler.<E>query(stmt, resultHandler);--->SimpleStatementHandler类的statement.execute(sql); 这里就是原生的JDBC的 statement执行查询语句

1-->AbstractApplicationContext类的 refersh()方法

	1.1--->obtainFreshBeanFactory(); 这个方法是: 读取xml文件,解析标签(包括默认标签:  bean, import, aralirs,beans,  特殊标签: pointcut, aspectj,advice)将对象 转化为BeanDefinition, 存入map容器中,

	1.2--->prepareBeanFactory(beanFactory); 这个是beanFactory的前期准备, 可以看到给beanFactory设置了各种属性

	1.3--->registerBeanPostProcessors(beanFactory); 这是beanFactory的后置处理器, 作用是注入一些处理器: 比如aop的 AspectJAwareAdvisorAutoProxyCreator(xml情况下) ,AnnotationAwareAspectJAutoProxyCreator (注解情况下) 这些处理器,可以生成目标类的代理对象,然后添加到容器中

	1.4--->finishBeanFactoryInitialization(beanFactory); 通过前面几步, bean对象已经被解析成BeanDefinition,存到容器中了, 这个方法作用是, 实例化所有剩余 非懒加载的bean--->这个方法中看到会先 对那些有实现各种aware接口的类进行回调自身进行赋值, 然后开始实例化-->先从beanFactory中获取到对应的beanDefinition--->之后三步走

		1.4.1:--->createBeanInstance(beanName, mbd, args); 创建bean实例

		1.4.2--->populateBean(beanName, mbd, instanceWrapper); 属性注入, 比如有autoware注解的属性注入

		1.4.3--->initializeBean(beanName, exposedObject, mbd);  实例化bean对象--->调用初始化方法

springboot原理:

导入父依赖 spring-boot-start-parent 点进去后可以看到有个父依赖 spring-boot-dependencies, 这个父依赖中可以看到各种依赖: 比如spring 消息中间件, mysql, elasticsearch, 日志 传递依赖,从而减少了我们自己使用原生spring框架搭建项目的时间

@SpringbootApplication注解点进去--->@EnableAutoConfiguration--->@Import(AutoConfigurationImportSelector)--->AutoConfigurationImportSelector--->可以看到是默认将 spring.factory配置文件中的各个配置类或者实体类,  读取到各种配置类后,自动装配