Spring IoC and AOP Principles Explained

Spring IoC, or Inversion of Control, is a design principle where the framework manages object creation and dependency injection instead of the application code. The Spring container (ApplicationContext) reads configuration — whether from XML, annotations like @Component and @Autowired, or Java @Configuration classes — and creates a dependency graph of beans. When a bean needs a dependency, the container injects it via constructor, setter, or field injection. The bean lifecycle includes instantiation, dependency injection, various aware interface callbacks, BeanPostProcessor hooks, initialization (@PostConstruct), and finally destruction (@PreDestroy). This lifecycle is what enables AOP to work. Spring AOP uses the proxy pattern to add behavior to beans without modifying their code. When you annotate a method with @Transactional, for example, Spring wraps the bean in a proxy. For beans implementing interfaces, Spring uses JDK dynamic proxies; for concrete classes, it uses CGLIB to generate a subclass at runtime. The proxy intercepts method calls and executes advice — @Before runs before the method, @After runs after, and @Around wraps the entire execution with custom logic. The pointcut expression defines which methods the advice applies to. Internally, Spring AOP is built on the BeanPostProcessor mechanism — AbstractAutoProxyCreator checks each bean during initialization and wraps it in a proxy if any advisor matches. This is why self-invocation bypasses AOP — calling this.method() doesn't go through the proxy.