在 Spring Boot 开发中，Controller 层接收前端参数是最基础也最容易踩坑的地方。本文用最直观的方式，把 GET/POST 请求下的单参数、多参数、混合参数、数组集合场景一网打尽，附带代码示例和避坑指南，建议收藏。

一、参数接收方式概览

二、GET 请求参数接收

1. 单个参数

方式一：路径占位符（RESTful）

// 前端请求：GET /user/1001
@GetMapping("/user/{id}")
public String getById(@PathVariable Long id) {
    return "查询单个用户ID：" + id;
}

方式二：Query 参数（? 传参）

// 前端请求：GET /user?id=1001
@GetMapping("/user")
public String getById2(@RequestParam Long id) {
    return "查询单个用户ID：" + id;
}

2. 多个参数

写法一：多个 @RequestParam 逐一列出

// 前端请求：GET /user?name=Jack&age=25&city=北京
@GetMapping("/user")
public String getUsers(@RequestParam String name, 
                       @RequestParam Integer age, 
                       @RequestParam String city) {
    return "姓名：" + name + "，年龄：" + age + "，城市：" + city;
}

写法二：使用 Map 接收（参数不固定时）

// 前端请求：GET /user?name=Jack&age=25&hobby=football
@GetMapping("/user/map")
public String getUsersByMap(@RequestParam Map<String, String> params) {
    return "所有参数：" + params.toString();
    // 输出：{name=Jack, age=25, hobby=football}
}

写法三：使用实体类接收（最优雅，强烈推荐）

// 前端请求：GET /user?name=Jack&age=25&city=北京
@GetMapping("/user/entity")
public String getUsersByEntity(UserQuery query) {
    return "姓名：" + query.getName() + "，年龄：" + query.getAge() + "，城市：" + query.getCity();
}

// 对应的实体类（需有 getter/setter）
public class UserQuery {
    private String name;
    private Integer age;
    private String city;
    // 省略 getter/setter...
}

三、POST 请求参数接收

1. 单个参数（JSON）

// 前端请求：POST /user
// Body: {"name": "Jack"}
@PostMapping("/user")
public String createUser(@RequestBody User user) {
    return "创建用户：" + user.getName();
}

2. 多个参数（JSON 对象）

// 前端请求：POST /user
// Body: {"name":"Jack", "age":25, "email":"jack@qq.com", "address":"北京"}
@PostMapping("/user")
public String createUserFull(@RequestBody User user) {
    return "姓名：" + user.getName() + 
           "，年龄：" + user.getAge() + 
           "，邮箱：" + user.getEmail() + 
           "，地址：" + user.getAddress();
}

// 对应的实体类
public class User {
    private String name;
    private Integer age;
    private String email;
    private String address;
    // 省略 getter/setter...
}

3. 不想建实体类？用 Map 接收 JSON

// 前端请求：POST /user/map
// Body: {"name":"Jack", "age":25, "score":98.5}
@PostMapping("/user/map")
public String createUserByMap(@RequestBody Map<String, Object> params) {
    return "所有参数：" + params.toString();
    // 输出：{name=Jack, age=25, score=98.5}
}

四、混合场景：路径 + Query + Body 同时使用

实际开发中，一个接口可能同时包含多种参数来源，这是完全合法的：

// 前端请求：PUT /order/1001?status=PAID
// Body: {"productName": "手机", "price": 5999}
@PutMapping("/order/{orderId}")
public String updateOrder(@PathVariable Long orderId,          // 路径参数
                          @RequestParam String status,         // Query 参数
                          @RequestBody Order order) {          // Body 参数
    return "订单ID：" + orderId + 
           "，状态：" + status + 
           "，商品：" + order.getProductName() + 
           "，价格：" + order.getPrice();
}

五、数组 / 集合参数接收

GET 请求：多个相同参数名

// 前端请求：GET /users?ids=1001&ids=1002&ids=1003
@GetMapping("/users")
public String getUsers(@RequestParam List<Long> ids) {
    return "用户ID列表：" + ids.toString(); // 输出：[1001, 1002, 1003]
}

POST 请求：JSON 数组

// 前端请求：POST /users/batch
// Body: [1001, 1002, 1003]
@PostMapping("/users/batch")
public String batchGetUsers(@RequestBody List<Long> ids) {
    return "批量查询ID：" + ids.toString();
}

六、速查对照表（单参 vs 多参）

七、避坑指南（重点！）

八、开发实践建议

1. 统一规范：项目内约定好 GET 用 Query + 实体类，POST/PUT 用 JSON + @RequestBody，避免风格混乱。
2. 优先使用实体类：参数超过 3 个时，建议封装为实体类，提高代码可读性和可维护性。
3. 参数校验：配合 @Valid + @NotNull 等注解做参数校验，减少业务层判空代码。
4. 日志打印：在 Controller 层打印接收到的参数，方便联调排查问题。

总结

Spring Boot 接收参数的方式虽然多样，但总结下来无非是参数来源和注解选择的排列组合。记住三个核心注解：

• @PathVariable → URL 路径中的值
• @RequestParam → URL 问号后面的值
• @RequestBody → 请求体中的 JSON

掌握这三个，再加上实体类自动绑定，就能覆盖 95% 以上的开发场景。

如果你在实践中有任何疑问，欢迎在评论区留言交流！

客户要求在银河麒麟服务器版使用docker安装mysql5.7

难点

1、mysql版本 ARM 架构的银河麒麟架构匹配，不然不会报错
2、需要的是 arm64v8/mysql:5.7
3、在docker镜像官网找到的最低版本都是8.0了

解决

最终在 腾讯云的公有镜像里找到了（https://console.cloud.tencent.com/tcr/publicimage/tag?rid=1&reponame=arm64v8%2Fmysql）
docker pull ccr.ccs.tencentyun.com/arm64v8/mysql:5.7.31

以下是 Collectors 类中常用工厂方法的详细使用案例：

1. toList() - 收集到列表

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

public class CollectorExamples {
    public static void main(String[] args) {
        // 示例数据
        List<String> names = Arrays.asList("Alice", "Bob", "Charlie", "David", "Alice");

        // toList() - 收集到列表
        List<String> nameList = names.stream()
            .filter(name -> name.length() > 3)
            .collect(Collectors.toList());
        System.out.println("toList 示例: " + nameList);
        // 输出: [Alice, Charlie, David, Alice] (保留重复元素)

        // 处理数值类型
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
        List<Integer> squares = numbers.stream()
            .map(n -> n * n)
            .collect(Collectors.toList());
        System.out.println("数值平方列表: " + squares);
        // 输出: [1, 4, 9, 16, 25]
    }
}

2. toSet() - 收集到集合（去重）

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

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

        // toSet() - 自动去重
        Set<String> nameSet = names.stream()
            .filter(name -> name.length() > 3)
            .collect(Collectors.toSet());
        System.out.println("toSet 示例: " + nameSet);
        // 输出: [Alice, Charlie, David] (自动去重，顺序可能不同)

        // 自定义对象示例
        List<Employee> employees = Arrays.asList(
            new Employee("Alice", "HR", 5000),
            new Employee("Bob", "IT", 6000),
            new Employee("Alice", "IT", 5500),
            new Employee("Charlie", "HR", 5200)
        );

        // 根据姓名去重收集
        Set<String> uniqueNames = employees.stream()
            .map(Employee::getName)
            .collect(Collectors.toSet());
        System.out.println("员工姓名集合: " + uniqueNames);
        // 输出: [Alice, Bob, Charlie]
    }

    static class Employee {
        private String name;
        private String department;
        private double salary;

        public Employee(String name, String department, double salary) {
            this.name = name;
            this.department = department;
            this.salary = salary;
        }

        public String getName() { return name; }
        public String getDepartment() { return department; }
        public double getSalary() { return salary; }
    }
}

3. toMap() - 收集到映射

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

public class CollectorExamples {
    public static void main(String[] args) {
        List<Employee> employees = Arrays.asList(
            new Employee("Alice", "HR", 5000),
            new Employee("Bob", "IT", 6000),
            new Employee("Charlie", "HR", 5200),
            new Employee("David", "IT", 6500)
        );

        // 简单的 toMap - 姓名作为键，员工对象作为值
        Map<String, Employee> employeeMap = employees.stream()
            .collect(Collectors.toMap(
                Employee::getName,  // 键提取器
                employee -> employee  // 值提取器
            ));
        System.out.println("员工映射: " + 
            employeeMap.keySet().stream()
                .map(key -> key + "=" + employeeMap.get(key).getDepartment())
                .collect(Collectors.joining(", ")));
        // 输出类似: Alice=HR, Bob=IT, Charlie=HR, David=IT

        // 处理键冲突的情况
        List<Employee> employeesWithDuplicates = Arrays.asList(
            new Employee("Alice", "HR", 5000),
            new Employee("Bob", "IT", 6000),
            new Employee("Alice", "Finance", 5500)  // 重复的键
        );

        Map<String, Employee> mergedMap = employeesWithDuplicates.stream()
            .collect(Collectors.toMap(
                Employee::getName,
                employee -> employee,
                (existing, replacement) -> {
                    // 处理键冲突：保留工资更高的员工
                    return existing.getSalary() >= replacement.getSalary() 
                        ? existing : replacement;
                }
            ));
        System.out.println("处理冲突后的映射: " + 
            mergedMap.entrySet().stream()
                .map(e -> e.getKey() + "=" + e.getValue().getDepartment())
                .collect(Collectors.joining(", ")));
        // 输出: Alice=Finance, Bob=IT

        // 指定特定的 Map 实现
        Map<String, Double> salaryMap = employees.stream()
            .collect(Collectors.toMap(
                Employee::getName,
                Employee::getSalary,
                (v1, v2) -> v1,  // 如果键重复，保留第一个值
                TreeMap::new  // 使用 TreeMap 保持排序
            ));
        System.out.println("排序的薪资映射: " + salaryMap);
        // 输出: {Alice=5000.0, Bob=6000.0, Charlie=5200.0, David=6500.0}
    }
}

4. groupingBy() - 分组收集

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

public class CollectorExamples {
    public static void main(String[] args) {
        List<Employee> employees = Arrays.asList(
            new Employee("Alice", "HR", 5000),
            new Employee("Bob", "IT", 6000),
            new Employee("Charlie", "HR", 5200),
            new Employee("David", "IT", 6500),
            new Employee("Eve", "Finance", 7000),
            new Employee("Frank", "Finance", 5500)
        );

        // 简单分组 - 按部门分组
        Map<String, List<Employee>> employeesByDept = employees.stream()
            .collect(Collectors.groupingBy(Employee::getDepartment));

        System.out.println("按部门分组:");
        employeesByDept.forEach((dept, empList) -> 
            System.out.println(dept + ": " + 
                empList.stream()
                    .map(Employee::getName)
                    .collect(Collectors.joining(", ")))
        );
        // 输出:
        // HR: Alice, Charlie
        // Finance: Eve, Frank
        // IT: Bob, David

        // 分组后对值进行进一步处理
        Map<String, Long> deptCount = employees.stream()
            .collect(Collectors.groupingBy(
                Employee::getDepartment,
                Collectors.counting()  // 统计每个部门的人数
            ));
        System.out.println("各部门人数: " + deptCount);
        // 输出: {HR=2, Finance=2, IT=2}

        // 分组后计算平均薪资
        Map<String, Double> avgSalaryByDept = employees.stream()
            .collect(Collectors.groupingBy(
                Employee::getDepartment,
                Collectors.averagingDouble(Employee::getSalary)
            ));
        System.out.println("各部门平均薪资: " + avgSalaryByDept);
        // 输出类似: {HR=5100.0, Finance=6250.0, IT=6250.0}

        // 多级分组 - 先按部门，再按薪资级别
        Map<String, Map<String, List<Employee>>> multiLevelGrouping = employees.stream()
            .collect(Collectors.groupingBy(
                Employee::getDepartment,
                Collectors.groupingBy(emp -> 
                    emp.getSalary() >= 6000 ? "高薪" : "普通"
                )
            ));

        System.out.println("\n多级分组结果:");
        multiLevelGrouping.forEach((dept, salaryGroup) -> {
            System.out.println("部门: " + dept);
            salaryGroup.forEach((level, empList) ->
                System.out.println("  " + level + ": " +
                    empList.stream()
                        .map(Employee::getName)
                        .collect(Collectors.joining(", ")))
            );
        });
        // 输出:
        // 部门: HR
        //   普通: Alice, Charlie
        // 部门: Finance
        //   高薪: Eve
        //   普通: Frank
        // 部门: IT
        //   高薪: Bob, David

        // 使用特定 Map 实现的分组
        Map<String, Set<String>> namesByDept = employees.stream()
            .collect(Collectors.groupingBy(
                Employee::getDepartment,
                TreeMap::new,  // 使用 TreeMap 保持部门名称排序
                Collectors.mapping(
                    Employee::getName,
                    Collectors.toSet()  // 收集为 Set 去重
                )
            ));
        System.out.println("\n排序的部门-姓名映射: " + namesByDept);
        // 输出类似: {Finance=[Eve, Frank], HR=[Alice, Charlie], IT=[Bob, David]}
    }
}

5. joining() - 连接字符串

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

public class CollectorExamples {
    public static void main(String[] args) {
        List<String> fruits = Arrays.asList("Apple", "Banana", "Cherry", "Date");

        // 简单连接
        String simpleJoin = fruits.stream()
            .collect(Collectors.joining());
        System.out.println("简单连接: " + simpleJoin);
        // 输出: AppleBananaCherryDate

        // 使用分隔符连接
        String withDelimiter = fruits.stream()
            .collect(Collectors.joining(", "));
        System.out.println("带分隔符连接: " + withDelimiter);
        // 输出: Apple, Banana, Cherry, Date

        // 使用分隔符、前缀和后缀
        String withPrefixSuffix = fruits.stream()
            .collect(Collectors.joining(", ", "[", "]"));
        System.out.println("带前缀后缀连接: " + withPrefixSuffix);
        // 输出: [Apple, Banana, Cherry, Date]

        // 结合其他操作
        String filteredJoin = fruits.stream()
            .filter(fruit -> fruit.length() > 5)
            .map(String::toUpperCase)
            .collect(Collectors.joining(" | ", "Fruits: ", " (end)"));
        System.out.println("过滤转换后连接: " + filteredJoin);
        // 输出: Fruits: BANANA | CHERRY (end)

        // 处理对象列表
        List<Employee> employees = Arrays.asList(
            new Employee("Alice", "HR", 5000),
            new Employee("Bob", "IT", 6000),
            new Employee("Charlie", "HR", 5200)
        );

        String employeeNames = employees.stream()
            .map(Employee::getName)
            .collect(Collectors.joining(", ", "Employees: ", ""));
        System.out.println("员工姓名连接: " + employeeNames);
        // 输出: Employees: Alice, Bob, Charlie

        // 复杂连接示例
        String complexJoin = employees.stream()
            .map(emp -> emp.getName() + "(" + emp.getDepartment() + ")")
            .collect(Collectors.joining("; ", "[", "]"));
        System.out.println("复杂格式连接: " + complexJoin);
        // 输出: [Alice(HR); Bob(IT); Charlie(HR)]
    }
}

6. 综合示例

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

public class CollectorExamples {
    public static void main(String[] args) {
        List<Employee> employees = Arrays.asList(
            new Employee("Alice", "HR", 5000),
            new Employee("Bob", "IT", 6000),
            new Employee("Charlie", "HR", 5200),
            new Employee("David", "IT", 6500),
            new Employee("Eve", "Finance", 7000),
            new Employee("Frank", "Finance", 5500),
            new Employee("Grace", "IT", 6200)
        );

        // 综合应用：分析员工数据
        Map<String, String> departmentSummary = employees.stream()
            .collect(Collectors.groupingBy(
                Employee::getDepartment,
                Collectors.collectingAndThen(
                    Collectors.toList(),
                    list -> {
                        long count = list.size();
                        double avgSalary = list.stream()
                            .mapToDouble(Employee::getSalary)
                            .average()
                            .orElse(0.0);
                        String names = list.stream()
                            .map(Employee::getName)
                            .sorted()
                            .collect(Collectors.joining(", "));
                        return String.format("人数: %d, 平均薪资: %.2f, 员工: [%s]", 
                            count, avgSalary, names);
                    }
                )
            ));

        System.out.println("部门综合分析:");
        departmentSummary.forEach((dept, summary) -> 
            System.out.println(dept + " -> " + summary)
        );

        // 输出示例:
        // HR -> 人数: 2, 平均薪资: 5100.00, 员工: [Alice, Charlie]
        // Finance -> 人数: 2, 平均薪资: 6250.00, 员工: [Eve, Frank]
        // IT -> 人数: 3, 平均薪资: 6233.33, 员工: [Bob, David, Grace]
    }
}

7. 其他常用收集器

import java.util.*;
import java.util.stream.*;
import java.util.IntSummaryStatistics;

public class CollectorExamples {
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);

        // 统计信息
        IntSummaryStatistics stats = numbers.stream()
            .collect(Collectors.summarizingInt(Integer::intValue));
        System.out.println("统计信息: " + stats);
        System.out.println("平均值: " + stats.getAverage());
        System.out.println("总数: " + stats.getSum());
        System.out.println("最大值: " + stats.getMax());
        System.out.println("最小值: " + stats.getMin());
        System.out.println("数量: " + stats.getCount());

        // 分区（分为 true 和 false 两组）
        Map<Boolean, List<Integer>> partitioned = numbers.stream()
            .collect(Collectors.partitioningBy(n -> n % 2 == 0));
        System.out.println("奇偶数分区: " + partitioned);
        // 输出: {false=[1, 3, 5, 7, 9], true=[2, 4, 6, 8, 10]}

        // 归约操作
        Optional<Integer> sum = numbers.stream()
            .collect(Collectors.reducing((a, b) -> a + b));
        System.out.println("总和: " + sum.orElse(0));

        // 映射后再收集
        List<String> numberStrings = numbers.stream()
            .collect(Collectors.mapping(
                n -> "Number: " + n,
                Collectors.toList()
            ));
        System.out.println("映射后收集: " + numberStrings);
    }
}

总结

这些收集器可以组合使用，创建复杂的数据处理管道，是Java Stream API中非常强大的工具。

1. In-memory
2. Redis-stack
3. Qdrant
4. Pinecone

对比总结

选择建议

1. 快速验证/POC：In-memory
2. 已有Redis基础设施：Redis-stack
3. 自托管，注重性价比：Qdrant
4. 无运维团队，追求快速上线：Pinecone
5. 数据敏感，需私有化部署：Qdrant
6. 混合数据类型需求：Redis-stack

测试此代码报错，分析为：
不兼容的CPU架构
错误信息显示"Unexpected flavor: cpu"，这通常意味着当前平台的CPU架构不被支持
检查是否在Apple Silicon (M1/M2) Mac上运行，这可能需要特定的ARM64版本

由于我的mac是interl芯片，解决兼容问题：
加入下面这个依赖

<dependency>
    <groupId>ai.djl.huggingface</groupId>
    <artifactId>tokenizers</artifactId>
    <version>0.28.0</version>
</dependency>

@Aspect 
@Component 
public class PayAspect { 
    @Before("execution(public void com.flyaction.demo.aopreview.PayServiceImpl.pay(..))") 
    public void beforeNotify() { System.out.println("-----@Before前置通知"); } 

    @After("execution(public void com.flyaction.demo.aopreview.PayServiceImpl.pay(..))") 
    public void afterNotify() { System.out.println("-----@After后置通知"); } 

    @AfterReturning("execution(public void com.flyaction.demo.aopreview.PayServiceImpl.pay(..))") 
    public void afterReturningNotify() { System.out.println("-----@AfterReturning返回通知"); } 

    @AfterThrowing("execution(public void com.flyaction.demo.aopreview.PayServiceImpl.pay(..))") 
    public void afterThrowingNotify() { System.out.println("-----@AfterThrowing异常通知"); } 

    @Around("execution(public void com.flyaction.demo.aopreview.PayServiceImpl.pay(..))") 
    public Object aroundNotify(ProceedingJoinPoint proceedingJoinPoint) throws Throwable { 
        Object retValue = null; 
        System.out.println("-----@Around环绕通知AAA"); 
        retValue = proceedingJoinPoint.proceed();//放行 
        System.out.println("-----@Around环绕通知BBB"); return retValue; 
    } 
}

无异常情况下

异常情况下

@Component
@ConfigurationProperties(prefix = "person") //和配置文件person前缀的所有配置进行绑定
@Data //自动生成JavaBean属性的getter/setter
//@NoArgsConstructor //自动生成无参构造器
//@AllArgsConstructor //自动生成全参构造器
public class Person {
    private String name;
    private Integer age;
    private Date birthDay;
    private Boolean like;
    private Child child; //嵌套对象
    private List<Dog> dogs; //数组（里面是对象）
    private Map<String,Cat> cats; //表示Map
}

@Data
public class Dog {
    private String name;
    private Integer age;
}

@Data
public class Child {
    private String name;
    private Integer age;
    private Date birthDay;
    private List<String> text; //数组
}

@Data
public class Cat {
    private String name;
    private Integer age;
}

properties表示法

person.name=张三
person.age=18
person.birthDay=2010/10/12 12:12:12
person.like=true
person.child.name=李四
person.child.age=12
person.child.birthDay=2018/10/12
person.child.text[0]=abc
person.child.text[1]=def
person.dogs[0].name=小黑
person.dogs[0].age=3
person.dogs[1].name=小白
person.dogs[1].age=2
person.cats.c1.name=小蓝
person.cats.c1.age=3
person.cats.c2.name=小灰
person.cats.c2.age=2

yaml表示法

person:
  name: 张三
  age: 18
  birthDay: 2010/10/10 12:12:12
  like: true
  child:
    name: 李四
    age: 20
    birthDay: 2018/10/10
    text: ["abc","def"]
  dogs:
    - name: 小黑
      age: 3
    - name: 小白
      age: 2
  cats:
    c1:
      name: 小蓝
      age: 3
    c2: {name: 小绿,age: 2} #对象也可用{}表示

细节

● birthDay 推荐写为 birth-day
● 文本：
○ 单引号不会转义【\n 则为普通字符串显示】
○ 双引号会转义【\n会显示为换行符】
● 大文本
○ |开头，大文本写在下层，保留文本格式，换行符正确显示
○ >开头，大文本写在下层，折叠换行符
● 多文档合并
○ 使用---可以把多个yaml文档合并在一个文档中，每个文档区依然认为内容独立

1. 命令简介

ssh-copy-id 是一个用于将本地 SSH 公钥自动添加到远程服务器 authorized_keys 文件的工具，实现免密 SSH 登录。

2. 基本语法

ssh-copy-id [-i [identity_file]] [user@]hostname

3. 常用选项

4. 使用示例

4.1 基本使用

ssh-copy-id user@192.168.1.100

4.2 指定公钥文件

ssh-copy-id -i ~/.ssh/id_ed25519.pub user@host

4.3 指定非标准端口

ssh-copy-id -p 2222 user@host

4.4 组合使用

ssh-copy-id -i ~/.ssh/work_key.pub -p 2222 user@work-server

5. 工作原理

1. 检查本地公钥文件
2. 通过 SSH 连接到目标服务器
3. 将公钥追加到 ~/.ssh/authorized_keys
4. 设置正确的文件权限：
   • ~/.ssh → 700
   • ~/.ssh/authorized_keys → 600

6. 手动替代方案

当 ssh-copy-id 不可用时：

cat ~/.ssh/id_rsa.pub | ssh user@host "mkdir -p ~/.ssh && 
cat >> ~/.ssh/authorized_keys && 
chmod 700 ~/.ssh && 
chmod 600 ~/.ssh/authorized_keys"

7. 验证配置

ssh user@host

成功则无需输入密码直接登录

8. 注意事项

• 确保已生成密钥对：ssh-keygen
• 首次连接需确认主机指纹
• 检查远程服务器文件权限：

  chmod 700 ~/.ssh
  chmod 600 ~/.ssh/authorized_keys

• 某些系统需在 /etc/ssh/sshd_config 中启用：

  PubkeyAuthentication yes

9. 故障排查

• 权限问题：

  ssh -v user@host  # 查看详细错误

• 服务端配置：
  检查 /var/log/secure 或 /var/log/auth.log

10. 扩展知识

• 生成新密钥：ssh-keygen -t ed25519
• 查看公钥：cat ~/.ssh/id_ed25519.pub
• 禁用密码登录（安全建议）：

  # 在 /etc/ssh/sshd_config 中设置：
  PasswordAuthentication no

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

Linux转发是要开启内核转发功能net.ipv4.ip_forward的，于是检查内核转发是否打开

[root@VM-20-17-centos ~]# sysctl net.ipv4.ip_forward
net.ipv4.ip_forward = 0

这里发现内核转发是处于关闭状态的（0代表内核转发没有打开）这里手动echo命令开启内核转发，并再次查询内核转发是否开启

[root@VM-20-17-centos ~]# echo 1 > /proc/sys/net/ipv4/ip_forward
[root@VM-20-17-centos ~]# sysctl net.ipv4.ip_forward
net.ipv4.ip_forward = 1

这个时候在通过ip访问就OK了
永久生效的话 vim /etc/sysctl.conf，手动修改 ,sysctl -p 重新加载