refresh() -＞ obtainFreshBeanFactory()

最新推荐文章于 2024-07-22 14:15:06 发布
最新推荐文章于 2024-07-22 14:15:06 发布
阅读量92 收藏
点赞数
分类专栏： Spring java 文章标签： java spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/min_chaoxi/article/details/129433427
版权
java 同时被 2 个专栏收录
15 篇文章 0 订阅
订阅专栏
Spring
13 篇文章 0 订阅
订阅专栏

refresh() -> obtainFreshBeanFactory()

  1. 创建容器对象：DefaultListableBeanFactory
  2. 加载xml配置文件的属性值到当前工厂中（将xml中命名空间对象解析为BeanDefinition放入容器对象）
protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
   // 初始化BeanFactory,并进行XML文件读取，并将得到的BeanFactory记录在当前实体的属性中
   refreshBeanFactory();
   // 返回当前实体的beanFactory属性
   return getBeanFactory();
}

refreshBeanFactory()

protected final void refreshBeanFactory() throws BeansException {
		// 如果存在beanFactory，则销毁beanFactory
		if (hasBeanFactory()) {
			destroyBeans();
      //清空当前beanFactory之前赋值的属性并将beanFactor对象引用指向null（如果不为null）
			closeBeanFactory();
		}
		try {
			// 创建DefaultListableBeanFactory对象
			DefaultListableBeanFactory beanFactory = createBeanFactory();
			// 为了序列化指定id，可以从id反序列化到beanFactory对象
			beanFactory.setSerializationId(getId());
			// 定制beanFactory，设置相关属性，包括是否允许覆盖同名称的不同定义的对象以及循环依赖
			customizeBeanFactory(beanFactory);
			// 初始化documentReader,并进行XML文件读取及解析,默认命名空间的解析，自定义标签的解析
			loadBeanDefinitions(beanFactory);
			this.beanFactory = beanFactory;
		}
		catch (IOException ex) {
			throw new ApplicationContextException("I/O error parsing bean definition source for " + getDisplayName(), ex);
		}
	}

customizeBeanFactory()

修改参数默认值设置：

  1. allowBeanDefinitionOverriding：是否允许覆盖同名bean的不同定义的对象
  2. allowCircularReferences：是否允许bean之间存在循环依赖
protected void customizeBeanFactory(DefaultListableBeanFactory beanFactory) {
		// 如果属性allowBeanDefinitionOverriding不为空，设置给beanFactory对象相应属性，是否允许覆盖同名称的不同定义的对象
		if (this.allowBeanDefinitionOverriding != null) {
			beanFactory.setAllowBeanDefinitionOverriding(this.allowBeanDefinitionOverriding);
		}
		// 如果属性allowCircularReferences不为空，设置给beanFactory对象相应属性，是否允许bean之间存在循环依赖
		if (this.allowCircularReferences != null) {
			beanFactory.setAllowCircularReferences(this.allowCircularReferences);
		}
	}

默认情况下this.allowBeanDefinitionOverriding & this.allowCircularReferences为null，将不改变DefaultListableBeanFactory beanFactory中这两个参数的值（默认true）

可重写该方法改变这一现状

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.support.DefaultListableBeanFactory;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class ArminClassPathApplicationContext extends ClassPathXmlApplicationContext {

 public ArminClassPathApplicationContext(String... configLocations) throws BeansException {
     super(configLocations);
 }

 @Override
 protected void customizeBeanFactory(DefaultListableBeanFactory beanFactory) {
     setAllowBeanDefinitionOverriding(false);
     setAllowCircularReferences(false);
     super.customizeBeanFactory(beanFactory);
 }
}

最终结果为beanFactory的allowBeanDefinitionOverriding & allowCircularReferences都将修改为false

loadBeanDefinitions()

初始化documentReader,并进行XML文件读取及解析,默认命名空间的解析，自定义标签的解析

AbstractXmlApplicationContext

protected void loadBeanDefinitions(DefaultListableBeanFactory beanFactory) throws BeansException, IOException {
		// Create a new XmlBeanDefinitionReader for the given BeanFactory.
		// 创建一个xml的beanDefinitionReader，并通过回调设置到beanFactory中
		XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(beanFactory);

		// Configure the bean definition reader with this context's
		// resource loading environment.
		// 给reader对象设置环境对象
		beanDefinitionReader.setEnvironment(this.getEnvironment());
		beanDefinitionReader.setResourceLoader(this);
		beanDefinitionReader.setEntityResolver(new ResourceEntityResolver(this));

		// Allow a subclass to provide custom initialization of the reader,
		// then proceed with actually loading the bean definitions.
		//  初始化beanDefinitionReader对象，此处设置配置文件是否要进行验证
		initBeanDefinitionReader(beanDefinitionReader);
		// 开始完成beanDefinition的加载
		loadBeanDefinitions(beanDefinitionReader);
	}

new ResourceEntityResolver(this)

设置实体（xml对象）资源解析器，并设置需要解析schemas文档标准的本地文件路径

//ResourceEntityResolver
public ResourceEntityResolver(ResourceLoader resourceLoader) {
super(resourceLoader.getClassLoader());
this.resourceLoader = resourceLoader;
}
//DelegatingEntityResolver
public DelegatingEntityResolver(@Nullable ClassLoader classLoader) {
this.dtdResolver = new BeansDtdResolver();
// 当完成这行代码的调用之后，大家神奇的发现一件事情，schemaResolver对象的schemaMappings属性被完成了赋值操作，但是你遍历完成所有代码后依然没有看到显式调用
// 其实此时的原理是非常简单的，我们在进行debug的时候，因为在程序运行期间需要显示当前类的所有信息，所以idea会帮助我们调用toString方法（此处该方法调用了设置方法），只不过此过程我们识别不到而已
this.schemaResolver = new PluggableSchemaResolver(classLoader);
}
//PluggableSchemaResolver
public PluggableSchemaResolver(@Nullable ClassLoader classLoader) {
this.classLoader = classLoader;
this.schemaMappingsLocation = DEFAULT_SCHEMA_MAPPINGS_LOCATION;
}
//DEFAULT_SCHEMA_MAPPINGS_LOCATION
public static final String DEFAULT_SCHEMA_MAPPINGS_LOCATION = "META-INF/spring.schemas";

loadBeanDefinitions

loadBeanDefinitions(XmlBeanDefinitionReader reader)

开始完成beanDefinition的加载

protected void loadBeanDefinitions(XmlBeanDefinitionReader reader) throws BeansException, IOException {
  // 以Resource的方式获得配置文件的资源位置（默认为null，可重写改变这一现状）
  Resource[] configResources = getConfigResources();
  if (configResources != null) {
    reader.loadBeanDefinitions(configResources);
  }
  // 以String的形式获得配置文件的位置
  String[] configLocations = getConfigLocations();
  if (configLocations != null) {
    reader.loadBeanDefinitions(configLocations);
  }
}

getConfigLocations()对应

public ClassPathXmlApplicationContext(
String[] configLocations, boolean refresh, @Nullable ApplicationContext parent)
throws BeansException {
// 调用父类构造方法，进行相关的对象创建等操作,包含属性的赋值操作
super(parent);
setConfigLocations(configLocations);
if (refresh) {
 refresh();
}
}

将获取到指定的xml配置文件

loadBeanDefinitions(String… locations)

循环加载配置文件

public int loadBeanDefinitions(String... locations) throws BeanDefinitionStoreException {
   Assert.notNull(locations, "Location array must not be null");
   int count = 0;
   for (String location : locations) {
      count += loadBeanDefinitions(location);
   }
   return count;
}

loadBeanDefinitions(String location)

public int loadBeanDefinitions(String location) throws BeanDefinitionStoreException {
  return loadBeanDefinitions(location, null);
}

loadBeanDefinitions(String location, @Nullable Set<Resource> actualResources)

将xml文件目的路径转化为Resource对象

public int loadBeanDefinitions(String location, @Nullable Set<Resource> actualResources) throws BeanDefinitionStoreException {
  //此处获取resourceLoader对象
  ResourceLoader resourceLoader = getResourceLoader();
  if (resourceLoader == null) {
    throw new BeanDefinitionStoreException(
      "Cannot load bean definitions from location [" + location + "]: no ResourceLoader available");
  }

  if (resourceLoader instanceof ResourcePatternResolver) {
    // Resource pattern matching available.
    try {
      // 调用DefaultResourceLoader的getResource完成具体的Resource定位
      Resource[] resources = ((ResourcePatternResolver) resourceLoader).getResources(location);
      int count = loadBeanDefinitions(resources);
      if (actualResources != null) {
        Collections.addAll(actualResources, resources);
      }
      if (logger.isTraceEnabled()) {
        logger.trace("Loaded " + count + " bean definitions from location pattern [" + location + "]");
      }
      return count;
    }
    catch (IOException ex) {
      throw new BeanDefinitionStoreException(
        "Could not resolve bean definition resource pattern [" + location + "]", ex);
    }
  }
  else {
    // Can only load single resources by absolute URL.
    Resource resource = resourceLoader.getResource(location);
    int count = loadBeanDefinitions(resource);
    if (actualResources != null) {
      actualResources.add(resource);
    }
    if (logger.isTraceEnabled()) {
      logger.trace("Loaded " + count + " bean definitions from location [" + location + "]");
    }
    return count;
  }

loadBeanDefinitions(Resource… resources)

循环加载转化为Resource的对象

public int loadBeanDefinitions(Resource... resources) throws BeanDefinitionStoreException {
  Assert.notNull(resources, "Resource array must not be null");
  int count = 0;
  for (Resource resource : resources) {
    count += loadBeanDefinitions(resource);
  }
  return count;
}

loadBeanDefinitions(resource)

加载单个Resource对象，EncodedResource主要作用为设置解码相关参数（默认无设置）

public int loadBeanDefinitions(Resource resource) throws BeanDefinitionStoreException {
   return loadBeanDefinitions(new EncodedResource(resource));
}

loadBeanDefinitions(EncodedResource encodedResource)

xml文件读取前的操作

public int loadBeanDefinitions(EncodedResource encodedResource) throws BeanDefinitionStoreException {
   Assert.notNull(encodedResource, "EncodedResource must not be null");
   if (logger.isTraceEnabled()) {
      logger.trace("Loading XML bean definitions from " + encodedResource);
   }

   // 通过属性来记录已经加载的资源
   Set<EncodedResource> currentResources = this.resourcesCurrentlyBeingLoaded.get();

   if (!currentResources.add(encodedResource)) {
      throw new BeanDefinitionStoreException(
            "Detected cyclic loading of " + encodedResource + " - check your import definitions!");
   }

   // 从encodedResource中获取已经封装的Resource对象并再次从Resource中获取其中的inputStream
   try (InputStream inputStream = encodedResource.getResource().getInputStream()) {
      InputSource inputSource = new InputSource(inputStream);
      if (encodedResource.getEncoding() != null) {
         inputSource.setEncoding(encodedResource.getEncoding());
      }
      // 逻辑处理的核心步骤
      return doLoadBeanDefinitions(inputSource, encodedResource.getResource());
   }
   catch (IOException ex) {
      throw new BeanDefinitionStoreException(
            "IOException parsing XML document from " + encodedResource.getResource(), ex);
   }
   finally {
      currentResources.remove(encodedResource);
      if (currentResources.isEmpty()) {
         this.resourcesCurrentlyBeingLoaded.remove();
      }
   }
}

doLoadBeanDefinitions()

  1. 获取xml解析后的文档对象
  2. 从Document对象中获取不同标签（命名空间）中的BeanDefinition（bean定义对象信息）信息并注册
protected int doLoadBeanDefinitions(InputSource inputSource, Resource resource)
      throws BeanDefinitionStoreException {

   try {
      // 此处获取xml文件的document对象，这个解析过程是由documentLoader完成的,从String[] -string-Resource[]- resource,最终开始将resource读取成一个document文档，根据文档的节点信息封装成一个个的BeanDefinition对象
      Document doc = doLoadDocument(inputSource, resource);
      int count = registerBeanDefinitions(doc, resource);
      if (logger.isDebugEnabled()) {
         logger.debug("Loaded " + count + " bean definitions from " + resource);
      }
      return count;
   }
   catch (BeanDefinitionStoreException ex) {
      throw ex;
   }
   catch (SAXParseException ex) {
      throw new XmlBeanDefinitionStoreException(resource.getDescription(),
            "Line " + ex.getLineNumber() + " in XML document from " + resource + " is invalid", ex);
   }
   catch (SAXException ex) {
      throw new XmlBeanDefinitionStoreException(resource.getDescription(),
            "XML document from " + resource + " is invalid", ex);
   }
   catch (ParserConfigurationException ex) {
      throw new BeanDefinitionStoreException(resource.getDescription(),
            "Parser configuration exception parsing XML from " + resource, ex);
   }
   catch (IOException ex) {
      throw new BeanDefinitionStoreException(resource.getDescription(),
            "IOException parsing XML document from " + resource, ex);
   }
   catch (Throwable ex) {
      throw new BeanDefinitionStoreException(resource.getDescription(),
            "Unexpected exception parsing XML document from " + resource, ex);
   }
}

registerBeanDefinitions()

对xml的beanDefinition进行解析注册

public int registerBeanDefinitions(Document doc, Resource resource) throws BeanDefinitionStoreException {
  BeanDefinitionDocumentReader documentReader = createBeanDefinitionDocumentReader();
  int countBefore = getRegistry().getBeanDefinitionCount();
  // 完成具体的beanDefinition解析注册过程
  documentReader.registerBeanDefinitions(doc, createReaderContext(resource));
  return getRegistry().getBeanDefinitionCount() - countBefore;
}

public void registerBeanDefinitions(Document doc, XmlReaderContext readerContext) {
  this.readerContext = readerContext;
  doRegisterBeanDefinitions(doc.getDocumentElement());
}

doRegisterBeanDefinitions()

protected void doRegisterBeanDefinitions(Element root) {
		// Any nested <beans> elements will cause recursion in this method. In
		// order to propagate and preserve <beans> default-* attributes correctly,
		// keep track of the current (parent) delegate, which may be null. Create
		// the new (child) delegate with a reference to the parent for fallback purposes,
		// then ultimately reset this.delegate back to its original (parent) reference.
		// this behavior emulates a stack of delegates without actually necessitating one.
		BeanDefinitionParserDelegate parent = this.delegate;
		this.delegate = createDelegate(getReaderContext(), root, parent);

		if (this.delegate.isDefaultNamespace(root)) {
			String profileSpec = root.getAttribute(PROFILE_ATTRIBUTE);
			if (StringUtils.hasText(profileSpec)) {
				String[] specifiedProfiles = StringUtils.tokenizeToStringArray(
						profileSpec, BeanDefinitionParserDelegate.MULTI_VALUE_ATTRIBUTE_DELIMITERS);
				// We cannot use Profiles.of(...) since profile expressions are not supported
				// in XML config. See SPR-12458 for details.
				if (!getReaderContext().getEnvironment().acceptsProfiles(specifiedProfiles)) {
					if (logger.isDebugEnabled()) {
						logger.debug("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;
	}

parseBeanDefinitions()

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)) {
          // 默认命名空间的解析 bean beans import alias
          parseDefaultElement(ele, delegate);
        }
        else {
          // 自定义命名空间的解析
          delegate.parseCustomElement(ele);
        }
      }
    }
  }
  else {
    delegate.parseCustomElement(root);
  }
}

// 默认命名空间的解析
private void parseDefaultElement(Element ele, BeanDefinitionParserDelegate delegate) {
		if (delegate.nodeNameEquals(ele, IMPORT_ELEMENT)) { // import
			importBeanDefinitionResource(ele);
		}
		else if (delegate.nodeNameEquals(ele, ALIAS_ELEMENT)) { // alias
			processAliasRegistration(ele);
		}
		else if (delegate.nodeNameEquals(ele, BEAN_ELEMENT)) { // bean
			processBeanDefinition(ele, delegate);
		}
		else if (delegate.nodeNameEquals(ele, NESTED_BEANS_ELEMENT)) { // beans
			// recurse
			doRegisterBeanDefinitions(ele);
		}
	}

processBeanDefinition()

bean命名空间的解析

protected void processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) {
  // beanDefinitionHolder是beanDefinition对象的封装类，封装了BeanDefinition，bean的名字和别名，用它来完成向IOC容器的注册
  // 得到这个beanDefinitionHolder就意味着beandefinition是通过BeanDefinitionParserDelegate对xml元素的信息按照spring的bean规则进行
  // 解析得到的
  BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);
  if (bdHolder != null) {
    bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder);
    try {
      // Register the final decorated instance.
      // 向ioc容器注册解析得到的beandefinition的地方
      BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, getReaderContext().getRegistry());
    }
    catch (BeanDefinitionStoreException ex) {
      getReaderContext().error("Failed to register bean definition with name '" +
                               bdHolder.getBeanName() + "'", ele, ex);
    }
    // Send registration event.
    // 在beandefinition向ioc容器注册完成之后，发送消息
    getReaderContext().fireComponentRegistered(new BeanComponentDefinition(bdHolder));
  }
}

BeanDefinitionReaderUtils.registerBeanDefinition()

向ioc容器注册解析得到的beandefinition的地方

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

  // Register bean definition under primary name.
  // 使用beanName做唯一标识注册
  String beanName = definitionHolder.getBeanName();
  registry.registerBeanDefinition(beanName, definitionHolder.getBeanDefinition());

  // Register aliases for bean name, if any.
  // 注册所有的别名
  String[] aliases = definitionHolder.getAliases();
  if (aliases != null) {
    for (String alias : aliases) {
      registry.registerAlias(beanName, alias);
    }
  }
}

registerBeanDefinition()

使用beanName做唯一标识注册 form DefaultListableBeanFactory

public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition)
			throws BeanDefinitionStoreException {

		Assert.hasText(beanName, "Bean name must not be empty");
		Assert.notNull(beanDefinition, "BeanDefinition must not be null");

		if (beanDefinition instanceof AbstractBeanDefinition) {
			try {
				// 注册前的最后一个校验，这里的检验不同于之前的xml文件校验，主要是对应abstractBeanDefinition属性的methodOverrides校验，
				// 检验methodOverrides是否与工厂方法并存或者methodoverrides对应的方法根本不存在
				((AbstractBeanDefinition) beanDefinition).validate();
			}
			catch (BeanDefinitionValidationException ex) {
				throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName,
						"Validation of bean definition failed", ex);
			}
		}

		BeanDefinition existingDefinition = this.beanDefinitionMap.get(beanName);
		// 处理注册已经注册的beanName情况
		if (existingDefinition != null) {
			// 如果对应的beanName已经注册且在配置中配置了bean不允许被覆盖，则抛出异常
			if (!isAllowBeanDefinitionOverriding()) {
				throw new BeanDefinitionOverrideException(beanName, beanDefinition, existingDefinition);
			}
			else if (existingDefinition.getRole() < beanDefinition.getRole()) {
				// e.g. was ROLE_APPLICATION, now overriding with ROLE_SUPPORT or ROLE_INFRASTRUCTURE
				if (logger.isInfoEnabled()) {
					logger.info("Overriding user-defined bean definition for bean '" + beanName +
							"' with a framework-generated bean definition: replacing [" +
							existingDefinition + "] with [" + beanDefinition + "]");
				}
			}
			else if (!beanDefinition.equals(existingDefinition)) {
				if (logger.isDebugEnabled()) {
					logger.debug("Overriding bean definition for bean '" + beanName +
							"' with a different definition: replacing [" + existingDefinition +
							"] with [" + beanDefinition + "]");
				}
			}
			else {
				if (logger.isTraceEnabled()) {
					logger.trace("Overriding bean definition for bean '" + beanName +
							"' with an equivalent definition: replacing [" + existingDefinition +
							"] with [" + beanDefinition + "]");
				}
			}
			this.beanDefinitionMap.put(beanName, beanDefinition);
		}
		else {
			if (hasBeanCreationStarted()) {
				// Cannot modify startup-time collection elements anymore (for stable iteration)
				synchronized (this.beanDefinitionMap) {
					this.beanDefinitionMap.put(beanName, beanDefinition);
					List<String> updatedDefinitions = new ArrayList<>(this.beanDefinitionNames.size() + 1);
					updatedDefinitions.addAll(this.beanDefinitionNames);
					updatedDefinitions.add(beanName);
					this.beanDefinitionNames = updatedDefinitions;
					removeManualSingletonName(beanName);
				}
			}
			else {
				// Still in startup registration phase
				// 注册beanDefinition
				this.beanDefinitionMap.put(beanName, beanDefinition);
				// 记录beanName
				this.beanDefinitionNames.add(beanName);
				removeManualSingletonName(beanName);
			}
			this.frozenBeanDefinitionNames = null;
		}

		if (existingDefinition != null || containsSingleton(beanName)) {
			// 重置所有beanName对应的缓存
			resetBeanDefinition(beanName);
		}
		else if (isConfigurationFrozen()) {
			clearByTypeCache();
		}
	}
Armin_1024
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
5.2、spring-refresh-obtainFreshBeanFactory-parseDefaultElement加载解析bean.vsdx
08-10
本次为spring解析配置文件中spring.xml的过程，并且根据解析的spring.xml中的<bean>节点加载bean到map中。
Spring的refresh()方法相关异常解析
08-28
ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory(); // 准备 BeanFactory 以供 ApplicationContext 使用 prepareBeanFactory(beanFactory); try { // 子类可通过格式此方法来对 ...
spring源码Refresh--obtainFreshBeanFactory()详解
Code-zyc的博客
03-30 694
目录方法的入口：进入到方法里面：refreshBeanFactory()if-elsecreateBeanFactory() 方法的入口： 进入到方法里面： 首先 进入到 refreshBeanFactory() 方法里面 refreshBeanFactory() if-else 这一个就是起到 刷新工程 如果你已经存在了工厂就给你清空 并关闭重新给你整一个。 执行完后 执行后面的 createBeanFactory() 具体我就不点了 主要就是 创建DefaultListableBeanFact
Spring refresh - obtainFreshBeanFactory()
mrathena
10-15 72
博文目录 文章目录前言 前言 obtainFreshBeanFactory() 和主流程关系不大, 主要是获取到 BeanFactory, xml 模式的话, 会在这里读取 BeanDefinition
4.refresh-obtainFreshBeanFactory方法详解
泽济天下的专栏
09-10 115
本文继续分析refresh方法中的obtainBeanFactory方法。
Spring 5 ApplicationContext#refresh() -- obtainFreshBeanFactory()源码解析
qq_30321211的博客
09-09 237
本文分析 AbstractApplicationContext 的 obtainFreshBeanFactory() /** * <p> * 获取新的Bean工厂： * <ol> * <li>调用供子类实现refreshBeanFactory()方法执行实际的配置加载</li> * <li>调用供子类实现的getBeanFactory()方法获取子类提供的Bean工厂</li
①、Spring AnnotationConfigApplicationContext 源码分析(3) ----＞refresh() 大概结构；
yang108666的博客
04-05 402
整个spring 框架最重要的部分就是这个方法了。 这里先讲前面三个方法，后面的方法比较重要的都分开来单独讲。 public void refresh() throws BeansException, IllegalStateException { synchronized (this.startupShutdownMonitor) { // Prepare this context for refreshing. /** * 准备工作： * 设置启动时间、是否激活标识位
spring（六）-------refresh中的obtainFreshBeanFactory方法
qq_37822914的博客
03-04 127
这个方法也很简单首先顾名思义就是得到BeanFactory，并用ConfigurableListableBeanFactory去接收bean工厂。 ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory(); 代码方法如下： protected ConfigurableListableBeanFactory...
Spring源码阅读 -- ＞ BeanFactory的创建
xinyu
02-26 155
Spring-BeanFactory的创建
Spring源码阅读 -- ＞ SpringIOC初始化流程
xinyu
02-26 111
Spring IOC容器初始化
spring源码阅读（二）--ioc容器加载（二）--obtainFreshBeanFactory()；
sxl100323的博客
04-18 60
直接上源码 /** *Tell the subclass to refresh the intern+al bean factory *告诉子类刷新内部bean工厂 */ ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory(); 继续步入得到 refreshBeanFactory(); @Override protected final void refreshBeanFactory() throws BeansE
SpringIoc源码（六）- ApplicationContext（二）- refresh（obtainFreshBeanFactory和StandardEnvironment）
it_lihongmin的博客
12-03 637
目录 1、StandardEnvironment 1）、PropertyResolver（Property相关处理） 2）、Environment（Spring profiles相关处理） 3）、ConfigurablePropertyResolver（类型转换相关ConversionService） 4）、ConfigurableEnvironment 5）、AbstractEnvi...
Spring教程之refresh()执行逻辑浅析
09-07
2. **获取新鲜的Bean工厂(obtainFreshBeanFactory())**： 这是核心步骤之一，它解析配置文件，将bean的信息存储到beanDefinition中，并注册到BeanFactory。但此时bean并未初始化，只是在beanDefinition的映射中存储...
Spring启动流程refresh()源码深入解析
09-07
2. **获取并初始化`BeanFactory` (`obtainFreshBeanFactory()`)** 这一步会创建一个新的`BeanFactory`，通常是`DefaultListableBeanFactory`，并根据配置文件或注解来填充bean的定义。这是Spring容器的基础，用于...
Spring IoC学习之ApplicationContext中refresh过程详解
09-07
接下来，`obtainFreshBeanFactory()` 负责创建或刷新Bean工厂，这是一个至关重要的步骤，因为Bean工厂是Spring管理Bean实例的底层实现。在这个过程中，Spring会解析XML配置文件（如果使用的是基于XML的配置），加载...
12. Hibernate 模板设计模式
最新发布
这是一个web全栈开发的博客，取其精华去其糟粕，争取让大家一看就懂，一学就会，一用就成~
07-22 1092
如何运用模板设计模式重构 Hibernate 操作流程；持久化对象与序列化接口；OOP中有一个编码原则 ：写仅写一次。翻译过来就是，不要重复，要重用。答案是：使用模板设计模式进一步封装Hibernate的操作。在真实项目中，Hibernate仅仅只是完成项目中的一部分工作，需要和其它，如Spring等框架联合工作，一起承担整体项目的开发。Spring框架中就提供的有Hibernate模板对象。一个常规的、频繁的操作代码中，大部分代码不需要变动，只有小部分代码需要根据需求变动。
Java内存模型
weixin_44267758的博客
07-19 768
此处的变量不是指java编程中的变量，它包括了实例字段，静态字段和构成数值对象的元素，但不包括局部变量和方法参数。JMM规定所有变量都存储在主内存中。每条线程有自己的工作内存，工作内存中保留了该线程使用到变量的主内存的副本。线程对变量的所有操作都必须在工作内存中进行，不能直接读写主内存的变量，不同的线程间也无法直接访问对方工作内存的变量，线程之间的变量值传递需要通过主内存来完成。
Promise 详解（原理篇）
山重水复疑无路，柳暗花明又一村。
07-20 740
Promise 是一种异步编程的解决方案。在异步操作中，callback 会导致回调地狱的问题，Promise 解决了这个问题。一个 Promise对象有以下三种状态:pending：初始状态，既不是成功，也不是失败状态。：意味着操作成功完成。rejected：意味着操作失败。当 new Promise() 被实例化后，即表示 Promise 进入 pending 初始化状态，准备就绪，等待运行。
接口防刷！利用redisson快速实现自定义限流注解
架构师小吴的博客
07-18 1311
如登录接口，当用户使用手机号+验证码登录时，一般我们会生成6位数的随机验证码，并将验证码有效期设置为1-3分钟，如果对登录接口不加以限制，理论上，通过技术手段，快速重试100000次，即可将验证码穷举出来。解决思路：对登录接口加上限流操作，如限制一分钟内最多登录5次，登录次数过多，就返回失败提示，或者将账号锁定一段时间。在日常开发中，一些重要的对外接口，需要加上访问频率限制，以免造成资��损失。ok，通过以上两步，即可完成我们的限流注解了，下面通过一个接口验证下效果。
帮我优化一下这段代码 public function checkToken() { # 校验token $cache = Cache::store('redis'); $cacheKey = 'yibutongchengPlatform'; if (!$cache->has($cacheKey)) { $response = $this->getToken(); $cache->put($cacheKey, $response['data']); return $response['data']['access_token']; } $info = $cache->get($cacheKey); $time = time(); if ($info['refresh_expires_time'] - 86400 < $time) { $response = $this->getToken(); $info = $response['data']; $cache->put($cacheKey, $info); } elseif ($info['expires_time'] - 3600 < $time) { $response = $this->refreshToken(); $info = $response['data']; $cache->put($cacheKey, $info); } return $info['access_token']; }
02-19
我能帮你优化一下这段代码：public function checkToken(){ $token = $this->request->get('token'); if($token){ if(checkToken($token)){ return true; } } return false; }
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值