Fei

非淡泊无以明志，非宁静无以致远

发表于 更新于 分类于

基于Ubuntu 24.04 快速部署K8S 1.31.0集群

1. K8S集群主机准备

主机操作系统版本: Ubuntu 24.04

硬件配置说明:
master 2核 4G内存 20GB硬盘
node1 2核 4G内存 20GB硬盘
node2 2核 4G内存 20GB硬盘

1.1 主机名配置

master: hostnamectl set-hostname k8s-master01
node1: hostnamectl set-hostname k8s-worker01
node2: hostnamectl set-hostname k8s-worker02

1.2 主机IP地址配置

vim /etc/netplan/50-cloud-init.yaml

1
静态配置

发表于 更新于 分类于

1. 基本操作

gitignore
忽略文件
如果有文件需要忽略，可以在根目录下创建一个.gitignore文件，在里面写上需要忽略的文件名，比如：

1
2
3
4
.idea/
node_modules/
public/
temp.txt

如果某些文件已被 Git 跟踪，即使你将它们添加到 .gitignore 文件中，Git 仍然会继续跟踪它们。你需要使用以下命令停止跟踪这些文件

1
2
3
git rm --cached <file> # 停止跟踪文件
git rm -r --cached <folder_name> # 停止跟踪文件夹
git rm -r --cached . # 停止跟踪所有文件

发表于 更新于 分类于

index_img: /img/; summary:

https://wild-flame.github.io/guides/docs/mac-os-x-setup-guide/nodejs

1. 安装

1
brew install node

2. 配置

查看当前镜像源: npm config get registry

  1. 配置华为云镜像

    1
    npm config set registry https://mirror.cloud.huawei.com/npm/registry

  2. 修改成腾讯云镜像源

    1
    npm config set registry http://mirrors.cloud.tencent.com/npm/

  3. 配置淘宝镜像

    1
    npm config set registry https://registry.npmmirror.com

发表于 更新于 分类于

index_img: /img/; summary:

1. Mac

1.1 Terminal

2. Vscode

2.1 Markdown

  1. Command + Shift + v 打开预览
  2. Command + Shift + c 唤出命令行

2.2 截图配置

2.2.1 Vscode 配置

在设置中找到Markdown › Copy Files: Destination
配置内容为
Item: *.md
Value: ./${documentBaseName}/${fileName}

发表于 更新于 分类于

Hexo

1. 基础介绍

1.1 目录介绍

1
2
3
4
5
6
7
8
9
10
├── _config.fluid.yml
├── _config.yml
├── db.json
├── node_modules
├── packag$$e-lock.json
├── package.json
├── public
├── scaffolds
├── source
└── themes
  1. _config.fluid.yml: 这是一个配置文件，用于配置Hexo的插件、主题等。
  2. _config.yml: 这是一个配置文件，用于配置Hexo的插件、主题等。
  3. db.json: 这是一个数据库文件，用于存储Hexo的博客数据。
  4. package.json: 这是一个配置文件，存储应用程序的信息。 EJS, Stylus 和 Markdown 渲染引擎 已默认安装，您可以自由移除。 如果您想，可以稍后卸载它们。
  5. scaffolds: 模版 文件夹。 当您新建文章时，Hexo 会根据 scaffold 来创建文件。
  6. source: 资源文件夹。 是存放用户资源的地方。 除 _posts 文件夹之外，开头命名为 _ (下划线)的文件 / 文件夹和隐藏的文件将会被忽略。 Markdown 和 HTML 文件会被解析并放到 public 文件夹，而其他文件会被拷贝过去
  7. themes: 主题文件夹。 Hexo 会根据主题来生成静态页面。

1.2 配置文件

您可以在_config.yml中修改大部分的配置。

1.3 资源文件夹

发表于 更新于 分类于

1. 介绍

在使用Python开发时，遇到了很多配置环境的情形。有时需要安装不同版本的Python，有时需要安装不同的Python包，有时需要安装不同的Python包的不同版本。

最开始使用时我基本上都是看网上的教程，不同的Python项目可能使用不同的环境管理工具，不知不觉就用过了pip、conda、mamba、virtualenv、venv等等。这些工具各有优劣，有时候我也会混用，导致环境变量混乱，有时候还会出现冲突。

由于一直没有什么一致性，导致电脑上的Python环境比较乱，我自己也感觉云里雾里的，所以我打算总结一下这些工具的使用方法，以及它们的优缺点。最后会给出我自己推荐的一些使用方法。

2.Python管理工具分类

Python管理工具可以分为两类：

包管理工具：用于安装、卸载、更新Python包，如pip、conda、mamba等。

环境管理工具：用于管理Python环境，如venv、virtualenv、conda、mamba等。

我们这里主要讨论环境管理工具，因为包管理工具的使用方法比较简单，而且大多数情况下我们都会使用pip，所以这里不再赘述。

发表于 更新于 分类于

从五月份开始直至昨天，断断续续读完了这本书，但这个过程还是过于走马观花。因为是走马观花，所以大部分的内容根本没有深入理解，更谈不让将之运用于实践了。不过我知道这是一本好书，一本对于我的个人发展是一本好书，它能指导我的阅读。而阅读本本身可以让我获取更多的思想以及思考方式，所以重读这本书是很有必要的。而在这里，我也需要通过写读书笔记的方式来辅助我对这本书对我有利的内容尽可能多地进行吸纳。

我会按照这本书的结构来进行读书笔记的书写，除了对于文中重要内容的复述，也会加入我个人新的思考。

第一篇 阅读的层次

第1章 阅读的活力与艺术

本书的目的是为了那些以增进自己理解力为目标而阅读的人提供指导

  • 主动地阅读

​ 阅读越主动，收获也就越多

​ 作者与读者的关系就如同发球手和捕球手的关系一样。作者“发出”某个思想，读者需要主动地去“捕 获”这个思想。

​ 首先，阅读需要主动。其次，阅读需要有技巧。

发表于 更新于 分类于

1. 易忘知识点

用于记录已遗忘的知识点

1.1 基础语法

  • 一个JAVA文件中的不同类中均可以有public static 方法， 并且可用java 类名的方式运行public static方法

  • javadoc 用于生成java文件的文档，使用方式javadoc xxx.java.

  • 补码 = 反码 + 1， 计算机运行使用补码

    • 正数：原码，反码，补码都一样：第一位是符号位，0代表正数，数值位为二进制数
    • 负数：
      • 原码：第一位是符号位，1代表负数，数值位为2进制数
      • 反码：第一位是符号位，1代表负数，数值位为对应原码的数值位取反
      • 补码：反码数值位加1

  • 方法重载（Overload）

    • 方法名必须相同

    • 形参列表必须不同：参数顺序，类型，个数，至少有一样不同

    • 返回类型：无要求

      注意：仅仅是形参名不同无法实现方法重载

  • 可变参数

    java允许将同一个类中多个同名同功能但参数个数不同的方法，封装成一个方法

    1
    2
    3
    public void varPara(int... parameters){
      //parameters 是一个数组
    }
    1. 可变参数的实参可以为0或任意多个
    2. 可变参数的实参可以是数组
    3. 可变参数可以和普通类型的参数放在一个形参列表里，但需要保证可变参数在最后
    4. 一个形参列表中只能出现一个可变参数

  • 构造器

    • 构造器没有返回值
    • 方法名和类名必须相同
    • 参数列表和成员方法一样的规则
    • 构造器的调用由系统完成
    • 构造器，即构造方法可以重载
    1
    2
    3
    4
    5
    class Constructer{
      public Constructer(){
        
      }
    }

    作用：对新对象的初始化

  • 反编译

    javap [-c -v] 类名

    -c 对代码反汇编

    -v 输出附加信息

1.2 面向对象

  • 代码块

    属于类中的成员，将逻辑语句封装在方法体中，通过“{}”包围起来。

    和方法不同，没有方法名，没有返回值，没有参数，只有方法体，不通过类或对象显式调用。在加载类或者创建对象时隐式调用。

    1
    2
    3
    [修饰符]{
      code...
    }; // 此分号可有可无

    修饰符 可选，使用修饰符时只能用static

    代码块使用场景：e.g. 当多个构造器中有相同的代码语句时，可以将其放入代码块中

    创建对象时，系统先调用代码块，后调用构造器

  • 类加载顺序

    1. 父类的静态代码块和静态属性
    2. 子类的静态代买块和静态属性
    3. 父类的普通代码块和普通属性
    4. 父类的构造方法
    5. 子类的普通代码块和普通属性
    6. 子类的构造方法

  • final关键字

    使用情况:

    (1) 当一个类不希望被继承时, 可使用final关键字修饰

    (2) 当不希望类中某个方法被子类重写时, 可用final关键字修饰

    (3) 当不希望类中某个属性的值被修改时, 使用final关键字修饰

    (4) 当不希望某个局部变量被修改时, 使用final关键字修饰

  • abstract 类

    当不打算在父类中定义某些方法,但又想提前声明这些方法时, 使用abstract修饰这个父类以及这些方法

    1
    2
    3
    class abstract Test{
      public abstract void m(); // 没有方法体
    }

    • interface

      JDK8.0后接口可以有静态方法, 默认方法

      在接口中抽象方法可以省略abstract关键字

      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      public interface Test{
         public int n1 = 10;
         default public void ok(){ // 默认方法, 注意要使用default关键字修饰
           System.out.println("ok..");
         }
        public static void test(){ // 静态方法
          System.out.println("test.."); 
        }
      }

      一个类可以同时实现多个接口

      1
      2
      3
      class Test implements IA, IB, ...{
        ...
      }

      接口中的属性是final static修饰的, 例如在接口中写int a = 1; , 实际上是public static final int a = 1;

  • 内部类

    一个类的内部又完整地嵌套了另一个类结构. 被嵌套的类称为内部类(inner class), 嵌套的其他类称为外部类(outer class). 

    1
    2
    3
    4
    5
    6
    // 基本语法
    class Outer{// 外部类
      class Inner{// 内部类
        
      }
    }

    内部类的分类

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    //1. 定义在外部类的局部位置(如方法中, 代码块中)
    //1.1 局部内部类
    class Outer01{
      private int n1 = 1;
      public void m1(){
        class Inner01{ // 可使用final修饰
          private int n1 = 22;
          public void m10(){
            System.out.println(A.this.n1); // 可以直接访问所在外部内的所有成员, 使用 外部类名.this精确定位
          }
        }
      }//局部内部类的作用域只在对应的方法体内或代码块中
    }

    //1.2 匿名内部类
    class Outer02{
      private int n2 = 1;
      public void m2(){
        IA ia = new IA(){ // class xxx implements IA{...}
          public void test(){
            System.out.println(n2);
          }
        }
      }
    }
    interface IA{}

    //2. 定义在外部类的成员变量位置
    //2.1 成员内部类

    class Outer03{
      private int n3 = 1;
      class Inner{
        public void m3(){
          System.out.println(n3);
        }
      }
    }

    //2.2 静态内部类

    class Outer04{
      private int n4 = 1;
      static class Inner{
        public void m4(){
          System.out.println(n4);
        }
      }
    }

  • 枚举

枚举: 枚举属于一种特定的类, 里面只包含一组有限的特定的对象

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
//1. 自定义枚举

class Season{
    private String name;
    private String desc;
    // public Season season = new Season("ok", "001");


    public static final Season SPRING = new Season("Spring", "Warm");
    public static final Season SUMMER = new Season("Summer", "Hot");
    public static final Season AUTUMN = new Season("Autumn", "Cozy");
    public static final Season WINTER = new Season("Winter", "Cold");

    private Season(String name, String desc){
        this.name = name;
        this.desc = desc;
    }

    public String getName() {
        return name;
    }

    public String getDesc() {
        return desc;
    }
}







//2. 使用enum关键字


enum Season_{
    //1. 多个常量时， 用','间隔
    //2. 常量对象需要定义在类的最前面

    SPRING("Spring", "Warm"), SUMMER("Summer", "Hot"), AUTUMN("Autumn","Cozy"), WINTER("Winter","Cold");
    
    private String name ;
    private String desc;
    private Season_(String name, String desc){
      this.name = name;
      this.desc = desc;
    }

    public String getName() {
        return name;
    }

    public String getDesc() {
        return desc;
    }
}

  • 注解

    注解(Annotation)也被称为元数据, 用于修饰包, 类, 方法, 属性, 构造器, 局部变量等数据信息

    不影响程序逻辑, 但是注解可以被编译和执行

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    //1. @Override 标明方法为重写方法
    //2. @Deprecated 标明某个类或方法已过时
    //3. @SuppressWarnings 抑制编译器警告


    //元注解, 注解的注解
    //1. @Retention(RetentionPolicy.SOURCE)  指定注解的作用范围(SOURCE(编译器使用后直接丢弃), CLASS(记录在class文件, 但jvm运行时不保留), RUNTIME)
    //   代码(SOURCE) ==> class 文件(class) ==> JVM运行(RUNTIME)
    //2. Target(ElementType.METHOD) 指定注解的使用范围(CONSTRUCTURE, FIELD, LOCAL_VARIABLE, METHOD, PACKAGE, PARAMETER, TYPE)
    //3. Documented 指定该注解是否在javadoc中显示
    //4. Inherited 子类会继承父类注解

    • 异常

      运行时异常: 程序运行时发生异常

      编译时异常: 编译器检测出的异常

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    Java.lang.Throwable
      -Error
      -Exception
      	--编译时异常
      		--IOException
      		--SQLException
        --运行时异常 RuntimeException
      		--NullPointException
      		--ArrayindexOutOfBundsException
      		--ArithmeticException
      		--ClassCastExcetption
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    // 1. try-catch-finally
    try{
      ...
    }catch(NullPointerException e){
      e. sss;
    }catch(ArithmeticException e){
      
    }finally{
      
    }

    // 2. throws

    public void method() throws {
      
    }
    //当抛出的是运行时异常, 调用该方法的方法可以不处理
    //当抛出的是编译时异常, 调用该方法的方法需要进行处理

发表于 更新于 分类于

文章管理

2023年9月19日生效

时间-文章类型-文章名称

文章类型：

  • 日记随想：D : Thoughts

  • 总结反思：S : Summary

  • 技术文章：T : Tech

  • 读书笔记：R : Reading

  • 效率管理：E : Efficiency

日记： 记录一天经历的事件或所思所想

技术文章：整理所学到的技术知识, 以及技术相关的工作学习收获

读书笔记：整理每次阅读完一本书的知识点或者读后感。对于论述性书籍进行总结归纳，对于文学类书籍写读后感

效率提升：记录能提升知识输入输出的方式。比如本文档可归为此分类。因为本文档用于阐述我所写文章的分类方式。