Nginx

本文所用系统：CentOS 7.5 64位

通过源码编译安装

  1. 下载nginx-1.22.0，这里我放到/opt目录下

  2. 解压缩

  3. 安装依赖库

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    #安装C编译器（功能：预处理、编译、链接、汇编）
    yum install -y gcc

    #安装pcre库（功能：解析正则表达式）
    yum install -y pcre pcre-devel

    #安装zlib（功能：用于对数据进行压缩）
    yum install -y zlib zlib-devel

    #安装openssl（功能：网络加密通信）
    yum install -y openssl openssl-devel


    # 也可用一条指令代替上面👆的
    yum install -y gcc pcre pcre-devel zlib zlib-devel openssl openssl-devel

  4. 安装

    1
    2
    3
    4
    5
    6
    # 使用prefix选项指定安装的目录，使用with-http_ssl_module添加https模块
    ./configure --prefix=/usr/local/nginx --with-http_ssl_module

    make

    make install

  5. 启动

    1
    2
    3
    4
    5
    # 进入nginx的sbin目录
    cd /usr/local/nginx/sbin

    # 启动
    ./nginx

  6. 放行端口。分下面两种情况

    • 若为本地虚拟机，则手动关闭防火墙

      1
      2
      3
      4
      # 关闭防火墙
      systemctl stop firewalld.service
      # 禁止防火墙开机启动
      systemctl disable firewalld.service

    • 若为云服务器（阿里云、腾讯云…），则配置安全组策略

nginx命令：

1
2
3
4
5
6
7
8
9
10
11
# 快速停止
./nginx -s stop

 # 完成已接受的请求后，停止
./nginx -s quit

# 重新加载配置
./nginx -s reload

# 检查nginx配置是否正确
./nginx -t

注册系统服务

通过系统服务的方式启动nginx

  1. 创建服务脚本
1
vim /usr/lib/systemd/system/nginx.service
  1. 服务脚本内容
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
[Unit] 
Description=nginx
After=network.target remote-fs.target nss-lookup.target

[Service]
Type=forking
PIDFile=/usr/local/nginx/logs/nginx.pid
ExecStartPre=/usr/local/nginx/sbin/nginx -t -c /usr/local/nginx/conf/nginx.conf
ExecStart=/usr/local/nginx/sbin/nginx -c /usr/local/nginx/conf/nginx.conf
ExecReload=/usr/local/nginx/sbin/nginx -s reload
ExecStop=/usr/local/nginx/sbin/nginx -s stop
ExecQuit=/usr/local/nginx/sbin/nginx -s quit 
PrivateTmp=true
   
[Install]   
WantedBy=multi-user.target
  1. 重新加载系统服务
1
systemctl daemon-reload
  1. 设置开机启动
1
systemctl enable nginx.service

系统服务命令：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
# 查看nginx状态
systemctl status nginx

# 启动nginx
systemctl start nginx

# 停止nginx
systemctl stop nginx

# 重启nginx
systemctl restart nginx

# 重载nginx配置文件
systemctl reload nginx

增加https模块

若安装nginx时没有安装http_ssl_module模块，通过以下方式增加

记得先关闭运行的nginx！！！

  1. 进入nginx源码包目录
1
cd /opt/nginx-1.22.0
  1. 查看configure arguments参数
1
/usr/local/nginx/sbin/nginx -V
  1. 追加https模块的参数
1
./configure --prefix=/usr/local/nginx --with-http_ssl_module
  1. 执行make（不能是make install，否则会覆盖安装）
1
make
  1. 当前目录下会生出一个objs文件夹，将里面的nginx文件复制覆盖到/usr/local/nginx/sbin中
1
cp ./objs/nginx /usr/local/nginx/sbin/
  1. 重启nginx，通过命令查看发现已经增加了https模块
1
/usr/local/nginx/sbin/nginx -V　

展开全文 >>

支付对接

支付安全

对称加密

加密密钥与解密密钥相同

  • 优点：运算速度快
  • 缺点：密钥需要交换信息的双方共享，一旦被窃取，消息会被解密

AES算法：密钥长度128、256或512。安全强度高，性能很好（目前最流行的）

加密分组模式：将明文分组加密，微信支付中使用AEAD_AES_256_GCM

非对称加密

密钥分为公钥与私钥，公钥可以公开，私钥需要自己保密

使用公钥加密后只能用私钥解密，反之亦然

  • 优点：私钥严格保密，公钥任意分发，黑客获取公钥无法破解密文
  • 缺点：运算速度慢

RSA算法：最著名的非对称加密算法

  • 公钥加密，私钥解密：保证消息私密性
  • 私钥加密，公钥解密：身份认证

摘要算法

用于保证消息的完整性

  • 不可逆：只要算法，没要密钥。只能加密，不能解密
  • 难题友好性：想要破解，只能暴力枚举
  • 发散性：只要原文进行一点点改动，摘要就会发生剧烈变化
  • 抗碰撞性：原文不同，计算后的摘要也不同

常见摘要算法：MD5，SHA1，SHA2（SHA224、SHA256、SHA384）

数字签名

发送方：将消息的明文使用摘要算法计算出摘要，再通过私钥对摘要加密，将摘要的密文与消息的明文一起发送

接收发：使用公钥解密出摘要的明文，再与自己收到的消息明文计算的摘要进行对比。

数字证书

由受信任的CA颁布，以确保发布的公钥的是真实未被篡改的

典型场景：HTTPS

展开全文 >>

Spring常用的类

Maven: org.springframework:spring-beans

org.springframeworkspring.beans.factory

接口BeanFactory

spring bean容器的顶级接口

接口InitializingBean

bean实现该接口，会在创建完成后执行afterPropertiesSet()

接口DisposableBean

bean实现该接口，会在销毁执行destroy()

org.springframeworkspring.beans.factory.annotation

注解Autowired

自动注入

org.springframework.beans.factory.config

接口BeanDefinition

Bean定义信息

接口BeanFactoryPostProcessor

BeanFactory后置处理器

接口BeanPostProcessor

Bean后置处理器

  • postProcessBeforeInitialization()
  • postProcessAfterInitialization()

类PropertyOverrideConfigurer

通过读取自定义的配置文件来覆盖bean definition中的属性值（工作模式: “推”）

Maven: org.springframework:spring-context

org.springframework.context

接口ApplicationContextAware

org.springframework.context.annotation

注解Bean

org.springframework.context.support

类PropertySourcesPlaceholderConfigurer

替换bean definition中的${…}为配置文件中的真实值（工作模式: “拉”）

org.springframework.stereotype

注解Component

注解Controller

注解Repository

注解Service

Maven: org.springframework:spring-core

org.springframework.core

接口Ordered

表示排序的接口，值越小优先级越高

接口PriorityOrdered

继承自Ordered接口，当PriorityOrdered与纯Ordered一起排序时，PriorityOrdered的优先级总是比Ordered更高（无视其order value）

org.springframework.util

抽象类FileCopyUtils

Stream工具类，会手动关闭流

抽象类StreamUtils

Stream工具类，不会关闭流

抽象类StringUtils

String工具类

LIFECYCLE CALLBACK

- 硬编码（官方不推荐） 注解 xml
初始化后 类实现InitializingBean接口 @BEAN注解中的initMethod属性（Spring）或方法添加注解@PostConstruct（JSR-250） init-method属性
销毁前 类实现DisposableBean接口 @BEAN注解中的destroyMethod属性（Spring）或方法添加注解@PreDestroy（JSR-250） destroy-method属性

展开全文 >>

Git指令

菜鸟教程https://www.runoob.com/git/git-tutorial.html

初次安装后设置

设置用户名和邮箱

1
2
git config --global user.name <your_username>
git config --global user.email <your_email>

创建仓库

  • git init：在当前目录下创建仓库
  • git init <directory>：在指定目录下创建仓库
  • git clone <repo> ：将远程仓库克隆到当前目录下
  • git clone <repo> <directory>：将远程仓库克隆到指定目录中
  • git config --list：查看git配置信息
  • git config -e：编辑当前仓库的git配置
  • git config -e --global ：编辑git的全局配置

基本操作

分支管理

  • git branch：不带任何参数，列出所有本地分支
  • git branch <branchName>：以当前分支的最新提交创建新分支
  • git checkout <branchName>：切换到指定分支
  • git checkout -b <branchName>：创建新分支并立即切换到该分支
  • git branch -d <branchName>：删除指定分支（本地）（如果有未提交的文件，则会删除失败）
  • git branch -D <branchName>：强制删除指定分支（本地）
  • git merge <branchName>：将指定分支合并到当前分支

提交记录

  • git log：查看历史提交记录

展开全文 >>

Linux指令

ls

列出目录

  • -l: 详细信息。简写：ll
  • -a：列出所有节点，包含以.开头的
  • -h：显示文件大小的单位，利于人（humen）看
  • -t：按修改时间（time）排序，最新的排在最前
  • -S：按文件大小（Size）排序，最大的排在最前
  • -r：颠倒（reverse）排序

常用

  • grep
    • 直接命令形式：grep ‘123’ test.log在test.log文件中查找包含123的部分
    • 被动管道符形式：| grep xxx在管道符前面命令执行的结果中查找包含xxx的部分
    • | grep xxx：筛选处理结果中包含xxx的部分
    • | grep -v xxx：筛选处理结果中不包含xxx的部分
    • | grep -C 3 xxx：筛选处理结果中包含xxx的前后3行
    • | grep -A 3 -B 3 xxx：同上(可分别制定前后不同行数)
    • | grep -3 xxx：同上（简写形式）
    • | grep -A 3 xxx：筛选处理结果中包含xxx的后3行
    • | grep -B 3 xxx：筛选处理结果中包含xxx的前3行
  • open xxx：（Mac中）打开文件/文件夹

关闭进程

查询pid

  • ps -ef | grep xxx：查询xxx进程
  • lsof -i tcp:xxx：查询xxx端口

关闭端口

  • kill -9 xxx：强制关闭pid为xxx的进程

展开全文 >>

gRPC的Java端使用

介绍

gRPC简介

gRPC is a modern open source high performance Remote Procedure Call (RPC) framework that can run in any environment.

gRPC是一个现代、开源、高性能的远程调用（RPC） 框架，可以在任何环境中运行

gRPC

  • 适合场景

    gRPC非常适合以下场景：

    • 微服务 - gRPC设计为低延迟和高吞吐量通信。gRPC非常适用于效率至关重要的轻型微服务。
    • 点对点实时通信 - gRPC对双向流媒体提供出色的支持。gRPC服务可以实时推送消息而无需轮询。
    • 多语言混合开发环境 - gRPC工具支持所有流行的开发语言，使gRPC成为多语言开发环境的理想选择。
    • 网络受限环境 - 使用Protobuf（一种轻量级消息格式）序列化gRPC消息。gRPC消息始终小于等效的JSON消息。

  • 不建议使用场景

    在以下场景中，建议使用其他框架而不是gRPC：

    • 浏览器可访问的API - 浏览器不完全支持gRPC。gRPC-Web可以提供浏览器支持，但它有局限性并引入了服务器代理。
    • 广播实时通信 - gRPC支持通过流媒体进行实时通信，但不存在向已注册连接广播消息的概念。例如，在应该将新聊天消息发送到聊天室中的所有客户端的聊天室场景中，需要每个gRPC呼叫以单独地将新的聊天消息流传输到客户端。对于这种场景，SignalR是这种情况的有用框架。SignalR具有持久连接的概念和对广播消息的内置支持。
    • 进程间通信 - 进程必须承载HTTP/2服务才能接受传入的gRPC调用。对于Windows，进程间通信管道是一种快速，轻量级的通信方法。

Protocol Buffers

一种轻便、高效的结构化数据存储方式，与语言、平台无关

  • gRPC框架默认使用的数据交换格式
  • 文件名以.proto结尾
  • 字段类型包含常见的数字、字符串、布尔、枚举、数组
  • 每个字段需要一个数字标识符，定义好后不能改变。最小的标识号可以从1开始，最大到2^29 - 1, or 536,870,911。不可以使用其中的[19000－19999]的标识号， Protobuf协议实现中对这些进行了预留。如果非要在.proto文件中使用这些预留标识号，编译时就会报警

示例：

person.proto

1
2
3
4
5
message Person {
  int32 id = 1;
  string name = 2;
  bool is_married = 3;
}

gRPC的四种通信模式

  1. unary call 一元通信
  2. Server-side streaming RPC 服务端流式通信
  3. Client-side streaming RPC 客户端流式通信
  4. Bidirectional streaming RPC 双向流式通信

maven依赖

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
<dependencies>
  <dependency>
    <groupId>io.grpc</groupId>
    <artifactId>grpc-protobuf</artifactId>
    <version>${grpc.version}</version>
  </dependency>

  <dependency>
    <groupId>io.grpc</groupId>
    <artifactId>grpc-stub</artifactId>
    <version>${grpc.version}</version>
  </dependency>

  <dependency>
    <groupId>io.grpc</groupId>
    <artifactId>grpc-netty</artifactId>
    <version>${grpc.version}</version>
  </dependency>
</dependencies>

<build>
  <extensions>
    <extension>
      <groupId>kr.motd.maven</groupId>
      <artifactId>os-maven-plugin</artifactId>
      <version>1.6.2</version>
    </extension>
  </extensions>
  
  <plugins>
    <plugin>
      <groupId>org.xolstice.maven.plugins</groupId>
      <artifactId>protobuf-maven-plugin</artifactId>
      <version>0.6.1</version>
      <configuration>
        <protocArtifact>
          com.google.protobuf:protoc:3.19.2:exe:${os.detected.classifier}																		</protocArtifact>
        <pluginId>grpc-java</pluginId>
        <pluginArtifact>
          io.grpc:protoc-gen-grpc-java:1.45.1:exe:${os.detected.classifier}																	</pluginArtifact>
      </configuration>
      <executions>
        <execution>
          <goals>
            <goal>compile</goal>
            <goal>compile-custom</goal>
          </goals>
        </execution>
      </executions>
    </plugin>
  </plugins>
</build>

定义gRPC服务

定义proto文件

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
syntax = "proto3";

option java_package = "com.example.demo";
option java_multiple_files = true;

service Greeter {
  
  // unary call
  rpc SayHello (HelloRequest) returns (HelloReply) {}
  
  // server stream
  rpc SayHelloAgain (HelloRequest) returns (stream HelloReply) {}
}

message HelloRequest {
  string name = 1;
}

message HelloReply {
  string message = 1;
}

生成代码

截屏2022-05-16 14.28.34 截屏2022-05-16 14.25.53
  • compile: 生成proto文件
  • compile-custom: 生成gRPC文件

gRPC

服务端

  • 自己写一个类，继承GreeterGrpc.GreeterImplBase

    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
    public class GreeterService extends GreeterGrpc.GreeterImplBase {

        @Override
        public void sayHello(HelloRequest request, StreamObserver<HelloReply> responseObserver) {
         	  System.out.println(request.getName());
          	// 构造返回对象
            HelloReply helloReply = HelloReply.newBuilder()
                    .setMessage("okok")
                    .build();
            responseObserver.onNext(helloReply);
          	// 结束调用
            responseObserver.onCompleted();
        }

        @Override
        public void sayHelloAgain(HelloRequest request, StreamObserver<HelloReply> responseObserver) {
            System.out.println(request.getName());
            for (int i = 0; i < 10; i++) {
                HelloReply helloReply = HelloReply.newBuilder()
                        .setMessage("okok" + i)
                        .build();
                // 多次调用onNext()
                responseObserver.onNext(helloReply);
            }
            // 结束调用
            responseObserver.onCompleted();
        }
    }

  • 启动服务

    1
    2
    3
    4
    5
    6
    7
    8
    9
    public static void main(String[] args) throws IOException, InterruptedException {
        Server server = ServerBuilder.forPort(8527)
                .addService(new GreeterService())
                .build()
                .start();
        System.out.println("server started");
        System.out.println("==============");
        server.awaitTermination();
    }

客户端

使用stub调用进行远程调用

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
public class GreeterClient {

    public static void main(String[] args) {
        // 指定主机和端口
        ManagedChannel channel = ManagedChannelBuilder.forAddress("localhost", 8527)
                .usePlaintext()
                .build();
        GreeterGrpc.GreeterBlockingStub blockingStub = GreeterGrpc.newBlockingStub(channel);
				
      	// 构造请求对象
        HelloRequest helloRequest = HelloRequest.newBuilder()
                .setName("张三")
                .build();
      	// 远程调用，获取响应 
        HelloReply helloReply = blockingStub.sayHello(helloRequest);
        System.out.println(helloReply);
    }
}

展开全文 >>

Vim

查看软件信息

1
vim --version

三种模式

  • 普通模式
  • 输入模式
  • 命令模式

指令

移动

  • k：上（k代表king，比jack大）
  • j：下（代表jack）
  • h：左
  • l：右
  • gg：顶部
  • Shift + g：地底部
  • （命令模式下）: + 行号：直接跳转到指定行
  • w：跳到下个单词首部（word）
  • e：跳到下个单词尾部（end）
  • b：跳到上个单词首部（back）

插入

在普通模式下，键入：

  • i：在光标位置前输入（insert）
  • a：在光标位置后输入（append）
  • o：在光标位置下方新增一行（open a new line）
  • Shift + o：在光标位置上方新增一行

复制、粘贴、删除

  • yy：复制当前行（yank）
  • p：粘贴（paste）
  • 数字 + p：多次粘贴
  • dd：删除当前行（delete）
  • 数字 + dd：删除以当前行开始的多行
  • .：重复上一次操作
  • u：撤回上一次操作（undo）
  • Ctrl + r：取消上一次的撤回
  • dw：删除一个单词（delete word）
  • cw：改变一个单词（change word）（并进入编辑模式）
  • yw：复制一个单词（yank word）

搜索、替换

  • / + 搜索内容：搜索指定内容
    • 有多个结果时，n下一个，N上一个
  • :%s + /旧内容 + /新内容 + /g：全局替换指定内容（global）

行缩进

在普通模式下：

  • 命令>>将对当前行增加缩进
  • 命令<<则将对当前行减少缩进

配置vim显示行号和语法高亮

特别好

  1. 进入当前用户家目录

  2. 编辑.vimrc，首次创建前是没有这个文件的，没关系

    1
    vim .vimrc

  3. 添加内容：显示行号和语法高亮

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    "语法高亮"
    syntax on

    "显示行号"
    set nu

    "搜索词高亮"
    set hls
     
    "实时搜索" 
    set incsearch

    "tab键缩进为2格"
    set tabstop=2
     
    "行缩进为2格"
    set shiftwidth=2

  4. 保存后生效

展开全文 >>

Docker学习

镜像命令

1
2
3
4
5
6
7
8
9
10
11
12
13
14
# 列出本地的所有镜像
docker images

# 搜索dockerHub上的镜像
docker search 镜像名

# 从远程仓库中拉取镜像
docker pull 镜像名

# 按镜像名或哈希值删除一个或多个镜像，加-f强制删除
docker rmi 镜像名或id

# 删除本地的所有镜像
docker rmi $(docker images -qa)

容器命令

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
58
59
60
61
62
63
64
# 运行容器，交互式启动：-i（交互式）、-t（伪终端）
docker run -it 镜像id

# 运行容器，守护式启动
docker run -d 镜像id

# 在容器中退出并停止
exit

# 在容器退出但不停止
⌃+P+Q

# 重启容器
docker restart 容器id

# 停止容器
docker stop 容器id

# 强制停止容器
docker kill 容器id

# 删除已停止的单个容器
docker rm 容器id
# 删除多个容器
docker rm -f $(docker ps -aq)


# 查看正在运行的容器
docker ps
# 查看正在运行的容器+历史上运行过的容器
docker ps -a
# 查看最近创建的容器
docker ps -l
# 查看最近n次创建的容器
docker ps -n 3
# 静默查看，只显示容器编号
docker ps -q


# 查看日志：-t（显示时间戳）、-f（跟随最新的日志）、--tail n 显示最后n条
docker logs -tf --tail 3 容器id

# 查看容器内的进程
docker top 容器id

# 检查容器内的细节，以json字符串形式返回
docker inspect 容器id

# 进入正在运行的容器,
# 第一种，进入容器
docker attach 容器id
# 第二种，在容器中执行命令并将结果返回宿主机（隔山打牛），
# 例：docker exec 2b0a1908772c ls -l
# 例：docker exec -it 2b0a1908772c /bin/bash
docker exec -it 容器id bashShell


# 从容器拷贝文件到宿主机上
# 例：docker cp 2b0a1908772c:/home/hello.txt /Users/dongpengfei/desktop
docker cp 容器id:容器内路径 宿主机路径


# 提交镜像
docker commit -a="作者名" -m="描述" 容器id 镜像名:版本号

数据卷

1
2
3
4
5
6
7
# 启动时挂载数据卷
# 此处宿主机挂载目录为/Users/dongpengfei/dev/myHostVolume，容器挂载目录为/myContainerVolume
docker run -it -v /Users/dongpengfei/dev/myHostVolume:/myContainerVolume centos

# :ro（只读，容器内只可读不可写）
docker run -it -v /Users/dongpengfei/dev/myHostVolume:/myContainerVolume:ro centos

使用DockerFile创建数据卷

DockerFile：

1
2
3
4
FROM centos
VOLUME ["/containerVolume1","/containerVolume2"]
CMD echo "----------success1---------"
CMD /bin/bash

docker命令：

1
2
3
# （-f设置DockerFile文件路径，-t设置tag）
# 注意最后有一个英文点号！
docker build -f /Users/dongpengfei/dev/mydocker/DockerFile -t "zzyy/centos" .

数据卷容器

1
2
3
4
5
6
# 创建第一个容器
docker run -it --name dc01 zzyy/centos
# 使用第一个容器的数据卷创建第二个容器
docker run -it --name dc02 --volumes-from dc01 zzyy/centos

## dc01和dc02的数据卷会共享。数据卷的生命周期一直持续到没有容器使用位置

本地镜像推送阿里云仓库

1
2
3
4
5
6
7
8
9
# 1.在本地用容器提交镜像
docker commit -a zzyy -m "new centos with vim and ifconfig" 411ab1b82170 atguigu/mycentos:1.4

# 2.在阿里云上上创建一个仓库
# 3.将镜像推送到Registry
docker login --username=flya****nally registry.cn-chengdu.aliyuncs.com
docker tag 89f7e45fa5bb registry.cn-chengdu.aliyuncs.com/atguigu-docker-study/mycentos:1.4.1
docker push registry.cn-chengdu.aliyuncs.com/atguigu-docker-study/mycentos:1.4.1

安装mysql

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
# 1.拉取镜像，此处使用mac m1为arm架构，所以拉取的是mysql/mysql-server
docker pull mysql/mysql-server

# 2.启动容器（后台启动），此处取名叫docker-mysql，其实可以随意
docker run -d --name docker-mysql -p 3306:3306 mysql/mysql-server

# 3.查看一次性密码（例：此处为12#n63mig/Fr1fi:2.8VISNb?:K8%G:q）。这个密码只能使用一次，登录mysql后请立即修改密码！
docker logs mysql1 2>&1 | grep GENERATED

# 4.进入容器，登录mysql并修改root用户密码（此处设置为123456）
docker exec -it docker-mysql mysql -uroot -p
# 下面进入到了mysql中进行操作
mysql> ALTER USER 'root'@'localhost' IDENTIFIED BY '123456';

# 5.打开远程访问权限
mysql> use mysql;
mysql> update user set host = '%' where user = 'root';
# 刷新权限（千万别忘了！）
mysql> flush privileges;


# 题外话：将docker中的数据库备份到宿主机上
docker exec 8f33bdab475e sh -c 'exec mysqldump --all-databases -uroot -p123456' > /Users/dongpengfei/Desktop/dk-mysql-bak.sql

制作一个简单的springboot web项目镜像

  1. 创建springboot web工程，写一个简单接口用于调用测试

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    @Slf4j
    @RestController
    public class HelloController {

        @GetMapping("/")
        public String hello() {
            log.info("🤣 request GET '/hello'");
            return "🎵 hello from the other side ～";
        }
    }

  2. 使用maven插件打包（package），生成jar包

  3. 编写Dockerfile文件

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
       # 基础环境
       FROM openjdk:8-jdk-slim
       # 作者
       LABEL maintainer = fly
       
       # 复制jar包到容器中并重命名为app.jar
       COPY target/*.jar /app.jar
       # 启动命令：ENTRYPOINT或CMD
       ENTRYPOINT ["java", "-jar", "/app.jar"]


    4. 上传文件到linux服务器上，目录结构：

       ```sh
       /demo
       ├── Dockerfile
       └── target
           └── docker-test-0.0.1-SNAPSHOT.jar

  4. 构建镜像

    进入Dockerfile所在路径，输入命令：

    1
    docker build -t springboot-demo:v1.0 .

    构建完成。

    查看镜像：

    1
    docker images

展开全文 >>

搭建我的第一个hexo博客

官方文档：https://hexo.io/docs/

准备工作

  1. 安装git环境
  2. 安装node环境

快速开始

  1. 安装hexo

    1
    2
    3
    4
    # 安装
    npm install -g hexo-cli
    # 验证
    hexo -v

  2. 新建一个目录，用于存放工程文件。开始初始化

    1
    2
    3
    4
    5
    6
    # 我在当前用户目录下新建了一个blog目录，其实可以随意
    cd ~
    mkdir blog
    cd blog
    # 初始化hexo
    hexo init

  3. 启动，访问http://localhost:4000预览

    1
    2
    # 简写：hexo s 
    hexo server

新建一篇文章

  1. 新建文章

    1
    2
    # 简写：hexo n "我的第一篇文章"
    hexo new "我的第一篇文章"

    执行后在工程目录下的：source/_posts中会生成一个空的markdown文件：我的第一篇文章.md

  2. 编辑这个md文件，添加自己的内容，保存

  3. 生成

    1
    2
    3
    4
    # 清除之前生成的和缓存
    hexo clean
    # 简写：hexo g
    hexo generate

部署

这里演示部署到github上

  1. 在github中新建一个仓库。

    注意：仓库名一定要为：<当前github用户名>.github.io

  2. 在博客工程目录下安装git部署工具

    1
    npm install --save hexo-deployer-git

  3. 编辑工程根目录下的_config.yml配置文件，在文件最底部添加部署信息

    1
    2
    3
    4
    deploy:
      type: git
      repo: 第一步中新建的仓库的克隆地址
      branch: master

  4. 部署到远端

    1
    2
    # 简写：hexo d
    hexo deploy

    将会推送到github仓库。

    若配置文件中的repo是https地址，则需要输入github账号和密码。

    若配置文件中的repo是ssh地址，则会自动验证身份，无需操作

  5. 通过<当前github用户名>.github.io访问

进阶

更换皮肤

  1. 看中一款心怡的皮肤（这里举例yilia），将其克隆到博客工程的themes目录下

    1
    2
    cd ~/blog
    git clone https://github.com/litten/hexo-theme-yilia.git themes/yilia

  2. 修改配置文件_config.yml中的主题为yilia

    1
    theme: yilia

  3. 重新生成、部署

    1
    2
    3
    hexo clean
    hexo g
    hexo d

展开全文 >>

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

很惭愧<br><br>只做了一点微小的工作<br>谢谢大家