Spring启动流程refresh()源码深入解析

一、Spring容器的refresh()

spring  version:4.3.12  ，尚硅谷Spring注解驱动开发—源码部分

//refresh():543, AbstractApplicationContext (org.springframework.context.support) 
public void refresh() throws BeansException, IllegalStateException {
 synchronized (this.startupShutdownMonitor) {
  //1 刷新前的预处理
  prepareRefresh();
  //2 获取BeanFactory；刚创建的默认DefaultListableBeanFactory
  ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
  //3 BeanFactory的预准备工作（BeanFactory进行一些设置）
  prepareBeanFactory(beanFactory);
​
  try {
  // 4 BeanFactory准备工作完成后进行的后置处理工作；
   // 4.1）、抽象的方法，当前未做处理。子类通过重写这个方法来在BeanFactory创建并预准备完成以后做进一步的设置
  postProcessBeanFactory(beanFactory); 
 /**************************以上是BeanFactory的创建及预准备工作 ****************/
  
  // 5 执行BeanFactoryPostProcessor的方法；
//BeanFactoryPostProcessor：BeanFactory的后置处理器。在BeanFactory标准初始化之后执行的；
//他的重要两个接口：BeanFactoryPostProcessor、BeanDefinitionRegistryPostProcessor
  invokeBeanFactoryPostProcessors(beanFactory);
​
  //6 注册BeanPostProcessor（Bean的后置处理器）
  registerBeanPostProcessors(beanFactory);
​
  // 7 initMessageSource();初始化MessageSource组件（做国际化功能；消息绑定，消息解析）；
  initMessageSource();
​
  // 8 初始化事件派发器
  initApplicationEventMulticaster();
​
  // 9 子类重写这个方法，在容器刷新的时候可以自定义逻辑；
  onRefresh();
​
  // 10 给容器中将所有项目里面的ApplicationListener注册进来
 
  registerListeners();
 
​
  // 11.初始化所有剩下的单实例bean；
  finishBeanFactoryInitialization(beanFactory);
​
  // 12.完成BeanFactory的初始化创建工作；IOC容器就创建完成；
  finishRefresh();
  }
​
  catch (BeansException ex) {
  if (logger.isWarnEnabled()) {
   logger.warn("Exception encountered during context initialization - " +
    "cancelling refresh attempt: " + ex);
  }
​
  // Destroy already created singletons to avoid dangling resources.
  destroyBeans();
​
  // Reset 'active' flag.
  cancelRefresh(ex);
​
  // Propagate exception to caller.
  throw ex;
  }
​
  finally {
  // Reset common introspection caches in Spring's core, since we
  // might not ever need metadata for singleton beans anymore...
  resetCommonCaches();
  }
 }
 }

1 、prepareRefresh()刷新前的预处理;

//刷新前的预处理;
protected void prepareRefresh() {
 this.startupDate = System.currentTimeMillis();
 this.closed.set(false);
 this.active.set(true);
​
 if (logger.isInfoEnabled()) {
 logger.info("Refreshing " + this);
 }
 // 初始化一些属性设置;子类自定义个性化的属性设置方法；
 initPropertySources(); 
 // 校验配置文件的属性，合法性
 getEnvironment().validateRequiredProperties();
 //保存容器中的一些事件
 this.earlyApplicationEvents = new LinkedHashSet();
}

2、 obtainFreshBeanFactory();创建了一个BeanFactory

protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
 refreshBeanFactory(); //创建了一个this.beanFactory = new DefaultListableBeanFactory();设置了序列化的ID
 //返回刚才创建的DefaultListableBeanFactory
 ConfigurableListableBeanFactory beanFactory = getBeanFactory();
 if (logger.isDebugEnabled()) {
 logger.debug("Bean factory for " + getDisplayName() + ": " + beanFactory);
 }
 return beanFactory;
}

3、 BeanFactory的预准备工作

protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {
 // 1）、设置BeanFactory的类加载器
 beanFactory.setBeanClassLoader(getClassLoader());
 // 1）、设置支持表达式解析器
 beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader()));
 beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, getEnvironment()));
​
 // 2）、添加部分BeanPostProcessor【ApplicationContextAwareProcessor】
 beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));
 // 3）、设置忽略的自动装配的接口EnvironmentAware、EmbeddedValueResolverAware、xxx；
 // 这些接口的实现类不能通过类型来自动注入
 beanFactory.ignoreDependencyInterface(EnvironmentAware.class);
 beanFactory.ignoreDependencyInterface(EmbeddedValueResolverAware.class);
 beanFactory.ignoreDependencyInterface(ResourceLoaderAware.class);
 beanFactory.ignoreDependencyInterface(ApplicationEventPublisherAware.class);
 beanFactory.ignoreDependencyInterface(MessageSourceAware.class);
 beanFactory.ignoreDependencyInterface(ApplicationContextAware.class);
​
 // 4）、注册可以解析的自动装配；我们能直接在任何组件中自动注入：
 //BeanFactory、ResourceLoader、ApplicationEventPublisher、ApplicationContext
 /* 其他组件中可以通过下面方式直接注册使用
 @autowired 
 BeanFactory beanFactory */
 beanFactory.registerResolvableDependency(BeanFactory.class, beanFactory);
 beanFactory.registerResolvableDependency(ResourceLoader.class, this);
 beanFactory.registerResolvableDependency(ApplicationEventPublisher.class, this);
 beanFactory.registerResolvableDependency(ApplicationContext.class, this);
​
 // 5）、添加BeanPostProcessor【ApplicationListenerDetector】后置处理器，在bean初始化前后的一些工作
 beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(this));
​
 // 6）、添加编译时的AspectJ；
 if (beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
 beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
 // Set a temporary ClassLoader for type matching.
 beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
 }
​
 // 7）、给BeanFactory中注册一些能用的组件；
 if (!beanFactory.containsLocalBean(ENVIRONMENT_BEAN_NAME)) {
 // 环境信息ConfigurableEnvironment
 beanFactory.registerSingleton(ENVIRONMENT_BEAN_NAME, getEnvironment());
 }
 //系统属性，systemProperties【Map】
 if (!beanFactory.containsLocalBean(SYSTEM_PROPERTIES_BEAN_NAME)) {
 beanFactory.registerSingleton(SYSTEM_PROPERTIES_BEAN_NAME, getEnvironment().getSystemProperties());
 }
 //系统环境变量systemEnvironment【Map】
 if (!beanFactory.containsLocalBean(SYSTEM_ENVIRONMENT_BEAN_NAME)) {
 beanFactory.registerSingleton(SYSTEM_ENVIRONMENT_BEAN_NAME, getEnvironment().getSystemEnvironment());
 }
}

5 执行BeanFactoryPostProcessor的后置处理器方法（BeanFactory）；

protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) {
 //执行BeanFactoryPostProcessor的方法
 PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, getBeanFactoryPostProcessors());
​
 // Detect a LoadTimeWeaver and prepare for weaving, if found in the meantime
 // (e.g. through an @Bean method registered by ConfigurationClassPostProcessor)
 if (beanFactory.getTempClassLoader() == null && beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
 beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
 beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
 }
}

5.1    执行invokeBeanFactoryPostProcessors

public static void invokeBeanFactoryPostProcessors(
 ConfigurableListableBeanFactory beanFactory, List beanFactoryPostProcessors) {
​
 // Invoke BeanDefinitionRegistryPostProcessors first, if any.
 Set processedBeans = new HashSet();
 // 判断beanFatory类型
 if (beanFactory instanceof BeanDefinitionRegistry) {
 BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;
 List regularPostProcessors = new LinkedList();
 List registryProcessors = new LinkedList();
 //得到所有的BeanFactoryPostProcessor 遍历
 for (BeanFactoryPostProcessor postProcessor : beanFactoryPostProcessors) {
  if (postProcessor instanceof BeanDefinitionRegistryPostProcessor) {
  BeanDefinitionRegistryPostProcessor registryProcessor =
   (BeanDefinitionRegistryPostProcessor) postProcessor;
  registryProcessor.postProcessBeanDefinitionRegistry(registry);
  registryProcessors.add(registryProcessor);
  }
  else {
  regularPostProcessors.add(postProcessor);
  }
 }
​
 // Do not initialize FactoryBeans here: We need to leave all regular beans
 // uninitialized to let the bean factory post-processors apply to them!
 // Separate between BeanDefinitionRegistryPostProcessors that implement
 // PriorityOrdered, Ordered, and the rest.
 List currentRegistryProcessors = new ArrayList();
​
 
 //从容器中获取所有的BeanDefinitionRegistryPostProcessor，
 String[] postProcessorNames =
  beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
 // 第一步，先执行实现了PriorityOrdered接口的BeanDefinitionRegistryPostProcessor
 for (String ppName : postProcessorNames) {
  if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
  currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
  processedBeans.add(ppName);
  }
 }
 //排序
 sortPostProcessors(currentRegistryProcessors, beanFactory);
 registryProcessors.addAll(currentRegistryProcessors);
 //执行BeanDefinitionRegistryPostProcessor的 postProcessor.postProcessBeanDefinitionRegistry(registry)
 invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
 currentRegistryProcessors.clear();
​
 // 在执行实现了Ordered顺序接口的BeanDefinitionRegistryPostProcessor；
 postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
 for (String ppName : postProcessorNames) {
  if (!processedBeans.contains(ppName) && beanFactory.isTypeMatch(ppName, Ordered.class)) {
  currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
  processedBeans.add(ppName);
  }
 }
 //排序
 sortPostProcessors(currentRegistryProcessors, beanFactory);
 registryProcessors.addAll(currentRegistryProcessors);
 //执行postProcessor.postProcessBeanDefinitionRegistry(registry)
 invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
 currentRegistryProcessors.clear();
​
 // 最后执行没有实现任何优先级或者是顺序接口的BeanDefinitionRegistryPostProcessors；
 boolean reiterate = true;
 while (reiterate) {
  reiterate = false;
  postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
  for (String ppName : postProcessorNames) {
  if (!processedBeans.contains(ppName)) {
   currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
   processedBeans.add(ppName);
   reiterate = true;
  }
  }
  sortPostProcessors(currentRegistryProcessors, beanFactory);
  registryProcessors.addAll(currentRegistryProcessors);
  invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
  currentRegistryProcessors.clear();
 }
​
 // 现在执行 BeanFactoryPostProcessor的postProcessBeanFactory()方法
 invokeBeanFactoryPostProcessors(registryProcessors, beanFactory);
 invokeBeanFactoryPostProcessors(regularPostProcessors, beanFactory);
 }
​
 else {
 // Invoke factory processors registered with the context instance.
 invokeBeanFactoryPostProcessors(beanFactoryPostProcessors, beanFactory);
 }
​
 //再执行BeanFactoryPostProcessor的方法
 //1）、获取所有的BeanFactoryPostProcessor 和执行BeanDefinitionRegistryPostProcessors的接口逻辑一样
 String[] postProcessorNames =
 beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false);
​
 
 List priorityOrderedPostProcessors = new ArrayList();
 List orderedPostProcessorNames = new ArrayList();
 List nonOrderedPostProcessorNames = new ArrayList();
 //把BeanFactoryPostProcessor 分类
 for (String ppName : postProcessorNames) {
 if (processedBeans.contains(ppName)) {
  // skip - already processed in first phase above
 }
 else if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
  priorityOrderedPostProcessors.add(beanFactory.getBean(ppName, BeanFactoryPostProcessor.class));
 }
 else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
  orderedPostProcessorNames.add(ppName);
 }
 else {
  nonOrderedPostProcessorNames.add(ppName);
 }
 }
​
 // 2）、看先执行实现了PriorityOrdered优先级接口的BeanFactoryPostProcessor、
 sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
 invokeBeanFactoryPostProcessors(priorityOrderedPostProcessors, beanFactory);
​
 // 3）、在执行实现了Ordered顺序接口的BeanFactoryPostProcessor；
 List orderedPostProcessors = new ArrayList();
 for (String postProcessorName : orderedPostProcessorNames) {
 orderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
 }
 sortPostProcessors(orderedPostProcessors, beanFactory);
 invokeBeanFactoryPostProcessors(orderedPostProcessors, beanFactory);
​
 // 4）、最后执行没有实现任何优先级或者是顺序接口的BeanFactoryPostProcessor；
 List nonOrderedPostProcessors = new ArrayList();
 for (String postProcessorName : nonOrderedPostProcessorNames) {
 nonOrderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
 }
 invokeBeanFactoryPostProcessors(nonOrderedPostProcessors, beanFactory);
 beanFactory.clearMetadataCache();
}

6、注册BeanPostProcessor（Bean的后置处理器）

bean的创建拦截器

不同接口类型的BeanPostProcessor；在Bean创建前后的执行时机是不一样的

  • BeanPostProcessor、
  • DestructionAwareBeanPostProcessor、
  • InstantiationAwareBeanPostProcessor、   在createBean()方法中处理的，bean创建之前调用的
  • SmartInstantiationAwareBeanPostProcessor、
  • MergedBeanDefinitionPostProcessor【internalPostProcessors】  （bean创建完成后调用，11章节中）
registerBeanPostProcessors(beanFactory);

​
public static void registerBeanPostProcessors(
 ConfigurableListableBeanFactory beanFactory, AbstractApplicationContext applicationContext) {
//1）、获取所有的 BeanPostProcessor;后置处理器都默认可以通过PriorityOrdered、Ordered接口来执行优先级
 String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanPostProcessor.class, true, false);
​
  //检查器，检查所有的BeanPostProcessor
 int beanProcessorTargetCount = beanFactory.getBeanPostProcessorCount() + 1 + postProcessorNames.length;
 beanFactory.addBeanPostProcessor(new BeanPostProcessorChecker(beanFactory, beanProcessorTargetCount));
​
 // Separate between BeanPostProcessors that implement PriorityOrdered,
 // Ordered, and the rest.
 List priorityOrderedPostProcessors = new ArrayList();
 List internalPostProcessors = new ArrayList();
 List orderedPostProcessorNames = new ArrayList();
 List nonOrderedPostProcessorNames = new ArrayList();
 for (String ppName : postProcessorNames) {
  if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
   BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
   priorityOrderedPostProcessors.add(pp);
   if (pp instanceof MergedBeanDefinitionPostProcessor) {
    internalPostProcessors.add(pp);
   }
  }
  else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
   orderedPostProcessorNames.add(ppName);
  }
  else {
   nonOrderedPostProcessorNames.add(ppName);
  }
 }
​
 /* 2）、先注册PriorityOrdered优先级接口的BeanPostProcessor；
   把每一个BeanPostProcessor；添加到BeanFactory中
   beanFactory.addBeanPostProcessor(postProcessor);*/
 sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
 registerBeanPostProcessors(beanFactory, priorityOrderedPostProcessors);
​
 // 3）、再注册Ordered接口的
 List orderedPostProcessors = new ArrayList();
 for (String ppName : orderedPostProcessorNames) {
  BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
  orderedPostProcessors.add(pp);
  if (pp instanceof MergedBeanDefinitionPostProcessor) {
   internalPostProcessors.add(pp);
  }
 }
 sortPostProcessors(orderedPostProcessors, beanFactory);
 registerBeanPostProcessors(beanFactory, orderedPostProcessors);
​
 // 4）、最后注册没有实现任何优先级接口的
 List nonOrderedPostProcessors = new ArrayList();
 for (String ppName : nonOrderedPostProcessorNames) {
  BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
  nonOrderedPostProcessors.add(pp);
  if (pp instanceof MergedBeanDefinitionPostProcessor) {
   internalPostProcessors.add(pp);
  }
 }
 registerBeanPostProcessors(beanFactory, nonOrderedPostProcessors);
​
 // 5）、最终注册MergedBeanDefinitionPostProcessor；
 sortPostProcessors(internalPostProcessors, beanFactory);
 registerBeanPostProcessors(beanFactory, internalPostProcessors);
​
 // 6）、注册一个ApplicationListenerDetector；判断创建完成的bean是否监听器
 /* 在Bean创建完成后ApplicationListenerDetector.postProcessAfterInitialization()中检查是否是ApplicationListener 类型，如果是applicationContext.addApplicationListener((ApplicationListener) bean);如果是添加到容器中 */
 beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(applicationContext));
}

7、initMessageSource();国际化

初始化MessageSource组件（做国际化功能；消息绑定，消息解析）；

​
protected void initMessageSource() {
 // 1）、获取BeanFactory
 ConfigurableListableBeanFactory beanFactory = getBeanFactory();
 /* 
 2）、看容器中是否有id为messageSource的，类型是MessageSource的组件
   如果有赋值给messageSource，如果没有自己创建一个DelegatingMessageSource；
   MessageSource作用：取出国际化配置文件中的某个key的值；能按照区域信息获取；
 */
 if (beanFactory.containsLocalBean(MESSAGE_SOURCE_BEAN_NAME)) {
  this.messageSource = beanFactory.getBean(MESSAGE_SOURCE_BEAN_NAME, MessageSource.class);
  // Make MessageSource aware of parent MessageSource.
  if (this.parent != null && this.messageSource instanceof HierarchicalMessageSource) {
   HierarchicalMessageSource hms = (HierarchicalMessageSource) this.messageSource;
   if (hms.getParentMessageSource() == null) {
    // Only set parent context as parent MessageSource if no parent MessageSource
    // registered already.
    hms.setParentMessageSource(getInternalParentMessageSource());
   }
  }
  if (logger.isDebugEnabled()) {
   logger.debug("Using MessageSource [" + this.messageSource + "]");
  }
 }
 else {
  // 如果没有自己创建一个DelegatingMessageSource；
  DelegatingMessageSource dms = new DelegatingMessageSource();
  dms.setParentMessageSource(getInternalParentMessageSource());
  this.messageSource = dms;
  //把创建好的messageSource注册到容器中，以后获取国际化配置文件的值的时候，可以自动注入MessageSource； 
  //注入后通过这个方法使用MessageSource.getMessage(String code, Object[] args, String defaultMessage, Locale locale);
  beanFactory.registerSingleton(MESSAGE_SOURCE_BEAN_NAME, this.messageSource);
  if (logger.isDebugEnabled()) {
   logger.debug("Unable to locate MessageSource with name '" + MESSAGE_SOURCE_BEAN_NAME +
       "': using default [" + this.messageSource + "]");
  }
 }
}

8、初始化事件派发器initApplicationEventMulticaster()

​
protected void initApplicationEventMulticaster() {
 //1）、获取BeanFactory
 ConfigurableListableBeanFactory beanFactory = getBeanFactory();
 //判断容器中是否有applicationEventMulticaster 的这个bean ,如果有获取，没有创建
 if (beanFactory.containsLocalBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME)) {
  //2）、从BeanFactory中获取applicationEventMulticaster的ApplicationEventMulticaster；
  this.applicationEventMulticaster =
   beanFactory.getBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, ApplicationEventMulticaster.class);
  if (logger.isDebugEnabled()) {
   logger.debug("Using ApplicationEventMulticaster [" + this.applicationEventMulticaster + "]");
  }
 }
 else {
  //3) 个SimpleApplicationEventMulticaster 类型的 applicationEventMulticaster
  this.applicationEventMulticaster = new SimpleApplicationEventMulticaster(beanFactory);
  //4）、将创建的ApplicationEventMulticaster添加到BeanFactory中，以后其他组件直接自动注入
  beanFactory.registerSingleton(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, this.applicationEventMulticaster);
  if (logger.isDebugEnabled()) {
   logger.debug("Unable to locate ApplicationEventMulticaster with name '" +
       APPLICATION_EVENT_MULTICASTER_BEAN_NAME +
       "': using default [" + this.applicationEventMulticaster + "]");
  }
 }
}

9、onRefresh();留给子容器（子类）

 1、子类重写AbstractApplicationContext.onRefresh()这个方法，在容器刷新的时候可以自定义逻辑；

10、registerListeners();检查和注册 Listener

将所有项目里面的ApplicationListener注册到容器中；

​
protected void registerListeners() {
 //1、从容器中拿到所有的ApplicationListener
 for (ApplicationListener listener : getApplicationListeners()) {
  //2、将每个监听器添加到事件派发器中；
  getApplicationEventMulticaster().addApplicationListener(listener);
 }
​
  
 // 1.获取所有的ApplicationListener
 String[] listenerBeanNames = getBeanNamesForType(ApplicationListener.class, true, false);
 for (String listenerBeanName : listenerBeanNames) {
  //2、将每个监听器添加到事件派发器中；
  getApplicationEventMulticaster().addApplicationListenerBean(listenerBeanName);
 }
​
 // earlyApplicationEvents 中保存之前的事件，
 Set earlyEventsToProcess = this.earlyApplicationEvents;
 this.earlyApplicationEvents = null;
 if (earlyEventsToProcess != null) {
  for (ApplicationEvent earlyEvent : earlyEventsToProcess) {
   //3、派发之前步骤产生的事件；
   getApplicationEventMulticaster().multicastEvent(earlyEvent);
  }
 }
}

11、初始化所有剩下的单实例bean；finishBeanFactoryInitialization(beanFactory);

protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
 // 类型装换器
 if (beanFactory.containsBean(CONVERSION_SERVICE_BEAN_NAME) &&
  beanFactory.isTypeMatch(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class)) {
  beanFactory.setConversionService(
   beanFactory.getBean(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class));
 }
​
 //值解析器
 if (!beanFactory.hasEmbeddedValueResolver()) {
  beanFactory.addEmbeddedValueResolver(new StringValueResolver() {
   @Override
   public String resolveStringValue(String strVal) {
    return getEnvironment().resolvePlaceholders(strVal);
   }
  });
 }
​
 // Initialize LoadTimeWeaverAware beans early to allow for registering their transformers early.
 String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);
 for (String weaverAwareName : weaverAwareNames) {
  getBean(weaverAwareName);
 }
​
 // Stop using the temporary ClassLoader for type matching.
 beanFactory.setTempClassLoader(null);
​
 // Allow for caching all bean definition metadata, not expecting further changes.
 beanFactory.freezeConfiguration();
​
 // 初始化剩下的单实例bean
 beanFactory.preInstantiateSingletons();
}

11.1 beanFactory.preInstantiateSingletons()初始化剩下的单实例bean

//preInstantiateSingletons():781, DefaultListableBeanFactory 
public void preInstantiateSingletons() throws BeansException {
 if (this.logger.isDebugEnabled()) {
  this.logger.debug("Pre-instantiating singletons in " + this);
 }
  //1）、获取容器中的所有Bean，依次进行初始化和创建对象 
 List beanNames = new ArrayList(this.beanDefinitionNames);
 for (String beanName : beanNames) {
  //2）、获取Bean的定义信息；RootBeanDefinition
  RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
  //3）、Bean不是抽象的，是单实例的，不是懒加载；
  if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
   // 3.1）、判断是否是FactoryBean；是否是实现FactoryBean接口的Bean；
   if (isFactoryBean(beanName)) {
    final FactoryBean factory = (FactoryBean) getBean(FACTORY_BEAN_PREFIX + beanName);
    boolean isEagerInit;
    if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
     isEagerInit = AccessController.doPrivileged(new PrivilegedAction() {
      @Override
      public Boolean run() {
       return ((SmartFactoryBean) factory).isEagerInit();
      }
     }, getAccessControlContext());
    }
    else {
     isEagerInit = (factory instanceof SmartFactoryBean &&
         ((SmartFactoryBean) factory).isEagerInit());
    }
    if (isEagerInit) {
     getBean(beanName);
    }
   }
   else { //3.2）、不是工厂Bean。利用getBean(beanName);创建对象
    getBean(beanName); //详情请见 （11.1.3.2 创建bean ->doGetBean）章节
   }
  }
 }
​
 // 循环所有的bean 
 for (String beanName : beanNames) {
  Object singletonInstance = getSingleton(beanName);
  //判断bean是否实现了SmartInitializingSingleton 接口如果是；就执行afterSingletonsInstantiated()；
  if (singletonInstance instanceof SmartInitializingSingleton) {
   final SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;
   if (System.getSecurityManager() != null) {
    AccessController.doPrivileged(new PrivilegedAction() {
     @Override
     public Object run() {
      
      smartSingleton.afterSingletonsInstantiated();
      return null;
     }
    }, getAccessControlContext());
   }
   else {
    //执行实现类的afterSingletonsInstantiated()；
    smartSingleton.afterSingletonsInstantiated();
   }
  }
 }
}
 
  
 
11.1.3.2 创建bean  ->doGetBean
 
 
AbstractBeanFactory.doGetBean()方法
 
 
5）、将创建的Bean添加到缓存中singletonObjects；ioc容器就是这些Map；很多的Map里面保存了单实例Bean，环境信息。。。。；
 
 
 
  
protected  T doGetBean(
 final String name, final Class requiredType, final Object[] args, boolean typeCheckOnly)
 throws BeansException {
​
 final String beanName = transformedBeanName(name);
 Object bean;
​
/**
2、先获取缓存中保存的单实例Bean。如果能获取到说明这个Bean之前被创建过（所有创建过的单实例Bean都会被缓存起来）
从private final Map singletonObjects = new ConcurrentHashMap(256);获取的
 **/
 Object sharedInstance = getSingleton(beanName);
 //如果没有获取到创建bean 
 if (sharedInstance != null && args == null) {
  if (logger.isDebugEnabled()) {
   if (isSingletonCurrentlyInCreation(beanName)) {
    logger.debug("Returning eagerly cached instance of singleton bean '" + beanName +
        "' that is not fully initialized yet - a consequence of a circular reference");
   }
   else {
    logger.debug("Returning cached instance of singleton bean '" + beanName + "'");
   }
  }
  bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
 }
​
 else {//3、缓存中获取不到，开始Bean的创建对象流程；
  // Fail if we're already creating this bean instance:
  // We're assumably within a circular reference.
  if (isPrototypeCurrentlyInCreation(beanName)) {
   throw new BeanCurrentlyInCreationException(beanName);
  }
​
  // 获取父beanFatory 检查这个bean是否创建了
  BeanFactory parentBeanFactory = getParentBeanFactory();
  if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
   // Not found -> check parent.
   String nameToLookup = originalBeanName(name);
   if (args != null) {
    return (T) parentBeanFactory.getBean(nameToLookup, args);
   }
   else { 
    return parentBeanFactory.getBean(nameToLookup, requiredType);
   }
  }
​
  // 4、标记当前bean已经被创建
  if (!typeCheckOnly) {
   markBeanAsCreated(beanName);
  }
​
  try {
   // 5、获取Bean的定义信息；
   final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
   checkMergedBeanDefinition(mbd, beanName, args);
​
   // 6、【获取当前Bean依赖的其他Bean;如果有按照getBean()把依赖的Bean先创建出来；】
   String[] dependsOn = mbd.getDependsOn();
   if (dependsOn != null) {
    for (String dep : dependsOn) {
     if (isDependent(beanName, dep)) {
      throw new BeanCreationException(mbd.getResourceDescription(), beanName,
              "Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
     }
     registerDependentBean(dep, beanName);
     getBean(dep); //先创建依赖的bean
    }
   }
​
   // 启动单实例的bean的创建流程
   if (mbd.isSingleton()) {
    //获取到单实例bean后，添加到缓存中 singletonObjects（）
  //Map singletonObjects = new ConcurrentHashMap(256);
    sharedInstance = getSingleton(beanName, new ObjectFactory() {
     @Override
     public Object getObject() throws BeansException {
      try {
       //创建Bean ,见11.1.3.2.6.1
       return createBean(beanName, mbd, args);
      }
      catch (BeansException ex) {
       destroySingleton(beanName);
       throw ex;
      }
     }
    });
    bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
   }
// 下面部分不重要了
   else if (mbd.isPrototype()) {
    // It's a prototype -> create a new instance.
    Object prototypeInstance = null;
    try {
     beforePrototypeCreation(beanName);
     prototypeInstance = createBean(beanName, mbd, args);
    }
    finally {
     afterPrototypeCreation(beanName);
    }
    bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
   }
​
   else {
    String scopeName = mbd.getScope();
    final 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, new ObjectFactory() {
      @Override
      public Object getObject() throws BeansException {
       beforePrototypeCreation(beanName);
       try {
        return createBean(beanName, mbd, args);
       }
       finally {
        afterPrototypeCreation(beanName);
       }
      }
     });
     bean = getObjectForBeanInstance(scopedInstance, name, beanName, mbd);
    }
    catch (IllegalStateException ex) {
     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",
             ex);
    }
   }
  }
  catch (BeansException ex) {
   cleanupAfterBeanCreationFailure(beanName);
   throw ex;
  }
 }
​
 // Check if required type matches the type of the actual bean instance.
 if (requiredType != null && bean != null && !requiredType.isInstance(bean)) {
  try {
   return getTypeConverter().convertIfNecessary(bean, requiredType);
  }
  catch (TypeMismatchException ex) {
   if (logger.isDebugEnabled()) {
    logger.debug("Failed to convert bean '" + name + "' to required type '" +
        ClassUtils.getQualifiedName(requiredType) + "'", ex);
   }
   throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
  }
 }
 return (T) bean;
}
 
  
 
11.1.3.2.6.1 创建单实例bean
 
 
AbstractAutowireCapableBeanFactory.createBean() 这个类中
 
 
 
  
​
protected Object createBean(String beanName, RootBeanDefinition mbd, Object[] args) throws BeanCreationException {
 if (logger.isDebugEnabled()) {
  logger.debug("Creating instance of bean '" + beanName + "'");
 }
 RootBeanDefinition mbdToUse = mbd; //bean定义信息
​
 // 解析bean的类型
 Class resolvedClass = resolveBeanClass(mbd, beanName);
 if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
  mbdToUse = new RootBeanDefinition(mbd);
  mbdToUse.setBeanClass(resolvedClass);
 }
​
 // Prepare method overrides.
 try {
  mbdToUse.prepareMethodOverrides();
 }
 catch (BeanDefinitionValidationException ex) {
  throw new BeanDefinitionStoreException(mbdToUse.getResourceDescription(),
            beanName, "Validation of method overrides failed", ex);
 }
​
 try {
  //让BeanPostProcessor先拦截返回代理对象；
  /** 判断是否为：InstantiationAwareBeanPostProcessor 的，如果是执行前后置方法
  【InstantiationAwareBeanPostProcessor】：提前执行；
  先触发：postProcessBeforeInstantiation()；
  如果有返回值：再触发postProcessAfterInitialization()；
  **/
  Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
  if (bean != null) { //如果 有对象返回
   return bean;
  }
 }
 catch (Throwable ex) {
  throw new BeanCreationException(mbdToUse.getResourceDescription(), beanName,
          "BeanPostProcessor before instantiation of bean failed", ex);
 }
 // 没有对象 创建一个bean
 Object beanInstance = doCreateBean(beanName, mbdToUse, args);
 if (logger.isDebugEnabled()) {
  logger.debug("Finished creating instance of bean '" + beanName + "'");
 }
 //返回创建的bean 
 return beanInstance;
}


 
 
 
 
1、doCreateBean()创建一个bean
 
 
   后置处理器：MergedBeanDefinitionPostProcessor ，bean实例化之后调用
 
 
 
  
//doCreateBean():508, AbstractAutowireCapableBeanFactory 类中
protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final Object[] args)
 throws BeanCreationException {
​
 // bean的包装
 BeanWrapper instanceWrapper = null;
 if (mbd.isSingleton()) {
  instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
 }
 if (instanceWrapper == null) {
  // 1）、【创建Bean实例】利用工厂方法或者对象的构造器创建出Bean实例；
  instanceWrapper = createBeanInstance(beanName, mbd, args);
 }
 final Object bean = (instanceWrapper != null ? instanceWrapper.getWrappedInstance() : null);
 Class beanType = (instanceWrapper != null ? instanceWrapper.getWrappedClass() : null);
 mbd.resolvedTargetType = beanType;
​
 // Allow post-processors to modify the merged bean definition.
 synchronized (mbd.postProcessingLock) {
  if (!mbd.postProcessed) {
   try {
    //调用MergedBeanDefinitionPostProcessor的postProcessMergedBeanDefinition(mbd, beanType, beanName);
    //判断是否为：MergedBeanDefinitionPostProcessor 类型的，如果是，调用方法
    //MergedBeanDefinitionPostProcessor 后置处理器是在bean实例换之后调用的
    applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
   }
   catch (Throwable ex) {
    throw new BeanCreationException(mbd.getResourceDescription(), beanName,
            "Post-processing of merged bean definition failed", ex);
   }
   mbd.postProcessed = true;
  }
 }
​
 //判断bean 是否为单实例的，如果是单实例的添加到缓存中
 boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
          isSingletonCurrentlyInCreation(beanName));
 if (earlySingletonExposure) {
  if (logger.isDebugEnabled()) {
   logger.debug("Eagerly caching bean '" + beanName +
       "' to allow for resolving potential circular references");
  }
  //添加bean到缓存中
  addSingletonFactory(beanName, new ObjectFactory() {
   @Override
   public Object getObject() throws BeansException {
    return getEarlyBeanReference(beanName, mbd, bean);
   }
  });
 }
​
 // Initialize the bean instance.
 Object exposedObject = bean;
 try {
  //为bean 赋值,见1.1部分
  populateBean(beanName, mbd, instanceWrapper);
  if (exposedObject != null) {
   // 4）、【Bean初始化】
   exposedObject = initializeBean(beanName, exposedObject, mbd);
  }
 }
 catch (Throwable ex) {
  if (ex instanceof BeanCreationException && beanName.equals(((BeanCreationException) ex).getBeanName())) {
   throw (BeanCreationException) ex;
  }
  else {
   throw new BeanCreationException(
    mbd.getResourceDescription(), beanName, "Initialization of bean failed", ex);
  }
 }
​
 if (earlySingletonExposure) {
  //获取单实例bean,此时已经创建好了
  Object earlySingletonReference = getSingleton(beanName, false);
  if (earlySingletonReference != null) {
   if (exposedObject == bean) {
    exposedObject = earlySingletonReference;
   }
   else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {
    String[] dependentBeans = getDependentBeans(beanName);
    Set actualDependentBeans = new LinkedHashSet(dependentBeans.length);
    for (String dependentBean : dependentBeans) {
     if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) {
      actualDependentBeans.add(dependentBean);
     }
    }
    if (!actualDependentBeans.isEmpty()) {
     throw new BeanCurrentlyInCreationException(beanName,
                "Bean with name '" + beanName + "' has been injected into other beans [" +
                StringUtils.collectionToCommaDelimitedString(actualDependentBeans) +
                "] in its raw version as part of a circular reference, but has eventually been " +
                "wrapped. This means that said other beans do not use the final version of the " +
                "bean. This is often the result of over-eager type matching - consider using " +
                "'getBeanNamesOfType' with the 'allowEagerInit' flag turned off, for example.");
    }
   }
  }
 }
​
 // 5）、注册实现了DisposableBean 接口Bean的销毁方法；只是注册没有去执行，容器关闭之后才去调用的
 try {
  registerDisposableBeanIfNecessary(beanName, bean, mbd);
 }
 catch (BeanDefinitionValidationException ex) {
  throw new BeanCreationException(
   mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
 }
​
 return exposedObject;
}
 
  
 
1.1 populateBean()创建bean后属性赋值
 
 
 
  
//populateBean():1204, AbstractAutowireCapableBeanFactory 
protected void populateBean(String beanName, RootBeanDefinition mbd, BeanWrapper bw) {
 PropertyValues pvs = mbd.getPropertyValues();
​
 if (bw == null) {
  if (!pvs.isEmpty()) {
   throw new BeanCreationException(
    mbd.getResourceDescription(), beanName, "Cannot apply property values to null instance");
  }
  else {
   // Skip property population phase for null instance.
   return;
  }
 }
​
 // Give any InstantiationAwareBeanPostProcessors the opportunity to modify the
 // state of the bean before properties are set. This can be used, for example,
 // to support styles of field injection.
 boolean continueWithPropertyPopulation = true;
​
 //赋值之前：
 /* 1）、拿到InstantiationAwareBeanPostProcessor后置处理器；
  执行处理器的postProcessAfterInstantiation()； 方法*/
 if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
  for (BeanPostProcessor bp : getBeanPostProcessors()) {
   if (bp instanceof InstantiationAwareBeanPostProcessor) {
    InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
    //执行
    if (!ibp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {
     continueWithPropertyPopulation = false;
     break;
    }
   }
  }
 }
​
 if (!continueWithPropertyPopulation) {
  return;
 }
​
 if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_NAME ||
  mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_TYPE) {
  MutablePropertyValues newPvs = new MutablePropertyValues(pvs);
​
  // autowire 按name注入
  if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_NAME) {
   autowireByName(beanName, mbd, bw, newPvs);
  }
​
  // autowire 按类型注入
  if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_TYPE) {
   autowireByType(beanName, mbd, bw, newPvs);
  }
​
  pvs = newPvs;
 }
​
 boolean hasInstAwareBpps = hasInstantiationAwareBeanPostProcessors();
 boolean needsDepCheck = (mbd.getDependencyCheck() != RootBeanDefinition.DEPENDENCY_CHECK_NONE);
/*2）、拿到InstantiationAwareBeanPostProcessor后置处理器；
 执行 postProcessPropertyValues()； 获取到属性的值，此时还未赋值*/
 if (hasInstAwareBpps || needsDepCheck) {
  PropertyDescriptor[] filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
  if (hasInstAwareBpps) {
   for (BeanPostProcessor bp : getBeanPostProcessors()) {
    if (bp instanceof InstantiationAwareBeanPostProcessor) {
     InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
     pvs = ibp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName);
     if (pvs == null) {
      return;
     }
    }
   }
  }
  if (needsDepCheck) {
   checkDependencies(beanName, mbd, filteredPds, pvs);
  }
 }
//=====赋值之前：=== 
//3）、应用Bean属性的值；为属性利用setter方法等进行赋值；
 applyPropertyValues(beanName, mbd, bw, pvs);
}

 
 
 
 
1.2 、Bean初始化 initializeBean
 
 
initializeBean():1605, AbstractAutowireCapableBeanFactory 
 
 
 
  
//初始化
protected Object initializeBean(final String beanName, final Object bean, RootBeanDefinition mbd) {
 if (System.getSecurityManager() != null) {
  AccessController.doPrivileged(new PrivilegedAction() {
   @Override
   public Object run() {
    invokeAwareMethods(beanName, bean);
    return null;
   }
  }, getAccessControlContext());
 }
 else {
  //1）、【执行Aware接口方法】invokeAwareMethods(beanName, bean);执行xxxAware接口的方法
  //判断是否实现了 BeanNameAware\BeanClassLoaderAware\BeanFactoryAware 这些接口的bean，如果是执行相应的方法
  invokeAwareMethods(beanName, bean);
 }
​
 Object wrappedBean = bean;
 if (mbd == null || !mbd.isSynthetic()) {
  //2）、【执行后置处理器BeanPostProcessor初始化之前】 执行所有的 BeanPostProcessor.postProcessBeforeInitialization（）;
  wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
 }
​
 try {
  //3）、【执行初始化方法】
  invokeInitMethods(beanName, wrappedBean, mbd);
 }
 catch (Throwable ex) {
  throw new BeanCreationException(
   (mbd != null ? mbd.getResourceDescription() : null),
   beanName, "Invocation of init method failed", ex);
 }
 //4）、【执行后置处理器初始化之后】 执行所有的beanProcessor.postProcessAfterInitialization(result, beanName);方法
 if (mbd == null || !mbd.isSynthetic()) {
  wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
 }
 return wrappedBean;
}
 
  
 
1.2.1  执行bean的初始化方法init
 
 
1）、是否是InitializingBean接口的实现；执行接口规定的初始化；
 
 
2）、是否自定义初始化方法；通过注解的方式添加了initMethod方法的，
 
 
​    例如： @Bean(initMethod="init",destroyMethod="detory")
 
 
 
  
//invokeInitMethods():1667, AbstractAutowireCapableBeanFactory 
protected void invokeInitMethods(String beanName, final Object bean, RootBeanDefinition mbd)
 throws Throwable {
//1）、是否是InitializingBean接口的实现；执行接口规定的初始化 ,执行afterPropertiesSet()这个方法；
 boolean isInitializingBean = (bean instanceof InitializingBean);
 if (isInitializingBean && (mbd == null || !mbd.isExternallyManagedInitMethod("afterPropertiesSet"))) {
  if (logger.isDebugEnabled()) {
   logger.debug("Invoking afterPropertiesSet() on bean with name '" + beanName + "'");
  }
  if (System.getSecurityManager() != null) {
   try {
    AccessController.doPrivileged(new PrivilegedExceptionAction() {
     @Override
     public Object run() throws Exception {
      ((InitializingBean) bean).afterPropertiesSet();
      return null;
     }
    }, getAccessControlContext());
   }
   catch (PrivilegedActionException pae) {
    throw pae.getException();
   }
  }
  else {
   //执行实现InitializingBean的afterPropertiesSet方法
   ((InitializingBean) bean).afterPropertiesSet();
  }
 }
​
 if (mbd != null) {
  //执行通过注解自定义的initMethod 方法
  String initMethodName = mbd.getInitMethodName();
  if (initMethodName != null && !(isInitializingBean && "afterPropertiesSet".equals(initMethodName)) &&
   !mbd.isExternallyManagedInitMethod(initMethodName)) {
   invokeCustomInitMethod(beanName, bean, mbd);
  }
 }
}
 
  
 
12、完成BeanFactory的初始化创建工作；IOC容器就创建完成；刷新
 
 
 
  
protected void finishRefresh() {
 //1. 初始化生命周期有关的后置处理器，BeanFactory创建完成后刷新相关的工作
 //默认从容器中找是否有lifecycleProcessor的组件【LifecycleProcessor】；如果没有new DefaultLifecycleProcessor();加入到容器；
 initLifecycleProcessor();
  
 //2. 拿到前面定义的生命周期处理器（LifecycleProcessor）；回调onRefresh()；
 getLifecycleProcessor().onRefresh();
​
 //3. 发布容器刷新完成事件；
 publishEvent(new ContextRefreshedEvent(this));
​
 //4.暴露
 LiveBeansView.registerApplicationContext(this);
}

 
 
 
 
二、Spring 启动流程的总结
 
 
1）、Spring容器在启动的时候，先会保存所有注册进来的Bean的定义信息；
 
 
   1）、xml注册bean；
 
 
   2）、注解注册Bean；@Service、@Component、@Bean、xxx
 
 
2）、Spring容器会合适的时机创建这些Bean
 
 
   1）、用到这个bean的时候；利用getBean创建bean；创建好以后保存在容器中；
 
 
   2）、统一创建剩下所有的bean的时候；finishBeanFactoryInitialization()；
 
 
3）、后置处理器；BeanPostProcessor
 
 
   1）、每一个bean创建完成，都会使用各种后置处理器进行处理；来增强bean的功能；
 
 
      AutowiredAnnotationBeanPostProcessor:处理自动注入
 
 
      AnnotationAwareAspectJAutoProxyCreator:来做AOP功能；
 
 
      xxx....
 
 
      增强的功能注解：
 
 
      AsyncAnnotationBeanPostProcessor
 
 
      ....
 
 
4）、事件驱动模型；
 
 
   ApplicationListener；事件监听；
 
 
   ApplicationEventMulticaster；事件派发：
 
 
总结
 
 
到此这篇关于Spring启动流程refresh()源码深入解析的文章就介绍到这了,更多相关Spring 启动流程refresh()源码内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！
 
 
 
   
 
 

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(Spring启动流程refresh()源码深入解析)

        

            

                
    
                    
  • 店群合一模式下的社区团购新发展——结合链动 2+1 模式、AI 智能名片与 S2B2C 商城小程序源码
                        说私域
人工智能小程序
                        
    摘要：本文探讨了店群合一的社区团购平台在当今商业环境中的重要性和优势。通过分析店群合一模式如何将互联网社群与线下终端紧密结合，阐述了链动2+1模式、AI智能名片和S2B2C商城小程序源码在这一模式中的应用价值。这些创新元素的结合为社区团购带来了新的机遇，提升了用户信任感、拓展了营销渠道，并实现了线上线下的完美融合。一、引言随着互联网技术的不断发展，社区团购作为一种新兴的商业模式，在满足消费者日常需
    
                    
    • 
                    
  • 四章-32-点要素的聚合
                        彩云飘过

                        
    本文基于腾讯课堂老胡的课《跟我学Openlayers--基础实例详解》做的学习笔记，使用的openlayers5.3.xapi。源码见1032.html，对应的官网示例https://openlayers.org/en/latest/examples/cluster.htmlhttps://openlayers.org/en/latest/examples/earthquake-clusters.
    
                    
    • 
                    
  • DIV+CSS+JavaScript技术制作网页（旅游主题网页设计与制作）云南大理
                        STU学生网页设计
网页设计期末网页作业html静态网页html5期末大作业网页设计web大作业
                        
    ️精彩专栏推荐作者主页:【进入主页—获取更多源码】web前端期末大作业：【HTML5网页期末作业(1000套)】程序员有趣的告白方式：【HTML七夕情人节表白网页制作(110套)】文章目录二、网站介绍三、网站效果▶️1.视频演示2.图片演示四、网站代码HTML结构代码CSS样式代码五、更多源码二、网站介绍网站布局方面：计划采用目前主流的、能兼容各大主流浏览器、显示效果稳定的浮动网页布局结构。网站程
    
                    
    • 
                    
  • 关于城市旅游的HTML网页设计——(旅游风景云南 5页)HTML+CSS+JavaScript
                        二挡起步
web前端期末大作业javascripthtmlcss旅游风景
                        
    ⛵源码获取文末联系✈Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业|游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作|HTML期末大学生网页设计作业，Web大学生网页HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScrip
    
                    
    • 
                    
  • libyuv之linux编译
                        jaronho
Linuxlinux运维服务器
                        
    文章目录一、下载源码二、编译源码三、注意事项1、银河麒麟系统（aarch64）（1）解决armv8-a+dotprod+i8mm指令集支持问题（2）解决armv9-a+sve2指令集支持问题一、下载源码到GitHub网站下载https://github.com/lemenkov/libyuv源码，或者用直接用git克隆到本地，如：gitclonehttps://github.com/lemenko
    
                    
    • 
                    
  • SpringBlade dict-biz/list 接口 SQL 注入漏洞
                        文章永久免费只为良心
oracle数据库
                        
    SpringBladedict-biz/list接口SQL注入漏洞POC:构造请求包查看返回包你的网址/api/blade-system/dict-biz/list?updatexml(1,concat(0x7e,md5(1),0x7e),1)=1漏洞概述在SpringBlade框架中，如果dict-biz/list接口的后台处理逻辑没有正确地对用户输入进行过滤或参数化查询（PreparedSta
    
                    
    • 
                    
  • spring如何整合druid连接池？
                        惜.己
springspringjunit数据库javaidea后端xml
                        
    目录spring整合druid连接池1.新建maven项目2.新建mavenModule3.导入相关依赖4.配置log4j2.xml5.配置druid.xml1)xml中如何引入properties2)下面是配置文件6.准备jdbc.propertiesJDBC配置项解释7.配置druid8.测试spring整合druid连接池1.新建maven项目打开IDE（比如IntelliJIDEA,Ecl
    
                    
    • 
                    
  • ArrayList 源码解析
                        程序猿进阶
Java基础ArrayListListjava面试性能优化架构设计idea
                        
    ArrayList是Java集合框架中的一个动态数组实现，提供了可变大小的数组功能。它继承自AbstractList并实现了List接口，是顺序容器，即元素存放的数据与放进去的顺序相同，允许放入null元素，底层通过数组实现。除该类未实现同步外，其余跟Vector大致相同。每个ArrayList都有一个容量capacity，表示底层数组的实际大小，容器内存储元素的个数不能多于当前容量。当向容器中添
    
                    
    • 
                    
  • Python神器！WEB自动化测试集成工具 DrissionPage
                        亚丁号
python开发语言
                        
    一、前言用requests做数据采集面对要登录的网站时，要分析数据包、JS源码，构造复杂的请求，往往还要应付验证码、JS混淆、签名参数等反爬手段，门槛较高。若数据是由JS计算生成的，还须重现计算过程，体验不好，开发效率不高。使用浏览器，可以很大程度上绕过这些坑，但浏览器运行效率不高。因此，这个库设计初衷，是将它们合而为一，能够在不同须要时切换相应模式，并提供一种人性化的使用方法，提高开发和运行效率
    
                    
    • 
                    
  • SpringCloudAlibaba—Sentinel(限流)
                        菜鸟爪哇

                        
    前言：自己在学习过程的记录，借鉴别人文章，记录自己实现的步骤。借鉴文章：https://blog.csdn.net/u014494148/article/details/105484410Sentinel介绍Sentinel诞生于阿里巴巴，其主要目标是流量控制和服务熔断。Sentinel是通过限制并发线程的数量（即信号隔离）来减少不稳定资源的影响，而不是使用线程池，省去了线程切换的性能开销。当资源
    
                    
    • 
                    
  • springboot+vue项目实战一-创建SpringBoot简单项目
                        苹果酱0567
面试题汇总与解析springboot后端java中间件开发语言
                        
    这段时间抽空给女朋友搭建一个个人博客，想着记录一下建站的过程，就当做笔记吧。虽然复制zjblog只要一个小时就可以搞定一个网站，或者用cms系统，三四个小时就可以做出一个前后台都有的网站，而且想做成啥样也都行。但是就是要从新做，自己做的意义不一样，更何况，俺就是专门干这个的，嘿嘿嘿要做一个网站，而且从零开始，首先呢就是技术选型了，经过一番思量决定选择-SpringBoot做后端，前端使用Vue做一
    
                    
    • 
                    
  • 笋丁网页自动回复机器人V3.0.0免授权版源码
                        希希分享
软希网58soho_cn源码资源笋丁网页自动回复机器人
                        
    笋丁网页机器人一款可设置自动回复，默认消息，调用自定义api接口的网页机器人。此程序后端语言使用Golang，内存占用最高不超过30MB，1H1G服务器流畅运行。仅支持Linux服务器部署，不支持虚拟主机，请悉知！使用自定义api功能需要有一定的建站基础。源码下载：https://download.csdn.net/download/m0_66047725/89754250更多资源下载：关注我。安
    
                    
    • 
                    
  • Spring MVC 全面指南：从入门到精通的详细解析
                        一杯梅子酱
技术栈学习springmvcjava
                        
    引言：SpringMVC，作为Spring框架的一个重要模块，为构建Web应用提供了强大的功能和灵活性。无论是初学者还是有一定经验的开发者，掌握SpringMVC都将显著提升你的Web开发技能。本文旨在为初学者提供一个全面且易于理解的学习路径，通过详细的知识点分析和实际案例，帮助你快速上手SpringMVC，让学习过程既深刻又高效。一、SpringMVC简介1.1什么是SpringMVC？Spri
    
                    
    • 
                    
  • ESP32-C3入门教程 网络篇⑩——基于esp_https_ota和MQTT实现开机主动升级和被动触发升级的OTA功能
                        小康师兄
ESP32-C3入门教程https服务器esp32OTAMQTT
                        
    文章目录一、前言二、软件流程三、部分源码四、运行演示一、前言本文基于VSCodeIDE进行编程、编译、下载、运行等操作基础入门章节请查阅：ESP32-C3入门教程基础篇①——基于VSCode构建HelloWorld教程目录大纲请查阅：ESP32-C3入门教程——导读ESP32-C3入门教程网络篇⑨——基于esp_https_ota实现史上最简单的ESP32OTA远程固件升级功能二、软件流程
    
                    
    • 
                    
  • Spring Boot中实现跨域请求
                        BABA8891
springboot后端java
                        
    在SpringBoot中实现跨域请求（CORS，Cross-OriginResourceSharing）可以通过多种方式，以下是几种常见的方法：1.使用@CrossOrigin注解在SpringBoot中，你可以在控制器或者具体的请求处理方法上使用@CrossOrigin注解来允许跨域请求。在控制器上应用：importorg.springframework.web.bind.annotation.
    
                    
    • 
                    
  • 博客网站制作教程
                        2401_85194651
javamaven
                        
    首先就是技术框架：后端：Java+SpringBoot数据库：MySQL前端：Vue.js数据库连接：JPA(JavaPersistenceAPI)1.项目结构blog-app/├──backend/│├──src/main/java/com/example/blogapp/││├──BlogApplication.java││├──config/│││└──DatabaseConfig.java
    
                    
    • 
                    
  • 【Python搞定车载自动化测试】——Python实现车载以太网DoIP刷写（含Python源码）
                        疯狂的机器人
Python搞定车载自动化pythonDoIPUDSISO142291SO13400Bootloadertcp/ip
                        
    系列文章目录【Python搞定车载自动化测试】系列文章目录汇总文章目录系列文章目录前言一、环境搭建1.软件环境2.硬件环境二、目录结构三、源码展示1.DoIP诊断基础函数方法2.DoIP诊断业务函数方法3.27服务安全解锁4.DoIP自动化刷写四、测试日志1.测试日志五、完整源码链接前言随着智能电动汽车行业的发展，汽车=智能终端+四个轮子，各家车企都推出了各自的OTA升级方案，本章节主要介绍如何使
    
                    
    • 
                    
  • 进销存小程序源码 PHP网络版ERP进销存管理系统 全开源可二开
                        摸鱼小号
php
                        
    可直接源码搭建部署发布后使用：一、功能模块介绍该系统模板主要有进，销，存三个主要模板功能组成，下面将介绍各模块所对应的功能；进：需要将产品采购入库，自动生成采购明细台账同时关联财务生成付款账单；销：是指对客户的销售订单记录，汇总生成产品销售明细及回款计划；存：库存的日常盘点与统计，库存下限预警、出入库台账、库存位置等。1.进购管理采购订单：采购下单审批→由上级审批通过采购入库；采购入库：货品到货>
    
                    
    • 
                    
  • 计算机毕业设计PHP仓储综合管理系统（源码+程序+VUE+lw+部署）
                        java毕设程序源码王哥
php课程设计vue.js
                        
    该项目含有源码、文档、程序、数据库、配套开发软件、软件安装教程。欢迎交流项目运行环境配置：phpStudy+Vscode+Mysql5.7+HBuilderX+Navicat11+Vue+Express。项目技术：原生PHP++Vue等等组成，B/S模式+Vscode管理+前后端分离等等。环境需要1.运行环境：最好是小皮phpstudy最新版，我们在这个版本上开发的。其他版本理论上也可以。2.开发
    
                    
    • 
                    
  • RabbitMQ生产者重复机制与确认机制
                        java炒饭小能手
java-rabbitmqrabbitmqjava
                        
    重复机制生产者发送消息时，出现了网络故障，导致与MQ的连接中断。为了解决这个问题，SpringAMQP提供的消息发送时的重试机制。即：当RabbitTemplate与MQ连接超时后，多次重试。需要修该发送端模块的application.yaml文件，添加下面的内容：spring:rabbitmq:connection-timeout:1s#设置MQ的连接超时时间template:retry:ena
    
                    
    • 
                    
  • 绝招曝光！3小时高效利用ChatGPT写出精彩论文
                        kkai人工智能
chatgpt人工智能ai学习媒体
                        
    在这份指南中，我将深入解析如何利用ChatGPT4.0的高级功能，指导整个学术研究和写作过程。从初步探索研究主题，到撰写结构严谨的学术论文，我将一步步展示如何在每个环节中有效运用ChatGPT。如果您还未使用PLUS版本，可以参考相关教程。**初步探索与主题的确定**起初，我处于庞大的知识领域中，寻找一个可深入研究的领域。ChatGPT如同灯塔，通过深入分析最新研究趋势和领域热点，帮助我在广阔的学
    
                    
    • 
                    
  • 【Java】已解决：org.springframework.jdbc.datasource.lookup.DataSourceLookupFailureException
                        屿小夏
java开发语言
                        
    文章目录一、分析问题背景问题背景描述出现问题的场景二、可能出错的原因三、错误代码示例四、正确代码示例五、注意事项已解决：org.springframework.jdbc.datasource.lookup.DataSourceLookupFailureException在使用Spring框架进行开发时，数据源的配置和使用是非常关键的一环。然而，有时候我们可能会遇到org.springframewo
    
                    
    • 
                    
  • JVM源码分析之堆外内存完全解读
                        HeapDump性能社区

                        
    概述广义的堆外内存说到堆外内存，那大家肯定想到堆内内存，这也是我们大家接触最多的，我们在jvm参数里通常设置-Xmx来指定我们的堆的最大值，不过这还不是我们理解的Java堆，-Xmx的值是新生代和老生代的和的最大值，我们在jvm参数里通常还会加一个参数-XX:MaxPermSize来指定持久代的最大值，那么我们认识的Java堆的最大值其实是-Xmx和-XX:MaxPermSize的总和，在分代算法
    
                    
    • 
                    
  • html+css网页设计 旅游网站首页1个页面
                        html+css+js网页设计
htmlcss旅游
                        
    html+css网页设计旅游网站首页1个页面网页作品代码简单，可使用任意HTML辑软件（如：Dreamweaver、HBuilder、Vscode、Sublime、Webstorm、Text、Notepad++等任意html编辑软件进行运行及修改编辑等操作）。获取源码1，访问该网站https://download.csdn.net/download/qq_42431718/897527112，点击
    
                    
    • 
                    
  • SpringBoot和SpringMVC是什么关系?SpringBoot替代SpringMVC了吗?
                        瑞金彭于晏
springboot后端javaMVCspring数据库
                        
    SpringBoot和SpringMVC都是SpringFramework生态系统中的一部分，但它们各自扮演着不同的角色和提供不同的功能集。理解它们之间的关系，首先需要了解SpringFramework本身。SpringFrameworkSpringFramework是一个全面的、开源的应用程序开发框架，它提供了广泛的功能来支持企业应用开发的几乎所有方面。SpringFramework的核心特性之
    
                    
    • 
                    
  • spring mvc @RequestBody String类型参数
                        zoyation
spring-mvcspringmvc
                        
    通过如下配置：text/html;charset=UTF-8application/json;charset=UTF-8在springmvc的Controller层使用@RequestBody接收Content-Type为application/json的数据时，默认支持Map方式和对象方式参数@RequestMapping(value="/{code}/saveUser",method=Requ
    
                    
    • 
                    
  • Istio pilot-discovery服务发现源码解析（1.13版本）
                        xidianjiapei001
#Istioistio云原生服务发现
                        
    Istiopilot-discovery服务发现介绍工作机制初始化初始化Config控制器初始化Service控制器controller初始化NamespaceServiceNodePodPilotDiscovery各组件启动流程DiscoveryServer接收Envoy的gRPC连接请求流程Config变化后向Envoy推送更新的流程总结参考介绍IstioPilot的代码分为Pilot-Dis
    
                    
    • 
                    
  • Java -jar 如何在后台运行项目
                        vincent_hahaha

                        
    撸了今年阿里、头条和美团的面试，我有一个重要发现.......>>>说到运行jar包通常我们都会以下面的方式运行:java-jarspringboot-0.0.1-SNAPSHOT.jar这样运行的话会有一个问题，就是我们一关闭当前窗口就会停止运行项目，要想解决这个问题，就需要在后台运行。nohupjava-jarbabyshark-0.0.1-SNAPSHOT.jar >log.file 2>&
    
                    
    • 
                    
  • spring security中几大组件的作用和执行顺序
                        阿信在这里
javaspring
                        
    springsecurity中几大组件的作用和执行顺序在SpringSecurity中，AuthenticationProvider、GroupPermissionEvaluator、PermissionEvaluator、AbstractAuthenticationProcessingFilter、DefaultMethodSecurityExpressionHandler和ManageSecu
    
                    
    • 
                    
  • python中文版软件下载-Python中文版
                        编程大乐趣

                        
    python中文版是一种面向对象的解释型计算机程序设计语言。python中文版官网面向对象编程，拥有高效的高级数据结构和简单而有效的方法，其优雅的语法、动态类型、以及天然的解释能力，让它成为理想的语言。软件功能强大，简单易学，可以帮助用户快速编写代码，而且代码运行速度非常快，几乎可以支持所有的操作系统，实用性真的超高的。python中文版软件介绍：python中文版的解释器及其扩展标准库的源码和编
    
                    
    • 
                                
  • Dom
                                    周华华
JavaScripthtml
                                    
    <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"> 
<html xmlns="http://www.w3.org/1999/xhtml&q
    
                                
    • 
                                
  • 【Spark九十六】RDD API之combineByKey
                                    bit1129
spark
                                    
    1. combineByKey函数的运行机制 
  
RDD提供了很多针对元素类型为(K,V)的API，这些API封装在PairRDDFunctions类中，通过Scala隐式转换使用。这些API实现上是借助于combineByKey实现的。combineByKey函数本身也是RDD开放给Spark开发人员使用的API之一 
  
首先看一下combineByKey的方法说明：
    
                                
    • 
                                
  • msyql设置密码报错：ERROR 1372 (HY000): 解决方法详解
                                    daizj
mysql设置密码
                                    
    MySql给用户设置权限同时指定访问密码时，会提示如下错误： 
ERROR 1372 (HY000): Password hash should be a 41-digit hexadecimal number； 
  
问题原因：你输入的密码是明文。不允许这么输入。 
  
解决办法：用select password('你想输入的密码');查询出你的密码对应的字符串， 
然后
    
                                
    • 
                                
  • 路漫漫其修远兮 吾将上下而求索
                                    周凡杨
学习 思索
                                    
    王国维在他的《人间词话》中曾经概括了为学的三种境界古今之成大事业、大学问者，罔不经过三种之境界。“昨夜西风凋碧树。独上高楼，望尽天涯路。”此第一境界也。“衣带渐宽终不悔，为伊消得人憔悴。”此第二境界也。“众里寻他千百度，蓦然回首，那人却在灯火阑珊处。”此第三境界也。学习技术，这也是你必须经历的三种境界。第一层境界是说，学习的路是漫漫的，你必须做好充分的思想准备，如果半途而废还不如不要开始。这里，注
    
                                
    • 
                                
  • Hadoop(二)对话单的操作
                                    朱辉辉33
hadoop
                                    
    Debug： 
 
1、 
 
A = LOAD '/user/hue/task.txt' USING PigStorage(' ') 
AS (col1,col2,col3); 
DUMP A; 
 
//输出结果前几行示例： 
(>ggsnPDPRecord(21),,) 
(-->recordType(0),,) 
(-->networkInitiation(1),,) 

    
                                
    • 
                                
  • web报表工具FineReport常用函数的用法总结（日期和时间函数）
                                    老A不折腾
finereport报表工具web开发
                                    
    web报表工具FineReport常用函数的用法总结（日期和时间函数） 
  
说明：凡函数中以日期作为参数因子的，其中日期的形式都必须是yy/mm/dd。而且必须用英文环境下双引号(" ")引用。 
  
DATE 
DATE(year,month,day):返回一个表示某一特定日期的系列数。 
Year:代表年，可为一到四位数。 
Month:代表月份。
    
                                
    • 
                                
  • c++ 宏定义中的##操作符
                                    墙头上一根草
C++
                                    
    #与##在宏定义中的--宏展开 #include <stdio.h> #define f(a,b) a##b #define g(a)   #a #define h(a) g(a) int main() {       &nbs
    
                                
    • 
                                
  • 分析Spring源代码之，DI的实现
                                    aijuans
springDI现源代码
                                    
    (转) 
   
分析Spring源代码之，DI的实现  
2012/1/3 by tony 
                接着上次的讲，以下这个sample    
[java]  
view plain 
copy 
print 

    
                                
    • 
                                
  • for循环的进化
                                    alxw4616
JavaScript
                                    
    // for循环的进化
// 菜鸟
for (var i = 0; i < Things.length ; i++) {
	// Things[i]
}

// 老鸟
for (var i = 0, len = Things.length; i < len; i++) {
	// Things[i]
}

// 大师
for (var i = Things.le
    
                                
    • 
                                
  • 网络编程Socket和ServerSocket简单的使用
                                    百合不是茶
网络编程基础IP地址端口
                                    
      
网络编程;TCP/IP协议 
  
网络:实现计算机之间的信息共享,数据资源的交换 
  
协议:数据交换需要遵守的一种协议,按照约定的数据格式等写出去 
  
端口:用于计算机之间的通信 
     每运行一个程序，系统会分配一个编号给该程序，作为和外界交换数据的唯一标识 
0~65535 
  
查看被使用的
    
                                
    • 
                                
  • JDK1.5 生产消费者
                                    bijian1013
javathread生产消费者java多线程
                                    
    ArrayBlockingQueue： 
       一个由数组支持的有界阻塞队列。此队列按 FIFO（先进先出）原则对元素进行排序。队列的头部 是在队列中存在时间最长的元素。队列的尾部 是在队列中存在时间最短的元素。新元素插入到队列的尾部，队列检索操作则是从队列头部开始获得元素。 
ArrayBlockingQueue的常用方法： 

    
                                
    • 
                                
  • JAVA版身份证获取性别、出生日期及年龄
                                    bijian1013
java性别出生日期年龄
                                    
            工作中需要根据身份证获取性别、出生日期及年龄，且要还要支持15位长度的身份证号码，网上搜索了一下，经过测试好像多少存在点问题，干脆自已写一个。 
CertificateNo.java 
package com.bijian.study;

import java.util.Calendar;
import 
    
                                
    • 
                                
  • 【Java范型六】范型与枚举
                                    bit1129
java
                                    
    首先，枚举类型的定义不能带有类型参数，所以，不能把枚举类型定义为范型枚举类，例如下面的枚举类定义是有编译错的 
  
public enum EnumGenerics<T> { //编译错，提示枚举不能带有范型参数
    OK, ERROR;
    public <T> T get(T type) {
        return null;
    
    
                                
    • 
                                
  • 【Nginx五】Nginx常用日志格式含义
                                    bit1129
nginx
                                    
    1. log_format 
1.1 log_format指令用于指定日志的格式，格式： 
  
log_format name(格式名称) type(格式样式) 
  
1.2 如下是一个常用的Nginx日志格式： 
  
log_format      main    '[$time_local]|$request_time|$status|$body_bytes
    
                                
    • 
                                
  • Lua 语言 15 分钟快速入门
                                    ronin47
lua 基础
                                    
    -
- 
单行注释   
-
-
[[   
    
[多行注释]   
-
-
]]       
-
-
-
-
-
-
-
-
-
-   
- 
1. 
变量 & 控制流   
-
-
-
-
-
-
-
-
-
-   
num 
= 
23 
-
- 
数字都是双精度   
str 
= 
'aspythonstring' 

    
                                
    • 
                                
  • java-35.求一个矩阵中最大的二维矩阵 ( 元素和最大 )
                                    bylijinnan
java
                                    
    the idea is from: 
http://blog.csdn.net/zhanxinhang/article/details/6731134 
 


public class MaxSubMatrix {

	/**see http://blog.csdn.net/zhanxinhang/article/details/6731134
	 * Q35
求一个矩阵中最大的二维
    
                                
    • 
                                
  • mongoDB文档型数据库特点
                                    开窍的石头
mongoDB文档型数据库特点
                                    
    MongoDD: 文档型数据库存储的是Bson文档-->json的二进制 
 
特点：内部是执行引擎是js解释器，把文档转成Bson结构，在查询时转换成js对象。 
 
mongoDB传统型数据库对比 
   传统类型数据库：结构化数据，定好了表结构后每一个内容符合表结构的。也就是说每一行每一列的数据都是一样的 
   文档型数据库：不用定好数据结构，
    
                                
    • 
                                
  • [毕业季节]欢迎广大毕业生加入JAVA程序员的行列
                                    comsci
java
                                    
     
    一年一度的毕业季来临了。。。。。。。。 
 
     正在投简历的学弟学妹们。。。如果觉得学校推荐的单位和公司不适合自己的兴趣和专业，可以考虑来我们软件行业，做一名职业程序员。。。 
 
     软件行业的开发工具中，对初学者最友好的就是JAVA语言了，网络上不仅仅有大量的
    
                                
    • 
                                
  • PHP操作Excel – PHPExcel 基本用法详解
                                    cuiyadll
PHPExcel
                                    
    导出excel属性设置//Include classrequire_once('Classes/PHPExcel.php');require_once('Classes/PHPExcel/Writer/Excel2007.php');$objPHPExcel = new PHPExcel();//Set properties 设置文件属性$objPHPExcel->getProperties
    
                                
    • 
                                
  • IBM Webshpere MQ Client User Issue (MCAUSER)
                                    darrenzhu
IBMjmsuserMQMCAUSER
                                    
    IBM MQ JMS Client去连接远端MQ Server的时候，需要提供User和Password吗？ 
答案是根据情况而定，取决于所定义的Channel里面的属性Message channel agent user identifier (MCAUSER)的设置。 
 
 
http://stackoverflow.com/questions/20209429/how-mca-user-i
    
                                
    • 
                                
  • 网线的接法
                                    dcj3sjt126com

                                    
    一、PC连HUB (直连线)A端：（标准568B）：白橙，橙，白绿，蓝，白蓝，绿，白棕，棕。 B端：（标准568B）：白橙，橙，白绿，蓝，白蓝，绿，白棕，棕。 二、PC连PC （交叉线）A端：(568A)： 白绿，绿，白橙，蓝，白蓝，橙，白棕，棕； B端：（标准568B）：白橙，橙，白绿，蓝，白蓝，绿，白棕，棕。 三、HUB连HUB&nb
    
                                
    • 
                                
  • Vimium插件让键盘党像操作Vim一样操作Chrome
                                    dcj3sjt126com
chromevim
                                    
    什么是键盘党？ 
 
 键盘党是指尽可能将所有电脑操作用键盘来完成，而不去动鼠标的人。鼠标应该说是新手们的最爱，很直观，指哪点哪，很听话！不过常常使用电脑的人，如果一直使用鼠标的话，手会发酸，因为操作鼠标的时候，手臂不是在一个自然的状态，臂肌会处于绷紧状态。而使用键盘则双手是放松状态，只有手指在动。而且尽量少的从鼠标移动到键盘来回操作，也省不少事。 
 在chrome里安装 vimium 插件 

    
                                
    • 
                                
  • MongoDB查询（2）——数组查询[六]
                                    eksliang
mongodbMongoDB查询数组
                                    
    MongoDB查询数组 
转载请出自出处：http://eksliang.iteye.com/blog/2177292 一、概述 
 MongoDB查询数组与查询标量值是一样的，例如，有一个水果列表，如下所示： 
> db.food.find()
{ "_id" : "001", "fruits" : [ "苹
    
                                
    • 
                                
  • cordova读写文件（1）
                                    gundumw100
JavaScriptCordova
                                    
    使用cordova可以很方便的在手机sdcard中读写文件。 
 
首先需要安装cordova插件：file 
命令为： 
 
cordova plugin add org.apache.cordova.file 
 
然后就可以读写文件了，这里我先是写入一个文件，具体的JS代码为： 
 


var datas=null;//datas need write
var directory=&
    
                                
    • 
                                
  • HTML5 FormData 进行文件jquery ajax 上传 到又拍云
                                    ileson
jqueryAjaxhtml5FormData
                                    
    html5 新东西：FormData  可以提交二进制数据。 
 
 
页面test.html 
 

<!DOCTYPE>
<html>
<head>
<title> formdata file jquery ajax upload</title>
</head>

<body>
<
    
                                
    • 
                                
  • swift appearanceWhenContainedIn:(version1.2 xcode6.4)
                                    啸笑天
version
                                    
      
swift1.2中没有oc中对应的方法： 
+ (instancetype)appearanceWhenContainedIn:(Class <UIAppearanceContainer>)ContainerClass, ... NS_REQUIRES_NIL_TERMINATION; 
 解决方法： 
在swift项目中新建oc类如下： 
#import &
    
                                
    • 
                                
  • java实现SMTP邮件服务器
                                    macroli
java编程
                                    
    电子邮件传递可以由多种协议来实现。目前，在Internet 网上最流行的三种电子邮件协议是SMTP、POP3 和 IMAP，下面分别简单介绍。 
　　◆ SMTP 协议 
　　简单邮件传输协议(Simple Mail Transfer Protocol,SMTP)是一个运行在TCP/IP之上的协议，用它发送和接收电子邮件。SMTP 服务器在默认端口25上监听。SMTP客户使用一组简单的、基于文本的
    
                                
    • 
                                
  • mongodb group by having where 查询sql
                                    qiaolevip
每天进步一点点学习永无止境mongo纵观千象
                                    
    SELECT cust_id,
       SUM(price) as total
FROM orders
WHERE status = 'A'
GROUP BY cust_id
HAVING total > 250

db.orders.aggregate( [
   { $match: { status: 'A' } },
   {
     $group: {

    
                                
    • 
                                
  • Struts2 Pojo（六）
                                    Luob.
POJOstrust2
                                    
    注意：附件中有完整案例 
1.采用POJO对象的方法进行赋值和传值 
2.web配置 
 

<?xml version="1.0" encoding="UTF-8"?>
<web-app version="2.5" 
	xmlns="http://java.sun.com/xml/ns/javaee&q
    
                                
    • 
                                
  • struts2步骤
                                    wuai
struts
                                    
    1、添加jar包 
2、在web.xml中配置过滤器 
 <filter> 
       <filter-name>struts2</filter-name> 
       <filter-class>org.apache.st
    
                                
    •