Câblage des beans : @Component, @Service, @Repository
Utilisez les annotations de stéréotype, définissez des beans avec @Bean et comprenez l’analyse des composants.
Câblage des beans : @Component, @Service, @Repository est une leçon Java Academy gratuite sur CoddyKit. Ceci est la leçon 3 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Java Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Java Academy comprend 4 leçons au total.
Annotations de stéréotype
Spring fournit des annotations de stéréotype qui indiquent que des classes sont des composants gérés par Spring et précisent leur rôle : @Component (générique), @Service (logique métier), @Repository (accès aux données), @Controller/@RestController (couche web).
@Component : composant générique
Toute classe annotée avec @Component est détectée lors de l’analyse des composants et enregistrée comme composant Spring. C’est la base de tous les autres stéréotypes.
@Component
public class EmailFormatter {
public String format(String to, String subject) {
return "To: " + to + "\nSubject: " + subject;
}
}@Service : couche de logique métier
@Service est une spécialisation de @Component qui indique sémantiquement qu’il s’agit d’une classe de service. Spring la traite comme @Component, mais elle exprime l’intention et peut être utilisée par les conseillers 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 : couche d’accès aux données
@Repository marque les classes DAO. Spring ajoute une traduction automatique des exceptions de persistance : SQLException et les exceptions propres au fournisseur sont encapsulées dans la hiérarchie DataAccessException de 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 dans les classes @Configuration
Utilisez @Bean sur une méthode d’une classe @Configuration pour enregistrer manuellement des composants — ce qui est utile pour les classes tierces que vous ne pouvez pas annoter.
@Configuration
public class AppConfig {
@Bean
public ObjectMapper objectMapper() {
return new ObjectMapper().registerModule(new JavaTimeModule());
}
@Bean
public RestTemplate restTemplate() { return new RestTemplate(); }
}Analyse des composants
@SpringBootApplication déclenche l’analyse des composants à partir du paquetage de l’application et de ses sous-paquetages. Les classes des sous-paquetages sont découvertes automatiquement. Utilisez @ComponentScan(basePackages=...) pour personnaliser ce comportement.
// Explicit scan (rarely needed in Spring Boot):
@SpringBootApplication
@ComponentScan(basePackages = {"com.example.app", "com.example.shared"})
public class MyApp { ... }Nommage des composants
Par défaut, le nom du composant est le nom de la classe avec sa première lettre en minuscule (OrderService → orderService). Indiquez un nom personnalisé : @Service("orders") ou @Bean("myMapper").
@Service("orderSvc")
public class OrderService { ... }
// Inject by name:
@Autowired @Qualifier("orderSvc")
private OrderService svc;Portées des composants
La portée par défaut est singleton (une instance par contexte Spring). Les autres portées sont : prototype (une nouvelle instance par injection), request et session (uniquement sur le web).
@Service
@Scope("prototype")
public class ReportBuilder {
private List<String> lines = new ArrayList<>();
public void addLine(String line) { lines.add(line); }
}@Primary et @Qualifier pour lever les ambiguïtés
Lorsque plusieurs composants implémentent la même interface, utilisez @Primary pour marquer le composant par défaut, ou @Qualifier("name") au point d’injection pour en sélectionner un précisément.
@Service @Primary
public class CacheUserService implements UserService { ... }
@Service
public class DbUserService implements UserService { ... }
// Inject specific one:
@Autowired @Qualifier("dbUserService")
private UserService userService;Initialisation différée
Par défaut, les composants singleton sont créés au démarrage. Ajoutez @Lazy pour différer leur création jusqu’à leur première utilisation — ce qui est utile pour les composants coûteux et rarement utilisés.
@Service @Lazy
public class HeavyReportService {
public HeavyReportService() { System.out.println("Created on first use"); }
}@PostConstruct et @PreDestroy
Exécutez la logique d’initialisation après l’injection des dépendances avec @PostConstruct. Libérez les ressources avant la destruction du composant avec @PreDestroy.
@Service
public class CacheService {
@PostConstruct
public void init() { System.out.println("Cache warming up..."); }
@PreDestroy
public void cleanup() { System.out.println("Cache cleared."); }
}Vérification rapide
Quel comportement supplémentaire @Repository apporte-t-il par rapport à @Component ?
Récapitulatif
Utilisez @Service pour la logique métier, @Repository pour le DAO, @Component pour les utilitaires et @Bean pour les types tiers. @Primary/@Qualifier permettent de résoudre les ambiguïtés entre plusieurs composants. Utilisez @PostConstruct/@PreDestroy pour les points d’extension du cycle de vie.
Questions Fréquemment Posées
La leçon « Câblage des beans : @Component, @Service, @Repository » est-elle gratuite ?
Oui — le texte complet de « Câblage des beans : @Component, @Service, @Repository » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Java Academy, passe à CoddyKit PRO. Le cours Java Academy comprend 4 leçons au total.
Qu'est-ce que j'apprendrai dans « Câblage des beans : @Component, @Service, @Repository » ?
Utilisez les annotations de stéréotype, définissez des beans avec @Bean et comprenez l’analyse des composants. Tu pratiques Java Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.
Dois-je avoir de l'expérience pour commencer Java Academy ?
Aucune expérience préalable n'est requise. Java Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 3 sur 4.
Combien de temps prend la leçon « Câblage des beans : @Component, @Service, @Repository » ?
La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.
Peux-tu écrire et exécuter du code dans cette leçon Java Academy ?
Oui. Chaque leçon Java Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.
Toutes les leçons de ce cours
- Auto-configuration et starters Spring Boot
- Propriétés d’application et profils
- Câblage des beans : @Component, @Service, @Repository
- Injection par constructeur et dépendances circulaires