Glossary

The exam is precise about words. These definitions are the ones we use in every lesson — learn them exactly. Grows as the course does.

ApplicationContext

Spring's central interface for the IoC container. A BeanFactory with enterprise extras: event publishing, i18n (MessageSource), resource loading, and automatic BeanPostProcessor/BeanFactoryPostProcessor registration. It's what actually holds and wires your beans.

Advice

(AOP) The action taken by an aspect at a join point — the "what". Types: @Before, @AfterReturning, @AfterThrowing, @After (finally), @Around.

Aspect

(AOP) A module of cross-cutting concern (e.g. logging, transactions) = pointcut + advice.

Autowiring

Spring supplying a bean's dependencies automatically. With @Autowired, resolution is by type first, then narrowed by @Qualifier / @Primary / bean name.

Bean

An object instantiated, assembled, and managed by the Spring IoC container. If Spring made it and holds it, it's a bean.

BeanFactory

The most basic IoC container interface. ApplicationContext extends it. Lazy by default; ApplicationContext pre-instantiates singletons eagerly.

BeanPostProcessor (BPP)

Extension point that operates on bean instances — postProcessBeforeInitialization / AfterInitialization. This is how proxies (AOP, @Transactional) get wrapped around beans.

BeanFactoryPostProcessor (BFPP)

Extension point that operates on bean definitions (metadata) before any bean is instantiated. e.g. PropertySourcesPlaceholderConfigurer resolving ${...}.

Component scanning

Automatic detection of classes annotated with stereotypes (@Component and friends) to register them as beans. Enabled by @ComponentScan (included in @SpringBootApplication).

DataAccessException

Root of Spring's unchecked data-access exception hierarchy. Spring translates vendor-specific SQLExceptions into these portable, technology-agnostic exceptions.

Dependency Injection (DI)

The pattern where an object's dependencies are supplied from outside rather than created internally. Constructor injection is preferred (immutability, testability, no partially-built objects).

Inversion of Control (IoC)

The principle that the framework, not your code, controls object creation and wiring. DI is how Spring implements IoC.

Join point

(AOP) A point during execution where advice can run. In Spring AOP this is always a method execution.

Pointcut

(AOP) A predicate that selects join points — the "where". e.g. execution(* com.app.service.*.*(..)).

Primary / Qualifier

@Primary marks the default bean when multiple candidates match by type; @Qualifier("name") selects a specific one at the injection point.

Proxy

A generated wrapper Spring places around a bean to add behaviour (AOP advice, transactions). JDK dynamic proxy if the bean implements an interface; CGLIB subclass proxy otherwise. Self-invocation (calling this.method()) bypasses the proxy.

Scope

The lifecycle & visibility of a bean instance. singleton (default, one per container), prototype (new each request), plus web scopes request, session, application, websocket.

Stereotype annotation

A specialised @Component: @Service, @Repository (adds exception translation), @Controller/@RestController. All are detected by component scanning.

Transaction propagation

How a @Transactional method joins/creates transactions. Defaults to REQUIRED (join existing or start new); REQUIRES_NEW always starts a new one; NESTED uses savepoints.