Stream模板

中间方法

中间方法的特点惰性求值：中间操作不会立即执行，而是返回一个新的流。实际的计算会在遇到终结方法时进行。可以链式调用：多个中间操作可以链接在一起，形成一个操作链。返回类型：所有的中间操作返回的都是一个 Stream 对象。

Stream中间代码

功能：过滤流中的元素，仅保留满足给定条件的元素。
// 示例：
Stream.of(1, 2, 3, 4, 5)
      .filter(n -> n % 2 == 0) // 只保留偶数
      .forEach(System.out::println);//打印功能：将流中的元素映射为其他形式（通常是不同类型）。
// 示例：
Stream.of("a", "b", "c")
     .map(String::toUpperCase) // 将每个字符串转换为大写功能：将流中的每个元素映射为一个流，并将所有流连接成一个流。示例：Stream<List<String>> listStream = Stream.of(Arrays.asList("a", "b"), Arrays.asList("c", "d"));
listStream
    .flatMap(List::stream) // 将嵌套列表展平为一个流
    .forEach(System.out::println);功能：去除流中的重复元素。示例：Stream.of(1, 2, 2, 3, 4, 4)
     .distinct()
     .forEach(System.out::println); // 输出 1, 2, 3, 4功能：对流中的元素进行排序。示例：Stream.of(5, 3, 1, 4, 2)
     .sorted() // 默认升序排序
     .forEach(System.out::println);功能：截取流中的前 maxSize 个元素。示例：Stream.of(1, 2, 3, 4, 5)
     .limit(3) // 只保留前 3 个元素
     .forEach(System.out::println);功能：跳过流中的前 n 个元素。示例：Stream.of(1, 2, 3, 4, 5)
     .skip(2) // 跳过前 2 个元素
     .forEach(System.out::println); // 输出 3, 4, 5下面是一个示例，展示了多种中间方法的使用：import java.util.Arrays;
import java.util.List;

Stream.of(1, 2, 3, 4, 5)
.filter(n -> n % 2 == 0) // 只保留偶数
.forEach(System.out::println);//打印

Stream.of("a", "b", "c")
     .map(String::toUpperCase) // 将每个字符串转换为大写

Stream<List<String>> listStream = Stream.of(Arrays.asList("a", "b"), Arrays.asList("c", "d"));
listStream
    .flatMap(List::stream) // 将嵌套列表展平为一个流
    .forEach(System.out::println);

Stream.of(1, 2, 2, 3, 4, 4)
     .distinct()
     .forEach(System.out::println); // 输出 1, 2, 3, 4

Stream.of(5, 3, 1, 4, 2)
     .sorted() // 默认升序排序
     .forEach(System.out::println);

Stream.of(1, 2, 3, 4, 5)
     .limit(3) // 只保留前 3 个元素
     .forEach(System.out::println);

Stream.of(1, 2, 3, 4, 5)
     .skip(2) // 跳过前 2 个元素
     .forEach(System.out::println); // 输出 3, 4, 5

import java.util.Arrays;
import java.util.List;
public class StreamIntermediateOperations {
    public static void main(String[] args) {
        List<String> names = Arrays.asList("Alice", "Bob", "Charlie", "David", "Eve");

    // 使用中间方法
    names.stream()
        .filter(name -&gt; name.startsWith(&quot;A&quot;)) // 过滤以 'A' 开头的名字
        .map(String::toUpperCase) // 将名字转换为大写
        .sorted() // 排序
        .forEach(System.out::println); // 输出结果
}

}

Stream.of("a", "b", "c").forEach(System.out::println);

List<String> list = Stream.of("a", "b", "c").collect(Collectors.toList());

int sum = Stream.of(1, 2, 3, 4).reduce(0, Integer::sum);

long count = Stream.of("a", "b", "c").count();

boolean hasA = Stream.of("a", "b", "c").anyMatch(s -> s.equals("a"));

boolean allMatch = Stream.of(1, 2, 3).allMatch(n -> n < 5);

Optional<String> first = Stream.of("a", "b", "c").findFirst();

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;


public class StreamTerminalOperations {
    public static void main(String[] args) {
        List<String> names = Arrays.asList("Alice", "Bob", "Charlie", "David");
    // forEach
    names.stream().forEach(System.out::println);

    // collect
    List&lt;String&gt; filteredNames = names.stream()
        .filter(name -&gt; name.startsWith(&quot;A&quot;))
        .collect(Collectors.toList());
    System.out.println(filteredNames);

    // reduce
    String concatenated = names.stream()
        .reduce(&quot;&quot;, (a, b) -&gt; a + b);
    System.out.println(concatenated);
    
    // count
    long count = names.stream().count();
    System.out.println(&quot;Count: &quot; + count);
    
    // findFirst
    String firstName = names.stream().findFirst().orElse(&quot;No Name&quot;);
    System.out.println(&quot;First Name: &quot; + firstName);
}

}

stream流超强引用

package com.itheima.pojo.test;

import java.util.*;
import java.util.stream.Collectors;

/**
 * Arrays.asList 是 Java 中 java.util.Arrays 类的一个静态方法，
 * 用于将指定的数组或可变数量的参数转换为一个固定大小的 List。
 * 这个 List 是 ArrayList 的一个内部实现类，
 * 但它不是 java.util.ArrayList，
 * 而是一个不可变的列表
 */
public class Test2 {
    public static void main(String[] args) {
        // List<String> list：将上述列表赋值给 list 变量
        List<String> list = Arrays.asList("apple", "banana", "orange");
        // 定义一个映射，键为整数，值为字符串列表 = 创建一个新的空哈希映射
        // 键的类型是 Integer，值的类型是 List<String> 表示具有相同长度的字符串列表
        // 用HashMap  允许 null 值：键和值都可以为 null，但键只能有一个 null。
        Map<Integer, List<String>> groups = new HashMap<>();
        for (String s : list) {
            int length = s.length();
            // 检查 groups 映射中是否已经存在键为 length 的条目
            if (!groups.containsKey(length)) {
                // 将新创建的列表作为值，以 length 为键添加到 groups 映射中
                // 创建一个新的 ArrayList，并将当前字符串 s 添加到其中
                groups.put(length, new ArrayList<>(Arrays.asList(s)));
            } else {
                // 从 groups 映射中获取键为 length 的列表
                List<String> group = groups.get(length);
                group.add(s);
            }
            System.out.println(groups);
        }

        // 使用 Stream API 进行分组
        // 使用 Collectors.groupingBy 方法按字符串长度进行分组
        // 将分组结果收集到一个新的映射 group2 中。
        Map<Integer, List<String>> group2 = list.stream().collect(Collectors.groupingBy(String::length));
        System.out.println(group2);
    }
}

Lambda+Stream实用方法

// 创建一个包含字符串的列表
List<String> List = Arrays.asList("apple","banana", "orange");
1.for循环输出
for (String s : list){
System.out.println(s);}

2.表达式输出   
list.forEach(s ->
System.out.println(s);});

3.表达式最简洁输出
List.forEach(System.out::println);

// 创建一个包含字符串的列表
List<String> list = Arrays.asList("apple","banana", "orange");

1.使用重写Collections 排序
Collections.sort(list,new Comparator<String>（） {
@override
public int compare(String o1, String o2) {
return o1.compareTo(o2);
}
});

2.使用lambda表达式排序
Collections.sort(list,(o1,o2) ->{
    return o1.compareTo(o2)
});

3.使用最简洁的表达式
Collections.sort(list,(o1,o2) ->{o1.compareTo(o2)});

// 创建一个包含字符串的列表
List<String> list = Arrays.asList("apple","banana", "orange");

1.普通方式过滤
List<String> list2 = new ArrayList<>();
List<String s : list2){
if(s.startsWith("a")){
     list2.add(s);
} }

2.使用 Stream API 进行过滤和收集,过滤以 'a' 开头的字符串,收集结果到一个新的 List 中
List<String>list3 = list.stream().filter(s - > s.startsWith("a")).collect(Collectrs.toList());

// 创建一个包含字符串的列表
List<String> list = Arrays.asList("apple","banana", "orange");

1.普通方式获取长度
List<Integer> List2 = new ArrayList<>();
for （String s:list){
    
list2.add(s.length());}

2.Lambda表达式+stream流获取长度
(map)这个函数对我们管道中的每个元素做了处理，在此处为把string转换为Integer类型 主要进行转换作用
List<Integer> list3 = list.stream().map(s -> s.length()).collect(Collectors.toList());

//新建一个List集合
List<Integer> list = Arrays.asList（1,2, 3, 4, 5);
1.普通方式相加操作
int sum =0;
for (Integer v : list) {
SUm +=V  }
System.out.println(sum);

2.Lambda+stream
(表达式含义)：【0】操作的起始值，【a = a+b】 循环下去
int sum2 = list.stream().reduce( identity: 0, (a, b) -> a + b);
System.out.println(sum2)

//新建一个集合
List<String> list = Arrays.asList("apple", "banana", "orange");

Map<Integer,List<String>> groups = new HashMap<>();

1.普通方式分组
for （String s:list){
int length = s.length();
if (!groups.containsKey(length)){
groups.put(length,new ArrayList<>());
}
groups.get(Length) .add(s);
}
    System.out.println(groups);

2.Lambda+stream分组
Map<Integer,List<String>> groups2 = list.stream().collect(Collectors.groupingBy(String::length));
System.out.println（groups2）

1.普通方式创建线程

Thread thread = newThread(new Runnable(){
@Override
public void run(){
System.out.println("hello world");
}
});
thread.start();

2.Lambda表达式

Thread thread1 = new Threal(() -> System.out.println(hello world"));
thread1.start();

1.创建接口
interface  MyInterface{
public void doSomething(String s);}

2.普通实现接口
MyInterface myInterface = new MyInterface{
    @override
    public void doSomething(String s){
    System.out.println(s);
    }
};
myInterface.doSomething( s:"hello world");

3.Lambda表达式实现接口
MyInterface myInterface1 = (s) -> System.out.println(s);
myInterface1.doSomething( s:"hello worLd")

String str = "hello world";

1.普通方式
if（str !=null）{
System.out.println(str.toUpperCase());}

2.Lambda表达式
Optional.ofNuLlable(str).map(String::toUpperCase).ifPresent(System.out::println);

List<String> List = Arrays.asList("apple","banana", "orange");
1.普通方式
List<String> list2 = new ArrayList<>();
for （String s:list2){ //遍历循环
    if （s.startsWith("a")){ //取出 包含a的元素
        list2.add(s.toUpperCase());//添加到list2中然后转换为大写
    }
}       Collections.sort(list2); //排序

2.Lambda+stream方式

List<String> list3 = list.stream().filter(s -> s.startsWith("a"))
.map(String::toupperCase).sorted().collect(collectors.toList());

public class Dept {
    private int id;

    public Dept(int id) {
        this.id = id;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    @Override
    public String toString() {
        return "Dept{id=" + id + "}";
    }
}

public class TestCollectStopOptions {

    public void testCollectStopOptions() {
        // 创建一个包含 Dept 对象的列表
        List<Dept> ids = Arrays.asList(new Dept(17), new Dept(22), new Dept(23));

        // 使用 Stream API 过滤 id 大于 20 的 Dept 对象，并收集到 List 中
        List<Dept> collectList = ids.stream()
                                   .filter(dept -> dept.getId() > 20)
                                   .collect(Collectors.toList());
        System.out.println("collectList: " + collectList);

        // 使用 Stream API 过滤 id 大于 20 的 Dept 对象，并收集到 Set 中
        Set<Dept> collectSet = ids.stream()
                                 .filter(dept -> dept.getId() > 20)
                                 .collect(Collectors.toSet());
        System.out.println("collectSet: " + collectSet);

        // 使用 Stream API 过滤 id 大于 20 的 Dept 对象，并收集到 Map 中，key 为 id，value 为 Dept 对象
        Map<Integer, Dept> collectMap = ids.stream()
                                          .filter(dept -> dept.getId() > 20)
                                          .collect(Collectors.toMap(Dept::getId, dept -> dept));
        System.out.println("collectMap: " + collectMap);
    }

    public static void main(String[] args) {
        new TestCollectStopOptions().testCollectStopOptions();
    }
}

结果

collectList:[Dept{id=22}, Dept{id=23}]
collectSet:[Dept{id=23}, Dept{id=22}]
collectMap:{22=Dept{id=22}, 23=Dept{id=23}}

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

public class User {
    private String id;

    public User() {
    }

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    @Override
    public String toString() {
        return "User{id='" + id + '\'' + '}';
    }
}

public class TestStringToIntMap {

    /**
     * 演示map的用途：一对一转换
     */
    public void stringToIntMap() {
        // 创建一个包含字符串 ID 的列表
        List<String> ids = Arrays.asList("205", "105", "308", "469", "627", "193", "111");

        // 使用流操作
        List<User> results = ids.stream()
                               .map(id -> {
                                   // 创建一个新的 User 对象
                                   User user = new User();
                                   // 设置 User 对象的 id 属性
                                   user.setId(id);
                                   // 返回 User 对象
                                   return user;
                               })
                               .collect(Collectors.toList()); // 收集结果到一个新的 List 中

        // 打印结果
        System.out.println(results);
    }

    public static void main(String[] args) {
        new TestStringToIntMap().stringToIntMap();
    }
}

@注释笔记

@RequestBody ：获取请全体json字符串数据 封装给java对象，封装的前提是 json字符串属性要与实体类属性名一致才可以封装。

—————————————————————————————–

#{name} 占位符 会从方法参数 对象里面调用getname封装方法获取数据映射到占位符位置。

#{参数名} 是Mybatis的参数占位符，可以自动将参数映射到SQL语句去执行

参数名要与接口方法的参数名要一致，但是方法只有一个参数时，参数名可以是任意的。

—————————————————————————————–

Spring MVC 的 @RequestMapping 注解能够处理 HTTP 请求的方法, 比如 GET, PUT, POST, DELETE 以及 PATCH。

所有的请求默认都会是 HTTP GET 类型的。比如@GetMapping

加入路径处理前端响应

—————————————————————————————–

注解@RequiredArgsConstructor 是 Lombok 提供的一个注解，其主要作用在于简化 @Autowired 的书写过程。在编写 Controller 层或 Service 层代码时，常常需要注入众多的 mapper 接口或 service 接口。若每个接口都使用 @Autowired 进行标注，代码会显得繁琐。而 @RequiredArgsConstructor 注解能够替代 @Autowired 注解，但需注意，在类上添加 @RequiredArgsConstructor 时，需要注入的类必须使用 final 进行声明。

—————————————————————————————–

<font style="color:#000000;background-color:rgb(249, 242, 244);">@Repository</font> ：<font style="color:#000000;background-color:rgb(249, 242, 244);">@Repository</font>的作用与<font style="color:#000000;background-color:rgb(249, 242, 244);">@Controller</font>，<font style="color:#000000;background-color:rgb(249, 242, 244);">@Service</font>的作用都是把对象交给<font style="color:#000000;background-color:rgb(249, 242, 244);">Spring</font>管理。<font style="color:#000000;background-color:rgb(249, 242, 244);">@Repository</font>是标注在<font style="color:#000000;background-color:rgb(249, 242, 244);">Dao</font>层接口上，作用是将接口的一个实现类交给<font style="color:#000000;background-color:rgb(249, 242, 244);">Spring</font>管理。

—————————————————————————————–

@Mapper

@Mapper: 这个注解一般使用在Dao层接口上，相当于一个mapper.xml文件，它的作用就是将接口生成一个动态代理类。加入了@Mapper注解，目的就是为了不再写mapper映射文件。这个注解就是用来映射mapper.xml文件的。

使用@mapper后，不需要在spring配置中设置扫描地址，通过mapper.xml里面的namespace属性对应相关的mapper类，spring将动态的生成Bean后注入到ServiceImpl中

注意：

在Dao层不要存在相同名字的接口，也就是在Dao不要写重载。因为mapper文件是通过id与接口进行对应的，如果写了两个同名的接口，就会导致mapper文件映射出错。

—————————————————————————————–

@Transactional

Spring事务管理-控制事务 注解:@Transactional

作用:将当前方法交给spring进行事务管理，方法执行前，开启事务;成功执行完毕，提交事务;出现异常，回滚事务 放在类上 则是整个类都会启动事务 放在接口上 接口的实现类都会去启动事务。放在方法上此方法中的代码会启动事务。

—————————————————————————————–

规则:JSON数据的键名与方法形参对象的属性名相同，并需要使用@RequestBody注解标识。

—————————————————————————————–

MultipartFile 接收文件接口

—————————————————————————————–

@Service 表明这个是逻辑层 可以被调用

—————————————————————————————–

@ConfigurationPropertise（）

—————————————————————————————–

@Autowired 注入bean

—————————————————————————————–

集合:@RequestParam[List ids

—————————————————————————————–

是一个在Java项目中常用的注解，特别是在使用日志框架如SLF4J时，通过在你的类上使用@Slf4j注解，Lombok会自动为你的类生成一个静态的日志字段，这个字段通常是org.slf4j.Logger类型的，并且通常命名为log。这样，你就可以在类中直接使用log.info(), log.error(), log.debug()等方法来记录日志，而无需手动声明和初始化Logger对象。

—————————————————————————————–

@PathVariable 是 Spring MVC 中用于将 URL 模板变量绑定到你控制器处理器方法参数上的注解。这个注解使得你可以从 URL 中提取出变量值，并将其作为参数传递给控制器的方法。

—————————————————————————————–

@RequestParam(defaultValue = “1”) 给参数设置默认值 如果前端没有参数传进来 默认值为1 可自己设置

—————————————————————————————–

@RequestBody 注解 使用对象去接收 的时候使用的注解

—————————————————————————————–

@RestControllerAdvice

—————————————————————————————–

@ExceptionHandler

—————————————————————————————–

限制请求的方式

@RequestMapping 可以放在类上，获取的路径可以当做所有方法的父路径

@PostMapping(value=”/depts”,method=RequestMethod.GET)注解 可以放方法上，获取前端的路径。

@GetMapping（”/depts”）

@PutMapping

@DeleteMapping

—————————————————————————————–

junnit5

@Test

@ParameterizedTest

@BeforeEach

@AfterEach

@BeforeAll 标识静态方法

@AfterAll 标识静态方法

—————————————————————————————–

@RestController = @Controller+@ResponseBody

标识当前控制类所有方法都有了@ResponseBody

@ResponseBody 将控制器方法直接输出给前端，将java对象转换为json字符串输出给前端

—————————————————————————————–

lombok

—————————————————————————————–

在定义完Filter之后，Filter其实并不会生效，还需要完成Filter的配置，Filter的配置非常简单，只需要在Filter类上添加一个注解：<font style="color:rgb(51, 51, 51);background-color:rgb(243, 244, 244);">@WebFilter</font>，并指定属性<font style="color:rgb(51, 51, 51);background-color:rgb(243, 244, 244);">urlPatterns</font>，通过这个属性指定过滤器要拦截哪些请求。

当我们在Filter类上面加了@WebFilter注解之后，接下来我们还需要在启动类上面加上一个注解@ServletComponentScan，通过这个@ServletComponentScan注解来开启SpringBoot项目对于Servlet组件的支持。

@Order注解 控制过滤器优先级数字越小 优先级越高

—————————————————————————————–

Spring Boot 中注解的作用

Spring Boot 利用注解来简化配置和提高开发效率。主要注解包括但不限于：

@SpringBootApplication: 启动 Spring Boot 应用程序。

@Component, @Service, @Repository, @Controller: 标记组件，以便 Spring 容器可以自动检测和管理它们。

@Bean 该方法会在spring项目启动时自动调用，并将方法的返回值交给IOC容器管理 – bean对象

@Autowired: 用于自动装配 Bean。

@Bean: 在配置类中定义 Bean。

@Configuration: 定义配置类。

@EnableAutoConfiguration: 开启自动配置。

这些注解通常被组合使用，以提供一个高度可配置且易于扩展的应用程序结构。

12. @PathVariable, @RequestParam, @ModelAttribute, @RequestBody, @ResponseBody

参数绑定

这些注解用于从 HTTP 请求中提取参数，并将它们绑定到方法参数上。

@PathVariable: 用于从 URL 中提取路径变量。

@RequestParam: 用于从查询字符串中提取参数。

@ModelAttribute: 用于将多个请求参数绑定到一个对象上。

@RequestBody: 用于将请求体中的数据绑定到方法参数上。 获取请求体json字符串数据封装给java对象

@ResponseBody: 用于将方法的结果直接写入响应体。

13. @RestController

控制器注解

@RestController 注解是一个组合注解，它等价于 @Controller 和 @ResponseBody 的组合。它表示这是一个 REST 控制器，所有返回值都将被序列化为 JSON 格式并直接写入 HTTP 响应体。

全局异常处理

<font style="color:rgb(199, 37, 78);background-color:rgb(249, 242, 244);">@ControllerAdvice</font> 注解用于定义全局异常处理类，它可以捕获控制器方法抛出的所有异常，并提供统一的错误响应。

@RunWith(SpringRunner.class)

测试运行器

@RunWith(SpringRunner.class) 注解告诉 JUnit 使用 Spring 测试运行器 (SpringRunner) 来运行测试。Spring 测试运行器提供了一种方便的方式来加载 Spring 上下文并管理测试生命周期。

整体测试

<font style="color:rgb(199, 37, 78);background-color:rgb(249, 242, 244);">@SpringBootTest</font> 注解用于执行整体测试，它会加载整个 Spring 应用上下文，包括所有自动配置的 Bean。这对于集成测试非常有用，因为它可以模拟完整的 Spring Boot 应用程序。

@Configuration 用于定义配置类，配置类中的bean可以自动装配到其他bean中

@Configuration类可以使用其他Spring注解，如@ComponentScan和@Import，来扫描组件或导入其他配置类

@Configuration类在Spring容器启动时会通过CGLIB动态代理机制生成代理类，以确保@Bean方法只被调用一次，从而保证单例bean的行为

环境和属性配置：
使用@PropertySource和@Value注解可以将外部属性文件中的值注入到配置类中

—————————————————————————————–

作用:按照一定的条件进行判断，在满足给定条件才会注册对应的bean对象到Spring IOC容器中。

位置:方法、类

@Conditional 本身是一个父注解，派生出大量子注解

@ConditionalonClass:判断环境中是否有对应节码文件才注册bean到IOC容器

对应的bean(类型或名称)，才注册bean到IOC容器@ConditionalOnMissingBean:判断环境中没@ConditionalonProperty:判断配置文件中有应属性和值，才注册bean到IOC容器。

—————————————————————————————–

SpringBoot 底层原理

bean获取。

@singleton 默认容器内同名称的bean只有一个实例（单例）

@prototype 每次使用该bean时会创建新的实例（非单例）

@request 每个请求范围内会创建新的实例（web环境中，了解即可）

@session 每个会话范围内都会创建新的实例（web环境中，了解）

@application 每个应用范围内会创建新的实例（web环境中，了解）

@Scope 设置bean的作用域

@Lazy 延迟加载 会延迟到第一次使用的时候才会去加载

默认singleton的bean，在容器启动时被创建，可以使用aLazy注解来延迟初始化(延迟到第一次使用时)

prototype的bean，每一次使用该bean的时候都会创建一个新的实例。

实际开发当中，绝大部分的Bean是单例的，也就是说绝大部分Bean不需要配置scope属性

– 非单例是每次使用时会创建一个全新的bean

@Import 是 Java 中 Spring 框架（特别是 Spring Framework 和 Spring Boot）中用于配置类的一个注解。它主要用于导入其他配置类，使得当前的配置类能够复用其他配置类中的配置信息，从而避免重复的配置代码。

<font style="color:rgb(5, 7, 59);">@Conditional</font> 是 Spring Framework 中的一个注解，它用于在自动配置类（@Configuration 类）中或者通过 <font style="color:rgb(5, 7, 59);">@Bean</font> 方法定义 bean 时，根据特定的条件来决定是否创建某个 bean 或配置。这个注解使得 Spring 的自动配置更加灵活和强大，因为它允许开发者基于特定的条件（如类路径上的特定类、操作系统属性、环境变量等）来启用或禁用配置。

—————————————————————————————–

@Transactional注解书写位置：

• 方法
  • 当前方法交给spring进行事务管理
• 类
  • 当前类中所有的方法都交由spring进行事务管理 （推荐）
• 接口
  • 接口下所有的实现类当中所有的方法都交给spring 进行事务管理

—————————————————————————————–

• @Data是lombok注解,可以生成getter/setter方法,tostring/hashcode/equals等方法重写

  @NoArgsConstructor /添加无参构造
  
  @AllArgsConstructor //添加全参构造
  

—————————————————————————————–

@ResponseBody: 将控制器方法返回值直接输出给前端，将java对象转换为json字符串输出给前端@RestController = @controller + @ResponseBody

标识了当前控制器类所有方法就都有了@ResponseBody

@Controller : spring框架的ioc注解，用于给当前类创建实例对象，也就是加入ioc容器中。

@Autowired ：依赖注入注解:在运行时会从spring容器中找当前接口实现类对象并注入

@Qualifier(“Bean对象”)：指定Bean别名这与对象

@Qualifier常与@Autowired一起使用

@0ptions(useGeneratedKeys = true，keyProperty =”id”)//需要获取数据库赋值的id属性 并赋值给对象的id

—————————————————————————————–

常用方法模板集合

@Test
1:JsONUtil.toJsonStr(paramMap)//将任意对象转换为json字符串形式
                     
//使用hutool工具类把BedDto类型转换成Bed实体类 类型
2:Bed bean = BeanUtil.toBean(bedDto, Bed.class);

//判断对象是否为null 如果为null 返回true
3:Objects.isNull(xx)

//判断对象是否不为null 如果不为null 返回true
4:Objects.nonNull(xx)
                  
//工具类Objects 专门用来解决空指针异常 意思 先判断s1！=null 在调用s1.equals(s2)
5:Objects.equals(s1,s2)

//强转方法
6:String.valueOf() 

//整个对象的转换方法
7:BeanUtils.copyProperties(user,userPojo) 

8:StringUtils.toStringArray(把括号中的内容转换为一个字符串类型数组)

//在java中，JSONOBject类中的get（String key）方法接收一个字符串参数作为键名，用于从JSON对象中获取对应的值，这种方法运行通过建模来检索特定的数据项
//当我们调用JSONOBject.get("acces_token")的时候，实际上是在告诉程序：请查找名为“access_token”的键，并返回其关键的值，
//如果找到匹配的键，则返回相应的值，如果没有找到，则返回null
9:JSONOBject.get("acces_token")
//建造者设计模式：利用各种组件（各种属性）随意组合生成对象，目的是创建对象更加灵活
//与直接调用构造函数对比
//类一般要提供很多构造函数才可以灵活构建对象，这种方式很麻烦
//建造者模式创建对象底层只需需要提供一个构造函数即可，在使用的时候想设置哪个属性就设置哪个属性，最终都调用同一个构造函数
@Data
@AllArgsConstructor
@NoArgsConstructor
@Builder给当前类添加建造者设计模式创建对象    这几个注解都要有
10：member = Member.builder()
.openId(openid)
.build();

@Author yuan

Git作用

Git 作用

代码回溯 版本控制 多人协作 远程备份

Git 简介

Git 是一个分布式版本控制工具，通常用来对软件开发过程中的源代码文件进行管理。通过Git 仓库来存储和管理这些文件，Git 仓库分为两种:

本地仓库:开发人员自己电脑上的 Git 仓库

远程仓库:远程服务器上的 Git 仓库

commit:提交,将本地文件和版本信息保存到本地仓库

push:推送,将本地仓库文件和版本信息上传到远程仓库

pull:拉取,将远程仓库文件和版本信息下载到本地仓库

常用的 Git 代码托管服务

Git中存在两种类型的仓库，即本地仓库和远程仓库。那么我们如何搭建Git远程仓库呢?

我们可以借助互联网上提供的一些代码托管服务来实现，其中比较常用的有GitHub、码云、GitLab等。

获取Git 仓库-从远程仓库克隆

可以通过Git提供的命令从远程仓库进行克隆，将远程仓库克隆到本地命令形式:git clone【远程Git仓库地址】

工作区、暂存区、版本库 概念

版本库:前面看到的.git隐藏文件夹就是版本库，版本库中存储了很多配置信息、日志信息和文件版本信息等工作区:包含.git文件夹的目录就是工作区，也称为工作目录，主要用于存放开发的代码暂存区:.git文件夹中有很多文件，其中有一个index文件就是暂存区，也可以叫做stage。暂存区是一个临时保存修改文件的地方

Git工作区中文件的状态

Git工作区中的文件存在两种状态:untracked 未跟踪(未被纳入版本控制)

tracked 已跟踪(被纳入版本控制)

1.Unmodified 未修改状态

2.Modified 已修改状态

3.Staged 已暂存状态

本地仓库操作

本地仓库常用命令如下:

git status 查看文件状态

git add 将文件的修改加入暂存区

git reset 将暂存区的文件取消暂存或者是切换到指定版本

git commit 将暂存区的文件修改提交到版本库

git log 查看日志

Git项目克隆

在IDEA中克隆Git项目

首先配置Git

说明：如果Git安装在默认目录中（C:\Program Files\Git），则IDEA中无需再手动配置，直接就可以使用。

第一步：

第二步：

第三步：

第四步：

第五步：

第六步：

红色:未跟踪文件

绿色:已暂存文件

蓝色:已修改文件

黑色:未修改文件

标签

1.创建一个标签

确认标签名：

添加成功：

推送到远程仓库：

分支操作

分支操作:

查看分支，本质就是执行 gitbranch 命令

创建分支，本质就是执行 git branch 分支名

命令切换分支，本质就是执行 git checkout命令

将分支推送到远程仓库，本质就是执行 git push 命令

合并分支，本质就是执行 git merge 命令

IDEA中查看分支在右下角，如图

新建分支

新建分支推送

切换分支：

合并分支：

合并分支后需要推送到远程仓库同步

切换版本开发

切换版本：

在开发过程中，有a1到a5这几个版本的项目，现在需要重新基于a3去开发后续项目。基于这种情况，我们可以右键这个版本的项目，新建分支进行开发。

新建分支：

提交 && 拉取 && 冲突

1.提交

2.推送

3.拉取

4.提交推送2

5.拉取

操作冲突：多个人操作同一个文件，其中有人基于旧的版本修改，提交新版本会成功，但是推送到远程会失败，就是发送冲突。

冲突为什么发生：a和b同时修改c1文件，a先修改完成c1文件，提交推送到远程仓库，c1文件进行更新版本成为c2，提交推送后b也修改完成c1文件，提交的时候成功 推送则失败，因为远程仓库的文件已经进行了更新。b推送的时候没有拉取最新的文件进行修改，而是使用的过期版本，所以造成冲突。

解决冲突，拉取，合并，推送

操作冲突：

解决冲突操作：1

解决冲突操作：2

解决冲突操作：3

解决冲突操作：4

推送合并后的项目到远程仓库

RuoYi-Vue

• RuoYi-Vue版本，采用了前后端分离的单体架构设计
  https://gitee.com/ys-gitee/RuoYi-Vue3
  https://gitee.com/y_project/RuoYi-Vue

• 技术选型：SpringBoot、SpringSecurity、MyBatis、Jwt、VUE3、Element-Plus

1. 从VCS导入项目：

   • 点击VCS菜单。

   • 选择Get from Version Control...选项。

   • URL：https://gitee.com/y_project/RuoYi-Vue.git
     Directory：C:\Users\Pluminary\Desktop\RuoYi-Vue
     

2. 输入项目地址：

   • 在弹出的窗口中，您可以看到不同的版本控制系统（例如Git, SVN等）。
   • 选择您要导入的项目所使用的版本控制系统。
   • 在接下来的窗口中，您需要输入项目的URL地址。这通常是项目的仓库地址，例如Git仓库的HTTPS或SSH链接。

① 若模块没有导入进去没有亮 就Maven → clean → package

C:\Users\Pluminary\Desktop\RuoYi-Vue\sql 导入Sql文件两个
sql/quartz.sql
sql/ry_20240629.sql

先gitwzs28150/RuoYi-Vue3: :tada: (RuoYi)官方仓库 基于SpringBoot，Spring Security，JWT，Vue3 & Vite、Element Plus 的前后端分离权限管理系统下载这里面的资料，在里面C:\Users\Pluminary\Desktop\itcast>code ./RuoYi-Vue3导入vscode里面，再安装依赖(要进入Vue3里面才能利用package.json去生成)npm install → 运行前端项目npm run dev

// npm install慢的话 就用中国镜像去下载
npm install --registr=https://registry.npmmirror.com

C:\Users\Pluminary\Desktop\itcast\RuoYi-Vue3>npm run dev

> ruoyi@3.8.8 dev
> vite


  VITE v5.3.2  ready in 2026 ms

  ➜  Local:   http://localhost:8080/
  ➜  Network: http://10.254.3.124:8080/
  ➜  Network: http://192.168.104.38:8080/
  ➜  Network: http://192.168.22.1:8080/
  ➜  Network: http://192.168.36.1:8080/
  ➜  press h + enter to show help

再导入课程管理.sql数据库 → 在若依的后台系统 → 系统工具 → 代码生成 → 配置好后下载代码 → 导入数据库

→ 导入RuoYi生成的前端代码C:\Users\Pluminary\Downloads\ruoyi\vue\api 的course导入vscode中 C:\Users\Pluminary\Desktop\itcast\RuoYi-Vue3\src\api\course && C:\Users\Pluminary\Downloads\ruoyi\vue\views 的course导入vscode中 C:\Users\Pluminary\Desktop\itcast\RuoYi-Vue3\src\api\course

→ 导入RuoYi生成的后端代码C:\Users\Pluminary\Desktop\itcast\RuoYi-Vue3\src\views\course的com 并且导入配置文件 && C:\Users\Pluminary\Downloads\ruoyi\main\resources的mapper导入到idea的resource中

功能详解

权限控制

• 若依内置了强大的权限控制系统，为企业级项目提供了通用的解决方案
  • **demo账号 (超级管理员)**，查看所有功能菜单
  • **zhangsan账号 (市场专员)**，查看线索菜单
  • **yueyue账号 (销售专员)**，查看商机、合同等菜单
• RBAC (基于角色的控制访问) 是一种广泛使用的访问控制模型，通过角色来分配和管理用户的菜单权限

创建新用户小智并关联课研人员角色，仅限课程管理和统计分析菜单访问。

① 创建菜单
② 创建角色，并分配权限课研人员
③ 创建用户，并关联角色xiaozhi

若依通过简单的功能配置实现RBC的权限管理

数据字典

• 若依内置的数据字典，用于维护系统中常见的静态数据。例如：性别、状态
• 功能包括：字典类型管理、字典数据管理
• 表关系说明【一对多】

• 将一些不经常修改的数据(课程管理的学科字段)改为数据字典维护，以免占用大量空间

  • 添加字典类型和数据

    系统管理 → 字典管理 → 新增 → 添加字典类型
    字典名称：学科
    字典类型：course_subject
    第二页点进去添加字典数据
    javaEE → 0 → 1

  • 修改代码生成信息

    系统工具 → 代码生成 → 编辑课程管理 → subject课程学科 显示类型从文本框改成下拉框 → 字典类型 是学科 → 下载最新的代码
    只需要修改前端vue组件 因为只改了从前端文本框到下拉框 和一些数据字典

  • 下载代码，导入前端

    C:\Users\Pluminary\Downloads\ruoyi (1)\vue\views\course\course\index.vue去替换前端的index.vue 此时去若依前端查看课程管理→课程学科就会发现已经添加新的进去了

此时去课程管理里面找课程学科：JavaEE进行筛选不会出 因为若依底层
http://10.254.2.179/dev-api/course/course/list?pageNum=1&pageSize=10&subject=0
要从数据库里把JavaEE的subject改成0
优点：降低数据库的存储压力 提高磁盘利用率

其他功能

• 参数设置：对系统中的参数进行动态维护

  系统管理 → 参数设置 → 验证码开关 → 修改 → 参数键值 → false
  还可以开启是否 用户注册功能 → 前端代码隐藏需要修改 → src/views/login.vue → 97行注册开关
  const register = ref(true) 此时登录界面就有立即注册 跳转注册

• 通知公告(半成品)：促进组织内部信息传递

  系统管理 → 通知公告 → 新增

• 日志管理：轻松追踪用户行为和系统运行状况

  系统管理 → 通知公告 → 日志管理 → 操作日志

系统监控

• 若依提供了一些列强大的监控工具，能够帮助开发者和运维快速了解应用程序的性能状态

  系统监控 → 在线用户 && 缓存列表
  数据监控【Druid Monitor】 → ruoyi && 123456

定时任务

• 若依为定时任务功能提供方便友好的web界面，实现动态管理任务

  @Component
  public class MyTask{
    @Scheduled(cron = "0/5 *****?")
    public void showTime(){
       sout("定时任务开始执行：" + new Date());
    }
  }
  // 硬编码 改代码需要重新修改 重新编译 重新上传...
  

• 每间隔5秒，控制台输出系统时间

  • 创建任务类

    创建一个类 C:\Users\Pluminary\Desktop\RuoYi-Vue\ruoyi-quartz\src\main\java\com\ruoyi\quartz\task\MyTask.java

    package com.ruoyi.quartz.task;
    
    import org.springframework.stereotype.Component;
    
    import java.util.Date;
    
    @Component
    public class MyTask {
        public void showTime(){
            System.out.println("定时任务开始执行：" + new Date());
        }
    }
    

  • 添加任务规则

    系统监控 → 定时任务 → 新增 →
    任务名称：输出时间 任务分组：默认
    调用方式：myTask.showTime()
    Cron表达式生成器：从0秒开始，每5秒执行一次 → 0/5 * * * * ?
    开启输出时间 状态打开！

    然后每间隔5秒就会向控制台输出时间

    定时任务开始执行：Wed Nov 06 18:12:30 CST 2024
    18:12:30.001 [quartzScheduler_Worker-4] DEBUG c.r.q.m.S.insertJobLog - [debug,135] - > Preparing: insert into sys_job_log( job_name, job_group, invoke_target, job_message, status, create_time )values( ?, ?, ?, ?, ?, sysdate() ) 18:12:30.002 [quartzScheduler_Worker-4] DEBUG c.r.q.m.S.insertJobLog - [debug,135] - –> Parameters: 输出时间(String), DEFAULT(String), myTask.showTime()(String), 输出时间 总共耗时：0毫秒(String), 0(String) 18:12:30.009 [quartzScheduler_Worker-4] DEBUG c.r.q.m.S.insertJobLog - [debug,135] - < Updates: 1 定时任务开始执行：Wed Nov 06 18:12:35 CST 2024 18:12:35.006 [quartzScheduler_Worker-5] DEBUG c.r.q.m.S.insertJobLog - [debug,135] - > Preparing: insert into sys_job_log( job_name, job_group, invoke_target, job_message, status, create_time )values( ?, ?, ?, ?, ?, sysdate() ) 18:12:35.006 [quartzScheduler_Worker-5] DEBUG c.r.q.m.S.insertJobLog - [debug,135] - –> Parameters: 输出时间(String), DEFAULT(String), myTask.showTime()(String), 输出时间 总共耗时：0毫秒(String), 0(String) 18:12:35.012 [quartzScheduler_Worker-5] DEBUG c.r.q.m.S.insertJobLog - [debug,135] - < Updates: 1

  • 启动任务

    官方有提供可以训练的模型

    在这里面：com/ruoyi/quartz/task/RyTask.java

表单构建

• 通过表单构建工具，单独制作一个添加课程的表单页面

  • 制作表单并导出

    系统工具 → 表单构建 → 左侧行容器 → 拖入第一个单行文本 → 右侧可以改名字 如果想实现一行两个文本的化 就把表单栅格调小一点 → 选择性组件的下拉选择托到右面 → 修改字段名、标题、表单栅格…
    日期范围 → 课程有效期 → 选择型组件里的日期范围 命名为：课程有效期
    文件上传组件 → 课程封面
    评分 → 推荐指数
    多行文本 → 课程介绍

  • 复制到前端工程

    搞完后打开前端工程把add.vue它放在 src/views/course/course/中

  • 创建动态菜单

    系统管理 → 菜单管理 → 添加菜单 →
    菜单类型：菜单
    菜单名称：添加课程
    显示排序：1
    路由地址：course/add
    组件路径：course/course/add
    刷新界面 就会有菜单管理→添加课程了

系统工具

代码生成

• 代码生成器，根据数据库表结构自动生成前后端CRUD代码
• 提供三种生成模板：单表、树表、主子表(一对多)
• 树表是一种展示层级数据的表格，能展开折叠，清晰呈现父子关系，便于管理

系统工具 → 代码生成 → 导入部门表 → 编辑 → 生成信息 → 生成模板：树表 →
树编码字段：dept_id：部门id
树父编码字段：parent_id：父部门id
树名称字段：dept_name：部门名称
提交后下载代码
导入后就是 系统管理/部门管理 的树型结构界面了

系统接口

• Swagger，能够自动生成API的同步在线文档，并提供Web界面进行接口调用和测试

  系统工具 → 系统接口
  若依的Token在应用程序里 需要搞token进去
  测试：获取用户列表GET
  得到Token(F12后找应用程序 → Cookie若依 → 找到Admin-Token一定是当前ip地址的Token → 在Authorize中设置Token令牌 → 去后端改swagger的请求前缀pathMapping：/因为他的地址前面默认佩戴/dev-api

  # Swagger配置
  swagger:
    # 是否开启swagger
    enabled: true
    # 请求前缀
    pathMapping: /
  

  然后重启后台项目刷新浏览器打开接口再调用Token再去测试
  此时就操作成功了

  {
    "code": 200,
    "msg": "操作成功",
    "data": [
      {
        "userId": 1,
        "username": "admin",
        "password": "admin123",
        "mobile": "15888888888"
      },
      {
        "userId": 2,
        "username": "ry",
        "password": "admin123",
        "mobile": "15666666666"
      }
    ]
  }
  

若依常用功能？

① 权限控制
② 数据字典
③ 定时任务
④ 表单构建
⑤ 代码生成

项目结构

表结构

前端代码分析

• api/course/course.js 用于向后端发送Ajax请求的接口代码
• views/course/course/index.vue用于在浏览器展示课程的视图组件

src\views\course\course\index.vue
<template>
  <div class="app-container">
    <!-- :model做双向绑定 将前端录入条件封装给响应对象  v-show控制搜索栏显示隐藏-->
    <el-form :model="queryParams" ref="queryRef" :inline="true" v-show="showSearch" label-width="68px">
      <el-form-item label="课程编码" prop="code">
        <!-- v-model双向绑定code(前端课程编码) clearable清理用户输入信息 @keyup键盘回车事件完成搜索-->
        <el-input
          v-model="queryParams.code"
          placeholder="请输入课程编码"
          clearable
          @keyup.enter="handleQuery"
        />
      </el-form-item>
      <el-form-item label="课程学科" prop="subject">
        <!-- v-for遍历课程学科的字典数据列表 :lable展示label :value提交value值-->
        <el-select v-model="queryParams.subject" placeholder="请选择课程学科" clearable>
          <el-option
            v-for="dict in course_subject"
            :key="dict.value"
            :label="dict.label"
            :value="dict.value"
          />
        </el-select>
      </el-form-item>
      <el-form-item label="课程名称" prop="name">
        <el-input
          v-model="queryParams.name"
          placeholder="请输入课程名称"
          clearable
          @keyup.enter="handleQuery"
        />
      </el-form-item>
      <el-form-item label="适用人群" prop="applicablePerson">
        <el-select v-model="queryParams.applicablePerson" placeholder="请选择适用人群" clearable>
          <el-option
            v-for="dict in course_applicable_person"
            :key="dict.value"
            :label="dict.label"
            :value="dict.value"
          />
        </el-select>
      </el-form-item>
      <el-form-item>
        <el-button type="primary" icon="Search" @click="handleQuery">搜索</el-button>
        <el-button icon="Refresh" @click="resetQuery">重置</el-button>
      </el-form-item>
    </el-form>

    <el-row :gutter="10" class="mb8">
      <el-col :span="1.5">
        <!-- @click点击新增按钮弹出新增 v-hasPermi自定义属性完成菜单显示/隐藏 -->
        <el-button
          type="primary"
          plain
          icon="Plus"
          @click="handleAdd"
          v-hasPermi="['course:course:add']"
        >新增</el-button>
      </el-col>
      <!-- :disabled表示这个框是否可用 -->
      <el-col :span="1.5">
        <el-button
          type="success"
          plain
          icon="Edit"
          :disabled="single"
          @click="handleUpdate"
          v-hasPermi="['course:course:edit']"
        >修改</el-button>
      </el-col>
      <el-col :span="1.5">
        <el-button
          type="danger"
          plain
          icon="Delete"
          :disabled="multiple"
          @click="handleDelete"
          v-hasPermi="['course:course:remove']"
        >删除</el-button>
      </el-col>
      <el-col :span="1.5">
        <el-button
          type="warning"
          plain
          icon="Download"
          @click="handleExport"
          v-hasPermi="['course:course:export']"
        >导出</el-button>
      </el-col>
      <!-- 点击会控制'搜索栏'显示隐藏 @queryTable重新加载表格展示数据 -->
      <right-toolbar v-model:showSearch="showSearch" @queryTable="getList"></right-toolbar>
    </el-row>
    <!-- v-loading展示表格的加载状态 遍历展示courseList 事件监听器监听选中行 -->
    <el-table v-loading="loading" :data="courseList" @selection-change="handleSelectionChange">
      <!-- 当用户勾选复选框 触发@selection-change -->
      <el-table-column type="selection" width="55" align="center" />
      <!-- 展示具体数据源数据 -->
      <el-table-column label="课程id" align="center" prop="id" />
      <el-table-column label="课程编码" align="center" prop="code" />
      <el-table-column label="课程学科" align="center" prop="subject">
 <!-- 通过scope拿到整个表格数据 通过:value="scope.row.subject"拿到字典值去匹配字典数据列表 找到该值对应的标签显示给前端-->
        <template #default="scope">
          <dict-tag :options="course_subject" :value="scope.row.subject"/>
        </template>
      </el-table-column>
      <el-table-column label="课程名称" align="center" prop="name" />
      <el-table-column label="价格" align="center" prop="price" />
      <el-table-column label="适用人群" align="center" prop="applicablePerson">
        <template #default="scope">
          <dict-tag :options="course_applicable_person" :value="scope.row.applicablePerson"/>
        </template>
      </el-table-column>
      <el-table-column label="课程介绍" align="center" prop="info" />
      <el-table-column label="操作" align="center" class-name="small-padding fixed-width">
<!-- 使用了模板插槽 -->
        <template #default="scope">
          <!-- @click="handleUpdate(scope.row)把当前行的数据传给当前方法  v-hasPermi自定义权限属性-->
          <el-button link type="primary" icon="Edit" @click="handleUpdate(scope.row)" v-hasPermi="['course:course:edit']">修改</el-button>
          <el-button link type="primary" icon="Delete" @click="handleDelete(scope.row)" v-hasPermi="['course:course:remove']">删除</el-button>
        </template>
      </el-table-column>
    </el-table>
    
    <!-- 分页区域 -->
     <!-- v-show如果大于0条就显示反之隐藏 :total展示总条数 展示分页页码 @pagination="getList"换页后新数据的查询-->
    <pagination
      v-show="total>0"
      :total="total"
      v-model:page="queryParams.pageNum"
      v-model:limit="queryParams.pageSize"
      @pagination="getList"
    />

    <!-- 添加或修改课程管理对话框 -->
     <!-- el-dialog默认隐藏的 点击会显示 append-to-body默认将对话框在body上追加显示 :title动态绑定标题(新增和修改不一样)-->
    <el-dialog :title="title" v-model="open" width="500px" append-to-body>
      <!-- :model来双向绑定 :rules校验规则-->
      <el-form ref="courseRef" :model="form" :rules="rules" label-width="80px">
        <el-form-item label="课程编码" prop="code">
          <el-input v-model="form.code" placeholder="请输入课程编码" />
        </el-form-item>
        <el-form-item label="课程学科" prop="subject">
          <el-select v-model="form.subject" placeholder="请选择课程学科">
            <el-option
              v-for="dict in course_subject"
              :key="dict.value"
              :label="dict.label"
              :value="dict.value"
            ></el-option>
          </el-select>
        </el-form-item>
        <el-form-item label="课程名称" prop="name">
          <el-input v-model="form.name" placeholder="请输入课程名称" />
        </el-form-item>
        <el-form-item label="价格" prop="price">
          <el-input v-model="form.price" placeholder="请输入价格" />
        </el-form-item>
        <el-form-item label="适用人群" prop="applicablePerson">
          <el-select v-model="form.applicablePerson" placeholder="请选择适用人群">
            <el-option
              v-for="dict in course_applicable_person"
              :key="dict.value"
              :label="dict.label"
              :value="dict.value"
            ></el-option>
          </el-select>
        </el-form-item>
        <el-form-item label="课程介绍" prop="info">
          <el-input v-model="form.info" placeholder="请输入课程介绍" />
        </el-form-item>
      </el-form>
      <template #footer>
        <div class="dialog-footer">
          <!-- 提交前先进行表单规则的校验:rules="rules"  -->
          <el-button type="primary" @click="submitForm">确 定</el-button>
          <el-button @click="cancel">取 消</el-button>
        </div>
      </template>
    </el-dialog>
  </div>
</template>

<script setup name="Course">
// 引入后端api接口文件
import { listCourse, getCourse, delCourse, addCourse, updateCourse } from "@/api/course/course";
// 获取当前实例代理对象，用于访问组件数据、方法
const { proxy } = getCurrentInstance();
// 获取课程学科的数据字典
const { course_applicable_person, course_subject } = proxy.useDict('course_applicable_person', 'course_subject');
// 列表数据
const courseList = ref([]);
// 是否显示弹框
const open = ref(false);
// 是否显示加载状态
const loading = ref(true);
// 是否显示搜索栏
const showSearch = ref(true);
// 复选框，被选中id的数组
const ids = ref([]);
// 复选框，是否单选，用于高亮修改、删除按钮
const single = ref(true);
// 复选框，是否多选，仅高亮删除按钮
const multiple = ref(true);
// 总(记录)条数
const total = ref(0);
// 用于区分新增、修改对话框标题
const title = ref("");
// 定义reactive响应式对象
const data = reactive({
  // 新增或修改表单数据
  form: {},
  // 搜索条件参数
  queryParams: {
    pageNum: 1,
    pageSize: 10,
    code: null,
    subject: null,
    name: null,
    applicablePerson: null,
  },
  // 表单校验规则
  rules: {
    code: [
      { required: true, message: "课程编码不能为空", trigger: "blur" }
    ],
    subject: [
      { required: true, message: "课程学科不能为空", trigger: "change" }
    ],
    name: [
      { required: true, message: "课程名称不能为空", trigger: "blur" }
    ],
    price: [
      { required: true, message: "价格不能为空", trigger: "blur" }
    ],
    applicablePerson: [
      { required: true, message: "适用人群不能为空", trigger: "change" }
    ],
    info: [
      { required: true, message: "课程介绍不能为空", trigger: "blur" }
    ],
  }
});
// 将data对象的三个属性，转换为ref响应式对象
const { queryParams, form, rules } = toRefs(data);

/** 查询课程管理列表 */
function getList() {
  loading.value = true;
  listCourse(queryParams.value).then(response => {
    courseList.value = response.rows;
    total.value = response.total;
    loading.value = false;
  });
}

// 取消按钮
function cancel() {
  open.value = false;
  reset();
}

// 表单重置
function reset() {
  form.value = {
    id: null,
    code: null,
    subject: null,
    name: null,
    price: null,
    applicablePerson: null,
    info: null,
    createTime: null,
    updateTime: null
  };
  proxy.resetForm("courseRef");
}

/** 搜索按钮操作 */
function handleQuery() {
  // 最新的从第一页开始 再发送请求
  queryParams.value.pageNum = 1;
  getList();
}

/** 重置按钮操作 */
function resetQuery() {
  proxy.resetForm("queryRef");
  handleQuery();
}

// 多选框选中数据
// 把选中的复选框对象传递过来
function handleSelectionChange(selection) {
  // 拿到对象调用map方法进行遍历取每个复选框的id
  // 封装给ids的响应式数组对象
  ids.value = selection.map(item => item.id);
  // 控制修改和删除按钮是否高亮可用的 23默认为true
  single.value = selection.length != 1;
  // 修改按钮只要大于0 就是false 那么修改按钮可用使用
  multiple.value = !selection.length;
}

/** 新增按钮操作 */
function handleAdd() {
  reset();
  open.value = true;
  title.value = "添加课程管理";
}

/** 修改按钮操作 */
// 拿到行对象 重置 取出当前行id或一个id
function handleUpdate(row) {
  reset();
  const _id = row.id || ids.value
  getCourse(_id).then(response => {
    form.value = response.data;
    open.value = true;
    title.value = "修改课程管理";
  });
}

/** 提交按钮 */
function submitForm() {
  // '修改课程'对表单进行校验 正则规则...是否必填
  proxy.$refs["courseRef"].validate(valid => {
    if (valid) {// 区分新增还是修改的操作
      if (form.value.id != null) {
        updateCourse(form.value).then(response => {
          proxy.$modal.msgSuccess("修改成功");
          open.value = false;
          getList();
        });
      } else {
        addCourse(form.value).then(response => {
          proxy.$modal.msgSuccess("新增成功");
          open.value = false;
          getList();
        });
      }
    }
  });
}

/** 删除按钮操作 */
function handleDelete(row) {
  // 一行或数组
  const _ids = row.id || ids.value;
  // 防止误操作
  proxy.$modal.confirm('是否确认删除课程管理编号为"' + _ids + '"的数据项？').then(function() {
    return delCourse(_ids);
  }).then(() => {
    getList();
    proxy.$modal.msgSuccess("删除成功");
  }).catch(() => {});
}

/** 导出按钮操作 */
function handleExport() {
  proxy.download('course/course/export', {
    ...queryParams.value
  }, `course_${new Date().getTime()}.xlsx`)
}

getList();
</script>

src\api\course\course.js
// 封装了请求和响应拦截器 下面return每个都调用请求
import request from '@/utils/request'

// 查询课程管理列表
// 接收用户输入参数 调用工具类把参数传过去 向后端发送请求完成课程列表的查询
// 然后返回前端并展示数据
export function listCourse(query) {
  return request({
    url: '/course/course/list',
    method: 'get',
    params: query
  })
}

// 查询课程管理详细
// 点击修改按钮时候根据id去查询 返回给前端
export function getCourse(id) {
  return request({
    url: '/course/course/' + id,
    method: 'get'
  })
}

// 新增课程管理
// 当点击确定按钮的时候 就把数据添加进来发送请求后返回前端
export function addCourse(data) {
  return request({
    url: '/course/course',
    method: 'post',
    data: data
  })
}

// 修改课程管理
// 修改完毕(根据id去查找数据库的)
export function updateCourse(data) {
  return request({
    url: '/course/course',
    method: 'put',
    data: data
  })
}

// 删除课程管理
// 批量/单体删除
export function delCourse(id) {
  return request({
    url: '/course/course/' + id,
    method: 'delete'
  })
}

再次熟悉：前+后端结构

若i18n乱码的情况下

file -> settings -> editor -> file ecoding -> default encoding for properties files：utf-8

后端代码分析

• CourseController

• ICourseService及实现类

• CourseMapper及映射方法

• Course

• BaseController：web层通用数据处理

/**
     * 查询课程管理列表
     */
    @PreAuthorize("@ss.hasPermi('course:course:list')")
    @GetMapping("/list")
    public TableDataInfo list(Course course) {
        //1.开启分页
        startPage();
        //2.查询课程列表
        List<Course> list = courseService.selectCourseList(course);
        return getDataTable(list);
    }
// 在分页查询那块会附带着两个封装好的sql语句
// select * from tb_course where xxx 【逐步细分成两个小sql】
  1. select count(*) from tb_course where xxx      //总记录数
  2. select * from tb_course where xxx limit ?,?   //获取当前的数据列表

分页原理

AjaxResult：操作消息提醒

权限解读

• @PreAuthorize注解是Spring Security框架中用来做权限检查的。
• 它在运行方法前先验证权限，权限够就放行，不够就拦截

@RestController
@RequestMapping("/course/course")
public class CourseController extends BaseController {
    @Autowired
    private ICourseService courseService;

    /**
     * 查询课程管理列表
     */
// 问题：我怎么知道该用户有没有权限呢？基于RBC权限模型 
    @PreAuthorize("@ss.hasPermi('course:course:list')")
    @GetMapping("/list")
    public TableDataInfo list(Course course) {
        startPage();
        List<Course> list = courseService.selectCourseList(course);
        return getDataTable(list);
    }
}

PermissionService.java
源码解读在后期

/**
 * RuoYi首创 自定义权限实现，ss取自SpringSecurity首字母
 * 
 * @author ruoyi
 */
@Service("ss")
public class PermissionService
{
    /**
     * 验证用户是否具备某权限
     * 
     * @param permission 权限字符串
     * @return 用户是否具备某权限
     */
    public boolean hasPermi(String permission)
    {
        if (StringUtils.isEmpty(permission))
        {
            return false;
        }
        LoginUser loginUser = SecurityUtils.getLoginUser();
        if (StringUtils.isNull(loginUser) || CollectionUtils.isEmpty(loginUser.getPermissions()))
        {
            return false;
        }
        PermissionContextHolder.setContext(permission);
        return hasPermissions(loginUser.getPermissions(), permission);
    }

二次开发 —— 苍穹外卖

若依框架修改器

• 若依框架修改器是一个可以一键修改RuoYi框架包名、项目名等的工具

E:\Java实例项目1-20套\2024-Java若依框架专题课\01-基础篇\资料\04-二次开发\若依框架修改器.exe

选择系列：RuoYi-Vue
目录名称: sky
项目名：sky
包名：com.sky
artifactId：sky
groupId：com.sky
站点名称：外卖管理系统


C:\Users\Pluminary\Desktop\20241108150415\sky

新建业务模块

• 新建sky-merchant子模块商家管理

  • 新建子模块
    sky-merchant → Advanced Settings → GroupId：com.sky

  • 父工程版本锁定

    pom.xml(sky总)
    <!-- 商家管理-->
                <dependency>
                    <groupId>com.sky</groupId>
                    <artifactId>sky-merchant</artifactId>
                    <version>${sky.version}</version>
                </dependency>
    

    pom.xml(sky-merchant)
    <dependencies>
            <dependency>
                <groupId>com.sky</groupId>
                <artifactId>sky-framework</artifactId>
            </dependency>
        </dependencies>
    

  • sky-admin添加依赖

    pom.xml(sky-admin) 
    <dependency>
                <groupId>com.sky</groupId>
                <artifactId>sky-merchant</artifactId>
            </dependency>
    

菜品管理

• 利用若依代码生成器(主子表模板)，生成菜品管理的前后端代码

• 准备SQL并导入数据库

  E:\Java实例项目1-20套\2024-Java若依框架专题课\01-基础篇\资料\04-二次开发\菜品管理

• 配置代码生成信息【主子表的生成】

  在若依代码生成 → 导入表tb_dish 和 tb_dish_flavor

• 下载代码并导入项目

• 修改代码 → 系统工具 → 代码生成 → 菜品管理(修改) →

  基本信息：实体类名称→Dish 作者→itheima

  字段信息参考页面原型生成 → 系统管理 → 字典管理 →

  字典名称：售卖状态
  字典类型：dish_status
  第二页点进去售卖状态的字典类型 dish_status → 新增

  数据标签：停售 + 起售
  数据键值：0 + 1
  显示排序：1 + 2

​ 回到系统工具 → 代码生成 → 菜品管理修改 → 售卖状态 → 显示类型：下拉框 → 字典类型：售卖状态

→ 代码生成 → 修改菜单配置信息 → 菜品

→ 上面的生成信息

生成模板：主子表
生成模块名：merchant
生成业务名：dish
关联子表的表名：tb_dish_flavor：菜品口味关系表
子表关联的外键名：dish_id：菜品

→ 在代码生成 → tb_dish_flavor菜品口味关系表 → 点击编辑

基本信息：
实体名：DishFalvor

→ 生成代码(main后端 + vue前端 + dishMenu.sql数据库动态菜单) → 动态sql导入进去 → 前端vue将merchant导入到./src/api中，将views导入到views中 → 在前端中将java和resources导入到merchant模块中

对菜品管理进行升级改造

主键隐藏掉 售价前缀￥ 修改时间时分秒

src\views\merchant\dish\index.vue 
把  <el-table-column label="主键" align="center" prop="id" />  打注释符
////////////////////////////////////////////////////////////////////////////
插入￥流程：
<el-table-column label="售价" align="center" prop="price" /> 修改为 →
<el-table-column label="售价" align="center" prop="price">
        <template #default="scope">
          <div>
            ￥{{ scope.row.price }}
          </div>
        </template>
      </el-table-column>
通义灵码操作：
先解析那行代码，然后输入使用vue3语法在售价前显示￥
////////////////////////////////////////////////////////////////////////////
生成年月日时分秒：
<el-table-column label="更新时间" align="center" prop="updateTime" width="180">
        <template #default="scope">
          <span>{{ parseTime(scope.row.updateTime, '{y}-{m}-{d}') }}</span>
        </template>
      </el-table-column>
修改为：

修改图片回显bug

新增毛血旺的图片若依默认保存在了本地服务器而不是阿里云上
/profile/upload/2024/11/10/毛血旺_20241110093243A001.jpg

C:\Users\Pluminary\Desktop\20241108150415\sky\sky-admin\src\main\resources\application.yml

# 项目相关配置
ruoyi:
  # 名称
  name: RuoYi
  # 版本
  version: 3.8.8
  # 版权年份
  copyrightYear: 2024
  # 文件路径 示例（ Windows配置D:/ruoyi/uploadPath，Linux配置 /home/ruoyi/uploadPath）
  profile: D:/ruoyi/uploadPath
  # 获取ip地址开关
  addressEnabled: false
  # 验证码类型 math 数字计算 char 字符验证
  captchaType: math

D:\ruoyi\uploadPath\upload\2024\11\10
文件上传组件标签修改 增加&& item.indexOf("http") === -1

watch(() => props.modelValue, val => {
  if (val) {
    // 首先将值转为数组
    const list = Array.isArray(val) ? val : props.modelValue.split(",");
    // 然后将数组转为对象数组
    fileList.value = list.map(item => {
      if (typeof item === "string") {
        if (item.indexOf(baseUrl) === -1 && item.indexOf("http") === -1) {
          item = { name: baseUrl + item, url: baseUrl + item };
        } else {
          item = { name: item, url: item };
        }
      }
      return item;
    });
  } else {
    fileList.value = [];
    return [];
  }
},{ deep: true, immediate: true });

修改口味列表数组格式 改为下拉框的口味搭配

src\views\merchant\dish\index.vue
//------------------------------------------------
// 定义口味名称和口味列表静态数据
const dishFlavorListSelect = ref([
  {name:"辣度", value:["不辣","微辣","中辣","重辣"]},
  {name:"忌口", value:["不要葱","不要蒜","不要香菜","不要辣"]},
  {name:"甜味", value:["无糖","少糖","半糖"]}
]);
//------------------------------------------------

src\views\merchant\dish\index.vue
<template #default="scope">
      <!-- <el-input v-model="scope.row.name" placeholder="请输入口味名称" /> -->
               <!-- label是最终看到下拉框的内容 value是用户提交的内容 -->
           <el-select v-model="scope.row.name"  placeholder="请选择口味名称">
                <el-option
                  v-for="dishFlavor in dishFlavorListSelect"
                  :key="dishFlavor.name"
                  :label="dishFlavor.name" 
                  :value="dishFlavor.name"
                >
                </el-option>
            </el-select>
           </template>
       </el-table-column>

src\views\merchant\dish\index.vue【修改当选中辣度时候 后面的规格】
// 存储当前选中口味列表数组
const checkValueList = ref([]);
// 定义改变口味名称时更新当前选中的口味列表
function changeFlavorName(row){
  // 清空当前行的value
  row.value = [];
  // 根据选中的name去查找静态数据的value
  checkValueList.value = dishFlavorListSelect.value.find(item=>item.name==row.name).value;
}

//增加了一个 @change   注意：如果是多选框一定要 → multiple

<el-table-column label="口味名称" prop="name" width="150">
            <template #default="scope">
              <!-- <el-input v-model="scope.row.name" placeholder="请输入口味名称" /> -->
               <!-- label是最终看到下拉框的内容 value是用户提交的内容 -->
               <el-select v-model="scope.row.name"  placeholder="请选择口味名称"
               @change="changeFlavorName(scope.row)">
                <el-option
                  v-for="dishFlavor in dishFlavorListSelect"
                  :key="dishFlavor.name"
                  :label="dishFlavor.name" 
                  :value="dishFlavor.name"
                >
                </el-option>
               </el-select>
            </template>
          </el-table-column>
          <el-table-column label="口味列表" prop="value" width="150">
            <template #default="scope">
              <!-- <el-input v-model="scope.row.value" placeholder="请输入口味列表" /> -->
          <el-select v-model="scope.row.value"  placeholder="请选择口味列表" multiple>
                <el-option
                  v-for="value in checkValueList"
                  :key="value"
                  :label="value" 
                  :value="value"
                />
          </el-select>
          </template>
          </el-table-column>

//------------------------------------------------
// 定义口味名称和口味列表静态数据
const dishFlavorListSelect = ref([
  {name:"辣度", value:["不辣","微辣","中辣","重辣"]},
  {name:"忌口", value:["不要葱","不要蒜","不要香菜","不要辣"]},
  {name:"甜味", value:["无糖","少糖","半糖"]}
]);


// 存储当前选中口味列表数组
const checkValueList = ref([]);
// 定义改变口味名称时更新当前选中的口味列表
function changeFlavorName(row){
  // 根据选中的name去查找静态数据的value
  checkValueList.value =       dishFlavorListSelect.value.find(item=>item.name==row.name).value;
}
//------------------------------------------------

// 此时报错了 
11:59:00.441 [http-nio-8080-exec-64] ERROR c.s.f.w.e.GlobalExceptionHandler - [handleRuntimeException,100] - 请求地址'/merchant/dish',发生未知异常.
org.springframework.http.converter.HttpMessageNotReadableException: JSON parse error: Cannot deserialize value of type `java.lang.String` from Array value (token `JsonToken.START_ARRAY`); nested exception is com.fasterxml.jackson.databind.exc.MismatchedInputException: Cannot deserialize value of type `java.lang.String` from Array value (token `JsonToken.START_ARRAY`)
 at [Source: (org.springframework.util.StreamUtils$NonClosingInputStream); line: 1, column: 239] (through reference chain: com.sky.system.domain.Dish["dishFlavorList"]->java.util.ArrayList[0]->com.sky.system.domain.DishFlavor["value"])
    
/*
根据错误日志，问题出在请求地址 /merchant/dish 处理过程中，JSON 解析时出现了类型不匹配的问题。具体来说，Dish 对象中的 dishFlavorList 字段下的 DishFlavor 对象的 value 字段期望接收一个 String 类型的值，但实际接收到的是一个数组。
*/

解决序列化问题bug将口味列表中value通过JSON工具类转换为字符串

提交数据后是字符串 而不是数组

在331行
/** 提交按钮 */
function submitForm() {
  proxy.$refs["dishRef"].validate(valid => {
    if (valid) {
      form.value.dishFlavorList = dishFlavorList.value;
      // 将口味列表中value通过JSON工具类转换为字符串
      form.value.dishFlavorList.forEach(item=>item.value = JSON.stringify(item.value))
      if (form.value.id != null) {
        updateDish(form.value).then(response => {
          proxy.$modal.msgSuccess("修改成功");
          open.value = false;
          getList();
        });
      } else {
        addDish(form.value).then(response => {
          proxy.$modal.msgSuccess("新增成功");
          open.value = false;
          getList();
        });
      }
    }
  });

解决后端添加成功后 修改后口味列表无法回显再增加个非空判断

因为前端提交了字符串給后端，后端再回去修改的时候无法解析字符串 拿到字符串后返回JSON数组即可

/** 修改按钮操作 */
function handleUpdate(row) {
  reset();
  const _id = row.id || ids.value
  getDish(_id).then(response => {
    form.value = response.data;
    dishFlavorList.value = response.data.dishFlavorList;
    // 将口味列表的value字符串转成json数组
    if(dishFlavorList.value!=null){
      form.value.dishFlavorList.forEach(item=>item.value = JSON.parse(item.value))
    }
    open.value = true;
    title.value = "修改菜品管理";
  });
}

/** 提交按钮 */
function submitForm() {
  proxy.$refs["dishRef"].validate(valid => {
    if (valid) {
      form.value.dishFlavorList = dishFlavorList.value;
      // 将口味列表中value通过JSON工具类转换为字符串
      if(form.value.dishFlavorList!=null){
        form.value.dishFlavorList.forEach(item=>item.value = JSON.stringify(item.value))
      }
      if (form.value.id != null) {
        updateDish(form.value).then(response => {
          proxy.$modal.msgSuccess("修改成功");
          open.value = false;
          getList();
        });
      } else {
        addDish(form.value).then(response => {
          proxy.$modal.msgSuccess("新增成功");
          open.value = false;
          getList();
        });
      }
    }
  });
}

解决修改时无法修改口味列表的下拉框

給口味下拉框绑定一个获取焦点事件 再该事件内调用方法根据当前行的口味名称去查询静态数据 再赋值給静态数组

// 删除清除策略
// 定义口味列表获取焦点时更新当前选中的口味列表
function FocusFlavorName(row){
  // 根据选中的name去查找静态数据的value
  checkValueList.value = dishFlavorListSelect.value.find(item=>item.name==row.name).value;
}

// 加个 @focus
<el-table-column label="口味列表" prop="value" width="150">
            <template #default="scope">
              <!-- <el-input v-model="scope.row.value" placeholder="请输入口味列表" /> -->
              <el-select v-model="scope.row.value"  placeholder="请选择口味列表" multiple
              @focus = "FocusFlavorName(scope.row)">
                <el-option
                  v-for="value in checkValueList"
                  :key="value"
                  :label="value" 
                  :value="value"
                />
               </el-select>
            </template>
          </el-table-column>

二次开发——页面调整

将原有的页面，调整为外卖管理系统的项目标识

• 浏览器标签页icon、标题
• 系统页面中的logo、标题
• 去除源码 & 文档
• 主题和自定义图标
• 登录页面中标题、背景图

icon：public中的favicon.ico 改为 favicon.ico.bak 就作废了
把新的图标复制进来改成favicon.ico

标题：最外层index.html
< title> 外卖管理系统 < /title>
但是改完没有效果 是因为运行环境給覆盖了
.env.development修改一下

logo放在了静态资源页面
src\assets\logo\logo.png

修改顶部源码和文档图标内容
src\layout\components\Navbar.vue

<!-- <el-tooltip content="源码地址" effect="dark" placement="bottom">
          <ruo-yi-git id="ruoyi-git" class="right-menu-item hover-effect" />
        </el-tooltip>

        <el-tooltip content="文档地址" effect="dark" placement="bottom">
          <ruo-yi-doc id="ruoyi-doc" class="right-menu-item hover-effect" />
        </el-tooltip> -->

iconfont-阿里巴巴矢量图标库
下载一个菜品管理的小图标
然后给它复制进去src\assets\icons\svg\菜品管理.svg
随后回到菜单管理修改图标就好

登录界面图片修改：
src\views\login.vue 修改一下标题
背景图 → src\assets\images\login-background1.jpg
通过css样式修改背景图
171行
background-image: url("../assets/images/login-background.jpg");
修改为
background-image: url("../assets/images/login-background1.jpg");

.login {
  display: flex;
  justify-content: right;
  align-items: center;
  height: 100%;
  background-image: url("../assets/images/login-background1.jpg");
  background-size: cover;
}

給外卖商家的员工创建角色和用户分配菜单的权限 登录后只能看到自己的功能

系统管理 → 角色管理 → 新增 →
角色名称：商家员工
权限字符串：merchant
角色顺序：4
菜单权限：父子联动
√ 菜品管理

再到用户管理 → 新增 → 添加用户 →
用户昵称：波妞
用户名称：boniu
用户密码：admin123
角色：商家员工

帝可得

• 帝可得是一个基于物联网概念下的智能售货机运营管理系统

  • 物联网(IOT)

    让各种物品通过互联网链接起来，实现信息的交换和通信

    • 智能家居
    • 共享充电桩
    • 智能售货机

  • 智能售货机

    是物联网技术的一个典型应用

    • 物联网技术
    • 智能分析与推荐
    • 人员设备绑定管理
    • 线上线下融合

• 售货机术语

  • 区域管理

    为了更高效地进行经营管理，公司将运营范围划分为若干个逻辑区域

  • 点位选择

    点位指的是智能售货机的具体放置位置

  • 售货机功能

    自动小店，摆满了各种零食

  • 货道设计

    售货机里的货道

角色与功能

• 一个完整的售货机系统由**五端五角色**组成:
• 管理员：对基础数据(区域、点位、设备、货道、商品等)进行管理
• 运维人员：投放设备、撤除设备、维修设备。
• 运营人员：补货。
• 合作商：仅提供点位，坐收渔翁之利。
• 消费者：在小程序或屏幕端下单购买商品。

帝可得在线功能文档_Docs

帝可得项目点击链接立即查看 https://codesign.qq.com/s/426304924036117

库表设计

• 系统后台基础数据表关系说明：

AIGC

• AI (Artificial Intelligence)：即人工智能，是指通过计算机系统模拟人类思维和行为一种技术

• 它通过机器学习、深度学习等算法，使计算机具备对数据分析、理解、推理和决策的能力

• AIGC (AI Generated content)：是AI领域的一个应用分支，专注于利用AI技术自动生成内容

• 国内常见的通用大模型(AGI)产品：

  • 文心一言
  • 讯飞星火
  • 通义千问
  • KIMI

Prompt的组成

• 角色：给 AI 定义一个最匹配任务的角色，比如：「你是一位软件工程师」「你是一位小学老师」
• 指示：对任务进行描述
• 上下文：给出与任务相关的其它背景信息（尤其在多轮交互中）
• 例子：必要时给出举例，[实践证明其对输出正确性有帮助]
• 输入：任务的输入信息；在提示词中明确的标识出输入
• 输出：输出的格式描述，以便后继模块自动解析模型的输出结果，比如（JSON、Java）

先定义角色，其实就是在开头把问题域收窄，减少二义性。

案例：

角色：你是一位专业的博客作者。

指示：撰写一篇关于最新AI技术发展的文章。

上下文：文章应该涵盖AI技术的当前状态和未来趋势。

例子：可以引用最近的AI技术突破和行业专家的见解。

输入：当前AI技术的相关信息和数据。

输出：一篇结构清晰、观点鲜明的文章草稿。

角色：你是一位资深的Java开发工程师。

指示：编写一个Java函数，该函数接收两个整数参数，并返回它们的和。

上下文：这个函数将被用于一个简单的数学应用程序，该程序帮助学生练习基本的算术运算。

例子：如果你调用函数 `addNumbers(3, 5)`，它应该返回 `8`。

输入：两个整数参数，分别为 `int a` 和 `int b`。

输出：返回这两个整数的和，类型为 `int`。

常见的编程相关的Prompt

表结构

你是一个软件工程师，帮我生成MySQL的表结构
需求如下：
    1，课程管理表，表名tb_course，字段有主键id、课程编码、课程学科、课程名称、课程价格、适用人群、课程介绍
其他要求：
    1，每个表中都有创建时间(create_time)、修改时间(date_time)、创建人(create_by)、修改人(update_by)、备注(remark)这些字段
    2，每个表的主键都是自增的
    3，课程价格是整型、课程编码是字符串
    4，请为每个字段都添加上comment
    5，帮我给生成的表中插入一些IT课程示例数据
        课程学科：Java、人工智能、大数据
        适用人群：小白学员、中级程序员

生成数据库说明文档

你是一个软件工程师，现在要根据数据库的sql脚本，编写数据库说明文档，sql脚本如下：
CREATE TABLE `tb_course` (
    `id` INT AUTO_INCREMENT COMMENT '主键ID',
    `course_code` VARCHAR(255) NOT NULL COMMENT '课程编码',
    `course_subject` VARCHAR(100) NOT NULL COMMENT '课程学科',
    `course_name` VARCHAR(255) NOT NULL COMMENT '课程名称',
    `course_price` INT COMMENT '课程价格',
    `target_audience` VARCHAR(100) COMMENT '适用人群',
    `course_introduction` TEXT COMMENT '课程介绍',
    `create_time` DATETIME COMMENT '创建时间',
    `update_time` DATETIME COMMENT '修改时间',
    `create_by` VARCHAR(64) COMMENT '创建人',
    `update_by` VARCHAR(64) COMMENT '修改人',
    `remark` VARCHAR(255) COMMENT '备注',
    PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='课程管理表';

输出要求是：
    1，每个表以及每个表的字段都要详细说明，包括，字段名称、类型、作用
    2，使用markdown的输出格式，字段的描述需要使用表格展示
    3，如果表之间有关系，需要描述清楚表之间的关系

生成代码

代码生成算是比较常规的方案，用的也比较多，分为了几种情况

• 给出表生成代码（项目中常见）
  • 给出表结构的ddl，可以输出这个表的增删改查的所有代码
  • 给出表结构的dll，可以输出增删改查的接口文档
• 补全代码
  • 例1-给出实体类，帮助编写getter、setter、toString、构造方法等等
  • 例2-给出一个controller，帮助编写swagger注解等
• 提取结构（无含金量，费时间的编程）
  • 例1-根据接口文档提取dto类或者vo类

生成代码流程图

有一些比较复杂的业务流程，往往需要画出流程图，现在就可以使用ai协助我们画流程图

你是一个软件工程师，为了方便理解代码执行流程，需要给出代码执行的流程图，代码如下：
    // 创建工单
    @Transactional
    @Override
    public int insertTaskDto(TaskDto taskDto) {
    //1. 查询售货机是否存在
    VendingMachine vm = vendingMachineService.selectVendingMachineByInnerCode(taskDto.getInnerCode());
    if (vm == null) {
        throw new ServiceException("设备不存在");
    }
    //2. 校验售货机状态与工单类型是否相符
    checkCreateTask(vm.getVmStatus(), taskDto.getProductTypeId());
    //3. 校验这台设备是否有未完成的同类型工单，如果存在则不能创建
    hasTask(taskDto.getInnerCode(), taskDto.getProductTypeId());
    //4. 校验员工是否存在
    Emp emp = empService.selectEmpById(taskDto.getUserId());
    if (emp == null) {
        throw new ServiceException("员工不存在");
    }
    // 5. 校验非同区域下的工作人员不能接受工单
    if (emp.getRegionId() != vm.getRegionId()) {
        throw new ServiceException("非同区域下的工作人员不能接受工单");
    }
    //6. 保存工单信息
    Task task = new Task();
    BeanUtil.copyProperties(taskDto, task);// 属性赋值
    task.setCreateTime(DateUtils.getNowDate());// 创建时间
    task.setTaskCode(generateTaskCode());// 工单编号 202405150001
    task.setTaskStatus(DkdContants.TASK_STATUS_CREATE);// 创建工单
    task.setAddr(vm.getAddr());
    task.setRegionId(vm.getRegionId());
    task.setUserName(emp.getUserName());
    int taskResult = taskMapper.insertTask(task);
    //7. 如果是补货工单，向工单明细表插入记录
    if (task.getProductTypeId() == DkdContants.TASK_TYPE_SUPPLY) {
        if (CollUtil.isEmpty(taskDto.getDetails())) {
            throw new ServiceException("补货工单明细不能为空");
        }
        List<TaskDetails> taskDetailsList = taskDto.getDetails().stream().map(details -> {
            TaskDetails taskDetails = BeanUtil.copyProperties(details, TaskDetails.class);
            taskDetails.setTaskId(task.getTaskId());
            return taskDetails;
        }).collect(Collectors.toList());
        taskDetailsService.insertBatch(taskDetailsList);
    }

    return taskResult;
}

输出：请使用mermaid语言来描述这个方法的流程

graph TD;
    A[查询售货机] --> B(售货机不存在?)
    B -- 是 --> C[抛出异常: 设备不存在]
    B -- 否 --> D[校验售货机状态与工单类型]
    D --> E(校验失败?)
    E -- 是 --> F[抛出异常]
    E -- 否 --> G[检查未完成同类型工单]
    G --> H(存在未完成同类型工单?)
    H -- 是 --> I[抛出异常]
    H -- 否 --> J[查询员工]
    J --> K(员工不存在?)
    K -- 是 --> L[抛出异常: 员工不存在]
    K -- 否 --> M[校验员工区域与售货机区域是否一致]
    M --> N(不一致?)
    N -- 是 --> O[抛出异常: 非同区域工作人员不能接受工单]
    N -- 否 --> P[保存工单信息]
    P --> Q(保存成功?)
    Q -- 否 --> R[处理保存失败]
    Q -- 是 --> S(工单类型为补货?)
    S -- 是 --> T[处理补货工单明细]
    T --> U[补货明细处理结果?]
    U -- 失败 --> V[抛出异常: 补货工单明细不能为空]
    U -- 成功 --> END(结束)
    S -- 否 --> END

项目搭建(后端)

复制gitee克隆的地址https://gitee.com/Pluminary/dkd-parent.git，在新的idea中找到Get from Version Control在URL中导入xxx.git
若左列模块没有高亮 右侧找maven→clean→package
MySQL的配置和导入 → sql里的sql文件导入到Database
C:\Users\Pluminary\Desktop\dkd-parent\dkd-admin\src\main\resources\application-druid.yml
连接好数据库配置信息
Redis的配置(搞个密码)
为了方便学习我没有搞redis的password 项目里的是：root【application.yml的redis里面】
打开redis服务后就可以启动啦dkd-parent\dkd-admin\src\main\java\com\dkd\DkdApplication.java

项目搭建(前端)

通过vscode克隆源码，仓库地址：https://gitee.com/ys-gitee/dkd-vue.git\

• 打开VS Code，并确保已经安装了Git。如果未安装Git，请先下载并安装。
• 在VS Code左侧的活动栏中点击”Source Control”图标，或者按下Ctrl+Shift+G，打开Git集成面板。
• 在Git集成面板上方的输入框中，选择并输入要克隆的Git仓库地址。可以是HTTP或SSH地址。
• 点击Enter键，VS Code将连接到Git仓库并拉取最新的代码

在vscode中右上角第二个小框框 点击打开命令行 导入jar包 npm install
然后npm run dev打开项目
帝可得管理系统 http://10.254.1.228/index

在VSCode项目中运行npm install命令主要是用于安装项目所需的Node.js包依赖。以下是具体的作用和步骤：

安装依赖包：当你创建一个Node.js项目或者从版本控制系统中克隆一个项目到本地时，项目中通常会包含一个package.json文件。这个文件里列出了项目所有依赖的包及其版本号。运行npm install命令会读取这个文件，然后从npm（Node Package Manager）仓库下载并安装所有列出的依赖包到项目的node_modules目录。

确保环境一致性：通过npm install，可以确保在不同的开发环境和生产环境中，项目使用的是相同版本的依赖包，这有助于避免因为环境差异导致的bug。

项目初始化：如果你是第一次在一个项目中运行npm install，它还会运行每个依赖包的install脚本，这些脚本可能会进行一些设置工作，比如编译代码、生成必要的文件等。

脚本命令：在package.json中，除了依赖项，还可以定义一些脚本命令（scripts）。npm install会使得这些命令变为可用状态，你可以在项目目录下通过npm run <script-name>来执行这些脚本。

[npm 加速，命令行修改国内镜像源【附带国内最新几个镜像】超简约版_npm 修改国内镜像-CSDN博客](https://blog.csdn.net/m0_52172586/article/details/142930356#::text=1.查看目前的镜像源 >npm get registry 2.设置镜像源 >npm,config set registry https%3A %2F%2Fregistry.npmmirror.com 3.验证)

1.查看目前的镜像源
> npm get registry
2.设置镜像源
> npm config set registry https://registry.npmmirror.com
3.验证
> npm get registry
    
/////////////////////////////////////////
后端maven镜像就先设置好maven地址(非C盘)
然后再去配置maven里的文件设置镜像

点位管理

需求说明

业务场景： 假设我们的公司现在有一个宏伟的计划——在北京发展业务。首先，我们需要确定几个有潜力的区域，这些区域可能是人流量大、消费能力高的商业区或居民区。然后，我们要与这些区域内的潜在合作商进行洽谈，比如商场、写字楼、学校等地方的管理者或所有者。

一旦我们与合作商达成协议，确定了合作的细节和点位，我们就可以安排工作人员去投放智能售货机了。这些点位将成为我们智能售货机的“家”，为消费者提供便捷的购买服务。

点位管理主要涉及到三个功能模块，业务流程如下：

1. 登录系统：后台管理人员登录后台系统
2. 新增区域: 后台管理人员可以添加区域范围，区域范围与运维/运维人员挂钩，区域下可关联点位。
3. 新增合作商: 管理人员可以添加合作商，合作商与点位进行关联。
4. 新增区域点位: 后台管理人员可以在特定区域内新增点位，这些点位是放置智能售货机的具体位置。

graph TD
    A[登录系统] 
    A --> B[新增区域]
    B --> C[新增合作商]
    C --> D[新增区域点位]

库表设计

• 参考页面原型和具体需求完成库表设计

区域表: 主键id、区域名称、备注说明
合作商表: 主键id、合作商名称、联系人、联系电话、分成比例、账号、密码
点位表: 主键id、点位名称、详细地址、商圈类型、区域外键、合作商外键

// 你是一位软件工程师，帮我生成MySQL的表结构
需求如下：
1，区域表，表名tb_region，字段有主键id、区域名称
2，合作商表，表名tb_partner，字段有主键id、合作商名称、联系人、联系电话、分成比例（int类型）、账号、密码
3，点位表，表名tb_node，字段有主键id、点位名称、详细地址、商圈类型（int类型）
    
其他要求：
1，每张表中都有创建时间(create_time)、修改时间(date_time)、创建人(create_by)、修改人(update_by)、备注(remark)这些字段
2，每张表的主键都是自增的
3，区域与点位是一对多的关系，合作商与点位是一对多的关系，请用字段表示出来，并建立外键约束
4，请为所有字段都添加上comment
5，帮我给生成的表中插入一些北京城市相关区域、点位、合作商的测试数据

CREATE TABLE `tb_region` (
  `id` INT AUTO_INCREMENT COMMENT '主键id' PRIMARY KEY,
  `region_name` VARCHAR(255) NOT NULL COMMENT '区域名称',
  `create_time` TIMESTAMP DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
  `update_time` TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '修改时间',
  `create_by` VARCHAR(64) COMMENT '创建人',
  `update_by` VARCHAR(64) COMMENT '修改人',
  `remark` TEXT COMMENT '备注'
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='区域表';

-- 插入测试数据
INSERT INTO `tb_region` (`region_name`,`remark`) VALUES ('北京市朝阳区','北京市朝阳区'), ('北京市海淀区','北京市海淀区'), ('北京市东城区','北京市东城区');

CREATE TABLE `tb_partner` (
  `id` INT AUTO_INCREMENT COMMENT '主键id' PRIMARY KEY,
  `partner_name` VARCHAR(255) NOT NULL COMMENT '合作商名称',
  `contact_person` VARCHAR(64) COMMENT '联系人',
  `contact_phone` VARCHAR(15) COMMENT '联系电话',
  `profit_ratio` INT COMMENT '分成比例',
  `account` VARCHAR(64) COMMENT '账号',
  `password` VARCHAR(64) COMMENT '密码',
  `create_time` TIMESTAMP DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
  `update_time` TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '修改时间',
  `create_by` VARCHAR(64) COMMENT '创建人',
  `update_by` VARCHAR(64) COMMENT '修改人',
  `remark` TEXT COMMENT '备注'
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='合作商表';

-- 插入测试数据
INSERT INTO `tb_partner` (`partner_name`, `contact_person`, `contact_phone`, `profit_ratio`, `account`, `password`) VALUES
('合作商A', '张三', '13800138000', 30, 'a001', 'pwdA'),
('合作商B', '李四', '13912345678', 25, 'b002', 'pwdB');

CREATE TABLE `tb_node` (
  `id` INT AUTO_INCREMENT COMMENT '主键id' PRIMARY KEY,
  `node_name` VARCHAR(255) NOT NULL COMMENT '点位名称',
  `address` VARCHAR(255) NOT NULL COMMENT '详细地址',
  `business_type` INT COMMENT '商圈类型',
  `region_id` INT COMMENT '区域ID',
  `partner_id` INT COMMENT '合作商ID',
  `create_time` TIMESTAMP DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
  `update_time` TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '修改时间',
  `create_by` VARCHAR(64) COMMENT '创建人',
  `update_by` VARCHAR(64) COMMENT '修改人',
  `remark` TEXT COMMENT '备注',
  FOREIGN KEY (`region_id`) REFERENCES `tb_region`(`id`) ON DELETE CASCADE ON UPDATE CASCADE,
  FOREIGN KEY (`partner_id`) REFERENCES `tb_partner`(`id`) ON DELETE CASCADE ON UPDATE CASCADE
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='点位表';


-- 插入测试数据
-- 假设区域ID为1对应'北京市朝阳区'，合作商ID为1对应'合作商A'
INSERT INTO `tb_node` (`node_name`, `address`, `business_type`, `region_id`, `partner_id`) VALUES
('三里屯点位', '北京市朝阳区三里屯路', 1, 1, 1),
('五道口点位', '北京市海淀区五道口', 2, 2, 2);

对于点位管理数据模型，下面是示意图：

• 关系字段：region_id、partner_id

• 数据字典：business_type

生成基础代码

使用若依代码生成器，生成区域管理、合作商管理、点位管理前后端基础代码，导入项目中：

• 创建目录菜单
• 添加数据字典
• 配置代码生成信息
• 下载代码并导入项目

系统管理 → 菜单管理 → 新增菜单
→ 主类目、点位管理、2、node

→ 系统管理 → 字典管理
→ 字典名称：商圈类型
字典类型：business_type
→ 在第二页找到商圈类型点进去
→ 新增：旅游区
<u>数据标签：旅游区
数据键值：1
显示排序：1
→ 新增：商场写字楼、2、2；学校33、交通枢纽44

→ 系统工具 → 代码生成 → 导入表(tb_node、tb_partner、tb_region)
分别配置表的生成信息
→ 点击区域表 → 字段信息
→ 根据新增区域弹出菜单显示 需要增加区域名称全打勾 备注说明除了查询全打勾 其余全×

→ 点击**合作商表** → 生成信息
→ 包路径：com.dkd.manage、生成模块名：manage、生成业务名：region、生成功能名：区域管理、上级菜单：点位管理
→ 代码生成：Partner
→ 基本信息：
实体类名称：Partner
作者：itheima
→ 字段信息：见**帝可得后台管理系统.md**
→ 生成信息：
生成包路径：com.dkd.manage
生成模块名：manage
生成功能名：合作商管理
上级菜单：点位管理

→ 点击**点位表**
→ 生成信息：
生成包路径：com.dkd.manage
生成模块名：manage
生成功能名：点位管理
上级菜单：点位管理
→ 字段信息：见**帝可得后台管理系统.md**
→ 基本信息：
实体类名称：Node
表描述：点位表
作者：itheima

回到代码生成 选中三张表 生成！！
分别在前后端和数据库 导入java/manage、vue/manage、sql代码

细节：如果当你创建一个模块以后 src.main.java里面没有任何代码 resources里面也没有 它提交仓库的时候是默认空的 所以可以手动添加一个占位符.gitkeep虽然什么都不是，但是可以提交空项目模块

区域管理改造

基础页面

需求

• 参考页面原型，完成基础布局展示改造

// 让前端页面自动排序
src\views\manage\region\index.vue
<el-table-column label="序号" type="index" width="50" align="center" prop="id" />

区域管理改造

• 查看详情，需要显示所有区域下所有点位列表(稍后完成)

• 在查询区域列表时，同时显示每个区域的点位数，还要新增查看详情

  修改后端要参考接口文档，修改前端要参考产品原型

• 实现此功能方案：

  (1) 同步存储在区域表中有点位数的字段，当点位发生变化时候，同步区域表中的点位数(在tb_region里面新增一个node_count 方案可行考虑缺点：每次点位数据变化时都要更新区域表[增加了工作量]，添加数据不一致也会)
  (2) 关联查询编写关联查询语句，在mapper层封装

SQL查询：先聚合统计每个区域的点位数，然后与区域表进行关联查询
[提前在idea中下面的通义灵码状态勾选 本地补全模型、云端模型自动触发]
数据库返回的数据 要结合前端所需要的返回数据来写
比如接口文档需要返回remark id name nodeCount ==> select r.id,r.region_name,r.remark,ifnull(n.node_count,0) as node_count

-- 传统模式
-- 1.先聚合统计每个区域下的点位数
-- 确定查询表 tb_node
-- 确定分组字段 region_id
select region_id,count(*) as node_count from tb_node group by region_id;
-- 2.然后与区域表进行关联查询   内连接是两个表的交集
select r.id,r.region_name,r.remark,ifnull(n.node_count,0) as node_count 
   from tb_region r
left join (select region_id,count(*) as node_count 
   from tb_node group by region_id) n 
on r.id=n.region_id;

-- AI辅助编程模式
-- 查询区域表所有的信息,需要显示每个区域的点位数
SELECT r.*, COUNT(n.id) AS node_count FROM tb_region r LEFT JOIN tb_node n ON r.id = n.region_id GROUP BY r.id;

com/dkd/manage/domain/Region.java
package com.dkd.manage.domain;

import org.apache.commons.lang3.builder.ToStringBuilder;
import org.apache.commons.lang3.builder.ToStringStyle;
import com.dkd.common.annotation.Excel;
import com.dkd.common.core.domain.BaseEntity;

/**
 * 区域管理对象 tb_region
 * 
 * @author itheima
 * @date 2024-11-12
 */
public class Region extends BaseEntity
{
    private static final long serialVersionUID = 1L;

    /** 主键id */
    private Long id;

    /** 区域名称 */
    @Excel(name = "区域名称")
    private String regionName;

    public void setId(Long id) 
    {
        this.id = id;
    }

    public Long getId() 
    {
        return id;
    }
    public void setRegionName(String regionName) 
    {
        this.regionName = regionName;
    }

    public String getRegionName() 
    {
        return regionName;
    }

    @Override
    public String toString() {
        return new ToStringBuilder(this,ToStringStyle.MULTI_LINE_STYLE)
            .append("id", getId())
            .append("regionName", getRegionName())
            .append("createTime", getCreateTime())
            .append("updateTime", getUpdateTime())
            .append("createBy", getCreateBy())
            .append("updateBy", getUpdateBy())
            .append("remark", getRemark())
            .toString();
    }
}

com/dkd/manage/domain/vo/RegionVo.java
package com.dkd.manage.domain.vo;

import com.dkd.manage.domain.Region;
import lombok.Data;

@Data
public class RegionVo extends Region {
    // 点位数量
    private Integer nodeCount;

}

com/dkd/manage/mapper/RegionMapper.java
/**
     * 查询区域列表
     * @param regionVo
     * @return
     */
    public List<RegionVo> selectRegionVoList(RegionVo regionVo);

mapper/manage/RegionMapper.xml    
<select id="selectRegionVoList" resultType="com.dkd.manage.domain.vo.RegionVo">
        SELECT r.*, COUNT(n.id) AS node_count FROM tb_region r LEFT JOIN tb_node n ON r.id = n.region_id GROUP BY r.id
    </select>

思考：上面的xml中提取的字段是 node_count 而前端让返回的是驼峰式命名 nodeCount, 若依默认关闭了此功能需要手动开启此功能

dkd-parent → resources → mybatis → mybatis-config.xml
<!-- 使用驼峰命名法转换字段 -->
<setting name="mapUnderscoreToCamelCase" value="true"/>

Ctrl+F9是热部署 在不新增文件的时候可以直接部署

RegionMapper

/**
 * 查询区域管理列表
 * @param region
 * @return RegionVo集合
 */
public List<RegionVo> selectRegionVoList(Region region);

RegionMapper.xml

<select id="selectRegionVoList" resultType="com.dkd.manage.domain.vo.RegionVo">
select r.id,r.region_name,r.remark,ifnull(n.node_count,0) as node_count from tb_region r
    left join (select region_id,count(*) as node_count from tb_node group by region_id) n on r.id=n.region_id
    <where>
       <if test="regionName != null  and regionName != ''"> and r.region_name like concat('%', #{regionName}, '%')</if>
    </where>
</select> 

IRegionService

/**
 * 查询区域管理列表
 * @param region
 * @return RegionVo集合
 */
public List<RegionVo> selectRegionVoList(Region region);

RegionServiceImpl

/**
 * 查询区域管理列表
 * @param region
 * @return RegionVo集合
 */
@Override
public List<RegionVo> selectRegionVoList(Region region) {
    return regionMapper.selectRegionVoList(region);
}

RegionController

/**
 * 查询区域管理列表
 */
@PreAuthorize("@ss.hasPermi('manage:region:list')")
@GetMapping("/list")
public TableDataInfo list(Region region)
{
    startPage();
    List<RegionVo> voList = regionService.selectRegionVoList(region);
    return getDataTable(voList);
}

region/index.vue

<!-- 区域列表 -->
<el-table v-loading="loading" :data="regionList" @selection-change="handleSelectionChange">
  <el-table-column type="selection" width="55" align="center" />
  <el-table-column label="序号" type="index" width="50" align="center" prop="id" />
  <el-table-column label="区域名称" align="center" prop="regionName" />
  <el-table-column label="点位数" align="center" prop="nodeCount" />
  <el-table-column label="备注说明" align="center" prop="remark" />
  <el-table-column label="操作" align="center" class-name="small-padding fixed-width">
    <template #default="scope">
      <el-button link type="primary"  @click="handleUpdate(scope.row)" v-hasPermi="['manage:region:edit']">修改</el-button>
      <el-button link type="primary"  @click="handleDelete(scope.row)" v-hasPermi="['manage:region:remove']">删除</el-button>
    </template>
  </el-table-column>
</el-table>

小结

• 区域列表改造步骤
  • 确定关联查询方案并编写sql
  • 创建RegionVo
  • 在RegionMapper和xml中添加查询Vo方法和sql
  • 在RegionService接口和实现类中添加查询Vo方法
  • 修改RegionController查询方法
  • 修改前端视图组件

合作商改造-查看详情

密码是明文 改成密文

<el-form-item label="密码" prop="password">
   <el-input v-model="form.password" type="password" placeholder="请输入密码" />
</el-form-item>

隐藏修改时的账号密码id存在时隐藏不存在显示,因为修改和新增共用了一个对话框ui

<el-form-item label="账号" prop="account" v-if="form.id==null">
    <el-input v-model="form.account" placeholder="请输入账号" />
</el-form-item>
<el-form-item label="密码" prop="password" v-if="form.id==null">
    <el-input v-model="form.password" type="password" placeholder="请输入密码" />
</el-form-item>

前端需要返回创建时间因为数据返回时有，用v-if判断是否修改显示创建时间

 <el-form-item label="创建时间" prop="contactPhone" v-if="form.id!=null">
          {{form.createTime}}
        </el-form-item>

新增时保存的数据是以明文保存到了数据库此时新增的合作商就是密文了

com/dkd/manage/service/impl/PartnerServiceImpl.java  
/**
     * 新增合作商管理
     *
     * @param partner 合作商管理
     * @return 结果
     */
    @Override
    public int insertPartner(Partner partner) {
        // 使用SpringSecurity工具类，对前端传入的密码进行加密
        partner.setPassword(SecurityUtils.encryptPassword(partner.getPassword()));
        partner.setCreateTime(DateUtils.getNowDate());
        return partnerMapper.insertPartner(partner);
    }

合作商管理改造—合作商详情

• 查看详情，需要显示合作商名称、联系人、联系电话、分成比例
• 在查询合作商列表时，同时显示每个合作商的点位数
• 重置密码，初始密码为123456

/** 借鉴修改流程
/** 修改按钮操作 */
function handleUpdate(row) {
  reset();
  const _id = row.id || ids.value
  getPartner(_id).then(response => {
    form.value = response.data;
    open.value = true;
    title.value = "修改合作商管理";
  });
}

<el-table-column label="操作" align="center" class-name="small-padding fixed-width">
  <template #default="scope">
    <el-button link type="primary" icon="Edit" @click="getPartnerInfo(scope.row)" v-hasPermi="['manage:partner:query']">查看详情</el-button>
  </template>
</el-table-column>

com/dkd/manage/controller/PartnerController.java
    /**
     * 获取合作商管理详细信息
     */
    @PreAuthorize("@ss.hasPermi('manage:partner:query')")
    @GetMapping(value = "/{id}")
    public AjaxResult getInfo(@PathVariable("id") Long id)
    {
        return success(partnerService.selectPartnerById(id));
    }

/** 查看合作商详情 **/
  const partnerInfoOpen = ref(false)
  function getPartnerInfo(row){
    reset();
    const _id = row.id
    getPartner(_id).then(response => {
      form.value = response.data;
      partnerInfoOpen.value = true;
    });
  }

    <!-- 查看合作商详情对话框 -->
<el-dialog title="合作商详情" v-model="partnerInfoOpen" width="500px" append-to-body>
    <!-- 使用el-descriptions组件以卡片形式展示信息，更加整洁 -->
    <el-descriptions :column="2" border>
        <el-descriptions-item label="合作商名称">{{ form.partnerName }}</el-descriptions-item>
        <el-descriptions-item label="联系人">{{ form.contactPerson }}</el-descriptions-item>
        <el-descriptions-item label="联系电话">{{ form.contactPhone }}</el-descriptions-item>
        <el-descriptions-item label="分成比例">{{ form.profitRatio }}%</el-descriptions-item>
    </el-descriptions>
</el-dialog>

合作商改造—列表查询点位管理→合作商管理→增加点位数

• 实现此功能方案：

后端改造

关联查询编写关联查询语句，在mapper层封装

tb_node(点位表)的partner_id(合作商ID)
关联
tb_partner(合作商表)的id

-- 查询合作商表的所有信息，同时显示每个合作商的点位数
select p.*, count(n.id) as node_count
from tb_partner p
    left join tb_node n on p.id = n.partner_id
group by p.id

首先先创建一个需要查询新东西的方法增加

com/dkd/manage/domain/vo/PartnerVo.java
package com.dkd.manage.domain.vo;

import com.dkd.manage.domain.Partner;
import lombok.Data;

@Data
public class PartnerVo extends Partner {
    // 点位数量
    private Integer nodeCount;
}

com/dkd/manage/controller/PartnerController.java
 /**
     * 查询合作商管理列表
     */
    @PreAuthorize("@ss.hasPermi('manage:partner:list')")
    @GetMapping("/list")
    public TableDataInfo list(Partner partner) {
        startPage();
        List<PartnerVo> voList = partnerService.selectPartnerVoList(partner);
        return getDataTable(voList);
    }

com/dkd/manage/service/IPartnerService.java
/**
     * 查询合作商列表
     * @param partner
     * @return
     */
    public List<PartnerVo> selectPartnerVoList(Partner partner);

com/dkd/manage/service/impl/PartnerServiceImpl.java
/**
     * 查询合作商列表
     * @param partner
     * @return
     */
    @Override
    public List<PartnerVo> selectPartnerVoList(Partner partner) {
        return partnerMapper.selectPartnerVoList(partner);
    }

com/dkd/manage/mapper/PartnerMapper.java
/**
     * 查询合作商列表
     * @param partner
     * @return
     */
    public List<PartnerVo> selectPartnerVoList(Partner partner);

mapper/manage/PartnerMapper.xml
</select>
        <select id="selectPartnerVoList" resultType="com.dkd.manage.domain.vo.PartnerVo">
        select p.*, count(n.id) as node_count
        from tb_partner p
                 left join tb_node n on p.id = n.partner_id
        <where>
            <if test="partnerName != null  and partnerName != ''"> and partner_name like concat('%', #{partnerName}, '%')</if>
        </where>
        group by p.id
    </select>

前端改造

<el-table-column type="selection" width="55" align="center" />
      <el-table-column label="序号" type="index" width="50" align="center" prop="id" />
      <el-table-column label="合作商名称" align="center" prop="partnerName" />
      <el-table-column label="点位数" align="center" prop="nodeCount" />
      <el-table-column label="账号" align="center" prop="account" />
      <el-table-column label="分成比例" align="center" prop="profitRatio">
        <template #default="scope">
          {{ scope.row.profitRatio + '%' }}
        </template>
      </el-table-column>
      <el-table-column label="联系人" align="center" prop="contactPerson" />
      <el-table-column label="联系电话" align="center" prop="contactPhone" />
      <el-table-column label="操作" align="center" class-name="small-padding fixed-width">

合作商改造——重置密码

• 查看详情，需要显示合作商名称、联系人、联系电话、分成比例
• 在查询合作商列表时，同时显示每个合作商的点位数
• 重置密码，初始密码为123456

后端部分

在PartnerController中

/**
 * 重置合作商密码
 */
@PreAuthorize("@ss.hasPermi('manage:partner:edit')")
@Log(title = "重置合作商密码", businessType = BusinessType.UPDATE)
@PutMapping("/resetPwd/{id}")
public AjaxResult resetpwd(@PathVariable Long id) {//1. 接收参数
    //2. 创建合作商对象
    Partner partner = new Partner();
    partner.setId(id);// 设置id
    partner.setPassword(SecurityUtils.encryptPassword("123456"));// 设置加密后的初始密码
    //3. 调用service更新密码
    return toAjax(partnerService.updatePartner(partner));
}

前端部分

在manage/partner.js请求api中

// 重置合作商密码
export function resetPartnerPwd(id){
  return request({
    url: '/manage/partner/resetPwd/' + id,
    method: 'put'
  })
}

在partner/index.vue视图组件中参考@click=”handleDelete”，此方法删除时弹出对话框

<el-table-column label="操作" align="center" class-name="small-padding fixed-width" width="300px">
    <template #default="scope">
        <el-button link type="primary" @click="resetPwd(scope.row)" v-hasPermi="['manage:partner:edit']">重置密码</el-button>
    </template>
</el-table-column>

<script>
    import { listPartner, getPartner, delPartner, addPartner, updatePartner,resetPartnerPwd } from "@/api/manage/partner";
    /* 重置合作商密码 */
    function resetPwd(row) {
        proxy.$modal.confirm('你确定要重置该合作商密码吗？').then(function () {
            return resetPartnerPwd(row.id);
        }).then(() => {
            proxy.$modal.msgSuccess("重置成功");
        }).catch(() => { });
    }
</script>

点位管理改造——基础布局

修改前端更简单一些 可以把前端一次性请求1w条数据 后端接口就可以重复调用

在src\views\manage\node\index.vue视图组件中

import {listRegion} from "@/api/manage/region";

/* 查询所有条件对象 */
const loadAllParams=reactive({
  pageNum:1,
  pageSize:10000
})
/** 查询区域列表 **/
const regionList=ref([]);
function getRegionList() {
  listRegion(loadAllParams).then(response=>{
    regionList.value=response.rows;
  })
}
getRegionList();
getList();

在src\api\manage\region.js中

// 查询区域管理列表
export function listRegion(query) {
  return request({
    url: '/manage/region/list',
    method: 'get',
    params: query
  })
}

新增点位管理的时候想把合作商输入的改成自动获取的下拉框

• 定义js代码向后台发送请求，将请求后的结果封装给合作商parnterList集合
• 将文本框改成下拉框来遍历展示每个合作商的名称，提交时关联合作商的id

      <el-table-column label="详细地址" align="center" prop="address" show-overflow-tooltip/> 详细地址多出的部分隐藏只有鼠标移动到才会显示


import {listPartner} from "@/api/manage/partner"

<el-form-item label="合作商ID" prop="partnerId">
          <!-- <el-input v-model="form.partnerId" placeholder="请输入合作商ID" /> -->
           <el-select v-model="form.partnerId" placeholder="请选择合作商">
            <el-option
              v-for="item in partnerList"
              :key="item.id"
              :label="item.partnerName"
              :value="item.id">
            </el-option>
           </el-select>
</el-form-item>

/* 查询合作商列表 */
const partnerList=ref([]);
function getPartnerList(){
  listPartner(loadAllParams).then(response=>{
    partnerList.value = response.rows;
  })
}
getPartnerList();

避免每次都要写pageSize：10000 直接搞入js里面

src\api\page.js
/* 查询所有条件对象 */
// const loadAllParams=reactive({
//   pageNum:1,
//   pageSize:10000
// }) →

export const loadAllParams = reactive({
  pageNum: 1,
  pageSize: 10000,
});

点位管理改造点位中增加个查看详情(将单表查询改为多表查询咯)

• 查看详情，需要显示当前点位下所有设备列表(稍后完成)
• 在区域详情中，需要显示每个点位的设备数
• 在点位列表查询中，关联显示区域、合作商等信息
• 关联查询：对于设备数量的统计，我们需要执行关联查询，在mapper层封装
• 关联实体：对于区域和合作商的数据，我们会采用Mybatis提供的嵌套查询功能

<resultMap>......</resultMap>   #完成手动映射

#解决一对一 或 多对一 映射结果集只有一个对象时完成的ORM的映射封装
<association>......</association>  #点位和点位1对1  点位和合作商1对多

#解决一对多场景下来映射多个结果的集合 单个区域表+区域点位列表 映射的是集合！！
<collection>......</collection> 

# AI辅助编程模式
-- AI辅助编程模式
-- 你是一个软件开发工程师，现在要根据数据库的sql脚本，查询并显示点位表所有的字段信息,同时显示每个点位的设备数量，sql脚本如下：
create table tb_node
(
    id            int auto_increment comment '主键id'
        primary key,
    node_name     varchar(255)                        not null comment '点位名称',
    address       varchar(255)                        not null comment '详细地址',
    business_type int                                 null comment '商圈类型',
    region_id     int                                 null comment '区域ID',
    partner_id    int                                 null comment '合作商ID',
    create_time   timestamp default CURRENT_TIMESTAMP null comment '创建时间',
    update_time   timestamp default CURRENT_TIMESTAMP null on update CURRENT_TIMESTAMP comment '修改时间',
    create_by     varchar(64)                         null comment '创建人',
    update_by     varchar(64)                         null comment '修改人',
    remark        text                                null comment '备注',
    constraint tb_node_ibfk_1
        foreign key (region_id) references tb_region (id)
            on update cascade on delete cascade,
    constraint tb_node_ibfk_2
        foreign key (partner_id) references tb_partner (id)
            on update cascade on delete cascade
)
    comment '点位表';
    
create table tb_vending_machine
(
    id                   bigint auto_increment comment '主键'
        primary key,
    inner_code           varchar(15) default '000'                 null comment '设备编号',
    channel_max_capacity int                                       null comment '设备容量',
    node_id              int                                       not null comment '点位Id',
    addr                 varchar(100)                              null comment '详细地址',
    last_supply_time     datetime    default '2000-01-01 00:00:00' not null comment '上次补货时间',
    business_type        int                                       not null comment '商圈类型',
    region_id            int                                       not null comment '区域Id',
    partner_id           int                                       not null comment '合作商Id',
    vm_type_id           int         default 0                     not null comment '设备型号',
    vm_status            int         default 0                     not null comment '设备状态，0:未投放;1-运营;3-撤机',
    running_status       varchar(100)                              null comment '运行状态',
    longitudes           double      default 0                     null comment '经度',
    latitude             double      default 0                     null comment '维度',
    client_id            varchar(50)                               null comment '客户端连接Id,做emq认证用',
    policy_id            bigint                                    null comment '策略id',
    create_time          timestamp   default CURRENT_TIMESTAMP     not null comment '创建时间',
    update_time          timestamp   default CURRENT_TIMESTAMP     null comment '修改时间',
    constraint vendingmachine_VmId_uindex
        unique (inner_code),
    constraint tb_vending_machine_ibfk_1
        foreign key (vm_type_id) references tb_vm_type (id),
    constraint tb_vending_machine_ibfk_2
        foreign key (node_id) references tb_node (id),
    constraint tb_vending_machine_ibfk_3
        foreign key (policy_id) references tb_policy (policy_id)
)
    comment '设备表';

-- 查询并显示点位表所有的字段信息,同时显示每个点位的设备数量
SELECT
    n.id,
    n.node_name,
    n.address,
    n.business_type,
    n.region_id,
    n.partner_id,
    n.create_time,
    n.update_time,
    n.create_by,
    n.update_by,
    n.remark,
    COUNT(v.id) AS vm_count
FROM
    tb_node n
LEFT JOIN
    tb_vending_machine v ON n.id = v.node_id
GROUP BY
    n.id;

package com.dkd.manage.domain.vo;

import com.dkd.manage.domain.Node;
import com.dkd.manage.domain.Partner;
import com.dkd.manage.domain.Region;
import lombok.Data;

@Data
public class NodeVo extends Node {
    // 设备数量
    private Integer vmCount;
    // 区域信息
    private Region region;
    // 合作商信息
    private Partner partner;
}

com/dkd/manage/mapper/NodeMapper.java
/**
     *  查询点位管理列表
     * @param node
     * @return
     */
    public List<NodeVo> selectNodeVoList(Node node);

<!--
resultType="com.dkd.manage.domin.vo.NodeVo">...
这个是mybatis以前搞的自动映射封装直接把结果映射给了NodeVo的实体类了
嵌套查询就不能使用resultType自动映射 要改为resultMap做自动映射
<resultMap type="NodeVo" id="NodeVoResult">
多表查询一定要起别名噢 不然会报错没有指明where的子句是来自tb_node表的region_id  还是来自tb_vending_machine表的region_id
-->

<select id="selectNodeVoList" parameterType="Node" resultMap="NodeVoResult">
        SELECT
        n.id,
        n.node_name,
        n.address,
        n.business_type,
        n.region_id,
        n.partner_id,
        n.create_time,
        n.update_time,
        n.create_by,
        n.update_by,
        n.remark,
        COUNT(v.id) AS vm_count
        FROM
        tb_node n
        LEFT JOIN
        tb_vending_machine v ON n.id = v.node_id
        <where>
            <if test="nodeName != null  and nodeName != ''"> and n.node_name like concat('%', #{nodeName}, '%')</if>
            <if test="regionId != null "> and n.region_id = #{regionId}</if>
            <if test="partnerId != null "> and n.partner_id = #{partnerId}</if>
        </where>
        GROUP BY
        n.id
    </select>

多对一标签用association
<resultMap type="NodeVo" id="NodeVoResult">
        <result property="id"    column="id"    />
        <result property="nodeName"    column="node_name"    />
        <result property="address"    column="address"    />
        <result property="businessType"    column="business_type"    />
        <result property="regionId"    column="region_id"    />
        <result property="partnerId"    column="partner_id"    />
        <result property="createTime"    column="create_time"    />
        <result property="updateTime"    column="update_time"    />
        <result property="createBy"    column="create_by"    />
        <result property="updateBy"    column="update_by"    />
        <result property="remark"    column="remark"    />
        <result property="vmCount"    column="vm_count"    />
<!--
sql语法拿到region_id去执行区域当中的selectRegionById 方法执行的时候需要传递区域的id
原理：RegionMapper.java中的 public Region selectRegionById(Long id)把条件拿到手并封装给区域的Region对象 返回的Region对象最终映射给NodeVo.java的 private Region region;
怎么执行的映射呢？需要指定java属性名和执行的类型：
property="region" 
javaType="Region"
至此完成了mybatis的嵌套查询
-->
        <association property="region" javaType="Region" column="region_id" select="com.dkd.manage.mapper.RegionMapper.selectRegionById"/>
        <association property="partner" javaType="Partner" column="partner_id" select="com.dkd.manage.mapper.PartnerMapper.selectPartnerById"/>
    </resultMap>

<resultMap>......</resultMap>   // 完成手动映射 为了实现多表映射情况组合查询

// 解决一对一 或 多对一 映射结果集只有一个对象时完成的ORM的映射封装
<association>......</association>  #点位和点位1对1  点位和合作商1对多

// 解决一对多场景下来映射多个结果的集合 单个区域表+区域点位列表 映射的是集合！！
<collection>......</collection> 


/*
// <association> 标签允许你在查询结果中嵌套另一个对象。
 这样可以方便地在 NodeVo 对象中直接访问 Region 和 Partner 的属性，而不需要额外的查询
 
property：指定 NodeVo 类中的属性名称，该属性将引用关联的对象。
javaType：指定关联对象的 Java 类型。
column：指定用于关联查询的列名，通常是外键。
select：指定一个子查询的方法，用于根据外键查询关联对象
*/

NodeService

/**
 * 查询点位管理列表
 * @param node
 * @return NodeVo集合
 */
public List<NodeVo> selectNodeVoList(Node node);

NodeServiceImpl

/**
 * 查询点位管理列表
 *
 * @param node
 * @return NodeVo集合
 */
@Override
public List<NodeVo> selectNodeVoList(Node node) {
    return nodeMapper.selectNodeVoList(node);
}

NodeController

/**
 * 查询点位管理列表
 */
@PreAuthorize("@ss.hasPermi('manage:node:list')")
@GetMapping("/list")
public TableDataInfo list(Node node)
{
    startPage();
    List<NodeVo> voList = nodeService.selectNodeVoList(node);
    return getDataTable(voList);
}

com/dkd/manage/mapper/NodeMapper.java
/**
     *  查询点位管理列表
     * @param node
     * @return
     */
    public List<NodeVo> selectNodeVoList(Node node);

node/index.vue

<!-- 点位列表 -->
<el-table v-loading="loading" :data="nodeList" @selection-change="handleSelectionChange">
  <el-table-column type="selection" width="55" align="center" />
  <el-table-column label="序号" type="index" width="50" align="center" prop="id" />
  <el-table-column label="点位名称" align="center" prop="nodeName" />
  <el-table-column label="所在区域" align="center" prop="region.regionName" />
  <el-table-column label="商圈类型" align="center" prop="businessType">
    <template #default="scope">
      <dict-tag :options="business_type" :value="scope.row.businessType" />
    </template>
  </el-table-column>
  <el-table-column label="合作商" align="center" prop="partner.partnerName" />
  <el-table-column label="详细地址" align="center" prop="address" show-overflow-tooltip="true"/>
  <el-table-column label="操作" align="center" class-name="small-padding fixed-width">
    <template #default="scope">
      <el-button link type="primary" icon="Edit" @click="handleUpdate(scope.row)" v-hasPermi="['manage:node:edit']">修改</el-button>
      <el-button link type="primary" icon="Delete" @click="handleDelete(scope.row)" v-hasPermi="['manage:node:remove']">删除</el-button>
    </template>
  </el-table-column>
</el-table>

区域管理改造-地区详情新增查看详情

src\views\manage\region\index.vue
<el-table-column label="操作" align="center" class-name="small-padding fixed-width">
        <template #default="scope">
          <el-button link type="primary"  @click="getRegionInfo(scope.row)" v-hasPermi="['manage:region:list']">查看详情</el-button>
          <el-button link type="primary"  @click="handleUpdate(scope.row)" v-hasPermi="['manage:region:edit']">修改</el-button>
          <el-button link type="primary"  @click="handleDelete(scope.row)" v-hasPermi="['manage:region:remove']">删除</el-button>
        </template>
      </el-table-column>

<!-- 
template 插槽：
#default="scope"：定义默认插槽，scope 是当前行的数据对象。

@click="getRegionInfo(scope.row)"：点击按钮时调用 getRegionInfo 函数，并传入当前行的数据。
-->

...
...

/* 查看详情操作按钮 */
function getRegionInfo(row) {
  // 查询区域信息
  reset();
  const _id = row.id
  getRegion(_id).then(response => {
    form.value = response.data
  });
}

<!-- 
nodeList 变量：

const nodeList = ref([])：定义一个响应式数组 nodeList，用于存储点位列表。
getRegionInfo 函数：

reset()：调用 reset 函数，可能用于重置表单或其他状态。
const _id = row.id：获取当前行的 id。
getRegion(_id).then(response => { form.value = response.data })：调用 getRegion 函数查询区域信息，并将返回的数据赋值给 form.value。
loadAllParams.regionId = row.id：设置 loadAllParams 对象的 regionId 属性为当前行的 id。
listNode(loadAllParams).then(response => { nodeList.value = response.rows })：调用 listNode 函数查询点位列表，并将返回的行数据赋值给 nodeList.value。
-->

区域管理里引入点位的api文件

import { listNode } from "@/api/manage/node";
import { loadAllParams } from "@/api/page";
...
/* 查看详情操作按钮 */
const nodeList = ref([]);
function getRegionInfo(row) {
  // 查询区域信息
  reset();
  const _id = row.id
  getRegion(_id).then(response => {
    form.value = response.data
  });
  // 查看点位列表
  loadAllParams.regionId=row_id
  listNode(loadAllParams).then(response => {
    nodeList.value = response.rows;
  });
}

添加区域管理对话框

 <!-- 添加或修改区域管理对话框 -->
    <el-dialog :title="title" v-model="open" width="500px" append-to-body>
      <el-form ref="regionRef" :model="form" :rules="rules" label-width="80px">
        <el-form-item label="区域名称" prop="regionName">
          <el-input v-model="form.regionName" placeholder="请输入区域名称" />
        </el-form-item>
        <el-form-item label="备注说明" prop="remark">
          <el-input v-model="form.remark" type="textarea" placeholder="请输入内容" />
        </el-form-item>
      </el-form>
      <template #footer>
        <div class="dialog-footer">
          <el-button type="primary" @click="submitForm">确 定</el-button>
          <el-button @click="cancel">取 消</el-button>
        </div>
      </template>
    </el-dialog>
   <!-- 查看详情对话框 -->
<el-dialog title="区域详情" v-model="regionInfoOpen" width="500px" append-to-body>
    <el-form-item label="区域名称" prop="regionName">
        <el-input v-model="form.regionName" disabled />
    </el-form-item>
    <label>包含点位：</label>
    <el-table :data="nodeList">
        <el-table-column label="序号" type="index" width="50" align="center" />
        <el-table-column label="点位名称" align="center" prop="nodeName" />
        <el-table-column label="设备数量" align="center" prop="vmCount" />
    </el-table>
</el-dialog>

/* 查看详情操作按钮 */
const nodeList = ref([]);
const regionInfoOpen=ref(false);
function getRegionInfo(row) {
  // 查询区域信息
  reset();
  const _id = row.id
  getRegion(_id).then(response => {
    form.value = response.data
  });
  // 查看点位列表
  loadAllParams.regionId=row_id
  listNode(loadAllParams).then(response => {
    nodeList.value = response.rows;
  });
  regionInfoOpen.value=true;
}

数据完整性

• 在删除区域或合作商数据时，关联的点位数据该如何处理？

tb_region(区域表) tb_node(点位表) tb_partner(合作商表)
id ←region_id:id ← region_id id
partner_id partner_id:id →→→↑

找到设置外键约束(取消约束)dkd → tb_node → Modify Table(old) 找到Foreign Keys 双击打开后将Update rule和Delete rule修改为：no action

**CASCADE（级联操作）:**当父表中的某行记录被删除或更新时，与其关联的所有子表中的匹配行也会自动被删除或更新。这种方式适用于希望保持数据一致性的场景，即父记录不存在时，相关的子记录也应该被移除。

**SET NULL（设为空）:**若父表中的记录被删除或更新，子表中对应的外键字段会被设置为NULL。选择此选项的前提是子表的外键列允许为NULL值。这适用于那些子记录不再需要明确关联到任何父记录的情况。

**RESTRICT（限制）:**在尝试删除或更新父表中的记录之前，数据库首先检查是否有相关联的子记录存在。如果有，则拒绝执行删除或更新操作，以防止意外丢失数据或破坏数据关系的完整性。这是一种保守策略，确保数据间的引用完整性。

**NO ACTION（无操作）:**在标准SQL中，NO ACTION是一个关键字，它要求数据库在父表记录被删除或更新前，检查是否会影响子表中的相关记录。在MySQL中，NO ACTION的行为与RESTRICT相同，即如果子表中有匹配的行，则禁止执行父表的删除或更新操作。这意味着如果存在依赖关系，操作将被阻止，从而保护数据的参照完整性。

修改完毕后，如果你尝试进行删除操作，会发现数据库的完整性约束生效了，它会阻止删除操作并给出错误提示。但是，这个错误提示信息可能对于用户来说不够友好，可能会让用户感到困惑。

SQLIntegrityConstraintViolationException是Java中的一个异常类，这个类通常用于表示SQL数据库操作中的完整性约束违反异常

例如：外键约束、唯一约束等。当数据库操作违反了这些约束时，就会抛出这个异常。

这个错误是由于外键约束导致的。它表明在删除或更新父表的行时，存在外键约束，子表中的相关行会受到影响。

是因为在删除tb_region表中的行时，tb_node表中的region_id外键约束会阻止操作。

如果你在使用Spring框架进行数据库操作，可能会先遇到DataIntegrityViolationException，它是对SQLIntegrityConstraintViolationException的一个更高层次的抽象，旨在提供一种更加面向应用的错误表示。

而SQLIntegrityConstraintViolationException是更底层的异常，直接来源于数据库驱动，包含更多底层数据库相关的细节。

在实际开发中，推荐捕获并处理DataIntegrityViolationException，因为它更符合Spring应用的异常处理模式，同时也可以通过其内部的cause（原因）属性来获取具体的SQLIntegrityConstraintViolationException，进而获取详细的错误信息。

为了提升用户体验，我们可以使用Spring Boot框架的全局异常处理器来捕获这些错误信息，并返回更友好的提示信息给用户。这样，当用户遇到这种情况时，他们将收到一个清晰、易懂的提示，告知他们操作无法完成的原因。

com/dkd/framework/web/exception/GlobalExceptionHandler.java
/**
     * 数据完整性异常
     */
    @ExceptionHandler(DataIntegrityViolationException.class)
    public AjaxResult handleDataIntegrityViolationException(DataIntegrityViolationException e) {
        log.error(e.getMessage(), e);
        if (e.getMessage().contains("foreign")) {
            return AjaxResult.error("无法删除该数据，有其他数据引用");
        }
        return AjaxResult.error("数据完整性异常，请联系管理员");
    }

16

Redis篇

我看你做的项目中，都用到了redis，你在最近的项目中哪些场景使用了redis呢？

• 验证你项目场景的真实性，二是为了深入发问的切入点
• 缓存 缓存三兄弟(穿透、击穿、雪崩)、双写一致、持久化、数据过期策略、数据淘汰策略
• 分布式锁 setnx、redisson
• 消息队列、延迟队列 何种数据类型

==缓存穿透==：查询一个不存在的数据，mysql查询不到数据也不会直接写入缓存，就会导致每次请求都查询数据库(可能原因是数据库被攻击了 发送了假的/大数据量的请求url)

• 解决方案一：缓存空数据，查询返回的数据为空，仍把这个空结果进行缓存 {key:1, value:null}
  优点：简单
  缺点：消耗内存，可能会发生不一致的问题

• 解决方案二：布隆过滤器 (拦截不存在的数据)

  在缓存预热时，要预热布隆过滤器。根据id查询文章时查询布隆过滤器如果不存在直接返回

  bitmap（位图）：相当于一个以bit位为单位的数组，数组中每个单元只能存储二进制数0或1

  布隆过滤器作用：可以用于检索一个元素是否在集合中

  • 存储数据：id为1的数据，通过多个hash函数获取hash值，根据hash计算数组对应位置改为1
  • 查询数据：使用相同hash函数获取hash值，判断对应位置是否都为1

  存在误判率：数组越小 误判率越大

  bloomFilter.tryInit(size, 0.05) //误判率5%
  

==缓存击穿==：给某一个key设置了过期时间，当key过期的时候，恰好这个时间点对这个key有大量的并发请求过来，这些并发请求可能一瞬间把DB击穿

• 解决方案一：互斥锁【数据强一致性 性能差 (银行)】

  1.查询缓存,未命中 → 2.获取互斥锁成功 → 3.查询数据库重建缓存数据 → 4.写入缓存 → 5.释放锁

  1.查询缓存,未命中 → 2.获取互斥锁失败 → 3.休眠一会再重试 → 4.写入缓存重试 → 5.缓存命中

• 解决方案二：逻辑过期[不设置过期时间] 【高可用 性能优 不能保证数据绝对一致 (用户体验)】
  也可以搞个永不过期 具体是先在业务里写好某种情况下 某些时候不会过期 比如疫情卖口罩时期

  在数据库一条数据里面添加一个 “expire”: 153213455

  1.查询缓存,发现逻辑时间已过期 → 2.获取互斥锁成功 → 3.开启线程 ↓→ 4.返回过期数据

  ​ 【在新的线程】→ 1.查询数据库重建缓存数据 → 2.写入缓存,重置逻辑过期时间 → 3.释放锁
  1.查询数据缓存,发现逻辑时间已过期 → 2.获取互斥锁失败 → 3.返回过期数据

==缓存雪崩==：在同一个时段内大量的缓存key同时失效或者Redis服务宕机，导致大量请求到达数据库，带来压力

• 解决方案一：给不同的key的TTL(过期时间)添加随机值
• 解决方案二：利用Redis集群提高服务的可用性 【哨兵模式、集群模式】
• 解决方案三：给缓存业务添加降级限流策略【nginx、springcloud、gateway】
• 解决方案四：给业务添加多级缓存 【Guava(做一级缓存 然后Redis是二级缓存)或Caffeine】

《缓存三兄弟》
穿透无中生有key，布隆过滤null隔离。
缓存击穿过期key，锁与非期解难题。
雪崩大量过期key，过期时间要随机。
面试必考三兄弟，可用限流来保底。

redis作为缓存，mysql的数据如何与redis进行同步呢？(双写一致性)

✅ 二、Redis 和 MySQL 不一致会发生什么？

如果同步失败，会出现：

• 缓存中的数据是脏的（脏读）
• 缓存中没有数据，但数据库中有（缓存穿透）
• 数据库更新了，但 Redis 仍是旧值（一致性问题）
• 并发写操作丢失最新值（写丢失）

写先插入数据库
更新先更新数据库 更新数据库成功但redis不成功 影响不大 因为后面会有过期删除 最终会一致，更新mysql后缓存可以删除也可以修改
更新完数据库直接删除缓存了 有过期时间兜底 最终会保持一致 我们项目中对数据敏感性一致性不高 我们追求实时性
如果是最终保持一致性的就MQ 我们对实时性不高 对数据敏感性 一致性高
删除问题不大 哪里都行！
读多写少的可以上缓存
mysql保存购物车表 但是再页面操作的时候 只操作redis 用mq给到消费者修改或定时任务 更新数据到mysql，MQ问题：我们对数据实时性要求不高 只需要保存最终一致性就行

你如果只写redis 万一丢了数据怎么办？
购物车丢点订单无影响 数据安全性要求不太高 mysql尽量不要搞购物车的表 都在redis的表 丢就丢了呗。
或者异步同步/定时任务
实时性要求 安全性要求 → MySQL
电商一般数据库和mysql都要存 → 读多写少

一定、一定、一定要设置前提，介绍自己的业务背景 (一致性要求高？允许延迟一致？)

① 介绍自己简历上的业务，我们当时是把文章的热点数据存入到了缓存中，虽然是热点数据，但是实时要求性并没有那么高，所以我们采用的是异步的方案同步的数据

② 我们当时是把抢卷的库存存入到了缓存中，这个需要实时的进行数据同步，为了保证数据的强一致性，我们当时采用的是redission提供的读写锁来保证数据的同步

双写一致性：当修改了数据库的数据也要同时更新缓存的数据，缓存和数据库的数据要保持一致

• 读操作：缓存命中，直接返回；缓存未命中查询数据库，写入缓存，设定超时时间

• 写操作：延迟双删 [因为无论先删除缓存还是先删除数据库都可能会出数据不一致问题 有脏数据]

• ==基于redisson互斥锁：==[放入缓存中的数据 读多写少] 【强一致性业务 性能低】

  • 共享锁：读锁readLock，加锁之后，其他线程可以共享读操作，但**不允许写操作**
  • 排他锁：独占锁writeLock也叫，加锁之后，阻塞其他线程读写操作(只允许一个用户或进程独占地对数据进行读取和写入操作)排他锁确保了写操作的原子性和一致性
  • 读数据的时候添加共享锁(读不互斥、写互斥)
  • 写数据的时候添加排他锁(阻塞其他线程的读写 因为读多写少)

  redissionClient.getReadWriteLock(“xxxx”);

• ==异步通知==： 异步通知保证数据的最终一致性(需要保证MQ的可靠性)需要在Redis中更新数据的同时，通知另一个服务进行某些操作。

  • 使用场景：
    • 缓存与数据库双写： 当应用需要同时更新Redis缓存和数据库时，可以先将数据写入Redis，然后通过异步通知机制触发数据库的更新操作。
    • 跨地域数据复制： 在跨地域部署的服务中，为了实现数据的最终一致性，可以在一个地域写入数据后，通过异步通知机制在另一个地域进行数据复制。
    • 系统间数据同步： 在微服务架构中，不同的服务可能有自己的数据存储。当一个服务更新了数据后，可以通过异步通知机制告知其他相关服务进行数据同步。

• ==基于Canal的异步通知==：监听mysql的binlog

  • 使用MQ中间件，更新数据之后，通知缓存删除
  • 利用canal中间件，不需要修改业务代码，伪装为mysqls的一个从节点，canal通过读取binlog数据更新缓存

✅ 为什么会出现 Redis 和 MySQL 数据不一致？

Redis 是缓存，MySQL 是数据库，它们的数据生命周期不同，导致在更新时会出现以下几种情况：

---

💥 情况1：先更新数据库，再删除缓存（常见写法）

update DB
delete cache

• 假设刚执行完 update DB，还没来得及 delete cache，此时某个高并发请求进来：
  • 它先查缓存，发现是旧数据；
  • 然后返回了错误的数据；
  • 后续即使删了缓存，已经晚了。

这就是：缓存未及时失效，读取到了脏数据。

---

💥 情况2：先删除缓存，再更新数据库

delete cache
update DB

• 这个时候如果并发查询线程来得很快：
  • 缓存刚被删，查询请求就查不到；
  • 就会穿透查数据库，查到旧数据；
  • 然后又把旧数据写入了 Redis，覆盖了更新后的数据！

---

💥 情况3：缓存过期后查询数据库，正好遇到更新未完成

Redis key 过期
查询数据库返回旧数据
写入 Redis（错的数据被缓存）

这就是缓存击穿 + 数据同步延迟的问题。

---

✅ 数据为什么会“丢”？需要同步吗？

Redis 是内存数据库，不具备强一致性保障，以下情况会导致“看起来丢数据”：

1. 更新了数据库，但缓存没更新/没删除
2. 缓存提前过期，重新加载了旧数据
3. Redis 重启，缓存丢失
4. 并发穿透，旧数据反复写入缓存
5. 程序异常，缓存更新/删除逻辑没执行

✅ 怎么保证 Redis 和 MySQL 的一致性？

这就是我们说的：缓存与数据库双写一致性问题，常见策略如下：

1️⃣ 读写操作采用延迟双删策略（推荐）

update DB
delete Redis
sleep 500ms
delete Redis again

• 延迟双删可以尽可能避免并发查询旧缓存的情况。

2️⃣ 加分布式锁

• 给关键资源加锁，串行化更新操作，避免并发穿透。

3️⃣ 异步更新缓存（利用消息队列）

• 变更数据后，发送消息通知缓存异步刷新。

4️⃣ 设置合理的缓存 TTL + 定时刷新

• 防止长期过期数据驻留，降低不一致几率。

5️⃣ 不缓存非热点数据

• 某些冷门数据没必要缓存，避免无谓一致性维护。

Redis作为缓存，数据的持久化是怎么做的？

Redis持久化：RDB全称Redis Database Backup file(Redis数据备份文件)，也被叫做Redis数据快照，简单来说就是把内存中的所有数据都记录到磁盘中。当Redis实例故障重启后，从磁盘读取快照文件，数据恢复。

[root@localhost ~]# redis-cli
127.0.0.1:6379> save          #由Redis主进程来执行RDB，会阻塞所有命令
ok

127.0.0.1:6379> bgsave        #开 启子进程执行RDB，避免主进程受到影响
Background saving started

Redis内部有触发RDB的机制，可以在redis.conf文件中找到，格式如下：

// 900秒内，如果至少有1个key被修改，则执行bgsave
save 900 1
save 300 10
save 60 10000

==RDB的执行原理？==数据完整性高用RDB
save就是直接让主线程去执行

bgsave开始时会fork主进程得到子进程，子进程共享主进程的内存数据，完成fork后读取内存数据并写入RDB文件

在LInux中主进程并无法直接读取物理内存，它只能通过虚拟内存去读。因此有页表(记录虚拟地址与物理地址的映射关系)去执行操作 同时 主进程也会fork(复制页表) 成为一个新的子进程(携带页表) → 写新RDB文件替换旧的RDB文件 → 磁盘

fork采用的是copy-on-write技术：

• 当主进程执行读操作时，访问共享内存
• 当主进程执行写操作时，则会拷贝一份数据，执行写操作

优点：二进制数据重启后 Redis无需过多解析 直接恢复

==AOF==对数据不敏感要求不高

AOF全称为Append Only File(追加文件)底层硬盘顺序读写。Redis处理的每个写命令都会记录在AOF，可以看作是命令日志文件
AOF默认是关闭的，需要修改redis.conf配置文件来开启AOF：

# 是否开启AOF功能，默认是no
appendonly yes
# AOF文件的名称
appendfilename "appendonly.aof"

AOF的命令记录的频率也可以通过redis.conf文件来配

# 表示每执行一次写命令，立即记录到AOF文件
appendfsync always
# 写命令执行完毕先放入AOF缓冲区，然后表示每隔一秒将缓冲区数据写到AOF文件，是默认方案
appendfsync everysec
# 写命令执行完先放入AOF缓冲区，由操作系统决定何时将缓冲区内容写回磁盘
appendfsync no

因为是记录命令，AOF文件会比RDB文件大的多。而且AOF会记录对同一个key的多次写操作，但只有最后一次写操作才有意义。通过执行bgrewriteaof命令，可以让AOF文件执行重读功能，用最少的命令达到相同效果这是AOF文件越来越大的处理方式

Redis会在出发阈值时自动重写AOF文件。阈值也可以在redis.conf中配置

# AOF文件比上次文件 增多超过多少百分比则触发重写
auto-aof-rewrite-percentage 100
# AOF文件体积最小多大以上才触发重写
auto-aof-rewrite-min-size 64mb

★★★★★★★★ RDB与AOF对比 ★★★★★★★★

RDB和AOF各有优缺点，如果对数据安全性要求较高，在实际开发中往往会结合两者来使用
RDB是二进制文件，在保存时体积较小恢复较快，但也有可能丢失数据，我们通常在项目中使用AOF来恢复数据，虽然慢但丢失数据风险小，在AOF文件中可以设置刷盘策略(每秒批量写入一次命令)

假如Redis的key过期之后，会立即删除吗

Redis对数据设置数据的有效时间，数据过期以后就需要将数据从内存中删除掉。可以按照不同的规则进行删除，这种删除规则就被称之为数据的删除策略(数据过期策略)

==Redis数据删除策略-惰性删除==

惰性删除：设置该key过期时间后，我们不去管它，当需要该key时，我们在检查其是否过期，如果过期，我们就删掉它，反之返回该key

set name zhangsan 10
get name # 发现name过期了，直接删除key

优点：对CPU友好，只会在使用该key时才会进行过期检查，对于很多用不到的key不会浪费时间进行过期检查
缺点：对内存不友好，如果一个key已经过期，但是一直没有使用，那么该key就会一直存在内存中，内存永远不会释放

==Redis数据删除策略-定期删除==

定期删除：每隔一段时间，我们就会对一些key进行检查，删除里面过期的key (从一定数量的数据库中取出一定数量的随机key进行检查，并删除其中的过期key)

定期清理的两种模式：

• SLOW模式是定时模式，执行频率默认为10hz，每次不超过25ms，以通过修改配置文件redis.conf的hz选项来调整这个次数
• FAST模式执行频率不固定，但两次间隔不低于2ms，每次耗时不超过1ms

优点：可以通过限制删除操作执行的时长和频率来减少删除操作对CPU的影响。另外定期删除，也能有效释放过期键占用的内存
难点：难以确定删除操作执行的时长和频率

Redis过期删除策略： 惰性删除 + 定期删除 两种策略进行配合使用

假如缓存过多，内存是有限的，内存被占满了怎么办？

==数据淘汰策略==

当Redis中的内存不够用时，此时在向Redis中添加新的key，那么Redis就会按照某一种规则将内存中的数据制除掉，这种数据的制除规则被称之为内存的淘汰策略

Redis支持8种不同策略来选择要删除的key:

• noeviction：不淘汰任何key，但是内存满时不允许写入新数据，默认就是这种策略

  maxmemory-policy noeviction

• volatile-ttl：对设置了TTL的key，比较key的剩余TTL值，TTL越小越先被淘汰 (TTL:过期时间的key)

• allkeys-random：对全体key，随机进行淘汰

• volatile-random：对设置了TTL的key，随机进行淘汰

• allkeys-lru：对全体key，基于LRU算法进行淘汰

  LRU(Least Recently Used)：最近最少使用，用当前时间减去最后一次访问时间，这个值越大测淘汰优先级越高 [逐出访问时间最少的]
  LFU(Least Frequently Used)：最少频率使用。会统计每个key的访问频率，值越小淘汰优先级越高。[逐出频率最低的] 【电商会应用】

• allkeys-lfu：对全体key，基于LFU算法进行淘汰

• volatile-lfu：对设置了TTL的key，基于LFU算法进行淘汰

淘汰策略 - 使用建议

1.优先使用 allkeys-lru 策略。充分利用LRU算法的优势，把最近最常访问的数据留在缓存中，如果业务有明显的冷热数据区分，建议使用。
2.如果业务中数据访问频率差别不大，没有明显冷热数据区分，建议使用allkeys-random，随机选择淘汰
3.如果业务中有置顶的需求，可以使用volatile-lru策略，同时置顶数据不设置过期时间，这些数据就一直不会被删除，会淘汰其他设置过期时间的数据
4.如果业务中有短时高频访问的数据，可以使用allkeys-lfu或volatile-lfu策略

数据库有1000万数据，Redis只能缓存20w数据，如何保证Redis中的数据都是热点数据？

• 使用allkeys-lru(挑选最近最少使用的数据淘汰) 淘汰策略，留下来的都是经常访问的热点数据

Redis的内存用完了会发生什么？

• 主要看数据淘汰策略是什么？如果是默认的配置(noeviction)，会直接报错

redis分布式锁，是如何实现的？

需要结合项目中的业务进行回答，通常情况下，分布式锁的使用场景：
集群情况下的定时任务、抢单、幂等性场景
如果使用互斥锁的话 那么在集群项目有多个服务器就会出现问题

==Redis分布式锁==

Redis实现分布式锁主要利用Redis的setnx命令，setnx是**SET if not exists**(如果不存在，则SET)的简写
在同一时刻，只有一个线程/进程/服务节点能拿到锁，执行关键代码。其他的只能等或者失败退出。

• 获取锁

  添加锁，NX是互斥、PX是设置超时时间
  SET lock value NX PX 10

• 释放锁

  释放锁，删除即可
  DEL key

Redis实现分布式锁如何合理的控制锁的有效时长？

• 根据业务执行时间预估
• 给锁续期

你“自己用 Redis 实现分布式锁” vs 用 Redisson 实现锁 —— 有哪些区别？

==redisson实现分布式锁 - 执行流程==
✅ 只有在 你没指定超时时间 时，Watchdog 才会自动开启

加锁 ↓→ 加锁成功 → Watch dog(看门狗)每隔(releaseTime/3的时间做一次续期) → Redis
↓ 操作redis → Redis
↓→→ 释放锁↑ → 通知看门狗无需继续监听 → Redis

加锁 → → → 是否加锁成功？→→→ ↓
↑←←while循环不断尝试获取锁←←←↓

public void redisLock() throws InterruptedException{
    RLock lock = redissonClient.getLock("heimalock");
 // boolean isLock = lock.tryLock(10, 30, TimeUnit.SECONDS);
// 如果不设置中间的过期时间30 才会触发看门狗
// 加锁，设置过期时间等操作都是基于lua脚本完成的[调用redis命令来保证多条命令的原子性]
    boolean isLock = lock.tryLock(10, TimeUnit.SECONDS);
    if(isLock){
        try{
            sout("执行业务");
        } finally{
            lock.unlock();
        }
    }
}

要加依赖

<dependency>
    <groupId>redis.clients</groupId>
    <artifactId>jedis</artifactId>
    <version>3.7.0</version>
</dependency>

❌ 如果你这样写：

lock.lock(10, TimeUnit.SECONDS);

就不会有自动续命，看门狗不会工作。这种锁就是严格 10 秒后自动释放，不管你业务是否完成。

🔄 Watchdog 自动续命流程图

lock.lock() 被调用
     ↓
Redisson 设置锁为30秒过期
     ↓
启动看门狗线程，每10秒刷新一次锁 TTL
     ↓
如果线程还持有锁 → Redis.expire(lockKey, 30秒)
     ↓
直到 unlock() 调用 → 结束看门狗 + 删除锁

==redisson实现分布式锁 - 可重入==

redis实现分布式锁是不可重入的 但是 redisson实现分布式锁是可以重入的
可重入原理：它俩是同一个线程 每个线程都有唯一的线程id 根据线程id唯一标识做判断 判断之前获取锁是不是同一个线程
利用hash结构记录线程id和重入次数

KEY	VALUE	VALUE
	field	value
heimalock	thread1	0

public void add1(){
  RLock lock = redissonClient.getLock("heimalock");
  boolean isLock = lock.tryLock();
// 执行业务
  add2();
// 释放锁
  lock.unlock();
}
public void add2(){
  RLock lock = redissonClient.getLock("heimalock");
  boolean isLock = lock.tryLock();
// 执行业务
// 释放锁 锁次数-1不完全释放
  lock.unlock();
}

==redisson实现分布式锁 - 主从一致性==

Redis Master主节点：主要负责 写操作(增删改) 只能写
Redis Slave从节点：主要负责读操作只能读

当RedisMaster主节点突然宕机后 Java应用会去格外获取锁 这时两个线程就同时持有一把锁 容易出现脏数据
怎么解决呢？

• RedLock(红锁)：不能只在一个redis实例上创建锁，应该是在多个redis实例上创建锁(n/2+1)，避免在一个redis实例【实现复杂、性能差、运维繁琐】怎么解决？→ CP思想：zookeeper

Redis集群有哪些方案？

• ==主从复制==

  单节点Redis的并发能力是有上限的，要进一步提高Redis的并发能力，就需要搭建主从集群，实现读写分离
  主节点写操作→增删改 从节点读操作→查

  介绍一下redis的主从同步

  单节点Redis的并发能力是有上限的，要进一步提高Redis的并发能力，就要搭建主从集群，实现读写分离。一般都是一主多从，主节点负责写数据，从节点负责读数据

  主从数据同步原理：

  • 主从全量同步：

  slave从节点执行replicaof命令建立链接 → 请求master主节点数据同步(replid+offset) → master判断是否是第一次同步(判断replid是否一致) → 是第一次, 返回master的数据版本信息(replid+offset) → slave保存版本信息 → master执行bgsave, 生成RDB → 发送RDB文件给slave → slave清空本地数据加载RDB数据 → 此时master记录RDB期间所有命令repl_balklog → 发送repl_backlog中的命令 → slave执行接收到的命令

  Replication ld: 简称replid，是数据集的标记，id一致则说明是同一数据集。每一个master都有唯一的replid,slave则会继承master节点的replid
  offset: 偏移量，随着记录在repl baklog中的数据增多而逐渐增大。save完成同步时也会记录当前同步的offset，如果slave的offset小于master的offset，说明slave数据落后于master，需要更新。

  简述全量同步的流程？

  • slave节点请求增量同步

  • master节点判断replid，发现不一致，拒绝增量同步

  • master将完整内存数据生成RDB，发送RDB到slave

  • slave清空本地数据，加载master的RDB

  • master将RDB期间的命令记录在repl_baklog，并持续将log中的命令发送给slave

  • slave执行接收到的命令，保持与master之间的同步

  能说一下，主从同步数据的流程吗？

  全量同步

  1.从节点请求主节点同步数据(replication id、offset)
  2.主节点判断是否为第一次请求，是第一次就与从节点同步版本信息(replication id和offset)
  3.主节点执行bgsave, 生成RDB文件后, 发送给从节点去执行
  4.在RDB生成执行期间, 主节点会从命令的方式记录到缓冲区(日志文件)

  • 主从增量同步
    主从增量同步(slave重启或后期数据变化)

  ① slave重启后 → 携带(replid+offset)找master → master判断请求replid是否一致 → 是第一次, 返回主节点replid和offset → 保存版本信息
  ② slave重启后 → 携带(replid+offset)找master → master判断请求replid是否一致 → 不是第一次, 回复continue向slave → master 去repl_baklog中获取offset后的数据 → 发送offset后的命令给slave → 执行命令

  增量同步

  1.从节点请求主节点同步数据，主节点判断不是第一次请求，不是第一次就获取从节点的offset值
  2.主节点从命令日志中获取offset值后的数据，发送给节点进行数据同步

简述全量同步和增量同步区别？

•全量同步：master将完整内存数据生成RDB，发送RDB到slave。后续命令则记录在repl_baklog，逐个发送给slave。

•增量同步：slave提交自己的offset到master，master获取repl_baklog中从offset之后的命令给slave

什么时候执行全量同步？

•slave节点第一次连接master节点时

•slave节点断开时间太久，repl_baklog中的offset已经被覆盖时

什么时候执行增量同步？

•slave节点断开又恢复，并且在repl_baklog中能找到offset时

• ==哨兵模式==搭过集群，具体多少个节点是组长那边，不太清楚[并发量不是太多 搭哨兵可以节省一点资源]~
  Redis提供了哨兵(Sentinel)机制来实现主从集群的自动故障恢复

  • 监控：Sentinel会不断检查您的master和slave是否按预期工作
  • 自动故障恢复：如果master故障，Sentinel会将一个slave提升为一个master。当故障实例恢复后也以新的master为主
  • 通知：Sentinel充当Redis客户端的服务发现来源，当集群发生故障转移时，会将最新信息推送给Redis的客户端

  服务状态监控
  Sentinel基于心跳机制监测服务状态，每隔1秒向集群的每个实例发送ping命令 期待回复pong

  • 主观下线：如果某sentinel节点发现或某实例未在规定时间相应，则认为该实例主观下线
  • 客观下线：若超过指定数量(quorum)的sentinel都认为该实例主观下线，则该实例客观下线，quorum值最好超过Sentinel实例数量的一半

  哨兵选主规则

  • 首先判断主与从节点断开时间长短，如超过指定值就排该从节点
  • 然后判断从节点的slave-priority值，越小优先级越高
  • 如果slave-priority值一样，则判断slave节点的offset值，越大优先级越高 (数据是最全的)
  • 最后是判断slave节点的运行id大小，越小优先级越高

  redis集群(哨兵模式) 脑裂
  因网络问题 主节点和从节点分别在不同的网络分区 这样sentinel只会监控到一部分从节点网络分区 导致RedisClient继续写主节点的数据，这时网络恢复了，哨兵会将老的master强制降级到slave(携带着脑裂前的最新数据)，这个时候slave就会把自己数据清空去同步master数据，这时就存在真正的数据丢失了

  怎么解决？

  redis中有两个配置参数：【若不能达成就拒绝客户端请求 这样就会避免大量数据丢失】
  min-replicas-to-write 1 表示最少的salve节点为1
  min-replicas-max-lag 5 表示数据复制和同步的延迟不能超过5秒
  达不到这两个条件就拒绝写入，从而避免数据丢失。

  怎么保证Redis的高并发高可用呢？

  哨兵模式：实现主从集群的自动故障恢复(监控、自动故障恢复、通知)

  你们使用redis是单点还是集群，哪种集群？

  主从(1主1从) + 哨兵就可以了。单节点不超过10G内存，如果Redis内存不足则可以给不同服务分配独立的Redis主从节点

  redis集群脑裂，该怎么解决？

  集群脑裂是由于主节点和从节点和sentinel处于不同网络分区，使得sentinel没有能够心跳感知到主节点，所以通过选举的方式提升了一个从节点为主，这样就存在了两个master，就像大脑分裂了一样，这样会导致客户端还在老的主节点那里写入数据，新节点无法同步数据，当为网络恢复后，sentinel会将老的主节点降为从节点，此时再从新master同步数据，就会导致数据丢失
  解决：我们可以修改redis的配置，可以设置最少的从节点数量以及缩短主从数据同步的延迟时间，达不到要求就拒绝请求，这样就会避免大量数据丢失。

• ==分片集群==

  主从和哨兵可以解决高可用、高并发读的问题，但是依然有两个问题没有解决：

  • 海量数据存储问题
  • 高并发写的问题

  使用分片集群可用解决上述问题，分片集群特征：

  • 集群中有多个master，每个master保存不同数据
  • 每个master都可用有多个slave节点
  • master之间通过ping监测彼此健康状态
  • 客户端请求可用访问集群任意节点，最终都会被转发到正确节点

  分片集群结果 - 数据读写

  Redis分片集群引入了哈希槽的概念，Redis集群有16384个哈希值，每个key通过CRC16校验后对16384取模来决定放置哪个槽，集群的每个节点负责一部分hash槽

  存数据流程：
  set name itheima → CRC16计算name的hash值(666666) → 666666%16384=11306 → 根据11306找寻所对应哈希槽的范围 并且插入数据

  redis的分片集群有什么用？

  • 集群中有多个master，每个master保存不同数据。(解决高并发写的问题)
  • 每个master都可以有多个slave节点。(解决高并发读的问题)
  • master之间通过ping监测彼此健康状态
  • 客户端请求可用访问集群任意节点，最终都会被转发到正确节点

  redis的分片集群中数据是怎么存储和读取的？

  • Redis 分片集群引入了哈希槽的概念，Redis 集群有16384个哈槽
  • 将16384个插槽分配到不同的实例
  • 读写数据:根据key的**有效部分**计算哈希值，对16384取余(有效部分，如果key前面有大括号，大括号的内容就是有效部分，如果没有，则以key本身做为有效部分)余数做为播槽，寻找插所在的实例

🚀 Redis 集群常见三种方式（解决不同问题）

Redis是单线程的，但是为什么还那么快

• Redis是纯内存操作，执行速度非常快
• 采用单线程，避免不必要的上下文切换可竞争条件，多线程还要考虑线程安全问题
• 使用I/O多路复用模型，非阻塞IO

解释一下I/O多路复用模型？

Redis是纯内存操作，执行速度非常快，它的性能瓶颈是网络延迟而不是执行速度，I/O多路复用模型主要就是实现了高效的网络请求

• 是指利用单个线程来同时监听多个Socket ，并在某个Socket可读、可写时得到通知，从而避免无效的等待，充分利用CPU资源，目前的I/O多路复用都是采用的epol模式实现，它会在通知用户进程Socket就绪的同时，把已就绪的Socket写入用户空间，不需要换个Socket来判断是否就绪，提升了性能

• Redis网络模型:

  就是使用I/O多路复用结合事件的处理器来应对多个Socket请求

  • 连接应答处理器

  • 命令回复处理器，在Redis6.0之后，为了提升更好的性能，使用了多线程来处理回复事件

  • 命令请求处理器，在Redis6.0之后，将命令的转换使用了多线程，增加命令转换速度，在命令执行的时候，依然是单线程

• ==用户空间和内核空间==

  • Linux系统中一个进程使用的内存情况划分两部分：内核空间、用户空间
  • 用户空间只能执行受限的命令Ring3，而且不能直接调用系统资源必须通过内核提供的接口来访问
  • 内核空间可以执行特权命令Ring0，调用一切系统资源

  Linux系统为了提高IO效率，会在用户空间和内核空间都加入缓冲区

  • 写数据时，要把用户缓冲数据拷贝到内核缓冲区，然后写入设备
  • 读数据时，要从设备读取数据到内核缓冲区，然后拷贝到用户缓冲区

• 常见的IO模型

  • ==阻塞IO==

    阻塞IO就是两个阶段都必须阻塞等待：
    阶段一：

    • 用户进程尝试读取数据(网卡数据等)
    • 此时数据尚未到达，内核需要等待数据
    • 此时用户进程也处于阻塞状态

    阶段二：

    • 数据到达并拷贝到内核缓冲区，代表已就绪
    • 将内核数据拷贝到用户缓冲区
    • 拷贝过程中，用户进程依然阻塞等待
    • 拷贝完成，用户进程解除阻塞，处理数据

  • ==非阻塞IO==

    阶段一：

    • 用户进程尝试读取数据(比如网卡数据)
    • 此时数据尚未到达，内核需要等待数据
    • 返回异常给用户进程
    • 用户进程拿到error后，再次尝试读取
    • 循环往复，直到数据就绪

    阶段二:

    • 将内核数据拷贝到用户缓冲区
    • 拷贝过程中，用户进程依然阻塞等待
    • 拷贝完成，用户进程解除阻塞，处理数据

  • ==IO多路复用==

    是利用单个线程来同时监听多个Socket，并在某个Socket可读、可写时得到通知，从而避免无效的等待，充分利用CPU资源

    IO多路复用是利用单个线程来同步监听多个Socket，并在某个Socket可读、可写时得到通知，从而避免无效的等待，充分利用CPU资源。不过监听Socket的方式、通知的方式又有多种实现

    • select
    • poll
    • epoll

    差异:
    ★ select和polI只会通知用户进程有Socket就绪，但不确定具体是哪个Socket，需要用户进程逐个历Socket来确认
    ★ epoll则会在通知用户进程Socket就绪的同时，把已就绪的Socket写入用户空间,

    阶段一:

    • 用户进程调用select，指定要监听的Socket集合
    • 内核监听对应的多个socket
    • 任意一个或多个sacket数据就绪则返回readable
    • 此过程中用户进程阻塞

    阶段二:

    • 用户进程找别就格的socket
    • 依次调用recvfrom读取数据
    • 内核将数据拷贝到用户空间
    • 用户进程处理数据

• Redis网络模型

MySQL篇

在MySQL中，如何定位慢查询？

1.介绍一下当时产生问题的场景(我们当时的一个接口测试的时候非常的慢，压测的结果大概5秒钟)
2.我们系统中当时采用了运维工具(Skywalking)，可以监测出哪个接口，最终因为是sql的问题
3.在mysql中开启了慢日志查询，我们设置的值就是2秒，一旦sql执行超过2秒就会记录到日志中(调试阶段)

产生原因：

• 聚合查询
• 多表查询
• 表数据量过大查询
• 深度分页查询

方案一：==开源工具==[调试阶段才会开启 生产阶段不会开启]

• 调试工具Arthas
• 运维工具：Prometheus、Skywalking(接口访问时间)

方案二：==MySQL自带慢日志==

慢查询日志记录了所有执行时间超过指定参数(long_query_time, 单位：秒，默认10秒)的所有SQL语句的日志，如果要开启慢查询日志，需要在MySQL的配置文件(/etc/my.cnf)中配置信息：

# 开启MySQL慢日志查询开关
slow_query_log = 1
# 设置慢日志的时间为2秒，SQL语句执行时间超过2秒，就会被视为慢查询，记录慢查询日志
long_query_time = 2

那这个SQL语句执行很慢，如何分析呢？

可以采用MySQL自带的分析工具 explain

• 通过key和key_len检查是否命中了索引(索引本身存在是否有失效的情况)
• 通过type字段查看sql是否有进一步的优化空间，是否存在全索引扫描或全盘扫描
• 通过extra建议判断，是否出现了回表的情况，如果出现了，可以尝试添加索引或修改返回字段来修复

产生原因：

• 聚合查询 → 新增临时表的数据
• 多表查询 → 优化SQL语句结构
• 表数据量过大查询 → 添加索引
• 深度分页查询

一个SQL语句执行很慢，如何分析？

可以采用EXPLAIN或者DESC命令获取MySQL如何执行SELECT语句的信息

# 直接在select语句之前加上关键字 explain/desc
EXPLAIN SELECT 字段列表 FROM 表名 WHERE 条件;

mysql > explain select * from t_user where id = ‘1’

id	select_type	table	partitions	type	possible_keys	key	key_len	ref	rows	filtered	Extra
1	SIMPLE	t_user	NULL	const	PRIMARY	PRIMARY	98	const	1	100.00	NULL

• possible_key：当前sql可能会使用到的索引
• key：当前sql实际命中的索引 通过它俩查看是否可能会命中索引
• key_len：索引占用的大小 通过它俩查看是否可能会命中索引
• Extra：额外的优化建议 看是否走过覆盖索引或回表查询

Extra	含义
Using where; Using Index	查找使用了索引，需要的数据都在索引列中能找到，不需要回表查询数据
Using index condition	查找使用了索引，但是需要回表查询数据

• type：这条sql的连接的类型，性能由好到差为
  • NULL
  • system：查询系统中的表
  • const：根据主键查询
  • eq_ref：主键索引查询或唯一索引查询
  • ref：索引查询
  • range：范围查询
  • index：索引树扫描
  • all：全盘扫描

了解过索引吗？（什么是索引）

索引(index)是帮助MySQL高效获取数据的数据结构(有序)，在数据之外，数据库系统还维护着满足特定查找算法的数据结构**(B+树)**，这些数据结构以某种方式引用(指向)数据，这样就可以在这些数据结构上实现高级查找算法，这种数据结构就是索引

• 索引(index)是帮助MySQL高效获取数据的数据结构(有序)
• 提高数据检索的效率，降低数据库的IO成本(不需要全表扫描)
• 通过索引列对数据进行排序，降低数据排序的成本，降低了CPU的消耗

索引的底层数据结构了解过吗？

MySQL的InnoDB引擎采用的B+树的数据结构来存储索引

• 阶数更多，路径更短
• 磁盘读写代价B+树更低，非叶子节点只存储指针，叶子阶段存储数据
• B+树便于扫库和区间查询，叶子节点是一个双向链表

**MySQL默认使用的索引底层数据结构是B+树**。再聊B+树之前，先来聊聊二叉树和B树

==B Tree(矮胖树)== B树是一种多叉路衡查找树，相对于二叉树，B树每个节点可以有多个分支，即多叉。以一颗最大度数(max-degree)为5(5阶)的b-tree为例，那这个B树每个节点最多存储4个key

==B+Tree== 是再BTree基础上的一种优化，使其更适合实现外存储索引结构，InnoDB存储引擎就是B+Tree实现其索引结构

B树与B+树对比：

• 磁盘读写代价B+树更低
• 查询效率B+树更加稳定
• B+树便于扫库和区间查询

B树要找12 首先找38 左面小 再去缩小范围16和29 找到12 → 但是我们只想要12的数据 B树会额外的把38,16,29的数据全查一遍最后才到12的数据

B+树是在叶子节点才会存储数据，在非叶子节点全是指针，这样就没有其他乱七八糟的数据影响 。且查找路径是差不多的，效率较稳定

便于扫库：比如我们要查询6-34区间的数据，先去根节点扫描一次38 → 16-29 → 由于叶子节点之间有双向指针，就可以一次性把所有数据都给拿到[无需再去根节点找一次]

什么是聚簇索引？什么是非聚簇索引(二级索引)？什么是回表？

• 聚簇索引(聚集索引)：数据与索引放到一块，B+树的叶子节点保存了整行数据，有且只有一个
• 非聚簇索引(二级索引)：数据与索引分开存储，B+树的叶子节点保存对应的主键，可以有多个
• 回表查询：通过二级索引找到对应的主键值，到聚集索引中查找正行数据，这个过程就是回表

聚集索引选取规则：

• 如果存在主键，主键索引就是聚集索引
• 如果不存在主键，将使用第一个唯一 (UNIQUE) 索引作为聚集索引
• 如果表没有主键，或没有合适的唯一索引，则InnoDB会自动生成一个rowid作为隐藏的聚集索引

聚集索引和非聚集索引的具体区别

==回表查询==

select * from user where name = 'Arm';

知道什么叫覆盖索引吗？

覆盖索引是指查询使用了索引，返回的列，必须在索引中全部能够找到

• 使用id查询，直接走聚集索引查询，一次索引描述，直接返回数据，性能高
• 如果返回的列中没有创建索引，有可能会触发回表查询，尽量避免使用 **select *** [除非用的聚簇索引(主键)]

==覆盖索引==是指查询使用了索引，并且需要返回的列，在该索引中已经全部能够找到

• id为主键，默认是主键索引
• name字段为普通索引

select * from tb_user where id = 1;                     【覆盖索引】
select id, name from tb_user where name = 'Arm'         【覆盖索引】
select id, name, gender from tb_user where name = 'Arm' 【非覆盖索引】(需要回表查询)

MySQL超大分页怎么处理？

问题：再数据量比较大时，limit分页查询，需要对数据进行排序，效率低
解决方案：可以用覆盖索引 + 子查询处理
[我们先分页查询获取表中的id 并且对表的id进行排序 就能筛选出分页后的id集合(因为id是覆盖索引效率高) 最后再根据id集合到原来的表中做关联查询就可以得到提升了]

在数据量比较大时，如果用limit分页查询，在查询时，越往后，分页查询效率越低

mysql > select * from tb_sku limit 0,10;
10 rows in set (0.00 sec)

mysql > select * from tb_sku limit 9000000,10;
10 rows in set (11.05 sec)

因为，当在进行分页查询时，如果执行 limit 9000000,10，此时需要MySQL排序前9000010记录，仅仅返回9000000 - 9000010 的记录，其他记录丢失，查询排序的代价非常大。

==MySQL超大分页查询优化思路==：一般分页查询时，通过创建覆盖索引能够比较好地提高性能，可以通过覆盖索引加子查询形式进行优化

# 超大分页处理：先通过覆盖索引找到符合条件的id，再通过这个id的覆盖索引查询到所有的列
select * 
from tb_sku t,
(select id from tb_sku order by id limit 9000000,10) a
where t.id = a.id

# 10 rows in set (7.15 sec)

索引创建原则有哪些？

① 数据量较大，且查询比较频繁的表
② 常作为查询条件、排序、分组的字段
③ 字段内容区分度高
④ 内容较长，使用前缀索引
⑤ 尽量联合索引
⑥ 要控制索引的数量
⑦ 如果索引列不能存储NULL值，请在创建表时使用NOT NULL约束它

• 先陈述自己再实际工作中是怎么用的
• 主键索引
• 唯一索引
• 根据业务创建的索引(复合索引)

创建索引的方式1

① SQL的方式
ALTER TABLE user_innodb ADD INDEX idx_name(name)

② 在建表的时候 去指定索引
...
PRIMARY KEY('id'),
KEY 'idx_name' ('name') USING HASH

③ 通过界面化工具去指定索引
字段旁边有个`索引` 可以去添加

=============================================
单个字段的索引 → 单列索引
多个字段的索引 → 联合索引

索引的类型

索引可以增加查询速度 同时也增加了更新/修改速度因为更新的第一步就是查询

① 普通索引 经过特殊设计的数据结构
② 唯一索引 唯一约束
[索引必须是唯一的 比如name就不行 因为名字可以很多建立普通索引]
③ 主键索引 在主键索引上添加了非空约束
④ 全文索引 一般使用搜索引擎，因为对中文的搜索不太友好美国英文开发的
[特殊的sql：select * from 表名 where match(字段名) against(‘马士兵教育’ IN NATURAL LANGUAGE MODE);]

AVL树 右右型左旋 左子树与右子树的深度差绝对值不超过1
树的节点里应该放：键值+Value值+左右子树的地址left+right
Innodb一次会加载16k(16384字节=Redis的槽位) 内存到内存
不选红黑树是因为它是二叉的，我们需要多叉树
要用==B+树==全盘扫描能力更强 叶子节点是双向链表
因为稳定性比较好 B树非所见所得 B+树是稳定几层的查找数据因为数据都在最后一层叶子节点上
Innodb的索引方法是BTREE 不能改成HASH

**数据结构可视化网**：Data Structure Visualization

• 针对数据量较大，且查询比较频繁的表建立索引。单表超过10万数据(增加用户体验)
• 针对常作为查询条件(where)、排序(order by)、分组(group by) 操作的字段建立索引
• 尽量选择区分度高的列作为索引，尽量建立唯一索引，区分度越高，使用索引的效率越高 (比如address都在北京市)
• 如果是字符串类型的字段，字段的长度越长(描述信息…)，可以针对于字段的特点，建立前缀索引
• 尽量使用联合索引，减少单列索引，查询时，联合索引很多时候可以覆盖索引(避免回表)，节省存储空间，提高查询效率
• 要控制索引的数量，索引并不是多多益善，索引越多，维护索引结构的代价也就越大，会影响增删改的效率
• 如果索引列不能存储NULL值，请在创建表时使用NOT NULL约束它。当优化器知道每列是否包含NULL值时，它可以更好地确定哪个索引最有效地用于查询。

什么情况下索引会失效？

• 违反最左前缀法则
• 范围查询右边的列，不能使用索引
• 不要在索引列上进行运算操作，索引将失效
• 字符串不加单引号，造成索引失效。(类型转换)
• 以**%开头的Like模糊查询**，索引失效
  [不影响正常查询业务 但未运用超大分页查询优化 会导致索引失效]

怎么哪块读判断索引是否失效了呢？

# 执行计划explain

【2024最新版MySQL索引讲解！一个视频带你彻底搞懂MySQL索引！！【马士兵】】https://www.bilibili.com/video/BV17z421i7Kb?vd_source=5966d6c3cf3709c10b3c53b278b0f4d3

什么情况下索引会失效？
如果索引了多列，要遵守最左前缀法则。指的是查询从索引的最左前列开始，并且不跳过索引中的列。匹配最左前缀法则，走索引：

谈谈你对sql的优化经验？

• 表的设计优化，数据类型的选择
• 索引优化，索引创建原则
• sql语句优化，避免索引失效，避免使用select
• 主从复制、读写分离，不让数据的写入，影响读操作
• 分库分表

• 表的设计优化(参考阿里开发手册《嵩山版》)

  • 比如设置合适的数值(tinyint、int、bigint) ，要根据实际情况选择
  • 比如设置合适的字符串类型(char和varchar) char定长效率高，varchar可变长度，效率低

  候选人: 这个我们主要参考的阿里出的那个开发手册《嵩山版》，就比如，在定义字段的时候需要结合字段的内容来选择合适的类型，如果是数值的话，像tinyint、int、bigint这些类型，要根据实际情况选择。如果是字符串类型，也是结合存储的内容来选择char和varchar或者text类型

• 索引优化(参考优化创建原则和索引失效)

• SQL语句优化

  • SELECT语句务必指明字段名称 (避免直使用select *)回表

  • SQL语句要避免造成索引失效的写法

  • 尽量使用union all代替union，union(不会重复)会多一次过滤, 效率低

    select * from t_user where id > 2
    union all | union
    select * from t_user where id < 5
    

  • 避免在where子句中对字段进行表达式操作

  • join优化 能用inner join 就不用left join, right 如必须使用 一定要以小表为驱动；内链接会对两个表进行优化，优先把小表放到外边，把大表放到里边。left join 或 right join，不会重新调整顺序

    for(int i = 0; i < 3; i++){ //只链接查询3次
     for(int j = 0; j < 1000; j++){
    
     }  
    }
    

• 主从复制、读写分离(在生产环境下一般会搭建主库和从库 分开读操作和写操作)

  如果数据库的使用场景读的操作比较多的时候，为了避免写的操作所造成的性能影响 可以采用读写分离的架构。读写分离解决的是，数据库的写入，影响了查询的效率。[Master(写) 和 Slave(读)]

• 分库分表(后面有介绍)

事务的特性是什么？可以详细的说一下吗？【ACID】

事务是一组操作的集合，它是一个不可分割的工作单位，事务会把所有的操作作为一个整体一起向系统提交或撤销操作请求，即这些操作要么同时成功，要么同时失败。

候选人：嗯，这个比较清楚，ACID，分别指的是:原子性、一致性、隔离性、持久性;
我举个例子：A向B转账500，转账成功，A扣除500元，B增加500元。
原子性操作体现在要么都成功，要么都失败。
在转账的过程中，数据要一致性，A扣除了500，B必须增加500
在转账的过程中，隔离性体现在A像B转账，不能受其他事务干扰
在转账的过程中，持久性体现在事务提交后，要把数据持久化(可以说是落盘操作)

• **原子性(**Atomicity)：事务是不可分割的最小操作单元，要么全部成功，要么全部失败。
• 一致性(Consistency)：事务完成时，必须使所有的数据都保持一致状态。
• 隔离性(lsolation)：数据库系统提供的隔离机制，保证事务在不受外部并发操作影响的独立环境运行
• 持久性(Durabiity)：事务一旦提交或回滚，它对数据库中的数据的改变就是永久的。

并发事务带来哪些问题？怎么解决这些问题？MySQL默认隔离级别是？

• ==并发事务问题==：脏读、不可重复读、幻读
• ==隔离级别==：读未提交、读已提交、可重复读、串行化

怎么解决并发事务的问题呢？？

对事务进行隔离 (× 是代表可以解决此问题)

注意：**事务隔离级别越高，数据越安全，但是性能越低**

数据库的undo log 和 redo log的区别？

redo log：记录的是数据页的物理变化，服务宕机可用来同步数据
undo log：记录的是逻辑日志，当事务回滚时，通过逆操作恢复原来的数据
redo log 保证了事务的持久性，undolog保证了事务的原子性和一致性

redo log 和 undo log 是 InnoDB 为了实现事务的 原子性 和 持久性 而设计的两种日志机制：

• 缓冲池(buffer pool)：主内存中的一个区域，里面可以缓存磁盘上经常操作的真实数据，在执行增删改査操作时，先操作缓冲池中的数据(若缓冲池没有数据，则从磁盘加载并缓存)，以一定频率刷新到磁盘，从而减少磁盘IO，加快处理速度
• 数据页(page)：是InnoD8 存储引擎磁盘管理的最小单元，每个页的大小默认为 16KB。页中存储的是行数据

假设你执行一条 SQL：

UPDATE account SET balance = balance - 100 WHERE id = 1;

InnoDB 的执行顺序是：

1. 写入 undo log（记录原值，便于回滚） ✅
2. 修改内存中的数据（Buffer Pool）✅
3. 写入 redo log（记录新的值，崩溃后可重做）✅
4. 提交事务时将 redo log 落盘（刷到磁盘）

🔄 崩溃恢复时如何用它们？

• 💥 宕机恢复（crash recovery）时，MySQL 会用 redo log 把“已提交但还没写到磁盘的数据”重做一遍，确保数据不丢失（持久性）。
• ❌ 事务失败或回滚时，MySQL 用 undo log 把数据恢复到修改之前的样子，确保事务“要么全做，要么全不做”（原子性）。

==redo log==

重做日志，记录的是事务提交时数据页的物理修改，是用来实现事务的持久性
该日志文件由两部分组冲：重做日志缓冲(redo log buffer) 以及 **重做日志文件(redo log file)**，前者是在内存中，后者是在磁盘中。当事务提交之后会把所有修改信息都保存到该日志文件中，用于在刷新脏页到磁盘，发生错误时，进行数据恢复使用。

==undo log==

回滚日志，用于记录数据被修改前的信息，作用包含两个：提供回滚和 MVCC(多版本并发控制)。undolog 和 redolog记录物理日志不一样，它是逻辑日志

• **可以认为当delete一条记录时，undo log中会记录一条对应的insert记录**，反之亦然
• 当update一条记录时，它记录一条对应相反的update记录。当执行rolback时，就可以从undolog中的逻辑记录读取到相应的内容并进行回滚。

undo log可以实现事务的一致性和原子性

事务中的隔离性是如何保证的呢？

事务的隔离性主要是通过锁机制和 MVCC（多版本并发控制） 来实现的。

对于更新操作 (写)，MySQL 会使用加锁机制，比如行级锁中的排他锁（X锁）来避免并发写冲突；
对于查询操作 (读)，MySQL 使用 MVCC 来避免加锁带来的性能开销，从而支持高并发读操作。
MVCC 的核心思想是：为同一条数据维护多个版本，从而实现 “读写不冲突、并发更高效”。

排他锁 (如果一个事务获取到了一个数据行的排他锁，其他事务就不能再获取该行的其他锁)
mvcc: 多版本并发控制 让MySQL中的多版本并发控制。指维护一个数据的多个版本，使得读写操作没有冲突
隐藏字段:
每一行数据都会有两个隐藏字段
① trx _id(事务id)，记录每一次操作的事务id，是自增的 [当前这条记录是由哪个事务创建的（事务ID）]
② roll_pointer(回滚指针)，指向上一个版本的事务版本记录地址（形成一个版本链）

undo log:
① 回滚日志，存储老版本数据
② 版本链：多个事务并行操作某一行记录，记录不同事务修改数据的版本，通过rollpointer指针形成一个链表

readView：解决的是一个事务查询选择版本的问题
根据readView的匹配规则和当前的一些事务id判断该访问那个版本的数据》不同的隔离级别快照读是不一样的，最终的访问的结果不一样RC:每一次执行快照读时生成ReadView
RR:仅在事务中第一次执行快照读时生成ReadView，后续复用

面试官: 事务中的隔离性是如何保证的呢?(你解释一下MVCC)
候选人: 事务的隔离性是由锁和mvcc实现的。
其中mvcc的意思是多版本并发控制。指维护一个数据的多个版本，使得读写操作没有冲突，它的底层实现主要是分为了三个部分，第一个是隐藏字段，第二个是undolog日志，第三个是readView读视图
隐藏字段是指:在mysq!中给每个表都设置了隐藏字段，有一个是x_id(事务id)，记录每一次操作的事务id，是自增的;另一个字段是roll-pointer(回滚指针)，指向上一个版本的事务版本记录地址
undolog主要的作用是记录回滚日志，存储老版本数据，在内部会形成一个版本链，在多个事务并行探作某一行记录，记录不同事务修改数据的版本，通过roll_pointer指针形成一个链表
readview解决的是一个事务查询选择版本的问题，在内部定义了一些匹配规则和当前的一些事务id判断该访问那个版本的数据，不同的隔离级别快照读是不一样的，最终的访问的结果不一样。如果是rc隔离级别，每一次执行快照读时生成ReadView，如果是r隔离级别仅在事务中第一次执行快照读时生成ReadView，后续复用

MVCC底层的三个关键机制

🔹 1. 隐藏字段

每一行数据都会有两个隐藏字段：

• trx_id：当前这条记录是由哪个事务创建的（事务ID）
• roll_pointer：回滚指针，指向这条记录的上一个版本（形成一个版本链）

---

🔹 2. undo log（回滚日志）

• 当事务对数据进行修改时，会记录修改前的旧数据到 undo log
• 所有旧版本数据通过 roll_pointer 串成一个“版本链”
• 查询时可以根据版本选择合适的数据版本，从而“读老数据”

---

🔹 3. ReadView（读视图）

• 在执行快照读时，InnoDB 会生成一个 ReadView
• 它记录了当前活跃的事务ID列表，以及当前事务的ID
• 查询时，会根据 ReadView 判断：这条记录版本是否“可见”

总的来说，写操作靠加锁，读操作靠 MVCC。MVCC 通过维护多个版本的数据 + ReadView 机制，让不同事务之间在查询时互不干扰，从而保证隔离性，同时提升并发性能。

🔐 写用锁、📚 读用 MVCC，🔁 多版本 + 🔍 读视图 + 🧾 回滚日志，性能高，隔离强！

解释一下MVCC？

全程 Multi-Version Concurrency Control，多版本并发控制。指维护一个数据的多个版本，使得读写操作没有冲突

问题的来源：(橙色的)查询的是哪个事务版本的记录？

MVCC-实现原理

• 记录中的隐藏字段

• DB_TRX_ID：最近修改事务ID，记录插入这条记录或最后一次修改该记录的事务ID
• DB_ROLL_PTR：回滚指针，指向这条记录的上一个版本，用于配合undo log, 指向上一个版本
• DB_ROW_ID：隐藏主键，如果表结构没有指定主键，将会生成该隐藏字段

undo log

• 回滚日志，在insert、update、delete的时候产生的便于数据回滚的日志相反的语句。
• 当insert的时候，产生的undolog日志只在回滚时需要，在事务提交后，可被立即删除。
• 而update、delete的时候，产生的undo log日志不仅在回滚时需要，mvcc版本访问也需要，不会立即被删除。

undo log版本链

不同事务或相同事务对同一条记录进行修改，会导致该记录的undolog生成一条记录版本链表，链表的头部是最新的旧记录，链表尾部是最早的旧记录

• readview

ReadView(读视图) 是 快照读 SQL执行时MVCC提取数据的依据，记录并维护系统当前活跃的事务(未提交的)id

ReadView中包含了四个核心字段

• 当前读

读取的是记录的最新版本，读取时还要保证其他并发事务不能修改当前记录，会对读取的记录进行加锁。对于我们日常的操作，如:select .. lock in share mode(共享锁)，select .. for update、update、insert、delete(排他锁)都是一种当前读。

• 快照读

简单的select(不加锁)就是快照读，快照读，读取的是记录数据的可见版本，有可能是历史数据，不加锁，是非阻塞读。
Read Committed：每次select，都生成一个快照读。
Repeatable Read：开启事务后第一个select语句才是快照读的地方。

MySQL主从同步原理？

主从同步就是主库把所有数据修改写到日志文件（Binlog）里，从库再去“抄作业”——读日志，写自己，中继日志相当于中转站，最终把主库的修改同步过来。

MySQL主从复制的核心就是二进制日志binlog[DDL(数据定义语言)语句 和 DML(数据操纵语言)语句]
主库在事务提交时，会把数据变更记录在二进制日志文件 Binlog 中。
从库读取主库的二进制日志文件 Binlog，写入到从库的中继日志 Relay Log。
从库重做中继日志中的事件，将改变反映它自己的数据。

---

MySQL 主从同步分三步：

• 写日志：主库提交事务 → 写 Binlog
• 拉日志：从库 I/O 线程拉取 Binlog → 写 Relay Log
• 执行日志：从库 SQL 线程执行 Relay Log → 同步数据

整个过程就是：主库写 → 从库拉 → 从库执行

MySQL主从复制的核心就是二进制日志

二进制文件(BINLOG) 记录了所有的DDL(数据定义语言)语句 和 DML(数据操纵语言)语句，但不包括数据查询(SELECT、SHOW)语句

       +---------------------+
       |      Master 主库     |
       | 写 Binlog（记录变更） |
       +---------------------+
                  ↓
       [ I/O 线程拉取 Binlog ]
                  ↓
       +---------------------+
       |      Slave 从库      |
       | 写 Relay Log（中继） |
       | 执行日志 → 同步数据  |
       +---------------------+

复制分成三步：

• Master主库在事务提交时，会把数据变更记录在二进制日志文件Binlog中
• 从库读取主库的二进制日志文件Binlog，写入到从库的中继日志Relay Log
• slave重做中继日志中的事件，将改变反应他自己的数据

你们项目用过分库分表吗？

是的，我们项目在业务数据达到一定规模后使用了分库分表策略。
具体来说，我们在做【举个真实业务：比如订单系统、日志存储系统、会员行为分析系统】时，由于单表数据量突破了 1000W+，单表容量超过 20GB，查询响应变慢，索引命中率降低，磁盘和网络 I/O 成为瓶颈。
一开始我们尝试通过主从读写分离、加索引、缓存优化等方式缓解，但效果有限，最终采用了分库分表来从根本上解决性能问题。

• 业务介绍
  1，根据自己简历上的项目，想一个数据量较大业务(请求数多或业务累积大)
  2，达到了什么样的量级(单表1000万或超过20G)

• 具体拆分策略
  1，水平分库，将一个库的数据拆分到多个库中，解决海量数据存储和高并发的问题
  2，水平分表，解决单表存储和性能的问题
  3，垂直分库，根据业务进行拆分，高并发下提高磁盘I0和网络连接数
  4，垂直分表，冷热数据分离，多表互不影响

分担了访问压力、解决存储压力

分库分表的时机：

① 前提：项目业务数据逐渐增多，业务发展比较迅速【单表数据量达1000W或20G以后】
② 优化解决不了性能问题(主从读写分离、查询索引)
③ IO瓶颈(磁盘IO、网络IO)、CPU瓶颈(聚合查询、连接数太多)

拆分策略【垂直 ≈ 微服务、水平 ≈ 分配数值】

• ==垂直拆分==
  • 垂直分库：以表为依据，根据业务将不同表拆分到不同库中
    (特点：按业务对数据分级管理、维护、监控、扩展；在高并发下，提高磁盘IO和数据量连接数)
    • tb_user → 用户微服务
    • tb_order → 订单微服务
    • tb_sku → 商品微服务
  • 垂直分表：以字段为依据，根据字段属性将不同字段拆分到不同表中
    (把不常用的字段单独放在一张表；把text, blob等大字段[描述]拆分出来放在附表中)
    (特点：冷热数据分离、减少IO过渡争抢，两表互不影响)
• ==水平拆分==
  • 水平分库：将一个库的数据拆分到多个库中
    (解决了单库大数量，高并发的性能瓶颈问题；提高了系统的稳定性和可用性)
    路由规则
    • 根据id节点取模
    • 按id也就是范围路由，节点1(1-100万)，节点2(100万-200万)
  • 水平分表：将一个库的数据拆分到多个表中(可以在同一个库内)
    (优化单一表数据量过大而产生的性能问题；避免IO争抢并减少锁表的几率)

分库后的问题：↓↓

• 分布式事务一致性问题
• 跨节点关联查询
• 跨节点分页、排序函数
• 主键避重

使用分库分表中间件

• sharding-sphere
• mycat

Spring框架中的单例bean是线程安全的吗？

不是线程安全的，是这样的

当多用户同时请求一个服务时，容器会给每一个请求分配一个线程，这是多个线程会并发执行该请求对应的业务逻辑(成员方法)，如果该处理逻辑中有对该单列状态的修改(体现为该单例的成员属性)，则必须考虑线程同步问题。

Spring框架并没有对单例bean进行任何多线程的封装处理。关于单例bean的线程安全和并发问题需要开发者自行去搞定。
比如:我们通常在项目中使用的Springbean都是不可可变的状态(比如Service类和DAO类)，所以在某种程度上说Spring的单例bean是线程安全的。

如果你的bean有多种状态的话(比如 View Model对象)，就需要自行保证线程安全。最浅显的解决办法就是将多态bean的作用由“singleton”变更为“prototype”。

Spring框架中的bean是单例的

@Service
@Scope("singleton")
public class UserServiceImpl implements UserService{

}

• singleton：bean在每个Spring IOC容器中只有一个实例
• prototype：一个bean的定义可以有多个实例

Spring bean并没有可变的状态(比如Service类和DAO类), 所以在某种程度上说Spring的单例bean是线程安全的。但要尽可能的少创造可变参数比如count

@Controller
@RequeestMapping("/user")
public class UserController{
    private int count; //成员方法需要考虑线程安全问题

    @Autowired
    private UserService userService;

    @GetMapping("/getById/{id}")
    public User getById(@PathVariable("id") Integer id){
        count++;
        sout(count);
        return userService.getById(id);
    }
}

1. 单例Bean就像共享单车：
   • 整个小区（Spring容器）只有一辆共享单车（单例Bean），所有居民（线程）都要轮流骑这辆车。
   • 如果只是骑车（调用无状态方法），不会出问题。
   • 但如果有人在车筐里放东西（修改成员变量），下个人可能就会看到/改动这些东西。
2. 什么时候安全？
   • 比如Service、DAO这类Bean，它们通常只干活不记账（没有成员变量），就像只提供骑行服务的单车，很安全。
   • 这也是为什么我们平时用@Autowired注入的Service不会出问题。
3. 什么时候危险？
   • 如果Bean里有个计数器count（就像你代码里的例子），多个线程同时”+1”就会乱套。
   • 就像多个人同时往单车筐里放苹果，最后苹果数量肯定对不上。
4. 怎么解决？
   • 方法一：不记账 → 永远不在Bean里放成员变量（推荐）
   • 方法二：用锁 → 像公共厕所那样，一个人用的时候锁门（加synchronized）
   • 方法三：每人发一辆车 → 改用@Scope(“prototype”)，每次请求都新建Bean（但浪费资源）
5. 实际开发建议：
   • 大多数情况下，Service/Dao写成单例完全没问题
   • 遇到要记录状态的场景（比如计数器），要么改成prototype，要么把变量存在ThreadLocal里
   • 绝对不要在Controller里定义成员变量！你代码里的count就是个典型反例

简单说：单例Bean本身不是线程安全的，但只要我们遵守”不用成员变量记事情”的原则，就能安全使用。就像共享单车，只要大家都不往车筐里放私人物品，就不会有问题。

什么是AOP，你们项目中有没有用到AOP？

AOP称为面向切面编程，用于将那些与业务无关，但却对多个对象产生影响的公共行为和逻辑，抽取并封装为一个可重用的模块，这个模块被命名为“切面”(Aspect)，减少系统中的重复代码，降低了模块间的耦合度，同时提高了系统的可维护性。

常见AOP使用场景：

• 拒绝策略记录操作日志

  nginx → 新增用户 → @Around(“pointcut()”) 环绕通知

• 缓存处理

• Spring中内置的事务处理

Spring中的事务是如何实现的
Spring支持 编程式事务管理 和 声明式事务 管理两种方式。

• 编程式事务控制：需使用TransactionTemplate来进行实现，对业务代码有侵入性，项目中很少使用
• 声明式事务管理：声明式事务管理建立在AOP之上的。其本质是通过AOP功能，对方法前后进行拦截，将事务处理的功能编织到拦截的方法中，也就是在目标方法开始之前加入一个事务，在执行完目标方法之后根据执行情况提交或者回滚事务。

AOP（面向切面编程）可以理解为 “在不修改原有代码的情况下，给程序动态添加功能”。

生活中的例子：

• 假设你开了一家咖啡店，主要业务是 做咖啡（核心业务）。
• 但除了做咖啡，你还要 记录销售日志、检查权限、处理异常（如咖啡机坏了）等（横切关注点）。
• 如果用传统OOP（面向对象编程），你需要在每个做咖啡的方法里都写日志、权限检查代码，这样代码会变得臃肿且难以维护。
• 而AOP的做法是：把这些公共逻辑（如日志、权限）抽出来，做成一个“切面”，然后“织入”到需要的地方，不影响原有业务代码。

---

AOP的核心概念

1. 切面（Aspect）：封装横切逻辑的模块（比如日志、事务）。
2. 连接点（Join Point）：程序执行的点（如方法调用、异常抛出）。
3. 通知（Advice）：切面在连接点执行的动作（如方法执行前、后、异常时做什么）。
4. 切点（Pointcut）：定义哪些连接点会被切面影响（如“所有Service层的方法”）。
5. 织入（Weaving）：把切面应用到目标对象的过程（编译期、类加载期、运行时）。

Spring中事务失效的场景有哪些？

异常捕获处理，自己处理了异常，没有抛出，解决：手动抛出
抛出检查异常，配置rollbackFor属性为Exception
非public方法导致的事务失效，改为public

考察对spring框架的深入理解、复杂业务的编码经验

• ==异常捕获处理==【异常被try-catch吃掉】

  原因：事务通知只有捉到了目标抛出的异常，才能进行后续的回滚处理，如果目标自己处理掉异常，事务通知无法知悉【Spring 的事务是基于 AOP 的，只有方法抛出异常，事务管理器才能感知并触发回滚；你在方法内部 try-catch 了异常，但没有再往外抛，就会导致事务不能回滚】

  解决：在catch块添加throw new RuntimeException(“转账失败”) 抛出

• ==抛出检查异常==

  原因：Spring 默认只对 非检查异常（RuntimeException 及其子类）、 进行回滚

  @Transactional
  public void update(...) throw FileNotFoundException{
      ...
      new FileInputStream("dddd")
      ...
  }
  

  解决：配置rollbackFor属性

  @Transcational(rollbackFor=Exception.class)
  

• ==非public方法==
  Spring 的事务本质是基于 AOP 代理实现的，而 AOP 默认只对 public 方法生效。

  @Transcational(rollbackFor=Exception.class)
  void update(...) throw FileNotFoundException{
      ...
      new FileInputStream("dddd")
      ...
  }
  

  原因：Spring为方法创建代理、添加事务通知、前提条件都是该方法是public的
  解决：把方法改为public

• ==同类内部调用，导致代理失效==

  原因：Spring AOP 基于代理机制。如果类内部方法调用类内的另一个 @Transactional 方法，实际上不会经过代理，事务不会生效。

  // ❌ 会失效
  public void methodA() {
      methodB(); // 不经过代理
  }
    
  @Transactional
  public void methodB() {
      // 无效
  }
  

  • 解决：
    • 将方法调用抽出到另一个 bean 中；
    • 或使用 AopContext.currentProxy() 获取当前代理对象执行调用。

Spring的bean的生命周期？

Spring容器是如何管理和创建bean实例
方便调试和解决问题

① 通过BeanDefinition获取bean的定义信息 [Spring 会将 XML 或注解配置的 Bean 信息封装成 BeanDefinition 对象，用于描述 Bean 的元数据信息，如 class 类型、作用域、是否懒加载等]
② 调用构造函数实例化bean [通过构造函数或工厂方法创建 Bean 对象，还没进行依赖注入]
③ bean的依赖注入 [Spring 根据 BeanDefinition 中的配置信息，进行依赖注入，例如通过 @Autowired、@Resource 等注解注入其它 Bean]
④ 处理Aware接囗回调(BeanNameAware、BeanFactoryAware、ApplicationContextAware)
⑤ Bean的后置处理器BeanPostProcessor-前置
⑥ 初始化方法(InitializingBean、init-method)
⑦ Bean的后置处理器BeanPostProcessor-后置
⑧ 销毁bean

BeanDefinition

Spring容器在进行实例化时，会将xml配置的< bean >的信息封装成一个BeanDefinition对象，Spring根据BeanDefinition来创建Bean对象，里面有很多的属性来描述Bean

<bean id="userDao" class="com.itheima.dao.impl.UserDaolmpl" lazy-init="true"/><bean id="userService" class="com.itheima.service.UserServicelmpl" scope="singleton">
  <property name="userDao" ref="userDao"></property>
</bean>

Spring中的循环引用？

★ 循环依赖：循环依赖其实就是循环引用, 也就是两个或两个以上的bean互相持有对方,最终形成闭环。比如A依赖于B,B依赖于A
★ 循环依赖在spring中是允许存在，spring框架**依据三级缓存已经解决了大部分的循环依赖**
☆ 一级缓存：单例池，缓存已经经历了完整的生命周期，已经初始化完成的bean对象
☆ 二级缓存：缓存早期的bean对象(生命周期还没走完)
☆ 三级缓存：缓存的是ObjectFactory，表示对象工厂，用来创建某个对象的

✅ 处理流程简要说明：

1. Spring 创建 A → A 依赖 B → 创建 B
2. B 依赖 A，发现 A 还没完成创建
3. Spring 把 A 的 半成品（early reference） 暴露到二级缓存，让 B 先注入用
4. 最后 A 初始化完成，加入一级缓存

✅ 这样就解决了大多数基于 setter 注入 / 字段注入 的循环依赖问题。

构造方法出现了循环依赖怎么解决？

A依赖于B，B依赖于A，注入的方式是构造函数
原因：由于bean的生命周期中构造函数是第一个执行的，spring框架并不能解决构造函数的的依赖注入
解决方案：使用**@Lazy进行懒加载**，什么时候需要对象再进行bean对象的创建

public A(@Lazy B b){
sout(“A的构造方法执行了”);
this.b=b;
}

@Component @Component
public class A{ → ← public class B{
@Autowired ↑ ↑ @Autowired
private B b; →↑ ↑← private A a;
} }

🧠 三大缓存：

缓存级别	对应源码字段名	作用说明
一级缓存	singletonObjects	已完全初始化的 Bean（生命周期完成），正式放入单例池
二级缓存	earlySingletonObjects	暂时暴露的半成品 Bean 实例（未执行初始化方法）
三级缓存	singletonFactories	存的是创建代理对象的 ObjectFactory，用于解决代理类循环依赖

Spring 把 A 的 半成品（early reference） 暴露到二级缓存，让 B 先注入用为啥要放到二级缓存 而不是一级呢？

✅ 答案核心：

因为此时 A 只是一个 尚未完成初始化的半成品对象，它还没有执行：

• 属性填充（依赖注入）
• Aware 接口回调
• 初始化方法（如 @PostConstruct、afterPropertiesSet()）

➡️ 这个 Bean 还不“完整”，不能放入正式的一级缓存！🔍 为什么不能直接放入一级缓存？

一级缓存是 singletonObjects，是 Spring 的“成品仓库”：

• 放入这个缓存意味着：
  • Bean 已经完成生命周期（包括依赖注入、初始化）
  • 可以被别人安全引用

但在处理循环依赖时，我们是中途打断流程，把未初始化完成的 Bean 暴露出来给另一个 Bean 注入（比如 A 注入给 B）

🔴 如果此时放入一级缓存，有两个风险：

1. 状态不一致风险
   其他 Bean 拿到这个未初始化完成的 Bean，会误以为它是“成品”，使用后可能报错或引发不一致。
2. 生命周期混乱
   BeanPostProcessor、InitializingBean、@PostConstruct 等生命周期操作可能被跳过或错乱，严重破坏 Spring 的生命周期管理逻辑。

✅ 二级缓存的作用正是：**”暴露早期引用”，但不当成成品！**

// 二级缓存 earlySingletonObjects：仅仅作为“抢先使用”的通道
this.earlySingletonObjects.put(beanName, earlyReference);

它是 Spring 对“对象未完成但又必须提前使用”这个两难问题的妥协方案。✅ 最终完整的 Bean 放入一级缓存：

当整个 Bean 初始化完成（属性注入 + 初始化方法 + 后置处理器都执行完），才会放入一级缓存：

addSingleton(beanName, exposedObject); // 放入 singletonObjects

---

---

那按照你这样说 三级缓存又是干啥的?你问得非常到位！
✅ 我们已经知道：

• 一级缓存：成品 Bean 的正式仓库；
• 二级缓存：未初始化完成的“早期引用”，暴露给依赖它的 Bean 使用。

✅ 简明结论（先记住）：

三级缓存的本质作用是：为了解决“代理对象”在循环依赖中的提前暴露问题。

🎯 三级缓存的角色是什么？

三级缓存存的是：

Map<String, ObjectFactory<?>> singletonFactories

也就是说：它不是直接存 Bean 实例本身，而是存一个对象工厂 ObjectFactory，这个工厂可以在需要的时候返回一个 Bean（甚至是它的代理对象）。

🧠 为什么需要三级缓存？——解决AOP 代理对象的提前暴露

Spring 在三级缓存里放一个 ObjectFactory，用于 延迟构建代理对象

等到别的 Bean（比如 B）需要注入 A 时，先从二级缓存找不到，就用三级缓存的 ObjectFactory.getObject() 来构造这个 Bean，此时可以通过 SmartInstantiationAwareBeanPostProcessor（比如 AOP 后置处理器）提前生成代理。

什么是Spring的循环依赖？？

==一级缓存==作用：限制bean在beanFactory中只存一份，即实现singleton scope，解决不了循环依赖

如果想打破循环依赖，就需要一个中间人的参与，这个中间人就是==二级缓存==如果一个对象是代理对象(被增强了)就不行

针对如果是代理对象的话如何解决呢？ → ==三级缓存==

那如果构造方法出现了循环依赖怎么解决？

@Component @Component
public class A{ → ← public class B{
private B b; ↑ ↑ private A a;
public A(B c){ →↑ ↑← public B(A c){
sout(“A的构造方法执行了”) sout(“B的构造方法执行了”)
this.b=b; this.b=b;
} }
} }

报错信息：Is there an unresolvable circular reference?
解决：@Lazy 延迟加载→什么时候需要对象的时候什么时候实例化对象

public A(@Lazy B b){
 sout("A的构造方法执行了");
 this.b=b;
}

Spring解决循环依赖是通过三级缓存

// 单实例对象注册器
public class DefaultSingletonBeanRegistry extends SimpleAliasRegistry implements SingletonBeanRegistry {
private static final int SUPPRESSED EXCEPTIONS LIMIT= 100;  
private final Map<String, Object>singletonObjects = new ConcurrentHashMap(256); 一级缓存
private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap(16); 三级缓存
private final Map<String, Object> earlySingletonObjects = new ConcurrentHashMap(16); 二级缓存 
}

SpringMVC的执行流程知道吗？

• 视图阶段(老旧JSP等)
• 前后端分离阶段(接口开发，异步)

==视图阶段(jsp)==

• 用户发送出请求到前端控制器DispatcherServlet
• DispatcherServlet收到请求调用HandlerMapping(处理器映射器)
• HandlerMapping找到具体的处理器，生成处理器对象及处理器拦截器(如果有)
• DispatcherServlet调用HandlerAdapter(处理器适配器)HandlerAdapter经过适配调用具体的处理器(Handler/Controller)Controller执行完成返回
• ModelAndView对象HandlerAdapter将Controller执行结果ModelAndView返回给DispatcherServlet
• DispatcherServlet将ModelAndView传给ViewReslover(视图解析器)
• ViewReslover解析后返回具体View(视图)
• DispatcherServlet根据View进行渲染视图(即将模型数据填充至视图中)
• DispatcherServlet响应用户

==前后端分离阶段(接口开发，异步请求)==

• 用户发送出请求到前端控制器DispatcherServlet
• DispatcherServlet收到请求调用HandlerMapping(处理器映射器)
• HandlerMapping找到具体的处理器，生成处理器对象及处理器拦截器(如果有)，再一起返回给DispatcherServlet
• DispatcherServlet调用HandlerAdapter(处理器适配器)
• HandlerAdapter经过适配调用具体的处理器(Handler/Controller)

✅ 一、SpringMVC 是什么？

SpringMVC 是基于Servlet 的原生请求处理模型封装的一套 MVC Web 框架，它通过 DispatcherServlet 实现请求分发，解耦了控制器、视图解析器等组件之间的关系。

🚀 1. 用户发起请求

浏览器访问一个 URL，例如：http://localhost:8080/user/list，请求会先到达 前端控制器 DispatcherServlet。

---

🔄 2. DispatcherServlet 接收到请求

DispatcherServlet 是 SpringMVC 的核心入口，用于请求分发和生命周期管理。

---

🔎 3. 查找 HandlerMapping（处理器映射器）

• DispatcherServlet 调用 HandlerMapping 来查找当前请求所匹配的 Handler（Controller 方法）；
• 会封装成 HandlerExecutionChain，里面包含目标处理器和拦截器链。

---

⚙️ 4. 调用 HandlerAdapter（处理器适配器）

SpringMVC 不直接调用 Handler，而是交给 HandlerAdapter 来统一调用逻辑（比如支持 @RequestMapping/@RestController 方法）。

---

🧠 5. 执行 Handler（也就是 Controller 方法）

通过适配器调用具体的 Controller 中的业务处理方法，如：

java复制代码@GetMapping("/user/list")
public List<User> list() {
    return userService.findAll();
}

---

📦 6. 返回 ModelAndView（传统视图模式）或 @ResponseBody 数据（前后端分离）

• 传统 MVC 场景下，Controller 返回一个 ModelAndView；
• 如果是前后端分离，通常会返回 JSON 数据，经过 HttpMessageConverter 处理后直接写入响应体。

---

🪞 7. 调用 ViewResolver（视图解析器）【视图模式专属】

• 如果返回的是视图名（如 “userList”），SpringMVC 会调用 ViewResolver 解析为具体的 JSP 或 Thymeleaf 模板。

---

🎨 8. 渲染视图 View（视图模式专属）

• 将模型数据（Model）填充进视图模板，生成 HTML 页面。

---

📤 9. DispatcherServlet 返回响应给浏览器

• 前后端分离下是 JSON 响应；
• 传统模式下是完整渲染后的 HTML。

  [用户请求]
       ↓
 DispatcherServlet
       ↓
 HandlerMapping → 找到 Handler + 拦截器链
       ↓
 HandlerAdapter  → 统一执行 Handler
       ↓
 Controller      → 执行业务逻辑
       ↓
 返回 ModelAndView / JSON
       ↓
（传统）ViewResolver → 找视图模板
       ↓
 渲染视图 / 写入 JSON 响应体
       ↓
 DispatcherServlet 响应浏览器

✅ 四、不同开发阶段下的区别

阶段	返回值	是否走视图解析器	常见注解
JSP 阶段	ModelAndView	✅ 是	@Controller
前后端分离	JSON 数据	❌ 否	@RestController + @ResponseBody

🎯 五、总结金句（可背）：

SpringMVC 核心就是一个请求经过 DispatcherServlet，根据 HandlerMapping 找到处理器，由 HandlerAdapter 调用 Controller 执行逻辑，最终通过视图解析或消息转换，返回结果给客户端。

SpringBoot自动配置原理？

@SpringBootApplication = 
    @SpringBootConfiguration +
    @EnableAutoConfiguration +
    @ComponentScan

SpringBoot中最高频的一道面试题，也是框架最核心的思想
==@SpringBootConfiguration==：该注解与 @Configuration 注解作用相同，用来声明当前也是一个配置类
==@EnableAutoConfiguration==：SpringBoot实现自动化配置的核心注解，通过配置选择器导入自动配置类
==@ComponentScan==：组件扫描，默认扫描当前引导类所在包及其子包

1，在Spring Boot项目中的引导类上有一个注解@SpringBootApplication，这个注解是对三个注解进行了封装，分别是:

• @SpringBootConfiquration
• @EnableAutoConfiquration
• @ComponentScan

2，其中@EnableAutoConfiguration是实现自动化配置的核心注解。该注解通过@Import注解导入对应的配置选择器。内部就是读取了该项目和该项目引用的jar包的classpath路径下META-INF/spring.factories文件中的所配置的类的全类名。在这些配置类中所定义的Bean会根据条件注解所指定的条件来决定是否需要将其导入到Spring容器中。

3，条件判断会有像@ConditionalOnClass这样的注解，判断是否有对应的class文件，如果有则加载该类，把这个配置类的所有的Bean放入spring容器中使用。

package com.itheima;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

// SpringBoot的启动类
// 注意: 我们写的代码要在启动类的包或者子包中
// @SpringBootApplication注解中包含了 @ComponentScan，没有指定扫描哪个包，默认扫描当前类所在的包和子包
@SpringBootApplication
public class Day15TliasManagement01IocDiApplication {
    // 启动项目, 内嵌的Tomcat会启动, 把项目部署到这个内嵌Tomcat中
    public static void main(String[] args) {
        SpringApplication.run(Day15TliasManagement01IocDiApplication.class, args);
    }
}

按住ctrl+左键点击@SpringBootApplication会弹到SpringBootApplication.class界面

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@SpringBootConfiguration
@EnableAutoConfiguration
@ComponentScan(
    excludeFilters = {@Filter(
    type = FilterType.CUSTOM,
    classes = {TypeExcludeFilter.class}
), @Filter(
    type = FilterType.CUSTOM,
    classes = {AutoConfigurationExcludeFilter.class}
)}
)

按住ctrl+左键点击@EnableAutoConfiguration会弹到EnableAutoConfiguration.class界面

# @Import({AutoConfigurationImportSelector.class})
# AutoConfigurationImportSelector是自动配置的选择器 
# 会加载META-INF中的spring.factories文件的自动配置类...AutoConfiguration...
//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by FernFlower decompiler)
//

package org.springframework.boot.autoconfigure;

import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Inherited;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import org.springframework.context.annotation.Import;

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@AutoConfigurationPackage
@Import({AutoConfigurationImportSelector.class})
public @interface EnableAutoConfiguration {
    String ENABLED_OVERRIDE_PROPERTY = "spring.boot.enableautoconfiguration";

    Class<?>[] exclude() default {};

    String[] excludeName() default {};
}

Spring框架常见的注解有哪些？

SpringMVC框架常见的注解有哪些？

SpringBoot常见的注解有哪些？

MyBatis执行流程？

• 读取MyBatis配置文件:mybatis-config.xml加载运行环境和映射文件
• 构造会话工厂SqlSessionFactory
• 会话工厂创建SqlSession对象(包含了执行SQL语句的所有方法)
• 操作数据库的接口，Executor执行器，同时负责查询缓存的维护
• Executor接口的执行方法中有一个MappedStatement类型的参数，封装了映射信息
• 输入参数映射
• 输出结果映射

执行流程从读取配置文件、创建 SqlSession、查找 MappedStatement、参数映射、执行 SQL 到结果映射，每个环节都有对应的组件协作完成。

• 理解了各个组件的关系
• Sql的执行过程(参数映射、sql解析、执行和结果处理)

MyBatis是否支持延迟加载？

• 延迟加载的意思是：就是在需要用到数据时才进行加载，不需要用到数据时就不加载数据。
• Mybatis支持一对一关联对象和一对多关联集合对象的延迟加载
• 在Mybatis配置文件中，可以配置是否启用延迟加载 lazyLoadingEnabled=true/false，默认是关闭的

<settings>
  <setting name="lazyLoadingEnabled" value="true"/>
  <setting name="aggressiveLazyLoading" value="false"/>
</settings>

延迟加载(懒加载)：查询主对象时不立即加载关联对象，而是在访问关联属性时再去执行查询语句加载数据。
查询 User 时不查 Order，只有调用 user.getOrders() 时，才执行 select * from order where user_id = ?

延迟加载的底层原理知道吗？

MyBatis 延迟加载的核心是代理模式 + 拦截器机制，底层主要通过 CGLIB 创建目标对象的代理对象

• 使用CGLIB创建目标对象的代理对象
• 当调用目标方法时，进入拦截器invoke方法，发现目标方法是nul值，执行sql查询
• 获取数据以后，调用set方法设置属性值，再继续查询目标方法，就有值了

查询用户的时候，把用户所属的订单数据也查询出来，这个是==立即加载==
查询**用户的(sql)时候，暂时不查询订单数据，当需要订单的时候，再查询订单(sql)**，这个就是==延迟加载==

执行流程 👇

1. 查询主对象时，不会立即查关联对象，而是用 CGLIB 创建一个代理对象（继承目标类）
2. 当访问关联属性时，进入代理类的 intercept 方法（拦截器）
3. 拦截器判断属性是否已加载：
   • 没加载 → 执行对应的 SQL（如 selectOrdersForUser）
   • 查出结果后 → 通过 setXxx() 方法注入属性值
4. 属性值设置好之后，后续访问就是直接取值，不再触发数据库查询

延迟加载的实现步骤：

1. 配置开启延迟加载： 在MyBatis的配置文件中（通常是mybatis-config.xml），需要设置两个属性：
   • lazyLoadingEnabled=true：开启延迟加载。
   • aggressiveLazyLoading=false：关闭积极的延迟加载，即访问对象的时候不会立即加载其所有属性。
2. 映射文件配置： 在对应的Mapper映射文件中，对于需要延迟加载的关联查询，使用select标签定义延迟加载的SQL语句，并通过fetchType="lazy"属性明确指定使用延迟加载。
3. 创建代理对象： 当执行查询操作时，MyBatis不会立即执行关联查询的SQL，而是返回一个代理对象。这个代理对象是使用CGLIB库创建的，它继承自目标对象。
4. 拦截器方法调用： 当我们首次访问这个代理对象的某个方法（比如访问订单详情）时，实际上会调用CGLIB生成的代理对象的拦截器方法（intercept方法）。在拦截器方法中，会判断当前要访问的属性是否已经被加载：
   • 如果属性已经被加载，则直接返回属性值。
   • 如果属性未被加载，则会执行之前定义好的延迟加载SQL语句，从数据库中查询数据。
5. 设置属性值： 查询得到数据后，MyBatis会将这些数据设置到目标对象的相应属性上，这样下次访问该属性时，就不需要再次查询数据库了。

底层原理：

• CGLIB代理：MyBatis使用CGLIB库创建目标对象的代理，当调用目标方法时，实际上会进入拦截器（Interceptor）的intercept方法。
• 拦截器逻辑：在拦截器中，会判断当前调用的方法是否需要触发延迟加载。如果需要，则执行延迟加载的SQL查询。
• 结果处理：查询结果会被处理并设置到目标对象的属性上，这样目标对象的相关属性就持有了数据，后续访问将直接返回这些数据，而无需再次查询。MyBatis在执行完延迟加载的SQL查询后，会获取查询结果，并将这些结果映射到目标对象的相应属性中

示例说明：

假设有一个用户User和订单Order的关系，在查询用户时，通常不会立即加载其订单信息，而是当需要时再加载。以下是简化的代码示例：

<!-- UserMapper.xml -->
<resultMap id="userMap" type="User">
  <id property="id" column="id"/>
  <result property="name" column="name"/>
  <!-- 延迟加载订单信息 -->
  <collection property="orders" column="id" ofType="Order" select="selectOrdersForUser" fetchType="lazy"/>
</resultMap>

<select id="selectUser" resultMap="userMap">
  SELECT * FROM user WHERE id = #{id}
</select>

<select id="selectOrdersForUser" resultType="Order">
  SELECT * FROM order WHERE user_id = #{id}
</select>

在上述配置中，当调用selectUser查询用户信息时，不会立即查询订单信息。只有当程序中访问User对象的orders属性时，才会执行selectOrdersForUser查询，这就是延迟加载的具体实现。

MyBatis的一级、二级缓存用过吗？

• 一级缓存:基于 PerpetualCache 的 HashMap 本地缓存，其存储作用域为 Session，当Session进行flush或close之后，该Session中的所有Cache就将清空，默认打开一级缓存
• 二级缓存是基于namespace和mapper的作用域起作用的，不是依赖于SQLsession，默认也是采用PerpetualCache，HashMap 存储。需要单独开启，一个是核心配置，一个是mapper映射文件

MyBatis的二级缓存什么时候会清理缓存中的数据？

• 当某一个作用域(一级缓存 Session/二级缓存Namespaces)的进行了新增、修改、删除操作后，默认该作用域下所有 select 中的缓存将被 clear。

• 本地缓存，基于PerpetualCache，本质是一个HashMap
• 一级缓存：作用域是session级别
  • 基于 PerpetualCache 的 HashMap 本地缓存，其存储作用域为 Session，当Session进行flush或close之后，该Session中的所有Cache就将清空，默认打开一级缓存
• 二级缓存：作用域是namespace和mapper的作用域，不依赖于session
  • 二级缓存是基于namespace和mapper的作用域起作用的，不是依赖于SQLsession，默认也是采用 PerpetualCache
    HashMap 存储

注意事项

• 对于缓存数据更新机制，当某一个作用域(一级缓存 Session/二级缓存Namespaces)的进行了新增、修改、删除操作后，默认该作用域下所有 select 中的缓存将被 clear
• 二级缓存需要缓存的数据实现Serializable接口
• 只有会话提交或者关闭以后，一级缓存中的数据才会转移到二级缓存中

SpringCloud篇

SpringCloud 5大组件有哪些？

回答原则：简单的问题不能答错

服务注册和发现是什么意思？ SpringCloud 如何实现服务注册发现？

• 我们当时项目采用的eureka作为注册中心，这个也是SpringCloud体系的一个核心组件
• 服务注册：服务提供者需要把自己的信息注册到eureka来保存这些信息，比如**服务名称、ip、端口**等等
• 服务发现：消费者向eureka拉取服务列表信息，如果服务提供者有集群，则消费者利用负载均衡算法，选择一个发起调用
• 服务监控：服务提供者会每隔30秒向eureka发送心跳，报告健康状态，如果eureka服务90秒没有收到心跳，从eureka中剔除

• 微服务中必须要使用的组件，考虑我们使用微服务的程度
• 注册中心的核心作用是：服务注册和发现
• 常见的注册中心：eureka、nocas、zookeeper

请你说一下nacos与eureka的区别？

• Nacos与Eureka的共同点 (注册中心)
  • 都支持服务注册和服务拉取
  • 都支持服务者心跳方式做健康检测
• Nacos与Eureka的区别 (注册中心)
  • Nacos支持服务端主动检测提供者状态：临时实例采用心跳模式，非临时实例采用主动检测模式
  • 临时实例心跳不正常会被剔除，非临时实例则不会被提出
  • Nacos支持服务列表变更的消息推送模式，服务列表更新更及时
  • Nacos集群默认采用AP方式高可用模式，当集群中存在非临时实例时，采用CP模式；Eureka采用AP方式
• Nacos还支持了配置中心，Eureka只有注册中心，也是选择选用nacos的一个重要原因

把RestTemplate替换成OpenFeign后它们的底层还是一样的吗？OpenFeign是远程调用

OpenFeign的底层原理也是根据服务名称，首先去远程注册中心拉取服务列表，底层也会在本地缓存一份，也会根据负载均衡选出一个实例，又运用了jdk的动态代理生成代理类，也会涉及到反射机制，最终拼出完整的url，发起http远程调用

@FeignClient(name = "service-provider")
public interface ServiceProviderClient {
    // 定义接口方法，映射到服务提供者的具体API
    @GetMapping("/api/resource")
    String getResource();
}

✅ 一、使用方式不同

• RestTemplate 是显式调用（自己写 URL，拼参数）

  restTemplate.getForObject("http://user-service/user/1", String.class);
  

• OpenFeign 是声明式调用（只写接口 + 注解，SpringBoot自动帮你拼URL发请求）

  @FeignClient("user-service")
  public interface UserClient {
      @GetMapping("/user/{id}")
      String getUser(@PathVariable("id") Long id);
  }
  

---

✅ 二、底层原理差不多，但实现机制不同

对比点	RestTemplate	OpenFeign
发起方式	手动构造 URL + 参数	注解接口 + 动态代理自动拼 URL
底层通信方式	HttpClient / OKHttp / JDK Http	同样也是基于 HttpClient 或 OKHttp
注册中心拉取服务	可搭配 Ribbon 手动实现服务发现	默认集成 Spring Cloud LoadBalancer 自动发现服务
负载均衡	手动配置 Ribbon 或 LoadBalancer	自动内置 LoadBalancer，基于服务名均衡选择
动态代理	无	有，基于 JDK 动态代理生成接口实现类
扩展能力	灵活性高，配置复杂	扩展性强，统一规范，支持熔断/重试/拦截器等

✅ 三、OpenFeign 更高级，集成更好

OpenFeign 是对 RestTemplate 的一层封装 + 声明式远程调用：

• 内置了服务注册发现（Eureka/Nacos）
• 内置了负载均衡（Ribbon / Spring Cloud LoadBalancer）
• 可配合 Hystrix / Sentinel 实现熔断降级
• 支持拦截器、日志、重试、压缩等功能
• 统一异常处理、超时配置更方便

✅ 四、结论一句话总结：

虽然最终底层都是通过 HTTP 客户端发起请求（如 OkHttp / HttpClient），但 OpenFeign 是基于动态代理+注解的声明式封装，实现了更强大的远程调用能力和集成能力，远比 RestTemplate 更高级、更易维护。

如果面试官继续追问：“你们项目是怎么替换的？”，你可以说：

我们之前用 RestTemplate 是在业务代码里拼 URL，很冗余。后来统一封装为 OpenFeign，只保留接口定义，调用方更清晰，服务注册与发现、负载均衡也变成自动处理，配合 Sentinel 做了服务熔断与限流，提升了整体的系统健壮性。

怎么个自动处理法？

默认情况下 —— OpenFeign 自动处理

✅ 默认配置时：

• 服务注册与发现：依赖 Nacos / Eureka 等注册中心，OpenFeign 会根据服务名自动从注册中心拉取可用实例。
• 负载均衡：默认通过 Spring Cloud LoadBalancer（以前是 Ribbon）对服务列表进行轮询或权重等策略选择一个实例。
• HTTP请求：通过 HttpClient / OkHttp 等客户端执行。

你只写：

@FeignClient("user-service")
public interface UserClient {
    @GetMapping("/user/{id}")
    User getUser(@PathVariable("id") Long id);
}

OpenFeign 会自动做：

• 拉取 user-service 的服务列表
• 选出一个实例（负载均衡）
• 拼接 URL 发起 HTTP 请求

🧠 一、什么叫“选出一个实例”？

在 微服务架构 中，一个服务往往会 部署多个实例 来应对高并发或容灾，例如：

服务名	实例地址
user-service	10.0.0.1:8080
user-service	10.0.0.2:8080
user-service	10.0.0.3:8080

当你通过 OpenFeign 发送请求：

@FeignClient("user-service")
User getUser(...);

你只写了一个服务名 user-service，但后台其实有多个实例，必须从这些实例中选出一个具体地址来发请求，比如选中 10.0.0.2:8080。

---

⚖️ 二、这就是负载均衡要干的事！

✅ 负载均衡做的事：

就是 从多个可用实例中选择一个。

✅ 为什么要选？不选行不行？

如果不做选择，就不知道到底该请求哪个服务器，容易：

• 总是访问同一个实例 → 某一个实例过载
• 有的实例空闲，有的压力大 → 资源利用不均衡
• 某些实例宕机，没人检测 → 请求失败

✅ 所以负载均衡的作用是：

• 分摊压力：让不同请求打到不同实例，防止某一个服务器崩掉
• 提高可用性：某个实例挂了，下一次选择其他实例，系统还能继续用
• 自动切换：负载均衡组件还能感知服务状态变化，动态更新可用实例列表

---

🧮 三、OpenFeign 背后使用了什么做负载均衡？

在 Spring Cloud 中，OpenFeign 默认集成了：

✅ Spring Cloud LoadBalancer（或老版 Ribbon）

它的核心就是在每次请求前调用：

choose("user-service")

然后根据你配置的策略，比如：

• 轮询（RoundRobin）👉 按顺序一个一个来
• 随机（Random）👉 随机挑一个
• 最少连接数（LeastConnections）
• 权重（Weighted）

最终得到一个实例，例如 10.0.0.2:8080，然后拼接成最终 URL：

http://10.0.0.2:8080/api/user/1

再发起 HTTP 请求。

---

🎯 总结一句话：

OpenFeign 中的“选出一个实例”就是 从多个服务实例中选择一个合适的来发送请求的过程，这个选择过程就是“负载均衡”负责的。它的目标是为了 提升性能、避免单点压力、实现高可用。

你们项目负载均衡如何实现的？图1.1

微服务的负载均衡主要使用了一个组件Ribbon，比如，我们再使用feign远程调用的过程中，底层的负载均衡就是使用了Ribbon 【与RestTemplate不同，OpenFeign默认是LoadBalancer】

• 负载均衡Ribbon，发起远程调用feign就会使用Ribbon
• Ribbon负载均衡策略有哪些？
• 如果想自定义负载均衡策略如何实现？

Ribbon已经进入维护模式，Netflix不再积极开发新功能。而Spring Cloud LoadBalancer作为替代，不仅提供了Ribbon的核心功能，还引入了一些新特性和改进

Ribbon负载均衡策略有哪些？简单、权重、随机、区域

• RoundRobinRule：简单轮询服务列表来选择服务器
• WeightedResponseTimeRule：按照权重来选择服务器，响应时间越长，权重越小
• RandomRule：随机选择一个可用的服务器
• BestAvaliableRule：忽略那些短路的服务器，并选择并发数较低的服务器
• RetryRule：重试机制的选择逻辑
• AvaliabilityFilteringRule：可用性敏感策略，先过滤非健康的，再选择连接数较小的实例
• ZoneAvoidanceRule：以区域可用的服务器为基础进行服务器的选择。使用Zone对服务器进行分类，这个Zone可用理解为一个机房、一个机架等。而后再对Zone内的多个服务做轮询

✅ Ribbon 常见负载均衡策略一览

策略名	简介	核心逻辑	适用场景
RoundRobinRule	轮询策略	依次选择服务列表中的每个实例，循环使用	简单、适用于服务性能相当、请求量均匀的场景
RandomRule	随机策略	随机选一个可用实例	测试环境、低并发系统或对分布无要求的场景
WeightedResponseTimeRule	权重 + 响应时间	根据服务实例响应时间动态调整权重，响应快的被选中几率高	适用于实例性能差异明显，希望高性能实例被优先选中
RetryRule	带重试机制的轮询	每次选择失败后会在一段时间内重试其他实例（默认使用 RoundRobinRule）	适用于请求容错性强、临时性网络波动频繁的情况
BestAvailableRule	最少并发策略	忽略短路（熔断）的实例，选择并发数最少的可用实例	适用于高并发下控制服务压力
AvailabilityFilteringRule	可用性过滤策略	过滤掉连接失败次数多的和并发高的实例，避免访问不健康服务	适用于系统对可用性要求高、网络波动大的场景
ZoneAvoidanceRule（默认）	区域感知策略	综合评估 zone（区域）内实例的可用性和负载（Zone可以理解为机房或机架），选出最优 zone 再轮询选择服务	适用于跨机房、跨地域部署，希望优先选择本地/低延迟实例的系统

📌 补充小Tips

• Spring Cloud 2020 后 Ribbon 官方不再维护，推荐用 Spring Cloud LoadBalancer 替代，但思想类似。
• 如果你项目还用 Ribbon，推荐配合 Hystrix 或 Sentinel 做服务熔断和限流。

如果想自定义负载均衡策略如何实现？图1.2

• 创建类实现IRule接口，可以指定负载均衡策略（全局）
• 在客户端的配置文件中，可以配置某一个服务调用的负载均衡（局部）

首先，你需要创建一个类来实现 IRule 接口，这样就能自定义负载均衡的策略。
实现 IRule 接口：

import com.netflix.loadbalancer.IRule;
import com.netflix.loadbalancer.Server;
import com.netflix.loadbalancer.ZoneAwareLoadBalancer;
import com.netflix.loadbalancer.RandomRule;

import java.util.List;

public class CustomLoadBalancerRule implements IRule {

private IRule delegate = new RandomRule();  // 默认策略

@Override
public Server choose(Object key) {
  // 在这里实现自己的负载均衡算法
  // 比如，你可以使用 RoundRobin、Random 或者基于健康检查的策略
  return delegate.choose(key);
}

@Override
public void setLoadBalancer(ZoneAwareLoadBalancer<?> lb) {
  delegate.setLoadBalancer(lb);
}

@Override
public ZoneAwareLoadBalancer<?> getLoadBalancer() {
  return delegate.getLoadBalancer();
}
}

然后，你需要在 Spring 配置类或者启动类上注入该自定义的负载均衡策略。
配置 Bean 注册到容器（全局策略）：

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class RibbonConfig {

@Bean
public IRule customLoadBalancerRule() {
  return new CustomLoadBalancerRule();
}
}

SpringCloud中什么是服务雪崩，怎么解决这个问题？

• 什么是==服务雪崩==？一个服务失败，导致整条链路的服务都失败的情形

• 服务雪崩：当某个服务因为故障不可用，导致依赖它的上游服务纷纷失败，进而整个系统连锁崩溃的现象
  • 常发生在服务调用链路较长时
  • 一个服务挂了，所有调用它的服务都会超时挂起，线程资源被耗尽，最终整个系统瘫痪

📌 通俗比喻：你访问淘宝商品详情页面 → 商品服务依赖库存服务 → 库存服务挂了 → 商品服务一直卡着等 → 网页加载失败 → 淘宝崩了

• ==熔断降级== && ==服务熔断==（解决）Hystix 服务熔断降级

服务降级部分服务不可用：服务自我保护的一种方式，或者保护下游服务的一种方式，用于确保服务不会受请求突增影响变得不可用，确保服务不会崩溃，一般在实际开发中与Feign接口整合，编写降级逻辑 (某个服务挂了或响应慢，不让请求卡住，而是返回预设的“备胎数据”，用户体验不会很差)

服务熔断整个服务不可用：默认关闭，需要手动打开，如果监测到10秒内请求的失败率超过50%，就触发熔断机制。之后每隔5秒重新尝试请求微服务，如果微服务不能响应，继续走熔断机制。如果微服务可达，则关闭熔断机制，恢复正常请求

• 限流（预防）微服务限流(漏桶算法、令牌桶算法)

  限制单位时间的请求数，避免流量洪峰打垮服务

  • 漏桶算法：匀速出水，适合平滑限流
  • 令牌桶算法：按需取令牌，适合突发流量控制

  📍 实现工具：Sentinel、Gateway限流、Bucket4j、RateLimiter

你们项目中有没有做到限流？怎么做的？&& 限流常见的算法有哪些？？

① 先来介绍一下业务，什么情况下去做限流，需要说明QPS具体是多少

• 我们有一个活动，到了假期就会抢购优惠券，QPS最高可以达到2000，平时10-50之间，为了应对突发流量，需要做限流
• 常规限流，为了防止恶意攻击，保护系统正常运行，我们当时系统能够承受最大的QPS是多少(压测结果)

② nginx限流

• 控制速率(突发流量)，使用的漏桶算法来实现过滤，让请求以固定的速率处理请求，可以应对突发流量
• 控制并发数，限制单个ip的连接数和并发链接的总数

③ 网关限流

• 在SpringCloudGateway中支持局部过滤器RequestRateLimiter来做限流，使用的是令牌桶算法
• 可以根据ip或路径进行限流，可以设置每秒填充平均速率，和令牌桶总容量

解释原理：

QPS（Queries Per Second，每秒查询率）是衡量一个系统处理请求能力的指标，它表示服务器在一秒钟内能够处理的查询数量。这个指标常用于数据库和web服务器等应用，以评估系统在高并发情况下的性能。
以下是对您提到的两句话的分析：

1. 活动期间的高并发处理：

• 背景知识： 在电子商务等应用中，促销活动往往会引起用户的大量点击和购买行为，导致短时间内流量剧增。
• 限流原理： 为了应对这种突发的高流量，系统需要实施限流措施。限流是为了保护系统资源不被过度消耗，确保系统的稳定性和可靠性。常见的限流算法有固定窗口、滑动窗口、令牌桶和漏桶等。

固定窗口： 假设每 1 分钟允许 100 次请求，10:00:00 到 10:01:00 期间的 100 次请求被允许，超出 100 次则会被限流，10:01:00 到 10:02:00 则重新开始计算。

滑动窗口： 每 60 秒内最多允许 100 次请求，滑动窗口的时间长度为 60 秒，窗口内的请求数会随着时间滑动更新，防止请求在时间边界上积压

令牌桶：假设每秒生成 10 个令牌，令牌桶的容量为 100 个令牌。如果 1 秒内有 15 个请求到达，则前 10 个请求能获得令牌并继续执行，剩余的 5 个请求需要等到下一个时间窗口令牌生成后再执行。

漏桶：假设每秒钟流出 10 个请求，漏桶的容量为 100 个请求。如果 1 秒钟内接收了 30 个请求，系统只会处理 10 个请求，剩余的 20 个请求被丢弃，直到下一个时间点。

• 实施方式： 在您提到的情况下，可以采用以下策略：
  • 预判性扩容： 根据历史数据和活动规模预测流量，提前进行服务器资源的扩容。
  • 动态限流： 在活动期间，根据实时监控的QPS数据动态调整限流阈值，保证系统平稳运行。
  • 排队处理： 对于超出系统处理能力的请求，可以采用队列进行缓冲，分批次处理。

2. 常规限流与系统最大承受QPS：

• 背景知识： 常规限流是为了在日常运行中防止恶意攻击（如DDoS攻击）和保护系统资源不被滥用。
• 压测结果： 系统的最大承受QPS是通过压力测试得出的。压力测试（也称为负载测试）是通过模拟高并发访问来测试系统的极限性能，以确定系统在保证稳定运行的前提下能够承受的最大QPS。
• 原理分析：
  • 保护系统： 通过设定一个QPS上限，可以防止系统过载，保障系统的正常运行。
  • 资源分配： 了解系统的最大承受QPS有助于合理分配资源，如数据库连接、内存和CPU等。
  • 用户体验： 适当的限流可以保证用户的体验，避免因系统过载导致的响应缓慢或服务不可用。
    在实施限流策略时，还需要考虑以下因素：
• 业务优先级： 对于不同的业务请求，可能需要有不同的限流策略，优先保证核心功能的可用性。
• 用户体验： 限流策略应尽量减少对用户体验的影响，例如通过友好的错误提示或降级方案。
• 数据监控： 实时监控系统的QPS和其他关键指标，以便快速响应并调整限流策略。
  综上所述，限流是确保系统在高并发情况下稳定运行的重要措施，而了解系统的最大承受QPS是制定合理限流策略的基础。

为什么要限流？

• 并发业务量大(突发流量)
• 防止用户恶意刷接口

限流的实现方式：

• ==Tomcat==单体项目可以,分布式不行：可以设置最大连接数 <Connector port="8080"...maxThreads="150"...>

• ==Nginx==：漏桶算法固定速率露出(平滑)

  控制速率(突发流量)

  

• ==网关==：令牌桶算法

  

• 自定义拦截器

echos-gateway真实案例

🔷 1. 网关服务名称 + 动态发现配置

spring:
  application:
    name: ech-gateway
  cloud:
    nacos:
      discovery:
        server-addr: 192.168.188.120:8848

• 知识点：Gateway 是 Spring Cloud 架构中的 API 网关，用于请求路由、统一鉴权、日志跟踪、限流、熔断等功能。
• 动态路由注册中心配置：接入 Nacos 注册中心，自动发现服务实例。

---

🔷 2. Gateway 路由规则（重点）

spring:
  cloud:
    gateway:
      routes:
        - id: zk-sam-service
          uri: lb://ech-sam-cs
          predicates:
            - Path=/iclock/**

🧠 面试要点：

• id: 路由唯一标识
• uri: lb://xxx: 表示使用 负载均衡方式 路由到注册中心中 xxx 的实例（通过 Ribbon/LoadBalancer 实现）
• Path: 路径断言，匹配路径开头为 /iclock/** 的请求
• filters: StripPrefix=1: 去除路径中的第一级前缀（如 /ech-service/a/b → /a/b）

---

🔷 3. 自动路由发现开启

discovery:
  locator:
    enabled: true
    lower-case-service-id: true

🧠 面试延申：

• enabled=true：允许网关根据注册中心中注册的服务自动创建路由（简化配置）
• lower-case-service-id=true：将服务名小写化，避免大小写不一致导致路由失败

面试官可能问：
“你们项目中是手动配置路由还是用 locator 自动发现？哪种方式更推荐？”

✅ 回答思路：

• 自动发现适合内部测试环境，快速接入新服务
• 生产建议手动配置，便于管理、加权限、加限流、避免误暴露

---

✅ 三、Feign配置部分（Gateway下游调用）

feign:
  client:
    config:
      default:
        connectTimeout: 5000
        readTimeout: 5000
        loggerLevel: full
  httpclient:
    enabled: false
  okhttp:
    enabled: false

✅ 面试可延申：

• Feign 的连接/读取超时时间如何设置？
• loggerLevel 有哪些级别（NONE/BASIC/HEADERS/FULL）？
• Feign 支持哪几种底层 HTTP 客户端？为什么要关掉 HttpClient/OkHttp？

---

✅ 四、Redis连接池配置（网关限流、缓存常用）

spring:
  redis:
    database: 12
    host: 192.168.188.120
    port: 6379
    lettuce:
      pool:
        max-active: 1000
        max-idle: 10
        min-idle: 5

✅ 面试展开：

• 为什么使用 Redis？

  作为 限流、缓存、黑名单过滤、Token 存储 后端，具备高性能分布式能力

• 你们用 Lettuce 还是 Jedis？区别在哪？

---

✅ 五、Actuator配置（服务监控）

management:
  server:
    port: 9090

• 暴露 Spring Boot Actuator 指标信息，常用于结合 Prometheus/Grafana 做监控
• 可暴露如 /actuator/health、/metrics、/gateway/routes 等

你们的微服务是怎么监控的？

我们项目中采用的skywalking进行监控的

• skywalking主要可以监控接口、服务、物理实例的一些状态。特别是在压测的时候可以看到众多服务中哪些服务和接口比较慢，我们可以针对性的分析和优化。
• 我们还在skywalking设置了告警规则，特别是在项目上线以后，如果报错，我们分别设置了可以给相关负责人发短信和发邮件，第一时间知道项目的bug情况，第一时间修复

skywalking

一个分布式系统的应用程序性能监控工具(Application Performance Management), 提供了完善的链路追踪能力，apache的顶级项目(前华为产品经理吴晟主导开源)

✅ 面试追问题 & 答法建议

面试官可能追问的问题	答题建议
🔸SkyWalking 是怎么接入项目的？	我们使用 Java Agent 的方式，启动时通过 -javaagent:/path/to/skywalking-agent.jar 加载探针，同时在 agent.config 中配置服务名、采集后端等
🔸和 Zipkin、Prometheus 相比有什么优劣？	SkyWalking 支持 UI 更强，适合链路分析；Prometheus 更适合指标监控配合 Grafana；Zipkin 更轻量但功能少。SkyWalking 是综合性最强的一款
🔸SkyWalking 的数据存储用的什么？	默认是 ElasticSearch，也支持 H2（测试环境），生产建议搭配 ES 做查询与聚合
🔸你怎么通过 SkyWalking 优化过接口？	我们发现某个接口 RT 超过 1 秒，通过 Trace 发现是 MySQL 多表 Join 查询导致，优化了 SQL 才解决的
🔸SkyWalking 能采集哪些组件的数据？	HTTP请求、Dubbo、MySQL、Redis、Kafka、RocketMQ、Elasticsearch 等主流中间件都有探针支持

✅ 加分拓展：如何实现全链路追踪？

SkyWalking 通过在每个服务部署时挂载探针（agent），实现对请求头中 traceId 的自动传递，采集：

• 入参出参（拦截 Controller 层、Feign、RestTemplate）
• RPC调用（如Dubbo/Feign）
• 数据库执行耗时
• Redis访问
• MQ消息链路

最终统一聚合在 SkyWalking OAP 端，再通过 Web UI 展示，形成完整的 “调用链 + 指标 + 日志” 三位一体监控体系。

✅ 项目答题串联建议

你可以在项目介绍环节自然引入这段内容，例如👇：

为了保障我们微服务系统的稳定性，我们在项目中接入了 SkyWalking 作为 APM 工具。通过它我们做到了链路追踪、性能分析、异常预警等。特别在压测和上线之后，能第一时间通过短信和邮件告警通知我们，提升了系统稳定性和定位效率。

探针（Agent）本质上是一个Java 程序运行时的字节码增强器，可以在不修改源码的前提下，对目标应用的类和方法进行增强，从而实现请求数据的“埋点采集”。

---

✅ 简单理解：探针干了啥？

可以这样比喻👇

你写的业务代码是演员
探针就是藏在台下的摄像机
它在你表演的时候偷偷把你的一举一动都记录下来（记录你调了哪个接口，用了多久，是不是出错了）

---

✅ 具体工作原理：

1. 运行时注入字节码
   • 探针是以 -javaagent 参数的形式加载到 JVM 中
   • JVM 启动时，探针会监听所有类的加载过程，选择特定的类（如 Controller、RestTemplate、JdbcTemplate、RedisTemplate）进行增强
2. 插入监控逻辑
   • 在方法的前后插入监控逻辑：
     • 方法开始时记录时间
     • 方法执行完记录耗时、返回值
     • 如果抛出异常，也能捕获异常堆栈
3. traceId 传递
   • 每个请求入口（比如 SpringMVC Controller）会生成一个全局 traceId
   • 这个 ID 会自动透传到下游服务，比如 Feign 调用、MQ 发送、数据库访问等
   • 最终串成一条完整的调用链路

✅ 示例：

比如你访问这个接口：

@GetMapping("/user/{id}")
public User getUser(@PathVariable Long id) {
    return userService.getById(id);
}

探针实际会在你这个方法前后偷偷插入逻辑（伪代码）：

// 前置逻辑：记录 traceId、时间戳
recordTrace("traceId-xxx");
startTime = System.currentTimeMillis();

User result = userService.getById(id);

// 后置逻辑：记录耗时
long cost = System.currentTimeMillis() - startTime;
sendToSkywalking(traceId, methodName, cost);

探针就是自动化“打点采集 + 数据上传”的代码增强器，开箱即用，不入侵业务代码。

解释一下CAP和BASE分布式系统理论

• CAP 定理(一致性、可用性、分区容错性)

1. 分布式系统节点通过网络连接，一定会出现分区问题(P)
2. 当分区出现时，系统的一致性(C)和可用性(A)就无法同时满足

• BASE理论

1. 基本可用
2. 软状态
3. 最终一致

• 解决分布式事务的思想和模型

1. 最终一致思想：各分支事务分别执行并提交，如果有不一致的情况，再想办法恢复数据(AP)
2. 强一致思想：各分支事务执行完业务不要提交，等待彼此结果。而后统一提交或回滚(CP)

• 分布式事务方案的指导
• 分布式系统设计方向
• 根据业务指导使用正确的技术选择

==CAP定理==分布式系统无法同时满足三个指标

CAP 定理是 数学证明出来的分布式理论限制，不是人为规定的规则，而是无法回避的“物理规律”

• ==Consistency==（一致性）：用户访问分布式系统中的任意节点，得到的数据必须一致。主从一致
• ==Availability==（可用性）：用户访问集群中的任意健康节点，必须能得到响应，而不是超时或拒绝
• ==Partition tolerance==（分区容错性）：当出现网络分区现象后，系统能够继续运行
  • Partition（分区）：因为网络故障或其他原因导致分布式系统中的部分节点与其他节点失去链接，形成独立分区
  • Tolerance（容错）：在集群出现分区时，整个系统也要持续对外提供服务

结论：

• 分布式系统节点之间肯定是需要网络链接的，分区 (P) 必然存在
• 如果保证访问的高可用性（A）可以持续对外提供服务，但不能保证数据的强一致性 AP
• 如果保证访问的数据强一致性（C）就要放弃高可用性 CP

🎯 CAP 的结论：

在分布式系统中，由于网络问题不可避免（P必选），所以只能在 C 和 A 之间选其一：

类型	特点	场景
CP 系统	放弃可用性，保证一致性	银行/支付系统（宁可服务不可用，也不能出错）
AP 系统	放弃一致性，保证可用性	电商商品浏览、社交系统（稍微不一致无所谓）

为什么 CAP 无法同时满足？

我们来看一个例子理解「一致性（C） vs 可用性（A） 在分区故障（P）下的矛盾」：

---

❗ 场景设定：

• 系统有两个节点：节点A 和 节点B
• 正常时，A 和 B 通过网络通信同步数据
• 现在发生了网络分区（P）：A 和 B 之间断网了！

---

🧩 你怎么选？C 和 A 只能二选一：

✅ 如果你要保证【一致性 C】：

• 当客户端向 A 节点写数据时，为了保证一致性，A 必须等待 B 同步成功
• 但现在 A 和 B 网络断了，同步不了
• 所以 A 只能拒绝请求：不响应 —— ❌ 违反了可用性 A

✅ 如果你要保证【可用性 A】：

• A 收到写请求就立刻接受并返回成功
• 但 B 此时拿到的还是老数据
• 数据就不一致了 —— ❌ 违反了一致性 C

---

🎯 所以：在【网络分区 P】已发生的前提下 ——

你只能选：C+A ❌，C+P ✅，A+P ✅

这就是 CAP 定理的本质逻辑。
所以我们在设计系统时必须做权衡 —— 这正是分布式架构的难点和美感所在。

==BASE理论==

BASE理论是对CAP的一种解决思路，包含三个思想：

• ==Basically Avaliable==（基本可用）：分布式系统在出现故时，允许损失部分可用性，即保证核心可用
• ==Soft State==（软状态）：在一定时间内，允许出现中间状态，比如临时的不一致状态
• ==Eventually Consistent==（最终一致性）：虽然无法保证强一致性，但是在软状态结束后，最终达到数据一致性

🎯 举个通俗易懂的例子：

你去银行转账，系统提示：“资金将在2小时内到账”。这就是：

• ✅ 系统可用（你能转账）
• ✅ 软状态（中间状态是“处理中”）
• ✅ 最终一致（2小时内一定到账）

这就符合 BASE 理论。

---

✅ BASE 与 CAP 的关系？

理论	类型	强调
CAP	理论限制	三选二原则，强调不可能同时满足一致性、可用性、分区容错
BASE	实践理念	放弃强一致性，追求最终一致，以换取系统可用性与性能

CAP如何选择？

• CP[支付宝]或者AP[超级跑跑系统维护]
• 在什么场合，可用性高于一致性？
  • 网页必须要保障可用性(一定能看到最重要 是不是最新的不重要)和分区容错
  • 支付的时候一定要保障一致性(我可以保证不可用 但我不允许余额不一致)和分区容错
• 合适的才是最好的

你们采用哪种分布式事务解决方案？

● 简历上写的微服务，只要是发生了多个服务之间的写操作，都需要进行分布式事务控制

● 描述项目中采用的哪种方案(seataMQ)
⚪ seata的XA模式，CP，需要互相等待各个分支事务提交，可以保证强一致性，性能差 (银行业务 )
⚪ seata的AT模式，AP，底层使用undolog 实现，性能好 (互联网业务 )
⚪ seata的TCC模式，AP，性能较好，不过需要人工编码实现 (银行业务 )
⚪ MQ模式实现分布式事务，在A服务写数据的时候，需要在同一个事务内发送消息到另外一个事务异步，性能最好 (互联网业务 )

✅ 你的理解：Seata 的 XA ≈ CP，AT ≈ AP？

Seata 是实现，CAP 是原则

你这样理解有一定道理，但这两者并不是等价关系。
Seata 是一种“解决分布式事务问题的技术方案”，目的是确保多个数据库操作的一致性，属于 CAP 中的一致性实现策略之一，但不能反过来说它就是 CAP 的实现。

对比	Seata XA / AT 模式	CAP 理论中的 CP / AP
本质	一种分布式事务协议实现	一种分布式系统权衡模型
关注点	一致性、事务原子性	可用性 vs 一致性 vs 分区容忍性
使用背景	数据库操作级别的事务控制	整个分布式系统的架构设计选择

🟢 Seata 为什么要设计成 XA、AT 两种模式？

因为不同的业务场景对性能 vs 一致性 的需求不同，Seata 提供了“可插拔”式的事务解决方案：

模式	一致性	性能	特点
XA模式（两阶段提交）	强一致性	性能差、资源占用多	接近传统分布式事务，事务期间资源锁定
AT模式（自动补偿）	最终一致性	性能好	非侵入，靠 Undo Log 回滚操作，适用于大部分业务场景

• Seata框架(XA、AT、TCC)
• MQ

Seata架构

• TC(Transaction Coordinator) - 事务协调者：维护全局和分支事务的状态，协调全局事务提交或回滚
• TM(Transaction Manager) - 事务管理器：定义全局事务的范围、开启全局事务、提交或回滚全局事务
• RM(Resource Manager) - 资源管理器：管理分支事务处理的资源，与TC交谈以注册分支事务和报告分支事务的状态，并驱动分支事务提交或回滚

Seata 的 XA 和 AT 确实在一致性与可用性方面体现了 CAP 的设计权衡，但它并不是 CAP 的实现，而是面向分布式事务的一种可插拔事务解决方案。Seata 架构之所以独立，是因为它提供了统一的事务协调服务，支持多种协议（XA/AT/TCC/SAGA），以满足不同业务场景对一致性和性能的需求，这在真实的微服务架构中非常关键。

分布式服务的接口幂等性如何设计？

• 幕等：多次调用方法或者接口不务状态，可以保证重复调用的结果和单次调用的结果一致；常用于支付、下单等关键业务防止重复提交。
• 如果是**新增数据**，可以使用数据库的唯一索引
• 如果是**新增或修改数据**
  • 分布式锁，性能较低
  • 使用token+redis来实现，性能较好
    ● 第一次请求，生成一个唯一token存入redis，返回给前端
    ● 第二次请求，业务处理，携带之前的token，到redis进行验证，如果存在，可以执行业务，删除token; 如果不存在，则直接返回，不处理业务

🧠 一、什么是幂等性？

• 幂等性是指：一次和多次请求同一个接口，对资源的影响是相同的
• 幂等操作的特性是：无副作用（No Side Effect）

📌 二、幂等性为什么重要？

会出现重复调用的原因：

• 网络抖动、页面重复点击
• 分布式事务重试机制
• 网关重试、MQ重复投递
• 前端误操作（如双击支付按钮）

🎯 三、幂等性保障方案（重点）

场景	适用范围	实现方式	特点
✅ 数据库唯一约束	新增接口	通过唯一索引防止重复插入	简单高效
✅ Token机制 + Redis	提交类（订单、支付）	一次性Token防止重复提交	推荐，效率高
✅ 分布式锁	修改、转账等接口	基于Redisson、ZK等实现同步控制	精准，但性能稍差
✅ 接口幂等表	所有需幂等接口	记录请求唯一标识 + 状态	控制最强，适合高并发
✅ 乐观锁（版本号机制）	更新操作	防止并发更新，CAS思想	要求带版本号字段
✅ 幂等组件中间件	通用接口平台	拦截层统一幂等处理	企业封装，灵活可控

🔨 Token+Redis 实现幂等（推荐）

流程：

1. 客户端请求创建订单，先调用接口获取 幂等Token
2. 后续提交时在请求头中携带该 Token
3. 服务端收到请求：
   • 判断 Redis 中是否存在该 Token
   • 若存在，则处理业务并删除 Token
   • 若不存在，说明已处理或重复请求，直接返回

优点：

• 轻量级，无锁高并发
• 可扩展性强，适用于 POST/PUT 等需要控制的接口

幂等：多次调用方法或者接口不会改变业务状态，可以保证重复调用的结果和单次调用的结果一致

需要幂等场景

• 用户重复点击(网络波动)
• MQ消息重复
• 应用使用失败或超时

-- 幂等更新：将余额设置为固定值
UPDATE account SET money = 500 WHERE id = 1;

-- 非幂等更新：余额加上500
UPDATE account SET money = money + 500 WHERE id = 1;

• 数据库唯一索引【新增】

• ==token + redis== 【新增+修改】**AND** ==分布式锁== 【新增+修改】

  🧠 面试答题思路模板

  我们项目中对于需要幂等性的接口（如支付、下单等），主要采用了Token + Redis机制：

  • 请求前由前端向后端申请一次性 Token
  • 后续接口请求中携带该 Token
  • 后端通过 Redis 判断 Token 是否存在，从而保证接口只被处理一次

  此外，对于批量创建类操作，还会结合数据库唯一索引控制幂等，对于状态更新类操作会使用乐观锁或分布式锁。

  创建商品、提交订单、转账、支付等操作

你们项目中使用了什么分布式任务调度

xxl-job 是一个分布式任务调度平台，它致力于解决分布式场景下的任务调度问题，主要由调度中心和执行器两部分组成。调度中心负责统一管理任务调度，而执行器则是负责接收调度并执行任务逻辑的客户端。

🎯 一句话总结

我们项目使用的是 XXL-Job 分布式任务调度平台，用来实现定时任务管理，比如取消订单、同步库存、发送通知等，解决了分布式环境下定时任务重复、不可控的问题。

• xxl-job路由策略有哪些？

  xxl-job提供了很多的路由策略，我们平时用的较多的就是：轮询、故障转移、分片广播

  🚦 路由策略有哪些？（面试重点）

  路由策略就是调度中心选 哪个执行器节点去执行任务 的方式。

  路由策略	描述
  轮询（Round） ✅	多个节点轮流执行任务，负载均衡常用
  故障转移（Failover） ✅	优先使用健康节点，失败时自动切换执行
  分片广播（Broadcast） ✅	每个节点都执行一次任务，适合大数据并行处理
  随机（Random）	随机选取一个可用节点
  一致性哈希	根据任务参数哈希选节点，适合状态保持
  最少运行节点	选当前执行任务最少的机器
  指定机器	手动指定执行器

• xxl-job任务执行失败怎么解决？

  • 路由策略选择故障转移，使用健康的实例来执行任务
  • 设置重试次数
  • 查看日志+邮件警告来通知相关负责人解决
  • 配置 任务超时时间 + 告警通知（邮件、短信）
  • 失败日志可在调度中心查看，有堆栈信息

• 如果有大数据量的任务同时都现需要执行，怎么解决？

  • 让多个实例一块去执行(部署集群)，路由策略分片广播
  • 在任务执行的代码中可以获取分片总数和当前分片，按照取模的方式分摊到各个实例执行；通过 ShardingContext 拿到当前分片信息

  @JobHandler("xxxHandler")
  public ReturnT<String> execute(ShardingContext context) {
      int totalShards = context.getTotalShardCount();
      int shardIndex = context.getShardIndex();
  
      List<Data> allData = getData();
      for (int i = 0; i < allData.size(); i++) {
          if (i % totalShards == shardIndex) {
              process(allData.get(i));
          }
      }
      return SUCCESS;
  }
  

💡 面试高频问法总结

面试问题	回答提示
你们怎么做定时任务调度？	我们使用 XXL-Job 做分布式定时调度，支持失败重试、分片执行、失败告警
XXL-Job 怎么实现任务分片？	配置为广播策略，任务中使用 ShardingContext 获取分片信息
路由策略都有哪些？你们用哪个？	常用轮询、故障转移、分片广播；我们大任务用广播，小任务轮询
如果一个任务执行失败怎么办？	设置了最大重试次数、使用了 Failover 策略、并配置了邮件告警通知
为什么不用 @Scheduled？	@Scheduled 适用于单体项目，不能解决多实例下重复执行问题；XXL-Job 支持分布式调度、管理界面、执行日志等

✅ 详细对比分析：SpringTask vs XXL-Job

对比维度	SpringTask	XXL-Job
定位	本地轻量级定时调度工具	分布式定时任务调度平台
部署方式	内嵌在应用中（@Scheduled）	独立部署调度中心 + 执行器
集群支持	不支持，单实例任务	支持分布式执行和 failover
任务失效恢复	无（如服务挂了任务丢）	支持失败重试 + 调度日志记录
任务管理	无可视化界面	Web 界面管理、动态配置任务
任务执行方式	方法注解 + 固定周期	支持 Bean 调用、Shell、HTTP、RPC 等
执行结果监控	无	有日志管理、失败报警、状态追踪
调度策略	固定时间（cron）	cron、分片广播、失败重试、手动触发等
适用场景	简单、稳定的定时逻辑，如定期清理缓存	多任务调度、跨服务控制、任务分发、分片执行、手动补偿等复杂场景

xxl-job解决的问题

• 解决集群任务的重复执行问题 xxl-job路由策略有哪些？
• cron表达式定义灵活在页面上 xxl-job任务执行失败怎么解决？
• 定时任务失败了，重试和统计 如果有大数据量的任务同时都需要执行，怎么解决？
• 任务量大，分片执行

场景 1: 定时处理过期订单

假设用户下单后如果订单超过了某个时间没有支付，平台需要自动取消该订单并释放库存。这个任务需要在每天的某个固定时间（比如凌晨 2 点）运行。

解决的问题：

1. 定时任务调度：XXL-Job 可以轻松管理该任务的执行时间和周期，确保每天准时执行，不需要开发者手动触发。
2. 任务失败重试：如果该任务因为某些原因执行失败，XXL-Job 可以自动进行重试，并设置重试次数，确保任务最终被执行。
3. 分布式执行：假设电商平台是一个分布式系统，订单数据存储在多个数据库中，XXL-Job 可以通过分布式执行确保每个数据库的订单都被正确处理

假设每晚 2 点有一个任务需要取消未支付的订单：

public class OrderJob {
    @JobHandler("orderCancelJobHandler")
    public void cancelUnpaidOrders() {
        // 查询所有未支付的订单
        List<Order> unpaidOrders = orderService.findUnpaidOrders();
        for (Order order : unpaidOrders) {
            if (order.isExpired()) {
                orderService.cancelOrder(order);
                inventoryService.releaseStock(order.getProductId(), order.getQuantity());
                // 发送订单取消通知给用户
                notificationService.sendOrderCancelledNotification(order.getUserId());
            }
        }
    }
}

场景 2: 定时更新商品库存

假设电商平台上销售的是一些有时效性的商品，商家需要定期更新商品的库存状态（例如，库存数量达到一定阈值时，自动下架商品，或者增加库存数量）。这个任务同样需要定时执行。

解决的问题：

1. 任务分片：在商品很多的情况下，XXL-Job 可以通过任务分片的方式并行处理不同商品的库存更新，提升任务的执行效率。
2. 任务优先级：根据不同商品的重要程度，XXL-Job 可以设置任务的优先级，确保关键商品的库存更新优先执行。

public class InventoryJob {
    @JobHandler("inventoryUpdateJobHandler")
    public void updateProductInventory() {
        // 获取需要更新库存的商品
        List<Product> productsToUpdate = productService.findProductsForInventoryUpdate();
        for (Product product : productsToUpdate) {
            inventoryService.updateInventory(product);
            if (product.getStockQuantity() <= product.getLowStockThreshold()) {
                productService.deactivateProduct(product);
                // 发送商品下架通知
                notificationService.sendOutOfStockNotification(product.getId());
            }
        }
    }
}

场景 3: 定时发送促销活动通知

假设电商平台有一个促销活动，每个活动的开始和结束时间都由后台系统控制。需要在活动开始前 1 小时、活动结束时发送通知给用户。这些通知可以是短信、邮件或 APP 推送通知。

解决的问题：

1. 定时任务管理：XXL-Job 可以定时触发通知任务，确保用户在活动前后及时收到通知。
2. 高并发支持：在促销活动开始或结束时，平台可能会有大量的通知需要发送，XXL-Job 支持任务的并行处理，可以帮助我们高效地分发通知，避免性能瓶颈。
3. 任务状态监控：XXL-Job 提供任务的实时监控功能，平台可以随时查看任务的执行情况，确保通知任务按时执行。

public class PromotionJob {
    @JobHandler("promotionNotifyJobHandler")
    public void sendPromotionNotifications() {
        // 获取当前正在进行的促销活动
        List<Promotion> activePromotions = promotionService.findActivePromotions();
        for (Promotion promotion : activePromotions) {
            if (promotion.isStartingSoon()) {
                notificationService.sendStartNotification(promotion);
            } else if (promotion.isEndingSoon()) {
                notificationService.sendEndNotification(promotion);
            }
        }
    }
}

✅ 这段代码做了什么？

java复制编辑@JobHandler("orderCancelJobHandler")
public void cancelUnpaidOrders() { ... }

这是一个 XXL-Job 的定时任务处理方法，任务名叫 orderCancelJobHandler，作用是：

定时扫描所有未支付订单，判断是否过期，过期则取消订单、释放库存并通知用户

---

🔧 XXL-Job 是怎么运行这个方法的？

🧩 步骤 1：添加依赖

在你的 pom.xml 中，需要加入 XXL-Job 的执行器依赖：

<dependency>
    <groupId>com.xuxueli</groupId>
    <artifactId>xxl-job-core</artifactId>
    <version>2.4.0</version>
</dependency>

---

🧩 步骤 2：执行器配置（application.yml）

xxl:
  job:
    admin:
      addresses: http://localhost:8080/xxl-job-admin
    executor:
      appname: order-job-executor
      address:
      ip:
      port: 9999
      logpath: /data/applogs/xxl-job/jobhandler
      logretentiondays: 30
    accessToken:

说明：

• admin.addresses: 调度中心地址
• executor.*: 当前服务是执行器，配置端口、日志路径等

---

🧩 步骤 3：启动类开启执行器功能

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

---

🧩 步骤 4：创建 JobHandler 并注册到容器

@Component
public class OrderJob {

    @XxlJob("orderCancelJobHandler")
    public void cancelUnpaidOrders() {
        // 执行任务逻辑
    }
}

注意：你用的是 @JobHandler，它是旧版本用法，新版本统一改为 @XxlJob（推荐）

---

🧩 步骤 5：在调度中心页面注册该任务

登录调度中心（xxl-job-admin）

• 新建任务
  • 执行器：选择 order-job-executor
  • JobHandler名称：orderCancelJobHandler
  • 调度类型：如“CRON”
  • 执行方式：BEAN 模式
  • CRON 表达式：比如每天凌晨 2 点 0 0 2 * * ?
• 保存并启动任务

xxl-job路由策略有哪些？

实例找任务项执行任务 这种找机器的方式就是路由策略

消息中间件RabbitMQ+Kafka

消息中间件提供了服务与服务之间的异步调用，还可以服务与服务之间解耦

RabbitMQ：**消息不丢失、消息重复消费、消息堆积、延迟队列、死信队列、高可用机制**
Kafka：**消息不丢失、消息重复消费、高可用机制、高性能设计吞吐量达到百万级、数据存储和清理**

RabbitMQ-如何保证消息不丢失？

• 开启生产者确认机制，确保生产者的消息能到达队列
  confirm到交换机ack 不到nack 和 return没到返回nack机制保证生产者把消息发过去

  达到队列成功返回ack，失败返回nack【negative acknowledgment】

  1. 生产者发送消息到交换机。
  2. 交换机收到消息后，根据绑定规则（是否有匹配的队列）决定消息是否被正确路由。
  3. 如果消息成功路由到队列，交换机会向生产者返回 ack 确认。
  4. 如果消息没有成功路由到任何队列，交换机会通过 return 将消息退回给生产者。
  5. 生产者收到 ack 或 nack，可以处理消息确认或重试逻辑。

• 开启持久化功能，确保消息未消费前在队列中不会丢失 durable = True
  万一broker挂掉就惨了 保证至少成功一次消费
  MQ是默认内存存储信息，开启持久化功能可以确保缓存在MQ中的消息不丢失[把数据存在磁盘上]

  # 声明持久化交换器
  channel.exchange_declare(exchange='exchange_name', durable=True)
        
  # 声明持久化队列
  channel.queue_declare(queue='queue_name', durable=True)
        
  # 发送持久化消息
  channel.basic_publish(exchange='exchange_name',
                        routing_key='routing_key',
                        body='Hello World!',
                        properties=pika.BasicProperties(
                           delivery_mode=2,  # 使消息持久化
                        ))
  

• 开启消费者确认机制为auto，由spring确认消息处理成功后完成ack
  消费者三种机制：

  RabbitMQ支持消费者确认机制，即：**消费者处理消息后可以向MQ发送ack回执，MQ收到ack回执后才会删除该消息**，而Spring AMQP则允许配置三种确认模式：

  • manual：手动ack，需要在业务代码结束后，调用api发送ack。

  • auto：自动ack，由spring监测listener代码是否出现异常，没有异常则返回ack；抛出异常则返回nack

  • none：关闭ack，MQ假定消费者获取消息后会成功处理，因此消息投递后立即被删除

• 开启消费者失败重试机制，多次重试失败后将消息投递到异常交换机，交由人工处理

  在开启重试模式后，重试次数耗尽，如果消息依然失败，则需要有MessageRecoverer接口来处理，它包含三种不同的实现：

  • RejectAndDontRequeueRecoverer：重试耗尽后，直接reject，丢弃消息。默认就是这种方式

  • ImmediateRequeueMessageRecoverer：重试耗尽后，返回nack，消息重新入队

  • RepublishMessageRecoverer：重试耗尽后，将失败消息投递到指定的交换机

• 异步发送（验证码、短信、邮件）
• MySQL和Redis，ES之间的数据同步
• 分布式事务
• 削峰填谷

==生产者确认机制==

RabbitMQ提供了publisher confirm机制来避免消息发送到MQ过程中丢失。消息发送到MQ以后，会返回一个结果给发送者，表示消息是否处理成功

RabbitMQ消息的重复消费问题如何解决的？

我们当时消费者是设置了自动确认机制，当服务还没来得及给MQ确认的时候，服务宕机了，导致服务重启之后，又消费了一次消息，这样就重复消费了
因为我们当时处理的支付（订单|业务唯一标识），它有一个业务的唯一标识，我们再处理消息时，先到数据库查询一下，这个数据是否存在，如果不存在，说明没有处理过，这个时候就可以正常处理这个消息了。如果已经存在这个数据了，就说明消息重复消费了，我们就不需要再消费了。

原因

• 网络抖动
• 消费者挂了

解决方案：适用于任何MQ(Kafka，RabbitMQ，RocketMQ)

• 每条消息设置一个唯一的标识id
• 幂等方案：【分布式锁、数据库锁(悲观锁、乐观锁)】

RabbitMQ中死信交换机？(RabbitMQ延迟队列有了解过吗)

如果用原来的定时任务 也可以但是 可能会有订单空窗期 如果没人消费的时候 它内部还是回去sql查询已下单 +(now()-下单时间)?15min : true, false

• 我们当时一个什么业务使用到了延迟队列（超时订单、限时优惠、定时发布）
• 其中延迟队列就用到了死信交换机和TTL（消息存活时间）实现的
• 消息超时未消费就会变成死信（死信的其他情况：拒绝被消费，队列满了）

我们用延迟队列处理未支付订单：用户下单后 15 分钟未付款，自动取消订单+释放库存；其他场景也用到延迟队列，比如限时促销、定时发布文章、定时发通知等。

延迟队列插件实现延迟队列DelayExchange
延迟队列的底层实现就是通过 TTL（消息存活时间）+ 死信交换机（DLX）组合完成的。

• 声明一个交换机，添加delayed属性为true
• 发送消息时，添加x-delay头，值为超过时间

什么样的消息会成为死信？
★ 消费者返回reject或者nack，且requeue参数设置为false【消息被拒绝并且不重入队列】
★ 消息超时未消费
★ 队列满了

如何给队列绑定死信交换机？
★ 给队列设置dead-letter-exchange属性，指定一个交换机
★ 给队列设置dead-letter-routing-key属性，设置死信交换机与死信队列的RoutingKey

------------------------------------------------------------------------
★ ★ ★ 使用 Spring AMQP 配置 ★ ★ ★ 
import org.springframework.amqp.core.Queue;
import org.springframework.amqp.core.Exchange;
import org.springframework.amqp.core.TopicExchange;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class RabbitMQConfig {

    // 定义普通队列
    @Bean
    public Queue normalQueue() {
        return new Queue("normalQueue", true, false, false, 
                Map.of("x-dead-letter-exchange", "dlx_exchange", 
                       "x-dead-letter-routing-key", "dlx_routing_key"));
    }

    // 定义死信队列
    @Bean
    public Queue dlxQueue() {
        return new Queue("dlxQueue", true);
    }

    // 定义普通交换机
    @Bean
    public Exchange normalExchange() {
        return new TopicExchange("normal_exchange");
    }

    // 定义死信交换机
    @Bean
    public Exchange dlxExchange() {
        return new TopicExchange("dlx_exchange");
    }

    // 将普通队列与交换机绑定
    @Bean
    public Binding bindNormalQueue() {
        return BindingBuilder.bind(normalQueue()).to(normalExchange()).with("normal.routing.key").noargs();
    }

    // 将死信队列与死信交换机绑定
    @Bean
    public Binding bindDLXQueue() {
        return BindingBuilder.bind(dlxQueue()).to(dlxExchange()).with("dlx_routing_key").noargs();
    }
}
------------------------------------------------------------------------
如果你希望将死信队列配置成带有过期时间或其他特殊属性的队列，可以在定义 dlxQueue 时增加更多的设置，例如 TTL（过期时间）。
例如，设置死信队列的 TTL：

@Bean
public Queue dlxQueue() {
    return QueueBuilder.durable("dlxQueue")
            .withArgument("x-message-ttl", 60000) // 设置TTL为60秒
            .build();
}

✅ Spring AMQP 中配置延迟队列 + 死信队列（简洁版）

@Bean
public Queue orderQueue() {
    return QueueBuilder.durable("order.queue")
            .ttl(15 * 60 * 1000) // 15分钟TTL
            .deadLetterExchange("dlx.exchange") // 超时后投递到死信交换机
            .deadLetterRoutingKey("order.dlx")  // 指定死信路由key
            .build();
}

@Bean
public Queue orderDLXQueue() {
    return new Queue("order.dlx.queue");
}

延迟队列 = 死信交换机 + TTL (生存时间)

• 延迟队列：进入队列的消息会被延迟消费的队列
• 场景：超时订单、限时优惠，定时发布

死信交换机

当一个队列中的消息满足下列情况之一时，可以成为死信(dead letter)：

• 消费者使用basic.reject 或 basic.nack声明消费失败，并且信息的requeue参数设置为false
• 消息是一个过期消息，超时无人消费
• 要投递的队列消息堆积满了，最早的消息可能成为死信

如果该队列配置了dead-letter-exchange属性，指定了一个交换机，那么队列中的死信就会投递到这个交换机中，而这个交换机称为死信交换机(Dead Letter Exchange，简称DLX)

@Bean
public QUeue ttlQueue(){
    return QueueBuilder.durable("simple.queue") // 指定队列名称，并持久化
        .ttl(10000) // 设置队列的超时时间 10秒
        .deadLetterExchange("dl.direct") // 指定死信交换机
        .build();
}

✅ 死信交换机配置核心属性（面试考点）

x-dead-letter-exchange: 死信交换机名称
x-dead-letter-routing-key: 投递死信用的路由key
x-message-ttl: 消息过期时间（单位：毫秒）

TTL

TTL(Time-To-Live)。如果一个队列中的消息TTL结束仍未消费，则会变成死信，ttl超时分为两种情况：

• 消息所在的队列设置了存活时间
• 消息本身设置了存活时间

RabbitMQ如果有100万消息堆积在MQ，如何解决(消息堆积怎么解决)？

消息堆积的本质是消费能力不足，解决重点是提升消费者处理能力 + 降低系统压力。

**解决消息堆积有三种思路 **

• 增加更多消费者，提高消费速度
• 在消费者内开启线程池加快消息处理速度
• 扩大队列容积，提高堆积上限
  • 在声明队列的时候可以设置x-queue-model为lazy，即为惰性队列
  • 基于磁盘存储，消息上限高
  • 性能比较稳定，但基于磁盘存储，受限于磁盘IO，时效性会降低

当生产者发送消息的速度超过了消费者处理消息的速度，就会导致队列中的消息堆积，直到队列存储消息达到上限。之后发送的消息就会成为死信，可能会被丢弃，这就是堆积问题

**解决消息堆积有三种思路 **

• 增加更多消费者，提高消费速度
• 在消费者内开启线程池加快消息处理速度
• 扩大队列容积，提高堆积上限

达到上限发送的消息会变成死信，那我为什么不搞个死信交换机 而是用了上面的三种思路？？

使用死信交换机（DLX, Dead Letter Exchange）是另一种处理消息堆积的方式，但它的作用更偏向于“消息过期”或“处理失败”的情况下将消息转发到另一个队列。并不直接解决生产者发送消息过快或消费者处理速度过慢的问题。通过死信交换机，你可以将无法处理的消息转发到其他队列，方便你后续进行分析或处理，但它并不能提高消费者处理消息的速度。

针对消息堆积的本质问题，解决方式更多的是优化消费者处理能力，而不是仅依赖死信交换机。具体而言，死信交换机和你的三种思路的关系如下：

1. 死信交换机（DLX）：当消息达到队列上限或无法消费时，消息被转发到死信队列。你可以分析死信队列中的消息，了解原因，并决定是重试、丢弃还是进行其他处理。它的作用是不丢失消息，但并不能帮助消除堆积。
2. 增加消费者：这是直接针对堆积的根本解决方案，通过增加消费者数量来加速消息的处理。死信交换机无法直接解决消费者处理能力不足的问题。
3. 开启消费者线程池：在单个消费者上开启线程池，可以提高消费者的处理能力，减少堆积。死信交换机并不能增加消息处理速度，它只是用来应对消费失败的情况。
4. 扩大队列容量并使用惰性队列：惰性队列可以将消息存储在磁盘上，而非内存中，减轻内存压力，但这也会降低时效性，并不能解决生产者生产过快或消费者消费过慢的问题。死信交换机同样无法直接解决这一点。

总结来说，死信交换机是处理消息丢失或无法消费的方式，它和通过增加消费者、线程池、队列优化这些手段并不冲突，但也无法替代这些更直接的解决方案。你可以结合这两者，使用死信交换机来保障消息不丢失，同时采取上述方法来提高消息消费速度。

死信交换机主要作用是保底机制，用于处理失败的消息，比如超时、拒绝、队列满。它不能真正解决堆积问题，只能帮我们兜底不丢消息。
所以，我们会搭配使用：前面是用多线程和惰性队列来压堆积，后面用死信队列来兜住异常消息，保障系统稳定。

惰性队列

惰性队列特征如下：

• 接收到消息后直接存入磁盘而非内存
• 消费者要消费消息时才会从磁盘中读取并加载到内存
• 支持数百万条的消息存储

@Bean
public Queue lazyQueue(){
    return QueueBuilder
            .durable("lazy.queue")
            .lazy() // 设置为惰性队列，落盘存储
            .build();
}

// 惰性队列是 RabbitMQ 提供的一种机制，消息直接写入磁盘，内存消耗小，堆积能力强，适合处理海量不紧急消息。但缺点是消费速度会稍慢，因为要从磁盘读。

@RabbitListener(queuesToDeclare = @Queue){
    name = "lazy.queue",
    durable = "true",
    arguments = @Argument(name = "x-queue-mode"), value="lazy"
}
public void listenLazyQUeue(String msg){
    log.info("接收到lazy.queue的消息：{}",msg);
}

提高消费能力是解决堆积的根本；惰性队列能缓解内存压力，死信机制是辅助保障不丢消息。三者应配合使用。

RabbitMQ高可用机制有了解过吗？ &&  请描述 RabbitMQ 镜像队列的工作原理及其在高可用性场景下的优缺点

在我们项目中，为了保障消息队列的高可用性，我们采用了 RabbitMQ 的镜像队列集群部署方案，后来也了解并测试了仲裁队列来提升一致性保障。

我们当时的项目在生产环境下，采用的是镜像模式搭建的集群，共有3个节点
镜像队列结构是一主多从(从就是镜像)，所有(写)操作都是主节点完成，然后同步给镜像节点
主宕机后，镜像节点会代替成为新的主(如果在主从同步完成前，主就已经宕机，可能出现数据丢失)

🔹 RabbitMQ 高可用机制对比三种：

模式	原理	是否同步消息	容灾能力	是否强一致	应用场景
普通集群	共享元数据，不同步消息内容	❌	弱	❌	测试、非关键业务
镜像队列	主节点写入，同步到镜像节点	✅	中	弱~中	读多写少
仲裁队列	Raft 协议选主，多节点确认写入	✅	强	✅（强一致）	关键数据、支付

那出现丢数据怎么解决呢？

我们可以采用仲裁队列，与镜像队列一样，都是主从模式，支持主从数据同步，主从同步基于wwwwwwwwwwwwwwwwwwwww，强一致性，并且使用起来也非常简单，不需要格外的配置，在声明队列的时候只需要指定这个是仲裁队列即可

Raft 协议 是一种 共识算法（Consensus Algorithm）；
🔴 在分布式系统中，让多个节点就某个值达成一致（即使有部分节点故障）
Raft 就是“几个节点如何选出一个 Leader，让它来统筹所有更新，然后让大多数节点都确认成功后再算真正提交成功”。
为了避免这些 “脑裂、数据冲突” 问题，就需要一种 “大家达成共识” 的机制，Raft 协议就是这种机制🏗️ Raft 核心角色和流程

✅ Raft 有三种角色：

角色	说明
Leader	主节点，唯一能接收客户端写请求
Follower	跟随者，接受 Leader 同步数据
Candidate	候选人，用于选举新 Leader

✅ 正常流程：

1. 所有节点刚启动时，都是 Follower。
2. 一段时间内没收到 Leader 的心跳，会变成 Candidate，发起投票选举。
3. 多数投票成功后，变成新的 Leader。
4. 所有写请求只能由 Leader 处理，然后同步给其他节点（Follower）。
5. 如果 大多数节点都确认写入成功，则这条数据才算真正提交成功。

• 在生产环境下，使用集群来保证高可用性
• 普通集群、镜像集群、仲裁队列(Raft协议)

普通集群

普通集群，或者叫标准集群(classic cluster)

• 会在集群的各个节点间共享部分数据，包括：交换机、队列元信息。不包含队列中的信息
• 当访问集群某节点时，如果队列不在该节点，会从数据所在节点传递到当前节点并返回
• 队列所在节点宕机，队列中的消息就会丢失

镜像集群

镜像集群：本质是主从模式，具备下面的特征：

• 交换机、队列、队列中的消息会在各个mq的镜像节点之间同步备份
• 创建队列的节点被称为该队列的主节点，备份到的其他节点叫做该队列的镜像节点
• 一个队列的主节点可能是另一个队列的镜像节点
• 所有操作都是主节点完成，然后同步给镜像节点
• 主宕机后，镜像节点会替代成新的主

🔹 镜像队列原理（项目中实际使用）

在我们的生产环境中，RabbitMQ 集群采用的是 镜像队列（Classic Mirrored Queue） 模式，有以下特点：

• 主从同步： 队列存在一个主节点，多个镜像节点。
• 所有写操作都落在主节点，随后同步给镜像节点。
• 如果主节点宕机，镜像节点会被选举为新主。
• 同步存在延迟，一旦主节点宕机且尚未同步完，就可能出现数据丢失。

💡 镜像队列优点：

• 数据有副本，具备一定容灾能力
• 节点可切换，保证服务不中断

⚠ 镜像队列缺点：

• 主从同步可能延迟 → 存在数据丢失风险
• 配置复杂、资源开销大，大集群下性能差

---

🔹 那出现丢数据怎么办？

我们后来开始测试和使用了 仲裁队列（Quorum Queue），它在 3.8+ 中推出，作为镜像队列的替代方案，支持强一致性。

仲裁队列：.quorum()

仲裁队列是3.8版本以后才有的新功能，用来替代镜像队列

• 与镜像队列一样，都是主从模式，支持主从数据同步
• 使用非常简单，没有复杂的配置
• 主从同步基于Raft协议，强一致性

仲裁队列的工作原理如下：

1. 主从模式：仲裁队列也是主从模式，支持主从数据同步。
2. Raft 协议：主从同步基于 Raft 协议，确保数据的一致性和可靠性。
3. 强一致性：所有写操作必须得到大多数节点的确认后才能完成，避免了数据丢失。

仲裁队列通过以下机制保证数据不丢失：

• 多数派确认：每次写操作需要得到大多数节点的确认，确保数据已经成功复制到多个节点。
• 自动故障转移：如果主节点宕机，Raft 协议会自动选举新的主节点，确保服务的连续性。
• 数据一致性：Raft 协议保证了数据的强一致性，即使在网络分区或节点宕机的情况下，也不会出现数据不一致的问题。

仲裁队列的优点是配置简单、数据强一致，但需要至少 3 个节点，并且在写操作上的延迟和资源消耗可能会比镜像队列高。

@Bean
public Queue quorumQueue(){
    return QueueBuilder
            .durable("quorum.queue") // 持久化
            .quorum() // 仲裁队列
            .build();
}

Kafka是如何保证消息不丢失？

需要从三个层面去解决这个问题

• 生产者发送消息到Brocker丢失

  • 设置异步发送，发送失败使用回调进行记录或重发
  • 失败重试，参数配置，可以设置重试次数消息

• 在Brocker中存储丢失

  发送确认acks，选择all，让所有的副本都参与保存数据后确认

• 消费者从Brocker接收消息丢失

  • 关闭自动提交偏移量，开启手动提交偏移量
  • 提交方式：最好是同步+异步提交

使用Kafka在消息的收发过程中都会出现消息丢失，Kafka分别给出了解决方案

• 生产者发送消息到Brocker丢失
• 消息在Brocker中存储丢失
• 消费者从Brocker接收消息丢失

kafka-高产出的分布式消息系统(A high-throughput distributed messaging system)。

Kafka是一个高吞吐、分布式、基于发布订阅的消息系统，利用Kafka技术可以在廉价的PC Server上搭建起大规模消息系统。

Kafka的特性：

• 高吞吐量、低延迟：kafka每秒可以处理几十万条消息，它的延迟最低只有几毫秒，每个topic可以分多个partition, consumer group 对partition进行consume操作；
• 可扩展性：kafka集群支持热扩展；
• 持久性、可靠性：消息被持久化到本地磁盘，并且支持数据备份防止数据丢失；
• 容错性：允许集群中节点失败（若副本数量为n,则允许n-1个节点失败）；
• 高并发：支持数千个客户端同时读写；
• 支持实时在线处理和离线处理：可以使用Storm这种实时流处理系统对消息进行实时进行处理，同时还可以使用Hadoop这种批处理系统进行离线处理；

Kafka和其他组件比较，具有消息持久化、高吞吐、分布式、多客户端支持、实时等特性，适用于离线和在线的消息消费，如常规的消息收集、网站活性跟踪、聚合统计系统运营数据（监控数据）、日志收集等大量数据的互联网服务的数据收集场景。

1. 日志收集：一个公司可以用Kafka可以收集各种服务的log，通过kafka以统一接口服务的方式开放给各种consumer，例如Hadoop、Hbase、Solr等；
2. 消息系统：解耦和生产者和消费者、缓存消息等；
3. 用户活动跟踪：Kafka经常被用来记录web用户或者app用户的各种活动，如浏览网页、搜索、点击等活动，这些活动信息被各个服务器发布到kafka的topic中，然后订阅者通过订阅这些topic来做实时的监控分析，或者装载到Hadoop、数据仓库中做离线分析和挖掘；
4. 运营指标：Kafka也经常用来记录运营监控数据。包括收集各种分布式应用的数据，生产各种操作的集中反馈，比如报警和报告；
5. 流式处理：比如spark streaming和storm；
6. 事件源；
7. kafka在FusionInsight中的位置：

Kafka是如何保证消费的顺序性？

Kafka 保证消息不丢失需要从 生产者、Broker、消费者 三个维度考虑：

1. 生产者侧：通过设置 acks=all、启用 幂等性（enable.idempotence=true）、配置 重试机制 等，确保消息可靠送达 Kafka。
2. Broker 侧：通过消息持久化、副本同步机制（ISR）、故障转移机制等，确保存储端可靠。
3. 消费者侧：通过 关闭自动提交 offset，使用手动同步/异步提交，并搭配幂等消费逻辑，避免消息处理丢失。

多项机制结合，共同保障 Kafka 在高吞吐、高并发下仍具备良好的可靠性与稳定性。

问题原因：
一个topic的数据可能存储在不同的分区中 ，每个分区都有一个按照顺序的存储的偏移量，如果消费者关联了多个分区不能保证顺序性

==解决方案：==

• 发送消息时指定分区号
• 发送消息时按照相同的业务设置相同的key

应用场景：

• 即时消息中的单对单聊天和群聊，保证发送方消息发送顺序与接收方的顺序一致
• 充值转账两个渠道在同一个时间进行金额变更，短信通知必须要有顺序

承接上图消费者从Brocker接收消息丢失：
如何做？→ topic分区中消息只能由消费者组中的唯一一个消费者处理，所以消息肯定是按照先后顺序进行处理的。但是它也仅仅是保证Topic的一个分区顺序处理，不能保证跨分区的消息先后处理顺序。所以，如果你想要顺序的处理Topic的所有消息，那就只提供一个分区。

// 指定分区
kafkaTemplate.sent("springboot-kafka-topic",0,"key-001","value-001");
// 相同的业务key
kafkaTemplate.sent("springboot-kafka-topic","key-001","value-001");

会计算key的hashcode值推断出它在哪个分区，如果要求有顺序性 就可以设置同一个key，此时hash值都是一样的 就可以在同一个分区存储

Kafka的高可用机制有了解过吗？

• ==集群模式==

  一个kafka集群由多个broker实例组成，即使某一台宕机，也不会耽误其他broker继续对外提供服务

• ==分区备份机制==

  • 一个topic有多个分区，每个分区有多个副本，有一个leader，其余的是follower，副本存储在不同的broker中
  • 所有的分区副本的内容都是相同的，如果leader发生故障时，会自动将其中一个follower提升为leader，保证了系统的容错性、高可用性

✅ 真实业务场景案例：订单创建消息流的高可用设计（基于 Kafka）

🟡 业务背景

你在做一个电商平台系统，其中订单创建之后，需要进行如下异步操作：

1. 通知库存中心扣减库存
2. 通知积分服务赠送用户积分
3. 通知数据中心写入大数据平台（如 HDFS）

为了解耦服务、削峰填谷，并保障消息不丢失，我们决定使用 Kafka 进行消息中转。

---

🟧 Kafka 高可用设计

▶ 架构图概览（文字版）

[订单服务 OrderService] 
    |
    | 生产消息 send(order_id=1001)
    ▼
[Kafka集群 topic=order-create partition=0,1,2]        
    |  partition-0：leader 在 broker1，follower 在 broker2,3
    |  partition-1：leader 在 broker2，follower 在 broker1,3
    |  partition-2：leader 在 broker3，follower 在 broker1,2
    ▼
[消费者集群]
  ├── 库存服务（group=stock）
  ├── 积分服务（group=points）
  └── 数据服务（group=bigdata）

🔵 Kafka 高可用机制在这里怎么体现？

✅ 1. Kafka 集群部署（Broker 多节点）

部署 3 个 Kafka Broker：

broker.id=1,2,3 分别配置在三台服务器上

即便其中任意一台 Broker 宕机，剩下两台仍然可以继续服务。

✅ 2. Topic 分区 + 副本机制

创建 topic 时设定副本数：

bin/kafka-topics.sh --create \
  --topic order-create \
  --partitions 3 \
  --replication-factor 3 \
  --zookeeper zk1:2181

• 每个分区会有 1 个 leader + 2 个 follower

• Leader 负责读写，follower 同步数据

• 当 Leader 所在 Broker 宕机时，Kafka 会自动从 ISR 列表中选一个 follower 升级为 leader
  🔁 例如：

• 原来 partition-0 的 leader 是 broker1

• broker1 崩了 → Kafka Controller 会选 broker2 或 broker3 提升为新 leader

✅ 3. 生产者配置 acks=all + 幂等性

为了保障消息可靠写入 Kafka：

props.put("acks", "all"); // 所有副本都确认才算成功
props.put("enable.idempotence", "true"); // 避免重复投递

📝 所以生产者即便 retry 了，也不会生成重复消息。

✅ 4. 消费者使用手动提交 offset

为了保证消费者处理完消息再提交 offset，避免消息处理失败却误提交偏移量：

props.put("enable.auto.commit", "false");

while (true) {
    ConsumerRecords<String, String> records = consumer.poll(Duration.ofMillis(100));
    for (ConsumerRecord<String, String> record : records) {
        // 处理消息
        process(record);
    }
    consumer.commitSync(); // 处理完手动提交
}

🔻 模拟突发事件：Kafka Broker 宕机，系统是否正常？

❓ 假设 Broker1 宕机，会发生什么？

• partition-0 的 leader 在 broker1 → Kafka Controller 自动将 broker2 提升为新的 leader
• 生产者发送消息依然正常（因为 follower 已同步数据）
• 消费者照常消费 partition-0 的数据

✅ 总结一波这个真实案例带来的知识点

组件	高可用机制	关键作用
Kafka 集群	多 Broker + Controller	任一节点挂掉不影响整体服务
Topic 分区副本	leader + follower	保证消息副本安全、自动故障转移
Producer	acks=all + 幂等性	防止生产过程中消息丢失或重复
Consumer	手动提交 offset	避免处理失败误提交偏移量

❓面试模拟追问

面试官：你们 Kafka 的 leader 挂了会不会影响消费者？

你可以回答：

Kafka 的消费者是从分区的 leader 拉取消息的，如果 leader 节点挂了，Kafka 会自动从 ISR 列表中挑选新的 follower 作为 leader，整个过程对消费者来说是无感知的，消费过程会自动恢复。

解释一下复制机制中的ISR？

ISR (in-sync replica) 需要同步复制保存的follower；跟 Leader 保持同步 的副本集合
分区副本分为了两类，一个是ISR，与leader副本同步保存数据，另外一个普通的副本，是异步同步数据，当leader挂掉后，会优先从ISR副本列表中选取一个作为leader

Kafka 每个分区（Partition）都会有多个副本（Replicas）：

• 一个 Leader
• 若干个 Follower

这些副本被分成两类：

类型	描述
ISR 副本	与 Leader 保持数据同步的副本（最健康的副本集）
OSR（Out-of-Sync Replicas）	落后太多，未能及时同步 Leader 数据的副本

🧠 工作机制详解

1️⃣ 消息写入

• Producer 只写 Leader
• Leader 负责将数据同步到 ISR 中的所有 Follower
• 所有 ISR 成员都成功写入后，才向 Producer 发送 ack

如果 Leader 挂了：

• Kafka 只会从 ISR 列表中挑选一个副本晋升为新的 Leader
• 这样可以确保新 Leader 中的数据是完整的

🟩 举个例子助记

假设 topic 有 3 个副本：

Partition-0:
  - broker1 (Leader)
  - broker2 (Follower)
  - broker3 (Follower)

此时，**ISR = [broker1, broker2]**（broker3 落后太多，暂不在 ISR 中）

如果 broker1 挂掉了 → Kafka 会从 broker2 中选一个当 Leader（因为它是同步副本）

📌 broker3 不在 ISR 中，就算数据多，也不会被选为 leader（因为可能数据不一致）

---

Kafka 中每个分区都会有多个副本，其中 ISR（In-Sync Replicas）表示与 Leader 保持同步的副本集合。

ISR 是 Kafka 高可用的重要保障，Kafka 只会从 ISR 中选 leader，避免使用落后副本导致数据丢失。

可以通过配置 min.insync.replicas 来控制 ISR 最小数量，从而配合 acks=all 确保数据写入可靠性。

// 一个topic默认分区的replication个数，不能大于集群中broker的个数。默认为1
default.replication.factor=3
// 最小的ISR副本个数
min.insync.replicas=2

Kafka数据清理机制了解过吗？

• kafka文件存储机制
  • Kafka中topic的数据存储在分区上，分区如果文件过大会分段存储segment
  • 每个分段都在磁盘上以索引(xxxx.index)和日志文件(xxx.log)的形式存储
  • 分段的好处是，第一能够减少单个文件内容的大小，查找数据方便，第二方便kafka进行日志清理
• 数据清理机制
  • 根据消息的保留时间，当消息保存的时间超过了指定的时间，就会触发清理，默认168小时(7天)
  • 根据topic存储的数据大小，当topic所占的日志文件大小大于一定的阈值，则开始删除最久的消息(默认关闭)

✅ Kafka 和 RabbitMQ 对比

🧠 总结一句话对比

• 🔥 Kafka 更适合：高吞吐、日志/流式处理、大数据实时系统
• 🔧 RabbitMQ 更适合：业务系统间的解耦、任务异步处理、延迟消息机制

Kafka 和 RabbitMQ 都是消息中间件，但定位不同：

• Kafka 是高吞吐、分布式日志系统，更适合大数据场景和实时流式处理，使用 Partition 和 Offset 保证扩展性。
• RabbitMQ 是传统的消息队列中间件，支持 AMQP 协议，适合轻量级业务异步解耦，原生支持延迟队列和消息确认机制。

我们项目中如果要处理高并发日志或用户行为采集就选 Kafka，如果是下单通知、订单超时等场景就更适合 RabbitMQ。

Kafka中实现高性能的设计有了解过吗？

• 消息分区：不受单台服务器的限制，可以不受限的处理更多的数据
• 顺序读写：磁盘顺序读写，提升读写效率
• 页缓存：把磁盘中的数据缓存到内存中，把对磁盘的访问变为对内存的访问
• 零拷贝：减少上下文切换及数据拷贝
• 消息压缩：减少磁盘IO和网络IO
• 分批发送：将消息打包批量发送，减少网络开销

零拷贝

集合面试篇

算法复杂度分析

什么是算法时间复杂度？

• 时间复杂度表示了算法的执行时间与数据规模之间的增长关系

常见的时间复杂度有哪些？口诀：常对幂指阶

• O(1)、O(n)、O(n^2)、O(logn)

什么是算法的空间复杂度？

• 表示算法占用的额外存储空间和数据规模之间的增长关系
  常见的空间复杂度：O(1)、O(n)、O(n^2)

为什么要进行复杂度分析？

• 指导你编写出性能更优的代码
• 评判别人写的代码的好坏

时间复杂度分析：来评估代码的执行耗时的

• 大O表示法：不具体表示代码真正的执行时间，而是表示代码执行时间随数据规模增长的变化趋势

• 只要代码的执行时间**不随着n的增大而增大，这样的代码复杂度都是O(1)**

• 复杂度分析就是要弄清楚代码的执行次数和数据规模n之间的关系

时间复杂度：全称是渐进空间复杂度，表示算法占用的额外存储空间和数据规模之间的增长关系

List相关面试题

• 数组是一种用连续的内存空间存储相同数据类型数组的线性数据结构

• 数组下标为什么从0开始

  寻址公式是：baseAddress + i * data TypeSize 计算下标的内存地址效率较高

• 查找的时间复杂度

  • 随机(通过下标)查询的时间复杂度是O(1)
  • 查找元素(未知下标)的时间复杂度是O(n)
  • 查找元素(未知下标但排序)通过二分查找的时间复杂度是O(logn)

• 插入和删除时间复杂度

  插入和删除的时候，为了保证数组的内存连续性，需要挪动数组元素，平均复杂度为O(n)

底层实现

• 数据结构—数组
• ArrayList源码分析

面试问题

• ArrayList底层的实现原理是什么
• ArrayList list = new ArrayList(10)中的list扩容几次
• 如何实现数组和List之间的转换
• ArrayList和LinkedList的区别是什么

ArrayList源码分析

List< Integer > list = new ArrayList< Integer >();
list.add(1)

public class ArrayList<E> extends AbstractList<E>
        implements List<E>, RandomAccess, Cloneable, java.io.Serializable{

    private static final long serialVersionUID = 8683452581122892189L;

    /**
     * Default initial capacity.
     */
    private static final int DEFAULT_CAPACITY = 10;

    /**
     * 用于空实例的共享空数组实例
     */
    private static final Object[] EMPTY_ELEMENTDATA = {};

    /**
     * 用于默认大小的空实例的共享空数组实例
     * 与上面的区分开，以了解添加第一个元素时要膨胀多少
     */
    private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
  
    /* 存储ArrayList元素的数组缓冲区，ArrayList的容量就是这个数组缓冲区的长度 */
    transient Object[] elementData; // non-private to simplify nested class access

    /**
     * ArrayList的大小(包含的元素数量)
     * @serial
     */
    private int size;
...
}

--------------------------------------------------------------------------------

public ArrayList(int initialCapacity) {
        if (initialCapacity > 0) {
       // 创建一个真正存储集合位置的数组
            this.elementData = new Object[initialCapacity];
        } else if (initialCapacity == 0) {
    // 如果容量是0则创建一个新的数组给elementData
            this.elementData = EMPTY_ELEMENTDATA;
        } else {
            throw new IllegalArgumentException("Illegal Capacity: "+
                                               initialCapacity);
        }
    }
    public ArrayList() { 
         // 无参构造函数，默认创建空集合
        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
    }

-------------------------------------------------------------------------------
// Collection是所有单列集合的父接口
// 将 Collection 对象转换成数组，然后将数组的地址赋给 elementData
 public ArrayList(Collection<? extends E> c) {
        elementData = c.toArray();
        if ((size = elementData.length) != 0) {
            // 判断集合类型是否为不为object[] 
            // 在其他jdk此处是 ?? == ArrayList.class
            if (elementData.getClass() != Object[].class)
                // 不是的话就拷贝到数组elementData中
                elementData = Arrays.copyOf(elementData, size, Object[].class);
        } else {
            // replace with empty array.
            this.elementData = EMPTY_ELEMENTDATA;
        }
    }

ArrayList源码分析-添加和扩容操作(第1次添加数据)

ArrayList底层的实现原理是什么

• ArrayList底层是用动态数组实现的
• ArrayList初始容量为0，当第一次添加数据的时候才会初始化容量为10
• ArrayList在进行扩容的时候是原来容量的1.5倍，每次扩容都需要拷贝数组
• ArrayList在添加数据的时候
  • 确保数组已使用长度(size)加1之后足够存下下一个数据
  • 计算数组的容量，如果当前数组已使用长度+1后的大于当前的数组长度，则调用grow方法扩容(原来的1.5倍)
  • 确保新增的数据有地方存储之后，则将新元素添加到位于size的位置上
  • 返回添加成功布尔值

ArrayList list = new ArrayList(10)中的list扩容几次

• 该语句只是声明和实例了一个ArrayList，指定了容量为10，未扩容

如何实现数组和List之间的转换

• 数组转List，使用JDK中java.util.Arrays工具类的asList方法
• List转数组，使用List的toArray方法，无参toArray方法返回Object数组，传入初始化长度的数组对象，返回该对象数组

使用 Hutool 工具库可以非常方便地实现数组和 List 之间的转换。Hutool 提供了 ArrayUtil 和 CollUtil 工具类来处理数组和集合之间的转换。

问：我不能用BeanUtil吗？
答：BeanUtil 是 Hutool 工具库中用于 Java Bean 操作的工具类，主要用于 对象属性拷贝、Bean 转 Map、Map 转 Bean 等操作。它并不适用于 数组和 List 之间的转换。

如果你误以为 BeanUtil 可以用于数组和 List 的转换，可能是因为它的名字容易让人误解。实际上，数组和 List 的转换应该使用 ArrayUtil 或 CollUtil。

正确的工具类选择

1. 数组转 List：使用 ArrayUtil.toList。
2. List 转数组：使用 CollUtil.toArray。
3. Bean 属性拷贝：使用 BeanUtil.copyProperties。
4. Bean 转 Map：使用 BeanUtil.beanToMap。
5. Map 转 Bean：使用 BeanUtil.fillBeanWithMap。

更多的Hutool工具使用高能预警

1. 字符串工具类：StrUtil

• 功能：字符串操作，如判空、格式化、截取、替换等。
• 常用方法：
  • StrUtil.isEmpty()：判断字符串是否为空。
  • StrUtil.format()：格式化字符串。
  • StrUtil.split()：拆分字符串。
  • StrUtil.join()：连接字符串。

---

2. 日期时间工具类：DateUtil

• 功能：日期和时间的格式化、解析、计算等。
• 常用方法：
  • DateUtil.now()：获取当前时间。
  • DateUtil.format()：格式化日期。
  • DateUtil.parse()：解析字符串为日期。
  • DateUtil.offsetDay()：日期加减。

---

3. 文件工具类：FileUtil

• 功能：文件和目录的操作，如读写、复制、删除等。
• 常用方法：
  • FileUtil.readUtf8String()：读取文件内容为字符串。
  • FileUtil.writeUtf8String()：将字符串写入文件。
  • FileUtil.copy()：复制文件或目录。
  • FileUtil.del()：删除文件或目录。

---

4. JSON 工具类：JSONUtil

• 功能：JSON 的解析和生成。
• 常用方法：
  • JSONUtil.parseObj()：将 JSON 字符串解析为 JSON 对象。
  • JSONUtil.parseArray()：将 JSON 字符串解析为 JSON 数组。
  • JSONUtil.toJsonStr()：将对象转换为 JSON 字符串。

---

5. 集合工具类：CollUtil

• 功能：集合操作，如创建集合、判空、过滤、分组等。
• 常用方法：
  • CollUtil.newArrayList()：快速创建 ArrayList。
  • CollUtil.isEmpty()：判断集合是否为空。
  • CollUtil.filter()：过滤集合。
  • CollUtil.group()：对集合进行分组。

---

6. 反射工具类：ReflectUtil

• 功能：反射操作，如调用方法、获取字段、创建对象等。
• 常用方法：
  • ReflectUtil.invoke()：调用方法。
  • ReflectUtil.getFieldValue()：获取字段值。
  • ReflectUtil.newInstance()：创建对象实例。

---

7. HTTP 工具类：HttpUtil

• 功能：HTTP 请求的发送和响应处理。
• 常用方法：
  • HttpUtil.get()：发送 GET 请求。
  • HttpUtil.post()：发送 POST 请求。
  • HttpUtil.downloadFile()：下载文件。

---

8. 加密解密工具类：SecureUtil

• 功能：常见的加密解密操作，如 MD5、SHA、AES 等。
• 常用方法：
  • SecureUtil.md5()：计算 MD5 值。
  • SecureUtil.sha256()：计算 SHA-256 值。
  • SecureUtil.aes()：AES 加密解密。

---

9. IO 工具类：IoUtil

• 功能：IO 流操作，如读写、关闭流等。
• 常用方法：
  • IoUtil.read()：读取流内容。
  • IoUtil.write()：写入流内容。
  • IoUtil.close()：关闭流。

---

10. 随机工具类：RandomUtil

• 功能：生成随机数、随机字符串等。
• 常用方法：
  • RandomUtil.randomInt()：生成随机整数。
  • RandomUtil.randomString()：生成随机字符串。
  • RandomUtil.randomEle()：从集合中随机选择一个元素。

---

11. 验证工具类：Validator

• 功能：数据验证，如邮箱、手机号、身份证等。
• 常用方法：
  • Validator.isEmail()：验证是否为邮箱。
  • Validator.isMobile()：验证是否为手机号。
  • Validator.isCitizenId()：验证是否为身份证号。

---

12. 缓存工具类：CacheUtil

• 功能：简单的缓存操作。
• 常用方法：
  • CacheUtil.newTimedCache()：创建定时缓存。
  • CacheUtil.put()：添加缓存。
  • CacheUtil.get()：获取缓存。

---

13. 线程工具类：ThreadUtil

• 功能：线程操作，如睡眠、创建线程池等。
• 常用方法：
  • ThreadUtil.sleep()：线程睡眠。
  • ThreadUtil.newExecutor()：创建线程池。

---

14. Excel 工具类：ExcelUtil

• 功能：Excel 文件的读写操作。
• 常用方法：
  • ExcelUtil.getReader()：读取 Excel 文件。
  • ExcelUtil.getWriter()：写入 Excel 文件。

---

15. 压缩工具类：ZipUtil

• 功能：文件或目录的压缩和解压缩。
• 常用方法：
  • ZipUtil.zip()：压缩文件或目录。
  • ZipUtil.unzip()：解压缩文件。

---

16. 日志工具类：Log

• 功能：简化日志操作。
• 常用方法：
  • Log.get()：获取日志对象。
  • Log.info()：输出日志信息。

---

17. 数学工具类：MathUtil

• 功能：数学计算，如四舍五入、最大值、最小值等。
• 常用方法：
  • MathUtil.round()：四舍五入。
  • MathUtil.max()：获取最大值。
  • MathUtil.min()：获取最小值。

---

18. 网络工具类：NetUtil

• 功能：网络相关操作，如获取本机 IP、Ping 等。
• 常用方法：
  • NetUtil.getLocalhost()：获取本机 IP。
  • NetUtil.ping()：Ping 测试。

• 用Arrays.asList转List后，如果修改了数组内容，list受影响吗
• List用toArray转数组后，如果修改了List内容，数组受影响吗

再答：

• Arrays.asList转换list之后，如果修改了数组的内容，list会受影响，因为它的底层使用的Arrays类中的一个内部类ArrayList来构造的集合，在这个集合的构造器中，把我们传入的这个集合进行了包装而已，最终指向的都是同一个内存地址
• list用了toArray转数组后，如果修改了list内容，数组不会受影响，当调用了toArray以后，在底层是它进行了数组拷贝，跟原来的元素就没啥关系了，所以即使list修改了以后，数组也不受影响

LinkedList的数据结构—链表

单向链表

• 链表中的每一个元素称之为结点(Node)
• 物理存储单元上，非连续、非顺序的存储结构
• 单向链表：每个结点包括两个部分:一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。记录下个结点地址的指针叫作后继指针 next

1.单向链表和双向链表的区别是什么

• 单向链表只有一个方向，结点只有一个后继指针 next。
• 双向链表它支持两个方向，每个结点不止有一个后继指针next指向后面的结点，还有一个前驱指针prev指向前面的结点

2.链表操作数据的时间复杂度是多少

ArrayList和LinkedList的区别

• 底层数据结构

  • ArrayList 是动态数组的数据结构实现
  • LinkedList 是双向链表的数据结构实现

• 操作数组效率

  • ArrayList 按照下标查询的时间复杂度O(1);【内存是连续的，根据寻址公式】，LinkedList不支持下标查询

  • 查找(未知索引)：ArrayList需要遍历，链表也需要遍历，时间复杂度都是O(n)

  • 新增和删除【查询多用ArrayList；插入/删除多用Linked】

    • ArrayList 尾部插入和删除，时间复杂度是O(1)；其他部分增删需要挪动数组，时间复杂度是O(n)
    • LinkedList 头尾节点增删时间复杂度是O(1)，其他都需要遍历链表，时间复杂度是O(n)

• 内存空间占用

  • ArrayList 底层是数组，内存连续，节省内存
  • LinkedList 是双向链表需要存储数据，和两个指针，更占用内存

• 线程安全

  • ArrayList和LinkedList都不是线程安全的

  • 如果要保证线程安全，有两种方法

    • 在方法内使用，局部变量则是线程安全的

    • 使用线程安全的ArrayList和LinkedList

      List<Object> syncArrayList = Collections.synchronizedList(new ArrayList<>());
      List<Object> syncLinkedList = Collections.synchronizedList(new LinkedList<>());
      

HashMap相关面试题

• 二叉树

  • 满二叉树

  • 完全二叉树

  • 二叉搜索树

    二叉搜索树又名二叉查找树，有序二叉树或者排序二叉树，是二叉树中比较常用的一种类型二叉查找树要求，在树中的任意一个节点，其左子树中的每个节点的值，都要小于这个节点的值，而右子树节点的值都大于这个节点的值

  • 红黑树

• 红黑树

• 散列表

✅ 1. 二叉树（Binary Tree）

每个节点最多有两个子节点，称为左子节点和右子节点。

---

✅ 2. 满二叉树（Full Binary Tree）

每个节点要么是叶子节点，要么恰好有两个子节点，且所有叶子都在同一层。

---

✅ 3. 完全二叉树（Complete Binary Tree）

除了最后一层，其他每一层的节点数都达到最大值，且最后一层节点集中在左侧。

---

✅ 4. 二叉搜索树（Binary Search Tree，BST）

又叫：二叉查找树、有序二叉树

特点：

• 对于任意一个节点 node：
  • 左子树中所有节点值 < node 值
  • 右子树中所有节点值 > node 值
• 中序遍历是升序排列

用途：

• 用于快速查找、插入、删除（时间复杂度平均为 O(log n)，最坏为 O(n)）

---

✅ 5. 红黑树（Red-Black Tree）

红黑树是自平衡的二叉搜索树，在多种语言的底层集合结构（如 Java 的 TreeMap、TreeSet，C++ 的 map、set）都有使用。

特点：

• 每个节点是红或黑
• 根节点是黑色
• 每个叶子节点（NIL）是黑色
• 红色节点不能有红色子节点（即不能连续两个红）
• 任意一节点到其所有后代叶子节点的路径上，黑色节点数量相同

目的：

• 保证在最坏情况下，查找、插入、删除的时间复杂度是 O(log n)

---

✅ 6. 散列表（Hash Table）

与树不同，散列表是通过哈希函数（Hash Function）将键映射到数组下标进行查找。

特点：

• 查找时间接近 O(1)
• 冲突处理方式如链地址法、开放定址法等
• 用于实现如 Java 的 HashMap、HashSet、Python 的 dict、set 等结构