Is It Worth Learning Spring Boot in 2023
Tags: springboot, java, backend, microservices
Published: 2023-11-22 10:55:29

In this blog, I’ll outline why learning and mastering Spring Boot in 2023 is a worthwhile endeavor, even though there may be a few differing opinions. I’ll also explore how Spring Boot compares to other backend technologies and alternative Java frameworks.

##10 REASONS WHY LEARNING SPRING BOOT IS WORTH IT IN 2023

Hey folks, I’m currently in the process of exploring backend technologies, particularly for startups where time-to-market is crucial. As I started my research to find a technology that complements my existing knowledge, my heart was leaning toward Spring. However, there was a common concern that kept cropping up – many voices in the community seemed to echo the same sentiment: Spring Boot is sluggish in terms of development speed.

In my case, it’s even more confusing because I have a similar level of proficiency in Django, Node, and Spring. So, I decided to put them to the test, not with simple to-do lists or hello-world apps, but with a complex part of my app. And frankly, my experience led me to a different conclusion. I strongly disagree with the idea that Spring is slower when it comes to development speed. In fact, quite the opposite.

To make my decision-making process even more difficult,  I also get a choice of between the alternatives in building backend apps on Java like Quarkurs, Micronaut, VertX, Play + Akka, Dropwizard, etc. and the list can be even bigger if to include Kotlin, Scala and Clojure frameworks. 

I know that Spring/Boot does have a lot of problems to overcome. But the same counts for other ones as well. But the development speed part seems unjustified. So I continued my research and got more opinions. Based on my results and the different POVs of different Java SE and EM. 

The answer is yes, in 2023, and most likely will be in 2033 as well. Spring is everywhere! 

In this blog, I’ll list the reasons it is worth learning Spring Boot in 23 and how it compares to other backend technologies and alternative Java frameworks.

##1. SPRING REMAINS VIABLE, AND ITS TRACK RECORD OF STAYING CURRENT AND RELEVANT IS IMPRESSIVE


![diagram of best frameworks for Java](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/9anzrin6l1beyvm49akz.png)

Many experienced developers I’ve had the privilege to speak and work with, who have been deeply involved in the world of Java and Spring for many years, readily admit that the release of Spring Boot was nothing short of a relief. 

The burden of configuring every aspect of a Spring application was overwhelming, especially for newbies, and Spring Boot’s introduction marked a turning point. It brought simplicity and efficiency to Java development, allowing developers to shed the burden of a lot of boilerplate code and focus on what truly mattered: writing robust business logic.

But it doesn’t stop there. What truly sets Spring Boot apart is its ability to evolve. It’s not merely a technology of the past. Instead, it has continually adapted to meet the ever-changing demands of modern software development.

Spring Boot’s journey, marked by continuous innovation, a dynamic and supportive community, and an inherent commitment to staying at the forefront of technology trends, is a testament to its reliability.

Spring Boot now provides enterprise-ready features and integrates well with the microservices and cloud-native trend, providing a platform that’s perfectly suited for building scalable, distributed applications in a cloud-centric world.
According to the recent developer ecosystem survey JetBrains, Spring Boot and Spring MVC keep their leading positions as the most used web frameworks for developing in Java.

##2. THE ECOSYSTEM INTEGRATES WITH EXISTING POPULAR LIBRARIES

```java
<dependencies>
   <dependency>
     <groupId>org.springframework.boot</groupId>
     <artifactId>spring-boot-starter-data-jdbc</artifactId>
   </dependency>
   <dependency
     <groupId>org.springframework.boot</groupId>
     <artifactId>spring-boot-starter-data-jpa</artifactId>
   </dependency>
   <dependency>
     <groupId>org.springframework.boot</groupId>
     <artifactId>spring-boot-starter-graphql</artifactId>
   </dependency>
   <dependency>
     <groupId>com.mysql</groupId>
     <artifactId>mysql-connector-j</artifactId>
     <scope>runtime</scope>
   </dependency>
 
   <dependency>
     <groupId>org.springframework.boot</groupId>
     <artifactId>spring-boot-starter-test</artifactId>
     <scope>test</scope>
   </dependency>
   <dependency>
     <groupId>org.springframework.amqp</groupId>
     <artifactId>spring-rabbit-test</artifactId>
     <scope>test</scope>
   </dependency>
   <dependency>
     <groupId>org.springframework.graphql</groupId>
     <artifactId>spring-graphql-test</artifactId>
     <scope>test</scope>
   </dependency>
 </dependencies>
```
As a developer in the present day, you’ll find yourself juggling many tools and libraries to build applications.  These tools range from programming languages, frameworks, and libraries to databases, database connectors like Hibernate and JPA, and messaging systems like Apache Kafka and RabbitMQ. 

Let’s say you’re building a web application. You might use a programming language like Python, a backend web framework, a front-end framework, and a database like PostgreSQL. You may also need to tap into various third-party APIs for functionalities like payment processing, user authentication, and sometimes geolocation services. It is your job as a developer to make all of these components work seamlessly together.

Modern frameworks like Spring Boot make your work as a developer much easier.  Instead of trying to integrate these tools yourself each time you’re developing a new product, Spring Boot really makes your life as a developer much easier by streamlining the process of incorporating these technologies into your project.

 This reduces the time you’d have to spend integrating them by yourself and makes you a more efficient developer.

If you have been following developments in the tech space in the last couple of years, you can actually attest that Spring Boot has done well in keeping up with new libraries and tools that have emerged. Whether you’re working with GraphQL for powerful query languages, reactive programming with Spring WebFlux, or cloud-native technologies such as Docker and Kubernetes, Spring Boot integrates seamlessly, making it an excellent choice for modern development.

##3. SPRING IS EVERYWHERE – PERSONAL OR CORPORATE

When I reflect on my developer journey, I can’t help but appreciate how Spring Boot has become an integral part of my career. It’s a framework that bridges the gap between my personal passion projects and the projects we are doing at work. 

What struck me as remarkable was the seamless transition between my personal and corporate development experiences. This means that the skills I practice in personal projects using Spring Boot are directly transferable to my work in the corporate world. This means you can use Spring Boot anywhere.

So whether you want to build a simple personal project or a large enterprise application at your workplace, Spring Boot is the go-to framework that rises to the occasion.

In the corporate world, Spring Boot’s adoption has been remarkable. It’s not just a framework of choice; it’s become a standard and the backbone of many enterprise-level applications.

 Its reliability, community support, and mature ecosystem of integrations also make it the go-to solution for building scalable, maintainable, and enterprise-grade applications.

##4. SPRING BOOTS TESTABILITY 

```java
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
@SpringBootTest
public class ProductServiceTest {
    @Autowired
    private ProductService productService;
    @Test
    public void testProductCreation() {
       
        Product product = new Product("Sample Product", 10.0);
        // Act
        Product savedProduct = productService.createProduct(product);
        // Assert
        assertNotEquals(0, savedProduct.getId());
        assertEquals("Sample Product", savedProduct.getName());
        assertEquals(10.0, savedProduct.getPrice(), 0.01);
    }
}
```
Testing is every developer’s best friend, right? Well, it should be, but let me take you back to when it was more like a nagging headache than a relief.

In my early days as a developer, writing tests was a daunting exercise, especially while I was still trying to master the basic concepts of programming. Setting up test cases felt like solving a riddle and catching exceptions was always a constant struggle. The process was so cumbersome that I felt discouraged from writing thorough tests and would often find ways to evade them.

Fast forward a few years, when I started working with the Spring Boot framework writing unit, and integration tests became less of a headache and more of a satisfying routine. I would also encourage you to choose a framework with good features that enhance writing tests to help you along. 

Spring Boot is an excellent choice for developing applications with robust testing features. 

For the following reasons:

Spring Boot integrates seamlessly with popular testing frameworks like JUnit, Mockito, and Spring Test.
Spring Boot provides a wide range of testing annotations, including @SpringBootTest, @DataJpaTest, and @WebMvcTest, which help configure the application context for specific types of testing, streamlining the process.
 Spring Boot allows you to leverage the vast ecosystem of Spring Frameworks, such as Spring Security for security testing and Spring Data for database-related testing.
Spring Boot support for mocking frameworks like Mockito gives you access to utilities for generating test data, enabling you to build even more robust applications.
Spring Boot integrates well with [TestContainers](https://www.atomicjar.com/2023/10/beyond-pass-fail-a-modern-approach-to-java-integration-testing/) to fast-track your integration tests.
If you’re building a distributed application, testing is non-negotiable.

##5. MONITORING AND OBSERVABILITY
When I started my programming journey back in college I started by developing basic single-page applications, which were relatively straightforward and had limited complexity. These single-page applications typically had a simple front end, minimal data processing, and a single server handling requests. With this type of application, it was easy to pinpoint issues and make adjustments on the fly.

However, as time has gone by, my projects have grown in scope and complexity, and I now find myself dealing with more complicated applications. These applications mostly feature multiple microservices, databases, external integrations, and complex business logic.

Over this time, as the complexity of the systems I work on increases, I’ve learned to value metrics, logs, and distributed tracing. 

Spring Boot, especially Spring Boot 3, offers [built-in observability capabilities](https://digma.ai/blog/10-reasons-why-it-is-worth-learning-spring-boot-in-2023/) that make it easier for you to monitor, diagnose, and gain insights into the internal state of your applications in production environments. Here are some Spring Boot features that you can leverage to observe and monitor your applications:

1. Actuator Endpoints.

```
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-actuator</artifactId>
</dependency>
```

- /actuator/health endpoint that provides information about the health of your application
- /actuator/metrics provides detailed metrics on various aspects of your application, such as memory usage, garbage collection.
- The /actuator/info endpoint lets us expose custom application information.
- /actuator/env provides access to the application’s environment properties, which can be useful for troubleshooting configuration issues.
- You can also build your custom endpoints to help you expose specific data or trigger actions.

2. Metrics Collection – Micrometer integration. 
I’ve seen how the rise of microservices and cloud-native architectures has made monitoring these distributed systems absolutely necessary. This is where Micrometer comes into play, presenting itself as the go-to “SLF4J” for application metrics.

Micrometer is like an all-around utility belt for application metrics, ready to support a wide range of monitoring systems. It’s like a multipurpose tool for developers, enabling us to collect valuable insights from our applications without being locked into a particular monitoring solution. 

It’s all about giving us the flexibility to choose the right tool for the job and ensuring that we’re not confined to a single system. For instance, you can work with tools such as Prometheus, Datadog, InfluxDB, and more.

Micrometer also has a rich set of instrument types, such as gauges, counters, timers, and distribution summaries. 

```
2023-03-05 10:57:51.112  INFO 45469 --- [           main] org.apache.catalina.core.StandardEngine  : Starting Servlet Engine: Apache Tomcat/7.0.52
2023-03-05 10:57:51.253  INFO 45469 --- [ost-startStop-1] o.a.c.c.C.[Tomcat].[localhost].[/]       : Initializing Spring embedded WebApplicationContext
2023-03-05 10:57:51.253  INFO 45469 --- [ost-startStop-1] o.s.web.context.ContextLoader            : Root WebApplicationContext: initialization completed in 1358 ms
2023-03-05 10:57:51.698  INFO 45469 --- [ost-startStop-1] o.s.b.c.e.ServletRegistrationBean        : Mapping servlet: 'dispatcherServlet' to [/]
2023-03-05 10:57:51.702  INFO 45469 --- [ost-startStop-1] o.s.b.c.embedded.FilterRegistrationBean  : Mapping filter: 'hiddenHttpMethodFilter' to: [/*]
```
The significance of logging has grown over time from a mere debugging tool to a way that you can build reliable, maintainable, and efficient software. 

In my experience with Spring Boot, it’s great to know that it relies on Commons Logging for its internal logs but remains flexible when it comes to the underlying log implementation. It’s like having the best of both worlds!

Out of the box, Spring Boot provides default configurations for Java Util Logging, Log4J2, and Logback. In each scenario, the loggers come pre-configured to display log messages on the console, and you also have the option to direct the logs to a file if needed.

If you’re using the ‘Starters,’ Spring Boot sets up Logback for your logging needs by default. What’s cool is that it takes care of Logback routing too, ensuring that even if you have dependent libraries that use different logging frameworks like Java Util Logging, Commons Logging, Log4J, or SLF4J, everything will work harmoniously.

So, you’ve got the freedom to choose your preferred logging framework, but Spring Boot’s default setup with Logback simplifies things, making it easy to get started without worrying about compatibility issues with other libraries.

```
'dispatcherServlet' to [/]
2023-03-05 10:57:51.702  INFO 45469 --- [ost-startStop-1] o.s.b.c.embedded.FilterRegistrationBean  : Mapping filter: 'hiddenHttpMethodFilter' to: [/*]
```
4. Distributed Tracing with OpenTelemetry.
Let’s say you’re a relatively new developer responsible for maintaining a large e-commerce platform. One day, you receive a report from the customer support team indicating that some customers are experiencing issues during the checkout process. Users are complaining about orders not being processed, and they’re unable to complete their purchases.

Without proper observability tools and distributed tracing, you don’t have end-to-end visibility into the request flow. You’re blind to the interactions between microservices and it becomes hard to trace how each request is handled, and where are the errors and bottlenecks.

OpenTelemetry is today considered the standard for tracing with a wide range of OSS and commercial tools to support it such as Jaeger, Zipkin, and enterprise APMs. Fortunately, Spring has extensive support for OTEL across its many projects and libraries. Spring Boot supports both the OTEL agent instrumentation – a very quick and unobtrusive way to get started in dev and test, as well as the more performant Micrometer Tracing library.

If you need an extra shortcut in bootstrapping OpenTelemetry (OTEL)  to your spring application or want to integrate all of that important data into your dev process, consider free developer tools such as Digma. [Digma](https://digma.ai/) is a [Continuous Feedback(CF)](https://digma.ai/blog/coding-with-java-observability/) tool that is meant to streamline the work of collecting and processing data about your code from OTEL observability sources. Digma runs locally as an IDE plugin and collects data about your code, from traces to logs and metrics, while you’re coding. This means you can catch issues and get insights in real-time.


![displaying digma CF tool](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/jodm6z71ir123b1d3f3l.png)

##6. SIMPLICITY AND RAPID DEVELOPMENT
Choosing the right tool at the onset of any project is a strategic decision with far-reaching consequences. It can affect everything from the development process and performance to security, scalability, and user experience.

Equally, choosing the right framework can significantly impact your learning curve and early experiences. Spring Boot is an excellent choice if you’re just starting your coding adventure due to its “convention over configuration” philosophy. 

Spring Boot reduces Spring’s verbose and complex setup. This means that as a beginner, you can focus on coding your application’s core logic without getting lost in a sea of configuration files. With Spring Boot, you can create self-contained, executable JAR files, making deployment very easy. There’s no need to manage application servers or complex deployments. 

Spring Boot also offers preconfigured templates or collections of dependencies that simplify setting up and configuring an application; these are known as Spring Boot starters. These starters are designed to look at your classpath and the beans you’ve configured and make reasonable assumptions about what might be missing. They then automatically add the necessary components, libraries, and configurations to get your application up and running quickly.

##7. MICROSERVICE SUPPORT
![Microservices diagram](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/hae3v4u6k0h086uy8jq7.png)

You may have heard many conversations lately that microservice architectures are the ‘new normal,’  way of developing applications. 

It’s true, they’re cool. The idea of breaking down monolithic applications into smaller, independently deployable services makes sense. So, inspired by the hype, I joined a discussion on Reddit about microservices. It started with enthusiasm, but as the thread grew, a theme emerged – the “[Death by a Thousand Microservices.](https://www.reddit.com/r/programming/comments/16g7f3y/death_by_a_thousand_microservices/)“

As developers shared their experiences, it was evident that managing many microservices can be a real headache. The challenge of orchestrating and monitoring all these components can lead to complexity overload.

Spring Boot comes to the rescue. I’ve found that its features make working with microservices far less intimidating. Spring Boot’s integration with Spring Cloud provides tools for service discovery, load balancing, and distributed configuration. These features simplify the creation and management of microservices, ensuring they work seamlessly together.

Other features that I and many other Java developers appreciate when working with Spring Boot include support for containerization technologies like Docker and orchestration platforms like Kubernetes,  seamless integration and interoperability with many technologies and extensive documentation.

##8. EMBEDDED SERVERS

```Java
<dependency>
     <groupId>org.apache.tomcat.embed</groupId>
     <artifactId>tomcat-embed-core</artifactId>
     <version>8.5.23</version>
     <scope>compile</scope>
</dependency>
<dependency>
     <groupId>org.apache.tomcat.embed</groupId>
     <artifactId>tomcat-embed-el</artifactId>
     <version>8.5.23</version>
     <scope>compile</scope>
</dependency>
<dependency>
     <groupId>org.apache.tomcat.embed</groupId>
     <artifactId>tomcat-embed-websocket</artifactId>
     <version>8.5.23</version>
     <scope>compile</scope>
</dependency>
```
##9. SPRING BOOT IS OPEN SOURCE
The open-source nature of Spring Boot is something that has resonated deeply with me and many other developers. What I love about the open-source nature of Spring Boot is that it levels the playing field for everyone. So regardless of whether you’re a student, a newbie in technology, or an experienced developer, you have access to the same code, the same documentation, and the same opportunities for contribution as anyone else.

Open source promotes transparency. So you’re not just working with a black-box solution, but you can investigate how the framework works under the hood and even make modifications as you deem fit. It also means that there are no costs attached. You can use the framework freely for personal projects, side hustles, or enterprise-grade applications without worrying about costs.

Finally, one of the most fulfilling aspects is that you can contribute through bug fixes, documentation improvements, and even new Spring Boot features.

##10. COMMUNITY AND SUPPORT
I have been a developer for a little over a decade, and I have lost count of the number of times I have sought and received support from different communities. These communities are distributed across different platforms such as Reddit, Twitter, and Stack Overflow.

As a developer, it is often easy to get carried away with the notion that staying indoors in your small room and coding around the clock in isolation is the way to progress. However, the reality of software development is quite the opposite. The field of programming is collaborative in nature, driven by the constant exchange of ideas and a team approach to solving complex issues.

Being part of a community is very helpful, especially when you’re just starting your coding journey.

Spring Boot has been around for a while and has a thriving ecosystem of developers, architects, and experts who constantly share ideas and resources and help each other solve problems. Due to its open-source nature, developers can also share ideas that improve the Spring Boot framework, and you can also participate. 

##SPRING BOOT VS QUARKUS
I came across an engaging discussion on Reddit that revolved around the topic of “Micronaut vs others (Spring Boot, Quarkus, and co.).” Developers are actively exploring different alternatives when it comes to selecting a framework for building microservices.


![A discussion around Quarkus VS Spring Boot](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/37cm0nyhs1wm28veox8t.png)

##SPRING BOOT VS. DJANGO OR NODE JS.
In my experience and career, I have also come to appreciate the unique strengths and trade-offs of different technologies. Many developers seem to share similar opinions when comparing Spring Boot to other frameworks outside of the Java ecosystem.

The Java ecosystem has a relatively higher initial learning curve but stands out for its robustness and extensive libraries. Spring Boot excels in scenarios where reliability and scalability are important. However, one trade-off is the slightly longer startup times compared to other frameworks.

Python and Django, on the other hand, offer a delightful experience for web development, particularly in projects where developer productivity and rapid iterations are essential. 

Python may not be as performant as Java in certain situations, it has a readable and clean code syntax. Django has shown that it’s an excellent choice for content management systems, web applications, and situations where getting a project up and running quickly is a priority.

Node.js, with its JavaScript backbone, has been my go-to for real-time applications and microservices. Its performance, especially for I/O-bound and real-time scenarios, is exceptional. 

My experience with Node.js is that it is a perfect choice where speed and scalability are paramount, particularly when building real-time applications like chat platforms. Besides, the ability to use a single language for both client and server makes your life even easier.

##CONCLUSION: IT IS WORTH LEARNING SPRING BOOT
Spring Boot is still the leading framework in the Java world, and it doesn’t seem to change anytime soon.

Spring Boot is still very relevant. If or when it is surpassed by something else, you will learn portable concepts that will likely be used in other frameworks. Until then, the marketplace has opportunities for Spring Boot knowledge now and well into the future. Moreover, with the new Spring Boot releases, I’d say that Spring Boot is likely to stay the de-facto Java framework for the next few years at least. 

It’s also important to note the growing relevance of frameworks like Micronaut and Quarkus, which offer unique advantages for specific types of projects. Exploring these alternatives and understanding when to apply them can further enhance your abilities as a developer.

##FAQ
What is Spring Boot, and why should I consider learning it in 2023?

Spring Boot is a popular open-source Java framework that makes it easier to create microservices and web applications. Learning Spring Boot in 2023 is worth it because it offers numerous advantages for modern software development projects and a lot of work opportunities.

What are the key features that make Spring Boot stand out in 2023?

Spring Boot offers features like auto-configuration, rapid development, and a wide range of built-in tools for microservices, web applications, and more. These features enhance developer productivity and code quality.

What are some real-world applications of Spring Boot in 2023?

Spring Boot is used in a wide range of applications, from web development and microservices to API creation and backend systems. Companies such as  Netflix, Alibaba, LinkedIn, Uber and Groupon use Spring Boot.


Install Digma for free: [Here](https://digma.ai/get-digma/)