spring Boot

spring Boot
1.简介
- SpringBoot 是由 Pivotal 团队在 2013 年开始研发，2014 年 4 月发布第一个版本的全新开源的轻量级框架，它基于 Spring4.0 设计，不仅继承了 Spring 框架原有的优秀特性，而且还通过简化配置来进一步简化了 Spring 应用的整个搭建和开发过程，另外 SpringBoot 很好地解决了依赖包的版本冲突、引用的不稳定性等问题；
- SpringBoot 并不是什么新的技术，像 Maven 整合了 Jar 包一样，它整合了主流的第三方框架，形成的一套快速开发框架；
2.特性***
- 使用骨架：快速搭建项目；
- pom.xml: Starter 依赖，将常用的依赖按组聚集在一起，形成单条依赖，以 Maven 继承的方式，非常方便地进行包管理；
- 遵循“习惯优于配置”的原则，简化配置，无 web.xml；
- Bean 自动配置，完全采用注解化；
- 内嵌 Servlet 容器，无需外部 Tomcat；
- 提供运行时的应用监控：运维有用；
3.为什么要使用 SpringBoot ？
- 能够使配置、编码、部署变得简单；将中心放入业务层上去。
4.Mvc、Boot、Cloud
- SpringMvc：Web 应用中的 Mvc 框架；
- SpringBoot：垂直应用框架的大集成，Web 组件基于 SpringMvc；
- SpringCloud：分布式应用框架，包含注册中心、服务治理、网关中心、断路器……每个微服务都基于 SpringBoot，SpringBoot + SpringCloud = 分布式开发，可以把之看为三维立体应用的集成者；
5.对比以及打包

5.1 spring程序与springBoot程序对比
- spring程序与springBoot程序对比
- 开发springBoot必须联网，不然不行。
boot程序不需要依赖tomcat和idea工具等，只需要将jar包发给前端人员，然后连接数据就行

5.2 打包运行

1.使用maven打包

2.找到jar包

3.启动程序

6.spring Boot概述

7.springBoot起步依赖

1.起步依赖

2.辅助功能

3.启动方式

4.换一个服务器

使用jetty:轻量级，用的东西比较少时使用，因为需要自己配置

tomcat:里面配置了很多的东西，一般使用是需要配置很多的配置项

二、spring Boot项目和仓库

1.创建spring Boot项目步骤

2.springBoot必须掌握的注解

本身是一个配置类：
@SpringBootConfiguration

当前启动类可以扫描其他的配置类：扫描范围是同包或者子包
@EnableAutoConfiguration

启动类可以扫描其他的组件，并应用：扫描范围是同包或者子包
@ComponentScan

过滤
@Filter

3.克隆git仓库，并上传文件

3.1.创建git仓库

3.2.赋值仓库的地址

3.3.在本地的仓库中克隆此仓库

正在上传…重新上传取消

3.4.克隆后，创建一个项目

3.5.创建项目后，忽略不用上传的东西

3.6.上传项目

4.git 仓库的命令

4.1.git 常用的命令表

4.2.git 命令进行项目的上传

git status

git add *

git status

git commit -m "2022-08-16 创建spring项目"

git status

git push origin master

5.仓库的类型***

5.1.maven仓库（Jar仓库）

远程jar仓库

本地jar仓库：

依赖的三要素：groupId、artifactId、version

         maven软件读取项目pom.xml文件，根据依赖，从远处仓库下载依赖到本地仓库

        项目依赖本地仓库，根据三要素在本地仓库寻找响应的依赖包

        clean: 清除target

        cleaninstall:清除，安装时将项目打成jar包，打包的位置是本地仓库和target

        -D maven -test.skap :在安装时

5.2.代码仓库

远程的代码仓库：gitee

本地代码仓库:repository_git(防止项目的代码文件夹)/仓库的文件夹/项目的文件夹

三、REST 风格

1.REST简介

1.1定义

REST(Representational State Tranfer)，表示形式转换，也就是访问网络资源的格式。
- 传统的资源描述形式
```
http://localhost/user/getuserId?id=1
http://localhost/user/saveUser
```
- REST风格描述形式
```
http://localhost/user/1
http://localhost/user
```
- 优点：
- - 隐藏了资源的访问行为，无法通过地址得知资源是何种操作
  - 书写简化
1.2.REST风格的行为

路径+请求方式=行为

使用RESTful进行开发

2.RESTful入门案例

spring支持的8种提交方式

2.1 修改删除增加

2.2 设定参数请求参数（路径变量）

2.3 注解格式

1.@RequestMapping

2.@PathVariable

2.4 接收参数的注解区别

3.REST快速开发

简化代码

3.1.提出公共路径和@ResonseBody注解

在类上提出到类上，@ResponseBody也是提出来写到类的上方，表示类中所有的方法都可以引用。

但是由@controller和@ResonseBody一起的，所以可以用他们的共讨那个父类，替换两者，父类是@RestController

3.2 简化method
```
@RestController
@RequestMapping("/book")
public class UserController {
 
//    @RequestMapping(method = RequestMethod.POST)
    @PostMapping
    public  String  save(@RequestBody Book book){
        System.out.println("user  save。。。。。"+book);
        return "{'module','spring  mvc'}";
    }
 
//    @RequestMapping(value = "/{id}",method = RequestMethod.DELETE)
    @DeleteMapping("/{id}")
    public String delete(@PathVariable Integer id){
        System.out.println("user del "+id);
        return "{'module','spring  mvc'}";
    }
 
}
```
3.3 简化的注解两个

1.@RestController

2.请求方式的注解

4.案例：基于RESTful页面数据交互

四.注释的正确写法

/**
* 方法的描述：/test/helloworld
* 参数列表： get
* 返回值说明： string
* @return
*/

五、运行方式

1.Main 方法运行；

2.Java 命令运行；
1. java -jar *.jar || java -jar *.war；
2. java -jar ***.jar --server.port=9090 ---- 设置端口；
3. java -jar ***.jar --spring.profiles.active=dev ---- 设置环境；
4. java -jar ***.jar --spring.config.location=/opt/config/application.properties ---- 指定外部配置文件；
3.外置 Servlet 容器运行；

4.内置 Tomcat 和外置 Tomcat 的区别；
1. 内置：Jar 包 ---- 执行 Main 方法 ---- 启动 IOC ---- 启动 Servlet 容器；
2. 外置：War 包 ---- 启动 Servlet 容器 ---- 执行 Main 方法 ---- 启动 IOC；
问题：
- Spring 内置 Tomcat 相关 Jar，项目打包时会一起打入 War 包，放入 Tomcat 容器后，和外置 Tomcat 的 Jar 冲突；
- Tomcat 容器启动 Web 项目，读取 web.xml，但 SpringBoot 项目没有 web.xml；
解决方案：
- Pom 将打包方式改为 War；
- - war
- 解决 Tomcat Jar 冲突的问题
- - 方案一：Pom 中 spring-boot-starter-web 排除 spring-boot-starter-tomcat，再引入 javax.servlet-api；
  - 方案二：Pom 引入 spring-boot-starter-tomcat，设置 scope 为 provided，只在编译和测试阶段起作用，打包时候做了 Exclude 操作，使用外置 Tomcat 相关 Jar；
```
<dependency>
    <groupId>org.springframework.bootgroupId>
    <artifactId>spring-boot-starter-tomcatartifactId>
    <scope>providedscope>
dependency>
```
- - 解决无 web.xml 的问题
  - 启动类继承 SpringBootServletInitializer，重写 configure 方法，将启动类加入 SpringApplicationBuilder sources中；
```
@SpringBootApplication
public class JavaSpringBootApplication extends SpringBootServletInitializer {
    @Override
    protected SpringApplicationBuilder configure(SpringApplicationBuilder builder) {
        return builder.sources(JavaSpringBootApplication.class);
    }
    public static void main(String[] args) {
        SpringApplication.run(JavaSpringBootApplication.class, args);
    }
}
```
六、常用的注解
- 参见 Java_Spring ---- “常见注解”；
- @SpringBootApplication
- - @ComponentScan ---- 组件扫描，加载到 IOC 容器；
  - @EnableAutoConfiguration ---- 通过 @Import 将所有符合自动配置条件的 Bean 定义加载到 IOC 容器，通俗讲加载 @Configuration 类；
  - @SpringBootConfiguration ---- 继承自 @Configuration，标注当前类是配置类；
  - @Inherited ---- 让子类能继承父类注解；
  - @Documented ---- 表明注释是由 Javadoc 记录；
  - @Retention ---- 注解保留策略；
- - RetentionPolicy.SOURCE：注解只保留在源文件，当 Java 文件编译成 Class 文件的时候，注解被遗弃；
    RetentionPolicy.CLASS：注解被保留到 Class 文件，但 Jvm 加载 Class 文件时候被遗弃，这是默认的生命周期；
    RetentionPolicy.RUNTIME：注解不仅被保存到 Class 文件中，Jvm 加载 Class 文件之后，仍然存在；
- - @Target ---- 注解出现在 Java 文件中的位置；
七、Banner

1.简介
- SpringBoot Logo 以及版本信息：${spring-boot.version} 、${spring-boot.formatted-version}，参考 banner.txt 文件；
- 在线 Banner 地址：Ascii艺术字实现个性化Spring Boot启动banner图案，轻松修改更换banner.txt文件内容，收集了丰富的banner艺术字和图，并且支持中文banner下载，让你的banner好玩儿更有意思。-bootschool.net
2.应用
- 将生成好的 banner.txt 文件放到 src/main/resources 下；
- 启动项目，控制台输出给定的 Log 及版本信息；
3.关闭 Banner
```
@SpringBootApplication
public class JavaSpringBootApplication extends SpringBootServletInitializer {
 
    @Override
 
    protected SpringApplicationBuilder configure(SpringApplicationBuilder builder) {
 
        return builder.sources(JavaSpringBootApplication.class);    }
 
    public static void main(String[] args) {
 
//      SpringApplication.run(JavaSpringBootApplication.class, args);
 
        SpringApplication springApplication = new  SpringApplication(JavaSpringBootApplication.class);
 
        springApplication.setBannerMode(Banner.Mode.OFF);
 
        springApplication.run(args);
 
    }
 
}
```
八、文件配置、接口、读取、日志

1.配置文件

1.1种类
- 父上下文配置：bootstrap.properties || bootstrap.yml，使用 Spring Cloud Config 配置中心时，需要在 Bootstrap 配置文件中添加连接到配置中心的配置属性，来加载外部配置中心的配置信息，适用于：一些固定的不能被覆盖的属性、一些加密 / 解密的场景；
- 全局配置文件：application.properties、application.yml、application.yaml；
- 其他配置文件：logback.xml……；
1.2 编码

ASCII ----单字节编码0-127 ，键盘上

Iso8859-1 ------单字节

GBK ----

因为太多的编码格式出现乱码，所以使用

unicode -----多字节定长编码，也会出现异常

utf-8 -----多字节变长编码

所以在配置application时就不要使用中文

2.测试接口

2.1.application.properties
- application.properties 书写第一条配置：server.port=80
2.2 application.yml
- 准备 application.yml 文件，同样的位置、不同的端口配置，启动项目看谁的配置生效；
2.3 优先级

此时生效是application.properties文件中配置的接口生效
- 不同配置的 application.properties，分别放在 src/main/resources 和 src/main/resources/config 下，启动项目看谁生效；
此时放在src/main/resources/config 下的配置文件生效。

重点：
- 以后使用的话，常用yml的方式，
- 如果三者都存在的话，.properties为主启动文件：顺序是
- 三个文件的加载顺序优先级： .properties > .yml > .yaml
3.读取配置文件内容

3.1.使用@Value属性

使用 @Value 注解读取配置文件属性，注意 key 命名不能用 com.thornBird 驼峰法命名，需用.或者-间隔；
- 全局的application.properties添加配置
```
server.port=80
 
# for test
com.sfac.name=eternity
com.sfac.age=18
com.sfac.desc=${com.sfac.name}----${com.sfac.age}
com.sfac.random=${random.uuid}
```
- TestController.java 添加 config 测试接口
```
@Controller
public class TestController {
    
    @Value("${com.sfac.name}")
    private String name;
 
    @Value("${com.sfac.age}")
    private int age;
 
    @Value("${com.sfac.desc}")
    private String desc;
 
    @Value("${com.sfac.random}")
    private String random;
 
    /**
     * localhost
     * /test/config
     * get
     * @return
     */
    @GetMapping(value = "/test/config")
    @ResponseBody
    public String configTest(){
        StringBuffer sb = new StringBuffer();
        sb.append(name).append("---")
        .append(age).append("---")
        .append(desc).append("---")
        .append(random).append("---").append("
");
        return sb.toString();
    }
}
```
接下来测试,启动项目访问接口：http://127.0.0.1/test/config

3.2.使用配置文件整个读取
- 在 src\main\resources\config 下创建其他配置 applicationTest.properties
```
# for test
org.sfac.name=eternity1
org.sfac.age=19
org.sfac.desc=${com.sfac.name}----${com.sfac.age}
org.sfac.random=${random.uuid}
```
- 创建配置文件对应的 Bean：ApplicationTest.java,称为一个配置类
```
@Component
@PropertySource(value = "classpath:config/applicationTest.properties")
 
//这时的classpath是指在target的地方的路径
 
public class ApplicationTest {
    @Value("${org.sfac.name}")
    private String name;
 
    @Value("${org.sfac.age}")
    private int age;
 
    @Value("${org.sfac.desc}")
    private String desc;
 
    @Value("${org.sfac.random}")
    private String random;
 
    public String getName() {
        return name;
    }
    生成他们的set与get方法自己生成，此处省略
 
}
```
- TestController.java ---- 注入 ApplicationTest，并调用；
```
@Controller
public class TestController {
 
    //注入ApplicationTest这个bean
    
    @Autowired
    private ApplicationTest applicationTest;
 
 
 
    /**
     * 方法的描述：/test/helloworld
     * 参数列表： get
     * 返回值说明： string
     * @return  String
     */
    @GetMapping(value = "/test/helloworld")
    @ResponseBody
    public String HelloWorld(){
        return "Hello World";
    }
 
    /**
     * localhost
     * /test/config
     * get
     * @return
     */
    @GetMapping(value = "/test/config")
    @ResponseBody
    public String configTest(){
        StringBuffer sb = new StringBuffer();
        sb.append(
                applicationTest.getName()).append("---")
                .append(applicationTest.getAge()).append("---")
                .append(applicationTest.getDesc()).append("---")
                .append(applicationTest.getRandom());
        return sb.toString();
    }
```
启动项目访问接口：http://127.0.0.1/test/config

4.加入日志

4.1.配置logback.xml文件
- Pom 引入 Jar ---- SpringBoot 默认已引入；
- 在 src\main\resources\config 下创建 Logback 配置文件：logback.xml；
```
"1.0" encoding="UTF-8"?>
 
<configuration debug="false" scan="true" scanPeriod="30 seconds">
 
    
    <property name="env" value="dev"/>
    <property name="project" value="java_spring_boot"/>
    <property name="root" value="/var/log"/>
    <property name="fileSize" value="50MB"/>
    <property name="maxHistory" value="100"/>
    <timestamp key="dateTime" datePattern="yyyy-MM-dd HH:mm:ss"/>
    <property name="pattern" value="%d{${dateTime}} %-5level %logger{36} -- %msg%n"/>
 
    
    <appender name="console" class="ch.qos.logback.core.ConsoleAppender">
        <encoder charset="utf-8">
            <pattern>${pattern}pattern>
        encoder>
    appender>
 
    
    <appender name="file" class="ch.qos.logback.core.rolling.RollingFileAppender">
        <encoder charset="utf-8">
            <pattern>${pattern}pattern>
        encoder>
        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
            <fileNamePattern>${root}/${project}_${env}_%d.%i.logfileNamePattern>
            <maxHistory>${maxHistory}maxHistory>
            <timeBasedFileNamingAndTriggeringPolicy
                    class="ch.qos.logback.core.rolling.SizeAndTimeBasedFNATP">
                <maxFileSize>${fileSize}maxFileSize>
            timeBasedFileNamingAndTriggeringPolicy>
        rollingPolicy>
    appender>
    
    <Logger name="org.springframework" level="INFO" additivity="false">
        <appender-ref ref="console"/>
        <appender-ref ref="file"/>
    Logger>
    
    <root level="DEBUG">
        <appender-ref ref="console"/>
        <appender-ref ref="file"/>
    root>
configuration>
```
4.2 全局application.properties配置
- 全局application.properties中采用三方配置
```
#for  log
logging.config=classpath:config/logback.xml
```
4.3.添加 Log 测试接口
- TestController ---- 添加 Log 测试接口；
```
@Controller
public class TestController {
 
    private final static Logger LOGGER = LoggerFactory.getLogger(TestController.class);
    
// LOGGER 的构造方法参数是 Class，是根据类的结构来进行区分日志，所以一个类只要一个 LOGGER，故 static
// final 表示一种编程习惯，表示该类的 LOGGER 只是记录该类的信息，否则日志会无法提供可以令人信服的记录
// final 不可变，读取速度快
// static 静态，只创建一次，节省空间
 
 
    @RequestMapping(value = "/test/log")
    @ResponseBody
    public String logTest(){
        LOGGER.trace("This is trace loger");
        LOGGER.debug("This is debug loger");
        LOGGER.info("This is info loger");
        LOGGER.warn("This is warn loger");
        LOGGER.error("This is error loger");
 
        return "Log Test!";
    }
}
```
- 访问 127.0.0.1/test/logger，查看日志输出；
- 改变日志级别，重启项目再访问该接口，查看日志输出；
九、 yaml

1.YAML的简介

YAML(YAML Ain`t Markup Language) ,一种数据序列号格式

优点：
- 容易阅读
- 容易与脚本语言交互
- 以数据为核心，重数据轻格式
YAML文件的扩展名：
- .yml(主流)
- .yaml
2.YAML的语法规则
- 大小写敏感
- 属性层级关系使用多级描述，每行结束使用冒号结束
- 使用缩进表示层级关系，空格的数量不限制，只允许使用空格，不能使用tab
- 属性值前面添加空格（属性名与属性值之间使用冒号+空格作为分隔）
- ###表示注释
3.yaml数组数据
```
#配置端口号
server:
  port: 82
  
#  配置日志
logging:
  level:
    root:info
  
#数组数据
likes:
  - music
  - geme
  - run
```
4 yaml的读取数据的方式

4.1.读取单个数据的方式

4.2.封装数据到Environment对象，使用环境

这种方式是框架内部使用多

4.3.自定义对象指定数据，装进实体类中去

如果在自动装配时出现警告，加入一下坐标到pom.xml文件中

十、多环境启动

1.多环境配置方式

1.1： ---三个横线分隔
```
#设置启动的环境
spring:
  profiles:
    active: div
 
---
#开发
spring:
  profiles: dev
server:
  port: 80
```
1.2：使用不过时的写法
```
#开发
spring:
  config:
    activate:
      on-profile: dev
server:
  port: 80
```
1.3：properties文件多环境启动（不用，老格式）

2.多环境启动的命令格式

打包前先去clean一下。要注意备份配置文件。

带参数启动springBoot

3.参数加载优先级

4.多环境开发

maven中和springBoot中的配置环境谁起作用，启动jar包的话，执行package的指令后，maven的profile起主导作用，springBoot 的profile是打包时的工具

maven为主，springBoot为辅。

5.maven与springboot多环境兼容

6. 配置文件分类

十一、热部署

简介：在实际开发过程中，每次修改代码就得重启项目，对于一些大型应用来说，需要花费大量的时间成本，在 Java 开发领域，热部署一直是一个难以解决的问题，目前的 Java 虚拟机只能实现方法体的修改热部署，对于整个类的结构修改，仍然需要重启虚拟机，我们采用 Devtools 工具包完成热部署，操作简单，每次变更代码自动重启项目；

1.Pom 引入 Jar；
```
<dependency>
    <groupId>org.springframework.bootgroupId>
    <artifactId>spring-boot-devtoolsartifactId>
dependency>
```
2.配置
- application.properties
```
            dev tools
            #热部署生效
            spring.devtools.restart.enabled=true
            #设置重启的目录
            spring.devtools.restart.additional-paths=src/main/java
```
3.应用
- 启动应用，修改 TestController 中某接口返回内容，查看应用是否自动重启，调用接口，查看返回结果是否更新；
十二、Http & Https 配置

1.简介
- 简介
- - Http：超文本传输协议，使用 TCP 端口 80，默认情况下数据是明文传送的，可以通过抓包工具捕获到；
  - Https：由 SSL + HTTP 构建的可进行加密传输、身份认证的网络协议，称之为安全的超文本传输协议，使用 TCP 端口 443，数据会用 PKI（公钥基础设施）中的公钥进行加密，这样抓包工具捕获到的数据包也没有办法看包中的内容，安全性大大提高，要解密数据的话就要用到 PKI 中的私钥；
- 公匙、私匙
- - 公匙加密，私匙解密；
  - 私匙数字签名，公匙验证；
  - 它们是成对的，相互解密，举个栗子：两个用户想用双匙技术加密信息，A 将自己的公匙传给 B，B 用公匙加密信息后传给 A，A 用私匙解密信息；
- RSA 算法
- - RSA 公钥加密算法是 1977 年由 Ron Rivest、Adi Shamirh 和 LenAdleman 在美国麻省理工学院开发的，取名来自三个开发者的姓，RSA 是目前最有影响力的公钥加密算法，它能够抵抗到目前为止已知的所有密码攻击，已被 ISO 推荐为公钥数据加密标准，RSA 算法基于一个十分简单的数论事实：将两个大素数相乘十分容易，但要对其乘积进行因式分解却极其困难，因此可以将乘积公开作为加密密钥；
2.Https 通讯时序图
- Https 通讯时序图
3.http、https

自建证书、创建配置类、配置连接器、并将连接器注入容器中

静态资源配置

是将本地的静态文件映射给系统的一个路径
```
1.在全局配置中配置
          
```
```
            #for  port
            server.port=443
            server.http.port=80
 
            #for ssl 认证
            server.ssl.key-store=classpath:.keystore
            server.ssl.key-store-password=123456
```
```
2.访问资源
         
```
```
            https://127.0.0.1:80/test/log
            https://127.0.0.1:443/test/log
            出现不安全的提示，就表示测试成功
```
十三、SSL 证书

1.简介
- Https 在数据传输之前进行握手，该过程中确定了数据加密的密码，在握手过程中，网站会向浏览器发送 SSL 证书，SSL 证书是数字证书的一种，是一个支持 Https 网站的身份证明，SSL 证书里面包含了网站的域名，证书有效期，证书的颁发机构以及用于加密的公钥等信息，由于公钥加密的密码只能被在申请证书时生成的私钥解密，因此浏览器在生成密码之前需要先核对当前访问的域名与证书上绑定的域名是否一致，同时还要对证书的颁发机构进行验证，如果验证失败浏览器会给出证书错误的提示；
- SSL 证书需要向国际公认的证书认证机构（简称 CA，Certificate Authority）申请，CA 机构颁发的证书有 3 种类型；
- - 域名型 SSL 证书（DV SSL）：信任等级普通，只需验证网站的真实性便可颁发证书保护网站；
    企业型 SSL 证书（OV SSL）：信任等级强，须要验证企业的身份，审核严格，安全性更高；
    增强型 SSL 证书（EV SSL）：信任等级最高，一般用于银行证券等金融机构，审核严格，安全性最高，同时可以激活绿色网址栏；
2.获取方式
- 网上购买：阿里云、百度、腾讯等；
- Java 命令生成：
```
keytool -genkey -alias tomcat -keyalg RSA 
创建别名为 tomcat 的一条证书，指定使用 RSA 算法，
生成文件 C:\Users\XXX\.keystore；
如果该目录已经有了 .keystore，创建不成功，删除后再次创建；
```
3.步骤

3.1.在C盘用户那里生成.keystore
```
keytool -genkey -alias tomcat -keyalg RSA
```
3.2.在全局配置文件中配置
```
    server.ssl.key-store=classpath:.keystore
    server.ssl.key-store-password=123456
```
3.3.配置端口，在全局配置文件
```
    server.port=443
    server.http.port=80
```
3.4.编写配置类
```
        @Configuration
        @AutoConfigureAfter({WebMvcAutoConfiguration.class})
        public class WebMvcConfig {
            @Value("${server.http.port}")
            private  int httpPort;
            
        
         @Bean
        public Connector connector(){
            Connector connector = new Connector();
            connector.setPort(httpPort);
            connector.setScheme("http");
            return connector;
        }
 
        @Bean
        public ServletWebServerFactory servletWebServerFactory(){
            TomcatServletWebServerFactory factory = new TomcatServletWebServerFactory();
            factory.addAdditionalTomcatConnectors(connector());
            return factory;
        }
    }
```
十四、访问静态资源

1.原生方式访问
- 1.使用相对路径去访问静态资源文件
- 2.写一个配置了去实现静态资源的访问
  - 1.继承 WebMvcConfigurationSupport，重写 addResourceHandlers 方法；不推荐这种方式，因为继承该类后将无法识别默认的 /static 静态资源文件夹，需要手动配置一次；
  - 2.实现的接口是WebMvcConfigurer，实现 addResourceHandlers 方法；
  - 参数是：ResourceHandlerRegistry registry
    表示：提供了一个注册器，注册一个文件夹为系统的一个路径，把本地的路径映射给系统的一个相对路径
    将本地的文件夹映射给系统一个相对的路径：
    registry.addResourceHandler("/static")
    .addResourceLocations(ResourceUtils.FILE_URL_PREFIX+"D:\\repository\\static_repo");
        访问路径： 127.0.0.1/springboot_static_repo/2.png

2.访问本地静态资源的文件

2.1.分析

        上传图片----写道绝对路径地址---的那会url的路径地址（/static/1.jpg）--通过映射路径地址和文件相对路径拼接。/static/** + 1.jpg

2.2.需要配置的路径有四个

        1.映射路径地址前缀 /static/

        2.映射路径 /static/**

        3.Windows系统本地绝对路径地址

        4.Linux系统本地绝对路径地址

2.3.步骤
- 在application.properties中配置四种资源
```
#for  static  resource
spring.resource.path=/static/
spring.resource.pathPattern=/static/**
spring.resource.window.path=D:/repository/springboot_static_repo/
spring.resource.linux.path=/static/
```
- 生成配置bean
```
@Component
public class ResourceConfigBean {
    @Value("${spring.resource.path}")
    private String resourcepath;
 
    @Value("${spring.resource.pathPattern}")
    private String resourcepathPattern;
 
    @Value("${spring.resource.window.path}")
    private String localPathForWin;
 
    @Value("${spring.resource.linux.path}")
    private String localPathForLin;
    
    set和get方法
    }
```
- 注入到配置文件类中
```
@Configuration
@AutoConfigureAfter({WebMvcAutoConfiguration.class})
public class WebMvcConfig  implements WebMvcConfigurer {
  
 
    @Autowired
    private ResourceConfigBean resourceConfigBean;
 
 
    @Override
    public void addResourceHandlers(ResourceHandlerRegistry registry) {
        //将本地的文件夹映射给系统一个相对的路径
//        提供了一个注册器，注册一个文件夹为系统的一个路径，把本地的路径映射给系统的一个相对路径
        String  osname = System.getProperty("os.name");
        if (osname.toLowerCase().startsWith("win")){
            registry.addResourceHandler(resourceConfigBean.getResourcepathPattern())
                    .addResourceLocations(ResourceUtils.FILE_URL_PREFIX+resourceConfigBean.getLocalPathForWin());
 
        }else {
            registry.addResourceHandler(resourceConfigBean.getResourcepathPattern())
                    .addResourceLocations(ResourceUtils.FILE_URL_PREFIX+resourceConfigBean.getLocalPathForLin());
        }
     }
}
```
- 运行。。。。。
3.跨域配置

首先知道同源和跨域是什么？

1.同源策略

        同源策略是一种约定，它是浏览器最核心也最基本的安全功能，如果缺少了同源策略，则浏览器的正常功能可能都会受到影响。可以说Web是构建在同源策略基础之上的，浏览器只是针对同源策略的一种实现。它是一个安全策略。所有支持JavaScript的浏览器都会使用这个策略

        满足同源的三个条件：
        所谓同源是指，域名、协议、端口相同。

2.跨域

        跨域：指的是浏览器不能执行其他网站的脚本。它是由浏览器的同源策略造成的，是浏览器对javascript施加的安全限制。
注意：跨域限制访问，其实是浏览器的限制

3.解决方案

        1.页面：访问不同源的东西

        2.后端：在配置类中去实现接口的方法，设置所有的源
```
     @Override
        public void addCorsMappings(CorsRegistry registry) {
            registry.addMapping("/**")
                    .allowedOrigins("*")
                    .allowedOriginPatterns("*")
                    .allowedMethods("*")
                    .maxAge(3600);
        }
```
我会继续更新，有需要完整版笔记的猿猿可以在点击下面的地址在语雀app中去获取哟：

语雀：

https://www.yuque.com/docs/share/10a4736b-ac41-41d3-961a-273c4cb6c6c7?# 《springBoot阶段学习》密码：ggc4
相关阅读:
解决：第一次用python的pip报错
 LeetCode 1624. 两个相同字符之间的最长子字符串
 STM32F4X RNG随机数发生器
 FlinkSQL-- sql-client及源码解析 -- flink-1.13.6
Python机器学习库scikit-learn介绍_矩阵运算_Numpy_Pandas---人工智能工作笔记0016
SpringSecurity基础：CSRF攻击原理
 Shell脚本学习指南（三）——文本处理工具
 《Kafka 源码实战》看完面试不慌！
2022年各大企业java面试题解析，堪称全网最详细的java面试指南
 设计模式-10--多例模式（Multition pattern）
原文地址：https://blog.csdn.net/weixin_46048259/article/details/126489835

1.简介

2.特性***

3.为什么要使用 SpringBoot ？

4.Mvc、Boot、Cloud

5.对比以及打包

6.spring Boot概述

7.springBoot起步依赖

二、spring Boot项目和仓库

1.创建spring Boot项目步骤

2.springBoot必须掌握的注解

3.克隆git仓库，并上传文件

4.git 仓库的命令

5.仓库的类型***

三、REST 风格

1.REST简介

2.RESTful入门案例

3.REST快速开发

4.案例：基于RESTful页面数据交互

四.注释的正确写法

五、运行方式

1.Main 方法运行；

2.Java 命令运行；

3.外置 Servlet 容器运行；

4.内置 Tomcat 和外置 Tomcat 的区别；

六、常用的注解

七、Banner

1.简介

2.应用

3.关闭 Banner

八、文件配置、接口、读取、日志

1.配置文件

1.1种类

1.2 编码

2.测试接口

2.1.application.properties

2.2 application.yml

2.3 优先级

3.读取配置文件内容

3.1.使用@Value属性

3.2.使用配置文件整个读取

4.加入日志

4.1.配置logback.xml文件

4.2 全局application.properties配置

4.3.添加 Log 测试接口

九、 yaml

1.YAML的简介

2.YAML的语法规则

3.yaml数组数据

4 yaml的读取数据的方式

4.1.读取单个数据的方式

4.2.封装数据到Environment对象，使用环境

4.3.自定义对象指定数据，装进实体类中去

十、多环境启动

1.多环境配置方式

1.1： ---三个横线分隔

1.2： 使用不过时的写法

1.3：properties文件多环境启动（不用，老格式）

2.多环境启动的命令格式

3.参数加载优先级

4.多环境开发

5.maven与springboot多环境兼容

6. 配置文件分类

十一、热部署

1.Pom 引入 Jar；

2.配置

3.应用

十二、Http & Https 配置

1.简介

2.Https 通讯时序图

3.http、https

十三、SSL 证书

1.简介

2.获取方式

3.步骤

3.1.在C盘用户那里生成.keystore

3.2.在全局配置文件中配置

3.3.配置端口，在全局配置文件

3.4.编写配置类

十四、访问静态资源

1.2：使用不过时的写法