SpringBoot

基础：

1，创建SpringBoot的方法：

1，基于idea自己创建

2，基于SpringBoot官网创建

3，基于将idea中SpringBoot官网改为阿里云网站创建

4，使用maven工程仿建

2，Idea中隐藏指定文件或指定类型文件

Setting+File Types->Ignored Files and Folders

输入要隐藏的文件名，支持*号文件

3，统一springboot的版中依赖，插件的版本

spring boot的官网中统一版本

继承parent模块可以避免多个依赖使用相同技术时出现依赖版本冲突

内对应完整的版本信息，和坐标引用信息；

阿里云中的继承

继承parent的形式也可以采用引入依赖的形式实现效果

<dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-dependencies</artifactId>
            <version>${spring-boot.version}</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
    </dependencies>
</dependencyManagement>

<artifactId>spring-boot-starter</artifactId>

定义当前项目的依赖坐标，减少依赖配置

4，内置服务器

tomcat 默认，jetty，undertow

内嵌tomcat工作原理是将tomcat服务器作为对象运行，并将该对象交给Spring容器管理

5，rest风格

6，基础配置

属性配置

配置文件分类

优先级从上至下依次变低

application.properties

application.yml

application.yaml

不同配置文件中相同配置按照优先级相互覆盖，不同配置文件中不同配置全部保留

yaml文件

yaml语法规则：

字面值表示方式：

boolean:TRUE
#TRUE,true,True,FALSE,false,False均可
f1oat:3.14
#6.8523015e+5#支持科学计数法
int:123
#0b10100111010010101110
#支持二进制、八进制、十六进制
nu11:~
#使用表示muL(
string:HelloWorld
#字符串可以直接书写
string2:"Hello World"
#可以使用双引号包裹特殊字符
date:2018-02-17
#日期必须使用yyyy-MM-dd格式
datetime:2018-02-17T15:02:31+08:00#时间和日期之间使用T连接，最后使用+代表时区

1.yaml语法规则
大小写敏感
属性层级关系使用多行描述，每行结尾使用冒号结束
使用缩进表示层级关系，同层级左侧对齐，只允许使用空格（不允许
使用Tab键)
●
属性值前面添加空格（属性名与属性值之间使用冒号+空格作为分隔）
。#表示注释
2.注意属性名冒号后面与数据之间有一个空格
3.字面值、对象数据格式、数组数据格式（略)

yml数据读取

1,使用Environment对象封装全部配置信息
2.使用@Autowired自动装配数据到Environment对象中

@Value("${country}")
private String country1;
@Value("${user.name1}")
private String name;
@Value("${user.age}")
private int age;
@Value("${tempDir}")
private String tempDir;
//使用自动装配将yml文件中所有的数据全部封装到下面的变量中
@Autowired
private Environment env;

7，整合第三方技术

test包整合junit

测试类

需要引导类（main包下）和测试类（test包下）在相同的包路径下

若不在：解决方案：@SpringBootTest(class=引导类)

或@ContextConfiguration(class=引导类)

总结：

1.测试类如果存在于引导类所在包或子包中无需指定引导类
2,测试类如果不存在于引导类所在的包或子包中需要通过c1 asses属
性指定引导类

1.导入测试对应的starter（pom.xml）
2,测试类使用测试类用@SpringBootTest修饰
3.使用自动装配注解的形式添加要测试的对象

boot整合mybatis

I,勾选MyBatis技术，也就是导入MyBatis对应的starter
2,数据库连接相关信息转换成配置（application中添加数据库信息）
3.数据库SQL映射需要添加@Mapper被容器识别到(Dao层)

当mysql版本为5时的调整：

1.MySQL8.X驱动强制要求设置时区
修改url,添加serverTimezone设定
修改MySOL数据库配置（略）】
2.驱动类过时，提醒更换为com.mysql..cj,jdbc.Driver

boot整合mybatis-plus:

与mybatis的区别：

1，导入坐标不同

2，数据层实现简化

使用mybatis-plus

1，在idea中使用官网

在下面的网址中搜索mybatis-plus找到后点进去，用3.4.3版本查找到坐标

https://mvnrepository.com

如下

<dependency> <groupId>com.baomidou</groupId> <artifactId>mybatis-plus-boot-starter</artifactId> <version>3.4.3</version> </dependency>

替换

<dependency>
    <groupId>org.mybatis.spring.boot</groupId>
    <artifactId>mybatis-spring-boot-starter</artifactId>
    <version>2.2.2</version>
</dependency>

2，使用阿里云

直接导入mybatis-plus

boot整合druid

1，先导入druid的坐标，即

<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>druid-spring-boot-starter</artifactId>
    <version>1.2.22</version>
</dependency>

2，再变更druid的配置方式

spring:
  datasource:
    druid:
      driver-class-name: com.mysql.cj.jdbc.Driver
      ur1:jdbc: mysq1://localhost:3306/ssm?serverTimezone=UTC
      username: root
      password: root

spring:
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://localhost:3306/ssm?serverTimezone=UTC
    username: root
    password: 11235813
    type: com.alibaba.druid.pool.DruidDataSource

基于SpringBoot的SSMP整合案例

1,手工导入starter坐标（2个)
2,配置数据源与MyBatisPlus对应的配置
3.开发Dao接口（继承BaseMapper<泛型>)
4.制作测试类测试Dao功能是否有效

为Mp开日志

# id-type: auto使用id自增策略
# 进行日志配置
#  configuration:
#    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl
mybatis-plus:
  global-config:
    db-config:
设置数据库表的前缀
      table-prefix: t_
      id-type: auto
  configuration:
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl

分页操作：

1，设置拦截器，作用：内部是动态的拼接sql语句，limit。。。

@Configuration
public class MPConfig {
    @Bean
    public MybatisPlusInterceptor mybatisPlusInterceptor(){
        MybatisPlusInterceptor interceptor=new MybatisPlusInterceptor();
        interceptor.addInnerInterceptor(new PaginationInnerInterceptor());
        return interceptor;
    }
}

测试类中

@Test
void testGetPage() {
    IPage page = new Page(1, 1);
    bookDao.selectPage(page, null);
    System.out.println(page.getPages());最大页码值
    System.out.println(page.getCurrent());当前页面
    System.out.println(page.getSize());每页展示多少，条
    System.out.println(page.getTotal());每页数据总量
    System.out.println(page.getRecords());数据总量
}

分页功能修改bug：

分页功能

wrapper条件查询：

@Test
void testGetBy(){
    QueryWrapper<Book> qw=new QueryWrapper<>();
    qw.like("book_name","界");
    bookDao.selectList(qw);
}
//使用Lambda表达式
@Test
void testGetBy1(){
    String name="界";
    LambdaQueryWrapper<Book> lqw=new LambdaQueryWrapper<>();
    //当外界传入那么需要判断name是否为空，否则查不到数据
   /* **if(name!=null) {
        lqw.like(Book::getBookName, "界");
    }***/
    lqw.like(Strings.isNotEmpty(name),Book::getBookName,"Spring");
    bookDao.selectList(lqw);
}

service层的快速开发 ：

1.使用通用接口(ISerivce<T>)快速开发Service
2,使用通用实现类（ServiceImpl<M,T>)快速开发ServiceImpl
3,如果接口提供的现成方法不能满足业务需求，可以在通用接口基础上做功能重载或功能追加
4,注意重载时不要覆盖原始操作，避免原始提供的功能丢失

前后端联调

前端发送异步请求，调用后端接口
//列表
getAll(){
axios.get("/books").then((res)=>{
console.log(res.data);
});
},

清除数据

//重置表单
resetForm(){
this.formData {}
},
//弹出添加窗口
handleCreate(){
this.dialogFormVisible true;
this.resetForm();
},

//添加
handleAdd ()
//发送异步请求
axios.post("/books",this.formData).then((res)=>{
//加架操作成功，关闭弹层，显示数据
if(res.data.flag){
this.dialogFormVisible false;
this.$message.success("添加成功")；
}else
this.$message.error("添加失败")；
}
}).fina11y(()=>{
this.getAll();
})
},

删除操作

其中then为成功操作

catch为删除操作

删除操作步骤

请求方式使用Delete调用后台对应操作
删除操作需要传递当前行数据对应的1d值到后台
删除操作结束后动态刷新页面加载数据
根据操作结果不同，显示对应的提示信息
删除操作前弹出提示框避免误操作

修改功能

修改功能

同一将执行成功与否的信息交由后台代码执行 ：

业务层接口功能开发：

控制层中的分页条件查寻

项目中的异常处理配置：

import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.RestControllerAdvice;
//作为springmvc的异常处理器
//@ControllerAdvice
@RestControllerAdvice
public class ProjectExceptionAdvice {
    //拦截所有的异常信息
    @ExceptionHandler(Exception.class)
    public R doException(Exception ex){
        //记录日志
        //通知运维
        //通知开发
        //下面的一段代码，防止万一出异常了，控制台还有信息，必不可少
        ex.printStackTrace();**//打印出异常**
        return new R("服务器异常，请稍后重试！");
    }
}

运维实用篇

命令提示符窗口显示没有主清单属性

没有加入maven的插件
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
<version>${spring-boot.version}</version>
<configuration>
<mainClass>com.itheima.SSMP.SsmpApplication</mainClass>
<skip>false</skip>
<layout>JAR</layout>
</configuration>
<executions>
<execution>
<id>repackage</id>
<goals>
<goal>repackage</goal>
</goals>
</execution>
</executions>
</plugin>

BOOT-INF文件

jar包描述文件(MANIFEST.MF)
普通工程
Manifest-Version:1.0
Implementation-Title:springboot 08 ssmp
Implementation-Version:0.0.1-SNAPSHOT
Build-Jdk-Spec:1.8
Created-By:Maven Jar Plugin 3.2.0
基于spring-boot-maven-plugin打包的工程
Manifest-Version:1.0
Spring-Boot-Classpath-Index:BOOT-INF/classpath.idx
Implementation-Title:springboot_08_ssmp
Implementation-Version:0.0.1-SNAPSHOT
Spring-Boot-Layers-Index:BOOT-INF/layers.idx
Start-Class:com.itheima.SSMPApplication
Spring-Boot-Classes:BOOT-INF/classes/
Spring-Boot-Lib:BOOT-INF/1ib/
Build-Jdk-Spec:1.8
Spring-Boot-Version:2.5.4
Created-By:Maven Jar Plugin 3.2.0
Main-Class:org.springframework.boot.loader.JarLauncher//jar启动器

Windonws端口被占用

命令行启动常见问题及解决方案
Windonws端口被占用
#查询端口
netstat -ano
#查询指定端口
netstat-ano | findstr "端口号"
#根据进程PID查询进程名称
tasklist |findstr"进程PID号"
#根据PID杀死任务
taskkill -F -pid"进程PID号"
#根据进程名称杀死任务
taskkill -f -t -im"进程名称"//任务名称

临时属性：

配置临时端口：

1,使用jar命令启动SpringBoot工程时可以使用临时属性替换配置文件
中的属性
2,临时属性添加方式：java -jar工程名.jar-属性名=值
3,多个临时属性之间使用空格分隔
4.临时属性必须是当前boot工程支持的属性，否则设置无效

springboot项目在linux系统中启动：

配置文件分类：

1.SpringBoot中4级配置文件

1级：file:config./application.yml【最高】
2级：file:application.yml
3级：classpath:config/application.yml
4级：classpath:application.yml【最低】

2.作用：

1级与2级留做系统打包后设置通用属性，1级常用于运维经理进行线上整体项目部署方案调控
3级与4级用于系统开发阶段设置通用属性，3级常用于项目经理进行整体项目属性调控

自定义配置文件：

1，文件的名字

properties和yml文件均支持

2，文件的路径

支持写多个配置文件的格式 ，优先级：最后的配置优先

自定义配置文件总结：

1.配置文件可以修改名称，通过启动参数设定
2,配置文件可以修改路径，通过启动参数设定
3,微服务开发中配置文件通过配置中心进行设置

1.SpringBoot在开发和运行环境均支持使用临时参数修改工程配置
2.SpringBoot.支持4级配置文件，应用于开发与线上环境进行配置的灵
活设置
3,SpringBoot支持使用自定义配置文件的形式修改配置文件存储位置
4,基于微服务开发时配置文件将使用配置中心进行管理

springboot多环境开发：

1.多环境开发需要设置若干种常用环境，例如开发、生产、测试环境
2.yaml格式中设置多环境使用---区分环境设置边界
3.每种环境的区别在于加载的配置属性不同
4.启用某种环境时需要指定启动时使用该环境

防止配置泄露：测试，开发，生产分开配置

多环境分组管理 ：

常用的方法

使用include属性在激活指定环境的情况下，同时对多个环境进行加载使其生效，多个环境间使用逗号分隔

注意：

当主环境dev与其他环境有相同属性时，主环境属性生效；其他环境中有相同属性时，最后加载的环境属性生效

# 不常用                         
#spring:
#  profiles:
#    active: dev
#    include: devMVC,devDB

便于线上维护管理

spring:
  profiles:
    active: dev
    group:
      "dev": devDB,devMVC
      "pro": proDB,proMVC

多环境开发控制：

注意：在pom.xml中当改变活动文件dev为pro时clean还无法改变时，使用maven中的compile手工执行compoile加载文件，才可以切换

<!--    设置多环境-->
    <profiles>
        <profile>
            <id>env_dev</id>
            <properties>
                <profile.active>dev</profile.active>
            </properties>
            <activation>
                <activeByDefault>true</activeByDefault>
            </activation>
        </profile>
        <profile>
            <id>env_pro</id>
            <properties>
                <profile.active>pro</profile.active>
            </properties>
        </profile>
    </profiles>

1,当Maven与SpringBoot同时对多环境进行控制时，以Mavn为主，
SpringBoot使用@.，@占位符读取Maven对应的配置属性值
2.基于SpringBoot读取Maven配置属性的前提下，如果在Idea下测试
工程时pom.xml每次更新需要手动compile方可生效

日志：

设置日志级别

# 打开debug 
logging:
  level:
    root: info
#debug: true 开启debug级别

# 设置分组，对某个组设置日志级别

logging:
  group:
    ebank: com.itheima.profiles.controller,com.itheima.profiles.service
    iservice: com.alibaba
  level:
    root: info
    ebank: warn

快速创建日志对象：

第一种：控制层继承一个类如下：

public class BaseClass {
    private Class clazz;
    public static Logger logger;
    public BaseClass(){
        clazz=this.getClass();
        logger= LoggerFactory.getLogger(clazz);
    }
}

**第二种：使用注解： **

第一：<!--        添加lombok坐标  ：不用在控制层写log的代码-->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>
    </dependencies>

第二：使用在控制层的接口中使用@Slf4j注解

日志输出格式控制：

PID:进程ID,用于表明当前操作所处的进程，当多服务同时记录日志时，该值可用于协助程序员调试程序
所属类/接口名：当前显示信息为SpringBoot重写后的信息，名称过长时，简化包名书写为首字母，甚至直接删除

%d:日期
%m:消息
%n:换行

server:
  port: 80
# 打开debug
logging:
  group:
    ebank: com.itheima.profiles.controller,com.itheima.profiles.service
    iservice: com.alibaba
  level:
    root: info
    ebank: warn
#debug: true
# 设置某个包的日志级别
#    com.itheima.profiles.controller: debug
    # 设置分组，对某个组设置日志级别
# 设置日志的模板模式
  pattern:
    #console: "%d - %m %n"
**    console: "%d - %clr(%5p) --- [%16t] %clr(%-40.40c){cyan} : %m %n"**

设置日志文件：

单一日志：
logging:
    file:
       name: server.log

日志文件详细设置：

滚动日志：

logging:
file:

     name:  server.log

  

  logback:
     rollingpolicy:
       max-file-size: 1MB
       file-name-pattern: server.%d{yyyy-MM-dd}.%i.log

设置日志文件的最大内存和内存满时自动建立新的文件封装

开发实用篇：

热部署：

手工启动热部署：

第一步：开启开发者工具

<!--        导入热部署的坐标-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
            <optional>true</optional>
        </dependency>

第二步：激活热部署

ctrl+F9

或者点击idea上菜单栏Build中的build project

1,开启开发者工具后启用热部署
2.使用构建项目操作启动热部署（Ctr1+F9)
3,热部署仅仅加载当前开发者自定义开发的资源，不加载jar资源

自动开启热部署：

在手工开启热部署的基础上进行如下操作：

手动干预热部署的范围配置：

默认不触发重启的目录列表
/META-INF/maven
/META-INF/resources
/resources
/static
/public
/templates

手动干预：

在配置坐标的基础上进行如下配置：

spring:
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://localhost:3306/ssm?serverTimezone=UTC
    username: root
    password: 11235813
    type: com.alibaba.druid.pool.DruidDataSource
 ** devtools:
    restart:
      # 设置不参与热部署的文件或文件夹
      exclude: static/**,public/**,config/application.yml**

配置高级：

bean的第三方绑定：

添加依赖：lombok和

<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>**druid**</artifactId>
    <version>1.1.16</version>
</dependency>

无论是绑定自身的bean还是绑定第三方bean需要该注解：

//@ConfigurationProperties(prefix = "*****配置文件中的属性")

@Bean
@ConfigurationProperties(prefix = "datasource")
public DruidDataSource dataSource() {
    DruidDataSource ds = new DruidDataSource();
    //ds.setDriverClassName("com.mysql.jdbc.Driver");
    return ds;
}

注意：@EnableConfigurationProperties.（{要设为bean的类，便于管理，清晰可见，ServerConfig.class}）与@Component:（在引导类中设置前者则不能设置该注解，该注解也会将被注解的类设为bean导致bean重复）不能同时使用

//@Component
@Data
@ConfigurationProperties(prefix = "servers")
public class ServerConfig {
    private String ipAddress;
    private int port;
    private long timeout;
    private Duration serverTimeOut;
    private DataSize dataSize;
}

宽松绑定：

@ConfigurationProperties支持宽松绑定

@Value不支持宽松绑定

注意：绑定前缀名命名规范：仅能使用纯小写字母、数字、下划线作为合法的字符

@Bean
@ConfigurationProperties(prefix = "datasource")//不能用“dataSource”
public DruidDataSource dataSource() {
    DruidDataSource ds = new DruidDataSource();
    return ds;
}

1.@ConfigurationProperties绑定属性支持属性名宽松绑定
2,@Value注解不支持松散绑定
3.绑定前缀命名命名规则

bean的校验：

①：添加JSR303规范坐标与Hibernate校验框架对应坐标

     <!-- https://mvnrepository.com/artifact/javax.validation/validation-api -->
     <dependency>
         <groupId>javax.validation</groupId>
         <artifactId>validation-api</artifactId>
     </dependency>

<!--提供hibernate框架提供的校验器做实现类-->
        <dependency>
            <groupId>org.hibernate.validator</groupId>
            <artifactId>hibernate-validator</artifactId>
        </dependency>

②：对Bean开启校验功能

③：设置校验规则

@Validated
public class ServerConfig {
    private String ipAddress;
//③：设置校验规则
   ** @Max(value = 8888,message = "最大值不能超过8888")
    @Min(value = 202,message = "最小值不能低于202")**
    private int port；

yaml语法规则：

八进制：格式：“0（0-7）”

六进制：格式：0x（0-9，a-f）
字面值表达方式
boolean:TRUE #TRUE,true,True,FALSE,false,False.均可
f1oat:3.14 #6.8523015e+5#支持科学计数法
int:123 #0b1010_0111_0100_1010_1110 #支持二进制、八进制、十六进制
nu11:~ #使用~表示null
string:HelloWorld #字符串可以直接书写
string2:"Hello World" #可以使用双引号包裹特殊字符
date:2018-02-17 #日期必须使用yyyy-MM-dd格式
datetime:2018-02-17T15:02:31+08:00 #时间和日期之间使用T连接，最后使用+代表时区

加载测试专用属性：

// 注解内的两个属性都是作为更改yml配置文件中的临时属性，其中agrs配置的属性级别更高
@SpringBootTest(properties = {"test.prop=testValue1"},args = {"--test.prop=testValue2"})
class ConfigurationApplicationTests {
    @Value("${test.prop}")
    private String msg;
    @Test
    void contextLoads() {
        System.out.println(msg);
    }
}

加载测试专用配置：

测试类中加载web环境：

测试类中模拟web发送http请求：

测试类产生随机数据：

在配置文件中如下写：

然后在测试类中引入，并自动装配，打印出来。

测试类中不想测试时改变数据库原有数据：

在测试类上添加：

//设置事务回滚，防止测试类改变数据库的数据
@Transactional
若添加如下注解，事务无法回滚
@Rollback(value = false)

数据层解决方案：

内置数据源：

数据源配置
SpringBoot提供了3种内嵌的数据源对象供开发者选择

当druid数据源配置时没有type属性时

并且关闭druid的坐标

系统自动使用内置数据源HikariCp

spring:
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://localhost:3306/ssm?serverTimezone=UTC
    username: root
    password: 11235813
    //type: com.alibaba.druid.pool.DruidDataSource

在不使用druid时使用hikari：注意：url不能写入hikari中

三种springboot提供的内嵌数据源：

HikariCp
Tomcat提供DataSource
Commons DBCP

SpringBoot提供了3种内嵌的数据源对象供开发者选择
◆HikariCP：默认内置数据源对象
Tomcat提供DataSource:HikariCP不可用的情况下，且在web环境中，将使用tomcat服务器配置的数据源对象
Commons DBCP:Hikari不可用，tomcat数据源也不可用，将使用dbcp数据源
通用配置无法设置具体的数据源配置信息，仅提供基本的连接相关配置，如需配置，在下一级配置中设置具体设定

jdbcTemplate持久化取代：mybatis-plus/mybatis：

jdbcTemplate:相关配置：

内置持久化解决方案jdbcTemplate

关闭mybatis-plus坐标（其中含哟有dbc坐标，jdbc中含有hikari数据源坐标）

//导入jdbc坐标
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-jdbc</artifactId>
</dependency>

@Test
void jdbcTest(@Autowired JdbcTemplate jdbcTemplate) {
    String sql = "select * from t_book";
    /* //普通方法
    List<Map<String, Object>> maps = jdbcTemplate.queryForList(sql);
    System.out.println(maps);*/
    RowMapper<Book> rm = new RowMapper<Book>() {
        @Override
        public Book mapRow(ResultSet rs, int rowNum) throws SQLException {
            Book temp = new Book();
            temp.setId(rs.getInt("id"));
            temp.setBookName(rs.getString("book_name"));
            temp.setPrice(rs.getInt("price"));
            temp.setStack(rs.getInt("stack"));
            return temp;
        }
    };
    **//query进行查询操作**
    List<Book> list = jdbcTemplate.query(sql, rm);
    System.out.println(list);
}

spring:
  datasource:
    url: jdbc:mysql://localhost:3306/ssm?serverTimezone=UTC
    hikari:
      driver-class-name: com.mysql.cj.jdbc.Driver
      username: root
      password: 11235813
      # 最大的连接池数量
      maximum-pool-size: 50
 ** jdbc:
    template:
      fetch-size: -1 # 缓存行数
      max-rows: 500 # 最大行数
      query-timeout: -1 # 查询超时时间**

//存储操作
@Test
void jdbcSave(@Autowired JdbcTemplate jdbcTemplate) {
    String sql = "insert into t_book values(null,'吞噬星空',300,322)";
  **  //update进行增删改操作**
    jdbcTemplate.update(sql);

}

idea内置数据库：

内嵌数据库H2：

现有数据层解决方案技术选型：

Druid+MyBatis-Plus+MySQL

内嵌数据库
SpringBoot提供了3种内嵌数据库供开发者选择，提高开发测试效率
H2 HSQL Derby

关闭mysql驱动坐标 导入h2坐标和jpa 并设置当前项目工程为web环境：spring-boot-starter-web

但spring-boot-starter不能少

 <!--        测试内置数据库 不需要mysql驱动-->
        <dependency>
            <groupId>com.h2database</groupId>
            <artifactId>h2</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-jpa</artifactId>
        </dependency>
<!--测试内置数据库，需设置web环境-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

访问localhost/h2

**关闭mysql数据源，并添加如下配置 **

server:
  port: 80
spring:
  h2:
    console:
      enabled: true**//默认true为h2数据库开启**
      path: /h2 ** //运行引导类，并输入localhost/h2**
  datasource:
    url: jdbc:h2:~/test
    hikari:
      driver-class-name: org.h2.Driver
      username: sa
      password: 123456

访问用户名sa,默认密码123456

H2数据库线上运行时请务必关闭

将enabled: true 设位false，在上线时关闭。

总结：

数据源配置（Hikari)
持久化技术（JdbcTemplate)
数据库（H2)

NOSQL：

Redis下载与基本使用

Redis是一款key-value存储结构的内存级NoSQL数据库
支持多种数据存储格式
支持持久化
支持集群

下载路径
https://github.com/tporadowski/redis/releases

下载windows版本的Redis-x64-5.0.14.1.msi安装包

在安装路径下打开cmd命令提示符（两个控制台）

服务端启动命令
redis-server.exe redis.windows.conf
客户端启动命令
redis-cli.exe

使用shutdown处理bug

再次登录，就可以了。

若是清屏的话输入clear

windows时输入cls清屏

springboot整合redis：

//导入redis的坐标
<dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>

<!--        导入jedis坐标 -->
        <dependency>
            <groupId>redis.clients</groupId>
            <artifactId>jedis</artifactId>
        </dependency>

# 配置redis
spring:
  redis:
    host: localhost
    port: 6379
#    client-type: jedis
    client-type: lettuce
    lettuce:
      pool:
        max-active: 16
    jedis:
      pool:
        max-active: 16

# **使用jdis技术 默认是使用lettuce设置为jedis**

注意：lettuce不存在线程安全问题

idea中实现整合：

一：在创建新的项目时勾选nosql中的第一项

创建后产生的依赖

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

二：在yml文中进行配置local，port（多余，默认都设置了！）

三：在测试类中进行测试

@Autowired
private RedisTemplate redisTemplate;
//set方法
@Test
void set() {
    ValueOperations ops = redisTemplate.opsForValue();
    ops.set("age", 4);
}

@Test
void get() {
    ValueOperations ops = redisTemplate.opsForValue();
    Object age = ops.get("age");
    System.out.println(age);
}
//hset方法
@Test
void hset() {
    HashOperations ops = redisTemplate.opsForHash();
    ops.put("info","age", 4);
}

@Test
void hget() {
    HashOperations ops = redisTemplate.opsForHash();
    Object val = ops.get("info", "age");
    System.out.println(val);
}

springboot整合mongodb数据库

Mongodb应用场景

最像关系型数据库的非关系型数据库
淘宝用户数据
◆存储位置：数据库
◆特征：永久性存储，修改频度极低
游戏装备数据、游戏道具数据
◆存储位置：数据库、Mongodb
特征：永久性存储与临时存储相结合、修改频度较高
直播数据、打赏数据、粉丝数据
◆存储位置：数据库、Mongodb
◆特征：永久性存储与临时存储相结合，修改频度极高
物联网数据
存储位置：Mongodb
特征：临时存储，修改频度飞速

Windows版Mongo下载
https://www.mongodb.com/try/download

Windows)版Mongo启动
先进行服务端启动
mongod --dbpath=..\data\db（无空格）使用第一次就可以了，db内文件已添加
再进行客户端启动
mongo （--host=127.0.0.1--port=27017）括号内不用写

Mongodb基本操作

注意：在命令提示符窗口中，建立新的数据库时，仅仅只是在内存中建立，无法在硬盘中显示；
新增
db.集合名称.insert/save/insert0ne(文档)
修改
db.集合名称.remove(条件)
删除
db.集合名称.update(条件，{操作种类：{文档}})

常见错误：

@SpringBootTest
class Mongodb5ApplicationTests {

    @Autowired
    private MongoTemplate mongoTemplate;

    @Test
    void contextLoads() {
        Book book=new Book();
        book.setId(1);
        book.setName("springboot");
        book.setType("springboot");
        book.setDescription("springboot");
        mongoTemplate.save(book);
    }
//数据库中原有数据会引起报错，因为原有数据的id不是int类型的
    @Test
    void find(){
        List<Book> all = mongoTemplate.findAll(Book.class);
        System.out.println(all);
    }
报错rg.springframework.core.convert.ConverterNotFoundException: No converter found capable of converting from type [org.bson.types.ObjectId] to type [int]

spring boot整合ES

分布式全文搜索引擎

使用Apifox中

put http://localhost:9200/books 建立一个数据库之类的东西

{

"mappings":{

    "properties":{

        "id":{

            "type":"keyword"  

        },

        "name":{

            "type":"text",

            "analyzer":"ik_max_word",

            "copy_to":"all"

        },

        "type":{

            "type":"keyword"

        },

        "description":{

            "type":"text",

            "analyzer":"ik_max_word",

            "copy_to":"all"

        },

//将描述和名字内容整合进行分词，都进行查询

        "all":{

            "type":"text",

            "analyzer":"ik_max_word"//分词器

        }

    }

}

}

post http://localhost:9200/books/_doc/1（1代表的是id） 若后面没加数字代表的是随机id代表的是 执行的文档的post操作，将之前的text添加数据也可以是http://localhost:9200/books/_create/1

body类型的raw数据

{
"id":1,
"name":"springboot",
"type":"springboot",
"description":"springboot"
}

get  http://localhost:9200/books/_doc/1 查询单个数据
get http://localhost:9200/books/_search通过该方法查询全部

get http://localhost:9200/books？q=name：springboot

创建文档
POST
http://localhost:9200/books/_doc
#使用系统生成id
POST
http://localhost:9200/books/_create/1
#使用指定id,
POST
http://localhost:9200/books/doc/1
#使用指定id,不存在创建，存在更新（版本递增）

查询文档
GET
http://localhost:9200/books/_doc/1
#查询单个文档
GET
http://localhost:9200/books/_search
#查询全部文档
条件查询
A
GET
http://localhost:9200/books/_search?q=name:springboot
删除文档
DELETE
http://localhost:9200/books/_doc/1

修改文档（全量修改)
PUT
http://localhost:9200/books/_doc/1
name”:"springboot",
type":"springboot",
"description":"springboot"
修改文档（部分修改)
POST
http://localhost:9200/books/_update/1
"doc";{
name":"springboot"
}

将一个book对象转为json格式

1.导坐标

<dependency> <groupId>com.alibaba</groupId> <artifactId>fastjson</artifactId> <version>1.2.78</version> </dependency>

2.在测试类中转为json

String json =JSON.toJSONString(book);

springboot缓存作用

使用默认缓存

1，导坐标

<!--        导入缓存需要的坐标-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-cache</artifactId>
        </dependency>

2，在引导类中加入注解

//允许开启缓存功能
@EnableCaching

3，在服务层使用缓存注解

@Override
//value随便写，key使用#id形式写可以读取到id，存储数据到“cachespace”中
@Cacheable(value = "cacheSpace", key = "#id")
public Book getById(Integer id) {
    return bookDao.selectById(id);
}

SpringBoot提供的缓存技术除了提供默认的缓存方案，还可以对其他缓存技术进行整合，统一接口，方便缓存技术
的开发与管理
Generic
JCache
Ehcache
Hazelcast
Infinispan
Couchbase
Redis
Caffenine
Simple(默认)
memcached Springboot并未提供，但市面上流行

使用ehcache缓存

1.缓存供应商变更：Ehcache

在yml配置文件中进行配置缓存类型和ehcache的xml文件

spring:
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://localhost:3306/ssm?serverTimezone=UTC
    username: root
    password: 11235813
    type: com.alibaba.druid.pool.DruidDataSource
#    设置缓存格式默认是simple
  cache:
    type: ehcache
    ehcache:
      config: ehcache.xml

2，导坐标

注意：springboot原本的缓存坐标不能删除，springboot的内置缓存支持更该后的其他缓存类型

<!-- 导入ehcache的坐标，缓存坐标，并不是springboot自带的，还要导入ehcache的xml配置文件-->
        <dependency>
            <groupId>net.sf.ehcache</groupId>
            <artifactId>ehcache</artifactId>
        </dependency>

3，导ehcache.xml文件

注意：

<!--     diskPersistent="false"表示的是是否持久化存储-->

<!--单独定义一个缓存与接口层的缓存值相对应：name="smsCode"；缓存内容的存在时长timeToLiveSeconds="10"-->
    <cache
        name="smsCode"
        eternal="false"
        diskPersistent="false"
        maxElementsInMemory="1000"
        overflowToDisk="false"
        timeToIdleSeconds="10"
        timeToLiveSeconds="10"
        memoryStoreEvictionPolicy="LRU" />

使用redis格式缓存

1.导入坐标，不用删encache坐标，配置中更该缓存格式就可以

2.启动redis

3，配置redis到yml中

spring:
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://localhost:3306/ssm?serverTimezone=UTC
    username: root
    password: 11235813
    type: com.alibaba.druid.pool.DruidDataSource
  cache:
    type: redis
    redis:
#      是否添加前缀，就是缓存的value值
      use-key-prefix: true
#      是否使用value值的前缀
      cache-null-values: true
#      指定value值的前缀
      key-prefix: ssm_
      time-to-live: 10s
  redis:
    host: localhost
    port: 6379

使用memcached格式缓存

关闭的话就用memcached.exe -d stop进行关闭

SpringBoot未提供对memcached的整合，需要使用硬编码方式实现客户端初始化管理
1，导入坐标，因为没有整合，所以到maven仓库中复制

2，springboot并没有整合memcached，所以直接硬编码，无法在直接yml文件中配置

@Component
@ConfigurationProperties(prefix = "memcached")
@Data
public class XMemcachedProperties {
    //设置端口号，地址
    private String servers;
    //设置数据连接池的数量
    private int poolSize;
    //设置超时时间
    private long opTimeout;
}

# 在yml文件中自己配，springboot不提供
memcached:
  servers: localhost:11211
  poolSize: 10
  opTimeout: 3000

@Configuration
public class XMemcachedConfig {
    @Autowired
    private XMemcachedProperties memcachedProperties;
    //装上memcached的服务，还要告诉服务器的地址和端口在builder方法中
    @Bean
    public MemcachedClient getMemcachedClient() throws IOException {
        MemcachedClientBuilder memcachedClientBuilder=new XMemcachedClientBuilder(memcachedProperties.getServers());
        memcachedClientBuilder.setConnectionPoolSize(memcachedProperties.getPoolSize());
        memcachedClientBuilder.setOpTimeout(memcachedProperties.getOpTimeout());
        MemcachedClient memcachedClient=memcachedClientBuilder.build();
        return memcachedClient;
    }
}

使用jetCache格式缓存

jetCache设定了本地缓存与远程缓存的多级缓存解决方案
本地缓存（1oca1)
LinkedHashMap
Caffeine
远程缓存（remote)
Redis
Tair

jetcache在yml中的配置属性网上找

想实现缓存，要将是对象时可序列化的

第一点：

对象要序列化

public class Book **implements Serializable **

第二点：

jet cache:
#  statIntervalMinutes: 1
  local:
    default:
      type: linkedhashmap
#      键转换器，解决对象转为String类型，无论远程还是进程都要配置
      keyConvertor: fastjson
  remote:
    default:
      type: redis
      host: localhost
      port: 6379
      **keyConvertor: fastjson
      valueEncode: java
      valueDecode: java**
      poolConfig:
        maxTotal: 50
    sms:
      type: redis
      host: localhost
      port: 6379
      poolConfig:
        maxTotal: 50

spring的task使用

1，在引导类中 添加

//开启定时任务
@EnableScheduling

2，在一个class类中

@Component
public class MyBean {
//表示加载任务的时间间隔
    **@Scheduled(cron = "0/1 * * * * ?")**
    public void print(){
        System.out.println(

//表示当前线程的名字

**Thread.currentThread().getName()**+

"spring task run...");
    }

}

在yml文件中task的相关配置

activemq的安装

activemq的使用：

1，安装软件

2，导坐标

3，配置

spring:
  activemq:
    broker-url: tcp://localhost:61616
  jms:
#    发布订阅模式，不是点对点行式
    pub-sub-domain: true
    template:
      default-destination: itheima
  rabbitmq:
    host: localhost
    port: 5672
  kafka:
    bootstrap-servers: localhost:9092
    consumer:
      group-id: order

rocketmq:
  name-server: localhost:9876
  producer:
    group: group_rocketmq

4，设置监听，一发消息，就往下执行

//@Component
public class MessageListener {
    //jms监听器
  **  @JmsListener**(destination = "order.queue.id")
    **@SendTo**("order.other.queue.id")
    public String receive(String id){
        System.out.println("已完成短信发送业务，id："+id);
        return "new:"+id;
    }
}

spring整合ribbitmq

RabbitMQ基于Erlang语言编写，需要安装Erlang，并配置其环境变量path和erlang_home

登录ribbitmq的密码和用户名都为guest

服务管理可视化（插件形式）
查看已安装的插件列表
rabbitmq-plugins.bat list
开启服务管理插件
rabbitmq-plugins.bat enable rabbitmq_management
访问服务器
http://localhost:15672
服务端口：5672，管理后台端口：15672
用户名&密码：guest

可以手动在任务管理器中手动开启或停止

访问不了的可以重启

springboot整合kafka

springbootadmin

Spring Boot Admin,开源社区项目，用于管理和监控SpringBoot应用程序。客户端注册到服务端后，通过HTTP
请求方式，服务端定期从客户端获取对应的信息，并通过U界面展示对应信息。
使用spring-boot-admin时要设置其版本与springboot的版本一致

1，在pom中导入admin的坐标****，和web的坐标

2，配置yml文件中的端口为8080

3，在引导类中添加@EnableAdminServer的注解

在命令提示符窗口数据人jconsole，是Java提供的监控平台

C:\Users\魏正想>jconsole

** 终于结束了！**