When I started learning Spring Boot, I was also confused about the differences between Spring Boot and Spring. I have heard many conflicting answers to this problem, but with the accumulation of my experience, I started to understand the differences between the two frameworks better.
I believe some students that have used Spring Boot for a long time still don't understand the difference between Spring Boot and Spring. After reading my comparisons in the article, maybe you will have different answers and opinions!
As a Java developer, Spring is familiar to all. In short, the Spring Framework provides comprehensive infrastructure support for developing Java applications. It contains some good functions, such as dependency injection and out-of-the-box modules, including Spring JDBC, Spring MVC, Spring Security, Spring AOP, and Spring ORM, Spring Test.
These modules shorten the development time of applications and improve the efficiency of application development. For example, in the early stages of Java Web development, we need to write a lot of code to insert records into the database. However, we can simplify the operation into a few lines of code using the JDBCTemplate of the Spring JDBC module.
Spring Boot is basically an extension of the Spring Framework. It eliminates the XML configuration required to set up Spring applications, paving the way for a faster and more efficient development ecosystem.
Spring Boot has the following characteristics:
1) Create an independent Spring application
2) Embedded Tomcat, Jetty, and Undertow containers (war files are not required).
3) Provides simplified construction configuration of starters
4) Configure spring applications as automatically as possible
5) Provide production indicators, such as indicators, robust inspection, and externalized configuration
6) There are no code generation and XML configuration requirements at all.
First, let's take a look at the minimum dependencies required to create a Web application using Spring:
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-web</artifactId>
<version>5.1.0.RELEASE</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-webmvc</artifactId>
<version>5.1.0.RELEASE</version>
</dependency>
Unlike Spring, Spring Boot only requires one dependency to start and run a Web application:
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
<version>2.0.6.RELEASE</version>
</dependency>
During the build, all other dependencies are added to the project automatically.
Another good example is the test Library. We usually use Spring Test, JUnit, Hamcrest, and Mockito libraries. In Spring projects, we should add all these libraries as dependencies. However, in Spring Boot, we only need to add the spring-boot-starter-test dependency to include these libraries automatically.
Spring Boot provides many dependencies for different Spring modules.
Some of the most commonly used dependencies are listed below:
spring- boot-starter-data-jpa
spring- boot-starter-security
spring- boot-starter- test
spring- boot-starter-web
spring- boot-starter-thymeleaf
For a complete list of starters, please check the Spring documentation.
Let's take a look at the configurations required for Spring and Spring Boot to create a JSP Web application.
Spring needs to define the scheduler servlet, mapping, and other support configurations. We can do this using the web.xml file or the Initializer class:
public class MyWebAppInitializer implements WebApplicationInitializer {
@Override
public void onStartup(ServletContext container) {
AnnotationConfigWebApplicationContext context = new AnnotationConfigWebApplicationContext();
context.setConfigLocation("com.pingfangushi");
container.addListener(new ContextLoaderListener(context));
ServletRegistration.Dynamic dispatcher = container
.addServlet("dispatcher", new DispatcherServlet(context));
dispatcher.setLoadOnStartup(1);
dispatcher.addMapping("/");
}
}
You also need to add the @EnableWebMvc annotation to the @Configuration class and define a view parser to parse the View returned from the controller:
@EnableWebMvc
@Configuration
public class ClientWebConfig implements WebMvcConfigurer {
@Bean
public ViewResolver viewResolver() {
InternalResourceViewResolver bean
= new InternalResourceViewResolver();
bean.setViewClass(JstlView.class);
bean.setPrefix("/WEB-INF/view/");
bean.setSuffix(".jsp");
return bean;
}
}
Once we have added a Web launcher, Spring Boot only needs to configure several properties in the application configuration file to complete the operations above:
spring.mvc.view.prefix =/WEB-INF/jsp/
spring.mvc.view.suffix =.jsp
All Spring configurations above are included automatically by adding Boot web starter through a process called auto-configuration.
This means Spring Boot will review the dependencies, properties, and beans that exist in the application and configure the properties and beans according to these dependencies. If you want to add your custom configuration, Spring Boot auto-configuration will be returned.
Now, let's take a look at how to configure the Thymeleaf template engine in Spring and Spring Boot.
In Spring, we need to add thymeleaf-spring5
dependencies and some configuration for the view parser:
@Configuration
@EnableWebMvc
public class MvcWebConfig implements WebMvcConfigurer {
@Autowired
private ApplicationContext applicationContext;
@Bean
public SpringResourceTemplateResolver templateResolver() {
SpringResourceTemplateResolver templateResolver = new SpringResourceTemplateResolver();
templateResolver.setApplicationContext(applicationContext);
templateResolver.setPrefix("/WEB-INF/views/");
templateResolver.setSuffix(".html");
return templateResolver;
}
@Bean
public SpringTemplateEngine templateEngine() {
SpringTemplateEngine templateEngine = new SpringTemplateEngine();
templateEngine.setTemplateResolver(templateResolver());
templateEngine.setEnableSpringELCompiler(true);
return templateEngine;
}
@Override
public void configureViewResolvers(ViewResolverRegistry registry) {
ThymeleafViewResolver resolver = new ThymeleafViewResolver();
resolver.setTemplateEngine(templateEngine());
registry.viewResolver(resolver);
}
}
Spring Boot1X requires only spring-boot-starter-thymeleaf
dependencies to enable Thymeleaf support in Web applications.
However, due to the new features in Thymeleaf3.0, we must add thymeleaf-layout-dialect
as a dependency in SpringBoot2XWeb applications. After configuring the dependencies, we can add templates to the src/main/resources/templates folder. Spring Boot will display them automatically.
For simplicity, we use the framework's default HTTP Basic authentication. First, let's take a look at the dependencies and configurations required to enable Security using Spring.
Spring must depend on the spring-security-web
and the spring-security-config
modules. Next, we need to add a class that extends the WebSecurityConfigurerAdapter
and uses the @EnableWebSecurity annotation:
@Configuration
@EnableWebSecurity
public class CustomWebSecurityConfigurerAdapter extends WebSecurityConfigurerAdapter {
@Autowired
public void configureGlobal(AuthenticationManagerBuilder auth) throws Exception {
auth.inMemoryAuthentication()
.withUser("admin")
.password(passwordEncoder()
.encode("password"))
.authorities("ROLE_ADMIN");
}
@Override
protected void configure(HttpSecurity http) throws Exception {
http.authorizeRequests()
.anyRequest().authenticated()
.and()
.httpBasic();
}
@Bean
public PasswordEncoder passwordEncoder() {
return new BCryptPasswordEncoder();
}
}
Here, we use inMemoryAuthentication
to set up authentication. Similarly, Spring Boot needs these dependencies to make it work. However, we only need to define the dependency of spring-boot-starter-security
because this will add all relevant dependencies to the Classpath automatically.
The security configuration in Spring Boot is the same as above.
The basic difference between application Boot in Spring and Spring Boot is in the servlet.
Spring uses web.xml or springservletercontainerinitializer
as its boot entry point.
Spring Boot only uses the Servlet 3 feature to Boot applications. Let's learn more about it.
Spring supports the traditional web.xml boot method and the latest Servlet 3 + method. To configure the web.xml method startup:
1) Servlet container (server) reads web.xml
2) The DispatcherServlet
defined in web.xml is instantiated by the container.
3) DispatcherServlet
creates WebApplicationContext
by reading WEB-INF / {servletName} -servlet.xml
.
Finally, DispatcherServlet
registers the bean defined in the context of the application. Spring startup steps using Servlet 3 + method. Container searches for the classes that implement ServletContainerInitializer
and executes springservcontainerinitializer
to find the classes that implement WebApplicationInitializer.
WebApplicationInitializer
creates a WebApplicationInitializer
that has the XML or @context Configuration class that creates the DispatcherServlet
with the context created previously.
The entry point for a Spring Boot application is a class annotated with @SpringBootApplication:
@SpringBootApplication
public class Application {
public static void main(String[] args) {
SpringApplication.run(Application.class, args);
}
}
By default, Spring Boot uses embedded containers to run applications. In this case, Spring Boot uses the public static void main entry point to start the embedded Web server. In addition, it is responsible for binding Servlet, Filter, and ServletContextInitializer
bean from the application context to the embedded servlet container.
Another feature of Spring Boot is that it scans all classes in the same package or components in sub-packages of the Main class automatically.
Spring Boot provides a way to deploy it to an external container. We only need to extend the SpringBootServletInitializer
:
/**
* War deployment
*/
public class ServletInitializer extends SpringBootServletInitializer {
@Override
protected SpringApplicationBuilder configure(SpringApplicationBuilder application) {
return application.sources(Application.class);
}
@Override
public void onStartup(ServletContext servletContext) throws ServletException {
super.onStartup(servletContext);
servletContext.addListener(new HttpSessionEventPublisher());
}
}
Here, the external servlet container searches for the Main-class, which is defined in the MANIFEST.MF file of the META-INF folder under the war package.
SpringBootServletInitializer
is responsible for binding the Servlet, Filter, and ServletContextInitializer
.
Finally, let's take a look at how to package and deploy applications. Both frameworks support generic package management technologies, such as Maven and Gradle. However, these frameworks vary in terms of deployment. For example, the Spring Boot Maven plugin provides Spring Boot support in Maven. It also allows an executable jar or war package to be packaged and ran in place.
Spring Boot has the following advantages over Spring Boot in deployment environments:
In short, we can say that Spring Boot is just an extension of Spring itself, making development, testing, and deployment more convenient.
Article originally published on WeChat Account Programmer Bai Nannan
Disclaimer: The views expressed herein are for reference only and don't necessarily represent the official views of Alibaba Cloud.
What are the Differences and Functions of the Redo Log, Undo Log, and Binlog in MySQL?
2,599 posts | 763 followers
FollowAlibaba Clouder - March 17, 2021
Alibaba Cloud Community - May 6, 2024
Alibaba Cloud Community - March 9, 2022
Alibaba Cloud Community - June 14, 2024
Alibaba Cloud Community - August 20, 2024
Alibaba Developer - August 19, 2021
2,599 posts | 763 followers
FollowMSE provides a fully managed registration and configuration center, and gateway and microservices governance capabilities.
Learn MoreA low-code development platform to make work easier
Learn MoreHelp enterprises build high-quality, stable mobile apps
Learn MoreAlibaba Cloud Function Compute is a fully-managed event-driven compute service. It allows you to focus on writing and uploading code without the need to manage infrastructure such as servers.
Learn MoreMore Posts by Alibaba Clouder