1. springBoot从hello world开始

1. 创建一个hello world工程

1.1 导入spring boot相关的依赖

<parent>
	<groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-starter-parent</artifactId>
	<version>1.5.9.RELEASE</version>
</parent>
<dependencies>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>
</dependencies>

1.2 配置简化部署插件

<build>
<plugins>
    <!-- 插件的作用：可以将应用打包成一个可执行的jar包 -->
    <plugin>
	<groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-maven-plugin</artifactId>
    </plugin>
</plugins>
</build>

该插件的作用是：将这个应用打成jar包，直接使用java -jar的命令进行执行；

完整的pom配置如下：

<?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/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.bjc</groupId>
    <artifactId>springBoot01-hello</artifactId>
    <version>1.0-SNAPSHOT</version>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>1.5.9.RELEASE</version>
    </parent>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <!-- 插件的作用：可以将应用打包成一个可执行的jar包 -->
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

1.3 启动类

package com.bjc;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

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

1.4 controller类

package com.bjc.controller;

import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class Hello {
	@RequestMapping("/hello")
	public String hello(){
		return "hello";
	}
}

2. Hello World探究

2.1 POM文件

        在pom中有一个starter-parent的配置，该配置是boot项目的父启动器，进入该启动器，可以知道他的父项目是

<parent>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-dependencies</artifactId>
  <version>1.5.9.RELEASE</version>
  <relativePath>../../spring-boot-dependencies</relativePath>
</parent>

由该父项目来真正管理Spring Boot应用里面的所有依赖版本；该父项目可以称之为Spring Boot的版本的仲裁中心，以后我们导入依赖，默认是不需要写版本的。

2.2 启动器

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>

        Spring Boot将所有的功能场景都抽取出来，做成一个个的starters（启动器），只需要在项目里面引入这些starter相关场景的所有依赖都会导入进来。要用什么功能就导入什么场景的启动器。

        启动器一般是spring-boot-starter开头以-XX结尾的，该配置的作用是帮助我们导入web模块正常运行所依赖的组件。

2.3 启动类

        启动类也就是主程序入口，该类通过注解@SpringBootApplication 来标注一个主程序类，说明这是一个Spring Boot应用。Spring Boot应用标注在某个类上说明这个类是SpringBoot的主配置类，SpringBoot就应该运行这个类的main方法来启动SpringBoot应用

3. 简介

        Spring 诞生时是 Java 企业版（Java Enterprise Edition，JEE，也称 J2EE）的轻量级代替品。无需开发重量级的 Enterprise JavaBean（EJB），Spring 为企业级Java 开发提供了一种相对简单的方法，通过依赖注入和面向切面编程，用简单的Java 对象（Plain Old Java Object，POJO）实现了 EJB 的功能。
        虽然 Spring 的组件代码是轻量级的，但它的配置却是重量级的。一开始，Spring 用 XML 配置，而且是很多 XML 配置。Spring 2.5 引入了基于注解的组件扫描，这消除了大量针对应用程序自身组件的显式 XML 配置。Spring 3.0 引入了基于 Java 的配置，这是一种类型安全的可重构配置方式，可以代替 XML。所有这些配置都代表了开发时的损耗。因为在思考 Spring 特性配置和解决业务问题之间需要进行思维切换，所以写配置挤占了写应用程序逻辑的时间。和所有框架一样，Spring 实用，但与此同时它要求的回报也不少。
        除此之外，项目的依赖管理也是件吃力不讨好的事情。决定项目里要用哪些库就已经够让人头痛的了，你还要知道这些库的哪个版本和其他库不会有冲突，这难题实在太棘手。并且，依赖管理也是一种损耗，添加依赖不是写应用程序代码。一旦选错了依赖的版本，随之而来的不兼容问题毫无疑问会是生产力杀手。
Spring Boot 让这一切成为了过去。
        Spring Boot 是 Spring 社区较新的一个项目。该项目的目的是帮助开发者更容易的创建基于 Spring 的应用程序和服务，让更多人的人更快的对 Spring 进行入门体验，为 Spring 生态系统提供了一种固定的、约定优于配置风格的框架。

4. SpringBoot特性

1）为基于 Spring 的开发提供更快的入门体验
2）开箱即用，没有代码生成，也无需 XML 配置。同时也可以修改默认值来满足特定的需求。
3）提供了一些大型项目中常见的非功能性特性，如嵌入式服务器、安全、指标，健康检测、外部配置等。
4）Spring Boot 并不是不对 Spring 功能上的增强，而是提供了一种快速使用 Spring 的方式。

5. 启动依赖

boot工程区别于我们之前是SSM工程，它需要一个启动依赖，配置如下：

<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
<version>1.4.0.RELEASE</version>
  </parent>  
  <dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
  </dependencies>

spring-boot-starter-parent：就是父依赖，我们的boot项目必须继承自这个父依赖才能使用启动器。

启动器：启动器就是可以让使用者可以快速添加依赖的工程

web项目启动器：spring-boot-starter-web

如图，添加好启动依赖之后，工程中自动添加了以下这么多的jar包

6. 引导类

        boot项目不需要web容器（tomcat），是因为其内置了web容器的，但是，既然没有容器，我们需要有入口来运行我们的程序，在boot中是通过引导类（启动类）来完成的，该类是整个应用的一个入口。

        该类用注解@SpringBootApplication来标识，main函数就是应用的入口。在main函数中通过执行静态类SpringApplication的run方法来启动应用程序，例如：

package com.bjc.boot.demo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class Application {

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

}

注意：@SpringBootApplication其实就是以下三个注解的总和
1）@Configuration： 用于定义一个配置类
2）@EnableAutoConfiguration ：Spring Boot会自动根据你jar包的依赖来自动配置项目。该配置很重要，会让工程的所有配置都按照默认配置来运行，这样我们就可以更多的关注业务代码本身了，当然，如果默认配置不能满足我们的需求的时候，我们可以通过属性文件来修改配置。
3）@ComponentScan： 告诉Spring 哪个packages 的用注解标识的类 会被spring自动扫描并且装入bean容器。所以，引导内一般位于根包下，这样可以扫描更多的类。
在引导类中，我们还可以配置一些javabean配置对象。

7. 核心注解介绍

7.1 @SpringBootApplication

标记该类是 SpringBoot 的启动类。

打开该注解的定义文件

package org.springframework.boot.autoconfigure;

import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Inherited;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

import org.springframework.boot.SpringBootConfiguration;
import org.springframework.boot.context.TypeExcludeFilter;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.ComponentScan.Filter;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.FilterType;
import org.springframework.core.annotation.AliasFor;

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@SpringBootConfiguration
@EnableAutoConfiguration
@ComponentScan(excludeFilters = {
		@Filter(type = FilterType.CUSTOM, classes = TypeExcludeFilter.class),
		@Filter(type = FilterType.CUSTOM, classes = AutoConfigurationExcludeFilter.class) })
public @interface SpringBootApplication {

	@AliasFor(annotation = EnableAutoConfiguration.class, attribute = "exclude")
	Class<?>[] exclude() default {};

	@AliasFor(annotation = EnableAutoConfiguration.class, attribute = "excludeName")
	String[] excludeName() default {};

	@AliasFor(annotation = ComponentScan.class, attribute = "basePackages")
	String[] scanBasePackages() default {};

	@AliasFor(annotation = ComponentScan.class, attribute = "basePackageClasses")
	Class<?>[] scanBasePackageClasses() default {};

}

如上，可以看到@SpringBootApplication上又有很多注解，其中我们需要关注的注解有以下几个

7.1.1 @SpringBootConfiguration

         该注解可以通过 bean 对象来获取配置信息

查看其定义：

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Configuration
public @interface SpringBootConfiguration {

}

可以知道，该注解是一个空注解，但是，它又被@Configuration注解所标记，也就是说 @SpringBootConfiguration具备了@Configuration的能力的，而@Configuration注解可以通过对 bean 对象的操作替代 spring 中 xml 文件，所以@SpringBootConfiguration注解就可以了通过bean对象来获取配置信息了。

7.1.2 @EnableAutoConfiguration

打开该注解，发现，该注解被@AutoConfigurationPackage所标记，@AutoConfigurationPackage注解的作用就是根据我们导入的jar包来创建项目的启动环境，也就是完成一些初始化环境的配置。

7.1.3 @ComponentScan

该注解是用来完成 spring 的组件扫描。 替代之前在 xml 文件中配置组件扫描的配置<context:component-scan pacage=”....”>

这三个注解，构成了boot项目在启动时的一些核心配置支持，正是因为这些注解，所以我们在spring中的一些xml配置可以不需要再写了。