# 新建一个bat文件
```bat

@echo off
setlocal

set appName=C:/javaservice/eureka-1.0.jar
set appProfile=dev

echo "Start %appName% ..."
start javaw -jar %appName% --spring.profiles.active=%appProfile%

endlocal
Pause
exit
```

# 文件存放启动目录

    C:\ProgramData\Microsoft\Windows\Start Menu\Programs\StartUp

设置jar包自动启动

## 说明
根据业务要求需要将多个pdf合并成一个大的pdf，并且合并后的pdf还需要根据每个小pdf的标题生成目录。
本来使用的是iTextpdf5版本，这个版本不支持书签，所以引入新的依赖，使用pdfbox依赖写一个工具类合并pdf。
## 依赖
```xml
    <dependency>
      <groupId>org.apache.pdfbox</groupId>
      <artifactId>pdfbox</artifactId>
      <version>2.0.30</version>
    </dependency>
```



## 工具类
```java


package com.lhw.management.utils;

import org.apache.pdfbox.pdmodel.PDDocument;
import org.apache.pdfbox.pdmodel.PDPage;
import org.apache.pdfbox.pdmodel.interactive.documentnavigation.destination.PDPageXYZDestination;
import org.apache.pdfbox.pdmodel.interactive.documentnavigation.outline.PDDocumentOutline;
import org.apache.pdfbox.pdmodel.interactive.documentnavigation.outline.PDOutlineItem;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.util.List;

public class PdfBoxUtils {

   
    /**
     * 
     * @Description:  合并pdf生成目录
     * @Param: @param null
     * @author lihaowei
     * @since: 2024/5/21 13:46
     * @return 
     */
        public static byte[] MergeByteArrayAddBookMark(List<ByteArrayOutputStream> byteArrayOutputStreamList, List<String> bookMarkNames) throws IOException {
        PDDocument mergedDocument = new PDDocument();
        PDDocumentOutline outline = null;
        int num=0;
        for (int i = 0; i < byteArrayOutputStreamList.size(); i++) {
            ByteArrayInputStream inputStream = new ByteArrayInputStream(byteArrayOutputStreamList.get(i).toByteArray());
            PDDocument document = PDDocument.load(inputStream);

            for (PDPage page : document.getPages()) {
                mergedDocument.addPage(page);
            }

            if (i == 0) {
                outline = mergedDocument.getDocumentCatalog().getDocumentOutline();
                if (outline == null) {
                    outline = new PDDocumentOutline();
                    mergedDocument.getDocumentCatalog().setDocumentOutline(outline);
                }
            }
            PDOutlineItem item = new PDOutlineItem();
            // 设置目标页面索引和目标位置坐标
            PDPageXYZDestination destination = new PDPageXYZDestination();
            destination.setPage(mergedDocument.getPage(num)); // 设置目标页面索引
            destination.setLeft(0); // 设置目标位置坐标（这里设置为页面左上角）
            destination.setTop(0);
            item.setDestination(destination);
            item.setTitle(bookMarkNames.get(i));
            outline.addLast(item);

            //计算索引页数
            num=num+document.getNumberOfPages();
            // 将 document.close(); 移到循环外
        }

}

```
## 可能出现的问题
    java.io.IOException: Buffer already closed

## 优化
```java

public static byte[] MergeByteArrayAddBookMark(List<ByteArrayOutputStream> byteArrayOutputStreamList, List<String> bookMarkNames) throws IOException {
        PDDocument mergedDocument = new PDDocument();
        PDDocumentOutline outline = null;
        int num=0;
        List<PDDocument> docList = new ArrayList<>();
        for (int i = 0; i < byteArrayOutputStreamList.size(); i++) {
            ByteArrayInputStream inputStream = new ByteArrayInputStream(byteArrayOutputStreamList.get(i).toByteArray());
            PDDocument document= PDDocument.load(inputStream);
            docList.add(document);
            for (PDPage page : document.getPages()) {
                mergedDocument.addPage(page);
            }

            if (i == 0) {
                outline = mergedDocument.getDocumentCatalog().getDocumentOutline();
                if (outline == null) {
                    outline = new PDDocumentOutline();
                    mergedDocument.getDocumentCatalog().setDocumentOutline(outline);
                }
            }
            PDOutlineItem item = new PDOutlineItem();
            // 设置目标页面索引和目标位置坐标
            PDPageXYZDestination destination = new PDPageXYZDestination();
            destination.setPage(mergedDocument.getPage(num)); // 设置目标页面索引
            destination.setLeft(0); // 设置目标位置坐标（这里设置为页面左上角）
            destination.setTop(0);
            item.setDestination(destination);
            item.setTitle(bookMarkNames.get(i));
            outline.addLast(item);

            //计算索引页数
            num=num+document.getNumberOfPages();
        }
        ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
        mergedDocument.save(outputStream);
        for (PDDocument d:docList) {
            d.close();
        }
        mergedDocument.close();

        return outputStream.toByteArray();
    }

```

使用PDFBox合并PDF并生成目录

# 什么是 MQTT？
MQTT 是一种基于发布/订阅模式的轻量级消息协议。它专为受限网络环境和低带宽、高延迟或不可靠的网络而设计。其主要特点包括：

轻量与高效：协议开销小，非常适合物联网（IoT）、移动应用等场景。

发布/订阅模式：消息的发送者（发布者）和接收者（订阅者）通过 Topic（主题）解耦，不需要知道彼此的存在。

多级 QoS：支持最多一次（0）、至少一次（1）、刚好一次（2）三种消息服务质量等级，可按需保证消息的可靠传输。

双向通信：设备可通过 MQTT 上传数据（如传感器读数），服务端也可反向发布指令（如控制开关）。

# 核心组件与架构
在集成之前，你需要了解以下几个核心概念：

- MQTT 代理 (Broker)：消息的中枢服务器，负责接收所有客户端的消息，并根据主题将其推送给订阅的客户端。常见的有 EMQX、HiveMQ、Mosquitto 等。
- 
- MQTT 客户端 (Client)：你的 Java/Spring Boot 应用，它可以充当发布者、订阅者或两者皆是。
- 
- 主题 (Topic)：消息的“地址”，例如 device/sensor/temperature，客户端通过指定主题来收发消息。
- 
- QoS (服务质量)：定义了消息传递的可靠性级别。

# 部署mqtt服务
EMQX：定位是 云端的核心数据中枢。它追求极致的扩展性（集群可达亿万级连接）和高可用性，并提供强大的数据集成与处理能力。

NanoMQ：定位是 边缘侧的轻量级消息总线。它追求极致的轻量（占用资源极低）和高性能，专注于在资源受限的边缘环境中高效收集和处理数据。

[nonamq官网](https://nanomq.io/docs/zh/latest/config-description/http-server.html)
    
    docker run -d --name nanomq -p 1883:1883 -p 8083:8083 -p 8883:8883 emqx/nanomq:latest
    

[emqx官网](https://docs.emqx.com/zh/emqx/latest/deploy/install-docker.html)
```
docker run -d --name emqx-enterprise \
  --hostname node1.emqx.com \
  -e "EMQX_NODE_NAME=emqx@node1.emqx.com" \
  -p 1883:1883 -p 8083:8083 \
  -p 8084:8084 -p 8883:8883 \
  -p 18083:18083 \
  -v $PWD/data:/opt/emqx/data \
  -v $PWD/log:/opt/emqx/log \
  emqx/emqx-enterprise:6.2.0
```



#  两种主流集成方案
在 Java/Spring Boot 项目中，主要有两种集成 MQTT 的方式，你可以根据项目的复杂度和需求进行选择。

方案一：使用 Eclipse Paho 客户端库 (最直接的方式)
Eclipse Paho 是 Java 领域最成熟、最常用的 MQTT 客户端库。这种方式让你能对 MQTT 连接的细节有更精细的控制。

1. 添加依赖


在你的 pom.xml 中添加 Paho 客户端库依赖：

```xml
<dependency>
    <groupId>org.eclipse.paho</groupId>
    <artifactId>org.eclipse.paho.client.mqttv3</artifactId>
    <version>1.2.5</version>
</dependency>
```
2. 配置连接参数


在 application.yml 或 application.properties 中配置连接信息：

```yaml
mqtt:
  broker-url: tcp://localhost:1883   # Broker地址，SSL使用ssl://...
  client-id: your-mqtt-client-id     # 客户端ID，需唯一
  username: your-username            # 用户名（可选）
  password: your-password            # 密码（可选）
  timeout: 30                        # 连接超时（秒）
  keep-alive: 60                     # 心跳间隔（秒）
```
3. 编写 MQTT 配置类


创建一个配置类，用于初始化 Paho 的 MqttClient，并设置连接选项和回调函数。

```java
import org.eclipse.paho.client.mqttv3.*;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class MqttConfig {

    @Value("${mqtt.broker-url}")
    private String brokerUrl;
    @Value("${mqtt.client-id}")
    private String clientId;
    // ... 其他配置属性

    @Bean
    public MqttClient mqttClient() throws MqttException {
        // 1. 创建客户端
        MqttClient client = new MqttClient(brokerUrl, clientId, new MemoryPersistence());

        // 2. 配置连接选项
        MqttConnectOptions options = new MqttConnectOptions();
        options.setUserName(username);
        options.setPassword(password.toCharArray());
        options.setAutomaticReconnect(true);   // 开启自动重连
        options.setCleanSession(false);        // 启用持久会话
        options.setConnectionTimeout(timeout);
        options.setKeepAliveInterval(keepAlive);

        // 3. 设置回调函数，处理连接断开和消息到达
        client.setCallback(new MqttCallback() {
            @Override
            public void connectionLost(Throwable cause) {
                System.err.println("连接已断开，原因：" + cause.getMessage());
                // 可在此处添加自定义的异常告警逻辑
            }

            @Override
            public void messageArrived(String topic, MqttMessage message) {
                System.out.println("收到消息 - Topic: " + topic + ", Payload: " + new String(message.getPayload()));
                // 在这里处理业务逻辑，如解析JSON并存入数据库等
            }

            @Override
            public void deliveryComplete(IMqttDeliveryToken token) {}
        });

        // 4. 连接到Broker
        client.connect(options);
        System.out.println("MQTT 连接成功");
        return client;
    }
}
```
4. 实现发布与订阅


封装一个 MqttService 或直接在 Controller 中使用 mqttClient 的实例：

发布消息 (Publish)：通过 REST API 触发消息发送。

订阅主题 (Subscribe)：通常在应用启动后或特定条件下调用。

```java
@Service
public class MqttService {

    @Autowired
    private MqttClient mqttClient;

    // 发布消息
    public void publish(String topic, String payload, int qos) throws MqttException {
        MqttMessage message = new MqttMessage(payload.getBytes());
        message.setQos(qos);
        mqttClient.publish(topic, message);
    }

    // 订阅主题（可在 @PostConstruct 方法中调用）
    @PostConstruct
    public void subscribe() throws MqttException {
        mqttClient.subscribe("sensor/+/data", (topic, msg) -> {
            // 直接在回调中处理，或在messageArrived回调中处理
        });
    }
}
```

方案二：基于 Spring Integration 的消息驱动方案

如果你的系统基于 Spring，并且希望使用声明式、消息驱动的方式与 MQTT 交互，那么 Spring Integration 的 MQTT 模块是更优雅的选择。它提供了入站和出站适配器，能无缝融入 Spring 的消息通道（MessageChannel）体系。

1. 添加依赖

除了 Paho 依赖，还需要引入 spring-integration-mqtt。

```xml
<dependency>
    <groupId>org.eclipse.paho</groupId>
    <artifactId>org.eclipse.paho.client.mqttv3</artifactId>
    <version>1.2.5</version>
</dependency>
<dependency>
    <groupId>org.springframework.integration</groupId>
    <artifactId>spring-integration-mqtt</artifactId>
</dependency>
```
2. 配置 MQTT 通道适配器

你可以通过 XML 配置或 Java 配置来定义消息通道和适配器。配置中的 MqttPahoMessageDrivenChannelAdapter 用于接收消息，而 MqttPahoMessageHandler 用于发送消息。

```java
@Configuration
public class MqttIntegrationConfig {

    @Bean
    public DefaultMqttPahoClientFactory mqttClientFactory() {
        DefaultMqttPahoClientFactory factory = new DefaultMqttPahoClientFactory();
        MqttConnectOptions options = new MqttConnectOptions();
        options.setServerURIs(new String[]{"tcp://localhost:1883"});
        options.setAutomaticReconnect(true);
        // ... 其他配置
        factory.setConnectionOptions(options);
        return factory;
    }

    // 入站适配器：接收MQTT消息，发送到 inputChannel
    @Bean
    public MessageChannel mqttInputChannel() {
        return new DirectChannel();
    }

    @Bean
    public MqttPahoMessageDrivenChannelAdapter inboundAdapter() {
        MqttPahoMessageDrivenChannelAdapter adapter =
                new MqttPahoMessageDrivenChannelAdapter("clientIdIn", mqttClientFactory(), "topic1", "topic2");
        adapter.setOutputChannel(mqttInputChannel());
        adapter.setQos(1);
        return adapter;
    }

    // 出站适配器：从 outputChannel 接收消息，发布到MQTT
    @Bean
    public MessageChannel mqttOutputChannel() {
        return new DirectChannel();
    }

    @Bean
    public MqttPahoMessageHandler outboundAdapter() {
        MqttPahoMessageHandler handler = new MqttPahoMessageHandler("clientIdOut", mqttClientFactory());
        handler.setAsync(true);
        handler.setDefaultTopic("default-topic");
        handler.setOutputChannel(mqttOutputChannel());
        return handler;
    }
}
```
3. 处理业务逻辑

定义一个 @ServiceActivator 来监听 mqttInputChannel，处理接收到的 MQTT 消息，并将结果发送到 mqttOutputChannel 以发布新的 MQTT 消息。

```java
@Component
public class MqttMessageProcessor {

    @ServiceActivator(inputChannel = "mqttInputChannel", outputChannel = "mqttOutputChannel")
    public Message<?> handleMqttMessage(Message<?> message) {
        String topic = (String) message.getHeaders().get(MqttHeaders.RECEIVED_TOPIC);
        String payload = new String((byte[]) message.getPayload());
        System.out.println("收到并处理消息: " + payload);

        // 业务逻辑处理，例如解析数据、数据库存储等

        // 如果需要回复，可以构造一个新的消息发送到 outputChannel
        return MessageBuilder.withPayload("{\"response\":\"OK\"}")
                .setHeader(MqttHeaders.TOPIC, "response/topic")
                .build();
    }
}
```

# 两种方案对比
Spring Boot + Paho 客户端库

复杂度：低/中

核心依赖：org.eclipse.paho.client.mqttv3

适用场景：追求快速开发、直接控制连接和回调

特点：代码直观，控制粒度细，配置相对简单

Spring Integration MQTT

复杂度：中/高

核心依赖：spring-integration-mqtt

适用场景：复杂消息路由、需要声明式集成Spring生态

特点：基于消息通道，与Spring Messaging无缝集成，重连和会话管理更健壮、支持MQTT v5及主题模式匹配

MQTT协议

# 核心概念
两者都用于定义在 Bean 的所有必要属性（通过依赖注入设置）被设置之后，需要执行的初始化逻辑。例如，在数据库连接池 Bean 被创建且其 dataSource、maxPoolSize 等属性被注入后，你可能需要用它来预先建立几个连接进行预热。



# 1. InitializingBean 接口
InitializingBean 是 Spring 框架提供的一个接口。

## 工作原理
Bean 实现这个接口，并强制重写其唯一的 afterPropertiesSet() 方法。Spring 容器在设置完 Bean 的所有属性后，会自动调用这个方法。


```java
import org.springframework.beans.factory.InitializingBean;
import org.springframework.stereotype.Component;

@Component
public class MyService implements InitializingBean {

    private String someProperty;

    // 这个方法会被 Spring 的依赖注入机制调用
    public void setSomeProperty(String someProperty) {
        this.someProperty = someProperty;
    }

    // 实现 InitializingBean 接口的方法
    @Override
    public void afterPropertiesSet() throws Exception {
        // 在这里编写初始化逻辑
        System.out.println("MyService 初始化完成，someProperty 的值为: " + this.someProperty);
        // 例如：建立数据库连接、加载缓存数据、验证配置等
        preloadCache();
    }

    private void preloadCache() {
        // 模拟预加载缓存
        System.out.println("预加载缓存...");
    }
}
```
## 优点
非常明确，直接实现了接口，代码意图清晰。

## 缺点
与 Spring 框架紧耦合：你的 Bean 类直接引入了 Spring 的特定接口（InitializingBean）。如果你将来想将此类移植到另一个不依赖 Spring 的 IOC 容器中，就需要修改代码。这违反了依赖倒置原则。

# 2. @PostConstruct 注解
@PostConstruct 是 Java EE 标准注解（javax.annotation.PostConstruct），现在更常见的是来自 Jakarta EE（jakarta.annotation.PostConstruct）。Spring 也完全支持这个注解。

## 工作原理
你可以在 Bean 的任何一个方法上添加 @PostConstruct 注解。Spring 容器在完成依赖注入后，会识别这个注解并调用该方法。


```java
import jakarta.annotation.PostConstruct;
import org.springframework.stereotype.Component;

@Component
public class MyService {

    private String someProperty;

    public void setSomeProperty(String someProperty) {
        this.someProperty = someProperty;
    }

    // 使用 @PostConstruct 注解标记初始化方法
    @PostConstruct
    public void init() {
        // 在这里编写初始化逻辑
        System.out.println("使用 @PostConstruct: MyService 初始化完成，someProperty 的值为: " + this.someProperty);
        preloadCache();
    }

    private void preloadCache() {
        System.out.println("预加载缓存...");
    }
}
```
## 优点
与框架解耦：这是一个标准注解，不属于 Spring 特有。你的 Bean 类只需要导入 javax.annotation 或 jakarta.annotation 包，而不需要导入任何 Spring 特定的接口。这使得代码更容易移植和测试。

方法名自由：你可以随意命名初始化方法（如 init, startUp, loadConfig 等），比强制使用 afterPropertiesSet 更灵活。

可以定义多个（但不推荐）：你可以在一个 Bean 中定义多个 @PostConstruct 方法，但它们的执行顺序是不确定的，通常应避免这样做。

# 3. 第三种方式：XML 配置 init-method
除了以上两种，Spring 还支持通过 XML 配置来指定初始化方法，这种方式完全没有代码侵入性。
```
xml
<bean id="myService" class="com.example.MyService" init-method="initMethod">
    <property name="someProperty" value="someValue"/>
</bean>
java
public class MyService {

    private String someProperty;

    public void setSomeProperty(String someProperty) {
        this.someProperty = someProperty;
    }

    // 一个普通的自定义方法
    public void initMethod() {
        System.out.println("使用 XML init-method 进行初始化");
    }
}
```
在 Java 配置中，可以使用 @Bean 注解的 initMethod 属性达到同样效果：

```java
@Configuration
public class AppConfig {

    @Bean(initMethod = "initMethod")
    public MyService myService() {
        return new MyService();
    }
}
```
执行顺序
如果一个 Bean 同时使用了这三种方式，它们的执行顺序是：

- @PostConstruct 注解的方法

- InitializingBean 接口的 afterPropertiesSet() 方法

- 自定义的 init-method（在 XML 或 @Bean 中指定）

# 总结与推荐
|特性	|InitializingBean 接口	|@PostConstruct 注解	|XML/Java init-method|
|---|---|---|---|
|耦合性	|高（紧耦合 Spring）	|低（标准注解）	|极低（无代码侵入）
|灵活性	|低（固定方法名）	|高（任意方法名）	|高（任意方法名）|
|代码侵入	|需要实现接口	|只需添加注解	|无需修改类本身
|推荐度	|不推荐（ legacy 项目可见）	|强烈推荐（现代方式）	|推荐（用于配置外部库的类）|

# 最佳实践：
优先使用 @PostConstruct 注解。它是现代 Spring 应用中最常用、最推荐的方式，因为它结合了低耦合性和高灵活性。

如果你需要配置一个第三方库中的类（你无法修改其源代码）的初始化方法，那么使用 XML 或 Java 配置中的 init-method 是唯一的选择。

尽量避免使用 InitializingBean 接口，除非是为了维护一些遗留的老代码。

Java初始化Bean方式

# 什么是 SSE？
SSE 是一种允许服务器通过 HTTP 协议主动向客户端推送事件的技术。它特别适合那些实时性要求高、但不需要客户端频繁发送数据的场景，比如实时消息通知、进度更新、数据流推送等。



1. 添加依赖
确保你的 pom.xml 中包含 spring-boot-starter-web 依赖，这是使用 SseEmitter 的基础：

```xml
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>
```
2. 编写服务端 Controller
```java
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.servlet.mvc.method.annotation.SseEmitter;
import java.io.IOException;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;

@RestController
public class SseController {
    @GetMapping("/sse/demo")
    public SseEmitter streamSse() {
        // 1. 创建 SseEmitter 实例，设置超时时间（毫秒）
        SseEmitter emitter = new SseEmitter(60_000L);

        // 2. 使用线程池异步执行，避免阻塞主线程
        Executors.newSingleThreadExecutor().execute(() -> {
            try {
                for (int i = 1; i <= 10; i++) {
                    // 3. 模拟数据发送（例如实时消息）
                    emitter.send("当前消息：" + i);
                    TimeUnit.SECONDS.sleep(1);
                }
                // 4. 发送完成后关闭连接
                emitter.complete();
            } catch (IOException | InterruptedException e) {
                // 异常处理，将错误信息发送给客户端并关闭连接
                emitter.completeWithError(e);
            }
        });
        return emitter;
    }
}
```
3. 前端接入
```html
<script>
    // 连接 SSE 接口
    const eventSource = new EventSource('/sse/demo');
    // 监听消息
    eventSource.onmessage = function(event) {
        console.log('收到实时消息:', event.data);
        // 根据实际需要更新页面，例如追加到 div 中
        // document.getElementById('messages').innerHTML += event.data + '<br/>';
    };
    // 异常处理
    eventSource.onerror = function(err) {
        console.error('SSE 连接异常:', err);
        // 可在此处尝试重连或提示用户
    };
    // 需要关闭连接时调用
    // eventSource.close();
</script>
```

- 创建 SseEmitter：实例化时指定超时时间（单位为毫秒），避免连接无限期占用。
- 
- 异步推送消息：利用线程池执行耗时的推送任务，以免阻塞主线程，影响其他请求。
- 
- 发送消息：通过 emitter.send() 方法将数据发送到客户端。
- 
- 完成：调用 emitter.complete() 正确结束 SSE 流。
- 
- 异常处理：发生异常时调用 emitter.completeWithError(e)，将错误信息传递给客户端并关闭连接。