Bean-Verdrahtung: @Component, @Service, @Repository
Verwenden Sie Stereotyp-Annotationen, definieren Sie Beans mit @Bean und verstehen Sie das Scannen von Komponenten.
Bean-Verdrahtung: @Component, @Service, @Repository ist eine kostenlose Java Academy-Lektion auf CoddyKit. Dies ist Lektion 3 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Java Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Java Academy-Kurs umfasst insgesamt 4 Lektionen.
Stereotyp-Annotationen
Spring stellt Stereotyp-Annotationen bereit, die Klassen als von Spring verwaltete Beans kennzeichnen und ihre Rolle vermitteln: @Component (allgemein), @Service (Geschäftslogik), @Repository (Datenzugriff), @Controller/@RestController (Webschicht).
@Component: Allgemeine Bean
Jede mit @Component annotierte Klasse wird beim Component Scan erkannt und als Spring-Bean registriert. Sie bildet die Grundlage für alle anderen Stereotypen.
@Component
public class EmailFormatter {
public String format(String to, String subject) {
return "To: " + to + "\nSubject: " + subject;
}
}@Service: Schicht für Geschäftslogik
@Service ist eine Spezialisierung von @Component und kennzeichnet semantisch eine Serviceklasse. Spring behandelt sie genauso wie @Component, sie vermittelt jedoch die Absicht und kann von AOP-Advisors verwendet werden.
@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: Datenzugriffsschicht
@Repository kennzeichnet DAO-Klassen. Spring ergänzt automatisch die Übersetzung von Persistenzausnahmen: SQLException und anbieterspezifische Ausnahmen werden in die Spring-Hierarchie von DataAccessException verpackt.
@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 in @Configuration-Klassen
Verwenden Sie @Bean für eine Methode innerhalb einer @Configuration-Klasse, um Beans manuell zu registrieren – nützlich für Klassen von Drittanbietern, die Sie nicht annotieren können.
@Configuration
public class AppConfig {
@Bean
public ObjectMapper objectMapper() {
return new ObjectMapper().registerModule(new JavaTimeModule());
}
@Bean
public RestTemplate restTemplate() { return new RestTemplate(); }
}Component Scanning
@SpringBootApplication startet das Component Scanning ausgehend vom Package der Anwendung und abwärts. Klassen in Unter-Packages werden automatisch gefunden. Verwenden Sie @ComponentScan(basePackages=...), um das Verhalten anzupassen.
// Explicit scan (rarely needed in Spring Boot):
@SpringBootApplication
@ComponentScan(basePackages = {"com.example.app", "com.example.shared"})
public class MyApp { ... }Bean-Namensgebung
Standardmäßig ist der Bean-Name der kleingeschriebene Klassenname (OrderService → orderService). Geben Sie einen benutzerdefinierten Namen an: @Service("orders") oder @Bean("myMapper").
@Service("orderSvc")
public class OrderService { ... }
// Inject by name:
@Autowired @Qualifier("orderSvc")
private OrderService svc;Bean-Scopes
Der Standard-Scope ist singleton (eine Instanz pro Spring-Kontext). Weitere Scopes sind: prototype (eine neue Instanz pro Injection), request und session (nur im Web).
@Service
@Scope("prototype")
public class ReportBuilder {
private List<String> lines = new ArrayList<>();
public void addLine(String line) { lines.add(line); }
}@Primary und @Qualifier zur Unterscheidung
Wenn mehrere Beans dasselbe Interface implementieren, verwenden Sie @Primary, um die Standard-Bean zu kennzeichnen, oder @Qualifier("name") am Injection Point, um eine bestimmte Bean auszuwählen.
@Service @Primary
public class CacheUserService implements UserService { ... }
@Service
public class DbUserService implements UserService { ... }
// Inject specific one:
@Autowired @Qualifier("dbUserService")
private UserService userService;Verzögerte Initialisierung
Standardmäßig werden Singleton-Beans beim Start erstellt. Annotieren Sie eine Bean mit @Lazy, um ihre Erstellung bis zur ersten Verwendung zu verschieben – nützlich für aufwendige Beans, die selten verwendet werden.
@Service @Lazy
public class HeavyReportService {
public HeavyReportService() { System.out.println("Created on first use"); }
}@PostConstruct und @PreDestroy
Führen Sie Initialisierungslogik nach der Dependency Injection mit @PostConstruct aus. Geben Sie Ressourcen vor der Zerstörung einer Bean mit @PreDestroy frei.
@Service
public class CacheService {
@PostConstruct
public void init() { System.out.println("Cache warming up..."); }
@PreDestroy
public void cleanup() { System.out.println("Cache cleared."); }
}Schnelltest
Welches zusätzliche Verhalten fügt @Repository gegenüber @Component hinzu?
Zusammenfassung
Verwenden Sie @Service für Geschäftslogik, @Repository für DAOs, @Component für Hilfsklassen und @Bean für Typen von Drittanbietern. @Primary/@Qualifier lösen Mehrdeutigkeiten zwischen Beans auf. Verwenden Sie @PostConstruct/@PreDestroy für Lifecycle-Hooks.
Häufig gestellte Fragen
Ist die Lektion „Bean-Verdrahtung: @Component, @Service, @Repository“ kostenlos?
Ja — der vollständige Text von „Bean-Verdrahtung: @Component, @Service, @Repository“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Java Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Java Academy-Kurs umfasst insgesamt 4 Lektionen.
Was lerne ich in „Bean-Verdrahtung: @Component, @Service, @Repository“?
Verwenden Sie Stereotyp-Annotationen, definieren Sie Beans mit @Bean und verstehen Sie das Scannen von Komponenten. Du übst Java Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.
Brauche ich Erfahrung, um Java Academy zu starten?
Keine Vorkenntnisse erforderlich. Java Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 3 von 4.
Wie lange dauert die Lektion „Bean-Verdrahtung: @Component, @Service, @Repository“?
Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.
Kann ich in dieser Java Academy-Lektion Code schreiben und ausführen?
Ja. Jede Java Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.
Alle Lektionen in diesem Kurs
- Automatische Konfiguration und Spring-Boot-Starter
- Anwendungseigenschaften und Profile
- Bean-Verdrahtung: @Component, @Service, @Repository
- Konstruktor-Injektion und zirkuläre Abhängigkeiten