Tech Blog

2024-08-13

Spring Boot 的版本与 Java JDK 的版本关系如下：

Spring Boot 版本Java 版本

2.7.x17 (LTS)

3.0.x17 (LTS)

3.1.x17 (LTS)

3.2.x17 (LTS)

3.3.x17 (LTS)

3.4.x17 (LTS)

2.6.x11 (LTS)

2.5.x8 (LTS)

2.4.x8 (LTS)

2.3.x8 (LTS)

2.2.x8 (LTS)

2.1.x8 (LTS)

2.0.x8 (LTS)

1.5.x8 (LTS)

1.4.x7 (LTS)

1.3.x7 (LTS)

1.2.x6 (LTS)

1.1.x6 (LTS)

1.0.x6 (LTS)

注意：

LTS 表示长期支持版本。
上表中的数字表示 JDK 的主版本号，例如 8, 9, 10, 11, 12, 13, 14, 15, 16, 17。

如果你想要查看具体的 Spring Boot 版本对应的依赖关系，可以访问 Spring Initializr 网站，选择对应的 Boot 版本，它会展示出需要的 JDK 版本。

Spring Initializr 网站链接：https://start.spring.io/

此外，你还可以在项目的 pom.xml 文件或 build.gradle 文件中查看 Spring Boot 版本和对应的 JDK 版本。

例如，在 Maven 的 pom.xml 中，你可以通过以下方式查看：




<properties>
    <java.version>11</java.version>
</properties>
 
<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.5.0</version>
        <type>pom</type>
    </dependency>
</dependencies>

在 Gradle 的 build.gradle 中，你可以通过以下方式查看：




dependencies {
    implementation 'org.springframework.boot:spring-boot-starter-parent:2.5.0'
}
 
compileJava.options.encoding = 'UTF-8'
compileJava.sourceCompatibility = '11'
compileJava.targetCompatibility = '11'

在实际开发中，如果你使用的是 Spring Initializr 创建项目，通常它会自动帮你设置好这些版本关系。如果需要手动设置，你需要确保你的 JDK 版本与 Spring Boot 版本兼容。

推荐开源项目：jQuery.barrager.js - 专业网页弹幕插件

2024-08-13

所有,jquery

jQuery.barrager.js 是一个用于创建网页弹幕的 jQuery 插件。以下是如何使用该插件的示例代码：

首先，确保在您的 HTML 文档中包含了 jQuery 库和 barrager 插件的脚本：




<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Barrager Example</title>
    <script src="https://code.jquery.com/jquery-3.6.0.min.js"></script>
    <script src="path/to/jQuery.barrager.js"></script>
    <style>
        html, body {
            height: 100%;
            margin: 0;
            padding: 0;
        }
        #barrager-container {
            width: 100%;
            height: 100%;
            position: relative;
        }
    </style>
</head>
<body>
    <div id="barrager-container"></div>
 
    <script>
        $(function() {
            $('#barrager-container').barrager({
                // 配置弹幕的参数
                content: '这是一条弹幕测试信息',
                color: 'green',
                fontSize: 16,
                speed: 6 // 单位: s
            });
        });
    </script>
</body>
</html>

在上述代码中，我们首先引入了 jQuery 和 jQuery.barrager.js 插件。然后，我们定义了一个样式表确保弹幕容器可以覆盖整个页面。在 <script> 标签内，我们初始化了 barrager 插件，并通过一组选项定义了弹幕的内容、颜色、字体大小和速度。这将创建并显示一个从上到下的弹幕。

Vue 3中的v-for指令使用详解

2024-08-13

所有,vue.js




<template>
  <div>
    <!-- 使用v-for遍历items数组，同时使用v-slot接收子组件提供的数据 -->
    <ChildComponent v-for="(item, index) in items" :key="item.id" v-slot="{ msg }">
      <!-- 在template中显示数据和插槽内容 -->
      <div>{{ index }}: {{ item.name }} - {{ msg }}</div>
    </ChildComponent>
  </div>
</template>
 
<script>
import ChildComponent from './ChildComponent.vue';
 
export default {
  components: {
    ChildComponent
  },
  data() {
    return {
      items: [
        { id: 1, name: 'Item 1' },
        { id: 2, name: 'Item 2' },
        // ...更多items
      ]
    };
  }
};
</script>

在这个例子中，我们使用v-for指令来遍历items数组，并为每个元素渲染ChildComponent组件的实例。v-slot被用来接收来自子组件的数据，并在父组件的模板中展示出来。这个例子展示了如何在Vue 3中使用v-for和v-slot来创建动态列表和插槽内容。

2024-08-13

解释：

这个错误通常发生在尝试将一个字符串反序列化为java.time.LocalDateTime类型时，但是序列化过程失败了。这可能是因为字符串的格式和预期的LocalDateTime格式不匹配，或者缺少必要的日期时间格式化程序。

解决方法：

确保输入的字符串格式正确，符合LocalDateTime的解析标准，例如："yyyy-MM-ddTHH:mm:ss"。
如果你有自定义的日期时间格式，你需要提供一个自定义的反序列化器来处理这种格式。
使用DateTimeFormatter类来定义和使用正确的日期时间格式。

示例代码：




import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
 
public class Main {
    public static void main(String[] args) {
        String dateTimeString = "2021-01-01T10:15:30";
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd'T'HH:mm:ss");
        LocalDateTime dateTime = LocalDateTime.parse(dateTimeString, formatter);
        System.out.println(dateTime);
    }
}

确保输入的字符串与DateTimeFormatter定义的模式相匹配，这样就可以正确地将字符串转换为LocalDateTime对象。

【Java探索之旅】继承结构继承和组合 protected final

2024-08-13

在Java中，protected和final关键字可以用来修饰类成员（包括字段、方法），以控制其可见性和能否被覆盖或重新分配。

protected关键字允许被修饰的成员在定义它的类的子类中被访问。如果不在同一个包中，那么只有通过子类的实例才能访问。
final关键字意味着成员不能被覆盖或重写。对于字段，这通常意味着它是常量；对于方法，意味着它不能被覆盖。对于类，意味着它不能被继承。

protected和final一起使用时，意味着成员既可以被同一个包中的其他类访问，也可以被不同包中的子类访问，但不能被修改。

以下是一个简单的例子，演示了如何使用protected和final关键字：




package org.example;
 
public class Parent {
    protected final int VALUE = 10; // 可以被同包中的类访问和使用
 
    protected final void printValue() { // 可以被同包中的类访问，但不能被重写
        System.out.println(VALUE);
    }
}
 
package org.example;
 
public class Child extends Parent {
    public void demonstrate() {
        printValue(); // 正确，可以访问由父类保护的成员函数
        // VALUE++; // 错误，不能修改final字段的值
    }
}
 
public class Main {
    public static void main(String[] args) {
        Child child = new Child();
        child.demonstrate(); // 输出 10
    }
}

在这个例子中，Child类继承自Parent类，可以访问并使用Parent中用protected final修饰的字段VALUE和方法printValue()。但是，Child类不能修改VALUE的值，因为它被声明为final。

JAVA IDEA 项目打包为 jar 包详解

2024-08-13

在 IntelliJ IDEA 中将 Java 项目打包成一个可执行的 JAR 文件，你可以遵循以下步骤：

打开你的 Java 项目。
选择“File” > “Project Structure...”。
在“Project Structure”对话框中，选择“Artifacts”。
如果你的列表中还没有artifact，点击“+” > “JAR”，选择“From modules with dependencies...”。
在出现的对话框中，选择你的主模块。
在“Extract to the /META-INF/MANIFEST.MF file”部分，确保你有正确的主类配置。
配置你的 JAR 文件名和存储位置。
点击“OK”来保存你的 artifact 配置。
返回到主界面，选择“Build” > “Build Artifacts...”。
在“Build Artifacts”对话框中，选择你的 artifact，然后点击“Build”。
等待构建过程完成，你的 JAR 文件将会在你指定的输出目录中生成。

以下是一个简单的示例，演示如何在 IntelliJ IDEA 中创建一个 artifact：




// 假设这是你的主类，包含 main 方法
public class Main {
    public static void main(String[] args) {
        System.out.println("Hello, World!");
    }
}

在 IntelliJ IDEA 中配置 artifact 的步骤：

打开“File” > “Project Structure...”。
在左侧菜单选择“Artifacts”。
点击“+” > “JAR” > “From modules with dependencies...”。
选择你的主模块（包含 main 方法的类所在的模块）。
在“Extract to the /META-INF/MANIFEST.MF file”部分，确保主类配置正确。
指定 JAR 文件名和输出目录。
点击“OK”保存配置。
构建 artifact：“Build” > “Build Artifacts...”，然后选择你的 artifact 并构建。

请注意，如果你的项目依赖于外部库，确保这些依赖也被包含在你的 JAR 包中。

Java 算法篇-深入了解 BF 与 KMP 算法

2024-08-13

在Java中，BF（Brute Force）算法和KMP算法是用于字符串匹配的两种常见算法。

BF算法的核心思想是遍历主字符串，对每个字符开始向后比对是否与模式字符串匹配。

KMP算法的核心思想是通过一个next数组预处理模式字符串，当出现字符不匹配时，可以知道模式字符串中的哪些部分已经与主字符串匹配，可以直接跳过这些部分，从另一个位置开始比对。

以下是Java中实现这两种算法的示例代码：




// BF算法
public class BruteForce {
    public static int search(String txt, String pat) {
        int M = pat.length();
        int N = txt.length();
        for (int i = 0; i <= N - M; i++) {
            int j;
            for (j = 0; j < M; j++) {
                if (pat.charAt(j) != txt.charAt(i + j))
                    break;
            }
            if (j == M)
                return i;
        }
        return -1;
    }
}
 
// KMP算法
public class KMP {
    private int[] computePrefixFunction(String key) {
        int M = key.length();
        int[] prefix = new int[M];
        int j = 0;
        for (int i = 1; i < M; i++) {
            while (j > 0 && key.charAt(i) != key.charAt(j)) {
                j = prefix[j - 1];
            }
            if (key.charAt(i) == key.charAt(j)) {
                j++;
            }
            prefix[i] = j;
        }
        return prefix;
    }
 
    public int search(String txt, String pat) {
        int M = pat.length();
        int N = txt.length();
        int[] prefix = computePrefixFunction(pat);
        int j = 0;
        for (int i = 0; i < N; i++) {
            while (j > 0 && pat.charAt(j) != txt.charAt(i)) {
                j = prefix[j - 1];
            }
            if (pat.charAt(j) == txt.charAt(i)) {
                j++;
            }
            if (j == M) {
                return (i - M + 1);
            }
        }
        return -1;
    }
}

在这两个类中，search方法分别实现了BF和KMP算法来在主字符串txt中查找模式字符串pat的位置。如果找到，返回模式字符串在主字符串中的起始位置，如果未找到，返回-1。computePrefixFunction是KMP算法中用于计算模式字符串的next数组的辅助方法。

从零开始学习 Java：简单易懂的入门指南之查找算法及排序算法

2024-08-13




// 二分查找算法
public class BinarySearch {
    public static int binarySearch(int[] arr, int x) {
        int left = 0;
        int right = arr.length - 1;
        while (left <= right) {
            int mid = left + (right - left) / 2;
            if (arr[mid] == x)
                return mid;
            if (arr[mid] > x)
                right = mid - 1;
            else
                left = mid + 1;
        }
        return -1;
    }
 
    public static void main(String[] args) {
        int[] arr = {2, 3, 4, 10, 40, 100};
        int x = 100;
        int index = binarySearch(arr, x);
        if (index != -1)
            System.out.println("元素在数组中的索引为: " + index);
        else
            System.out.println("元素不在数组中");
    }
}
 
// 冒泡排序算法
public class BubbleSort {
    public static void bubbleSort(int[] arr) {
        int n = arr.length;
        for (int i = 0; i < n - 1; i++) {
            for (int j = 0; j < n - i - 1; j++) {
                if (arr[j] > arr[j + 1]) {
                    // 交换 arr[j+1] 和 arr[j]
                    int temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                }
            }
        }
    }
 
    public static void main(String[] args) {
        int[] arr = {64, 34, 25, 12, 22, 11, 90};
        bubbleSort(arr);
        System.out.println("排序后的数组:");
        for (int val : arr)
            System.out.print(val + " ");
    }
}

这段代码展示了二分查找算法和冒泡排序算法的实现。二分查找算法用于在有序数组中查找特定元素的索引，冒泡排序算法用于对数组进行升序排序。这两个算法都是计算机科学中基础的算法知识，对于学习数据结构和算法有重要的意义。

Java——Stream流的peek方法

2024-08-13

peek 方法是 Java 8 引入的流操作，它允许你在流的每个元素上执行一个简单的操作，同时它不会修改流中的元素。这个方法通常用于调试或者日志记录。

peek 方法的签名是这样的：




Stream<T> peek(Consumer<? super T> action)

这里的 Consumer<? super T> 是一个消费者函数式接口，你可以传递一个 lambda 表达式或方法引用来对流中的每个元素执行操作。

下面是一个使用 peek 方法的例子：




import java.util.Arrays;
import java.util.List;
import java.util.stream.Stream;
 
public class PeekExample {
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
 
        Stream<Integer> stream = numbers.stream();
 
        stream.peek(n -> System.out.println("Processing element: " + n))
              .forEach(n -> System.out.println("Element: " + n));
    }
}

在这个例子中，peek 方法被用来打印出流中每个元素的值，然后在 forEach 中再次打印出相同的值。这是为了演示 peek 方法可以用于调试目的。

注意，peek 方法不应该用于修改流中的元素，因为这可能会影响后续的流操作。如果你需要修改元素，应该使用 map 方法。

【Java用法】Lombok中@SneakyThrows注解的使用方法和作用

2024-08-13

@SneakyThrows 是 Lombok 库中的一个注解，用于在方法中自动捕获异常并转换为运行时异常（RuntimeException）。这样可以避免在使用 Lombok 的项目中必须在每个可能抛出异常的地方显式地添加 try-catch 块。

使用 @SneakyThrows 注解可以使代码更加简洁，但请注意，滥用这个注解可能会隐藏潜在的异常，所以应该谨慎使用，并确保你了解这可能对你的应用程序的健壮性产生负面影响。

以下是 @SneakyThrows 注解的使用方法：




import lombok.SneakyThrows;
 
public class Example {
 
    @SneakyThrows(UnsupportedOperationException.class)
    public void performOperation() {
        // 可能会抛出异常的代码
        throw new UnsupportedOperationException("Operation not supported");
    }
 
    public static void main(String[] args) {
        Example example = new Example();
        try {
            example.performOperation();
        } catch (RuntimeException e) {
            // 捕获到转换后的RuntimeException
            e.printStackTrace();
        }
    }
}

在这个例子中，performOperation 方法中抛出了 UnsupportedOperationException 异常，由于使用了 @SneakyThrows 注解，该异常被自动转换为 RuntimeException 并重新抛出，在 main 方法中被捕获。