@Autowired i metoda statyczna

Mam @Autowiredusługę, z której należy korzystać w ramach metody statycznej. Wiem, że to źle, ale nie mogę zmienić obecnego projektu, ponieważ wymagałoby to dużo pracy, więc potrzebuję do tego prostego hacka. Nie mogę zmienić się randomMethod()na niestatyczny i muszę użyć tej automatycznej fasoli. Jakieś wskazówki, jak to zrobić?

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

public class Boo {
    @Autowired
    Foo foo;

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

Możesz to zrobić, wykonując jedno z rozwiązań:

Korzystanie z konstruktora @Autowired

To podejście spowoduje skonstruowanie fasoli wymagającej pewnych ziaren jako parametrów konstruktora. W kodzie konstruktora ustawiasz pole statyczne z wartością otrzymaną jako parametr do wykonania konstruktora. Próba:

@Component
public class Boo {

    private static Foo foo;

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

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

Użycie @PostConstruct do przekazania wartości do pola statycznego

Pomysł polega na przekazaniu fasoli na statyczne pole po skonfigurowaniu fasoli na wiosnę.

@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();
    }
}

Musisz obejść ten problem za pomocą metody dostępu do kontekstu aplikacji statycznej:

@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);
    }

}

Następnie możesz uzyskać dostęp do instancji bean w sposób statyczny.

public class Boo {

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

}

To, co możesz zrobić, to @Autowiredmetoda ustawiająca i ustawić nowe pole statyczne.

public class Boo {
    @Autowired
    Foo foo;

    static Foo staticFoo;   

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

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

Gdy ziarno zostanie przetworzone, Spring wstrzyknie Fooinstancję implementacji do pola instancji foo. Następnie wstrzyknie to samo Foowystąpienie do setStaticFoo()listy argumentów, która zostanie użyta do ustawienia pola statycznego.

Jest to okropne obejście i zakończy się niepowodzeniem, jeśli spróbujesz użyć go, randomMethod()zanim Spring przetworzy wystąpienie Boo.

To jest do bani, ale możesz zdobyć fasolę za pomocą ApplicationContextAwareinterfejsu. Coś jak :

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;
    }
}

Opiera się to na odpowiedzi @ Pavel , aby rozwiązać problem braku inicjalizacji kontekstu Spring podczas uzyskiwania dostępu ze statycznej metody getBean:

@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 ();
  }
}

Ważnym elementem jest tutaj initContextmetoda. Zapewnia, że ​​kontekst zawsze zostanie zainicjowany. Ale pamiętaj, że initContextbędzie to punkt sporny w twoim kodzie, ponieważ jest zsynchronizowany. Jeśli Twoja aplikacja jest mocno zrównoleglona (na przykład: zaplecze witryny o dużym ruchu), może to nie być dobre rozwiązanie dla Ciebie.

Użyj AppContext. Upewnij się, że tworzysz fasolę w swoim pliku kontekstowym.

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

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