spring boot为什么要用 为什么要有springboot

本文概述了各种Spring配置样式，并帮助你了解配置Spring应用程序的复杂性。抽丝剥茧 细说架构那些事

Spring是一个非常流行的基于Java的框架，用于构建Web和企业应用程序。与许多其他框架仅关注一个领域不同，Spring框架通过其投资组合项目提供了广泛的功能来满足现代业务需求。

Spring框架提供了以多种方式（例如XML，Annotations和JavaConfig）配置bean的灵活性。随着功能数量的增加，复杂性也随之增加，配置Spring应用程序变得乏味且容易出错。

Spring团队创建了Spring Boot来解决配置的复杂性。

但是在深入探讨SpringBoot之前，我们将快速浏览一下Spring框架，看看SpringBoot试图解决什么样的问题。

在本文中，我们将介绍：

• Spring框架概述
• 使用Spring MVC和JPA（Hibernate）的Web应用程序
• 快速体验Spring Boot

Spring框架概述

如果你是Java开发人员，那么你很有可能听说过Spring框架，并且很可能已在项目中使用了它。Spring框架主要是作为依赖关系注入容器创建的，但不仅如此。

Spring非常受欢迎有几个原因：

• Spring的依赖注入方法鼓励编写可测试的代码
• 易于使用但功能强大的数据库事务管理功能
• Spring简化了与其他Java框架，比如JPA/Hibernate ORM, Struts/JSF/etc. web框架
• 用于构建Web应用程序的最新Web MVC框架

除Spring框架外，还有许多其他Spring姐妹项目可帮助构建满足现代业务需求的应用程序：

• Spring Data: 简化从关系和NoSQL数据存储的数据访问。
• Spring Batch: 提供强大的批处理框架。
• Spring Security: 强大的安全框架来保护应用程序。
• Spring Social: 支持与Facebook，Twitter，LinkedIn，GitHub等社交网站的集成。
• Spring Integration: 企业集成模式的实现，以促进使用轻量级消息传递和声明性适配器与其他企业应用程序集成。

还有许多其他有趣的项目可以满足其他各种现代应用程序开发需求。

最初，Spring框架提供了一种用于配置bean的基于XML的方法。后来，Spring引入了用于配置bean的基于XML的DSL，注释和基于JavaConfig的方法。

让我们快速看一下每种配置样式的外观。

基于XML的配置

1 <bean id="userService" class="com.sivalabs.myapp.service.UserService">
 2     <property name="userDao" ref="userDao"/>
 3 </bean>
 4 <bean id="userDao" class="com.sivalabs.myapp.dao.JdbcUserDao">
 5     <property name="dataSource" ref="dataSource"/>
 6 </bean>
 7 <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">
 8     <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
 9     <property name="url" value="jdbc:mysql://localhost:3306/test"/>
10     <property name="username" value="root"/>
11     <property name="password" value="secret"/>
12 </bean>

 

基于注释的配置

1 @Service
 2 public class UserService
 3 {
 4     private UserDao userDao;
 5     @Autowired
 6     public UserService(UserDao dao){
 7         this.userDao = dao;
 8     }
 9     ...
10     ...
11 }
12 @Repository
13 public class JdbcUserDao
14 {
15     private DataSource dataSource;
16     @Autowired
17     public JdbcUserDao(DataSource dataSource){
18         this.dataSource = dataSource;
19     }
20     ...
21     ...
22 }

 

基于JavaConfig的配置

1 @Configuration
 2 public class AppConfig
 3 {
 4     @Bean
 5     public UserService userService(UserDao dao){
 6         return new UserService(dao);
 7     }
 8     @Bean
 9     public UserDao userDao(DataSource dataSource){
10         return new JdbcUserDao(dataSource);
11     }
12     @Bean
13     public DataSource dataSource(){
14         BasicDataSource dataSource = new BasicDataSource();
15         dataSource.setDriverClassName("com.mysql.jdbc.Driver");
16         dataSource.setUrl("jdbc:mysql://localhost:3306/test");
17         dataSource.setUsername("root");
18         dataSource.setPassword("secret");
19         return dataSource;
20     }
21 }

 

哇... Spring提供了许多用于完成同一任务的方法，我们甚至可以混合使用这些方法，并在同一应用程序中同时使用基于JavaConfig和基于注释的配置样式。

这具有很大的灵活性，既有好处也有坏处。 刚接触Spring框架的人可能会对采用哪种方法感到困惑。 到目前为止，Spring团队建议遵循基于JavaConfig的方法，因为它可以提供更大的灵活性。

但是，没有一种千篇一律的解决方案。 必须根据自己的应用程序需求选择方法。

好的，现在你已经大致了解了各种样式的Spring bean配置外观。

让我们快速看一下典型的SpringMVC + JPA / Hibernate Web应用程序配置的配置。

使用Spring MVC和JPA的Web应用程序（休眠）

在了解什么是Spring Boot及其提供的功能之前，让我们看一下典型的Spring Web应用程序配置的外观，痛点以及Spring Boot如何解决这些问题。

步骤1：配置Maven依赖项

我们需要做的第一件事是配置pom.xml中所需的所有依赖项。

1 <?xml version="1.0" encoding="UTF-8"?>
 2 <project xmlns="http://maven.apache.org/POM/4.0.0"
 3     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 4     xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 
 5                         http://maven.apache.org/maven-v4_0_0.xsd">
 6     <modelVersion>4.0.0</modelVersion>
 7     <groupId>com.sivalabs</groupId>
 8     <artifactId>springmvc-jpa-demo</artifactId>
 9     <packaging>war</packaging>
10     <version>1.0-SNAPSHOT</version>
11     <name>springmvc-jpa-demo</name>
12     <properties>
13         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
14         <maven.compiler.source>1.8</maven.compiler.source>
15         <maven.compiler.target>1.8</maven.compiler.target>      
16         <failOnMissingWebXml>false</failOnMissingWebXml>
17     </properties>
18     <dependencies>
19         <dependency>
20             <groupId>org.springframework</groupId>
21             <artifactId>spring-webmvc</artifactId>
22             <version>4.2.4.RELEASE</version>
23         </dependency>
24         <dependency>
25             <groupId>org.springframework.data</groupId>
26             <artifactId>spring-data-jpa</artifactId>
27             <version>1.9.2.RELEASE</version>
28         </dependency>
29         <dependency>
30             <groupId>org.slf4j</groupId>
31             <artifactId>jcl-over-slf4j</artifactId>
32             <version>1.7.13</version>
33         </dependency>
34         <dependency>
35             <groupId>org.slf4j</groupId>
36             <artifactId>slf4j-api</artifactId>
37             <version>1.7.13</version>
38         </dependency>
39         <dependency>
40             <groupId>org.slf4j</groupId>
41             <artifactId>slf4j-log4j12</artifactId>
42             <version>1.7.13</version>
43         </dependency>
44         <dependency>
45             <groupId>log4j</groupId>
46             <artifactId>log4j</artifactId>
47             <version>1.2.17</version>
48         </dependency>
49         <dependency>
50             <groupId>com.h2database</groupId>
51             <artifactId>h2</artifactId>
52             <version>1.4.190</version>
53         </dependency>
54         <dependency>
55             <groupId>commons-dbcp</groupId>
56             <artifactId>commons-dbcp</artifactId>
57             <version>1.4</version>
58         </dependency>
59         <dependency>
60             <groupId>mysql</groupId>
61             <artifactId>mysql-connector-java</artifactId>
62             <version>5.1.38</version>
63         </dependency>
64         <dependency>
65             <groupId>org.hibernate</groupId>
66             <artifactId>hibernate-entitymanager</artifactId>
67             <version>4.3.11.Final</version>
68         </dependency>
69         <dependency>
70             <groupId>javax.servlet</groupId>
71             <artifactId>javax.servlet-api</artifactId>
72             <version>3.1.0</version>
73             <scope>provided</scope>
74         </dependency>
75         <dependency>
76             <groupId>org.thymeleaf</groupId>
77             <artifactId>thymeleaf-spring4</artifactId>
78             <version>2.1.4.RELEASE</version>
79         </dependency>
80     </dependencies>
81 </project>

 

我们已经将所有Maven jar依赖项配置为包括Spring MVC，Spring Data JPA，JPA / Hibernate，Thymeleaf和Log4j。

步骤2：使用JavaConfig配置服务/ DAO层Bean

1 @Configuration
 2 @EnableTransactionManagement
 3 @EnableJpaRepositories(basePackages="com.sivalabs.demo")
 4 @PropertySource(value = { "classpath:application.properties" })
 5 public class AppConfig 
 6 {
 7     @Autowired
 8     private Environment env;
 9     @Bean
10     public static PropertySourcesPlaceholderConfigurer placeHolderConfigurer()
11     {
12         return new PropertySourcesPlaceholderConfigurer();
13     }
14     @Value("${init-db:false}")
15     private String initDatabase;
16     @Bean
17     public PlatformTransactionManager transactionManager()
18     {
19         EntityManagerFactory factory = entityManagerFactory().getObject();
20         return new JpaTransactionManager(factory);
21     }
22     @Bean
23     public LocalContainerEntityManagerFactoryBean entityManagerFactory()
24     {
25         LocalContainerEntityManagerFactoryBean factory = new LocalContainerEntityManagerFactoryBean();
26         HibernateJpaVendorAdapter vendorAdapter = new HibernateJpaVendorAdapter();
27         vendorAdapter.setGenerateDdl(Boolean.TRUE);
28         vendorAdapter.setShowSql(Boolean.TRUE);
29         factory.setDataSource(dataSource());
30         factory.setJpaVendorAdapter(vendorAdapter);
31         factory.setPackagesToScan("com.sivalabs.demo");
32         Properties jpaProperties = new Properties();
33         jpaProperties.put("hibernate.hbm2ddl.auto", env.getProperty("hibernate.hbm2ddl.auto"));
34         factory.setJpaProperties(jpaProperties);
35         factory.afterPropertiesSet();
36         factory.setLoadTimeWeaver(new InstrumentationLoadTimeWeaver());
37         return factory;
38     }
39     @Bean
40     public HibernateExceptionTranslator hibernateExceptionTranslator()
41     {
42         return new HibernateExceptionTranslator();
43     }
44     @Bean
45     public DataSource dataSource()
46     {
47         BasicDataSource dataSource = new BasicDataSource();
48         dataSource.setDriverClassName(env.getProperty("jdbc.driverClassName"));
49         dataSource.setUrl(env.getProperty("jdbc.url"));
50         dataSource.setUsername(env.getProperty("jdbc.username"));
51         dataSource.setPassword(env.getProperty("jdbc.password"));
52         return dataSource;
53     }
54     @Bean
55     public DataSourceInitializer dataSourceInitializer(DataSource dataSource) 
56     {
57         DataSourceInitializer dataSourceInitializer = new DataSourceInitializer();
58         dataSourceInitializer.setDataSource(dataSource);
59         ResourceDatabasePopulator databasePopulator = new ResourceDatabasePopulator();
60         databasePopulator.addScript(new ClassPathResource("data.sql"));
61         dataSourceInitializer.setDatabasePopulator(databasePopulator);
62         dataSourceInitializer.setEnabled(Boolean.parseBoolean(initDatabase));
63         return dataSourceInitializer;
64     }   
65 }

 

在我们的AppConfig.java配置类中，我们执行了以下操作：

• 使用@Configuration批注将其标记为Spring Configuration类
• 使用@EnableTransactionManagement启用基于注释的事务管理
• 配置了@EnableJpaRepositories以指示在何处查找Spring Data JPA存储库
• 使用@PropertySource批注和PropertySourcesPlaceholderConfigurer Bean定义配置的PropertyPlaceHolder Bean，该定义从application.properties文件加载属性
• 为DataSource，JPA EntityManagerFactory，JpaTransactionManager定义的bean
• 已配置的DataSourceInitializer bean通过在应用程序启动时执行data.sql脚本来初始化数据库

我们需要在application.properties中配置属性占位符值，如下所示：

1 jdbc.driverClassName=com.mysql.jdbc.Driver
2 jdbc.url=jdbc:mysql://localhost:3306/test
3 jdbc.username=root
4 jdbc.password=admin
5 init-db=true
6 hibernate.dialect=org.hibernate.dialect.MySQLDialect
7 hibernate.show_sql=true
8 hibernate.hbm2ddl.auto=update

 

我们可以创建一个简单的SQL脚本data.sql，以将示例数据填充到USER表中：

1 delete from user;
2 insert into user(id, name) values(1,'Siva');
3 insert into user(id, name) values(2,'Prasad');
4 insert into user(id, name) values(3,'Reddy');

 

我们可以使用以下基本配置创建log4j.properties文件：

1 log4j.rootCategory=INFO, stdout
2 log4j.appender.stdout=org.apache.log4j.ConsoleAppender
3 log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
4 log4j.appender.stdout.layout.ConversionPattern=%5p %t %c{2}:%L - %m%n
5 log4j.category.org.springframework=INFO
6 log4j.category.com.sivalabs=DEBUG

 

步骤3：配置Spring MVC Web层Bean

我们将必须为i18n配置Thymeleaf ViewResolver，静态ResourceHandlers，MessageSource等。

1 @Configuration
 2 @ComponentScan(basePackages = { "com.sivalabs.demo"}) 
 3 @EnableWebMvc
 4 public class WebMvcConfig extends WebMvcConfigurerAdapter
 5 {
 6     @Bean
 7     public TemplateResolver templateResolver() {
 8         TemplateResolver templateResolver = new ServletContextTemplateResolver();
 9         templateResolver.setPrefix("/WEB-INF/views/");
10         templateResolver.setSuffix(".html");
11         templateResolver.setTemplateMode("HTML5");
12         templateResolver.setCacheable(false);
13         return templateResolver;
14     }
15     @Bean
16     public SpringTemplateEngine templateEngine() {
17         SpringTemplateEngine templateEngine = new SpringTemplateEngine();
18         templateEngine.setTemplateResolver(templateResolver());
19         return templateEngine;
20     }
21     @Bean
22     public ThymeleafViewResolver viewResolver() {
23         ThymeleafViewResolver thymeleafViewResolver = new ThymeleafViewResolver();
24         thymeleafViewResolver.setTemplateEngine(templateEngine());
25         thymeleafViewResolver.setCharacterEncoding("UTF-8");
26         return thymeleafViewResolver;
27     }
28     @Override
29     public void addResourceHandlers(ResourceHandlerRegistry registry)
30     {
31         registry.addResourceHandler("/resources/**").addResourceLocations("/resources/");
32     }
33     @Override
34     public void configureDefaultServletHandling(DefaultServletHandlerConfigurer configurer)
35     {
36         configurer.enable();
37     }
38     @Bean(name = "messageSource")
39     public MessageSource configureMessageSource()
40     {
41         ReloadableResourceBundleMessageSource messageSource = new ReloadableResourceBundleMessageSource();
42         messageSource.setBasename("classpath:messages");
43         messageSource.setCacheSeconds(5);
44         messageSource.setDefaultEncoding("UTF-8");
45         return messageSource;
46     }
47 }

 

在我们的WebMvcConfig.java配置类中，我们执行了以下操作：

• 使用@Configuration批注将其标记为Spring Configuration类
• 使用@EnableWebMvc启用基于注释的Spring MVC配置
• 通过注册TemplateResolver，SpringTemplateEngine，ThymeleafViewResolver Bean来配置Thymeleaf ViewResolver
• 已注册的ResourceHandlers bean，以指示将通过位置/resources/目录来提供对带有URI/resources/ **的静态资源的请求
• 已配置的MessageSource bean从类路径的ResourceBundle消息-{country-code} .properties中加载i18n消息

目前，我们没有任何消息要配置，因此请在src/main/ resources文件夹中创建一个空的messages.properties文件。

步骤4：注册Spring MVC FrontController Servlet DispatcherServlet

在Servlet 3.x规范之前，我们必须在web.xml中注册Servlet/过滤器。从Servlet 3.x规范开始，我们可以使用ServletContainerInitializer以编程方式注册Servlet/过滤器。

Spring MVC提供了一个方便的类AbstractAnnotationConfigDispatcherServletInitializer来注册DispatcherServlet。

1 public class SpringWebAppInitializer extends AbstractAnnotationConfigDispatcherServletInitializer
 2 {
 3     @Override
 4     protected Class<?>[] getRootConfigClasses()
 5     {
 6         return new Class<?>[] { AppConfig.class};
 7     }
 8     @Override
 9     protected Class<?>[] getServletConfigClasses()
10     {
11         return new Class<?>[] { WebMvcConfig.class };
12     }
13     @Override
14     protected String[] getServletMappings()
15     {
16         return new String[] { "/" };
17     }
18     @Override
19     protected Filter[] getServletFilters() {
20        return new Filter[]{ new OpenEntityManagerInViewFilter() };
21     }
22 }

 

在我们的SpringWebAppInitializer.java配置类中，我们执行了以下操作：

• 我们已将AppConfig.class配置为RootConfirationClasses，它将成为父ApplicationContext，其中包含由所有子（DispatcherServlet）上下文共享的bean定义。
• 我们已将WebMvcConfig.class配置为ServletConfigClasses，它是包含WebMvc bean定义的childApplicationContext。
• 我们已将“/”配置为ServletMapping，这意味着所有请求将由DispatcherServlet处理。
• 我们已经将OpenEntityManagerInViewFilter注册为Servlet过滤器，以便在呈现视图时可以延迟加载JPA Entity延迟集合。

步骤5：创建一个JPA实体和Spring Data JPA存储库

为用户实体创建一个JPA实体User.java和一个Spring Data JPA存储库。

1 @Entity
 2 public class User
 3 {
 4     @Id @GeneratedValue(strategy=GenerationType.AUTO)
 5     private Integer id;
 6     private String name;
 7     //setters and getters
 8 }
 9 public interface UserRepository extends JpaRepository<User, Integer>
10 {
11 }

 

步骤6：创建一个SpringMVC控制器

创建一个SpringMVC控制器来处理URL“/”并呈现用户列表。

1 @Controller
 2 public class HomeController
 3 {
 4     @Autowired UserRepository userRepo;
 5     @RequestMapping("/")
 6     public String home(Model model)
 7     {
 8         model.addAttribute("users", userRepo.findAll());
 9         return "index";
10     }
11 }

 

步骤7：创建Thymeleaf View /WEB-INF/views/index.html来呈现用户列表

1 <!DOCTYPE html>
 2 <html xmlns="http://www.w3.org/1999/xhtml"
 3       xmlns:th="http://www.thymeleaf.org">
 4 <head>
 5 <meta charset="utf-8"/>
 6 <title>Home</title>
 7 </head>
 8 <body>
 9     <table>
10         <thead>
11             <tr>
12                 <th>Id</th>
13                 <th>Name</th>
14             </tr>
15         </thead>
16         <tbody>
17             <tr th:each="user : ${users}">
18                 <td th:text="${user.id}">Id</td>
19                 <td th:text="${user.name}">Name</td>
20             </tr>
21         </tbody>
22     </table>
23 </body>
24 </html>

 

现在我们已经准备好运行该应用程序。但是在此之前，我们需要在你的IDE中下载并配置服务器，例如Tomcat或Jetty或Wildfly等。

你可以下载Tomcat 8并在你喜欢的IDE中进行配置，运行该应用程序并将浏览器指向http:// localhost:8080/ springmvcjpa-demo。你应该在表中看到用户详细信息列表。

是的...我们做到了。

但是，等等。仅显示从数据库表中提取的用户详细信息列表是否不是一项繁重的工作？

让我们诚实和公平。所有这些配置不仅仅针对这一用例。此配置也是其余应用程序的基础。

但是同样，如果你想快速启动并运行，这是太多的工作要做。

另一个问题是，假设你要开发具有类似技术堆栈的另一个SpringMVC应用程序？

好了，你复制粘贴配置并进行调整。对？但是请记住一件事：如果你必须一次又一次地执行相同的操作，则应该找到一种自动的方法来执行此操作。

除了一遍又一遍地写相同的配置，你在这里还看到其他问题吗？

好吧，让我列出我在这里看到的问题。

• 你需要寻找特定Spring版本的所有兼容库并进行配置。
• 95％的时间我们以相同的方式配置DataSource，EntitymanagerFactory，TransactionManager等bean。如果Spring可以自动为我完成任务，那不是很好。
• 同样，大多数情况下，我们以相同的方式配置SpringMVC bean，例如ViewResolver，MessageSource等。

想象一下，如果Spring能够自动配置bean呢？如果可以使用简单的可自定义属性自定义自动配置该怎么办？

例如，你不想将DispatcherServlet url-pattern映射到“/”，而是要将其映射到“/app/”。与其将Thymeleaf视图放置在“/ WEB-INF / views”文件夹中，不如将它们放置在“/WEB-INF/templates/”文件夹中。

因此，基本上，你希望Spring自动执行操作，但是提供了以更简单的方式覆盖默认配置的灵活性？

好吧，你即将进入SpringBoot的世界，梦想成真！！！

快速体验Spring Boot

欢迎使用Spring Boot！Spring Boot确实可以满足你的需求。它会自动为你执行操作，但是允许你覆盖默认值。

与其从理论上解释，不如说我以身作则。

因此，让我们实现与之前构建的应用程序相同的应用程序，但是这次使用SpringBoot。

步骤1：创建基于Maven的Spring Boot项目

创建一个Maven项目并配置依赖项，如下所示：

1 <?xml version="1.0" encoding="UTF-8"?>
 2 <project xmlns="http://maven.apache.org/POM/4.0.0"
 3         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 4         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 
 5                         http://maven.apache.org/maven-v4_0_0.xsd">
 6     <modelVersion>4.0.0</modelVersion>
 7     <groupId>com.sivalabs</groupId>
 8     <artifactId>hello-springboot</artifactId>
 9     <packaging>jar</packaging>
10     <version>1.0-SNAPSHOT</version>
11     <name>hello-springboot</name>
12     <parent>
13         <groupId>org.springframework.boot</groupId>
14         <artifactId>spring-boot-starter-parent</artifactId>
15         <version>1.3.2.RELEASE</version>
16     </parent>
17     <properties>
18         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
19         <java.version>1.8</java.version>
20     </properties>
21     <dependencies>
22         <dependency>
23             <groupId>org.springframework.boot</groupId>
24             <artifactId>spring-boot-starter-test</artifactId>
25         </dependency>
26         <dependency>
27             <groupId>org.springframework.boot</groupId>
28             <artifactId>spring-boot-starter-data-jpa</artifactId>
29         </dependency>
30         <dependency>
31             <groupId>org.springframework.boot</groupId>
32             <artifactId>spring-boot-starter-web</artifactId>
33         </dependency>
34         <dependency>
35             <groupId>org.springframework.boot</groupId>
36             <artifactId>spring-boot-starter-thymeleaf</artifactId>
37         </dependency>
38         <dependency>
39             <groupId>org.springframework.boot</groupId>
40             <artifactId>spring-boot-devtools</artifactId>
41         </dependency>
42         <dependency>
43             <groupId>mysql</groupId>
44             <artifactId>mysql-connector-java</artifactId>
45         </dependency>
46     </dependencies>
47 </project>

 

哇，我们的pom.xml突然变得如此之小！

步骤2：按照以下步骤在application.properties中配置数据源/ JPA属性

1 spring.datasource.driver-class-name=com.mysql.jdbc.Driver
2 spring.datasource.url=jdbc:mysql://localhost:3306/test
3 spring.datasource.username=root
4 spring.datasource.password=admin
5 spring.datasource.initialize=true
6 spring.jpa.hibernate.ddl-auto=update
7 spring.jpa.show-sql=true

 

你可以将相同的data.sql文件复制到src / main / resources文件夹中。

步骤3：为该实体创建JPA实体和Spring Data JPA存储库接口

创建与springmvc-jpa-demoapplication中相同的User.java，UserRepository.java和HomeController.java。

步骤4：创建Thymeleaf视图以显示用户列表

将我们在springmvc-jpa-demo应用程序中创建的/WEB-INF/views/index.html复制到新项目中的src/-main/resources/ templates文件夹中。

步骤5：创建SpringBoot EntryPoint类

使用以下主要方法创建一个Java类Application.java：

1 @SpringBootApplication
2 public class Application
3 {
4     public static void main(String[] args)
5     {
6         SpringApplication.run(Application.class, args);
7     }
8 }

 

现在，将Application.java作为Java应用程序运行，并将浏览器指向http:// localhost:8080/。

你应该以表格格式看到用户列表。酷!!!

好吧好吧，我听到你在喊“发生了什么事？？”。

让我解释一下发生了什么。

1. 轻松的依赖管理

• 首先要观察的是，我们正在使用一些名为spring-boot-starter- *的依赖项。请记住，我说过“ 95％的时间我使用相同的配置。因此，默认情况下，当你添加springboot-starter-web依赖项时，它将在开发Spring MVC应用程序（例如spring-webmvc，jackson-json，validation-api和tomcat）时提取所有常用的库。
• 我们添加了spring-boot-starter-data-jpa依赖性。这拉动了所有spring-data-jpa依赖关系，并添加了Hibernate库，因为大多数应用程序都将Hibernate用作JPA实现。

2. 自动配置

• 不仅spring-boot-starter-web添加了所有这些库，而且还使用合理的默认值配置了常用注册的Bean，例如DispatcherServlet，ResourceHandlers，MessageSource等Bean。
• 我们还添加了spring-boot-starter-Thymeleaf，它不仅添加Thymeleaf库依赖项，而且还自动配置ThymeleafViewResolver Bean。
• 我们尚未定义任何DataSource，EntityManagerFactory，TransactionManageretc Bean，但是会自动创建它们。怎么样？如果我们的类路径中有任何内存数据库驱动程序，例如H2或HSQL，那么SpringBoot将自动创建内存数据源，然后自动使用明智的默认值注册EntityManagerFactory和TransactionManager bean。但是我们正在使用MySQL，因此我们需要显式提供MySQL连接详细信息。我们已经在application.properties文件中配置了这些MySQL连接详细信息，SpringBoot使用这些属性创建了一个DataSource。

3. 嵌入式Servlet容器支持

最重要和令人惊讶的事情是，我们创建了一个简单的Java类，该类以一些神奇的注释@SpringApplication进行了注释，该类具有main方法，并且通过运行该main方法，我们可以运行该应用程序并在http:// localhost:8080/进行访问。

servlet容器来自哪里？

我们添加了spring-boot-starter-web，它会自动拉出spring-boot-starter-tomcat，当我们运行main()方法时，它将tomcat作为嵌入式容器启动，这样我们就不必在任何应用程序上部署应用程序 外部安装的tomcat服务器。

顺便说一句，你是否注意到我们在pom.xml中的包装类型是“罐子”而不是“战争”。精彩！

好的，但是如果我想使用Jetty服务器而不是tomcat怎么办？

简单，将spring-bootstarter-tomcat从spring-boot-starter-web中排除，并包括spring-boot-starter-jetty。

而已。

但是，这看起来很神奇！！！

我可以想象你在想什么。你在想，SpringBoot看起来很酷，它会自动为我做很多事情。但是，我仍然不完全了解幕后工作的一切。对？

我能够了解。观看魔术表演通常很有趣，但是在软件开发中却不是。不用担心，我们将在以后的文章中仔细研究每件事，并详细说明幕后情况。但是，我现在不想在本文中将所有内容都丢给你而让你不知所措。

总结

在本文中，我们快速概述了各种Spring配置样式，并了解了配置Spring应用程序的复杂性。另外，我们通过创建一个简单的Web应用程序快速浏览了SpringBoot。

在下一篇文章中，我们将深入研究SpringBoot并了解其工作原理。

感谢阅读！