Beans and Autowiring

class MyService{
	@Autowired
	MyRepository repo;
}

class MyController{
	MyService service = new MyService();	// Spring can't inject MyRepository bean in MyService
}

interface AutoService { }

@Service
class ServiceA implements AutoService { }

@Service
class ServiceB implements AutoService { }

class Main{
	@Autowired
	private AutoService autoService;		// compile-time error
}

// 1. specify service name as @Autowired field's name to select which bean to use
class Main{
	@Autowired
	private AutoService serviceA;		// instance of ServiceA is injected
}

// 2. use @Service("") along with @Qualifier("") to select which bean to use
@Service("foo")
class ServiceA implements AutoService { }

@Service("bar")
class ServiceB implements AutoService { }

class Main{

	@Autowired
	@Qualifier("bar")
	private AutoService autoService;	// ServiceB is injected
}

// 3. use @Primary to indicate a preferred impl (if multiple impl are present and there is ambiguity, this bean impl will be used)
@Service
@Primary
class ServiceA implements AutoService { }

@Service
class ServiceB implements AutoService { }

class Main{

	@Autowired
	private AutoService autoService;	// ServiceA is injected
}

// if both @Primary and @Qualifier mechanisms are present and causing ambiguity, then @Qualifier takes precedence (ofc as its more explicit and closer to usage (autowiring location))

@Repository
public interface UserRepository extends JpaRepository<User,Long> {
    User findByEmail(String email);
}

@Component
class Foobar{}		// default naming; a bean named "foobar" (notice the lowercase) is created

@Component("Baz")
class Foobar{}		// explicit naming; a bean named "Baz" is created (no case conversion since its explicit)

@Configuration
class MyCustomBeans{

	@Bean
	public ServiceA serviceABean(String s, int n){	// notice return type
		return new ServiceA("foo", 99);				// we can call any constructor we want here
	}

	// dependency on the existence of another bean
	@Bean
	public ServiceC serviceCBean(ServiceB s) {		// Spring will automatically init ServiceB Bean before this and use that to init ServiceC here
		return new ServiceC();
	}
}

@Bean
public Demo foo(){		// bean name is "foo" (default is method name)
	return new Demo();
}

@Bean("Bar")			// bean name is "Bar", explicitly specified bean name
public Demo foo(){
	return new Demo();
}

// configuration class
@Bean("foobar")
public Foobar getFoobar(){
	return new Foobar();
}

@Bean("foobar")
public Foobar getFoobarBean(){
	return new Foobar();
}

// this doesn't cause any application startup errors but the below bean overrides the above one since they have the same name

@Bean("foobar")
public Test getTestBean(){
	return new Test();
}

// this will still override above beans even if it is of diff type, since it has the same name (no startup errors here too)

// only one bean named "foobar" is created for the above three methods

// Beans present of type Foobar are - foobar, foo, bar (all subclasses of Foobar class)
class Service{
	@Autowired
	Foobar fb;		// ambiguous; application startup failure: required a single bean, but 2 were found
}

// resolve the above error just like we resolved ambiguity in interface autowiring: Autowired field name, @Primary, @Qualifier annotations

@Configuration
class AppConfig{
	@Value("${pet.isDog}")
	boolean flag;

	@Bean
	public Pet animal(){
		if(flag == true){
			return new Dog();
		} else {
			return new Cat();
		}
	}
}

// below 2 ways be used on @Bean annotation too instead of @Component

@Component
@ConditionalOnProperty(prefix="foobar", name="enabled", havingValue="true", matchIfMissing=false)
class Foobar{ }

@Component
@Profile("qa")
class Foobar{ }

spring.main.lazy-initialization=true

@Lazy						// specify here; applies to all beans in the class
@Configuration
public class MyCustomBeans{

	@Lazy							// or here
	@Bean
	ServiceA serviceBeanCreator(){
		return new ServiceA();
	}
}

class Main{

	@Autowired
	private AutoService autoService;	// field-based injection; injects AutoService bean on the field
}

----------------------------------------------------

class Main{

	private AutoService autoService;

	@Autowired		// Spring calls this setter automatically just after constructor call; also passes AutoService Bean if it exists
	private mySetter(AutoService autoService){	// setter-based injection; injects AutoService bean on the setter's param
		// any custom logic
		this.autoService = autoService;
	}	
}

----------------------------------------------------

class Main{

	private AutoService autoService;

	@Autowired								// Spring will use this constructor by default when creating Bean of Main
	private Main(AutoService autoService){	// constructor-based injection; injects AutoService bean on the constructor's param
		this.autoService = autoService;
	}
}

@Component
@Scope(value = "request", proxyMode = ScopedProxyMode.TARGET_CLASS)		// configure proxyMode for lazy bean
public class User{ }