SpringBoot：概述，注解，搭建，部署

1，SpringBoot简介

1.1，SpringBoot概述

Spring框架非常优秀，然而它最大的问题在于“配置过多”。基于Spring的企业级开发项目，需要大量的配置文件，SpringBoot的出现就是为了解决Spring框架存在的问题。

本质上讲：Spring只是一个“组件”容器，它负责创建并管理容器中的组件（Bean），并管理组件之间的依赖关系。正是由于Spring将容器功能用到了极致，JavaEE应用所涉及的各种组件（控制器、安全组件、逻辑层、消息、DAO、连接数据库组件），都处于Spring的管理之下。

SpringBoot设计的目的就是用来简化Spring应用的创建、运行、调试、部署等。使用SpringBoot可以做到专注于Spring应用的开发，而无须过多关注XML配置。Spring Boot使用“约定优先于配置”的理念。简单来说，Spring Boot提供了针对企业应用开发各种场景的很多spring-boot-starter自动配置依赖模块，这些模块都基于“开箱即用”的原则，使得企业应用开发中各种场景的Spring应用更加快速和高效。

SpringBoot是开发者和Spring框架的中间层，帮助开发者统筹管理应用的配置，提供基于实际开发中常见配置的默认处理（即约定优先于配置），简化应用的开发和运行为。总的来说，SpringBoot的目的就是为了对Java Web的开发进行“简化”和“加速”，简化开发过程中引入或启动相关Spring功能的配置。这样带来的好处就是降低开发人员对于框架的关注度，可以把更多的精力放在自己的业务代码上。

传统Spring使用XML配置或注解来管理这些组件，因此搭建一个Java EE应用往往需要进行大量的配置和注解。这些配置工作都属于项目的基础搭建，与业务功能无关，这些工作对于初级、中级开发者难度不小，容易出错。

SpringBoot可整合的框架：

前端：Spring WebFlux、SpringMVC、Struts2等。

安全领域：Spring Security、Shiro等。

消息组件：ActiveMQ、RabbitMQ、Kafka等。

缓存：JCache、EhCache、Hazelcast、Redis等。

持久化层框架：JPA、MyBatis、jOOQ、R2DBC等。

分布式：ZooKeeper、Dubbo等。

NoSQL存储：Redis、MongoDB、Neo4j、Cassandra、Geodo、CouchBase。

搜索引擎：Lucene、Solr、Elasticsearch等。

数据库存储：MySQL、PostgreSQL、Oracle等。

Web服务器：Tomcat、Jetty、Undertow。

SpringBoot解决的问题：

使设计变得简单：采用原生Java程序实现MVC设计模式时，一旦整体项目设计不到位，就会存在大量的重复代码，并且项目维护困难。

使整合变得简单：当使用一些第三方的服务组件（RabbitMQ、Kafka、JavaMail等）时，需要编写大量重复的配置文件，而且还需要根据环境定义不同的profile（dev、beta、product）。

使配置变得简单：为了简化MVC各个层的开发，可以引用大量的第三方开发框架，如Spring、Hibernate、MyBatis、Shiro、JPA、SpringSecurity等，但这些框架都需要在Spring中实现整合，其结果就是会存在大量的配置文件。

使部署变得简单：使用Maven作为构建工具时，需要配置大量的依赖关系，且程序需要被打包为 *.war 文件并部署到应用服务器上才可以执行。

使交互变得简单：Restful作为接口技术应用得越来越广泛，但如果使用Spring来搭建Restful服务，则需要引入大量的Maven依赖库，并且需要编写许多配置文件。

SpringBoot为绝大部分第三方框架的快速整合提供了自动配置，因此，当使用SpringBoot来整合这些第三方框架时，基本无须提供过多的基础配置。SpringBoot利用“约定优先配置”的理念，针对企业应用开发各种场景提供了对应的Starter，开发者只要将该Starter添加到项目的类加载路径中，该Starter即可完成第三方框架的整合。

SpringBoot的主要特性：

SpringBoot是伴随着Spring4.0诞生的，继承了Spring框架原有的优秀基因。

遵循“约定优先于配置”的原则，使用SpringBoot只需很少的配置，大部分的时候直接使用默认的配置即可。

对主流开发框架无配置集成，自动整合三方框架。

可被做成独立的Java应用程序，SpringBoot可以以jar包的形式独立运行。使用java -jar命令或者在项目的主程序中执行main函数就可成功运行项目。

内嵌Servlet容器，可以选择内嵌Tomcat、Jetty等Web容器，无须以war包形式部署项目。

提供starter简化Maven配置，基本上可以做到自动化配置，高度封装，开箱即用。

SpringBoot会根据项目依赖自动配置Spring框架，极大减少了项目所使用的配置。

SpringBoot提供了准生产环境的应用监控。

无代码生成和XML配置，纯Java的配置方式，很简单，很方便。

分布式开发，与SpringCloud无缝结合。

1.2，“开箱即用”的依赖模块

SpringBoot提供了针对企业应用开发各种场景的很多spring-boot-starter自动配置依赖模块，它们都约定以spring-boot-starter作为命名的前缀，并且都位于org.springframework.boot包或者命名空间下。

SpringBoot默认支持和提供了大约80个自动配置依赖模块，但开发者实际项目中不一定会用到。所有的spring-boot-starter模块都有约定的默认配置，但是允许开发者调整这些默认的配置用以改变默认的配置行为，这就是所谓的“约定优先于配置”。

简单来说，SpringBoot的配置主要可以分为一下几类：

命令行参数。

系统环境变量。

位于文件系统中的配置文件。

位于classpath中的配置文件

固话到代码中的配置。

以上几种方式按照优先级从高到低排列，高优先级方式提供的配置项会覆盖或者优先生效。

实际项目开发中最常用的配置是配置文件，不管是位于文件系统还是位于classpath，SpringBoot应用默认的配置文件名叫做application.properties，可以放在项目的src/main/resources目录下或者类路径的/config目录下。

日志依赖模块：spring-boot-starter-logging

Java的日志系统多种多样，有默认的java.util提供的日志支持，有log4j、log4j2、commons logging等日志框架。可以通过如下配置在Maven中添加spring-boot-starter-logging依赖模块。
<dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-logging</artifactId>
</dependency>
SpringBoot将自动使用logback作为项目的日志框架。SpringBoot为开发者提供了很多默认的日志配置，所以，只要将spring-boot-starter-loggging依赖模块添加到当前项目，即可以“开箱即用”，不需要任何多余的配置。

Web开发依赖模块：spring-boot-starter-web

在互联网时代，大部分项目都是基于Web开发的，Spring框架的使用者几乎都会使用SpringMVC来开发Web项目。为了帮助开发者简化快速搭建过程并开发Web项目，SpringBoot提供了spring-boot-starter-web自动依赖模块。
<dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-web</artifactId>
</dependency>
就这样就得到了一个可以直接执行的Web项目，运行当前项目的App的main方法可以直接启动一个使用了嵌入式Tomcat服务器的Web应用。只不过，在还没有提供任何服务Web请求Controller时，访问任何路径都会返回一个SpringBoot默认提供的错误请求页面。

SpringBoot使用spring-boot-starter-web依赖模块开发Web项目，非常简单、方便。但是，在简单的背后，其实有很多约定，只有充分了解这些“约定”，才能更好地使用spring-boot-starter-web依赖模块。

（1）项目结构层次约定：在传统的Java Web项目中，所有的静态文件和页面都放在WebContent目录下，而SpringBoot项目的静态文件和页面统一放在src/main/resources目录对应的子目录下；src/main/resources/static目录用户存放各类静态资源文件，比如css、js和image等；src/mian/resources/templates目录存放页面模板文件，比如html和jsp等。

（2）SpringMVC框架层面的约定：spring-boot-starter-web依赖模块默认自动配置一些SpringMVC必要的组件。

将ViewResolver注册到Spring容器。

将Converter和Formatter等bean注册到Spring容器。

将对Web请求的支持和相应的类转换的HttpMessageConverter自动注册到Spring容器。

将MessageCodesResolver自动注册到Spring容器。

（3）嵌入式Web容器层面的约定：spring-boot-starter-web依赖模块默认使用嵌入式Tomcat作为Web容器对外提供服务，默认使用8080端口对外监听和提供服务。

1.3，第一个SpringBoot应用

1，创建项目时选择Maven

设置项目的组织ID、项目ID和版本：

配置本地Maven：

得到项目：

2，配置pom.xml文件和目录

通过上图可以看出Maven项目包含一个pom.xml构建文件和一个src目录，该src目录下包含两个子目录：

main：该目录下保存了主项目的Java源文件和各种资源。该main目录下的java子目录用于保存Java源文件，resources子目录（要自行创建）用于保存各种资源文件。

test：该目录下保存了项目测试的Java源文件和各种资源。该test目录下的java子目录用于保存Java源文件，resources子目录（要自行创建）用于保存各种资源文件。

接下来就需要修改SpringBoot项目的pom.xml文件，为了避免开发者手动编写pom.xml文件，SpringBoot提供了SpringInitializr（https://start.spring.io/），这个工具可以自动生成SpringBoot的Maven或Gradle项目。

Project：选择创建Maven项目还是Gradle项目。

Language：选择项目所使用的编程语言，可以选择Java、Kotlin或Groovy。

SpringBoot的版本：建议选择最新发布版。SNAPSHOT代表快照版，通常不稳定。

在“Project Metadata”区域为项目输入组织名（通常为公司域名倒写）、Artifact名、name和包名等信息。

为SpringBoot选择打包类型：由于SpringBoot内嵌了Tomcat、Jetty或Undertow服务器，因此SpringBoot应用通常不需要被部署到Web服务器中，选择打包成JAR包即可。只有在极个别的情况下，不想使用SpringBoot内嵌服务器，才会考虑将它打包成WAR包（Web应用包），部署到独立的Web服务器上。

选择项目所使用的的Java版本，此处选择Java最新的LTS版本（长期支持版）：11。

为SpringBoot项目项目添加依赖库：Spring Web。

点击“EXPLORE”按钮，得到pom.xml：

将上述pom.xml拷贝到IDEA项目的pom.xml中：其中<build.../>元素中定义了一个SpringBootMaven插件，该插件可以用于运行SpringBoot应用，如果不需要使用该插件来运行SpringBoot应用，就不需要配置该插件。

3，编写控制器
package main.Controller;import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.ResponseBody;@Controller
public class BookController {@GetMapping("/")public String index(Model model) {model.addAttribute("tip", "Hello SpringBoot");return "hello";}@GetMapping("/rest")@ResponseBodypublic ResponseEntity restIndex() {return new ResponseEntity("Hello Spring", null, HttpStatus.OK);}
}
SpringMVC注解：

SpringMVC：Struts2区别、搭建应用、流程处理、核心控制器_燕双嘤-CSDN博客作为Spring框架的一部分，SpringMVC可以与Spring框架无缝整合。实际上，SpringMVC本身就是基于Spring核心容器的，SpringMVC的控制器天然就处于Spring容器的管理之下，因此Spring可以轻易地将Service组件注入控制器。SpringMVC已逐渐取代Struts2的地位，成为Java领域最流行的MVC框架，这不仅仅由于它是Spring家族的产品，更由于SpringMVC本身更加简单、易用，而且功能非常强大。SpringMVC的控制器、处理方法都非常简单，通常只.https://shao12138.blog.csdn.net/article/details/117247051#t6控制器类定义了两个处理方法，其中一个index()方法返回的“hello”字符串是一个逻辑视图名，因此它还需要物理视图资源。

4，添加视图依赖

SpringBoot推荐使用Thymeleaf作为视图模板技术，Thymeleaf具有很多优势，比传统的JSP、FreeMarker、Velocity等视图技术更加优秀。此外为了美化还需要添加SpringBootThymeleaf和Bootstrap依赖。
<dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-thymeleaf</artifactId>
</dependency>
<dependency><groupId>org.webjars</groupId><artifactId>bootstrap</artifactId><version>4.5.3</version>
</dependency>
<!DOCTYPE html>
<html lang="en">
<head><meta charset="UTF-8"><title>Title</title>
</head>
<body><div class="alert alert-primary" th:text="${tip}"></div>
</body>
</html>
SpringBoot默认要求将Thymeleaf视图页面放在resources\templates\目录下，因此需要将上面的视图页面放在该目录下。由于该页面是为“hello”逻辑视图名提供视图，因此该页面文件名为“hello.html”。

Thymeleaf视图页面语法较为简单，其核心设计就是一点：用以“th:”开头的属性来处理表达式的值，比如th:text属性的作用就是用目标元素来显示表达式的值。

5，运行应用

SpringBoot应用是独立的Java应用，它内嵌了Tomcat、Jetty和Undertow作为服务器，因此不需要被部署到其他服务器中，但正因为如此，SpringBoot应用至少需要一个主动类作为程序入口类。
package main;import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;@SpringBootApplication
public class APP {public static void main(String[] args) {SpringApplication.run(APP.class,args);}
}
该主类代码非常简单，仅仅调用了SpringApplication类的run()方法来创建Spring容器，运行SpringBoot应用。

SpringApplication类中的run()方法的返回值就是ConfigurableApplicationContext，这就是Spring容器，课件run()方法将会创建并返回Spring容器。

run()方法的第一个参数可以是任意用@Configuration注解修饰的Java类（Java配置类，相当于传统的XML配置文件），Spring容器会加载该配置类并创建该配置类中的所有Bean，并且会扫描该配置类相同包中或其子包下的所有Bean。

由于run()方法第一个参数为APP.class，一次你该类应该是@Configuration注解修饰的配置类，但很明显该类没有用@Configuration修饰，详细原因在2.1。

1.4，第二个SpringBoot应用（主要）

对于前后端分离框架的应用，SpringBoot应用根本不需要生成视图响应，自然不需要任何视图模板技术。SpringBoot只需要对外提供RESTful响应，前端通过RESTful接口与后端通信，前端应用负责生成界面，与用户交互。

1，创建项目时选择Spring Initializr

2，输入项目基本信息，然后添加依赖

3，打开就是已经创建好的SpringBoot项目，增加一些包和文件

4，Spring Boot基础配置

从上面我们可以了解到在向pom.xml文件中添加依赖之前需要添加spring-boot-starter-parent。spring-boot-parent主要提供了：Java版本默认使用1.8；编码格式默认使用UTF-8；提供Dependency Management进行项目管理。默认的资源过滤与插件配置。 通过IDEA自动创建的spring boot项目产生如下的启动类，与Maven创建的启动类在注解上存在出入。

Tomcat配置

在application.properties中添加，详细参考官方文档。

server.port=8081
server.error.path=/error
server.servlet.session.timeout=30m
server.servlet.context-path=/
server.tomcat.uri-encoding=UTF-8

Mysql配置

spring.datasource.type=com.alibaba.druid.pool.DruidDataSource
spring.datasource.url=jdbc:mysql://127.0.0.1:3306/test?serverTimezone=GMT%2B8&amp
spring.datasource.username=root
spring.datasource.password=123456

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 https://maven.apache.org/xsd/maven-4.0.0.xsd"><modelVersion>4.0.0</modelVersion><parent><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-parent</artifactId><version>2.4.0</version><relativePath/> <!-- lookup parent from repository --></parent><groupId>com.example</groupId><artifactId>demo</artifactId><version>0.0.1-SNAPSHOT</version><name>demo</name><description>Demo project for Spring Boot</description><properties><java.version>1.8</java.version></properties><dependencies><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-web</artifactId></dependency><dependency><groupId>org.mybatis.spring.boot</groupId><artifactId>mybatis-spring-boot-starter</artifactId><version>1.3.2</version></dependency><dependency><groupId>com.alibaba</groupId><artifactId>druid</artifactId><version>1.1.9</version></dependency><dependency><groupId>mysql</groupId><artifactId>mysql-connector-java</artifactId><scope>runtime</scope></dependency><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-test</artifactId><scope>test</scope></dependency></dependencies><build><!--在Maven中，xml配置文件建议写在resource中，但是为了统一Dao层，添加如下配置，防止Maven在运行时忽略包下的xml文件--><resources><resource><directory>src/main/java</directory><includes><include>**/*.xml</include></includes></resource><resource><directory>src/main/resources</directory></resource></resources><plugins><plugin><groupId>org.springframework.boot</groupId><artifactId>spring-boot-maven-plugin</artifactId></plugin></plugins></build></project>

5，Html+Pojo+Controller+Service+Dao

<!DOCTYPE html>
<html lang="en">
<head><meta charset="UTF-8"><title>Title</title>
</head>
<script type="text/javascript" src="https://cdn.bootcss.com/jquery/3.2.1/jquery.min.js"></script>
<script>function insert(){$.ajax({type : "POST",/*url : "/insertBook",*/url : "/insertBookPojo",    /*插入实体类传参*/data : {name:"盗墓笔记",author:"南派三叔"},success : function(data) {},});}
</script>
<body><a href="/selectBook">查询数据</a><button onclick="insert()">添加数据</button>
</body>
</html>

package com.example.demo.Pojo;public class Book {private Integer id;private String name;private String author;public Integer getId() {return id;}public void setId(Integer id) {this.id = id;}public String getName() {return name;}public void setName(String name) {this.name = name;}public String getAuthor() {return author;}public void setAuthor(String author) {this.author = author;}
}

package com.example.demo.Controller;
import com.example.demo.Pojo.Book;
import com.example.demo.Service.BookService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RestController;@RestController
public class BookController {@AutowiredBookService bookService;@GetMapping("/selectBook")public Book selectBook(){return bookService.selectBook();}@PostMapping("/insertBook")public void insertBook(String name,String author){bookService.insertBook(name,author);}@PostMapping("/insertBookPojo")public void insertBookPojo(Book book){bookService.insertBook(book.getName(),book.getAuthor());}
}

package com.example.demo.Service;import com.example.demo.Dao.BookMapper;
import com.example.demo.Pojo.Book;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;@Service
public class BookService {@AutowiredBookMapper bookDao;public Book selectBook(){return bookDao.selectBook();}public void insertBook(String name,String author) {bookDao.insertBook(name,author);}
}

package com.example.demo.Dao;import com.example.demo.Pojo.Book;
import org.apache.ibatis.annotations.Mapper;
import org.springframework.stereotype.Repository;@Repository
@Mapper
public interface BookMapper {Book selectBook();void insertBook(String name, String author);
}

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapperPUBLIC "-//mybatis.org//DTD Mapper 3.0//EN""http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.example.demo.Dao.BookMapper"><select id="selectBook" resultType="com.example.demo.Pojo.Book">select * from book;</select><insert id="insertBook">INSERT into book(name,author) values(#{name},#{author});</insert>
</mapper>

1.5，自动建表

application.properties：
server.port=8081
server.error.path=/error
server.servlet.session.timeout=30m
server.servlet.context-path=/
server.tomcat.uri-encoding=UTF-8
spring.datasource.type=com.alibaba.druid.pool.DruidDataSource
spring.datasource.url=jdbc:mysql://127.0.0.1:3306/test?serverTimezone=GMT%2B8&amp
spring.datasource.username=root
spring.datasource.password=123456
#指定显示SQL语句
spring.jpa.show-sql=true
#指定根据实体自动建表
spring.jpa.generate-ddl=true
实体类：book
package main.Pojo;
import javax.persistence.*;@Entity
@Table(name="book_inf")
public class Book {@Id@Column(name = "book_id")@GeneratedValue(strategy = GenerationType.IDENTITY)private Integer id;private String title;private String author;private double price;...
}
此处再次体现了SpringBoot的自动配置，上面的配置文件仅仅指定了连接数据库的基本信息，SpringBoot将会自动在容器中配置一个DataSource Bean；配置文件仅仅指定了两个JPA属性，SpringBoot将会自动在容器中配置一个EntityManagerFactory Bean。这一切都是自动发生的，当然，这正是SpringBoot的职责所在。

2，SpringBoot核心

2.1，@SpringBootApplication注解

SpringBoot项目都会有注解*Application标准的入口类，入口类会有一个main方法，main方法是一个标准的Java应用程序的入口方法，可以直接启动。@SpringBoot注解是SpringBoot的核心注解，用此注解标注的入口类是应用的启动类，通常会在启动类的main方法中通过SpringApplication.run(App.class, args)来启动Spring Boot应用项目。

@SpringBoot其实是一个组合注解，其源码如下：

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by FernFlower decompiler)
//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.beans.factory.support.BeanNameGenerator;
import org.springframework.boot.SpringBootConfiguration;
import org.springframework.boot.context.TypeExcludeFilter;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.FilterType;
import org.springframework.context.annotation.ComponentScan.Filter;
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)Class<?>[] exclude() default {};@AliasFor(annotation = EnableAutoConfiguration.class)String[] excludeName() default {};@AliasFor(annotation = ComponentScan.class,attribute = "basePackages")String[] scanBasePackages() default {};@AliasFor(annotation = ComponentScan.class,attribute = "basePackageClasses")Class<?>[] scanBasePackageClasses() default {};@AliasFor(annotation = ComponentScan.class,attribute = "nameGenerator")Class<? extends BeanNameGenerator> nameGenerator() default BeanNameGenerator.class;@AliasFor(annotation = Configuration.class)boolean proxyBeanMethods() default true;
}

实际上@SpringBootApplication=@SpringBootConfiguration+@EnableAutoConfiguration+@ComponentScan

@SpringBootConfiguration：这是SpringBoot项目的注解配置，也是一个组合配置，源码如下：
@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Configuration
@Indexed
public @interface SpringBootConfiguration {@AliasFor(annotation = Configuration.class)boolean proxyBeanMethods() default true;
}
在SpringBoot中推荐使用@SpringBootConfiguration注解代替@Configuration注解。

@EnableAutoConfiguration：启动自动配置，该注解会让SpringBoot根据当前项目所依赖的jar包自动配置项目的相关配置项。

例如：当在SpringBoot项目的pom.xml文件中配置了如下spring-boot-starter-web依赖。
<dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-web</artifactId>
</dependency>
项目会自动添加Tomcat和SpringMVC的依赖，同时SpringBoot会对Tomcat和SpringMVC进行配置项目的自动配置，打开pom.xml，选择Dependency查看。

@ComponentScan：扫描配置，SpringBoot默认会扫描@SpringBootApplication所在类的同级包以及它的子包，所以建议将@SpringBootApplication修饰的入口类放置在项目包下（GroupId+ArtifactId），这样做的好处是，可以保证SpringBoot项目自动扫描到项目所有的包。

由此可见，@SpringBootApplication注解和SpringApplication的run()方法就藏着SpringBoot自动配置的大部分秘密：其实所谓的自动配置，只不过是SpringBoot提供了预配置而已，并没有所谓的自动配置。

2.2，SpringBoot基本配置

关闭某个自动配置：通过@SpringBootApplication下的@EnableAutoConfiguration可知，SpringBoot会根据项目中的jar包依赖，自动做出配置，SpringBoot支持的部分自动配置非常多。假如想关闭某一项自动配置，可以关闭特定的自动配置应该使用@SpringBootApplication下的exclude参数：
@SpringBootApplication(exclude = {RedisAutoConfiguration.class})
public class Application {public static void main(String[] args) {SpringApplication.run(Application.class, args);}
}

定制启动Banner：在启动Spring项目的时候，可以看到如下启动图案。
  .   ____          _            __ _ _/\\ / ___'_ __ _ _(_)_ __  __ _ \ \ \ \
( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \\\/  ___)| |_)| | | | | || (_| |  ) ) ) )'  |____| .__|_| |_|_| |_\__, | / / / /=========|_|==============|___/=/_/_/_/
如果要关闭该Banner，则可通过application.properties文件中的spring.main.banner-mode属性进行设置。该属性支持三个属性：

console：在控制台输出Banner。

log：在日志文件中输出Banner。

off：彻底关闭Banner。

如下想要换成指定的图案，则需要按照如下步骤操作。

在浏览器中访问：http://patorjk.com/software/taag

选择自定义图案到新建的banner.txt文件。

将banner.txt文件放到src/main/resource目录下，重启项目。
 +-+-+-+-+-+ +-+-+-+-+-+-+|H|e|l|l|o| |S|p|r|i|n|g|+-+-+-+-+-+ +-+-+-+-+-+-+
此外，SpringBoot还运行使用图片文件添加Banner，只要在类加载路径下添加一个banner.gif、banner.jpg或banner.png图片文件，或者通过spring.banner.image.location属性设置图片Banner加载路径，SpringBoot就会自动把该图片转换为字符画形式，并作为应用程序的Banner。

当图片Banner和文本Banner同时存在时，SpringBoot将会优先显示Banner对应的字符画，然后再显示文本Banner的内容。

全局配置文件：可以在SpringBoot项目的src/main/resources目录下或者在类路径的/config目录下创建一个全局的配置文件application.properties或者是后缀为.yml的application.yml文件，用于修改SpringBoot项目的默认配置值。例如修改项目的默认端口，或者进入DispatcherServlet的请求地址规则等。

通常在实际开发中习惯使用application.properties文件作为应用的全局配置文件，一般放在src/mian/resources目录下，例如：
server.port=8090
spring.mvc.servlet.path=*.action

2.3，SpringBoot的依赖模块

SpringBoot提供了很多简化项目开发的“开箱即用”的依赖模块，例如在项目中使用的pom.xml文件中的配置：
<dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-web</artifactId>
</dependency>
SpringBoot会自动关联Web开发相关的依赖，如Tomcat以及spring-webmvc等，进而对Web开发进行支持，同时相关技术的配置也将实现自动配置，程序员即避免烦琐的配置文件。除此之外，官方还提供了如下依赖配置：

spring-boot-starter：这是SpringBoot的核心启动器，包含了自动配置、日志和YAML文件的支持。

spring-boot-starter-activemq：为JMS使用Apache ActiveMQ，ActiveMQ是Apache出品的最流行、能力最强的开源消息总线。

spring-boot-starter-amqp：通过spring-rabbit来支持AMQP协议。

spring-boot-starter-aop：支持切面编程，包括spring-aop和AspectJ。

spring-boot-starter-artemis：通过Apache Artemis支持JMS的API。

spring-boot-starter-batch：支持Spring Batch，包含HSQLDB数据库。

spring-boot-starter-cache：支持Spring的Cache抽象。

spring-boot-starter-cloud-connectors：支持Spring Cloud Connectors，简化了在像Cloud Foundry或Heroku这样的云平台上的连接服务。

spring-boot-starter-data-cassandra：使用Cassandra分布式数据库、Spring Data Cassandra。Apache Cassandra是一套开源分布式NoSQL数据库系统。

spring-boot-starter-data-couchbase：使用Couchbase文件存储数据库、Spring Data Couchbase.Spring Data是一个用于简化数据库访问并支持云服务的开源框架。

spring-boot-starter-data-elasticsearch：支持ElasticSearch搜索和分析引擎，包括spring-data-elasticsearch。

spring-boot-starter-data-gemfire：支持GemFire分布式数据存储，包括spring-data-gemfire。

spring-boot-starter-data-jpa：支持JPA，包括spring-data-jpa、spring-orm和Hibernate。

spring-boot-starter-data-ldap：支持Spring Data LDAP。

spring-boot-starter-data-mongodb：支持MongoDB数据库，包括spring-data-mongodb。

spring-boot-starter-data-neo4j：使用Neo4j图形数据库、Spring Data Neo4j。Neo4j是一个高性能的NoSQL图形数据库，它将结构化数据库存储在网格上而不是表中。

spring-boot-starter-redies：通过spring-data-rest-webmvc，支持通过REST暴露Spring Data数据仓库。

spring-boot-starter-data-solr：支持Apache Solar搜索平台，包括spring-data-solr。

spring-boot-starter-freemarket：支持FreeMarker模板引擎。

spring-boot-starter-groovy-templates：支持Groovy模板引擎。

spring-boot-starter-hateoas：通过spring-hateoas支持基于HATEOAS的RESTful Web服务。

spring-boot-starter-integration：支持通用的spring-integration模块。

spring-boot-starter-jdbc：支持JDBC数据库。

spring-boot-starter-jersey：支持Jersey RESTful Web服务框架。

spring-boot-starter-hornetq：通过HornetQ支持JMS。

spring-boot-starter-jta-atomikos：通过Atomikos支持JTA分布式事务管理。

spring-boot-starter-jta-bitronix：通过Bironix支持JTA分布式事务处理。

spring-boot-starter-mail：支持javax.mail模块。

spring-boot-starter-mobile：支持spring-mobile。

spring-boot-starter-mustache：支持Mustache模板引擎。

spring-boot-starter-security：支持spring-security。

spring-boot-starter-social-facebook：支持spring-social-facebook。

spring-boot-starter-social-linkedin：支持spring-social-linedin。

spring-boot-starter-social-twitter：支持spring-social-twitter。

spring-boot-starter-test：支持常规的测试依赖，包括JUnit、Hamcrest、Mockito以及spring-test模块。

spring-boot-starter-thymeleaf：支持Thymeleaf模板引擎，包括与Spring的集成。

spring-boot-starter-velocity：支持Velocity模板引擎。

spring-boot-starter-web：支持全栈式Web开发，包括Tomcat和spring-webmvc。

spring-boot-starter-websocket：支持WebSocket开发。

spring-boot-starter-ws：支持Spring Web Service。

3，项目部署

3.1，前提

由于SpringBoot应用内嵌了Web服务器（Tomcat、Jetty或Undertow），所以无须将SpringBoot应用部署到其他Web服务器中，SpringBoot应用完全可以独立运行。

在发布SpringBoot应用时，只需要将该应用打包成一个可执行的JAR包，以后就可以直接通过该JAR包来运行SpringBoot应用了。

为了将SpringBoot应用打包成JAR包，首先需要保证在pom.xml文件中添加了SpringBoot的Maven插件，也就是其中包含如下配置：
<build><plugins><plugin><groupId>org.springframework.boot</groupId><artifactId>spring-boot-maven-plugin</artifactId></plugin></plugins>
</build>
如果服务器报错：找不到启动类，则应该使用如下配置。
<plugin><groupId>org.springframework.boot</groupId><artifactId>spring-boot-maven-plugin</artifactId><executions><execution><phase>package</phase><goals><goal>repackage</goal></goals></execution></executions>
</plugin>
其中，如果在pom.xml文件中定义了<packaging.../>元素，请确保该元素是jar，即该内容为：
<packaging>jar</packaging>
省略<packaging.../>元素是完全可以的，当在pom.xml文件中添加了SpringBoot Maven插件后，<packaging.../>元素的内容默认就是jar，因此可以省略该元素。

3.2，打包

1，检查项目目录是否出现target文件夹，没有更好，有则删除。

2，通过maven的package功能，打包。

3，打包完成，在target的根目录出现jar包。

3.3，上传运行

1，上传到服务器。

2，运行SpringBoot项目

如果使用xShell，出现了断开xShell，SpringBoot项目断开，则使用如下命令：

Linux 运行jar包命令如下：nohup java -jar daka.jar >temp.txt &

方式一：java -jar daka.jar

问题：当前ssh窗口被锁定，可按CTRL + C打断程序运行，或直接关闭窗口，程序退出。那如何让窗口不锁定？

方式二：java -jar daka.jar &

&：在后台运行。

当前ssh窗口不被锁定，但是当窗口关闭时，程序中止运行。继续改进，如何让窗口关闭时，程序仍然运行？

方式三：nohup java -jar daka.jar &

nohup：意思是不挂断运行命令,当账户退出或终端关闭时,程序仍然运行

当用 nohup 命令执行作业时，缺省情况下该作业的所有输出被重定向到nohup.out的文件中，除非另外指定了输出文件。

方式四：nohup java -jar daka.jar >temp.txt &

>temp.txt：将command的输出重定向到out.file文件，即输出内容不打印到屏幕上，而是输出到out.file文件中。

SpringBoot：概述，注解，搭建，部署相关推荐

Zabbix搭建部署与概述（一）
搭建部署与概述(一) 链接:https://pan.baidu.com/s/1q5YwJMTcZLcS5OQ0iOu44A 提取码:8gdi 复制这段内容后打开百度网盘手机App,操作更方便哦 1. ...
（硅谷课堂项目）Java开发笔记2：项目概述，搭建项目环境和开发讲师管理接口
文章目录 (硅谷课堂项目)Java开发笔记2:项目概述,搭建项目环境和开发讲师管理接口 1.项目概述 1.1 项目介绍 1.2 硅谷课程流程图 1.3 硅谷课堂功能架构 1.4 硅谷课堂技术架构 1. ...
【Java】 SpringBoot - 零基础搭建并使用
目录一.快速入门 1.SpringBoot2.x依赖环境和版本新特性说明 2.快速创建SpringBoot2.x应用之手工创建web应用 3.快速创建SpringBoot2.x应用之工具类自动创建w ...
SpringBoot项目从搭建到发布
第一章 SpringBoot项目环境搭建文章目录第一章 SpringBoot项目环境搭建前言第二章使用IDEA搭建一个简单的SpringBoot项目--初始化项目前言创建项目第三章整 ...
使用springboot和vue搭建项目
文章目录第一步,搭建vue项目 vue的安装创建项目 springboot项目的创建 idea eclipse vue与springboot之间的交互跨域问题登录拦截问题部署问题 sprin ...
SpringBoot概述
一.SpringBoot SpringBoot实在Spring的基础之上产生的(确切的说是在Spring4.0的版本基础之上),其中"Boot"的意思就是"引导" ...
补习系列(1)-springboot项目基础搭建课
目录前言一.基础结构二.添加代码三.应用配置四.日志配置五.打包部署小结前言 springboot 最近火的不行,目前几乎已经是 spring 家族最耀眼的项目了.抛开微服务.技术社区 ...
SpringBoot 如何测试打包部署
SpringBoot 如何测试打包部署有很多网友会时不时的问我,spring boot项目如何测试,如何部署,在生产中有什么好的部署方案吗?这篇文章就来介绍一下spring boot 如何开发.调试 ...
springboot打包docker镜像部署
springboot打包docker镜像部署环境准备机器 vultr一台,centos7 资源下载 jdk8 maven git yum install git docker yum instal ...
【日常】SpringBoot缓存注解器及整合redis实现（附近期一些python零碎的内容）
序言似乎灵感枯竭了,完全不知道该写些什么东西,非常的痛苦,决定走读博这条路之后就失去了很多乐趣,总是想应该积累更多的论文和相关项目代码量,但是效率却总是很低,需要应付课程与考试,一篇paper的阅读 ...