在Spring中按顺序实例化bean? [英] Instantiate beans in order in Spring?

问题描述

是否可以在Spring中设置实例化顺序?

Is it possible to set order of instantiation in Spring?

我不想使用@DependsOn，也不想使用Ordered界面.我只需要一个实例化顺序.

I don't want to use @DependsOn and I don't want to use Ordered interface. I just need an order of instantiation.

@Order注释的以下用法不起作用:

The following usage of @Order annotation does not work:

import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.annotation.Order;

/**
 * Order does not work here
 */
public class OrderingOfInstantiation {

   public static class MyBean1 {{
      System.out.println(getClass().getSimpleName());
   }}

   public static class MyBean2 {{
      System.out.println(getClass().getSimpleName());
   }}

   @Configuration
   public static class Config {

      @Bean
      @Order(2)
      public MyBean1 bean1() {
         return new MyBean1();
      }

      @Bean
      @Order(1)
      public MyBean2 bean2() {
         return new MyBean2();
      }

   }

   public static void main(String[] args) {
      new AnnotationConfigApplicationContext(Config.class);
   }

}

Bean仍按字典顺序实例化.

Beans are still instantiated in lexicographic order.

为什么它在这里不起作用?

Why it does not work here?

反正我可以依靠词典顺序吗?

Can I rely of lexicographic order anyway?

更新

我想要任何允许提供创建顺序的解决方案.

I would like any solution allowing to provide order of creation.

目标是按照正确的顺序在配置级别填充集合. Depends on-与任务不匹配.关于Spring为什么不喜欢有顺序的实例化的任何解释"都与任务不匹配.

The goal is to populate collections at config level in correct order. Depends on -- does not match the task. Any "explanations" on why Spring does not like to have ordered instantiations -- also does not match the task.

订单表示订单:)

推荐答案

来自@Order javadoc

From @Order javadoc

注意:仅支持特定种类的组件，例如，基于注释的AspectJ方面.另一方面，Spring容器中的排序策略通常基于Ordered接口，以便允许以编程方式配置每个实例的排序.

NOTE: Annotation-based ordering is supported for specific kinds of components only — for example, for annotation-based AspectJ aspects. Ordering strategies within the Spring container, on the other hand, are typically based on the Ordered interface in order to allow for programmatically configurable ordering of each instance.

所以我想Spring在创建bean时不会遵循@Order().

So I guess Spring just doesn't follow @Order() when creating beans.

但是，如果您只是想填充集合，也许这对您已经足够了:

But if you just want to populate collections, maybe this is good enough for you:

import com.google.common.collect.Multimap;
import com.google.common.collect.MultimapBuilder;
import org.apache.commons.lang3.tuple.Pair;
import org.springframework.beans.BeansException;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.stereotype.Component;

import java.lang.annotation.*;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;

@Configuration
public class OrderingOfInstantiation {

    public static void main(String[] args) {
        new AnnotationConfigApplicationContext(OrderingOfInstantiation.class);
    }

    @Component
    @CollectionOrder(collection = "myBeans", order = 1)
    public static class MyBean1 {{
        System.out.println(getClass().getSimpleName());
    }}

    @Component
    @CollectionOrder(collection = "myBeans", order = 2)
    public static class MyBean2 {{
        System.out.println(getClass().getSimpleName());
    }}

    @Configuration
    public static class CollectionsConfig {

        @Bean
        List<Object> myBeans() {
            return new ArrayList<>();
        }
    }

    // PopulateConfig will populate all collections beans
    @Configuration
    public static class PopulateConfig implements ApplicationContextAware {

        @SuppressWarnings("unchecked")
        @Override
        public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
            Multimap<String, Object> beansMap = MultimapBuilder.hashKeys().arrayListValues().build();

            // get all beans
            applicationContext.getBeansWithAnnotation(CollectionOrder.class)
                    .values().stream()

                    // get CollectionOrder annotation
                    .map(bean -> Pair.of(bean, bean.getClass().getAnnotation(CollectionOrder.class)))

                    // sort by order
                    .sorted((p1, p2) -> p1.getRight().order() - p2.getRight().order())

                    // add to multimap
                    .forEach(pair -> beansMap.put(pair.getRight().collection(), pair.getLeft()));

            // and add beans to collections
            beansMap.asMap().entrySet().forEach(entry -> {
                Collection collection = applicationContext.getBean(entry.getKey(), Collection.class);
                collection.addAll(entry.getValue());

                // debug
                System.out.println(entry.getKey() + ":");
                collection.stream()
                        .map(bean -> bean.getClass().getSimpleName())
                        .forEach(System.out::println);
            });
        }

    }

    @Retention(RetentionPolicy.RUNTIME)
    @Target({ElementType.TYPE})
    @Documented
    public @interface CollectionOrder {
        int order() default 0;

        String collection();
    }
}

它不会更改实例化顺序，但是您将获得有序集合.

It won't change instantiation order, but you'll get ordered collections.

这篇关于在Spring中按顺序实例化bean?的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！