欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识！
您现在的位置是： 首页  >  IT编程

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

程序员文章站 2022-03-11 21:57:42
1 前言通过指定接口，重写指定方法，可以在bean对应的生命周期方法中执行相应的程序2 测试 本文将分析几个bean对象，为它们设置优先级（通过@order），然后再打断点调试，测试各种生命周期方法...

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获取对象，然后把对象重新注入进去。

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

销毁的顺序

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

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顺序内容请搜索以前的文章或继续浏览下面的相关文章希望大家以后多多支持！

相关标签： springboot 注入 Bean

上一篇： 2015年支付宝无法导入信用账单到qq邮箱该怎么办?

下一篇： 彻底解决 INSTALL_FAILED_TEST_ONLY安装失败的问题

推荐阅读