This project is a pure Spring Framework (Spring Core) learning project designed to demonstrate the fundamental concepts behind Spring's Inversion of Control (IoC) container, Dependency Injection (DI), bean management, autowiring, and component scanning.
Unlike Spring Boot, this project uses the core Spring Framework directly, helping build a deeper understanding of how Spring manages objects, dependencies, and application configuration internally.
This project serves as a foundational step toward mastering Spring Boot and enterprise backend development.
The primary goal of this project is to learn and demonstrate:
- Inversion of Control (IoC)
- Dependency Injection (DI)
- Tight vs Loose Coupling
- Bean configuration using XML
- Constructor Injection
- Setter Injection
- Autowiring (byName, byType, constructor)
- Annotation-based configuration
- Component Scanning
- Spring IoC Container behavior
- ApplicationContext usage
- Java 23 (or compatible version)
- Spring Core
- Spring Context
- Maven
Dependencies used:
- spring-core
- spring-context
Spring_Project
│
├── src
│ ├── main
│ │ ├── java
│ │ │
│ │ │── car.example
│ │ │ ├── bean
│ │ │ │ ├── App.java
│ │ │ │ └── MyBean.java
│ │ │ │
│ │ │ ├── constructor.injection
│ │ │ │ ├── App.java
│ │ │ │ ├── Car.java
│ │ │ │ └── Specification.java
│ │ │ │
│ │ │ └── setter.injection
│ │ │ ├── App.java
│ │ │ ├── Car.java
│ │ │ └── Specification.java
│ │ │
│ │ │── com.example
│ │ │ └── autowire
│ │ │ ├── constructor
│ │ │ │ ├── App.java
│ │ │ │ ├── Car.java
│ │ │ │ └── Specification.java
│ │ │ │
│ │ │ ├── name
│ │ │ │ ├── App.java
│ │ │ │ ├── Car.java
│ │ │ │ └── Specification.java
│ │ │ │
│ │ │ └── type
│ │ │ ├── App.java
│ │ │ ├── Car.java
│ │ │ └── Specification.java
│ │ │
│ │ │── autowired.annotations
│ │ │ ├── App.java
│ │ │ ├── AppConfig.java
│ │ │ ├── Employee.java
│ │ │ └── Manager.java
│ │ │
│ │ │── componentscan.annotation
│ │ │ ├── App.java
│ │ │ └── Employee.java
│ │ │
│ │ │── ioc.coupling
│ │ │ ├── IOCExample.java
│ │ │ ├── NewDatabaseProvider.java
│ │ │ ├── UserDatabaseProvider.java
│ │ │ ├── UserDataProvider.java
│ │ │ ├── UserManager.java
│ │ │ └── WebServiceDataProvider.java
│ │ │
│ │ │── loose.coupling
│ │ │ ├── LooseCouplingExample.java
│ │ │ ├── NewDatabaseProvider.java
│ │ │ ├── UserDatabaseProvider.java
│ │ │ ├── UserDataProvider.java
│ │ │ └── UserManager.java
│ │ │
│ │ │── tight.coupling
│ │ │ ├── TightCouplingExample.java
│ │ │ ├── UserDatabase.java
│ │ │ └── UserManager.java
│ │ │
│ │ └── resources
│ │ ├── applicationBeanContext.xml
│ │ ├── applicationConstructorInjection.xml
│ │ ├── applicationIoCLooseCouplingExample.xml
│ │ ├── applicationSetterInjection.xml
│ │ ├── autowireByConstructor.xml
│ │ ├── autowireByName.xml
│ │ ├── autowireByType.xml
│ │ └── componentScanDemo.xml
│ │
│ └── test
│
├── pom.xml
├── .gitattributes
└── README.md
In traditional programming, objects create their dependencies.
In Spring, the container creates and manages objects.
Example (Without IoC):
UserManager manager = new UserManager();
Example (With IoC):
Spring creates the UserManager object and injects dependencies automatically.
Benefits:
- Reduces coupling
- Improves flexibility
- Improves maintainability
Dependency Injection means providing dependencies to objects instead of letting them create dependencies themselves.
Spring supports multiple types:
Dependencies are injected through the constructor.
Example:
public Car(Specification spec) {
this.spec = spec;
}
Configured in XML:
<constructor-arg ref="specificationBean"/>
Benefits:
- Ensures required dependencies are available
- Makes objects immutable
Dependencies are injected using setter methods.
Example:
public void setSpecification(Specification spec) {
this.spec = spec;
}
Configured in XML:
<property name="specification" ref="specificationBean"/>
Benefits:
- Allows optional dependencies
- More flexible
Spring automatically injects dependencies.
Types demonstrated:
Matches bean name with property name.
autowire="byName"
Matches bean type with property type.
autowire="byType"
Matches constructor parameter type.
autowire="constructor"
Uses annotations like:
@Autowired
@Component
@Configuration
Spring automatically resolves dependencies.
Benefits:
- Cleaner code
- Less XML configuration
Spring automatically detects classes annotated with:
@Component
@Service
@Repository
Configured using:
<context:component-scan base-package="com.example"/>
Classes depend directly on specific implementations.
Example:
UserDatabase db = new UserDatabase();
Problems:
- Hard to change implementation
- Not flexible
Classes depend on interfaces instead of implementations.
Example:
UserDataProvider provider;
Spring injects appropriate implementation.
Benefits:
- Flexible
- Easy to extend
- Easier testing
The container:
- Creates objects (beans)
- Injects dependencies
- Manages lifecycle
Example:
ApplicationContext context =
new ClassPathXmlApplicationContext("applicationContext.xml");
- Java installed
- Maven installed
- IDE (IntelliJ recommended)
mvn clean install
Run any App.java file from IDE.
Example:
car.example.constructor.injection.App
or
ioc.coupling.IOCExample
After completing this project, you will understand:
- How Spring IoC container works
- How Spring manages objects
- How Dependency Injection works internally
- Difference between tight coupling and loose coupling
- XML vs Annotation configuration
- Foundation required for Spring Boot
- Add Spring Boot version of project
- Add Spring MVC
- Add database integration
- Add REST APIs
Aaryaman Jhatakia
GitHub: https://github.com/Aaryamanjhatakia