IoC

“Inversion of Control” ou “IoC” é um princípio dentro da engenharia de software que visa estabelecer um menor acoplamento, esse baixo acoplamento diz respeito a um código mais abstrato e genérico que cobre a maioria dos casos de uso, mas que ainda assim dá liberdade ao programador para extender essas funcionalidades dentro dos seus casos de uso específicos.

As vantagens desse tipo de arquitetura são:

• tirar o papel de execução da implementação feita pelo programador;
• torna mais fácil a refatoração para algum tipo de implementação diferente;
• maior mudolaridade do código;
• torna mais fácil o uso de testes com dependências “mockadas” pelo programador;

DI

“Dependency Injection” ou “DI” é uma das formas de se aplicar o princípio de IoC, dentro desse padrão jogamos a responsabilidade de injetar as dependências para o programador, e não para a interface desse código.

// caso não apliquemos o padrão de DI dentro de uma classe,
// estamos colocando a instanciação dessa classe dentro de
// sua própria definição, aumentando muito o acoplamento
// pois o atributo está "hard-coded" dentro da classe.

public class Person() {
    private Age age;

    public Person() {
        this.age = new AgeImpl();
    }
}

// aqui estamos aplicando o conceito de DI,
// estamos definindo o que queremos, sem dizer como
// assim diminuimos o acoplamento e aumentamos a 
// abstração do código escrito, facilitando os testes, por exemplo

public class Person() {
    private Age age
    public Person(Age age) {
        this.age = age
    }
}

Beans

Um “Bean” é um objeto que o Spring instancia, monta e cuida. A documentação oficial do Spring recomenda usar a anotação de @Bean apenas para códigos relacionados com a camada de services, DAO’s ou infraestrutura.

// exemplo de classe

public class AccountConfig() {
    @Autowired
    private AccountRepository accountRepository;
}

// ao usar a configuração de beans

@Configuration
public class AccountConfig() {

    @Bean
    public AccountService accountService() {
        return new AccountService(accountRepository());
    }

    @Bean 
    public AccountRepository accountRepository() {
        return new AccountRepository();
    }
}

Os Beans também são uma forma de customizar dependências que não necessariamente fazem parte do ecossistema do Spring, porém precisam ser injetadas na aplicação, então a responsabilidade de dizer como o Spring vai realizar o controle do life-cycle desse objeto cabe a configuração do bean.

Os Beans fazem com que as dependências com essas anotações sejam incluídas na interface ApplicationContext (que é responsável por realizar o IoC dentro do Spring, juntamente com a interface BeanFactory).