为何选择Spring Boot？

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

作者注：本文概述不同的Spring配置方式并帮助你理解复杂的Spring应用配置。

Spring是一个非常流行的、基于Java语言的开发框架，常用于开发web和企业应用。不同于其它在某一领域特别出名的框架，Spring通过一系列的项目为不同的业务需求提供了许多特性。

Spring提供诸如XML、Annotations和JavaConfig等方式来提高配置java beans的灵活性。随着Spring特性数量的不断增加，其复杂性也不断增加，这导致Spring应用的配置变得冗长且容易出错。

Spring团队创建SpringBoot项目来处理愈发复杂的配置问题。

在深入SpringBoot之前，我们先快速浏览一下Spring框架并理解SpringBoot试图去解决的问题

本文将涉及如下内容：

  • Spring框架概述
  • 使用Spring MVC和JPA(Hibernate)的web应用
  • SpringBoot快速体验

Spring框架概述

如果你是一名Java开发者，你很有可能听说并且在你自己的项目中使用过Spring框架。Spring框架主要用于提供 依赖注入容器，但功能绝不限于此。

Spring流行的原因：

  • Spring的依赖注入方法鼓励写出可测试 的代码
  • 强大而且易用的数据库事务管理能力
  • Spring易与诸如JPA/Hibernate ORM、Struts/JSF等web框架集成
  • 先进的Web MVC框架用于构建web应用

与Spring框架一起，还有许多Spring的项目用于构建满足不同业务需求的应用：

  • Spring Data：简单的关系型和NoSQL数据库访问框架
  • Spring Batch：批处理框架
  • Spring Security：安全框架
  • Spring Social：用于支持与Facebook、Twitter、LinkedIn、GitHub等社交网络站点的集成
  • Spring Integration：采用轻量级消息框架和公开适配接口，用于与其他企业应用集成的集成框架

此外，还有许多用于满足不同应用开发冯需求的项目，详见：http://spring.io/projects.

一开始的时候，Spring框架采用基于XML的方法进行java beans的配置。随后，Spring又引入了基于XML的DSLs、Annotations和JavaConfig。

让我们快速看一下这些方法的配置风格。

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

基于JavaConfig的配置方式

@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在bean配置一事上提供了如此多的方法，我们甚至可以在同一个应用中混用不同的方法。

如此灵活的配置方式是一把双刃剑。Spring框架的初学者会对使用哪种方式感到困惑。现在Spring团队建议使用基于JavaConfig的配置方式，因为这种方式提供了更高的灵活性。

但是，没有哪种方式能够适合所有类型的解决方案我们需要根据自己应用的需要选择合适的配置方式。

好了，现在你已经了解到多种Spring配置beean的方式。

接下来，让我们看一个典型的Spring MVC + JPA/Hibernate的web应用的配置。

使用Spring MVC和JPA(Hibernate)的web应用

在开始了解SpringBoot及其提供的特性之前，让我们先看一个典型的Spring web应用程序的配置，看一下配置的痛点所在，然后我们将讨论SpringBoot是如何解决这些问题的。

第一步：配置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>

通过配置，我们引入依赖了Spring MVC, Spring Data JPA, JPA/Hibernate, Thymeleaf和Log4j。

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

@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仓库
  • 使用@PropertySource注解和PropertySourcesPlaceholderConfigurer类读取配置文件application.properties
  • 定义DataSource、JPA EntityManagerFactory和JpaTransactionManager为java 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

第三步：配置Spring MVC Web层beans

配置Thymeleaf的ViewResolver，静态ResouceHandlers和用于国际化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和ThymeleafViewResolver，配置Thymeleaf的ViewResolver
  • 注册资源处理bean来标明来自URI/resources/**的请求会访问位于/resources/目录的资源
  • 配置MessageSource加载类路径上的messages-{country-code}.properties为i18n消息

现在我们没有配置任何消息，那就在src/main/resources文件夹下创建一个空的messages.properties文件。

第四步：注册Spring MVC 前端控制servlet-DispatcherServletf
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作为RootConfirationClasses，它是包含所有子上下文(DispatcherServlet)bean定义的父ApplicationContext。
  • 配置WebMvcConfig.class作为ServletConfigClasses，它是包括WebMvc bean定义的子ApplicationContext。
  • 配置ServletMapping为"/"，让DispatcherServlet处理所有请求。
  • 注册OpenEntityManagerInViewFilter过滤器，用于展开视图时懒加载JPA实体集合。

第五步：创建JPA实体和Spring Data JPA repository
创建JPA实体User.java和User实体对应的Spring Data JPA repository。

@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>
{
}

第六步：创建Spring MVC控制器
创建SpringMVC控制器来处理"/"URL请求并返回用户列表。

@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来展示用户列表

<!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>

我们准备好运行程序啦。但在此之前，我们需要下载和配置诸如Tomcat或者Jetty或者Wilddfly等容器。

你可以下载Tomcat 8并在你喜欢使用的IDE中配置并运行。然后打开浏览器访问http://localhost:8080/springmvcjpa-demo。你可以看到user的详细列表。
耶...我们做到了。

但是等等..仅仅从数据库获取数据并显示用户列表需要如此繁杂的工作吗？

让我们诚实而公正的看待这个问题。所有的配置工作不都是为了这个简单的用例。这些配置内容同样是应用程序配置的一部分。

但是，在迅速启动和运行之前仍有许多工作要做。

还有一个问题，假设你想使用相同的技术栈开发基于Spring MVC的另一个程序 。你复制黏贴配置并调整代码。但是记住一件事情：如果你必须重复做同样的事情，你应该去寻找一种自动化的方法。

除了重复写同样的配置，你还发现其他问题了吗？

好了，下面列出我发现的问题。

  • 你需要寻找依赖的特定版本的spring库文件并配置它们。
  • 我们配置DataSource、EntitymanagerFactory和TransactionManager等beans的工作，有95%的可能性是相同的，假如Spring可以自动配置的，那样会不会更酷？
  • 我们用相同的方法配置许多SpringMVC bean，如ViewResolver、MessageSource等。

如果Spring可以为我自动做这些工作，那该有多酷！！！

设想一下，如果spring能够自动配置bean会发生什么？如果你可以使用简单的配置化文件定制自动规则会发生什么？

例如，你想把url的模式从"/"变更为"/app/"，你想把"/WEB-INF/views"文件夹下的Thymeleaf
展示文件放到"/WEB-INF/templates/"文件夹下。

因此，你需要Spring即能够自动化配置又能够用简单的方式提供默认配置上的灵活的可配置性。

好了，你可以进入可以让你梦想成真的Spriing Boot的世界了。

Spring Boot快速尝鲜
欢迎来到Spring Boot，它正是你在寻找的技术。它可以为你自动化配置并且允许你覆盖默认配置。

我选择用具体的实例来介绍Spring Boot，而不是理论知识。

因此，让我们使用spring boot来实现与上面相同的应用。

第一步：创建基于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瞬间变小了很多。

第二步：在applicationroperties中配置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文件夹。

第三步：创建JPA实体和spring data JPA repository接口
创建与使用Spring MVC项目一样的fUserva/UserRepositoryva和HomeController.java。

第四步：创建展示用户列表的Thymeleaf视图
拷贝springmvc-jpa-demo应用中的/WEB-INF/views/index.html到新工程的src/main/resources/templates文件夹。

第五步：创建Spring Boot入口类
创建含有main方法的应用入口类，如下：

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

现在运行Application.java的main方法，打开浏览器访问http://localhost:8080/。你会看到用户列表，酷吧！！！

好了，我仿佛听见了你再说：发生了什么事情？？？我来介绍下发生了什么。

1.简单的依赖管理

  • 最显而易见的是我们使用了许多spring-boot-starter-*的依赖。还记得我说的95%的配置都是相同的吗？所以当你添加springboot-starter-web依赖时，你将会添加依赖到spring-webmvc、jackson-json、validation-api和tomcat等公共依赖库。
  • 我们添加了spring-boot-starter-data-jpa依赖。这将拉去所有spring-data-jpa依赖并且添加Hibernate库，因为应用使用Hibernate作为JPA实现。
    2.自动配置
  • 不仅能顾通过spring-boot-starer-web添加所有依赖库，而且诸如DispatcherServlet、ResourceHandlers和MessageSource等通用注册带的beans也能通过默认的方式自动配置。
  • 我们添加spring-boot-starter-Thymeleaf不仅添加所有Thymeleaf库依赖，而且自动配置ThymeleafViewResolver。
  • 我们没有定义诸如DataSource、EntityManagerFactory、TransactionManager等beans但是工程会自动创建它们。如何做到的？如果我们使用内存数据库驱动(如H2或者HSQL),通过默认配置SpringBoot会自动创建内存数据源并注册EntityManagerFactory、TransactionManager。但我们使用的是MySQL，因此我们需要明确提供MySQL连接的详细信息。我们在application.properties文件中配置MySQL连接信息，然后SpringBoot通过该配置文件创建DataSource。
    3.内置Servelet容器支持
    最重要和令人称奇的是我们通过@SpringAplication注解一个简单java类，然后运行该java类的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中排除spring-bootstarter-tomcat并包含spring-boot-starter-jetty。

只需要做这些，这是多么的奇妙！

我们设想你在想什么。你在想SpringBoot看上去如此酷并能自动为我做很多事情。但是我还是不太明白它背后是如何工作的，对吗？

我能理解。看魔术表演很有趣，但是软件开发则不然。别担心，在将来的文章中，我将逐步介绍每件事并详细介绍表象后面发生的具体事情。但是，我不打算在本文中将一切内容和盘托出，因为这会压垮你。

总结
本文中我们快速浏览了不同Spring配置风格并理解了配置Spring应用的复杂性。同时，我们通过一个简单的web应用快速体验了SprngBoot。

在下一篇文章中，我将深入SpringBoot内部，介绍它是如何工作的。

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

推荐阅读更多精彩内容