Spring VS Spring Boot - Comparison Between Spring and Spring Boot

1. Introduction

In this article, We'll discuss more Why spring boot is more popular and what are the advantages of using Spring boot even Spring web framework provides all the things that are needed for web application development. We can see Spring vs Spring Boot

This is part of the Spring Boot Series where you can find the related articles.

2. Disadvantages of Spring

In fact, When you develop the spring web application, you must do the following before actually start working on the core business logic.

First, we need to create a web project with a proper structure and including maven or Gradle build configurations along with the required dependencies.


Next, You'll have to make sure spring web and servlet API dependencies are in place and compatible with the dependency versions.

Additionally, must have to provide the declaration for the DispatcherServlet which is also called a front controller because all incoming requests are handled by this servlet.

At this point, this DispatcherServlet must be defined in the web.xml or WebApplicationInitializer.
All configurations are needed for spring mvc.
Create a controller and create a method that prints "welcome to first program in spring boot".
Finally, Build the application and deploy it in the tomcat server.

All the above steps must be performed before developing the web application in Spring.

Among all the steps we need is only creating core logic in the rest controller part and remaining all steps are boilerplate code which not required.

If all of these things are required for spring application then why should you have to provide these?

From this point of initiation, spring boot is evolved.

3. Core Advantages of Spring Boot

Spring Boot brings the magic and great features by default and nothing will be needed manually. There are lots of core tricks but the below 4 are main in spring boot.

• Starter Dependencies
• Auto Configurations
• Command-line Interface(CLI)
• Actuators

Each of these have its own advantages but going forward we will go in deep but for now loot at each what they offers.

3.1 Starter Dependencies

Once we decide which spring version you are going to work with then we need to find the artifact id and version. Along the side, you have to be very careful choosing the compatibility that means which version plays well with other dependencies in the same project.

Especially, Spring Boot bundles the right dependencies as starter dependencies. Starter Dependency is just like a maven or Gradle single dependency will all required and commonly used stable versions libraries together very handy.

For Example, if you are building a web-based application with spring mvc as well as going to expose REST api then you must need the following.

• org.springframework:spring-core
• org.springframework:spring-web
• org.springframework:spring-webmvc
• com.fasterxml.jackson.core:jackson-databind
• org.hibernate:hibernate-validator
• org.apache.tomcat.embed:tomcat-embed-core
• org.apache.tomcat.embed:tomcat-embed-el
• org.apache.tomcat.embed:tomcat-embed-logging-juli

hibernate for storing into the database and embed tomcat for deployment.

On the other hand, if you can use the spring boot web starter which brings all jars for us with a single dependency with as "org.springframework.boot:spring-boot-starter-web)" and this is called as boot web starter.

Furthermore, once you add this web starter then it will pull the required set of jars transitively and no need to add all in pom.xml.

Similar to the web starter, Spring boot has lots of starts for each application type rather than adding all of them in pom.xml or Gradle that makes more complicated and version issues.

• spring-boot-starter-web
• spring-boot-starter-activemq
• spring-boot-starter-integration
• spring-boot-starter-jdbc
• spring-boot-starter-aop
• spring-boot-starter-batch
• spring-boot-starter-batch
• spring-boot-starter-data-jpa

Spring Boot Ref

And also all the beans and its dependencies are auto-configured by Spring Boot.

3.2 Spring Boot Auto Configurations

If you see any spring application, that must be having xml based configuratiuon or java configuration or in sometimes both will be in place.

Any application that interacts with the database using jdbc then you must define a bean with @Bean annotation on a method that returns JdbcTemplate.

Look at the below method defined with @Bean and takes argument DataSource.

[@Bean
public JdbcTemplate jdbcTemplate(DataSource dataSource) {
return new JdbcTemplate(dataSource);
}]

Here, the above method returns JdbcTemplate instance and injects one of its data sources. That means you have to define another bean that creates a data source. For demonstration, We will use the embedded H2 database as DataSource.

[@Bean
public DataSource dataSource() {
return new EmbeddedDatabaseBuilder().setType(EmbeddedDatabaseType.H2).addScripts('main-schema.sql', 'static-data.sql').build();
}]

This configuration method creates an embedded H2 database and two scripts to execute on this.

All these are needed but not complex to write but if you all lots of configurations then it looks difficult to avoid error-prone.

So if all of this work can be done by framework then it is easy to focus just on the business logic.

If you add the H2 database in the dependency list in classpath then spring boot does auto-configuring the H2 data source and directly you can use the spring jdbc template where you want directly. JdbcTemplate is associated with the H2 data source.

Additionally, It does configuring the embedded tomcat server by default and once you run the spring boot applications then it will be deployed into tomcat and starts the application within seconds. No manual intervention is required.

3.3 Spring Boot Command Line Interface (CLI)

In addition to the above two, Spring Boot has introduced the new interesting way to develop the spring boot applications. But, This is optional and provides tremendous power with untraditional development. This is mostly useful to directly focus on the core business logic and uses the starter dependencies along with the auto configurations.

Not only this but also you no need to add import statements and will not give any errors while running the programs.

Important to realize that if you use RestController and RequestMapping annotations then CLI will detect these and CLI knows which starters to be added to the classpath to run the applications.

Consequently, After adding the starts to the classpath then it triggers the auto configurations and make sure DispatcherServlet and Spring MVC components enabled so that it can serve the HTTP Requests.

Finally, This is a basic introduction to the Spring BOOT CLI and will see the deeper look in the next articles.

3.4 Spring Boot Actuator

This an extremely interesting capability added to spring boot apart from the application development because it gives us the capability to inspect the internal working of the application.

The actuator can be accessed in two ways

A) Using End Points
B) Using Shell Interface

The following things can be seen using actuator api.

• What are the been configured in the application context?
• What are the things auto-configured?
• Can see all the variables and properties have been set 
• Memory utilization and garbage collection, resources
• Recent HTTP Requests handled by the application.

Spring Boot Hello World Rest Example

4. Conclusion

To conclude, We have seen what are the common things in spring application development. How sprig boot is automated the redundant work and does the following.

• Autoconfiguration
• Variety of Starter dependencies
• Spring boot CLI for testing 
• Actuator