开发前端软件素材源码教程下载网站

全部
网站模板
网页特效
网站源码
素材资源
建站学院
软件工具
mysql mysql 微信 微信 小程序 苹果 dedecms 修真图
当前位置：首页 > 建站学院 > 其他教程 >  SpringBoot源码之Bean的生命周期是什么

SpringBoot源码之Bean的生命周期是什么

其他教程   发布日期：2025年02月14日   浏览次数：241次

本文小编为大家详细介绍“SpringBoot源码之Bean的生命周期是什么”，内容详细，步骤清晰，细节处理妥当，希望这篇“SpringBoot源码之Bean的生命周期是什么”文章能帮助大家解决疑惑，下面跟着小编的思路慢慢深入，一起来学习新知识吧。

入口方法为SpringApplication#run()

1.

  1. SpringApplication#run()
  1. /**
  2. 	 * Run the Spring application, creating and refreshing a new
  3. 	 * {@link ApplicationContext}.
  4. 	 * @param args the application arguments (usually passed from a Java main method)
  5. 	 * @return a running {@link ApplicationContext}
  6. 	 */
  7. 	public ConfigurableApplicationContext run(String... args) {
  8. 		long startTime = System.nanoTime();
  9. 		DefaultBootstrapContext bootstrapContext = createBootstrapContext();
  10. 		ConfigurableApplicationContext context = null;
  11. 		configureHeadlessProperty();
  12. 		SpringApplicationRunListeners listeners = getRunListeners(args);
  13. 		listeners.starting(bootstrapContext, this.mainApplicationClass);
  14. 		try {
  15. 			ApplicationArguments applicationArguments = new DefaultApplicationArguments(args);
  16. 			ConfigurableEnvironment environment = prepareEnvironment(listeners, bootstrapContext, applicationArguments);
  17. 			Banner printedBanner = printBanner(environment);
  18. 			context = createApplicationContext();
  19. 			context.setApplicationStartup(this.applicationStartup);
  20. 			prepareContext(bootstrapContext, context, environment, listeners, applicationArguments, printedBanner);
  21. 			refreshContext(context);
  22. 			afterRefresh(context, applicationArguments);
  23. 			Duration timeTakenToStartup = Duration.ofNanos(System.nanoTime() - startTime);
  24. 			if (this.logStartupInfo) {
  25. 				new StartupInfoLogger(this.mainApplicationClass).logStarted(getApplicationLog(), timeTakenToStartup);
  26. 			}
  27. 			listeners.started(context, timeTakenToStartup);
  28. 			callRunners(context, applicationArguments);
  29. 		}
  30. 		catch (Throwable ex) {
  31. 			if (ex instanceof AbandonedRunException) {
  32. 				throw ex;
  33. 			}
  34. 			handleRunFailure(context, ex, listeners);
  35. 			throw new IllegalStateException(ex);
  36. 		}
  37. 		try {
  38. 			if (context.isRunning()) {
  39. 				Duration timeTakenToReady = Duration.ofNanos(System.nanoTime() - startTime);
  40. 				listeners.ready(context, timeTakenToReady);
  41. 			}
  42. 		}
  43. 		catch (Throwable ex) {
  44. 			if (ex instanceof AbandonedRunException) {
  45. 				throw ex;
  46. 			}
  47. 			handleRunFailure(context, ex, null);
  48. 			throw new IllegalStateException(ex);
  49. 		}
  50. 		return context;
  51. 	}

2.

  1. SpringApplication#run()=> SpringApplication#refreshContext(context)=> SpringApplication#refresh(context)=>ConfigurableApplicationContext#refresh()=>AbstractApplicationContext#refresh()
  1. @Override
  2. 	public void refresh() throws BeansException, IllegalStateException {
  3. 		synchronized (this.startupShutdownMonitor) {
  4. 			StartupStep contextRefresh = this.applicationStartup.start("spring.context.refresh");
  6. 			// Prepare this context for refreshing.
  7. 			prepareRefresh();
  9. 			// Tell the subclass to refresh the internal bean factory.
  10. 			ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
  12. 			// Prepare the bean factory for use in this context.
  13. 			prepareBeanFactory(beanFactory);
  15. 			try {
  16. 				// Allows post-processing of the bean factory in context subclasses.
  17. 				postProcessBeanFactory(beanFactory);
  19. 				StartupStep beanPostProcess = this.applicationStartup.start("spring.context.beans.post-process");
  20. 				// Invoke factory processors registered as beans in the context.
  21. 				invokeBeanFactoryPostProcessors(beanFactory);
  23. 				// Register bean processors that intercept bean creation.
  24. 				registerBeanPostProcessors(beanFactory);
  25. 				beanPostProcess.end();
  27. 				// Initialize message source for this context.
  28. 				initMessageSource();
  30. 				// Initialize event multicaster for this context.
  31. 				initApplicationEventMulticaster();
  33. 				// Initialize other special beans in specific context subclasses.
  34. 				onRefresh();
  36. 				// Check for listener beans and register them.
  37. 				registerListeners();
  39. 				// Instantiate all remaining (non-lazy-init) singletons.
  40. 				finishBeanFactoryInitialization(beanFactory);
  42. 				// Last step: publish corresponding event.
  43. 				finishRefresh();
  44. 			}
  46. 			catch (BeansException ex) {
  47. 				if (logger.isWarnEnabled()) {
  48. 					logger.warn("Exception encountered during context initialization - " +
  49. 							"cancelling refresh attempt: " + ex);
  50. 				}
  52. 				// Destroy already created singletons to avoid dangling resources.
  53. 				destroyBeans();
  55. 				// Reset 'active' flag.
  56. 				cancelRefresh(ex);
  58. 				// Propagate exception to caller.
  59. 				throw ex;
  60. 			}
  62. 			finally {
  63. 				// Reset common introspection caches in Spring's core, since we
  64. 				// might not ever need metadata for singleton beans anymore...
  65. 				resetCommonCaches();
  66. 				contextRefresh.end();
  67. 			}
  68. 		}
  69. 	}

3.

  1. SpringApplication#run()=> SpringApplication#refreshContext(context)=> SpringApplication#refresh(context)=>ConfigurableApplicationContext#refresh()=>AbstractApplicationContext#refresh()=>AbstractApplicationContext#finishBeanFactoryInitialization()=>ConfigurableListableBeanFactory#preInstantiateSingletons()=>DefaultListableBeanFactory#preInstantiateSingletons()
  1. @Override
  2. 	public void preInstantiateSingletons() throws BeansException {
  3. 		if (logger.isTraceEnabled()) {
  4. 			logger.trace("Pre-instantiating singletons in " + this);
  5. 		}
  7. 		// Iterate over a copy to allow for init methods which in turn register new bean definitions.
  8. 		// While this may not be part of the regular factory bootstrap, it does otherwise work fine.
  9. 		List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);
  11. 		// Trigger initialization of all non-lazy singleton beans...
  12. 		for (String beanName : beanNames) {
  13. 			RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
  14. 			if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
  15. 				if (isFactoryBean(beanName)) {
  16. 					Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
  17. 					if (bean instanceof SmartFactoryBean<?> smartFactoryBean && smartFactoryBean.isEagerInit()) {
  18. 						getBean(beanName);
  19. 					}
  20. 				}
  21. 				else {
  22. 					// 此处就是初始化bean的方法
  23. 					getBean(beanName);
  24. 				}
  25. 			}
  26. 		}
  28. 		// Trigger post-initialization callback for all applicable beans...
  29. 		for (String beanName : beanNames) {
  30. 			// 此处就是解决循环依赖的代码
  31. 			Object singletonInstance = getSingleton(beanName);
  32. 			if (singletonInstance instanceof SmartInitializingSingleton smartSingleton) {
  33. 				StartupStep smartInitialize = this.getApplicationStartup().start("spring.beans.smart-initialize")
  34. 						.tag("beanName", beanName);
  35. 				smartSingleton.afterSingletonsInstantiated();
  36. 				smartInitialize.end();
  37. 			}
  38. 		}
  39. 	}

解决循环依赖的代码如下：

  1. protected Object getSingleton(String beanName, boolean allowEarlyReference) {
  2. // 尝试从缓存中获取成品的目标对象，如果存在，则直接返回
  3.   Object singletonObject = this.singletonObjects.get(beanName);
  4.   // 如果缓存中不存在目标对象，则判断当前对象是否已经处于创建过程中，在前面的讲解中，第一次尝试获取A对象
  5.   // 的实例之后，就会将A对象标记为正在创建中，因而最后再尝试获取A对象的时候，这里的if判断就会为true
  6.   if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
  7.     synchronized (this.singletonObjects) {
  8.       singletonObject = this.earlySingletonObjects.get(beanName);
  9.       if (singletonObject == null && allowEarlyReference) {
  10.         // 这里的singletonFactories是一个Map，其key是bean的名称，而值是一个ObjectFactory类型的
  11.         // 对象，这里对于A和B而言，调用图其getObject()方法返回的就是A和B对象的实例，无论是否是半成品
  12.         ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
  13.         if (singletonFactory != null) {
  14.           // 获取目标对象的实例
  15.           singletonObject = singletonFactory.getObject();
  16.           this.earlySingletonObjects.put(beanName, singletonObject);
  17.           this.singletonFactories.remove(beanName);
  18.         }
  19.       }
  20.     }
  21.   }
  22.   return singletonObject;
  23. }

  • 一级缓存，singletonObjects 单例缓存，存储已经实例化的单例bean。

  • 二级缓存，earlySingletonObjects 提前暴露的单例缓存，这里存储的bean是刚刚构造完成，但还会通过属性注入bean。

  • 三级缓存，singletonFactories 生产单例的工厂缓存，存储工厂。

解决原理如下：

  • 在第一层中，先去获取 A 的 Bean，发现没有就准备去创建一个，然后将 A 的代理工厂放入“三级缓存”（这个 A 其实是一个半成品，还没有对里面的属性进行注入），但是 A 依赖 B 的创建，就必须先去创建 B；

  • 在第二层中，准备创建 B，发现 B 又依赖 A，需要先去创建 A，去创建 A，因为第一层已经创建了 A 的代理工厂，直接从“三级缓存”中拿到 A 的代理工厂，获取 A 的代理对象，放入“二级缓存”，并清除“三级缓存”；

  • 有了 A 的代理对象，对 A 的依赖完美解决（这里的 A 仍然是个半成品），B 初始化成功。在 B 初始化成功，完成 A 对象的属性注入，然后再填充 A 的其它属性，以及 A 的其它步骤（包括 AOP），完成对 A 完整的初始化功能（这里的 A 才是完整的 Bean）。

  • 将 A 放入“一级缓存”。

4.

  1. SpringApplication#run()=> SpringApplication#refreshContext(context)=> SpringApplication#refresh(context)=>ConfigurableApplicationContext#refresh()=>AbstractApplicationContext#refresh()=>AbstractApplicationContext#finishBeanFactoryInitialization()=>ConfigurableListableBeanFactory#preInstantiateSingletons()=>DefaultListableBeanFactory#preInstantiateSingletons()=>AbstractBeanFactory#getBean() => AbstractBeanFactory#doGetBean()=>AbstractBeanFactory#createBean()=>AbstractAutowireCapableBeanFactory#createBean()=>AbstractAutowireCapableBeanFactory#doCreateBean()

bean的生命周期：

1.调用InstantiationAwareBeanPostProcessor# postProcessBeforeInstantiation
跟进doCreateBean()

  1. @Override  
  2. protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)  
  3.       throws BeanCreationException {  
  4.   
  5.    if (logger.isTraceEnabled()) {  
  6.       logger.trace("Creating instance of bean '" + beanName + "'");  
  7.    }  
  8.    RootBeanDefinition mbdToUse = mbd;  
  9.   
  10.    // Make sure bean class is actually resolved at this point, and  
  11.    // clone the bean definition in case of a dynamically resolved Class   // which cannot be stored in the shared merged bean definition.   Class<?> resolvedClass = resolveBeanClass(mbd, beanName);  
  12.    if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {  
  13.       mbdToUse = new RootBeanDefinition(mbd);  
  14.       mbdToUse.setBeanClass(resolvedClass);  
  15.    }  
  16.   
  17.    // Prepare method overrides.  
  18.    try {  
  19.       mbdToUse.prepareMethodOverrides();  
  20.    }  
  21.    catch (BeanDefinitionValidationException ex) {  
  22.       throw new BeanDefinitionStoreException(mbdToUse.getResourceDescription(),  
  23.             beanName, "Validation of method overrides failed", ex);  
  24.    }  
  25.   
  26.    try {  
  27.       // 1.调用InstantiationAwareBeanPostProcessor# postProcessBeforeInstantiation
  28.       Object bean = resolveBeforeInstantiation(beanName, mbdToUse);  
  29.       if (bean != null) {  
  30.          return bean;  
  31.       }  
  32.    }  
  33.    catch (Throwable ex) {  
  34.       throw new BeanCreationException(mbdToUse.getResourceDescription(), beanName,  
  35.             "BeanPostProcessor before instantiation of bean failed", ex);  
  36.    }  
  37.   
  38.    try {  
  39. 	  // 跟进doCreateBean()
  40.       Object beanInstance = doCreateBean(beanName, mbdToUse, args);  
  41.       if (logger.isTraceEnabled()) {  
  42.          logger.trace("Finished creating instance of bean '" + beanName + "'");  
  43.       }  
  44.       return beanInstance;  
  45.    }  
  46.    catch (BeanCreationException | ImplicitlyAppearedSingletonException ex) {  
  47.       // A previously detected exception with proper bean creation context already,  
  48.       // or illegal singleton state to be communicated up to DefaultSingletonBeanRegistry.      throw ex;  
  49.    }  
  50.    catch (Throwable ex) {  
  51.       throw new BeanCreationException(  
  52.             mbdToUse.getResourceDescription(), beanName, "Unexpected exception during bean creation", ex);  
  53.    }  
  54. }

2.创建bean实例

跟进populateBean()
跟进initializeBean()

  1. protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)  
  2.       throws BeanCreationException {  
  3.   
  4.    // Instantiate the bean.  
  5.    BeanWrapper instanceWrapper = null;  
  6.    if (mbd.isSingleton()) {  
  7.       instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);  
  8.    }  
  9.    if (instanceWrapper == null) { 
  10. 	  // 2.创建bean实例 
  11.       instanceWrapper = createBeanInstance(beanName, mbd, args);  
  12.    }  
  13.    Object bean = instanceWrapper.getWrappedInstance();  
  14.    Class<?> beanType = instanceWrapper.getWrappedClass();  
  15.    if (beanType != NullBean.class) {  
  16.       mbd.resolvedTargetType = beanType;  
  17.    }  
  18.   
  19.    // Allow post-processors to modify the merged bean definition.  
  20.    synchronized (mbd.postProcessingLock) {  
  21.       if (!mbd.postProcessed) {  
  22.          try {
  23.             applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);  
  24.          }  
  25.          catch (Throwable ex) {  
  26.             throw new BeanCreationException(mbd.getResourceDescription(), beanName,  
  27.                   "Post-processing of merged bean definition failed", ex);  
  28.          }  
  29.          mbd.markAsPostProcessed();  
  30.       }  
  31.    }  
  32.   
  33.    // Eagerly cache singletons to be able to resolve circular references  
  34.    // even when triggered by lifecycle interfaces like BeanFactoryAware.   boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&  
  35.          isSingletonCurrentlyInCreation(beanName));  
  36.    if (earlySingletonExposure) {  
  37.       if (logger.isTraceEnabled()) {  
  38.          logger.trace("Eagerly caching bean '" + beanName +  
  39.                "' to allow for resolving potential circular references");  
  40.       }  
  41.       addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));  
  42.    }  
  43.   
  44.    // Initialize the bean instance.  
  45.    Object exposedObject = bean;  
  46.    try {
  47. 	  // 跟进populateBean()
  48.       populateBean(beanName, mbd, instanceWrapper); 
  49.       // 跟进initializeBean() 
  50.       exposedObject = initializeBean(beanName, exposedObject, mbd);  
  51.    }  
  52.    catch (Throwable ex) {  
  53.       if (ex instanceof BeanCreationException bce && beanName.equals(bce.getBeanName())) {  
  54.          throw bce;  
  55.       }  
  56.       else {  
  57.          throw new BeanCreationException(mbd.getResourceDescription(), beanName, ex.getMessage(), ex);  
  58.       }  
  59.    }  
  60.   
  61.    if (earlySingletonExposure) {  
  62.       Object earlySingletonReference = getSingleton(beanName, false);  
  63.       if (earlySingletonReference != null) {  
  64.          if (exposedObject == bean) {  
  65.             exposedObject = earlySingletonReference;  
  66.          }  
  67.          else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {  
  68.             String[] dependentBeans = getDependentBeans(beanName);  
  69.             Set<String> actualDependentBeans = new LinkedHashSet<>(dependentBeans.length);  
  70.             for (String dependentBean : dependentBeans) {  
  71.                if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) {  
  72.                   actualDependentBeans.add(dependentBean);  
  73.                }  
  74.             }  
  75.             if (!actualDependentBeans.isEmpty()) {  
  76.                throw new BeanCurrentlyInCreationException(beanName,  
  77.                      "Bean with name '" + beanName + "' has been injected into other beans [" +  
  78.                      StringUtils.collectionToCommaDelimitedString(actualDependentBeans) +  
  79.                      "] in its raw version as part of a circular reference, but has eventually been " +  
  80.                      "wrapped. This means that said other beans do not use the final version of the " +  
  81.                      "bean. This is often the result of over-eager type matching - consider using " +  
  82.                      "'getBeanNamesForType' with the 'allowEagerInit' flag turned off, for example.");  
  83.             }  
  84.          }  
  85.       }  
  86.    }  
  87.   
  88.    // Register bean as disposable.  
  89.    try {  
  90.       registerDisposableBeanIfNecessary(beanName, bean, mbd);  
  91.    }  
  92.    catch (BeanDefinitionValidationException ex) {  
  93.       throw new BeanCreationException(  
  94.             mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);  
  95.    }  
  96.   
  97.    return exposedObject;  
  98. }

3.调用InstantiationAwareBeanPostProcessor# postProcessAfterInstantiation

4.注入bean属性

  1. protected void populateBean(String beanName, RootBeanDefinition mbd, @Nullable BeanWrapper bw) {  
  2.    if (bw == null) {  
  3.       if (mbd.hasPropertyValues()) {  
  4.          throw new BeanCreationException(  
  5.                mbd.getResourceDescription(), beanName, "Cannot apply property values to null instance");  
  6.       }  
  7.       else {  
  8.          // Skip property population phase for null instance.  
  9.          return;  
  10.       }  
  11.    }  
  12.   
  13.    if (bw.getWrappedClass().isRecord()) {  
  14.       if (mbd.hasPropertyValues()) {  
  15.          throw new BeanCreationException(  
  16.                mbd.getResourceDescription(), beanName, "Cannot apply property values to a record");  
  17.       }  
  18.       else {  
  19.          // Skip property population phase for records since they are immutable.  
  20.          return;  
  21.       }  
  22.    }  
  23.   
  24.       // 3.调用InstantiationAwareBeanPostProcessor# postProcessAfterInstantiation
  25.       for (InstantiationAwareBeanPostProcessor bp : getBeanPostProcessorCache().instantiationAware) {  
  26.          if (!bp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {  
  27.             return;  
  28.          }  
  29.       }  
  30.    }  
  31.   
  32.    PropertyValues pvs = (mbd.hasPropertyValues() ? mbd.getPropertyValues() : null);  
  33.   
  34.    int resolvedAutowireMode = mbd.getResolvedAutowireMode();  
  35.    if (resolvedAutowireMode == AUTOWIRE_BY_NAME || resolvedAutowireMode == AUTOWIRE_BY_TYPE) {  
  36.       MutablePropertyValues newPvs = new MutablePropertyValues(pvs);  
  37.       // Add property values based on autowire by name if applicable.  
  38.       if (resolvedAutowireMode == AUTOWIRE_BY_NAME) {  
  39.          autowireByName(beanName, mbd, bw, newPvs);  
  40.       }  
  41.       // Add property values based on autowire by type if applicable.  
  42.       if (resolvedAutowireMode == AUTOWIRE_BY_TYPE) {  
  43.          autowireByType(beanName, mbd, bw, newPvs);  
  44.       }  
  45.       pvs = newPvs;  
  46.    }  
  47.    if (hasInstantiationAwareBeanPostProcessors()) {  
  48.       if (pvs == null) { 
  49.          pvs = mbd.getPropertyValues();  
  50.       }  
  51.       for (InstantiationAwareBeanPostProcessor bp : getBeanPostProcessorCache().instantiationAware) {  
  52.          PropertyValues pvsToUse = bp.postProcessProperties(pvs, bw.getWrappedInstance(), beanName);  
  53.          if (pvsToUse == null) {  
  54.             return;  
  55.          }  
  56.          pvs = pvsToUse;  
  57.       }  
  58.    }  
  59.   
  60.    boolean needsDepCheck = (mbd.getDependencyCheck() != AbstractBeanDefinition.DEPENDENCY_CHECK_NONE);  
  61.    if (needsDepCheck) {  
  62.       PropertyDescriptor[] filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);  
  63.       checkDependencies(beanName, mbd, filteredPds, pvs);  
  64.    }  
  65.   
  66.    if (pvs != null) {
  67. 	  // 4.注入属性  
  68.       applyPropertyValues(beanName, mbd, bw, pvs);  
  69.    }  
  70. }

5.设置Aware接口的属性

6.调用BeanPostProcessor的初始化前置方法

7.先((InitializingBean) bean).afterPropertiesSet(),后调用init-method方法，进行初始化操作

8.调用BeanPostProcessor的初始化后置方法

  1. protected Object initializeBean(String beanName, Object bean, @Nullable RootBeanDefinition mbd) {
  2.     // 5.设置Aware接口的属性
  3.    invokeAwareMethods(beanName, bean);  
  4.   
  5.    Object wrappedBean = bean;  
  6.    if (mbd == null || !mbd.isSynthetic()) {
  7. 	  // 5.调用BeanPostProcessor的初始化前置方法  
  8.       wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);  
  9.    }  
  10.   
  11.    try {
  12. 	  // 6.调用init-method方法，进行初始化操作  
  13.       invokeInitMethods(beanName, wrappedBean, mbd);  
  14.    }  
  15.    catch (Throwable ex) {  
  16.       throw new BeanCreationException(  
  17.             (mbd != null ? mbd.getResourceDescription() : null), beanName, ex.getMessage(), ex);  
  18.    }  
  19.    if (mbd == null || !mbd.isSynthetic()) { 
  20.       // 7. 调用BeanPostProcessor的初始化后置方法
  21.       wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);  
  22.    }  
  23.   
  24.    return wrappedBean;  
  25. }

以上就是SpringBoot源码之Bean的生命周期是什么的详细内容，更多关于SpringBoot源码之Bean的生命周期是什么的资料请关注九品源码其它相关文章！

相关热词： SpringBoot源码Bean生命周期是什么
上一篇：讲一讲如何在一个页面中使用多个百度分享按钮，分享不同的文章
下一篇：vue3怎么获取url地址参数

文章分类

IT资讯 CMS教程 服务器 数据库 前端开发 后端开发 工具使用 其他教程

最后更新

热门排行

网站首页 | 关于我们 | 免责声明 | 网站建设 | 在线工具 | 网站地图

版权声明：本站发布的资源部分自互联网，所有资源版权归原作者所有。如果有侵犯到您的权益，请联系本站删除，谢谢合作！

Copyright 2018-2025 ©19jp.com All Rights Reserved. 陕ICP备16002142号-1