零成本玩转Spring AI:基于通义千问免费额度实现人狗大战智能交互(SpringBoot3.3+JDK17)

人狗大战 Java新实现,更有趣,Java _Springboot_Spring AI 人狗大战最核心的还是用一个具体的例子来表达面向对象编程的能力,在最新的实现里面,我们扩展一下人和狗对战的流程,增加springboot,整合springaialibaba,实现一个人一边说话,一边跟狗对战的能力,主要想要体现springboot、springai的各种能力。本例使用springaialibaba+通义千问Qwenapi来构建这个智能问答系统,qwen有100万免费Token额度,可以快速实现需求。同时,因为qwen也是个开源的模型。 阅读详情

零成本玩转Spring AI:基于通义千问免费额度实现人狗大战智能交互(SpringBoot3.3+JDK17)

最近在技术社区里,看到不少开发者对AI应用开发跃跃欲试,但又被高昂的API调用成本或者复杂的模型部署流程劝退。其实,现在有很多大模型平台提供了相当慷慨的免费额度,足以支撑我们完成一个有趣的学习项目。今天,我就想和大家分享一个我前段时间捣鼓出来的小玩意儿——一个结合了经典编程练习“人狗大战”与智能对话的Spring Boot应用。整个项目几乎零成本,核心是利用了阿里云通义千问的免费API额度,再配上Spring AI Alibaba这个新潮的框架,让Java后端也能轻松玩转大模型。如果你手头有JDK 17和一个IDE,跟着走一遍,就能收获一个既能理解自然语言指令,又能进行趣味交互的Web应用。

这个项目特别适合那些想入门AI应用开发,但又不想一开始就投入真金白银的Java开发者。我们不仅会完成后端API的搭建,还会用一个简单的前端页面来展示流式响应的效果,整个过程就像搭积木一样,把Spring Boot的便捷、Spring AI的抽象能力以及通义千问的智能结合起来。你会发现,给传统的程序加上“大脑”,并没有想象中那么复杂。

1. 项目构思与环境搭建

“人狗大战”这个例子,很多朋友在初学面向对象编程时都写过,核心是通过Person和Dog两个类的交互来体现封装、继承和多态。这次,我们想给它来一次“智能化”升级。想象一下,你不再只是简单地调用person.attack()和dog.bark()这样预设好的方法,而是可以输入一句自然语言,比如“用扫帚吓唬一下小狗”,程序就能理解你的意图,并生成相应的、带有上下文和趣味性的战斗描述。这就是我们想借助大语言模型实现的效果。

要实现这个想法,我们需要几块“积木”:一个能跑起来的Spring Boot 3.3应用作为底座,一个能方便调用大模型的Java SDK(这里选择Spring AI Alibaba),以及一个能提供AI能力且成本可控的模型服务(通义千问的免费API)。首先,确保你的开发环境就绪。

1.1 开发环境与工具准备

工欲善其事,必先利其器。这个项目对工具链的要求很明确,主要是为了兼容Spring Boot 3.3和Spring AI的一些新特性。

  • JDK 17或更高版本:这是Spring Boot 3.x的硬性要求。你可以在终端用 java -version 检查。如果还没安装,建议直接下载OpenJDK 17的LTS版本。
  • 构建工具:Maven或Gradle均可。我个人习惯用Maven,本文的依赖配置也会以Maven为例。确保你的mvn -v命令能正确输出版本信息。
  • IDE:IntelliJ IDEA(社区版或旗舰版)、VS Code with Java插件,或者Eclipse with Spring Tools Suite都可以。选择你顺手的就行。
  • 网络环境:需要能正常访问阿里云的API服务端点,用于调用通义千问。

提示:虽然通义千问的模型也有开源版本可以本地部署,但为了极致简化“零成本”体验,我们优先使用其提供的云端API服务,每月有足够的免费额度供学习和轻度使用。

1.2 创建Spring Boot项目并配置依赖

打开你的IDE,使用Spring Initializr创建一个新项目。关键参数如下:

  • Project: Maven
  • Language: Java
  • Spring Boot: 3.3.x (例如 3.3.4)
  • Group & Artifact: 按你的喜好命名,例如 com.example 和 ai-battle
  • Packaging: Jar
  • Java: 17

在Dependencies选择界面,暂时只选择 Spring Web 即可。其他依赖我们手动添加,因为Spring AI Alibaba的starter尚未发布到中央仓库。

项目创建好后,打开 pom.xml 文件。我们需要手动添加Spring的Snapshot仓库和Milestone仓库,以及Spring AI Alibaba的依赖。将以下内容添加到你的pom.xml中:

<repositories>
    <repository>
        <id>spring-milestones</id>
        <name>Spring Milestones</name>
        <url>https://repo.spring.io/milestone</url>
        <snapshots>
            <enabled>false</enabled>
        </snapshots>
    </repository>
    <repository>
        <id>spring-snapshots</id>
        <name>Spring Snapshots</name>
        <url>https://repo.spring.io/snapshot</url>
        <releases>
            <enabled>false</enabled>
        </releases>
    </repository>
    <!-- 用于Spring AI Alibaba -->
    <repository>
        <id>sonatype-snapshots</id>
        <url>https://oss.sonatype.org/content/repositories/snapshots</url>
        <snapshots>
            <enabled>true</enabled>
        </snapshots>
    </repository>
</repositories>

<dependencies>
    <!-- Spring Boot Starter Web -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <!-- Spring AI Alibaba Starter -->
    <dependency>
        <groupId>com.alibaba.cloud.ai</groupId>
        <artifactId>spring-ai-alibaba-starter</artifactId>
        <version>1.0.0-M2</version> <!-- 请检查是否有更新版本 -->
    </dependency>
    <!-- 可选,用于Lombok简化代码 -->
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <optional>true</optional>
    </dependency>
</dependencies>

添加完成后,IDE通常会提示你重新加载Maven项目。点击加载,确保所有依赖都能成功解析。如果遇到spring-ai-alibaba-starter找不到,检查一下仓库地址是否正确,或者去Spring的官方仓库页面查看是否有版本更新。

2. 获取与配置通义千问API密钥

一切的基础,是获得调用大模型能力的“通行证”。阿里云的通义千问为开发者提供了非常友好的免费额度,足够我们完成这个项目乃至更多实验。

2.1 申请免费API Key

  1. 访问阿里云官网并登录。如果你没有账号,需要先注册一个。
  2. 在控制台搜索“灵积”(DashScope),这是阿里云提供的模型服务灵积平台。
  3. 进入灵积控制台,通常可以在“模型服务”或“API-KEY管理”页面找到创建API Key的选项。
  4. 创建一个新的API Key,并妥善保存。页面会明确显示该Key关联的免费额度,通常是每月一定量的Tokens,对于Qwen系列模型,这个额度足以进行成千上万次的交互。

2.2 在Spring Boot中安全配置密钥

拿到API Key后,切忌直接硬编码在代码里。我们使用Spring Boot的配置管理功能。在 src/main/resources/application.yml (或 application.properties) 文件中添加配置:

spring:
  ai:
    dashscope:
      api-key: ${DASHSCOPE_API_KEY:your-api-key-here} # 优先从环境变量读取,冒号后为默认值(仅用于本地开发测试)
      chat:
        options:
          model: qwen-max # 指定使用的模型,例如 qwen-max, qwen-plus, qwen-turbo等

最佳实践:在本地开发时,你可以暂时将your-api-key-here替换为你的真实Key。但更安全、更专业的方式是通过环境变量注入。在运行应用前,在终端设置环境变量:

# Linux/macOS
export DASHSCOPE_API_KEY=your_actual_api_key_here

# Windows (Command Prompt)
set DASHSCOPE_API_KEY=your_actual_api_key_here

# Windows (PowerShell)
$env:DASHSCOPE_API_KEY="your_actual_api_key_here"

然后启动应用,Spring Boot会自动读取这个环境变量。这样,你的敏感信息就不会出现在代码仓库中。

3. 核心业务逻辑:重构“人狗大战”

现在,我们来改造经典的“人狗大战”。核心思想是:人的攻击行为由用户输入的自然语言描述,而狗的反应则由大语言模型根据上下文动态生成。

3.1 定义领域模型

首先,创建两个简单的实体类,代表“人”和“狗”。为了简洁,我们使用Lombok注解。

// Person.java
package com.example.aibattle.entity;

import lombok.AllArgsConstructor;
import lombok.Data;

@Data
@AllArgsConstructor
public class Person {
    private String name;
    private int age;

    // 攻击行为,现在接收一个描述字符串
    public String attack(String actionDescription) {
        return String.format("%s(%d岁)%s", name, age, actionDescription);
    }
}
// Dog.java
package com.example.aibattle.entity;

import lombok.AllArgsConstructor;
import lombok.Data;

@Data
@AllArgsConstructor
public class Dog {
    private String name;
    private int age;
    private int mood = 50; // 新增心情值,用于丰富交互

    // 狗叫,但内容将由AI生成
    public String bark() {
        // 这个方法的实际内容将在Service层由AI填充
        return "";
    }
}

我在这里给Dog类加了一个mood属性,想象一下,我们可以根据AI返回的情绪词来影响这个值,让交互更有趣。比如,如果AI说“小狗害怕地缩了缩脖子”,我们可以让mood降低。

3.2 实现AI交互服务层

这是项目的核心。我们将创建一个Service,专门负责与通义千问对话。Spring AI Alibaba提供了高度抽象的 ChatClient,让调用变得异常简单。

// AIChatService.java
package com.example.aibattle.service;

import com.alibaba.cloud.ai.dashscope.chat.api.ChatCompletion;
import com.alibaba.cloud.ai.dashscope.chat.api.ChatCompletionParam;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.ai.chat.client.ChatClient;
import org.springframework.stereotype.Service;
import reactor.core.publisher.Flux;

@Service
@Slf4j
@RequiredArgsConstructor
public class AIChatService {

    private final ChatClient chatClient;

    /**
     * 获取狗对当前场景的反应(非流式)
     * @param sceneDescription 场景描述,例如“小明用扫帚吓唬了一下旺财”
     * @return 狗的反应文本
     */
    public String getDogReaction(String sceneDescription) {
        String prompt = String.format(
                "你是一只名叫旺财的小狗。请根据以下场景,以小狗的视角和语气做出反应,反应要生动有趣,带点情绪,控制在两句话内。场景:%s",
                sceneDescription
        );

        String response = chatClient.prompt()
                .user(prompt)
                .call()
                .content();

        log.info("AI生成狗的反应: {}", response);
        return response;
    }

    /**
     * 获取狗对当前场景的反应(流式)
     * @param sceneDescription 场景描述
     * @return 流式的狗的反应文本
     */
    public Flux<String> getDogReactionStream(String sceneDescription) {
        String prompt = String.format(
                "你是一只名叫旺财的小狗。请根据以下场景,以小狗的视角和语气做出反应,反应要生动有趣,带点情绪。场景:%s",
                sceneDescription
        );

        return chatClient.prompt()
                .user(prompt)
                .stream()
                .content();
    }
}

代码解释:

  1. 我们注入了 ChatClient,这是Spring AI的核心接口。
  2. getDogReaction 方法构造了一个给AI的提示词(Prompt),将用户输入的场景描述融入其中,并指定了AI需要扮演的角色(小狗旺财)和回答要求。
  3. .call().content() 是同步调用,会等待AI完整响应后一次性返回。
  4. getDogReactionStream 方法则使用了 .stream().content(),返回一个 Flux<String>,这是一个响应式流,可以逐词或逐句返回AI的生成结果,非常适合实现打字机效果。

3.3 构建RESTful API控制器

最后,我们将Service和实体类串联起来,通过HTTP接口暴露功能。

// BattleController.java
package com.example.aibattle.controller;

import com.example.aibattle.entity.Dog;
import com.example.aibattle.entity.Person;
import com.example.aibattle.service.AIChatService;
import lombok.RequiredArgsConstructor;
import org.springframework.web.bind.annotation.*;
import reactor.core.publisher.Flux;

@RestController
@RequestMapping("/api/battle")
@RequiredArgsConstructor
@CrossOrigin(origins = "*") // 为了方便前端调试,允许所有跨域请求,生产环境应具体配置
public class BattleController {

    private final AIChatService aiChatService;
    // 初始化战斗角色
    private final Person xiaoMing = new Person("小明", 18);
    private final Dog wangCai = new Dog("旺财", 3);

    @GetMapping("/action")
    public String performAction(@RequestParam String action) {
        // 1. 人执行动作
        String humanActionLog = xiaoMing.attack(action);
        // 2. 获取AI生成的狗的反应
        String dogReaction = aiChatService.getDogReaction(humanActionLog);
        // 3. 组合并返回战斗日志
        return String.format("战斗日志:\n- %s\n- 旺财:%s", humanActionLog, dogReaction);
    }

    @GetMapping(value = "/action/stream", produces = "text/event-stream")
    public Flux<String> performActionStream(@RequestParam String action) {
        // 1. 人执行动作(立即返回)
        String humanActionLog = xiaoMing.attack(action);
        Flux<String> humanActionFlux = Flux.just("战斗开始:\n", "- " + humanActionLog + "\n");

        // 2. 获取AI生成的狗的反应(流式)
        Flux<String> dogReactionFlux = aiChatService.getDogReactionStream(humanActionLog)
                .map(text -> "- 旺财:" + text + "\n");

        // 3. 合并两个流,先输出人的动作,再流式输出狗的反应
        return humanActionFlux.concatWith(dogReactionFlux);
    }
}

这个控制器提供了两个端点:

  • /api/battle/action:传统同步接口,一次性返回完整结果。
  • /api/battle/action/stream:流式接口,返回 text/event-stream 类型的数据。前端可以像接收服务器推送事件一样,实时看到文字一个个蹦出来的效果。Flux.just() 创建了一个包含人类动作的流,然后通过 .concatWith() 连接上AI生成的狗的反应流。

现在,启动你的Spring Boot应用,访问 http://localhost:8080/api/battle/action?action=轻轻地拍了拍小狗的脑袋,你应该能立刻收到一段完整的战斗描述。而流式接口的效果,我们需要一个前端页面来更好地展示。

4. 构建流式交互前端界面

一个酷炫的流式响应效果,怎么能没有界面呢?我们用最简化的方式,创建一个React单页应用来调用我们的流式接口。

4.1 创建React应用并编写核心组件

首先,在你的项目根目录外(或新建一个frontend目录),使用Create React App快速搭建:

npx create-react-app battle-frontend
cd battle-frontend

安装一个轻量级的UI库(如Ant Design)和用于处理流式数据的库(可选,这里我们用原生Fetch):

npm install antd

接下来,修改 src/App.js,创建一个简单的聊天界面。

// src/App.js
import React, { useState } from 'react';
import { Input, Button, Card, Typography, Space, Alert } from 'antd';
import './App.css';

const { TextArea } = Input;
const { Title, Paragraph } = Typography;

function App() {
  const [inputText, setInputText] = useState(''); // 用户输入
  const [battleLog, setBattleLog] = useState(''); // 战斗日志
  const [isLoading, setIsLoading] = useState(false); // 加载状态
  const [isStreaming, setIsStreaming] = useState(false); // 流式接收状态

  // 处理同步请求
  const handleSyncAction = async () => {
    if (!inputText.trim()) return;
    setIsLoading(true);
    setBattleLog('请求中...');
    try {
      const response = await fetch(`http://localhost:8080/api/battle/action?action=${encodeURIComponent(inputText)}`);
      const text = await response.text();
      setBattleLog(text);
    } catch (error) {
      setBattleLog(`请求失败: ${error.message}`);
      console.error(error);
    } finally {
      setIsLoading(false);
    }
  };

  // 处理流式请求 - 这是关键函数
  const handleStreamAction = async () => {
    if (!inputText.trim()) return;
    setIsStreaming(true);
    setBattleLog(''); // 清空日志,开始流式接收

    try {
      const response = await fetch(`http://localhost:8080/api/battle/action/stream?action=${encodeURIComponent(inputText)}`);
      const reader = response.body.getReader();
      const decoder = new TextDecoder('utf-8');
      let done = false;
      let receivedLog = '';

      while (!done) {
        const { value, done: readerDone } = await reader.read();
        done = readerDone;
        if (value) {
          const chunk = decoder.decode(value, { stream: true });
          receivedLog += chunk;
          // 每次接收到数据就更新状态,触发UI重新渲染
          setBattleLog(receivedLog);
        }
      }
    } catch (error) {
      setBattleLog(`流式请求失败: ${error.message}`);
      console.error(error);
    } finally {
      setIsStreaming(false);
    }
  };

  return (
    <div className="App" style={{ padding: '20px', maxWidth: '800px', margin: '0 auto' }}>
      <Title level={2}>🐶 智能人狗大战模拟器 🧑</Title>
      <Paragraph>输入你的动作描述(例如:“扔出一个飞盘”、“大声呵斥”、“拿出狗粮”),看看旺财如何智能反应!</Paragraph>

      <Space direction="vertical" size="large" style={{ width: '100%' }}>
        <Card title="控制面板">
          <TextArea
            rows={3}
            value={inputText}
            onChange={(e) => setInputText(e.target.value)}
            placeholder="请输入你对小狗的动作..."
            disabled={isLoading || isStreaming}
          />
          <Space style={{ marginTop: '16px' }}>
            <Button
              type="primary"
              onClick={handleSyncAction}
              loading={isLoading}
              disabled={isStreaming}
            >
              同步执行
            </Button>
            <Button
              type="default"
              onClick={handleStreamAction}
              loading={isStreaming}
              disabled={isLoading}
            >
              流式执行 (体验更佳)
            </Button>
            <Button onClick={() => { setInputText(''); setBattleLog(''); }}>
              清空
            </Button>
          </Space>
          {isStreaming && <Alert style={{ marginTop: '10px' }} message="正在接收AI流式响应..." type="info" showIcon />}
        </Card>

        <Card title="战斗日志" bordered={false}>
          <pre style={{
            whiteSpace: 'pre-wrap',
            wordBreak: 'break-word',
            backgroundColor: '#f6f8fa',
            padding: '16px',
            borderRadius: '6px',
            minHeight: '200px',
            fontFamily: 'monospace'
          }}>
            {battleLog || '日志将在这里显示...'}
          </pre>
          <Paragraph type="secondary">
            * 使用“流式执行”可以体验到文字逐字出现的效果,模拟实时对话感。
          </Paragraph>
        </Card>
      </Space>
    </div>
  );
}

export default App;

4.2 关键代码解析与注意事项

前端代码的核心是 handleStreamAction 函数:

  1. 使用 fetch 发起请求,请求我们后端定义的 text/event-stream 端点。
  2. 通过 response.body.getReader() 获取一个可读流阅读器。
  3. 在一个循环中,不断调用 reader.read(),该方法返回一个Promise,解析后包含 value (Uint8Array类型的数据块) 和 done (流是否结束) 。
  4. 使用 TextDecoder 将二进制数据块解码为字符串。
  5. 每次收到数据块,就将其追加到 receivedLog 中,并立即调用 setBattleLog(receivedLog) 更新React状态,从而实时刷新UI。

注意:由于后端Spring Boot的流式接口返回的是纯文本流,而非严格的Server-Sent Events (SSE) 格式,所以我们直接读取响应体即可。如果后端返回的是标准的SSE(以data:开头),前端解析方式需要稍作调整。

4.3 运行与联调

  1. 确保你的Spring Boot后端正在 localhost:8080 运行。
  2. 在 battle-frontend 目录下,运行 npm start。React开发服务器通常会在 localhost:3000 启动。
  3. 打开浏览器访问 http://localhost:3000。
  4. 在输入框尝试输入不同的动作,比如“假装要抢走旺财的骨头”或“温柔地呼唤旺财过来”,然后点击“流式执行”按钮。你应该能看到战斗描述和AI生成的小狗反应像打字一样逐字显示出来。

这种流式交互的体验,远比等待几秒后一次性看到所有文字要生动和有趣得多,它让AI的“思考”过程有了实时的反馈。

5. 项目扩展与优化思路

一个基础版本跑通后,我们可以从多个角度让它变得更好玩、更健壮。这里提供几个我实践过的扩展方向。

5.1 增强交互逻辑与游戏性

目前的交互还比较简单。我们可以引入状态机制,让“人狗大战”更像一个游戏。

  • 为Dog类添加更多属性:
    public class Dog {
        private String name;
        private int age;
        private int health = 100; // 生命值
        private int mood = 50; // 心情值 (0-100)
        private int obedience = 30; // 服从度
    
        // 根据AI返回的文本解析情绪,更新状态
        public void updateStatusBasedOnReaction(String aiReaction) {
            if (aiReaction.contains("开心") || aiReaction.contains("摇尾巴")) {
                this.mood = Math.min(100, this.mood + 20);
                this.obedience += 5;
            } else if (aiReaction.contains("害怕") || aiReaction.contains("躲开")) {
                this.mood = Math.max(0, this.mood - 15);
                this.health -= 5;
            } else if (aiReaction.contains("生气") || aiReaction.contains("吠叫")) {
                this.mood -= 10;
                this.obedience -= 10;
            }
        }
        // ... getters and setters
    }
    
  • 设计更复杂的Prompt:在请求AI时,不仅传递场景,还把小狗的当前状态(生命值、心情)作为上下文喂给模型,让它的反应更具个性和连续性。例如:“旺财现在心情一般(50/100),健康良好(100/100)。刚才小明对它做了:[用户输入]。请以旺财的视角反应,并可以适当体现它当前状态的影响。”
  • 增加回合制:前端可以记录多次交互,形成一个对话历史。每次新的请求,都把之前的战斗日志作为上下文传给AI,让AI能记住之前发生了什么。

5.2 后端优化与生产就绪考虑

如果想让这个小项目更接近真实应用,有几个点值得打磨:

  • 配置管理:将模型类型、API端点、超时时间、最大token数等参数全部提取到 application.yml 中,方便不同环境切换。
    spring:
      ai:
        dashscope:
          api-key: ${DASHSCOPE_API_KEY}
          chat:
            options:
              model: ${AI_MODEL:qwen-turbo} # 可配置化
              temperature: 0.8 # 创造性
              max-tokens: 500 # 限制响应长度
    
  • 异常处理与降级:在 AIChatService 中增加完善的异常处理。比如网络超时、API额度不足、返回内容不合规等情况,应该返回友好的错误信息,或者有一个备用的本地回复库。
  • 限流与监控:通义千问的免费额度虽高,但也经不住无限制调用。可以使用Spring的 @RestControllerAdvice 进行全局异常处理,并用AOP或拦截器对接口进行简单的限流(例如,每个IP每分钟最多调用10次)。同时,使用Spring Actuator或Micrometer添加简单的指标监控,记录调用次数和成功率。

5.3 探索Spring AI Alibaba的更多能力

我们目前只用了 ChatClient 最基本的对话功能。Spring AI Alibaba Starter 还封装了其他有用的功能:

  • 多模态支持:通义千问的某些模型支持图像理解。你可以尝试开发一个功能,上传一张人和狗的照片,让AI描述场景并生成对话。
  • 函数调用(Function Calling):这是让AI与你的代码逻辑深度结合的高级特性。你可以定义一些函数,比如 calculateDamage(attackType),然后在Prompt中告诉AI这些函数的存在和用途。AI在回复时,可能会请求调用某个函数,你的后端收到这个请求后执行相应逻辑,再把结果返回给AI继续生成。这可以用来实现更精确的游戏伤害计算。
  • 嵌入(Embeddings)与向量数据库:虽然在这个小游戏里用不上,但如果你想让AI拥有长期记忆,或者基于你自己的知识库进行问答,就需要用到嵌入模型将文本转换为向量,然后存入向量数据库进行相似度检索。Spring AI也提供了相应的抽象接口。

折腾完这个项目,我最深的感受是,AI应用开发的门槛正在被像Spring AI这样的框架迅速拉低。它把复杂的HTTP请求、参数组装、响应解析都封装成了简单的API调用,让我们Java开发者可以更专注于业务逻辑和创意本身。通义千问的免费额度就像一块不错的“试金石”,让你在真正投入成本前,充分验证想法和体验流程。下次如果你还想试试让AI扮演其他角色,或者接入不同的模型,只需要改改配置和Prompt,整个架构都是复用的。这种快速迭代和实验的能力,才是当前AI带给开发者最棒的礼物。

泛微E8流程监控指南:如何用SQL实时追踪审批节点状态? 本文详细介绍了如何利用SQL实时监控泛微E8系统中的审批流程状态,包括核心数据表结构解析、全链路监控SQL实战以及智能预警机制设计。通过数据库直接查询和状态关联分析,帮助企业快速定位卡顿节点,提升流程效率。适用于需要优化OA系统流程管理的企业IT人员和业务主管。 阅读详情

相关推荐

深入解析Carry4的内部结构与工作原理

本文深入解析了Xilinx/AMD FPGA中的核心硬件资源Carry4的内部结构和工作原理。作为实现超前进位的关键物理电路,Carry4通过其CI、DI、S、O、CO等端口,高效处理4位算术运算的进位逻辑。文章通过端口详解、结构分析和实战计算示例,揭示了其如何加速加法、减法等运算,并探讨了其在优化FPGA设计时序与资源利用中的关键作用。

n4o5p6q7r的博客 503

Spring Boot 3.x + Spring AI 实战:Java 一键对接本地大模型,告别 Python 中间层

Spring AI 1.0 的出现,标志着 Java 生态正式"入局"大模型赛道。以前咱们 Java 程序员想玩 AI,总得被 Python"卡脖子",现在终于可以用最熟悉的 Spring Boot 套路,纯 Java 搞定从开发到部署的全流程。本地部署 + Spring AI 的组合,特别适合那些数据敏感(不想把数据发到公网)、成本敏感(不想按 Token 付费)、或者网络受限(内网环境)的场景。

HHX_01的博客 930

GSM的“时间管理大师”:TDMA时隙、突发脉冲与逻辑信道映射实战图解

本文深入解析GSM网络中的TDMA时隙调度与逻辑信道映射技术,揭示2G网络如何通过精密的时间管理和突发脉冲设计实现高效通信。从TDMA帧结构到GMSK调制优化,详细介绍了GSM的工程艺术及其在现代通信中的延续价值。

weixin_30631587的博客 514

SpringBoot整合Spring AI Alibaba实战:用通义千问打造智能人狗对话系统(附完整代码)

本文详细介绍了如何使用SpringBoot整合Spring AI Alibaba,通过通义千问API构建智能人狗对话系统。从环境配置、项目初始化到核心业务逻辑实现,提供了完整的代码示例和优化建议,帮助开发者快速掌握AI与Java技术的结合应用。

play7的博客 948

用朴素贝叶斯分类模型判断病人是否感染幽门螺杆菌(Python实现)

朴素贝叶斯,Python

weixin_56529327的博客 1162

为什么传统CNN在视网膜分割中败给Mamba?从血管拓扑学揭秘Serp-Mamba的蛇形扫描黑科技

本文深入分析了传统CNN在视网膜血管分割任务中的局限性,特别是在处理高分辨率图像和复杂血管拓扑结构时。针对这些问题,文章重点介绍了Serp-Mamba模型的核心创新——蛇形交织自适应扫描(SIA)机制,该机制通过让扫描路径自适应地贴合血管曲率,并结合模糊驱动双重校准(ADDR)模块应对极端类别失衡,从而在视网膜血管分割任务上实现了性能的显著突破。

ss78901的博客 898

用SpringBoot玩转人狗大战:当传统OOP遇上Spring AI(含React前端流式响应实现)

本文介绍了如何利用SpringBoot和Spring AI Alibaba重构经典的人狗大战案例,实现智能交互。通过整合AI能力,开发者可以创建动态响应的对战系统,并配合React前端实现流式交互。文章详细讲解了环境配置、核心模型设计、流式后端实现及React前端处理,为Java开发者提供了AI与传统OOP结合的创新实践。

vvv99的博客 602

威纶通触摸屏与S7-1200 PLC通讯避坑指南:从TIA Portal配置到EasyBuilder Pro实战

本文详细解析了威纶通触摸屏与S7-1200 PLC通讯的完整流程与常见问题。从TIA Portal的安全设置、IP规划,到EasyBuilder Pro中的设备配置、数据地址映射,再到高级功能如报警、趋势图的实现,提供了一套从零到精通的实战避坑指南,帮助工程师高效稳定地完成项目集成。

weixin_29250403的博客 802

SpringBoot + Spring AI实战:用通义千问API打造智能人狗对话系统(附完整代码)

本文详细介绍了如何使用SpringBoot与Spring AI框架,集成通义千问API构建一个智能人狗对话系统。内容涵盖环境配置、核心服务开发、API设计及前端实现,提供了完整的代码示例,帮助Java开发者快速掌握AI能力集成到SpringBoot应用中的实战方法。

weixin_28452161的博客 396

二相混合式步进电机闭环矢量控制simulink仿真(含仿真文件)

在位置跟踪伺服系统中二相混合式步进电机闭环矢量控制simulink仿真

qq_39023633的博客 2万+

T527 uart串口配置导致系统进不去

T527 s_uart串口配置导致系统进不去。

Linux驱动开发工程师,熟悉Linux/Android底层驱动、TP、显示、IIC、网络等通用外设调试适配,Linux上层应用开发。常用平台瑞芯微、全志、恩智浦等。 678

SpringBoot整合Spring AI实现人狗对战智能交互系统

SpringBoot框架的自动配置特性大幅简化了项目搭建流程,配合Spring AI Alibaba的starter组件,仅需几行配置即可接入通义千问大模型能力。系统采用经典的MVC架构,当用户在前端输入攻击指令时,Controller层会同步触发两个动作:执行人物攻击方法,以及通过ChatClient调用AI接口获取狗狗的拟真反应。这种技术组合确保了对话过程的流畅性,用户能直观看到"狗狗"逐步生成的拟真反应,增强交互趣味性。整个过程中最惊喜的是省去了繁琐的部署配置,直接聚焦在核心的业务逻辑实现上。

JetFalcon67的博客 352

VB摄像头监控

该VB模块可对摄像头捕获的画面进行录像等,可在创建的窗口进行控制

SpringBoot整合Spring AI Alibaba实现人狗大战智能对话系统

核心业务逻辑通过ChatClient实现prompt交互,控制器层将人的攻击动作与AI响应串联成完整交互链。前端采用React+Fetch API实现流式数据传输,能实时展示AI生成的对话内容。与传统OOP练习不同,创新性地加入通义千问API,让人与AI生成的小狗进行智能对话交互。实际操作时,发现其预置的SpringBoot环境能自动处理依赖冲突问题,省去了本地配置Maven仓库的麻烦。一键部署功能直接将演示项目发布到线上,分享测试链接给同事时特别方便,比传统方式节省至少80%的环境搭建时间。

BlueTiger92的博客 569

android 蓝牙通讯demo

android 下蓝牙通讯demo,实现了发现蓝牙,使能蓝牙,通过蓝牙发送消息。

OV9734 DATASHEET,完整规格书

OV9734完整规格书,包括电气参数,尺寸规格,寄存器配置表等

5分钟跑起来:Java构建的AI人工智能智能问答系统_springboot_spring ai_LLM_人工智能_开源免费使用

智能问答系统是一种利用人工智能技术理解并回答用户提问的应用。该系统通过自然语言处理技术分析问题的含义,并在知识库中查找相关信息,以生成一个或多个可能的答案。这些答案基于对问题的理解及知识库中的数据生成。智能问答系统适用于多种场景,如在线客服、智能助手和教育辅导等,能够显著提升信息获取速度与用户体验。其关键组成部分包括:自然语言处理(NLP),用于解析问题;知识库,存储了丰富的结构化和非结构化信息;检索和匹配算法,负责从知识库中找出相关资料;答案生成机制,依据找到的信息形成回复;

whisperzzza的博客 2106

NTscan扫描工具

ntscan是一个扫描器,可以扫描没有密码和弱密码的共享,先到配置文件中填写猜测的用户名和密码,扫描过程中右侧出现的是扫描日志。

SpringBoot与Spring AI Alibaba实战:构建智能人狗对话系统

本文详细介绍了如何使用SpringBoot整合Spring AI Alibaba构建智能人狗对话系统。通过结合传统OOP与现代AI技术,实现人与虚拟宠物的自然语言交互。文章涵盖环境配置、API集成、业务逻辑实现及前端交互,为Java开发者提供完整的AI应用开发指南。

flower的专栏 322

Spring Boot 集成通义千问 API 实战

本文介绍了如何使用SpringBoot集成通义千问API构建Java智能问答工具。主要内容包括:API密钥申请、项目环境搭建、请求/响应实体封装、签名生成与API调用实现。文章详细讲解了从配置管理到接口开发的完整流程,并提供了流式响应、异常处理等优化建议。通过这个实战案例,开发者可以快速掌握Java与大模型API的集成方法,为开发智能客服、问答系统等项目打下基础,同时也可作为副业项目的技术储备。

qiuxunbin_csdn的博客 849

spring ai 教学 - 流式(stream)返回结果,基于springboot FLUX和国产大模型

本问主要介绍了如何能够在最短的代码里面实现能够直接与前端接驳的Flux流返回接口。 Flux流返回可以适应大部分市面上主流的LLM前端框架的需求。 例子使用 spring ai alibaba + 通义千问Qwen api实现,qwen有100万免费Token额度,可以快速实现需求。同时,因为qwen 也是个开源的模型,我们可以自己搭建模型来实现免费使用

whisperzzza的博客 7315

第七篇:SpringAI 实战 07|通过SpringAI接入通义千问

本文摘要:本文详细介绍了在SpringBoot 3.3.5环境中接入阿里云通义千问大模型的具体实现方案。通过OpenAI兼容协议方式,开发者可使用原生SpringAI接口无缝对接国内大模型。文章提供完整的环境配置清单(JDK21+Gradle8.8)、依赖配置、yml参数说明,并特别设计了配置校验功能,实时显示加载的API地址和模型参数。核心代码展示了通过ChatClient统一接口实现对话交互,同时解析了底层自动配置原理和常见问题排查方法,帮助开发者快速完成国产大模型集成。

一个java老菜鸟的学习手记 841

复制下来就能跑:Java智能问答系统-介绍与代码实践 - 基于springboot_springai_国产大模型

智能问答系统是一种人工智能应用,它能够理解用户提出的问题,并通过自然语言处理技术来分析和理解问题的含义。随后,系统会在其知识库中搜索相关信息,以生成一个或多个可能的答案。这些答案基于系统对问题的理解和知识库中的信息生成。自然语言处理(NLP):这是系统的核心部分,负责理解用户的输入。NLP 涉及分词、词性标注、句法分析和语义理解等多个步骤,确保系统准确地解析用户意图。知识库:存储了大量的结构化和非结构化数据,为系统提供解答问题所需的知识基础。这可以是事实数据库、规则集合或更复杂的概念框架。

whisperzzza的博客 4583
上一篇: 别浪费钱!实测6款热门USB扩展坞:从20元基础款到雷电4旗舰全横评
下一篇: 催化材料设计避坑指南:从表面能到d带中心的5个DFT关键指标解析
普通网友
博客等级 码龄27年 205粉丝 1502原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符  | 博主筛选后可见
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值