脚本之家 服务器常用软件
快捷导航
您的位置：首页 → 软件编程 → java → springboot注入Bean顺序

springboot2.x解决运行顺序及Bean对象注入顺序的问题

 更新时间：2021年01月06日 11:10:55   作者：qq_43851684  
这篇文章主要介绍了springboot2.x解决运行顺序及Bean对象注入顺序的问题,本文给大家介绍的非常详细，对大家的学习或工作具有一定的参考借鉴价值，需要的朋友可以参考下

1 前言

通过指定接口，重写指定方法，可以在Bean对应的生命周期方法中执行相应的程序

2 测试

  • 本文将分析几个Bean对象，为它们设置优先级（通过@Order），然后再打断点调试，测试各种生命周期方法的运行的顺序
  • 在项目当中最让人头疼的就是bean对象不被注入的问题，通过本文，你可以很好的解决这个问题。
  • 先看看本程序使用的依赖
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
   xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
 <modelVersion>4.0.0</modelVersion>
 <parent>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-parent</artifactId>
  <version>2.3.0.RELEASE</version>
  <relativePath/> <!-- lookup parent from repository -->
 </parent>
 <groupId>com.wu</groupId>
 <artifactId>smartport</artifactId>
 <version>0.0.1-SNAPSHOT</version>
 <name>smartport</name>
 <description>Demo project for Spring Boot</description>

 <properties>
  <java.version>1.8</java.version>
 </properties>

 <dependencies>
  <dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter</artifactId>
  </dependency>

  <dependency>
   <groupId>org.projectlombok</groupId>
   <artifactId>lombok</artifactId>
   <optional>true</optional>
  </dependency>
  <dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-test</artifactId>
   <scope>test</scope>
  </dependency>
 </dependencies>

 <build>
  <plugins>
   <plugin>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-maven-plugin</artifactId>
    <configuration>
     <excludes>
      <exclude>
       <groupId>org.projectlombok</groupId>
       <artifactId>lombok</artifactId>
      </exclude>
     </excludes>
    </configuration>
   </plugin>
  </plugins>
 </build>

</project>

2.1 Order = 1

package com.wu.smartport.controller;

import com.wu.smartport.test.User;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.*;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.config.AutowireCapableBeanFactory;
import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
import org.springframework.beans.factory.support.BeanDefinitionRegistry;
import org.springframework.beans.factory.support.BeanDefinitionRegistryPostProcessor;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;

@Component
@Order(1)
public class TestController implements BeanNameAware, BeanFactoryAware, ApplicationContextAware, BeanDefinitionRegistryPostProcessor, InitializingBean, DisposableBean {
 @Autowired
 private User user;

 /**
  * 最先执行，需要接口BeanNameAware
  *
  * @param name
  */
 @Override
 public void setBeanName(String name) {
  // 获取到的是testController,即注入进Spring中的名称
  System.out.println("setBeanName:" + name);
 }

 /**
  * 第2个执行，需要接口BeanFactoryAware
  * beanFactory可以获取其他已注入的Bean对象，但无法注入其他对象
  *
  * @param beanFactory
  * @throws BeansException
  */
 @Override
 public void setBeanFactory(BeanFactory beanFactory) throws BeansException {

 }

 /**
  * 第3个执行，需要ApplicationContextAware接口
  * 可以获取到上下文对象applicationContext，允许容器通过应用程序上下文环境创建、获取、管理bean
  *
  * @param applicationContext
  * @throws BeansException
  */
 @Override
 public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
  // 可以通过上下文对象获取工厂并注入对象
  AutowireCapableBeanFactory beanFactory = applicationContext.getAutowireCapableBeanFactory();

 }

 /**
  * 第4个执行，依赖于InitializingBean接口
  *
  * @throws Exception
  */
 @Override
 public void afterPropertiesSet() throws Exception {

 }

 /**
  * 第5个执行，依赖于BeanDefinitionRegistryPostProcessor接口
  * 当完成本方法后，对象就会完成注入
  * @param registry
  * @throws BeansException
  */
 @Override
 public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException {

 }

 /**
  * 第6个执行，来源于BeanFactoryPostProcessor接口，该接口被BeanDefinitionRegistryPostProcessor接口实现了。
  * 一般的Bean对象在此方法前都被注入到了容器中，如果本对象没有获取到，则可以在这里获取。
  * @param beanFactory
  * @throws BeansException
  */
 @Override
 public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
  Object user = beanFactory.getBean("user");
 }

 /**
  * 第7个执行，本方法将被多次执行，依赖于BeanPostProcessor接口
  * 每注入一个对象的时候，都会调用该方法
  * @param bean
  * @param beanName
  * @return
  * @throws BeansException
  */

 public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
  return null;
 }

 /**
  * 第8个执行，本方法将被多次执行，依赖于BeanPostProcessor接口
  * 每注入一个对象之后，都会调用该方法
  * @param bean
  * @param beanName
  * @return
  * @throws BeansException
  */

 public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
  return null;
 }

 /**
  * 在本对象被销毁后执行，依赖于DisposableBean接口
  * @throws Exception
  */
 @Override
 public void destroy() throws Exception {

 }
}

2.2 Order = 15

package com.wu.smartport.test;

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.*;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.beans.factory.config.AutowireCapableBeanFactory;
import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
import org.springframework.beans.factory.support.BeanDefinitionRegistry;
import org.springframework.beans.factory.support.BeanDefinitionRegistryPostProcessor;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Service;

/**
 * @Author ：吴用
 * @Date ：2021-01-05 8:40
 * @Version ：1.0
 */
@Service
@Order(15)
public class User implements BeanNameAware, BeanFactoryAware, ApplicationContextAware, BeanDefinitionRegistryPostProcessor, InitializingBean, DisposableBean {
 @Value("张三")
 private String name;
 @Value("12")
 private int age;

 public User() {
 }



 public User(String name, int age) {
  this.name = name;
  this.age = age;
 }

 public String getName() {
  return name;
 }

 public void setName(String name) {
  this.name = name;
 }

 public int getAge() {
  return age;
 }

 public void setAge(int age) {
  this.age = age;
 }

 /**
  * 最先执行，需要接口BeanNameAware
  *
  * @param name
  */
 @Override
 public void setBeanName(String name) {
  System.out.println("setBeanName:" + name);
 }

 /**
  * 第2个执行，需要接口BeanFactoryAware
  * beanFactory可以获取其他已注入的Bean对象，但无法注入其他对象
  *
  * @param beanFactory
  * @throws BeansException
  */
 @Override
 public void setBeanFactory(BeanFactory beanFactory) throws BeansException {

 }

 /**
  * 第3个执行，需要ApplicationContextAware接口
  * 可以获取到上下文对象applicationContext，允许容器通过应用程序上下文环境创建、获取、管理bean
  *
  * @param applicationContext
  * @throws BeansException
  */
 @Override
 public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {

 }

 /**
  * 第4个执行，依赖于InitializingBean接口
  *
  * @throws Exception
  */
 @Override
 public void afterPropertiesSet() throws Exception {

 }

 /**
  * 第5个执行，依赖于BeanDefinitionRegistryPostProcessor接口
  * 当完成本方法后，对象就会完成注入
  * @param registry
  * @throws BeansException
  */
 @Override
 public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException {

 }

 /**
  * 第6个执行，来源于BeanFactoryPostProcessor接口，该接口被BeanDefinitionRegistryPostProcessor接口实现了。
  * 一般的Bean对象在此方法前都被注入到了容器中，如果本对象没有获取到，则可以在这里获取。
  * @param beanFactory
  * @throws BeansException
  */
 @Override
 public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
  Object user = beanFactory.getBean("user");
 }

 /**
  * 第7个执行，本方法将被多次执行，依赖于BeanPostProcessor接口
  * 每注入一个对象的时候，都会调用该方法
  * @param bean
  * @param beanName
  * @return
  * @throws BeansException
  */

 public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
  return null;
 }

 /**
  * 第8个执行，本方法将被多次执行，依赖于BeanPostProcessor接口
  * 每注入一个对象之后，都会调用该方法
  * @param bean
  * @param beanName
  * @return
  * @throws BeansException
  */

 public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
  return null;
 }

 /**
  * 在本对象被销毁后执行，依赖于DisposableBean接口
  * @throws Exception
  */
 @Override
 public void destroy() throws Exception {

 }
}

2.3 Order = 30

package com.wu.smartport.test;

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.*;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
import org.springframework.beans.factory.support.BeanDefinitionRegistry;
import org.springframework.beans.factory.support.BeanDefinitionRegistryPostProcessor;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;

/**
 * @Author ：吴用
 * @Date ：2021-01-05 9:48
 * @Version ：1.0
 */
@Order(30)
@Component
public class User2 implements BeanNameAware, BeanFactoryAware, ApplicationContextAware, BeanDefinitionRegistryPostProcessor, InitializingBean, DisposableBean {
 @Value("张三")
 private String name;
 @Value("12")
 private int age;

 public User2() {
 }

 public String getName() {
  return name;
 }

 public void setName(String name) {
  this.name = name;
 }



 public int getAge() {
  return age;
 }

 public void setAge(int age) {
  this.age = age;
 }


 /**
  * 最先执行，需要接口BeanNameAware
  *
  * @param name
  */
 @Override
 public void setBeanName(String name) {
  System.out.println("setBeanName:" + name);
 }

 /**
  * 第2个执行，需要接口BeanFactoryAware
  * beanFactory可以获取其他已注入的Bean对象，但无法注入其他对象
  *
  * @param beanFactory
  * @throws BeansException
  */
 @Override
 public void setBeanFactory(BeanFactory beanFactory) throws BeansException {

 }

 /**
  * 第3个执行，需要ApplicationContextAware接口
  * 可以获取到上下文对象applicationContext，允许容器通过应用程序上下文环境创建、获取、管理bean
  *
  * @param applicationContext
  * @throws BeansException
  */
 @Override
 public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {

 }

 /**
  * 第4个执行，依赖于InitializingBean接口
  *
  * @throws Exception
  */
 @Override
 public void afterPropertiesSet() throws Exception {

 }

 /**
  * 第5个执行，依赖于BeanDefinitionRegistryPostProcessor接口
  * 当完成本方法后，对象就会完成注入
  * @param registry
  * @throws BeansException
  */
 @Override
 public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException {

 }

 /**
  * 第6个执行，来源于BeanFactoryPostProcessor接口，该接口被BeanDefinitionRegistryPostProcessor接口实现了。
  * 一般的Bean对象在此方法前都被注入到了容器中，如果本对象没有获取到，则可以在这里获取。
  * @param beanFactory
  * @throws BeansException
  */
 @Override
 public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
  Object user = beanFactory.getBean("user");
 }

 /**
  * 第7个执行，本方法将被多次执行，依赖于BeanPostProcessor接口
  * 每注入一个对象的时候，都会调用该方法
  * @param bean
  * @param beanName
  * @return
  * @throws BeansException
  */

 public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
  return null;
 }

 /**
  * 第8个执行，本方法将被多次执行，依赖于BeanPostProcessor接口
  * 每注入一个对象之后，都会调用该方法
  * @param bean
  * @param beanName
  * @return
  * @throws BeansException
  */

 public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
  return null;
 }

 /**
  * 在本对象被销毁后执行，依赖于DisposableBean接口
  * @throws Exception
  */
 @Override
 public void destroy() throws Exception {

 }
}

2.4 实验结果

  • 如下图所示
  • TestController 的Order=1，最高优先级
  • User 的 Order = 15，中等优先级
  • User2 的 Order = 30，低优先级
  • 前四个方法会按照优先级的顺序先后执行，然后按优先级顺序执行postProcessBeanDefinitionRegistry方法，然后再按优先级顺序执行postProcessBeanFactory方法
  • postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) 方法很不错，给了beanFactory。不仅如此，在此方法以前，所有的Bean对象已经被注入完毕了，所以如果之前你的对象没有注入进去，你就可以在这里通过beanFactroy获取对象，然后把对象重新注入进去。

在这里插入图片描述 

销毁的顺序

在这里插入图片描述 

3 @Dependon 和 @Order

  • @Dependon 和@Order 共同决定Bean对象的注入顺序，
  • 如果A对象 @Dependon B对象，则无论A对象和B对象的@Order的值是什么，都以@Dependon标签为主
  • 例如A对象@Dependon(“b”),@Order(1) ，B对象@Order(15)，则B对象将先于A对象注入spring容器中

4 利用BeanFactoryPostProcessor 初始化

4.1 一般初始化

  • 根据上面的实验我们知道实现BeanFactoryPostProcessor接口后，重写void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory)
  • 在该方法运行时，所有的bean对象都已经被注入到了spring容器中，此时可以利用观察者模式将你需要初始化的对象进行初始化。
  • 首先，需要写一个ObserverForInit接口
package com.wu.smartport.controller;

/**
 * 观察者，用于初始化
 * @Author ：吴用
 * @Date ：2021-01-05 11:02
 * @Version ：1.0
 */
public interface ObserverForInit {
 /**
  * 观察者初始化
  */
 void observerInit();
}

再让需要初始化操作的bean对象实现该接口

package com.wu.smartport.test;

import com.wu.smartport.controller.ObserverForInit;
import org.springframework.stereotype.Component;

/**
 * @Author ：吴用
 * @Date ：2021-01-05 11:11
 * @Version ：1.0
 */
@Component
public class User implements ObserverForInit {
 @Override
 public void observerInit() {
  System.out.println("我要进行初始化了！");
 }
}

然后再写一个管理bean初始化的类 通过遍历所有的Bean对象，然后查询指定的接口或者自定义注解，执行相应的操作（比如初始化操作。）

package com.wu.smartport.manager;

import com.wu.smartport.controller.ObserverForInit;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.BeanCreationException;
import org.springframework.beans.factory.config.BeanFactoryPostProcessor;
import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
import org.springframework.stereotype.Component;

import java.util.Iterator;

/**
 * @Author ：吴用
 * @Date ：2021-01-05 11:06
 * @Version ：1.0
 */
@Component
public class ControllerInitManager implements BeanFactoryPostProcessor {
 @Override
 public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
  Iterator<String> its = beanFactory.getBeanNamesIterator();
  while (its.hasNext()) {
   String beanName = its.next();
   try {
    Object bean = beanFactory.getBean(beanName);
    analysisObject(bean);
   } catch (BeanCreationException e) {
   } catch (Exception e) {
    e.printStackTrace();
   }
  }
 }

 /**
  * 分析bean对象
  *
  * @param bean
  */
 private void analysisObject(Object bean) {
  analysisInterface(bean);
  analysisAnnotation(bean);
 }


 /**
  * 分析接口
  *
  * @param bean
  */
 private void analysisInterface(Object bean) {
  Class<?> beanClass = bean.getClass();
  // 分析Interface 和 Annotation
  Class<?>[] interfaces = beanClass.getInterfaces();
  // 分析Class
  for (Class infs : interfaces) {
   if (infs.equals(ObserverForInit.class)) {
    ((ObserverForInit) bean).observerInit();
   }
  }
 }

 /**
  * 分析注解
  *
  * @param bean
  */
 private void analysisAnnotation(Object bean) {

 }
}

4.2 按序初始化

  • 如果对初始化的顺序有自己要求，可以采取如下的方法。至于4.1中的遍历顺序，读者可以自行研究，但建议自己写顺序，否则一旦springboot框架内部有变，咱们程序内部的初始顺序可能会出问题。
  • 设置一个TreeSet 并给定排序策略，遍历接口的时候，先将找到的对象放入TreeSet中排序，再遍历完成之后再执行相应的操作
  • 修改后的接口
package com.wu.smartport.controller;

/**
 * 观察者，用于初始化
 * @Author ：吴用
 * @Date ：2021-01-05 11:02
 * @Version ：1.0
 */
public interface ObserverForInit {
 /**
  * 观察者初始化
  */
 void observerInit();

 /**
  * 初始化的顺序，数越小，优先级越高
  * @return
  */
 int getInitOrder();
}

bean对象

/**
 * @Author ：吴用
 * @Date ：2021-01-04 22:51
 * @Version ：1.0
 */
@Component
public class PageManager implements ObserverForInit {
 @Override
 public void observerInit() {
  System.out.println("PageManager初始化");
 }

 @Override
 public int getInitOrder() {
  return 1000;
 }
}

管理初始化的类

package com.wu.smartport.manager;

import com.wu.smartport.controller.ObserverForInit;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.BeanCreationException;
import org.springframework.beans.factory.config.BeanFactoryPostProcessor;
import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
import org.springframework.stereotype.Component;
import java.util.Comparator;
import java.util.Iterator;
import java.util.TreeSet;

/**
 * @Author ：吴用
 * @Date ：2021-01-05 11:06
 * @Version ：1.0
 */
@Component
public class ControllerInitManager implements BeanFactoryPostProcessor {
 private TreeSet<ObserverForInit> inits = new TreeSet<>(Comparator.comparingInt(ObserverForInit::getInitOrder));

 @Override
 public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
  Iterator<String> its = beanFactory.getBeanNamesIterator();
  while (its.hasNext()) {
   String beanName = its.next();
   try {
    Object bean = beanFactory.getBean(beanName);
    analysisObject(bean);
   } catch (BeanCreationException e) {
   } catch (Exception e) {
    e.printStackTrace();
   }
  }
  // 遍历完成后的操作
  analysisByAfterIterator();
 }


 /**
  * 分析bean对象
  *
  * @param bean
  */
 private void analysisObject(Object bean) {
  analysisInterface(bean);
  analysisAnnotation(bean);
 }

 /**
  * 遍历之后的操作
  */
 private void analysisByAfterIterator() {
  // 按照指定的顺序遍历
  // 升序遍历，order小的先执行初始化方法
  for (ObserverForInit o : inits) {
   o.observerInit();
  }
 }

 /**
  * 分析接口
  *
  * @param bean
  */
 private void analysisInterface(Object bean) {
  Class<?> beanClass = bean.getClass();
  // 分析Interface 和 Annotation
  Class<?>[] interfaces = beanClass.getInterfaces();
  // 分析Class
  for (Class infs : interfaces) {
   if (infs.equals(ObserverForInit.class)) {
    inits.add((ObserverForInit) bean);
   }
  }
 }

 /**
  * 分析注解
  *
  * @param bean
  */
 private void analysisAnnotation(Object bean) {

 }
}

5 基于 Springboot 实现冯诺依曼结构

  • 下面讲解一个骚操作
  • 冯诺依曼结构：将程序和数据分别存储在内存当中
  • 基于这种思想，我们不光可以把数据存储在容器当中，我们还可以把代码也存储在springboot容器当中。
  • 创建一个Bean对象，实现BeanFactoryPostProcessor接口，在运行到该方法的时候，大部分的对象已经被装入了spring容器中。你可以在之后必要的地方从spring容器中提取该代码执行。
package com.wu.smartport.test;

import com.wu.smartport.SmartportApplication;
import javafx.stage.Stage;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanFactoryPostProcessor;
import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
import org.springframework.beans.factory.support.DefaultListableBeanFactory;

import java.io.IOException;
import java.util.ArrayList;
import java.util.function.Function;

import static com.wu.smartport.config.BeanInitOrder.INIT_METHODS;
import static com.wu.smartport.config.BeanInitOrder.STAGE_BEAN;

/**
 * @Author ：吴用
 * @Date ：2021-01-05 19:27
 * @Version ：1.0
 */
public class Manager implements BeanFactoryPostProcessor {
 @Override
 public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
  // 执行方法告诉javaFx
  ArrayList<Function> arr;
  try{
   // 尝试从容器中获取代码块
   Object bean = beanFactory.getBean("function");
   arr = (ArrayList<Function>)bean;
  }catch (Exception e2){
   // 如果不存在则创建代码块
   arr = new ArrayList<>();
  }
  // 书写一段代码
  Function<Void,Void> f = aVoid -> {
   // 相关的业务
   return null;
  };
  arr.add(f);
  // 将代码块注入到spring容器中
  DefaultListableBeanFactory factory = (DefaultListableBeanFactory)beanFactory;
  factory.registerSingleton(INIT_METHODS,arr);
 }
}

在之后一定会运行到的代码，比如启动类之后，可以执行指定的代码段。

package com.wu.smartport;

import javafx.application.Application;
import javafx.stage.Stage;
import org.springframework.beans.factory.support.DefaultListableBeanFactory;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ConfigurableApplicationContext;
import java.util.ArrayList;
import java.util.function.Function;
import static com.wu.smartport.config.BeanInitOrder.INIT_METHODS;
import static com.wu.smartport.config.BeanInitOrder.STAGE_BEAN;

/**
 * 主启动类
 * @author Wu_Sir
 */
@SpringBootApplication
public class SmartportApplication{
 private static volatile ConfigurableApplicationContext run;

 /**
  * 主程序入口
  *
  * @param args
  */
 public static void main(String[] args) {
  run = SpringApplication.run(SmartportApplication.class, args);
  // 查看是否有要处理的方法
  try{
   Object bean = beanFactory.getBean("function");
   ArrayList<Function> arr = (ArrayList<Function>) bean;
   for (int i = 0; i < arr.size(); i++) {
   	//如果有，则执行该方法。
    Function f = arr.get(i);
    f.apply(null);
   }
  }catch (Exception e){
   e.printStackTrace();
  }
 }
}

到此这篇关于springboot2.x解决运行顺序及Bean对象注入顺序的问题的文章就介绍到这了,更多相关springboot注入Bean顺序内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！

您可能感兴趣的文章:

相关文章

  • Java多线程下解决资源竞争的7种方法详解

    Java多线程下解决资源竞争的7种方法详解

    这篇文章主要介绍了Java多线程下解决资源竞争的7种方法详解,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
    2019-08-08
  • eclipse下搭建hibernate5.0环境的步骤(图文)

    eclipse下搭建hibernate5.0环境的步骤(图文)

    这篇文章主要介绍了eclipse下搭建hibernate5.0环境的步骤(图文)，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
    2018-05-05
  • 解决Intellij IDEA覆盖tomcat配置的问题

    解决Intellij IDEA覆盖tomcat配置的问题

    分析并解决Intellij IDEA覆盖tomcat配置的问题/解决修改server.xml无效的问题，本文给大家介绍的非常详细，对大家的学习或工作具有一定的参考借鉴价值，需要的朋友一起看看吧
    2021-02-02
  • Java JConsole远程连接配置案例详解

    Java JConsole远程连接配置案例详解

    这篇文章主要介绍了Java JConsole远程连接配置案例详解,本篇文章通过简要的案例,讲解了该项技术的了解与使用,以下就是详细内容,需要的朋友可以参考下
    2021-08-08
  • JavaWeb中Servlet的深入理解

    JavaWeb中Servlet的深入理解

    Java Servlet 是运行在 Web 服务器或应用服务器上的程序，它是作为来自 Web 浏览器或其他 HTTP 客户端的请求和 HTTP 服务器上的数据库或应用程序之间的中间层
    2021-10-10
  • jmeter添加自定函数的实例(jmeter5.3+IntelliJ IDEA)

    jmeter添加自定函数的实例(jmeter5.3+IntelliJ IDEA)

    这篇文章主要介绍了jmeter添加自定函数的实例(jmeter5.3+IntelliJ IDEA),本文通过图文并茂的形式给大家介绍的非常详细，对大家的学习或工作具有一定的参考借鉴价值，需要的朋友可以参考下
    2020-11-11
  • mybatis plus generator 根据数据库自动生成实体类的实现示例

    mybatis plus generator 根据数据库自动生成实体类的实现示例

    本文主要介绍了mybatis plus generator 根据数据库自动生成实体类的实现示例，文中通过示例代码介绍的非常详细，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
    2021-09-09
  • 面试官问如何启动Java 线程

    面试官问如何启动Java 线程

    这篇文章主要介绍了面试官问如何启动Java 线程，Java 的线程创建和启动非常简单，但如果问一个线程是怎么启动起来的往往并不清楚，甚至不知道为什么启动时是调用start()，而不是调用run()方法呢？下面我们就一起进入文章学习这个问题吧
    2021-12-12
  • 浅谈SpringBoot中properties、yml、yaml的优先级

    浅谈SpringBoot中properties、yml、yaml的优先级

    优先级低的配置会被先加载,所以优先级高的配置会覆盖优先级低的配置,本文就来介绍一下SpringBoot中properties、yml、yaml的优先级,感兴趣的可以了解一下
    2023-08-08
  • spring aop底层源码执行逻辑剖析(源码解析)

    spring aop底层源码执行逻辑剖析(源码解析)

    这篇文章主要介绍了spring aop底层源码执行逻辑剖析,本文给大家介绍的非常详细,对大家的学习或工作具有一定的参考借鉴价值,需要的朋友参考下吧
    2024-08-08

最新评论