[译]为何选择Spring Boot

原文：https://dzone.com/articles/why-springboot

Spring是一个非常流行的基于Java的框架，用于构建web和企业应用。与其他那些只专注于某一个领域的框架不同，Spring框架通过它的一系列项目提供了丰富的处理现代业务所需要的特性。
Spring框架对Bean的配置提供了极大灵活性，可以通过XML，Annotations和JavaConfig等多种方式来配置。随着特性的增加，响应地复杂度也随之上升，配置一个Spring应用变得冗长繁琐并且容易出错。
Spring团队创造了Spring Boot来解决配置的复杂性。
但在深入Spring Boot之前，我们先快速地浏览一下Spring框架并了解Spring Boot到底是用于解决哪些问题。
本文中我们会提到：

  1. Spring框架概览
  2. 使用Spring MVC和JPA（Hibernate）的web应用
  3. Spring Boot浅尝

Spring框架概览

如果你是一个Java开发者那么很大几率你已经听说过关于Spring框架并且已经将它用于你的项目中了。Spring框架生来主要被用于作为一个依赖注入容器，但它的作用远不止这样。

一些Spring非常流行的原因：

  1. Spring的依赖注入方法鼓励编写可测试的代码
  2. 易于上手但强大的数据库事务管理能力
  3. Spring简化了与诸如JPA/Hibernate ORM这样的Java框架，和Struts/JSF/等其他的web框架集成
  4. 最先进的用于构建web应用的Web MVC框架的状态

伴随着Spring框架的还有许多其他帮助构建能满足处理现代业务需要的应用的姊妹项目：

  1. Spring Data:简化了从关系型和非关系型数据存储的数据访问
  2. Spring Batch: 提供了强大的批量处理框架
  3. Spring Security: 用于保护应用的健壮的安全框架
  4. Spring Social: 支持与Fackbook,Twitter,LinkedIn,GitHub等社交网站的集成
  5. Spring Integration: 一个企业集成模式的实现，使用轻量级消息传递和声明式适配器来促进与其他企业级应用的聚合

另外有许多有趣的，用于解决其他各种现代应用发展需要的项目，详情请前往http://spring.io/projects。

在最初的时候，Spring框架提供了基于XML的方法来配置Bean。后续Spring引入了基于XML的DSLs，注解和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的各种配置方式有了一个大概的了解。
让我们再快速地看一下一个典型的SpringMVC+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依赖包括有Spring MVC，Spring JPA，JPA/Hibernate, Thymeleaf和Log4j。

步骤2：用JavaConfig配置Service/DAO层Beann

@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配置类中我们做了这些事：

  1. 用@Configuration注解把它标记成为一个Spring配置类
  2. 用@EnableTransactionManagement启用基于注解的事务管理
  3. 配置@EnableJpaRepositories来表明Spring Data Jpa存放位置
    1.用@PropertySource注解和从application.properties文件加载属性的PropertySourcesPlaceholderConfigurer bean定义来配置PropertyPlaceHolder bean
  4. 从DataSource,JPA EnntityManagerFactory,JpaTransactionManager定义bean
  5. 配置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

我们需要配置Thymeleaf 视图解析器（ViewResolver），静态资源处理器（ResourceHandlers），消息源（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配置类中我们做了这些事：

  1. 使用@Configuration注解把它标记成一个Spring配置类
  2. 使用@EnableWebMvc启用基于注解的Spring MVC配置
  3. 通过注册TemplateResolver，SpringTemplateEngine，ThymeleafViewResolver的bean来配置Thymeleaf视图解析器
  4. 注册资源处理器bean来声明对URI/resources/**的静态资源的请求会被定位到resources目录下
  5. 配置MessageSource bean来从classpath下的资源绑定messages-{country-code}.properties中加载i18n消息

目前我们还没有需要配置的消息，所以在src/main/resources下创建一个空的message.properties.

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

在Servlet 3.x规范之前我们不得不在web.xml中注册Servlets/Filters。在Servlet 3.x规范发布后我们可以使用ServletContainerInitializer来编程式地注册Servlets/Filters。
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配置类中我们做了这些事：

  1. 把AppConfig.class配置成了RootConfirationClasses，会成为父应用上下文( parent ApplicationContext)，包含的bean定义会被所有的子（DispatcherServlet）上下文共享
  2. 配置WebMvcConfig.class作为ServletConfigClasses，包含了WebMvc bean定义的子应用上下文（childApplicationContext）
  3. 把ServletMapping配置为"/"，表示所有的请求都会经过DispatcherServlet处理
  4. 注册了OpenEntityManagerInviewFilter作为一个Servlet过滤器从而可以我们可以在呈现视图时延迟加载JPA实体延迟集合

步骤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：创建一个SpringMVC控制器（Controller）

创建一个SpringMVC控制器来处理URL "/"并呈现一个user的列表。

@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来呈现User列表

<!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或Wildfyl等等的服务器。
你可以下载Tomcat8并配置在你最喜欢的IDE中，运行这个应用然后指定浏览器到http://localhost:8080/springmvcjpa-demo，你将会看到user的详情列表在一个表格中。
很好，我们完成了。
但是...等一下，这是不是太麻烦了，我们要做的仅仅是展示一列从数据库中获取的用户信息而已？
平心而论，所有这些配置并不只是为了这一个个例，这些配置也是其他应用的基础。
但是再强调一下，如果你想要快速的开始和启动，要做的工作实在是太多了。
它的另一个问题是，如果你想要用相似的技术栈开发另一个SpringMVC项目呢？
是的，你会复制粘贴这些配置再稍微修改它，对吧？但请记得：如果你不得不反反复复地做同一件事，那就应该将它变成自动化的。
除了一遍又一遍地写相同的配置之外，你还发现其他问题了吗？
在此罗列一下我发现的问题：

  1. 你需要找到所有的能兼容特定Spring版本的类库并配置他们。
  2. 我们配置DataSource, EntitymanagerFactory,TransactionManager的bean的时间中95%的时间是在做相同的事。如果Spring能为我们自动完成那就太棒了。
  3. 大多数情况下我们配置的ViewResolver, MessageSource等SpringMVC bean是差不多的

假象一下，如果Spring可以自动配置bean会怎么样？如果你可以通过简单的可定制属性来定制自动配置又是什么样？
例如，你想将DispatcherServlet url-pattern映射到"/app/"而不是"/",或是想将Thymeleaf视图放在"/WEB-INF/templates/"下而不是"/WEB-INF/views"下。
所以简单来讲你希望Spring能自动执行配置但是提供能以一种简单方式来覆盖默认配置的灵活性吗？
接下来你将要进入Spring Boot的世界，让你美梦成真的地方！！！

浅尝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中配置如下Datasource/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 存储库接口

创建和spring-jpa-demo应用中一样的User.java，UserRepository.java和HomeController.java。

步骤4：创建Thymeleaf视图来展示User列表

拷贝上一个项目的/WEB-INF/views/index.html到新项目的src/main/resources/templates目录下。

步骤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/。
你将会看到user的列表在一张表格格式里，cool！
我来讲解一下发生了什么：

  1. 简单的依赖管理
    · 首先发现的是我们使用了一些命名像spring-boot-starter-*的依赖。记得我说过“95%的情况下我使用的是相同的配置”，所以当你添加spring-boot-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等。
    · 我们还添加了spring-boot-starter-Thymeleaf，它不仅添加了Thymeleaf的依赖，还自动配置了ThymeleafViewResolver bean。
    · 我们没有定义任何DataSource, EntityManagerFactory, TransactionManager等bean，但他们都自动被创建了。怎么回事？如果我们有任何内存数据库如H2或者HSQL在我们的classpath下，那么SpringBoot会自动创建一个内存数据源，然后以合理的默认值自动注册EntityManagerFactory, TransactionManager bean。但是我们正在使用MySQL，所以我们需要明确地提供MySQL连接的详细信息。我们已经在application.properties文件中配置了那些MySQL连接信息，并且Spring Boot用这些属性创建了一个数据源。
  3. 内嵌的Servlet容器支持
    最重要也最令人惊讶的东西是我们已经创建了一个简单的带有神奇注解@SpringApplication的Java类，并且拥有一个main方法，通过运行这个main方法我们可以启动并在http://localhost:8080/进入这个应用。
    servlet容器是从哪来的？
    我们已经添加了spring-boot-starter-web，它自动拉取了spring-boot-starter-tomcat并且当我们运行main()方法时它将tomcat作为一个内嵌容器启动，所以我们不需要部署我们的应用在任何外部安装的tomcat服务器上。
    顺便问一下你有注意到我们的pom.xml中的packing type是jar而不是war吗？真棒！
    好了，但是如果我想要使用Jetty而不是tomcat呢？
    很简单，从spring-boot-starter-web排除掉spring-boot-starter-tomcat，再引入spring-boot-starter-jetty。
    就这么简单。
    但是，这看起来很神奇！
    我可以想象到你在想什么。你大概在想：Spring Boot真酷而且它能为我自动地做这么多事，但是我还没有完全理解它是如何在幕后做了这么多实际工作的。是吗？
    我能理解。看一场魔术表演通常都是有趣的，但在软件开发中并不是这样。不要着急，我们将在将来的文章中逐一研究这些事情，并详细解释幕后发生了什么。但我不想在这篇文章中立刻把一切都抛给你，这会使你感到不知所措。

总结

在这篇文章中我们已经对各种Spring配置方式有了一个快速的概览并理解了配置Spring应用的复杂性。此外，我们还通过创建一个简单的web应用对Spring Boot进行了一次速览。
在下一篇文章中我们会深入到Spring Boot并理解它是如何工作的。

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