后来丶_a24d
后来丶_a24d

Spring Ioc源码解析

目录

目录.png

一.spring模块

spring模块.png
  • 底层core container就是ioc容器，其中beans主要是BeanFactory低级容器，context 其中ApplicationContext是高级容器，通过组合的形式依赖BeanFactory低级容器。core是一些StringUtils之类的通用类
  • AOP面向切面编程
  • Web springMvc之类的
  • Data Access 中orm框架比如mybatis
    ....................................................................................................................................................

二. 项目中使用的地方

  • 采用拓展版的SpringMvc + Spring + 自定义orm框架
  • 项目实现了ServletContextListener(servlet这块代码不文不涉及)，其中启动时会调用如下代码
// ioc容器启动
ApplicationContext applicationContext = new ClassPathXmlApplicationContext(springConfigLocation);
// 存起来，后续springmvc处理url时会调用getBean。
ServletContext.INSTANCE.setApplicationContext(applicationContext);
  • applicationContent配置中配置了自动扫描bean

....................................................................................................................................................

三.spring ioc启动流程

  • 注意: 如果对spring一点基础都没有，请google下基本使用
1. 从ClassPathXmlApplicationContext开始分析
  • ClassPathXmlApplicationContext是根据 xml 文件内容来构建 ApplicationContext
ApplicationContext applicationContext = new ClassPathXmlApplicationContext(springConfigLocation);
2. ClassPathXmlApplicationContext继续关系

  • 盗用参考文章1的简化版继续关系图


    ClassPathXmlApplicationContext继续关系.png
  • 其中AbstractRefreshableApplicationContext持有DefaultListableBeanFactory beanFactory引用，也就是与低级容器组合，ApplicationContext高级容器提供更多更高级功能。

  • DefaultListableBeanFactory 顾名思义就是持有多个bean的list，其中持有多个BeanDefinition ，BeanDefinition 中保存了我们的 Bean 信息，比如这个 Bean 指向的是哪个类、是否是单例的、是否懒加载、这个 Bean 依赖了哪些 Bean 等等。


    DefaultListableBeanFactory 关系图.png
3.ioc启动过程分析
public ClassPathXmlApplicationContext(String[] configLocations, boolean refresh, ApplicationContext parent)
      throws BeansException {
 
    super(parent);
    // 根据提供的路径，处理成配置文件数组(以分号、逗号、空格、tab、换行符分割)
    setConfigLocations(configLocations);
    if (refresh) {
      // 核心方法
      refresh(); 
    }
}
4. refresh核心方法
  • refresh是在ClassPathXmlApplicationContext父类AbstractApplicationContext实现
// 不叫Init就是因为你可以refresh刷新下
@Override
public void refresh() throws BeansException, IllegalStateException {
   // 防止refresh还没结束，你又启动容器
   synchronized (this.startupShutdownMonitor) {
 
      // 步骤1. 准备工作，记录下容器的启动时间、处理配置文件中的占位符
      prepareRefresh();
 
      /**
      * 步骤2. 将各个需要spring管理的bean通过BeanDefinition形式 注册到DefaultListableBeanFactory中，
      * 说到底核心是一个 beanName-> beanDefinition 的 map，
      * 项目定义了spring自动扫描bean,spring会将需要扫描的包底下
      * 有@Component，@Service, @Controller等这些注解的扫描到注册到DefaultListableBeanFactory中
      **/

      ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
 
      // 步骤3. 设置 BeanFactory 的类加载器，添加几个特殊的BeanPostProcessor，保证了这些需要先添加的顺序性链表结构
      prepareBeanFactory(beanFactory);
 
      try {
        
        
        /**
        * 步骤4. 这里是提供给子类的扩展点，到这里的时候，所有的 Bean 都加载、注册完成了，但是都还没有初始化
        * 具体的子类可以在这步的时候添加一些特殊的 BeanFactoryPostProcessor 的实现类或做点什么事
        **/
         postProcessBeanFactory(beanFactory);
         //步骤 5. 调用 BeanFactoryPostProcessor 各个实现类的 postProcessBeanFactory(factory) 方法, 占位符解析就在这里。
         invokeBeanFactoryPostProcessors(beanFactory);
 
         /**
         * 步骤6. 注册 BeanPostProcessor 的实现类包括aop的后置处理器也是在这里注册的，注意看和 BeanFactoryPostProcessor 的区别
         * 此接口两个方法: postProcessBeforeInitialization 和 postProcessAfterInitialization
         * 两个方法分别在 Bean 初始化之前和初始化之后得到执行。注意，到这里 Bean 还没初始化
         **/
         registerBeanPostProcessors(beanFactory);
 
         // 步骤7. 初始化当前 ApplicationContext 的 MessageSource，国际化
         initMessageSource();
 
         // 步骤8. 初始化当前 ApplicationContext 的事件广播器
         initApplicationEventMulticaster();
 
         // 步骤9. 从方法名就可以知道，典型的模板方法(钩子方法)，供拓展
         onRefresh();
 
         // 步骤10. 注册事件监听器，监听器需要实现 ApplicationListener 接口。
         registerListeners();
 
       
         // 步骤11. 初始化除懒加载外所有的单例beans，原型bean不会被报错到ioc容器，比较核心的代码
         finishBeanFactoryInitialization(beanFactory);
 
         // 步骤12. 最后，广播事件，ApplicationContext 初始化完成
         finishRefresh();
      }
 
      catch (BeansException ex) {
         // 异常处理省略
      }
 
      finally {
         // 省略
      }
    }
}
5. 步骤1 prepareRefresh解析
  • 这块比较简单就是些准备工作，记录下容器的启动时间、处理配置文件中的占位符
6. 步骤2 obtainFreshBeanFactory解析
  • 初始化 BeanFactory(ioc容器)、加载 Bean、注册 Bean 等等。
  • 看下AbstractApplicationContext.obtainFreshBeanFactory方法
protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
   // 创建新的 BeanFactory，加载 Bean 定义、注册 Bean 等等
   refreshBeanFactory();
 
   // 返回刚刚创建的 BeanFactory （省略部分Log代码）
   ConfigurableListableBeanFactory beanFactory = getBeanFactory();
   return beanFactory;
}
  • 继续看AbstractRefreshableApplicationContext.refreshBeanFactory方法
protected final void refreshBeanFactory() throws BeansException {
    
   // 省略部分代码
   try {
      // 初始化一个 DefaultListableBeanFactory
      DefaultListableBeanFactory beanFactory = createBeanFactory();
      beanFactory.setSerializationId(getId());
      // 设置 BeanFactory 的两个配置属性：是否允许 Bean 覆盖、是否允许循环引用
      customizeBeanFactory(beanFactory);
 
      // 核心方法，加载 Bean 到 BeanFactory 中
      loadBeanDefinitions(beanFactory);
      synchronized (this.beanFactoryMonitor) {
         this.beanFactory = beanFactory;
      }
   }
   catch (IOException ex) {
      throw new ApplicationContextException("I/O error parsing bean definition source for " + getDisplayName(), ex);
   }
}
  • 继续看重要方法AbstractXmlApplicationContext.loadBeanDefinitions
//此方法将通过一个 XmlBeanDefinitionReader 实例来加载各个 Bean
protected void loadBeanDefinitions(DefaultListableBeanFactory beanFactory) throws BeansException, IOException {
   // 给这个 BeanFactory 实例化一个 XmlBeanDefinitionReader
   XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(beanFactory);

   beanDefinitionReader.setEnvironment(this.getEnvironment());
   beanDefinitionReader.setResourceLoader(this);
   beanDefinitionReader.setEntityResolver(new ResourceEntityResolver(this));
 
   // 重要方法
   loadBeanDefinitions(beanDefinitionReader);
   
}

protected void loadBeanDefinitions(XmlBeanDefinitionReader reader) throws BeansException, IOException {
   // 关注loadBeanDefinitions方法
   String[] configLocations = getConfigLocations();
   if (configLocations != null) {
      reader.loadBeanDefinitions(configLocations);
   }
}
  • 继续看AbstractBeanDefinitionReader.loadBeanDefinitions方法
public int loadBeanDefinitions(String... locations) throws BeanDefinitionStoreException {
    // 这里我们只传一个location, classpath:applicationContext.xml
    int counter = 0;
    for (String location : locations) {
        counter += loadBeanDefinitions(location);
    }
    return counter;
}

public int loadBeanDefinitions(String location) throws BeanDefinitionStoreException {
        return loadBeanDefinitions(location, null);
    }
  • 继续看XmlBeanDefinitionReader.loadBeanDefinitions方法
public int loadBeanDefinitions(Resource resource) throws BeanDefinitionStoreException {
    return loadBeanDefinitions(new EncodedResource(resource));
}

public int loadBeanDefinitions(EncodedResource encodedResource) throws BeanDefinitionStoreException {
    // 省略部分代码
    try {
        // 读取文件
        InputStream inputStream = encodedResource.getResource().getInputStream();
        try {
            InputSource inputSource = new InputSource(inputStream);
            if (encodedResource.getEncoding() != null) {
                inputSource.setEncoding(encodedResource.getEncoding());
            }
            // 重点关注
            return doLoadBeanDefinitions(inputSource, encodedResource.getResource());
        }
        finally {
            inputStream.close();
        }
    }
    // 省略部分代码
}


protected int doLoadBeanDefinitions(InputSource inputSource, Resource resource)
      throws BeanDefinitionStoreException {
   try {
      // xml文件解析成Document，org.w3c.dom里面的
      Document doc = doLoadDocument(inputSource, resource);
      // 重点关注
      return registerBeanDefinitions(doc, resource);
   }
   catch (...


// 返回从当前配置文件加载了多少数量的 Bean
public int registerBeanDefinitions(Document doc, Resource resource) throws BeanDefinitionStoreException {
   BeanDefinitionDocumentReader documentReader = createBeanDefinitionDocumentReader();
   int countBefore = getRegistry().getBeanDefinitionCount();
   // 重点关注
   documentReader.registerBeanDefinitions(doc, createReaderContext(resource));
   return getRegistry().getBeanDefinitionCount() - countBefore;
  • 继续看DefaultBeanDefinitionDocumentReader.registerBeanDefinitions

public void registerBeanDefinitions(Document doc, XmlReaderContext readerContext) {
   Element root = doc.getDocumentElement();
   // 重点关注
   doRegisterBeanDefinitions(root);
}
  • 这里一个配置文件终于转换为一颗 DOM 树了，继续看DefaultBeanDefinitionDocumentReader.doRegisterBeanDefinitions方法
protected void doRegisterBeanDefinitions(Element root) {
   /**
   * 我们看名字就知道，BeanDefinitionParserDelegate 必定是一个重要的类，它负责解析 Bean 定义，
   * 这里为什么要定义一个 parent? 看到后面就知道了，是递归问题
   * 因为  内部是可以定义  的，所以这个方法的 root 其实不一定就是 xml 的根节点，也可以是嵌套在里面的  节点，从源码分析的角度，我们当做根节点就好了
   **/
   BeanDefinitionParserDelegate parent = this.delegate;
   this.delegate = createDelegate(getReaderContext(), root, parent);
 
   if (this.delegate.isDefaultNamespace(root)) {
       /**
        * 这块说的是根节点  中的 profile 是否是当前环境需要的，
        * 如果当前环境配置的 profile 不包含此 profile，那就直接 return 了，不对此  解析
       **/
      String profileSpec = root.getAttribute(PROFILE_ATTRIBUTE);
      if (StringUtils.hasText(profileSpec)) {
         String[] specifiedProfiles = StringUtils.tokenizeToStringArray(
               profileSpec, BeanDefinitionParserDelegate.MULTI_VALUE_ATTRIBUTE_DELIMITERS);
         if (!getReaderContext().getEnvironment().acceptsProfiles(specifiedProfiles)) {
            if (logger.isInfoEnabled()) {
               logger.info("Skipped XML bean definition file due to specified profiles [" + profileSpec +
                     "] not matching: " + getReaderContext().getResource());
            }
            return;
         }
      }
   }
 
   preProcessXml(root); // 钩子
   // 重要方法
   parseBeanDefinitions(root, this.delegate);
   postProcessXml(root); // 钩子
 
   this.delegate = parent;
}


// default namespace 涉及到的就四个标签 、、 和 ，
// 其他的属于 custom 的
protected void parseBeanDefinitions(Element root, BeanDefinitionParserDelegate delegate) {
   if (delegate.isDefaultNamespace(root)) {
      NodeList nl = root.getChildNodes();
      for (int i = 0; i < nl.getLength(); i++) {
         Node node = nl.item(i);
         if (node instanceof Element) {
            Element ele = (Element) node;
            if (delegate.isDefaultNamespace(ele)) {
               parseDefaultElement(ele, delegate);
            }
            else {
               delegate.parseCustomElement(ele);
            }
         }
      }
   }
   else {
      // 我们这里要解析context:component-scan，所以直接看这个方法
      delegate.parseCustomElement(root);
   }
}
  • 继续看BeanDefinitionParserDelegate.parseCustomElement方法
public BeanDefinition parseCustomElement(Element ele, BeanDefinition containingBd) {
    String namespaceUri = getNamespaceURI(ele);
    NamespaceHandler handler = this.readerContext.getNamespaceHandlerResolver().resolve(namespaceUri);
    if (handler == null) {
        error("Unable to locate Spring NamespaceHandler for XML schema namespace [" + namespaceUri + "]", ele);
        return null;
    }
    // 因为这里要解析标签context:component-scan，所以是ContextNamespaceHandler处理
    return handler.parse(ele, new ParserContext(this.readerContext, this, containingBd));
}

// ContextNamespaceHandler父类NamespaceHandlerSupport处理
public BeanDefinition parse(Element element, ParserContext parserContext) {
        // 重点关注parse方法
    return findParserForElement(element, parserContext).parse(element, parserContext);
}
  • 调用ComponentScanBeanDefinitionParser.parse方法
public BeanDefinition parse(Element element, ParserContext parserContext) {
    String basePackage = element.getAttribute(BASE_PACKAGE_ATTRIBUTE);
    basePackage = parserContext.getReaderContext().getEnvironment().resolvePlaceholders(basePackage);
    String[] basePackages = StringUtils.tokenizeToStringArray(basePackage,
            ConfigurableApplicationContext.CONFIG_LOCATION_DELIMITERS);

    ClassPathBeanDefinitionScanner scanner = configureScanner(parserContext, element);
    // 扫描basePackage包将所有含有@Component,@Service等几个注解的类扫描出来
    // 通过BeanDefinition形式注册所有需要注册的bean到ioc容器
    Set beanDefinitions = scanner.doScan(basePackages);
    
    
    registerComponents(parserContext.getReaderContext(), beanDefinitions, element);

    return null;
}
  • 看下扫描的逻辑ClassPathBeanDefinitionScanner.doScan，这里面有扫描出来的bean放到ioc容器的操作
protected Set doScan(String... basePackages) {
    // 这里我们只传了一个basePackage
    Set beanDefinitions = new LinkedHashSet();
    for (String basePackage : basePackages) {
        Set candidates = findCandidateComponents(basePackage);
        // 对扫描出来的bean进行注册到ioc容器处理
        for (BeanDefinition candidate : candidates) {
            ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(candidate);
            candidate.setScope(scopeMetadata.getScopeName());
            String beanName = this.beanNameGenerator.generateBeanName(candidate, this.registry);
            if (candidate instanceof AbstractBeanDefinition) {
                postProcessBeanDefinition((AbstractBeanDefinition) candidate, beanName);
            }
            if (candidate instanceof AnnotatedBeanDefinition) {
                AnnotationConfigUtils.processCommonDefinitionAnnotations((AnnotatedBeanDefinition) candidate);
            }
            if (checkCandidate(beanName, candidate)) {
                BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(candidate, beanName);
                definitionHolder = AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);
                beanDefinitions.add(definitionHolder);
                // 注册到ioc容器
                registerBeanDefinition(definitionHolder, this.registry);
            }
        }
    }
    return beanDefinitions;
}

// 看下注册到ioc那块代码
protected void registerBeanDefinition(BeanDefinitionHolder definitionHolder, BeanDefinitionRegistry registry) {
    BeanDefinitionReaderUtils.registerBeanDefinition(definitionHolder, registry);
}

//BeanDefinitionReaderUtils.registerBeanDefinition
public static void registerBeanDefinition(
        BeanDefinitionHolder definitionHolder, BeanDefinitionRegistry registry)
        throws BeanDefinitionStoreException {

    // 重要代码
    registry.registerBeanDefinition(beanName, definitionHolder.getBeanDefinition());
    //省略部分代码
}

// 实际处理是放到DefaultListableBeanFactory的beanDefinitionMap 里面
private final Map beanDefinitionMap = new ConcurrentHashMap(256）;
  • 到这里已经初始化了ioc 容器， 配置也相应的转换为了一个个 BeanDefinition，然后注册了各个 BeanDefinition 到ioc容器
7. 准备 Bean 容器: prepareBeanFactory

-Spring 对一些特殊的 bean 进行了处理

  • 添加几个特殊的BeanPostProcessor，保证了这些需要先添加的顺序性链表结构
  • 比如EmbeddedValueResolverAware，ApplicationContextAware
8. 第四第五点
  • BeanFactoryPostProcessor是接触BeanDefinintion,可以在bean初始化化之前修改BeanDefinition。常见的PropertyPlaceholderConfigurer
void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException;
  • 注意 FactoryBean是在getBean中实现的
9.第六点

  • 盗图参考文章第六点图, BeanPostProcessor注册作用


    BeanPostProcessor.png
  • 注意图中的InstantiationAwareBeanPostProcessor是BeanPostProcessor的子类，其中的postProcessBeforeInstantiation和postProcessAfterInstantiation都重载了，所以spring总体调用
  • InitializingBean，FactoryBean, Aware, InstantiationAwareBeanPostProcessor解析
  1. InitializingBean源码: 初始化阶段一个个bean时会判断是否属于 InitializingBean，属于则回调
  2. SmartFactoryBean源码(继承自FactoryBean, 区别是前者启动时会注入ioc容器，后者第一次调用才会): 实现FactoryBean的接口不走正常的实例化，属性赋值，初始化流程，走refresh中preInstantiateSingletons另一个分支，如果isEagerInit设置为true那么启动时就初始化了。
  3. ApplicationContextAware源码：aware接口实现如EmbeddedValueResolverAware，ApplicationContextAware这些都是在实例化阶段调用postProcessBeforeInstantiation，set进行。初始化阶段会判断bean是否属于ApplicationContextAware，是则回调
  4. 自定义BeanPostProcessor源码: 在refresh的registerBeanPostProcessors方法中，会获取前面obtainFreshBeanFactory方法中获取到所有beanDefiniton的BeanPostProcessors类，拿出来注册到beanPostProcessors。然后在初始化阶段调用所有注册的BeanPostProcessors。
  5. InstantiationAwareBeanPostProcessor属于实例化的时候调用，这个aop会使用，分析aop的时候可以学习。

  6. 注意像这些postProcessor是每个类都会调用postProcessBeforeInstantiation，postProcessAfternstantiation方法的，像第四个是aop在使用，调用时会判断是否需要aop拦截生成代理类，不需要则跳过。上述3，4，5每个类初始化的都会调用对应postProcess方法，但是不属于对应的需要拦截的类都会跳过，像aop的AbstractAutoProxyCreator一样不属于需要aop拦截的都会过滤掉。aop中postProcessBeforeInstantiation(Class beanClass, String beanName)是在实例化前调用，目的是先遍历所有bean, 找出@AspectJ类，把其中的增强器封装成Advisor加入list中。postProcessAfterInitialization(@Nullable Object bean, String beanName)是在初始化后调用的，目的是如果需要代理则返回代理类。


    postProcessor
10. 初始化所有的 singleton beans
  • 重点分析finishBeanFactoryInitialization方法，这里会负责初始化所有的 singleton beans。先是类A调用默认构造函数进行默认初始化，再是将各个属性赋值，如果对属性赋值过程中涉及别的类B初始化会重复这个过程，这时候因为持有类B的引用所以初始化真正完成。
  • 看代码部分AbstractApplicationContext类下refresh 方法
// 初始化剩余的 singleton beans
protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory){
    // 省略部分代码

    // 开始初始化剩下的   beanFactory.preInstantiateSingletons();
}
  • DefaultListableBeanFactory. preInstantiateSingletons方法
public void preInstantiateSingletons() throws BeansException {
        //省略部分代码

        // 触发所有的非懒加载的 singleton beans 的初始化操作
        for (String beanName : beanNames) {

            // 非抽象、非懒加载的 singletons。如果配置了 'abstract = true'，那是不需要初始化的
            if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
                // 处理 FactoryBean
                if (isFactoryBean(beanName)) {
                    
                    if (isEagerInit) {
                        // 正常是走getBean
                        getBean(beanName);
                    }
                }
                else {
                    // 对于普通的 Bean，只要调用 getBean(beanName) 这个方法就可以进行初始化了
                    getBean(beanName);
                }
            }
        }
    }
  • 继续看AbstractBeanFactory. getBean
@Override
    public Object getBean(String name) throws BeansException {
        return doGetBean(name, null, null, false);
    }

    // 我们在剖析初始化 Bean 的过程，但是 getBean 方法我们经常是用来从容器中获取 Bean 用的
    @SuppressWarnings("unchecked")
    protected  T doGetBean(
            final String name, final Class requiredType, final Object[] args, boolean typeCheckOnly)
            throws BeansException {
      
        // 如果 args 不为空的时候，那么意味着调用方不是希望获取 Bean，而是创建 Bean
        if (sharedInstance != null && args == null) {
            // 下面这个方法：如果是普通 Bean 的话，直接返回 sharedInstance
            bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
        }
        // 这里走else分支，因为这里是要分析创建bean
        else {

            /*
             * 到这里的话，要准备创建 Bean 了，对于 singleton 的 Bean 来说，容器中还没创建过此 Bean；
             * 对于 prototype 的 Bean 来说，本来就是要创建一个新的 Bean。
             */
            try {
                // 先初始化依赖的所有 Bean，这个很好理解。
                // 这里的依赖指的是 depends-on 中定义的依赖
                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);
                    }
                }

                // 创建 singleton 的实例
                if (mbd.isSingleton()) {
                    sharedInstance = getSingleton(beanName, new ObjectFactory() {
                        @Override
                        public Object getObject() throws BeansException {
                            try {
                                // 执行创建 Bean，重要方法
                                return createBean(beanName, mbd, args);
                            }
                            catch (BeansException ex) {
                                destroySingleton(beanName);
                                throw ex;
                            }
                        }
                    });
                    bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
                }

                // 创建 prototype 的实例
                else if (mbd.isPrototype()) {
                    // 省略
                }

                // 如果不是 singleton 和 prototype 的话，需要委托给相应的实现类来处理
                else {
                    
                }
            }
            
        }

        // 最后，检查一下类型对不对，不对的话就抛异常，对的话就返回了
        if (requiredType != null && bean != null && !requiredType.isInstance(bean)) {
            
        }
        return (T) bean;
    }

 
 
     
  
  • 接下来当然是分析 createBean 方法，AbstractAutowireCapableBeanFactory类里面的，专门针对@Autowire
    •  
 
 
 
 protected Object createBean(String beanName, RootBeanDefinition mbd, Object[] args) throws BeanCreationException {  
     // 省略部分代码                                                                                                       
                                                                                                                     
     // 确保 BeanDefinition 中的 Class 被加载                                                                               
     Class resolvedClass = resolveBeanClass(mbd, beanName);                                                       
     if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {                           
     }                                                                                                               
     // 重头戏，创建 bean                                                                                                  
     Object beanInstance = doCreateBean(beanName, mbdToUse, args);                                                   
     return beanInstance;                                                                                            
 }                                                                                                                   
                                                                                                                     

 
 
     
  
  • 接下来看doCreateBean方法
    •  
 
 
 
protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final Object[] args)                
      throws BeanCreationException {                                                                                   
                                                                                                                       
    // 省略部分代码                                                                                                          
                                                                                                                       
    BeanWrapper instanceWrapper = null;                                                                                
                                                                                                                       
    // 这里只是调用默认构造函数进行实例化，属性还没有赋值                                                                                       
    if (instanceWrapper == null) {                                                                                     
        instanceWrapper = createBeanInstance(beanName, mbd, args);                                                     
    }                                                                                                                  
                                                                                                                       
                                                                                                                       
    Object exposedObject = bean;                                                                                       
    try {                                                                                                              
        // 这一步也是非常关键的，这一步负责属性装配，因为前面的实例只是实例化了，属性并没有设值，这里就是设值                                                           
        populateBean(beanName, mbd, instanceWrapper);                                                                  
        if (exposedObject != null) {                                                                                   
            // 还记得 init-method 吗？还有 InitializingBean 接口？还有 BeanPostProcessor 接口？                                       
            // 这里就是处理 bean 初始化完成后的各种回调                                                                                 
            exposedObject = initializeBean(beanName, exposedObject, mbd);                                              
        }                                                                                                              
    }                                                                                                                  
}                                                                                                                      

 
 
     
  
  • 接下来重点看下createBeanInstance，populateBean，initializeBean方法（调用spring xml中的init 方法，调用initlizible中afterProperty方法）, 先看下createBeanInstance
    •  
 
 
 
//省略部分代码                                                                                                
                                                                                                        
protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, Object[] args) {      
   //省略部分代码                                                                                             
                                                                                                        
   // 确保已经加载了此 class                                                                                    
   Class beanClass = resolveBeanClass(mbd, beanName);                                                
                                                                                                        
  //是否第一次                                                                                               
   boolean resolved = false;                                                                            
  //是否采用构造函数注入                                                                                          
   boolean autowireNecessary = false;                                                                   
   if (args == null) {                                                                                  
      synchronized (mbd.constructorArgumentLock) {                                                      
         if (mbd.resolvedConstructorOrFactoryMethod != null) {                                          
            resolved = true;                                                                            
            autowireNecessary = mbd.constructorArgumentsResolved;                                       
         }                                                                                              
      }                                                                                                 
   }                                                                                                    
   if (resolved) {                                                                                      
      if (autowireNecessary) {                                                                          
         return autowireConstructor(beanName, mbd, null, null);                                         
      }                                                                                                 
      else {                                                                                            
         // 无参构造函数                                                                                      
         return instantiateBean(beanName, mbd);                                                         
      }                                                                                                 
   }                                                                                                    
                                                                                                        
   // 判断是否采用有参构造函数                                                                                      
   Constructor[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);           
   if (ctors != null ||                                                                                 
         mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_CONSTRUCTOR ||                    
         mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args))  {                           
      // 构造函数依赖注入                                                                                       
      return autowireConstructor(beanName, mbd, ctors, args);                                           
   }                                                                                                    
                                                                                                        
   // 调用无参构造函数                                                                                          
   return instantiateBean(beanName, mbd);                                                               
}                                                                                                       


 
 
     
  
  • 选一个无参的构造看一下instantiateBean
    •  
 
 
 
 // 省略部分代码                                                                                                             
 protected BeanWrapper instantiateBean(final String beanName, final RootBeanDefinition mbd) {                          
    try {                                                                                                              
       Object beanInstance;                                                                                            
       final BeanFactory parent = this;                                                                                
       if (System.getSecurityManager() != null) {                                                                      
          beanInstance = AccessController.doPrivileged(new PrivilegedAction() {                                
             @Override                                                                                                 
             public Object run() {                                                                                     
                                                                                                                       
                return getInstantiationStrategy().instantiate(mbd, beanName, parent);                                  
             }                                                                                                         
          }, getAccessControlContext());                                                                               
       }                                                                                                               
       else {                                                                                                          
          // 重点方法，具体实例化的实现，往下看                                                                                         
          beanInstance = getInstantiationStrategy().instantiate(mbd, beanName, parent);                                
       }                                                                                                               
       BeanWrapper bw = new BeanWrapperImpl(beanInstance);                                                             
       initBeanWrapper(bw);                                                                                            
       return bw;                                                                                                      
    }                                                                                                                  
    catch (Throwable ex) {                                                                                             
       throw new BeanCreationException(                                                                                
             mbd.getResourceDescription(), beanName, "Instantiation of bean failed", ex);                              
    }                                                                                                                  
 }                                                                                                                     
                                                                                                                       
                                                                                                                       
 public Object instantiate(RootBeanDefinition bd, String beanName, BeanFactory owner) {                                
                                                                                                                       
    // 如果不存在方法覆写，那就使用 java 反射进行实例化，否则使用 CGLIB,                                                                         
    if (bd.getMethodOverrides().isEmpty()) {                                                                           
       Constructor constructorToUse;                                                                                
       synchronized (bd.constructorArgumentLock) {                                                                     
          constructorToUse = (Constructor) bd.resolvedConstructorOrFactoryMethod;                                   
          if (constructorToUse == null) {                                                                              
             final Class clazz = bd.getBeanClass();                                                                 
             if (clazz.isInterface()) {                                                                                
                throw new BeanInstantiationException(clazz, "Specified class is an interface");                        
             }                                                                                                         
             try {                                                                                                     
                if (System.getSecurityManager() != null) {                                                             
                   constructorToUse = AccessController.doPrivileged(new PrivilegedExceptionAction>() {  
                      @Override                                                                                        
                      public Constructor run() throws Exception {                                                   
                         return clazz.getDeclaredConstructor((Class[]) null);                                          
                      }                                                                                                
                   });                                                                                                 
                }                                                                                                      
                else {                                                                                                 
                   constructorToUse = clazz.getDeclaredConstructor((Class[]) null);                                    
                }                                                                                                      
                bd.resolvedConstructorOrFactoryMethod = constructorToUse;                                              
             }                                                                                                         
             catch (Throwable ex) {                                                                                    
                throw new BeanInstantiationException(clazz, "No default constructor found", ex);                       
             }                                                                                                         
          }                                                                                                            
       }                                                                                                               
       // 利用构造方法进行实例化，反射实例化，这里只是调用默认构造函数，属性并没有赋值                                                                       
       return BeanUtils.instantiateClass(constructorToUse);                                                            
    }                                                                                                                  
    else {                                                                                                             
       // 存在方法覆写，利用 CGLIB 来完成实例化，需要依赖于 CGLIB 生成子类，这里就不展开了                                                              
       return instantiateWithMethodInjection(bd, beanName, owner);                                                     
    }                                                                                                                  
 }                                                                                                                     

 
 
     
  
  • bean属性注入populateBean (), 重点如果属性是跟别的类B组那么这里会调用类B的初始化，并且持有类B的引用，当类B初始化完成时，类A也完成了属性注入了。
    •  
 
 
 
// 省略部分代码                                                                                                    
protected void populateBean(String beanName, RootBeanDefinition mbd, BeanWrapper bw) {                       
   // bean的所有属性                                                                                              
   PropertyValues pvs = mbd.getPropertyValues();                                                             
                                                                                                             
                                                                                                             
   boolean continueWithPropertyPopulation = true;                                                            
   if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {                                    
      for (BeanPostProcessor bp : getBeanPostProcessors()) {                                                 
         if (bp instanceof InstantiationAwareBeanPostProcessor) {                                            
            InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;              
            // 如果返回 false，代表不需要进行后续的属性设值，也不需要再经过其他的 BeanPostProcessor 的处理                                    
            if (!ibp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {                     
               continueWithPropertyPopulation = false;                                                       
               break;                                                                                        
            }                                                                                                
         }                                                                                                   
      }                                                                                                      
   }                                                                                                         
                                                                                                             
   if (!continueWithPropertyPopulation) {                                                                    
      return;                                                                                                
   }                                                                                                         
                                                                                                             
   boolean hasInstAwareBpps = hasInstantiationAwareBeanPostProcessors();                                     
   boolean needsDepCheck = (mbd.getDependencyCheck() != RootBeanDefinition.DEPENDENCY_CHECK_NONE);           
                                                                                                             
   if (hasInstAwareBpps || needsDepCheck) {                                                                  
      PropertyDescriptor[] filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);  
      if (hasInstAwareBpps) {                                                                                
         for (BeanPostProcessor bp : getBeanPostProcessors()) {                                              
            if (bp instanceof InstantiationAwareBeanPostProcessor) {                                         
               InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;           
               // 这里就是上方曾经提到过得对@Autowired处理的一个BeanPostProcessor了                                             
               // 它会对所有标记@Autowired、@Value 注解的属性进行设值                                                         
               pvs = ibp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName);     
               if (pvs == null) {                                                                            
                  return;                                                                                    
               }                                                                                             
            }                                                                                                
         }                                                                                                   
      }                                                                                                      
      if (needsDepCheck) {                                                                                   
         checkDependencies(beanName, mbd, filteredPds, pvs);                                                 
      }                                                                                                      
   }                                                                                                         
   // 设置 bean 实例的属性值                                                                                         
   applyPropertyValues(beanName, mbd, bw, pvs);                                                              
}                                                                                                            
                                                                                                             

 
 
     
  
  • 最终都初始化完成之后，会放到ioc容器councurrent map缓存（DefaultSingletonBeanRegistry.singleObject, key是名称，value是实例对象）
    •  
 
 
 
 
 
单例getBean
 
 
     
  
  • 本质上是从councurrent map缓存获取（DefaultSingletonBeanRegistry.singleObject, key是名称，value是实例对象）
    •  
 
 
 
 
 
循环依赖
 
 
     
  
  • 三种循环依赖：
    •  
 
 
 
     
  
  1. 构造器的循环依赖：这种依赖spring是处理不了的，this .singletonsCurrentlylnCreation.add(beanName）将当前正要创建的bean 记录在缓存中
     Spring 容器将每一个正在创建的bean 标识符放在一个“当前创建bean 池”中， bean 标识
     ：在创建过程中将一直保持在这个池中，因此如果在创建bean 过程中发现自己已经在“当前
     创建bean 池” 里时，将抛出BeanCurrentlylnCreationException 异常表示循环依赖。
    2.  
  
  2. 单例模式下的setter循环依赖：通过“三级缓存”处理循环依赖。
    3.  
  
  3. 非单例循环依赖：对于“prototype”作用域bean无法处理，spirng没有缓存非单例的bean。
    4.  
 
 
 
     
  
  • 单例模式下bean：使用三级缓存
    •  
 
 
 
     
  
  1. singletonFactories ： 进入实例化阶段的单例对象工厂的cache （三级缓存）
    2.  
  
  2. earlySingletonObjects ：完成实例化但是尚未初始化的，提前暴光的单例对象的Cache （二级缓存）
    3.  
  
  3. singletonObjects：完成初始化的单例对象的cache（一级缓存）
    4.  
 
 
 
     
  
  • 分析一下“A的某个field或者setter依赖了B的实例对象，同时B的某个field或者setter依赖了A的实例对象”这种循环依赖的情况。A首先完成了初始化的第一步，并且将自己提前曝光到singletonFactories中，此时进行初始化的第二步，发现自己依赖对象B，此时就尝试去get(B)，发现B还没有被create，所以走create流程，B在初始化第一步的时候发现自己依赖了对象A，于是尝试get(A)，尝试一级缓存singletonObjects(肯定没有，因为A还没初始化完全)，尝试二级缓存earlySingletonObjects（也没有），尝试三级缓存singletonFactories，由于A通过ObjectFactory将自己提前曝光了，所以B能够通过ObjectFactory.getObject拿到A对象(虽然A还没有初始化完全，但是总比没有好呀)，B拿到A对象后顺利完成了初始化阶段1、2、3，完全初始化之后将自己放入到一级缓存singletonObjects中。此时返回A中，A此时能拿到B的对象顺利完成自己的初始化阶段2、3，最终A也完成了初始化，进去了一级缓存singletonObjects中，而且更加幸运的是，由于B拿到了A的对象引用，所以B现在hold住的A对象完成了初始化。
    •  
 
 
 
 
 
占位符替换PropertyPlaceholderConfigurer解析
 
 
  
         
         
  


  
         
             classpath:/application.properties  
         
  



 
 
     
  
  • 步骤 5. 调用 BeanFactoryPostProcessor 各个实现类的 postProcessBeanFactory(factory) 中解析的
    •  
  
  • 最终会调用PlaceholderConfigurerSupport的doProcessProperties()，这个方法就会取出BeanFactory中的BeanDefinition，然后循环处理除了本身以外的bean的占位符替换
    •  
 
 
 
 
 
设计模式
 
 
建造者模式
 
 
     
  
  • BeanDefinitionBuilder创建BeanDefinition
    •  
 
 
 
工厂方法
 
 
     
  
  • 在Spring中，我们可以通过指定的工厂方法创建bean
    •  
 
 
 

    


 
 
代理模式
 
 
     
  
  • spring aop就是用的代理模式，比如jdk动态代理，cglib代理
    •  
 
 
 
策略模式
 
 
     
  
  • 策略定义了通过不同方式完成相同事情的几个对象。完成任务的方式取决于采用的策略。
    •  
  
  • 作为Spring中的每个控制器，MultiActionController（已经过时）执行方法来响应提供的请求。策略用于检测应使用哪种方法。解析过程在MethodNameResolver实现中实现，例如在同一个包中的ParameterMethodNameResolver中。方法可以通过多个条件解决：属性映射，HTTP请求参数或URL路径。
    •  
 
 
 
模版方法
 
 
     
  
  • 此模式定义了类行为的骨架，并将子步骤的某些步骤的延迟执行
    •  
  
  • refresh方法就是个模版方法
    •  
 
 
 
原型模式
 
 
     
  
  • bean作用域的文章中介绍了类似的概念(prototype)
    •  
  
  • 此设计模式允许通过复制已存在的对象来创建一个对象的实例
    •  
 
 
 
public class PrototypeTest {

  @Test
  public void test() {
    Robot firstRobot = new Robot("Droid#1");
    Robot secondRobot = (Robot) firstRobot.clone();
    assertTrue("Cloned robot's instance can't be the same as the"
      +" source robot instance",
      firstRobot != secondRobot);
    assertTrue("Cloned robot's name should be '"+firstRobot.getName()+"'"
      +" but was '"+secondRobot.getName()+"'",
      secondRobot.getName().equals(firstRobot.getName()));
  }

}


class Robot implements Cloneable {
  private String name;

  public Robot(String name) {
    this.name = name;
  }

  public String getName() {
    return this.name;
  }

  protected Object clone() throws CloneNotSupportedException {
    return super.clone();
  }
}

 
 
观察者模式
 
 
     
  
  • 将应用程序的上下文事件分派给适当的监听器的观察者
    •  
  
  • spring发布订阅模式，可以找个例子实际看看，网上比较多，不展开
    •  
 
 
 
单例模式
 
 
     
  
  • 这种比较多，不展开
    •  
 
 
 
适配器
 
 
     
  
  • springmvc使用适配器模式把不同Handler适配在一起统一对外提供功能
    •  
 
 
 
装饰器
 
 
     
  
  • mybatis提供的二级缓存就是用装饰器，装饰一级缓存，对外提供功能
    •  
 
 
 
命令模式
 
 
     
  
  • 它允许将请求封装在一个对象内并附加一个回调动作(每次遇到所所谓的回调大家就只需要理解为一个函数方法就好，省的去浪费那么多脑子)。请求被封装在命令对象之下，而请求的结果被发送到接收者。命令本身不是由调用者执行。
    •  
  
  • 类似于输入linux命令最终都是由终端执行。客户端输入命令。
    •  
  
  • 实践: 我们将多个方法最终执行某个底层方法
    •  
  
  • spring中:
     我要BeanFactory里面得到对象(也就是为了得到一个命令的执行结果)，那么，想要在得到对象的时候就已经实现了一些对其修改的想法，那么就通过后置处理器，也是就实现了后置处理器接口的beans(命令里可以通过传入不同的参数来得到不同结果，或者对命令的脚本进行修改)，然后还需要一个执行者(我们在做自动化运维的时候，不止操作一个脚本，这里的PostProcessorRegistrationDelegate就是集中来管理这些的)，最后得到的结果就由BeanFactory来展示咯
    •  
 
 
 
访问者模式
 
 
     
  
  • 抽象一点就是通过另一种类型的对象来使一个对象访问，需要对一个对象结构中的对象进行很多不同的并且不相关的操作，而需要避免让这些操作"污染"这些对象的类，使用访问者模式将这些封装到类中。
    •  
  
  • 可参考 访问者模式 
    •  
 
 
 
....................................................................................................................................................
 
 
参考文章
 
 
     
  
  1. 最详细的Spring核心IOC的源码分析
    2.  
  
  2. 【一叶知秋】Spring 源码解析五个spring用到的设计模式
    3.  
  
  3. 面试问烂的 Spring IOC 过程，里面getBean分析还可以
    4.  
  
  4. SpringIOC源码解析(上)
    5.  
  
  5. SpringIOC源码解析(下)
    6.  
  
  6. 别再问Spring Bean的生命周期了！
    7.  
  
  7. spring是如何解决循环依赖的
    8.  
  
  8. Spring自定义占位符替换(PropertyPlaceholderConfigurer解析)
    9.  
 
 

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(Spring Ioc源码解析)

        

            

                
    
                    
  • ARM驱动学习之4小结
                        JT灬新一
嵌入式C++arm开发学习linux
                        
    ARM驱动学习之4小结#include#include#include#include#include#defineDEVICE_NAME"hello_ctl123"MODULE_LICENSE("DualBSD/GPL");MODULE_AUTHOR("TOPEET");staticlonghello_ioctl(structfile*file,unsignedintcmd,unsignedlo
    
                    
    • 
                    
  • 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，表示底层数组的实际大小，容器内存储元素的个数不能多于当前容量。当向容器中添
    
                    
    • 
                    
  • SpringCloudAlibaba—Sentinel(限流)
                        菜鸟爪哇

                        
    前言：自己在学习过程的记录，借鉴别人文章，记录自己实现的步骤。借鉴文章：https://blog.csdn.net/u014494148/article/details/105484410Sentinel介绍Sentinel诞生于阿里巴巴，其主要目标是流量控制和服务熔断。Sentinel是通过限制并发线程的数量（即信号隔离）来减少不稳定资源的影响，而不是使用线程池，省去了线程切换的性能开销。当资源
    
                    
    • 
                    
  • springboot+vue项目实战一-创建SpringBoot简单项目
                        苹果酱0567
面试题汇总与解析springboot后端java中间件开发语言
                        
    这段时间抽空给女朋友搭建一个个人博客，想着记录一下建站的过程，就当做笔记吧。虽然复制zjblog只要一个小时就可以搞定一个网站，或者用cms系统，三四个小时就可以做出一个前后台都有的网站，而且想做成啥样也都行。但是就是要从新做，自己做的意义不一样，更何况，俺就是专门干这个的，嘿嘿嘿要做一个网站，而且从零开始，首先呢就是技术选型了，经过一番思量决定选择-SpringBoot做后端，前端使用Vue做一
    
                    
    • 
                    
  • Spring MVC 全面指南：从入门到精通的详细解析
                        一杯梅子酱
技术栈学习springmvcjava
                        
    引言：SpringMVC，作为Spring框架的一个重要模块，为构建Web应用提供了强大的功能和灵活性。无论是初学者还是有一定经验的开发者，掌握SpringMVC都将显著提升你的Web开发技能。本文旨在为初学者提供一个全面且易于理解的学习路径，通过详细的知识点分析和实际案例，帮助你快速上手SpringMVC，让学习过程既深刻又高效。一、SpringMVC简介1.1什么是SpringMVC？Spri
    
                    
    • 
                    
  • 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
    
                    
    • 
                    
  • GenVisR 基因组数据可视化实战(三)
                        11的雾

                        
    3.genCov画每个突变位点附件的coverage，跟igv有点相似。这个操作起来很复杂，但是图还是挺有用的。可以考虑。由于我的referencegenomebuild是hg38BiocManager::install(c("TxDb.Hsapiens.UCSC.hg38.knownGene","BSgenome.Hsapiens.UCSC.hg38"))library(TxDb.Hsapien
    
                    
    • 
                    
  • RabbitMQ生产者重复机制与确认机制
                        java炒饭小能手
java-rabbitmqrabbitmqjava
                        
    重复机制生产者发送消息时，出现了网络故障，导致与MQ的连接中断。为了解决这个问题，SpringAMQP提供的消息发送时的重试机制。即：当RabbitTemplate与MQ连接超时后，多次重试。需要修该发送端模块的application.yaml文件，添加下面的内容：spring:rabbitmq:connection-timeout:1s#设置MQ的连接超时时间template:retry:ena
    
                    
    • 
                    
  • 【Java】已解决：org.springframework.jdbc.datasource.lookup.DataSourceLookupFailureException
                        屿小夏
java开发语言
                        
    文章目录一、分析问题背景问题背景描述出现问题的场景二、可能出错的原因三、错误代码示例四、正确代码示例五、注意事项已解决：org.springframework.jdbc.datasource.lookup.DataSourceLookupFailureException在使用Spring框架进行开发时，数据源的配置和使用是非常关键的一环。然而，有时候我们可能会遇到org.springframewo
    
                    
    • 
                    
  • 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
    
                    
    • 
                    
  • 探索Zebra4J：构建高效企业级Web应用的微服务框架
                        叶准鑫Natalie

                        
    探索Zebra4J：构建高效企业级Web应用的微服务框架ZebraZebra4J/Zebra4Js基于SpringBoot的JavaWeb/Nodejs框架项目地址:https://gitcode.com/gh_mirrors/zebra/Zebra项目介绍在当今快速发展的技术环境中，构建高效、可扩展的企业级Web应用是每个开发团队的追求。Zebra4J作为一款基于SpringBoot的全新微服务
    
                    
    • 
                    
  • 基于JavaWeb开发的Java+SpringMvc+vue+element实现上海汽车博物馆平台
                        网顺技术团队
成品程序项目javavue.js汽车课程设计springboot
                        
    基于JavaWeb开发的Java+SpringMvc+vue+element实现上海汽车博物馆平台作者主页网顺技术团队欢迎点赞收藏⭐留言文末获取源码联系方式查看下方微信号获取联系方式承接各种定制系统精彩系列推荐精彩专栏推荐订阅不然下次找不到哟Java毕设项目精品实战案例《1000套》感兴趣的可以先收藏起来，还有大家在毕设选题，项目以及论文编写等相关问题都可以给我留言咨询，希望帮助更多的人文章目录基
    
                    
    • 
                    
  • 分布式锁和spring事务管理
                        暴躁的鱼
锁及事务分布式springjava
                        
    最近开发一个小程序遇到一个需求需要实现分布式事务管理业务需求用户在使用小程序的过程中可以查看景点，对景点地区或者城市标记是否想去，那么需要统计一个地点被标记的人数，以及记录某个用户对某个地点是否标记为想去，用两个表存储数据，一个地点表记录改地点被标记的次数，一个用户意向表记录某个用户对某个地点是否标记为想去。由于可能有多个用户同时标记一个地点，每个用户在前端点击想去按钮之后，后台接收到请求，从数据
    
                    
    • 
                    
  • SPI机制
                        我们仍未知道那天所看见的猫的名

                        
    1、SPI机制：ServiceProviderInterface：服务提供发现机制，类型IOCJavaSPI实现：ServiceLoader定义接口A；实现接口A的实现类，B和C；在/META-INF/services/下创建文件，文件名为A类的全名称，内容为B和C的类全名调用：ServiceLoaderload=ServiceLoader.load(A.class);Interatori=loa
    
                    
    • 
                    
  • Java面试笔记记录6
                        今天背八股了吗
java面试笔记
                        
    1.Spring是什么？特性？有哪些模块？Spring是一个轻量级、非入侵式的控制反转Ioc和面向切面AOP的框架。特性：1.Ioc和DISpring的核心就是一个大的工厂容器，可以维护所有对象的创建和依赖关系，Spring工厂用于生成Bean，并且管理Bean的生命周期，实现高内聚低耦合的设计理念。2.AOP编程Spring提供面向切面编程，可以方便实现对程序进行权限拦截、运行监控等切面功能。3
    
                    
    • 
                    
  • Sentinel
                        眼泪落在琴弦
springcloudjavajava
                        
    Sentinel（服务熔断降级限流）1.引入spring-cloud-starter-alibaba-sentinel2.下载sentinel服务器3.配置application地址信息4.在控制台调整参数【默认所以流控设置保存在内存中，重启失效】5.想实时监控需每个微服务导入actuator，并配置application暴露所有端口6.自定义sentinel流控返回数据7.配置sentinel类
    
                    
    • 
                    
  • Spring @Async 深度解读：默认线程池执行器的配置与优化
                        小码快撩
springjava前端
                        
    在Spring中，@Async注解用于异步执行方法。默认情况下，@Async注解的任务是由一个线程池执行的。然而，这个默认的线程池是如何初始化的呢？本文将深入探讨这一过程，帮助你理解Spring异步任务背后的线程池执行器的初始化原理。1.@Async的基本使用首先，让我们快速回顾一下@Async的基本用法。@Async通常用于标注在需要异步执行的方法上，比如：@Servicepublicclass
    
                    
    • 
                    
  • Sentinel实时监控不展示问题
                        朱杰jjj
sentinelsentinel
                        
    问题官方插件Endpoint支持，可以实时统计出SpringBoot的健康状况和请求的调用信息在使用Endpoint特性之前需要在Maven中添加spring-boot-starter-actuator依赖，并在配置中允许Endpoints的访问。SpringBoot1.x中添加配置management.security.enabled=false。暴露的endpoint路径为/sentinelS
    
                    
    • 
                    
  • 36. MyBatis如何支持多数据库操作？如何配置不同的数据源？
                        这孩子叫逆
Mybatis笔记mybatis数据库
                        
    在许多企业级应用中，可能需要访问多个数据库。MyBatis可以通过配置多个数据源和动态切换数据源来支持多数据库操作。下面介绍如何在MyBatis中配置和使用多个数据源。1.多数据源的基本配置1.1配置多个数据源要支持多个数据源，首先需要在Spring或SpringBoot中配置不同的数据源。假设我们要连接两个数据库db1和db2，可以通过以下步骤进行配置。SpringBoot示例：applicat
    
                    
    • 
                    
  • SpringBoot整合ES搜索引擎 实现网站热搜词及热度计算
                        码踏云端
springbootElasticsearchspringbootelasticsearch后端热搜词热度计算java
                        
    博主简介：历代文学网（PC端可以访问：https://literature.sinhy.com/#/literature?__c=1000，移动端可微信小程序搜索“历代文学”）总架构师，15年工作经验，精通Java编程，高并发设计，Springboot和微服务，熟悉Linux，ESXI虚拟化以及云原生Docker和K8s，热衷于探索科技的边界，并将理论知识转化为实际应用。保持对新技术的好奇心，乐于
    
                    
    • 
                    
  • Java集合类框架源码分析 之 RoleList源码解析 【6】
                        yunzhonghefei
Java集合类源码分析RoleList源码解析
                        
    该类继承于ArrayList，针对Role进行了一些扩展。其他方法和ArrayList中基本相同，源码不做针对性分析：看一下类简介：/***代表了一个roles的列表，作为方法setRoles()的参数，去创建一个关联关系，并且尝试在同一个关系中设置多个角色。*ARoleListrepresentsalistofroles(Roleobjects).Itisusedas*parameterwhen
    
                    
    • 
                    
  • Spring Security静态资源过滤（11）
                        小黑屋说YYDS
spring
                        
    在一个实际项目中，并非所有的请求都需要经过SpringSecurity过滤器，有一些特殊的请求，例如静态资源等，一般来说并不需要经过SpringSecurity过滤器链，用户如果访问这些静态资源，直接返回对应的资源即可。回顾关于WebSecurity的讲解，提到它里边维护了一个ignoredRequests变量,该变量，记录的就是所有需要被忽略的请求，这些被忽略的请求将不再经过SpringSecu
    
                    
    • 
                    
  • Spring Security定义多个过滤器链（10）
                        小黑屋说YYDS
spring
                        
    在SpringSecurity中可以同时存在多个过滤器链，一个WebSecurityConfigurerAdapter的实例就可以配置一条过滤器链。我们来看如下一个案例：@ConfigurationpublicclassSecurityConfig{@BeanUserDetailsServiceus(){InMemoryUserDetailsManagerusers=newInMemoryUser
    
                    
    • 
                                
  • windows下源码安装golang
                                    616050468
golang安装golang环境windows
                                    
             系统： 64位win7， 开发环境：sublime text 2，  go版本： 1.4.1 
  
 1.  安装前准备(gcc, gdb, git) 
       golang在64位系
    
                                
    • 
                                
  • redis批量删除带空格的key
                                    bylijinnan
redis
                                    
    redis批量删除的通常做法： 
 
 
redis-cli keys "blacklist*" | xargs redis-cli del 
 
上面的命令在key的前后没有空格时是可以的，但有空格就不行了： 
 

$redis-cli keys "blacklist*"
1) "blacklist:12: [email protected]
    
                                
    • 
                                
  • oracle正则表达式的用法
                                    0624chenhong
oracle正则表达式
                                    
      方括号表达示 
方括号表达式 
描述 
[[:alnum:]] 
字母和数字混合的字符 
[[:alpha:]] 
字母字符 
[[:cntrl:]] 
控制字符 
[[:digit:]] 
数字字符 
[[:graph:]] 
图像字符 
[[:lower:]] 
小写字母字符 
[[:print:]] 
打印字符 
[[:punct：]] 
标点符号字符 
[[:space:]]
    
                                
    • 
                                
  • 2048源码(核心算法有，缺少几个anctionbar，以后补上)
                                    不懂事的小屁孩
2048
                                    
    2048游戏基本上有四部分组成， 
1：主activity，包含游戏块的16个方格，上面统计分数的模块 
2：底下的gridview，监听上下左右的滑动，进行事件处理， 
3：每一个卡片，里面的内容很简单，只有一个text，记录显示的数字 
4：Actionbar，是游戏用重新开始，设置等功能(这个在底下可以下载的代码里面还没有实现) 
 
写代码的流程 
1：设计游戏的布局，基本是两块，上面是分
    
                                
    • 
                                
  • jquery内部链式调用机理
                                    换个号韩国红果果
JavaScriptjquery
                                    
    只需要在调用该对象合适(比如下列的setStyles)的方法后让该方法返回该对象（通过this  因为一旦一个函数称为一个对象方法的话那么在这个方法内部this（结合下面的setStyles）指向这个对象） 

function  create(type){
var element=document.createElement(type);
    //this=element;

    
                                
    • 
                                
  • 你订酒店时的每一次点击 背后都是NoSQL和云计算
                                    蓝儿唯美
NoSQL
                                    
    全球最大的在线旅游公司Expedia旗下的酒店预订公司，它运营着89个网站，跨越68个国家，三年前开始实验公有云，以求让客户在预订网站上查询假期酒店时得到更快的信息获取体验。 
云端本身是用于驱动网站的部分小功能的，如搜索框的自动推荐功能，还能保证处理Hotels.com服务的季节性需求高峰整体储能。 
Hotels.com的首席技术官Thierry Bedos上个月在伦敦参加“2015 Clou
    
                                
    • 
                                
  • java笔记1
                                    a-john
java
                                    
    1，面向对象程序设计（Object-oriented Propramming，OOP）：java就是一种面向对象程序设计。 
2，对象：我们将问题空间中的元素及其在解空间中的表示称为“对象”。简单来说，对象是某个类型的实例。比如狗是一个类型，哈士奇可以是狗的一个实例，也就是对象。 
3，面向对象程序设计方式的特性： 
    3.1 万物皆为对象。 
   
    
                                
    • 
                                
  • C语言 sizeof和strlen之间的那些事 C/C++软件开发求职面试题 必备考点（一）
                                    aijuans
C/C++求职面试必备考点
                                    
            找工作在即，以后决定每天至少写一个知识点，主要是记录，逼迫自己动手、总结加深印象。当然如果能有一言半语让他人收益，后学幸运之至也。如有错误，还希望大家帮忙指出来。感激不尽。 
       后学保证每个写出来的结果都是自己在电脑上亲自跑过的，咱人笨，以前学的也半吊子。很多时候只能靠运行出来的结果再反过来
    
                                
    • 
                                
  • 程序员写代码时就不要管需求了吗？
                                    asia007
程序员不能一味跟需求走
                                    
          编程也有2年了，刚开始不懂的什么都跟需求走，需求是怎样就用代码实现就行，也不管这个需求是否合理，是否为较好的用户体验。当然刚开始编程都会这样，但是如果有了2年以上的工作经验的程序员只知道一味写代码，而不在写的过程中思考一下这个需求是否合理，那么，我想这个程序员就只能一辈写敲敲代码了。 
      我的技术不是很好，但是就不代
    
                                
    • 
                                
  • Activity的四种启动模式
                                    百合不是茶
android栈模式启动Activity的标准模式启动栈顶模式启动单例模式启动
                                    
    android界面的操作就是很多个activity之间的切换,启动模式决定启动的activity的生命周期 ; 
  
启动模式xml中配置 
    <activity android:name=".MainActivity" android:launchMode="standard&quo
    
                                
    • 
                                
  • Spring中@Autowired标签与@Resource标签的区别
                                    bijian1013
javaspring@Resource@Autowired@Qualifier
                                    
    Spring不但支持自己定义的@Autowired注解，还支持由JSR-250规范定义的几个注解，如：@Resource、 @PostConstruct及@PreDestroy。 
  
1. @Autowired    @Autowired是Spring 提供的，需导入    Package:org.springframewo
    
                                
    • 
                                
  • Changes Between SOAP 1.1 and SOAP 1.2
                                    sunjing
ChangesEnableSOAP 1.1SOAP 1.2
                                    
    JAX-WS 
SOAP Version 1.2 Part 0: Primer (Second Edition) 
SOAP Version 1.2 Part 1: Messaging Framework (Second Edition) 
SOAP Version 1.2 Part 2: Adjuncts (Second Edition) 
  
Which style of WSDL
    
                                
    • 
                                
  • 【Hadoop二】Hadoop常用命令
                                    bit1129
hadoop
                                    
    以Hadoop运行Hadoop自带的wordcount为例， 
  
hadoop脚本位于/home/hadoop/hadoop-2.5.2/bin/hadoop，需要说明的是，这些命令的使用必须在Hadoop已经运行的情况下才能执行 
  Hadoop HDFS相关命令 
 
  hadoop fs -ls 
 
 列出HDFS文件系统的第一级文件和第一级
    
                                
    • 
                                
  • java异常处理（初级）
                                    白糖_
javaDAOspring虚拟机Ajax
                                    
    从学习到现在从事java开发一年多了，个人觉得对java只了解皮毛，很多东西都是用到再去慢慢学习，编程真的是一项艺术，要完成一段好的代码，需要懂得很多。 
最近项目经理让我负责一个组件开发，框架都由自己搭建，最让我头疼的是异常处理，我看了一些网上的源码，发现他们对异常的处理不是很重视，研究了很久都没有找到很好的解决方案。后来有幸看到一个200W美元的项目部分源码，通过他们对异常处理的解决方案，我终
    
                                
    • 
                                
  • 记录整理-工作问题
                                    braveCS
工作
                                    
    1）那位同学还是CSV文件默认Excel打开看不到全部结果。以为是没写进去。同学甲说文件应该不分大小。后来log一下原来是有写进去。只是Excel有行数限制。那位同学进步好快啊。 
2）今天同学说写文件的时候提示jvm的内存溢出。我马上反应说那就改一下jvm的内存大小。同学说改用分批处理了。果然想问题还是有局限性。改jvm内存大小只能暂时地解决问题，以后要是写更大的文件还是得改内存。想问题要长远啊
    
                                
    • 
                                
  • org.apache.tools.zip实现文件的压缩和解压，支持中文
                                    bylijinnan
apache
                                    
    刚开始用java.util.Zip，发现不支持中文（网上有修改的方法，但比较麻烦） 
后改用org.apache.tools.zip 
org.apache.tools.zip的使用网上有更简单的例子 
下面的程序根据实际需求，实现了压缩指定目录下指定文件的方法 
 



import java.io.BufferedReader;
import java.io.BufferedWrit
    
                                
    • 
                                
  • 读书笔记-4
                                    chengxuyuancsdn
读书笔记
                                    
    1、JSTL 核心标签库标签 
2、避免SQL注入 
3、字符串逆转方法 
4、字符串比较compareTo 
5、字符串替换replace 
6、分拆字符串 
 
 
1、JSTL 核心标签库标签共有13个，
学习资料：http://www.cnblogs.com/lihuiyy/archive/2012/02/24/2366806.html
功能上分为4类：
(1)表达式控制标签：out
    
                                
    • 
                                
  • [物理与电子]半导体教材的一个小问题
                                    comsci
问题
                                    
     
 
      各种模拟电子和数字电子教材中都有这个词汇-空穴 
 
      书中对这个词汇的解释是; 当电子脱离共价键的束缚成为自由电子之后,共价键中就留下一个空位,这个空位叫做空穴 
 
      我现在回过头翻大学时候的教材,觉得这个
    
                                
    • 
                                
  • Flashback Database --闪回数据库
                                    daizj
oracle闪回数据库
                                    
    Flashback 技术是以Undo segment中的内容为基础的， 因此受限于UNDO_RETENTON参数。要使用flashback 的特性，必须启用自动撤销管理表空间。 
在Oracle 10g中， Flash back家族分为以下成员： Flashback Database， Flashback Drop，Flashback Query(分Flashback Query,Flashbac
    
                                
    • 
                                
  • 简单排序:插入排序
                                    dieslrae
插入排序
                                    
    
    public void insertSort(int[] array){
        int temp;
        
        for(int i=1;i<array.length;i++){
            temp = array[i];
            
            for(int k=i-1;k>=0;k--)
    
                                
    • 
                                
  • C语言学习六指针小示例、一维数组名含义，定义一个函数输出数组的内容
                                    dcj3sjt126com
c
                                    
    # include <stdio.h>

int main(void)
{
	int * p; //等价于 int *p 也等价于 int* p;
	int i = 5;
	char ch = 'A';

	//p = 5;	//error
	//p = &ch;	//error
	//p = ch;	//error

	p = &i;		// 
    
                                
    • 
                                
  • centos下php redis扩展的安装配置3种方法
                                    dcj3sjt126com
redis
                                    
    方法一 
1.下载php redis扩展包     代码如下 复制代码    
#wget http://redis.googlecode.com/files/redis-2.4.4.tar.gz     
2 tar -zxvf 解压压缩包，cd /扩展包 （进入扩展包然后 运行phpize 一下是我环境中phpize的目录，/usr/local/php/bin/phpize (一定要
    
                                
    • 
                                
  • 线程池(Executors)
                                    shuizhaosi888
线程池
                                    
    在java类库中，任务执行的主要抽象不是Thread，而是Executor，将任务的提交过程和执行过程解耦 
	public interface Executor {

	    void execute(Runnable command);
	}
 
  
public class RunMain implements Executor{

	@Override
	pub
    
                                
    • 
                                
  • openstack 快速安装笔记
                                    haoningabc
openstack
                                    
    前提是要配置好yum源 
版本icehouse，操作系统redhat6.5 
最简化安装，不要cinder和swift 
三个节点 
172 control节点keystone glance horizon 
173 compute节点nova 
173 network节点neutron 
 

control
/etc/sysctl.conf

net.ipv4.ip_forward =
    
                                
    • 
                                
  • 从c面向对象的实现理解c++的对象（二）
                                    jimmee
C++面向对象虚函数
                                    
    1. 类就可以看作一个struct，类的方法，可以理解为通过函数指针的方式实现的，类对象分配内存时，只分配成员变量的，函数指针并不需要分配额外的内存保存地址。 
2. c++中类的构造函数，就是进行内存分配(malloc)，调用构造函数 
3. c++中类的析构函数，就时回收内存(free) 
4. c++是基于栈和全局数据分配内存的，如果是一个方法内创建的对象，就直接在栈上分配内存了。 
专门在
    
                                
    • 
                                
  • 如何让那个一个div可以拖动
                                    lingfeng520240
html
                                    
    
<!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
    
                                
    • 
                                
  • 第10章 高级事件（中）
                                    onestopweb
事件
                                    
    index.html 
<!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/
    
                                
    • 
                                
  • 计算两个经纬度之间的距离
                                    roadrunners
计算纬度LBS经度距离
                                    
    要解决这个问题的时候，到网上查了很多方案，最后计算出来的都与百度计算出来的有出入。下面这个公式计算出来的距离和百度计算出来的距离是一致的。 
	/**
	 * 
	 * @param longitudeA
	 *            经度A点
	 * @param latitudeA
	 *            纬度A点
	 * @param longitudeB
	 *    
    
                                
    • 
                                
  • 最具争议的10个Java话题
                                    tomcat_oracle
java
                                    
    1、Java8已经到来。什么！？ Java8 支持lambda。哇哦，RIP Scala！   　　随着Java8 的发布，出现很多关于新发布的Java8是否有潜力干掉Scala的争论，最终的结论是远远没有那么简单。Java8可能已经在Scala的lambda的包围中突围，但Java并非是函数式编程王位的真正觊觎者。   　 
　2、Java 9 即将到来   　　 
Oracle早在8月份就发布
    
                                
    • 
                                
  • zoj 3826 Hierarchical Notation(模拟)
                                    阿尔萨斯
rar
                                    
     题目链接：zoj 3826 Hierarchical Notation 
 题目大意：给定一些结构体，结构体有value值和key值，Q次询问，输出每个key值对应的value值。 
 解题思路：思路很简单，写个类词法的递归函数，每次将key值映射成一个hash值，用map映射每个key的value起始终止位置，预处理完了查询就很简单了。 这题是最后10分钟出的，因为没有考虑value为{}的情
    
                                
    •