为什么是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 的配置

<bean id="userService" class="com.sivalabs.myapp.service.UserService">
    <property name="userDao" ref="userDao"/>
</bean>
<bean id="userDao" class="com.sivalabs.myapp.dao.JdbcUserDao">
    <property name="dataSource" ref="dataSource"/>
</bean>
<bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">
    <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
    <property name="url" value="jdbc:mysql://localhost:3306/test"/>
    <property name="username" value="root"/>
    <property name="password" value="secret"/>
</bean>

基于注解的配置

@Service
public class UserService
{
    private UserDao userDao;
    @Autowired
    public UserService(UserDao dao){
        this.userDao = dao;
    }
    ...
    ...
}

@Repository
public class JdbcUserDao
{
    private DataSource dataSource;
    @Autowired
    public JdbcUserDao(DataSource dataSource){
        this.dataSource = dataSource;
    }
    ...
    ...
}

基于 Java 代码的配置

@Configuration
public class AppConfig
{
    @Bean
    public UserService userService(UserDao dao){
        return new UserService(dao);
    }
    @Bean
    public UserDao userDao(DataSource dataSource){
        return new JdbcUserDao(dataSource);
    }
    @Bean
    public DataSource dataSource(){
        BasicDataSource dataSource = new BasicDataSource();
        dataSource.setDriverClassName("com.mysql.jdbc.Driver");
        dataSource.setUrl("jdbc:mysql://localhost:3306/test");
        dataSource.setUsername("root");
        dataSource.setPassword("secret");
        return dataSource;
    }
}

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 中所需的依赖：

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 
                        http://maven.apache.org/maven-v4_0_0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.sivalabs</groupId>
    <artifactId>springmvc-jpa-demo</artifactId>
    <packaging>war</packaging>
    <version>1.0-SNAPSHOT</version>
    <name>springmvc-jpa-demo</name>
    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <maven.compiler.source>1.8</maven.compiler.source>
        <maven.compiler.target>1.8</maven.compiler.target>      
        <failOnMissingWebXml>false</failOnMissingWebXml>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>4.2.4.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.data</groupId>
            <artifactId>spring-data-jpa</artifactId>
            <version>1.9.2.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>jcl-over-slf4j</artifactId>
            <version>1.7.13</version>
        </dependency>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-api</artifactId>
            <version>1.7.13</version>
        </dependency>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-log4j12</artifactId>
            <version>1.7.13</version>
        </dependency>
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>1.2.17</version>
        </dependency>
        <dependency>
            <groupId>com.h2database</groupId>
            <artifactId>h2</artifactId>
            <version>1.4.190</version>
        </dependency>
        <dependency>
            <groupId>commons-dbcp</groupId>
            <artifactId>commons-dbcp</artifactId>
            <version>1.4</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.38</version>
        </dependency>
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-entitymanager</artifactId>
            <version>4.3.11.Final</version>
        </dependency>
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>javax.servlet-api</artifactId>
            <version>3.1.0</version>
            <scope>provided</scope>
        </dependency>
        <dependency>
            <groupId>org.thymeleaf</groupId>
            <artifactId>thymeleaf-spring4</artifactId>
            <version>2.1.4.RELEASE</version>
        </dependency>
    </dependencies>
</project>

我们配置了所有的 Maven jar 依赖，包括 Spring MVC、Spring Data JPA、JPA/Hibernate、Thymeleaf 和 Log4j。

步骤 2、使用 Java 配置配置 Service/DAO 层的 Bean

@Configuration
@EnableTransactionManagement
@EnableJpaRepositories(basePackages="com.sivalabs.demo")
@PropertySource(value = { "classpath:application.properties" })
public class AppConfig 
{
    @Autowired
    private Environment env;
    @Bean
    public static PropertySourcesPlaceholderConfigurer placeHolderConfigurer()
    {
        return new PropertySourcesPlaceholderConfigurer();
    }
    @Value("${init-db:false}")
    private String initDatabase;
    @Bean
    public PlatformTransactionManager transactionManager()
    {
        EntityManagerFactory factory = entityManagerFactory().getObject();
        return new JpaTransactionManager(factory);
    }
    @Bean
    public LocalContainerEntityManagerFactoryBean entityManagerFactory()
    {
        LocalContainerEntityManagerFactoryBean factory = new LocalContainerEntityManagerFactoryBean();
        HibernateJpaVendorAdapter vendorAdapter = new HibernateJpaVendorAdapter();
        vendorAdapter.setGenerateDdl(Boolean.TRUE);
        vendorAdapter.setShowSql(Boolean.TRUE);
        factory.setDataSource(dataSource());
        factory.setJpaVendorAdapter(vendorAdapter);
        factory.setPackagesToScan("com.sivalabs.demo");
        Properties jpaProperties = new Properties();
        jpaProperties.put("hibernate.hbm2ddl.auto", env.getProperty("hibernate.hbm2ddl.auto"));
        factory.setJpaProperties(jpaProperties);
        factory.afterPropertiesSet();
        factory.setLoadTimeWeaver(new InstrumentationLoadTimeWeaver());
        return factory;
    }
    @Bean
    public HibernateExceptionTranslator hibernateExceptionTranslator()
    {
        return new HibernateExceptionTranslator();
    }
    @Bean
    public DataSource dataSource()
    {
        BasicDataSource dataSource = new BasicDataSource();
        dataSource.setDriverClassName(env.getProperty("jdbc.driverClassName"));
        dataSource.setUrl(env.getProperty("jdbc.url"));
        dataSource.setUsername(env.getProperty("jdbc.username"));
        dataSource.setPassword(env.getProperty("jdbc.password"));
        return dataSource;
    }
    @Bean
    public DataSourceInitializer dataSourceInitializer(DataSource dataSource) 
    {
        DataSourceInitializer dataSourceInitializer = new DataSourceInitializer();
        dataSourceInitializer.setDataSource(dataSource);
        ResourceDatabasePopulator databasePopulator = new ResourceDatabasePopulator();
        databasePopulator.addScript(new ClassPathResource("data.sql"));
        dataSourceInitializer.setDatabasePopulator(databasePopulator);
        dataSourceInitializer.setEnabled(Boolean.parseBoolean(initDatabase));
        return dataSourceInitializer;
    }   
}

在 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 中完善配置，如下所示：

jdbc.driverClassName=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/test
jdbc.username=root
jdbc.password=admin
init-db=true
hibernate.dialect=org.hibernate.dialect.MySQLDialect
hibernate.show_sql=true
hibernate.hbm2ddl.auto=update

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

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

我们可以创建一个附带基本配置的 log4j.properties 文件，如下所示：

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

步骤 3、配置 Spring MVC Web 层的 Bean

我们必须配置 Thymleaf 的 ViewResolver、处理静态资源的 ResourceHandler 和处理 I18n 的 MessageSource 等。

@Configuration
@ComponentScan(basePackages = { "com.sivalabs.demo"}) 
@EnableWebMvc
public class WebMvcConfig extends WebMvcConfigurerAdapter
{
    @Bean
    public TemplateResolver templateResolver() {
        TemplateResolver templateResolver = new ServletContextTemplateResolver();
        templateResolver.setPrefix("/WEB-INF/views/");
        templateResolver.setSuffix(".html");
        templateResolver.setTemplateMode("HTML5");
        templateResolver.setCacheable(false);
        return templateResolver;
    }
    @Bean
    public SpringTemplateEngine templateEngine() {
        SpringTemplateEngine templateEngine = new SpringTemplateEngine();
        templateEngine.setTemplateResolver(templateResolver());
        return templateEngine;
    }
    @Bean
    public ThymeleafViewResolver viewResolver() {
        ThymeleafViewResolver thymeleafViewResolver = new ThymeleafViewResolver();
        thymeleafViewResolver.setTemplateEngine(templateEngine());
        thymeleafViewResolver.setCharacterEncoding("UTF-8");
        return thymeleafViewResolver;
    }
    @Override
    public void addResourceHandlers(ResourceHandlerRegistry registry)
    {
        registry.addResourceHandler("/resources/**").addResourceLocations("/resources/");
    }
    @Override
    public void configureDefaultServletHandling(DefaultServletHandlerConfigurer configurer)
    {
        configurer.enable();
    }
    @Bean(name = "messageSource")
    public MessageSource configureMessageSource()
    {
        ReloadableResourceBundleMessageSource messageSource = new ReloadableResourceBundleMessageSource();
        messageSource.setBasename("classpath:messages");
        messageSource.setCacheSeconds(5);
        messageSource.setDefaultEncoding("UTF-8");
        return messageSource;
    }
}

在 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。

public class SpringWebAppInitializer extends AbstractAnnotationConfigDispatcherServletInitializer
{
    @Override
    protected Class<?>[] getRootConfigClasses()
    {
        return new Class<?>[] { AppConfig.class};
    }
    @Override
    protected Class<?>[] getServletConfigClasses()
    {
        return new Class<?>[] { WebMvcConfig.class };
    }
    @Override
    protected String[] getServletMappings()
    {
        return new String[] { "/" };
    }
    @Override
    protected Filter[] getServletFilters() {
       return new Filter[]{ new OpenEntityManagerInViewFilter() };
    }
}

在 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 资源库。

@Entity
public class User
{
    @Id @GeneratedValue(strategy=GenerationType.AUTO)
    private Integer id;
    private String name;
    //setters and getters
}

public interface UserRepository extends JpaRepository<User, Integer>
{
}

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

创建一个 Spring MVC 控制器来处理 URL 为 /，并渲染一个用户列表。

@Controller
public class HomeController
{
    @Autowired UserRepository userRepo;
    @RequestMapping("/")
    public String home(Model model)
    {
        model.addAttribute("users", userRepo.findAll());
        return "index";
    }
}

步骤 7、创建一个 Thymeleaf 视图 /WEB-INF/views/index.html 来渲染用户列表

<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml"
      xmlns:th="http://www.thymeleaf.org">
<head>
<meta charset="utf-8"/>
<title>Home</title>
</head>
<body>
    <table>
        <thead>
            <tr>
                <th>Id</th>
                <th>Name</th>
            </tr>
        </thead>
        <tbody>
            <tr th:each="user : ${users}">
                <td th:text="${user.id}">Id</td>
                <td th:text="${user.name}">Name</td>
            </tr>
        </tbody>
    </table>
</body>
</html>

所有都配置好了，可以启动应用了。但在此之前，我们需要在 IDE 中下载并配置像 Tomcat、Jetty 或者 Wildfly 等服务器。

你可以下载 Tomcat 8 并配置在你喜欢的 IDE 中，之后运行应用并将浏览器指向 http://localhost:8080/springmvc-jpa-demo。你应该看到一个以表格形式展示的用户详细信息列表。

真激动，我们做到了！

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

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

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

另一个问题是，假设你想要开发另一个 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 它有没有提供一个简单灵活的方式来覆盖掉默认配置呢？

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

快速尝试 Spring Boot

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

与其夸夸而谈，不如来点案例实战。

步骤 1、创建一个基于 Maven 的 Spring Boot 应用

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

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 
                        http://maven.apache.org/maven-v4_0_0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.sivalabs</groupId>
    <artifactId>hello-springboot</artifactId>
    <packaging>jar</packaging>
    <version>1.0-SNAPSHOT</version>
    <name>hello-springboot</name>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>1.3.2.RELEASE</version>
    </parent>
    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <java.version>1.8</java.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-jpa</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-thymeleaf</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>
    </dependencies>
</project>

太神奇了，我们的 pom.xml 文件一下子变小了许多！

步骤 2、如下在 application.properties 中配置 DataSoure/JPA

spring.datasource.driver-class-name=com.mysql.jdbc.Driver
spring.datasource.url=jdbc:mysql://localhost:3306/test
spring.datasource.username=root
spring.datasource.password=admin
spring.datasource.initialize=true
spring.jpa.hibernate.ddl-auto=update
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，如下所示：

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

现在把 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 实现。

  2. 自动配置

    • 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。

  3. 支持嵌入式 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。

在下一篇文章中，我们将深入了解 Spring Boot，了解它的工作原理。

最后编辑于 ：
©著作权归作者所有,转载或内容合作请联系作者
  • 人面猴
    序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
    沈念sama阅读 157,924评论 4赞 360
  • 死咒
    序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
    沈念sama阅读 66,902评论 1赞 290
  • 救了他两次的神仙让他今天三更去死
    文/潘晓璐 我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
    开封第一讲书人阅读 107,716评论 0赞 239
  • 道士缉凶录：失踪的卖姜人
    文/不坏的土叔 我叫张陵，是天一观的道长。 经常有香客问我，道长，这世上最难降的妖魔是什么？ 我笑而不...
    开封第一讲书人阅读 43,783评论 0赞 203
  • 港岛之恋（遗憾婚礼）
    正文 为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
    茶点故事阅读 52,166评论 3赞 286
  • 恶毒庶女顶嫁案：这布局不是一般人想出来的
    文/花漫 我一把揭开白布。 她就那样静静地躺着，像睡着了一般。 火红的嫁衣衬着肌肤如雪。 梳的纹丝不乱的头发上，一...
    开封第一讲书人阅读 40,510评论 1赞 216
  • 城市分裂传说
    那天，我揣着相机与录音，去河边找鬼。 笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。 我是一名探鬼主播，决...
    沈念sama阅读 31,784评论 2赞 311
  • 双鸳鸯连环套：你想象不到人心有多黑
    文/苍兰香墨 我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
    开封第一讲书人阅读 30,476评论 0赞 196
  • 万荣杀人案实录
    序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
    沈念sama阅读 34,196评论 1赞 241
  • 护林员之死
    正文 独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋 以下内容为张勋视角 年9月15日...
    茶点故事阅读 30,459评论 2赞 243
  • 白月光启示录
    正文 我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。 大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
    茶点故事阅读 31,978评论 1赞 258
  • 活死人
    序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
    沈念sama阅读 28,321评论 2赞 252
  • 日本核电站爆炸内幕
    正文 年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
    茶点故事阅读 32,964评论 3赞 235
  • 男人毒药：我在死后第九天来索命
    文/蒙蒙 一、第九天 我趴在偏房一处隐蔽的房顶上张望。 院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
    开封第一讲书人阅读 26,046评论 0赞 8
  • 一桩弑父案，背后竟有这般阴谋
    文/苍兰香墨 我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。 一阵脚步声响...
    开封第一讲书人阅读 26,803评论 0赞 193
  • 情欲美人皮
    我被黑心中介骗来泰国打工， 没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。 一个月前我还...
    沈念sama阅读 35,530评论 2赞 271
  • 代替公主和亲
    正文 我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。 传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
    茶点故事阅读 35,420评论 2赞 265

推荐阅读更多精彩内容

  • Spring boot参考指南
    Spring Boot 参考指南 介绍 转载自:https://www.gitbook.com/book/qbgb...
    毛宇鹏阅读 46,352评论 6赞 344
  • Spring Cloud
    Spring Cloud为开发人员提供了快速构建分布式系统中一些常见模式的工具（例如配置管理，服务发现，断路器，智...
    卡卡罗2017阅读 134,097评论 18赞 139
  • Spring Boot 参考指南3（1.5.2.RELEASE）
    此篇翻译的是Spring Boot官方指南 Part III. 使用 Spring Boot (Using Spr...
    K天道酬勤阅读 6,594评论 0赞 21
  • 丝念[恋风原创诗第122首]
    丝念 [诗第122首] 文\恋风 月光下 蜘蛛 悄悄地织起一根根的丝念 独自刷屏了整个网 它 寂寞的守在网中间 看...
    恋风2016阅读 286评论 1赞 1
  • 寂寞
    寂寞是夜里的寒星 ， 你披上衣衫， 举首遥望 ， 天空蔓延出娇喘的黎明 。 寂寞是案前的孤灯 ， 你奋笔疾书 ， ...
    A欣欣向荣阅读 271评论 0赞 0