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

< the 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 >Copy the code

Unlike Spring, Spring Boot requires only 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 >Copy the code

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-jpa spring-boot-starter-security spring-boot-starter-test spring-boot-starter-web spring-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:

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("/"); }}Copy the code

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; }}Copy the code

Once we add the Web launcher, SpringBoot only needs to configure a few properties in the Application configuration file to do this:

Prefix =/ web-INF/JSP/spring.mvc.view.suffix=.jsp all spring configurations above are added to Bootweb through a process called auto-configuration Starter is automatically included.

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:

@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);
    }
}Copy the code

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.

@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();
    }
}Copy the code

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 supports traditional web.xml bootstringing as well as the latest Servlet3+ method.

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 executed
  • SpringServletContainerInitializer find all classes
  • WebApplicationInitializerWebApplicationInitializer create an XML or context @ the Configuration class WebApplicationInitializer created The DispatcherServlet with the previously created context.

SpringBoot boot configuration

The entry point for a SpringBoot application is a class annotated with @SpringBootApplication

@SpringBootApplication public class Application { public static void main(String[] args) { SpringApplication.run(Application.class, args); }}Copy the code

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:

/ * * * * 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()); }}Copy the code

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

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 command _java-jar_

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

In short, we can say that SpringBoot is just an extension of Spring itself, and that’s the end of this article. Hope you can have a harvest after reading it!

Wenyuan network, only for the use of learning, if there is infringement please contact delete.

I’ve compiled the interview questions and answers in PDF files, as well as a set of learning materials covering, but not limited to, the Java Virtual Machine, the Spring framework, Java threads, data structures, design patterns and more.

Follow the public account “Java Circle” for information, as well as quality articles delivered daily.