Why Spring Boot

原文：https://dzone.com/articles/why-springboot 作者：Siva Prasad Reddy Katamreddy 译者：Oopsguy

本文介绍将各种Spring的配置方式，帮助您了解配置Spring应用的复杂性。

Spring是一个非常受欢迎的Java框架，它用于构建web和企业应用。不像许多其他框架只关注一个领域，Spring框架提供了各种功能，通过项目组合来满足当代业务需求。

Spring框架提供了多种灵活的方式配置Bean。例如XML、注解和Java配置。随着功能数量的增加，复杂性也随之增加，配置Spring应用将变得乏味而且容易出错。 Spring团队创建了Spring Boot以解决配置复杂的问题。

但在开始Spring Boot之前，我们将快速浏览一下Spring框架，看看Spring Boot正在决解什么样的问题。

在本文中，我们将介绍：

• Spring框架概述

• 一个使用了Spring MVC和JPA（Hibernate）的web应用

• 快速尝试Spring Boot

Spring框架概述

如果您是一名Java开发人员，那么您很可能听说过Spring框架，甚至可能已经在您的项目中使用了它。Spring框架主要是作为依赖注入容器，但它不仅仅是这样。

Spring很受欢迎的原因有几点：

• Spring的依赖注入方式鼓励编写可测试代码。

• 具备简单但功能强大的数据库事务管理功能

• Spring简化了与其他Java框架的集成工作，比如JPA/Hibernate ORM和Struts/JSF等web框架。

• 构建web应用最先进的Web MVC框架。

连同Spring一起的，还有许多其他的Spring姊妹项目，可以帮助构建满足当代业务需求的应用：

• Spring Data：简化了关系数据库和NoSQL数据存储的数据访问。

• Spring Batch：提供强大的批处理框架。

• Spring Security：用于保护应用的强大的安全框架。

• Spring Social：支持与Facebook、Twitter、Linkedin、Github等社交网站集成。

• Spring Integration：实现了企业集成模式，以便于使用轻量级消息和声明式适配器与其他企业应用集成。

还有许多其他有趣的项目涉及各种其他当代应用开发需求。有关更多信息，请查看http://spring.io/projects。

刚开始，Spring框架只提供了基于XML的方方式来配置bean。后来，Spring引入了基于XML的DSL、注解和基于Java配置的方式来配置bean。

让我们快速了解一下这些配置风格的大概样子。

基于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. }

1. @Repository

2. public class JdbcUserDao

3. {

4.    private DataSource dataSource;

5.    @Autowired

6.    public JdbcUserDao(DataSource dataSource){

7.        this.dataSource = dataSource;

8.    }

9.    ...

10.    ...

11. }

基于Java配置

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提供给了许多方法来做同样的事，我们甚至可以混合使用，在同一个应用中使用基于Java配置和注解配置的方式。

这非常灵活，但它有好有坏。刚开始接触Spring的新人可能会困惑应该使用哪一种方式。到目前为止，Spring团队建议使用基于Java配置的方式，因为它具有更多的灵活性。

没有哪一种方案是万能，我们应该根据自己的需求来选择合适的方式。

很好，现在您已经了解了多种Spring Bean的配置方式的基本形式。

让我们快速地了解一下典型的Spring MVC+JPA/Hibernate web应用的配置。

一个使用了Spring MVC和JPA（Hibernate）的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：使用Java配置配置Service/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配置类。

• 使用 @EnableTransactionManagement开启基于注解的事务管理。

• 配置 @EnableJpaRepositories指定去哪查找Spring Data JPA资源库（repository）。

• 使用 @PropertySource注解和 PropertySourcesPlaceholderConfigurer Bean定义配置PropertyPlaceHolder bean从 application.properties文件加载配置。

• 为DataSource、JAP的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

我们必须配置Thymleaf的ViewResolver、处理静态资源的ResourceHandler和处理i18n的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配置类。

• 使用 @EnableWebMvc注解启用基于注解的Spring MVC配置。

• 通过注册TemplateResolver、SpringTemplateEngine和`hymeleafViewResolver Bean来配置Thymeleaf视图解析器。

• 注册ResourceHandler Bean将以URI为 /resource/**的静态资源请求定位到 /resource/目录下。

• 配置MessageSource bean从classpath下加载messages-{国家代码}.properties文件来加载i18n配置。

现在我们没有配置任何i18n内容，所以需要在 src/main/resources文件夹下创建一个空的 messages.properties文件。

步骤4：注册Spring MVC的前端控制器DispatcherServlet

在Servlet 3.x规范之前，我们必须在web.xml中注册Servlet/Filter。由于当前是Servlet 3.x规范，我们可以使用ServletContainerInitializer以编程的方式注册Servlet /Filter。

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配置为RootConfigurationClass，它将成为包含了所有子上下文（DispatcherServlet）共享的Bean定义的父ApplicationContext。

• 我们将 WebMvcConfig.class配置为ServletConfigClass，它是包含了WebMvc Bean定义的子ApplicationContext。

• 我们将 /配置为ServletMapping，这意味所有的请求将由DispatcherServlet处理。

• 我们将OpenEntityManagerInViewFilter注册为Servlet过滤器，以便我们在渲染视图时可以延迟加载JPA Entity的延迟集合。

步骤5：创建一个JPA实体和Spring Data JPA资源库

为User实体创建一个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. }

1. public interface UserRepository extends JpaRepository<User, Integer>

2. {

3. }

步骤6：创建一个Spring MVC控制器

创建一个Spring MVC控制器来处理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视图/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/springmvc-jpa-demo。您应该看到一个以表格形式展示的用户详细信息列表。

Yay…( •̀ ω •́ )y，我们做到了。

但是等等，做了那么多的工作仅仅是为了从数据库中获取用户信息然后展示一个列表？

让我们诚实公平地来看待，所有的这些配置不仅仅是为了这次示例，这些配置也是其他应用的基础。

但我还是想说，如果您想早点起床跑步，这有太多的工作要做。

另一个问题是，假设您想要开发另一个Spring MVC应用，您会使用类似的技术栈？

好，您要做的就是复制粘贴配置并调整它。对么？但请记住一件事：如果您一次又一次地做同样的事情，您应该寻找一种自动化的方式来完成它。

除了一遍又一遍地编写相同的配置，您还能发现其他问题么？

这样吧，让我列出我从中发现的问题。

• 您需要寻找特定版本的Spring以便完全兼容所有的库，并进行配置。

• 我们花费了95%的时间以同样的方式配置DataSource、EntityManagerFactory和TransactionManager等bean。如果Spring能自动帮我们完成这些事，是不是非常棒？

• 同样，我们大多时候以同样的方式配置Spring MVC的bean，比如ViewResolver、MessageResource等。

如果Spring可以自动帮我做这些事情，那真的非常棒！！！

想象一下，如果Spring能够自动配置bean呢？如果您可以使用简单的自定义配置来定义自动配置又将怎么样？

例如，您可以将DispatcherServlet的url-pattern映射到 /app/，而不是 /。您可以将Theymeleaf视图放在 /WEB-INF/template/文件夹下，而不是放在 /WEB-INF/views中。

所以基本上您希望Spring能自动执行这些操作，但是它有没有提供一个简单灵活的方式来覆盖掉默认配置呢？

很好，您即将进入Spring Boot的世界，您将梦想成真！

快速尝试Sprig Boot

欢迎来到Spring Boot世界！Spring Boot正是您一直在寻找的。它可以自动为您完成某些事情，但如果有必要，您可以覆盖掉默认配置。

与拿理论解释相比，我更喜欢通过案例来讲解。

步骤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中配置DataSoure/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-demo应用一样，创建User.java、UserRepository.java和HomeController.java。

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

从 springmvc-jpa-demo项目中复制之前创建的 /WEB-INF/views/index.html到 src/main/resources/template文件夹中。

步骤5：创建Spring Boot入口类

创建一个含有 main方法的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-start-*的依赖。记住我说过我花费95%的时间来配置同样的配置。当您在开发Spring MVC应用时添加了 spring-boot-start-web依赖，它已经包含了常用的一些库，比如spring-webmvc、jackson-json、validation-api和tomcat等。

• 我们添加了 spring-boot-starter-data-jpa依赖。它包含了所有的 spring-data-jpa依赖，并且还添加了Hibernate库，因为很多应用使用Hibernate作为JPA的实现。

1. 自动配置

• spring-boot-starter-web不仅添加了这些库，还配置了经常被注册的bean，比如DispatcherServlet、ResourceHandler和MessageSource等bean，并且应用了合适的默认配置。

• 我们还添加了 spring-boot-starter-Thymeleaf，它不仅添加了Thymeleaf的依赖，还自动配置了ThymeleafViewResolver bean。

• 虽然我们没有定义任何DataSource、EntityManagerFactory和TransactionManager等bean，但它们可以被自动创建。怎么样？如果在classpath下没有任何内存数据库驱动，如H2或者HSQL，那么Spring Boot将自动创建一个内存数据库的DataSource，然后应用合理的默认配置自动注册EntityManagerFactory和TransactionManager等bean。但是我们正在使用MySQL，所以我们需要明确提供MySQL的连接信息。我们已经在 application.properties文件中配置了MySQL连接信息，Spring Boot将应用这些配置来创建DataSource。

1. 支持嵌入式Servlet容器

• 最重要且最让人惊讶的是，我们创建了一个简单的Java类，标记了一个神奇的注解 @SpringApplication，它有一个main方法。通过运行main方法，我们可以运行这个应用并通过 http://localhost:8080/来访问。

Servlet容器来自哪里？

我们添加了 spring-boot-starter-web，它会自动引入 spring-boot-starter-tomcat。当我们运行main()方法时，它将tomcat作为一个嵌入式容器启动，我们不需要部署我们的应用到外部安装好的tomcat上。

顺便说一句，您看到我们在pom.xml中配置的打包类型是jar而不是war，真有趣！

很好，但是如果我想使用jetty服务器而不是tomcat呢？很简单，只需要从 spring-boot-starter-web中排除掉 sprig-boot-starter-tomcat，并包含 spring-boot-starter-jetty依赖即可。

就是这样。

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

我可以想象此时您在想什么。您正在感叹Spring Boot真的很酷，它为我自动完成了很多事情。但是，我还没了完全明白它幕后是怎样工作的，对不对？

我可以理解，观看魔术表演是非常有趣的，但软件开发则不一样，不用担心，未来我们将看到各种新奇的东西，并在以后的文章中详细地解释它们幕后的工作原理。很遗憾的是，我不能在这篇文章中把所有的东西都教给您。

总结

在本文中，我们快速介绍了各种Spring配置的样式，并了解了配置Spring应用的复杂型。此外，我们通过创建一个简单的web应用来快速了解Spring Boot。

推荐阅读

• 程序员你为什么这么累【续】：编码习惯之接口定义

长按指纹

一键关注

点击“阅读原文”