SpringBoot使用汇总

1. Spring Boot是什么
   我们知道，从 2002 年开始，Spring 一直在飞速的发展，如今已经成为了在Java EE（Java Enterprise Edition）开发中真正意义上的标准，但是随着技术的发展，Java EE使用 Spring 逐渐变得笨重起来，大量的 XML 文件存在于项目之中。繁琐的配置，整合第三方框架的配置问题，导致了开发和部署效率的降低。
   2012 年 10 月，Mike Youngstrom 在 Spring jira 中创建了一个功能请求，要求在 Spring 框架中支持无容器 Web 应用程序体系结构。他谈到了在主容器引导 spring 容器内配置 Web 容器服务。这是 jira 请求的摘录：
   我认为 Spring 的 Web 应用体系结构可以大大简化，如果它提供了从上到下利用 Spring 组件和配置模型的工具和参考体系结构。在简单的 main()方法引导的 Spring 容器内嵌入和统一这些常用Web 容器服务的配置。
   这一要求促使了 2013 年初开始的 Spring Boot 项目的研发，到今天，Spring Boot 的版本已经到了 2.0.3 RELEASE。Spring Boot 并不是用来替代 Spring 的解决方案，而是和 Spring 框架紧密结合用于提升 Spring 开发者体验的工具。
   它集成了大量常用的第三方库配置，Spring Boot应用中这些第三方库几乎可以是零配置的开箱即用（out-of-the-box），大部分的 Spring Boot 应用都只需要非常少量的配置代码（基于 Java 的配置），开发者能够更加专注于业务逻辑。
2. 为什么学习Spring Boot
   2.1 从Spring官方来看
   我们打开 Spring 的官方网站，可以看到下图：

我们可以看到图中官方对 Spring Boot 的定位：Build Anything， Build任何东西。Spring Boot旨在尽可能快地启动和运行，并且只需最少的 Spring 前期配置。 同时我们也来看一下官方对后面两个的定位：
SpringCloud：Coordinate Anything，协调任何事情；SpringCloud Data Flow：Connect everything，连接任何东西。
仔细品味一下，Spring 官网对 Spring Boot、SpringCloud 和 SpringCloud Data Flow三者定位的措辞非常有味道，同时也可以看出，Spring 官方对这三个技术非常重视，是现在以及今后学习的重点（SpringCloud 相关达人课课程届时也会上线）。
2.2 从Spring Boot的优点来看
Spring Boot 有哪些优点？主要给我们解决了哪些问题呢？我们以下图来说明：

2.2.1 良好的基因
Spring Boot 是伴随着 Spring 4.0 诞生的，从字面理解，Boot是引导的意思，因此 Spring Boot 旨在帮助开发者快速搭建 Spring 框架。Spring Boot 继承了原有 Spring 框架的优秀基因，使 Spring 在使用中更加方便快捷。

2.2.2 简化编码
举个例子，比如我们要创建一个 web 项目，使用 Spring 的朋友都知道，在使用 Spring 的时候，需要在 pom 文件中添加多个依赖，而 Spring Boot 则会帮助开发着快速启动一个 web 容器，在 Spring Boot 中，我们只需要在 pom 文件中添加如下一个 starter-web 依赖即可。

org.springframework.boot
spring-boot-starter-web

我们点击进入该依赖后可以看到，Spring Boot 这个 starter-web 已经包含了多个依赖，包括之前在 Spring 工程中需要导入的依赖，我们看一下其中的一部分，如下：

org.springframework
spring-web
5.0.7.RELEASE
compile

org.springframework
spring-webmvc
5.0.7.RELEASE
compile

由此可以看出，Spring Boot 大大简化了我们的编码，我们不用一个个导入依赖，直接一个依赖即可。
2.2.3 简化配置
Spring 虽然使Java EE轻量级框架，但由于其繁琐的配置，一度被人认为是“配置地狱”。各种XML、Annotation配置会让人眼花缭乱，而且配置多的话，如果出错了也很难找出原因。Spring Boot更多的是采用 Java Config 的方式，对 Spring 进行配置。举个例子：
我新建一个类，但是我不用 @Service注解，也就是说，它是个普通的类，那么我们如何使它也成为一个 Bean 让 Spring 去管理呢？只需要@Configuration 和@Bean两个注解即可，如下：
public class TestService {
public String sayHello () {
return "Hello Spring Boot!";
}
}
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
@Configuration
public class JavaConfig {
@Bean
public TestService getTestService() {
return new TestService();
}
}
@Configuration表示该类是个配置类，@Bean表示该方法返回一个 Bean。这样就把TestService作为 Bean 让 Spring 去管理了，在其他地方，我们如果需要使用该 Bean，和原来一样，直接使用@Resource注解注入进来即可使用，非常方便。
@Resource
private TestService testService;
另外，部署配置方面，原来 Spring 有多个 xml 和 properties配置，在 Spring Boot 中只需要个 application.yml即可。
2.2.4 简化部署
在使用 Spring 时，项目部署时需要我们在服务器上部署 tomcat，然后把项目打成 war 包扔到 tomcat里，在使用 Spring Boot 后，我们不需要在服务器上去部署 tomcat，因为 Spring Boot 内嵌了 tomcat，我们只需要将项目打成 jar 包，使用 java -jar xxx.jar一键式启动项目。
另外，也降低对运行环境的基本要求，环境变量中有JDK即可。
2.2.5 简化监控
我们可以引入 spring-boot-start-actuator 依赖，直接使用 REST 方式来获取进程的运行期性能参数，从而达到监控的目的，比较方便。但是 Spring Boot 只是个微框架，没有提供相应的服务发现与注册的配套功能，没有外围监控集成方案，没有外围安全管理方案，所以在微服务架构中，还需要 Spring Cloud 来配合一起使用。
2.3 从未来发展的趋势来看
微服务是未来发展的趋势，项目会从传统架构慢慢转向微服务架构，因为微服务可以使不同的团队专注于更小范围的工作职责、使用独立的技术、更安全更频繁地部署。而 继承了 Spring 的优良特性，与 Spring 一脉相承，而且 支持各种REST API 的实现方式。Spring Boot 也是官方大力推荐的技术，可以看出，Spring Boot 是未来发展的一个大趋势。

1. 本课程能学到什么
   本课程使用目前 Spring Boot 最新版本2.0.3 RELEASE，课程文章均为作者在实际项目中剥离出来的场景和demo，目标是带领学习者快速上手 Spring Boot，将 Spring Boot 相关技术点快速运用在微服务项目中。全篇分为两部分：基础篇和进阶篇。
   基础篇（01—10课）主要介绍 Spring Boot 在项目中最常使用的一些功能点，旨在带领学习者快速掌握 Spring Boot 在开发时需要的知识点，能够把 Spring Boot 相关技术运用到实际项目架构中去。该部分以 Spring Boot 框架为主线，内容包括Json数据封装、日志记录、属性配置、MVC支持、在线文档、模板引擎、异常处理、AOP 处理、持久层集成等等。
   进阶篇（11—17课）主要是介绍 Spring Boot 在项目中拔高一些的技术点，包括集成的一些组件，旨在带领学习者在项目中遇到具体的场景时能够快速集成，完成对应的功能。该部分以 Spring Boot 框架为主线，内容包括拦截器、监听器、缓存、安全认证、分词插件、消息队列等等。
   认真读完该系列文章之后，学习者会快速了解并掌握 Spring Boot 在项目中最常用的技术点，作者课程的最后，会基于课程内容搭建一个 Spring Boot 项目的空架构，该架构也是从实际项目中剥离出来，学习者可以运用该架构于实际项目中，具备使用 Spring Boot 进行实际项目开发的能力。
   课程所有源码提供免费下载：下载地址。
2. 适合阅读的人群
   本课程适合以下人群阅读：
   ● 有一定的Java语言基础，了解Spring、Maven的在校学生或自学者
   ● 有传统项目经验，想往微服务方向发展的工作人员
   ● 热衷于新技术并对 Spring Boot 感兴趣的人员
   ● 希望了解 Spring Boot 2.0.3 的研究人员
3. 本课程开发环境和插件
   本课程的开发环境：
   ● 开发工具：IDEA 2017
   ● JDK版本： JDK 1.8
   ● Spring Boot版本：2.0.3 RELEASE
   ● Maven版本：3.5.2
   涉及到的插件：
   ● FastJson
   ● Swagger2
   ● Thymeleaf
   ● MyBatis
   ● Redis
   ● ActiveMQ
   ● Shiro
   ● Lucence
4. 课程目录
   ● 导读：课程概览
   ● 第01课：Spring Boot开发环境搭建和项目启动
   ● 第02课：Spring Boot返回Json数据及数据封装
   ● 第03课：Spring Boot使用slf4j进行日志记录
   ● 第04课：Spring Boot中的项目属性配置
   ● 第05课：Spring Boot中的MVC支持
   ● 第06课：Spring Boot集成Swagger2展现在线接口文档
   ● 第07课：Spring Boot集成Thymeleaf模板引擎
   ● 第08课：Spring Boot中的全局异常处理
   ● 第09课：Spring Boot中的切面AOP处理
   ● 第10课：Spring Boot中集成MyBatis
   ● 第11课：Spring Boot事务配置管理
   ● 第12课：Spring Boot中使用监听器
   ● 第13课：Spring Boot中使用拦截器
   ● 第14课：Spring Boot中集成Redis
   ● 第15课：Spring Boot中集成ActiveMQ
   ● 第16课：Spring Boot中集成Shiro
   ● 第17课：Spring Boot中结成Lucence
   ● 第18课：Spring Boot搭建实际项目开发中的架构
   第01课：Spring Boot开发环境搭建和项目启动
   上一节对 SpringBoot 的特性做了一个介绍，本节主要对 jdk 的配置、Spring Boot工程的构建和项目的启动、Spring Boot 项目工程的结构做一下讲解和分析。

5. jdk 的配置
   本课程是使用 IDEA 进行开发，在IDEA 中配置 jdk 的方式很简单，打开File->Project Structure，如下图所：

6. 选择 SDKs

7. 在 JDK home path 中选择本地 jdk 的安装目录
8. 在 Name 中为 jdk 自定义名字
   通过以上三步骤，即可导入本地安装的 jdk。如果是使用 STS 或者 eclipse 的朋友，可以通过两步骤添加：
   ● window->preference->java->Instralled JRES来添加本地 jdk。
   ● window-->preference-->java-->Compiler选择 jre，和 jdk 保持一致。
9. Spring Boot 工程的构建
   2.1 IDEA 快速构建
   IDEA 中可以通过File->New->Project来快速构建 Spring Boot 工程。如下，选择 Spring Initializr，在 Project SDK 中选择刚刚我们导入的 jdk，点击 Next，到了项目的配置信息。
   ● Group：填企业域名，本课程使用com.itcodai
   ● Artifact：填项目名称，本课程中每一课的工程名以course+课号命令，这里使用 course01
   ● Dependencies：可以添加我们项目中所需要的依赖信息，根据实际情况来添加，本课程只需要选择 Web 即可。
   2.2 官方构建
   第二种方式可以通过官方构建，步骤如下：
   ● 访问 http://start.spring.io/。
   ● 在页面上输入相应的 Spring Boot 版本、Group 和 Artifact 信息以及项目依赖，然后创建项目。
   ●
   ● 解压后，使用 IDEA 导入该 maven 工程：File->New->Model from Existing Source，然后选择解压后的项目文件夹即可。如果是使用 eclipse 的朋友，可以通过Import->Existing Maven Projects->Next，然后选择解压后的项目文件夹即可。
   2.3 maven配置
   创建了 Spring Boot 项目之后，需要进行 maven 配置。打开File->settings，搜索 maven，配置一下本地的 maven 信息。如下：

在 Maven home directory 中选择本地 Maven 的安装路径；在 User settings file 中选择本地 Maven 的配置文件所在路径。在配置文件中，我们配置一下国内阿里的镜像，这样在下载 maven 依赖时，速度很快。

nexus-aliyun
*
Nexus aliyun
http://maven.aliyun.com/nexus/content/groups/public

如果是使用 eclipse 的朋友，可以通过window-->preference-->Maven-->User Settings来配置，配置方式和上面一致。
2.4 编码配置
同样地，新建项目后，我们一般都需要配置编码，这点非常重要，很多初学者都会忘记这一步，所以要养成良好的习惯。
IDEA 中，仍然是打开File->settings，搜索 encoding，配置一下本地的编码信息。如下：

如果是使用 eclipse 的朋友，有两个地方需要设置一下编码：
● window--> perferences-->General-->Workspace，将Text file encoding改成utf-8
● window-->perferences-->General-->content types，选中Text，将Default encoding填入utf-8
OK，编码设置完成即可启动项目工程了。

1. Spring Boot 项目工程结构
   Spring Boot 项目总共有三个模块，如下图所示：

● src/main/java路径：主要编写业务程序
● src/main/resources路径：存放静态文件和配置文件
● src/test/java路径：主要编写测试程序
默认情况下，如上图所示会创建一个启动类 Course01Application，该类上面有个@SpringBootApplication注解，该启动类中有个 main 方法，没错，Spring Boot 启动只要运行该 main 方法即可，非常方便。另外，Spring Boot 内部集成了 tomcat，不需要我们人为手动去配置 tomcat，开发者只需要关注具体的业务逻辑即可。
到此为止，Spring Boot 就启动成功了，为了比较清楚的看到效果，我们写一个 Controller 来测试一下，如下：
package com.itcodai.course01.controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
@RestController
@RequestMapping("/start")
public class StartController {
@RequestMapping("/springboot")
public String startSpringBoot() {
return "Welcome to the world of Spring Boot!";
}
}
重新运行 main 方法启动项目，在浏览器中输入 localhost:8080/start/springboot，如果看到 “Welcome to the world of Spring Boot!”，那么恭喜你项目启动成功！Spring Boot 就是这么简单方便！端口号默认是8080，如果想要修改，可以在 application.yml 文件中使用 server.port 来人为指定端口，如8001端口：
server:
port: 8001

1. 总结
   本节我们快速学习了如何在 IDEA 中导入 jdk，以及使用 IDEA 如何配置 maven 和编码，如何快速的创建和启动 Spring Boot 工程。IDEA 对 Spring Boot 的支持非常友好，建议大家使用 IDEA 进行 Spring Boot 的开发，从下一课开始，我们真正进入 Spring Boot 的学习中。课程源代码下载地址：戳我下载
   第02课：Spring Boot返回Json数据及数据封装
   在项目开发中，接口与接口之间，前后端之间数据的传输都使用 Json 格式，在 Spring Boot 中，接口返回 Json 格式的数据很简单，在 Controller 中使用@RestController注解即可返回 Json 格式的数据，@RestController也是 Spring Boot 新增的一个注解，我们点进去看一下该注解都包含了哪些东西。
   @Target({ElementType.TYPE})
   @Retention(RetentionPolicy.RUNTIME)
   @Documented
   @Controller
   @ResponseBody
   public @interface RestController {
   String value() default "";
   }
   可以看出， @RestController 注解包含了原来的 @Controller 和 @ResponseBody 注解，使用过 Spring 的朋友对 @Controller 注解已经非常了解了，这里不再赘述， @ResponseBody 注解是将返回的数据结构转换为 Json 格式。所以在默认情况下，使用了 @RestController 注解即可将返回的数据结构转换成 Json 格式，Spring Boot 中默认使用的 Json 解析技术框架是 jackson。我们点开 pom.xml 中的 spring-boot-starter-web 依赖，可以看到一个 spring-boot-starter-json 依赖：
   
   org.springframework.boot
   spring-boot-starter-json
   2.0.3.RELEASE
   compile
   
   Spring Boot 中对依赖都做了很好的封装，可以看到很多 spring-boot-starter-xxx 系列的依赖，这是 Spring Boot 的特点之一，不需要人为去引入很多相关的依赖了，starter-xxx 系列直接都包含了所必要的依赖，所以我们再次点进去上面这个 spring-boot-starter-json 依赖，可以看到：
   
   com.fasterxml.jackson.core
   jackson-databind
   2.9.6
   compile
   
   
   com.fasterxml.jackson.datatype
   jackson-datatype-jdk8
   2.9.6
   compile
   
   
   com.fasterxml.jackson.datatype
   jackson-datatype-jsr310
   2.9.6
   compile
   
   
   com.fasterxml.jackson.module
   jackson-module-parameter-names
   2.9.6
   compile
   
   到此为止，我们知道了 Spring Boot 中默认使用的 json 解析框架是 jackson。下面我们看一下默认的 jackson 框架对常用数据类型的转 Json 处理。
2. Spring Boot 默认对Json的处理
   在实际项目中，常用的数据结构无非有类对象、List对象、Map对象，我们看一下默认的 jackson 框架对这三个常用的数据结构转成 json 后的格式如何。
   1.1 创建 User 实体类
   为了测试，我们需要创建一个实体类，这里我们就用 User 来演示。
   public class User {
   private Long id;
   private String username;
   private String password;
   / 省略get、set和带参构造方法 /
   }
   1.2 创建Controller类
   然后我们创建一个 Controller，分别返回 User对象、List 和 Map。
   import com.itcodai.course02.entity.User;
   import org.springframework.web.bind.annotation.RequestMapping;
   import org.springframework.web.bind.annotation.RestController;
   import java.util.ArrayList;
   import java.util.HashMap;
   import java.util.List;
   import java.util.Map;
   @RestController
   @RequestMapping("/json")
   public class JsonController {
   @RequestMapping("/user")
   public User getUser() {

    return new User(1, "倪升武", "123456");
   

   }
   @RequestMapping("/list")
   public List getUserList() {

    List<User> userList = new ArrayList<>();
    User user1 = new User(1, "倪升武", "123456");
    User user2 = new User(2, "达人课", "123456");
    userList.add(user1);
    userList.add(user2);
    return userList;
   

   }
   @RequestMapping("/map")
   public Map getMap() {

    Map<String, Object> map = new HashMap<>(3);
    User user = new User(1, "倪升武", "123456");
    map.put("作者信息", user);
    map.put("博客地址", "http://blog.itcodai.com");
    map.put("CSDN地址", "http://blog.csdn.net/eson_15");
    map.put("粉丝数量", 4153);
    return map;
   

   }
   }
   1.3 测试不同数据类型返回的json
   OK，写好了接口，分别返回了一个 User 对象、一个 List 集合和一个 Map 集合，其中 Map 集合中的 value 存的是不同的数据类型。接下来我们依次来测试一下效果。
   在浏览器中输入：localhost:8080/json/user 返回 json 如下：
   {"id":1,"username":"倪升武","password":"123456"}
   在浏览器中输入：localhost:8080/json/list 返回 json 如下：
   [{"id":1,"username":"倪升武","password":"123456"},{"id":2,"username":"达人课","password":"123456"}]
   在浏览器中输入：localhost:8080/json/map 返回 json 如下：
   {"作者信息":{"id":1,"username":"倪升武","password":"123456"},"CSDN地址":"http://blog.csdn.net/eson_15","粉丝数量":4153,"博客地址":"http://blog.itcodai.com"}
   可以看出，map 中不管是什么数据类型，都可以转成相应的 json 格式，这样就非常方便。
   1.4 jackson 中对null的处理
   在实际项目中，我们难免会遇到一些 null 值出现，我们转 json 时，是不希望有这些 null 出现的，比如我们期望所有的 null 在转 json 时都变成 "" 这种空字符串，那怎么做呢？在 Spring Boot 中，我们做一下配置即可，新建一个 jackson 的配置类：
   import com.fasterxml.jackson.core.JsonGenerator;
   import com.fasterxml.jackson.databind.JsonSerializer;
   import com.fasterxml.jackson.databind.ObjectMapper;
   import com.fasterxml.jackson.databind.SerializerProvider;
   import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
   import org.springframework.context.annotation.Bean;
   import org.springframework.context.annotation.Configuration;
   import org.springframework.context.annotation.Primary;
   import org.springframework.http.converter.json.Jackson2ObjectMapperBuilder;
   import java.io.IOException;
   @Configuration
   public class JacksonConfig {
   @Bean
   @Primary
   @ConditionalOnMissingBean(ObjectMapper.class)
   public ObjectMapper jacksonObjectMapper(Jackson2ObjectMapperBuilder builder) {

    ObjectMapper objectMapper = builder.createXmlMapper(false).build();
    objectMapper.getSerializerProvider().setNullValueSerializer(new JsonSerializer<Object>() {
        @Override
        public void serialize(Object o, JsonGenerator jsonGenerator, SerializerProvider serializerProvider) throws IOException {
            jsonGenerator.writeString("");
        }
    });
    return objectMapper;
   

   }
   }