跳至主要內容
JingxcJingxc
主页
前端
运维
知识点
片段
个人简历
  • 2023面试题
    • 1. JAVA OOP
      • 1.1 short s1 = 1; s1 = s1 + 1;有错吗? short s1 = 1; s1 += 1; 有错吗?
        • 1.2 重载和重写的区别
          • 1.3 数组实例化有几种方式?
            • 1.4 Java 中各种数据默认值
              • 1.5 Object 类常用方法有那些?
                • 1.6 java 中是值传递引用传递?
                  • 1.7 形参与实参区别
                    • 1.8 构造方法能不能重写?能不能重载?
                      • 1.9 内部类与静态内部类的区别?
                        • 1.10 Static 关键字有什么作用?
                          • 1.11 final 在 java 中的作用,有哪些用法?
                            • 1.12 String str=”aaa”,与 String str=new String(“aaa”)一样吗?
                              • 1.13 讲下 java 中的 math 类有那些常用方法?
                                • 1.14 Char 类型能不能转成 int 类型?能不能转化成 string 类型,能不能转成 double 类型
                                  • 1.15 什么是拆装箱?
                                    • 1.16 Java 中的包装类都是那些?
                                      • 1.17 那针对浮点型数据运算出现的误差的问题,你怎么解决?
                                        • 1.19 面向对象的特征有哪些方面?
                                          • 1.20 访问修饰符 public,private,protected,以及不写(默认) 时的区别?
                                            • 1.21 接口有什么特点?
                                              • 1.22 抽象类和接口的区别?
                                                • 1.23 Hashcode 的作用
                                                  • 1.24 普通类与抽象类有什么区别?
                                                    • 1.25 什么是接口?为什么需要接口?
                                                      • 1.26 接口有什么特点?
                                                        • 1.27 拷贝和浅拷贝的区别是什么?
                                                          • 1.28 JDBC 操作的步骤
                                                            • 1.29 什么时候用 assert
                                                              • 1.30 数组有没有 length()这个方法? String 有没有 length()这个方法
                                                                • 1.31 用最有效率的方法算出3乘以8等于几?
                                                                  • 1.32 String 和 StringBuilder、StringBuffer 的区别?
                                                                    • 1.33 接口是否可继承(extends)接口?抽象类是否可实现(implements)接口?抽象类是否可继承具体类(concreteclass)?
                                                                      • 1.34 一个”.java”源文件中是否可以包含多个类(不是内部类)?有什么限制?
                                                                        • 1.35 Java 中的 final 关键字有哪些用法?
                                                                        • 2.JAVA集合/范型
                                                                          • 2.1 ArrayList 和 linkedList 的区别
                                                                            • 2.2 HashMap 排序
                                                                              • 2.3 Collection 包结构,与 Collections 的区别
                                                                                • 2.4 说说 List,Set,Map 三者的区别
                                                                                  • 2.5 并发集合和普通集合的区别
                                                                                    • 2.6 Map 有什么特点
                                                                                      • 2.7 集合类存放于 Java.util 包中, 主要有几种接口
                                                                                        • 2.8 什么是 list 接口
                                                                                          • 2.9 说说 ArrayList(数组)
                                                                                            • 2.10 说说Vector的( 数组实现、 线程同步)
                                                                                              • 2.11 说说 LinkList的链表
                                                                                                • 2.12 什么 Set 集合
                                                                                                  • 2.13 HashSet( Hash 表)
                                                                                                    • 2.14 什么是 TreeSet(二叉树)
                                                                                                      • 2.15 List 和 Map、Set 的区别?
                                                                                                        • 2.16 数组和链表分别比较适合用于什么场景,为什么?
                                                                                                          • 2.17 说说 ConcurrentHashMap
                                                                                                            • 2.18 Java 中 ArrayList 和 LinkedList 区别?
                                                                                                              • 2.19 TreeMap(可排序)
                                                                                                                • 2.20 请用两个队列模拟堆栈结构?
                                                                                                                  • 2.21 Map 中的 key 和 value 可以为 null?
                                                                                                                    • 2.22 HashMap 的底层实现
                                                                                                                      • 2.23 ConcurrentHashMap 和 Hashtable有什么区别
                                                                                                                        • 2.24 说说 ArrayList,Vector,LinkedList 的存储性能和特性
                                                                                                                          • 2.25 HashMap 原理,java8 做了什么改变
                                                                                                                            • 2.26 poll()方法和 remove()方法的区别?
                                                                                                                              • 2.27 写一段代码在遍历 ArrayList 时移除一个元素
                                                                                                                              • 3. Java 异常
                                                                                                                                • 3.1 Java 中异常分为哪两种?
                                                                                                                                  • 3.2 异常的处理机制有几种?
                                                                                                                                    • 3.3 如何自定义一个异常
                                                                                                                                      • 3.4 try catch fifinally,try 里有 return,finally 还执行么?
                                                                                                                                        • 3.5 Excption 与 Error 包结构
                                                                                                                                          • 3.6 Thow 与 thorws 区别
                                                                                                                                            • 3.7 Error 与 Exception 区别?
                                                                                                                                              • 3.8 final、finally、finalize 的区别?
                                                                                                                                                • 3.9 Java 异常处理机制的理解?
                                                                                                                                                  • 3.10 说出最常见的 5 个 RuntimeException?
                                                                                                                                                  • 4. Java 中的 IO 与 NIO
                                                                                                                                                    • 4.1 字节流如何转为字符流?
                                                                                                                                                      • 4.2 常用 io 类有那些
                                                                                                                                                        • 4.3 如何将一个 java 对象序列化到文件里?
                                                                                                                                                          • 4.4 字节流和字符流的区别?
                                                                                                                                                            • 4.5 如何实现对象克隆?
                                                                                                                                                              • 4.6 什么是 java 序列化,如何实现 java 序列化?
                                                                                                                                                                • 4.7 NIO 的缓冲区
                                                                                                                                                                  • 4.8 面向 Stream 和面向 Buffer
                                                                                                                                                                  • 5. Java 反射
                                                                                                                                                                    • 5.1 什么是反射?
                                                                                                                                                                      • 5.2 Java 反射创建对象效率高还是通过 new 创建对象的效率高?
                                                                                                                                                                        • 5.3 哪里会用到反射机制?
                                                                                                                                                                          • 5.4 反射机制的优缺点
                                                                                                                                                                            • 5.5 动态代理是什么?有哪些应用?
                                                                                                                                                                              • 5.6 如何使用 Java 的反射?
                                                                                                                                                                                • 5.7 java 反射的作用
                                                                                                                                                                                • 6. Java 序列化
                                                                                                                                                                                  • 6.1 什么是 java 序列化?
                                                                                                                                                                                    • 6.2 序列化id?
                                                                                                                                                                                      • 6.3 序列化用户远程对象传输
                                                                                                                                                                                        • 6.4 writeObject 和 readObject 自定义序列化策略
                                                                                                                                                                                          • 6.5 静态变量的序列化?
                                                                                                                                                                                          • 7. Java 注解
                                                                                                                                                                                            • 7.1 4 种标准元注解是哪四种?
                                                                                                                                                                                            • 8. 多线程 &并发面试题
                                                                                                                                                                                              • 8.1 什么是线程?
                                                                                                                                                                                                • 8.2 创建线程的 4 种方式
                                                                                                                                                                                                  • 8.3 实现多线程 Thread 和 Runnable 区别?
                                                                                                                                                                                                    • 8.4 4种线程池
                                                                                                                                                                                                      • 8.5 线程池的 7 个参数介绍
                                                                                                                                                                                                        • 8.6 java 中的 volatile 变量
                                                                                                                                                                                                          • 8.7 notify()和 notifyAll()有什么区别?
                                                                                                                                                                                                            • 8.8 sleep()和 wait() 有什么区别?
                                                                                                                                                                                                              • 8.9 Thread 类中的 start() 和 run() 方法有什么区别?
                                                                                                                                                                                                                • 8.9 为什么 wait, notify 和 notifyAll 这些方法不在 thread 类里面?
                                                                                                                                                                                                                  • 8.10 共享锁和独占锁
                                                                                                                                                                                                                    • 8.11 Java 中 interrupted 和 isInterruptedd 方法的区别?
                                                                                                                                                                                                                      • 8.12 Java 中 synchronized 和 ReentrantLock 有什么不同?
                                                                                                                                                                                                                        • 8.13 有三个线程 T1,T2,T3,如何保证顺序执行?
                                                                                                                                                                                                                          • 8.14 SynchronizedMap 和 ConcurrentHashMap 有什么区别?
                                                                                                                                                                                                                            • 8.15 什么是线程安全
                                                                                                                                                                                                                              • 8.16 重量级锁(Mutex Lock)
                                                                                                                                                                                                                                • 8.17 偏向锁
                                                                                                                                                                                                                                  • 8.18 Java 线程池中 submit() 和 execute()方法有什么区别?
                                                                                                                                                                                                                                    • 8.19 说说自己是怎么使用 synchronized 关键字,在项目中用到了吗 synchronized 关键字最主要的三种使用方式
                                                                                                                                                                                                                                      • 8.20 什么是线程安全?Vector 是一个线程安全类吗?
                                                                                                                                                                                                                                        • 8.21 如何停止一个正在运行的线程
                                                                                                                                                                                                                                          • 8.22 线程基本方法
                                                                                                                                                                                                                                          • 9. JVM
                                                                                                                                                                                                                                            • 9.1 JVM 运行时内存(内存模型)
                                                                                                                                                                                                                                              • 9.2 64 位 JVM 中,int 的长度是多数?
                                                                                                                                                                                                                                                • 9.3 新生代、老年代、永久代
                                                                                                                                                                                                                                                  • 9.4 怎样通过 Java 程序来判断 JVM 是 32 位 还是 64 位?
                                                                                                                                                                                                                                                    • 9.5 分代收集算法
                                                                                                                                                                                                                                                      • 9.6 JRE、JDK、JVM 及 JIT 之间有什么不同?
                                                                                                                                                                                                                                                        • 9.7 JAVA 强引用、软引用、弱引用、虚引用
                                                                                                                                                                                                                                                          • 9.8 怎么获取 Java 程序使用的内存?堆使用的百分比?
                                                                                                                                                                                                                                                            • 9.9 描述一下 JVM 加载 class 文件的原理机制
                                                                                                                                                                                                                                                              • 9.10 Serial Old 收集器(单线程标记整理算法)
                                                                                                                                                                                                                                                                • 9.11 Parallel Old收集器
                                                                                                                                                                                                                                                                  • 9.12 CMS收集器
                                                                                                                                                                                                                                                                    • 9.13 G1收集器
                                                                                                                                                                                                                                                                      • 9.14 Minor GC 与 Full GC 分别在什么时候发生?
                                                                                                                                                                                                                                                                        • 9.15 有哪些JVM调优
                                                                                                                                                                                                                                                                        • 10. MySql
                                                                                                                                                                                                                                                                          • 10.1 MySQL 中有哪些不同的表格?
                                                                                                                                                                                                                                                                            • 10.2 TokuDB( Fractal Tree-节点带数据)
                                                                                                                                                                                                                                                                              • 10.3 MySQL 中 InnoDB 支持的四种事务隔离级别名称,以及逐级之间的区别?
                                                                                                                                                                                                                                                                                • 10.4 myisamchk 是用来做什么的?
                                                                                                                                                                                                                                                                                  • 10.5 MyISAM 表格将在哪里存储,并且还提供其存储格式?
                                                                                                                                                                                                                                                                                    • 10.6 常见索引原则有
                                                                                                                                                                                                                                                                                      • 10.7 如何显示前 50 行?
                                                                                                                                                                                                                                                                                        • 10.8 MySql 第一范式(1st NF - 列都是不可再分)
                                                                                                                                                                                                                                                                                          • 10.9 第二范式(2nd NF- 每个表只描述一件事情)
                                                                                                                                                                                                                                                                                            • 10.10 第三范式(3rd NF- 不存在对非主键列的传递依赖)
                                                                                                                                                                                                                                                                                              • 10.11 锁的优化策略
                                                                                                                                                                                                                                                                                                • 10.12 SQL优化
                                                                                                                                                                                                                                                                                                  • 10.13 为表中得字段选择合适得数据类型
                                                                                                                                                                                                                                                                                                    • 10.14 什么是视图
                                                                                                                                                                                                                                                                                                      • 10.15 什么情况下设置了索引但无法使用
                                                                                                                                                                                                                                                                                                        • 10.16 MySql并发事务带来哪些问题?
                                                                                                                                                                                                                                                                                                          • 10.17 什么是乐观锁、悲观锁、时间戳、行级锁、表级锁、页级锁
                                                                                                                                                                                                                                                                                                          • 11. Redis
                                                                                                                                                                                                                                                                                                            • 11.1 什么是redis?
                                                                                                                                                                                                                                                                                                              • 11.2 怎么理解 Redis 事务?
                                                                                                                                                                                                                                                                                                                • 11.3 Redis 的数据类型?
                                                                                                                                                                                                                                                                                                                  • 11.4 Redis key 的过期时间和永久有效分别怎么设置?
                                                                                                                                                                                                                                                                                                                    • 11.5 Redis 相比 Memcached 有哪些优势?
                                                                                                                                                                                                                                                                                                                      • 11.6 Redis 回收进程如何工作的?
                                                                                                                                                                                                                                                                                                                        • 11.7 缓存雪崩、缓存穿透、缓存预热、缓存更新、缓存降级等问题
                                                                                                                                                                                                                                                                                                                          • 11.8 一个 Redis 实例最多能存放多少的 keys?List、Set、Sorted Set 他们最多能存放多少元素
                                                                                                                                                                                                                                                                                                                            • 11.9 Redis集群间是如何复制的
                                                                                                                                                                                                                                                                                                                              • 11.10 redis 的数据类型,以及每种数据类型的使用场景
                                                                                                                                                                                                                                                                                                                                • 11.11 redis 的过期策略以及内存淘汰机制
                                                                                                                                                                                                                                                                                                                                  • 11.12 Redis 集群最大节点个数是多少?
                                                                                                                                                                                                                                                                                                                                    • 11.13 为什么 Redis 的操作是原子性的,怎么保证原子性的?
                                                                                                                                                                                                                                                                                                                                      • 11.14 Redis 集群如何选择数据库?
                                                                                                                                                                                                                                                                                                                                        • 11.15 使用过 Redis 分布式锁么,它是什么回事
                                                                                                                                                                                                                                                                                                                                          • 11.16 为什么 Redis 是单线程的?
                                                                                                                                                                                                                                                                                                                                          • 12. Spring Boot
                                                                                                                                                                                                                                                                                                                                            • 12.1 什么是 Spring Framework?
                                                                                                                                                                                                                                                                                                                                              • 12.2 什么是 Spring 配置文件?
                                                                                                                                                                                                                                                                                                                                                • 12.3 Spring Framework 有哪些不同的功能?
                                                                                                                                                                                                                                                                                                                                                  • 12.4 什么是依赖注入?
                                                                                                                                                                                                                                                                                                                                                    • 12.5 spring 中有多少种 IOC 容器?
                                                                                                                                                                                                                                                                                                                                                      • 12.6 区分 BeanFactory 和 ApplicationContext?
                                                                                                                                                                                                                                                                                                                                                        • 12.7 列举 IoC 的一些好处
                                                                                                                                                                                                                                                                                                                                                          • 12.8 Spring IoC 的实现机制
                                                                                                                                                                                                                                                                                                                                                            • 12.9 spring 支持集中 bean scope?
                                                                                                                                                                                                                                                                                                                                                              • 12.10 什么是 spring 的内部 bean?
                                                                                                                                                                                                                                                                                                                                                                • 12.11 什么是 spring 装配
                                                                                                                                                                                                                                                                                                                                                                  • 12.13 spring bean 容器的生命周期是什么样的?
                                                                                                                                                                                                                                                                                                                                                                    • 12.14 自动装配有哪些方式?
                                                                                                                                                                                                                                                                                                                                                                      • 12.16 自动装配有什么局限?
                                                                                                                                                                                                                                                                                                                                                                        • 12.17 什么是基于注解的容器配置
                                                                                                                                                                                                                                                                                                                                                                          • 12.18 @Required 注解有什么用?
                                                                                                                                                                                                                                                                                                                                                                            • 12.19 spring DAO 有什么用?会抛出什么异常
                                                                                                                                                                                                                                                                                                                                                                              • 12.20 @RequestMapping 注解有什么用?
                                                                                                                                                                                                                                                                                                                                                                              • 13. Spring Cloud
                                                                                                                                                                                                                                                                                                                                                                                • 13.1 什么是 Spring Cloud?
                                                                                                                                                                                                                                                                                                                                                                                  • 13.2 负载平衡的意义什么?
                                                                                                                                                                                                                                                                                                                                                                                    • 13.3 什么是 Spring Cloud Bus?我们需要它吗?
                                                                                                                                                                                                                                                                                                                                                                                      • 13.4 什么是 Netflix Feign?它的优点是什么?
                                                                                                                                                                                                                                                                                                                                                                                        • 13.5 什么是服务熔断?什么是服务降级
                                                                                                                                                                                                                                                                                                                                                                                          • 13.6 Eureka 和 zookeeper 都可以提供服务注册与发现的功能,请说说两个的区别?
                                                                                                                                                                                                                                                                                                                                                                                            • 13.7 说说 RPC 的实现原理
                                                                                                                                                                                                                                                                                                                                                                                              • 13.8 微服务之间是如何独立通讯的?
                                                                                                                                                                                                                                                                                                                                                                                                • 13.9 REST 和 RPC 对比
                                                                                                                                                                                                                                                                                                                                                                                                  • 13.10 你所知道的微服务技术栈?
                                                                                                                                                                                                                                                                                                                                                                                                  • 14. RabbitMQ
                                                                                                                                                                                                                                                                                                                                                                                                    • 14.1 什么是 rabbitmq
                                                                                                                                                                                                                                                                                                                                                                                                      • 14.2 RabbitMQ 有什么优缺点?
                                                                                                                                                                                                                                                                                                                                                                                                        • 14.3 如何确保消息正确地发送至 RabbitMQ? 如何确保消息接收方消费了消息?
                                                                                                                                                                                                                                                                                                                                                                                                          • 14.4 为什么使用MQ
                                                                                                                                                                                                                                                                                                                                                                                                          • 15. MyBatis
                                                                                                                                                                                                                                                                                                                                                                                                            • 15.1 MyBatis 实现一对一有几种方式?具体怎么操作的?
                                                                                                                                                                                                                                                                                                                                                                                                              • 15.2 MyBatis 实现一对多有几种方式,怎么操作的?
                                                                                                                                                                                                                                                                                                                                                                                                                • 15.3 Mybatis 是否支持延迟加载?如果支持,它的实现原理是什么?
                                                                                                                                                                                                                                                                                                                                                                                                                  • 15.4 当实体类中的属性名和表中的字段名不一样 ,怎么办 ?
                                                                                                                                                                                                                                                                                                                                                                                                                    • 15.5 Mybatis 的一级、二级缓存:
                                                                                                                                                                                                                                                                                                                                                                                                                      • 15.6 通常一个 Xml 映射文件,都会写一个 Dao 接口与之对应,请问,这个 Dao 接口的工作原理是什么?
                                                                                                                                                                                                                                                                                                                                                                                                                      • 16. Zookeeper
                                                                                                                                                                                                                                                                                                                                                                                                                        • 16.1 什么是 Zookeeper?
                                                                                                                                                                                                                                                                                                                                                                                                                          • 16.2 zookeeper 的数据结构(树)
                                                                                                                                                                                                                                                                                                                                                                                                                            • 16.3 讲一下基于它实现的分布式锁
                                                                                                                                                                                                                                                                                                                                                                                                                              • 16.4 基于它实现的 Master 选举?
                                                                                                                                                                                                                                                                                                                                                                                                                                • 16.5 zookeeper 的注册(watch)机制和轮询机制的使用场景?
                                                                                                                                                                                                                                                                                                                                                                                                                                  • 16.6 ZAB 协议?
                                                                                                                                                                                                                                                                                                                                                                                                                                    • 16.7 Zookeeper 的同步过程,写操作流程,读操作流程
                                                                                                                                                                                                                                                                                                                                                                                                                                      • 16.8 ZK 的部署方式有哪几种?集群中的角色有哪些?集群中最少需要几台机器
                                                                                                                                                                                                                                                                                                                                                                                                                                        • 16.9 zk 节点宕机如何处理?
                                                                                                                                                                                                                                                                                                                                                                                                                                          • 16.10 zookeeper 负载均衡和 nginx 负载均衡区别
                                                                                                                                                                                                                                                                                                                                                                                                                                          • 17. 数据结构
                                                                                                                                                                                                                                                                                                                                                                                                                                            • 17.1 栈(stack)
                                                                                                                                                                                                                                                                                                                                                                                                                                              • 17.2 队列(queue)
                                                                                                                                                                                                                                                                                                                                                                                                                                                • 17.3 排序二叉树
                                                                                                                                                                                                                                                                                                                                                                                                                                                  • 17.4 前缀树
                                                                                                                                                                                                                                                                                                                                                                                                                                                    • 17.5 红黑树
                                                                                                                                                                                                                                                                                                                                                                                                                                                      • 17.6 散列表
                                                                                                                                                                                                                                                                                                                                                                                                                                                        • 17.7 B-TREE
                                                                                                                                                                                                                                                                                                                                                                                                                                                          • 17.8 位图
                                                                                                                                                                                                                                                                                                                                                                                                                                                            • 17.9 链表(Link)
                                                                                                                                                                                                                                                                                                                                                                                                                                                              • 17.10 栈和队列的共同特点是?
                                                                                                                                                                                                                                                                                                                                                                                                                                                                • 17.11 栈通常采用的两种存储结构是?
                                                                                                                                                                                                                                                                                                                                                                                                                                                                • 18. 算法
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • 18.1 数据里有{1,2,3,4,5,6,7,8,9},请随机打乱顺序,生成一个新的数组(请以代码实现)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • 18.2 给定一个数组 nums,编写一个函数将所有 0 移动到数组的末尾,同时保持非零元素的相对顺序。
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • 18.3 二分查找
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • 18.4 冒泡排序算法
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • 18.5 插入排序算法
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • 18.6 快速排序算法
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • 18.7 希尔排序算法
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • 18.8 归并排序算法
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • 18.9 桶排序算法
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • 18.10 基数排序算法
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • 19. Elasticsearch
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • 19.1 Elasticsearch
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • 19.2 ES的集群架构
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • 19.3 elasticsearch 索引数据多了怎么办,如何调优,部署
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • 19.3 详细描述一下 Elasticsearch 索引文档的过程
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • 19.4 ES的倒排索引是什么?
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • 19.4 ES是如何实现master选举的
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • 成长之路.1
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • 线程
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • 游戏术语
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • ConcurrentHashMap
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • ES
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • HashMap-01
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • HashMap-02
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • IO模型
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • JDK新特性
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • jvm
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • RabbitMQ
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • redis缓存
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      联系我 | Copyright © 2018-present Jingxc
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Copyright © 2024 Jingxc