spring boot - hello world

关键字

感性认识、搭建步骤

1. 上期回顾

上一章我们对spring boot有了一个初步认识，了解了它产生的原因以及所能解决的问题。但是对于初学者过于理论化，今天按照国际惯例，我们从无到有的搭建一个hello world项目，以对spring boot有一个更感性的理解。

在此之前回顾一下上期内容：spring boot的目标：简化spring项目从搭建到部署监控整个流程中的重要环节。

上期关键字：简化。

今天我们就用一个实例，以点到为止的方式了解spring boot项目的搭建步骤、以及简化过程。

2. 目标

• 搭建一个简单的spring boot项目
• 对spring boot有一个感性认识
• 验证是否简化了项目流程
• 简单了解spring boot的启动流程

3. 前提条件

• spring boot版本：1.5.4.RELEASE
• jdk版本： 7及以上版本
• spring framework：4.3.9及以上版本
• 内置tomcat版本：8

3. 搭建过程

下面将创建一个名为“demo-springboot”的项目，开发工具使用idea，构建工具使用maven(如果没有使用过构建工具的，推荐学习后使用，因为简化依赖主要是使用构建工具实现的）

3.1 项目结构

spring boot项目与普通项目无任何区别，理论上项目结构不需要特殊要求，但为了后续简化配置，推荐一个常用的项目结构。

在intellj idea中创建maven项目如下:

demo-springboot
 +- src
     +- main
         +- java
         |   +- com
         |       +- blog
         |           +- demo
         |               +- springboot
         |                   +- App.java
         |                   |
         |                   +- controller
         |                   |   +- HelloController.java
         |                   |
         |                    +- service
         +- resources
           +- application.yml

• 不要使用"default"包

 所谓的"default"包，即没有包，代码直接位于classPath下，如：src/main/HelloController.java。推荐创建自己的项目包：如 com.blog.demo.springboot

原因：spring boot是通过自动扫描(@ComponentScan)加载bean。如果有自定义的包，则scan是从mainClass所在的包路径下开始扫描，否则是从classPath下扫描，会把很多第三方jar中不需要的class也加载并生成bean，导致配置混乱，产生不可预知的问题。

• MainClass位于root包下

main class是整个项目的入口，通常情况也是是自动扫描的初始路径。自动扫描会从main class所在包开始扫描，并扫描当前包以及所有子包。因此可以把当前项目所有bean加载到项目中。否则，如果当前项目中有bean 类位于main class 包的父包中，则无法被自动扫描到，只能通过其它方式（如：配置扫描路径、@Import)加载，使项目配置变的复杂。

3.2 依赖

在项目中创建pom.xml文件，内容如下：

<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/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <name>demo-springboot</name>

  <!--当前项目配置-->
  <groupId>com.flypigs</groupId>
  <artifactId>demo-springboot</artifactId>
  <version>1.0-SNAPSHOT</version>

  <!--打包类型：jar/war-->
  <packaging>jar</packaging>

  <!--属性配置：可以用于覆盖默认属性，如默认jar的版本号-->
  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  </properties>

  <!--引入spring boot：提供了Maven默认配置，以及dependencyManagement-->
  <parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>1.5.3.RELEASE</version>
  </parent>

  <!--依赖-->
  <dependencies>
    <!--引用spring web:得益于spring-boot-starter-parent中的parent中的dependencyManagement，此处可以不指定版本号-->
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
  </dependencies>

  <build>
    <plugins>
      <!--构建fatJar的插件：jar中jar并不是java标准，是spring自己实现的特性，因此需要引用spring的特殊插件来实现jar包构建-->
      <plugin>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-maven-plugin</artifactId>
      </plugin>
    </plugins>
  </build>
</project>

上面pom.xml主要做了以下几点：

• 继承spring-boot-starter-parent

提供很多默认配置，如：指定依赖的版本号。 spring-boot-starter-web依赖并未指定版本号，但可以正确加载，是因为parent 中配置此依赖的版本号。后续如果升级，只需升级parent 即可。

• 引入spring-boot-starter-web

parent依赖中只配置了默认配置，并未引用任何依赖，因此如果项目需要引入相关依赖，必须在<dependency>中配置。

此处我们需要创建web项目，因此只需要加入spring-boot-starter-web依赖即可。它加载了spring MVC需要的所有jar及内置了tomcat的jar。

• 设置spring-boot-maven-plugin

如果仅仅在ide中运行，此插件是非必需的。但如果需要打成fatJar就必须配置。

spring boot最终是打包成一个可运行的jar，而标准的jar中是不能再打入其它jar(jar中jar)，因此spring 自己实现了这个功能，它不是一个标准，所以需要spring自己提供打包插件。

3.3 编码和配置

 创建App.java,代码如下：

package com.blog.demo.springboot;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;

/**
 * Hello world!
 *
 */
@Configuration
@ComponentScan //扫描包，并根据相应注解创建bean
@EnableAutoConfiguration //启动自动配置
//@SpringBootApplication //（为了简单方便，当前注解可以替换上面三个注解）
public class App 
{
    public static void main( String[] args )
    {
        //项目启动入口：
        // Ａ：启动tomcat等web容器（如果是web项目）
        // Ｂ：初始化并启动spring（根据当前类配置的注解），进入spring生命周期
        SpringApplication.run(App.class,args);
    }
}

创建HelloController.java

package com.blog.demo.springboot.controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

import java.util.*;

/**
 * Created by yangsp1 on 17/7/27.
 */
@Controller
@RequestMapping("/hello")
public class HelloController {

    @RequestMapping("/user/{userName}")
    @ResponseBody
    public Map<String,Object> sayHello(@PathVariable(name = "userName") String userName){
        Map<String,Object> result = new HashMap();
        String hello = userName == null ? "i don't know who you are" : userName + ", hello , i am baymax";
        result.put("msg",hello);
        result.put("status","ok");
        return result;
    }
}

创建application.yml配置文件如下：

#应用名称(非必须，推荐每个项目都起一个唯一的名称，方便后面管理及配置使用)
spring:
  application:
    name: springBootDemo

#web容器端口(默认是8080，此处手动覆盖默认值)
server:
  port: 9090

3.4 容器

参见3.2节中的spring-boot-starter-web依赖。它可以引入一个内置的tomcat 包。

3.5 监控

略，为了不让hello world过于复杂，此处略过，后续涉及

3.5 启动并验收

ide中运行App.java

浏览器中运行如下链接：http://local.dooioo.net:9090/hello/user/laoyang

结果如下：

是不是很简单，只配置了一个 pom.xml文件，编写了一个main class和一个HelloController并加入了几个注解，最后设置了一个yml配置文件，就成功搭建成一个完整的web项目。

4. 过程分析

使用spring boot真的太简单方便了，可是开心之余你是否有一点点不安。它太简单了，可是为什么这么简单？它到底做了什么？如果出错如何解决？想要集成新功能该如何下手？

有时一头雾水会使因简单带来的优势微不足道。所有简单的使用都是建立在熟悉、理解的基础上。如果只是懵懵懂懂的使用，最多也是一个熟练使用ctrl+c ctrl+v的代码搬运工。如果完全理解了spring boot的原理和执行过程，则会越用越简单。下面我就简单的分析一下项目整个执行过程。

4.1 依赖

一个简单的配置加载所有依赖包：创建pom.xml，配置spring-boot-starter-web依赖，利用构建工具maven ,把web项目所需要的jar包全部加载到项目中。

4.2 编码

• 创建一个启动类：App main class，并配置三个注解。
• 创建一个业务类：HellowController，并配置Spring MVC注解

4.3 配置

• bean注解配置（编码阶段）
• 组件配置（如：yml中tomcat端口配置）
• 自动配置（@EnableAutoConfig自动配置了spring MVC）

4.4 执行

执行流程有很多细节和步骤，最核心的主要为以下两大步骤：

• 加载spring框架

• 启动tomcat容器

普通的web项目部署在tomcat容器中，因此首先启动tomcat，再触发spring 框架的加载。而spring boot项目中，tomcat内置在spring 框架中，因此首先启动spring框加，然后启动tomcat，最后所有web请求转由tomcat接管。

spring 框架加载过程，大部分操作与普通的spring项目启动过程没有本质区别，但spring boot中的自动配置功能是spring boot项目中的一大集成利器，它极大的简化了各种第三方组件与spring框架的无缝集成。

spring 框架加载过程中，执行invokeBeanFactoryPostProcessors时，会解析@EnableAutoConfiguration，从此处打开所有组件自动解析的大门，如：springMVC组件的自动配置。具体细节后续涉及。

5.  接下来

到目前为止，我们知道了spring boot为何而生，也对其实践有了一个感性认识。下面，我们将详情了解spring boot有哪些特性