猫头鹰的深夜翻译：为什么要使用Spring Boot？

发表于 更新于 分类于

前言

spring是一个用于创建web和企业应用的一个很流行的框架。和别的只关注于一点的框架不同，Spring框架通过投资并组合项目提供了大量的功能来满足现代的业务需求。

Spring提供了许多灵活的方式来配置bean，如XML，注解和JavaConfig。随着功能数量的增加，复杂度也提升了，导致Spring应用的配置变得单调乏味且容易出错。

Spring团队开发出SpringBoot来解决配置复杂的问题。

但是在深入了解SpringBoot之前，我们会快速了解一下Spring框架，看一看SpringBoot究竟试图解决什么问题。

在这篇文章中将会涉及：

  • Spring框架概览
  • 使用SpringMVC和JPA(Hibernate)的Web应用
  • SpringBoot初体验

Spring框架概览

如果你是一个JAVA开发人员，那么你很可能听说过Spring框架，并且可能已经在项目中使用过它。Spring框架最初创建是为了依赖注入容器，但是它的功能远远不止这个。

Spring之所以流行是以下几个原因：

  • Spring的依赖注入功能支持编写可测试的代码
  • 既简单又强大的数据库事务管理功能
  • Spring简化了和其它框架的集成如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：企业集成模式的实现，通过使用轻量级的消息和声明适配器和别的企业应用集成。

还有很多其他解决各种各样当代应用开发需求的有趣的项目。更多详情可以参考Spring官网

在早期，Spring框架提供了基于XML的方式来配置bean。后来Spring引入了基于XML的DSL，注解和基于JavaConfig的方法来配置bean。

让我们快速了解一下这些不同的配置风格：

基于XML的配置

1
2
3
4
5
6
7
8
9
10
11
12
<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>

基于注解的配置

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
@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;
    }
    ...
    ...
}

基于JavaConfig的配置

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
@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;
    }
}

Wow…Spring为做同一件事情提供了那么多方法，我们甚至可以在同一个应用中将三者混合使用。

高灵活性既有好的一面也有坏的一面。初次使用Spring的人往往会困惑，不知道该使用哪种方法。目前来说，Spring团队推荐使用基于JavaConfig的方法来提供更高的灵活性。

但是没有一劳永逸的解决方法。每个人都应当基于应用的需求来选择方法。

好了，现在你看到了各种Spring配置的风格。
让我们看一下经典的SpringMVC + JPA/Hibernate的Web应用的配置。

一个只用Spring MVC 和JPA(Hibernate)的Web应用

在了解什么是SpringBoot以及它提供了什么功能之前，让我们看一个经典的Spring Web项目的配置，它的痛点是什么。然后我们会讨论SpringBoot是如何解决这些问题的。

第一步：配置Maven依赖

我们首先要做的就是在pom.xml文件中配置所有的依赖。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
<?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>

我们已经配置好了所需的jar依赖，包括Spring MVC, Spring Data JPA, JPA/Hibernate, Thymeleaf, 和 Log4j。

第二步：使用JavaConfig配置Service/Dao层

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
@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;
    }   
}

在AppCofig.java配置类中我们做了以下几件事情：

  • 使用@Configuration将其标记为Spring配置类
  • 使用@EnableTransactionManagement支持基于注解的事务管理
  • 使用@EnableJpaRepositories说明在寻找Spring Data JPA库
  • 使用@PropertySource和PropertySourcesPlaceholderConfigure配置PropertyPlaceHolder bean，它将会从application.properties文件中读取配置。
  • 定义DataSource，JPA EntityManagerFactory和JpaTransactionManager。
  • 配置DataSourceInitializer，从而在应用启动时执行data.sql脚本来初始化数据库。

我们需要在application.properties文件中配置属性占位符值：

1
2
3
4
5
6
7
8
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表中：

1
2
3
4
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文件：

1
2
3
4
5
6
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

第三步：配置Spring MVC Web层

我们还需要配置Thymeleaf的ViewResolver，i18n的ResourceHandler和MessageSource等。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
@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注解将其标记为配置类
  • 使用@EnbaleWebMvc支持基于注解的Spring MVC配置
  • 通过注册TemplateResolver, SpringTemplateEngine, ThymeleafViewResolver来配置ThymeleafViewResolver。
  • 注册了ResourceHandler bean来说明对路径为URI/resources/**的静态资源的访问将会定向至/resources/direcotry。
  • 配置MessageSource来从messages-{country-code}.properties加载i18n信息。

目前为止我们没有任何消息需要配置，所以只在src/main/resources文件夹中创建一个空的message.properties文件。

第四步：注册Spring MVC的前端控制器DispatcherServlet

在Servlet3.x之前我们需要在web.xml文件中注册Servlets/Filters。从Servlet3.x开始我们可以直接使用代码在ServletContainerInitializer中注册。

SpringMVC提供了一个很方便的类AbstractAnnotationConfigDispatcherServletInitializer来注册DispatcherServlet。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
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配置为RootConfigClassess，使其成为应用上下文并包含被所有其它上下文所共享的bean定义。
  • 将WebMvcConfig.class配置为ServletConfigClasses，它包含WebMvc bean的上下文。
  • 将/作为ServletMapping，意味着所有的请求都将被DispatcherServlet处理
  • 注册OpenEntityManagerInViewFilter作为Servlet过滤器，从而使我们可以在渲染视图的时候惰性加载JPA实体的集合。

第五步：创建JPA实体和JPA DAO

1
2
3
4
5
6
7
8
9
10
11
@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>
{
}

第六步：创建SpringMVC控制器

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

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
<!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。

你可以下载Tomcat8并在你最喜欢的IDE中配置它，然后运行应用并在浏览器中访问http://localhost:8080/springmvcjpa-demo，你应当会看见一个用户列表。

耶…我们做到了。

但是等等…只是为了展示一个从数据库中获取的用户列表，工作量未免太大了吧？
让我们客观的来看。所有的配置不只是为了这个应用场景，它还适用于所有其他的应用。
而且，再次强调，如果你想快速上手并运行，这里的工作量太大了。
还有一个问题是，假设你想开发另一个有相似技术栈的SpringMVC应用？那么你就需要复制粘贴这些配置并且修改。但是记住，当你需要重复的做一件事情的时候，你就应当寻找一个将其自动化的方法。

除了需要一遍遍的写相同的配置，你还发现以下问题了吗？

  • 你需要为特定的Spring版本寻找兼容的库并且配置这些库
  • 在95%的情况下我们用相同的方式配置DataSource, EntitymanagerFactory,TransactionManager，spring不能自动帮我完成这些事情吗？
  • 同样的，我们在大多数情况下都用相同的方式配置SpringMVC beans如ViewResolver, MessageSource 。

如果Spring能够自动帮我完成这些事情，那真的是美滋滋！

想想一下，如果Spring能够自动配置beans？如果你能够使用简单的自定义属性来自定义自动配置的过程？

比如，你希望要将DispatcherServlet映射的URL模式从/改变为/app/。你还希望不要将Thymeleaf视图放在/WEB-INF/views文件夹中而是/WEB-INF/templates/文件夹中。

所以基本上你希望Spring自动完成这些事情但是允许你用一种简单的方式重写默认的配置。

那么，你讲进入SpringBoot的世界，在那里你将梦想成真！

Spring Boot初体验

欢迎来到Spring Boot！Spring Boot正是你所寻找的东西、它会自动帮你完成配置并允许你重写默认的配置。

我将用一个例子来说明。让我们实现和之前相同的Web应用，不过这次我们使用Spring Boot。

第一步：创建一个基于Maven的Spring Boot项目

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
<?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>

Wow!我们的pom.xml文件突然变得好短！

第二步：在application.properties中配置Datasource/JPA属性

1
2
3
4
5
6
7
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

第三步：创建JPA实体和Repository

这里和Spring中创建的User.java, UserRepository.java和HomeController.java相同。

第四步：创建Thymeleaf视图展示用户列表

将springmvc-jpa-demo项目中的/WEB-INF/views/index.html复制到新项目的src/-main/resources/templates文件夹中。

第五步：创建SpringBoot入口类

创建一个带有main方法的Application.java类

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

现在运行Application.java并且在浏览器上访问http://localhost:8080/
你应该能够看到一个用户列表的表格。太酷了！
okok，我听到你在大喊“发生了什么？”
让我来解释发生了什么。

1.简单的依赖管理

  • 首先，可以看到我们使用了一些形如spring-boot-starter-*的依赖。记住我说过“95%的情况下我们会使用相同个配置”。所以当你添加了sping-boot-starter-web依赖时，它会自动拉取开发SpringMVC所常用的库如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库还会自动配置ThyemeleafViewResovler。
  • 我们没有定义任何的DataSource, EntityManagerFactory, TransactionManager等bean，但是它们被自动创建了。怎么做到的？如果我们有内存级数据库如H2或是HSQL，那么SpringBoot就会自动创建一个内存的EntityManager并且注册EntityManagerFactory,将TransactionsManagerbeans按照默认自动配置。但是我们在使用MySQL，因此我们需要明确提供MySQL连接的详情。我们已经在application.properties中配置了连接详细信息，Spring Boot会利用这些配置创建一个DataSource。

3.嵌入式Servlet容器的支持
最重要的是，我们使用@SpringApplication注解创建了一个简单的包含main函数的Java类。我们可以运行main方法启动应用并且通过http://localhost:8080/访问。

servlet容器是哪里来的？
spring-boot-starter-web自动拉取了spring-boot-starter-tomcat。当我们运行main方法时，它将tomcat作为内嵌容器启动，我们无需将应用部署到外部安装的tomcat服务器上。

顺便说一下，你注意到我们的打包方式是jar而不是war吗。太棒了！

好吧，那要是我想要用Jetty服务器而不是tomcat怎么办呢？很简单，你只需要在spring-boot-starter-web中exclude掉spring-boot-starter-tomcat然后includespring-boot-starter-jetty。

总结

这篇文章我们快速了解了一下各种Sring配置的风格，并且了解了配置Spring应用的复杂性。同时我们也快速了解了如何通过spring-boot创建一个简单的web应用。

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