@Configuration Anotasyonlu Sınıfta @Bean ve Diğer Beanlere Dependency - Full Mode

Giriş
Klasik @Configuration kullanımında @Bean olarak işaretli metoda gerekli diğer bean'leri metod çağrısı ile almak yeterli.

Ancak istenirse parametre olarak geçmek te mümkün.
İlave olarak bazen field olarak ta kullanılabiliyor.

1. Metod Çağrısı - Full Mode
Bu Yöntem Sadece @Configuration Sınıfında Kullanılmalı
Çünkü @Configuration içindeki @Bean ve @Component içindeki @Bean farklı şeyler. Spring bu moda Full Mode diyor. Açıklaması şöyle.

Full @Configuration vs 'lite' @Beans mode?
When @Bean methods are declared within classes that are not annotated with @Configuration they are referred to as being processed in a 'lite' mode. For example, bean methods declared in a @Component or even in a plain old class will be considered 'lite'. 

Unlike full @Configuration, lite @Bean methods cannot easily declare inter-bean dependencies. Usually one @Bean method should not invoke another @Bean method when operating in 'lite' mode. 

Only using @Bean methods within @Configuration classes is a recommended approach of ensuring that 'full' mode is always used. This will prevent the same @Bean method from accidentally being invoked multiple times and helps to reduce subtle bugs that can be hard to track down when operating in 'lite' mode.

Yani @Configuration ve @Component içindeki @Bean'ler farklı şeyler. Açıklaması şöyle.

Spring does actually use ASM (embedded in the spring-core dependency) to load and process @Configuration classes. This is also the main difference in processing @Bean methods in @Configuration and @Component classes.

@Configuration aslında proxy gibi çalışıyor. Dolayısıyla metod çağrısı her zaman aynı bean'i dönüyor. Açıklaması şöyle.

With @Configuration you will get the same and proxied object. With @Component you are running in so called lite mode, you will get a proxy but when calling the simpleBean() multiple times you will get a fresh proxied instance for each call.

Örnek
Açıklaması şöyle.

When @Bean have dependencies on one another, then to resolve this dependency one bean method can call the other one.

Şöyle yaparız.

@Bean
public Dog dog() {
  ...
  return dog;
}

@Bean
public DogHouse dogHouse() {
  Dog d = dog(); 
  ...
  return dogHouse;
}

Örnek
Şöyle yaparız

@Configuration
public class Config {
  @Bean
  public SimpleBean simpleBean() {
    return new SimpleBean();
  }

  @Bean
  public SimpleBeanConsumer simpleBeanConsumer() {
    return new SimpleBeanConsumer(simpleBean());
  }

  @Bean
  public AnotherBeanConsumer anotherBeanConsumer() {
    return new AnotherBeanConsumer(simpleBean());
  }        
 }

Örnek
Şöyle yaparız.

@Configuration 
public class Config {

  @Bean
  public FooUser fooUser() {
    return new FooUser(foo());
  }

  @Bean
  public FooFactory fooFactory() {
    return new FooFactory();
  }

  @Bean
  public Foo foo() {
    return fooFactory().createFoo();
  }
}

2. Parametre
Bu kullanımın çok bir özelliği yok. Klasik bean kullanımı

Örnek

Şöyle yaparız.

@Bean
public DogHouse dogHouse(Dog d) {
  ...
  return dogHouse;
}

3. Field Injection

Örnek 
Şöyle yaparız. Burada @Bean için gereken diğer bean Field Injection ile geliyor.

@SpringBootApplication
public class Application {

  @Autowired
  BookingService bookingService;

  @Bean
  BookingService bookingService() {
    return new BookingService();
  }
  ...  
}