作者： 清朝云

共计 246 个字符，预计需要花费 1 分钟才能阅读完成。

CDN 是个好东西，但是开启 CDN 后，用户评论后显示的 ip 全是 cdn 节点的 ip。这样的话，如果需要显示评论归属地和运营商就变得毫无意义。

解决也很简单，只需要在 wp-config.php 文件加入以下代码：

// 解决获取不到用户真实ip问题
if(isset($_SERVER['HTTP_X_FORWARDED_FOR'])) {
    $list = explode(',',$_SERVER['HTTP_X_FORWARDED_FOR']);
    $_SERVER['REMOTE_ADDR'] = $list[0];
}

提醒：本文发布于458天前，文中所关联的信息可能已发生改变，请知悉！

共计 305 个字符，预计需要花费 1 分钟才能阅读完成。

最好根据该文档进行操作：https://github.com/nodesource/distributions

1. yum安装设置Node.js v16版本

curl --silent --location https://rpm.nodesource.com/setup_16.x | sudo bash

setup_16里16是版本号，可根据自己需要修改。

2. yum方式安装

sudo yum -y install nodejs

3. 其它参考：

以上命令安装不成功可执行：

sudo yum clean all

若本地存在多个nodesoucre，可以执行以下命令， 再重新yum安装命令。

sudo rm -fv /etc/yum.repos.d/nodesource*

提醒：本文发布于456天前，文中所关联的信息可能已发生改变，请知悉！

共计 603 个字符，预计需要花费 2 分钟才能阅读完成。

阿里开发手册里面强制规定，布尔类型的数据，无论是 boolean 还是 Boolean 都不准使用 isXXX 来命名，要理解为什么，首先要明确以下几点：

1. 对于非 boolean 类型的参数，getter 和 setter 方法命名的规范是以 get 和 set 开头

2. 对于 boolean 类型的参数，setter 方法是以 set 开头，但是 getter 方法命名的规范是以 is 开头

3. 包装类自动生成的 getter 和 setter 方法的名称都是以 get 和 set 开头

@Data
public class Car {

    private String brand = null;

    private int doors = 0;

    private boolean isUse  = true;
}

比如使用该实体类接受 json 参数，前端传参理论上应该是：

{ "brand" : "Mercedes", "doors" : 5, "isUse" : true }

但是实际使用就会报错，因为在反序列化过程中框架会把 isUse 字段当作 use，这里需要传递如下参数才能接收：

{ "brand" : "Mercedes", "doors" : 5, "use" : true }

但是如果使用包装类，传 isUse 就不会报错。所以，为了避免这种情况的发生，布尔类型的字段名称不要 is 开头。

如下：

@Data
public class Car {

    private String brand = null;

    private int doors = 0;

    private boolean use  = true;
}

提醒：本文发布于443天前，文中所关联的信息可能已发生改变，请知悉！

共计 6233 个字符，预计需要花费 16 分钟才能阅读完成。

一、 Read+Write注解

Jackson包含一组注解，这些注解会影响从 JSON 读取 Java 对象以及将 Java 对象写入 JSON，这些称为 Read + Write 注解。

1. @JsonIgnore

@JsonIgnore 用于告诉 Jackson 忽略 Java 对象的某个属性（字段）。 在将 JSON 读取到 Java 对象中以及将 Java 对象写入 JSON 时，都将忽略该属性。

public class PersonIgnore {

    @JsonIgnore
    public long  personId = 0;

    public String name = null;
}

在上面的类中，不会从 JSON 读取或写入 JSON 属性 personId。

2. @JsonIgnoreProperties

@JsonIgnoreProperties 注解用于指定要忽略的类的属性列表。 @JsonIgnoreProperties注解放置在类声明上方，而不是要忽略的各个属性（字段）上方。

@JsonIgnoreProperties({"firstName", "lastName"})
public class PersonIgnoreProperties {

    public long   personId = 0;

    public String  firstName = null;
    public String  lastName  = null;

}

属性 firstName 和 lastName 都将被忽略，因为它们的名称在类声明上方的@JsonIgnoreProperties 注解声明内列出。

3. @JsonIgnoreType

@JsonIgnoreType 注解用于将整个类型（类）标记为在使用该类型的任何地方都将被忽略。

public class PersonIgnoreType {

    @JsonIgnoreType
    public static class Address {
        public String streetName  = null;
        public String houseNumber = null;
        public String zipCode     = null;
        public String city        = null;
        public String country     = null;
    }

    public long    personId = 0;

    public String  name = null;

    public Address address = null;
}

所有 Address 实例将被忽略。

4. @JsonAutoDetect

@JsonAutoDetect 用于告诉 Jackson 在读写对象时包括非 public 修饰的属性。

@JsonAutoDetect(fieldVisibility = JsonAutoDetect.Visibility.ANY )
public class PersonAutoDetect {

    private long  personId = 123;
    public String name     = null;

}

JsonAutoDetect.Visibility 类包含与 Java 中的可见性级别匹配的常量，表示 ANY，DEFAULT，NON_PRIVATE，NONE，PROTECTED_AND_PRIVATE 和 PUBLIC_ONLY。

二、 Read注解

Jackson 包含一组注解，这些注解仅影响 Jackson 将 JSON 解析为对象的方式-意味着它们影响 Jackson 对 JSON 的读取。

1. @JsonSetter

@JsonSetter 用于告诉 Jackson，当将 JSON 读入对象时，应将此 setter 方法的名称与 JSON 数据中的属性名称匹配。 如果 Java 类内部使用的属性名称与 JSON 文件中使用的属性名称不同，这个注解就很有用了。

例如 json 数据为：

{
  "id"   : 1234,
  "name" : "John"
}

对应的 java 对象：

public class Person {

    private long   personId = 0;
    private String name     = null;

    public long getPersonId() { return this.personId; }
    @JsonSetter("id")
    public void setPersonId(long personId) { this.personId = personId; }

    public String getName() { return name; }
    public void setName(String name) { this.name = name; }
}

默认情况下，Jackson 无法将 id 属性从 JSON 对象映射到 Java 类的 personId 字段，所以需要使用 JsonSetter 注解指定注入 id 属性。

2. @JsonAnySetter

@JsonAnySetter 表示 Jackson 为 JSON 对象中所有无法识别的字段调用相同的 setter 方法。 无法识别是指尚未映射到 Java 对象中的属性或设置方法的所有字段。

现有如下 java 对象：

public class Bag {

    private Map<String, Object> properties = new HashMap<>();

    public void set(String fieldName, Object value){
        this.properties.put(fieldName, value);
    }

    public Object get(String fieldName){
        return this.properties.get(fieldName);
    }
}

需要接受的 json 数据为：

{
  "id"   : 1234,
  "name" : "John"
}

Jackson 无法直接将此 JSON 对象的 id 和 name 属性映射到 Bag 类，因为 Bag 类不包含任何公共字段或 setter 方法。

可以通过添加@JsonAnySetter 注解来告诉 Jackson 为所有无法识别的字段调用 set()方法，如下所示：

public class Bag {

    private Map<String, Object> properties = new HashMap<>();

    @JsonAnySetter
    public void set(String fieldName, Object value){
        this.properties.put(fieldName, value);
    }

    public Object get(String fieldName){
        return this.properties.get(fieldName);
    }
}

3. @JsonCreator

@JsonCreator 用于告诉 Jackson 该 Java 对象具有一个构造函数（“创建者”），该构造函数可以将 JSON 对象的字段与 Java 对象的字段进行匹配。

@JsonCreator 注解在无法使用 @JsonSetter 注解的情况下很有用。 例如，不可变对象没有任何设置方法，因此它们需要将其初始值注入到构造函数中。

public class PersonImmutable {

    private long   id   = 0;
    private String name = null;

    @JsonCreator
    public PersonImmutable(
            @JsonProperty("id")  long id,
            @JsonProperty("name") String name  ) {

        this.id = id;
        this.name = name;
    }
}

但是，仅凭在构造函数中添加 @JsonCreator 注解还不够。 还必须注解构造函数的参数，以告诉 Jackson 将 JSON 对象中的哪些字段传递给哪些构造函数参数。

所以在这种情况下，即使没有 set 方法也能够通过构造方法将如下 json 解析为 java 对象。

{
  "id"   : 1234,
  "name" : "John"
}

4. @JsonDeserialize

注解 @JsonDeserialize 用于为 Java 对象中给定的属性指定自定义反序列化器类。

例如，假设想优化布尔值 false 和 true 的在线格式，使其分别为 0 和 1。

public class PersonDeserialize {

    public long    id      = 0;
    public String  name    = null;

    @JsonDeserialize(using = OptimizedBooleanDeserializer.class)
    public boolean enabled = false;
}

OptimizedBooleanDeserializer 类如下：

public class OptimizedBooleanDeserializer
    extends JsonDeserializer<Boolean> {

    @Override
    public Boolean deserialize(JsonParser jsonParser,
            DeserializationContext deserializationContext) throws
        IOException, JsonProcessingException {

        String text = jsonParser.getText();
        if("0".equals(text)) return false;
        return true;
    }
}

三、Write注解

Jackson 还包含一组注解，这些注解可以影响 Jackson 将 Java 对象序列化（写入）到 JSON 的方式。

1. @JsonInclude

注解 @JsonInclude 告诉 Jackson 仅在某些情况下包括属性。 例如，仅当属性为非 null，非空或具有非默认值时，才应包括该属性。

@JsonInclude(JsonInclude.Include.NON_EMPTY)
public class PersonInclude {

    public long  personId = 0;
    public String name = null;

}

如果直接创建一个 PersonInclude 类，并将其序列化，那么将得到：

{"id":0}

2. @JsonGetter

@JsonGetter 注解用于告诉 Jackson，应该通过调用 getter 方法而不是通过直接字段访问来获取某个字段值。

public class PersonGetter {

    private long  personId = 0;

    @JsonGetter("id")
    public long personId() { return this.personId; }

    @JsonSetter("id")
    public void personId(long personId) { this.personId = personId; }

}

该 JSON 对象中 personId 的名称是 id。 生成的 JSON 对象如下所示：

{"id":0}

3. @JsonAnyGetter

@JsonAnyGetter 注解可以将 Map 用作要序列化为 JSON 的属性的容器。 这是在 Java 类中使用 @JsonAnyGetter 注解的示例：

public class PersonAnyGetter {

    private Map<String, Object> properties = new HashMap<>();

    @JsonAnyGetter
    public Map<String, Object> properties() {
        return properties;
    }
}

Jackson 将从 @JsonAnyGetter 注解的方法中获取返回的 Map，并将该 Map 中的每个键值对都视为一个属性。 换句话说，Map 中的所有键值对都将作为 PersonAnyGetter 对象的一部分序列化为 JSON。

注意，这种情况下，也会把 properties 属性给序列化。

4. @JsonPropertyOrder

@JsonPropertyOrder 可用于指定将Java对象的字段序列化为JSON的顺序。

@JsonPropertyOrder({"name", "personId"})
public class PersonPropertyOrder {

    public long  personId  = 0;
    public String name     = null;

}

通常，Jackson 会按照在类中找到的顺序序列化 PersonPropertyOrder 中的属性。 但是，@JsonPropertyOrder 注解指定了不同的顺序，在序列化的 JSON 输出中，name 属性将首先出现，personId 属性将随后出现。

5. @JsonRawValue

@JsonRawValue 注解告诉 Jackson 该属性值应直接写入 JSON 输出。 如果该属性是字符串，Jackson 通常会将值括在引号中，但是如果使用 @JsonRawValue 属性进行注解，Jackson 将不会这样做。

例如有以下对象需要序列化。

public class PersonRawValue {

    public long   personId = 0;

    @JsonRawValue
    public String address  =
            "{ \"street\" : \"Wall Street\", \"no\":1}";

}

如果不加 @JsonRawValue 注解，结果为：

{"personId":0,"address":"{ \"street\" : \"Wall Street\", \"no\":1}"}

如果加上注解，则结果为：

{"personId":0,"address":{ "street" : "Wall Street", "no":1}}

6. @JsonValue

@JsonValue告诉Jackson，Jackson不应该尝试序列化对象本身，而应在对象上调用将对象序列化为JSON字符串的方法。

请注意，Jackson 将在自定义序列化返回的 String 内转义任何引号，因此不能返回完整的 JSON 对象。 为此，应该改用 @JsonRawValue。

例如有以下 java 对象：

public class PersonValue {

    public long   personId = 0;
    public String name = null;

    @JsonValue
    public String toJson(){
        return this.personId + "," + this.name;
    }

}

序列化后的结果为：

"0,null"

引号由 Jackson 添加。 请记住，对象返回的值字符串中的所有引号均会转义。

7. @JsonSerialize

@JsonSerialize 注解用于为Java对象中的字段指定自定义序列化程序。

public class PersonSerializer {

    public long   personId = 0;
    public String name     = "John";

    @JsonSerialize(using = OptimizedBooleanSerializer.class)
    public boolean enabled = false;
}

OptimizedBooleanSerializer 类如下：

public class OptimizedBooleanSerializer extends JsonSerializer<Boolean> {

    @Override
    public void serialize(Boolean aBoolean, JsonGenerator jsonGenerator, 
        SerializerProvider serializerProvider) 
    throws IOException, JsonProcessingException {

        if(aBoolean){
            jsonGenerator.writeNumber(1);
        } else {
            jsonGenerator.writeNumber(0);
        }
    }
}

提醒：本文发布于442天前，文中所关联的信息可能已发生改变，请知悉！

共计 3520 个字符，预计需要花费 9 分钟才能阅读完成。

项目加了鉴权以后，调试会变得比较麻烦，因为 token 随时可能失效，每次都要手动调用登录接口重新设置 token 比较麻烦。

好在大部分接口调试工具都可以配置前置脚本，比如在 postman 和 apifox 中可以设置如下前置脚本进行 token 的获取，设置为环境变量 ACCESS_TOKEN，然后在 Auth 引用变量即可。

/>

相关环境变量，这里设置的是每个环境自己的环境变量，而不是全局变量。

/>

以下为本人在具体项目中根据官方示例修改过的脚本，具体链接：https://apifox.com/help/best-practices/how-to-handle-auth

// 这里存在token失效的可能，所以调用一个需要token的接口来检查，检查失败则重新设置token
function accessTokenCheck(accessToken){

  const baseUrl = pm.environment.get("SYSTEM_BASEURL");

  const checkRequest = {
    url: baseUrl + "/auth/current/user",
    method: "POST",
    // 这里根据自己需要
    header: {
      "Authorization": "Bearer " + accessToken
    }
  };

  pm.sendRequest(checkRequest, function(err, res) {
    if (err) {
      console.log(err);
    } else {
      const jsonData = res.json();
      if(jsonData.code != 200){
        console.log("token失效，重新获取token");
        sendLoginRequest();
      }
    }
  });
}

function sendLoginRequest() {
  // 获取系统服务的Url地址，如果只是通过官方获取前置url有可能请求不到获取token接口
  const baseUrl = pm.environment.get("SYSTEM_BASEURL");

  // 登录用户名，这里从环境变量 LOGIN_USERNAME 获取，也可以写死（但是不建议）
  const username = pm.environment.get("LOGIN_USERNAME");

  // 登录密码，这里从环境变量 LOGIN_PASSWORD 获取，也可以写死（但是不建议）
  const password = pm.environment.get("LOGIN_PASSWORD");

  // 构造一个 POST 请求
  const loginRequest = {
    url: baseUrl + "/auth/login",
    method: "POST",
    header: {
      "Content-Type": "application/json"
    },
    body: {
      mode: 'raw', // 此处为 raw
      raw: JSON.stringify({ 
        "username": username, 
        "password": password 
      }), // 序列化后的 json 字符串
    }
  };

  // 请求成功则设置token
  pm.sendRequest(loginRequest, function(err, res) {
    if (err) {
      console.log(err);
    } else {
      const jsonData = res.json();
      // 将 accessToken 写入环境变量 ACCESS_TOKEN
      if (jsonData.data && jsonData.data.access_token) {
        pm.environment.set("ACCESS_TOKEN", jsonData.data.access_token);
      } else {
        console.log("Access token 不存在");
      }
    }
  });
}

// 获取环境变量里的 ACCESS_TOKEN
const accessToken = pm.environment.get("ACCESS_TOKEN");
// 开始校验
accessTokenCheck(accessToken);

官方示例：

// 定义发送登录接口请求方法
function sendLoginRequest() {
  // 获取环境里的 前置 URL
  const baseUrl = pm.request.getBaseUrl();

  // 登录用户名，这里从环境变量 LOGIN_USERNAME 获取，也可以写死（但是不建议）
  const username = pm.environment.get("LOGIN_USERNAME");

  // 登录密码，这里从环境变量 LOGIN_PASSWORD 获取，也可以写死（但是不建议）
  const password = pm.environment.get("LOGIN_PASSWORD");

  // 构造一个 POST x-www-form-urlencoded 格式请求。这里需要改成你们实际登录接口的请求参数。
  const loginRequest = {
    url: baseUrl + "/api/v1/login",
    method: "POST",
    // body 为 x-www-form-urlencoded 格式
    body: {
      mode: "urlencoded", // 此处为 urlencoded
      // 此处为 urlencoded
      urlencoded: [
        { key: "account", value: "apifox" },
        { key: "password", value: "123456" },
      ],
    },
    /*
    // body 为 form-data 格式
    body: {
      mode: 'formdata', // 此处为 formdata
      // 此处为 formdata
      formdata: [
        { key: 'account', value: 'apifox' },
        { key: 'password', value: '123456' }
      ]
    }

    // body 为 json 格式
    header: {
      "Content-Type": "application/json", // 注意：header 需要加上 Content-Type
    },
    body: {
      mode: 'raw',// 此处为 raw
      raw: JSON.stringify({ account: 'apifox', password:'123456' }), // 序列化后的 json 字符串
    }

    // body 为 raw 或 json 格式
    body: {
      mode: 'raw',
      raw: '此处为 body 内容',
    }
    */
  };

  // 发送请求。
  // pm.sendrequest 参考文档: https://apifox.com/help/app/scripts/api-references/pm-reference/#pm-sendrequest
  pm.sendRequest(loginRequest, function(err, res) {
    if (err) {
      console.log(err);
    } else {
      // 读取接口返回的 json 数据。
      // 如果你的 token 信息是存放在 cookie 的，可以使用 res.cookies.get('token') 方式获取。
      // cookies 参考文档：https://apifox.com/help/app/scripts/api-references/pm-reference/#pm-cookies
      const jsonData = res.json();
      // 将 accessToken 写入环境变量 ACCESS_TOKEN
      pm.environment.set("ACCESS_TOKEN", jsonData.data.accessToken);
      // 将 accessTokenExpires 过期时间写入环境变量 ACCESS_TOKEN_EXPIRES
      pm.environment.set(
        "ACCESS_TOKEN_EXPIRES",
        jsonData.data.accessTokenExpires
      );
    }
  });
}

// 获取环境变量里的 ACCESS_TOKEN
const accessToken = pm.environment.get("ACCESS_TOKEN");

// 获取环境变量里的 ACCESS_TOKEN_EXPIRES
const accessTokenExpires = pm.environment.get("ACCESS_TOKEN_EXPIRES");

// 如 ACCESS_TOKEN 没有值，或 ACCESS_TOKEN_EXPIRES 已过期，则执行发送登录接口请求
if (
  !accessToken ||
  (accessTokenExpires && new Date(accessTokenExpires) <= new Date())
) {
  sendLoginRequest();
}

提醒：本文发布于440天前，文中所关联的信息可能已发生改变，请知悉！

共计 390 个字符，预计需要花费 1 分钟才能阅读完成。

1. 【TypeScript】JSX 元素隐式具有类型 “any“，因为不存在接口 “JSX.IntrinsicElements“。ts(7026)

{
  "compilerOptions": {
    "jsx": "preserve",
    "jsxImportSource": "vue",
        // ...
  }
}

vue 大于等于 3.4 看此链接：https://vuejs.org/guide/extras/render-function.html#jsx-type-inference

2. Cannot find module … or its corresponding type declarations.（ts2307）

vscode 中快捷键 ctrl + shift + p，搜索 Select TypeScript Version，选择 Use WorkspaceVersion 选项，然后重启 vscode。

这里需要先执行 pnpm install 才能进行选择。

共计 662 个字符，预计需要花费 2 分钟才能阅读完成。

1. syncing: opening temp file: open xxx: permission denied

这种是经典的权限问题。可以将需要文件夹的权限修改为容器内用户可操作的权限。

或者以 root 用户运行容器：

services:
  syncthing:
    image: syncthing/syncthing:latest
    container_name: syncthing
    ports:
      - 8384:8384
      - 22000:22000/tcp
      - 22000:22000/udp
      - 21027:21027/udp
    environment:
      - PUID=0
      - PGID=0
    volumes:
      - /home/docker/syncthing/:/var/syncthing
      - /home/docker/:/home/docker/
    restart: unless-stopped

2. syncing: delete dir: directory has been deleted on a remote device but is not empty; the contents are probably ignored on that remote device, but not locally

由于设备 1 忽略模式忽略了文件夹 A 下的某个文件 B，此时设备 1 删除了 A 文件夹，当然文件夹内的文件都会一起删除。syncthing 同步到设备 2 时会先删除文件夹 A 下的文件，然后再删除文件夹 A，这里删除 A 时就出问题了，因为此时设备 2 下面的文件 B 没有删除，所以就会导致设备 2 不能删除文件夹 A。

解决方法很简答，直接去设备 2 把 文件 B 删除，就可以正常同步了。

共计 1327 个字符，预计需要花费 4 分钟才能阅读完成。

在 Go 1.18 引入的多模块工作区（Workspace）功能使我们可以在一个工作区中同时使用多个模块，这对开发大型项目或需要同时处理多个模块依赖的项目非常有帮助。

下面是一个简单使用多模块工作区的案例：

1. 创建主目录

首先创建主目录：

mkdir myworkspace
cd myworkspace

2. 创建第一个模块

在 myworkspace 文件夹下运行命令：

mkdir mod1
cd mod1
go mod init example.com/mod1

在 mod1 下新建 hello.go文件：

package mod1

import "fmt"

func Hello() {
    fmt.Println("Hello from mod1!")
}

3. 创建第二个模块

在 myworkspace 文件夹下运行命令：

mkdir mod2
cd mod2
go mod init example.com/mod2

在 mod2 下新建 main.go文件：

package main

import "example.com/mod1"

func main() {
    mod1.Hello()
}

4. 创建go.work文件

可以使用 go work 命令来创建一个工作区文件 go.work，将多个模块纳入同一工作区中。在 myworkspace 目录下执行以下命令：

# 初始化工作区
go work init ./mod1 ./mod2

此命令会在 myworkspace 目录下生成一个 go.work 文件，内容如下：

go 1.18

use (
    ./mod1
    ./mod2
)

这个 go.work 文件指定了工作区包含的模块目录 mod1 和 mod2。

5. 运行代码

在 myworkspace/mod2 目录下执行如下命令：

go run main.go

6. 引用并修改第三方库

在 myworkspace 下执行如下命令：

git clone https://go.googlesource.com/example

这里是将第三方的代码下载到本地，通过 go work 将其添加到工作区：

go work use ./example/hello

这里不使用 go work use ./example 的原因是 go work use 命令要求提供的是 Go 模块的根目录，myworkspace/example/hello 是一个 Go 模块的根目录（它包含自己的 go.mod 文件），所以它是一个独立的模块，即使 myworkspace/example 也有 go.mod 文件，它也不再属于上层模块的范围。

在 myworkspace/example/hello/reverse 目录下创建 int.go 文件：

package reverse

import "strconv"

// Int 返回整数的十进制反转值。
func Int(i int) int {
    i, _ = strconv.Atoi(String(strconv.Itoa(i)))
    return i
}

修改 myworkspace/mod2/main.go 文件：

package main

import (
    "fmt"
    "golang.org/x/example/hello/reverse"
)

func main() {
    fmt.Println(reverse.String("Hello"), reverse.Int(24601))
}

在 myworkspace/mod2 下运行如下命令：

go run main.go