[Java知识库]SpringBoot学习

1. SpringBoot简介

1.1 什么是SpringBoot

一个JavaWeb开发框架，和SpringMVC类似，相比其他JavaWeb框架的好处是简化开发，约定大于配置。SpringBoot完全抛弃了繁琐的xml配置过程，采用大量的默认配置简化了我们的开发过程。

1.2 SpringBoot的特性

• 能够快速创建基于Spring的应用程序
• 能够直接使用main方法启动内嵌的Tomcat服务器运行SpringBoot程序，不需要部署war包文件
• 提供约定的starter POM来简化Maven配置
• 自动化配置，根据项目的Maven依赖配置，SpringBoot自动配置Spring、SpringMVC等
• 基本完全不使用xml文件，采用注解配置
• 提供了程序的健康检查等功能

1.3 什么是微服务

微服务是一种架构风格，它要求我们在开发一个应用的时候，这个应用必须构建成一系列小服务的组合。

1.4 第一个SpringBoot程序

创建步骤

• 创建新项目
• 选择Spring Initializr
• 添加Spring Web
  
  @SpringBootApplication注解用于开启spring配置，它会扫描下面的所有spring注解。
  在pom文件中
  

SpringBoot项目代码必须放到Application类（启动入口类）所在的同级目录或下级目录

启动程序后，在网页中输入localhost:8080/hello，即可展示出hello
注：@ResponseBody的作用其实是将java对象转为json格式的数据。
@responseBody注解的作用是将controller的方法返回的对象通过适当的转换器转换为指定的格式之后，写入到response对象的body区，通常用来返回JSON数据或者是XML数据。
注意：在使用此注解之后不会再走视图处理器，而是直接将数据写入到输入流中，他的效果等同于通过response对象输出指定格式的数据。
@ResponseBody是作用在方法上的，@ResponseBody 表示该方法的返回结果直接写入 HTTP response body 中，一般在异步获取数据时使用【也就是AJAX】。
在使用 @RequestMapping后，返回值通常解析为跳转路径，但是加上 @ResponseBody 后返回结果不会被解析为跳转路径，而是直接写入 HTTP response body 中。 比如异步获取 json 数据，加上 @ResponseBody 后，会直接返回 json 数据。@RequestBody 将 HTTP 请求正文插入方法中，使用适合的 HttpMessageConverter 将请求体写入某个对象。

1.5 核心配置文件application.properties

一个SpringBoot项目中只能有一个核心配置文件
所有的配置，只要不使用默认值，通通都要在这个配置文件中设置

此时需要在网页输入 localhost:8081/springboot/xx方法，才能访问到xx方法

1.6 第二种核心配置文件application.yml或application.yaml

与application.properties效果相同，只不过格式不同

如果核心配置文件application.properties和application.yaml或application.yml同时存在，则会优先选择application.properties中的配置。properties优先级更高！

1.7 多环境下核心配置文件的使用

工作中开发的环境有：开发环境，测试环境，准生产环境，生产环境
在不同环境下，配置文件也不同，频繁修改会较复杂，因此采用调用的方式。

yml或yaml与properties类似，是创建application-dev.yml，application-test.yml,…

1.8 SpringBoot在application.properties中的自定义配置（@Value）

1.8.1 方式一：一个值一个值的获取

例如在核心配置文件中有如下自定义配置

在程序的任意位置可通过 @Value 注解进行获取，即每一个@Value得到一个值。

1.8.2 方式二：将自定义配置映射到一个对象

首先在配置文件定义如下自定义配置，两个对象，school和abc

然后分别创建两个对象所对应的类，下面列举school类

package com.liu.controller.config;

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

@Controller // school类放进spring容器中进行管理
@ConfigurationProperties(prefix = "school") //将此类设置为配置类，并加上前缀，指明对象
public class school {
    private String name;
    private String website;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getWebsite() {
        return website;
    }

    public void setWebsite(String website) {
        this.website = website;
    }
}

然后便可通过注入（@Autowired）来使用这个对象

    @Autowired
    private school school; //从spring容器中取出school对象
    

    @RequestMapping("/say")  //设置这个方法的请求路径
    @ResponseBody
    public String say(){
        return "say: Hello " + school.getName() + "     " + school.getWebsite();
    }

这种方式在运用时，自定义配置参数必须要有前缀，即a.b型。

注：解决使用@ConfigurationProperties注解出现的警告问题

  <!--   解决使用@ConfigurationProperties注解出现的警告问题-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-configuration-processor</artifactId>
    <optional>true</optional>
</dependency>

1.9 SpringBoot集成JSP

首先考虑jsp存放的位置，之前放哪，现在仍放哪。在main文件夹下建立webapp文件夹。然后在项目结构中设置web资源文件夹。设置完之后点击Artifact，然后应用。

SpringBoot官方推荐使用的前端页面是Thymeleaf，如果使用Thymeleaf就可以直接使用，如果使用其他的就要单独做集成，在pom文件中添加依赖

<!-- 引入SpringBoot内嵌tomcat对jsp的解析依赖 -->
<!-- 仅仅只是展示jsp页面，只添加以下一个依赖, 若是jstl等，则另加依赖 -->
<dependency>
    <groupId>org.apache.tomcat.embed</groupId>
    <artifactId>tomcat-embed-jasper</artifactId>
</dependency>

在build中添加resources

<!--    SpringBoot项目默认推荐使用的前端引擎是thymeleaf
        现在我们要使用springboot集成jsp，需手动指定jsp最后编译的路径
        而且springboot集成jsp编译jsp的路径是springboot规定好的位置：
        META-INF/resources
-->
<resources>
    <resource>
        <!--源文件夹 -->
        <directory>src/main/webapp</directory>
        <!--指定编译到META-INF/resources -->
        <targetPath>META-INF/resources</targetPath>
        <!--指定源文件夹中的哪个资源要编译进行，这里是所有资源 -->
        <includes>
            <include>*.*</include>
        </includes>
    </resource>
</resources>

最后需要在application.properties中配置视图解析器

配置完成后，使用方式如下：
1.在webapp下新建一个jsp文件

2.在Controller中创建IndexController（方式一）

方式二

2. SpringBoot框架web开发

2.1 SpringBoot集成Mybatis

在pom文件中添加mybatis依赖，mysql驱动

<!--MySQL驱动-->
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <!-- 可通过version设置版本号 -->
</dependency>

<!--MyBatis整合SpringBoot框架的起步依赖-->
<dependency>
    <groupId>org.mybatis.spring.boot</groupId>
    <artifactId>mybatis-spring-boot-starter</artifactId>
    <version>2.0.0</version>
</dependency>

一般情况下我们都需要书写这两个包

但现在可以不用写，采用MyBatis提供的逆向工程来生成实体bean，映射文件mapper，Dao接口。也就是根据数据库自动生成，非常方便。步骤如下：

1. 在项目根目录下新建GeneratorMapper.xml文件
   把如下内容填入进去(00处修改驱动所在位置，11处修改jdbc连接，22处修改包名，33处修改表名、实体类名)

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE generatorConfiguration
        PUBLIC "-//mybatis.org//DTD MyBatis Generator Configuration 1.0//EN"
        "http://mybatis.org/dtd/mybatis-generator-config_1_0.dtd">
<generatorConfiguration>

    <!-- 00-->
    <!-- 指定连接数据库的 JDBC 驱动包所在位置，指定到你本机的完整路径，也就是maven中的jdbc包 -->
    <classPathEntry location="D:\all_Java_Environment\apache-maven-3.8.3\maven-repo\mysql\mysql-connector-java\8.0.28\mysql-connector-java-8.0.28.jar"/>
    <!-- 配置 table 表信息内容体，targetRuntime 指定采用 MyBatis3 的版本 -->
    <context id="tables" targetRuntime="MyBatis3">
        <!-- 抑制生成注释，由于生成的注释都是英文的，可以不让它生成 -->
        <commentGenerator>
            <property name="suppressAllComments" value="true" />
        </commentGenerator>
        <!-- 11 -->
        <!-- 配置数据库连接信息 -->
        <jdbcConnection driverClass="com.mysql.jdbc.Driver"
                        connectionURL="jdbc:mysql://localhost:3306/springboot"
                        userId="root"
                        password="root">
        </jdbcConnection>
        <!-- 22  实体类-->
        <!-- 生成 model 类，targetPackage 指定 model 类的包名， targetProject 指定
       生成的 model 放在 eclipse 的哪个工程下面-->
        <javaModelGenerator targetPackage="com.liu.pojo"
                            targetProject="src/main/java">
            <property name="enableSubPackages" value="false" />
            <property name="trimStrings" value="false" />
        </javaModelGenerator>
        <!-- 22  Mapper.xml文件-->
        <!-- 生成 MyBatis 的 Mapper.xml 文件，targetPackage 指定 mapper.xml 文件的
       包名， targetProject 指定生成的 mapper.xml 放在 eclipse 的哪个工程下面 -->
        <sqlMapGenerator targetPackage="com.liu.mapper"
                         targetProject="src/main/java">
            <property name="enableSubPackages" value="false" />
        </sqlMapGenerator>
        <!-- 22  Mapper接口文件-->
        <!-- 生成 MyBatis 的 Mapper 接口类文件,targetPackage 指定 Mapper 接口类的包
       名， targetProject 指定生成的 Mapper 接口放在 eclipse 的哪个工程下面 -->
        <javaClientGenerator type="XMLMAPPER"
                             targetPackage="com.liu.mapper"
                             targetProject="src/main/java">
            <property name="enableSubPackages" value="false" />
        </javaClientGenerator>

        <!-- 33-->
        <!-- 数据库表名及对应的 Java 模型类名 (第一行前后两个分别是 表名 和 实体类名 )
			数据库中有多少个表就要配对应数量的table
		-->
        <table tableName="t_student" domainObjectName="Student"
               enableCountByExample="false"
               enableUpdateByExample="false"
               enableDeleteByExample="false"
               enableSelectByExample="false"
               selectByExampleQueryId="false"/>
    </context>
</generatorConfiguration>

2. 在pom文件中添加一个插件

<!--mybatis 代码自动生成插件-->
<plugin>
    <groupId>org.mybatis.generator</groupId>
    <artifactId>mybatis-generator-maven-plugin</artifactId>
    <version>1.3.6</version>
    <configuration>
        <!--配置文件的位置-->
        <configurationFile>GeneratorMapper.xml</configurationFile>
        <verbose>true</verbose>
        <overwrite>true</overwrite>
    </configuration>
</plugin>

3. 双击生成
   
   生成过后，Dao接口 StudentMapper：
   
   映射文件StudentMapper：

2.1.1 小案例

通过网页输入id号，查询用户信息
操作步骤是控制层（Controller） -> 业务层（Service） -> Dao层（Mapper）
控制层：
需添加@Controller注解

通过alt + enter 键可以快速创建service包，并创建StudentService接口。在StudentService接口中仍通过alt + enter 键可以快速创建接口实现类，并实现对应方法。
业务层：
需添加@Service注解

Dao层：
需添加@Mapper注解（或采取下面会提出的@MapperScan方式）

以上操作完成之后，还需在pom文件中添加resources。原因是main下的java文件夹中只解析java文件，xml文件由resources文件下进行解析，而规定的Mapper.xml文件必须与Dao接口放在一起，因此需要添加此步让java文件夹下的所有xml文件都得到解析。（这是第一种方式，后面还有第二种）

 <resource>
     <directory>src/main/java</directory>
     <includes>
         <include>**/*.xml</include>
     </includes>
 </resource>

application.properties配置文件中设置连接数据库的信息

spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver //数据库8.版本需要加上cj
spring.datasource.url=jdbc:mysql://localhost:3306/springboot?useUnicode=true&characterEncoding=UTF-8&useJDBCCompliantTimezoneShift=true&useLegacyDatetimeCode=false&serverTimezone=GMT%2B8
spring.datasource.username=root
spring.datasource.password=root

运行即可进行测试。

Mapper接口这里要加@Mapper注解，service接口实现类这里要加@Service注解
可以对mapper包里的每一个接口都加一个@Mapper注解，也可以直接在启动入口类那里加一个总的注解 @MapperScan(basePackages = “com.liu.mapper”)

Mapper映射文件存放位置方式二
将java文件夹下的xml资源文件，放到resources下面的mapper文件夹（自己创建）
然后在application.properties中指定MyBatis映射文件（Mapper）的路径：

# 指定MyBatis映射文件的路径(这里面classpath:指的是resources文件夹)
# (下面这句话的意思就是resources文件夹下mapper文件夹下的所有.xml文件)
mybatis.mapper-locations=classpath:mapper/*.xml
# 下面这个也可以加上,关于别名的(后面是实体类路径)
mybatis.type-aliases-package=com.liu.pojo

2.1.2 总结

SpringBoot集成Mybatis，最主要的是两个注解@Mapper，@MapperScan
@Mapper 需要在每一个Mapper接口类上添加，作用是扫描Dao接口，放进spring容器中
@MapperScan 是在SpringBoot启动入口类上添加的，它是扫描所有的包

关于Mapper映射文件存放位置的写法有以下两种：

1. 将Mapper接口和Mapper映射文件存放到src/main/java同一目录下，然后在pom文件中手动指定资源文件夹路径resources
2. 将Mapper接口和Mapper映射文件分开存放，Mapper接口类存放到src/main/java目录下，Mapper映射文件存放到resources(类路径)目录下自己新建的mapper文件夹下，在application.properties中指定mapper映射文件的存放位置。

2.2 SpringBoot下使用事务

事务是一个完整的功能，也叫做一个完整的业务
事务只跟DML语句有关系：即增删改
使用事务功能只需要在相应方法上加上@Transactional注解就行了
Controller层

Service层

2.3 SpringBoot常用注解

@RestController

@GetMapping

@PostMapping

@DeleteMapping

@PutMapping

2.4 RESTFull风格

2.5 SpringBoot集成Redis

a.添加操作redis数据类型的依赖

在这里插入代码片<!-- SpringBoot集成Redis的起步依赖 -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>

b.在SpringBoot核心配置文件中添加redis的配置

// 设置redis配置信息，连接自己本机的redis
spring.redis.host=
spring.redis.port=
spring.redis.password=

设置完之后，在操作时是通过此语句进行数据操作

@Autowired
private RedisTemplate<Object, Object> redisTemplate;

插入数据

取数据

2.6 SpringBoot集成Dubbo分布式框架

相当于是几个工程间通信
首先需要创建三个工程
a. 接口工程：存放实体bean（即对象）和业务接口（建立一个maven工程，用于存放接口）
b.服务提供者：存放业务接口的实现类并将服务暴露且注册到注册中心，调用数据持久层（即Dao层也在服务提供者书写）（建立一个springboot工程，实现接口工程中的接口）

• 添加依赖：dubbo，注册中心，接口工程
• 配置服务提供者的核心配置文件

c.服务消费者：处理浏览器客户端发送的请求，从注册中心调用服务提供者所提供的服务（即实现类）（建立一个springboot工程，是对业务的实现）

• 添加依赖：dubbo，注册中心，接口工程
• 配置服务消费者的核心配置文件

详细内容

1. 在服务提供者pom文件中添加依赖

<!-- dubbo集成springboot框架起步依赖，dubbo主导 -->
<dependency>
    <groupId>com.alibaba.spring.boot</groupId>
    <artifactId>dubbo-spring-boot-starter</artifactId>
    <version>2.0.0</version>
</dependency>
<!-- 注册中心 -->
<dependency>
    <groupId>com.101tec</groupId>
    <artifactId>zkclient</artifactId>
    <version>0.10</version>
</dependency>
<!-- 接口工程，引入接口-->
<dependency>
    <groupId>com.liu</groupId>
    <artifactId>springboot-dubbo-interface</artifactId>
    <version>1.0.0</version>
</dependency>

2. 在服务提供者核心配置文件中配置信息

# 设置内嵌Tomcat端口号
server.port=8080
# 设置上下文根
server.servlet.context-path=/
# 设置dubbo的配置
spring.application.name=springboot-dubbo-provider
# 当前工程是一个服务提供者
spring.dubbo.server=true
# 设置注册中心
spring.dubbo.registry=zookeeper://localhost:3306

3. 在服务消费者中添加依赖，同服务提供者
4. 在服务消费者核心配置文件中配置信息

# 设置内嵌Tomcat端口号
server.port=8080
# 设置上下文根
server.servlet.context-path=/
# 设置dubbo的配置
spring.application.name=springboot-dubbo-consumer
# 设置注册中心
spring.dubbo.registry=zookeeper://localhost:3306

基本流程是，先在服务消费者的controller包下创建一个StudentController类，然后调用一个Service层的方法，此方法的接口放在接口工程中的service包下，此方法的实现类放在服务提供者的service包下。

相关注解：
在服务提供者中，实现类需要加注解@Component 和@Service。

在服务消费者中，控制层类里面加注解@Reference

在服务提供者和服务消费者的启动类前都要加注解@EnableDubboConfiguration

2.7 SpringBoot集成Dubbo，Redis，MyBatis，Spring，SpringMVC，JSP

前面知识的总和，还是三个工程

• 接口工程：存放实体类bean和业务接口（service的接口）
• 服务提供者：它是一个springboot框架web项目，集成mybatis，redis。说白了是存放业务接口实现类和mapper接口及mapper.xml文件
  • 添加依赖：mybatis依赖，mysql驱动依赖，dubbo依赖，zookeeper依赖，redis依赖，接口工程
  • 配置springboot核心配置文件
    • 配置连接数据库
    • 配置连接redis
    • 配置dubbo
• 服务消费者：它是一个springboot框架web项目，集成jsp，dubbo。说白了就是存放控制层和jsp页面。
  • 添加依赖：dubbo依赖，zookeeper依赖，解析jsp页面的依赖，接口工程
  • 配置springboot核心配置文件
    • 配置视图解析器
    • 配置dubbo

2.8 SpringBoot创建非web工程

创建时不勾选spring web即可
非web工程无法按照原先从spring容器注入的方式直接操纵业务方法。只能采取如下方式。
方式一：

方式二：
实现CommandLineRuner，重写run方法。通过此方式可实现从spring容器中注入并操纵方法。

2.9 修改工程的启动Logo

在resource文件夹下新建一个 banner.txt ，把内容贴进去即可。
可以利用网站生成图标：链接

2.10 SpringBoot使用拦截器

a.定义一个拦截器，实现HandlerInterceptor接口

b.再创建一个配置类。（相当于原来的在springmvc配置文件中使用mvc:interceptors标签，只不过现在改成了配置类）

控制层测试代码：

@Controller
@RequestMapping(value = "/user")  // 访问请求时统一带着此前缀
public class UserController {

    //该请求不登陆也可访问
    @RequestMapping(value = "/login")
    public @ResponseBody Object login(HttpServletRequest request){
        // 将用户的信息存放到session中
        User user = new User();
        user.setId(1001);
        user.setName("zhangsan");
        request.getSession().setAttribute("user",user);
        return "login SUCCESS";
    }

    // 该请求需要用户登录之后才能访问
    @RequestMapping(value = "/center")
    public @ResponseBody Object center(){
        return "See Center Message";
    }
    // 该请求不登陆也可访问
    @RequestMapping(value = "/out")
    public @ResponseBody Object out(){
        return "Out";
    }
    // 该请求不登陆也可访问，如果用户未登录但访问了需要登录才能访问的请求，会跳转到此路径
    @RequestMapping(value = "/error")
    public @ResponseBody Object error(){
        return "Error";
    }
}

2.11 SpringBoot使用Servlet（了解）

原先方式：

• 创建一个servlet它要继承HttpServlet
• 在web.xml配置文件中使用servlet servlet-mapping

现在的方式：
方式一（Servlet类上加一个注解，入口启动类加一个注解）：

• @WebServlet(urlPatterns = “”),
• @ServletComponentScan(basePackages = “”)
  
  

方式二：不使用注解，通过配置类的方式

2.12 SpringBoot使用过滤器Filter

也是有两种方式，与使用Servlet时的两种方式相同。
方式一：注解方式
在建立的filter类上使用注解@WebFilter(urlPatterns = “”)， 并在启动类使用注解@ServletComponentScan(basePackages = “”)


方式二：不使用注解，通过配置类的方式


注意在书写过滤路径时，**不代表子包不会生效，单个*才代表子包。

2.13 SpringBoot设置字符编码

首先在servlet中设置浏览器的编码格式

然后在核心配置文件中添加如下内容，即可显示中文。

# 设置请求相应字符编码
server.servlet.encoding.enabled=true
server.servlet.encoding.force=true
server.servlet.encoding.charset=utf-8

2.14 SpringBoot打war包

war包端口号和上下文根是以内嵌Tomcat为准.

1. 在.pom文件中加以下代码:
   在gva坐标前写：

   <!--修改打包方式-->
   <packaging>war</packaging>
   

   在build中写：

   <!--指定打war包的字符,  名字可以自己来取-->
   <finalName>SpringBootWar</finalName>
   

2. 在入口类中继承SpringBootServletInitializer类
   

3. 在Meven中双击package即可
   

开发者涨薪指南

48位大咖的思考法则、工作方式、逻辑体系