Siva Prasad Reddy Katamreddy1 and Sai Subramanyam Upadhyayula2
(1)
Hyderabad, India
(2)
Rotterdam, The Netherlands
The Spring Framework
is a popular and widely used Java framework for building web and enterprise applications. Spring, at its core, is a dependency injection container that provides flexibility to configure beans in multiple ways, such as XML, Annotations, and JavaConfig. Over the years, the Spring Framework has grown exponentially by addressing the needs of modern business applications
like security, support for NoSQL datastores, handling big data, batch processing, integration with other systems, and more. Along with its subprojects, Spring has become a viable platform for building enterprise applications.
The Spring Framework
is very flexible and provides multiple ways of configuring application components. With rich features combined with various configuration options, configuring Spring applications becomes complex and error prone. The Spring team created Spring Boot to address configuration complexity through its powerful AutoConfiguration mechanism.
This chapter takes a quick look at the Spring Framework. You’ll develop a web application using Spring MVC and JPA the traditional way (without Spring Boot). Then you will look at the pain points of the conventional way and see how to develop the same application using Spring Boot.
Overview of the Spring Framework
If you are a Java developer, there is a good chance that you have heard about the Spring Framework and have used it in your projects. The Spring Framework was created primarily as a dependency injection container, but it is much more than that. Spring
is famous for several reasons:
Easy-to-use and powerful database transaction management capabilities
Spring simplifies integration with other Java frameworks, like the JPA/Hibernate ORM and JooQ.
State-of-the-art Web MVC framework for building web applications
Along with the Spring Framework, many other Spring subprojects
help build applications that address modern business needs:
Spring Data: Simplifies data access from relational and NoSQL datastores
Spring Batch: Provides a powerful batch-processing framework
Spring Security: Robust security framework to secure applications
Spring Cloud: Provides a set of tools for developers to implement common distributed system patterns like Service Discovery, Configuration Management, Circuit Breaker, and more
Spring Integration: An implementation of enterprise integration patterns to facilitate integration
with other enterprise applications using lightweight messaging and declarative adapters
There are many other interesting projects addressing various other modern application development needs. For more information, take a look at https://spring.io/projects.
Spring Configuration Styles
Spring initially provided an XML-based approach for configuring beans. Later, Spring introduced XML-based DSLs, Annotations
, and JavaConfig-based approaches for configuring beans. Listings 1-1 through 1-3 show each of those configuration styles.
Spring provides multiple approaches for configuring application components. You can use JavaConfig- and Annotation-based configuration styles in the same application. That is a lot of flexibility, which is good and bad. People new to the Spring Framework may get confused about which approach to follow.
The Spring
community suggests you follow the JavaConfig-based approach, as it gives you more flexibility. But there is no one-size-fits-all kind of solution. You have to choose the approach based on your own application needs.
Now that you’ve had a glimpse of how various styles of Spring Bean configurations look, you’ll take a quick look at the configuration of a typical SpringMVC and JPA/Hibernate-based web application.
Developing a Web Application Using SpringMVC and JPA
Before getting to know Spring Boot and learning about its features, let’s look at a typical Spring web application configuration and learn about the pain points. Then, you will see how Spring Boot addresses those problems.
The first thing to do is create a Maven project called springmvc-jpa-demo and configure all the dependencies required in the pom.xmlfile
, as shown in Listing 1-4.
All of the Spring MVC, Spring Data JPA, JPA/Hibernate, Thymeleaf, and Log4j dependencies are configured in the Maven pom.xml file. Also, it defines the maven-war-plugin and cargo-maven-plugin to run an embedded Tomcat container to save you the manual configuration of the Tomcat server to run your application.
Configure the service/DAO layer beans using JavaConfig
, as shown in Listing 1-5.
In the AppConfig.java configuration class
, you do the following:
Mark it as a Spring Configuration class using the @Configuration annotation.
Enable annotation-based transaction management using @EnableTransactionManagement.
Configure @EnableJpaRepositories to indicate where to look for Spring Data JPA repositories.
Configure the PropertyPlaceHolder bean using the @PropertySource annotation and the PropertySourcesPlaceholderConfigurer bean definition, which loads properties from the application.properties file.
Define beans for DataSource, JPA EntityManagerFactory, and JpaTransactionManager.
Configure the DataSourceInitializer bean to initialize the database by executing the data.sql script on application start-up.
1.
Now configure the property placeholder values in application.properties, as shown in Listing 1-6.
Now configure the Spring MVC web layer beans
such as ThymeleafViewResolver, static ResourceHandlers, and MessageSource for i18n, as shown in Listing 1-9.
public void configureDefaultServletHandling(DefaultServletHandlerConfigurer configurer) {
configurer.enable();
}
@Bean(name = "messageSource")
public MessageSource messageSource() {
ReloadableResourceBundleMessageSource messageSource = new ReloadableResourceBundleMessageSource();
messageSource.setBasename("classpath:messages");
messageSource.setCacheSeconds(5);
messageSource.setDefaultEncoding("UTF-8");
return messageSource;
}
}
Listing 1-9
The com.apress.demo.config.WebMvcConfig.java File
In the WebMvcConfig.java configuration class
, you do the following:
Mark it as a Spring Configuration class using @Configuration annotation.
Enable an annotation-based Spring MVC configuration using @EnableWebMvc.
Configure ThymeleafViewResolver by registering the TemplateResolver, SpringTemplateEngine, and ThymeleafViewResolver beans.
Register the ResourceHandlers bean to indicate requests for static resources. The URI /resources/** will be served from the /resources/ directory.
Configure a MessageSource bean to load i18n messages from ResourceBundle messages_{country-code}.properties from the classpath.
5.
Create the messages.properties file in the src/main/resources folder and add the following property:
app.title=SpringMVC JPA Demo (Without SpringBoot)
6.
Next, you register
the Spring MVC FrontController servlet DispatcherServlet.
Note
Prior to the Servlet 3.x specification, you had to register servlets and filters in web.xml. Since the Servlet 3.x specification, you can register servlets and filters programmatically using ServletContainerInitializer. Spring MVC provides a convenient class called AbstractAnnotationConfigDispatcherServletInitializer to register DispatcherServlet.
Listing 1-10 shows how to configure the SpringWebAppInitializer.javaclass
.
public class SpringWebAppInitializer extends AbstractAnnotationConfigDispatcherServletInitializer
{
@Override
protected Class<?>[] getRootConfigClasses()
{
return new Class<?>[] { AppConfig.class};
}
@Override
protected Class<?>[] getServletConfigClasses()
{
return new Class<?>[] { WebMvcConfig.class };
}
@Override
protected String[] getServletMappings()
{
return new String[] { "/" };
}
@Override
protected Filter[] getServletFilters()
{
return new Filter[]{ new OpenEntityManagerInViewFilter() };
}
}
Listing 1-10
The com.apress.demo.config.SpringWebAppInitializer.java File
In the SpringWebAppInitializer.java configuration class, you do the following:
Configure AppConfig.class as RootConfirationClasses, which will become the parent ApplicationContext that contains bean definitions shared by all child (DispatcherServlet) contexts.
Configure WebMvcConfig.class as ServletConfigClasses, which is the child ApplicationContext that contains WebMvc bean definitions.
Configure / as ServletMapping, which means that all the requests will be handled by DispatcherServlet.
Register OpenEntityManagerInViewFilter as a servlet filter so that you can lazy-load the JPA entity lazy collections while rendering the view.
7.
Create a JPA entity user and its Spring Data JPA Repository interface UserRepository. Create a JPA entity called User.java, as shown in Listing 1-11, and a Spring Data JPA repository called UserRepository.java, as shown in Listing 1-12.
The com.apress.demo.web.controllers.HomeController.java File
9.
Create a Thymeleaf view called index.html in the /WEB-INF/views/ folder to render a list of users, as shown in Listing 1-14.
<!DOCTYPE html>
<html xmlns:="http://www.w3.org/1999/xhtml"
xmlns:th="http://www.thymeleaf.org">
<head>
<meta charset="utf-8"/>
<title>Home</title>
</head>
<body>
<h2 th:text="#{app.title}">App Title</h2>
<table>
<thead>
<tr>
<th>Id</th>
<th>Name</th>
</tr>
</thead>
<tbody>
<tr th:each="user : ${users}">
<td th:text="${user.id}">Id</td>
<td th:text="${user.name}">Name</td>
</tr>
</tbody>
</table>
</body>
</html>
Listing 1-14
The src/main/webapp/WEB-INF/views/index.html File
You are all set now to run the application. Run the command mvn cargo:run. This command will start an embedded Tomcat container. Now point your browser to http://localhost:8080/springmvcjpa-demo. If you do, you should see the list of user details
in a table, as shown in Figure 1-1.
A window of a list of user details. It has a heading that reads, Spring M V C J P A Demo, without spring boot, and a list of three I D names.
Figure 1-1
Showing a list of users
Yay, you did it. But wait, isn’t this too much work to just show a list of user details pulled from a database table?
Let’s be honest and fair. All this configuration is not just for this one use case. This configuration becomes the basis for the rest of the application. Again, this is too much work to do if you want to get up and running quickly. Another problem
is assuming that you want to develop another SpringMVC application with a similar technical stack. You could copy and paste the configuration and tweak it. Right?
Remember one thing: if you have to do the same thing repeatedly, you should find an automated way to do it.
Apart from writing the same configuration again and again, do you see any other problems here? Let’s take a look at the problems
I see:
You must search all the compatible libraries for the Spring version and configure them.
Most of the time, you configure the DataSource, EntitymanagerFactory, TransactionManager, etc. beans the same way. Wouldn’t it be great if Spring could do it for you automatically?
Similarly, you configure the SpringMVC beans like ViewResolver and MessageSource the same way most of the time
. If Spring can automatically do it for you, that would be awesome.
What if Spring is capable of configuring beans automatically? What if you can customize the automatic configuration
using simple, customizable properties?
For example, instead of mapping the DispatcherServlet url-pattern to /, you want to map it to /app/. Instead of putting Thymeleaf views in the /WEB-INF/views folder, you want to place them in the /WEB-INF/templates/ folder.
So basically, you want Spring to do things automatically yet provide the flexibility to override the default configuration more simply. You are about to enter the world of Spring Boot, where your dreams can come true!
A Quick Taste of Spring Boot
Welcome to Spring Boot! Spring Boot will configure application components automatically for you but allows you to override the defaults if you want to.
Instead of explaining this in theory, I prefer to explain it by example. In this section, you’ll see how to implement the same application using Spring Boot.
1.
Create a Maven-based Spring Boot project and configure the dependencies in the pom.xmlfile
, as shown in Listing 1-15.
Don’t worry if this configuration doesn’t make sense at this point in time. You have plenty more to learn in the coming chapters.
If you want to use any of the MILESTONE or SNAPSHOT versions of Spring Boot, you need to configure the following milestone/snapshot repositories
in pom.xml:
The src/main/resources/application.properties File
Copy the same data.sql file into the src/main/resources folder.
3.
Create a JPA Entity called User.java, a Spring Data JPA Repository Interface called UserRepository.java, and a controller called HomeController.java, as shown in the previous springmvc-jpa-demo application.
4.
Create a Thymeleaf view to show the list of users. You can copy /WEB-INF/views/index.html, which you created in the springmvc-jpa-demo application, into the src/main/resources/templates folder of this new project.
5.
Create a Spring Boot EntryPointclass Application.javafile
with the main method, as shown in Listing 1-17.
Now run Application.java as a Java application and point your browser to http://localhost:8080/. You should see the list of users in a table format.
By now, you might be scratching your head, thinking, “What is going on?” The next section explains what just happened.
Easy Dependency Management
The first thing to note is the use of the dependencies named spring-boot-starter-*. Remember that I said, “Most of the time, you use the same configuration.” So, when you add the springboot-starter-webdependency
, it will, by default, pull all the commonly used libraries while developing Spring MVC applications, such as spring-webmvc, jackson-json, validation-api, and tomcat.
You added the spring-boot-starter-data-jpa dependency. This pulls all the spring-data-jpa dependencies and adds Hibernate libraries because most applications use Hibernate as a JPA implementation.
Autoconfiguration
Not only does the spring-boot-starter-web add all these libraries but it also configures
the commonly registered beans like DispatcherServlet, ResourceHandlers, MessageSource, etc. with sensible defaults.
You also added spring-boot-starter-thymeleaf, which not only adds the Thymeleaf library dependencies but also configures the ThymeleafViewResolver beans automatically.
You haven’t defined any DataSource, EntityManagerFactory, or TransactionManager beans, but they are automatically created. How?
Suppose you have in-memory database drivers like H2 or HSQL in the classpath. In that case, Spring Boot will automatically create an in-memory data source and register the EntityManagerFactory and TransactionManager beans automatically with sensible defaults.
But you are using MySQL, so you need to provide MySQL connection details explicitly. You have configured those MySQL connection details in the application.properties file and Spring Boot creates a DataSource using those properties.
Embedded Servlet Container Support
The most important and surprising thing is that you created a simple Java class
annotated with some magical annotation (@SpringApplication), which has a main() method. By running that main() method, you can run the application and access it at http://localhost:8080/. Where does the servlet container come from?
You added spring-boot-starter-web, which pulls spring-boot-starter-tomcat automatically. When you run the main() method, it starts Tomcat as an embedded container so that you don’t have to deploy your application on any externally installed Tomcat server. What if you want to use a Jetty server instead of Tomcat? You simply exclude spring-boot-starter-tomcat from spring-boot-starter-web and include spring-boot-starter-jetty. That’s it.
But this looks magical!. You may be thinking Spring Boot looks cool, and it's doing a lot of things for you. You still don’t understand how it works behind the scenes.
I can understand. Watching a magic show is fun, but the mystery is not so fun with software development. Don’t worry; we will be looking at each of these things and I will explain in detail what’s happening behind the scenes. I don’t want to overwhelm you by dumping everything on you in this first chapter.
Summary
This chapter was a quick overview of various Spring configuration styles. The goal was to show you the complexity of configuring Spring applications. Also, you had a quick look at Spring Boot by creating a simple web application.
The next chapter takes a more detailed look at Spring Boot and shows how you can create Spring Boot applications in different ways.
