Spring Boot项目中成功集成了JWT

news2025/3/18 0:39:48

JWT 原理解释

什么是 JWT？

JSON Web Token（JWT）是一种开放标准（RFC 7519），用于在网络应用环境间安全地将信息作为JSON对象传输。JWT通常用于身份验证和信息交换。

JWT 的结构

JWT由三部分组成，以点.分隔：

  1. Header（头部）：包含令牌的类型（typ）和签名算法（alg）。
  2. Payload（负载）：包含声明（claims），即实体（通常是用户）和其他数据。
  3. Signature（签名）：通过将Base64Url编码的Header和Payload连接起来，并使用密钥进行签名得到。
生成与验证流程

  1. 生成JWT：

    • 构建Header和Payload。
    • 使用指定的签名算法和密钥生成签名。
    • 将Header、Payload和Signature拼接成JWT字符串。

  2. 验证JWT：

    • 解码Header和Payload。
    • 根据Header中的签名算法和提供的密钥重新计算签名。
    • 比较新计算的签名与JWT中的签名是否一致。

实现步骤

以下是详细的代码实现步骤，包括生成密钥、配置JWT、创建工具类和控制器，并加入JWT自动续期功能。

1. 准备工作

添加依赖

首先，在 pom.xml 中添加 com.auth0 的 java-jwt 依赖：

<dependencies>
    <!-- Spring Boot Starter Web -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>

    <!-- Auth0 JWT Library -->
    <dependency>
        <groupId>com.auth0</groupId>
        <artifactId>java-jwt</artifactId>
        <version>3.10.0</version>
    </dependency>
</dependencies>

2. 生成密钥文件

对称密钥（HMAC）

我们可以使用 Java 代码生成一个对称密钥并保存到文件中：

import java.nio.file.Files;
import java.nio.file.Paths;
import java.security.SecureRandom;

public class KeyGenerator {
    public static void main(String[] args) throws Exception {
        // 定义一个32字节的数组用于存储密钥
        byte[] secretKey = new byte[32];
        
        // 使用强随机数生成器填充密钥数组
        SecureRandom.getInstanceStrong().nextBytes(secretKey);
        
        // 将生成的密钥写入名为 jwt_secret.key 的文件
        Files.write(Paths.get("jwt_secret.key"), secretKey);
        
        // 输出提示信息
        System.out.println("密钥已生成并保存到 jwt_secret.key 文件中");
    }
}
非对称密钥（RSA）

使用 OpenSSL 生成 RSA 密钥对，并将其保存到文件中：

# 生成私钥
openssl genpkey -algorithm RSA -out private.key -aes256 -pass pass:your_password -pkeyopt rsa_keygen_bits:2048

# 从私钥中提取公钥
openssl rsa -pubout -in private.key -out public.key -passin pass:your_password

3. 在Spring Boot中集成JWT

创建配置类

加载密钥文件并配置 JWT 相关的参数。

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.security.KeyFactory;
import java.security.PrivateKey;
import java.security.PublicKey;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;
import java.util.Base64;

@Configuration
public class JwtConfig {

    /**
     * 读取对称密钥文件
     * @return 密钥字符串
     * @throws IOException 如果读取文件失败
     */
    @Bean
    public String getSecretKey() throws IOException {
        // 从 jwt_secret.key 文件读取密钥字节数组
        byte[] keyBytes = Files.readAllBytes(Paths.get("jwt_secret.key"));
        
        // 使用Base64编码将字节数组转换为字符串
        return Base64.getEncoder().encodeToString(keyBytes);
    }

    /**
     * 读取私钥文件
     * @return 私钥对象
     * @throws Exception 如果解析私钥失败
     */
    @Bean
    public PrivateKey getPrivateKey() throws Exception {
        // 从 private.key 文件读取私钥字节数组
        byte[] keyBytes = Files.readAllBytes(Paths.get("private.key"));
        
        // 创建PKCS8EncodedKeySpec对象
        PKCS8EncodedKeySpec spec = new PKCS8EncodedKeySpec(keyBytes);
        
        // 获取RSA算法的KeyFactory实例
        KeyFactory kf = KeyFactory.getInstance("RSA");
        
        // 生成私钥对象
        return kf.generatePrivate(spec);
    }

    /**
     * 读取公钥文件
     * @return 公钥对象
     * @throws Exception 如果解析公钥失败
     */
    @Bean
    public PublicKey getPublicKey() throws Exception {
        // 从 public.key 文件读取公钥字节数组
        byte[] keyBytes = Files.readAllBytes(Paths.get("public.key"));
        
        // 创建X509EncodedKeySpec对象
        X509EncodedKeySpec spec = new X509EncodedKeySpec(keyBytes);
        
        // 获取RSA算法的KeyFactory实例
        KeyFactory kf = KeyFactory.getInstance("RSA");
        
        // 生成公钥对象
        return kf.generatePublic(spec);
    }
}
创建JWT工具类

实现 JWT 的生成、验证和自动续期功能。

import com.auth0.jwt.JWT;
import com.auth0.jwt.algorithms.Algorithm;
import com.auth0.jwt.interfaces.DecodedJWT;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.security.PrivateKey;
import java.security.PublicKey;
import java.util.Date;

@Component
public class JwtUtil {

    @Autowired
    private String secretKey; // 对称密钥

    @Autowired
    private PrivateKey privateKey; // 私钥

    @Autowired
    private PublicKey publicKey; // 公钥

    private static final long EXPIRATION_TIME = 1000 * 60 * 60; // 1小时
    private static final long REFRESH_THRESHOLD = 1000 * 60 * 55; // 55分钟

    /**
     * 使用对称密钥生成JWT
     * @param username 用户名
     * @return 生成的JWT字符串
     */
    public String generateToken(String username) {
        // 使用对称密钥创建算法实例
        Algorithm algorithm = Algorithm.HMAC256(secretKey);
        
        // 创建JWT构建器
        return JWT.create()
                // 设置主题为用户名
                .withSubject(username)
                // 设置签发时间
                .withIssuedAt(new Date())
                // 设置过期时间为1小时后
                .withExpiresAt(new Date(System.currentTimeMillis() + EXPIRATION_TIME))
                // 使用指定算法签名并生成JWT字符串
                .sign(algorithm);
    }

    /**
     * 使用私钥生成JWT
     * @param username 用户名
     * @return 生成的JWT字符串
     */
    public String generateTokenWithRsa(String username) {
        // 使用RSA密钥创建算法实例
        Algorithm algorithm = Algorithm.RSA256((com.auth0.jwt.impl.crypto.RSAPublicKey) publicKey, (com.auth0.jwt.impl.crypto.RSAPrivateKey) privateKey);
        
        // 创建JWT构建器
        return JWT.create()
                // 设置主题为用户名
                .withSubject(username)
                // 设置签发时间
                .withIssuedAt(new Date())
                // 设置过期时间为1小时后
                .withExpiresAt(new Date(System.currentTimeMillis() + EXPIRATION_TIME))
                // 使用指定算法签名并生成JWT字符串
                .sign(algorithm);
    }

    /**
     * 验证JWT（使用对称密钥）
     * @param token 要验证的JWT字符串
     * @return 解析后的DecodedJWT对象
     */
    public DecodedJWT validateToken(String token) {
        // 使用对称密钥创建算法实例
        Algorithm algorithm = Algorithm.HMAC256(secretKey);
        
        // 创建验证器并构建验证器
        return JWT.require(algorithm)
                .build()
                // 验证并返回解码后的JWT
                .verify(token);
    }

    /**
     * 使用公钥验证JWT
     * @param token 要验证的JWT字符串
     * @return 解析后的DecodedJWT对象
     */
    public DecodedJWT validateTokenWithRsa(String token) {
        // 使用公钥创建算法实例
        Algorithm algorithm = Algorithm.RSA256((com.auth0.jwt.impl.crypto.RSAPublicKey) publicKey, null);
        
        // 创建验证器并构建验证器
        return JWT.require(algorithm)
                .build()
                // 验证并返回解码后的JWT
                .verify(token);
    }

    /**
     * 判断JWT是否需要刷新
     * @param decodedJWT 解码后的JWT
     * @return 是否需要刷新
     */
    public boolean shouldRefresh(DecodedJWT decodedJWT) {
        // 获取JWT的过期时间
        Date expiresAt = decodedJWT.getExpiresAt();
        
        // 计算当前时间和过期时间的差值
        long timeLeft = expiresAt.getTime() - System.currentTimeMillis();
        
        // 如果剩余时间小于刷新阈值，则返回true，表示需要刷新
        return timeLeft <= REFRESH_THRESHOLD;
    }

    /**
     * 刷新JWT
     * @param username 用户名
     * @return 新的JWT字符串
     */
    public String refreshToken(String username) {
        // 使用对称密钥创建算法实例
        Algorithm algorithm = Algorithm.HMAC256(secretKey);
        
        // 创建JWT构建器
        return JWT.create()
                // 设置主题为用户名
                .withSubject(username)
                // 设置签发时间
                .withIssuedAt(new Date())
                // 设置过期时间为1小时后
                .withExpiresAt(new Date(System.currentTimeMillis() + EXPIRATION_TIME))
                // 使用指定算法签名并生成JWT字符串
                .sign(algorithm);
    }
}
创建过滤器

在请求到达控制器之前检查JWT的有效性，并根据需要刷新JWT。

import com.auth0.jwt.JWT;
import com.auth0.jwt.interfaces.DecodedJWT;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.web.filter.OncePerRequestFilter;

import javax.servlet.FilterChain;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

@Component
public class JwtAuthenticationFilter extends OncePerRequestFilter {

    @Autowired
    private JwtUtil jwtUtil;

    @Override
    protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain) throws ServletException, IOException {
        // 从请求头中获取Authorization字段
        String header = request.getHeader("Authorization");

        if (header == null || !header.startsWith("Bearer ")) {
            // 如果没有Authorization字段或格式不正确，直接放行
            filterChain.doFilter(request, response);
            return;
        }

        try {
            // 提取JWT字符串
            String token = header.substring(7);

            // 验证JWT
            DecodedJWT decodedJWT = jwtUtil.validateToken(token);

            // 判断是否需要刷新JWT
            if (jwtUtil.shouldRefresh(decodedJWT)) {
                // 获取用户名
                String username = decodedJWT.getSubject();

                // 刷新JWT
                String newToken = jwtUtil.refreshToken(username);

                // 将新的JWT放入响应头
                response.setHeader("New-Token", newToken);
            }

            // 放行请求
            filterChain.doFilter(request, response);
        } catch (Exception e) {
            // 处理异常情况，如无效的JWT
            response.setStatus(HttpServletResponse.SC_UNAUTHORIZED);
            response.getWriter().write("Invalid JWT");
        }
    }
}

创建控制器

提供 API 接口来测试 JWT 的生成、验证和刷新功能。

import com.auth0.jwt.interfaces.DecodedJWT;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

@RestController
@RequestMapping("/api")
public class JwtController {

    @Autowired
    private JwtUtil jwtUtil;

    /**
     * 生成JWT（使用对称密钥）
     * @param username 用户名
     * @return 生成的JWT字符串
     */
    @GetMapping("/generate-token")
    public String generateToken(@RequestParam String username) {
        // 调用JwtUtil生成JWT
        return jwtUtil.generateToken(username);
    }

    /**
     * 使用私钥生成JWT
     * @param username 用户名
     * @return 生成的JWT字符串
     */
    @GetMapping("/generate-token-rsa")
    public String generateTokenWithRsa(@RequestParam String username) {
        // 调用JwtUtil使用私钥生成JWT
        return jwtUtil.generateTokenWithRsa(username);
    }

    /**
     * 验证JWT（使用对称密钥）
     * @param request 包含要验证的JWT字符串的请求体
     * @return 解析后的DecodedJWT对象
     */
    @PostMapping("/validate-token")
    public DecodedJWT validateToken(@RequestBody TokenRequest request) {
        // 调用JwtUtil验证JWT
        return jwtUtil.validateToken(request.getToken());
    }

    /**
     * 使用公钥验证JWT
     * @param request 包含要验证的JWT字符串的请求体
     * @return 解析后的DecodedJWT对象
     */
    @PostMapping("/validate-token-rsa")
    public DecodedJWT validateTokenWithRsa(@RequestBody TokenRequest request) {
        // 调用JwtUtil使用公钥验证JWT
        return jwtUtil.validateTokenWithRsa(request.getToken());
    }
}

/**
 * 请求体类，用于接收包含JWT字符串的请求
 */
class TokenRequest {
    private String token;

    public String getToken() {
        // 返回token字段值
        return token;
    }

    public void setToken(String token) {
        // 设置token字段值
        this.token = token;
    }
}

4. 完整的Spring Boot启动类

为了完整性，这里是一个简单的 Spring Boot 启动类，并注册过滤器：

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.web.servlet.FilterRegistrationBean;
import org.springframework.context.annotation.Bean;

@SpringBootApplication
public class JwtDemoApplication {

    public static void main(String[] args) {
        // 运行Spring Boot应用
        SpringApplication.run(JwtDemoApplication.class, args);
    }

    @Bean
    public FilterRegistrationBean<JwtAuthenticationFilter> loggingFilter(){
        FilterRegistrationBean<JwtAuthenticationFilter> registrationBean = new FilterRegistrationBean<>();

        registrationBean.setFilter(new JwtAuthenticationFilter());
        registrationBean.addUrlPatterns("/api/*");

        return registrationBean;
    }
}

测试API

生成JWT

  • 使用对称密钥生成JWT：

    GET /api/generate-token?username=john_doe

  • 使用私钥生成JWT：

    GET /api/generate-token-rsa?username=john_doe
验证JWT

  • 使用对称密钥验证JWT：

    POST /api/validate-token
Content-Type: application/json
{
    "token": "your_jwt_token"
}

  • 使用公钥验证JWT：

    POST /api/validate-token-rsa
Content-Type: application/json
{
    "token": "your_jwt_token"
}
自动续期

当JWT接近过期时（例如剩余有效期少于55分钟），过滤器会在响应头中返回一个新的JWT，客户端可以从中获取新的JWT并更新本地存储的JWT。

自动续期原理

工作流程
  1. 检查JWT有效期：每次请求到来时，过滤器会从请求头中提取JWT，并解析出其有效期。
  2. 判断是否需要续期：如果JWT的有效期剩余时间小于设定的阈值（例如55分钟），则认为该JWT即将过期，需要续期。
  3. 生成新JWT：调用 JwtUtil 类中的 refreshToken 方法生成一个新的JWT，并将其放入响应头中返回给客户端。
  4. 更新客户端JWT：客户端接收到带有新JWT的响应后，更新本地存储的JWT。
关键代码解释
判断是否需要续期
public boolean shouldRefresh(DecodedJWT decodedJWT) {
    // 获取JWT的过期时间
    Date expiresAt = decodedJWT.getExpiresAt();
    
    // 计算当前时间和过期时间的差值
    long timeLeft = expiresAt.getTime() - System.currentTimeMillis();
    
    // 如果剩余时间小于刷新阈值，则返回true，表示需要刷新
    return timeLeft <= REFRESH_THRESHOLD;
}

此方法计算JWT的剩余有效时间，如果剩余时间小于设定的阈值（如55分钟），则返回 true 表示需要刷新。

刷新JWT
public String refreshToken(String username) {
    // 使用对称密钥创建算法实例
    Algorithm algorithm = Algorithm.HMAC256(secretKey);
    
    // 创建JWT构建器
    return JWT.create()
            // 设置主题为用户名
            .withSubject(username)
            // 设置签发时间
            .withIssuedAt(new Date())
            // 设置过期时间为1小时后
            .withExpiresAt(new Date(System.currentTimeMillis() + EXPIRATION_TIME))
            // 使用指定算法签名并生成JWT字符串
            .sign(algorithm);
}

此方法重新生成一个新的JWT，并设置其过期时间为1小时后。客户端在收到新的JWT后应更新本地存储的JWT。

过滤器处理逻辑
@Override
protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain) throws ServletException, IOException {
    // 从请求头中获取Authorization字段
    String header = request.getHeader("Authorization");

    if (header == null || !header.startsWith("Bearer ")) {
        // 如果没有Authorization字段或格式不正确，直接放行
        filterChain.doFilter(request, response);
        return;
    }

    try {
        // 提取JWT字符串
        String token = header.substring(7);

        // 验证JWT
        DecodedJWT decodedJWT = jwtUtil.validateToken(token);

        // 判断是否需要刷新JWT
        if (jwtUtil.shouldRefresh(decodedJWT)) {
            // 获取用户名
            String username = decodedJWT.getSubject();

            // 刷新JWT
            String newToken = jwtUtil.refreshToken(username);

            // 将新的JWT放入响应头
            response.setHeader("New-Token", newToken);
        }

        // 放行请求
        filterChain.doFilter(request, response);
    } catch (Exception e) {
        // 处理异常情况，如无效的JWT
        response.setStatus(HttpServletResponse.SC_UNAUTHORIZED);
        response.getWriter().write("Invalid JWT");
    }
}

此过滤器负责在每个请求到来时检查JWT的有效性，并在需要时刷新JWT。

注意事项

  1. 密钥管理：

    • 对称密钥应妥善保管，避免泄露。
    • 非对称密钥中的私钥应严格保密，公钥可以公开。

  2. 安全性：

    • 设置合理的过期时间，防止长时间有效的令牌被滥用。
    • 使用HTTPS传输JWT，防止中间人攻击。

  3. 错误处理：

    • 在验证JWT时捕获异常，处理无效或过期的令牌。

  4. 性能优化：

    • 缓存解析后的Claims对象，减少重复解析开销。

通过上述步骤，我们已经在Spring Boot项目中成功集成了JWT，并实现了自动续期功能。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/2316890.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

专题|Python贝叶斯金融数据应用实例合集：随机波动率SV模型、逻辑回归、参数更新、绩效比较BEST分析亚马逊股票、普尔指数...

专题|Python贝叶斯金融数据应用实例合集：随机波动率SV模型、逻辑回归、参数更新、绩效比较BEST分析亚马逊股票、普尔指数...

原文链接&#xff1a;https://tecdat.cn/?p41020 本专题合集系统梳理了贝叶斯方法在金融数据分析与分类建模中的前沿应用。合集聚焦于PyMC3概率编程框架&#xff0c;深度探讨了共轭先验参数更新、贝叶斯逻辑回归、贝叶斯夏普比率等核心算法在实际场景中的落地实践&#xff08;…
阅读更多...
Linux调度器 --- 负载均衡的存在的问题

Linux调度器 --- 负载均衡的存在的问题

文章目录 前言一、简介二、Linux 调度器2.1 在单核系统上&#xff0c;CFS 非常简单2.2 在多核系统上&#xff0c;CFS 变得非常复杂2.2.1 负载均衡算法2.2.2 优化措施 三、Linux调度器负载均衡的存在的问题3.1 组负载不均衡问题&#xff08;Group Imbalance Bug&#xff09;3.2 …
阅读更多...
从零开始用AI开发游戏（三）背景故事

从零开始用AI开发游戏（三）背景故事

《迷域回响》背景故事 第一章&#xff1a;失落的符文纪元 在远古的“艾瑟兰”大陆&#xff0c;掌握空间魔法的「筑界者文明」曾建造了连通万界的回响迷宫——这座迷宫既是试炼场&#xff0c;也是囚笼。文明巅峰时期&#xff0c;筑界者将禁忌知识刻入虚空符文&#xff0c;嵌于…
阅读更多...
IXTUR气控永磁铁：以高精度气控和稳定磁场，为机器人应用提供稳定抓取力

IXTUR气控永磁铁：以高精度气控和稳定磁场，为机器人应用提供稳定抓取力

在现代工业生产和物流领域&#xff0c;物料的抓取与搬运是影响生产效率和成本控制的重要环节。传统夹爪在面对不同材质、形状和重量的物体时&#xff0c;常常存在适应性差、抓取不稳定、操作复杂等问题&#xff0c;导致生产流程中频繁出现停机调整&#xff0c;增加了人工干预成…
阅读更多...
硬件驱动——51单片机：寄存器、LED、动态数码管

硬件驱动——51单片机：寄存器、LED、动态数码管

目录 一、51单片机 1.寄存器 二、LED点灯 1.原理 2.封装函数 3.顺序点灯 4.特定位点灯 三、动态数码管 1.原理 2.封装函数 3.0~9跳变 4.顺序移位0~9跳变 一、51单片机 1.寄存器 51单片机共40个引脚&#xff0c;其中P0,P1,P2,P3是四个有8引脚的寄存器&#xff0…
阅读更多...
2025 香港 Web3 嘉年华：全球 Web3 生态的年度盛会

2025 香港 Web3 嘉年华：全球 Web3 生态的年度盛会

自 2023 年首届香港 Web3 嘉年华成功举办以来&#xff0c;这一盛会已成为全球 Web3 领域规模最大、影响力最深远的行业活动之一。2025 年 4 月 6 日至 9 日&#xff0c;第三届香港 Web3 嘉年华将在香港盛大举行。本届活动由万向区块链实验室与 HashKey Group 联合主办、W3ME 承…
阅读更多...
【MySQL】多表查询（笛卡尔积现象，联合查询、内连接、左外连接、右外连接、子查询）-通过练习快速掌握法

【MySQL】多表查询（笛卡尔积现象，联合查询、内连接、左外连接、右外连接、子查询）-通过练习快速掌握法

在DQL的基础查询中&#xff0c;我们已经学过了多表查询的一种&#xff1a;联合查询&#xff08;union&#xff09;。本文我们将系统的讲解多表查询。 笛卡尔积现象 首先&#xff0c;我们想要查询emp表和stu表两个表&#xff0c;按照我们之前的知识栈&#xff0c;我们直接使用…
阅读更多...
Leetcode-132.Palindrome Partitioning II [C++][Java]

Leetcode-132.Palindrome Partitioning II [C++][Java]

目录 一、题目描述 二、解题思路 【C】 【Java】 Leetcode-132.Palindrome Partitioning IIhttps://leetcode.com/problems/palindrome-partitioning-ii/description/132. 分割回文串 II - 力扣&#xff08;LeetCode&#xff09;132. 分割回文串 II - 给你一个字符串 s&…
阅读更多...
在 macOS 上优化 Vim 用于开发

在 macOS 上优化 Vim 用于开发

简介 这篇指南将带你通过一系列步骤&#xff0c;如何在 macOS 上优化 Vim&#xff0c;使其具备 代码补全、语法高亮、代码格式化、代码片段管理、目录树等功能。此外&#xff0c;我们还会解决在安装过程中可能遇到的常见错误。 1. 安装必备工具 在开始 Vim 配置之前&#xff…
阅读更多...
SOME/IP-SD -- 协议英文原文讲解8

SOME/IP-SD -- 协议英文原文讲解8

前言 SOME/IP协议越来越多的用于汽车电子行业中&#xff0c;关于协议详细完全的中文资料却没有&#xff0c;所以我将结合工作经验并对照英文原版协议做一系列的文章。基本分三大块&#xff1a; 1. SOME/IP协议讲解 2. SOME/IP-SD协议讲解 3. python/C举例调试讲解 5.1.4.4 S…
阅读更多...
【Agent实战】货物上架位置推荐助手（RAG方式+结构化prompt（CoT）+API工具结合ChatGPT4o能力Agent项目实践）

【Agent实战】货物上架位置推荐助手（RAG方式+结构化prompt（CoT）+API工具结合ChatGPT4o能力Agent项目实践）

本文原创作者：姚瑞南 AI-agent 大模型运营专家，先后任职于美团、猎聘等中大厂AI训练专家和智能运营专家岗；多年人工智能行业智能产品运营及大模型落地经验，拥有AI外呼方向国家专利与PMP项目管理证书。（转载需经授权） 目录 结论 效果图示 1.prompt 2. API工具封…
阅读更多...
PyTorch 深度学习实战（11）：强化学习与深度 Q 网络（DQN）

PyTorch 深度学习实战（11）：强化学习与深度 Q 网络（DQN）

在之前的文章中&#xff0c;我们介绍了神经网络、卷积神经网络&#xff08;CNN&#xff09;、循环神经网络&#xff08;RNN&#xff09;、Transformer 等多种深度学习模型&#xff0c;并应用于图像分类、文本分类、时间序列预测等任务。本文将介绍强化学习的基本概念&#xff0…
阅读更多...
Python学习第十九天

Python学习第十九天

Django-分页 后端分页 Django提供了Paginator类来实现后端分页。Paginator类可以将一个查询集&#xff08;QuerySet&#xff09;分成多个页面&#xff0c;每个页面包含指定数量的对象。 from django.shortcuts import render, redirect, get_object_or_404 from .models impo…
阅读更多...
Windows环境下安装部署dzzoffice+onlyoffice的私有网盘和在线协同系统

Windows环境下安装部署dzzoffice+onlyoffice的私有网盘和在线协同系统

安装前需要准备好Docker Desktop环境&#xff0c;可查看我的另一份亲测安装文章 https://blog.csdn.net/qq_43003203/article/details/146283915?spm1001.2014.3001.5501 1、安装配置onlyoffice 1、Docker 拉取onlyoffice容器镜像 管理员身份运行Windows PowerShell&#x…
阅读更多...
ChatPromptTemplate的使用

ChatPromptTemplate的使用

ChatPromptTemplate 是 LangChain 中专门用于管理多角色对话结构的提示词模板工具。它的核心价值在于&#xff0c;开发者可以预先定义不同类型的对话角色消息&#xff08;如系统指令、用户提问、AI历史回复&#xff09;&#xff0c;并通过数据绑定动态生成完整对话上下文。 1.…
阅读更多...
Blender插件NodeWrangler导入贴图报错解决方法

Blender插件NodeWrangler导入贴图报错解决方法

Blender用NodeWrangler插件 CtrlShiftT 导入贴图 直接报错 解决方法: 用CtrlshiftT打开需要导入的材质文件夹时&#xff0c;右边有一个默认勾选的相对路径&#xff0c;取消勾选就可以了。 开启node wrangler插件&#xff0c;然后在导入贴图是取消勾选"相对路径"&am…
阅读更多...
java项目之基于ssm的药店药品信息管理系统（源码+文档）

java项目之基于ssm的药店药品信息管理系统（源码+文档）

项目简介 药店药品信息管理系统实现了以下功能&#xff1a; 个人信息管理 负责管理个人用户的信息。 员工管理 负责管理药店或药品管理机构的员工信息。 药品管理 负责管理药品的详细信息&#xff0c;可能包括药品名称、成分、剂量、价格、库存等。 进货管理 负责管理药品…
阅读更多...
论文分享 | HE-Nav: 一种适用于复杂环境中空地机器人的高性能高效导航系统

论文分享 | HE-Nav: 一种适用于复杂环境中空地机器人的高性能高效导航系统

阿木实验室始终致力于通过开源项目和智能无人机产品&#xff0c;为全球无人机开发者提供强有力的技术支持&#xff0c;并推出了开源项目校园赞助活动&#xff0c;助力高校学子在学术研究与技术创新中取得更大突破。近日&#xff0c;香港大学王俊铭同学&#xff0c;基于阿木实验…
阅读更多...
ubuntu 24 安装 python3.x 教程

ubuntu 24 安装 python3.x 教程

目录 注意事项 一、安装不同 Python 版本 1. 安装依赖 2. 下载 Python 源码 3. 解压并编译安装 二、管理多个 Python 版本 1. 查看已安装的 Python 版本 2. 配置环境变量 3. 使用 update-alternatives​ 管理 Python 版本 三、使用虚拟环境为项目指定特定 Python 版本…
阅读更多...
【sql靶场】第13、14、17关-post提交报错注入保姆级教程

【sql靶场】第13、14、17关-post提交报错注入保姆级教程

目录 【sql靶场】第13、14、17关-post提交报错注入保姆级教程 1.知识回顾 1.报错注入深解 2.报错注入格式 3.使用的函数 4.URL 5.核心组成部分 6.数据编码规范 7.请求方法 2.第十三关 1.测试闭合 2.列数测试 3.测试回显 4.爆出数据库名 5.爆出表名 6.爆出字段 …
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023