Spring vs Spring Boot

Spring and Spring Boot are popular frameworks in the Java ecosystem that simplify the development of enterprise and microservices-based applications. They provide powerful features to reduce boilerplate code and improve productivity while building robust systems.

• Enables development of scalable and production-ready applications
• Reduces complexity through simplified configuration and auto-setup
• Promotes modular design using reusable components

Spring 

Spring is a comprehensive Java framework that provides support for building robust and scalable enterprise applications. It focuses on dependency injection, aspect-oriented programming, and modular architecture.

• Dependency Injection (DI): Simplifies object creation and management, promoting loose coupling.
• Modular Framework: Offers various modules like Spring MVC, Spring Security, Spring Data, allowing selective use.
• Flexible Configuration: Supports XML, annotations, and Java-based configuration for application setup.

Example: Spring application manually configured with beans and controllers:

@Configuration
@ComponentScan(basePackages = "com.example")
public class AppConfig {
    @Bean
    public UserService userService() {
        return new UserServiceImpl();
    }
}

@Controller
@RequestMapping("/users")
public class UserController {
    @Autowired
    private UserService userService;

    @GetMapping
    public String getUsers(Model model) {
        model.addAttribute("users", userService.getAllUsers());
        return "userList"; // JSP or HTML view
    }
}

// Main class deployed as WAR on external server like Tomcat
public class Main {
    public static void main(String[] args){
        
        // Deploy this app manually to an external server
    }
}

Explanation: This is a traditional Spring MVC application using Java-based configuration, where beans are defined manually and components are scanned for dependency injection. The application is deployed as a WAR file on an external server like Tomcat, with a controller handling web requests and returning a view.

Spring Boot 

Spring Boot is a project built on top of Spring that simplifies the development of Spring applications by providing auto-configuration, embedded servers, and production-ready features. It is designed to reduce boilerplate code and setup complexity.

• Auto-Configuration: Automatically configures Spring applications based on the dependencies added.
• Embedded Servers: Comes with embedded Tomcat, Jetty, or Undertow, eliminating the need for external servers.
• Starter POMs: Provides ready-to-use dependencies to simplify build configuration.

Example: Spring Boot REST API with minimal configuration:

@SpringBootApplication
public class UserApplication{
    
    public static void main(String[] args) {
        
        // Embedded Tomcat runs automatically
        SpringApplication.run(UserApplication.class, args); 
    }
}

@RestController
@RequestMapping("/api/users")
public class UserController {
    private List<String> users = List.of("Alice", "Bob", "Charlie");

    @GetMapping
    public List<String> getUsers() {
        
        // Returns JSON response
        return users; 
    }
}

Explanation: This is a Spring Boot application that uses auto-configuration and an embedded server, so no manual setup or deployment is required. It exposes a REST API that directly returns JSON data instead of rendering a view.

Spring vs Spring Boot