Computer Science Wiki

Spring and Spring Boot

3 min read

Spring is one of the most popular and widely used Java frameworks in enterprise development. It is a Java platform that provides comprehensive infrastructure support for developing large scale Java applications including web applications, microservices, and distributed systems in a modular and loosely coupled manner. It provides a rich range of features including Dependency Injection (DI), Aspect-Oriented Programming (AOP), data access, transaction management, and more. One of the key benefits of using Spring is that it allows developers to focus more on business logic by abstracting away the complexities of object creation, dependency management, and control flow.

Inversion of Control (IoC)

IoC is a design principle that transfers the control of object creation and dependency management from the application code to the Spring Framework. The benefits of IoC are:

  • Decoupling
    • Objects are not responsible for creating or managing their dependencies.
  • Easier testing
    • Mock dependencies can be injected during testing.
  • Flexible
    • Changing dependencies are easier because they are managed externally.
  • Reusability
    • Components can be reused as they are loosely coupled.

IoC container

The IoC container in Spring is the core component responsible for managing the lifecycle, configuration, and dependencies of beans (objects managed by Spring Framework) within a Spring application. The IoC container ensures that the dependencies required by objects are injected at runtime. In the Spring framework, the interface ApplicationContext represents the IoC container.

Spring bean

A bean is a instance of a class managed by the Spring framework, specifically, the IoC container. When you define a class as a Spring bean (using XML configuration or annotation), the framework takes control of its lifecycle, including its creation, initialisation, dependency injection, and destruction.

Dependency Injection (DI)

Dependency injection is a pattern used to implement IoC where the framework injects required dependencies (the other objects with which they work) into objects automatically rather than the objects creating those dependencies themselves. The objects have to define their dependencies only through constructor arguments, arguments to a factory method, or properties that are set on the object instance after it is constructed or returned from a factory method. This process is fundamentally the IoC.

Spring Boot

Spring Boot is a framework built on top of the Spring Framework. It simplifies the process of creating production-ready Spring applications by minimising boilerplate configuration and providing default settings. You can start with Spring Boot as it offers faster and more convenient way to build applications, or you can start with Spring Framework to understand how things work in the background (such as dependency injection, ApplicationContext, and bean lifecycle management) in a traditional way.

Java reflection

Spring Framework relies on Java reflection API to provide its core functionality, especially for dependency injection (create object instances, Inject dependencies into fields, methods, and constructors), aspect-oriented programming, and other dynamic features. Using reflection repeatedly can impact performance. Spring optimises it by:

  • Caching Metadata
    • Spring scans classes only once and stores metadata (e.g., annotated fields, methods) in caches for reuse.
  • Lazy initialisation
    • Reflection is used only when required (e.g., lazy-loaded beans).
  • Efficient proxies
    • Spring minimises reflection overhead by using bytecode manipulation libraries like CGLIB or JDK dynamic proxies.

Table of contents

Web_and_App_Development Java Java_Framework Spring_Framework Spring_Boot

Reference:

Graph View

Backlinks