Spring ApplicationContext加载过程的示例分析

这篇文章给大家分享的是有关spring ApplicationContext加载过程的示例分析的内容。小编觉得挺实用的，因此分享给大家做个参考，一起跟随小编过来看看吧。

1、找准入口，使用ClassPathXmlApplicationContext的构造方法加载配置文件，用于加载classPath下的配置文件

//第一行，执行完成之后就完成了spring配置文件的加载，刷新spring上下文ClassPathXmlApplicationContext context=new ClassPathXmlApplicationContext(    "classpath:spring-mvc.xml");//获取实例BeanPerson person=context.getBean("person",Person.class);

2、ClassPathXmlApplicationContext构造方法源码如下：

public ClassPathXmlApplicationContext(String[] configLocations, boolean refresh, ApplicationContext parent)   throws BeansException {  //设置父级的ApplicationContext，null  super(parent);  //1.设置配置文件的路径， 2. 将路径中的占位符${placeholder}使用系统的变量替换  setConfigLocations(configLocations);  if (refresh) {   refresh();  } }

3、主要方法为setConfigLocation(configLocation),这个方法调用其父类AbstractRefreshableConfigApplicationContext中的方法

//locations : 配置文件路径public void setConfigLocations(String[] locations) {  if (locations != null) {   //断言   Assert.noNullElements(locations, "Config locations must not be null");   //存储配置文件路径的数组，存储去掉占位符后的文件路径数组   this.configLocations = new String[locations.length];   //遍历locations，解析占位符   for (int i = 0; i < locations.length; i++) {     //调用resolvePath解析占位符    this.configLocations[i] = resolvePath(locations[i]).trim();   }  }  else {   this.configLocations = null;  } }

4、进入resovePath的源码，实际上执行的是AbstractPropertyResolver的doResolverPlaceholders方法

private String doResolvePlaceholders(String text, PropertyPlaceholderHelper helper) {  //调用PropertyPlaceholderHelper类中的replacePlaceholders方法  return helper.replacePlaceholders(text, new PropertyPlaceholderHelper.PlaceholderResolver() {   public String resolvePlaceholder(String placeholderName) {    return getPropertyAsRawString(placeholderName);   }  }); }

5、进入PropertyHelper的replacePlaceholder方法，实际上调用PropertyPlaceholderHelper的parseStringValue解析占位符

public String replacePlaceholders(String value, PlaceholderResolver placeholderResolver) {  Assert.notNull(value, "Argument 'value' must not be null.");  //调用的是parseStringValue方法  return parseStringValue(value, placeholderResolver, new HashSet<String>()); } protected String parseStringValue(   String strVal, PlaceholderResolver placeholderResolver, Set<String> visitedPlaceholders) {  //将strval转换成StringBuilder，便于后续到操作  StringBuilder buf = new StringBuilder(strVal);  //this.placeholderPrefix这个是占位符的前缀 ${,在创建PropertyHelper的时候就已经指定了占位符的placeholderPrefix="${" ,placeholderSuffix="}",valueSeparator=":" //获取前缀在这个配置文件路径中的开始索引   int startIndex = strVal.indexOf(this.placeholderPrefix);   while (startIndex != -1) {   //占位符前缀在路径中的结束索引   int endIndex = findPlaceholderEndIndex(buf, startIndex);      //如果结束索引存在   if (endIndex != -1) {        //此时取出${plcaeholder}中的占位符内容placeholder    String placeholder = buf.substring(startIndex + this.placeholderPrefix.length(), endIndex);        //保存取出来的占位符内容placeholder    String originalPlaceholder = placeholder;        //如果占位符中的内容已经被访问过了，抛出出异常返回，递归结束的条件    if (!visitedPlaceholders.add(originalPlaceholder)) {     throw new IllegalArgumentException(       "Circular placeholder reference '" + originalPlaceholder + "' in property definitions");    }        //递归解析已经取出的占位符中的内容 palceholder    placeholder = parseStringValue(placeholder, placeholderResolver, visitedPlaceholders);            //这个最重要的一步，将解析占位符内容placeholder的值，比如将java.version转换成1.8.0_60    String propVal = placeholderResolver.resolvePlaceholder(placeholder);        if (propVal == null && this.valueSeparator != null) {     int separatorIndex = placeholder.indexOf(this.valueSeparator);     if (separatorIndex != -1) {      String actualPlaceholder = placeholder.substring(0, separatorIndex);      String defaultValue = placeholder.substring(separatorIndex + this.valueSeparator.length());      propVal = placeholderResolver.resolvePlaceholder(actualPlaceholder);      if (propVal == null) {       propVal = defaultValue;      }     }    }    //如果解析出来的占位符不为空，比如${java.version}将被解析成 1.8.0_60    if (propVal != null) {     //此时继续递归解析出1.8.0_60中的占位符     propVal = parseStringValue(propVal, placeholderResolver, visitedPlaceholders);     //将路径中的占位符替换成系统变量的值，比如将${java.version} 替换成 1.8.0_60     buf.replace(startIndex, endIndex + this.placeholderSuffix.length(), propVal);     if (logger.isTraceEnabled()) {      logger.trace("Resolved placeholder '" + placeholder + "'");     }     //继续在路径字符串中剩余的子串中查找占位符，如果有占位符，那么还会继续解析占位符     startIndex = buf.indexOf(this.placeholderPrefix, startIndex + propVal.length());    }    else if (this.ignoreUnresolvablePlaceholders) {     // Proceed with unprocessed value.     startIndex = buf.indexOf(this.placeholderPrefix, endIndex + this.placeholderSuffix.length());    }    else {     throw new IllegalArgumentException("Could not resolve placeholder '" +       placeholder + "'" + " in string value \"" + strVal + "\"");    }    //将已转换成功的占位符从以访问的集合中移除即可    visitedPlaceholders.remove(originalPlaceholder);   }   else {    startIndex = -1;   }  }   return buf.toString(); //将解析完成之后的配置文件返回 }

6、然后是ClassPathXmlApplicationContext中的refresh方法，实际上调用的是父类AbstractApplicationContext的方法

//刷新spring上下文public void refresh() throws BeansException, IllegalStateException {  synchronized (this.startupShutdownMonitor) {   //在刷新之前设置一些参数，比如设置开始时间戳，上下文是否激活的标志，输出刷新上下文的信息，验证一些必要的属性   prepareRefresh();    //需要创建beanFactory，如果已经存在beanFactory，那么关闭，详细其请看 10   ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();    // 准备上下文工厂，详情见12   prepareBeanFactory(beanFactory);    try {    //允许子类向后置处理器添加组件    postProcessBeanFactory(beanFactory);     // 调用BeanFactoryPostProcessor和BeanDefintionReGIStoryPostProcessor这两个后置处理器    invokeBeanFactoryPostProcessors(beanFactory);     // 注册BeanPostProcessor,用来拦截bean的创建，详情见 14    registerBeanPostProcessors(beanFactory);     //初始化消息源    initMessageSource();     // 初始化应用程序事件广播器，用户可以自定义一个事件广播器，如果用户没有定义，那么使用默认的事件广播器SimpleApplicationEventMulticaster    initApplicationEventMulticaster();     // 在其他子类中初始化bean    onRefresh();     // 检测事件监听器    registerListeners();     //完成实例化剩余的单例(non-lazy-init)    finishBeanFactoryInitialization(beanFactory);     // 完成刷新，初始化生命周期处理器......    finishRefresh();   }    catch (BeansException ex) {    // Destroy already created singletons to avoid dangling resources.    destroyBeans();     // Reset 'active' flag.    cancelRefresh(ex);     // Propagate exception to caller.    throw ex;   }  } }

7、进入obtainFreshBeanFactory方法

//AbastractApplicationContext的方法protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {  //实际刷新上下文的方法，这个方法就是实际的刷新上下文方法，其中会调用loadBeanDefinitions(beanFactory);加载配置文件中的内容到BeanDefiniton中  refreshBeanFactory();  ConfigurableListableBeanFactory beanFactory = getBeanFactory();  if (logger.isDebugEnabled()) {   logger.debug("Bean factory for " + getDisplayName() + ": " + beanFactory);  }  return beanFactory; }   //org.springframework.context.support.AbstractRefreshableApplicationContext中的方法 //AbstractApplicationContext的子类中的方法 @Override protected final void refreshBeanFactory() throws BeansException {  //如果其中有beanfactory，那么销毁  if (hasBeanFactory()) {   destroyBeans();   closeBeanFactory();  }    try {   //重新创建一个beanFactory   DefaultListableBeanFactory beanFactory = createBeanFactory();   //设置序列化id   beanFactory.setSerializationId(getId());      //定制beanFactory，设置相关属性，包括是否允许覆盖名称的不同定义的对象及循环依赖以及   //设置@Autowired和@Qualifier，注解解析器QualifierAnnotationAutowireCandidateResolver   customizeBeanFactory(beanFactory);   //加载BeanDefine 详情见 11   loadBeanDefinitions(beanFactory);   synchronized (this.beanFactoryMonitor) {    this.beanFactory = beanFactory;   }  }  catch (IOException ex) {   throw new ApplicationContextException("I/O error parsing bean definition source for " + getDisplayName(), ex);  } }

8、进入loadBeanDefinitions(beanFactory)方法

 //这个是org.springframework.context.support.AbstractXmlApplicationContext类中的方法 protected void loadBeanDefinitions(DefaultListableBeanFactory beanFactory) throws BeansException, IOException {    //创建要给beanDefinitionReader，用于读取BeanDefinition  XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(beanFactory);   //配置XmlBeanDefinitionReader  beanDefinitionReader.setEnvironment(this.getEnvironment());  beanDefinitionReader.setResourceLoader(this);   beanDefinitionReader.setEntityResolver(new ResourceEntityResolver(this));   initBeanDefinitionReader(beanDefinitionReader);  //加载BeanDefiniton，主要的功能从配置文件中读取BeanDefiniton注册到注册表中  loadBeanDefinitions(beanDefinitionReader); }

9、prepareBeanFactory:准备BeanFactory

//准备BeanFactory，设置一些参数，比如后置处理器，protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {  //设置类加载器  beanFactory.setBeanClassLoader(getClassLoader());   //设置表达式解析器，用来解析BeanDefiniton中的带有表达式的值  beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader()));     beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, getEnvironment()));   // 配置后置处理器，主要的作用就是在spring实例化bean的前后做一些操作  beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));    //忽略自动装配的类，这些类都不能使用@Resource或者@Autowired自动装配获取对象  beanFactory.ignoreDependencyInterface(EnvironmentAware.class);  beanFactory.ignoreDependencyInterface(EmbeddedValueResolverAware.class);  beanFactory.ignoreDependencyInterface(ResourceLoaderAware.class);  beanFactory.ignoreDependencyInterface(ApplicationEventPublisherAware.class);  beanFactory.ignoreDependencyInterface(MessageSourceAware.class);  beanFactory.ignoreDependencyInterface(ApplicationContextAware.class);   //注册可解析的自动装配类  beanFactory.registerResolvableDependency(BeanFactory.class, beanFactory);  beanFactory.registerResolvableDependency(ResourceLoader.class, this);  beanFactory.registerResolvableDependency(ApplicationEventPublisher.class, this);  beanFactory.registerResolvableDependency(ApplicationContext.class, this);   //在添加一个应用程序监听器  beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(this));   //检查这些类是否被  if (beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {   beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));    beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));  }   // 将下面这些类注册到容器中，使用registerSingleton方法注册，我们可以直接从容器中获取这些类的对象使用  if (!beanFactory.containsLocalBean(ENVIRONMENT_BEAN_NAME)) {   beanFactory.registerSingleton(ENVIRONMENT_BEAN_NAME, getEnvironment());  }  if (!beanFactory.containsLocalBean(SYSTEM_PROPERTIES_BEAN_NAME)) {   beanFactory.registerSingleton(SYSTEM_PROPERTIES_BEAN_NAME, getEnvironment().getSystemProperties());  }  if (!beanFactory.containsLocalBean(SYSTEM_ENVIRONMENT_BEAN_NAME)) {   beanFactory.registerSingleton(SYSTEM_ENVIRONMENT_BEAN_NAME, getEnvironment().getSystemEnvironment());  } }

10、调用BeanFactory的后置处理器，主要的功能就是调用注册在容器中的BeanFactoryPostProcessor和BeanDefinitionRegistoryPostProcessor

//实例化和调用BeanFactory后置处理器，必须在单例实例化之前调用protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) {  //调用后置处理器注册委托类的方法调用，getBeanFactoryPostProcessors用于获取注册的全部的BeanFactoryPostProcessor  PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, getBeanFactoryPostProcessors()); } //实际的调用方法，PostProcessorRegistrationDelegate中的方法public static void invokeBeanFactoryPostProcessors(   ConfigurableListableBeanFactory beanFactory, List<BeanFactoryPostProcessor> beanFactoryPostProcessors) {   // Invoke BeanDefinitionRegistryPostProcessors first, if any.  Set<String> processedBeans = new HashSet<String>();    //如果beanFactory是BeanDefinitionRegistry的子类，BeanDefinitionRegistry使用来向注册表中注册Bean的元信息的(BeanDefintion)  if (beanFactory instanceof BeanDefinitionRegistry) {   BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;      //存放BeanFactoryPostProcessor   List<BeanFactoryPostProcessor> regularPostProcessors = new LinkedList<BeanFactoryPostProcessor>();      //存放BeanDefinitionRegistryPostProcessor   List<BeanDefinitionRegistryPostProcessor> registryPostProcessors =     new LinkedList<BeanDefinitionRegistryPostProcessor>();      //遍历。判断是否是BeanDefinitionRegistryPostProcessor实例   for (BeanFactoryPostProcessor postProcessor : beanFactoryPostProcessors) {    if (postProcessor instanceof BeanDefinitionRegistryPostProcessor) {     BeanDefinitionRegistryPostProcessor registryPostProcessor =       (BeanDefinitionRegistryPostProcessor) postProcessor;           //调用BeanDefinitionRegistryPostProcessor     registryPostProcessor.postProcessBeanDefinitionRegistry(registry);     //添加     registryPostProcessors.add(registryPostProcessor);    }    else {     //表示这个是BeanFactoryPostProcessor实例，添加进集合     regularPostProcessors.add(postProcessor);    }   }    //--- 根据类型类型获取beanFactory中注册的BeanDefinitionRegistryPostProcessor的bean的所有名称数组   String[] postProcessorNames =     beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);    // ---- 首先调用的是BeanDefinitionRegistryPostProcessor类型的后置处理器      //存放实现PriorityOrdered这个接口的BeanDefinitionRegistryPostProcessor   List<BeanDefinitionRegistryPostProcessor> priorityOrderedPostProcessors = new ArrayList<BeanDefinitionRegistryPostProcessor>();      //遍历，如果实现了PriorityOrdered这个接口就保存下来   for (String ppName : postProcessorNames) {    if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {     priorityOrderedPostProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));     processedBeans.add(ppName);    }   }      //按照优先级排序   OrderComparator.sort(priorityOrderedPostProcessors);   //添加进入集合   registryPostProcessors.addAll(priorityOrderedPostProcessors);      //首先调用实现PriorityOrdered这个接口的BeanDefinitionRegistryPostProcessor   invokeBeanDefinitionRegistryPostProcessors(priorityOrderedPostProcessors, registry);    // ---- 下面是调用实现Orderd这个接口的BeanDefinitionRegistryPostProcessor   postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);   List<BeanDefinitionRegistryPostProcessor> orderedPostProcessors = new ArrayList<BeanDefinitionRegistryPostProcessor>();   for (String ppName : postProcessorNames) {    if (!processedBeans.contains(ppName) && beanFactory.isTypeMatch(ppName, Ordered.class)) {     orderedPostProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));     processedBeans.add(ppName);    }   }   OrderComparator.sort(orderedPostProcessors);   registryPostProcessors.addAll(orderedPostProcessors);   invokeBeanDefinitionRegistryPostProcessors(orderedPostProcessors, registry);       // ---- 最终调用剩余全部的BeanDefinitionRegistryPostProcessor      boolean reiterate = true;   while (reiterate) {    reiterate = false;    postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);    for (String ppName : postProcessorNames) {     if (!processedBeans.contains(ppName)) {      BeanDefinitionRegistryPostProcessor pp = beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class);      registryPostProcessors.add(pp);      processedBeans.add(ppName);      pp.postProcessBeanDefinitionRegistry(registry);      reiterate = true;     }    }   }    // 调用BeanFactoryPostProcessor接口中的方法，因为BeanDefitionRegistory继承了这个接口   invokeBeanFactoryPostProcessors(registryPostProcessors, beanFactory);   invokeBeanFactoryPostProcessors(regularPostProcessors, beanFactory);  }   else {   // Invoke factory processors registered with the context instance.   invokeBeanFactoryPostProcessors(beanFactoryPostProcessors, beanFactory);  }   //--- 下面是调用实现BeanFactoryPostProcessor接口的类，和上面的流程一样  String[] postProcessorNames =    beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false);   // Separate between BeanFactoryPostProcessors that implement PriorityOrdered,  // Ordered, and the rest.  List<BeanFactoryPostProcessor> priorityOrderedPostProcessors = new ArrayList<BeanFactoryPostProcessor>();  List<String> orderedPostProcessorNames = new ArrayList<String>();  List<String> nonOrderedPostProcessorNames = new ArrayList<String>();  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);   }  }   // First, invoke the BeanFactoryPostProcessors that implement PriorityOrdered.  OrderComparator.sort(priorityOrderedPostProcessors);  invokeBeanFactoryPostProcessors(priorityOrderedPostProcessors, beanFactory);   // Next, invoke the BeanFactoryPostProcessors that implement Ordered.  List<BeanFactoryPostProcessor> orderedPostProcessors = new ArrayList<BeanFactoryPostProcessor>();  for (String postProcessorName : orderedPostProcessorNames) {   orderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));  }  OrderComparator.sort(orderedPostProcessors);  invokeBeanFactoryPostProcessors(orderedPostProcessors, beanFactory);   // Finally, invoke all other BeanFactoryPostProcessors.  List<BeanFactoryPostProcessor> nonOrderedPostProcessors = new ArrayList<BeanFactoryPostProcessor>();  for (String postProcessorName : nonOrderedPostProcessorNames) {   nonOrderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));  }  invokeBeanFactoryPostProcessors(nonOrderedPostProcessors, beanFactory); }

11、注册BeanPostProcessor，用来拦截Bean的创建，这个接口可以实现在Bean初始化和初始化之后执行相关的操作

//依然这里依然调用的PostProcessorRegistrationDelegate，其中包含了注册后置处理器和调用后置处理器的方法，相当于一个代理人protected void registerBeanPostProcessors(ConfigurableListableBeanFactory beanFactory) {  PostProcessorRegistrationDelegate.registerBeanPostProcessors(beanFactory, this); } //PostProcessorRegistrationDelegate中的注册BeanPostProcessors的方法//其中beanFactory这个新创建的beanFactory，其中的BeanPostProcessor都没有注册，applicationContext这个是之前创建的，其中的处理器已经注册过了public static void registerBeanPostProcessors(   ConfigurableListableBeanFactory beanFactory, AbstractApplicationContext applicationContext) {    //根据类型新加载全部的BeanFactoryProcessor的类，  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<BeanPostProcessor> priorityOrderedPostProcessors = new ArrayList<BeanPostProcessor>();  List<BeanPostProcessor> internalPostProcessors = new ArrayList<BeanPostProcessor>();  List<String> orderedPostProcessorNames = new ArrayList<String>();  List<String> nonOrderedPostProcessorNames = new ArrayList<String>();  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);   }  }   // First, register the BeanPostProcessors that implement PriorityOrdered.  OrderComparator.sort(priorityOrderedPostProcessors);  registerBeanPostProcessors(beanFactory, priorityOrderedPostProcessors);   // Next, register the BeanPostProcessors that implement Ordered.  List<BeanPostProcessor> orderedPostProcessors = new ArrayList<BeanPostProcessor>();  for (String ppName : orderedPostProcessorNames) {   BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);   orderedPostProcessors.add(pp);   if (pp instanceof MergedBeanDefinitionPostProcessor) {    internalPostProcessors.add(pp);   }  }  OrderComparator.sort(orderedPostProcessors);  registerBeanPostProcessors(beanFactory, orderedPostProcessors);   // Now, register all regular BeanPostProcessors.  List<BeanPostProcessor> nonOrderedPostProcessors = new ArrayList<BeanPostProcessor>();  for (String ppName : nonOrderedPostProcessorNames) {   BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);   nonOrderedPostProcessors.add(pp);   if (pp instanceof MergedBeanDefinitionPostProcessor) {    internalPostProcessors.add(pp);   }  }  registerBeanPostProcessors(beanFactory, nonOrderedPostProcessors);   // Finally, re-register all internal BeanPostProcessors.  OrderComparator.sort(internalPostProcessors);  registerBeanPostProcessors(beanFactory, internalPostProcessors);   beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(applicationContext)); }

感谢各位的阅读！关于“Spring ApplicationContext加载过程的示例分析”这篇文章就分享到这里了，希望以上内容可以对大家有一定的帮助，让大家可以学到更多知识，如果觉得文章不错，可以把它分享出去让更多的人看到吧！