```xml
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">

<mapper namespace="com.demo.dao.DemoDao">
    <select></select>
    <insert></insert>
    <update></update>
    <delete></delete>
</mapper>
```

Mybatis的xml文档模板

## 简介

对于大火ChatGPT，个人感觉在有些问题上，他看起来很厉害，但在另一些问题上，他好像总是给出一些看起来很对的错误结论。

本文以ChatGPT来讨论`@RequiredArgsConstructor(onConstructor_ = @Autowired)`为例，看看他是有多么的  **能说会道** ！



## 全部讨论记录

- 其中可能有部分错别字出现，但并未影响讨论结果。

--- 

> 问：@RequiredArgsConstructor(onConstructor\_ = @Autowired) 为什么onConstructor后边要下\_

答：`onConstructor_` 是 Lombok 提供的一个注解属性，用于指定构造函数参数的赋值顺序。`@RequiredArgsConstructor` 注解会自动生成一个包含所有 `@NonNull` 注解的成员变量的构造函数，但这个构造函数参数的顺序是按照成员变量在类中声明的顺序。如果需要自定义构造函数参数的赋值顺序，则可以使用 `onConstructor_` 属性来指定。

在 `@RequiredArgsConstructor` 中使用 `onConstructor_` 属性时，需要在属性名称后面加上下划线，以避免与 Java 关键字冲突。所以，`onConstructor_` 后面要加下划线。

---

> 问：java中由onConstructor关键字吗？

答： Java中并没有`onConstructor`这个关键字。

`@RequiredArgsConstructor(onConstructor_ = @Autowired)`这行代码是使用了Lombok的注解处理器。其中`@RequiredArgsConstructor`是Lombok中的一个注解，可以自动为类中的非空final字段生成对应的构造方法。在这里，`onConstructor_`是一个Lombok注解参数，用来表示对构造方法进行自定义处理，其中`@Autowired`表示自动注入。通过这种方式，可以简化Java代码，减少一些重复性的劳动。

---

> 问：@RequiredArgsConstructor(onConstructor\_ = @Autowired) 和 @RequiredArgsConstructor(onConstructor = @Autowired) 哪个是正确的写法？为什么？

答：在 Lombok 中，使用 `onConstructor_` 和 `onConstructor` 是等效的，都是用来指定构造函数上的注解，用于注入依赖。不同之处在于，`onConstructor_` 是一个废弃的 API，Lombok 推荐使用 `onConstructor` 来指定构造函数上的注解。

所以，在使用 Lombok 时，建议使用 `@RequiredArgsConstructor(onConstructor = @Autowired)` 的写法。

---

> 问：`@RequiredArgsConstructor(onConstructor = @Autowired)`写法会报错：Incompatible types. Found: 'org.springframework.beans.factory.annotation.Autowired', required: 'lombok.RequiredArgsConstructor.AnyAnnotation\[\]'

答：`@RequiredArgsConstructor(onConstructor = @Autowired)`写法会报错，是因为 `@RequiredArgsConstructor` 注解中的 `onConstructor` 属性需要传入 `lombok.RequiredArgsConstructor.AnyAnnotation[]` 类型的参数，而 `@Autowired` 注解并不是该类型。

正确的写法应该是 `@RequiredArgsConstructor(onConstructor_ = @Autowired.class)`，其中的 `onConstructor_` 属性用于指定构造函数注入依赖时使用的注解。同时要注意加上 `.class` 来指定注解类型。

---

> 问：@RequiredArgsConstructor(onConstructor\_ = @Autowired)才可以

答：是的，正确的写法是 `@RequiredArgsConstructor(onConstructor_ = @Autowired)`，其中 `onConstructor_` 表示使用下划线语法来避免与 `lombok` 中的其他注解发生冲突。

---

> 问：举个例子，onConstructor和谁有可能冲突

答：`onConstructor` 可能会与 Lombok 中的 `@AllArgsConstructor(onConstructor = @__({@Deprecated}))` 冲突。这是因为它们都使用了 `onConstructor` 参数。

如果您同时使用了 `@AllArgsConstructor` 和 `@RequiredArgsConstructor`，并想在 `@AllArgsConstructor` 中使用 `onConstructor` 参数，那么您可以将 `@AllArgsConstructor` 作为主要注解，并在其中设置 `@RequiredArgsConstructor` 的 `staticName` 属性。例如：

java

```java
@AllArgsConstructor(onConstructor = @__(@Autowired), staticName = "of")
@RequiredArgsConstructor
public class MyClass {
    // ...
}
```

这将保留 `@AllArgsConstructor` 的 `onConstructor` 参数，同时在 `@RequiredArgsConstructor` 中使用默认设置。同时，您可以使用 `MyClass.of(...)` 作为静态构造函数来创建对象。

---

> 问：听不懂

答：让我们先来看一个例子：

java

```java
public class MyClass {
    private String name;
    private int age;

    public MyClass(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public MyClass(int age, String name) {
        this.name = name;
        this.age = age;
    }
}
```

这是一个简单的 Java 类，它有两个构造方法，一个是按照 `name` 和 `age` 的顺序初始化，另一个是按照 `age` 和 `name` 的顺序初始化。这两个构造方法的参数列表是不同的，但是它们的名字是相同的。这种情况下，如果我们使用 `@RequiredArgsConstructor(onConstructor = @Autowired)` 来生成构造方法，会发生什么呢？答案是，它会报错，因为 `@Autowired` 的作用是让 Spring 自动注入依赖，而它只能用在方法上，所以它和构造方法同名会发生冲突。

为了避免这种冲突，Lombok 使用了一个下划线的方式，让我们可以在注解上指定一个别名来避免和其他注解发生冲突。在上面的例子中，如果我们使用 `@RequiredArgsConstructor(onConstructor_ = @Autowired)`，就不会发生冲突了。

---

问：@RequiredArgsConstructor的作用

答：`@RequiredArgsConstructor` 是 Lombok 提供的注解，它可以自动为类生成一个包含常量或 final 属性的构造方法，从而避免了手写构造方法的麻烦。

通常情况下，如果一个 Java 类中有很多的成员变量需要赋值，我们需要手动编写构造函数。而使用 `@RequiredArgsConstructor` 可以省去这些手动编写构造函数的过程。

例如，下面的代码是手动编写的构造函数：

java

```java
public class MyClass {
    private final String field1;
    private final int field2;
    private final double field3;

    public MyClass(String field1, int field2, double field3) {
        this.field1 = field1;
        this.field2 = field2;
        this.field3 = field3;
    }
}
```

使用 `@RequiredArgsConstructor` 后，可以省去构造函数的编写：

java

```java
@RequiredArgsConstructor
public class MyClass {
    private final String field1;
    private final int field2;
    private final double field3;
}
```

Lombok 会在编译期自动生成构造函数的代码。

`@RequiredArgsConstructor` 还有一些其他的参数，可以控制自动生成的构造函数的一些特性，比如是否包含某些字段、是否加上访问修饰符、是否生成一个带参数的 static 构造函数等。

---

> 问：我还是没有明白使用onConstructor\_和onConstructor的区别

答：好的，让我再进一步解释一下。

`@RequiredArgsConstructor(onConstructor = @Autowired)` 和 `@RequiredArgsConstructor(onConstructor_ = @Autowired)` 在实现上没有什么区别，它们都会自动生成一个带有 `@Autowired` 注解的构造函数。

区别在于，`@RequiredArgsConstructor(onConstructor_ = @Autowired)` 基于 Lombok 的一个特性：允许使用 `_` 来避免在生成的构造函数中使用参数名作为变量名，因为参数名可能会与字段名冲突。这种情况下，使用 `onConstructor_` 可以避免命名冲突。

这个 `_` 只是一个惯例，实际上你可以用任何不会和合法的 Java 变量名冲突的字符来代替它，比如 `onConstructorX`。

因此，如果你的代码中不需要使用 `_` 来避免命名冲突，那么你可以使用 `@RequiredArgsConstructor(onConstructor = @Autowired)`，否则你需要使用 `@RequiredArgsConstructor(onConstructor_ = @Autowired)`。

希望这次解释更加清晰明了。

---

> 问：能给我个示例说明吗？它避免了谁和谁的命名冲突？

答：可以看下面这个示例：

java

```java
import lombok.AllArgsConstructor;
import lombok.NoArgsConstructor;
import lombok.RequiredArgsConstructor;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Component
@RequiredArgsConstructor(onConstructor_ = {@Autowired})
public class MyService {
    private final MyRepository myRepository;
    private final MyHelper myHelper;
}

@NoArgsConstructor
@AllArgsConstructor
class MyRepository {
    private String name;
}

@NoArgsConstructor
@AllArgsConstructor
class MyHelper {
    private String name;
}
```

这里定义了一个`MyService`类，它依赖于`MyRepository`和`MyHelper`两个类，这两个类都有无参构造器和有参构造器，而它们的有参构造器需要通过Spring容器注入相应的依赖。

使用`@RequiredArgsConstructor(onConstructor_ = {@Autowired})`可以为`MyService`类自动生成一个带有两个参数的构造器，并且使用`@Autowired`注解来将依赖注入到构造器中。同时，由于`MyRepository`和`MyHelper`类已经有了自己的构造器，使用`onConstructor_`可以避免命名冲突，确保注入的构造器和需要注入的构造器不会混淆。

如果使用`onConstructor`，则可能会发生命名冲突，因为需要注入的构造器和`MyRepository`和`MyHelper`已经有的构造器都需要命名为`MyRepository`和`MyHelper`。

---

> 问：在你的示例中，MyService 类中的构造器名字不应该是\`MyService\`吗？为什么可能与 MyRepository和MyHelper 冲突

答：非常抱歉，是我的笔误。MyService 的构造器名字应该是 `MyService`，因为它与类名相同。下面我将进行更正和说明：

`@RequiredArgsConstructor` 注解生成的构造器参数名默认是根据字段名生成的，如果有多个字段的类型相同，参数名也就相同了。这就有可能导致在构造器中命名冲突，因为不能有重复的参数名。

例如，假设我们有以下类：

java

```java
@RequiredArgsConstructor(onConstructor_ = {@Autowired})
public class MyService {
    private final MyRepository myRepository;
    private final MyHelper myHelper;
    private final MyHelper anotherHelper;
}
```

这个类有三个字段，其中 `myHelper` 和 `anotherHelper` 的类型相同，都是 `MyHelper`。如果我们使用默认的构造器生成方式，会生成以下构造器：

java

```java
public MyService(MyRepository myRepository, MyHelper myHelper, MyHelper myHelper1) {
    this.myRepository = myRepository;
    this.myHelper = myHelper;
    this.anotherHelper = myHelper1;
}
```

这里就会有命名冲突，因为两个参数都叫做 `myHelper`。但是，如果我们使用 `onConstructor_` 属性和 `@Autowired` 注解，就可以给这些参数指定不同的名字，避免命名冲突：

java

```java
@RequiredArgsConstructor(onConstructor_ = {@Autowired})
public class MyService {
    private final MyRepository myRepository;
    private final MyHelper myHelper;
    private final MyHelper anotherHelper;
    
    public MyService(MyRepository myRepository, @Qualifier("myHelper") MyHelper myHelper, @Qualifier("anotherHelper") MyHelper anotherHelper) {
        this.myRepository = myRepository;
        this.myHelper = myHelper;
        this.anotherHelper = anotherHelper;
    }
}
```

这里使用了 `@Qualifier` 注解来为参数指定了不同的名字，从而避免了命名冲突。

---

> 问：我觉得你说的不对，起码没有说服我

答：非常抱歉我的解释没有让您明白。我再次尝试解释一下。

在Java中，我们可以使用多个构造函数来创建类的对象。如果我们使用`@RequiredArgsConstructor`注解来自动生成一个构造函数，那么这个构造函数的名称将与类名相同。但是，如果我们在同一个类中使用多个`@RequiredArgsConstructor`注解来自动生成多个构造函数，那么所有这些构造函数的名称将相同，这就可能导致冲突。

为了避免这种冲突，Lombok允许我们使用`onConstructor_`参数来指定一个前缀，它将与构造函数名称组合在一起。例如，如果我们在`MyService`类中使用`@RequiredArgsConstructor(onConstructor_=@Autowired)`注解来生成一个构造函数，那么它的名称将是`MyService_autowired`，这将避免与其他使用`@RequiredArgsConstructor`注解生成的构造函数名称相冲突。

相反，如果我们使用`onConstructor`参数而不是`onConstructor_`，那么Lombok将使用与类名相同的名称作为构造函数名称，这将可能导致命名冲突。

希望这次解释能够让您理解。如果您还有任何疑问，请随时询问。

---

> 问：在源码注释中有说明：Any annotations listed here are put on the generated constructor. The syntax for this feature depends on JDK version (nothing we can do about that; it's to work around javac bugs). 这是什么意思？

答：这段注释的意思是，`@RequiredArgsConstructor`注解会将指定的注解放在生成的构造函数上。不同的JDK版本可能有不同的语法要求，这是为了解决javac的一些bug而采取的措施。具体而言，这是因为不同的JDK版本对于注解处理器有不同的实现方式，有些JDK版本会在编译时将注解信息丢失，因此使用`onConstructor`或`onConstructor_`指定注解的语法可能有所不同。

---

> 问：from JDK8: @RequiredArgsConstructor(onConstructor\_={@AnnotationsGohere}) // note the underscore after onConstructor. 这是不是说明JDK语法规定必须这么写，而不是你说的规避命名冲突？

答：您说得对，我之前的解释不是很准确。实际上，`@RequiredArgsConstructor(onConstructor_ = @Autowired)` 中的下划线是 Lombok 的语法规则，而不是 JDK 的规定，是用来规避命名冲突的。因此，在使用 `onConstructor_` 时，必须在参数列表中加上下划线，而不能直接使用 `onConstructor`。

对于 Lombok 的语法规则，它们的语法和行为可能会受到 JDK 版本的影响，具体可以参考 Lombok 的文档。

---

> 问：注释中不是说这是由于javac的bug才必须这么写吗

答：是的，Lombok 官方文档中的注释说明了这个问题是由于 javac 的 bug 引起的，所以才需要使用 `onConstructor_` 而不是 `onConstructor`。在 JDK 8 及之前的版本中，当使用 `onConstructor` 时，由于 javac 的 bug，生成的代码中的注解可能会丢失，所以需要使用 `onConstructor_` 来指定注解。而在 JDK 9 之后，这个问题已经被修复了，使用 `onConstructor` 也可以正确生成代码。

## 总结

经过漫长的讨论，终于得到了想要的答案，也就是最后一问ChatGPT给出的结果：

> 在 JDK 8 及之前的版本中，当使用 onConstructor 时，由于 javac 的 bug，生成的代码中的注解可能会丢失，所以需要使用 onConstructor_ 来指定注解。而在 JDK 9 之后，这个问题已经被修复了，使用 onConstructor 也可以正确生成代码。

但是好像并不是ChatGPT给出的呀？看起来是我们自己发现的结果并告诉了他，他才像恍然大悟一样给出了一连串正确答案。。。

能说会道ChatGPT：讨论Lombok的onConstructor_为什么要有_

## 简介

Gradle作为项目构建工具，有很多与Maven相同功能，其中依赖管理是比较重要的项。

本次就来学习使用Gradle引入相关依赖。



## 回顾

上一篇文章【[Gradle学习-创建Springboot项目](https://oldmoon.top/post/67)】中，学习了使用不同的方式搭建Gradle-springboot项目，本片文章将在上篇的基础上，讲解Gradle的重要功能：**依赖管理**，

## dependencies

> 简述：在 Gradle 中，`dependencies` 配置项用于指定项目所依赖的外部库或模块。
> 
> 官方文档：[DependencyHandler](https://docs.gradle.org/current/dsl/org.gradle.api.artifacts.dsl.DependencyHandler.html)

### 基本语法

dependencies 配置项中可以包含多个依赖声明，每个依赖声明都可以指定依赖的库或模块的名称、版本、以及依赖的类型和范围。依赖声明的格式如下：

```groovy
implementation 'group:name:version'
```

其中，implementation：表示依赖库需要在编译和运行时都可用；group 表示依赖库所属的组，name 表示依赖库的名称，version 表示依赖库的版本号。Gradle 支持使用通配符来指定版本号，例如：

```groovy
implementation 'group:name:1.+'
```

这表示依赖库的版本号是以 1 开头的任意版本。

### 其他用法

除了上述基本语法格式，还可以使用以下格式来指定特殊的依赖项：

```groovy
implementation files('libs/foo.jar')  // 从本地文件系统中引入 jar 包
implementation project(':mylibrary')  // 引入另一个 Gradle 项目（多模块项目时常用）
```

### 关键字

上面的用法都是使用的`implementation`关键字，使用该关键字引入的依赖表示需要在编译和运行时都可用，除此之外还有其他关键字，按依赖类型和依赖范围划分如下：

#### 依赖类型

- implementation：表示依赖库需要在编译和运行时都可用；
- api：表示依赖库需要在编译时可用，但不一定需要在运行时可用；
- runtimeOnly：表示依赖库只需要在运行时可用，不需要在编译时可用；
- testImplementation：表示依赖库只需要在测试代码编译和运行时可用；
- testRuntimeOnly：表示依赖库只需要在测试代码运行时可用。

#### 依赖范围

- compileOnly：表示依赖库不会被打包到最终的构建结果中，但可以在编译时使用；
- annotationProcessor：表示依赖库只用于编译期的注解处理；
- runtimeOnly：表示依赖库只需要在运行时可用，不需要在编译时可用；
- testCompileOnly：表示依赖库只会被用于测试代码的编译，不会被打包到最终的构建结果中；
- testRuntimeOnly：表示依赖库只需要在测试代码运行时可用。

### 依赖传递

引入的依赖可以配置其传递性，Maven中也存在响应配置，Gradle中的写法如下：

```groovy
implementation ('group:name:version') {
    transitive = true  // 允许传递依赖（默认值），false:禁止传递依赖
}
```

## 示例

上一篇文章创建好了springboot项目，如果你启动测试会发现，启动虽然成功，但立即自动结束了，这是因为没有web服务的相关依赖，导致其没有作为web服务器从而一直保持运行。

本示例为：使用`implementation`引入`spring-boot-starter-web`，并编写一个 http 接口用于测试。

### 引入依赖

修改`build.gradle`文件中的`dependencis`如下：

```groovy
dependencies {
	implementation 'org.springframework.boot:spring-boot-starter',
			'org.springframework.boot:spring-boot-starter-web'

	testImplementation 'org.springframework.boot:spring-boot-starter-test'
}
```

> 其中多个依赖可以用`,`间隔，使用一个`implementation`即可，等价于下面的配置：
> 
> ```groovy
> dependencies {
> 	implementation 'org.springframework.boot:spring-boot-starter'
> 	implementation 'org.springframework.boot:spring-boot-starter-web'
> 
> 	testImplementation 'org.springframework.boot:spring-boot-starter-test'
> }
> ```

修改后刷新依赖（上一篇文章在项目初始化时有讲到），如果使用`IDEA`，在`build.gradle`文件修改后，右上角会自动出现刷新提示按钮，点击即可刷新。

#### 拓展

细心的朋友可以发现，`implementation 'org.springframework.boot:spring-boot-starter'`与上面讲到的基本语法有所区别，`org.springframework.boot`是group，`spring-boot-starter`是name，那么version 去哪了？

答案是：**省略了**

但需要注意的是，**并不是所有依赖项都可以省略版本号**，这里可以省略version版本号的编写，是因为在`plugins`中引入了相关插件：`org.springframework.boot`和`io.spring.dependency-management`，这些插件中有一个重要的作用，就是维护了`springframeword`众多依赖的版本。

顾名思义`dependency-management`就是依赖管理的意思，如果你的某个依赖没有被这些插件所维护管理，那么引入那个依赖就必须填写版本号，否则会报错！

### 编写代码

1. 编写TestController

创建controller包，并创建`TestController`类，编写代码如下：

```java
package com.example.controller;

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

/**
 * 测试 http 接口
 *
 * @author dingdangdog
 * @date 2023/3/27 16:38
 */
@RestController
@RequestMapping("/test")
public class TestController {
    @GetMapping
    public String hello(String name) {
        return "Hello " + name;
    }
}

```

3. 编写基本配置application.yml

在`src/main/resources`文件夹下创建`application.yml`文件，该文件是Springboot默认的配置文件，也可以是`application.properties`，写法不同而已。

application.yml内容如下

```yaml
server:
  port: 8080

spring:
  application:
    name: gradle-boot-my
```

### 启动服务

以上工作完成后，运行SpringBoot的启动类即可，启动日志如下：

```log
"C:\Program Files\Java\jdk1.8.0_131\bin\java.exe" ...
Connected to the target VM, address: '127.0.0.1:13446', transport: 'socket'

  .   ____          _            __ _ _
 /\\ / ___'_ __ _ _(_)_ __  __ _ \ \ \ \
( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \
 \\/  ___)| |_)| | | | | || (_| |  ) ) ) )
  '  |____| .__|_| |_|_| |_\__, | / / / /
 =========|_|==============|___/=/_/_/_/
 :: Spring Boot ::                (v2.7.9)

2023-03-27 16:44:37.878  INFO 19252 --- [           main] com.example.BootApplication              : Starting BootApplication using Java 1.8.0_131 on DESKTOP-M8KVEAO with PID 19252 (E:\code\DingDangDog_sapce\gradle-boot-my\build\classes\java\main started by xxhu5 in E:\code\DingDangDog_sapce\gradle-boot-my)
2023-03-27 16:44:37.882  INFO 19252 --- [           main] com.example.BootApplication              : No active profile set, falling back to 1 default profile: "default"
2023-03-27 16:44:38.651  INFO 19252 --- [           main] o.s.b.w.embedded.tomcat.TomcatWebServer  : Tomcat initialized with port(s): 8080 (http)
2023-03-27 16:44:38.659  INFO 19252 --- [           main] o.apache.catalina.core.StandardService   : Starting service [Tomcat]
2023-03-27 16:44:38.659  INFO 19252 --- [           main] org.apache.catalina.core.StandardEngine  : Starting Servlet engine: [Apache Tomcat/9.0.71]
2023-03-27 16:44:38.754  INFO 19252 --- [           main] o.a.c.c.C.[Tomcat].[localhost].[/]       : Initializing Spring embedded WebApplicationContext
2023-03-27 16:44:38.754  INFO 19252 --- [           main] w.s.c.ServletWebServerApplicationContext : Root WebApplicationContext: initialization completed in 824 ms
2023-03-27 16:44:39.051  INFO 19252 --- [           main] o.s.b.w.embedded.tomcat.TomcatWebServer  : Tomcat started on port(s): 8080 (http) with context path ''
2023-03-27 16:44:39.060  INFO 19252 --- [           main] com.example.BootApplication              : Started BootApplication in 1.6 seconds (JVM running for 2.592)
2023-03-27 16:45:07.066  INFO 19252 --- [nio-8080-exec-1] o.a.c.c.C.[Tomcat].[localhost].[/]       : Initializing Spring DispatcherServlet 'dispatcherServlet'
2023-03-27 16:45:07.066  INFO 19252 --- [nio-8080-exec-1] o.s.web.servlet.DispatcherServlet        : Initializing Servlet 'dispatcherServlet'
2023-03-27 16:45:07.067  INFO 19252 --- [nio-8080-exec-1] o.s.web.servlet.DispatcherServlet        : Completed initialization in 1 ms

```

观察日志可以看到服务以`8080`端口启动成功。

### 测试接口

浏览器访问`http://localhost:8080/test?name=dingdangdog`，现象如下：

![test-api](https://images.oldmoon.top/images/dingdangdog/dingdangdog-1679910471224.jpg)


## 总结

最终服务启动成功并且接口测试成功，说明依赖正确注入并使用。通过使用Gradle进行依赖注入，可以发现以下两点：

1. Gradle对依赖管理的编写，相比Maven更加简洁。
2. Maven支持的依赖管理、依赖传递等行为，Gradle同样支持。

## 台阶

通过本文学习，对Gradle的依赖管理（引入）有了初步的认识，勉强算是迈上了一个台阶。

但还有很多不足之处，比如文中提到的依赖版本管理`version`，既然引入插件可以省略部分依赖的版本号配置，那么可不可以自己实现依赖版本管理，从而省略全部版本的配置？

答案当时是**可以**。Maven中就可以自定义依赖管理，Gradle怎么可能不行呢！这比分知识留给有兴趣的同学自行学习吧~（挖坑😁）

Gradle学习-依赖引入

## 简介

某度百科：

> Go（又称 Golang）是 Google 的 Robert Griesemer，Rob Pike 及 Ken Thompson 开发的一种静态强类型、编译型语言。Go 语言语法与 C 相近，但功能上有：内存安全，GC（垃圾回收），结构形态及 CSP-style 并发计算。

在某个开源项目中，使用了Go作为后端服务开发语言，在此背景下第一次接触Golang，历经艰难险阻终于跑起来了后端服务。。。




## 项目

- 项目名：**van-nav**
- 项目简介：一个轻量导航站，汇总你的所有服务。全平台支持，单文件部署，有配套浏览器插件。
- Github仓库：https://github.com/Mereithhh/van-nav

这是一个简洁的个人网站收藏夹，体积小，操作简单。

但是这个项目的代码显然没有经过认真整理，很多go文件零散的放在根目录，对于我这种没学过go的小白，直接无从下脚，但不管怎样，依照原有的开发经验（`ps:最重要的还是咨询了作者`），最终还是跑起来了。

## Go下载安装

Go官网：[The Go Programming Language](https://go.dev/)

Go下载：[All release](https://go.dev/dl/)

> 选在自己系统对应的版本，下载安装即可。

## go.mod

`go.mod`文件用于管理go项目所需要的三方依赖，类似于Java项目常用的Maven的`pom.xml`。

- ChatGPT的回答：

> go.mod 文件是 Go 1.11 之后引入的模块管理工具，它用于管理 Go 项目的依赖。它主要的作用有以下几个方面：
> 
> 1. 定义模块和模块版本：go.mod 文件记录了当前模块的名称、模块的版本号以及依赖的其他模块及其版本。
> 2. 自动管理依赖：通过 go mod 命令可以方便地自动安装或更新依赖模块，同时也可以方便地移除不再需要的依赖模块。
> 3. 保证构建的可重复性：在 go.mod 中指定了依赖版本号，可以保证在不同的环境中构建同一个项目时使用的依赖版本是一致的，保证了构建的可重复性。
> 4. 支持私有仓库：可以在 go.mod 中指定私有仓库地址，实现对私有依赖的支持。

### 下载依赖

当一个已存在的项目，且项目中已经有`go.mod`文件，说明该项目已经启用了 Go Modules，这时候你就可以通过 `go build`、`go run`、`go test` 等命令来构建、运行或测试你的代码。当然你应该先下载依赖：

```
go mod download
```

`go mod download` 是 Go 模块下载依赖的命令，它会下载 go.mod 文件中列出的依赖包及其依赖包的依赖包到本地缓存。通常在项目中第一次构建或添加新依赖包时，需要运行该命令。运行该命令可以保证依赖包的版本一致性，同时也能加快后续构建过程的速度。

- 下载失败

如果 `go mod download` 命令执行失败，可能是因为网络问题或者是无法连接到默认的 Go 模块代理。此时，您可以尝试切换到其他可用的代理地址，例如 Goproxy.io、Aliyun、Golang 中国等。

可以通过设置环境变量 GOPROXY 来切换 Go 模块代理地址：

```
# Mac | Linux
export GOPROXY=https://goproxy.io,direct

# Windwos
set GOPROXY=https://goproxy.io,direct
```

设置完成后，使用 `go env GOPROXY` 可以查看当前设置的代理地址。设置成功狗再试执行 `go mod download` 尝试下载依赖

## go-embed

`go:embed` 是 Go 1.16 版本新增的一个指令，用于将文件或目录嵌入到 Go 程序的二进制文件中。可以方便地将静态文件（如 HTML、CSS、JS、图片等）打包到二进制文件中，无需额外的文件读取、解析等操作。

在本项目的`main.go`中有一行代码是：
```go
//go:embed public
```

运行`go run main.go`时会报错，但看到这一行代码还很奇怪注释为什么会报错，其实并不是注释，语法就这样。。。

> 在 Go 1.16 版本中，添加了一个新的特性 `//go:embed`，它允许将文件或目录嵌入到 Go 二进制文件中。而为了确保该特性能够正确解析，需要在 `//go:embed` 前加上两个正斜杠 `//`。这样，Go 编译器就能够识别该注释，并执行对应的嵌入操作。

**根据上面的说明，`//go:embed public` 这行代码是将`public`文件夹嵌入到`Go程序`中，但是download下来的代码并没有`public`文件夹，所以报错，在根目录创建`public`文件夹，并随便创建一个文件即可。**

## undefined: XXX

解决上述`public`的报错后，再次运行`go run main.go`，会报错：

```
# command-line-arguments
.\main.go:52:25: undefined: updateCatelogDto
.\main.go:67:44: undefined: Img
.\main.go:128:22: undefined: updateToolDto  
.\main.go:146:25: undefined: Setting        
.\main.go:161:27: undefined: Token
.\main.go:176:22: undefined: updateUserDto  
.\main.go:191:22: undefined: addCatelogDto  
.\main.go:215:19: undefined: addToolDto     
.\main.go:231:31: undefined: Tool
.\main.go:248:34: undefined: Catelog
.\main.go:248:34: too many errors
```

报错的这些都是实体类型，在根目录下的 `types.go` 文件中有定义，但是为什么会报错呢？刚开始以为是没有引用，所以尝试了各种引用方式，不行。

**是在没办法，最后咨询了项目的作者，得到的答复是：运行 `go run .`**

```go
# go run .
数据库初始化成功。。。
应用启动成功，网址:   http://localhost:6412
```

## 结语

虽然最终把项目跑起来了，也自己实现了几个功能，但也只是`COPY`而已，里学会Golang还差的远那。

初次认识Golang

## 问题

Node版本太新，启动老项目时，可能会报错`Error: error:0308010C:digital envelope routines::unsupported`





## 解决

在要执行的脚本前增加以下环境参数设置：

> set NODE_OPTIONS=--openssl-legacy-provider

如：

```
set NODE_OPTIONS=--openssl-legacy-provider && react-scripts start
```

使用`&&`连接两条指令。

Node项目报错 error:0308010C

twitter:card

twitter:creator

twitter:site