智能数据分析报告生成系统（Java技术栈）

原创 已于 2025-12-24 15:47:11 修改 · 1k 阅读 · 26 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#AI

于 2025-12-23 12:32:40 首次发布

一、介绍

智能数据分析报告生成系统是一种基于多智能体协作的自动化报告生成解决方案。该系统通过多个专业智能体的分工协作，将复杂的分析任务转化为高质量的数据报告。以下是系统的主要工作流程，主要过程包括任务拆解、数据查询、数据分析、报告生成、结果校验。

二、技术栈

本系统基于Java技术栈构建，主要采用以下技术组件：JDK 17作为开发环境，Spring Boot作为基础框架，结合LangChain4J智能体开发框架和LangGraph4J任务编排工具，并利用Spring AI Alibaba NL2SQL实现自然语言转SQL功能。这些技术的组合充分展现了Java生态在多智能体协作领域的实现能力。

三、实现思路

1、Maven依赖

<properties>
   <java.version>17</java.version>
   <langgraph4j.version>0.24.0</langgraph4j.version>
   <langchain4j.version>1.3.0</langchain4j.version>
</properties>

<dependencies>
   <dependency>
      <groupId>com.alibaba.cloud.ai</groupId>
      <artifactId>spring-ai-alibaba-starter-nl2sql</artifactId>
      <exclusions>
         <exclusion>
            <groupId>com.alibaba.cloud.ai</groupId>
            <artifactId>spring-ai-alibaba-starter-dashscope</artifactId>
         </exclusion>
      </exclusions>
   </dependency>

   <!-- Other spring dependencies -->
   <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-webflux</artifactId>
   </dependency>

   <dependency>
      <groupId>org.springframework.ai</groupId>
      <artifactId>spring-ai-advisors-vector-store</artifactId>
   </dependency>

   <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-data-jpa</artifactId>
   </dependency>

   <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-jdbc</artifactId>
   </dependency>

   <!-- LangGraph4j 核心（图流程、状态管理） -->
   <dependency>
      <groupId>org.bsc.langgraph4j</groupId>
      <artifactId>langgraph4j-core</artifactId>
      <version>1.7.4</version>
   </dependency>
   <!-- LangGraph4j + Spring AI 适配（简化模型集成） -->
   <dependency>
      <groupId>org.bsc.langgraph4j</groupId>
      <artifactId>langgraph4j-spring-ai</artifactId>
      <version>1.7.4</version>
   </dependency>

   <dependency>
      <groupId>org.projectlombok</groupId>
      <artifactId>lombok</artifactId>
      <version>1.18.42</version>
   </dependency>

   <!-- LangChain4j -->
   <dependency>
      <groupId>dev.langchain4j</groupId>
      <artifactId>langchain4j</artifactId>
      <version>${langchain4j.version}</version>
   </dependency>
   <dependency>
      <groupId>dev.langchain4j</groupId>
      <artifactId>langchain4j-open-ai</artifactId>
      <version>${langchain4j.version}</version>
   </dependency>
</dependencies>

2、数据集准备

为了更好的进行测试，准备了一些demo测试数据集，通过代码在系统启动时写入到mysql数据库中，代码如下：

@Repository
public interface OrderRepository extends JpaRepository<Orders, Long> {

}

@Entity
@Data
@NoArgsConstructor
@AllArgsConstructor
public class Orders {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String category; // 商品品类（如 电子产品、服装、食品）
    private LocalDate orderDate; // 订单日期
    private BigDecimal amount; // 订单金额（元）
    private Integer quantity; // 销售数量
    private String region; // 销售区域（如 华北、华东）
}

@Component
public class OrderDataInitializer {

    @Autowired
    private OrderRepository orderRepository;

    @PostConstruct
    @Transactional
    public void initTestData() {
        // 插入 2025年Q3（7-9月）的订单数据
        List<Orders> orders = Arrays.asList(
                new Orders(null, "电子产品", LocalDate.of(2025, 7, 10), new BigDecimal("3999.00"), 100, "华东"),
                new Orders(null, "电子产品", LocalDate.of(2025, 8, 15), new BigDecimal("3999.00"), 150, "华北"),
                new Orders(null, "电子产品", LocalDate.of(2025, 9, 20), new BigDecimal("3999.00"), 180, "华南"),
                new Orders(null, "服装", LocalDate.of(2025, 7, 5), new BigDecimal("599.00"), 200, "华东"),
                new Orders(null, "服装", LocalDate.of(2025, 8, 25), new BigDecimal("599.00"), 220, "华北"),
                new Orders(null, "服装", LocalDate.of(2025, 9, 10), new BigDecimal("599.00"), 250, "华南"),
                new Orders(null, "食品", LocalDate.of(2025, 7, 12), new BigDecimal("99.00"), 500, "华东"),
                new Orders(null, "食品", LocalDate.of(2025, 8, 18), new BigDecimal("99.00"), 600, "华北"),
                new Orders(null, "食品", LocalDate.of(2025, 9, 25), new BigDecimal("99.00"), 700, "华南"),
                new Orders(null, "家居", LocalDate.of(2025, 7, 20), new BigDecimal("1999.00"), 80, "华东")
        );

        orders.forEach(orders1 -> {
            orderRepository.save(orders1);
        });
        System.out.println("测试订单数据初始化完成！");
    }
}

3、智能体开发

3.1、定义智能体状态

在开发智能体之前，我们需要定义一个智能体状态类，用于智能体协作期间数据的共享，自定义的状态类需要继承AgentState这个基础类，具体的状态类的代码结构如下：

public class AnalysisTaskState extends AgentState {

    public static final Map<String, Channel<?>> SCHEMA = Map.of(
            "user_query", Channels.appender(ArrayList::new)
    );

    public AnalysisTaskState(Map<String, Object> initData) {
        super(initData);
    }

    public boolean needRetry() {
        return (boolean) this.value("needRetry").get();
    }
}

initData类负责数据初始化，并作为智能体间共享数据的载体。

3.2、任务拆分智能体

收到用户请求后，我会按照以下步骤进行分析和拆解，具体过程可参考代码中的提示词内容

@Component
public class DataAnalysisAgent implements NodeAction<AnalysisTaskState> {
   @Autowired
   private ChatModel dashScopeChatModel;

    public Map<String, Object> analyze(AnalysisTaskState state) {

        String userQuery = (String) state.data().get("userQuery");
        String rawData = (String) state.data().get("rawData");
        String targetIndicator = (String) state.data().get("targetIndicator");
        String analysisDimension = (String) state.data().get("analysisDimension");

        // 构建提示词：让 AI 分析原始数据，生成结构化结论
        String prompt = String.format("""
                以下是原始数据（%s按%s统计）：
                %s
                
                请完成以下分析：
                1. 找出%s排名前3的%s；
                2. 计算前3名的总%s占比；
                3. 分析前3名领先的可能原因（结合电商行业常识）；
                4. 结论简洁明了，分点说明（不要超过500字）。
                
                用户原始需求：%s
                """, targetIndicator, analysisDimension, rawData, targetIndicator, analysisDimension, targetIndicator, userQuery);

        // 调用 AI 模型获取分析结果
        String analysisResult = dashScopeChatModel.chat(prompt);
        System.out.println("数据分析结论：" + analysisResult);

        return Map.of("analysisResult", analysisResult);
    }

    @Override
    public Map<String, Object> apply(AnalysisTaskState analysisTaskState) throws Exception {
        return analyze(analysisTaskState);
    }
}

3.3、数据查询智能体

基于用户输入，系统可通过NL2SQL技术自动生成数据分析查询语句，无需预先定义查询规则，直接根据需求动态生成。

@Component
public class DataQueryAgent implements NodeAction<AnalysisTaskState> {

    private final JdbcTemplate jdbcTemplate;

    @Autowired
    private SimpleNl2SqlService simpleNl2SqlService;

    @Autowired
    private SimpleVectorStoreService simpleVectorStoreService;

    @Autowired
    private DbConfig dbConfig;

    public DataQueryAgent(JdbcTemplate jdbcTemplate) {
        this.jdbcTemplate = jdbcTemplate;
    }

    public Map<String, Object> query(AnalysisTaskState state) {
        // 1. 构建 SQL（根据指标和维度动态生成）
        SchemaInitRequest schemaInitRequest = new SchemaInitRequest();
        schemaInitRequest.setDbConfig(dbConfig);
        schemaInitRequest.setTables(Arrays.asList("orders"));
        String sql = "";
        String userQuery = (String) state.data().get("userQuery");
        try {
            simpleVectorStoreService.schema(schemaInitRequest);
            sql = simpleNl2SqlService.nl2sql(userQuery);
            System.out.println("nl2sql根据用户Message[" + userQuery + "]生成sql：" + sql);
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
        
        // 2. 调用数据库工具执行查询
        List<Map<String, Object>> resultList = jdbcTemplate.queryForList(sql);
        String rawData = resultList.toString();
        System.out.println("查询原始数据：" + rawData);

        // 3. 返回更新后的状态
        return Map.of("rawData", rawData);
    }
    
    @Override
    public Map<String, Object> apply(AnalysisTaskState analysisTaskState) throws Exception {
        return query(analysisTaskState);
    }
}

3.4、数据分析智能体

@Component
public class DataAnalysisAgent implements NodeAction<AnalysisTaskState> {
   @Autowired
   private ChatModel dashScopeChatModel;

    public Map<String, Object> analyze(AnalysisTaskState state) {

        String userQuery = (String) state.data().get("userQuery");
        String rawData = (String) state.data().get("rawData");
        String targetIndicator = (String) state.data().get("targetIndicator");
        String analysisDimension = (String) state.data().get("analysisDimension");

        // 构建提示词：让 AI 分析原始数据，生成结构化结论
        String prompt = String.format("""
                以下是原始数据（%s按%s统计）：
                %s
                
                请完成以下分析：
                1. 找出%s排名前3的%s；
                2. 计算前3名的总%s占比；
                3. 分析前3名领先的可能原因（结合电商行业常识）；
                4. 结论简洁明了，分点说明（不要超过500字）。
                
                用户原始需求：%s
                """, targetIndicator, analysisDimension, rawData, targetIndicator, analysisDimension, targetIndicator, userQuery);

        // 调用 AI 模型获取分析结果
        String analysisResult = dashScopeChatModel.chat(prompt);
        System.out.println("数据分析结论：" + analysisResult);

        return Map.of("analysisResult", analysisResult);
    }

    @Override
    public Map<String, Object> apply(AnalysisTaskState analysisTaskState) throws Exception {
        return analyze(analysisTaskState);
    }
}

3.5、报告生成智能体

@Component
public class ReportGenerationAgent implements NodeAction<AnalysisTaskState> {

    @Autowired
    private ChatModel dashScopeChatModel;

    public Map<String, Object> generate(AnalysisTaskState state) {
        String userQuery = (String) state.data().get("userQuery");
        String analysisResult = (String) state.data().get("analysisResult");
        String timeRange = (String) state.data().get("timeRange");

        // 构建提示词：生成结构化报告
        String prompt = String.format("""
                请根据以下分析结论，生成一份正式的数据分析报告，格式要求：
                1. 标题：包含时间范围、分析主题（如《2025年Q3电商%s分析报告》）；
                2. 核心数据：提炼前3名的关键数据；
                3. 原因分析：简述领先原因；
                4. 业务建议：基于分析结果给出2-3条可落地的建议；
                5. 语言正式、专业，段落清晰（不要超过800字）。
                
                分析结论：%s
                用户原始需求：%s
                时间范围：%s
                """, state.data().get("targetIndicator"), analysisResult, userQuery, timeRange);

        String reportDraft = dashScopeChatModel.chat(prompt);
        System.out.println("报告草稿：" + reportDraft);

        return Map.of("reportDraft", reportDraft);
    }

    @Override
    public Map<String, Object> apply(AnalysisTaskState analysisTaskState) throws Exception {
        return generate(analysisTaskState);
    }
}

3.6、结果校验智能体

@Component
public class ResultValidationAgent implements NodeAction<AnalysisTaskState> {

    @Autowired
    private ChatModel dashScopeChatModel;

    public Map<String, Object> validate(AnalysisTaskState state) {
        String userQuery = (String) state.data().get("userQuery");
        String reportDraft = (String) state.data().get("reportDraft");

        // 构建提示词：校验报告是否符合需求
        String prompt = String.format("""
                请判断以下报告是否完全满足用户需求，仅返回结论（二选一）：
                1. 符合：报告包含用户需求的所有关键点，数据准确、结构完整；
                2. 不符合：报告缺少关键信息、数据错误或未回应核心需求。
                
                用户需求：%s
                报告内容：%s
                
                仅返回「符合」或「不符合」，不要额外内容！
                """, userQuery, reportDraft);

        String validationResult = dashScopeChatModel.chat(prompt);
        System.out.println("报告校验结果：" + validationResult);

        // 标记是否需要重试
        boolean needRetry = "不符合".equals(validationResult.trim());
        if (needRetry) {
            return Map.of("needRetry", true);
        } else {
            return Map.of("finalReport", reportDraft,
                    "needRetry", false);
        }
    }

    @Override
    public Map<String, Object> apply(AnalysisTaskState analysisTaskState) throws Exception {
        return validate(analysisTaskState);
    }
}

4、任务编排

多智能体协作需通过任务编排实现，具体协作流程如下图所示：

任务编排通过langgrap4j实现，它主要包括了Node、Edge、ConditionalEdge等组成，代码如下：

public class AgentWorkflowConfig {

    @Bean
    public ChatModel dashScopeChatModel() {
        return OpenAiChatModel.builder()
                .modelName("qwen3-max")
                .apiKey("your-api-key")
                .baseUrl("https://dashscope.aliyuncs.com/compatible-mode/v1")
                .temperature(0.8)
                .build();
    }

    @Bean
    public StateGraph<AnalysisTaskState> analysisWorkflow(
            TaskDecompositionAgent decompositionAgent,
            DataQueryAgent dataQueryAgent,
            DataAnalysisAgent dataAnalysisAgent,
            ReportGenerationAgent reportGenerationAgent,
            ResultValidationAgent validationAgent
    ) throws GraphStateException {
        // 1. 创建状态图构建器（指定状态类型）
        StateGraph<AnalysisTaskState> graph = new StateGraph<>(AnalysisTaskState.SCHEMA, initData -> new AnalysisTaskState(initData));

        // 2. 添加节点（每个智能体对应一个节点）
        graph.addNode("decompose", AsyncNodeAction.node_async(decompositionAgent)); // 任务拆解
        graph.addNode("query", AsyncNodeAction.node_async(dataQueryAgent)); // 数据查询
        graph.addNode("analyze", AsyncNodeAction.node_async(dataAnalysisAgent)); // 数据分析
        graph.addNode("generateReport", AsyncNodeAction.node_async(reportGenerationAgent)); // 报告生成
        graph.addNode("validate", AsyncNodeAction.node_async(validationAgent)); // 结果校验

        // 3. 定义流程流转规则（边）
        // 起始节点 → 任务拆解节点
        graph.addEdge(GraphDefinition.START, "decompose");

        // 任务拆解 → 数据查询 → 数据分析 → 报告生成 → 结果校验
        graph.addEdge("decompose", "query");
        graph.addEdge("query", "analyze");
        graph.addEdge("analyze", "generateReport");
        graph.addEdge("generateReport", "validate");

        // 结果校验 → 分支判断（符合则结束，不符合则重试任务拆解）
        graph.addConditionalEdges(
                "validate",
                // 分支判断逻辑：根据 needRetry 决定下一个节点
                AsyncEdgeAction.edge_async(state -> {
                    return state.needRetry() ? "retry" : "end";
                }),
                // 映射：判断结果 → 目标节点（重试→任务拆解，结束→终止流程）
                Map.of(
                        "retry", "decompose",
                        "end", StateGraph.END
                )
        );

        // 4. 构建并返回状态图
        return graph;
    }
}

5、配置文件

本文采用的使用dashscope提供的大模型，可以去阿里百炼平台注册使用免费的。

spring.datasource.url=jdbc:mysql://127.0.0.1:3306/orderdb?useUnicode=true&characterEncoding=utf8&zeroDateTimeBehavior=convertToNull&useSSL=false&serverTimezone=GMT%2B8
spring.datasource.driverClassName=com.mysql.cj.jdbc.Driver
spring.datasource.username=root
spring.datasource.password=123456
spring.jpa.database-platform=org.hibernate.dialect.MySQLDialect
spring.jpa.hibernate.ddl-auto=create-drop
spring.jpa.show-sql=true
#spring.h2.console.enabled=true
#spring.h2.console.path=/h2-console

chatBi.dbConfig.url=jdbc:mysql://127.0.0.1:3306/orderdb?useUnicode=true&characterEncoding=utf8&zeroDateTimeBehavior=convertToNull&useSSL=false&serverTimezone=GMT%2B8
chatBi.dbConfig.username=root
chatBi.dbConfig.password=123456
chatBi.dbConfig.schema=orderdb
chatBi.dbConfig.connection-type=jdbc
chatBi.dbConfig.dialect-type=mysql

spring.ai.openai.base-url=https://dashscope.aliyuncs.com/compatible-mode
spring.ai.openai.api-key=your-api-key
spring.ai.openai.model=qwen3-max
spring.ai.vectorstore.analytic.enabled=false
spring.ai.vectorstore.analytic.collectName=chatBi
spring.ai.vectorstore.analytic.regionId:=cn-hangzhou
spring.ai.vectorstore.analytic.dbInstanceId=
spring.ai.vectorstore.analytic.managerAccount=
spring.ai.vectorstore.analytic.managerAccountPassword=
spring.ai.vectorstore.analytic.namespace=chat
spring.ai.vectorstore.analytic.namespacePassword=chat
spring.ai.vectorstore.analytic.defaultTopK=6
spring.ai.vectorstore.analytic.defaultSimilarityThreshold=0.75
spring.ai.vectorstore.analytic.accessKeyId=
spring.ai.vectorstore.analytic.accessKeySecret=

6、测试验证

@RestController
public class ReportController {

    @Autowired
    private StateGraph<AnalysisTaskState> analysisWorkflow;

    @Autowired
    private ChatModel chatModel;

    @GetMapping("/api/generateReport")
    public String analysisWorkflow(@RequestParam("userQuery") String userQuery) throws GraphStateException {
        CompiledGraph<AnalysisTaskState> app = analysisWorkflow.compile();
        GraphRepresentation graph = app.getGraph(GraphRepresentation.Type.PLANTUML, "智能数据分析报告生成系统");
        System.out.println("智能数据分析报告生成系统 PlantUML Graph:\n"+ graph.content());

        Optional<AnalysisTaskState> result = app.invoke(Map.of("userQuery", userQuery));

        // 3. 输出最终报告
        System.out.println("\n==================== 最终数据分析报告 ====================");
        return (String) result.get().data().get("finalReport");
    }
}

四、总结

本文基于Java技术开发了一套智能数据分析报告生成系统，通过多智能体协同工作机制，实现了自动化报告生成功能。

疾风sxp
关注
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值