Java Academy · Les

Beans koppelen: @Component, @Service, @Repository

Gebruik stereotype-annotaties, definieer beans met @Bean en begrijp component scanning.

Les 3 van 413 stappen

Beans koppelen: @Component, @Service, @Repository is een gratis Java Academy-les op CoddyKit. Dit is les 3 van 4. Je kunt de volledige les hieronder gratis lezen en daarna in de browser praktisch oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject Java Academy. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus Java Academy bevat in totaal 4 lessen.

Stereotype-annotaties

Spring biedt stereotype-annotaties die klassen markeren als door Spring beheerde beans en hun rol aangeven: @Component (algemeen), @Service (bedrijfslogica), @Repository (gegevenstoegang), @Controller/@RestController (weblaag).

@Component: Algemene bean

Elke klasse met de annotatie @Component wordt tijdens de componentscan gedetecteerd en als Spring-bean geregistreerd. Het is de basis voor alle andere stereotypes.

@Component
public class EmailFormatter {
    public String format(String to, String subject) {
        return "To: " + to + "\nSubject: " + subject;
    }
}

@Service: Laag voor bedrijfslogica

@Service is semantisch een specialisatie van @Component die aangeeft dat het om een serviceklasse gaat. Spring behandelt deze hetzelfde als @Component, maar de annotatie geeft de bedoeling aan en kan door AOP-adviseurs worden gebruikt.

@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: Laag voor gegevenstoegang

@Repository markeert DAO-klassen. Spring voegt automatisch vertaling van persistentie-uitzonderingen toe: SQLException en leveranciersspecifieke uitzonderingen worden verpakt in de hiërarchie van Spring's DataAccessException.

@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

Gebruik @Bean op een methode binnen een @Configuration-klasse om beans handmatig te registreren — nuttig voor klassen van derden die je niet kunt annoteren.

@Configuration
public class AppConfig {
    @Bean
    public ObjectMapper objectMapper() {
        return new ObjectMapper().registerModule(new JavaTimeModule());
    }
    @Bean
    public RestTemplate restTemplate() { return new RestTemplate(); }
}

Componentscan

@SpringBootApplication start de componentscan vanuit het pakket van de toepassing en alle onderliggende pakketten. Klassen in subpakketten worden automatisch gevonden. Gebruik @ComponentScan(basePackages=...) om dit aan te passen.

// Explicit scan (rarely needed in Spring Boot):
@SpringBootApplication
@ComponentScan(basePackages = {"com.example.app", "com.example.shared"})
public class MyApp { ... }

Naamgeving van beans

Standaard is de beannaam de naam van de klasse met een kleine beginletter (OrderService → orderService). Geef een aangepaste naam op: @Service("orders") of @Bean("myMapper").

@Service("orderSvc")
public class OrderService { ... }
// Inject by name:
@Autowired @Qualifier("orderSvc")
private OrderService svc;

Bean-bereiken

Het standaardbereik is singleton (één instantie per Spring-context). Andere bereiken zijn: prototype (nieuwe instantie per injectie), request en session (alleen voor webtoepassingen).

@Service
@Scope("prototype")
public class ReportBuilder {
    private List<String> lines = new ArrayList<>();
    public void addLine(String line) { lines.add(line); }
}

@Primary en @Qualifier voor ondubbelzinnigheid

Wanneer meerdere beans hetzelfde koppelvlak implementeren, gebruik je @Primary om de standaardbean te markeren, of @Qualifier("name") op het injectiepunt om een specifieke bean te selecteren.

@Service @Primary
public class CacheUserService implements UserService { ... }
@Service
public class DbUserService implements UserService { ... }
// Inject specific one:
@Autowired @Qualifier("dbUserService")
private UserService userService;

Uitgestelde initialisatie

Standaard worden singleton-beans bij het opstarten gemaakt. Gebruik de annotatie @Lazy om het aanmaken uit te stellen tot het eerste gebruik — nuttig voor dure beans die zelden worden gebruikt.

@Service @Lazy
public class HeavyReportService {
    public HeavyReportService() { System.out.println("Created on first use"); }
}

@PostConstruct en @PreDestroy

Voer initialisatielogica uit na afhankelijkheidsinjectie met @PostConstruct. Ruim bronnen op vóór de vernietiging van de bean met @PreDestroy.

@Service
public class CacheService {
    @PostConstruct
    public void init() { System.out.println("Cache warming up..."); }
    @PreDestroy
    public void cleanup() { System.out.println("Cache cleared."); }
}

Korte controle

Welke extra functionaliteit voegt @Repository toe ten opzichte van @Component?

Beantwoord dit in de interactieve les

Samenvatting

Gebruik @Service voor bedrijfslogica, @Repository voor DAO's, @Component voor hulpprogramma's en @Bean voor typen van derden. @Primary/@Qualifier lossen conflicten tussen meerdere beans op. Gebruik @PostConstruct/@PreDestroy voor acties tijdens de levenscyclus.

Gratis beginnen

Leer Java met een AI-tutor — gratis

Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.

Cursussen: 104
Lessen: 374

Gratis beginnen met leren Bekijk de volledige cursus

Veelgestelde vragen

Is de les “Beans koppelen: @Component, @Service, @Repository” gratis?

Ja — de volledige tekst van “Beans koppelen: @Component, @Service, @Repository” kun je hier gratis op het web lezen. Als je interactief wilt oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is, en de rest van de cursus Java Academy wilt ontgrendelen, kun je upgraden naar CoddyKit PRO. De cursus Java Academy bevat in totaal 4 lessen.

Wat leer ik in “Beans koppelen: @Component, @Service, @Repository”?

Gebruik stereotype-annotaties, definieer beans met @Bean en begrijp component scanning. Je oefent met Java Academy door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.

Heb ik ervaring nodig om met Java Academy te beginnen?

Ervaring vooraf is niet nodig. Java Academy op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 3 van 4.

Hoe lang duurt de les “Beans koppelen: @Component, @Service, @Repository”?

De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.

Kan ik code schrijven en uitvoeren in deze les over Java Academy?

Ja. Elke les over Java Academy bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.

Alle lessen in deze cursus

Auto-configuratie en Spring Boot Starters
Applicatieproperties en profielen
Beans koppelen: @Component, @Service, @Repository
Constructor-injectie en circulaire afhankelijkheden

← Terug naar Java Academy