汉东哥

谷粒商城详细笔记

前言

mysql安装在腾讯云

redis安装在本地虚拟机master上

运行时，renren-fast这个项目要到单独开个idea窗口打开。

一、项目简介

1、项目微服务架构图

微服务：拒绝大型单体应用，基于业务边界进行服务微化拆分，各个服务独立部署运行。
各个服务都注册到注册中心，别的服务可以通过注册中心发现我们的服务。

2、微服务划分图

二、开发

1、配置虚拟机

安装vmware（阿里云盘：IT技术学习 - gulimall-soft）
- 网址：https://www.vmware.com/cn/products/workstation-pro/workstation-pro-evaluation.html
- 下载地址：https://www.vmware.com/go/getworkstation-win
- vmware16pro许可证密钥最新
  - ZF3R0-FHED2-M80TY-8QYGC-NPKYF
  - YF390-0HF8P-M81RQ-2DXQE-M2UT6
  - ZF71R-DMX85-08DQY-8YMNC-PPHV8
本机搭建Linux (centos)
- 点击创建新的虚拟机
- 点击自定义下一步
- 点击下一步
- 点击稍后安装操作系统下一步
- 点击 Linux CentOS 7 64位下一步
- 修改虚拟机名称slave 修改位置下一步
- 处理器配置设置下一步
- 内存3072 下一步
- 网络类型
- 虚拟机向导
- 磁盘类型
- 选择磁盘
- 指定磁盘容量50G
- 指定磁盘文件（直接下一步）
- 点击完成
- 点击编辑虚拟机设置
- 点击 CD/DVD 使用ISO映像文件浏览
- 选择镜像文件所在位置（下载地址:http://ftp.sjtu.edu.cn/centos/7/isos/x86_64/CentOS-7-x86_64-DVD-2009.iso）
- 点击确定
- 点击开启此虚拟机
- 鼠标点进去点回车
- 继续点回车
- 点击 ESC （停止检测）
- 选择中文简体继续
- 稍等片刻，待出现如下时，点击软件选择
- 选择基础设施服务器完成
- 稍等片刻，待出现如下时，点击安装位置
- 点击完成
- 点击网络和主机名
- 点击配置
- 点击常规选中-可用时自动链接到这个网络
- 查看网段
  - 点击编辑虚拟网络编辑
  - 复制好这个网段 192.168.91.0
- 按如下配置，完了点保存
- 设置主机名
- 点击开始安装
- 设置 root密码
- 稍等片刻，安装完成！！！
- 视频地址：https://www.bilibili.com/video/BV1Qv41167ck?p=6
- centos镜像下载地址：http://ftp.sjtu.edu.cn/centos/7/isos/x86_64/CentOS-7-x86_64-DVD-2009.iso

2、linux连接工具安装

位置：阿里云盘（IT技术学习 - gulimall-soft - Xmanager-7）
解压安装包运行安装程序，点击下一步，选择安装位置，建议安D盘（英文路径），记住自己的安装位置，后面要用到
解压插件包

解压后如下图所示
全选复制解压后的文件，到安装包安装的路径，例如我安装的路径 D:\ruanjian\Xmanager-7，粘贴->替换目标中的文件
破解完毕！！！
原版地址：https://www.yuque.com/yinghuashuxia-cohok/ahov4c/eipegl

3、虚拟机安装docker

1、创建/etc/docker文件夹

sudo mkdir -p /etc/docker

2、配置镜像加速

// 阿里云 https://cr.console.aliyun.com/cn-shanghai/instances/mirrors
// 从上面地址里的 镜像工具 中找到 镜像加速器
sudo tee /etc/docker/daemon.json <<-'EOF'
{
  "registry-mirrors": ["https://lcfrsqb4.mirror.aliyuncs.com"]
}
EOF

//腾讯云
sudo tee /etc/docker/daemon.json <<-'EOF'
{
"registry-mirrors": ["https://mirror.ccs.tencentyun.com"]
}
EOF

// 设置完后重启下daemon
sudo systemctl daemon-reload

//重启docker
sudo systemctl restart docker

3、卸载旧版本

sudo yum remove docker \
                docker-client \
                docker-client-latest \
                docker-common \
                docker-latest \
                docker-latest-logrotate \
                docker-logrotate \
                docker-engine

4、设置Docker仓库源地址

// 阿里云的源地址
$ sudo yum-config-manager \
    --add-repo \
    http://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo

// 清华大学源地址
$ sudo yum-config-manager \
    --add-repo \
    https://mirrors.tuna.tsinghua.edu.cn/docker-ce/linux/centos/docker-ce.repo

5、安装 Docker

sudo yum install docker-ce docker-ce-cli containerd.io

6、启动Docker

sudo systemctl start docker

7、设置为开机自启

sudo systemctl enable docker

3、docker安装mysql

1、拉取mysql镜像

docker pull mysql:5.7

2、运行mysql

# --name指定容器名字 -v目录挂载 -p指定端口映射  -e设置mysql参数 -d后台运行
sudo docker run -p 3306:3306 --name mysql \
-v /mydata/mysql/log:/var/log/mysql \
-v /mydata/mysql/data:/var/lib/mysql \
-v /mydata/mysql/conf:/etc/mysql \
-e MYSQL_ROOT_PASSWORD=root \
-d mysql:5.7
####
-v 将对应文件挂载到主机
-e 初始化对应
-p 容器端口映射到主机的端口

3、创建&修改配置文件

vi /mydata/mysql/conf/my.cnf

里面的具体内容

[client]
default-character-set=utf8
[mysql]
default-character-set=utf8
[mysqld]
init_connect='SET collation_connection = utf8_unicode_ci'
init_connect='SET NAMES utf8'
character-set-server=utf8
collation-server=utf8_unicode_ci
skip-character-set-client-handshake
skip-name-resolve

4、重启mysql

docker restart mysql

5、设置自动启动

sudo docker update mysql --restart=always   //docker中开机自启

4、安装Redis

1、下载镜像文件

docker pull redis

2、创建本地映射文件

mkdir -p /mydata/redis/conf

touch /mydata/redis/conf/redis.conf

3、修改映射配置文件内容

vim /mydata/redis/conf/redis.conf

具体内容

appendonly yes

表示数据持久化，不会重启就丢。

4、启动同时映射到对应文件夹

docker run -p 6379:6379 --name redis \
-v /mydata/redis/data:/data \
-v /mydata/redis/conf/redis.conf:/etc/redis/redis.conf \
-d redis redis-server /etc/redis/redis.conf

5、使用 redis 镜像执行 redis-cli 命令连接

docker exec -it redis redis-cli

6、重启Redis

docker restart redis

7、设置为开机自启

sudo docker update redis --restart=always

8、安装redis-desktop-manager

安装包在阿里云盘。（IT技术学习 - gulimall-soft）

8、统一开发环境

1、jdk至少是1.8

1、查看云端目前支持安装的jdk版本

[root@localhost ~]# yum search java|grep jdk
ldapjdk-javadoc.noarch : Javadoc for ldapjdk
java-1.6.0-openjdk.x86_64 : OpenJDK Runtime Environment
java-1.6.0-openjdk-demo.x86_64 : OpenJDK Demos

2、安装

[root@localhost ~]#  yum install -y java-1.8.0-openjdk

3、验证

[root@localhost ~]# java -version
openjdk version "1.8.0_151"

4、安装openjdk-devel（jps）

sudo yum install java-1.8.0-openjdk-devel.x86_64

2、安装配置linux maven

下载maven
- 下载地址：https://maven.apache.org/download.cgi （或者直接从阿里网盘取）
  
  [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-TFKIB7Ex-1684464779513)(images/谷粒商城项目笔记/image-20220502155305378.png)]
放到/usr/local/目录下

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-60LOfMgw-1684464779513)(images/谷粒商城项目笔记/image-20220502155403659.png)]
解压
```
tar -zxvf apache-maven-3.8.5-bin.tar.gz
```
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-5tPUA9ZZ-1684464779514)(images/谷粒商城项目笔记/image-20220502155506298.png)]
配置maven仓库
- 进入cd apache-maven-3.6.3目录
```
cd apache-maven-3.8.5   #进入apache-maven-3.8.5目录
```
- 创建ck目录
```
mkdir ck    #创建ck目录
```
- 编辑settings.xml文件
```
cd conf            # 进入conf目录

vi settings.xm # settings.xm文件
```
- 找到localRepository下面加上如下
```
<localRepository>/usr/local/apache-maven-3.8.5/ck</localRepository>
```
  [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-5wFTKqqt-1684464779514)(images/谷粒商城项目笔记/image-20220502160004889.png)]
- 找到mirror 加上阿里的仓库配置
```
<mirror>
      <id>alimaven</id>
      <name>aliyun maven</name>
       <url>http://maven.aliyun.com/nexus/content/groups/public/</url>
      <mirrorOf>central</mirrorOf>
</mirror>
```
  [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-2t0CsTBF-1684464779514)(images/谷粒商城项目笔记/image-20220502160037809.png)]
- 编辑：vi /etc/profile 文件，翻到最后加上如下
```
export MAVEN_HOME=/usr/local/apache-maven-3.8.5
export PATH=$PATH:$MAVEN_HOME/bin
```
  [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-bz7rUllG-1684464779514)(images/谷粒商城项目笔记/image-20220502160217274.png)]
- 重新加载一下，使新增配置生效
```
source /etc/profile
```
安装完成，测试一下
```
mvn -v
```
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-tMOXM6Pd-1684464779515)(images/谷粒商城项目笔记/image-20220502160403364.png)]

3、配置win10 maven

配置阿里云镜像

<mirrors>
		<mirror>
		<id>nexus-aliyun</id>
		<mirrorOf>central</mirrorOf>
		<name>Nexus aliyun</name>
		<url>http://maven.aliyun.com/nexus/content/groups/public</url>
		</mirror>
	</mirrors>

配置 jdk 1.8 编译项目

<profiles>
		<profile>
			<id>jdk-1.8</id>
			<activation>
				<activeByDefault>true</activeByDefault>
				<jdk>1.8</jdk>
			</activation>
			<properties>
				<maven.compiler.source>1.8</maven.compiler.source>
				<maven.compiler.target>1.8</maven.compiler.target>
				<maven.compiler.compilerVersion>1.8</maven.compiler.compilerVersion>
			</properties>
		</profile>
	</profiles>

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-noRl1Do1-1684464779515)(images/谷粒商城项目笔记/image-20220502161154177.png)]

4、安装vscode

下载地址：https://code.visualstudio.com/Download （阿里网盘也有备份）
- 安装插件
  
  [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-2FEKrngd-1684464779515)(images/谷粒商城项目笔记/image-20220502162914480.png)]

5、配置git信息

安装git （https://git-scm.com/）（阿里网盘有备份：IT技术学习 - gulimall-soft）

配置用户名

git config --global user.name "liuhandong" #这个不需要和注册时一样

配置邮箱
```
git config --global user.email "[email protected]" # 注册账号使用的邮箱
```
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-htmFg8L2-1684464779515)(images/谷粒商城项目笔记/image-20220502163225891.png)]

配置 ssh 免密登录

ssh-keygen -t rsa -C "[email protected]"

连点三次回车

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-niFrhzpR-1684464779515)(images/谷粒商城项目笔记/image-20220502164158401.png)]
查看密钥
```
cat ~/.ssh/id_rsa.pub
```
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ErhKAlNh-1684464779516)(images/谷粒商城项目笔记/image-20220502164238936.png)]
复制密钥
进入gitee的安全设置，把刚才复制的密钥粘贴到公钥框中

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-KSvm3zbv-1684464779516)(images/谷粒商城项目笔记/image-20220502164358929.png)]
测试该密钥
```
ssh -T [email protected]
```
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ws89M2Lh-1684464779516)(images/谷粒商城项目笔记/image-20220502164714488.png)]

6、初始化gitee

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-jjs2cjVK-1684464779516)(images/谷粒商城项目笔记/image-20220502164939532.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-VNphaNbB-1684464779516)(images/谷粒商城项目笔记/image-20220502165236550.png)]

7、填充几大核心服务骨架

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-UDBslGaR-1684464779517)(images/谷粒商城项目笔记/image-20220502175101221.png)]

8、初始化数据库

创建数据库（服务器中的数据库，每个服务分别对应一个数据库）
```
gulimall_oms   //订单系统

gulimall_pms   //商品系统

gulimall_sms   //sell营销系统

gulimall_ums   //用户系统

gulimall_wms   //库存系统
```
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-cJHj9CNc-1684464779517)(images/谷粒商城项目笔记/image-20220502174800320.png)]
分别运行下面gitee中的sql语句
```
https://gitee.com/dongHangDongHang/gulimall/tree/master/sql
```
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-3KxOH4SC-1684464779517)(images/谷粒商城项目笔记/image-20220502174252737.png)]

9、逆向工程搭建

打开renren-generator项目
- 下载地址：https://gitee.com/renrenio/renren-generator.git
修改application.yml中的数据库配置
- 数据库指向我们想要生成实体类，controller代码的哪个数据库。
修改generator.properties配置文件

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-W84R96N5-1684464779517)(images/谷粒商城项目笔记/image-20220506101644326.png)]
启动该项目
- 访问localhost:80
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-XTK2YXy9-1684464779518)(images/谷粒商城项目笔记/image-20220506102339977.png)]

10、MybatisPlus整合

导入依赖

<dependency>
    <groupId>com.baomidougroupId>
    <artifactId>mybatis-plus-boot-starterartifactId>
    <version>3.2.0version>
dependency>

配置数据源

导入数据库驱动

https://mvnrepository.com/artifact/mysql/mysql-connector-java

 
        <dependency>
            <groupId>mysqlgroupId>
            <artifactId>mysql-connector-javaartifactId>
            <version>8.0.17version>
        dependency>

在application.yml配置数据源相关信息

spring:
  datasource:
    username: root
    password: root
    url: jdbc:mysql://192.168.56.10:3306/gulimall_pms
    driver-class-name: com.mysql.jdbc.Driver
mybatis-plus:
	# mapper文件扫描
  mapper-locations: classpath*:/mapper/**/*.xml
  global-config:
    db-config:
      id-type: auto # 数据库主键自增

配置MyBatis-Plus包扫描：

使用@MapperScanner

告诉MyBatis-Plus,Sql映射文件位置

@MapperScan("com.atguigu.gulimall.product.dao")
@SpringBootApplication
public class GulimallProductApplication {
    public static void main(String[] args) {
        SpringApplication.run(GulimallProductApplication.class, args);
    }
}

具体过程参考官网： https://baomidou.com/guide/install.html#release

分页配置

@Configuration // 声明配置类
@EnableTransactionManagement // 开启注解
@MapperScan("com.atguigu.gulimall.product.dao") // 指定扫描包
public class MyBatisConfig {


    /**
     * 引入分页插件 拦截器
     * @return
     */
    @Bean
    public PaginationInterceptor paginationInterceptor() {
        PaginationInterceptor paginationInterceptor = new PaginationInterceptor();
        // 设置请求的页面大于最大页后操作， true调回到首页，false 继续请求  默认false
         paginationInterceptor.setOverflow(true);
        // 设置最大单页限制数量，默认 500 条，-1 不受限制
         paginationInterceptor.setLimit(1000);
        // 开启 count 的 join 优化,只针对部分 left join
        paginationInterceptor.setCountSqlParser(new JsqlParserCountOptimize(true));
        return paginationInterceptor;
    }
}

逻辑删除

说明:

只对自动注入的sql起效:

插入: 不作限制
查找: 追加where条件过滤掉已删除数据,且使用 wrapper.entity 生成的where条件会忽略该字段
更新: 追加where条件防止更新到已删除数据,且使用 wrapper.entity 生成的where条件会忽略该字段
删除: 转变为更新

例如:

删除: update user set deleted=1 where id = 1 and deleted=0
查找: select id,name,deleted from user where deleted=0

步骤1：配置 application.yml

mybatis-plus:
  mapper-locations: classpath*:/mapper/**/*.xml
  global-config:
    db-config:
      id-type: auto # 数据库主键自增
      logic-delete-value: 1 # 逻辑已删除值(默认为 1)
      logic-not-delete-value: 0 # 逻辑未删除值(默认为 0)

步骤2：实体类字段上加上@TableLogic注解

/**
 * 是否显示[0-不显示，1显示]
 */
@TableLogic(value = "1",delval = "0")
private Integer showStatus;

11、安装postman

下载安装包（阿里云盘：IT技术学习 - gulimall-soft）
安装后账号登陆
- 账号：[email protected]
- 密码：19950420liu

9、SpringCloudAlibaba搭建

1、中文文档地址

https://github.com/alibaba/spring-cloud-alibaba/blob/2.2.x/README-zh.md

nacos标准注册流程：

https://github.com/alibaba/spring-cloud-alibaba/blob/2.2.x/spring-cloud-alibaba-examples/nacos-example/nacos-discovery-example/readme-zh.md

2、版本选择

<spring-boot.version>2.1.8.RELEASEspring-boot.version>
<spring-cloud.version>Greenwich.SR3spring-cloud.version>

3、在common的pom.xml中加入

        
        <dependency>
            <groupId>com.alibaba.cloudgroupId>
            <artifactId>spring-cloud-starter-alibaba-nacos-discoveryartifactId>
        dependency>

# 下面是依赖管理，相当于以后再dependencies里引spring cloud alibaba就不用写版本号， 全用dependencyManagement进行管理
<dependencyManagement>
     <dependencies>
         <dependency>
             <groupId>com.alibaba.cloudgroupId>
             <artifactId>spring-cloud-alibaba-dependenciesartifactId>
             <version>2.1.0.RELEASEversion>
             <type>pomtype>
             <scope>importscope>
         dependency>
     dependencies>
dependencyManagement>

4、下载nacos

地址：https://github.com/alibaba/nacos/releases/tag/1.1.3 （阿里网盘有备份）

5、启动nacos

双击nacos/bin目录下的startup.cmd

5、在服务配置文件中指定注册中心地址

spring:
  application:
    name: gulimall-coupon  # 注意这里的name一定要有，不然注册不进去
  cloud:
    nacos:
      discovery:
        server-addr: localhost:8848

6、使用 @EnableDiscoveryClient 注解开启服务注册与发现功能

 @SpringBootApplication
 @EnableDiscoveryClient
 public class ProviderApplication {

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

7、查看注册结果

启动刚才使用了@EnableDiscoveryClient注解的服务
访问：http://localhost:8848/nacos/#/serviceManagement?dataId=&group=&appName=&namespace=
点击服务列表，看到该服务已注册进去。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-fvaFRdoZ-1684464779518)(images/谷粒商城项目笔记/image-20220503115337555.png)]

8、使用Feign进行远程调用

给调用者导包（此时他就有了远程调用其他服务的能力）

<dependency>
    <groupId>org.springframework.cloudgroupId>
    <artifactId>spring-cloud-starter-openfeignartifactId>
dependency>

在该服务中创建远程调用的哪个服务的接口
```
public interface CouponFeignService {

}
```

在该接口前加注解

@FeignClient("gulimall-coupon")  //里面就是被调用的服务的类目，和nacos上显示的一致
public interface CouponFeignService {

}

把要调用的哪个服务的方法粘过来

@FeignClient("gulimall-coupon")
public interface CouponFeignService {

    @RequestMapping("/coupon/coupon/member/list")  //这里的路径要写全
    public R membercoupons();

}

在该服务中开启远程调用的功能（主启动类前加注解@EnableFeignClients）

@EnableFeignClients(basePackages = "com.atguigu.gulimall.member.feign")
@EnableDiscoveryClient
@SpringBootApplication
public class GulimallMemberApplication {
    public static void main(String[] args) {
        SpringApplication.run(GulimallMemberApplication.class, args);
    }
}

在controller中注入该类，，并使用

@Autowired
private CouponFeignService couponFeignService;

@RequestMapping("/coupons")
public R test(){
    MemberEntity member = new MemberEntity();
    member.setNickname("张三");
    R membercoupons = couponFeignService.membercoupons();
    return new R().put("member",member).put("coupons",membercoupons.get("coupons"));
}

然后启动这个服务和被调用的服务，并查看nacos上是否注册成功（启动时坑：若IDEA是2021.3版本，则lombok需是最新版）

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-cxEPxHLf-1684464779518)(images/谷粒商城项目笔记/image-20220503145255418.png)]
发起url调用，测试调用结果：http://localhost:8000/member/member/coupons

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-BvWtsuPv-1684464779518)(images/谷粒商城项目笔记/image-20220503145533880.png)]

9、使用nacos做分布式配置中心

中文文档：github.com/alibaba/spring-cloud-alibaba/blob/master/spring-cloud-alibaba-examples/nacos-example/nacos-config-example/readme-zh.md
gitee：https://gitee.com/gaoziteng/spring-cloud-alibaba-0221.git

导包（直接放在common的pom中）


<dependency>
    <groupId>com.alibaba.cloudgroupId>
    <artifactId>spring-cloud-starter-alibaba-nacos-configartifactId>
dependency>

在要使用配置中心的服务中创建bootstrap.properties，配置Nacos Config元数据（该文件优先与application.yml，先被加载）
```
spring.application.name=gulimail-coupon
spring.cloud.nacos.config.server-addr=127.0.0.1:8848
```
测试读取application.properties中的值
- application.properties加入如下
```
coupon.user.name=jiangsan
coupon.user.age=15
```
- CouponController加入如下
```
@Value("${coupon.user.name}")
private String name;

@Value("${coupon.user.age}")
private Integer age;

@RequestMapping("/test")
public R test(){
    return R.ok().put("name",name).put("age",age);
}
```
- 测试路径：http://localhost:7000/coupon/coupon/test
  
  [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-6UOwFOuo-1684464779519)(images/谷粒商城项目笔记/image-20220503151651919.png)]
在nacos中添加配置

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-dLUQtRV5-1684464779519)(images/谷粒商城项目笔记/image-20220506124044548.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-tVi1Jk9I-1684464779519)(images/谷粒商城项目笔记/image-20220506124201393.png)]
此时重启服务，加载到nacos配置

http://localhost:7000/coupon/coupon/test

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-fGXq5Q4p-1684464779520)(images/谷粒商城项目笔记/image-20220506131542325.png)]
但是此时没有动态刷新

在启动类加@RefreshScope

@RefreshScope
@EnableDiscoveryClient
@SpringBootApplication
public class Coupon7000 {
    public static void main(String[] args) {
        SpringApplication.run(Coupon7000.class, args);
    }
}

这里保留一个问题，就是我加了注解，但是任然没有动态刷新

后来发现@RefreshScope注解应加在controller上面

@RefreshScope
@RestController
@RequestMapping("coupon/coupon")
public class CouponController {

测试application.yml和application.properties的加载优先级
- 此时在application.yml加入如下
```
coupon:
  user:
    name: 战狼
    age: 27
```
- 此时application.yml和application.properties中都有，运行http://localhost:7000/coupon/coupon/test
  
  [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-JwIOqkJA-1684464779520)(images/谷粒商城项目笔记/image-20220503151651919.png)]
- 发现此时还是application.properties生效
- 将application.properties中的内容删除，再次运行
  
  [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-uKaYB3PQ-1684464779520)(images/谷粒商城项目笔记/image-20220503152258290.png)]
- 此时application.yml生效
删除本地的这俩位置配置，并去nacos新建配置（名字是服务名+.properties）

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-R78UfpXn-1684464779520)(images/谷粒商城项目笔记/image-20220503152649781.png)]

去主启动类，加注解 @RefreshScope

@RefreshScope   //动态刷新
@EnableDiscoveryClient
@SpringBootApplication
public class GulimallCouponApplication {

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

}

10、nacos配置中心进阶

10.1、命名空间

命名空间：配置集隔离

默认public。默认新增的配置都在public空间下
    
用于进行租户粒度的配置隔离。不同的命名空间下，可以存在相同的 Group 或 DatalD 的配置。Namespace 的常用场景之一是不同环境的配置的区分隔离，例如开发测试环境和生产环境的资源(如配置、服务)隔离等。

创建几个命名空间

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Q5FAhtsx-1684464779521)(images/谷粒商城项目笔记/image-20220506135227732.png)]
在prop下也创建gulimall-coupon.properties

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-9W14qoCu-1684464779521)(images/谷粒商城项目笔记/image-20220506135607821.png)]
如果希望使用prop下的配置
- 在bootstrop.properties下
```
spring.application.name=gulimail-coupon   
spring.cloud.nacos.config.server-addr=127.0.0.1:8848
spring.cloud.nacos.config.namespace=6a6e47e3-f4e3-4605-ad67-b7759e3c1c5f
```
- namespace的值从如下位置获取
  
  [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-LmZ1eg24-1684464779521)(images/谷粒商城项目笔记/image-20220506135930145.png)]
- 此时就使用的是prop下的配置文件了

10.2、配置集

一组相关或者不相关的配置项的集合称为配置集。在系统中，一个配置文件通常就是一个配置集，包含了系统各个方面的配置。例如，一个配置集可能包含了数据源、线程池、日志级别等配置项。

10.3、配置集ID

类似文件名

10.4、配置分组

如果不写就默认DEFAULT_GROUP

Group

切换配置组的操作
- 新建配置
  
  [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-4fb8JUTe-1684464779521)(images/谷粒商城项目笔记/image-20220506141033940.png)]
- bootstrap.properties加如下配置
```
spring.application.name=gulimail-coupon   
spring.cloud.nacos.config.server-addr=127.0.0.1:8848
spring.cloud.nacos.config.namespace=6a6e47e3-f4e3-4605-ad67-b7759e3c1c5f
spring.cloud.nacos.config.group=1111
```
- 重启服务后生效的就是1111这个组的配置

每个微服务创建自己的命名空间，使用配置分组来区分环境

11.5、同时加载多个配置集

在coupon命名空间下新建配置（存储数据库加载相关配置）

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-abqGVqmr-1684464779522)(images/谷粒商城项目笔记/image-20220506142047462.png)]
在coupon命名空间下新建配置（mybatis相关配置）

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-kjzXcWRh-1684464779522)(images/谷粒商城项目笔记/image-20220506142331778.png)]
其他配置

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-eYPTbey0-1684464779522)(images/谷粒商城项目笔记/image-20220506142553381.png)]

修改bootstrap.properties

spring.application.name=gulimail-coupon
spring.cloud.nacos.config.server-addr=127.0.0.1:8848
spring.cloud.nacos.config.namespace=70a3355c-30cf-45c9-8a29-7ebc568cf41a
#spring.cloud.nacos.config.group=dev

spring.cloud.nacos.config.ext-config[0].data-id=datasource.yml
spring.cloud.nacos.config.ext-config[0].group=dev
spring.cloud.nacos.config.ext-config[0].refresh=true

spring.cloud.nacos.config.ext-config[1].data-id=mybatis.yml
spring.cloud.nacos.config.ext-config[1].group=dev
spring.cloud.nacos.config.ext-config[1].refresh=true

spring.cloud.nacos.config.ext-config[2].data-id=other.yml
spring.cloud.nacos.config.ext-config[2].group=dev
spring.cloud.nacos.config.ext-config[2].refresh=true
#
spring.cloud.nacos.config.ext-config[3].data-id=gulimall-coupon.properties
spring.cloud.nacos.config.ext-config[3].group=dev
spring.cloud.nacos.config.ext-config[3].refresh=true

重启后配置生效

11、Gateway网关

官方文档：https://docs.spring.io/spring-cloud-gateway/docs/current/reference/html/

开启网关服务注册发现（注册到nacos）

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

配置文件中注册中心和配置中心nacos地址

spring:
  application:
    name: gulimall-gateway
  cloud:
    nacos:
      discovery:
        server-addr: localhost:8848
      config:
        server-addr: localhost:8848

设置配置中心名称空间

由于网关暂时没有引入数据库的配置，就拍掉相关依赖

@EnableDiscoveryClient
@SpringBootApplication(exclude = {DataSourceAutoConfiguration.class})
public class Gateway88 {
    public static void main(String[] args) {
        SpringApplication.run(Gateway88.class, args);
    }
}

设置网关路由

spring:
  cloud:
    gateway:
      routes:
        - id: test_route
          uri: https://www.baidu.com
          predicates:
            - Query=url,baidu   #url=baidu则进去百度页面
        - id: test_qq
          uri: https://www.qq.com
          predicates:
            - Query=url,qq      #url=qq则进去qq页面

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-SaV6QONl-1684464779522)(images/谷粒商城项目笔记/image-20220503194841442.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-X89A3xFP-1684464779523)(images/谷粒商城项目笔记/image-20220503194900304.png)]

10、运行gateway服务

11、运行renren-fast服务

12、运行renren-fast-vue服务

安装nodejs 10.16.3
- 下载地址：https://nodejs.org/download/release/v10.16.3/node-v10.16.3-x64.msi
- 安装完成后检查一下
  
  [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-o2TuImPp-1684464779523)(images\谷粒商城项目笔记\image-20220611174029302.png)]
设置npm的镜像仓库位置
```
npm config set registry http://registry.npm.taobao.org/  # 设置node仓库。提高下载速度
```
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-32ZqihlR-1684464779523)(images\谷粒商城项目笔记\image-20220611174325843.png)]
下载组件
```
npm install
```
此时如果出现了异常，可以尝试安装不同版本的nodejs试试（这里使用14.13.0版本的好像比较好使）
运行程序
```
npm run dev
```
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-bieH5B0g-1684464779524)(images\谷粒商城项目笔记\image-20220612094318245.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-W2bjQNQ8-1684464779524)(images\谷粒商城项目笔记\image-20220612094330215.png)]
- 如果出现了如下异常
```
Module build failed: Error: Missing binding D:\Idea_WorkSpace\gulimall\renren-fast-vue\node_modules\node-sass\vendor\win32-x64-83\binding.node Node Sass could not find a binding for your current environment: Windows 64-bit with Node.js 14.x
```
- 就执行如下代码
```
npm i node-sass
```
- 然后再执行
```
npm run dev
```
登录进去（账号密码：admin/admin）

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-fWaTqPTg-1684464779524)(images\谷粒商城项目笔记\image-20220612094432674.png)]

这里使用vscode

启动虚拟机

启动虚拟机
启动里面的redis

7、运行thirdparty服务

8、运行product服务

9、运行ware服务

10、安装elasticsearch、kibana、ik分词器

11、配置nginx

开发

商品服务-三级分类

三级分类添加

新增一级目录

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-BT0jwEWb-1684464779525)(images\谷粒商城项目笔记\image-20220612103734072.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-hYt2vcPm-1684464779526)(images\谷粒商城项目笔记\image-20220612103836424.png)]

此时刷新页面看到如下：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-gNI7jTfY-1684464779526)(images\谷粒商城项目笔记\image-20220612104038960.png)]

具体添加的系统数据本身在gulimall_admin库里的sys_menu表中

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ISfh3VyI-1684464779526)(images\谷粒商城项目笔记\image-20220612104202570.png)]
新增分类维护

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-T72muG2l-1684464779527)(images\谷粒商城项目笔记\image-20220612104246007.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-87DcmmaF-1684464779527)(images\谷粒商城项目笔记\image-20220612104410785.png)]

解决跨域问题

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

同源策略：是指协议，域名，端口都要相同，其中有一个不同都会产生跨域；

下图详细说明了 URL 的改变导致是否允许通信

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-TtiyG380-1684464779527)(images\谷粒商城项目笔记\image-20201017090210286.png)]

跨域流程

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-cdZto4Ng-1684464779527)(images\谷粒商城项目笔记\image-20201017090318165.png)]

浏览器发请求都要实现发送一个请求询问是否可以进行通信，我直接给你返回可以通信不就可以了吗？[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-NGRAjZc6-1684464779528)(/image-20201017090546193.png)]

相关资料参考：https://developer.mozilla.org/zh-CN/docs/Web/HTTP/Access_control_CORS

解决跨越（一）使用nginx部署为同一域

开发过于麻烦，上线在使用

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-LN1uPQiy-1684464779528)(images\谷粒商城项目笔记\image-20201017090434369.png)]

解决跨域（二）配置当次请求允许跨域

1、添加响应头

Access-Control-Allow-Origin: 支持哪些来源的请求跨域
Access-Control-Allow-Methods: 支持哪些方法跨域
Access-Control-Allow-Credentials: 跨域请求默认不包含cookie,设置为true可以包含cookie
Access-Control-Expose-Headers: 跨域请求暴露的字段

CORS请求时, XML .HttpRequest对象的getResponseHeader()方法只能拿到6个基本字段: CacheControl、Content-L anguage、Content Type、Expires、

Last-Modified、 Pragma。如果想拿到其他字段，就必须在Access-Control-Expose-Headers里面指定。
Access-Control-Max- Age: 表明该响应的有效时间为多少秒。在有效时间内，浏览器无须为同一-请求再次发起预检请求。请注意，浏览器自身维护了一个最大有效时间，如果该首部字段的值超过了最大有效时间，将不会生效。

网关配置文件

        - id: product_route
          uri: lb://gulimall-product
          predicates:
            - Path=/api/product/**
          filters:
            - RewritePath=/api/(?>/?.*),/$\{segment}

        - id: admin_route
          uri: lb://renren-fast  # lb负载均衡 到指定的服务
          predicates:
            - Path=/api/**  # path指定对应路径
          filters: # 重写路径
            - RewritePath=/api/(?>/?.*), /renren-fast/$\{segment}

跨越设置

请求先发送到网关，网关在转发给其他服务事先都要注册到注册中心

@Configuration
public class GulimallCorsConfiguration {

    @Bean
    public CorsWebFilter corsWebFilter() {
        UrlBasedCorsConfigurationSource source = new UrlBasedCorsConfigurationSource();

        CorsConfiguration corsConfiguration = new CorsConfiguration();

        // 配置跨越
        corsConfiguration.addAllowedHeader("*"); // 允许那些头
        corsConfiguration.addAllowedMethod("*"); // 允许那些请求方式
        corsConfiguration.addAllowedOrigin("*"); //  允许请求来源
        corsConfiguration.setAllowCredentials(true); // 是否允许携带cookie跨越
        // 注册跨越配置
        source.registerCorsConfiguration("/**",corsConfiguration);

        return new CorsWebFilter(source);
    }

}

配置中心

新建命名空间

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-qQDKeWi4-1684464779528)(images\谷粒商城项目笔记\image-20220613132743147.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-sE8s8Gq7-1684464779528)(images\谷粒商城项目笔记\image-20220613132810649.png)]
复制命名空间ID

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-z0DUw2zB-1684464779528)(images\谷粒商城项目笔记\image-20220613133056738.png)]

新建 bootstrap.properties

spring.application.name=gulimall-product

spring.cloud.nacos.config.server-addr=127.0.0.1:8848
spring.cloud.nacos.config.namespace=41bfdf41-f5db-4487-a2a8-b0a3b7c89c26   //刚才新建的命名空间的命名空间ID

商品服务&品牌管理

新建品牌管理页

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-1M5ccVCn-1684464779529)(images\谷粒商城项目笔记\image-20220613200550385.png)]

阿里云上传

上传模型

上传的账号信息存储在应用服务器
上传先找应用服务器要一个policy上传策略，生成防伪签名

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-QhDiTclS-1684464779529)(images\谷粒商城项目笔记\image-20220613204431958.png)]

和传统的单体应用不同，这里我们选择将数据上传到分布式文件服务器上。

这里我们选择将图片放置到阿里云上，使用对象存储。

阿里云上使使用对象存储方式：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-9dtFQnme-1684464779529)(images/谷粒商城项目笔记/image-20220507213107240.png)]

创建Bucket

地址：https://oss.console.aliyun.com/bucket

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-skpsqLrz-1684464779529)(images/谷粒商城项目笔记/image-20220507213248903.png)]

创建Bucket（作为项目）

上传文件：上传成功后，取得图片的URL

这种方式是手动上传图片，实际上我们可以在程序中设置自动上传图片到阿里云对象存储。

使用代码上传

查看阿里云关于文件上传的帮助：

https://help.aliyun.com/document_detail/32009.html?spm=a2c4g.11186623.6.768.549d59aaWuZMGJ

1）添加依赖包

在Maven项目中加入依赖项（推荐方式）

在 Maven 工程中使用 OSS Java SDK，只需在 pom.xml 中加入相应依赖即可。以 3.8.0 版本为例，在 pom内加入如下内容：

<dependency>
    <groupId>com.aliyun.ossgroupId>
    <artifactId>aliyun-sdk-ossartifactId>
    <version>3.8.0version>
dependency>

2）上传文件流

以下代码用于上传文件流：

// Endpoint以杭州为例，其它Region请按实际情况填写。
String endpoint = "http://oss-cn-hangzhou.aliyuncs.com";
// 云账号AccessKey有所有API访问权限，建议遵循阿里云安全最佳实践，创建并使用RAM子账号进行API访问或日常运维，请登录 https://ram.console.aliyun.com 创建。
String accessKeyId = "";
String accessKeySecret = "";

// 创建OSSClient实例。
OSS ossClient = new OSSClientBuilder().build(endpoint, accessKeyId, accessKeySecret);

// 上传文件流。
InputStream inputStream = new FileInputStream("");
ossClient.putObject("", "", inputStream);

// 关闭OSSClient。
ossClient.shutdown();

上面代码的信息可以通过如下查找：

endpoint
- 点击概览：（https://oss.console.aliyun.com/bucket/oss-cn-shanghai/gulimall-handong/overview）
  
  [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-hIzXP2Jh-1684464779530)(images\谷粒商城项目笔记\image-20220614092823502.png)]
accessKey的获取
- 点击AccessKey管理：（https://ram.console.aliyun.com/manage/ak?spm=5176.8466032.top-nav.dak.4c861450qNVy5P）
  
  [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-skanunlj-1684464779530)(images\谷粒商城项目笔记\image-20220614093010116.png)]
  
  [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-QUsangUL-1684464779530)(images\谷粒商城项目笔记\image-20220614093053334.png)]
  
  [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-gbZahInm-1684464779530)(images\谷粒商城项目笔记\image-20220614093126163.png)]
  
  [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Oj9Jd4AK-1684464779531)(images\谷粒商城项目笔记\image-20220614093202853.png)]
  
  [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-McWZjker-1684464779531)(images\谷粒商城项目笔记\image-20220614093221895.png)]
  
  [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-BALnNB3Q-1684464779531)(images\谷粒商城项目笔记\image-20220614093240612.png)]
  
  [外链图片转存中…(img-oZcI88SQ-1684464779531)]
  
  accessKeyId accessKeySecret参数上面就是。
添加权限
- [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-jSntkYPw-1684464779531)(images\谷粒商城项目笔记\image-20220614093533817.png)]
- [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-GwlwXkVX-1684464779532)(images\谷粒商城项目笔记\image-20220614093629762.png)]
图片的路径：比如，“D:\User\zzpic15479.jpg”
- https://oss.console.aliyun.com/bucket
- [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-oAMNaYFZ-1684464779532)(images\谷粒商城项目笔记\image-20220614094517968.png)]
上传后的文件名，自己取，比如：15479.jpg
运行此程序
查看上传的图片
- https://oss.console.aliyun.com/bucket
- [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-MD8Ct8d9-1684464779532)(images\谷粒商城项目笔记\image-20220614095418490.png)]
- [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-XEQj4nFE-1684464779532)(images\谷粒商城项目笔记\image-20220614095432736.png)]

3）使用SpringCloud Alibaba管理oss

接入OSS

导包（把上面导的那个包先注掉）（这个包放在common里面）

<dependency>
    <groupId>com.alibaba.cloudgroupId>
    <artifactId>spring-cloud-starter-alicloud-ossartifactId>
dependency>

配置文件
```
access-key: LTAI4G4W1RA4JXz2QhoDwHhi
  secret-key: R99lmDOJumF2x43ZBKT259Qpe70Oxw
  oss:
    endpoint: oss-cn-shanghai.aliyuncs.com
```
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-YomwQPDA-1684464779533)(images\谷粒商城项目笔记\image-20220614101038976.png)]
注入如下
```
@Autowired
OSSClient ossClient;
```

完整代码

@Autowired
OSSClient ossClient;

@Test
public void upload() throws FileNotFoundException {
    // 上传文件流。
    InputStream inputStream = new FileInputStream("D:\\User\\dahai.jpg");
    ossClient.putObject("gulimall-handong", "dahai.jpg", inputStream);
    // 关闭OSSClient。
    ossClient.shutdown();
    System.out.println("上传成功...");
}

服务端签名后直传实现

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-8QgT8gyI-1684464779533)(images\谷粒商城项目笔记\image-20220614101941089.png)]

创建第三方服务模块

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-fsN0vjpG-1684464779533)(images\谷粒商城项目笔记\image-20220614102058519.png)]

导包

<dependency>
    <groupId>com.alibaba.cloud</groupId>
    <artifactId>spring-cloud-starter-alicloud-oss</artifactId>
</dependency>

配置文件

alicloud:
    access-key: LTAI5tSGcmqPbjBm7nXWtwuQ
    secret-key: 0et8rK9M4M6gPzIht34TZKIawBpQ9k
    oss:
        endpoint: oss-cn-shanghai.aliyuncs.com
        bucket: gulimall-handong

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-JheiXJGV-1684464779534)(images\谷粒商城项目笔记\image-20220614102509609.png)]

创建新的名称空间

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-5ETpH0me-1684464779534)(images\谷粒商城项目笔记\image-20220614102710350.png)]
新建配置

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-MVI2QIAK-1684464779534)(images\谷粒商城项目笔记\image-20220614103039069.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-vfiulFOX-1684464779534)(images\谷粒商城项目笔记\image-20220614103149785.png)]
```
spring:
  cloud:
    nacos:
      discovery:
        server-addr: 127.0.0.1:8848
    alicloud:
      access-key: LTAI5tSGcmqPbjBm7nXWtwuQ
      secret-key: 0et8rK9M4M6gPzIht34TZKIawBpQ9k
      oss:
        endpoint: oss-cn-shanghai.aliyuncs.com
        bucket: gulimall-handong
```

bootstrap.properties

spring.application.name=gulimall-third-party
spring.cloud.nacos.config.server-addr=127.0.0.1:8848
spring.cloud.nacos.config.namespace=796ec540-3ef8-472b-927f-dc8bff7f60cf

spring.cloud.nacos.config.ext-config[0].data-id=oss.yml
spring.cloud.nacos.config.ext-config[0].group=DEFAULT_GROUP
spring.cloud.nacos.config.ext-config[0].refresh=true

启动该服务

官方文档：

前面后直传

官方文档：https://help.aliyun.com/document_detail/31926.html?spm=5176.12818093.help.dexternal.4d1d16d0KcuZ0x
配置跨域
- https://oss.console.aliyun.com/bucket/oss-cn-shanghai/gulimall-handong/overview
- [外链图片转存中…(img-wUHclvBt-1684464779535)]
- [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-wNESapcz-1684464779535)(images\谷粒商城项目笔记\image-20220614110538671.png)]
- [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-iieWszFC-1684464779535)(images\谷粒商城项目笔记\image-20220614110609815.png)]

JSR303校验

问题引入：填写form时应该有前端校验，后端也应该有校验
前端
前端的校验是element-ui表单验证
Form 组件提供了表单验证的功能，只需要通过 rules 属性传入约定的验证规则，并将 Form-Item 的 prop 属性设置为需校验的字段名即可。

后端

@NotNull等

步骤1：使用校验注解

在Java中提供了一系列的校验方式，它这些校验方式在“javax.validation.constraints”包中，提供了如@Email，@NotNull等注解。


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

里面依赖了hibernate-validator
在非空处理方式上提供了@NotNull，@NotBlank和@NotEmpty
1 @NotNull

The annotated element must not be null. Accepts any type.
注解元素禁止为null，能够接收任何类型

2 @NotEmpty

the annotated element must not be null nor empty.

该注解修饰的字段不能为null或""

Supported types are:

支持以下几种类型

CharSequence (length of character sequence is evaluated)字符序列（字符序列长度的计算）
Collection (collection size is evaluated)
集合长度的计算
Map (map size is evaluated)
map长度的计算
Array (array length is evaluated)
数组长度的计算
3 @NotBlank

The annotated element must not be null and must contain at least one non-whitespace character. Accepts CharSequence.
该注解不能为null，并且至少包含一个非空格字符。接收字符序列。

@Valid

步骤2：controller中加校验注解@Valid，开启校验

@RequestMapping("/save")
public R save(@Valid @RequestBody BrandEntity brand){
    brandService.save(brand);
    return R.ok();
}

测试： http://localhost:88/api/product/brand/save

在postman种发送上面的请求

{
    "timestamp": "2020-04-29T09:20:46.383+0000",
    "status": 400,
    "error": "Bad Request",
    "errors": [
        {
            "codes": [
                "NotBlank.brandEntity.name",
                "NotBlank.name",
                "NotBlank.java.lang.String",
                "NotBlank"
            ],
            "arguments": [
                {
                    "codes": [
                        "brandEntity.name",
                        "name"
                    ],
                    "arguments": null,
                    "defaultMessage": "name",
                    "code": "name"
                }
            ],
            "defaultMessage": "不能为空",
            "objectName": "brandEntity",
            "field": "name",
            "rejectedValue": "",
            "bindingFailure": false,
            "code": "NotBlank"
        }
    ],
    "message": "Validation failed for object='brandEntity'. Error count: 1",
    "path": "/product/brand/save"
}

能够看到"defaultMessage": “不能为空”，这些错误消息定义在“hibernate-validator”的“\org\hibernate\validator\ValidationMessages_zh_CN.properties”文件中。在该文件中定义了很多的错误规则：

javax.validation.constraints.AssertFalse.message     = 只能为false
javax.validation.constraints.AssertTrue.message      = 只能为true
javax.validation.constraints.DecimalMax.message      = 必须小于或等于{value}
javax.validation.constraints.DecimalMin.message      = 必须大于或等于{value}
javax.validation.constraints.Digits.message          = 数字的值超出了允许范围(只允许在{integer}位整数和{fraction}位小数范围内)
javax.validation.constraints.Email.message           = 不是一个合法的电子邮件地址
javax.validation.constraints.Future.message          = 需要是一个将来的时间
javax.validation.constraints.FutureOrPresent.message = 需要是一个将来或现在的时间
javax.validation.constraints.Max.message             = 最大不能超过{value}
javax.validation.constraints.Min.message             = 最小不能小于{value}
javax.validation.constraints.Negative.message        = 必须是负数
javax.validation.constraints.NegativeOrZero.message  = 必须是负数或零
javax.validation.constraints.NotBlank.message        = 不能为空
javax.validation.constraints.NotEmpty.message        = 不能为空
javax.validation.constraints.NotNull.message         = 不能为null
javax.validation.constraints.Null.message            = 必须为null
javax.validation.constraints.Past.message            = 需要是一个过去的时间
javax.validation.constraints.PastOrPresent.message   = 需要是一个过去或现在的时间
javax.validation.constraints.Pattern.message         = 需要匹配正则表达式"{regexp}"
javax.validation.constraints.Positive.message        = 必须是正数
javax.validation.constraints.PositiveOrZero.message  = 必须是正数或零
javax.validation.constraints.Size.message            = 个数必须在{min}和{max}之间

org.hibernate.validator.constraints.CreditCardNumber.message        = 不合法的信用卡号码
org.hibernate.validator.constraints.Currency.message                = 不合法的货币 (必须是{value}其中之一)
org.hibernate.validator.constraints.EAN.message                     = 不合法的{type}条形码
org.hibernate.validator.constraints.Email.message                   = 不是一个合法的电子邮件地址
org.hibernate.validator.constraints.Length.message                  = 长度需要在{min}和{max}之间
org.hibernate.validator.constraints.CodePointLength.message         = 长度需要在{min}和{max}之间
org.hibernate.validator.constraints.LuhnCheck.message               = ${validatedValue}的校验码不合法, Luhn模10校验和不匹配
org.hibernate.validator.constraints.Mod10Check.message              = ${validatedValue}的校验码不合法, 模10校验和不匹配
org.hibernate.validator.constraints.Mod11Check.message              = ${validatedValue}的校验码不合法, 模11校验和不匹配
org.hibernate.validator.constraints.ModCheck.message                = ${validatedValue}的校验码不合法, ${modType}校验和不匹配
org.hibernate.validator.constraints.NotBlank.message                = 不能为空
org.hibernate.validator.constraints.NotEmpty.message                = 不能为空
org.hibernate.validator.constraints.ParametersScriptAssert.message  = 执行脚本表达式"{script}"没有返回期望结果
org.hibernate.validator.constraints.Range.message                   = 需要在{min}和{max}之间
org.hibernate.validator.constraints.SafeHtml.message                = 可能有不安全的HTML内容
org.hibernate.validator.constraints.ScriptAssert.message            = 执行脚本表达式"{script}"没有返回期望结果
org.hibernate.validator.constraints.URL.message                     = 需要是一个合法的URL

org.hibernate.validator.constraints.time.DurationMax.message        = 必须小于${inclusive == true ? '或等于' : ''}${days == 0 ? '' : days += '天'}${hours == 0 ? '' : hours += '小时'}${minutes == 0 ? '' : minutes += '分钟'}${seconds == 0 ? '' : seconds += '秒'}${millis == 0 ? '' : millis += '毫秒'}${nanos == 0 ? '' : nanos += '纳秒'}
org.hibernate.validator.constraints.time.DurationMin.message        = 必须大于${inclusive == true ? '或等于' : ''}${days == 0 ? '' : days += '天'}${hours == 0 ? '' : hours += '小时'}${minutes == 0 ? '' : minutes += '分钟'}${seconds == 0 ? '' : seconds += '秒'}${millis == 0 ? '' : millis += '毫秒'}${nanos == 0 ? '' : nanos += '纳秒'}

想要自定义错误消息，可以覆盖默认的错误提示信息，如@NotBlank的默认message是

public @interface NotBlank {
	String message() default "{javax.validation.constraints.NotBlank.message}";
}

可以在添加注解的时候，修改message：

@NotBlank(message = "品牌名必须非空")
private String name;

当再次发送请求时，得到的错误提示信息：

{
    "timestamp": "2020-04-29T09:36:04.125+0000",
    "status": 400,
    "error": "Bad Request",
    "errors": [
        {
            "codes": [
                "NotBlank.brandEntity.name",
                "NotBlank.name",
                "NotBlank.java.lang.String",
                "NotBlank"
            ],
            "arguments": [
                {
                    "codes": [
                        "brandEntity.name",
                        "name"
                    ],
                    "arguments": null,
                    "defaultMessage": "name",
                    "code": "name"
                }
            ],
            "defaultMessage": "品牌名必须非空",
            "objectName": "brandEntity",
            "field": "name",
            "rejectedValue": "",
            "bindingFailure": false,
            "code": "NotBlank"
        }
    ],
    "message": "Validation failed for object='brandEntity'. Error count: 1",
    "path": "/product/brand/save"
}

但是这种返回的错误结果并不符合我们的业务需要。

BindResult

步骤3：给校验的Bean后，紧跟一个BindResult，就可以获取到校验的结果。拿到校验的结果，就可以自定义的封装。

@RequestMapping("/save")
public R save(@Valid @RequestBody BrandEntity brand, BindingResult result){
    if( result.hasErrors()){
        Map<String,String> map=new HashMap<>();
        //1.获取错误的校验结果
        result.getFieldErrors().forEach((item)->{
            //获取发生错误时的message
            String message = item.getDefaultMessage();
            //获取发生错误的字段
            String field = item.getField();
            map.put(field,message);
        });
        return R.error(400,"提交的数据不合法").put("data",map);
    }else {
        
    }
    brandService.save(brand);
    return R.ok();
}

这种是针对于该请求设置了一个内容校验，如果针对于每个请求都单独进行配置，显然不是太合适，实际上可以统一的对于异常进行处理。

统一异常处理@ControllerAdvice

步骤4：统一异常处理

可以使用SpringMvc所提供的@ControllerAdvice，通过“basePackages”能够说明处理哪些路径下的异常。
1 抽取一个异常处理类

@Slf4j
@RestControllerAdvice(basePackages = "com.atguigu.gulimall.product.controller")
public class GulimallExceptionControllerAdvice {

    @ExceptionHandler(value = Exception.class) // 也可以返回ModelAndView
    public R handleValidException(MethodArgumentNotValidException exception){
    
        Map<String,String> map=new HashMap<>();
        // 获取数据校验的错误结果
        BindingResult bindingResult = exception.getBindingResult();
        bindingResult.getFieldErrors().forEach(fieldError -> {
            String message = fieldError.getDefaultMessage();
            String field = fieldError.getField();
            map.put(field,message);
        });
    
        log.error("数据校验出现问题{},异常类型{}",exception.getMessage(),exception.getClass());
    
        return R.error(400,"数据校验出现问题").put("data",map);
    }

}

2 测试： http://localhost:88/api/product/brand/save

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Hud4EvGM-1684464779536)(images/谷粒商城项目笔记/image-20220508124513443.png)]

在这里插入图片描述

3 默认异常处理

@ExceptionHandler(value = Throwable.class)
public R handleException(Throwable throwable){
    log.error("未知异常{},异常类型{}",throwable.getMessage(),throwable.getClass());
    return R.error(400,"数据校验出现问题");
}

4 错误状态码
上面代码中，针对于错误状态码，是我们进行随意定义的，然而正规开发过程
中，错误状态码有着严格的定义规则，如该在项目中我们的错误状态码定义

package com.atguigu.common.exception;

/***
 * 错误码和错误信息定义类
 * 1. 错误码定义规则为5为数字
 * 2. 前两位表示业务场景，最后三位表示错误码。例如：100001。10:通用 001:系统未知异常
 * 3. 维护错误码后需要维护错误描述，将他们定义为枚举形式
 * 错误码列表：
 *  10: 通用
 *      001：参数格式校验
 *  11: 商品
 *  12: 订单
 *  13: 购物车
 *  14: 物流
 */
public enum BizCodeEnum {

    UNKNOW_EXEPTION(10000,"系统未知异常"),

    VALID_EXCEPTION( 10001,"参数格式校验失败");

    private int code;
    private String msg;

    BizCodeEnum(int code, String msg) {
        this.code = code;
        this.msg = msg;
    }

    public int getCode() {
        return code;
    }

    public String getMsg() {
        return msg;
    }
}

在这里插入图片描述

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-vfgN0PDi-1684464779536)(images/谷粒商城项目笔记/image-20220508124544452.png)]

为了定义这些错误状态码，我们可以单独定义一个常量类，用来存储这些错误状态码

5 测试： http://localhost:88/api/product/brand/save

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-SeyuLXga-1684464779536)(images/谷粒商城项目笔记/image-20220508124558551.png)]

在这里插入图片描述
1.5 分组校验功能（完成多场景的复杂校验）

1 groups
1 给校验注解，标注上groups，指定什么情况下才需要进行校验
groups里面的内容要以接口的形式显示出来
如：指定在更新和添加的时候，都需要进行校验。新增时不需要带id，修改时必须带id

@NotNull(message = "修改必须定制品牌id", groups = {UpdateGroup.class})
@Null(message = "新增不能指定id", groups = {AddGroup.class})
@TableId
private Long brandId;

在这种情况下，没有指定分组的校验注解，默认是不起作用的。想要起作用就必须要加groups。

2 @Validated
2 业务方法参数上使用@Validated注解

@Validated的value方法：

Specify one or more validation groups to apply to the validation step kicked off by this annotation.
指定一个或多个验证组以应用于此注释启动的验证步骤。

JSR-303 defines validation groups as custom annotations which an application declares for the sole purpose of using
them as type-safe group arguments, as implemented in SpringValidatorAdapter.

JSR-303 将验证组定义为自定义注释，应用程序声明的唯一目的是将它们用作类型安全组参数，如 SpringValidatorAdapter 中实现的那样。

Other SmartValidator implementations may support class arguments in other ways as well.

其他SmartValidator 实现也可以以其他方式支持类参数。

@RequestMapping("/save")
public R save(@Validated(AddGroup.class) @RequestBody BrandEntity brand) {
    brandService.save(brand);

    return R.ok();

}
@RequestMapping("/delete")
//@RequiresPermissions("${moduleNamez}:brand:delete")
public R delete(@RequestBody Long[] brandIds) {
    brandService.removeByIds(Arrays.asList(brandIds));

    return R.ok();

}

3 分组情况下，校验注解生效问题
3 默认情况下，在分组校验情况下，没有指定指定分组的校验注解，将不会生效，它只会在不分组的情况下生效。

1.6 自定义校验功能

场景：要校验showStatus的01状态，可以用正则，但我们可以利用其他方式解决
复杂场景。比如我们想要下面的场景

/**

  * 显示状态[0-不显示；1-显示]
    */
    @NotNull(groups = {AddGroup.class, UpdateStatusGroup.class})
    @ListValue(vals = {0,1}, groups = {AddGroup.class, UpdateGroup.class, UpdateStatusGroup.class})
    private Integer showStatus;

如何做：

添加依赖

<dependency>
    <groupId>javax.validationgroupId>
    <artifactId>validation-apiartifactId>
    <version>2.0.1.Finalversion>
dependency>

1 编写自定义的校验注解
必须有3个属性

message()错误信息
groups()分组校验
payload()自定义负载信息

@Documented
@Constraint(validatedBy = { ListValueConstraintValidator.class})
@Target({ METHOD, FIELD, ANNOTATION_TYPE, CONSTRUCTOR, PARAMETER, TYPE_USE })
@Retention(RUNTIME)
public @interface ListValue {
    // 使用该属性去Validation.properties中取
    String message() default "{com.atguigu.common.valid.ListValue.message}";

    Class<?>[] groups() default { };
    
    Class<? extends Payload>[] payload() default { };
    
    int[] value() default {};

}

该属性值取哪里取呢？
common创建文件ValidationMessages.properties
里面写上com.atguigu.common.valid.ListValue.message=必须提交指定的值 [0,1]

2 编写自定义的校验器

public class ListValueConstraintValidator implements ConstraintValidator<ListValue,Integer> {
    private Set<Integer> set=new HashSet<>();
    @Override
    public void initialize(ListValue constraintAnnotation) {
        int[] value = constraintAnnotation.value();
        for (int i : value) {
            set.add(i);
        }

    }
    
    @Override
    public boolean isValid(Integer value, ConstraintValidatorContext context) {


        return  set.contains(value);
    }

}

3 关联校验器和校验注解

@Constraint(validatedBy = { ListValueConstraintValidator.class})

一个校验注解可以匹配多个校验器

4 使用实例

/**

  * 显示状态[0-不显示；1-显示]
    */
    @ListValue(value = {0,1},groups ={AddGroup.class})
    private Integer showStatus;

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-3LvkZ8gN-1684464779537)(images/谷粒商城项目笔记/image-20220508115031123.png)]

商品基本概念

SPU 和 SKU

SPU：Standard Product Unit （标准化产品单元）

是商品信息聚合的最小单位，是一组可复用，易检索的标准化信息的组合，该集合描述了一个产品的特性

IPhoneX 是 SPU,MI8 是 SPU

IPhoneX 64G 黑曜石是 SKU

MIX8 + 64G 是 SKU

SKU: Stock KeepingUnit (库存量单位)

基本属性【规格参数】与销售属性

每个分共下的商共享规格参数、与销售属性，只是有些商品不一定更用这个分类下全部的属性：

属性是以三级分类组织起来的

规格参数中有些是可以提供检索的

规格参数也是基本属性，他们具有自己的分组

属性的分组也是以三级分类组织起来的

属性名确定的，但是值是每一个商品不同来决定的

【属性分组-规格参数-销售属性-三级分类】关联关系

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ksOi5AXe-1684464779537)(images/谷粒商城项目笔记/image-20220614174042452.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-QWxbSi0c-1684464779537)(images/谷粒商城项目笔记/image-20220614174057934.png)]

属性分组

接口文档：https://easydoc.net/s/78237135/ZUqEdvA4/HqQGp9TI

设置隔离级别

SET SESSION TRANSACTION ISOLATION LEVEL READ UNCOMMITTED;

ElasticSearch

索引：库

类型：表

数据是json格式

文档：就相当于表中一列列数据

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-lYTfQvho-1684464779537)(images/谷粒商城项目笔记/image-20220510123223174.png)]

倒排索引

1、安装ElasticSearch

下载镜像文件

docker pull elasticsearch:7.4.2
docker pull kibana:7.4.2

本地创建两个文件

mkdir -p /mydata/elasticsearch/config    //配置文件信息挂载到这个文件夹下
mkdir -p /mydata/elasticsearch/data      //

修改配置文件

echo "http.host: 0.0.0.0" >> /mydata/elasticsearch/config/elasticsearch.yml

给文件夹添加权限
```
chmod -R 777 /mydata/elasticsearch/
```

运行镜像

docker run --name elasticsearch -p 9200:9200 -p 9300:9300 \
-e "discovery.type=single-node" \
-e ES_JAVA_OPTS="-Xms64m -Xmx512m" \
-v /mydata/elasticsearch/config/elasticsearch.yml:/usr/share/elasticsearch/config/elasticsearch.yml \
-v /mydata/elasticsearch/data:/usr/share/elasticsearch/data \
-v /mydata/elasticsearch/plugins:/usr/share/elasticsearch/plugins \
-d elasticsearch:7.4.2

设置开机自启

docker update elasticsearch --restart=always

启动起来后查看该容器的日志

docker logs elasticsearch
或者
docker logs [容器id]
或者
docker logs [容器id前三位]

测试
- 地址：124.222.248.51:9200
- 出现如下界面表示安装成功
  
  [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-YyaaO0vy-1684464779538)(images/谷粒商城项目笔记/image-20220510134053961.png)]

特别注意：

-e ES_JAVA_OPTS="-Xms64m -Xmx256m" \ 测试环境下，设置 ES 的初始内存和最大内存，否则导致过大启动不了 ES

2、启动Kibana

运行镜像

docker run --name kibana -e ELASTICSEARCH_HOSTS=http://192.168.91.100:9200 -p 5601:5601 \
-d kibana:7.4.2

// 注意如果用的是云服务器，并且es和kibana在一台机器，则使用如下命令找到ip地址
docker inspect elasticsearch | grep IPAddress
// 并把ip地址放在host后面
// 一般是172.17.0.3

// http://192.168.91.100:9200 一定改为自己虚拟机的地址

启动完成后等待一会儿，或许几秒，或许几分钟
设置开机自启
```
docker update kibana --restart=always
```
测试
- 测试地址：124.222.248.51:5601
- 出现如下则成功
  
  [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-sbRFit6I-1684464779538)(images/谷粒商城项目笔记/image-20220510141748528.png)]

初始化es

PUT gulimall_product
{
  "mappings":{
    "properties":{
      "skuId":{
        "type":"long"
      },
       "spuId":{
        "type":"keyword"
      },
       "skuTitle":{
        "type":"text",
        "analyzer": "ik_smart"
      },
       "skuPrice":{
        "type":"keyword"
      },
       "skuImg":{
        "type":"text",
        "analyzer": "ik_smart"
      },
       "saleCount":{
        "type":"long"
      },
       "hasStock":{
        "type":"boolean"
      },
      "hotScore":{
        "type":"long"
      },
      "brandId":{
        "type":"long"
      },
      "catelogId":{
        "type":"long"
      },
      "brandName":{
        "type":"keyword",
        "index": false,
        "doc_values": false
      },
      "brandImg":{
        "type":"keyword",
         "index": false,
        "doc_values": false
      },
      "catalogName":{
        "type":"keyword",
         "index": false,
         "doc_values": false
      },
      "attrs":{
        "type":"nested",
        "properties": {
          "attrId":{
            "type":"long"
          },
          "attrName":{
            "type":"keyword",
            "index":false,
            "doc_values":false
          },
          "attrValue": {
            "type":"keyword"
          }
        }
      }
    }
  }
}

3、初步检索

1、_cat

GET /_cat/nodes：查看所有节点  实例：http://124.222.248.51:9200/_cat/nodes
GET /_cat/health：查看 es 健康状况  http://124.222.248.51:9200/_cat/health
GET /_cat/master：查看主节点 
GET /_cat/indices：查看所有索引  相当于show databases;

2、索引一个文档

即保存一条数据，保存在哪个索引的哪个类型下，指定用哪个唯一标识。

1. PUT 请求

接口：PUT http://192.168.163.131:9200/customer/external/1

参数解释：192.168.131：9200/索引名（库名）/类型名（表名）/唯一标识id

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-xgA5udXF-1684464779538)(images/谷粒商城项目笔记/1615298924150-ef6c809b-eda8-41cc-8eba-2156ec376cb5.png)]

2. POST 请求

接口：POST http://192.168.163.131:9200/customer/external/

如果不带id则是新增，带了Id，如果有就是更新，没有就是新增。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Q6Sdxa8m-1684464779538)(images/谷粒商城项目笔记/1615299124434-93f69d46-00f1-423e-b795-313bb1d2f3c9.png)]

PUT和POST都可以

POST新增，如果不指定id，会自动生成id。指定id就会修改这个数据，并新增版本号；
PUT可以新增也可以修改。PUT必须指定id；由于PUT需要指定id，我们一般用来做修改操作，不指定id会报错。

3、查看文档

/index/type/id

接口：GET http://192.168.163.131:9200/customer/external/1

[外链图片转存中…(img-D8uK1b4u-1684464779539)]

{
    "_index": "customer",  # 在哪个索引(库)
    "_type": "external",   # 在哪个类型(表)
    "_id": "1",						 # 文档id(记录)
    "_version": 5,				 # 版本号
    "_seq_no": 4,					 # 并发控制字段，每次更新都会+1，用来做乐观锁
    "_primary_term": 1,		 # 同上，主分片重新分配，如重启，就会变化
    "found": true,
    "_source": {					 # 数据
        "name": "zhangsan"
    }
}

# 乐观锁更新时携带 ?_seq_no=0&_primary_term=1  当携带数据与实际值不匹配时更新失败

更新文档

/index/type/id/_update

接口：POST http://192.168.163.131:9200/customer/external/1/_update

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-DO8VvAab-1684464779539)(images/谷粒商城项目笔记/1615345823323-a4869fd9-d54d-461a-bcf2-77046a9f1970.png)]

几种更新文档的区别

在上面索引文档即保存文档的时候介绍，还有两种更新文档的方式：

当PUT请求带id，且有该id数据存在时，会更新文档；
当POST请求带id，与PUT相同，该id数据已经存在时，会更新文档；

这两种请求类似，即带id，且数据存在，就会执行更新操作。

类比：

请求体的报文格式不同，_update方式要修改的数据要包裹在 doc 键下
_update方式不会重复更新，数据已存在不会更新，版本号不会改变，另两种方式会重复更新（覆盖原来数据），版本号会改变
这几种方式在更新时都可以增加属性，PUT请求带id更新和POST请求带id更新，会直接覆盖原来的数据，不会在原来的属性里面新增属性

删除文档&索引

删除文档

接口：DELETE http://192.168.163.131:9200/customer/external/1

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-J2rZPb0l-1684464779539)(images/谷粒商城项目笔记/1615355451681-013af65f-aa49-43bb-94e9-1e6fdad42791.png)]

删除索引

接口：DELETE http://192.168.163.131:9200/customer

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-P4klT6GB-1684464779540)(images/谷粒商城项目笔记/1615355541689-70478b27-b1ec-4c06-a16c-f23b5b6552f1.png)]

bulk-批量操作数据

语法格式：

{action:{metadata}}\n   // 例如index保存记录，update更新
{request body  }\n

{action:{metadata}}\n
{request body  }\n

1. 指定索引和类型的批量操作

接口：POST /customer/external/_bulk

参数：

{"index":{"_id":"1"}}
{"name":"John Doe"}
{"index":{"_id":"2"}}
{"name":"John Doe"}

在Kibana中使用dev-tools测试批量：

[外链图片转存中…(img-6mFM23Z5-1684464779540)]

2. 对所有索引执行批量操作

接口：POST /_bulk

参数：

{"delete":{"_index":"website","_type":"blog","_id":"123"}}
{"create":{"_index":"website","_type":"blog","_id":"123"}}
{"title":"my first blog post"}
{"index":{"_index":"website","_type":"blog"}}
{"title":"my second blog post"}
{"update":{"_index":"website","_type":"blog","_id":"123"}}
{"doc":{"title":"my updated blog post"}}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-hFGHG052-1684464779540)(images/谷粒商城项目笔记/1615356270583-8b578bba-5ffb-4e69-85b9-8d083c1958a2.png)]

这里的批量操作，当发生某一条执行发生失败时，其他的数据仍然能够接着执行，也就是说彼此之间是独立的。
bulk api以此按顺序执行所有的action（动作）。如果一个单个的动作因任何原因失败，它将继续处理它后面剩余的动作。
当bulk api返回时，它将提供每个动作的状态（与发送的顺序相同），所以您可以检查是否一个指定的动作是否失败了。

批量创建数据

官方测试数据地址：https://gitee.com/xlh_blog/common_content/blob/master/es%E6%B5%8B%E8%AF%95%E6%95%B0%E6%8D%AE.json

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-upmqozj7-1684464779540)(images/谷粒商城项目笔记/image-20220510151413430.png)]

4、进阶检索

检索示例介绍

下面的请求都是在Kibana dev-tools 操作

请求接口

GET /bank/_search
{
  "query": {
    "match_all": {}
  },
  "sort": [
    {
      "account_number": "asc"
    }
  ]
}
# query 查询条件
# sort 排序条件

结果

{
  "took" : 7,
  "timed_out" : false,
  "_shards" : {
    "total" : 1,
    "successful" : 1,
    "skipped" : 0,
    "failed" : 0
  },
  "hits" : {
    "total" : {
      "value" : 1000,
      "relation" : "eq"
    },
    "max_score" : null,
    "hits" : [
      {
        "_index" : "bank",
        "_type" : "account",
        "_id" : "0",
        "_score" : null,
        "_source" : {
          "account_number" : 0,
          "balance" : 16623,
          "firstname" : "Bradshaw",
          "lastname" : "Mckenzie",
          "age" : 29,
          "gender" : "F",
          "address" : "244 Columbus Place",
          "employer" : "Euron",
          "email" : "[email protected]",
          "city" : "Hobucken",
          "state" : "CO"
        },
        "sort" : [
          0
        ]
      },
      ...
    ]
  }
}

响应字段解释

took – how long it took Elasticsearch to run the query, in milliseconds
timed_out – whether or not the search request timed out
_shards – how many shards were searched and a breakdown of how many shards succeeded, failed, or were skipped.
max_score – the score of the most relevant document found
hits.total.value - how many matching documents were found
hits.sort - the document’s sort position (when not sorting by relevance score)
hits._score - the document’s relevance score (not applicable when using match_all)

响应结果说明

Elasticsearch 默认会分页返回10条数据，不会一下返回所有数据。

请求方式说明

ES支持两种基本方式检索；

通过REST request uri 发送搜索参数（uri +检索参数）；
通过REST request body 来发送它们（uri+请求体）；

也就是说除了上面示例的请求接口，根据请求体进行检索外；

还可以用GET请求参数的方式检索：

GET bank/_search?q=*&sort=account_number:asc
# q=* 查询所有
# sort=account_number:asc 按照account_number进行升序排列

Query DSL

本小节参考官方文档：Query DSL

Elasticsearch提供了一个可以执行查询的Json风格的DSL。这个被称为Query DSL，该查询语言非常全面。

1. 基本语法格式

一个查询语句的典型结构:

QUERY_NAME:{
   ARGUMENT:VALUE,
   ARGUMENT:VALUE,...
}

如果针对于某个字段，那么它的结构如下：

{
  QUERY_NAME:{
     FIELD_NAME:{
       ARGUMENT:VALUE,
       ARGUMENT:VALUE,...
      }   
   }
}

请求示例：

GET bank/_search
{
  "query": {
    "match_all": {}
  },
  "from": 0,
  "size": 5,
  "sort": [
    {
      "account_number": {
        "order": "desc"
      },
      "balance": {
      	"order": "asc"
      }
    }
  ]
}

# match_all 查询类型【代表查询所有的所有】，es中可以在query中组合非常多的查询类型完成复杂查询；
# from+size 限定，完成分页功能；从第几条数据开始，每页有多少数据
# sort 排序，多字段排序，会在前序字段相等时后续字段内部排序，否则以前序为准；

2. 返回部分字段

请求示例：

GET bank/_search
{
  "query": {
    "match_all": {}
  },
  "from": 0,
  "size": 5,
  "sort": [
    {
      "account_number": {
        "order": "desc"
      }
    }
  ],
  "_source": ["balance","firstname"]
}

# _source 指定返回结果中包含的字段名

结果示例：

{
  "took" : 2,
  "timed_out" : false,
  "_shards" : {
    "total" : 1,
    "successful" : 1,
    "skipped" : 0,
    "failed" : 0
  },
  "hits" : {
    "total" : {
      "value" : 1000,
      "relation" : "eq"
    },
    "max_score" : null,
    "hits" : [
      {
        "_index" : "bank",
        "_type" : "account",
        "_id" : "999",
        "_score" : null,
        "_source" : {
          "firstname" : "Dorothy",
          "balance" : 6087
        },
        "sort" : [
          999
        ]
      },
    	...
    ]
 	}
}

3. match-匹配查询

精确查询-基本数据类型(非文本)

GET bank/_search
{
  "query": {
    "match": {
      "account_number": 20
    }
  }
}
# 查找匹配 account_number 为 20 的数据 非文本推荐使用 term

模糊查询-文本字符串

GET bank/_search
{
  "query": {
    "match": {
      "address": "mill lane"
    }
  }
}
# 查找匹配 address 包含 mill 或 lane 的数据

match即全文检索，对检索字段进行分词匹配，会按照响应的评分 _score 排序，原理是倒排索引。

精确匹配-文本字符串

GET bank/_search
{
  "query": {
    "match": {
      "address.keyword": "288 Mill Street"
    }
  }
}
# 查找 address 为 288 Mill Street 的数据。
# 这里的查找是精确查找，只有完全匹配时才会查找出存在的记录，
# 如果想模糊查询应该使用match_phrase 短语匹配

4. match_phrase-短语匹配

将需要匹配的值当成一整个单词（不分词）进行检索

GET bank/_search
{
  "query": {
    "match_phrase": {
      "address": "mill lane"
    }
  }
}
# 这里会检索 address 匹配包含短语 mill lane 的数据

5. multi_math-多字段匹配

GET bank/_search
{
  "query": {
    "multi_match": {
      "query": "mill",
      "fields": [
        "city",
        "address"
      ]
    }
  }
}
# 检索 city 或 address 匹配包含 mill 的数据，会对查询条件分词

6. bool-复合查询

复合语句可以合并，任何其他查询语句，包括符合语句。这也就意味着，复合语句之间

可以互相嵌套，可以表达非常复杂的逻辑。

must：必须达到must所列举的所有条件
must_not，必须不匹配must_not所列举的所有条件。
should，应该满足should所列举的条件。

GET bank/_search
{
  "query": {
    "bool": {
      "must": [
        {
          "match": {
            "gender": "M"
          }
        },
        {
          "match": {
            "address": "mill"
          }
        }
      ]
    }
  }
}
# 查询 gender 为 M 且 address 包含 mill 的数据

7. filter-结果过滤

并不是所有的查询都需要产生分数，特别是哪些仅用于filtering过滤的文档。为了不计算分数，elasticsearch会自动检查场景并且优化查询的执行。

filter 对结果进行过滤，且不计算相关性得分。

GET bank/_search
{
  "query": {
    "bool": {
      "must": [
        {
          "match": {
            "address": "mill"
          }
        }
      ],
      "filter": {
        "range": {
          "balance": {
            "gte": "10000",
            "lte": "20000"
          }
        }
      }
    }
  }
}
# 这里先是查询所有匹配 address 包含 mill 的文档，
# 然后再根据 10000<=balance<=20000 进行过滤查询结果

Each must, should, and must_not element in a Boolean query is referred to as a query clause. How well a document meets the criteria in each must or should clause contributes to the document’s relevance score. The higher the score, the better the document matches your search criteria. By default, Elasticsearch returns documents ranked by these relevance scores.

在boolean查询中，must, should 和must_not 元素都被称为查询子句。文档是否符合每个“must”或“should”子句中的标准，决定了文档的“相关性得分”。得分越高，文档越符合您的搜索条件。默认情况下，Elasticsearch 返回根据这些相关性得分排序的文档。

The criteria in a must_not clause is treated as a filter. It affects whether or not the document is included in the results, but does not contribute to how documents are scored. You can also explicitly specify arbitrary filters to include or exclude documents based on structured data.

“must_not”子句中的条件被视为“过滤器”。 它影响文档是否包含在结果中，但不影响文档的评分方式。还可以显式地指定任意过滤器来包含或排除基于结构化数据的文档。

8. term-精确检索

Avoid using the term query for text fields.

避免使用 term 查询文本字段

By default, Elasticsearch changes the values of text fields as part of analysis. This can make finding exact matches for text field values difficult.

默认情况下，Elasticsearch 会通过analysis分词将文本字段的值拆分为一部分，这使精确匹配文本字段的值变得困难。

To search text field values, use the match query instead.

如果要查询文本字段值，请使用 match 查询代替。

https://www.elastic.co/guide/en/elasticsearch/reference/7.11/query-dsl-term-query.html

在上面3.match-匹配查询中有介绍对于非文本字段的精确查询，Elasticsearch 官方对于这种非文本字段，使用 term来精确检索是一个推荐的选择。

GET bank/_search
{
  "query": {	
    "term": {
      "age": "28"
    }
  }
}
# 查找 age 为 28 的数据

9. Aggregation-执行聚合

https://www.elastic.co/guide/en/elasticsearch/reference/7.11/search-aggregations.html

聚合语法

GET /my-index-000001/_search
{
  "aggs":{
    "aggs_name":{ # 这次聚合的名字，方便展示在结果集中
        "AGG_TYPE":{ # 聚合的类型(avg,term,terms)
        }	
     }
	}
}

示例1-搜索address中包含mill的所有人的年龄分布以及平均年龄

GET bank/_search
{
  "query": {
    "match": {
      "address": "Mill"
    }
  },
  "aggs": {
    "ageAgg": {
      "terms": {
        "field": "age",
        "size": 10
      }
    },
    "ageAvg": {
      "avg": {
        "field": "age"
      }
    },
    "balanceAvg": {
      "avg": {
        "field": "balance"
      }
    }
  },
  "size": 0
}
# "ageAgg": {   				  --- 聚合名为 ageAgg
#   "terms": {				    --- 聚合类型为 term
#     "field": "age",     --- 聚合字段为 age
#     "size": 10			    --- 取聚合后前十个数据
#   }
# },
# ------------------------
# "ageAvg": {   				  --- 聚合名为 ageAvg
#   "avg": {				      --- 聚合类型为 avg 求平均值
#     "field": "age"	    --- 聚合字段为 age
#   }
# },
# ------------------------
# "balanceAvg": {				  --- 聚合名为 balanceAvg
#   "avg": {				      --- 聚合类型为 avg 求平均值
#     "field": "balance"  --- 聚合字段为 balance
#   }
# }
# ------------------------
# "size": 0               --- 不显示命中结果，只看聚合信息

结果：

{
  "took" : 10,
  "timed_out" : false,
  "_shards" : {
    "total" : 1,
    "successful" : 1,
    "skipped" : 0,
    "failed" : 0
  },
  "hits" : {
    "total" : {
      "value" : 4,
      "relation" : "eq"
    },
    "max_score" : null,
    "hits" : [ ]
  },
  "aggregations" : {
    "ageAgg" : {
      "doc_count_error_upper_bound" : 0,
      "sum_other_doc_count" : 0,
      "buckets" : [
        {
          "key" : 38,
          "doc_count" : 2
        },
        {
          "key" : 28,
          "doc_count" : 1
        },
        {
          "key" : 32,
          "doc_count" : 1
        }
      ]
    },
    "ageAvg" : {
      "value" : 34.0
    },
    "balanceAvg" : {
      "value" : 25208.0
    }
  }
}

示例2-按照年龄聚合，并且求这些年龄段的这些人的平均薪资

GET bank/_search
{
  "query": {
    "match_all": {}
  },
  "aggs": {
    "ageAgg": {
      "terms": {
        "field": "age",
        "size": 100
      },
      "aggs": {
        "ageAvg": {
          "avg": {
            "field": "balance"
          }
        }
      }
    }
  },
  "size": 0
}

结果：

{
  "took" : 12,
  "timed_out" : false,
  "_shards" : {
    "total" : 1,
    "successful" : 1,
    "skipped" : 0,
    "failed" : 0
  },
  "hits" : {
    "total" : {
      "value" : 1000,
      "relation" : "eq"
    },
    "max_score" : null,
    "hits" : [ ]
  },
  "aggregations" : {
    "ageAgg" : {
      "doc_count_error_upper_bound" : 0,
      "sum_other_doc_count" : 0,
      "buckets" : [
        {
          "key" : 31,
          "doc_count" : 61,
          "ageAvg" : {
            "value" : 28312.918032786885
          }
        },
        {
          "key" : 39,
          "doc_count" : 60,
          "ageAvg" : {
            "value" : 25269.583333333332
          }
        },
        {
          "key" : 26,
          "doc_count" : 59,
          "ageAvg" : {
            "value" : 23194.813559322032
          }
        },
        {
          "key" : 32,
          "doc_count" : 52,
          "ageAvg" : {
            "value" : 23951.346153846152
          }
        },
        {
          "key" : 35,
          "doc_count" : 52,
          "ageAvg" : {
            "value" : 22136.69230769231
          }
        },
        {
          "key" : 36,
          "doc_count" : 52,
          "ageAvg" : {
            "value" : 22174.71153846154
          }
        },
        {
          "key" : 22,
          "doc_count" : 51,
          "ageAvg" : {
            "value" : 24731.07843137255
          }
        },
        {
          "key" : 28,
          "doc_count" : 51,
          "ageAvg" : {
            "value" : 28273.882352941175
          }
        },
        {
          "key" : 33,
          "doc_count" : 50,
          "ageAvg" : {
            "value" : 25093.94
          }
        },
        {
          "key" : 34,
          "doc_count" : 49,
          "ageAvg" : {
            "value" : 26809.95918367347
          }
        },
        {
          "key" : 30,
          "doc_count" : 47,
          "ageAvg" : {
            "value" : 22841.106382978724
          }
        },
        {
          "key" : 21,
          "doc_count" : 46,
          "ageAvg" : {
            "value" : 26981.434782608696
          }
        },
        {
          "key" : 40,
          "doc_count" : 45,
          "ageAvg" : {
            "value" : 27183.17777777778
          }
        },
        {
          "key" : 20,
          "doc_count" : 44,
          "ageAvg" : {
            "value" : 27741.227272727272
          }
        },
        {
          "key" : 23,
          "doc_count" : 42,
          "ageAvg" : {
            "value" : 27314.214285714286
          }
        },
        {
          "key" : 24,
          "doc_count" : 42,
          "ageAvg" : {
            "value" : 28519.04761904762
          }
        },
        {
          "key" : 25,
          "doc_count" : 42,
          "ageAvg" : {
            "value" : 27445.214285714286
          }
        },
        {
          "key" : 37,
          "doc_count" : 42,
          "ageAvg" : {
            "value" : 27022.261904761905
          }
        },
        {
          "key" : 27,
          "doc_count" : 39,
          "ageAvg" : {
            "value" : 21471.871794871793
          }
        },
        {
          "key" : 38,
          "doc_count" : 39,
          "ageAvg" : {
            "value" : 26187.17948717949
          }
        },
        {
          "key" : 29,
          "doc_count" : 35,
          "ageAvg" : {
            "value" : 29483.14285714286
          }
        }
      ]
    }
  }
}

示例3-查出所有年龄分布，并且这些年龄段中M的平均薪资和F的平均薪资以及这个年龄段的总体平均薪资

GET bank/_search
{
  "query": {
    "match_all": {}
  },
  "aggs": {
    "ageAgg": {
      "terms": {
        "field": "age",
        "size": 100
      },
      "aggs": {
        "genderAgg": {
          "terms": {
            "field": "gender.keyword"
          },
          "aggs": {
            "balanceAvg": {
              "avg": {
                "field": "balance"
              }
            }
          }
        },
        "ageBalanceAvg": {
          "avg": {
            "field": "balance"
          }
        }
      }
    }
  },
  "size": 0
}
# "field": "gender.keyword" gender是txt没法聚合 必须加.keyword精确替代

结果：

{
  "took" : 17,
  "timed_out" : false,
  "_shards" : {
    "total" : 1,
    "successful" : 1,
    "skipped" : 0,
    "failed" : 0
  },
  "hits" : {
    "total" : {
      "value" : 1000,
      "relation" : "eq"
    },
    "max_score" : null,
    "hits" : [ ]
  },
  "aggregations" : {
    "ageAgg" : {
      "doc_count_error_upper_bound" : 0,
      "sum_other_doc_count" : 0,
      "buckets" : [
        {
          "key" : 31,
          "doc_count" : 61,
          "genderAgg" : {
            "doc_count_error_upper_bound" : 0,
            "sum_other_doc_count" : 0,
            "buckets" : [
              {
                "key" : "M",
                "doc_count" : 35,
                "balanceAvg" : {
                  "value" : 29565.628571428573
                }
              },
              {
                "key" : "F",
                "doc_count" : 26,
                "balanceAvg" : {
                  "value" : 26626.576923076922
                }
              }
            ]
          },
          "ageBalanceAvg" : {
            "value" : 28312.918032786885
          }
        },
        {
          "key" : 39,
          "doc_count" : 60,
          "genderAgg" : {
            "doc_count_error_upper_bound" : 0,
            "sum_other_doc_count" : 0,
            "buckets" : [
              {
                "key" : "F",
                "doc_count" : 38,
                "balanceAvg" : {
                  "value" : 26348.684210526317
                }
              },
              {
                "key" : "M",
                "doc_count" : 22,
                "balanceAvg" : {
                  "value" : 23405.68181818182
                }
              }
            ]
          },
          "ageBalanceAvg" : {
            "value" : 25269.583333333332
          }
        },
        ...
      ]
    }
  }
}

Mapping

1、字段类型

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-DAaHEs74-1684464779541)(images/谷粒商城项目笔记/image-20201026074813810.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-4l1gMLil-1684464779541)(images/谷粒商城项目笔记/image-20201026074841875.png)]

2、映射

Mapping（映射）

Mapping 是用来定义一个文档（document）,以及他所包含的属性（field）是如何存储索引的，比如使用 mapping来定义的：

哪些字符串属性应该被看做全文本属性（full text fields）
那些属性包含数字，日期或者地理位置
文档中的所有属性是能被索引（_all 配置）
日期的格式
自定义映射规则来执行动态添加属性

查看 mapping 信息

GET bank/_mapping

修改 mapping 信息

https://www.elastic.co/guide/en/elasticsearch/reference/7.10/mapping-types.html

自动猜测的映射类型

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ozAZ1WVd-1684464779542)(images/谷粒商城项目笔记/image-20201026075424198.png)]

3、新版本改变

关系型数据库中两个数据表示是独立的，即使他们里面有相同名称的列也不影响使用，但ES中不是这样的。elasticsearch 是基于Lucene开发的搜索引擎，而ES中不同type下名称相同的filed 最终在Lucene,中的处理方式是一样的。
两个不同 type下的两个user_ name, 在ES同-个索引下其实被认为是同一一个filed,你必须在两个不同的type中定义相同的filed映射。否则，不同typpe中的相同字段称就会在处理中出现神突的情况，导致Lucene处理效率下降。
去掉type就是为了提高ES处理数据的效率。

ES 7.x

URL 中的 type 参数可选，比如索引一个文档不再要求提供文档类型

ES 8.X

不在支持 URL 中的 type 参数

解决：

1、将索引从多类型迁移到单类型，每种类型文档一个独立的索引

2、将已存在的索引下的类型数据，全部迁移到指定位置即可，详见数据迁移

1、创建映射

PUT /my_index
{
  "mappings":{
    "properties": {
      "age":{"type":"integer"},
      "email":{"type":"keyword"}
    }
  }
}

2、添加新的字段映射

PUT /my_index/_mapping
{
  "properties":{
    "employeeid":{
      "type":"keyword",
      "index":false
    }
  }
}

3、更新映射

对于已经存在的映射字段，我们不能更新，更新必须创建新的索引进行数据迁移

4、数据迁移

先创 new_twitter 的正确映射，然乎使用如下方式进行数据迁移

POST _reindex [固定写法]
{
  "source":{
    "index":"twitter"
  },
  "dest":{
    "index":"new_twitter"
  }
}
## 将旧索引的 type 下的数据进行迁移
POST _reindex
{
  "source": {
    "index":"twitter",
    "type":"tweet"
  },
  "dest":{
    "index":"twweets"
  }
}

参考官网：https://www.elastic.co/guide/en/elasticsearch/reference/7.10/mapping-types.html

参数映射规则：https://www.elastic.co/guide/en/elasticsearch/reference/7.10/mapping-params.html#mapping-params

分词

一个 tokenizer（分词器）接收一个字符流，将之分割为独立的 tokens（词元，通常是独立的单词），然后输出 token 流

列如，witespace tokenizer 遇到的空白字符时分割文本，它会将文本 “Quick brown fox” 分割为【Quick brown fox】

该 tokenizer (分词器)还负责记录各个term (词条)的顺序或 position 位置(用于phrase短语和word proximity词近邻查询)，以及

term (词条)所代表的原始 word (单词)的start(起始)和end (结束)的 character offsets (字符偏移量) (用于高亮显示搜索的内容)。

Elasticsearch 提供了很多内置的分词器，可以用来构建custom analyzers(自定义分词器)

1、安装 ik 分词器

注意:不能用默认的 elasticsearch-plugin.install xxx.zip 进行自动安装

https://github.com/medcl/elasticsearch-analysis-ik/releases 下载与 es对应的版本

安装后拷贝到 plugins 目录下

下载安装包：（阿里云盘有备份：IT技术学习 - gulimall-s）
- 下载地址：https://github.com/medcl/elasticsearch-analysis-ik/releases/download/v7.4.2/elasticsearch-analysis-ik-7.4.2.zip
在/mydata/elasticsearch/plugins/目录下新建文件夹ik
```
cd /mydata/elasticsearch/plugins/

mkdir ik
```
将下好的压缩包拷贝到ik文件夹里

解压缩

unzip elasticsearch-analysis-ik-7.4.2.zip

删除zip文件

rm -rf elasticsearch-analysis-ik-7.4.2.zip

进入elasticsearch中查看安装情况

[root@master ik]# docker ps
CONTAINER ID   IMAGE                 COMMAND                  CREATED          STATUS          PORTS                                                                                  NAMES
c23a3a8c65b3   kibana:7.4.2          "/usr/local/bin/dumb…"   23 minutes ago   Up 23 minutes   0.0.0.0:5601->5601/tcp, :::5601->5601/tcp                                              kibana
545c3c3a9ff9   elasticsearch:7.4.2   "/usr/local/bin/dock…"   24 minutes ago   Up 14 minutes   0.0.0.0:9200->9200/tcp, :::9200->9200/tcp, 0.0.0.0:9300->9300/tcp, :::9300->9300/tcp   elasticsearch

[root@master ik]# docker exec -it 545 /bin/bash

[root@545c3c3a9ff9 elasticsearch]# ls
LICENSE.txt  NOTICE.txt  README.textile  bin  config  data  jdk  lib  logs  modules  plugins

[root@545c3c3a9ff9 elasticsearch]# cd bin

[root@545c3c3a9ff9 bin]# ls
elasticsearch           elasticsearch-cli       elasticsearch-enve      elasticsearch-node           elasticsearch-setup-passwords  elasticsearch-sql-cli-7.4.2.jar  x-pack-env
elasticsearch-certgen   elasticsearch-croneval  elasticsearch-keystore  elasticsearch-plugin         elasticsearch-shard            elasticsearch-syskeygen          x-pack-security-env
elasticsearch-certutil  elasticsearch-env       elasticsearch-migrate   elasticsearch-saml-metadata  elasticsearch-sql-cli          elasticsearch-users              x-pack-watcher-env

[root@545c3c3a9ff9 bin]# elasticsearch-plugin list
ik

2、测试

使用前记得重启elasticsearch
```
docker restart elasticsearch
```

分词器

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-kd0cFEUQ-1684464779542)(images/谷粒商城项目笔记/image-20201026092255250.png)]

docker run -p 80:80 --name nginx -d nginx:1.10

3、自定义词库

Docker 安装 Nginx

创建要挂载的配置目录
```
mkdir -p /mydata/nginx/conf
```

启动临时nginx容器

docker run -p 80:80 --name nginx -d nginx:1.10

拷贝出 Nginx 容器的配置

# 将nginx容器中的nginx目录复制到本机的/mydata/nginx/conf目录
docker container cp nginx:/etc/nginx /mydata/nginx/conf

# 复制的是nginx目录，将该目录的所有文件移动到 conf 目录
mv /mydata/nginx/conf/nginx/* /mydata/nginx/conf/

# 删除多余的 /mydata/nginx/conf/nginx目录
rm -rf /mydata/nginx/conf/nginx

删除临时nginx容器

# 停止运行 nginx 容器
docker stop nginx

# 删除 nginx 容器
docker rm nginx

启动 nginx 容器

docker run -p 80:80 --name nginx \
-v /mydata/nginx/html:/usr/share/nginx/html \
-v /mydata/nginx/logs:/var/log/nginx \
-v /mydata/nginx/conf/:/etc/nginx \
-d nginx:1.10

设置 nginx 随 Docker 启动
```
docker update nginx --restart=always
```
测试 nginx
- ```
echo '谷粒商城源码
' \
>/mydata/nginx/html/index.html
```
- 打开：http://192.168.163.131/ 可以看到下面内容说明安装成功
  
  [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Zt6nim4y-1684464779543)(images/谷粒商城项目笔记/image-20220510180925529.png)]

nginx 中自定义分词文件
```
mkdir /mydata/nginx/html/es

echo "蔡徐坤" > /mydata/nginx/html/es/fenci.txt
```
nginx 默认请求地址为 ip:port/es/fenci.txt；本机为：192.168.163.131/es/fenci.txt

如果想要增加新的词语，只需要在该文件追加新的行并保存新的词语即可。

给 es 配置自定义词库

# 1. 打开并编辑 ik 插件配置文件
vim /mydata/elasticsearch/plugins/ik/config/IKAnalyzer.cfg.xml

修改为以下内容：

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE properties SYSTEM "http://java.sun.com/dtd/properties.dtd">
<properties>
        <comment>IK Analyzer 扩展配置</comment>
        <!--用户可以在这里配置自己的扩展字典 -->
        <entry key="ext_dict"></entry>
         <!--用户可以在这里配置自己的扩展停止词字典-->
        <entry key="ext_stopwords"></entry>
        <!--用户可以在这里配置远程扩展字典 -->
        <!-- <entry key="remote_ext_dict">words_location</entry> -->
        <entry key="remote_ext_dict">http://192.168.91.100/es/fenci.txt</entry>
        <!--用户可以在这里配置远程扩展停止词字典-->
        <!-- <entry key="remote_ext_stopwords">words_location</entry> -->
</properties>

重启 elasticsearch 容器
```
docker restart elasticsearch
```
测试自定义词库
```
GET my_index/_analyze
{
   "analyzer": "ik_max_word", 
   "text":"蔡徐坤"
}
```
结果：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-XAJImH0j-1684464779543)(images/谷粒商城项目笔记/image-20220510181243145.png)]

5 Elasticsearch - Rest - client

1、9300：TCP

Spring-data-elasticsearch:transport-api.jar

SpringBoot版本不同，transport-api.jar 不同，不能适配 es 版本

7.x 已经不在适合使用，8 以后就要废弃

2、9200：HTTP

JestClient 非官方，更新慢

RestTemplate:默认发送 HTTP 请求，ES很多操作都需要自己封装、麻烦

HttpClient：同上

Elasticsearch - Rest - Client：官方RestClient，封装了 ES 操作，API层次分明

最终选择 Elasticsearch - Rest - Client （elasticsearch - rest - high - level - client）

1、SpringBoot 整合

1、Pom.xml


<dependency>
    <groupId>org.elasticsearch.clientgroupId>
    <artifactId>elasticsearch-rest-high-level-clientartifactId>
    <version>7.4.2version>
dependency>

为什么要导入这个？这个配置那里来的？

官网：https://www.elastic.co/guide/en/elasticsearch/client/java-rest/current/java-rest-high-getting-started-maven.html

2、Config配置

/**
 * @author gcq
 * @Create 2020-10-26
 *
 * 1、导入配置
 * 2、编写配置，给容器注入一个RestHighLevelClient
 * 3、参照API 官网进行开发
 */
@Configuration
public class GulimallElasticsearchConfig {


    public static final RequestOptions COMMON_OPTIONS;
    static {
        RequestOptions.Builder builder = RequestOptions.DEFAULT.toBuilder();
//        builder.addHeader("Authorization", "Bearer " + TOKEN);
//        builder.setHttpAsyncResponseConsumerFactory(
//                new HttpAsyncResponseConsumerFactory
//                        .HeapBufferedResponseConsumerFactory(30 * 1024 * 1024 * 1024));
        COMMON_OPTIONS = builder.build();
    }



    @Bean
    public RestHighLevelClient esRestClient() {
        RestClientBuilder builder = null;
        builder = RestClient.builder(new HttpHost("192.168.56.10", 9200, "http"));

        RestHighLevelClient client = new RestHighLevelClient(builder);
//        RestHighLevelClient client = new RestHighLevelClient(
//                RestClient.builder(
//                        new HttpHost("localhost", 9200, "http"),
//                        new HttpHost("localhost", 9201, "http")));
        return client;
    }

}

官网：https://www.elastic.co/guide/en/elasticsearch/client/java-rest/current/java-rest-high-getting-started-initialization.html

3、使用

测试是否注入成功

@Autowired
private RestHighLevelClient client;

@Test
public void contextLoads() {
    System.out.println(client);
}

测试是否能添加或更新数据

/**
 * 添加或者更新
 * @throws IOException
 */
@Test
public void indexData() throws IOException {
    IndexRequest indexRequest = new IndexRequest("users");
    User user = new User();
    user.setAge(19);
    user.setGender("男");
    user.setUserName("张三");
    String jsonString = JSON.toJSONString(user);
    indexRequest.source(jsonString,XContentType.JSON);

    // 执行操作
    IndexResponse index = client.index(indexRequest, GulimallElasticsearchConfig.COMMON_OPTIONS);

    // 提取有用的响应数据
    System.out.println(index);
}

测试复杂检索

 @Test
    public void searchTest() throws IOException {
        // 1、创建检索请求
        SearchRequest searchRequest = new SearchRequest();
        // 指定索引
        searchRequest.indices("bank");
        // 指定 DSL，检索条件
        SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();

        sourceBuilder.query(QueryBuilders.matchQuery("address", "mill"));

        //1、2 按照年龄值分布进行聚合
        TermsAggregationBuilder aggAvg = AggregationBuilders.terms("ageAgg").field("age").size(10);
        sourceBuilder.aggregation(aggAvg);

        //1、3 计算平均薪资
        AvgAggregationBuilder balanceAvg = AggregationBuilders.avg("balanceAvg").field("balance");
        sourceBuilder.aggregation(balanceAvg);


        System.out.println("检索条件" + sourceBuilder.toString());

        searchRequest.source(sourceBuilder);

        // 2、执行检索
        SearchResponse searchResponse = client.search(searchRequest, GulimallElasticsearchConfig.COMMON_OPTIONS);

        // 3、分析结果
        System.out.println(searchResponse.toString());

        // 4、拿到命中得结果
        SearchHits hits = searchResponse.getHits();
        // 5、搜索请求的匹配
        SearchHit[] searchHits = hits.getHits();
        // 6、进行遍历
        for (SearchHit hit : searchHits) {
            // 7、拿到完整结果字符串
            String sourceAsString = hit.getSourceAsString();
            // 8、转换成实体类
            Accout accout = JSON.parseObject(sourceAsString, Accout.class);
            System.out.println("account:" + accout );
        }

        // 9、拿到聚合
        Aggregations aggregations = searchResponse.getAggregations();
//        for (Aggregation aggregation : aggregations) {
//
//        }
        // 10、通过先前名字拿到对应聚合
        Terms ageAgg1 = aggregations.get("ageAgg");
        for (Terms.Bucket bucket : ageAgg1.getBuckets()) {
            // 11、拿到结果
            String keyAsString = bucket.getKeyAsString();
            System.out.println("年龄:" + keyAsString);
            long docCount = bucket.getDocCount();
            System.out.println("个数：" + docCount);
        }
        Avg balanceAvg1 = aggregations.get("balanceAvg");
        System.out.println("平均薪资：" + balanceAvg1.getValue());
        System.out.println(searchResponse.toString());
    }

结果：

accout:GulimallSearchApplicationTests.Accout(account_number=970, balance=19648, firstname=Forbes, lastname=Wallace, age=28, gender=M, address=990 Mill Road, employer=Pheast, email=forbeswallace@pheast.com, city=Lopezo, state=AK)accout:GulimallSearchApplicationTests.Accout(account_number=136, balance=45801, firstname=Winnie, lastname=Holland, age=38, gender=M, address=198 Mill Lane, employer=Neteria, email=winnieholland@neteria.com, city=Urie, state=IL)accout:GulimallSearchApplicationTests.Accout(account_number=345, balance=9812, firstname=Parker, lastname=Hines, age=38, gender=M, address=715 Mill Avenue, employer=Baluba, email=parkerhines@baluba.com, city=Blackgum, state=KY)accout:GulimallSearchApplicationTests.Accout(account_number=472, balance=25571, firstname=Lee, lastname=Long, age=32, gender=F, address=288 Mill Street, employer=Comverges, email=leelong@comverges.com, city=Movico, state=MT)年龄:38
个数:2
年龄:28
个数:1
年龄:32
个数:1
平均薪水:25208.0

总结：参考官网的API 和对应在 kibana 中发送的请求，在代码中通过调用对应API实现效果

官网：https://www.elastic.co/guide/en/elasticsearch/client/java-rest/current/java-rest-high-search.html#java-rest-high-search-request-optional

ELK

Elasticsearch 用于检索数据

logstach：存储数据

Kiban:视图化查看数据

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-rP98RzZT-1684464779543)(images/谷粒商城项目笔记/image-20201027120603889.png)]

Nginx-搭建域名访问环境

修改 Windows hosts 文件

位置：C:\Windows\System32\drivers\etc

后面追加

# guli mall #  注意这个ip地址是nginx所在服务器主机地址
192.168.91.100		gulimall.com

Nginx 配置文件

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-QIKbapSk-1684464779544)(images/谷粒商城项目笔记/image-20220511151810799.png)]

分析Nginx配置文件

位置：cat /mydata/nginx/conf/nginx.conf

user  nginx;
worker_processes  1;

error_log  /var/log/nginx/error.log warn;
pid        /var/run/nginx.pid;

events {
    worker_connections  1024;
}

http {
    include       /etc/nginx/mime.types;
    default_type  application/octet-stream;

    log_format  main  '$remote_addr - $remote_user [$time_local] "$request" '
                      '$status $body_bytes_sent "$http_referer" '
                      '"$http_user_agent" "$http_x_forwarded_for"';

    access_log  /var/log/nginx/access.log  main;

    sendfile        on;
    #tcp_nopush     on;

    keepalive_timeout  65;

    #gzip  on;

    include /etc/nginx/conf.d/*.conf;
}

可以看到，在 http 块中最后有 include /etc/nginx/conf.d/*.conf; 这句配置说明在 conf.d 目录下所有 .conf 后缀的文件内容都会作为 nginx 配置文件 http 块中的配置。这是为了防止主配置文件太复杂，也可以对不同的配置进行分类。

下面我们参考 conf.d 目录下的配置，来配置 gulimall 的 server 块配置

配置gulimall.conf

复制出来

cd /mydata/nginx/conf/conf.d

cp default.conf gulimall.conf

查看Windows ip
- 打开cmd 输入 ipconfig
  
  [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Vcv47X3G-1684464779544)(images/谷粒商城项目笔记/image-20220511152556498.png)]
- 这里的 192.168.1.7 和 192.168.56.1 也是 Windows 的本机地址
  
  所以我们配置当访问 nginx /请求时代理到 192.168.56.1:10000 商品服务首页

配置代理

vim gulimall.conf

server {
    listen       80;
    server_name  gulimall.com;

    #charset koi8-r;
    #access_log  /var/log/nginx/log/host.access.log  main;

    location / {
      proxy_pass http://192.168.91.1:10000;
    }

    #error_page  404              /404.html;

    # redirect server error pages to the static page /50x.html
    #
    error_page   500 502 503 504  /50x.html;
    location = /50x.html {
        root   /usr/share/nginx/html;
    }
}

图示

[外链图片转存中…(img-UB12NNaY-1684464779544)]

反向代理：nginx 代理网关由网关进行转发

修改 nginx.conf
```
vim /mydata/nginx/conf/nginx.conf
```

修改 http 块，配置上游服务器为网关地址

user  nginx;
worker_processes  1;

error_log  /var/log/nginx/error.log warn;
pid        /var/run/nginx.pid;

events {
    worker_connections  1024;
}

http {
    include       /etc/nginx/mime.types;
    default_type  application/octet-stream;

    log_format  main  '$remote_addr - $remote_user [$time_local] "$request" '
                      '$status $body_bytes_sent "$http_referer" '
                      '"$http_user_agent" "$http_x_forwarded_for"';

    access_log  /var/log/nginx/access.log  main;

    sendfile        on;
    #tcp_nopush     on;

    keepalive_timeout  65;

    #gzip  on;
    upstream gulimall {
        server 192.168.56.1:88;
    }
    include /etc/nginx/conf.d/*.conf;
}

[外链图片转存中…(img-8SAmwc3X-1684464779544)]

修改 gulimall.conf

配置代理地址为上面配置的上游服务器名

server {
    listen       80;
    server_name  gulimall.com;

    #charset koi8-r;
    #access_log  /var/log/nginx/log/host.access.log  main;

    location / {
      proxy_set_header Host $host;
      proxy_pass http://gulimall;
    }

    #error_page  404              /404.html;

    # redirect server error pages to the static page /50x.html
    #
    error_page   500 502 503 504  /50x.html;
    location = /50x.html {
        root   /usr/share/nginx/html;
    }
}

[外链图片转存中…(img-9AhpDrha-1684464779545)]

效果

[外链图片转存中…(img-fvD3NgtB-1684464779545)]
访问跳转分析
- 当前通过域名的方式，请求 gulimall.com ；
- 根据 hosts 文件的配置，请求 gulimall.com 域名时会请求虚拟机 ip
- 当请求到 192.168.163.131:80 时，会被 nginx 转发到我们配置的 192.168.163.1:10000 路径，该路径为运行商品服务的 windows 主机 ip 地址，至此达到通过域名访问商品服务的目的。
后续网关配置
- 之后为了统一管理我们的各种服务，我们将通过配置网关作为 nginx 转发的目标。最后通过配置网关根据不同的域名来判断跳转对应的服务。
  
  [外链图片转存中…(img-zQtzpXIC-1684464779545)]

性能与压力测试

简介

压力测试考察当前软硬件环境下系统所能承受住的最大负荷并帮助找出系统的瓶颈所在，压测都是为了系统

在线上的处理能力和稳定性维持在一个标准范围内，做到心中有数

使用压力测试，我们有希望找到很多种用其他测试方法更难发现的错误，有两种错误类型是：

内存泄漏、并发与同步

有效的压力测试系统将应用以下这些关键条件：重复、并发、量级、随机变化

Jvm 内存模型

1、Jvm内存模型

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-UGPVndiC-1684464779545)(images/谷粒商城项目笔记/image-20201029112517466.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-DdDalfLm-1684464779546)(images/谷粒商城项目笔记/image-20201029113956043.png)]

堆

所有的对象实例以及数组都要在堆上分配，堆时垃圾收集器管理的主要区域，也被称为 “GC堆”，也是我们优化最多考虑的地方

堆可以细分为：

新生代
- Eden空间
- From Survivor 空间
- To Survivor 空间
老年代
永久代/原空间
- Java8 以前永久代、受 JVM 管理、Java8 以后原空间，直接使用物理内存，因此默认情况下，原空间的大小仅受本地内存限制

垃圾回收

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-jbZ04yzV-1684464779546)(images/谷粒商城项目笔记/image-20201029114153244.png)]

从 Java8 开始,HotSpot 已经完全将永久代（Permanent Generation）移除，取而代之的是一个新的区域 - 元空间（MetaSpac)

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-U6s0KZwb-1684464779546)(images/谷粒商城项目笔记/image-20201029114218716.png)]

jconsole 与 jvisualvm

jdk 的两个小工具 jconsole、jvisualvm（升级版本的 jconsole）。通过命令行启动、可监控本地和远程应用、远程应用需要配置

1、jvisualvm 能干什么

监控内存泄漏、跟踪垃圾回收、执行时内存、cpu分析、线程分析…

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Q6SV5caZ-1684464779547)(images/谷粒商城项目笔记/image-20201029120502383.png)]

运行：正在运行的线程

休眠：sleep

等待：wait

驻留：线程池里面的空闲线程

监视：组赛的线程、正在等待锁

2、安装插件方便查看 gc

cmd 启动 jvisualvm

工具->插件

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-9QoN3Kdr-1684464779547)(images/谷粒商城项目笔记/image-20201029121108492.png)]

如果503 错误解决

打开网址： https://visualvm.github.io/pluginscenters.html

cmd 查看自己的jdk版本，找到对应的

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-3oTglkSt-1684464779547)(images/谷粒商城项目笔记/image-20220617194246919.png)]
打开https://visualvm.github.io/pluginscenters.html

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-0NgPAOe6-1684464779547)(images/谷粒商城项目笔记/image-20220617194345745.png)]
复制下面这个链接

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-IB3Afz7S-1684464779548)(images/谷粒商城项目笔记/image-20220617194416881.png)]
打开jvisualvm，点击工具 - 插件

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Tof7HulC-1684464779548)(images/谷粒商城项目笔记/image-20220617194514322.png)]
点击设置 - 编辑

[外链图片转存中…(img-ODx1xX0t-1684464779548)]
刚才复制好的链接复制到如下位置：（注意此时要切换为手机热点网络）

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-hchTdEeE-1684464779548)(images/谷粒商城项目笔记/image-20220617194636634.png)]
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-9COMVAsI-1684464779549)(images/谷粒商城项目笔记/image-20220617194746696.png)]
- 安装完成后重启jvisualvm（安装完成记得网络切换回去，流量贵）
此时打开某个java应用，就发现多了个Visual GC

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-AIOu6V1a-1684464779549)(images/谷粒商城项目笔记/image-20220617195055516.png)]

docker stats 查看相关命令

JMeter

1、安装

（阿里云盘：IT技术学习 - gulimall-soft）

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

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-MyGqcHC7-1684464779549)(images/谷粒商城项目笔记/image-20220504155752345.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-NCLLGLey-1684464779550)(images/谷粒商城项目笔记/image-20220504155833695.png)]

2、启动

解压后打开bin目录

点击jmeter.bat

就开启了jmeter

JMeter 压测示例

1、添加线程组

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-FK4MQiZ0-1684464779550)(images/谷粒商城项目笔记/image-20201029084634498.png)]

2、添加 HTTP 请求

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-iCs6ZJ3M-1684464779550)(images/谷粒商城项目笔记/image-20201029085843220.png)]

3、添加监听器

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Tqhj4CQ6-1684464779550)(images/谷粒商城项目笔记/image-20201029085942442.png)]

4、启动压测&查看

汇总图

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-qxxIKqew-1684464779550)(images/谷粒商城项目笔记/image-20201029092357910.png)]

察看结果树

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-RewbCIRt-1684464779551)(images/谷粒商城项目笔记/image-20201029092436633.png)]

汇总报告

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-zjrDWtza-1684464779551)(images/谷粒商城项目笔记/image-20201029092454376.png)]

聚合报告

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-bl2wq72p-1684464779551)(images/谷粒商城项目笔记/image-20201029092542876.png)]

JMeter Address Already in use 错误解决

windows本身提供的端口访问机制的问题。 Windows提供给TCP/IP 链接的端口为1024-5000，并且要四分钟来循环回收他们。就导致我们在短时间内跑大量的请求时将端口占满了。

1.cmd中，用regedit命令打开注册表

2.在HKEY_ LOCAL MACHINE\SYSTEMCurrentControlSet\Services Tcpip\Parameters下，

1.右击parameters,添加一个新的DWORD,名字为MaxUserPort 2.然后双击 MaxUserPort,输入数值数据为65534,基数选择十进制(如果是分布式运行的话，控制机器和负载机器都需要这样操作哦)

3.修改配置完毕之后记得重启机器才会生效

TCPTimedWaitDelay:30

性能优化 - Nginx 动静分离

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-vAR3SWUO-1684464779551)(images/谷粒商城项目笔记/image-20220511173747297.png)]

新建static目录
```
mkdir /mydata/nginx/html/static
```
首先，把商品服务中静态文件夹 index 放到 nginx 下 /mydata/nginx/html/static目录；

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-7s8oRaVg-1684464779552)(images/谷粒商城项目笔记/image-20220618104825684.png)]
修改 Nginx 配置文件 /mydata/nginx/conf/conf.d/gulimall.conf

vi /mydata/nginx/conf/conf.d/gulimall.conf

# /static/ 下所有的请求都转给 nginx
location /static/ {
	root /usr/share/nginx/html;
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-3fMZl1cv-1684464779552)(images/谷粒商城项目笔记/image-20220511173837394.png)]

重启nginx
```
docker restart nginx
```

缓存和分布式锁

缓存

整合 redis 作为缓存

1、引入依赖

SpringBoot 整合 redis，查看SpringBoot提供的 starts

[外链图片转存中…(img-BDZpIDTr-1684464779552)]

官网：https://docs.spring.io/spring-boot/docs/2.1.18.RELEASE/reference/html/using-boot-build-systems.html#using-boot-starter

pom.xml

 
        
            org.springframework.boot
            spring-boot-starter-data-redis
            
            
                
                    io.lettuce
                    lettuce-core
                
            
        

        
        
            redis.clients
            jedis

堆外内存溢出异常：

这里可能会产生堆外内存溢出异常：OutOfDirectMemoryError。

下面进行分析：

SpringBoot 2.0 以后默认使用 lettuce 作为操作 redis 的客户端，它使用 netty 进行网络通信；
lettuce 的 bug 导致 netty 堆外内存溢出；
netty 如果没有指定堆外内存，默认使用 -Xmx 参数指定的内存；
可以通过 -Dio.netty.maxDirectMemory 进行设置；

解决方案：不能只使用 -Dio.netty.maxDirectMemory 去调大堆外内存，这样只会延缓异常出现的时间。

升级 lettuce 客户端，或使用 jedis 客户端

2、配置

application.yaml

Spring:
  redis:
    host: 192.168.56.10
    port: 6379

RedisAutoConfig.java

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-gziOAEFg-1684464779552)(images/谷粒商城项目笔记/image-20201031154710108.png)]

3、测试

@Autowired
StringRedisTemplate stringRedisTemplate;

@Test
public void testStringRedisTemplate() {

    stringRedisTemplate.opsForValue().set("hello","world_" + UUID.randomUUID().toString());
    String hello = stringRedisTemplate.opsForValue().get("hello");
    System.out.println("之前保存的数据是：" + hello);
}

4、优化三级分类数据获取

/**
 * TODO 产生堆外内存溢出 OutOfDirectMemoryError
 * 1、SpringBoot2.0以后默认使用 Lettuce作为操作redis的客户端，它使用 netty进行网络通信
 * 2、lettuce 的bug导致netty堆外内存溢出，-Xmx300m netty 如果没有指定堆内存移除，默认使用 -Xmx300m
 *      可以通过-Dio.netty.maxDirectMemory 进行设置
 *   解决方案 不能使用 -Dio.netty.maxDirectMemory调大内存
 *   1、升级 lettuce客户端，2、 切换使用jedis
 *   redisTemplate:
 *   lettuce、jedis 操作redis的底层客户端，Spring再次封装
 * @return
 */
@Override
public Map> getCatelogJson() {

    // 给缓存中放 json 字符串、拿出的是 json 字符串，还要逆转为能用的对象类型【序列化和反序列化】

    // 1、加入缓存逻辑，缓存中放的数据是 json 字符串
    // JSON 跨语言，跨平台兼容
    String catelogJSON = redisTemplate.opsForValue().get("catelogJSON");
    if (StringUtils.isEmpty(catelogJSON)) {
        // 2、缓存没有，从数据库中查询
        Map> catelogJsonFromDb = getCatelogJsonFromDb();
        // 3、查询到数据，将数据转成 JSON 后放入缓存中
        String s = JSON.toJSONString(catelogJsonFromDb);
        redisTemplate.opsForValue().set("catelogJSON",s);
        return catelogJsonFromDb;
    }
    // 转换为我们指定的对象
    Map> result = JSON.parseObject(catelogJSON, new TypeReference>>() {});

    return result;
}

分布式锁

分布式锁基本原理

[外链图片转存中…(img-fdkVCYEz-1684464779553)]

**理解：**就先当1000个人去占一个厕所，厕所只能有一个人占到这个坑，占到这个坑其他人就只能在外面等待，等待一段时间后可以再次来占坑，业务执行后，释放锁，那么其他人就可以来占这个坑

分布式锁演进 - 阶段一

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-2pmY4YGt-1684464779553)(images/谷粒商城项目笔记/image-20201031123441336.png)]

代码：

 Boolean lock = redisTemplate.opsForValue().setIfAbsent("lock", "0");
        if (lock) {
            // 加锁成功..执行业务
            Map> dataFromDb = getDataFromDB();
            redisTemplate.delete("lock"); // 删除锁
            return dataFromDb;
        } else {
            // 加锁失败，重试 synchronized()
            // 休眠100ms重试
            return getCatelogJsonFromDbWithRedisLock();
        }

分布式锁演进 - 阶段二

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-oHC4ysjT-1684464779553)(images/谷粒商城项目笔记/image-20201031123640746.png)]

代码：

 Boolean lock = redisTemplate.opsForValue().setIfAbsent()
        if (lock) {
            // 加锁成功..执行业务
            // 设置过期时间
            redisTemplate.expire("lock",30,TimeUnit.SECONDS);
            Map> dataFromDb = getDataFromDB();
            redisTemplate.delete("lock"); // 删除锁
            return dataFromDb;
        } else {
            // 加锁失败，重试 synchronized()
            // 休眠100ms重试
            return getCatelogJsonFromDbWithRedisLock();
        }

分布式锁演进 - 阶段三

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-tBemFBkT-1684464779554)(images/谷粒商城项目笔记/image-20201031124210112.png)]

代码：

// 设置值同时设置过期时间
Boolean lock = redisTemplate.opsForValue().setIfAbsent("lock","111",300,TimeUnit.SECONDS);
if (lock) {
    // 加锁成功..执行业务
    // 设置过期时间,必须和加锁是同步的，原子的
    redisTemplate.expire("lock",30,TimeUnit.SECONDS);
    Map> dataFromDb = getDataFromDB();
    redisTemplate.delete("lock"); // 删除锁
    return dataFromDb;
} else {
    // 加锁失败，重试 synchronized()
    // 休眠100ms重试
    return getCatelogJsonFromDbWithRedisLock();
}

分布式锁演进 - 阶段四

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-cTcvtlkS-1684464779554)(images/谷粒商城项目笔记/image-20201031124615670.png)]

图解：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-RfSczvzd-1684464779554)(images/谷粒商城项目笔记/image-20201031130547173.png)]

代码：

 String uuid = UUID.randomUUID().toString();
        // 设置值同时设置过期时间
        Boolean lock = redisTemplate.opsForValue().setIfAbsent("lock",uuid,300,TimeUnit.SECONDS);
        if (lock) {
            // 加锁成功..执行业务
            // 设置过期时间,必须和加锁是同步的，原子的
//            redisTemplate.expire("lock",30,TimeUnit.SECONDS);
            Map> dataFromDb = getDataFromDB();
//            String lockValue = redisTemplate.opsForValue().get("lock");
//            if (lockValue.equals(uuid)) {
//                // 删除我自己的锁
//                redisTemplate.delete("lock"); // 删除锁
//            }
// 通过使用lua脚本进行原子性删除
            String script = "if redis.call('get',KEYS[1]) == ARGV[1] then return redis.call('del',KEYS[1]) else return 0 end";
                //删除锁
                Long lock1 = redisTemplate.execute(new DefaultRedisScript(script, Long.class), Arrays.asList("lock"), uuid);

            return dataFromDb;
        } else {
            // 加锁失败，重试 synchronized()
            // 休眠100ms重试
            return getCatelogJsonFromDbWithRedisLock();
        }

分布式锁演进 - 阶段五最终模式

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-tkhsSQRl-1684464779555)(images/谷粒商城项目笔记/image-20201031130201609.png)]

代码：

 String uuid = UUID.randomUUID().toString();
        // 设置值同时设置过期时间
        Boolean lock = redisTemplate.opsForValue().setIfAbsent("lock",uuid,300,TimeUnit.SECONDS);
        if (lock) {
            System.out.println("获取分布式锁成功");
            // 加锁成功..执行业务
            // 设置过期时间,必须和加锁是同步的，原子的
//            redisTemplate.expire("lock",30,TimeUnit.SECONDS);
            Map> dataFromDb;
//            String lockValue = redisTemplate.opsForValue().get("lock");
//            if (lockValue.equals(uuid)) {
//                // 删除我自己的锁
//                redisTemplate.delete("lock"); // 删除锁
//            }
            try {
                dataFromDb = getDataFromDB();
            } finally {
                String script = "if redis.call('get',KEYS[1]) == ARGV[1] then return redis.call('del',KEYS[1]) else return 0 end";
                //删除锁
                Long lock1 = redisTemplate.execute(new DefaultRedisScript(script, Long.class), Arrays.asList("lock"), uuid);
            }
            return dataFromDb;
        } else {
            // 加锁失败，重试 synchronized()
            // 休眠200ms重试
            System.out.println("获取分布式锁失败，等待重试");
            try { TimeUnit.MILLISECONDS.sleep(200); } catch (InterruptedException e) { e.printStackTrace(); }
            return getCatelogJsonFromDbWithRedisLock();
        }

问题：

分布式加锁解锁都是这两套代码，可以封装成工具类
分布式锁有更专业的框架

分布式锁 - Redisson

1、整合

1、引入依赖



    org.redisson
    redisson
    3.12.0

2、配置 redisson

@Configuration
public class MyRedissonConfig {
    /**
     * 所有对 Redisson 的使用都是通过 RedissonClient
     *
     * @return
     * @throws IOException
     */
    @Bean(destroyMethod = "shutdown")
    public RedissonClient redisson() throws IOException {
        // 1、创建配置
        Config config = new Config();
        // Redis url should start with redis:// or rediss://
        config.useSingleServer().setAddress("redis://192.168.163.131:6379");

        // 2、根据 Config 创建出 RedissonClient 实例
        return Redisson.create(config);
    }
}

3、使用

// 1. 获取一把锁
Rlock lock = redisson.getLock("my-lock");

// 2. 加锁, 阻塞式等待
lock.lock();
try {
	System.out.println("加锁成功，执行业务...");
} catch (Exception e) {
} finally {
	// 3. 解锁 假设解锁代码没有运行，Redisson 会出现死锁吗？（不会）
    lock.unlock();
}

2、Redisson - Lock 锁测试 & Redisson - Lock 看门狗原理 - Redisson 如何解决死锁

@RequestMapping("/hello")
@ResponseBody
public String hello(){
    // 1、获取一把锁，只要锁得名字一样，就是同一把锁
    RLock lock = redission.getLock("my-lock");

    // 2、加锁
    lock.lock(); // 阻塞式等待，默认加的锁都是30s时间
    // 1、锁的自动续期，如果业务超长，运行期间自动给锁续上新的30s，不用担心业务时间长，锁自动过期后被删掉
    // 2、加锁的业务只要运行完成，就不会给当前锁续期，即使不手动解锁，锁默认会在30s以后自动删除

    lock.lock(10, TimeUnit.SECONDS); //10s 后自动删除
    //问题 lock.lock(10, TimeUnit.SECONDS) 在锁时间到了后，不会自动续期
    // 1、如果我们传递了锁的超时时间，就发送给 redis 执行脚本，进行占锁，默认超时就是我们指定的时间
    // 2、如果我们为指定锁的超时时间，就是用 30 * 1000 LockWatchchdogTimeout看门狗的默认时间、
    //      只要占锁成功，就会启动一个定时任务，【重新给锁设置过期时间，新的过期时间就是看门狗的默认时间】,每隔10s就自动续期
    //      internalLockLeaseTime【看门狗时间】 /3,10s

    //最佳实践
    // 1、lock.lock(10, TimeUnit.SECONDS);省掉了整个续期操作，手动解锁

    try {
        System.out.println("加锁成功，执行业务..." + Thread.currentThread().getId());
        Thread.sleep(3000);
    } catch (Exception e) {

    } finally {
        // 解锁 将设解锁代码没有运行，reidsson会不会出现死锁
        System.out.println("释放锁...." + Thread.currentThread().getId());
        lock.unlock();
    }

    return "hello";
}

进入到 Redisson Lock 源码

1、进入 Lock 的实现发现他调用的也是 lock 方法参数时间为 -1

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-LB9jyr9Q-1684464779555)(images/谷粒商城项目笔记/image-20201101051659465.png)]

2、再次进入 lock 方法

发现他调用了 tryAcquire

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-LSNihe65-1684464779555)(images/谷粒商城项目笔记/image-20201101051925487.png)]

3、进入 tryAcquire

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-e6ry8esG-1684464779556)(images/谷粒商城项目笔记/image-20201101052008724.png)]

4、里头调用了 tryAcquireAsync

这里判断 laseTime != -1 就与刚刚的第一步传入的值有关系

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-qWYyU12W-1684464779556)(images/谷粒商城项目笔记/image-20201101052037959.png)]

5、进入到 tryLockInnerAsync 方法

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-zu16j6Fa-1684464779556)(images/谷粒商城项目笔记/image-20201101052158592.png)]

6、internalLockLeaseTime 这个变量是锁的默认时间

这个变量在构造的时候就赋初始值

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-YJnPEcC1-1684464779557)(images/谷粒商城项目笔记/image-20201101052346059.png)]

7、最后查看 lockWatchdogTimeout 变量

也就是30秒的时间

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Zv2I5wfJ-1684464779557)(images/谷粒商城项目笔记/image-20201101052428198.png)]

3、Reidsson - 读写锁

二话不说，上代码！！！

/**
     * 保证一定能读取到最新数据，修改期间，写锁是一个排他锁（互斥锁，独享锁）读锁是一个共享锁
     * 写锁没释放读锁就必须等待
     * 读 + 读 相当于无锁，并发读，只会在 reids中记录好，所有当前的读锁，他们都会同时加锁成功
     * 写 + 读 等待写锁释放
     * 写 + 写 阻塞方式
     * 读 + 写 有读锁，写也需要等待
     * 只要有写的存在，都必须等待
     * @return String
     */
    @RequestMapping("/write")
    @ResponseBody
    public String writeValue() {

        RReadWriteLock lock = redission.getReadWriteLock("rw_lock");
        String s = "";
        RLock rLock = lock.writeLock();
        try {
            // 1、改数据加写锁，读数据加读锁
            rLock.lock();
            System.out.println("写锁加锁成功..." + Thread.currentThread().getId());
            s = UUID.randomUUID().toString();
            try { TimeUnit.SECONDS.sleep(3); } catch (InterruptedException e) { e.printStackTrace(); }
            redisTemplate.opsForValue().set("writeValue",s);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            rLock.unlock();
            System.out.println("写锁释放..." + Thread.currentThread().getId());
        }
        return s;
    }

    @RequestMapping("/read")
    @ResponseBody
    public String readValue() {
        RReadWriteLock lock = redission.getReadWriteLock("rw_lock");
        RLock rLock = lock.readLock();
        String s = "";
        rLock.lock();
        try {
            System.out.println("读锁加锁成功..." + Thread.currentThread().getId());
            s = (String) redisTemplate.opsForValue().get("writeValue");
            try { TimeUnit.SECONDS.sleep(3); } catch (InterruptedException e) { e.printStackTrace(); }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            rLock.unlock();
            System.out.println("读锁释放..." + Thread.currentThread().getId());
        }
        return s;
    }

来看下官网的解释

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-78BNd7tK-1684464779557)(images/谷粒商城项目笔记/image-20201101053042268.png)]

4、Redisson - 闭锁测试

官网！！！

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-AH6aLyTW-1684464779557)(images/谷粒商城项目笔记/image-20201101053053554.png)]

上代码

/**
 * 放假锁门
 * 1班没人了
 * 5个班级走完，我们可以锁们了
 * @return
 */
@GetMapping("/lockDoor")
@ResponseBody
public String lockDoor() throws InterruptedException {
    RCountDownLatch door = redission.getCountDownLatch("door");
    door.trySetCount(5);
    door.await();//等待闭锁都完成

    return "放假了....";
}
@GetMapping("/gogogo/{id}")
@ResponseBody
public String gogogo(@PathVariable("id") Long id) {
    RCountDownLatch door = redission.getCountDownLatch("door");
    door.countDown();// 计数器减一

    return id + "班的人走完了.....";
}

和 JUC 的 CountDownLatch 一致

await()等待闭锁完成

countDown() 把计数器减掉后 await就会放行

5、Redisson - 信号量测试

官网！！！

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-siFzJljP-1684464779558)(images/谷粒商城项目笔记/image-20201101053450708.png)]

/**
 * 车库停车
 * 3车位
 * @return
 */
@GetMapping("/park")
@ResponseBody
public String park() throws InterruptedException {
    RSemaphore park = redission.getSemaphore("park");
    boolean b = park.tryAcquire();//获取一个信号，获取一个值，占用一个车位

    return "ok=" + b;
}

@GetMapping("/go")
@ResponseBody
public String go() {
    RSemaphore park = redission.getSemaphore("park");

    park.release(); //释放一个车位

    return "ok";
}

类似 JUC 中的 Semaphore

缓存数据一致性

缓存数据一致性 - 双写模式

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-SzujftcI-1684464779558)(images/谷粒商城项目笔记/image-20201101053613373.png)]

两个线程写最终只有一个线程写成功，后写成功的会把之前写的数据给覆盖，这就会造成脏数据

缓存数据一致性 - 失效模式

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-0ZpmefIo-1684464779558)(images/谷粒商城项目笔记/image-20201101053834126.png)]

三个连接

一号连接写数据库然后删缓存

二号连接写数据库时网络连接慢，还没有写入成功

三号链接直接读取数据，读到的是一号连接写入的数据，此时二号链接写入数据成功并删除了缓存，三号开始更新缓存发现更新的是二号的缓存

缓存数据一致性解决方案

无论是双写模式还是失效模式，都会到这缓存不一致的问题，即多个实力同时更新会出事，怎么办？

1、如果是用户纯度数据（订单数据、用户数据），这并发几率很小，几乎不用考虑这个问题，缓存数据加上过期时间，每隔一段时间触发读的主动更新即可
2、如果是菜单，商品介绍等基础数据，也可以去使用 canal 订阅，binlog 的方式
3、缓存数据 + 过期时间也足够解决大部分业务对缓存的要求
4、通过加锁保证并发读写，写写的时候按照顺序排好队，读读无所谓，所以适合读写锁，（业务不关心脏数据，允许临时脏数据可忽略）

总结:

我们能放入缓存的数据本来就不应该是实时性、一致性要求超高的。所以缓存数据的时候加上过期时间，保证每天拿到当前的最新值即可
我们不应该过度设计，增加系统的复杂性
遇到实时性、一致性要求高的数据，就应该查数据库，即使慢点

最后符上三级分类数据加上分布式锁

Spring Cache

1、简介

Spring 从3.1开始定义了 org.springframework.cache.Cache 和 org.sprngframework.cache.CacheManager 接口睐统一不同的缓存技术
并支持使用 JCache（JSR-107）注解简化我们的开发
Cache 接口为缓存的组件规范定义，包含缓存的各种操作集合 Cache 接口下 Spring 提供了各种 XXXCache的实现，如 RedisCache、EhCache,ConcrrentMapCache等等，
每次调用需要缓存功能实现方法的时候，Spring 会检查检查指定参数的马努表犯法是否已经被嗲用过，如果有就直接从缓存中获取方法调用后的结果，如果没有就调用方法并缓存结果后返回给用户，下次直接调用从缓存中获取
使用 Sprng 缓存抽象时我们需要关注的点有以下两点
- 1、确定方法需要被缓存以及他们的的缓存策略
- 2、从缓存中读取之前缓存存储的数据

官网地址：https://docs.spring.io/spring-framework/docs/5.2.10.RELEASE/spring-framework-reference/integration.html#cache-strategie

缓存注解配置

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-SudDETQU-1684464779559)(images/谷粒商城项目笔记/image-20201228171806703-16555137421881.png)]

2、基础概念

从3.1版本开始，Spring 框架就支持透明地向现有 Spring 应用程序添加缓存。与事务支持类似，缓存抽象允许在对代码影响最小的情况下一致地使用各种缓存解决方案。从 Spring 4.1 开始，缓存抽象在JSR-107注释和更多定制选项的支持下得到了显著扩展。

 /**
 *  8、整合SpringCache简化缓存开发
 *      1、引入依赖
 *          spring-boot-starter-cache
 *      2、写配置
 *          1、自动配置了那些
 *              CacheAutoConfiguration会导入 RedisCacheConfiguration
 *              自动配置好了缓存管理器，RedisCacheManager
 *          2、配置使用redis作为缓存
 *          Spring.cache.type=redis
 *
 *       4、原理
 *       CacheAutoConfiguration ->RedisCacheConfiguration ->
 *       自动配置了 RedisCacheManager ->初始化所有的缓存 -> 每个缓存决定使用什么配置
 *       ->如果redisCacheConfiguration有就用已有的，没有就用默认的
 *       ->想改缓存的配置，只需要把容器中放一个 RedisCacheConfiguration 即可
 *       ->就会应用到当前 RedisCacheManager管理所有缓存分区中
 */

3、注解

对于缓存声明，Spring的缓存抽象提供了一组Java注解

/**
@Cacheable: Triggers cache population:触发将数据保存到缓存的操作
@CacheEvict: Triggers cache eviction: 触发将数据从缓存删除的操作
@CachePut: Updates the cache without interfering with the method execution:不影响方法执行更新缓存
@Caching: Regroups multiple cache operations to be applied on a method:组合以上多个操作
@CacheConfig: Shares some common cache-related settings at class-level:在类级别共享缓存的相同配置
**/

注解使用

com.atguigu.gulimall.product.service.impl.CategoryServiceImpl#getLevel1Categorys

/**
     * 1、每一个需要缓存的数据我们都需要指定放到那个名字的缓存【缓存分区的划分【按照业务类型划分】】
     * 2、@Cacheable({"category"})
     *      代表当前方法的结果需要缓存，如果缓存中有，方法不调用
     *      如果缓存中没有，调用方法，最后将方法的结果放入缓存
     * 3、默认行为:
     *      1、如果缓存中有，方法不用调用
     *      2、key默自动生成，缓存的名字:SimpleKey[](自动生成的key值)
     *      3、缓存中value的值，默认使用jdk序列化，将序列化后的数据存到redis
     *      3、默认的过期时间，-1
     *
     *    自定义操作
     *      1、指定缓存使用的key     key属性指定，接收一个SpEl
     *      2、指定缓存数据的存活时间  配置文件中修改ttl
     *      3、将数据保存为json格式
     * @return
     */
	//value 缓存的别名
     // key redis中key的名称，默认是方法名称
    @Cacheable(value = {"category"},key = "#root.method.name")
    @Override
    public List<CategoryEntity> getLevel1Categorys() {
        long l = System.currentTimeMillis();
        // parent_cid为0则是一级目录
        List<CategoryEntity> categoryEntities = baseMapper.selectList(new QueryWrapper<CategoryEntity>().eq("parent_cid", 0));
        System.out.println("耗费时间：" + (System.currentTimeMillis() - l));
        return categoryEntities;
    }

4、表达式语法

配置

package com.atguigu.gulimall.product.config;

import org.springframework.boot.autoconfigure.cache.CacheProperties;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.cache.RedisCacheConfiguration;
import org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.RedisSerializationContext;
import org.springframework.data.redis.serializer.StringRedisSerializer;

/**
 * @author gcq
 * @Create 2020-11-01
 */
@EnableConfigurationProperties(CacheProperties.class)
@EnableCaching
@Configuration
public class MyCacheConfig {

    /**
     * 配置文件中的东西没有用上
     * 1、原来的配置吻技安绑定的配置类是这样子的
     *      @ConfigurationProperties(prefix = "Spring.cache")
     * 2、要让他生效
     *      @EnableConfigurationProperties(CacheProperties.class)
     * @param cacheProperties
     * @return
     */
    @Bean
    RedisCacheConfiguration redisCacheConfiguration(CacheProperties cacheProperties) {
        RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig();
        // 设置key的序列化
        config = config.serializeKeysWith(RedisSerializationContext.SerializationPair.fromSerializer(new StringRedisSerializer()));
        // 设置value序列化 ->JackSon
        config = config.serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(new GenericJackson2JsonRedisSerializer()));

        CacheProperties.Redis redisProperties = cacheProperties.getRedis();
        if (redisProperties.getTimeToLive() != null) {
            config = config.entryTtl(redisProperties.getTimeToLive());
        }
        if (redisProperties.getKeyPrefix() != null) {
            config = config.prefixKeysWith(redisProperties.getKeyPrefix());
        }
        if (!redisProperties.isCacheNullValues()) {
            config = config.disableCachingNullValues();
        }
        if (!redisProperties.isUseKeyPrefix()) {
            config = config.disableKeyPrefix();
        }
        return config;
    }

}

yaml

Spring:
  cache:
    type: redis
    redis:
      time-to-live: 3600000           # 过期时间
      key-prefix: CACHE_              # key前缀
      use-key-prefix: true            # 是否使用写入redis前缀
      cache-null-values: true         # 是否允许缓存空值

5、缓存穿透问题解决

/**
 * 1、每一个需要缓存的数据我们都需要指定放到那个名字的缓存【缓存分区的划分【按照业务类型划分】】
 * 2、@Cacheable({"category"})
 *      代表当前方法的结果需要缓存，如果缓存中有，方法不调用
 *      如果缓存中没有，调用方法，最后将方法的结果放入缓存
 * 3、默认行为:
 *      1、如果缓存中有，方法不用调用
 *      2、key默自动生成，缓存的名字:SimpleKey[](自动生成的key值)
 *      3、缓存中value的值，默认使用jdk序列化，将序列化后的数据存到redis
 *      3、默认的过期时间，-1
 *
 *    自定义操作
 *      1、指定缓存使用的key     key属性指定，接收一个SpEl
 *      2、指定缓存数据的存活时间  配置文件中修改ttl
 *      3、将数据保存为json格式
 * 4、Spring-Cache的不足：
 *      1、读模式：
 *          缓存穿透:查询一个null数据，解决 缓存空数据：ache-null-values=true
 *          缓存击穿:大量并发进来同时查询一个正好过期的数据，解决:加锁 ？ 默认是无加锁
 *          缓存雪崩:大量的key同时过期，解决：加上随机时间，Spring-cache-redis-time-to-live
 *       2、写模式：（缓存与数据库库不一致）
 *          1、读写加锁
 *          2、引入canal，感知到MySQL的更新去更新数据库
 *          3、读多写多，直接去数据库查询就行
 *
 *    总结：
 *      常规数据（读多写少，即时性，一致性要求不高的数据）完全可以使用SpringCache 写模式（ 只要缓存数据有过期时间就足够了）
 *
 *    特殊数据：特殊设计
 *      原理：
 *          CacheManager(RedisManager) -> Cache(RedisCache) ->Cache负责缓存的读写
 * @return
 */
@Cacheable(value = {"category"},key = "#root.method.name",sync = true)
@Override
public List<CategoryEntity> getLevel1Categorys() {
    long l = System.currentTimeMillis();
    // parent_cid为0则是一级目录
    List<CategoryEntity> categoryEntities = baseMapper.selectList(new QueryWrapper<CategoryEntity>().eq("parent_cid", 0));
    System.out.println("耗费时间：" + (System.currentTimeMillis() - l));
    return categoryEntities;
}

6、缓存更新

com.atguigu.gulimall.product.service.impl.CategoryServiceImpl#updateCascade

/**
     * 级联更新所有的关联数据
     * @CacheEvict 失效模式
     * 1、同时进行多种缓存操作 @Caching
     * 2、指定删除某个分区下的所有数据 @CacheEvict(value = {"category"},allEntries = true)
     * 3、存储同一类型的数据，都可以指定成同一分区，分区名默认就是缓存的前缀
     *
     * @param category
     */
    @Caching(evict = {
            @CacheEvict(value = {"category"},key = "'getLevel1Categorys'"),
            @CacheEvict(value = {"category"},key = "'getCatelogJson'")
    })
//    @CacheEvict(value = {"category"},allEntries = true)
    @Transactional
    @Override
    public void updateCascate(CategoryEntity category) {
        // 更新自己表对象
        this.updateById(category);
        // 更新关联表对象
        categoryBrandRelationService.updateCategory(category.getCatId(), category.getName());
    }

总结业务流程：

如果忘了这个技术点看下做的笔记的例子，然后去官网看下文档，温故而知新

流程图

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-fdORvY5H-1684464779559)(images/谷粒商城项目笔记/image-20201228171552816-16555137421892.png)]

检索服务

在虚拟机新建search文件夹
```
mkdir /mydata/nginx/html/static/search
```
将 html\搜索页目录下的所有内容放入该目录下

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-NaxzENjI-1684464779560)(images/谷粒商城项目笔记/image-20220618101539423.png)]
启动search服务
配置 Windows hosts 文件
```
192.168.91.100		search.gulimall.com
```
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-CrC33TLt-1684464779560)(images/谷粒商城项目笔记/image-20220618102202062.png)]

进入配置文件

cd mydata/nginx/conf/conf.d

vi gulimall.conf

修改配置文件

server {
    listen       80;
    server_name  gulimall.com *.gulimall.com;
		...
 }

重启nginx
```
docker restart nginx
```
2
2
2

找到 Nginx 的配置文件，编辑 gulimall.conf，将所有 *.gulimall.com 的请求都经由 Nginx 转发给网关；

server {
    listen       80;
    server_name  search.gulimall.com gulimall.com;
		...
 }

然后重启 Nginx

docker restart nginx

配置网关服务转发到 search 服务

- id: mall_search_route
  uri: lb://mall-search
  predicates:
  - Host=search.gulimall.com

配置页面跳转

配置 /list.html 请求转发到 list 模板

/**
 * 自动将页面提交过来的所有请求参数封装成我们指定的对象
 *
 * @param param
 * @return
 */
@GetMapping(value = "/list.html")
public String listPage(SearchParam param, Model model, HttpServletRequest request) {
    return "list";
}

检索功能实现

添加模板页面


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

将资料中的前端页面放到 search 服务模块下的 resource/templates 下；

配置请求跳转

配置 Nginx 转发

配置 Windows hosts 文件：

192.168.56.100		search.gulimall.com

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-O4P4KFUz-1684464779560)(images/谷粒商城项目笔记/image-20220512132128091.png)]

异步和线程池

初始化线程的 4 种方式

1、继承 Thread

2、实现 Runnable

3、实现 Callable 接口 + FutureTask（可以拿到返回结果，可以处理异常）

4、线程池

方式一和方式二主进程无法获取线程的运算结果，不适合当前场景

方式三：主进程可以获取当前线程的运算结果，但是不利于控制服务器种的线程资源，可以导致服务器资源耗尽

方式四：通过如下两种方式初始化线程池

Executors.newFixedThreadPool(3);
//或者
new ThreadPollExecutor(corePoolSize,maximumPoolSize,keepAliveTime,TimeUnit,unit,workQueue,threadFactory,handler);

通过线程池性能稳定，也可以获取执行结果，并捕获异常，但是，在业务复杂情况下，一个异步调用可能会依赖另一个异步调用的执行结果

线程池的 7 大参数

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-bVjmoNnV-1684464779561)(images/谷粒商城项目笔记/image-20201105154808826.png)]

运行流程：

1、线程池创建，准备好 core 数量的核心线程，准备接受任务

2、新的任务进来，用 core 准备好的空闲线程执行

core 满了，就将再进来的任务放入阻塞队列中，空闲的 core 就会自己去阻塞队列获取任务执行
阻塞队列也满了，就直接开新线程去执行，最大只能开到 max 指定的数量
max 都执行好了，Max-core 数量空闲的线程会在 keepAliveTime 指定的时间后自动销毁，终保持到 core 大小
如果线程数开到了 max 数量，还有新的任务进来，就会使用 reject 指定的拒绝策略进行处理

3、所有的线程创建都是由指定的 factory 创建的

面试;

一个线程池 core 7、max 20 ，queue 50 100 并发进来怎么分配的 ?

先有 7 个能直接得到运行，接下来 50 个进入队列排队，再多开 13 个继续执行，线程70个被安排上了，剩下30个默认拒绝策略

常见的 4 种线程池

```
newCacheThreadPool
```
- 创建一个可缓存的线程池，如果线程池长度超过需要，可灵活回收空闲线程，若无可回收，则新建线程
```
newFixedThreadPool
```
- 创建一个指定长度的线程池，可控制线程最大并发数，超出的线程会再队列中等待
```
newScheduleThreadPool
```
- 创建一个定长线程池，支持定时及周期性任务执行
```
newSingleThreadExecutor
```
- 创建一个单线程化的线程池，她只会用唯一的工作线程来执行任务，保证所有任务

开发中为什么使用线程池

降低资源的消耗
- 通过重复利用已创建好的线程降低线程的创建和销毁带来的损耗
提高响应速度
- 因为线程池中的线程没有超过线程池的最大上限时，有的线程处于等待分配任务的状态，当任务来时无需创建新的线程就能执行
提高线程的客观理性
- 线程池会根据当前系统的特点对池内的线程进行优化处理，减少创建和销毁线程带来的系统开销，无限的创建和销毁线程不仅消耗系统资源，还降低系统的稳定性，使用线程池进行统一分配

CompletableFuture 异步编排

业务场景：

查询商品详情页逻辑比较复杂，有些数据还需要远程调用，必然需要花费更多的时间

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-eySYWXvD-1684464779561)(images/谷粒商城项目笔记/image-20201105163535757.png)]

假如商品详情页的每个查询，需要如下标注时间才能完成

那么，用户需要5.5s后才能看到商品相详情页的内容，很显然是不能接受的

如果有多个线程同时完成这 6 步操作，也许只需要 1.5s 即可完成响应

创建异步对象

CompletableFuture 提供了四个静态方法来创建一个异步操作

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-iqmpROZc-1684464779561)(images/谷粒商城项目笔记/image-20201105185420349.png)]

1、runXxx 都是没有返回结果的，supplyXxxx都是可以获取返回结果的

2、可以传入自定义的线程池，否则就是用默认的线程池

3、根据方法的返回类型来判断是否该方法是否有返回类型

代码实现：

  public static void main(String[] args) throws ExecutionException, InterruptedException {
        System.out.println("main....start.....");
        CompletableFuture<Void> completableFuture = CompletableFuture.runAsync(() -> {
            System.out.println("当前线程：" + Thread.currentThread().getId());
            int i = 10 / 2;
            System.out.println("运行结果：" + i);
        }, executor);

        CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> {
            System.out.println("当前线程：" + Thread.currentThread().getId());
            int i = 10 / 2;
            System.out.println("运行结果：" + i);
            return i;
        }, executor);
        Integer integer = future.get();

        System.out.println("main....stop....." + integer);
    }

计算完成时回调方法

[外链图片转存中…(img-3QZWzFK7-1684464779561)]

whenComplete 可以处理正常和异常的计算结果，exceptionally 处理异常情况

whenComplete 和 whenCompleteAsync 的区别

whenComplete ：是执行当前任务的线程继续执行 whencomplete 的任务

whenCompleteAsync：是执行把 whenCompleteAsync 这个任务继续提交给线程池来进行执行

方法不以 Async 结尾，意味着 Action 使用相同的线程执行，而 Async 可能会使用其他线程执行（如果是使用相同的线程池，也可能会被同一个线程选中执行）

CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> {
    System.out.println("当前线程：" + Thread.currentThread().getId());
    int i = 10 / 0;
    System.out.println("运行结果：" + i);
    return i;
}, executor).whenComplete((res,exception) ->{
    // 虽然能得到异常信息，但是没法修改返回的数据
    System.out.println("异步任务成功完成了...结果是：" +res + "异常是：" + exception);
}).exceptionally(throwable -> {
    // 可以感知到异常，同时返回默认值
    return 10;
});

handle 方法

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-HflXsQQl-1684464779562)(images/谷粒商城项目笔记/image-20201105194503175.png)]

和 complete 一样，可以对结果做最后的处理（可处理异常），可改变返回值

CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> {
    System.out.println("当前线程：" + Thread.currentThread().getId());
    int i = 10 / 2;
    System.out.println("运行结果：" + i);
    return i;
}, executor).handle((res,thr) ->{
    if (res != null ) {
        return res * 2;
    }
    if (thr != null) {
        return 0;
    }
    return 0;
});

线程串行方法

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-4o9W7iqH-1684464779562)(images/谷粒商城项目笔记/image-20201105195632819.png)]

thenApply 方法：当一个线程依赖另一个线程时，获取上一个任务返回的结果，并返回当前任物的返回值

thenAccept方法：消费处理结果，接受任务处理结果，并消费处理，无返回结果

thenRun 方法：只要上面任务执行完成，就开始执行 thenRun ,只是处理完任务后，执行 thenRun的后续操作

带有 Async 默认是异步执行的，同之前，

以上都要前置任务完成

   /**
         * 线程串行化，
         * 1、thenRun:不能获取到上一步的执行结果，无返回值
         * .thenRunAsync(() ->{
         *             System.out.println("任务2启动了....");
         *         },executor);
         * 2、能接受上一步结果，但是无返回值 thenAcceptAsync
         * 3、thenApplyAsync 能收受上一步结果，有返回值
         *
         */
        CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
            System.out.println("当前线程：" + Thread.currentThread().getId());
            int i = 10 / 2;
            System.out.println("运行结果：" + i);
            return i;
        }, executor).thenApplyAsync(res -> {
            System.out.println("任务2启动了..." + res);
            return "Hello " + res;
        }, executor);
        String s = future.get();

        System.out.println("main....stop....." + s);

两任务组合 - 都要完成

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-cnDAALxl-1684464779562)(images/谷粒商城项目笔记/image-20210102044028142.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-KDtM1DNK-1684464779562)(images/谷粒商城项目笔记/image-20210102044044914.png)]

两个任务必须都完成，触发该任务

thenCombine: 组合两个 future，获取两个 future的返回结果，并返回当前任务的返回值

thenAccpetBoth: 组合两个 future，获取两个 future 任务的返回结果，然后处理任务，没有返回值

runAfterBoth:组合两个 future，不需要获取 future 的结果，只需要两个 future处理完成任务后，处理该任务，

   /**
         * 两个都完成
         */
        CompletableFuture<Integer> future01 = CompletableFuture.supplyAsync(() -> {
            System.out.println("任务1当前线程：" + Thread.currentThread().getId());
            int i = 10 / 4;
            System.out.println("任务1结束：" + i);
            return i;
        }, executor);

        CompletableFuture<String> future02 = CompletableFuture.supplyAsync(() -> {
            System.out.println("任务2当前线程：" + Thread.currentThread().getId());
            System.out.println("任务2结束：");
            return "Hello";
        }, executor);

        // f1 和 f2 执行完成后在执行这个
//        future01.runAfterBothAsync(future02,() -> {
//            System.out.println("任务3开始");
//        },executor);

        // 返回f1 和 f2 的运行结果
//        future01.thenAcceptBothAsync(future02,(f1,f2) -> {
//            System.out.println("任务3开始....之前的结果:" + f1 + "==>" + f2);
//        },executor);

        // f1 和 f2 单独定义返回结果
        CompletableFuture<String> future = future01.thenCombineAsync(future02, (f1, f2) -> {
            return f1 + ":" + f2 + "-> Haha";
        }, executor);

        System.out.println("main....end....." + future.get());

两任务组合 - 一个完成

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-54dm2QvE-1684464779563)(images/谷粒商城项目笔记/image-20201106101904880.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-lW9C68FO-1684464779563)(images/谷粒商城项目笔记/image-20201106101918013.png)]

当两个任务中，任意一个future 任务完成时，执行任务

applyToEither;两个任务有一个执行完成，获取它的返回值，处理任务并有新的返回值

acceptEither: 两个任务有一个执行完成，获取它的返回值，处理任务，没有新的返回值

runAfterEither:两个任务有一个执行完成，不需要获取 future 的结果，处理任务，也没有返回值

/**
         * 两个任务，只要有一个完成，我们就执行任务
         * runAfterEnitherAsync：不感知结果，自己没有返回值
         * acceptEitherAsync：感知结果，自己没有返回值
         *  applyToEitherAsync：感知结果，自己有返回值
         */
//        future01.runAfterEitherAsync(future02,() ->{
//            System.out.println("任务3开始...之前的结果:");
//        },executor);

//        future01.acceptEitherAsync(future02,(res) -> {
//            System.out.println("任务3开始...之前的结果:" + res);
//        },executor);

        CompletableFuture<String> future = future01.applyToEitherAsync(future02, res -> {
            System.out.println("任务3开始...之前的结果：" + res);
            return res.toString() + "->哈哈";
        }, executor);

多任务组合

[外链图片转存中…(img-ZTm2KXj6-1684464779563)]

allOf：等待所有任务完成

anyOf:只要有一个任务完成

        CompletableFuture<String> futureImg = CompletableFuture.supplyAsync(() -> {
            System.out.println("查询商品的图片信息");
            return "hello.jpg";
        });

        CompletableFuture<String> futureAttr = CompletableFuture.supplyAsync(() -> {
            System.out.println("查询商品的属性");
            return "黑色+256G";
        });

        CompletableFuture<String> futureDesc = CompletableFuture.supplyAsync(() -> {
            try { TimeUnit.SECONDS.sleep(3); } catch (InterruptedException e) { e.printStackTrace(); }
            System.out.println("查询商品介绍");
            return "华为";
        });

        // 等待全部执行完
//        CompletableFuture allOf = CompletableFuture.allOf(futureImg, futureAttr, futureDesc);
//        allOf.get();

        // 只需要有一个执行完
        CompletableFuture<Object> anyOf = CompletableFuture.anyOf(futureImg, futureAttr, futureDesc);
        anyOf.get();
        System.out.println("main....end....." + anyOf.get());

商品业务 & 认证服务

环境搭建

修改host文件

192.168.91.100		item.gulimall.com
192.168.91.100		auth.gulimall.com

[外链图片转存中…(img-V8Fq96us-1684464779564)]

上传商品详情页资源文件
- 新建文件夹
```
cd /mydata/nginx/html/static

mkdir item
```
- 上传资源
  
  [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Niq2rUZg-1684464779564)(images/谷粒商城项目笔记/image-20220619185729846.png)]
上传登录注册页资源文件
- 新建文件夹
```
cd /mydata/nginx/html/static

mkdir login

mkdir reg
```
- 上传资源文件
  
  [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-GQZghHhH-1684464779564)(images/谷粒商城项目笔记/image-20220620190134368.png)]
  
  [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-X8ldEUZn-1684464779564)(images/谷粒商城项目笔记/image-20220620190217887.png)]

整合短信验证码

1、短信验证我们选择的是阿里云的短信服务

https://market.aliyun.com/products/57124001/cmapi00037170.html?spm=5176.730005.result.4.6276123eDrvPdz&innerSource=search_%E4%B8%89%E7%BD%91%E7%9F%AD%E4%BF%A1%E6%8E%A5%E5%8F%A3#sku=yuncode3117000001

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Sv3rwQb9-1684464779565)(images/谷粒商城项目笔记/image-20220620193819698.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-OqJfQtnI-1684464779565)(images/谷粒商城项目笔记/image-20220620194026673.png)]

[外链图片转存中…(img-kComzpoD-1684464779565)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-WwwfeU7D-1684464779565)(images/谷粒商城项目笔记/image-20220620194214068.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-GlXebTP5-1684464779565)(images/谷粒商城项目笔记/image-20220620194243185.png)]

往下翻

[外链图片转存中…(img-STvfMBNw-1684464779566)]

点击去调试

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-BMEROylG-1684464779566)(images/谷粒商城项目笔记/image-20220620195327734.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-prLwXewf-1684464779566)(images/谷粒商城项目笔记/image-20220620195421316.png)]

[外链图片转存中…(img-SOuyL1mf-1684464779566)]

使用postman调试

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-x0xsqH58-1684464779567)(images/谷粒商城项目笔记/image-20220620201003988.png)]

[外链图片转存中…(img-vXXRJadB-1684464779567)]

点击Send 手机就会接收到验证码。

下面有使用java发送验证码：

[外链图片转存中…(img-i1jbPTJD-1684464779567)]

[外链图片转存中…(img-IU1MG0XO-1684464779568)]

[外链图片转存中…(img-EKu0By8Q-1684464779568)]

2、选择对应短信服务进行开通

在云市场就能看到购买的服务

[外链图片转存中…(img-g761hPPU-1684464779568)]

3、验证短信功能是否能发送

在购买短信的页面，能进行调试短信

[外链图片转存中…(img-e9zZJxQn-1684464779569)]

输入对应手机号，appCode 具体功能不做演示

[外链图片转存中…(img-8ztC0m7z-1684464779569)]

4、使用 Java 测试短信是否能进行发送

往下拉找到对应 Java 代码

注意：

服务商提供的接口地址，请求参数都不同，请参考服务商提供的测试代码

@Test
public void contextLoads() {
   String host = "http://dingxin.market.alicloudapi.com";
	    String path = "/dx/sendSms";
	    String method = "POST";
	    String appcode = "你自己的AppCode";
	    Map<String, String> headers = new HashMap<String, String>();
	    //最后在header中的格式(中间是英文空格)为Authorization:APPCODE 83359fd73fe94948385f570e3c139105
	    headers.put("Authorization", "APPCODE " + appcode);
	    Map<String, String> querys = new HashMap<String, String>();
	    querys.put("mobile", "159xxxx9999");
	    querys.put("param", "code:1234");
	    querys.put("tpl_id", "TP1711063");
	    Map<String, String> bodys = new HashMap<String, String>();


	    try {
	    	/**
	    	* 重要提示如下:
	    	* HttpUtils请从
	    	* https://github.com/aliyun/api-gateway-demo-sign-java/blob/master/src/main/java/com/aliyun/api/gateway/demo/util/HttpUtils.java
	    	* 下载
	    	*
	    	* 相应的依赖请参照
	    	* https://github.com/aliyun/api-gateway-demo-sign-java/blob/master/pom.xml
	    	*/
	    	HttpResponse response = HttpUtils.doPost(host, path, method, headers, querys, bodys);
	    	System.out.println(response.toString());
	    	//获取response的body
	    	//System.out.println(EntityUtils.toString(response.getEntity()));
	    } catch (Exception e) {
	    	e.printStackTrace();
	    }
}

需要导入对应工具类，参照注释就行

验证码防刷校验

用户要是一直提交验证码

前台：限制一分钟后提交
后台：存入redis 如果有就返回

/**
 * 发送短信验证码
 * @param phone 手机号
 * @return
 */
@GetMapping("/sms/sendCode")
@ResponseBody
public R sendCode(@RequestParam("phone") String phone) {
    // TODO 1、接口防刷
    // 先从redis中拿取
    String redisCode = redisTemplate.opsForValue().get(AuthServerConstant.SMS_CODE_CACHE_PREFIX + phone);
    if(!StringUtils.isEmpty(redisCode)) {
        // 拆分
        long l = Long.parseLong(redisCode.split("_")[1]);
        // 当前系统事件减去之前验证码存入的事件 小于60000毫秒=60秒
        if (System.currentTimeMillis() -l < 60000) {
            // 60秒内不能再发
            R.error(BizCodeEnume.SMS_CODE_EXCEPTION.getCode(),BizCodeEnume.SMS_CODE_EXCEPTION.getMsg());
        }
    }
    // 2、验证码的再次效验
    // 数据存入 =》redis key-phone value - code sms:code:131xxxxx - >45678
    String code = UUID.randomUUID().toString().substring(0,5).toUpperCase();
    // 拼接验证码
    String substring = code+"_" + System.currentTimeMillis();
    // redis缓存验证码 防止同一个phone在60秒内发出多次验证吗
    redisTemplate.opsForValue().set(AuthServerConstant.SMS_CODE_CACHE_PREFIX+phone,substring,10, TimeUnit.MINUTES);

    // 调用第三方服务发送验证码
    thirdPartFeignService.sendCode(phone,code);
    return R.ok();
}

一步一坑注册页环境

1、编写 vo 接收页面提交

使用到了 JSR303校验

/**
 * 注册数据封装Vo
 * @author gcq
 * @Create 2020-11-09
 */
@Data
public class UserRegistVo {
    @NotEmpty(message = "用户名必须提交")
    @Length(min = 6,max = 18,message = "用户名必须是6-18位字符")
    private String userName;

    @NotEmpty(message = "密码必须填写")
    @Length(min = 6,max = 18,message = "密码必须是6-18位字符")
    private String password;

    @NotEmpty(message = "手机号码必须提交")
    @Pattern(regexp = "^[1]([3-9])[0-9]{9}$",message = "手机格式不正确")
    private String phone;

    @NotEmpty(message = "验证码必须填写")
    private String code;
}

2、页面提交数据与Vo一致

设置 name 属性与 Vo 一致，方便将传递过来的数据转换成 JSON

[外链图片转存中…(img-VSkKU6A2-1684464779569)]

3、数据校验

/**
 * //TODO 重定向携带数据，利用session原理，将数据放在session中，
 * 只要跳转到下一个页面取出这个数据，session中的数据就会删掉
 * //TODO分布式下 session 的问题
 * RedirectAttributes redirectAttributes 重定向携带数据
 * redirectAttributes.addFlashAttribute("errors", errors); 只能取一次
 * @param vo 数据传输对象
 * @param result 用于验证参数
 * @param redirectAttributes 数据重定向
 * @return
 */
@PostMapping("/regist")
public String regist(@Valid UserRegistVo vo, BindingResult result,
                     RedirectAttributes redirectAttributes) {
    // 校验是否通过
    if (result.hasErrors()) {
        // 拿到错误信息转换成Map
        Map<String, String> errors = result.getFieldErrors().stream().collect(Collectors.toMap(FieldError::getField, FieldError::getDefaultMessage));
        //用一次的属性
        redirectAttributes.addFlashAttribute("errors",errors);
        // 校验出错，转发到注册页
        return "redirect:http://auth.gulimall.com/reg.html";
    }

    // 将传递过来的验证码 与 存redis中的验证码进行比较
    String code = vo.getCode();
    String s = redisTemplate.opsForValue().get(AuthServerConstant.SMS_CODE_CACHE_PREFIX + vo.getPhone());
    if (!StringUtils.isEmpty(s)) {
        // 验证码和redis中的一致
        if(code.equals(s.split("_")[0])) {
            // 删除验证码：令牌机制
            redisTemplate.delete(AuthServerConstant.SMS_CODE_CACHE_PREFIX + vo.getPhone());
            // 调用远程服务，真正注册
            R r = memberFeignService.regist(vo);
            if (r.getCode() == 0) {
                // 远程调用注册服务成功
                return "redirect:http://auth.gulimall.com/login.html";
            } else {
                Map<String, String> errors = new HashMap<>();
                errors.put("msg",r.getData(new TypeReference<String>(){}));
                redirectAttributes.addFlashAttribute("errors", errors);
                return "redirect:http://auth.gulimall.com/reg.html";
            }
        } else {
            Map<String, String> errors = new HashMap<>();
            errors.put("code", "验证码错误");
            redirectAttributes.addFlashAttribute("code", "验证码错误");
            // 校验出错，转发到注册页
            return "redirect:http://auth.gulimall.com/reg.html";
        }
    } else {
        Map<String, String> errors = new HashMap<>();
        errors.put("code", "验证码错误");
        redirectAttributes.addFlashAttribute("code", "验证码错误");
        // 校验出错，转发到注册页
        return "redirect:http://auth.gulimall.com/reg.html";
    }
}

4、前端页面接收错误信息

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-NK7Uss1J-1684464779570)(images/谷粒商城项目笔记/image-20201110101306173.png)]

5、异常机制 & 用户注册

用户注册单独抽出了一个服务

Controller

/**
 * 注册
 * @param registVo
 * @return
 */
@PostMapping("/regist")
public R regist(@RequestBody MemberRegistVo registVo) {
    try {
        memberService.regist(registVo);
    } catch (PhoneExsitException e) {
        // 返回对应的异常信息
       return R.error(BizCodeEnume.PHONE_EXIST_EXCEPTION.getCode(),BizCodeEnume.PHONE_EXIST_EXCEPTION.getMsg());
    } catch (UserNameExistException e) {
        return R.error(BizCodeEnume.USER_EXIST_EXCEPTION.getCode(),BizCodeEnume.USER_EXIST_EXCEPTION.getMsg());
    }
    return R.ok();
}
@Override
public void regist(MemberRegistVo registVo) {
    MemberDao memberDao = this.baseMapper;
    MemberEntity entity = new MemberEntity();

    // 设置默认等级
    MemberLevelEntity memberLevelEntity = memberLevelDao.getDefaultLevel();
    entity.setLevelId(memberLevelEntity.getId());


    // 检查手机号和用户名是否唯一
    checkPhoneUnique(registVo.getPhone());
    checkUserNameUnique(registVo.getUserName());

    entity.setMobile(registVo.getPhone());
    entity.setUsername(registVo.getUserName());

    //密码要加密存储
    BCryptPasswordEncoder passwordEncoder = new BCryptPasswordEncoder();
    String encode = passwordEncoder.encode(registVo.getPassword());
    entity.setPassword(encode);

    memberDao.insert(entity);
}

@Override
public void checkPhoneUnique(String phone) throws PhoneExsitException {
    MemberDao memberDao = this.baseMapper;
    Integer mobile = memberDao.selectCount(new QueryWrapper<MemberEntity>().eq("mobile", phone));
    if (mobile > 0) {
        throw new PhoneExsitException();
    }
}

@Override
public void checkUserNameUnique(String username) throws UserNameExistException {
    MemberDao memberDao = this.baseMapper;
    Integer count = memberDao.selectCount(new QueryWrapper<MemberEntity>().eq("username", username));
    if (count > 0) {
        throw new PhoneExsitException();
    }
}

此处引入一个问题

密码是直接存入数据库吗？这样子会导致数据的不安全，
引出了使用 MD5进行加密，但是MD5加密后，别人任然可以暴力破解
可以使用加盐的方式，将密码加密后，得到一串随机字符，
随机字符和密码和进行验证相同结果返回true否则false

至此注册相关结束~

账号密码登录

1、定义 Vo 接收数据提交

/**
 * @author gcq
 * @Create 2020-11-10
 */
@Data
public class UserLoginVo {
    private String loginacct;
    private String password;
}

同时需要保证前端页面提交字段与 Vo 类中一致

2、在 Member 服务中编写接口

@Override
public MemberEntity login(MemberLoginVo vo) {
    String loginacct = vo.getLoginacct();
    String password = vo.getPassword();

    // 1、去数据库查询 select * from  ums_member where username=? or mobile =?
    MemberDao memberDao = this.baseMapper;
    MemberEntity memberEntity = memberDao.selectOne(new QueryWrapper<MemberEntity>()
            .eq("username", loginacct).or().
                    eq("mobile", loginacct));
    if (memberDao == null) {
        // 登录失败
        return null;
    } else {
        // 获取数据库的密码
        String passwordDB = memberEntity.getPassword();
        BCryptPasswordEncoder passwordEncoder = new BCryptPasswordEncoder();
        // 和用户密码进行校验
        boolean matches = passwordEncoder.matches(password, passwordDB);
        if(matches) {
            // 密码验证成功 返回对象
            return memberEntity;
        } else {
            return null;
        }
    }
}

分布式 Session不共享不同步问题

我们在auth.gulimall.com中保存session，但是网址跳转到 gulimall.com中，取不出auth.gulimall.com中保存的session，这就造成了微服务下的session不同步问题

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-rwqrDfqk-1684464779570)(images/谷粒商城项目笔记/image-20201111103637615.png)]

1、Session同步解决方案-分布式下session共享问题

同一个服务复制多个，但是session还是只能在一个服务上保存，浏览器也是只能读取到一个服务的session

[外链图片转存中…(img-nciPpBQs-1684464779570)]

2、Session共享问题解决-session复制

[外链图片转存中…(img-0alkFR0A-1684464779570)]

3、Session共享问题解决-客户端存储

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-DBYzyhtl-1684464779571)(images/谷粒商城项目笔记/image-20201111104913888.png)]

4、Session共享问题解决-hash一致性

[外链图片转存中…(img-odP5VouD-1684464779571)]

5、Session共享问题解决-统一存储

[外链图片转存中…(img-FPQt9lrA-1684464779571)]

SpringSession整合

1、官网文档阅读

进入到 Spring Framework

[外链图片转存中…(img-9jrug9WN-1684464779572)]

2、选择Spring Session文档

[外链图片转存中…(img-CMsOAZbr-1684464779572)]

[外链图片转存中…(img-xU1xrIBS-1684464779572)]

3、开始使用Spring Session

[外链图片转存中…(img-rGtwvfmV-1684464779572)]

[外链图片转存中…(img-FQW8vZsZ-1684464779572)]

整合SpringBoot

1、添加Pom.xml依赖

https://docs.spring.io/spring-session/docs/2.5.0/reference/html5/#samples

auth 服务、product 服务、 search 服务 pom文件


<dependency>
  <groupId>org.springframework.sessiongroupId>
  <artifactId>spring-session-data-redisartifactId>
dependency>

2、application.yml 配置

spring:
  session:
    store-type: redis

**主启动类增加注解：@EnableRedisHttpSession **

3、reids配置

[外链图片转存中…(img-Wo4JUXnH-1684464779573)]

4、启动类加上如下注解

@EnableRedisHttpSession // 整合spring session

自定义 SpringSession 完成 Session 子域共享

`CookieSerializer`

api文档参考：https://docs.spring.io/spring-session/docs/2.4.1/reference/html5/index.html#api-cookieserializer

[外链图片转存中…(img-Hemiq2rO-1684464779573)]

指定redis序列化

文档地址：

https://docs.spring.io/spring-session/docs/2.4.1/reference/html5/index.html#api-redisindexedsessionrepository-config

[外链图片转存中…(img-aasYShtK-1684464779573)]

redis中json序列化

官网文档地址：https://docs.spring.io/spring-session/docs/2.4.1/reference/html5/index.html#samples

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-UUNGwEeS-1684464779574)(images/谷粒商城项目笔记/image-20210101125216426.png)]

提供的实例：

https://github.com/spring-projects/spring-session/blob/2.4.1/spring-session-samples/spring-session-sample-boot-redis-json/src/main/java/sample/config/SessionConfig.java

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-IIfbi8oF-1684464779574)(images/谷粒商城项目笔记/image-20210101125303807.png)]

/**
 * SpringSession整合子域
 * 以及redis数据存储为json
 * @author gcq
 * @Create 2020-11-11
 */
@Configuration
public class GulimallSessionConfig {

    /**
     * 设置cookie信息
     * @return
     */
    @Bean
    public CookieSerializer CookieSerializer(){
        DefaultCookieSerializer cookieSerializer = new DefaultCookieSerializer();
        // 设置一个域名的名字
        cookieSerializer.setDomainName("gulimall.com");
        // cookie的路径
        cookieSerializer.setCookieName("GULIMALLSESSION");
        return cookieSerializer;
    }

    /**
     * 设置json转换
     * @return
     */
    @Bean
    public RedisSerializer

谷粒商城详细笔记

前言

一、项目简介

1、项目微服务架构图

2、微服务划分图

二、开发

1、配置虚拟机

2、linux连接工具安装

3、虚拟机安装docker

1、创建/etc/docker文件夹

2、配置镜像加速

3、卸载旧版本

4、设置Docker仓库源地址

5、安装 Docker

6、启动Docker

7、设置为开机自启

3、docker安装mysql

1、拉取mysql镜像

2、运行mysql

3、创建&修改配置文件

4、重启mysql

5、设置自动启动

4、安装Redis

1、下载镜像文件

2、创建本地映射文件

3、修改映射配置文件内容

4、启动 同时 映射到对应文件夹

5、使用 redis 镜像执行 redis-cli 命令连接

6、重启Redis

7、设置为开机自启

8、安装redis-desktop-manager

8、统一开发环境

1、jdk至少是1.8

2、安装配置linux maven

3、配置win10 maven

4、安装vscode

5、配置git信息

6、初始化gitee

7、填充几大核心服务骨架

8、初始化数据库

9、逆向工程搭建

10、MybatisPlus整合

导入依赖

配置数据源

导入数据库驱动

在application.yml配置数据源相关信息

分页配置

逻辑删除

11、安装postman

9、SpringCloudAlibaba搭建

1、中文文档地址

2、版本选择

3、在common的pom.xml中加入

4、下载nacos

5、启动nacos

5、在服务配置文件中指定注册中心地址

6、使用 @EnableDiscoveryClient 注解开启服务注册与发现功能

7、查看注册结果

8、使用Feign进行远程调用

9、使用nacos做分布式配置中心

10、nacos配置中心进阶

10.1、命名空间

10.2、配置集

10.3、配置集ID

10.4、配置分组

11.5、同时加载多个配置集

11、Gateway网关

10、运行gateway服务

11、运行renren-fast服务

12、运行renren-fast-vue服务

启动虚拟机

7、运行thirdparty服务

8、运行product服务

9、运行ware服务

10、安装elasticsearch、kibana、ik分词器

11、配置nginx

开发

商品服务-三级分类

三级分类添加

解决跨域问题

4、启动同时映射到对应文件夹

基本属性【规格参数】与销售属性