1. 拉取镜像
```sh
docker pull minio/minio
```
2. （可选）常见目录来持久化存储数据
```sh
mkdir -p /mnt/data
```
3.运行Minio容器
```sh
docker run \
    -itd \
    -p 9000:9000 \
    -p 9001:9001 \
    --name minio \
    -e "MINIO_ROOT_USER=用户名" \
    -e "MINIO_ROOT_PASSWORD=密码" \
    -v /docker/minio/data:/data \
    quay.io/minio/minio server /data --console-address ":9001"
```

![image.png](https://best-blog.oss-cn-hangzhou.aliyuncs.com/article/a016453c34be7f842ff5f6713930116d.image.webp)

Docker安装minIO

# 1.安装docker
## 1.1 Debian系统中安装Docker
可以按以下步骤进行:
1. 更新apt包索引
```bash
sudo apt-get update
```
2. 安装相关依赖包
```bash
sudo apt-get install apt-transport-https ca-certificates curl gnupg2 software-properties-common
```
3. 添加Docker官方GPG密钥
```bash 
curl -fsSL https://download.docker.com/linux/debian/gpg | sudo apt-key add -
```
4. 添加Docker仓库地址
```bash
sudo add-apt-repository "deb [arch=amd64] https://download.docker.com/linux/debian $(lsb_release -cs) stable"
```
5. 再次更新apt包索引
```bash 
sudo apt-get update  
```
6. 安装最新版本Docker CE
```bash
sudo apt-get install docker-ce
```
7. 启动Docker服务并设置为开机自启动
```bash
sudo systemctl start docker
sudo systemctl enable docker
```
8. 验证Docker安装成功
```bash 
sudo docker run hello-world
```
如果能正常输出Hello World信息,则Docker安装成功。
9. 安装Docker Compose(可选)
```bash
sudo curl -L "https://github.com/docker/compose/releases/download/1.24.0/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose
sudo chmod +x /usr/local/bin/docker-compose
```

## 1.2 Ubuntu 22上安装Docker
1. 更新系统软件包列表：
```bash
sudo apt update
```
2. 安装一些必要的依赖库，以便您能够从Docker存储库中下载和安装软件包：
```bash
sudo apt install -y curl gnupg-agent software-properties-common
```
3. 添加Docker官方GPG密钥：
```bash
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /usr/share/keyrings/docker-archive-keyring.gpg
```

4. 添加Docker存储库到APT源列表：
```bash
echo "deb [arch=amd64 signed-by=/usr/share/keyrings/docker-archive-keyring.gpg] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null
```

5. 更新APT软件包索引并安装Docker：
```bash
sudo apt update
sudo apt install -y docker-ce docker-ce-cli containerd.io
```
6. 检查Docker是否已成功安装：
```bash
sudo docker run hello-world
```
# 2.安装nacos
1. 拉去最新nacos镜像
```bash
docker pull nacos/nacos-server
```
2. 创建nacos容器，并设置启动参数
 
使用nacos的嵌入式数据库
```bash
# 不用MySQL
docker run -d -p 8848:8848 --env JVM_XMS=128m --env JVM_XMX=300m --env JVM_XMN=128m -e MODE=standalone nacos/nacos-server 
```

使用MySQL作为Nacos的数据库
- 需要提前创建nacos_config数据库
- 初始化表结构
    - 下载nacos-db.sql脚本
    - 下载地址：https://github.com/alibaba/nacos
    - sql脚本路径：`nacos-develop/nacos-develop/config/src/main/resources/META-INF`

    
```bash
# 先提前创建好表，再创建容器
docker run -d -p 8848:8848 --env JVM_XMS=128m --env JVM_XMX=300m --env JVM_XMN=128m -e MODE=standalone -e SPRING_DATASOURCE_PLATFORM=mysql -e MYSQL_SERVICE_HOST=localhost -e MYSQL_SERVICE_PORT=3306 -e MYSQL_SERVICE_DB_NAME=nacos_config  -e MYSQL_SERVICE_USER=user -e MYSQL_SERVICE_PASSWORD=password nacos/nacos-server 
```

3. 访问测试

浏览器访问：`ip:8848/nacos`

![image.png](https://best-blog.oss-cn-hangzhou.aliyuncs.com/article/1b8313f16790a190a3ed4a2d95bcea7c.image.webp)

4. 添加配置后，在数据库查看信息

![image.png](https://best-blog.oss-cn-hangzhou.aliyuncs.com/article/eb4c988e9246e1fbb35a7ca8ba45fadd.image.webp)




docker安装nacos

# 使用@Autowired产生警告

![image.png](https://best-blog.oss-cn-hangzhou.aliyuncs.com/article/d3eb55d24c43ad46040001b8df59b0d4.image.png)
**产生警告的原因：**
    Spring团队建议：始终在bean中使用基于构造函数的依赖注入，
    所以idea出现警告，让我们改正。

### 1.Spring的注入方式
- 基于属性注入
- 基于setter方法注入
- 基于构造方法注入

### 2.使用@Autowired修饰属性的缺点

1. 使用final修饰属性，可以防止值被更改，但@Autowired不能修饰final修饰的属性。
    
![image.png](https://best-blog.oss-cn-hangzhou.aliyuncs.com/article/2b35d80b2e4a16fbc68877ea32cc7ba6.image.png)

2. 会导致程序与容器的**紧耦合**，必须通过容器创建对象，否则无法对私有属性进行赋值。
3. 无法检测到bean循环依赖引起的启动异常。

### 3.处理方案

#### 1. 使用setter注入

使用setter注入时，通过@Autowired修饰setter方法
```java
import com.best.service.StudyService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;

/**
 * @author : best
 * @date : 2023/4/19
 * @description: @Autowired解决方案-修饰setter方法
 */
@Controller
public class StudyController {

    private StudyService service;

    @Autowired
    public void setStudyService(StudyService service) {
        this.service = service;
    }
}
```

#### 2. 通过构造方法注入
Spring团队推荐，通过构造方法注入

通过final修饰注入的属性，可以防止值被更改，程序更健壮
```java
import com.best.service.StudyService;
import org.springframework.stereotype.Controller;

/**
 * @author : best
 * @date : 2023/4/19
 * @description: @Autowired解决方案-构造参数注入
 */
@Controller
public class StudyController {

    private final StudyService service;

    public StudyController(StudyService service) {
        this.service = service;
    }
}
```


#### 3. 结合@RequiredArgsConstructor使用
适用于需要注入的属性多，对应的构造方法的参数就会比较多

使用Lombok的@RequiredArgsConstructor注解用于为final或者@NonNull修饰的属性生成对应的构造方法
```java
import com.best.service.StudyService;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Controller;

/**
 * @author : best
 * @date : 2023/4/19
 * @description: @Autowired解决方案-RequiredArgsConstructor结合构造参数注入
 */
@Controller
@RequiredArgsConstructor
public class StudyController {

    private final StudyService service1;
    private final StudyService service2;
    private final StudyService service3;
}
```

@Autowired产生警告

# CentOS 7上卸载GNOME桌面
> 卸载GNOME桌面，不影响其他程序、文件和服务的运行
1. 查看当前系统的桌面环境
```bash
rpm -qa | grep gnome
```
2. 卸载gnome界面以及相关软件包
```bash
yum remove gnome-terminal gnome-screensaver  gnome-session gnome-menus gnome-panel gnome-shell gnome-desktop3 gnome-font-viewer
```
以上命令会卸载gnome的终端、屏幕保护程序、会话管理、
菜单、面板、外壳和文字查看器等相关软件包
3. 卸载GDM(显示管理器)
GDM是GNOME的默认显示管理器，卸载GDM后，系统将不再有图形界面，只能通过命令行登录系统，需要单独卸载
```bash
yum remove gnome-shell
yum remove gdm
```
4. 确认卸载结果
> 重启系统后，如果系统没有图形界面，说明卸载成功。
> 部分残留文件不影响系统使用，可以忽略
    


CentOS 7上卸载GNOME桌面

## Java操作emqx，控制emqx服务器


Java可以通过MQTT协议来连接emqx服务器，并通过订阅、发布消息等操作来控制emqx服务器。下面是Java操作emqx的示例代码：

1. 使用Eclipse Paho MQTT Client连接emqx服务器：

```java
String broker = "tcp://localhost:1883";
String clientId = "Java_Client";
MemoryPersistence persistence = new MemoryPersistence();

MqttClient client = new MqttClient(broker, clientId, persistence);
MqttConnectOptions connOpts = new MqttConnectOptions();
connOpts.setCleanSession(true);

//connect to the broker
client.connect(connOpts);
```

2. 订阅MQTT主题：

```java
String topic = "test/topic";
int qos = 2;
client.subscribe(topic, qos);
```

3. 发布MQTT消息：

```java
String topic = "test/topic";
String content = "Hello, emqx!";
int qos = 2;
MqttMessage message = new MqttMessage(content.getBytes());
message.setQos(qos);
client.publish(topic, message);
```

通过以上操作，我们可以很方便地使用Java来控制emqx服务器。

## springboot操作emqx的项目

实现了一个简单的MQTT消息发送和订阅功能，可以用来操作emqx服务器。

1. 创建Spring Boot项目

使用IDEA或其他编辑器创建一个新的Spring Boot项目，选择Web和Thymeleaf等依赖。具体的依赖配置如下：

```xml
<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>

    <dependency>
        <groupId>org.springframework.integration</groupId>
        <artifactId>spring-integration-stream</artifactId>
    </dependency>

    <dependency>
        <groupId>org.springframework.integration</groupId>
        <artifactId>spring-integration-mqtt</artifactId>
    </dependency>

    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <scope>test</scope>
    </dependency>
</dependencies>
```

其中，使用spring-integration-mqtt依赖来实现MQTT客户端的功能。

2. 配置MQTT客户端

在application.properties文件中添加MQTT相关配置：

```
spring.mqtt.username=user
spring.mqtt.password=passwd
spring.mqtt.url=tcp://localhost:1883
# 客户端ID，建议使用唯一的字符串
spring.mqtt.client-id=client-1
# 订阅的主题
spring.mqtt.default-topic=test/topic
```

3. 编写MQTT配置类

创建MQTT的配置类，并设置连接参数和订阅主题：

```java
@Configuration
@EnableMqtt
public class MqttConfig {

    @Autowired
    private MqttPahoMessageDrivenChannelAdapter mqttAdapter;

    @Bean
    public MqttConnectOptions mqttConnectOptions() {
        MqttConnectOptions mqttConnectOptions = new MqttConnectOptions();
        mqttConnectOptions.setUserName("${spring.mqtt.username}");
        mqttConnectOptions.setPassword("${spring.mqtt.password}".toCharArray());
        mqttConnectOptions.setServerURIs(new String[]{ "${spring.mqtt.url}" });
        return mqttConnectOptions;
    }

    @ServiceActivator(inputChannel = "mqttInputChannel")
    public void messageReceiver(String message) {
        System.out.println("Received message: " + message);
    }

    @Bean
    public MessageChannel mqttInputChannel() {
        return new DirectChannel();
    }

    @Bean
    public IntegrationFlow mqttInFlow() {
        return IntegrationFlows
                .from(mqttAdapter)
                .channel(mqttInputChannel())
                .get();
    }

    @Bean
    public MqttPahoClientFactory mqttClientFactory() {
        DefaultMqttPahoClientFactory factory = new DefaultMqttPahoClientFactory();
        factory.setConnectionOptions(mqttConnectOptions());
        return factory;
    }

    @Bean
    public MqttPahoMessageDrivenChannelAdapter mqttAdapter() {
        MqttPahoMessageDrivenChannelAdapter adapter =
                new MqttPahoMessageDrivenChannelAdapter("${spring.mqtt.client-id}",
                        mqttClientFactory(),
                        "${spring.mqtt.default-topic}");
        adapter.setCompletionTimeout(5000);
        adapter.setConverter(new DefaultPahoMessageConverter());
        adapter.setQos(1);
        return adapter;

    }

}
```

其中，mqttConnectOptions方法用来设置MQTT连接的参数，messageReceiver方法用来接收MQTT消息，mqttInputChannel和mqttInFlow用来配置MQTT消息的输入流。mqttClientFactory方法用来创建MQTT客户端，mqttAdapter用来设置MQTT的相关参数。

4. 编写MQTT服务类

创建MQTT服务类，用来实现MQTT客户端的连接、消息的发送和订阅等操作：

```java
@Service
public class MqttService {

    @Autowired
    private MqttPahoMessageHandler mqttHandler;

    @Autowired
    private MqttAdapter mqttAdapter;

    public void sendMessage(String topic, String message) {
        MqttMessage mqttMessage = new MqttMessage();
        mqttMessage.setPayload(message.getBytes());
        mqttMessage.setQos(1);
        mqttMessage.setRetained(false);
        mqttHandler.handleMessage(new Message<byte[]>(mqttMessage.getPayload(), new MessageHeaders(Collections.singletonMap(MqttHeaders.TOPIC, topic))));
    }

    public void subscribe(String topic) {
        mqttAdapter.addTopic(topic);
    }

}
```

其中，sendMessage方法用来发送MQTT消息，subscribe方法用来订阅MQTT主题。

5. 创建控制器

创建一个MqttController控制器，用来处理MQTT相关的请求：

```java
@RestController
@RequestMapping("/mqtt")
public class MqttController {

    @Autowired
    private MqttService mqttService;

    @GetMapping("/subscribe")
    public String subscribe(String topic) {
        mqttService.subscribe(topic);
        return "订阅成功";
    }

    @PostMapping("/send")
    public String sendMessage(String topic, String message) {
        mqttService.sendMessage(topic, message);
        return "发送成功";
    }

}
```

其中，subscribe方法处理订阅MQTT主题的请求，sendMessage方法处理发送MQTT消息的请求。

6. 编写页面

最后，创建页面，用来测试订阅和发送MQTT消息。这里省略具体页面代码。

至此，一个完整的Spring Boot项目就完成了，它可以实现订阅MQTT主题和发送MQTT消息的功能，可以用来操作emqx服务器。