小小卷王

框架学习 ---- SpringBoot

SpringBoot

博主个人博客已经搭建好，可以移步访问 http://lss-coding.top/
本文图片丢失，后期有时间在补充上

1. SpringBoot 简介

官方文档：https://spring.io/projects/spring-boot
中文文档：https://www.springcloud.cc/spring-boot.html

SpringBoot 就是一个 javaweb 开发框架，与 SpringMVC 类似，相较于其他框架好处，简化开发，约定大于配置，能够迅速开发 web 应用。

所有的技术框架的发展似乎都遵循了一条主线规律：从一个复杂应用场景衍生一种规范框架，只需要进行各种配置而不需要自己去实现，这时候强大的配置功能成了优点；发展到一定程度后，根据实际生产应用情况，选取其中实用功能和设计精华，重构出一些轻量级的框架，之后为了提高开发效率，嫌弃原先的各类配置过于麻烦，于是开始提倡 约定大于配置，进而衍生出一些一站式的解决方案。

随着 Spring 不断的发展，涉及的领域越来越多，项目整合开发需要配合各种各样的文件，慢慢变得不那么易用简单，违背了最初的理念，甚至人称配置地狱。SpringBoot 正是在这样的一个背景下被抽象出来的开发框架，目的为了让大家更容易的使用 Spring，更容易的集成各种常用的中间件，开源软件。

Spring Boot 基于Spring 开发，SpringBoot 本身并不提供 Spring 框架的核心特性以及扩展功能，只是用于快速，敏捷地开发新一代基于 Spring 框架的应用程序。也就是说，它并不是用来替代 Spring 的解决方案，而是和 Spring 框架紧密结合用于提升 Spring 开发者体验的工具。SpringBoot以约定大于配置的核心思想，默认帮我们进行了很多设置，多数 SpringBoot 应用只需要很少的 Spring 配置。同时它集成了大量常用的第三方库配置，例如：Redis，MongoDB 等，SpringBoot 应用中这些第三方库几乎可以零配置的开箱即用。

简单来说 SpirngBoot 不是什么新的框架，它默认配置了很多框架的使用方式，就像 maven 整合了所有的 jar 包，SpringBoot 整合了所有的框架。生态完善。

主要优点：

为所有 Spring 开发者更快的入门
开箱即用，提供各种默认配置来简化项目配置
内嵌式容器简化 web 项目
没有冗余代码生成和 xml 配置的要求

2. 微服务介绍

2.1 什么是微服务

随着互联网的发展，网站应用的规模不断扩大，常规的垂直应用框架已无法应对，分布式框架以及流行计算框架势在必行，需要一个治理系统确保框架有条不紊的演进。

微服务就是一种框架风格，要求我们在开发一个应用的时候，这个应用必须构建成一系列小服务的组合，可以通过 http 的方式进行互通，要说微服务架构，先说单体应用框架。

单一应用框架

所谓单体应用框架(all in one)是指我们将一个应用中的所有应用服务封装在一个应用中。

无论什么系统，都把数据库访问，web访问等各个功能放到一个 war 包中
- 优点：易于开发和测试，十分方便部署，当需要扩展时只需要将 war 复制多份然后放到多个服务器上再做个负载均衡就可以了
- 缺点：要修改一个非常小的地方都需要停掉整个服务重新打包，部署这个应用 war 包。特别是对于一个大型应用我们不可能把所有内容都放在一个应用里面，这样维护，分工合作都是问题。
垂直应用框架

当访问量逐渐增大，单一应用增加机器带来的加速度越来越小，提升效率的方法之一是将应用拆成互不相干的几个应用，以提升效率。此时，用于加速前端页面开发的 web 框架(MVC)是关键
分布式服务框架

当垂直应用越来越多，应用之间交互不可避免，将核心业务抽取出来，作为独立的服务，逐渐形成稳定的服务中心，使前端应用能更快速的响应多变的市场需求。此时，用于提高业务复用及整合的分布式服务框架(RPC)是关键。
流动计算架构

当服务越来越多，容量的评估，小服务资源的浪费等问题逐渐显现，此时需增加一个调度中心基于访问压力实时管理集群容量，提高集群利用率。此时，用于提高机器利用率的资源调度和治理中心(SOA)是关键。
微服务架构

all in one的架构方式，我们把所有的功能单元放在一个应用里面。然后我们把整个应用部署到服务器上。如果负载能力不行，我们将整个应用进行水平复制，进行扩展，然后在负载均衡。

所谓微服务架构，就是打破之前all in one的架构方式，把每个功能元素独立出来。把独立出来的功能元素的动态组合，需要的功能元素才去拿来组合。需要多一些时可以整合多个功能元素。所以微服务架构是对功能元素进行复制,而没有对整个应用进行复制。

**好处：**节省了调用资源；每个功能元素的服务调度是一个可替换的，可独立升级的软件代码。

这篇文章阐述了什么是微服务：

原文地址：https://www.martinfowler.com/articles/microservices.html
翻译：https://www.cnblogs.com/liuning8023/p/4493156.html

2.2 如何构建微服务

一个大型系统的微服务框架就像一个复杂交织的神经网络，每一个神经元素就是一个功能元素，它们各自完成自己的功能，然后通过 http 相互请求调用。比如一个电商系统，查缓存、连接数据库、浏览页面、结账、支付等服务都是一个个独立的功能服务，被微服务了，它们作为一个个微服务共同构建了一个庞大的系统，如果修改其中一个功能，只需要更新升级其中一个功能服务单元就可以。

但是这种庞大的系统架构给部署和运维带来很大的难度，于是 Spring 为我们带来了构建大型分布式微服务的全套，全程产品：

构建一个个功能独立的微服务应用单元，可以使用 SpringBoot，可以快速构建一个应用
大型分布式网络服务的调用，可以由 SpringCloud 完成，实现分布式
在分布式中间，进行流式数据计算、批处理可以使用：SpringCloud data flow
Spring 想清楚了从开始构建应用到大型分布式应用全流程方案

3. 第一个 SpringBoot 程序

3.1 官网创建项目

https://spring.io

下载好的 zip 压缩包解压后，打开 idea import 就可以使用了

删掉无用的文件就行

启动测试访问 8080 端口就可以了，因为是初始化的项目，所以会访问 localhost:8080/error

新建文件夹 controller ，新建 HelloSpringBoot.java

@Controller
public class HelloSpringBoot {

    @RequestMapping("/hello")
    @ResponseBody
    public String hello(){
        return "first SprongBoot Project";
    }
}

然后启动访问这个接口即可

3.2 idea 创建

至此创建完成

项目结构分析：


<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.0modelVersion>
    
    <parent>
        <groupId>org.springframework.bootgroupId>
        <artifactId>spring-boot-starter-parentartifactId>
        <version>2.4.2version>
        <relativePath/> 
    parent>
    <groupId>com.examplegroupId>
    <artifactId>springboot-01-helloworldartifactId>
    <version>0.0.1-SNAPSHOTversion>
    <name>springboot-01-helloworldname>
    <description>Demo project for Spring Bootdescription>
    <properties>
        <java.version>1.8java.version>
    properties>
    <dependencies>
        
        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starter-webartifactId>
        dependency>
        
        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starter-testartifactId>
            <scope>testscope>
        dependency>
    dependencies>

    <build>
        <plugins>
            
            <plugin>
                <groupId>org.springframework.bootgroupId>
                <artifactId>spring-boot-maven-pluginartifactId>
            plugin>
        plugins>
    build>
project>

3.2.1 测试 HelloSpringBoot

在主程序的同级目录下新建 controller，一定在同级目录下，否则识别不到

HelloSpringBoot.java

@RestController
public class HelloSpringBoot {
    @RequestMapping("/hello")
    public String hello(){
        return "Hello,World";
    }
}

测试访问

3.3 将项目打成 jar 包

如果遇到错误，可以配置打包时跳过项目运行测试用例：


<plugin>
    <groupId>org.apache.maven.pluginsgroupId>
    <artifactId>maven-surefire-pluginartifactId>
    <configuration>
        
        <skipTests>trueskipTests>
    configuration>
plugin>

打包完成后，会在 target 目录下生成一个 jar 包

3.4 修改项目的端口号

3.5 更改启动时控制台显示的图案

在 resources 目录下新建一个 banner.txt 文件

https://www.bootschool.net/ascii 这个网站可以生成，也可以上百度搜索拷贝到 banner.txt 中即可

4. 执行原理

4.1 pom.xml 文件中的jar包版本管理

spring-boot-dependencies：核心依赖在父工程中

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-6KjfKkGT-1628259661085)(C:\Users\lishisen\AppData\Roaming\Typora\typora-user-images\image-20210617112226390.png)]

按住 Ctrl 点进去就可以

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-6FcYB0aH-1628259661086)(C:\Users\lishisen\AppData\Roaming\Typora\typora-user-images\image-20210617112257888.png)]

同样的方法再次点进去就可以看到大量的 jar 包的版本管理信息了。我们在写或者引入一些 SpringBoot 依赖的时候，不需要指定版本，因为有这些版本仓库。

启动器

启动器说白了就是 SpringBoot 的启动场景；比如 spring-boot-starter-web，他就会帮我们自动导入web环境的所有的依赖，springboot会将所有的功能场景都变成一个个的启动器。需要使用什么功能，就需要找到相对应的启动器就可以了。
```
<dependency>
     <groupId>org.springframework.bootgroupId>
     <artifactId>spring-boot-starter-webartifactId>
dependency>
```

4.2 启动类

//@SpringBootApplication：标注这个类是一个 springboot 的应用
@SpringBootApplication
public class Springboot01HelloworldApplication {

    public static void main(String[] args) {
    //将springboot应用启动
        SpringApplication.run(Springboot01HelloworldApplication.class, args);
    }
}

按住 Ctrl 点 @SpringBootApplication 进去源码
```
@SpringBootConfiguration：springboot的配置
    @Configuration：spring配置类
    	@Component：说明这个也是一个 spring 组件
@EnableAutoConfiguration：自动配置
    @AutoConfigurationPackage：自动配置包
    	@Import({Registrar.class})：自动配置`包注册`
    @Import({AutoConfigurationImportSelector.class})：自动配置导入选择
    
 //获取所有的配置
List<String> configurations = 		     this.getCandidateConfigurations(annotationMetadata, attributes);
//获取候选的配置
protected List<String> getCandidateConfigurations(AnnotationMetadata metadata, AnnotationAttributes attributes) {
    //首先通过加载器加载所有的配置
        List<String> configurations = 
            SpringFactoriesLoader.loadFactoryNames(this.getSpringFactoriesLoaderFactoryClass(), this.getBeanClassLoader());
        Assert.notEmpty(configurations, "No auto configuration classes found in META-INF/spring.factories. If you are using a custom packaging, make sure that file is correct.");
        return configurations;
    }
```
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-S7Wi3eWW-1628259661087)(C:\Users\lishisen\AppData\Roaming\Typora\typora-user-images\image-20210617123325396.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-65yNFEJK-1628259661089)(C:\Users\lishisen\AppData\Roaming\Typora\typora-user-images\image-20210617123656887.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Kwl97iX1-1628259661090)(C:\Users\lishisen\AppData\Roaming\Typora\typora-user-images\image-20210617124813243.png)]

总结：springboot 所有的自动配置都是在启动的时候扫描并加载：spring.factories所有的自动配置类都在这里面，但是不一定生效，要判断条件是否成立，只要导入了对应的start，就有对应的启动器了，有了启动器，我们自动装配就会生效，然后就配置成功！
1. springboot 在启动的时候从类路径下 /META-INF/spring.factories 获取指定的值；
2. 将这些自动配置的类导入容器，自动配置类就会生效，帮我们进行自动配置
3. 以前我们需要自动配置的东西，现在springboot 帮我们做了！
4. 整个 javaEE，解决方案和自动配置的东西都在 spring-boot-autoconfigure-X.X.X.RELEASE.jar这个包下
5. 它会把所有需要导入的组件，以类名的方式返回，这些组件就会被添加到容器；
6. 容器中也会存在很多的 XXXAutoConfiguration 的文件(@Bean)，就是这些类给容器中导入了这个场景需要的所有组件，并自动配置，@Configuration
7. 有了自动配置类，就免去了手动编写配置注入功能组件等的工作

4.3 启动类的run方法

在springboot 中启动程序后不只是运行了一个main方法，而是开启了一个服务；

SpringApplication，这个类做了四件事情
1. 推断应用的类型是普通的项目还是 web 项目
2. 查找并加载所有的可用的初始化器，设置 initializers 属性中
3. 找出所有的应用程序监听器(全局存在)，获取上下文处理 Bean，全面接管springmvc的配置设置到 listeners 属性中
4. 推断并设置 main 方法的定义类，找到运行的主类

5. yaml 配置注入

在 SpringBoot 中使用一个全局的配置文件，配置文件的名称是固定的

application.properties

key=value
application.yml

key:空格value

**配置文件作用：**修改 SpringBoot 自动配置的默认值，因为 SpringBoot 在底层都给我们自动配置好了。

5.1 yaml 基础语法

这种语言以数据作为中心，而不是以标记语言为重点。

以前的配置文件大多数都是用 xml 配置：

xml
```
<server>
    <port>8080<port>
server>
```
yaml
```
server：
  prot: 8080
```

语法要求严格

空格不能省略

以缩进来控制层级关系

属性和值的大小写敏感

注意：

双引号不会转义字符串里面的特殊字符

name: “name \n aaa” 输出：name \n aaa

单引号会转义特殊字符

name: “name \n aaa” 输出：name 换行 aaa

# 1. 普通值，int，boolean，string ...
  字符串默认不用加引号
name: li
# 2. 对象，Map格式
student:
  name: li
  age: 20
# 行内写法
student: {name: li,age: 20}
# 3. 数组(List,Set)
pets:
  - cat
  - dog
  - pig
# 行内写法
pets: [cat,dog,pig]
#修改SpringBoot默认端口号
server:
  port: 8081

5.2 yaml 注入配置文件

创建一个 SpringBoot

编写实体类

@Component//注册bean 到容器中
public class Dog {

    @Value("小黄")
    private String name;
    @Value("20")
    private Integer age;
    //省略 有无参构造，get/set 方法，toString方法
}

之前给 bean 注入属性值方法，@Value

@Component//注册bean 到容器中
public class Dog {

    @Value("小黄")
    private String name;
    @Value("20")
    private Integer age;
}

在 SpringBoot 的测试类下注入测试输出

@SpringBootTest
class Springboot02ConfigApplicationTests {

    @Autowired//将 Dog 自动注入进来
    Dog dog;
    @Test
    void contextLoads() {
        System.out.println(dog);
    }
}

结果成功输出，这是以前属性注入值的方法 @Value

新建 Person.java 类较复杂，引用 Dog 类

/*
    @ConfigurationProperties作用：
    将配置文件中配置的每一个属性的值映射到这个组件中
    告诉 SpringBoot 将本类中的所有属性和配置文件中相关的配置进行绑定
    参数：prefix = "person"：将配置文件中的 person 下面的所有属性一一对应
*/
@Component
@ConfigurationProperties(prefix = "person")
public class Person {
    private String name;
    private Integer age;
    private Boolean happy;
    private Date birthday;
    private Map<String,Object> maps;
    private List<Object> lists;
    private Dog dog;
    //省略 有无参构造，get/set方法，toString 方法
}

在 resources 下创建 application.yaml 配置文件进行注入。

person:
  name: li
  age: 20
  happy: false
  birthday: 2001/01/01
  maps: {k1: v1,k2: v2}
  lists:
    - music
    - dance
  dog:
    name: 小黄
    age: 1

提示：SpringBoot 配置注解处理器没有找到，需要进入官方文档导入依赖

有的之后官网可能进不去


<dependency>
  <groupId>org.springframework.bootgroupId>
  <artifactId>spring-boot-configuration-processorartifactId>
  <optional>trueoptional>
dependency>

配置好之后测试类测试

@SpringBootTest
class Springboot02ConfigApplicationTests {

    @Autowired//将 person 自动注入进来
    Person person;
    @Test
    void contextLoads() {
        System.out.println(person);
    }
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-U7CwBUYt-1628259661093)(D:\notes\note\SpringBoot\SpringBoot.assets\image-20210130122808661.png)]

加载 .properties 配置文件

新建 prop.properties 文件
```
name=小黄
```

Dog.java 类中注入

@PropertySource(value = "classpath:prop.properties")
@Component//注册bean 到容器中
public class Dog {

    @Value("${name}")
    private String name;
    private Integer age;
    //省略 有无参构造，get/set 方法,toString 方法
}

测试

输出中文会有乱码问题

File – setting – FileEncodings 进行设置

可以使用占位符

person:
	#${random.int} 
  name: li${random.int} 
  #${person.birthday}
  age: 20${person.birthday}_岁
  happy: false
  birthday: 2001/01/01
  maps: {k1: v1,k2: v2}
  lists:
    - music
    - dance
  dog:
    name: 小黄
    age: 1

5.3 总结

	@ConfigurationProperties	@Value
功能	批量注入配置文件中的属性	一个个指定
松散绑定	支持	不支持
SPEL	不支持	支持
JSR303数据校验	支持	不支持
复杂性类型封装	支持	不支持

@ConfigurationProperties只需要写一次即可， @Value每个字段都添加
松散绑定：yaml 中写的 last-name(实体类lastName)，这个和 lastName 是一样的，- 后面跟着的字母默认是大写的，这就是松散绑定
JSR303 数据校验，就是在字段增加一层过滤器验证，可以保证数据的合法性
复杂类型封装，yaml 可以封装对象，value 不支持

yaml properties 都可以获取值，但是推荐使用yaml

如果需要获取某个文件中的某一个值可以使用 @Value

但是如果编写一个 javaBean 来配置文件进行一一映射，直接使用 @ConfigurationProperties

6. JSR 303 数据校验

@Component //注册bean
@ConfigurationProperties(prefix = "person")
@Validated  //数据校验
public class Person {
    @Email(message="邮箱格式错误") //name必须是邮箱格式
    private String name;
}

运行结果在控制台，如果配置文件中 name 不是电子邮件地址

default message [不是一个合法的电子邮件地址];

使用数据校验可以保证数据的正确性

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-APCgBLWj-1628259661095)(C:\Users\lishisen\AppData\Roaming\Typora\typora-user-images\image-20210617160101281.png)]

常见参数：

@NotNull(message="名字不能为空")
private String userName;
@Max(value=120,message="年龄最大不能查过120")
private int age;
@Email(message="邮箱格式错误")
private String email;
 
 
空检查
@Null       验证对象是否为null
@NotNull    验证对象是否不为null, 无法查检长度为0的字符串
@NotBlank   检查约束字符串是不是Null还有被Trim的长度是否大于0,只对字符串,且会去掉前后空格.
@NotEmpty   检查约束元素是否为NULL或者是EMPTY.
    
Booelan检查
@AssertTrue     验证 Boolean 对象是否为 true  
@AssertFalse    验证 Boolean 对象是否为 false  
    
长度检查
@Size(min=, max=) 验证对象（Array,Collection,Map,String）长度是否在给定的范围之内  
@Length(min=, max=) string is between min and max included.
 
 
日期检查
@Past       验证 Date 和 Calendar 对象是否在当前时间之前  
@Future     验证 Date 和 Calendar 对象是否在当前时间之后  
@Pattern    验证 String 对象是否符合正则表达式的规则
 
 
.......等等
除此以外，我们还可以自定义一些数据校验规则

7. 多配置文件

在主配置文件中编写的时候，文件名可以是 application-{profile}.properties/yaml，用来指定多个环境版本。

4 个位置优先级：

使用 properties 配置文件需要建立多个文件

#比如在配置文件中指定使用dev环境，我们可以通过设置不同的端口号进行测试；
#我们启动SpringBoot，就可以看到已经切换到dev下的配置了；
spring.profiles.active=dev

yaml 的多文档

不需要建立多个文档

#选择激活那个模块
spring:
  profiles:
    active: test
---
server:
  port: 8081
spring:
  profiles:test

---
server:
  port: 8082
spring:
  profiles: dev  #配置环境的名称

---
server:
  port: 8083
spring:
  profiles: prod  #配置环境的名称

8. yaml配置文件原理

配置文件到底能写什么？

进入源码 spring.factories 文件，找到 HttpEncodingAutoConfiguratin.class 类进入

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-cLhnv2ae-1628259661099)(C:\Users\lishisen\AppData\Roaming\Typora\typora-user-images\image-20210617202253592.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ll0LDkL6-1628259661100)(C:\Users\lishisen\AppData\Roaming\Typora\typora-user-images\image-20210617202545066.png)]

@Conditional扩展注解	作用(判断是否满足当前指定条件)
@ConditionalOnJava	系统的Java版本是否符合要求
@ConditionalOnBean	容器中存在指定Bean
@ConditionalOnMissingBean	容器中不存在指定Bean
@ConditionalOnExpression	满足SpEL表达式指定
@ConditionalOnClass	系统中有指定的类
@ConditionalOnMissingClass	系统中没有指定的类
@ConditionalOnSingleCandidate	容器中只有一个指定的Bean，或者这个Bean是首选Bean
@ConditionalOnProperty	系统指定的属性是否有指定的值
@ConditionalOnResource	类路径下是否存在指定资源文件
@ConditionalOnWebApplication	当前是web环境
@ConditionalOnNotWebApplication	当前不是web环境
@ConditionalOnJndi	JNDI存在指定项

自动装配的原理：

SpringBoot 启动会加载大量的自动配置类

我们看我们需要的功能有没有在 SpringBoot默认写好的自动配置类当中

我们再看这个自动配置类中到底配置了那些组件；(只要我们要用的组件存在其中，我们就不需要再手动配置了)

给容器中自动配置类添加组件的时候，会从properties类中获取某些属性，我们只需要在配置文件中指定这些属性的值即可

XXXAutoConfiguration：自动配置类；给容器中添加组件

XXXProperties：封装配置文件中相关属性
在我们这配置文件中能配置的东西，都存在一个固定的规律
XXXAutoConfiguration：会有默认值，如果需要使用修改在-->XXXProperties文件中修改
@ConfigurationProperties(prefix = "server") 这里绑定配置文件
这样我们就可以使用自定义的配置了

每一个XXXAutoConfiguration 类都是容器中的一个组件，最后都加入到容器中；用他们来做自动配置；
每一个自动配置类可以进行自动配置功能；
根据当前不同的条件判断，决定这个配置类是否生效
一旦这个配置类生效；这个配置类就会给容器中添加各种组件；这些组件的属性是从对应的properties 类中
获取的，这些类里面的每一个属性又是和配置文件绑定的；
所有在配置文件中能配置的属性都是在XXXProperties类中封装；配置文件能配置什么就可以参照某个功能对应的属性类

debug: true 可以通过这个查看哪些配置生效，那些不生效

9. 静态资源

9.1 通过 webjars 得到静态文件

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ecbRGYh7-1628259661100)(C:\Users\lishisen\AppData\Roaming\Typora\typora-user-images\image-20210618091620969.png)]

找到WebMvcAutoConfiguration.class 类，并找到方法：

//添加静态资源方法
public void addResourceHandlers(ResourceHandlerRegistry registry) {
    	//这个判断，如果在yaml中添加属性则不生效，有(spring.mvc.servlet.path="...")
       if (!this.resourceProperties.isAddMappings()) {
             logger.debug("Default resource handling disabled");
       } else {
            //只要是 "/webjars/**" 都会去 "classpath:/META-INF/resources/webjars/" 这里面找
            this.addResourceHandler(registry, "/webjars/**", "classpath:/META-INF/resources/webjars/");
            this.addResourceHandler(registry, this.mvcProperties.getStaticPathPattern(), (registration) -> {
            registration.addResourceLocations(this.resourceProperties.getStaticLocations());
            if (this.servletContext != null) {
                 ServletContextResource resource = new ServletContextResource(this.servletContext, "/");
                    registration.addResourceLocations(new Resource[]{resource});
             }

         });
     }
}

在这里可以通过maven的方式引入jquery 等

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-K8zu9xwW-1628259661101)(C:\Users\lishisen\AppData\Roaming\Typora\typora-user-images\image-20210618094739745.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-RVXbbBRn-1628259661102)(C:\Users\lishisen\AppData\Roaming\Typora\typora-user-images\image-20210618095020090.png)]

9.2 通过路径访问resources下的文件

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-03xq9oaO-1628259661103)(C:\Users\lishisen\AppData\Roaming\Typora\typora-user-images\image-20210618100306688.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-s7P1kC6W-1628259661105)(C:\Users\lishisen\AppData\Roaming\Typora\typora-user-images\image-20210618101343005.png)]

优先级：/resources > /static > /public

总结
1. 在springboot 中，我们可以使用下面方式处理静态资源
  - webjars
  - public，static，/**，resources
2. 优先级：resources > static > public

10. 简单网站开发

10.1 首页定制

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-aMRuRiya-1628259661106)(C:\Users\lishisen\AppData\Roaming\Typora\typora-user-images\image-20210618114448364.png)]

10.2 网站图标

2.2.0之前的版本可以在源码中找到 setFavico 方法，之后找不见了，只需要将 favico.ico 文件放到静态资源路径下就可以使用了。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-rhHtRU3a-1628259661108)(C:\Users\lishisen\AppData\Roaming\Typora\typora-user-images\image-20210618150128592.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-5EmiZTca-1628259661109)(C:\Users\lishisen\AppData\Roaming\Typora\typora-user-images\image-20210618150138082.png)]

11. 模板引擎

11.1 模板引擎介绍

前端交给我们的页面，是html页面。如果我们以前开发，我们需要把他们转换成jsp页面，jsp好处就是当我们查出一些数据转发到jsp页面以后，我们可以用jsp轻松实现数据的显示，及交互等。jsp支持非常强大的功能，包括能写java代码，但是，我们现在的这种情况，SpringBoot 这个项目首先是以jar的方式，不是war，其次，我们用的还是嵌入式的Tomcat，所以，他现在默认是不支持jsp的。

SpringBoot 推荐可以使用模板引擎。其实 jsp 就是一个模板引擎，还有用的比较多的freemarker，包括SpringBoot推荐使用的Thymeleaf，模板引擎有很多，但他们的思想都是一样。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-4d5l628p-1628259661110)(C:\Users\lishisen\AppData\Roaming\Typora\typora-user-images\image-20210618150735748.png)]

模板引擎的作用就是我们来写一个页面模板，比如有些值是动态的，我们写一些表达式。而这些值，从哪来呢？我们来组装一些数据，我们把这些数据找到，然后把这个模板和这个数据交给我们模板引擎，模板引擎按照我们这个数据帮你把表达式解析、填充到我们指定的位置，然后把这个数据最终生成一个我们想要的内容给我们写出去，这就是模板引擎，不管是jsp还是其他的，都是这个思想。只不过是模板引擎之间的语法有点不一样。

11.2 thymeleaf 引入

首先需要引入 thymelead

Thymeleaf 官网：https://www.thymeleaf.org/
Thymeleaf 在Github的主页：https://github.com/thymeleaf/thymeleaf
Spring官方文档：https://docs.spring.io/spring-boot/docs/2.1.6.RELEASE/reference/htmlsingle/#using-boot-starter

从github 找到依赖引入到 springboot 项目中

		
        <dependency>
            <groupId>org.thymeleafgroupId>
            <artifactId>thymeleaf-spring5artifactId>
        dependency>
        <dependency>
            <groupId>org.thymeleaf.extrasgroupId>
            <artifactId>thymeleaf-extras-java8timeartifactId>
        dependency>

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-9yeHipOU-1628259661111)(C:\Users\lishisen\AppData\Roaming\Typora\typora-user-images\image-20210618154346358.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-1rMYQh0I-1628259661112)(C:\Users\lishisen\AppData\Roaming\Typora\typora-user-images\image-20210618154519333.png)]

**总结：**只要需要使用thymeleaf，只需要导入对应的依赖就可以了，我们将html放在我们的templates目录

public static final String DEFAULT_PREFIX = "classpath:/templates/";

public static final String DEFAULT_SUFFIX = ".html";

11.2 Thymeleaf 基本语法

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-keQxKHIu-1628259661113)(C:\Users\lishisen\AppData\Roaming\Typora\typora-user-images\image-20210618160545349.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-8qf5PDIw-1628259661114)(C:\Users\lishisen\AppData\Roaming\Typora\typora-user-images\image-20210618163014887.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-m01HLhM1-1628259661114)(C:\Users\lishisen\AppData\Roaming\Typora\typora-user-images\image-20210618163108894.png)]

12. 扩展MVC

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-C8lE3dUz-1628259661115)(C:\Users\lishisen\AppData\Roaming\Typora\typora-user-images\image-20210619080950616.png)]

如果我们要自己定制一个视图解析器，我们要做的就是编写一个 @Configuration 注解类，并且类型要为 WebMvcConfigurer，还不能标注 @EnableWebMvc 注解。

//如果想要自己定制一些功能，只要写这个组件，然后将他交给springboot，springboot会帮我们自动装配
//全部扩展springmvc
//首先注解为一个配置类
@Configuration
public class MyMvcConfig implements WebMvcConfigurer {

    //ViewResolver 实现了视图解析器接口类，我们就可以把它看作试图解析器
    @Bean
    public ViewResolver myViewResolver(){
        return new MyViewResolver();
    }

    //自定义一个自己的视图解析器MyViewResolver
    //实现了 ViewResolver 接口的类，我们就可以叫他视图解析器
    public static class MyViewResolver implements ViewResolver{
        @Override
        public View resolveViewName(String s, Locale locale) throws Exception {
            return null;
        }
    }
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-tOJHB90v-1628259661116)(C:\Users\lishisen\AppData\Roaming\Typora\typora-user-images\image-20210619083822991.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-sV3WbSgG-1628259661117)(C:\Users\lishisen\AppData\Roaming\Typora\typora-user-images\image-20210619083917697.png)]

这么多的自动配置，原理都是一样。

SpringBoot 在自动配置很多组件的时候，先看容器中有没有用户自己配置的(如果用户自己配置@Bean)，如果有就用用户配置的，如果没有就用自动配置的；如果有些组件可以存在多个，比如我们的视图解析器，就将用户配置的和自己默认的结合起来。

在springboot中，有很多的 XXXX Configuration 帮助我们进行扩展配置，只要看见了这个东西，我们就要注意看一下扩展了什么东西。

13. 国际化

在resources下建立文件夹 i18n，然后建立配置文件

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-czMYFrmj-1628259661118)(C:\Users\lishisen\AppData\Roaming\Typora\typora-user-images\image-20210619123935062.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-sbWaJ77D-1628259661118)(C:\Users\lishisen\AppData\Roaming\Typora\typora-user-images\image-20210619124049253.png)]

在 application.properties，里面设置本地的国际化的真实位置

# 设置本地国际化文件的真实位置
spring.messages.basename=i18n.login

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-omuHN7vx-1628259661119)(C:\Users\lishisen\AppData\Roaming\Typora\typora-user-images\image-20210619125013389.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Z9z0KAJv-1628259661120)(C:\Users\lishisen\AppData\Roaming\Typora\typora-user-images\image-20210619125510074.png)]

创建自己的国际化

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-7nrSfmr6-1628259661122)(C:\Users\lishisen\AppData\Roaming\Typora\typora-user-images\image-20210619125644720.png)]

创建一个类 MyLocaleResolver，并且注册到 spring 中使其生效

@Configuration
public class MyLocaleResolver implements LocaleResolver {
    
    //自定义的国际化生效
    @Bean
    public LocaleResolver localeResolver(){
        return new MyLocaleResolver();
    }
    
    //解析请求，国际化
    @Override
    public Locale resolveLocale(HttpServletRequest httpServletRequest) {
        //获取请求中的语言参数
        String lang = httpServletRequest.getParameter("l");
        Locale locale = Locale.getDefault();//如果没有就使用默认的
        //如果请求的链接携带了国际化的参数
        if (!StringUtils.isEmpty(lang)){
            String[] split = lang.split("_");
            locale = new Locale(split[0], split[1]);
        }
        return locale;
    }

    @Override
    public void setLocale(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Locale locale) {

    }
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-rwhvP0Uh-1628259661123)(C:\Users\lishisen\AppData\Roaming\Typora\typora-user-images\image-20210619132725236.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-wKr6xDNZ-1628259661124)(C:\Users\lishisen\AppData\Roaming\Typora\typora-user-images\image-20210619132742306.png)]

总结：

需要配置 i18n 文件

如果需要在项目中进行按钮自动切换，我要我们自定义一个组件 LocaleResolver

将自己写的组件配置到 spring 容器中：@Bean

14. 使用拦截器

创建一个拦截器类实现 HandlerInterceptor 接口

/**
 * 定义一个拦截器用于处理用户是否登录
 * 首先需要继承 HandlerInterceptor 接口，实现执行前过滤，用于判断session是否为空
 */
public class LoginHandlerInterceptor implements HandlerInterceptor {
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        Object userInfo = request.getSession().getAttribute("userInfo");
        if (userInfo == null){
            request.setAttribute("msg","没有权限，请先登录");
            request.getRequestDispatcher("/index.html").forward(request,response);
            return false;
        }else {
            return true;
        }
    }
}

将自己创建的拦截器注册到 spring 中

@Configuration
public class MyMvcConfig implements WebMvcConfigurer {
    //接管拦截器
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(new LoginHandlerInterceptor()).addPathPatterns("/**").
               excludePathPatterns("/index.html","/","/user/login","/css/**","/font/**","/img/**","/js/**");
    }
}

15. 整合数据库

对于数据访问层，无论是 SQL，还是 NOSQL，SpringBoot 底层都是采用 Spring Data 的方式进行统一处理的。

SpringBoot 底层都是采用 Spring Data 的方式进行统一处理各种数据库，Spring Data 也是Spring 中与SpringBoot、Spring Cloud 等齐名的知名项目。

Spring Data 官网：https://spring.io/projects/spring-data

SpringBoot 所有启动器链接：https://docs.spring.io/spring-boot/docs/current/reference/html/using.html#using.devtools

15.1 JDBC

创建好一个 springboot 项目，然后导入需要的依赖，也可以在创建时候选择依赖信息


<dependency>
    <groupId>org.springframework.bootgroupId>
    <artifactId>spring-boot-starter-webartifactId>
dependency>

<dependency>
    <groupId>org.springframework.bootgroupId>
    <artifactId>spring-boot-starter-jdbcartifactId>
dependency>

<dependency>
    <groupId>mysqlgroupId>
    <artifactId>mysql-connector-javaartifactId>
    <scope>runtimescope>
dependency>

首先需要建立 application.yml 配置文件，修改springboot 默认的配置信息

spring:
  datasource:
    username: root
    password: root
    url: jdbc:mysql://localhost:3306/studentgrade?useUnicode=true&characterEncoding=utf-8&serverTimezone=UTC
    driver-class-name: com.mysql.jdbc.Driver

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-AHW0kP9Z-1628259661125)(C:\Users\lishisen\AppData\Roaming\Typora\typora-user-images\image-20210620123049143.png)]

写具体的 Controller业务

@Controller
public class JDBCController {
    //导入 JDBCTemplate 模板，可以直接使用
    @Autowired
    JdbcTemplate jdbcTemplate;

    @RequestMapping("/list")
    @ResponseBody
    //得到表里面的信息，没有实体类，所以可以存储到 Map 中
    public List<Map<String, Object>> list(){
        String sql = "select * from course";
        List<Map<String, Object>> result = jdbcTemplate.queryForList(sql);
        return result;
    }
 	//删除一条记录，通过 localhost:8080/delete/4 进行删除即可   
    @RequestMapping("/delete/{cno}")
    @ResponseBody
    public void delete(@PathVariable("cno") Integer cno){
        String sql = "delete from course where cno = ?";
        jdbcTemplate.update(sql,cno);
    }
}

//在springboot test类中输出数据源的类型
@SpringBootTest
class Springboot05JdbcApplicationTests {
    @Autowired
    DataSource dataSource;
    @Test
    void contextLoads() throws SQLException {
        //查看一下默认的数据源
        System.out.println(dataSource.getClass());
        //获得数据库链接
        Connection connection = dataSource.getConnection();
        System.out.println(connection);
        connection.close();
    }
}

class com.zaxxer.hikari.HikariDataSource //结果是这个，springboot 默认是 hikari

15.2 DruidDataSource 自定义数据源

Druid 是阿里巴巴开源平台上一个数据库连接池实现，结合了 C3PO、DBCP、PROXOOL 等 DB 池的优点，同时加入了日志监控。

Druid 可以很好的监控 DB 连接池和 SQL 的执行情况，天生就是针对监控而生的 DB 连接池。

SpringBoot 2.0 以上默认使用 Hikari 数据源，可以说 Hikari 与 Druid 都是当前 JavaWeb 上最优秀的数据源。

首先要引入依赖

<dependency>
    <groupId>com.alibabagroupId>
    <artifactId>druidartifactId>
    <version>1.2.6version>
dependency>
<dependency>
    <groupId>log4jgroupId>
    <artifactId>log4jartifactId>
    <version>1.2.17version>
dependency>

然后修改 application.yml 配置文件的最后一行

spring:
  datasource:
    username: root
    password: root
    url: jdbc:mysql://localhost:3306/studentgrade?useUnicode=true&characterEncoding=utf-8&serverTimezone=UTC
    driver-class-name: com.mysql.jdbc.Driver
    # 修改数据源类型为 Druid
    type: com.alibaba.druid.pool.DruidDataSource

在 test 类中输出数据源的类型进行验证

@SpringBootTest
class Springboot05JdbcApplicationTests {
    @Autowired
    DataSource dataSource;
    @Test
    void contextLoads() throws SQLException {
        //查看一下默认的数据源
        System.out.println(dataSource.getClass());
        //获得数据库链接
        Connection connection = dataSource.getConnection();
        System.out.println(connection);
        connection.close();
    }
}

结果：class com.alibaba.druid.pool.DruidDataSource

自定义配置 Druid

首先要修改 application.yml 文件，配置监听过滤等属性

spring:
  datasource:
    username: root
    password: root
    url: jdbc:mysql://localhost:3306/studentgrade?useUnicode=true&characterEncoding=utf-8&serverTimezone=UTC
    driver-class-name: com.mysql.jdbc.Driver
    type: com.alibaba.druid.pool.DruidDataSource

    #SpringBoot默认是不注入这些的，需要自己绑定
    #druid数据源专有配置
    initialSize: 5
    minIdle: 5
    maxActive: 20
    maxWait: 60000
    timeBetweenEvictionRunsMillis: 60000
    minEvictableIdleTimeMillis: 300000
    validationQuery: SELECT 1 FROM DUAL
    testWhileIdle: true
    testOnBorrow: false
    testOnReturn: false
    poolPreparedStatements: true

    #配置监控统计拦截的filters，stat：监控统计、log4j：日志记录、wall：防御sql注入
    #如果允许报错，java.lang.ClassNotFoundException: org.apache.Log4j.Properity
    #则导入log4j 依赖就行
    filters: stat,wall,log4j
    maxPoolPreparedStatementPerConnectionSize: 20
    useGlobalDataSourceStat: true
    connectionoProperties: druid.stat.mergeSql=true;druid.stat.slowSqlMillis=500

创建一个 DruidConfig 类

@Configuration
public class DruidConfig {

    //绑定 application.yml 配置文件
    @ConfigurationProperties(prefix = "spring.datasource")
    @Bean
    public DataSource druidDataSource(){
        return  new DruidDataSource();
    }
    //后台监控功能:web.xml ServletRegistrationBean,这个类会自动监控后台，生成一些可视化东西
    //因为 springboot 内置了 servlet 容器，所有没有web.xml，替代方法：servletRegistrationBean
    @Bean
    public ServletRegistrationBean statViewServlet(){
        //固定的代码，设置一个访问路径，一般为 /druid/
        ServletRegistrationBean<StatViewServlet> bean = new ServletRegistrationBean<>(new StatViewServlet(), "/druid/*");
        //后台需要有人登录，账号密码配置，都是固定的
        Map<String, String> initParameters = new HashMap<>();
        //增加配置
        initParameters.put("loginUsername","admin");//登录的 key 是固定的，loginUsername，loginPassword
        initParameters.put("loginPassword","123456");
        //允许谁能访问
        initParameters.put("allow","");//如果参数为空表示所有人可以访问，具体的具体能访问
        //禁止谁能访问
        //initParameters.put("li","192.168.1.1");//不重要
        bean.setInitParameters(initParameters);//设置初始化参数
        return bean;
    }
    // 自己配置过滤器filter
    @Bean
    public FilterRegistrationBean webStatFilter(){
        FilterRegistrationBean<Filter> bean = new FilterRegistrationBean<>();
        bean.setFilter(new WebStatFilter());
        //可以过滤哪些请求
        Map<String,String> initParameters = new HashMap<>();
        //这些东西不进行统计
        initParameters.put("exclusions","*.js,*.css,/druid/*");
        return bean;
    }
}

配置好之后可以通过 localhost:8080/druid 可以进入后台监控的页面，需要使用用户名密码进行登录，如果依赖中没有配置 log4j 的坐标是没办法看到效果，所以需要在 pom.xml 文件中进行 log4j 的引入

进入登录页面：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-v55xG83p-1628259661126)(C:\Users\lishisen\AppData\Roaming\Typora\typora-user-images\image-20210620134520843.png)]

这里可以看到刚才执行的sql语句

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-vyGtVG9U-1628259661127)(C:\Users\lishisen\AppData\Roaming\Typora\typora-user-images\image-20210620134604710.png)]

15.3 Mybatis 整合

首先整合mybatis 需要先导入依赖



    org.mybatis.spring.boot
    mybatis-spring-boot-starter
    2.1.1



    org.springframework.boot
    spring-boot-starter-jdbc



    mysql
    mysql-connector-java
    runtime

创建实体类，mapper接口，service，mapper.xml 文件

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-pfH0arl2-1628259661129)(C:\Users\lishisen\AppData\Roaming\Typora\typora-user-images\image-20210620162917946.png)]

在 application.properties 文件中配置数据源以及绑定Mapper.xml 文件

spring.datasource.username=root
spring.datasource.password=root
spring.datasource.url=jdbc:mysql://localhost:3306/studentgrade?serverTimezone=UTC&useUnicode=true&characterEncoding=utf-8
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver

# 整合 mybatis
# 别名设置
mybatis.type-aliases-package=com.example.pojo
# 扫描 xml 文件
mybatis.mapper-locations=classpath:mybatis/mapper/*.xml

实体类

public class Course {

    private Integer cno;
    private String cname;
    private Integer classHour;
	//省略 get、set方法
}

mapper接口

//这个注解表示是mybatis 的mapper
@Mapper
@Controller
public interface CourseMapper {

    //得到全部
    List<Course> getAll();

    //删除
    Integer delete(Integer cno);
}

服务层接口

public interface CourseService {

    //得到全部
    List<Course> getAll();

    //删除
    Integer delete(Integer cno);

}

服务层实现类

@Service
public class CourseServiceImpl implements CourseService {
    @Autowired
    CourseMapper courseMapper;
    @Override
    public List<Course> getAll() {
        List<Course> all = courseMapper.getAll();
        return all;
    }
    @Override
    public Integer delete(Integer cno) {
        return courseMapper.delete(cno);
    }
}

mapper.xml 文件


DOCTYPE mapper
  PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
  "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.example.mapper.CourseMapper">
  <select id="getAll" resultType="Course">
    select * from course
  select>
  <delete id="delete">
    delete from course where cno = #{cno}
  delete>
mapper>

Controller 层代码

@Controller
public class CourseController {
    @Autowired
    CourseService courseService;

    @RequestMapping("/getAll")
    @ResponseBody
    public List<Course> getAll(){
        List<Course> all = courseService.getAll();
        return all;
    }
    @RequestMapping("/delete/{cno}")
    @ResponseBody
    public String delete(@PathVariable("cno") Integer cno){
        Integer delete = courseService.delete(cno);
        if (delete > 0){
            return "删除成功";
        }
        return "失败";
    }
}

最后使用浏览器通过访问 localhost:8080/getAll 就可以得到表中的信息，通过 localhost:8080/delete/1 就可以实现删除操作

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-3cQUG1rT-1628259661130)(C:\Users\lishisen\AppData\Roaming\Typora\typora-user-images\image-20210620163432544.png)]

16. SpringSecurity

主要是为了简化，之前使用过滤器、拦截器比较繁琐，所有衍生出一些框架用于简化开发。

在 Web 开发中，安全是第一位的。

SpringSecurity 是针对 Spring 项目的安全框架，也是 SpringBoot 底层安全模块默认的技术造型，他可以实现强大的 Web 安全控制，对于安全控制，我们仅需要引入 spring-boot-starter-security模块，进行少量的配置，即可实现强大的安全管理。

WebSecurityConfigurerAdapter：自定义 Security 策略，需要继承
AuthenticationManagerBuilder：自定义认证策略
@EnableWebSecurity：开启 WebSecurity 模式，@EnableXXXXX就是开启某个功能

SpringSecurity 的两个主要目标是“认证(Authentication)”和“授权(访问控制Authorization)”，通用概念

Spring Security is a powerful and highly customizable authentication and access-control framework. It is the de-facto standard for securing Spring-based applications.

There is no PasswordEncoder mapped for the id “null”

16.1 使用–认证授权

导入依赖


<dependency>
    <groupId>org.springframework.bootgroupId>
    <artifactId>spring-boot-starter-securityartifactId>
dependency>

编写配置类

//1. 开启 WebSecurity 模式
@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {

    //采用的链式编程
    //2. 授权,重写 WebSecurityConfigurerAdapter 的 configure(HttpSecurity http) 方法
    @Override
    protected void configure(HttpSecurity http) throws Exception {
        //首页所有人可以访问，但是里面的功能页只有对应有权限的人才能访问
        //请求授权的规则
        // 采用链式编程来设置访问权限 hasRole 判断权限，permitAll() 表示所有权限
        http.authorizeRequests().antMatchers("/").permitAll()
                .antMatchers("/level1/**").hasRole("vip1")
                .antMatchers("/level2/**").hasRole("vip2")
                .antMatchers("/level3/**").hasRole("vip3");
        //没有权限需要跳到登录页，需要开启登录的页面
        http.formLogin();
        //方式网站攻击工具，关闭 csrf 功能，登录失败肯定存在的原因
        http.csrf().disable();
        //注销，开启了注销功能,注销后回到主页
        http.logout().logoutSuccessUrl("/");
    }

    //3. 认证
    // springboot 2.1.x 可以直接使用的
    // 如果不加编码会认为密码不安全，报错：There is no PasswordEncoder mapped for the id "null"
    // spring security 5.0+ 中新增加了很多的加密方法
    // 使用链式编程设置编码格式、用户名、密码、角色权限，可以使用 and() 连接多个
    @Override
    protected void configure(AuthenticationManagerBuilder auth) throws Exception {
        //数据正常应该从数据库中读取，这里是从内存中读取
        auth.inMemoryAuthentication().passwordEncoder(new BCryptPasswordEncoder())
                .withUser("li").password(new BCryptPasswordEncoder().encode("123456")).roles("vip2","vip3").and()
                .withUser("root").password(new BCryptPasswordEncoder().encode("123456")).roles("vip1","vip2","vip3").and()
                .withUser("guest").password(new BCryptPasswordEncoder().encode("123456")).roles("vip1");
    }
}

	 /** 	auth
	 * 	// enable in memory based authentication with a user named
	 * 	// "user" and "admin"
	 * 	.inMemoryAuthentication().withUser("user").password("password").roles("USER").and()
	 * 			.withUser("admin").password("password").roles("USER", "ADMIN");
	 * }**/ 源码给与说明

16.2 thymeleaf 整合 security 实现界面的分角色显示模块

首先引入整合包


        <dependency>
            <groupId>org.thymeleaf.extrasgroupId>
            <artifactId>thymeleaf-extras-springsecurity5artifactId>
            <version>3.0.4.RELEASEversion>
        dependency>

html 代码中引入命名空间

xmlns:sec="http://www.thymeleaf.org/thymeleaf-extras-springsecurity5"

编写代码



<div sec:authorize="!isAuthenticated()">
    <a class="item" th:href="@{/toLogin}">
        <i class="address card icon">i> 登录
    a>
div>

<div sec:authorize="isAuthenticated()">
    <a class="item">
        用户名： <span sec:authentication="name">span>
    a>
div>
<div sec:authorize="isAuthenticated()">
    <a class="item" th:href="@{/logout}">
        <i class="address card icon">i> 注销
    a>
div>


<div class="column" sec:authorize="hasRole('vip1')">

16.3 记住我

在 SecurityConfig 类的 onfigure(HttpSecurity http) 方法中添加如下一句代码

        //开启记住我功能,有效期2周
        http.rememberMe();

这样在登录页面下面会有一个选择框，如果选择则会记录登录的信息到 Cookie 中，就算关闭浏览器，重新访问也会生效的，有效期限 2周左右。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-qqjqHlk3-1628259661131)(C:\Users\lishisen\AppData\Roaming\Typora\typora-user-images\image-20210629124158250.png)]

16.4 自定义的首页

在 SecurityConfig 类的 onfigure(HttpSecurity http) 方法中添加如下一句代码

这里的参数修改表示如果页面的name属性不是 username或者 password 则根据修改的值进行接受参数

http.formLogin().loginPage("/toLogin").usernameParameter("name").passwordParameter("word");

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-NSb5HSGd-1628259661132)(C:\Users\lishisen\AppData\Roaming\Typora\typora-user-images\image-20210629131525067.png)]

17. Shiro

17.1 Shiro 简介

是一个 Java 的安全(权限)框架
Shiro 可以非常容易的开发足够好的应用，其不仅可以用在 JavaSE 环境，也可以用在 JavaEE 环境
可以完成认证、授权、加密、会话管理、web 集成、缓存等
下载地址：http://shiro.apache.org/

17.2 功能

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-EXKFMfyB-1628259661132)(C:\Users\lishisen\AppData\Roaming\Typora\typora-user-images\image-20210629160528790.png)]

Authentication: 身份认证、登录，验证，验证用户是不是拥有相应的身份
Authorization：授权，即权限验证，验证某个已认证的用户是否拥有某个权限，即判断用户能否进行什么操作，如：验证某个角色是否拥有某个角色，或者细粒度的验证某个用户对某个资源是否具有某个权限
Session Manager：会话管理，即用户登录后就是第一次会话，在没有退出之前，它的所有信息都在会话中；会话可以是普通的 JavaSE 环境，也可以是 Web 环境
Cryptography：加密，保护数据的安全性，如密码加密存储到数据库中，而不是明文存储
Web Support： Web 支持，可以非常容易的集成到 Web 环境
Caching：缓存，比如用户登录后，其用户信息，拥有的角色、权限不必每次去查，这样可以提高效率
Concurrency： Shiro 支持多线程应用的并发验证，即，如在一个线程中开启另一个线程，能把权限自动的传播过去
Testing：提供测试的支持
Run As：允许一个用户假装另一个用户(如果他们允许) 的身份进行访问
Remember Me：记住我，这个是非常常见的功能，即一次登录后，下次再来的话不用登录了

17.3 Shiro 架构(外部)

从外部来看 Shiro，即从应用程序角度来观察如何使用 Shiro 完成工作

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-1yROugk3-1628259661133)(C:\Users\lishisen\AppData\Roaming\Typora\typora-user-images\image-20210629161651339.png)]

subject：应用代码直接交互的对象是 subject，也就是说 Shiro 的对外 API 核心就是 Subject，Subject 代表了当前的用户，这个用户不一定是一个具体的人，与当前应用交互的任何东西都是 Subject，如网络爬虫，机器人等，与 Subject 的所有交互都会委托给 SecurityManager；Subject 其实是一个门面，SecurityManager 才是实际的执行者
SecurityManager：安全管理器，即所有与安全有关的操作都会与 SecurityManager 交互，并且它管理者所有的 Subject，可以看出它是 Shiro 的核心，它负责与 Shiro 的其他组件进行交互，它相当于 SpringMVC 的 DispatcherServlet 的角色
Realm： Shiro 从 Realm 获取安全数据(如用户、角色、权限)，就是说 SecurityManager 要验证用户身份，那么它需要从 Realm 获取相应的用户进行比较，来确定用户的身份是否合法；也需要从 Realm 得到用户相应的角色、权限，进行验证用户的操作是否能够进行，可以把 Realm 看成 DataSource；

17.4 Shiro 架构(内部)

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-1U9qjowF-1628259661134)(C:\Users\lishisen\AppData\Roaming\Typora\typora-user-images\image-20210629162312228.png)]

Subject：任何可以与应用交互的”用户“
Security Manager：相当于 SpringMVC 中的 DeispatcherServlet；是 Shiro 的心脏，所有具体的交互都通过 Security Manager 进行控制，它管理这所有的 Subject，且负责进行认证、授权、会话、及缓存的管理。
Authenticator：负责 Subject 认证，是一个扩展点，可以自定义实现；可以使用认证策略(Authentication Strategy)，即什么情况下算用户认证通过了
Authorizer：授权器，即访问控制器，用来注定主题是否有权限进行相应的操作；即控制着用户能访问应用中的哪些功能；
Realm：可以有一个或者多个 realm，可以认为是安全实体数据源，即用于获取安全实体的，可以使用 JDBC 实现，也可以是内存实现等等，由用户提供；所以一般在应用中都需要实现自己的 realm
SessionManager：管理 Session 生命周期的组件，而Shiro并不仅仅可以用在web环境，也可以用在普通的 JavaSE 环境中
CacheManager：缓存控制器，来管理如用户、角色、权限等缓存的；因为这些数据基本上很少改变，放到缓存中后可以提高访问的性能；
Cryptography：密码模块，Shiro 提高了一些常见的加密组件用于密码加密，解密等。

17.5 SpringBoot 集成 Shiro

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-sFw8bBmZ-1628259661135)(C:\Users\lishisen\AppData\Roaming\Typora\typora-user-images\image-20210629232238244.png)]

首先导入依赖

        
        <dependency>
            <groupId>org.apache.shirogroupId>
            <artifactId>shiro-springartifactId>
            <version>1.7.1version>
        dependency>

编写 UserRealm 类

// 自定义的 UserRealm
public class UserRealm extends AuthorizingRealm {
    //授权
    @Override
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principalCollection) {
        System.out.println("执行了-----授权doGetAuthorizationInfo");
        return null;
    }
    //认证
    @Override
    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken authenticationToken) throws AuthenticationException {
        System.out.println("执行了-----认证doGetAuthorizationInfo");
        return null;
    }
}

创建 ShiroConfig 类

@Configuration
public class ShiroConfig {

    //3. ShiroFilterFactoryBean
    @Bean
    public ShiroFilterFactoryBean getShiroFilterFactoryBean(@Qualifier("securityManager") DefaultWebSecurityManager defaultWebSecurityManager){
        ShiroFilterFactoryBean bean = new ShiroFilterFactoryBean();
        // 设置安全管理器
        bean.setSecurityManager(defaultWebSecurityManager);
        /**
         * anno ： 无需认证就可以访问
         * authc：必须认证了才能访问
         * user：必须拥有 记住我 功能才能用
         * perms：拥有对某个资源的权限才能访问
         * role：拥有某个角色权限才能访问
         */
        //添加 Shiro 的内置过滤器
        //拦截
        Map<String, String> filterMap = new LinkedHashMap<>();
        filterMap.put("/user/*","authc");
        bean.setFilterChainDefinitionMap(filterMap);
        //设置登录的请求
        bean.setLoginUrl("/toLogin");
        return bean;
    }

    //2. DefaultWebSecurityManager
    @Bean(name = "securityManager")
    public DefaultWebSecurityManager getDefaultWebSecurityManager(@Qualifier("userRealm") UserRealm userRealm){
        DefaultWebSecurityManager securityManager = new DefaultWebSecurityManager();
        //关联 UserRealm
        securityManager.setRealm(userRealm);
        return securityManager;
    }
    //1. 创建 realm 对象，需要自定义
    @Bean
    public UserRealm userRealm(){
        return new UserRealm();
    }
}

17.6 登录的认证

认证信息主要是在 UserRealm 类中

首先在 Controller 中接受前端页面输入的用户名密码信息

@RequestMapping("/login")
public String login(String username,String password, Model model){
    //1. 获取当前用户
    Subject subject = SecurityUtils.getSubject();
    //2. 封装用户的登录数据
    UsernamePasswordToken token = new UsernamePasswordToken(username,password);
    try {
        subject.login(token); // 执行登录方法，如果没有异常就ok了
        return "index";
    } catch (UnknownAccountException e) { //用户名错误
        model.addAttribute("msg", "用户名错误");
        return "login";
    } catch (IncorrectCredentialsException e){ // 密码错误
        model.addAttribute("msg","密码错误");
        return "login";
    }
}

在 UserRealm 类中进行信息的认证，认证的信息自定义变量

//认证
@Override
protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken authenticationToken) throws AuthenticationException {
    System.out.println("执行了-----认证doGetAuthorizationInfo");
    //1. 用户名，密码   正常从数据库中取出，这里模拟使用
    String name = "root";
    String password = "123456";
	// 这里的 (UsernamePasswordToken) authenticationToken; 对应于 Controller 中的封装好的 token
    UsernamePasswordToken userToken =  (UsernamePasswordToken) authenticationToken;
    if (!userToken.getUsername().equals(name)){
        return null;  //抛出异常  UnknownAccountException
    }
    //密码认证，shiro做，不让接触密码
    return new SimpleAuthenticationInfo("",password,"");
}

在 UserRealm 类中进行信息的认证，认证的信息从数据库中取出用户名密码

首先需要测试连接好数据库，保证数据库可以使用

然后在 认证 修改即可

@Autowired
UserService userService;

//认证
@Override
protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken authenticationToken) throws AuthenticationException {
    System.out.println("执行了-----认证doGetAuthorizationInfo");

    UsernamePasswordToken userToken =  (UsernamePasswordToken) authenticationToken;
    //连接数据库，从数据库中取出
    User user = userService.queryUserByName(userToken.getUsername());

    if (user == null){ // 登录失败
        return null;  //抛出异常  UnknownAccountException
    }
    //密码认证，shiro做，不让接触密码
    return new SimpleAuthenticationInfo("",user.getUser_password(),"");
}

17.8 授权

首先在 ShiroConfig.java 类中 getShiroFilterFactoryBean（）方法中进行设置访问的权限

//添加 Shiro 的内置过滤器
Map<String, String> filterMap = new LinkedHashMap<>();

// 授权，正常的情况下，没有授权会跳到未授权页面
filterMap.put("/user/add","perms[add]");
filterMap.put("/user/update","perms[update]");
/**
*
**/
// 设置未授权页面
bean.setUnauthorizedUrl("/noauth");

然后在 UserRealm.java 中授权部分设置授权的用户信息

//授权
@Override
protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principalCollection) {
    System.out.println("执行了-----授权doGetAuthorizationInfo");

    SimpleAuthorizationInfo info = new SimpleAuthorizationInfo();

    // 拿到当前登录的这个对象
    Subject subject = SecurityUtils.getSubject();
    User currentUser = (User) subject.getPrincipal();//拿到 User 对象
    //设置当前用户的权限，getUser_perms 从数据库中拿到权限信息 用于判断
    info.addStringPermission(currentUser.getUser_perms());

    return info;
}

前提需要在认证部分返回 principal 的值，用户获得当前用户的信息
return new SimpleAuthenticationInfo(user,user.getUser_password(),"");

17.9 Shiro 整合 thymeleaf

首先需要引入整合的依赖


<dependency>
    <groupId>com.github.theborakompanionigroupId>
    <artifactId>thymeleaf-extras-shiroartifactId>
    <version>2.0.0version>
dependency>

html 页面中引入命名空间

xmlns:shiro="http://www.thymeleaf.org/thymeleaf-extras-shiro"

然后编写分模块

判断是否登录，如果没有登录过就显示首页，点击首页可以登录
<div th:if="${session.userInfo == null}">
    <a th:href="@{/toLogin}"><h1>首页h1>a>
div>
<p th:text="${msg}">p>
<hr>
获得 shiro:hasPermission 权限，进行区分，如果只有 add 权限就显示 add，以此类推
<div shiro:hasPermission="add">
    <a th:href="@{/user/add}">adda>
div>

<div shiro:hasPermission="update">
    <a th:href="@{/user/update}">updatea>
div>

18. Swagger

18.1 简介

号称世界上最流行的 Api 框架；
RestFul Api 文档在线自动生成工具 => Api 文档与 API 定义同步更新；
直接运行，可以在线测试 API 接口；
支持多种语言；

官网：https://swagger.io/

18.2 SpringBoot 集成 Swagger

新建 springboot-web 项目

导入相关依赖

<dependency>
    <groupId>io.springfoxgroupId>
    <artifactId>springfox-swagger2artifactId>
    <version>3.0.0version>
dependency>
<dependency>
    <groupId>io.springfoxgroupId>
    <artifactId>springfox-swagger-uiartifactId>
    <version>3.0.0version>
dependency>

编写一个 hello 接口

集成Swagger2 的配置文件，开启 Swagger2

@Configuration
@EnableSwagger2  //开启 Swagger2
public class SwaggerConfig {

}

测试运行：http://localhost:8080/swagger-ui.html

可以看到一下界面信息

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-YB9a1fsX-1628259661136)(C:\Users\lishisen\AppData\Roaming\Typora\typora-user-images\image-20210630174307805.png)]

18.3 配置 Swagger 基本信息

@Configuration
@EnableSwagger2
public class SwaggerConfig {
    //配置了 swagger 的 Docket 的 bean 实例
    @Bean
    public Docket docket() {
        return new Docket(DocumentationType.SWAGGER_2).apiInfo(apiInfo());
    }

    // 配置 Swagger 信息  ----   apiInfo
    public ApiInfo apiInfo() {
        Contact contact = new Contact("lishisen", "www.miss.com", "[email protected]");
        return new ApiInfo(
                "SpringBoot Swagger",
                "一个接口的文档",
                "v1.1",
                "www.baidu.com",
                contact,
                "Apache 2.0",
                "http://www.apache.org/licenses/LICENSE-2.0",
                new ArrayList<>());
    }
}

18.4 配置 Swagger 扫描的接口

//配置了 swagger 的 Docket 的 bean 实例
@Bean
public Docket docket() {
    return new Docket(DocumentationType.SWAGGER_2).apiInfo(apiInfo())
            //RequestHandlerSelectors ，配置要扫描接口的方式
            //basePackage：指定要扫描的包
            //any()：扫描全部
            //none()：不扫描
            //withClassAnnotation: 扫描类上的注解，参数是一个注解的反射对象
            //withMethodAnnotation：扫描方法上的注解
        	// .enable(false)  是否启用 swagger，如果为 false 不能访问swagger
            .select().apis(RequestHandlerSelectors.basePackage("com.example.controller"))
            //paths() 过滤什么路径
            .paths(PathSelectors.ant("/com/example/**")).build();
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-JzNDN7S3-1628259661137)(C:\Users\lishisen\AppData\Roaming\Typora\typora-user-images\image-20210630192010023.png)]

因为设置扫描的 basePackage 和 paths 过滤的冲突了，所以上面没有信息输出。

18.5 配置多环境下使用 Swagger

首先创建两套环境

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-K6kUIIYX-1628259661138)(C:\Users\lishisen\AppData\Roaming\Typora\typora-user-images\image-20210630213605117.png)]

设置环境选择的文件，并且判断是否启用 swagger

    //配置了 swagger 的 Docket 的 bean 实例
    @Bean
    public Docket docket(Environment environment) {
        
        // 设置要显示的 swawgger 环境
        Profiles profiles = Profiles.of("dev", "pro1");
        // 通过 environment.acceptsProfiles 判断是否处在自己设定的环境当中
        boolean flag = environment.acceptsProfiles(profiles);

        return new Docket(DocumentationType.SWAGGER_2).apiInfo(apiInfo())
                .enable(flag)
                .select().apis(RequestHandlerSelectors.basePackage("com.example.controller"))
                //paths() 过滤什么路径
//                .paths(PathSelectors.ant("/com/example/**"))
                .build();
    }

18.6 配置 API 文档的分组

在 docket 类中进行设置

.groupName("myGroup")

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-VWFQQcST-1628259661139)(C:\Users\lishisen\AppData\Roaming\Typora\typora-user-images\image-20210630214057788.png)]

设置多个分组

// 配置多个 swagger ，查看分组
@Bean
public Docket docket1(){
    return new Docket(DocumentationType.SWAGGER_2).groupName("docket1");
}
@Bean
public Docket docket2(){
    return new Docket(DocumentationType.SWAGGER_2).groupName("docket2");
}
@Bean
public Docket docket3(){
    return new Docket(DocumentationType.SWAGGER_2).groupName("docket3");
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-nmxyL0Js-1628259661140)(C:\Users\lishisen\AppData\Roaming\Typora\typora-user-images\image-20210630214536045.png)]

18.7 Swagger 文档说明

编写接口

// 只要接口返回的实体类，就会被记录到 Swagger 的Model中
@GetMapping("/user")
// Operation 接口，放在方法上，说明方法作用
@ApiOperation("hello 控制方法")
// @ApiParam("") 可以放在方法形参上，说明参数
public User user(@ApiParam("用户名") String username){
    return new User();
}

还有实体类可以使用
@ApiModel("用户实体类")
public class User {
    @ApiModelProperty("用户名")
    private String username;
    @ApiModelProperty("用户密码")
    private String password;

}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-EguGehQA-1628259661141)(C:\Users\lishisen\AppData\Roaming\Typora\typora-user-images\image-20210630220448554.png)]

总结：

我们可以通过 Swagger 给一些比较难以理解的属性或者接口，增加注释信息；接口文档实时更新；可以在线测试；

【注意】：在正式发布的时候，关闭 Swagger，处于安全考虑，节省运行的内存；

19. 任务

19.1 异步任务

模拟异步数据，分别创建两个类

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-LnXpO8gC-1628259661142)(C:\Users\lishisen\AppData\Roaming\Typora\typora-user-images\image-20210630223704453.png)]

AsynService

@Service
public class AsynService {
    public void hello(){
        try {
            // 休眠 3秒后在执行下面内容
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("数据正在处理中.....");
    }

}

HelloController

@Controller
public class HelloController {
    @Autowired
    AsynService asynService;

    @RequestMapping("/hello")
    @ResponseBody
    public String hello(){
        asynService.hello();
        return "OK";
    }
}

启动运行后 3 秒后才输出内容

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Za5QMX1c-1628259661143)(C:\Users\lishisen\AppData\Roaming\Typora\typora-user-images\image-20210630223905276.png)]

**解决等待时间问题： **

在 Service 方法上添加注解 @Async

@Service
public class AsynService {

    @Async  //告诉 spring 这是一个异步方法
    public void hello(){

在启动类上添加注解 @EnableAsync 启动异步任务
```
@EnableAsync  // 开启异步
```

19.2 邮件任务

首先需要导入依赖


        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starter-mailartifactId>
        dependency>

通过查看源码 MailSenderAutoConfiguration.class，MailProperties.class 得到需要的属性文件，然后编写配置文件

[email protected]
spring.mail.password=kvprsezzhjfbjgbi
# 发送的服务器
spring.mail.host=smtp.qq.com
# 开启加密验证
spring.mail.properties.mail.smtp.ssl.enable=true

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-IuZtDI39-1628259661144)(C:\Users\lishisen\AppData\Roaming\Typora\typora-user-images\image-20210701091930801.png)]

测试

@SpringBootTest
class Springboot12TaskApplicationTests {

    @Autowired
    JavaMailSenderImpl mailSender;

    @Test
    void contextLoads() {
        // 一个简单的邮件
        SimpleMailMessage simpleMailMessage = new SimpleMailMessage();
        simpleMailMessage.setSubject("你好");
        simpleMailMessage.setText("好好学习 JAVAEE");
        simpleMailMessage.setTo("[email protected]");
        simpleMailMessage.setFrom("[email protected]");
        mailSender.send(simpleMailMessage);

    }
    @Test
    void contextLoads2() throws MessagingException {
        // 一个复杂的邮件
        MimeMessage mimeMessage = mailSender.createMimeMessage();
        // 组装
        MimeMessageHelper helper = new MimeMessageHelper(mimeMessage, true);
        helper.setSubject("nihao");
        helper.setText("好好学习
",true);
        // 附件
        helper.addAttachment("1.jpg",new File("C:\\Users\\lishisen\\Desktop\\1.jpg"));
        helper.setTo("[email protected]");
        helper.setFrom("[email protected]");
        mailSender.send(mimeMessage);
    }
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-BAPDQSed-1628259661144)(C:\Users\lishisen\AppData\Roaming\Typora\typora-user-images\image-20210701093433472.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Buuh6HnR-1628259661145)(C:\Users\lishisen\AppData\Roaming\Typora\typora-user-images\image-20210701093446651.png)]

19.3 定时任务

TaskExecutor		任务执行者	
TaskScheduler		任务调度者
    
@EnableScheduling 	//开启定时功能的注解
@Scheduled			// 什么时候执行

在 Test 类上开启定时功能

@SpringBootApplication
@EnableScheduling//开启定时功能
public class Springboot12TaskApplication {

    public static void main(String[] args) {
        SpringApplication.run(Springboot12TaskApplication.class, args);
    }

}

编写定时功能的服务

@Service
public class ScheduledService {
    // 在一个特定的时间执行这个方法
    // cron 表达式   秒 分 时 日 月 周
    @Scheduled(cron = "0 * * * * 0-7")
    public void hello(){
        System.out.println("hello,你被执行了.....");
    }
}

20. 分布式

什么是分布式系统？

分布式系统是若干独立计算机的集合，这些计算机对于用户来说就像单个相关系统；

分布式系统是由一组通过网络进行通信，为了完成共同的任务而协调工作的计算机节点组成的系统。分布式系统的出现是为了用廉价的、普通的机器完成单个计算机无法完成的计算、存储任务。其目的是利用更多的机器，处理更多的数据。

分布式系统(distributed system) 是建立在网络之上的软件系统。

首先需要明确的是，只有当单个节点的处理能力无法满足日益增长的计算、存储任务的时候，且硬件的提升(加内存、加磁盘、使用更好的 CPU) 高昂到得不偿失的时候，应用程序也不能进一步优化的时候，我们才需要考虑分布式系统。因为，分布式系统要解决的问题本身就是和单机系统一样的，而由于分布式系统多节点、通过网络通信的拓扑结构，会引入很多单机系统没有的问题，为了解决这些问题又会引入更多的机制、协议，带来更多的问题。。。

Dubbo 文档

官网：https://dubbo.apache.org/

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-4ACZkkCY-1628259661146)(C:\Users\lishisen\AppData\Roaming\Typora\typora-user-images\image-20210701101949736.png)]
RPC

什么是 RPC？

RPC(Remote Rroducure Call) 是指远程过程调用，是一种进程间通信方式，它是一种技术的思想，而不是规范。它允许程序调用另一个地址空间(通常是共享网络的另一台机器上)的过程或函数，而不用程序显示编程这个远程调用的细节。即程序员无论是调用本地的还是远程的函数，本质上编写的调用代码基本相同。

也就是说两台服务器 A，B，一个应用部署在 A 服务器上，想要调用 B 服务器上应用提供的函数/方法，由于不在一个内存空间，不能直接调用，需要通过网络来表达调用的语义和传达调用的数据，为什么要用 RPC呢？就是无法在一个进程内，甚至一个计算机内通过本地调用的方式完成的需求，比如不同的系统间的通讯，甚至不同的组织间的通讯，由于计算能力需要横向扩展，需要在多台机器组成的集群上部署应用。RPC 就是要像调用本地的函数一样去调远程函数；

解释RPC文章：https://www.jianshu.com/p/2accc2840a1b
RPC 基本原理

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-HideiVTa-1628259661147)(C:\Users\lishisen\AppData\Roaming\Typora\typora-user-images\image-20210701103111263.png)]
- 步骤解析
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-uus4HrZZ-1628259661147)(C:\Users\lishisen\AppData\Roaming\Typora\typora-user-images\image-20210701103150943.png)]
- RPC 两个核心模块：通讯，序列化

20.1 Dubbo

什么是 dubbo？

Apache Dubbo 是一款高性能、轻量级的开源 Java RPC框架，它提供了三大核心能力：面向接口的远程方法调用，智能容错和负载均衡，以及服务自动注册和发现。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Y1johoMx-1628259661148)(C:\Users\lishisen\AppData\Roaming\Typora\typora-user-images\image-20210701104344059.png)]
- 服务提供者(Provider)：暴露服务的服务提供方，服务提供者在启动时，向注册中心注册自己提供的服务
- 服务消费者(Consumer)：调用远程服务的服务消费方，服务消费者在启动时，向注册中心订阅自己所需的服务，服务消费者，从提供者地址列表中，基于软负载均衡算法，选一台提供者进行调用，如果调用失败，再选另一台调用
- 注册中心(Registry)：注册中心返回服务提供者地址列表给消费者，如果有变更，注册中心将基于长连接推送变更数据给消费者
- 监控中心(Monitor)：服务消费者和提供者，在内存中累计调用次数和调用时间，定时每分钟发送一次统计数据到监控中心
Dubbo 环境搭建

点进 dubbo 官方文档，推荐我们使用 Zookeeper 注册中心

window 下安装 zookeeper
1. 下载 http://archive.apache.org/dist/zookeeper/zookeeper-3.4.14/
2. 运行 /bin/zkServer.cmd ，初次运行会报错，因为在 conf 中没有 zoo.cfg 配置文件，可能会闪退
  
  [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Rh7U8gCx-1628259661149)(C:\Users\lishisen\AppData\Roaming\Typora\typora-user-images\image-20210701125257576.png)]
  
  [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-IVa8skLb-1628259661150)(C:\Users\lishisen\AppData\Roaming\Typora\typora-user-images\image-20210701125324414.png)]
  
  解决方法**：E:\Environment\zookeeper-3.4.14\conf**
  
  [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-iAgrYwUi-1628259661150)(C:\Users\lishisen\AppData\Roaming\Typora\typora-user-images\image-20210701125410860.png)]

zoo.cfg 配置文件
- dataDir=./ 临时数据存储的目录(可写相对路径)
- clientPort=2181 zookeeper 的端口号

使用 zkCli.cmd 测试

ls / ：列出 zookeeper 根下保存的所有结点

[zk: localhost:2181(CONNECTED) 0] ls /
[zookeeper]

create -e /li 123 ：创建一个 li 节点，值为 123

[zk: localhost:2181(CONNECTED) 1] create -e /li 123
Created /li

get /li ：获取 /li 节点的值

[zk: localhost:2181(CONNECTED) 3] get /li
123			// 这里是自己设置的值
cZxid = 0x6
ctime = Thu Jul 01 13:02:52 CST 2021
mZxid = 0x6
mtime = Thu Jul 01 13:02:52 CST 2021
pZxid = 0x6
cversion = 0
dataVersion = 0
aclVersion = 0
ephemeralOwner = 0x1001ab811750001
dataLength = 3
numChildren = 0

windows 下安装 dubbo-admin

dubbo 本身并不是一个服务软件，它其实就是一个 jar 包，能够帮你的 java 程序连接到 zookeeper，并利用 zookeeper 消费、提供服务。

但是为了让用户更好的管理监控众多的 dubbo 服务，官方提供了一个可视化的监控程序 dubbo-admin，不过这个监控即使不装也不影响使用。

下载 dubbo-admin

下载地址：https://github.com/apache/dubbo-admin/tree/master

解压进入目录

修改 E:\Environment\dubbo-admin-master\dubbo-admin\src\main\resources \application.properties 指定 zookeeper 地址

server.port=7001
spring.velocity.cache=false
spring.velocity.charset=UTF-8
spring.velocity.layout-url=/templates/default.vm
spring.messages.fallback-to-system-locale=false
spring.messages.basename=i18n/message
spring.root.password=root
spring.guest.password=guest
# 注册中心的地址
dubbo.registry.address=zookeeper://127.0.0.1:2181

在项目目录下打包 dubbo-admin
```
mvn clean package -Dmaven.test.skip=true
```
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-8MI1oLYt-1628259661151)(C:\Users\lishisen\AppData\Roaming\Typora\typora-user-images\image-20210701132331726.png)]

成功后会在 target 目录下生成 jar 包文件 dubbo-admin-0.0.1-SNAPSHOT.jar
cmd 中执行命令运行：
```
java -jar dubbo-admin-0.0.1-SNAPSHOT.jar
```
注意：zookeeper 的服务一定要打开

执行完毕后用浏览器访问 http://localhost:7001/,需要输入登录账户和密码，默认都为 root

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-2PO8WZOu-1628259661152)(C:\Users\lishisen\AppData\Roaming\Typora\typora-user-images\image-20210701132914379.png)]

zookeeper ：注册中心

dubbo-admin：是一个监控管理后台，查看我们注册了哪些服务，哪些服务被消费了

20.2 dubbo+zookeeper

首先创建两个项目 provider-service 和 consumer-service，并在 provider-service 写服务接口

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-7r2ZuHtn-1628259661153)(C:\Users\lishisen\AppData\Roaming\Typora\typora-user-images\image-20210701152746409.png)]

在 provider-service 项目中导入依赖，编写配置文件，编写服务

依赖导入


<dependency>
    <groupId>org.apache.dubbogroupId>
    <artifactId>dubbo-spring-boot-starterartifactId>
    <version>3.0.0version>
dependency>

<dependency>
    <groupId>com.github.sgroschupfgroupId>
    <artifactId>zkclientartifactId>
    <version>0.1version>
dependency>

<dependency>
    <groupId>org.apache.curatorgroupId>
    <artifactId>curator-frameworkartifactId>
    <version>2.12.0version>
dependency>
<dependency>
    <groupId>org.apache.zookeepergroupId>
    <artifactId>zookeeperartifactId>
    <version>3.4.14version>
    
    <exclusions>
        <exclusion>
            <groupId>org.slf4jgroupId>
            <artifactId>slf4j-log4j12artifactId>
        exclusion>
    exclusions>
dependency>

配置文件

server.port=8081

# 服务应用名字
dubbo.application.name=provider-server
# 注册中心地址
dubbo.registry.address=zookeeper://127.0.0.1:2181
# 哪些服务要被注册
dubbo.scan.base-packages=com.example.service

编写服务内容

import org.apache.dubbo.config.annotation.Service;
import org.springframework.stereotype.Component;
//zookeeper：服务注册与发现
@Service    //可以被扫描到，在项目已启动就自动注册到注册中心
@Component //使用了 Dubbo 后尽量不要使用 Service 注解
public class TicketServiceImpl implements TicketService{
    @Override
    public String getTicket() {
        return "你好啊！！！dubbo，zookeeper";
    }
}

编写好以上内容后，启动 zkServer.cmd
执行 jar 包内容，访问 localhost:7001 查看监控信息，现在是没有的，需要启动一下编写的服务就可以看到服务的信息
```
java -jar dubbo-admin-0.0.1-SNAPSHOT.jar
```
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-6AjUJjcQ-1628259661154)(C:\Users\lishisen\AppData\Roaming\Typora\typora-user-images\image-20210701155003380.png)]

学习参考视频网址

你可能感兴趣的:(笔记,spring,springboot)

10月|愿你的青春不负梦想-读书笔记-01 Tracy的小书斋
本书的作者是俞敏洪，大家都很熟悉他了吧。俞敏洪老师是我行业的领头羊吧，也是我事业上的偶像。本日摘录他书中第一章中的金句：『一个人如果什么目标都没有，就会浑浑噩噩，感觉生命中缺少能量。能给我们能量的，是对未来的期待。第一件事，我始终为了进步而努力。与其追寻全世界的骏马，不如种植丰美的草原，到时骏马自然会来。第二件事，我始终有阶段性的目标。什么东西能给我能量？答案是对未来的期待。』读到这里的时候，我便
《投行人生》读书笔记小蘑菇的树洞
《投行人生》----作者詹姆斯-A-朗德摩根斯坦利副主席40年的职业洞见-很短小精悍的篇幅，比较适合初入职场的新人。第一部分成功的职业生涯需要规划1.情商归为适应能力分享与协作同理心适应能力，更多的是自我意识，你有能力识别自己的情并分辨这些情绪如何影响你的思想和行为。2.对于初入职场的人的建议，细节，截止日期和数据很重要截止日期，一种有效的方法是请老板为你所有的任务进行优先级排序。和老板喝咖啡的好
【一起学Rust | 设计模式】习惯语法——使用借用类型作为参数、格式化拼接字符串、构造函数广龙宇一起学Rust #Rust设计模式 rust 设计模式开发语言
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档文章目录前言一、使用借用类型作为参数二、格式化拼接字符串三、使用构造函数总结前言Rust不是传统的面向对象编程语言，它的所有特性，使其独一无二。因此，学习特定于Rust的设计模式是必要的。本系列文章为作者学习《Rust设计模式》的学习笔记以及自己的见解。因此，本系列文章的结构也与此书的结构相同（后续可能会调成结构），基本上分为三个部分
git常用命令笔记咩酱-小羊 git 笔记
###用习惯了idea总是不记得git的一些常见命令，需要用到的时候总是担心旁边站了人~~~记个笔记@_@，告诉自己看笔记不丢人初始化初始化一个新的Git仓库gitinit配置配置用户信息gitconfig--globaluser.name"YourName"gitconfig--globaluser.email"[email protected]"基本操作克隆远程仓库gitclone查看
509. 斐波那契数(每日一题) lzyprime
lzyprime博客(github)创建时间：2021.01.04qq及邮箱：2383518170leetcode笔记题目描述斐波那契数，通常用F(n)表示，形成的序列称为斐波那契数列。该数列由0和1开始，后面的每一项数字都是前面两项数字的和。也就是：F(0)=0，F(1)=1F(n)=F(n-1)+F(n-2)，其中n>1给你n，请计算F(n)。示例1：输入：2输出：1解释：F(2)=F(1)+
拥有断舍离的心态，过精简生活--《断舍离》读书笔记爱吃丸子的小樱桃
不知不觉间房间里的东西越来越多，虽然摆放整齐，但也时常会觉得空间逼仄，令人心生烦闷。抱着断舍离的态度，我开始阅读《断舍离》这本书，希望从书中能找到一些有效的方法，帮助我实现空间、物品上的断舍离。《断舍离》是日本作家山下英子通过自己的经历、思考和实践总结而成的，整体内涵也从刚开始的私人生活哲学的“断舍离”升华成了“人生实践哲学”，接着又成为每个人都能实行的“改变人生的断舍离”，从“哲学”逐渐升华成“
四章-32-点要素的聚合彩云飘过
本文基于腾讯课堂老胡的课《跟我学Openlayers--基础实例详解》做的学习笔记，使用的openlayers5.3.xapi。源码见1032.html，对应的官网示例https://openlayers.org/en/latest/examples/cluster.htmlhttps://openlayers.org/en/latest/examples/earthquake-clusters.
高端密码学院笔记285 柚子_b4b4
高端幸福密码学院（高级班）幸福使者：李华第（598）期《幸福》之回归内在深层生命原动力基础篇——揭秘“激励”成长的喜悦心理案例分析主讲：刘莉一，知识扩充:成功=艰苦劳动+正确方法+少说空话。贪图省力的船夫，目标永远下游。智者的梦再美，也不如愚人实干的脚印。幸福早课堂2020.10.16星期五一笔记:1，重视和珍惜的前提是知道它的价值非常重要，当你珍惜了，你就真正定下来，真正的学到身上。2，大家需要
Day17笔记-高阶函数 ~在杰难逃~ Python 笔记 python 开发语言 pycharm 数据分析
高阶函数【重点掌握】函数的本质：函数是一个变量，函数名是一个变量名，一个函数可以作为另一个函数的参数或返回值使用如果A函数作为B函数的参数，B函数调用完成之后，会得到一个结果，则B函数被称为高阶函数常用的高阶函数：map(),reduce(),filter(),sorted()1.map()map(func,iterable)，返回值是一个iterator【容器，迭代器】func:函数iterab
Day1笔记-Python简介&标识符和关键字&输入输出 ~在杰难逃~ Python python 开发语言大数据数据分析数据挖掘
大家好，从今天开始呢，杰哥开展一个新的专栏，当然，数据分析部分也会不定时更新的，这个新的专栏主要是讲解一些Python的基础语法和知识，帮助0基础的小伙伴入门和学习Python，感兴趣的小伙伴可以开始认真学习啦！一、Python简介【了解】1.计算机工作原理编程语言就是用来定义计算机程序的形式语言。我们通过编程语言来编写程序代码，再通过语言处理程序执行向计算机发送指令，让计算机完成对应的工作，编程
node.js学习小猿L node.js node.js 学习 vim
node.js学习实操及笔记温故node.js，node.js学习实操过程及笔记~node.js学习视频node.js官网node.js中文网实操笔记githubcsdn笔记为什么学node.js可以让别人访问我们编写的网页为后续的框架学习打下基础，三大框架vuereactangular离不开node.jsnode.js是什么官网：node.js是一个开源的、跨平台的运行JavaScript的运行
数据仓库——维度表一致性墨染丶eye 背诵数据仓库
数据仓库基础笔记思维导图已经整理完毕，完整连接为：数据仓库基础知识笔记思维导图维度一致性问题从逻辑层面来看，当一系列星型模型共享一组公共维度时，所涉及的维度称为一致性维度。当维度表存在不一致时，短期的成功难以弥补长期的错误。维度时确保不同过程中信息集成起来实现横向钻取货活动的关键。造成横向钻取失败的原因维度结构的差别，因为维度的差别，分析工作涉及的领域从简单到复杂，但是都是通过复杂的报表来弥补设计
【Git】常见命令(仅笔记) 好想有猫猫 Git Linux学习笔记 git 笔记 elasticsearch linux c++
文章目录创建/初始化本地仓库添加本地仓库配置项提交文件查看仓库状态回退仓库查看日志分支删除文件暂存工作区代码远程仓库使用`.gitigore`文件让git不追踪一些文件标签创建/初始化本地仓库gitinit添加本地仓库配置项gitconfig-l#以列表形式显示配置项gitconfiguser.name"ljh"#配置user.namegitconfiguser.email"[email protected]
SpringBlade dict-biz/list 接口 SQL 注入漏洞文章永久免费只为良心 oracle 数据库
SpringBladedict-biz/list接口SQL注入漏洞POC:构造请求包查看返回包你的网址/api/blade-system/dict-biz/list?updatexml(1,concat(0x7e,md5(1),0x7e),1)=1漏洞概述在SpringBlade框架中，如果dict-biz/list接口的后台处理逻辑没有正确地对用户输入进行过滤或参数化查询（PreparedSta
为什么你总是对下属不满意? ZhaoWu1050
【ZhaoWu的听课笔记】大多数公司，都存在两种问题。我创业四年，更是体会深切。这两种问题就是：老板经常不满意下属的表现；下属总是不知道老板想要什么；虽然这两种问题普遍存在，其实解决方法并不复杂。这节课，我们再聊聊第一个问题：为什么老板经常不满意下属表现?其实，这背后也是一条管理常识。管理学家德鲁克先生早就说过：管理者的任务，不是去改变人。*来自《卓有成效的管理者》只是大多数老板和我一样，都是一边
母亲节如何做小红书营销美橙传媒
小红书的一举一动引起了外界的高度关注。通过爆款笔记和流行话题，我们可以看到“干货”类型的内容在小红书中偏向实用的生活经验共享和生活指南非常受欢迎。根据运营社的分析，这种现象是由小红书用户心智和内容社区背后机制共同决定的。首先，小红书将使用“强搜索”逻辑为用户提供特定的“搜索场景”。在“我必须这样生活”中，大量使用了满足小红书站用户喜好和需求的内容。内容社区自制的高质量内容也吸引了寻找营销新途径的品
读书笔记|《遇见孩子，遇见更好的自己》5 抹茶社长
为人父母意味着放弃自己的过去，不要对以往没有实现的心愿耿耿于怀，只有这样，孩子们才能做回自己。985909803.jpg孩子在与父母保持亲密的同时更需要独立，唯有这样，孩子才会成为孩子，父母才会成其为父母。有耐心的人生往往更幸福，给孩子留点余地。认识到养儿育女是对耐心的考验。为失败做好心理准备，教会孩子控制情绪。了解自己的底线，说到底线，有一点很重要，父母之所以发脾气，真正的原因往往在于他们自己，
基于Python给出的PDF文档转Markdown文档的方法程序媛了了 python pdf 开发语言
注：网上有很多将Markdown文档转为PDF文档的方法，但是却很少有将PDF文档转为Markdown文档的方法。就算有，比如某些网站声称可以将PDF文档转为Markdown文档，尝试过，不太符合自己的要求，而且无法保证文档没有泄露风险。于是本人为了解决这个问题，借助GPT（能使用GPT镜像或者有条件直接使用GPT的，反正能调用GPT接口就行）生成Python代码来完成这个功能。笔记、代码难免存在
语文主题教学学习笔记之87 东哥杂谈
“语文主题教学”学习笔记之八十七（0125）今天继续学习小学语文主题教学的实践样态。板块三：教学中体现“书艺”味道。作为四大名著之一的《水浒传》，堪称我国文学宝库之经典。对从《水浒传》中摘选的单元，教师就要了解其原生态，即评书体特点。这也要求教师要了解一些常用的评书行话术语，然后在教学时适时地加入一些，让学生体味其文本中原有的特色。学生也要尽可能地通过朗读的方式，而不单是分析讲解的方式进行学习。细
spring如何整合druid连接池？惜.己 spring spring junit 数据库 java idea 后端 xml
目录spring整合druid连接池1.新建maven项目2.新建mavenModule3.导入相关依赖4.配置log4j2.xml5.配置druid.xml1)xml中如何引入properties2)下面是配置文件6.准备jdbc.propertiesJDBC配置项解释7.配置druid8.测试spring整合druid连接池1.新建maven项目打开IDE（比如IntelliJIDEA,Ecl
Armv8.3 体系结构扩展--原文版代码改变世界ctw ARM-TEE-Android armv8 嵌入式 arm架构安全架构芯片 Trustzone Secureboot
快速链接:.ARMv8/ARMv9架构入门到精通-[目录]付费专栏-付费课程【购买须知】:个人博客笔记导读目录(全部)TheArmv8.3architectureextensionTheArmv8.3architectureextensionisanextensiontoArmv8.2.Itaddsmandatoryandoptionalarchitecturalfeatures.Somefeat
SpringCloudAlibaba—Sentinel(限流) 菜鸟爪哇
前言：自己在学习过程的记录，借鉴别人文章，记录自己实现的步骤。借鉴文章：https://blog.csdn.net/u014494148/article/details/105484410Sentinel介绍Sentinel诞生于阿里巴巴，其主要目标是流量控制和服务熔断。Sentinel是通过限制并发线程的数量（即信号隔离）来减少不稳定资源的影响，而不是使用线程池，省去了线程切换的性能开销。当资源
springboot+vue项目实战一-创建SpringBoot简单项目苹果酱0567 面试题汇总与解析 spring boot 后端 java 中间件开发语言
这段时间抽空给女朋友搭建一个个人博客，想着记录一下建站的过程，就当做笔记吧。虽然复制zjblog只要一个小时就可以搞定一个网站，或者用cms系统，三四个小时就可以做出一个前后台都有的网站，而且想做成啥样也都行。但是就是要从新做，自己做的意义不一样，更何况，俺就是专门干这个的，嘿嘿嘿要做一个网站，而且从零开始，首先呢就是技术选型了，经过一番思量决定选择-SpringBoot做后端，前端使用Vue做一
阅读《认知觉醒》读书笔记就看看书
本周阅读了周岭的《认知觉醒开启自我改变的原动力》，启发较多，故做读书笔记一则，留待学习。全书共八章，讲述了大脑、潜意识、元认知、专注力、学习力、行动力、情绪力及成本最低的成长之道。具体描述了大脑、焦虑、耐心、模糊、感性、元认知、自控力、专注力、情绪专注、学习专注、匹配、深度、关联、体系、打卡、反馈、休息、清晰、傻瓜、行动、心智宽带、单一视角、游戏心态、早起、冥想、阅读、写作、运动等相关知识点。大脑
Spring MVC 全面指南：从入门到精通的详细解析一杯梅子酱技术栈学习 spring mvc java
引言：SpringMVC，作为Spring框架的一个重要模块，为构建Web应用提供了强大的功能和灵活性。无论是初学者还是有一定经验的开发者，掌握SpringMVC都将显著提升你的Web开发技能。本文旨在为初学者提供一个全面且易于理解的学习路径，通过详细的知识点分析和实际案例，帮助你快速上手SpringMVC，让学习过程既深刻又高效。一、SpringMVC简介1.1什么是SpringMVC？Spri
阅读笔记：阅读方法中的逻辑和转念施吉涛
聊聊一些阅读的方法论吧，别人家的读书方法刚开始想写，然后就不知道写什么了，因为作者写的非常的“精致”我有一种乡巴佬进城的感觉，看到精美的摆盘，精致的食材不知道该如何下口也就是《阅读的方法》，我们姑且来试一下强劲的大脑篇，第一节：逻辑通俗的来讲，也就是表达的排列和顺序，再进一步就是因果关系和关联实际上书已经看了大概一遍，但直到打算写一下笔记的时候，才发现作者讲的推理更多的是阅读的对象中呈现出的逻辑也
Spring Boot中实现跨域请求 BABA8891 spring boot 后端 java
在SpringBoot中实现跨域请求（CORS，Cross-OriginResourceSharing）可以通过多种方式，以下是几种常见的方法：1.使用@CrossOrigin注解在SpringBoot中，你可以在控制器或者具体的请求处理方法上使用@CrossOrigin注解来允许跨域请求。在控制器上应用：importorg.springframework.web.bind.annotation.
博客网站制作教程 2401_85194651 java maven
首先就是技术框架：后端：Java+SpringBoot数据库：MySQL前端：Vue.js数据库连接：JPA(JavaPersistenceAPI)1.项目结构blog-app/├──backend/│├──src/main/java/com/example/blogapp/││├──BlogApplication.java││├──config/│││└──DatabaseConfig.java
《转介绍方法论》学习笔记小可乐的妈妈
一、高效转介绍的流程：价值观---执行----方案一）转介绍发生的背景：1、对象：谁向谁转介绍？全员营销，人人参与。①员工的激励政策、客户的转介绍诱因制作客户画像：a信任；支付能力；意愿度；便利度（根据家长具备四个特征的个数分为四类）B性格分类C职业分类D年龄性别②执行：套路，策略，方法，流程2、诱因：为什么要转介绍？认同信任；多方共赢；传递美好；零风险承诺打动人心，超越期待。选择做教育，就是选择
JAVA学习笔记之23种设计模式学习 victorfreedom Java技术设计模式 android java 常用设计模式
博主最近买了《设计模式》这本书来学习，无奈这本书是以C++语言为基础进行说明，整个学习流程下来效率不是很高，虽然有的设计模式通俗易懂，但感觉还是没有充分的掌握了所有的设计模式。于是博主百度了一番，发现有大神写过了这方面的问题，于是博主迅速拿来学习。一、设计模式的分类总体来说设计模式分为三大类：创建型模式，共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。结构型模式，共七种：适配器
java解析APK 3213213333332132 java apk linux 解析APK
解析apk有两种方法 1、结合安卓提供apktool工具，用java执行cmd解析命令获取apk信息 2、利用相关jar包里的集成方法解析apk 这里只给出第二种方法，因为第一种方法在linux服务器下会出现不在控制范围之内的结果。 public class ApkUtil { /** * 日志对象 */ private static Logger
nginx自定义ip访问N种方法 ronin47 nginx 禁止ip访问
　　　因业务需要，禁止一部分内网访问接口，　由于前端架了F5，直接用deny或allow是不行的，这是因为直接获取的前端Ｆ５的地址。　　　所以开始思考有哪些主案可以实现这样的需求，目前可实施的是三种：　　　一：把ip段放在redis里，写一段lua 二：利用geo传递变量，写一段
mysql timestamp类型字段的CURRENT_TIMESTAMP与ON UPDATE CURRENT_TIMESTAMP属性 dcj3sjt126com mysql
timestamp有两个属性，分别是CURRENT_TIMESTAMP 和ON UPDATE CURRENT_TIMESTAMP两种，使用情况分别如下： 1. CURRENT_TIMESTAMP 当要向数据库执行insert操作时，如果有个timestamp字段属性设为 CURRENT_TIMESTAMP，则无论这
struts2+spring+hibernate分页显示 171815164 Hibernate
分页显示一直是web开发中一大烦琐的难题，传统的网页设计只在一个JSP或者ASP页面中书写所有关于数据库操作的代码，那样做分页可能简单一点，但当把网站分层开发后，分页就比较困难了，下面是我做Spring+Hibernate+Struts2项目时设计的分页代码，与大家分享交流。　　1、DAO层接口的设计，在MemberDao接口中定义了如下两个方法： public in
构建自己的Wrapper应用 g21121 rap
我们已经了解Wrapper的目录结构，下面可是正式利用Wrapper来包装我们自己的应用，这里假设Wrapper的安装目录为:/usr/local/wrapper。首先，创建项目应用 &nb
[简单]工作记录_多线程相关 53873039oycg 多线程
最近遇到多线程的问题,原来使用异步请求多个接口(n*3次请求) 方案一使用多线程一次返回数据,最开始是使用5个线程,一个线程顺序请求3个接口,超时终止返回缺点测试发现必须3个接
调试jdk中的源码，查看jdk局部变量程序员是怎么炼成的 jdk 源码
转自：http://www.douban.com/note/211369821/ 学习jdk源码时使用-- 学习java最好的办法就是看jdk源代码，面对浩瀚的jdk（光源码就有40M多，比一个大型网站的源码都多）从何入手呢，要是能单步调试跟进到jdk源码里并且能查看其中的局部变量最好了。可惜的是sun提供的jdk并不能查看运行中的局部变量
Oracle RAC Failover 详解 aijuans oracle
Oracle RAC 同时具备HA(High Availiablity) 和LB(LoadBalance). 而其高可用性的基础就是Failover(故障转移). 它指集群中任何一个节点的故障都不会影响用户的使用，连接到故障节点的用户会被自动转移到健康节点，从用户感受而言，是感觉不到这种切换。 Oracle 10g RAC 的Failover 可以分为3种： 1. Client-Si
form表单提交数据编码方式及tomcat的接受编码方式 antonyup_2006 JavaScript tomcat 浏览器互联网 servlet
原帖地址：http://www.iteye.com/topic/266705 form有2中方法把数据提交给服务器，get和post,分别说下吧。（一）get提交 1.首先说下客户端（浏览器）的form表单用get方法是如何将数据编码后提交给服务器端的吧。对于get方法来说，都是把数据串联在请求的url后面作为参数，如：http://localhost:
JS初学者必知的基础百合不是茶 js函数 js入门基础
JavaScript是网页的交互语言,实现网页的各种效果, JavaScript 是世界上最流行的脚本语言。 JavaScript 是属于 web 的语言，它适用于 PC、笔记本电脑、平板电脑和移动电话。 JavaScript 被设计为向 HTML 页面增加交互性。许多 HTML 开发者都不是程序员，但是 JavaScript 却拥有非常简单的语法。几乎每个人都有能力将小的
iBatis的分页分析与详解 bijian1013 java ibatis
分页是操作数据库型系统常遇到的问题。分页实现方法很多，但效率的差异就很大了。iBatis是通过什么方式来实现这个分页的了。查看它的实现部分，发现返回的PaginatedList实际上是个接口，实现这个接口的是PaginatedDataList类的对象，查看PaginatedDataList类发现，每次翻页的时候最
精通Oracle10编程SQL(15)使用对象类型 bijian1013 oracle 数据库 plsql
/* *使用对象类型 */ --建立和使用简单对象类型 --对象类型包括对象类型规范和对象类型体两部分。 --建立和使用不包含任何方法的对象类型 CREATE OR REPLACE TYPE person_typ1 as OBJECT( name varchar2(10),gender varchar2(4),birthdate date ); drop type p
【Linux命令二】文本处理命令awk bit1129 linux命令
awk是Linux用来进行文本处理的命令，在日常工作中，广泛应用于日志分析。awk是一门解释型编程语言，包含变量，数组，循环控制结构，条件控制结构等。它的语法采用类C语言的语法。 awk命令用来做什么？ 1.awk适用于具有一定结构的文本行，对其中的列进行提取信息 2.awk可以把当前正在处理的文本行提交给Linux的其它命令处理，然后把直接结构返回给awk 3.awk实际工
JAVA(ssh2框架)+Flex实现权限控制方案分析白糖_ java
目前项目使用的是Struts2+Hibernate+Spring的架构模式，目前已经有一套针对SSH2的权限系统，运行良好。但是项目有了新需求：在目前系统的基础上使用Flex逐步取代JSP，在取代JSP过程中可能存在Flex与JSP并存的情况，所以权限系统需要进行修改。【SSH2权限系统的实现机制】权限控制分为页面和后台两块：不同类型用户的帐号分配的访问权限是不同的，用户使
angular.forEach boyitech AngularJS AngularJS API angular.forEach
angular.forEach 描述: 循环对obj对象的每个元素调用iterator, obj对象可以是一个Object或一个Array. Iterator函数调用方法: iterator(value, key, obj), 其中obj是被迭代对象，key是obj的property key或者是数组的index，value就是相应的值啦. (此函数不能够迭代继承的属性.)
java-谷歌面试题-给定一个排序数组，如何构造一个二叉排序树 bylijinnan 二叉排序树
import java.util.LinkedList; public class CreateBSTfromSortedArray { /** * 题目:给定一个排序数组，如何构造一个二叉排序树 * 递归 */ public static void main(String[] args) { int[] data = { 1, 2, 3, 4,
action执行2次 Chen.H JavaScript jsp XHTML css Webwork
xwork 写道 <action name="userTypeAction" class="com.ekangcount.website.system.view.action.UserTypeAction"> <result name="ssss" type="dispatcher">
[时空与能量]逆转时空需要消耗大量能源 comsci 能源
无论如何,人类始终都想摆脱时间和空间的限制....但是受到质量与能量关系的限制,我们人类在目前和今后很长一段时间内,都无法获得大量廉价的能源来进行时空跨越..... 在进行时空穿梭的实验中,消耗超大规模的能源是必然
oracle的正则表达式(regular expression)详细介绍 daizj oracle 正则表达式
正则表达式是很多编程语言中都有的。可惜oracle8i、oracle9i中一直迟迟不肯加入，好在oracle10g中终于增加了期盼已久的正则表达式功能。你可以在oracle10g中使用正则表达式肆意地匹配你想匹配的任何字符串了。正则表达式中常用到的元数据(metacharacter)如下： ^ 匹配字符串的开头位置。 $ 匹配支付传的结尾位置。 *
报表工具与报表性能的关系 datamachine 报表工具 birt 报表性能润乾报表
在选择报表工具时，性能一直是用户关心的指标，但是，报表工具的性能和整个报表系统的性能有多大关系呢？要回答这个问题，首先要分析一下报表的处理过程包含哪些环节，哪些环节容易出现性能瓶颈，如何优化这些环节。一、报表处理的一般过程分析 1、用户选择报表输入参数后，报表引擎会根据报表模板和输入参数来解析报表，并将数据计算和读取请求以SQL的方式发送给数据库。 2、
初一上学期难记忆单词背诵第一课 dcj3sjt126com word english
what 什么 your 你 name 名字 my 我的 am 是 one 一 two 二 three 三 four 四 five 五 class 班级，课 six 六 seven 七 eight 八 nince 九 ten 十 zero 零 how 怎样 old 老的 eleven 十一 twelve 十二 thirteen
我学过和准备学的各种技术 dcj3sjt126com 技术
语言VB https://msdn.microsoft.com/zh-cn/library/2x7h1hfk.aspxJava http://docs.oracle.com/javase/8/C# https://msdn.microsoft.com/library/vstudioPHP http://php.net/manual/en/Html
struts2中token防止重复提交表单蕃薯耀重复提交表单 struts2中token
struts2中token防止重复提交表单 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 蕃薯耀 2015年7月12日 11:52:32 星期日 ht
线性查找二维数组 hao3100590 二维数组
1.算法描述有序（行有序，列有序，且每行从左至右递增，列从上至下递增）二维数组查找，要求复杂度O(n) 2.使用到的相关知识：结构体定义和使用，二维数组传递（http://blog.csdn.net/yzhhmhm/article/details/2045816） 3.使用数组名传递这个的不便之处很明显，一旦确定就是不能设置列值 //使
spring security 3中推荐使用BCrypt算法加密密码 jackyrong Spring Security
spring security 3中推荐使用BCrypt算法加密密码了，以前使用的是md5， Md5PasswordEncoder 和 ShaPasswordEncoder，现在不推荐了，推荐用bcrpt Bcrpt中的salt可以是随机的，比如： int i = 0; while (i < 10) { String password = "1234
学习编程并不难,做到以下几点即可! lampcy java html 编程语言
不论你是想自己设计游戏，还是开发iPhone或安卓手机上的应用，还是仅仅为了娱乐，学习编程语言都是一条必经之路。编程语言种类繁多，用途各异，然而一旦掌握其中之一，其他的也就迎刃而解。作为初学者，你可能要先从Java或HTML开始学，一旦掌握了一门编程语言，你就发挥无穷的想象，开发各种神奇的软件啦。 1、确定目标学习编程语言既充满乐趣，又充满挑战。有些花费多年时间学习一门编程语言的大学生到
架构师之mysql----------------用group+inner join,left join ,right join 查重复数据（替代in) nannan408 right join
1.前言。如题。 2.代码 (1)单表查重复数据,根据a分组 SELECT m.a,m.b, INNER JOIN （select a,b,COUNT(*) AS rank FROM test.`A` A GROUP BY a HAVING rank>1 )k ON m.a=k.a （2）多表查询，使用改为le
jQuery选择器小结 VS 节点查找（附css的一些东西） Everyday都不同 jquery css name选择器追加元素查找节点
最近做前端页面，频繁用到一些jQuery的选择器，所以特意来总结一下：测试页面： <html> <head> <script src="jquery-1.7.2.min.js"></script> <script> /*$(function() { $(documen
关于EXT tntxia ext
ExtJS是一个很不错的Ajax框架，可以用来开发带有华丽外观的富客户端应用，使得我们的b/s应用更加具有活力及生命力。ExtJS是一个用 javascript编写，与后台技术无关的前端ajax框架。因此，可以把ExtJS用在.Net、Java、Php等各种开发语言开发的应用中。 ExtJs最开始基于YUI技术，由开发人员Jack
一个MIT计算机博士对数学的思考 xjnine Math
在过去的一年中，我一直在数学的海洋中游荡，research进展不多，对于数学世界的阅历算是有了一些长进。为什么要深入数学的世界？作为计算机的学生，我没有任何企图要成为一个数学家。我学习数学的目的，是要想爬上巨人的肩膀，希望站在更高的高度，能把我自己研究的东西看得更深广一些。说起来，我在刚来这个学校的时候，并没有预料到我将会有一个深入数学的旅程。我的导师最初希望我去做的题目，是对appe