SpringBoot 简单开发流程（详解）

一，简介

    Spring Boot是由Pivotal团队提供的全新框架，其设计目的是用来简化新Spring应用的初始搭建以及开发过程。该框架使用了特定的方式来进行配置，从而使开发人员不再需要定义样板化的配置。通过这种方式，Spring Boot致力于在蓬勃发展的快速应用开发领域(rapid application development)成为领导者。

    Spring Boot提供了一种新的编程范式，能在最小的阻力下开发Spring应用程序。有了它， 开发人员可以更加敏捷地开发Spring应用程序，专注于应用程序的功能，不用在Spring的配置上多花功 夫，甚至完全不用配置。实际上，Spring Boot的一项重要工作就是让Spring配置不再成为开发路上的绊脚石。

    spring boot并不是一个全新的框架，它不是spring解决方案的一个替代品，而是spring的一个封装。所以，以前可以用spring做的事情，现在用spring boot都可以做。

    现在流行微服务与分布式系统，Spring boot就是一个非常好的微服务开发框架，可以使用它快速的搭建起一个系统。同时，你也可以使用spring Cloud（Spring Cloud是一个基于Spring Boot实现的云应用开发工具）来搭建一个分布式的网站。

二，SpringBoot的优点

   ** 使编码变得简单**

** **SpringBoot采用Java config的方式，对Spring进行配置，并且提供了大量的注解，极大地提高了工作效率。

    **使配置变得简单**

** **spring boot提供许多默认配置，当然也提供自定义配置。但是所有spring boot的项目都只有一个配置文件：application.properties/application.yml。用了spring boot，再也不用担心配置出错找不到问题所在了。

     **使部署变得简单**

** **spring boot内置了三种servlet容器：tomcat，jetty，undertow

**名称 **

*Servlet***版本 **

Java****版本

**Tomcat 8 **

3.1

Java 7+

**Tomcat 7 **

3

Java 6+

**Jetty 9 **

3.1

Java 7+

**Jetty 8 **

3

Java 6+

**Undertow 1.1 **

3.1

Java 7+

            所以，只需要一个Java的运行环境就可以运行SpringBoot的项目了。SpringBoot的项目可以打成一个jar包，然后通过java -jar xxx.jar来运行。（SpringBoot项目的入口是一个main方法，运行该方法即可）

            也可以将Spring Boot应用部署到任何兼容Servlet 3.0+的容器。

** 使监控变得简单**

** **SpringBoot提供了actuator包，可以使用它来对应用进行监控。

三，微服务架构

    微服务是一种架构风格，一个大型复杂软件应用由一个或多个微服务组成。系统中的各个微服务可被独立部署，各个微服务之间是松耦合的。每个微服务仅关注于完成一件任务并很好地完成该任务。在所有情况下，每个任务代表着一个小的业务能力。

    例如要开发一个购票系统。就可以简单的拆分为用户管理微服务和售票系统微服务。两个服务都可以独立运行，都有自己的数据库，他们之间通过HTTP API 进行通信。

    而SpringBoot就是搭建微服务的一个很好的选择。

    微服务一般都是运行在分布式环境中的，这可不是简单的写一个SSM框架的小程序就可以解决的，其中需要用到很多技术，比如负载均衡，反向代理，服务治理，配置管理，消息总线等，SpringCloud提供了这些技术。并且，SpringCloud生态是基于spring boot的。

四，SpringBoot的创建，使用

    可以像使用其他任何标准Java库那样使用SpringBoot，只需简单地在classpath下包含正确的 spring-boot-*.jar 文件。 SpringBoot不需要集成任何特殊的工具， 所以可以使用任何IDE或文本编辑器；Spring Boot应用也没有什么特殊之处， 所以可以像任何其他Java程序那样运行和调试。

    尽管可以拷贝SpringBoot jars， 不过，通常推荐使用一个支持依赖管理的构建工具（比如Maven或Gradle）或者内嵌依赖管理工具的IDE，如Spring的官方IDE-STS。

项目创建

可以选择打包方式

             可以选择需要的依赖

    **完成项目创建后添加为Maven项目**

** **首先设置Maven的路径

             将项目创建为Maven管理项目

     **配置.pom文件添加起步依赖**

<dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-tomcat</artifactId>
            <scope>provided</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <!--MybatisSpring整合-->
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>2.0.0</version>
        </dependency>

        <!--测试-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-tomcat</artifactId>
        </dependency>
        <!-- Springboot 外部的Tomcat支持  没有这个，不能访问jsp页面-->
        <dependency>
            <groupId>org.apache.tomcat.embed</groupId>
            <artifactId>tomcat-embed-jasper</artifactId>
        </dependency>

        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>jstl</artifactId>
        </dependency>

        <!-- 数据库支持 -->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.4.4</version>
        </dependency>

        <!-- 数据库连接 -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <scope>runtime</scope>
            <version>8.0.13</version>
        </dependency>

        <!-- 1.日志 -->
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>1.2.17</version>
        </dependency>

        <!--热部署的支持-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
        </dependency>
    </dependencies>

** 项目基本创建完成**

项目的配置

   ** .yml文件的配置**

    包括项目端口设置，项目路径设置，视图解析器，数据库连接池的配置，mybatis的配置。

五，SpringBoot的启动和退出相关

启动

    SpringApplication类提供了一种从main()方法启动Spring应用的便捷方式。 在很多情况下， 只需委托给SpringApplication.run这个静态方法：

package com.eeerosss;

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

@SpringBootApplication
public class SpringbootStartApplication {

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

}

    通过在classpath下添加一个banner.txt或设置banner.location来指定相应的文件可以改变启动过程中打印的banner（即启动时正常日志前拼接出来的Spring部分）。 如果这个文件有特殊的编码， 可以使用banner.encoding设置它（默认为UTF-8） 。

名称

描述

${application.version}

MANIFEST.MF中声明的应用版本号， 例如1.0

${application.formattedversion}

MANIFEST.MF中声明的被格式化后的应用版本号（被括号包裹

且以v作为缀） ， 用于显示， 例如(v1.0)

${spring-boot.version}

正在使用的Spring Boot版本号， 例如1.5.0.BUILD-SNAPSHOT

${spring-boot.formatted-version}

正在使用的Spring Boot被格式化后的版本号（被括号包裹且以

v作为缀） , 用于显示， 例如(v1.5.0.BUILD-SNAPSHOT)

            在banner.txt配置

             展示出springboot的版本

退出

    每个SpringApplication在退出时为了确保ApplicationContext被优雅的关闭， 将会注册一个JVM的shutdown钩子。 所有标准的Spring生命周期回调（比如，DisposableBean接口或@PreDestroy注解）都能使用。

    如果beans想在应用结束时返回一个特定的退出码（exit code） ， 可以实现org.springframework.boot.ExitCodeGenerator接口

六，属性注入

    Spring Boot在程序中允许使用外部的配置文件获取配置信息， 这样就能够在不同的环境下使用相同的代码。 

    外部配置支持使用properties文件，YAML文件， 环境变量和命令行参数。

    使用@Value注解， 可以直接将属性值注入到beans中。

    **Spring Boot使用一个非常特别的PropertySource次序来允许对值进行合理的覆盖， 需要以下面的次序考虑属性：**

** **1. 命令行参数

            2. 来自于java:comp/env的JNDI属性 

            3. Java系统属性（System.getProperties()） 

            4. 操作系统环境变量 

            5. 只有在random.*里包含的属性会产生一个RandomValuePropertySource 

            6. 在打包的jar外的应用程序配置文件（application.properties， 包含YAML和profile变量） 

            7. 在打包的jar内的应用程序配置文件（application.properties， 包含YAML和profile变量） 

            8. 在@Configuration类上的@PropertySource注解 

            9. 默认属性（使用SpringApplication.setDefaultProperties指定）

** 简单案例**

#管理监控端口
management.server.port=9999
#设置端口
server.port=1234
info.app.name=springboot
info.app.description=springboot-start
info.app.version=1.0

name=zhangSan
my.secret=${random.value}
my.number=${random.int}
my.bignumber=${random.long}
my.number.less.then.ten=${random.int(10)}
my.number.in.range=${random.int[1024,2048]}

app.name=zhangSi
app.info=${app.name}'s info  

    对应实体类属性 

 /**
     * 名字
     */
    @Value("${name}")
    private String name;
    /**
     * 随机字符串
     */
    @Value("${my.secret}")
    private String secret;
    /**
     * 随机整数
     */
    @Value("${my.number}")
    private int number;
    /**
     * 随机长整数
     */
    @Value("${my.bignumber}")
    private  long bignumber;
    /**
     * 十以内随机整数
     */
    @Value("${my.number.less.then.ten}")
    private String numberLessThenTen;
    /**
     * 范围内整数
     */
    @Value("${my.number.in.range}")
    private int numIntRange;
    @Value("app.name")
    private String name2;
    @Value("${app.info}")
    private String info;

    可以像上述示例一样将application.properties文件打包到jar文件内， 用来提供一个合理的默认name属性值。 当运行在生产环境时， 可以在 jar外提供一个application.properties文件来覆盖name属性。

    对于一次性的测试， 还可以使用特定的命令行开关启动（比如， java -jar app.jar --name="Spring"）

    默认情况下， SpringApplication将任何可选的命令行参数（以'--'开头， 比如， --server.port=9000） 转化为property，并将其添加到Spring Environment中。

    命令行属性总是优先于其他属性源。

    如果不想将命令行属性添加到Environment里，则可以使用SpringApplication.setAddCommandLineProperties(false)来禁止它们。

    SpringApplication将从以下位置加载application.properties文件， 并把它们添加到Spring环境上下文中：

    当前目录下的/config子目录

    当前目录

    classpath下的/config包

    classpath根路径（项目root）

    这个列表是按优先级排序的（列表中位置高的将覆盖位置低的），同时也可以使用YAML文件替代properties文件。

    如果不希望使用默认的application.properties作为配置文件名，可以通过指定spring.config.name环境属性来切换其他的名称。 也可以使用spring.config.location环境属性来引用一个明确的路径（目录位置或文件路径列表以逗号分割） ：

java -jar myproject.jar --spring.config.name=myproject
java -jar myproject.jar --spring.config.location=classpath:/default.properties,classpath:/override.properties

    如果spring.config.location包含目录（相对于文件） ， 那它们应该以/结尾（在加载前， spring.config.name产生的名称将被追加到后面） 。不管spring.config.location是什么值，默认的搜索路径classpath:,classpath:/config,file:,file:config/总会被使用。

    以这种方式， 可以在application.properties中为应用设置默认值， 然后在运行的时候使用不同的文件覆盖它，同时保留默认配置。

    如果使用环境变量而不是系统配置，大多数操作系统不允许以点分割的key名称， 在这种情况下可以使用下划线代替（比如， 使用SPRING_CONFIG_NAME代替spring.config.name）。 如果应用运行在一个容器中，那么JNDI属性（java:comp/env）或servlet上下文初始化参数可以用来取代环境变量或系统属性， 当然也可以使用环境变量或系统属性。

    当application.properties里的值被使用时，它们会被存在的环境过滤， 所以能够引用先前定义的值（如系统属性）：

app.name=zhangSi
app.info=${app.name}'s info  

七，SpringBootProfile

    在项目开发的时候，生产环境和测试环境的一些配置可能会不一样，有时候一些功能也可能会不一样，所以可能会在上线的时候手工修改这些配置信息。但是Spring中提供了Profile功能。只需要在启动的时候添加一个虚拟机参数，激活环境所要用的Profile就可以了。

    除了application.properties文件， 特定配置属性也能通过Profile配置文件application-{profile}.properties来定义。 特定Profile属性跟标准application.properties相同的路径加载， 并且特定profile文件会覆盖默认的配置。
     创建一个bean，用来测试是不是从不同的配置文件中取的值（代码中使用了统一的属性注入注解，也可以使用Value逐一对每个属性进行注入）

    在项目的classpath中创建两个profile对应的配置文件：

    application-dev.properties：

profile.test.userName=zhangSan
profile.test.passWord=123456

    application-prod.properties：

profile.test.userName=liSi
profile.test.passWord=654321

    对应实体类

package com.eeerosss.profile;

import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;

/**
 * @author : Eeerosss
 * @create 2022/9/23 14:55
 */
@Component
@ConfigurationProperties("profile.test")
public class ProfileDomain {
    private String userName;
    private String passWord;

    public String getUserName() {
        return userName;
    }

    public void setUserName(String userName) {
        this.userName = userName;
    }

    public String getPassWord() {
        return passWord;
    }

    public void setPassWord(String passWord) {
        this.passWord = passWord;
    }
}

    在Eenironment variables中设置要调用的配置文件

    开发环境：spring.profiles.active=dev

    生产环境：spring.profiles.active=prod

    **有时候可能还会有这样的需求：生产环境或者开发环境我们所看到的功能是不同的，也需要我们根据配置项来激活不同的功能，这种情况下，先定义一个Service的接口：**

  public String getProfileDomain();

    **提供两种Profile的实现：**

** **运行环境

@Service
@Profile("dev")
public class ProfileDevServiceImpl implements ProfileService {
    @Override
    public String getProfileDomain() {
        StringBuffer buffer = new StringBuffer("我是运行环境，我吃:");
        buffer.append("米饭");
        return buffer.toString();
    }
}

            生产环境

@Service
@Profile("pro")
public class ProfileProServiceImpl implements ProfileService {
    @Override
    public String getProfileDomain() {
        StringBuffer buffer = new StringBuffer("我是生产环境，我吃:");
        buffer.append("肉");
        return buffer.toString();
    }
}

            编写控制器查看使用的环境

@RestController
public class IndexController {
    @Autowired
    ProfileService profileService;

 
    @RequestMapping("/serviceinfo")
    public  String serviceInfo(){
        return profileService.getProfileDomain();
    }
}

            编写启动类 

@SpringBootApplication
public class SpringbootProfileApplication implements CommandLineRunner {
    @Autowired
    ProfileService profileService;
    public static void main(String[] args) {
        SpringApplication.run(SpringbootProfileApplication.class, args);
    }

    @Override
    public void run(String... args) throws Exception {
        System.out.println(profileService.getProfileDomain());
    }
}

            运行结果 

八，YAML配置

    可以使用YAML文件代替properties文件作为项目配置。

    YAML是JSON的一个超集，也是一种方便的定义层次配置数据的格式。

    将SnakeYAML库放到classpath下，Spring Boot都会自动支持YAML作为properties的替换。

    如果你使用starter POMs，spring-boot-starter会自动提供SnakeYAML，这就意味着在绝大部分情况下YAML的支持都是默认提供的。

    对于较复杂的数据结构来说，YAML远远优于properties。

    在处理层级关系的时候，properties需要使用大量的路径来描述层级（或者属性），比如environments.dev.url和environments.dev.name。其次，对于较为复杂的结构，比如数组，写起来更为复杂。而对应的YAML格式文件就简单很多

    YAML使用冒号加缩进的方式代表层级（属性）关系，使用短横杠(-)代表数组元素。

   ** YAML中允许表示三种格式，分别是常量值，对象和数组：**

    和properties相同，使用#作为注释，YAML中只有行注释

   ** YAML文件基本格式要求： **

** ** YAML大小写敏感；

            使用缩进代表层级关系；

            缩进只能使用空格，不能使用TAB，不要求空格个数，只需要相同层级左对齐（一般2个或4个空格）

** 对象**

** **使用冒号代表，格式为key: value。冒号后面要加一个空格：

            可以使用缩进表示层级关系：![](https://img-blog.csdnimg.cn/6bf4edad5eef4f12b8965300201fc5fa.png) 

             YAML中还支持流式(flow)语法表示对象，比如上面例子可以写为：![](https://img-blog.csdnimg.cn/c397abcd68084ef19c26764e0d958e4e.png)

            较为复杂的对象格式，可以使用问号加一个空格代表一个复杂的key，配合一个冒号加一个空格代表一个value：![](https://img-blog.csdnimg.cn/733d615c7a5b4b9b8ce0e24e6949fd75.png) 

            意思即对象的属性是一个数组[complexkey1,complexkey2]，对应的值也是一个数组[complexvalue1,complexvalue2]

            使用一个短横线加一个空格代表一个数组项：

            也可以有这样的写法(可以简单理解为：[[Java,LOL]])： 

            一个相对复杂的例子：

            数组也可以使用流式(flow)的方式表示：

            YAML中提供了多种常量结构，包括：整数，浮点数，字符串，NULL，日期，布尔，时间。下面使用一个例子来快速了解常量的基本使用：

            多个YAML配配置可以在同一个文件中，使用---表示一个文档的开始；比如Springboot中profile的定义：

            上例代表定义了两个profile，一个是development，一个production 

    **Spring框架提供两个便利的类用于加载YAML文档，YamlPropertiesFactoryBean会将YAML作为Properties来加载，YamlMapFactoryBean会将YAML作为Map来加载。**![](https://img-blog.csdnimg.cn/5514eafd74274e2b9257d089deadfc3a.png)

    YAML列表被表示成使用[index]间接引用作为属性keys的形式， 例如下面的YAML： ![](https://img-blog.csdnimg.cn/73150e1dda044e7da8cf9be925ab7edf.png)

    将会转化到下面的属性中: 

    使用前例用过的@ConfigurationProperties注入列表属性，需要确定目标bean中有个java.util.List或Set类型的属性， 并且需要提供一个setter或使用可变的值初始化它， 比如，下面的代码将绑定上面的属性： 

    可以在单个文件中定义多个特定Profile配置的YAML文档， 并通过一个spring.profiles key标示应用的文档。 例如：![](https://img-blog.csdnimg.cn/fed25d8b974f45c8a82c01e900a07a58.png) 

    正如前例中看到的，使用@Value(“${property}”)注解注入配置属性有时可能比较笨重， 特别是需要使用多个properties或数据本身有层次结构。 为了控制和校验应用配置， Spring Boot提供一个允许强类型beans的替代方法来使用properties：

可以通过在@EnableConfigurationProperties注解中直接简单的列出属性类来快捷的注册@ConfigurationProperties bean的定义：

    Spring Boot使用一些宽松的规则用于绑定Environment属性到@ConfigurationProperties beans， 所以Environment属性名和bean属性名不需要精确匹配。 常见的示例中有用的包括虚线分割（如context--path绑定到contextPath） 和将环境属性转为大写字母（比如，PORT绑定port）。![](https://img-blog.csdnimg.cn/e0506f6ba89e4abaa6e1317cee0e27e3.png) 下面的属性名都能用于上面的@ConfigurationProperties类：

属性

说明

person.firstName

标准驼峰命名规则

person.first-name

虚线表示， 推荐用于.properties和.yml文件中

PERSON_FIRST_NAME

大写形式， 使用系统环境变量时推荐

九，web相关

** **Spring Boot非常适合开发web应用程序。 可以使用内嵌的Tomcat， Jetty或Undertow轻轻松松地创建一个HTTP服务器。 大多数的web应用都使用spring-boot-starter-web模块进行快速搭建和运行。

    Spring Web MVC框架（通常简称为“Spring MVC”） 是一个“模型， 视图， 控制器”的web框架。 Spring MVC允许创建特定的@Controller或@RestController beans来处理传入的HTTP请求。 使用@RequestMapping注解可以将控制器中的方法映射到相应的HTTP请求。

    **Spring Boot为Spring MVC提供适用于多数应用的自动配置功能。 在Spring默认基础上， 自动配置添加了以下特性：**

** **引入ContentNegotiatingViewResolver和BeanNameViewResolver beans。

    对静态资源的支持， 包括对WebJars的支持。

    自动注册Converter， GenericConverter， Formatter beans。

    对HttpMessageConverters的支持。

    自动注册MessageCodeResolver。

    对静态index.html的支持。

    对自定义Favicon的支持。

    如果想全面控制Spring MVC， 可以添加自己的@Configuration， 并使用@EnableWebMvc对其注解。 如果想保留Spring Boot MVC的特性， 并只是添加其他的MVC配置(拦截器， formatters， 视图控制器等)， 可以添加自己的WebMvcConfigurerAdapter类型的@Bean（不使用@EnableWebMvc注解） 。

    **Spring MVC使用HttpMessageConverter接口转换HTTP请求和响应。 合理的缺省值被包含的恰到好处， 例如：**

** ** 对象可以自动转换为JSON（使用Jackson库） 或XML（如果Jackson XML扩展可用则使用它， 否则使用JAXB）

    字符串默认使用UTF-8编码

    **如果需要添加或自定义转换器， 可以使用Spring Boot的HttpMessageConverters类： **

    任何在上下文中出现的HttpMessageConverter bean将会添加到converters列表， 可以通过这种方式覆盖默认的转换器（converters） 。 

    **默认情况下， Spring Boot从classpath下一个叫/static（/public， /resources或/META-INF/resources） 的文件夹或从ServletContext根目录提供静态内容。 这使用了Spring MVC的ResourceHttpRequestHandler， 所以可以通过添加自己的WebMvcConfigurerAdapter并覆写addResourceHandlers方法来改变这个行为（加载静态文件） 。**

** 在一个单独的web应用中， 容器默认的servlet是开启的， 如果Spring决定不处理某些请求， 默认的servlet作为一个回退（降级） 将从ServletContext根目录加载内容。 大多数时候， 这不会发生（除非修改默认的MVC配置） ， 因为Spring总能够通过DispatcherServlet处理请求。**

** 此外， 上述标准的静态资源位置有个例外情况是Webjars内容。 任何在/webjars/路径下的资源都将从jar文件中提供， 只要它们以Webjars的格式打包。

** 注：如果应用将被打包成jar， 那就不要使用src/main/webapp文件夹。 尽管该文件夹是一个共同的标准， 但它仅在打包成war的情况下起作用， 并且如果产生一个jar， 多数构建工具都会静悄悄的忽略它。**

** 可以使用Spring MVC提供动态HTML内容。**

** **Spring MVC支持各种各样的模板技术， 包括Velocity,FreeMarker和JSPs。 很多其他的模板引擎也提供它们自己的Spring MVC集成Spring Boot为以下的模板引擎提供自动配置支持：

    FreeMarker

    Groovy

    Thymeleaf

    Velocity

    如果可能的话， 应该忽略JSPs， 因为在内嵌的servlet容器使用它们时存在一些已知的限制。 当你使用这些引擎的任何一种， 并采用默认的配置， 模板将会从src/main/resources/templates目录下自动加载。

    **如果要使用JSP，那么需要在项目的POM文件中加入如下依赖：**

<dependency>
            <groupId>org.apache.tomcat.embed</groupId>
            <artifactId>tomcat-embed-jasper</artifactId>
        </dependency>
<dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>jstl</artifactId>
        </dependency>

    **Spring Boot默认提供一个/error映射用来以合适的方式处理所有的错误， 并且它在servlet容器中注册了一个全局的 错误页面。 对于机器客户端（相对于浏览器而言， 浏览器偏重于人的行为） ， 它会产生一个具有详细错误， HTTP状态， 异常信息的JSON响应。 对于浏览器客户端， 它会产生一个白色标签样式（whitelabel） 的错误视图， 该视图将以HTML格式显示同样的数据（可以添加一个解析为erro的View来自定义它） 。 为了完全替换默认的行为， 你可以实现ErrorController， 并注册一个该类型的bean定义， 或简单地添加一个ErrorAttributes类型的bean以使用现存的机制， 只是替换显示的内容。如果在某些条件下需要比较多的错误页面， 内嵌的servlet容器提供了一个统一的Java DSL（领域特定语言） 来自定义错误处理。**

@Controller
public class ErrorPageController implements ErrorController {

    Logger logger = Logger.getLogger(ErrorPageController.class);

    public static final String ERROR_PATH = "/error";

    @RequestMapping(ERROR_PATH)
    public String error(){
        logger.info("进入了错误页面的控制器当中...");
        return "error404";
    }

    @Override
    public String getErrorPath() {
        return ERROR_PATH;
    }
}

    也可以使用常规的Spring MVC特性来处理错误， 比如@ExceptionHandler方法和@ControllerAdvice。 ErrorController将会捕获任何没有处理的异常

十，常用注解汇总

   ** @SpringBootApplication**

** ** 包含了@ComponentScan、@Configuration和@EnableAutoConfiguration注解。其中@ComponentScan让spring Boot扫描到Configuration类并把它加入到程序上下文。

    **@ResponseBody**

** ** 表示该方法的返回结果直接写入HTTP response body中，一般在异步获取数据时使用，用于构建RESTful的api。在使用@RequestMapping后，返回值通常解析为跳转路径，加上@Responsebody后返回结果不会被解析为跳转路径，而是直接写入HTTP response body中。比如异步获取json数据，加上@Responsebody后，会直接返回json数据。该注解一般会配合@RequestMapping一起使用。

   ** @RequestMapping**

** **提供路由信息，负责URL到Controller中的具体函数的映射。

   ** @ComponentScan**

** **组件扫描，可自动发现和装配一些Bean，@ComponentScan主要就是定义扫描的路径从中找出标识了需要装配的类自动装配到spring的bean容器中如@Controller，@Service，@Repository注解中有一个共同的注解@Component，@ComponentScan注解默认就会装配标识了@Controller，@Service，@Repository，@Component注解的类到spring容器中

** @Configuration**

** **等同于spring的XML配置文件；使用Java代码可以检查类型安全。

** @EnableAutoConfiguration**

** **自动配置

** @Controller**

** ** 用于定义控制器类，在spring项目中由控制器负责将用户发来的URL请求转发到对应的服务接口（service层），一般这个注解在类中，通常方法需要配合注解@RequestMapping。

  **  @RestController**

            @Controller和@ResponseBody的合集,表示这是个控制器bean,并且是将函数的返回值直 接填入HTTP响应体中,是REST风格的控制器。

    **@Autowired**

            自动导入

 **   @PathVariable**

            获取参数。等同于spring的XML配置文件；使用Java代码可以检查类型安全。

   ** @ImportResource**

            注解加载xml配置文件

   ** @Import**

            用来导入其他配置类。

   ** @Repository**

            使用@Repository注解可以确保DAO或者repositories提供异常转译，这个注解修饰的DAO或者repositories类会被ComponetScan发现并配置，同时也不需要为它们提供XML配置项。

    **@Bean**

            用@Bean标注方法等价于XML中配置的bean

   **  @Value**

            注入Spring boot application.properties配置的属性的值。

    ** @Qualifier**

            当有多个同一类型的Bean时，可以用@Qualifier(“name”)来指定。与@Autowired配合使用。@Qualifier限定描述符除了能根据名字进行注入，但能进行更细粒度的控制如何选择候选者。

  **  Spring Boot为Spring MVC提供适用于多数应用的自动配置功能。 在Spring默认基础上， 自动配置添加了以下特性：引入ContentNegotiatingViewResolver和BeanNameViewResolver beans，对静态资源的支持， 包括对WebJars的支持，自动注册Converter， GenericConverter， Formatter beans，对HttpMessageConverters的支持，自动注册MessageCodeResolver，对静态index.html的支持，对自定义Favicon的支持。**