FROM node:18
WORKDIR /app
COPY package*.json ./
RUN npm install
RUN npm install -g serve
COPY . .
RUN npm run build
EXPOSE 3000
CMD ["serve", "-s", "build", "-l", "3000"]

拉取指定架构的基础镜像编译
docker build --platform linux/amd64 -t pt20011203/echo-admin:amd64 .

docker push pt20011203/echo-admin:amd64

docker pull pt20011203/echo-admin:amd64
docker run -d -p 3000:3000 --name echo-admin pt20011203/echo-admin:amd64

location /echo-admin/ {
       proxy_pass http://127.0.0.1:3000/;
   }

{
  "alg": "HS256",
  "typ": "JWT"
}

{
  "sub": "1234567890",
  "name": "John Doe",
  "admin": true
}

HMACSHA256(
  base64UrlEncode(header) + "." +
  base64UrlEncode(payload),
  secret)

public static Integer verifyToken(String token) {
        byte[] bytes = generateKey().getBytes();
        Key secretKey = Keys.hmacShaKeyFor(bytes);

        try {
            Jws<Claims> claimsJws=Jwts.parser()
                    .setSigningKey(secretKey)
                    .build()
                    .parseClaimsJws(token);
            // Token 验证通过，可以从 claimsJws 对象中获取相关信息
            Claims claims = claimsJws.getBody();
            String id=claims.get("id").toString();
            return Integer.valueOf(id);
        }catch (Exception e){
            // 捕获异常，判断是否是因为过期
            if (e instanceof io.jsonwebtoken.ExpiredJwtException) {
                // 获取过期的 Claims
                Claims claims = ((io.jsonwebtoken.ExpiredJwtException) e).getClaims();
                // 判断是否在允许的刷新时间内
                long now = System.currentTimeMillis();
                long exp = claims.getExpiration().getTime();
                long diff = now - exp;
                // 如果过期时间不超过一定分钟数（例如 30 分钟）
                if (diff <= 30 * 60 * 1000) {
                    // 重新生成新的令牌
                    Map<String, Object> newClaims = new HashMap<>();
                    newClaims.put("id", claims.get("id"));
                    newClaims.put("exp", new Date(now + 60 * 60 * 1000)); // 设置新的过期时间为 1 小时
                    String newToken = Jwts.builder()
                            .setClaims(newClaims)
                            .signWith(secretKey)
                            .compact();
                    System.out.println("New token generated: " + newToken);
                    return Integer.valueOf(claims.get("id").toString());
                }
            }
            return -1;
        }
    }

-XX:+PrintGC：打印GC的基本信息。
-XX:+PrintGCDetails：打印更详细的GC信息，包括年轻代和老年代的使用情况。
-Xloggc:<file>：将GC日志输出到指定文件

Properties properties = new Properties();
// 2. 给kafka 配置对象添加配置信息：bootstrap.servers
properties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG,
"hadoop102:9092");
// key,value 序列化（必须）：key.serializer，value.serializer
properties.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG,
"org.apache.kafka.common.serialization.StringSerializer");
properties.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG,
"org.apache.kafka.common.serialization.StringSerializer");
// batch.size：批次大小，默认16K
properties.put(ProducerConfig.BATCH_SIZE_CONFIG, 16384);
// linger.ms：等待时间，默认0
properties.put(ProducerConfig.LINGER_MS_CONFIG, 1);
// RecordAccumulator：缓冲区大小，默认32M：buffer.memory
properties.put(ProducerConfig.BUFFER_MEMORY_CONFIG,33554432);
// compression.type：压缩，默认 none，可配置值 gzip、snappy、
lz4和 zstd
properties.put(ProducerConfig.COMPRESSION_TYPE_CONFIG,"snappy");
// 3. 创建 kafka生产者对象
KafkaProducer<String, String> kafkaProducer = new
KafkaProducer<String, String>(properties);
// 4. 调用 send方法,发送消息
for (int i = 0; i < 5; i++) {
kafkaProducer.send(new
ProducerRecord<>("first","atguigu " + i));
}
// 5. 关闭资源
kafkaProducer.close();
}
}

// 1. 创建 kafka生产者的配置对象
Properties properties = new Properties();
// 2. 给kafka 配置对象添加配置信息：bootstrap.servers
properties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG,
"hadoop102:9092");
// key,value 序列化（必须）：key.serializer，value.serializer
properties.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG,
StringSerializer.class.getName());
properties.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG,
StringSerializer.class.getName());
// 设置acks
properties.put(ProducerConfig.ACKS_CONFIG, "all");
// 重试次数retries，默认是int最大值，2147483647
properties.put(ProducerConfig.RETRIES_CONFIG, 3);
// 3. 创建 kafka生产者对象
KafkaProducer<String, String> kafkaProducer = new
KafkaProducer<String, String>(properties);
// 4. 调用 send方法,发送消息
for (int i = 0; i < 5; i++) {
kafkaProducer.send(new
ProducerRecord<>("first","atguigu " + i));
}
// 5. 关闭资源
kafkaProducer.close();
}
}

docker pull apache/kafka:3.9.0
docker run -p 9092:9092 apache/kafka:3.9.0

# Start the ZooKeeper service
$ bin/zookeeper-server-start.sh config/zookeeper.properties

# Start the Kafka broker service
$ bin/kafka-server-start.sh config/server.properties

public class CustomizeProducer {
    public static void main(String[] args) {
        // 1. 创建 kafka生产者的配置对象
        Properties properties = new Properties();
        // 2. 给kafka 配置对象添加配置信息：bootstrap.servers
        properties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG,
                "localhost:9092");
        properties.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG,
                "org.apache.kafka.common.serialization.StringSerializer");
        properties.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG,
                "org.apache.kafka.common.serialization.StringSerializer");
       // 3. 创建 kafka生产者对象
        KafkaProducer<String, String> kafkaProducer = new
                KafkaProducer<String, String>(properties);
      // 4. 调用 send方法,发送消息
        for (int i = 200; i < 210; i++) {
            kafkaProducer.send(new
                    ProducerRecord<>("my_topic",2,"","分区二上传数据:----atguigu_pt " + i));
        }
      // 5. 关闭资源
        kafkaProducer.close();
    }
}

// 同步发送
kafkaProducer.send(new ProducerRecord<>("three", "同步发送----kafka" + i)).get();

Kafka 的事务一共有如下 5 个API
// 1 初始化事务
void initTransactions();
// 2 开启事务
void beginTransaction() throws ProducerFencedException;
// 3 在事务内提交已经消费的偏移量（主要用于消费者）
void sendOffsetsToTransaction(Map<TopicPartition, OffsetAndMetadata> offsets,
String consumerGroupId) throws
ProducerFencedException;
// 4 提交事务
void commitTransaction() throws ProducerFencedException;
// 5 放弃事务（类似于回滚事务的操作）
void abortTransaction() throws ProducerFencedException;

public class CustomConsumerByHandSync {
    public static void main(String[] args) {
        // 1. 创建 kafka消费者配置类
        Properties properties = new Properties();
// 2. 添加配置参数
// 添加连接
        properties.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG,
                "localhost:9092");
// 配置序列化 必须
        properties.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG,
                "org.apache.kafka.common.serialization.StringDeserializer");
        properties.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG,
                "org.apache.kafka.common.serialization.StringDeserializer");
// 配置消费者组
        properties.put(ConsumerConfig.GROUP_ID_CONFIG, "test");
// 是否自动提交 offset
        properties.put(ConsumerConfig.ENABLE_AUTO_COMMIT_CONFIG,
                false);
//3. 创建kafka消费者
        KafkaConsumer<String, String> consumer = new
                KafkaConsumer<>(properties);
//4. 设置消费主题 形参是列表
        consumer.subscribe(Arrays.asList("__consumer_offsets"));
//5. 消费数据
        while (true){
// 读取消息
            ConsumerRecords<String, String> consumerRecords =
                    consumer.poll(Duration.ofSeconds(1));
// 输出消息
            for (ConsumerRecord<String, String> consumerRecord :
                    consumerRecords) {
                System.out.println(consumerRecord.value());
            }
// 同步提交offset
            consumer.commitSync();
        }
    }
}

public class CustomConsumerByHandAsync {
    public static void main(String[] args) {
        // 1. 创建 kafka消费者配置类
        Properties properties = new Properties();
// 2. 添加配置参数
        // 添加连接
        properties.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG,
                "localhost:9092");
// 配置序列化 必须
        properties.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG,
                "org.apache.kafka.common.serialization.StringDeserializer");
        properties.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG,
                "org.apache.kafka.common.serialization.StringDeserializer");
// 配置消费者组
        properties.put(ConsumerConfig.GROUP_ID_CONFIG, "test");
// 是否自动提交 offset
        properties.put(ConsumerConfig.ENABLE_AUTO_COMMIT_CONFIG,
                "false");
//3. 创建Kafka消费者
        KafkaConsumer<String, String> consumer = new
                KafkaConsumer<>(properties);
//4. 设置消费主题 形参是列表
        consumer.subscribe(Arrays.asList("my_topic"));
//5. 消费数据
        while (true){
// 读取消息
            ConsumerRecords<String, String> consumerRecords =
                    consumer.poll(Duration.ofSeconds(1));
// 输出消息
            for (ConsumerRecord<String, String> consumerRecord :
                    consumerRecords) {
                System.out.println(consumerRecord.value());
            }
// 异步提交offset
            consumer.commitAsync();
        }
    }
}

public class CustomConsumerForTime {
    public static void main(String[] args) {
        Properties properties = new Properties();
// 连接
        properties.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG,
                "localhost:9092");
// key value 反序列化
        properties.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG,
                StringDeserializer.class.getName());
        properties.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG,
                StringDeserializer.class.getName());
        properties.put(ConsumerConfig.GROUP_ID_CONFIG, "test2");
// 1 创建一个消费者
        KafkaConsumer<String, String> kafkaConsumer = new
                KafkaConsumer<>(properties);
// 2 订阅一个主题
        ArrayList<String> topics = new ArrayList<>();
        topics.add("my_topic");
        kafkaConsumer.subscribe(topics);
        Set<TopicPartition> assignment = new HashSet<>();
        while (assignment.size() == 0) {
            kafkaConsumer.poll(Duration.ofSeconds(1));
// 获取消费者分区分配信息（有了分区分配信息才能开始消费）
            assignment = kafkaConsumer.assignment();
        }
        Map<TopicPartition, Long> timestampToSearch = new
                HashMap<>();
// 封装集合存储，每个分区对应一天前的数据
        for (TopicPartition topicPartition : assignment) {
            timestampToSearch.put(topicPartition,
                    System.currentTimeMillis() - 1 * 24 * 3600 * 1000);
        }
// 获取从1天前开始消费的每个分区的 offset
        Map<TopicPartition, OffsetAndTimestamp> offsets =
                kafkaConsumer.offsetsForTimes(timestampToSearch);
// 遍历每个分区，对每个分区设置消费时间。
        for (TopicPartition topicPartition : assignment) {
            OffsetAndTimestamp offsetAndTimestamp =
                    offsets.get(topicPartition);
// 根据时间指定开始消费的位置
            if (offsetAndTimestamp != null){
                kafkaConsumer.seek(topicPartition,
                        offsetAndTimestamp.offset());
            }
        }// 3 消费该主题数据
        while (true) {
            ConsumerRecords<String, String> consumerRecords =
                    kafkaConsumer.poll(Duration.ofSeconds(1));
            for (ConsumerRecord<String, String> consumerRecord :
                    consumerRecords) {
                System.out.println(consumerRecord);
            }
        }
    }
}

  public class CustomConsumerSeek {
    public static void main(String[] args) {
        // 0 配置信息
        Properties properties = new Properties();
// 连接
        properties.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG,
                "localhost:9092");
// key value 反序列化
        properties.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG,
                StringDeserializer.class.getName());
        properties.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG,
                StringDeserializer.class.getName());
        properties.put(ConsumerConfig.GROUP_ID_CONFIG, "test2");
// 1 创建一个消费者
        KafkaConsumer<String, String> kafkaConsumer = new
                KafkaConsumer<>(properties);
        // 2 订阅一个主题  可订阅多个主题
// 指定要消费的主题和分区
        <!-- String topic = "my_topic";
        List<TopicPartition> partitions = new ArrayList<>();
        partitions.add(new TopicPartition(topic, 0)); // 消费分区 0
        partitions.add(new TopicPartition(topic, 1)); // 消费分区 1
        // 手动分配分区
        kafkaConsumer.assign(partitions);
 -->
        ArrayList<String> topics = new ArrayList<>();
        topics.add("my_topic");
        kafkaConsumer.subscribe(topics);
        Set<TopicPartition> assignment= new HashSet<>();
        while (assignment.size() == 0) {
            kafkaConsumer.poll(Duration.ofSeconds(1));
       // 获取消费者分区分配信息（有了分区分配信息才能开始消费）
            assignment = kafkaConsumer.assignment();
        }
// 遍历所有分区，并指定 offset从1700 的位置开始消费
        for (TopicPartition tp: assignment) {
            kafkaConsumer.seek(tp, 1700);
        }
// 3 消费该主题数据
        while (true) {
            ConsumerRecords<String, String> consumerRecords =
                    kafkaConsumer.poll(Duration.ofSeconds(1));
            for (ConsumerRecord<String, String> consumerRecord :
                    consumerRecords) {
                System.out.println(consumerRecord);
            }
        }
    }
}

public enum Channel {
    app(1),
    H5(1);
    Channel(int code) {
        this.code = code;
    }
    private final int code;

    public int getCode() {
        return code;
    }
    // 通过整数值获取枚举常量
    public static Channel getValue(int value) {
        for (Channel channel : Channel.values()) {
            if (channel.getCode() == value) {
                return channel;
            }
        }
        throw new IllegalArgumentException("Invalid channel value: " + value);
    }
}

@JsonComponent
public class Config {

    public static class Serializer extends JsonSerializer<Channel> {


        @Override
        public void serialize(Channel channel, JsonGenerator json, SerializerProvider serializerProvider) throws IOException {
            json.writeNumber(channel.getCode());
        }
    }

    public static class Deserializer extends JsonDeserializer<Channel> {
        @Override
        public Channel deserialize(JsonParser jsonParser, DeserializationContext deserializationContext) throws IOException, JacksonException {
            int i = jsonParser.getIntValue();
            return Channel.getValue(i);
        }
    }

    public static class DateSerializer extends JsonSerializer<Date> {
        private static final SimpleDateFormat dateFormat = new SimpleDateFormat("yy-MM-dd 00:00:00");

        @Override
        public void serialize(Date date, JsonGenerator jsonGenerator, SerializerProvider serializerProvider) throws IOException {
            String formattedDate = dateFormat.format(date);
            jsonGenerator.writeString(formattedDate);
        }
    }
    public static class DateDeserializer extends JsonDeserializer<Date> {
        private static final SimpleDateFormat dateFormat = new SimpleDateFormat("yy-MM-dd 00:00:00");

        @Override
        public Date deserialize(JsonParser jsonParser, DeserializationContext deserializationContext) throws IOException, JacksonException {
            String dateStr = jsonParser.getText().trim();
            try {
                return dateFormat.parse(dateStr);
            } catch (ParseException e) {
                throw new RuntimeException(e);
            }
        }
    }
}

this.prepareContext(bootstrapContext, context, environment, listeners, applicationArguments, printedBanner);

private void prepareContext(DefaultBootstrapContext bootstrapContext, ConfigurableApplicationContext context, ConfigurableEnvironment environment, SpringApplicationRunListeners listeners, ApplicationArguments applicationArguments, Banner printedBanner) {
       context.setEnvironment(environment);
       this.postProcessApplicationContext(context);
       this.addAotGeneratedInitializerIfNecessary(this.initializers);
       this.applyInitializers(context);
       listeners.contextPrepared(context);
       bootstrapContext.close(context);
       if (this.logStartupInfo) {
           this.logStartupInfo(context.getParent() == null);
           this.logStartupProfileInfo(context);
       }

       ConfigurableListableBeanFactory beanFactory = context.getBeanFactory();
       beanFactory.registerSingleton("springApplicationArguments", applicationArguments);
       if (printedBanner != null) {
           beanFactory.registerSingleton("springBootBanner", printedBanner);
       }

       if (beanFactory instanceof AbstractAutowireCapableBeanFactory autowireCapableBeanFactory) {
           autowireCapableBeanFactory.setAllowCircularReferences(this.allowCircularReferences);
           if (beanFactory instanceof DefaultListableBeanFactory listableBeanFactory) {
               listableBeanFactory.setAllowBeanDefinitionOverriding(this.allowBeanDefinitionOverriding);
           }
       }

       if (this.lazyInitialization) {
           context.addBeanFactoryPostProcessor(new LazyInitializationBeanFactoryPostProcessor());
       }

       if (this.keepAlive) {
           context.addApplicationListener(new KeepAlive());
       }

       context.addBeanFactoryPostProcessor(new PropertySourceOrderingBeanFactoryPostProcessor(context));
       if (!AotDetector.useGeneratedArtifacts()) {
           Set<Object> sources = this.getAllSources();
           Assert.notEmpty(sources, "Sources must not be empty");
           this.load(context, sources.toArray(new Object[0]));
       }

       listeners.contextLoaded(context);
   }