Spring is one of the most widely used frameworks in Java development. It provides a comprehensive programming and configuration model for modern enterprise applications. Understanding Spring is essential for building scalable, maintainable, and testable applications, because many applications depend on it for tasks like dependency management, configuration, and testing.

Spring Boot is a tool built on top of Spring that makes it easier to create stand-alone, production-ready applications with minimal configuration. It removes boiler-plate code and provides sensible defaults, which reduces setup time and complexity. Spring Boot provides tools like Spring Initializr, spring profiles, and environment configuration to streamline development and deployment. These features allow developers to quickly scaffold projects, manage environments, and reduce errors during deployment.

There is a variety of reading material provided here, it’s not essential to read it all, some covers similar content from a different point of view.

Self Study

Reading material

• What are Java Frameworks?
• Introduction to Spring Framework
• Introduction to Inversion of Control and Dependency Injection with Spring
• Why is field injection not recommended?
• How Spring Boot compares to Spring
• Boot strap a simple application
• Spring boot annotations

Framework documentation

These pages may be a useful first port of call when troubleshooting, but you don’t need to read them in their entirety:

• Spring Framework documentation
• Spring Boot documentation
• Spring Initializr documentation

Exercises

Quiz

1. Which of these best describes how the Spring Framework helps a developer build an application?
2. It acts as a “glue” that manages how different objects (dependencies) interact with each other
3. It provides specialised modules to help with tasks like Database access.
4. It removes the need for boiler-plate code
5. All of the above
6. Which annotation is used to indicate a Spring-managed bean?
7. @Component
8. @Bean
9. @Service
10. All of the above
11. What is dependency injection in Spring?
12. The process of creating an object
13. A design pattern for managing object creation
14. A way to achieve loose coupling between classes
15. Both 2 and 3
16. What annotation is used for automatic dependency injection in Spring?
17. @Inject
18. @Autowired
19. @Resource
20. @Qualifier

Answers

1. • 4: Spring acts as comprehensive toolbox that manges how objects interact, provides pre-built modules and eliminates repetitive setup code in favour of an annotation-driven approach
2. • 4: All these annotations indicate a Spring-managed bean. @Component is a generic stereotype, while @Service is used for service-layer beans, and @Bean is used in configuration classes.
3. • 4: Dependency injection is a design pattern that allows for loose coupling between classes by managing object creation and dependencies outside of the classes themselves.
4. • 2: The @Autowired annotation is used to tell Spring to automatically find and inject dependencies into a field, constructor or setter, without needing to instantiate objects using the new keyword

Most enterprise apps need persistent data (i.e. data that remains after the application/process that created it shuts down). Java Persistence API (JPA) provides a standard for object-relational mapping (ORM) (i.e. JPA defines how Java objects are mapped to database data). Spring Data JPA is built on top of this to reduce boilerplate code, and makes database access simple and consistent.

In a Spring application @Entity annotated classes represent data stored in the database. These are simple Java classes where each field in the class corresponds to a column in the table. Fields may be marked with annotations such as @Id and @Column.

For example, the following Entity represents an Employee table with three columns, id, name and email.

@Entity
public class Employee {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
 
    @Column(name = "name")
    private String name;
 
    @Column(name = "email")
    private String email;
 
    // Constructors, getters, and setters
}

@Repository annotated interfaces define how the data in the database is queried and persisted. Spring automatically generates Create, Read, Update, Delete (CRUD) operations. By following specific naming conventions, Spring Data JPA automatically generates queries at runtime, we call these Query Methods. Query methods are repository interface methods where the query is derived from the method name.

For example:

List<Entity>; findByFieldName(DataType fieldName);

Self Study

Reading Material

• Introduction to JPA
• Introduction to Spring Data JPA
• Documentation with examples

Exercises

Quiz

• Which of the following annotations is used for defining a repository bean?
  • @Service
  • @Component
  • @Repository
  • @Controller

Answers

1 - C: The @Repository annotation is specifically used to mark a class as a Data Access Object (DAO) or repository.

Importance: This introduces persistence, which is essential for real-world applications like e-commerce, social media, and enterprise systems.

REST stands for Representational State Transfer and allows applications to communicate using HTTP methods, for example GET, POST, PUT and DELETE. REST APIs follow a stateless architecture, i.e. every request contains all the necessary information for the server to process it without relying on previous requests.

Spring REST is part of the Spring Framework, which simplifies the process of writing REST APIs by providing support for handling HTTP requests, data conversion & error handling. To utilise Spring REST, we must have a dependency on Spring WEB (spring-boot-starter-web) in our project.

REST Controllers manage HTTP requests, to define a REST Controller, we use the @RestController spring annotation.

Postman is a popular HTTP client used for sending HTTP requests to a REST API and checking the response, allowing you to test out your newly created APIs.

Reading material

• Overview of HTTP
• Building REST services with Spring
• Introduction to Spring REST

Exercises

Testing ensures that your application is reliable, maintainable, and behaves the way you expect. Spring Boot provides powerful, built‑in support for testing through JUnit and Mockito, making it easy to test everything from small pieces of logic to full application flows. In this section, students will learn the difference between unit and integration tests, how to write each type using Spring Boot’s testing tools, and how to use Mockito to isolate components with mocks. By the end, they’ll have a solid foundation in verifying Spring applications efficiently and consistently.

Reading material

• Unit testing with spring framework
• Integration testing with spring framework
• MockMvc