@Autowired und statische Methode

Ich habe einen @AutowiredDienst, der innerhalb einer statischen Methode verwendet werden muss. Ich weiß, dass dies falsch ist, aber ich kann das aktuelle Design nicht ändern, da es viel Arbeit erfordern würde. Deshalb brauche ich dafür einen einfachen Hack. Ich kann mich nicht ändern randomMethod(), um nicht statisch zu sein, und ich muss diese automatisch verdrahtete Bean verwenden. Irgendwelche Hinweise, wie das geht?

@Service
public class Foo {
    public int doStuff() {
        return 1;
    }
}

public class Boo {
    @Autowired
    Foo foo;

    public static void randomMethod() {
         foo.doStuff();
    }
}

Sie können dies tun, indem Sie einer der folgenden Lösungen folgen:

Verwenden des Konstruktors @Autowired

Dieser Ansatz erstellt die Bean, für die einige Beans als Konstruktorparameter erforderlich sind. Innerhalb des Konstruktorcodes legen Sie das statische Feld mit dem Wert fest, der als Parameter für die Konstruktorausführung erhalten wurde. Stichprobe:

@Component
public class Boo {

    private static Foo foo;

    @Autowired
    public Boo(Foo foo) {
        Boo.foo = foo;
    }

    public static void randomMethod() {
         foo.doStuff();
    }
}

Verwenden von @PostConstruct, um den Wert an ein statisches Feld zu übergeben

Die Idee hier ist, eine Bohne an ein statisches Feld zu übergeben, nachdem die Bohne bis zum Frühjahr konfiguriert wurde.

@Component
public class Boo {

    private static Foo foo;
    @Autowired
    private Foo tFoo;

    @PostConstruct
    public void init() {
        Boo.foo = tFoo;
    }

    public static void randomMethod() {
         foo.doStuff();
    }
}

Sie müssen dies über den statischen Anwendungskontext-Accessor-Ansatz umgehen:

@Component
public class StaticContextAccessor {

    private static StaticContextAccessor instance;

    @Autowired
    private ApplicationContext applicationContext;

    @PostConstruct
    public void registerInstance() {
        instance = this;
    }

    public static <T> T getBean(Class<T> clazz) {
        return instance.applicationContext.getBean(clazz);
    }

}

Anschließend können Sie statisch auf Bean-Instanzen zugreifen.

public class Boo {

    public static void randomMethod() {
         StaticContextAccessor.getBean(Foo.class).doStuff();
    }

}

Sie können @Autowiredeine Setter-Methode verwenden und ein neues statisches Feld festlegen.

public class Boo {
    @Autowired
    Foo foo;

    static Foo staticFoo;   

    @Autowired
    public void setStaticFoo(Foo foo) {
        Boo.staticFoo = foo;
    }

    public static void randomMethod() {
         staticFoo.doStuff();
    }
}

Wenn die Bean verarbeitet wird, fügt Spring eine FooImplementierungsinstanz in das Instanzfeld ein foo. Anschließend wird dieselbe FooInstanz auch in die setStaticFoo()Argumentliste eingefügt, mit der das statische Feld festgelegt wird.

Dies ist eine schreckliche Problemumgehung und schlägt fehl, wenn Sie versuchen, sie zu verwenden, randomMethod()bevor Spring eine Instanz von verarbeitet hat Boo.

Es ist scheiße, aber Sie können die Bohne über die ApplicationContextAwareSchnittstelle erhalten. Etwas wie :

public class Boo implements ApplicationContextAware {

    private static ApplicationContext appContext;

    @Autowired
    Foo foo;

    public static void randomMethod() {
         Foo fooInstance = appContext.getBean(Foo.class);
         fooInstance.doStuff();
    }

    @Override
    public void setApplicationContext(ApplicationContext appContext) {
        Boo.appContext = appContext;
    }
}

Dies baut auf der Antwort von @ Pavel auf , um die Möglichkeit zu beseitigen, dass der Spring-Kontext beim Zugriff über die statische getBean-Methode nicht initialisiert wird:

@Component
public class Spring {
  private static final Logger LOG = LoggerFactory.getLogger (Spring.class);

  private static Spring spring;

  @Autowired
  private ApplicationContext context;

  @PostConstruct
  public void registerInstance () {
    spring = this;
  }

  private Spring (ApplicationContext context) {
    this.context = context;
  }

  private static synchronized void initContext () {
    if (spring == null) {
      LOG.info ("Initializing Spring Context...");
      ApplicationContext context = new AnnotationConfigApplicationContext (io.zeniq.spring.BaseConfig.class);
      spring = new Spring (context);
    }
  }

  public static <T> T getBean(String name, Class<T> className) throws BeansException {
    initContext();
    return spring.context.getBean(name, className);
  }

  public static <T> T getBean(Class<T> className) throws BeansException {
    initContext();
    return spring.context.getBean(className);
  }

  public static AutowireCapableBeanFactory getBeanFactory() throws IllegalStateException {
    initContext();
    return spring.context.getAutowireCapableBeanFactory ();
  }
}

Das wichtige Stück hier ist die initContextMethode. Es stellt sicher, dass der Kontext immer initialisiert wird. Beachten Sie jedoch, dass initContextdies ein Streitpunkt in Ihrem Code sein wird, wenn dieser synchronisiert wird. Wenn Ihre Anwendung stark parallelisiert ist (z. B. das Backend einer Site mit hohem Datenverkehr), ist dies möglicherweise keine gute Lösung für Sie.

Verwenden Sie AppContext. Stellen Sie sicher, dass Sie eine Bean in Ihrer Kontextdatei erstellen.

private final static Foo foo = AppContext.getApplicationContext().getBean(Foo.class);

public static void randomMethod() {
     foo.doStuff();
}