## 1.互斥锁解决缓存击穿问题（setnx简单实践）

![image.png](/static/img/8481a20b40b2a9c5b22c079fb25e6702.image.webp)

java中redis实践

## 相关问题概览



![image.png](/static/img/bd4dd6dfe4564120df5e41a20356857d.image.webp)

## (1)Spring中的单例bean是线程安全的吗

![image.png](/static/img/46aede189a4e9ce7a5025a489e00a749.image.webp)

面试话术

![image.png](/static/img/1f95e9439dfb3211d9fdb34e1b618938.image.webp)

`1. Spring框架中的单例bean是线程安全的吗？
候选人：
不是线程安全的。当多用户同时请求一个服务时，容器会给每个请求分配一个线程，这些线程会并发执行业务逻辑。如果处理逻辑中包含对单例状态的修改，比如修改单例的成员属性，就必须考虑线程同步问题。Spring框架本身并不对单例bean进行线程安全封装，线程安全和并发问题需要开发者自行处理。
通常在项目中使用的Spring bean是不可变状态（如Service类和DAO类），因此在某种程度上可以说Spring的单例bean是线程安全的。如果bean有多种状态（如ViewModel对象），就需要自行保证线程安全。最简单的解决办法是将单例bean的作用域由“singleton”变更为“prototype”。`

## (2)什么是AOP

![image.png](/static/img/2a1e88eca97be07c4fdadb7b5f3ef9d1.image.webp)


![image.png](/static/img/e5f403b1a8aa1b5067fb8ceb01592ceb.image.webp)

面试话术

`2. 什么是AOP？
候选人：
AOP，即面向切面编程，在Spring中用于将那些与业务无关但对多个对象产生影响的公共行为和逻辑抽取出来，实现公共模块复用，降低耦合。常见的应用场景包括公共日志保存和事务处理。`

`3. 你们项目中有没有使用到AOP？
候选人：
我们之前在后台管理系统中使用AOP来记录系统操作日志。主要思路是使用AOP的环绕通知和切点表达式，找到需要记录日志的方法，然后通过环绕通知的参数获取请求方法的参数，例如类信息、方法信息、注解、请求方式等，并将这些参数保存到数据库。`

## (3)Spring框架中事务失效的情况

### 1.异常捕获处理

![image.png](/static/img/3ced25ce1fcc1825b66dacc2a39aae41.image.webp)

需要在catch中抛出异常

### 2.抛出检查异常

![image.png](/static/img/b5793447aa481a2b45cbd37b6188513f.image.webp)

需要添加注释

![image.png](/static/img/5f8bc9c93530339b6ce2e41340b249ac.image.webp)

### 3.非public方法导致事务失效

![image.png](/static/img/337f8b1e04ba5ee1acf761e31a6c2c49.image.webp)

面试话术

![image.png](/static/img/66857af689e65ed8a066ffa6210d82c0.image.webp)

`4. Spring中的事务是如何实现的？
候选人：
Spring实现事务的本质是利用AOP完成的。它对方法前后进行拦截，在执行方法前开启事务，在执行完目标方法后根据执行情况提交或回滚事务。`

`5. Spring中事务失效的场景有哪些？
候选人：
在项目中，我遇到过几种导致事务失效的场景
;1. 如果方法内部捕获并处理了异常，没有将异常抛出，会导致事务失效。因此，处理异常后应该确保异常能够被抛出。
;2. 如果方法抛出检查型异常（checked exception），并且没有在@Transactional注解上配置rollbackFor属性为Exception，那么异常发生时事务可能不会回滚。
;3. 如果事务注解的方法不是公开（public）修饰的，也可能导致事务失效。`

## (4)Spring Bean的生命周期

![image.png](/static/img/19bf0af139855d5270757f63baed01cb.image.webp)

面试话术

`6. Spring的bean的生命周期？
候选人：
Spring中bean的生命周期包括以下步骤：
；1. 通过BeanDefinition获取bean的定义信息。
；2. 调用构造函数实例化bean。
；3. 进行bean的依赖注入，例如通过setter方法或@Autowired注解。
；4. 处理实现了Aware接口的bean。
；5. 执行BeanPostProcessor的前置处理器。
；6. 调用初始化方法，如实现了InitializingBean接口或自定义的init-method。
；7. 执行BeanPostProcessor的后置处理器，可能在这里产生代理对象。
；8. 最后是销毁bean。`

## (5)Spring中的循环引用问题

问题产生原因

![image.png](/static/img/6c35a80f44503d3568b7f6ec73ca785c.image.webp)

三级缓存解决循环依赖

![image.png](/static/img/13ea0e5b22467fead74bb6cb0585f3ba.image.webp)

构造方法出现循环依赖的问题

![image.png](/static/img/da57bc9158390130e0e6268baee9d205.image.webp)

面试话术

`7. Spring中的循环引用？
候选人：
循环依赖发生在两个或两个以上的bean互相持有对方，形成闭环。Spring框架允许循环依赖存在，并通过三级缓存解决大部分循环依赖问题：
；1. 一级缓存：单例池，缓存已完成初始化的bean对象。
；2. 二级缓存：缓存尚未完成生命周期的早期bean对象。
；3. 三级缓存：缓存ObjectFactory，用于创建bean对象。`

`8. 那具体解决流程清楚吗？
候选人：
解决循环依赖的流程如下：
；1. 实例化A对象，并创建ObjectFactory存入三级缓存。
；2. A在初始化时需要B对象，开始B的创建逻辑。
；3. B实例化完成，也创建ObjectFactory存入三级缓存。
；4. B需要注入A，通过三级缓存获取ObjectFactory生成A对象，存入二级缓存。
；5. B通过二级缓存获得A对象后，B创建成功，存入一级缓存。
；6. A对象初始化时，由于B已创建完成，可以直接注入B，A创建成功存入一级缓存。
；7. 清除二级缓存中的临时对象A。`

`9. 构造方法出现了循环依赖怎么解决？
候选人：
由于构造函数是bean生命周期中最先执行的，Spring框架无法解决构造方法的循环依赖问题。可以使用@Lazy懒加载注解，延迟bean的创建直到实际需要时。`

## (6)Spring MVC的执行流程

视图阶段

![image.png](/static/img/7b3b11ea8800fc9a35e296126fb256ff.image.webp)

前后端分离阶段

![image.png](/static/img/324bf262343dbf6a7418b5eb3992a666.image.webp)

面试话术

![image.png](/static/img/acaa98e5ee05cd95f39219e1de51fc42.image.webp)

`10. SpringMVC的执行流程？
候选人：
SpringMVC的执行流程包括以下步骤：
；1. 用户发送请求到前端控制器DispatcherServlet。
；2. DispatcherServlet调用HandlerMapping找到具体处理器。
；3. HandlerMapping返回处理器对象及拦截器（如果有）给DispatcherServlet。
；4. DispatcherServlet调用HandlerAdapter。
；5. HandlerAdapter适配并调用具体处理器（Controller）。
；6. Controller执行并返回ModelAndView对象。
；7. HandlerAdapter将ModelAndView返回给DispatcherServlet。
；8. DispatcherServlet传给ViewResolver进行视图解析。
；9. ViewResolver返回具体视图给DispatcherServlet。
；10. DispatcherServlet渲染视图并响应用户。`

## (7)SpringBoot自动配置原理

![image.png](/static/img/25a11f20b7b6a347e9e015c9bbfff8ce.image.webp)

面试话术

`11. Springboot自动配置原理？
候选人：
Spring Boot的自动配置原理基于@SpringBootApplication注解，它封装了@SpringBootConfiguration、@EnableAutoConfiguration和@ComponentScan。@EnableAutoConfiguration是核心，它通过@Import导入配置选择器，读取META-INF/spring.factories文件中的类名，根据条件注解决定是否将配置类中的Bean导入到Spring容器中。`

框架篇

## （1）如何定位慢查询

出现原因：

聚合查询

多表查询

表数据过大

深度分页查询

### 1.开源工具

Arthas Prometheus Skywalking

![image.png](/static/img/b24b69523d480b09365adbb8c00516dc.image.webp)

### 2.Mysql自带的慢日志

![image.png](/static/img/f60e1d8a3767f85b168b89b83fe9b091.image.webp)

面试话术

![image.png](/static/img/0c57893423ba4b40645827e01174c171.image.webp)

![image.png](/static/img/02de93ed8f20c83497e2b90e5866dc93.image.webp)

## （2）如何优化SQL

聚合查询 新增临时表

多表查询 优化SQL语句结构                     SQL执行计划(找到慢的原因)

表数据过大查询 添加索引

深度分页查询

![image.png](/static/img/82eacd3eee7c58a02e0f16cd5a2dfa32.image.webp)

![image.png](/static/img/e99c1acf2a72f9638a17bfe49774807b.image.webp)

![image.png](/static/img/1f843779fc4d03efa34c884ea186225a.image.webp)

面试话术

![image.png](/static/img/f931a0187af5af92f01792f734ffa2c4.image.webp)

## （3）索引

话术

![image.png](/static/img/c62ef96d8bea7130c1a024816a4e6d2c.image.webp)

![image.png](/static/img/9544d7e5a043821808b94d5e53681a7c.image.webp)

![image.png](/static/img/96837575a24345465d5a5a0ae070b58e.image.webp)

## （4）聚集索引，二级索引(聚簇索引，非聚簇索引)回表查询

### 1.聚集索引

![image.png](/static/img/fbf6cedd683ba1d59523c651623e22a0.image.webp)

### 2.回表查询

![image.png](/static/img/93e5dd9abf5cc86de2bb6f8ca0beedfa.image.webp)

面试话术

![image.png](/static/img/e5920646b57574c2e29385cb60db3811.image.webp)

![image.png](/static/img/12c9965addf8c6139707df91942722e7.image.webp)

## （5）覆盖索引，超大分页优化

### 1.覆盖索引

![image.png](/static/img/8d24298c83d075b5558c06aab4b9136f.image.webp)

![image.png](/static/img/f5bbdce603cbe8b6c8f56935500ddd1f.image.webp)

覆盖索引没有回表查询

面试话术

![image.png](/static/img/2a619ea56af53c04012aae0d7af5a53f.image.webp)

![image.png](/static/img/775231c87abc119f3a2f51a4822d384f.image.webp)
### 2.Mysql超大分页

![image.png](/static/img/5e42e7854c609559bd1ee1d6a0387e7a.image.webp)

![image.png](/static/img/73fe114ac9d9470ef4a71ef68b9f88bd.image.webp)

![image.png](/static/img/2db9a0197f211a267e44fba9dd85732a.image.webp)

## （6）创建索引的原则

![image.png](/static/img/142f0937182ae29d5a2d95323fc684af.image.webp)

面试话术

![image.png](/static/img/681256e06e9c0d48d6002bdc6dd35ecb.image.webp)

![image.png](/static/img/0728897b251b6a2dc4e0ec165a5ea4e6.image.webp)

## （7）索引失效

**失效情况**
 
 ### 1.违反最短前缀法则
 
![image.png](/static/img/f842ffea93eda8c758af52c2eaed95e7.image.webp)

![image.png](/static/img/bc858fee39f39b42151f324518d83886.image.webp)

### 2.范围查询右边的列不能使用索引

![image.png](/static/img/d4c99c3526a9f2dab5888bc9bba9cdaf.image.webp)

### 3.不要在索引列上进行运算操作

![image.png](/static/img/350539394f13945c3e3d9b0ad95129c6.image.webp)

### 4.字符串不加单引号，造成索引失效

![image.png](/static/img/68b9e2bf37973c65feb2fc6630909615.image.webp)

### 5.以%开头的like模糊查询，索引失效。如果仅仅是尾部匹配模糊查询索引不会失效。

![image.png](/static/img/aa179db68df1e011e375633d095e1858.image.webp)

面试话术

![image.png](/static/img/edc38d72e2db808739d3d7bbee1bb0b1.image.webp)

![image.png](/static/img/10707343269e24b5c5541bab2716c4e6.image.webp)

## (8)SQL优化

表设计的优化

索引优化

sql语句优化

主从复制，读写分离

分库分表

![image.png](/static/img/ee5448ad5861326ca01798c2585d6da8.image.webp)

![image.png](/static/img/18407798437c582cd8d7b6ad8dc6d9c9.image.webp)

面试话术

![image.png](/static/img/a6db11ab8c57defb2d92451870212bd5.image.webp)

## (9)事务特性

ACID

![image.png](/static/img/16dbbc36cc7a37822174088654ddc676.image.webp)

![image.png](/static/img/62b4a508a13a27b0313d10689735b170.image.webp)

原子性 隔离性 持久性 一致性

面试话术

![image.png](/static/img/71438f878aa06e42c51380f0c3d59569.image.webp)

## (10)并发事务带来的问题,如何解决,mysql的默认隔离级别

### 1.并发事务带来的问题

![image.png](/static/img/27b41532d11d0cb5fe6cd494ba20f40a.image.webp)
 
### 2.如何解决

对事务进行隔离

![image.png](/static/img/68fa7c7351190c7a94a8172dc0c583e8.image.webp)

面试话术

![image.png](/static/img/d1ebd6708dc2eef6eab9a6def56ce21c.image.webp)

## (11)undo log和redo log的区别

redo log

![image.png](/static/img/33df93e260cad6abbe4cdca2bc613177.image.webp)

undo log

![image.png](/static/img/0ca175797f28197badf9f06a020901b5.image.webp)

面试话术

![image.png](/static/img/feb0fce8885fa1d356b51e0f3e2c4ce0.image.webp)

## (12)mvcc

![image.png](/static/img/d29dbad569552429a276a17ba444c308.image.webp)

面试话术

![image.png](/static/img/e4d915bf74f54658e462ae4e22c97572.image.webp)

## (13)主从同步原理

主从同步核心是二进制文件

![image.png](/static/img/d1e7347c511339a01f55fd09eb116ae0.image.webp)

面试话术

![image.png](/static/img/dee828059c18530feffbbb225b6186a2.image.webp)

## (14)分库分表

![image.png](/static/img/45ccdacfd8d26d1842f8a406c8adc2f2.image.webp)

拆分策略

### 1.垂直分库

![image.png](/static/img/1f57d688834025b681ded7511a29467c.image.webp)

### 2.水平分库

![image.png](/static/img/f4d12e68f30e9581caac6c4baab97b05.image.webp)

分库分表策略

![image.png](/static/img/39613398243636a5886264595bfb9814.image.webp)


![image.png](/static/img/9b72ccf047b710890f00eee24818582a.image.webp)




Mysql篇

# 1.redis常见面试题

## （1）redis缓存穿透





![image.png](/static/img/78044e91fa212a3424e1e34e5931d2ae.image.webp)

使用不存在的id发送请求 不直接访问redis而是直接访问mysql

![image.png](/static/img/ff40159c8d19aaf6c4482bbd9c51ad26.image.webp)

**解决方案:**

### 1.缓存空数据,查询结果为空仍把这个空结果进行缓存
优点：简单
缺点：消耗内存，可能发生不一致的问题

### 2.布隆过滤器

![image.png](/static/img/268aa004c978781cd4b70adce9b5b9ad.image.webp)

优点：内存占用较小，没有多余的key
缺点：实现较为复杂，存在误判

创建一个bitmap 初始全为空 预热布隆过滤器对传入id进行多次hash计算 由计算结果bitmap的对应位置该为1 如果传入idhash计算后在bitmap中不全为1就拦截

![image.png](/static/img/25ce76d07a6f9c26ffb03b08dd9cf4c0.image.webp)

## （2）缓存击穿

![image.png](/static/img/65a1f4c6d3b04624a34354089d82dce7.image.webp)

![image.png](/static/img/192be4d88f55dc01131c3a73ffce8302.image.webp)

**解决方案:**

### 1.互斥锁

![image.png](/static/img/8b1bedda11d6f01f5ef351bbe59fa803.image.webp)

强一致 性能差

![image.png](/static/img/0329965fbfd1bbe68708bb6922e7d476.image.webp)

### 2.逻辑过期

![image.png](/static/img/b75e594e7956b08ca8c1ab065dd5faa8.image.webp)

高可用 性能优

![image.png](/static/img/edb4362b6446db8cd4e2e935b0cffed6.image.webp)

##  （3）缓存雪崩

![image.png](/static/img/961bbed3743bac4287d75c0517e39561.image.webp)

![image.png](/static/img/c449e6a26eb5256a67679e88b2477311.image.webp)

**解决方案**

![image.png](/static/img/e269057dce9cc531109f29834d4fafd3.image.webp)

![image.png](/static/img/59528bd685662234e6257219e0ff7b90.image.webp)

## （4）双写一致性

![image.png](/static/img/ff09fd0e0281c1ca2bc9003a672e008f.image.webp)

强一致

![image.png](/static/img/3ead054c08a3bc4474993c8a517a390a.image.webp)

读写锁

![image.png](/static/img/4440007991641b651962b5398f30a26d.image.webp)

延时双删

![image.png](/static/img/6714028a1c52350ee149320dac20e834.image.webp)

总结

![image.png](/static/img/614da7fad2ea3f813ab24f942bc82da7.image.webp)

## （5）redis数据持久化

### 1.RDB

![image.png](/static/img/d06bc50fc2a9fee697d59a0970d0d9af.image.webp)

执行原理

![image.png](/static/img/7c062d617595b705eb9eef88b8e102c5.image.webp)

### 2.AOF

![image.png](/static/img/73202da1de69fd5bd16c064e28bdcc20.image.webp)

RDB和AOF对比

![image.png](/static/img/5308f6af0e6f1a6d6f64006ca67eda46.image.webp)

![image.png](/static/img/0f57477042d1356642a57a622cf87efd.image.webp)

## （6）数据过期策略

### 1.惰性删除

设置该key过期后，我们不去管他，当需要该key时我们再检查其是否过期，如果过期，我们就删除它，反之则返回key。

![image.png](/static/img/15ee1ce590afe4ee1ab31d35ee371401.image.webp)

### 2.定期删除

每隔一段时间我们就对一些key进行检查，删除里面过期的key

![image.png](/static/img/8b6b499e85c753e0dc8c7e6dd8872d8f.image.webp)

![image.png](/static/img/1d1f3136191b7d58cf7145ac10250b59.image.webp)

![image.png](/static/img/8a5161b893c6cd9ca64f7b44bafeb738.image.webp)

## （7）redis数据淘汰策略

![image.png](/static/img/d7a8716844b7b9d959942bd712cd2538.image.webp)

数据淘汰策略推荐

![image.png](/static/img/7cc91663a4da79a5b6ebcd58d41b7e7a.image.webp)

其他问题

![image.png](/static/img/ccac6e8f31f0eab23112e607327b4bc2.image.webp)

![image.png](/static/img/b6cce873ae3abaf2a255852e0715d62a.image.webp)

## （8）redis分布式锁

### 1.setnx

![image.png](/static/img/bfdf6287071ca17a6d78f91719bdc11c.image.webp)

给锁续期

### 2.redisson实现的分布式锁

执行流程

![image.png](/static/img/6fa4461e67be4995a903064fe193c6ee.image.webp)

![image.png](/static/img/374ad521853ab1c66d9ab95945fe7751.image.webp)

同一线程中可重入

**主从一致性**
 
 当主节点redis在获取锁时宕机会导致其他进程也获取锁成功
 
![image.png](/static/img/20ce392bd795e6d8bd746a51739ba82b.image.webp)

红锁

![image.png](/static/img/a97c7fa5ef6e22f9165040e474a5d4e7.image.webp)

面试话术

![image.png](/static/img/db11e8cc2e84904555f5081d331217c7.image.webp)

![image.png](/static/img/a0d94e1791c504bce780a90a689c1cb4.image.webp)

![image.png](/static/img/b0a96400c5e2ae2b0071e87f781bfe7d.image.webp)

## （9）redis集群方案

**主从复制**

**哨兵模式**

**分片集群**

### 1.主从复制

全量同步：

![image.png](/static/img/925311aebda91cc53789ca82c7254f81.image.webp)

增量同步：

![image.png](/static/img/5d3336c9c29c2eff16afce1d23e6e11a.image.webp)

面试话术

![image.png](/static/img/3f87d72b71418e779e082ebd883af830.image.webp)

![image.png](/static/img/b85d3710296d75890a5010759bc7929e.image.webp)

### 2.哨兵模式

**哨兵作用: 监控 自动故障恢复 通知**

![image.png](/static/img/2afa91b8d7fe9ed87a3482a1717afac1.image.webp)

服务状态监控

![image.png](/static/img/42a6f69761580a884aa2d510afa29b2d.image.webp)

脑裂问题

![image.png](/static/img/5bb7c880b21f21e9da2e31f72f517b03.image.webp)

面试话术

![image.png](/static/img/efebfddc9c6d5cdfa8301d2e0fb20e91.image.webp)

![image.png](/static/img/b5e011af8dd5a2a0c315fe6890c9e053.image.webp)

### 3.分片集群

![image.png](/static/img/f364eda1dbbe2dcc25b77ff16314348b.image.webp)

数据读写

![image.png](/static/img/1ba0db13cbeb2744038a12ce65cfae3b.image.webp)

面试话术

![image.png](/static/img/80ae5c8de917c97d16492f16db881e19.image.webp)

![image.png](/static/img/51b7e26f37410cf672338a57f03b9ca4.image.webp)

## （9）redis其他面试问题

### 1.redis是单线程的为什么还这么快

reids是纯内存操作，执行速度非常快

采用单线程，避免不必要的上下文切换可竞争条件，多线程还要考虑线程安全问题

使用i/o多路复用模型，非阻塞io

![image.png](/static/img/f724a415f8f3b69a469802103243dfc8.image.webp)

### 2.解释一下i/o多路复用模型

![image.png](/static/img/15adf0a435f96228b4b2aff8a8620d04.image.webp)

![image.png](/static/img/08958a8b380aaab617772aeeeafc17f0.image.webp)

![image.png](/static/img/123e1cc3070b8a1e42e866d1c9ed7352.image.webp)

Redis篇

# 1.mongodb实现搜索记录




![image.png](/static/img/0d3706623b1b1bf8a77f3bad25477869.image.webp)

docker启动mongodb

`docker run -di --name mongo-service --restart=always -p 27017:27017 -v ~/data/mongodata:/data mongo`


java集成mongodb

![image.png](/static/img/2c63d6fb65201c8b7979f65c507884a3.image.webp)

实现用户搜索记录保存功能

```java
package com.heima.search.service.impl;

import com.heima.search.service.ApUserSearchService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Sort;
import org.springframework.data.mongodb.core.MongoTemplate;
import org.springframework.data.mongodb.core.query.Criteria;
import org.springframework.data.mongodb.core.query.Query;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;
import pojos.ApUserSearch;

import java.util.Date;
import java.util.List;


@Service
@Slf4j
public class ApUserSearchServiceImpl implements ApUserSearchService {


    @Autowired
    private MongoTemplate mongoTemplate;


    /**
     * 保存用户搜索历史记录
     *
     * @param keyward
     * @param userId
     */
    @Override
    @Async
    public void insert(String keyward, Integer userId) {
        // 1.查询当前用户的搜索关键词记录
        Query query = Query.query(Criteria.where("userId").is(userId).and("keyword").is(keyward));
        ApUserSearch apUserSearch = mongoTemplate.findOne(query,ApUserSearch.class);
        // 2.存在更新时间
        if (apUserSearch != null){
            apUserSearch.setCreatedTime(new Date());
            mongoTemplate.save(apUserSearch);
            return;
        }
        // 3.不存在，判断当前搜索记录是否超过10
        apUserSearch = new ApUserSearch();
        apUserSearch.setKeyword(keyward);
        apUserSearch.setUserId(userId);
        apUserSearch.setCreatedTime(new Date());


        Query query1 = Query.query(Criteria.where("userId").is(userId));
        query1.with(Sort.by(Sort.Direction.DESC, "createdTime"));
        List<ApUserSearch> apUserSearchList = mongoTemplate.find(query1,ApUserSearch.class);

        if (apUserSearchList == null|| apUserSearchList.size() < 10) {
            mongoTemplate.save(apUserSearch);
        }else{
            ApUserSearch lastApUserSearch = apUserSearchList.get(apUserSearchList.size() - 1);
            mongoTemplate.findAndReplace(Query.query(Criteria.where("id").is(lastApUserSearch.getId())),apUserSearch);
        }
    }
}

```

在调用es搜索时异步调用

```java
        if (apUser !=null && dto.getFromIndex() == 0){
            // 异步调用保存搜索记录
            apUserSearchService.insert(dto.getSearchWords(), apUser.getId());
        }
```

# 2.实现搜索记录查询

![image.png](/static/img/50c36b6ec1d52c5c55117aeee24fc25e.image.webp)

编写查询历史记录的实现类

```java
 /**
     * 查询用户搜索记录
     *
     * @return
     */
    @Override
    public ResponseResult findUserSearch() {
        // 获取当前用户
        ApUser user = AppThreadLocalUtil.getApUser();
        if (user==null){
            return ResponseResult.errorResult(AppHttpCodeEnum.NEED_LOGIN);
        }
        // 根据用户查询记录 降序排序
        List<ApUserSearch> apUserSearchList = mongoTemplate.find(Query.query(Criteria.where("userId").is(user.getId())).with(Sort.by(Sort.Direction.DESC, "createdTime")), ApUserSearch.class);
        return ResponseResult.okResult(apUserSearchList);
    }
```
编写接口层

```java
    @PostMapping("/load")
    public ResponseResult findUserSearch(){
        return apUserSearchService.findUserSearch();
    }
```

# 3.实现搜索记录删除功能

![image.png](/static/img/b68153e9e96cecafb8161b7f3df92378.image.webp)

代码实现

```java
    /**
     * 删除用户搜索记录
     *
     * @param dto
     */
    @Override
    public ResponseResult delUserSearch(HistorySearchDto dto) {
        // 1.检查参数
        if (dto == null || dto.getId() == null) {
            return ResponseResult.errorResult(AppHttpCodeEnum.PARAM_INVALID);
        }
        // 2.判断是否登录
        ApUser user = AppThreadLocalUtil.getApUser();
        if (user == null) {
            return ResponseResult.errorResult(AppHttpCodeEnum.NEED_LOGIN);
        }
        // 3.删除搜索记录
        mongoTemplate.remove(Query.query(Criteria.where("userId").is(user.getId()).and("id").is(dto.getId())), ApUserSearch.class);

        return ResponseResult.okResult(AppHttpCodeEnum.SUCCESS);
    }
```
# 4.关键词联想

代码实现

```java
    /**
     * 实现关键词联想功能
     *
     * @param dto
     * @return
     */
    @Override
    public ResponseResult search(UserSearchDto dto) {
        // 1.检查参数
        if (dto == null || StringUtils.isBlank(dto.getSearchWords())) {
            return ResponseResult.errorResult(AppHttpCodeEnum.PARAM_INVALID);
        }
        // 2.分页检查
        if (dto.getPageSize()>20){
            dto.setPageSize(20);
        }
        // 3.执行查询,模糊查询
        Query query = Query.query(Criteria.where("associateWords").regex(".*?\\" + dto.getSearchWords() + ".*"));
        query.limit(dto.getPageSize());
        List<ApAssociateWords> apAssociateWords = mongoTemplate.find(query, ApAssociateWords.class);
        return ResponseResult.okResult(apAssociateWords);
    }
```

# 5.xxl入门

定时任务

![image.png](/static/img/1899176fafcbb0672fcdeea9b310217a.image.webp)

定时任务框架

![image.png](/static/img/67a1558d07a7356c4c59e0a81cffb716.image.webp)

分布式任务调度

![image.png](/static/img/c2d0a06da6257b58a2175a2162f5c77b.image.webp)

 创建mysql容器
 
```shell
docker run -p 3306:3306 --name mysql57 \
-v /opt/mysql/conf:/etc/mysql \
-v /opt/mysql/logs:/var/log/mysql \
-v /opt/mysql/data:/var/lib/mysql \
-e MYSQL_ROOT_PASSWORD=root \
-d mysql:5.7。25
```

创建xxl-job-admin


```shell
docker run -e PARAMS="--spring.datasource.url=jdbc:mysql://192.168.42.10:3306/xxl_job?Unicode=true&characterEncoding=UTF-8 --spring.datasource.username=root --spring.datasource.password=root" \
-p 8888:8080 \
-v /tmp:/data/applogs \
--name xxl-job-admin \
--restart=always \
-d xuxueli/xxl-job-admin:2.3.0
```

快速入门

![image.png](/static/img/eaa079d0b3a72779ecd29a5cac2ed6a4.image.webp)

![image.png](/static/img/328c58c12e7ba01fc18bd5410f634b15.image.webp)

config

```java
package com.heima.config;

import com.xxl.job.core.executor.impl.XxlJobSpringExecutor;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * xxl-job config
 *
 * @author xuxueli 2017-04-28
 */
@Configuration
public class XxlJobConfig {
    private Logger logger = LoggerFactory.getLogger(XxlJobConfig.class);

    @Value("${xxl.job.admin.addresses}")
    private String adminAddresses;

//    @Value("${xxl.job.accessToken}")
//    private String accessToken;

    @Value("${xxl.job.executor.appname}")
    private String appname;
//
//    @Value("${xxl.job.executor.address}")
//    private String address;
//
//    @Value("${xxl.job.executor.ip}")
//    private String ip;

    @Value("${xxl.job.executor.port}")
    private int port;
//
//    @Value("${xxl.job.executor.logpath}")
//    private String logPath;
//
//    @Value("${xxl.job.executor.logretentiondays}")
//    private int logRetentionDays;


    @Bean
    public XxlJobSpringExecutor xxlJobExecutor() {
        logger.info(">>>>>>>>>>> xxl-job config init.");
        XxlJobSpringExecutor xxlJobSpringExecutor = new XxlJobSpringExecutor();
        xxlJobSpringExecutor.setAdminAddresses(adminAddresses);
        xxlJobSpringExecutor.setAppname(appname);
//        xxlJobSpringExecutor.setAddress(address);
//        xxlJobSpringExecutor.setIp(ip);
        xxlJobSpringExecutor.setPort(port);
//        xxlJobSpringExecutor.setAccessToken(accessToken);
//        xxlJobSpringExecutor.setLogPath(logPath);
//        xxlJobSpringExecutor.setLogRetentionDays(logRetentionDays);

        return xxlJobSpringExecutor;
    }

    /**
     * 针对多网卡、容器内部署等情况，可借助 "spring-cloud-commons" 提供的 "InetUtils" 组件灵活定制注册IP；
     *
     *      1、引入依赖：
     *          <dependency>
     *             <groupId>org.springframework.cloud</groupId>
     *             <artifactId>spring-cloud-commons</artifactId>
     *             <version>${version}</version>
     *         </dependency>
     *
     *      2、配置文件，或者容器启动变量
     *          spring.cloud.inetutils.preferred-networks: 'xxx.xxx.xxx.'
     *
     *      3、获取IP
     *          String ip_ = inetUtils.findFirstNonLoopbackHostInfo().getIpAddress();
     */


}
```

job


```java
package com.heima.job;


import com.xxl.job.core.handler.annotation.XxlJob;
import org.springframework.stereotype.Component;

@Component
public class HelloJob {

    @XxlJob("demoJobHandler")
    public void helloJob(){
        System.out.println("简单任务执行了");
    }
}

```
# 6.xxl-job分片广播

![image.png](/static/img/7fc8462f4365bdef7ad47d2585cc3db2.image.webp)

![image.png](/static/img/e158e5b87941500505c2b03d2cb7fa67.image.webp)

# 7.热点文章计算

![image.png](/static/img/f90ac3c8cb1e3ef223da74853e20e4d0.image.webp)

查询前5天的文章

![image.png](/static/img/f9bd3cf3231c1375e6969cffd7ffe5e6.image.webp)

计算分值

![image.png](/static/img/ae8c206a768e22e789439f71b4453167.image.webp)

为每一个频道缓存30条文章

![image.png](/static/img/57791ffc98719f53f50c7d46c77f0cb8.image.webp)

代码实现

```java
package com.heima.article.service.impl;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.heima.apis.wemedia.IWemediaClient;
import com.heima.article.mapper.ApArticleMapper;
import com.heima.article.service.HotArticleService;
import com.heima.common.redis.CacheService;
import com.heima.model.article.pojos.ApArticle;
import com.heima.model.article.vos.HotArticleVo;
import com.heima.model.common.dtos.ResponseResult;
import com.heima.model.wemedia.pojos.WmChannel;
import lombok.extern.slf4j.Slf4j;
import org.joda.time.DateTime;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.ArrayList;
import java.util.Comparator;
import java.util.Date;
import java.util.List;
import java.util.stream.Collectors;


@Service
@Slf4j
@Transactional
public class HotArticleServiceImpl implements HotArticleService {


    @Autowired
    private IWemediaClient iWemediaClient;


    @Autowired
    private ApArticleMapper apArticleMapper;


    @Autowired
    private CacheService cacheService;

    /**
     * 计算热点文章
     */
    @Override
    public void computeHotArticle() {
        // 查询前5天的文章数据
        Date dateParam = DateTime.now().minusDays(5).toDate();
        List<ApArticle> articleListByLast5Days = apArticleMapper.findArticleListByLast5Days(dateParam);
        // 计算文章的分值
        List<HotArticleVo> hotArticleVoList = computeHotArticleScore(articleListByLast5Days);
        // 为每个频道缓存30条分值高的文章
        cacheTagToRedis(hotArticleVoList);
    }




    /**
     * 为每个频道缓存30条文章
     * @param hotArticleVoList
     */
    private void cacheTagToRedis(List<HotArticleVo> hotArticleVoList) {
       // 每个频道缓存前30条数据
        ResponseResult channels = iWemediaClient.getChannels();
        if (channels.getCode().equals(200)){
            String channelStr = JSON.toJSONString(channels.getData());
            List<WmChannel> wmChannels = JSON.parseArray(channelStr, WmChannel.class);
            // 检索出每个频道的文章
            if (wmChannels != null && wmChannels.size() > 0){
                for (WmChannel wmChannel : wmChannels) {
                    List<HotArticleVo> hotArticleVos = hotArticleVoList.stream().filter(x -> x.getChannelId().equals(wmChannel.getId())).collect(Collectors.toList());
                    // 给文章排序，取30条文章分值较高的文章存入redis
                    sortAndCache(hotArticleVos, "hot_article_first_page" + wmChannel.getId());
                }
            }
        }

        // 设置推荐数据
        sortAndCache(hotArticleVoList, "__all__");
    }

    /**
     * 排序并且缓存数据
     * @param hotArticleVos
     * @param wmChannel
     */
    private void sortAndCache(List<HotArticleVo> hotArticleVos, String wmChannel) {
        hotArticleVos = hotArticleVos.stream().sorted(Comparator.comparing(HotArticleVo::getScore).reversed()).collect(Collectors.toList());
        if (hotArticleVos.size() > 30) {
            hotArticleVos = hotArticleVos.subList(0, 30);
        }
        cacheService.set(wmChannel, JSON.toJSONString(hotArticleVos));
    }


    /**
     * 计算文章分值返回热点文章列表
     * @param articleListByLast5Days
     * @return
     */
    private List<HotArticleVo> computeHotArticleScore(List<ApArticle> articleListByLast5Days) {
        List<HotArticleVo> hotArticleVoList = new ArrayList<>();

        for (ApArticle apArticle : articleListByLast5Days) {
            HotArticleVo hotArticleVo = new HotArticleVo();
            BeanUtils.copyProperties(apArticle,hotArticleVo);
            Integer score = computeScore(apArticle);
            hotArticleVo.setScore(score);
            hotArticleVoList.add(hotArticleVo);
        }
        return hotArticleVoList;
    }


    /**
     * 计算具体文章分值
     * @param apArticle
     * @return
     */
    private Integer computeScore(ApArticle apArticle) {
        Integer score = 0;
        if (apArticle.getLikes() != null){
            score += apArticle.getLikes()*3;
        }
        if (apArticle.getViews() != null){
            score += apArticle.getViews();
        }
        if (apArticle.getComment() != null){
            score += apArticle.getComment()*5;
        }
        if (apArticle.getCollection() != null){
            score += apArticle.getCollection()*8;
        }
        return score;
    }
}

```
# 8.流式计算

kafkaStream

![image.png](/static/img/6d972062090213e44800698f4aa67559.image.webp)

KStream

![image.png](/static/img/ad71da346202b9b02c3ddc93a44d6a79.image.webp)

入门案例

![image.png](/static/img/5d5fbfc65cda689b90774de8a50477be.image.webp)


![image.png](/static/img/46814542e7d78a8342ca48f2d9eebc63.image.webp)