I believe that many friends like me, commonly used Spring and Spring Boot, but do not study the difference between the two?
Today is the big reveal ↓
An overview of the
As for the difference between Spring and SpringBoot, I have heard many answers. At the beginning of learning SpringBoot, I was also confused. With the accumulation of experience, I gradually understood the difference between the two frameworks. Still not quite understand SpringBoot and Spring exactly what difference, read the article comparison, perhaps you have a different answer and view!
What is the Spring
As a Java developer, everyone is familiar with Spring. In short, the Spring framework provides comprehensive infrastructure support for developing Java applications. It contains some nice features like dependency injection and out-of-the-box modules such as: SpringJDBC, SpringMVC, SpringSecurity, SpringAOP, SpringORM, SpringTest, these modules shorten the development time of application programs and improve the efficiency of application development. For example, in the early stage of JavaWeb development, We need to write a lot of code to insert records into the database. But by using the JDBCTemplate of the SpringJDBC module, we can simplify this to a few lines of code.
What is Spring Boot
SpringBoot is basically an extension of the Spring framework that eliminates the XML configuration required to set up Spring applications, paving the way for a faster, more efficient development ecosystem.
Some features of SpringBoot:
1. Create a standalone Spring application.
Embedded Tomcat, Jetty, and Undertow containers (war files are not required).
3. Simplify the starters construction and configuration
4. Automatically configure Spring applications whenever possible.
5. Provide production metrics, such as metrics, robustness checks, and externalized configurations
No code generation or XML configuration requirements at all
Analysis by configuration
Maven rely on
First, let’s look at the minimum dependencies needed to create a Web application using Spring
Unlike Spring, Spring Boot requires only one dependency to start and run a Web application:
All other dependencies are automatically added to the project during the build process.
Another good example is test libraries. We usually use SpringTest, JUnit, Hamcrest and Mockito libraries. In our Spring project, we should add all of these libraries as dependencies. But in SpringBoot, we just need to add the spring-boot-starter-test dependency to automatically include these libraries.
Spring Boot provides many dependencies for different Spring modules. Some of the most commonly used are:
spring-boot-starter-data-jpaspring-boot-starter-securityspring-boot-
starter-testspring-boot-starter-webspring-boot-starter-thymeleaf
For a complete list of starter, see the Spring documentation.
MVC configuration
Let’s take a look at the configuration required by Spring and SpringBoot to create JSPWeb applications.
Spring needs to define scheduler servlets, mappings, and other supporting configurations. We can do this using the web.xml file or the Initializer class:
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
Once we add the Web launcher, SpringBoot only needs to configure a few properties in the Application configuration file to do this:
All of the Spring configuration above is automatically included by adding the Bootweb Starter in a process called auto-configuration.
This means that SpringBoot will look at the dependencies, properties, and beans that exist in the application and configure the properties and beans based on those dependencies. Of course, if we want to add our own custom configuration, SpringBoot automatic configuration will fall back.
Configuring the Template Engine
Now let’s look at how to configure the Thymeleaf template engine in Spring and Spring Boot.
In Spring, we need to add thymeleaf-Spring 5 dependencies and some configuration for the view parser:
SpringBoot1X requires only a spring-boot-starter-Thymeleaf dependency to enable Thymeleaf support in a Web application.
But because of the new features in Thymeleaf3.0, we had to add thymeleaf-layout-dialect as a dependency in our SpringBoot2XWeb application. Configured rely on, we can add the template to the SRC/main/resources/templates folder, SpringBoot will automatically display them.
Spring Security configuration
For simplicity, we use the framework’s default HTTPBasic authentication. Let’s start by looking at the dependencies and configuration required to enable Security using Spring.
Spring first relies on the spring-security-Web and spring-security-config modules. Next, we need to add an extension WebSecurityConfigurerAdapter class, and using the @ EnableWebSecurity comments:
Here we use inMemoryAuthentication to set up authentication. SpringBoot also needs these dependencies for it to work. But we only need to define the spring-boot-starter-Security dependency, because this automatically adds all related dependencies to the classpath.
The security configuration in SpringBoot is the same as above.
The application starts the boot configuration
The basic difference between application boot in Spring and SpringBoot is the servlet. Spring using web. XML or SpringServletContainerInitializer as its guide entry point. SpringBoot only uses Servlet3 functionality to boot applications, so let’s take a closer look
Spring Boot Configuration
Spring supports traditional web.xml bootstringing as well as the latest Servlet3+ approach.
Configure the steps to start the web.xml method
The Servlet container (server) reads web.xml
The DispatcherServlet defined in web.xml is instantiated by the container
DispatcherServlet creates the WebApplicationContext by reading web-INF /{servletName}-servlet.xml. Finally, the DispatcherServlet registers the beans defined in the application context
Spring startup steps using the Servlet3+ method
Container search implementation ServletContainerInitializer class and executes SpringServletContainerInitializer find WebApplicationInitializer implement all kind
WebApplicationInitializer create an XML or context @ the Configuration class WebApplicationInitializer create DispatcherServlet context with previously created.
SpringBoot boot configuration
The entry point for a SpringBoot application is a class annotated with @SpringBootApplication
By default, SpringBoot uses an embedded container to run applications. In this case, SpringBoot uses the PublicStaticVoidMain entry point to launch the embedded Web server. In addition, it also is responsible for the Servlet Filter and ServletContextInitializerbean from the application context is bound to the embedded Servlet container. Another feature of SpringBoot is that it automatically scans all classes in the same package or components in subpackages of the Main class.
SpringBoot provides a way to deploy it to an external container. We only need to expand SpringBootServletInitializer:
Under the external servlet container to find here in the war file under the meta-inf folder of the MANIFEST. MF file defined in the Main – class, SpringBootServletInitializer servlet will be responsible for binding, The Filter and ServletContextInitializer.
Packaging and deployment
Preamble: Packaging and deployment I am not involved in the actual but also have a simple understanding
Finally, let’s look at how to package and deploy the application. Both frameworks support common package management technologies such as Maven and Gradle. But when it comes to deployment, these frameworks vary widely. For example, the SpringBoot Maven plug-in provides SpringBoot support in Maven. It also allows you to package an executable JAR or WAR package and run the application in place.
Some of SpringBoot’s advantages over Spring in a deployment environment include:
1. Provide embedded container support
2. Run the jar independently using the java-jar command
3. When deployed in an external container, you can choose to exclude dependencies to avoid potential JAR conflicts
4. Flexibly specify configuration file options during deployment
5. Random port generation for integration testing
conclusion
In short, we can say that SpringBoot is simply an extension of Spring itself, making development, testing, and deployment easier.