原文： 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等社交网站集成。
• Sprign Integration：实现了企业集成模式，以便于使用轻量级消息和声明式适配器与其他企业应用集成。

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

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

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

基于XML的配置

"userService"class="com.sivalabs.myapp.service.UserService">
    "userDao"ref="userDao"/>

"userDao"class="com.sivalabs.myapp.dao.JdbcUserDao">
    "dataSource"ref="dataSource"/>

"dataSource"class="org.apache.commons.dbcp.BasicDataSource"destroy-method="close">
    "driverClassName"value="com.mysql.jdbc.Driver"/>
    "url"value="jdbc:mysql://localhost:3306/test"/>
    "username"value="root"/>
    "password"value="secret"/>

基于注解的配置

@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
    publicUserServiceuserService(UserDao dao){
        return new UserService(dao);
    }
    @Bean
    publicUserDaouserDao(DataSource dataSource){
        return new JdbcUserDao(dataSource);
    }
    @Bean
    publicDataSourcedataSource(){
        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"?>
<projectxmlns="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.0modelVersion>
    <groupId>com.sivalabsgroupId>
    <artifactId>springmvc-jpa-demoartifactId>
    <packaging>warpackaging>
    <version>1.0-SNAPSHOTversion>
    <name>springmvc-jpa-demoname>
    <properties>
        <project.build.sourceEncoding>UTF-8project.build.sourceEncoding>
        <maven.compiler.source>1.8maven.compiler.source>
        <maven.compiler.target>1.8maven.compiler.target>      
        <failOnMissingWebXml>falsefailOnMissingWebXml>
    properties>
    <dependencies>
        <dependency>
            <groupId>org.springframeworkgroupId>
            <artifactId>spring-webmvcartifactId>
            <version>4.2.4.RELEASEversion>
        dependency>
        <dependency>
            <groupId>org.springframework.datagroupId>
            <artifactId>spring-data-jpaartifactId>
            <version>1.9.2.RELEASEversion>
        dependency>
        <dependency>
            <groupId>org.slf4jgroupId>
            <artifactId>jcl-over-slf4jartifactId>
            <version>1.7.13version>
        dependency>
        <dependency>
            <groupId>org.slf4jgroupId>
            <artifactId>slf4j-apiartifactId>
            <version>1.7.13version>
        dependency>
        <dependency>
            <groupId>org.slf4jgroupId>
            <artifactId>slf4j-log4j12artifactId>
            <version>1.7.13version>
        dependency>
        <dependency>
            <groupId>log4jgroupId>
            <artifactId>log4jartifactId>
            <version>1.2.17version>
        dependency>
        <dependency>
            <groupId>com.h2databasegroupId>
            <artifactId>h2artifactId>
            <version>1.4.190version>
        dependency>
        <dependency>
            <groupId>commons-dbcpgroupId>
            <artifactId>commons-dbcpartifactId>
            <version>1.4version>
        dependency>
        <dependency>
            <groupId>mysqlgroupId>
            <artifactId>mysql-connector-javaartifactId>
            <version>5.1.38version>
        dependency>
        <dependency>
            <groupId>org.hibernategroupId>
            <artifactId>hibernate-entitymanagerartifactId>
            <version>4.3.11.Finalversion>
        dependency>
        <dependency>
            <groupId>javax.servletgroupId>
            <artifactId>javax.servlet-apiartifactId>
            <version>3.1.0version>
            <scope>providedscope>
        dependency>
        <dependency>
            <groupId>org.thymeleafgroupId>
            <artifactId>thymeleaf-spring4artifactId>
            <version>2.1.4.RELEASEversion>
        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 staticPropertySourcesPlaceholderConfigurerplaceHolderConfigurer()
    {
        return new PropertySourcesPlaceholderConfigurer();
    }
    @Value("${init-db:false}")
    private String initDatabase;
    @Bean
    publicPlatformTransactionManagertransactionManager()
    {
        EntityManagerFactory factory = entityManagerFactory().getObject();
        return new JpaTransactionManager(factory);
    }
    @Bean
    publicLocalContainerEntityManagerFactoryBeanentityManagerFactory()
    {
        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
    publicHibernateExceptionTranslatorhibernateExceptionTranslator()
    {
        return new HibernateExceptionTranslator();
    }
    @Bean
    publicDataSourcedataSource()
    {
        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
    publicDataSourceInitializerdataSourceInitializer(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 WebMvcConfigextends WebMvcConfigurerAdapter
{
    @Bean
    publicTemplateResolvertemplateResolver(){
        TemplateResolver templateResolver = new ServletContextTemplateResolver();
        templateResolver.setPrefix("/WEB-INF/views/");
        templateResolver.setSuffix(".html");
        templateResolver.setTemplateMode("HTML5");
        templateResolver.setCacheable(false);
        return templateResolver;
    }
    @Bean
    publicSpringTemplateEnginetemplateEngine(){
        SpringTemplateEngine templateEngine = new SpringTemplateEngine();
        templateEngine.setTemplateResolver(templateResolver());
        return templateEngine;
    }
    @Bean
    publicThymeleafViewResolverviewResolver(){
        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")
    publicMessageSourceconfigureMessageSource()
    {
        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 SpringWebAppInitializerextends 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 UserRepositoryextends JpaRepository<User,Integer>
{
}

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

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

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

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

<htmlxmlns="http://www.w3.org/1999/xhtml"
      xmlns:th="http://www.thymeleaf.org">
<head>
<metacharset="utf-8"/>
<title>Hometitle>
head>
<body>
    <table>
        <thead>
            <tr>
                <th>Idth>
                <th>Nameth>
            tr>
        thead>
        <tbody>
            <trth:each="user : ${users}">
                <tdth:text="${user.id}">Idtd>
                <tdth:text="${user.name}">Nametd>
            tr>
        tbody>
    table>
body>
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项目并配置如下依赖：

xml version="1.0"encoding="UTF-8"?>
<projectxmlns="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.0modelVersion>
    <groupId>com.sivalabsgroupId>
    <artifactId>hello-springbootartifactId>
    <packaging>jarpackaging>
    <version>1.0-SNAPSHOTversion>
    <name>hello-springbootname>
    <parent>
        <groupId>org.springframework.bootgroupId>
        <artifactId>spring-boot-starter-parentartifactId>
        <version>1.3.2.RELEASEversion>
    parent>
    <properties>
        <project.build.sourceEncoding>UTF-8project.build.sourceEncoding>
        <java.version>1.8java.version>
    properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starter-testartifactId>
        dependency>
        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starter-data-jpaartifactId>
        dependency>
        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starter-webartifactId>
        dependency>
        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starter-thymeleafartifactId>
        dependency>
        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-devtoolsartifactId>
        dependency>
        <dependency>
            <groupId>mysqlgroupId>
            <artifactId>mysql-connector-javaartifactId>
        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，了解它的工作原理。

from:http://www.tuicool.com/articles/NvqEnur