Ligação de beans: @Component, @Service, @Repository
Use anotações estereotipadas, defina beans com @Bean e entenda a varredura de componentes.
Ligação de beans: @Component, @Service, @Repository é uma aula grátis de Java Academy no CoddyKit. Esta é a aula 3 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Java Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Java Academy inclui 4 aulas no total.
Anotações de estereótipo
O Spring fornece anotações de estereótipo que marcam classes como componentes gerenciados pelo Spring e indicam sua função: @Component (genérico), @Service (lógica de negócio), @Repository (acesso a dados), @Controller/@RestController (camada web).
@Component: Componente genérico
Qualquer classe anotada com @Component é detectada durante a varredura de componentes e registrada como um componente do Spring. Ela é a base de todos os outros estereótipos.
@Component
public class EmailFormatter {
public String format(String to, String subject) {
return "To: " + to + "\nSubject: " + subject;
}
}@Service: Camada de lógica de negócio
@Service é uma especialização de @Component que, semanticamente, indica uma classe de serviço. O Spring a trata da mesma forma que @Component, mas ela transmite a intenção e pode ser usada por mecanismos de AOP.
@Service
public class OrderService {
private final OrderRepository repo;
public OrderService(OrderRepository repo) { this.repo = repo; }
public Order placeOrder(Cart cart) { /* business logic */ return repo.save(new Order(cart)); }
}@Repository: Camada de acesso a dados
@Repository marca classes DAO. O Spring adiciona a tradução automática de exceções de persistência: SQLException e exceções específicas do fornecedor são encapsuladas na hierarquia DataAccessException do Spring.
@Repository
public class JdbcUserRepository {
private final JdbcTemplate jdbc;
public JdbcUserRepository(JdbcTemplate jdbc) { this.jdbc = jdbc; }
public User findById(long id) {
return jdbc.queryForObject("SELECT * FROM users WHERE id=?",
new BeanPropertyRowMapper<>(User.class), id);
}
}@Bean em classes @Configuration
Use @Bean em um método dentro de uma classe @Configuration para registrar componentes manualmente — algo útil para classes de terceiros que não podem ser anotadas.
@Configuration
public class AppConfig {
@Bean
public ObjectMapper objectMapper() {
return new ObjectMapper().registerModule(new JavaTimeModule());
}
@Bean
public RestTemplate restTemplate() { return new RestTemplate(); }
}Varredura de componentes
@SpringBootApplication inicia a varredura de componentes a partir do pacote da aplicação e abrangendo os níveis abaixo. As classes em subpacotes são descobertas automaticamente. Use @ComponentScan(basePackages=...) para personalizar.
// Explicit scan (rarely needed in Spring Boot):
@SpringBootApplication
@ComponentScan(basePackages = {"com.example.app", "com.example.shared"})
public class MyApp { ... }Nomenclatura de componentes
Por padrão, o nome do componente é o nome da classe sem a inicial maiúscula (OrderService → orderService). Especifique um nome personalizado: @Service("orders") ou @Bean("myMapper").
@Service("orderSvc")
public class OrderService { ... }
// Inject by name:
@Autowired @Qualifier("orderSvc")
private OrderService svc;Escopos de componentes
O escopo padrão é singleton (uma instância por contexto do Spring). Outros escopos: prototype (uma nova instância por injeção), request, session (somente na web).
@Service
@Scope("prototype")
public class ReportBuilder {
private List<String> lines = new ArrayList<>();
public void addLine(String line) { lines.add(line); }
}@Primary e @Qualifier para desambiguação
Quando vários componentes implementam a mesma interface, use @Primary para marcar o padrão ou @Qualifier("name") no ponto de injeção para selecionar um componente específico.
@Service @Primary
public class CacheUserService implements UserService { ... }
@Service
public class DbUserService implements UserService { ... }
// Inject specific one:
@Autowired @Qualifier("dbUserService")
private UserService userService;Inicialização tardia
Por padrão, os componentes singleton são criados na inicialização. Anote-os com @Lazy para adiar a criação até o primeiro uso — algo útil para componentes dispendiosos que raramente são usados.
@Service @Lazy
public class HeavyReportService {
public HeavyReportService() { System.out.println("Created on first use"); }
}@PostConstruct e @PreDestroy
Execute a lógica de inicialização após a injeção de dependências com @PostConstruct. Limpe os recursos antes da destruição do componente com @PreDestroy.
@Service
public class CacheService {
@PostConstruct
public void init() { System.out.println("Cache warming up..."); }
@PreDestroy
public void cleanup() { System.out.println("Cache cleared."); }
}Verificação rápida
Que comportamento adicional @Repository adiciona em relação a @Component?
Recapitulação
Use @Service para lógica de negócio, @Repository para DAO, @Component para utilitários e @Bean para tipos de terceiros. @Primary/@Qualifier resolvem componentes múltiplos. Use @PostConstruct/@PreDestroy para ganchos do ciclo de vida.
Perguntas Frequentes
A aula “Ligação de beans: @Component, @Service, @Repository” é grátis?
Sim — o texto completo de “Ligação de beans: @Component, @Service, @Repository” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Java Academy, atualize para CoddyKit PRO. O curso de Java Academy inclui 4 aulas no total.
O que vou aprender em “Ligação de beans: @Component, @Service, @Repository”?
Use anotações estereotipadas, defina beans com @Bean e entenda a varredura de componentes. Você pratica Java Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.
Preciso ter experiência prévia para começar Java Academy?
Nenhuma experiência prévia é necessária. Java Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 3 de 4.
Quanto tempo leva a aula “Ligação de beans: @Component, @Service, @Repository”?
A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.
Posso escrever e executar código nesta aula de Java Academy?
Sim. Cada aula de Java Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.
Todas as aulas deste curso
- Autoconfiguração e starters do Spring Boot
- Propriedades da aplicação e perfis
- Ligação de beans: @Component, @Service, @Repository
- Injeção por construtor e dependências circulares