AI 助理
文档备案控制台
开发者社区 彭世瑜的博客 文章 正文

Java学习笔记：定时任务调度工具之Quartz

2021-11-26 327
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： Java学习笔记：定时任务调度工具之Quartz

Quartz官网

http://www.quartz-scheduler.org/

特点

  1. 强大的调度功能
  2. 灵活的应用方式
  3. 分布式和集群能力

主要用到的设计模式

  1. Builder 模式
  2. Factory 模式
  3. 组件模式
  4. 链式写法

三个核心概念

  1. 调度器
  2. 任务
  3. 触发器


Quartz 体系结构

JobDetail
scheduler
trigger
    -SimpleTrigger
    -CronTrigger

重要组成

Job
JobDetail
JobBuilder
JobStore
Trigger
TriggerBuilder
ThreadPool
Scheduler
Calendar
监听器
JobListener
TriggerListener
SchedulerListener

Quartz 实例

依赖

<dependency>
    <groupId>org.quartz-scheduler</groupId>
    <artifactId>quartz</artifactId>
    <version>2.3.2</version>
</dependency>
<dependency>
    <groupId>org.slf4j</groupId>
    <artifactId>slf4j-simple</artifactId>
    <version>1.7.25</version>
    <scope>compile</scope>
</dependency>

定义任务 MyJob.java

package timer;
import org.quartz.Job;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import java.text.SimpleDateFormat;
import java.util.Date;
public class MyJob implements Job {
    @Override
    public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {
        SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        System.out.println(dateFormat.format(new Date()));
    }
}

调度任务 QuartzDemo.java

package timer;
import org.quartz.*;
import org.quartz.impl.StdSchedulerFactory;
public class QuartzDemo {
    public static void main(String[] args) throws SchedulerException {
        // 创建JobDetail
        JobDetail jobDetail = JobBuilder
                .newJob(MyJob.class)
                .withIdentity("myJob", "group1")
                .build();
        // 每2s执行一次，无限循环
        SimpleScheduleBuilder scheduleBuilder = SimpleScheduleBuilder
                .simpleSchedule()
                .withIntervalInSeconds(2)
                .repeatForever();
        // 创建Trigger
        Trigger trigger = TriggerBuilder.newTrigger()
                .withIdentity("myTrigger", "group1")
                .startNow()
                .withSchedule(scheduleBuilder)
                .build();
        // 通过工厂方法创建Scheduler实例
        SchedulerFactory factory = new StdSchedulerFactory();
        Scheduler scheduler = factory.getScheduler();
        scheduler.start();
        scheduler.scheduleJob(jobDetail, trigger);
    }
}

Job 和 JobDetail

1、Job 源码：

package org.quartz;
public interface Job {
    void execute(JobExecutionContext context)
        throws JobExecutionException;
}

2、Job 的生命周期：


每次调度器执行 Job 时，调用 execute 方法前会创建一个新的 Job 实例

调用完成后，关联的 Job 对象实例会被释放，释放的实例会被垃圾回收机制回收


3、JobDetail：


JobDetail 为 Job 实例提供了许多设置属性，以及 JobDataMap 成员变量属性，

它用来存储特定 Job 实例的状态信息，调度器需要借助 JobDetail 对象来添加 Job 实例


4、JobDetail 重要属性

name
group 默认值DEFAULT
jobClass
jobDataMap
// 创建JobDetail
JobDetail jobDetail = JobBuilder
        .newJob(MyJob.class)
        .withIdentity("myJob", "group1")
        .build();
// 打印jobDetail属性
System.out.println(jobDetail.getKey().getName()); // myJob
System.out.println(jobDetail.getKey().getGroup()); // group1
System.out.println(jobDetail.getJobClass().getName()); // timer.MyJob

JobExecutionContext & JobDataMap

1、JobExecutionContext：


Scheduler 给 Job 传递参数


2、JobDataMap:


可以装载任何可序列化的数据对象

实现了 Map 接口


设置 JobDataMap 部分代码

// 创建JobDetail
JobDetail jobDetail = JobBuilder
        .newJob(MyJob.class)
        .withIdentity("myJob", "group1")
        .usingJobData("name", "jobDetail")
        .build();
// 每2s执行一次，无限循环
SimpleScheduleBuilder scheduleBuilder = SimpleScheduleBuilder
        .simpleSchedule()
        .withIntervalInSeconds(2)
        .repeatForever();
// 创建Trigger
Trigger trigger = TriggerBuilder.newTrigger()
        .withIdentity("myTrigger", "group1")
        .startNow()
        .usingJobData("name", "trigger")
        .withSchedule(scheduleBuilder)
        .build();

获取 JobDataMap

方法一：直接从 JobDataMap 对象中获取

package timer;
import org.quartz.*;
import java.text.SimpleDateFormat;
import java.util.Date;
public class MyJob implements Job {
    @Override
    public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {
        // 获取 jobkey
        JobKey jobKey = jobExecutionContext.getJobDetail().getKey();
        System.out.println(jobKey.getName()); // myJob
        System.out.println(jobKey.getGroup()); // group1
        // 获取JobDetail的DataMap
        JobDataMap jobDetailDataMap = jobExecutionContext.getJobDetail().getJobDataMap();
        System.out.println(jobDetailDataMap.getString("name"));
        // jobDetail
        // 获取Trigger的DataMap
        JobDataMap triggerDataMap = jobExecutionContext.getTrigger().getJobDataMap();
        System.out.println(triggerDataMap.getString("name"));
        // trigger
        // 获取合并后的DataMap
        JobDataMap dataMap = jobExecutionContext.getMergedJobDataMap();
        System.out.println(dataMap.getString("name"));
        // trigger
    }
}

方法二：定义同名变量获取

package timer;
import org.quartz.Job;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
public class MyJob implements Job {
    private String name;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    @Override
    public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {
        System.out.println(this.name);
    }
}

Trigger

Trigger 是触发器，用来告诉调度程序作业什么时候触发

触发器通用属性

JobKey： Job 实例的标识，触发器被触发时，指定的 job 实例会执行
StartTime：触发器的时间表首次被触发的时间，类型是 Java.util.Date
EndTime：触发器不再被触发的时间 Java.util.Date

设置部分代码

// 获取3秒后的时间
Date startDate = new Date();
startDate.setTime(startDate.getTime() + 3000);
// 获取6秒后的时间
Date endDate = new Date();
endDate.setTime(endDate.getTime() + 3000);
// 创建Trigger
Trigger trigger = TriggerBuilder.newTrigger()
        .withIdentity("myTrigger", "group1")
        .startAt(startDate)
        .endAt(endDate)
        .usingJobData("name", "trigger")
        .withSchedule(scheduleBuilder)
        .build();

Job 中获取 Trigger 数据

package timer;
import org.quartz.Job;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import org.quartz.Trigger;
import java.text.SimpleDateFormat;
public class MyJob implements Job {
    @Override
    public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {
        SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        Trigger trigger = jobExecutionContext.getTrigger();
        // 获取开始时间和结束时间
        System.out.println(dateFormat.format(trigger.getStartTime()));
        System.out.println(dateFormat.format(trigger.getEndTime()));
        // 获取JobKey
        System.out.println(trigger.getJobKey().getName());
        System.out.println(trigger.getJobKey().getGroup());
    }
}

SimpleTrigger

指定时间段内执行一次作业任务

或者在指定的时间间隔内多次执行作业任务

任务

package timer;
import org.quartz.Job;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import java.text.SimpleDateFormat;
import java.util.Date;
public class MyJob implements Job {
    @Override
    public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {
        SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        System.out.println(dateFormat.format(new Date()));
    }
}

示例 1

// 获取3秒后的时间
Date startDate = new Date();
startDate.setTime(startDate.getTime() + 3000);
// 3秒钟之后执行一次
Trigger trigger = TriggerBuilder.newTrigger()
        .withIdentity("myTrigger", "group1")
        .startAt(startDate)
        .build();

示例 2

// 获取3秒后的时间
Date startDate = new Date();
startDate.setTime(startDate.getTime() + 3000);
// 每2s执行一次，无限循环
SimpleScheduleBuilder scheduleBuilder = SimpleScheduleBuilder
        .simpleSchedule()
        .withIntervalInSeconds(2)
        .withRepeatCount(3);
// 3s之后执行第一次，之后每隔2s执行一次，重复3次
Trigger trigger = TriggerBuilder.newTrigger()
        .withIdentity("myTrigger", "group1")
        .startAt(startDate)
        .withSchedule(scheduleBuilder)
        .build();

示例 3

// 获取3秒后的时间
Date startDate = new Date();
startDate.setTime(startDate.getTime() + 3000L);
// 获取6秒后的时间
Date endDate = new Date();
endDate.setTime(endDate.getTime() + 6000L);
// 每2s执行一次，无限循环
SimpleScheduleBuilder scheduleBuilder = SimpleScheduleBuilder
        .simpleSchedule()
        .withIntervalInSeconds(2)
        .withRepeatCount(3);
// 3s之后执行第一次，之后每隔2s执行一次，6秒之后结束
Trigger trigger = TriggerBuilder.newTrigger()
        .withIdentity("myTrigger", "group1")
        .startAt(startDate)
        .endAt(endDate)
        .withSchedule(scheduleBuilder)
        .build();

注意：


重复次数可以为 0、正整数、SimpleTrigger.REPEAT_INDEFINITELY

重复执行间隔必须为 0 或长整数

一旦执行了 endTime 参数，那么会覆盖重复次数参数的效果

CronTrigger

基于日历的作业调度器，而不是像 SimpleTrigger 那样精确指定时间间隔，较为常用

格式：

秒 分 时 日 月 周 年

特殊符号说明

, 或 10,12
- 区间 10-12
/ 每 */5
* 所有值 *
? 不指定

提示

  1. L 和 W 可以组合使用
  2. 周字段不区分大小写 mon 与 MON 相同
  3. 利用在线生成工具

示例

// 每2秒执行一次
Trigger trigger = TriggerBuilder.newTrigger()
                .withIdentity("myTrigger", "group1")
                .withSchedule(CronScheduleBuilder.cronSchedule("*/2 * * * * ? *"))
                .build();

Scheduler

StdSchedulerFactory

配置参数一般存储在 quartz.properties

主要函数

// 将job和trigger注册到scheduler
Date scheduleJob(JobDetail jobDetail, Trigger trigger)
// 启动
void start()
// 暂停
void standby()
// 关闭
// true 等待所有任务执行完成再关闭
// false 直接关闭
void shutdown()

quartz.properties

文档位置和加载顺序

jar 包下有默认配置

组成部分

  1. 调度器属性
  2. 线程池属性
  3. 作业存储位置
  4. 插件配置

SpringMVC 整合 Quartz

新建 maven webapp

依赖

webmvc
context
aop
core

配置 Quartz 的两种方式：

  1. MethodInvokingJobDetailFactoryBean 适合调用特定 bean 方法时很方便
  2. JobDetailFactoryBean 支持传入一些参数

项目结构

$ tree -I target
.
├── pom.xml
├── src
│   └── main
│       ├── java
│       │   └── com
│       │       └── mouday
│       │           ├── controller
│       │           │   └── IndexController.java
│       │           └── quartz
│       │               ├── ComplexJob.java
│       │               └── SimpleJob.java
│       ├── resources
│       │   └── dispatcher-servlet.xml
│       └── webapp
│           ├── WEB-INF
│           │   └── web.xml
│           └── index.jsp

1、pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0
         http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>org.example</groupId>
    <artifactId>spring-mvc-demo</artifactId>
    <version>1.0-SNAPSHOT</version>
    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <spring.version>5.2.6.RELEASE</spring.version>
    </properties>
    <build>
        <finalName>springquartz</finalName>
        <plugins>
            <!-- tomcat7插件 maven 命令 tomcat7:run 启动项目-->
            <plugin>
                <groupId>org.apache.tomcat.maven</groupId>
                <artifactId>tomcat7-maven-plugin</artifactId>
                <version>2.2</version>
                <configuration>
                    <port>8080</port>
                    <path>/</path>
                    <uriEncoding>UTF-8</uriEncoding>
                    <!--添加忽略war包检查标签，则可以让tomcat7：run指令正常启动tomcat-->
                    <ignorePackaging>true</ignorePackaging>
                    <contextFile>src/main/webapp/WEB-INF/web.xml</contextFile>
                    <contextReloadable>true</contextReloadable>
                </configuration>
            </plugin>
        </plugins>
    </build>
    <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-beans</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context-support</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-tx</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-web</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aop</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-expression</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>commons-logging</groupId>
            <artifactId>commons-logging</artifactId>
            <version>1.2</version>
        </dependency>
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>javax.servlet-api</artifactId>
            <version>4.0.1</version>
            <scope>provided</scope>
        </dependency>
        <dependency>
            <groupId>jstl</groupId>
            <artifactId>jstl</artifactId>
            <version>1.2</version>
        </dependency>
        <!-- 需要 context-support tx 的支持-->
        <dependency>
            <groupId>org.quartz-scheduler</groupId>
            <artifactId>quartz</artifactId>
            <version>2.3.2</version>
        </dependency>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-simple</artifactId>
            <version>1.7.25</version>
            <scope>compile</scope>
        </dependency>
    </dependencies>
</project>

2、src/main/webapp/index.jsp

<html>
    <body>
        <h2>Hello World!</h2>
    </body>
</html>

3、src/main/webapp/WEB-INF/web.xml

<?xml version="1.0" encoding="utf-8" ?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee
        http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
         version="4.0">
  <!-- 配置分发器 默认加载配置文件：名字-servlet.xml -->
  <servlet>
    <servlet-name>dispatcher</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    <!-- 指定配置文件 -->
    <init-param>
      <param-name>contextConfigLocation</param-name>
      <param-value>classpath:dispatcher-servlet.xml</param-value>
    </init-param>
    <!-- 表示容器再启动时立即加载servlet -->
    <load-on-startup>1</load-on-startup>
  </servlet>
  <servlet-mapping>
    <servlet-name>dispatcher</servlet-name>
    <!-- 处理所有URL -->
    <url-pattern>/</url-pattern>
  </servlet-mapping>
  <welcome-file-list>
    <welcome-file>index.jsp</welcome-file>
  </welcome-file-list>
</web-app>

4、src/main/resources/dispatcher-servlet.xml

<?xml version="1.0" encoding="utf-8" ?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:p="http://www.springframework.org/schema/p"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:mvc="http://www.springframework.org/schema/mvc"
       xsi:schemaLocation="
       http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/context
       http://www.springframework.org/schema/context/spring-context.xsd
       http://www.springframework.org/schema/mvc
       http://www.springframework.org/schema/mvc/spring-mvc.xsd
">
    <!--防止中文乱码-->
    <bean class="org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter">
        <property name="messageConverters">
            <list>
                <bean class="org.springframework.http.converter.StringHttpMessageConverter">
                    <property name="supportedMediaTypes">
                        <list>
                            <value>text/html; charset=utf-8</value>
                        </list>
                    </property>
                </bean>
            </list>
        </property>
    </bean>
    <!-- 添加注解驱动-->
    <mvc:annotation-driven/>
    <!-- 默认扫描包路径-->
    <context:component-scan base-package="com.mouday"/>
    <!-- view-controller 可以直接不通过controller处理request，转发到view-->
    <mvc:view-controller path="/" view-name="index"/>
    <!-- 渲染器-->
    <bean id="jspViewResolver" class="org.springframework.web.servlet.view.UrlBasedViewResolver">
        <property name="viewClass" value="org.springframework.web.servlet.view.JstlView"/>
        <!-- 结果视图的前缀-->
        <property name="prefix" value="/"/>
        <!-- 结果视图的后缀-->
        <property name="suffix" value=".jsp"/>
    </bean>
    <!--配置Quartz-->
    <bean id="simpleJobDetail" class="org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean">
        <property name="targetObject" ref="simpleJob"/>
        <property name="targetMethod" value="sayHello"/>
    </bean>
    <bean id="complexJobDetail" class="org.springframework.scheduling.quartz.JobDetailFactoryBean">
        <property name="jobClass" value="com.mouday.quartz.ComplexJob"/>
        <property name="jobDataMap">
            <map>
                <entry key="name" value="Tom"/>
            </map>
        </property>
        <property name="Durability" value="true"/>
    </bean>
    <!--一s之后执行，每隔2s执行一次-->
    <bean id="simpleTrigger" class="org.springframework.scheduling.quartz.SimpleTriggerFactoryBean">
        <property name="jobDetail"  ref="simpleJobDetail"/>
        <property name="startDelay" value="1000"/>
        <property name="repeatInterval" value="2000"/>
    </bean>
    <bean id="cronTrigger" class="org.springframework.scheduling.quartz.CronTriggerFactoryBean">
        <property name="jobDetail" ref="complexJobDetail"/>
        <property name="cronExpression" value="0/3 * * * * ? *"/>
    </bean>
    <bean class="org.springframework.scheduling.quartz.SchedulerFactoryBean">
        <property name="jobDetails">
            <list>
                <ref bean="simpleJobDetail"/>
                <ref bean="complexJobDetail"/>
            </list>
        </property>
        <property name="triggers">
            <list>
                <ref bean="simpleTrigger"/>
                <ref bean="cronTrigger"/>
            </list>
        </property>
    </bean>
</beans>

5、src/main/java/com/mouday/controller/IndexController.java

package com.mouday.controller;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.ResponseBody;
/**
 * 仅用于SpringMVC服务测试
 */
@Controller
public class IndexController {
    @GetMapping("/login")
    @ResponseBody
    public String login(
            @RequestParam(value = "name", required = false) String name,
            @RequestParam(value = "password", required = false) String password
    ) {
        return "name:" + name + " password:" + password;
    }
}

6、src/main/java/com/mouday/quartz/SimpleJob.java

package com.mouday.quartz;
import org.springframework.stereotype.Component;
import java.text.SimpleDateFormat;
import java.util.Date;
@Component("simpleJob")
public class SimpleJob {
    public void sayHello(){
        SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        System.out.println("SimpleJob "+ dateFormat.format(new Date()) );
    }
}

7、src/main/java/com/mouday/quartz/ComplexJob.java

package com.mouday.quartz;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import org.springframework.scheduling.quartz.QuartzJobBean;
import java.text.SimpleDateFormat;
import java.util.Date;
public class ComplexJob extends QuartzJobBean {
    private String name;
    public void setName(String name) {
        this.name = name;
    }
    protected void executeInternal(JobExecutionContext jobExecutionContext) throws JobExecutionException {
        SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        System.out.println("ComplexJob name: " + this.name + " " + dateFormat.format(new Date()));
    }
}

总结

  1. Timer 优缺点
  2. Quartz 三大要素
  3. Quartz&Spring 融合
文章标签：
Java
Spring
Maven
调度
存储
设计模式
关键词：
Java工具
Java学习笔记
Java调度
Java定时任务
Java定时任务调度
编程达人
目录
相关文章
JJLIN距离
|
4月前
|
人工智能 监控 Java
Java与AI智能体：构建自主决策与工具调用的智能系统
随着AI智能体技术的快速发展，构建能够自主理解任务、制定计划并执行复杂操作的智能系统已成为新的技术前沿。本文深入探讨如何在Java生态中构建具备工具调用、记忆管理和自主决策能力的AI智能体系统。我们将完整展示从智能体架构设计、工具生态系统、记忆机制到多智能体协作的全流程，为Java开发者提供构建下一代自主智能系统的完整技术方案。
JJLIN距离
674 4
JJLIN距离
|
5月前
|
人工智能 Java API
Java AI智能体实战：使用LangChain4j构建能使用工具的AI助手
随着AI技术的发展，AI智能体（Agent）能够通过使用工具来执行复杂任务，从而大幅扩展其能力边界。本文介绍如何在Java中使用LangChain4j框架构建一个能够使用外部工具的AI智能体。我们将通过一个具体示例——一个能获取天气信息和执行数学计算的AI助手，详细讲解如何定义工具、创建智能体并处理执行流程。本文包含完整的代码示例和架构说明，帮助Java开发者快速上手AI智能体的开发。
JJLIN距离
1910 8
JJLIN距离
|
5月前
|
人工智能 缓存 监控
使用LangChain4j构建Java AI智能体：让大模型学会使用工具
AI智能体是大模型技术的重要演进方向，它使模型能够主动使用工具、与环境交互，以完成复杂任务。本文详细介绍如何在Java应用中，借助LangChain4j框架构建一个具备工具使用能力的AI智能体。我们将创建一个能够进行数学计算和实时信息查询的智能体，涵盖工具定义、智能体组装、记忆管理以及Spring Boot集成等关键步骤，并展示如何通过简单的对话界面与智能体交互。
JJLIN距离
1822 1
aliyun0598152856
|
5月前
|
Java
Java 数组学习笔记
本文整理Java数组常用操作：遍历、求和、查找、最值及二维数组行求和等典型练习，涵盖静态初始化、元素翻倍、去极值求平均等实例，帮助掌握数组基础与应用。
aliyun0598152856
413 3
aliyun0598152856
|
5月前
|
小程序 Java 知识图谱
Java 学习笔记 —— BMI & BMR 计算器
这是一个使用 Java 编写的 BMI 与 BMR 计算器小程序，可输入年龄、性别、身高和体重，计算身体质量指数（BMI）和基础代谢率（BMR），并输出健康评估结果。通过该项目，掌握了 Java 的输入处理、数据验证、条件判断、数学运算及格式化输出等基础知识，是 Java 初学者的理想练习项目。
aliyun0598152856
345 7
游客ib7xsk7hcucuo
|
8月前
|
Java 数据安全/隐私保护
银行转账虚拟生成器app，银行卡转账截图制作软件，java实现截图生成工具【仅供装逼娱乐用途】
本项目提供了一套基于Java的图片处理教学方案，包含自定义图片生成、图像水印添加及合法电子凭证生成技术示例。
游客ib7xsk7hcucuo
535 0
游客f2553rqkp3jqi
|
8月前
|
Java 数据安全/隐私保护 计算机视觉
银行转账虚拟生成器app，银行卡转账截图制作软件，java实现截图生成工具【仅供装逼娱乐用途】
本内容提供Java生成自定义图片的示例代码，涵盖基础图像创建、文本添加及保存功能，适合学习2D图形编程。包括教学示例图片生成、文本图层处理和数字水印技术实现方案。
游客f2553rqkp3jqi
452 23
啦啦啦191
|
8月前
|
Java API 微服务
2025 年 Java 从入门到精通学习笔记全新版
《Java学习笔记：从入门到精通（2025更新版）》是一本全面覆盖Java开发核心技能的指南，适合零基础到高级开发者。内容包括Java基础（如开发环境配置、核心语法增强）、面向对象编程（密封类、接口增强）、进阶技术（虚拟线程、结构化并发、向量API）、实用类库与框架（HTTP客户端、Spring Boot）、微服务与云原生（容器化、Kubernetes）、响应式编程（Reactor、WebFlux）、函数式编程（Stream API）、测试技术（JUnit 5、Mockito）、数据持久化（JPA、R2DBC）以及实战项目（Todo应用）。
啦啦啦191
458 5
34789737
|
8月前
|
安全 Java 编译器
JD-GUI，java反编译工具及原理: JavaDecompiler一个Java反编译器
Java Decompiler (JD-GUI) 是一款由 Pavel Kouznetsov 开发的图形化 Java 反编译工具，支持 Windows、Linux 和 Mac Os。它能将 `.class` 文件反编译为 Java 源代码，支持多文件标签浏览、高亮显示，并兼容 Java 5 及以上版本。JD-GUI 支持对整个 Jar 文件进行反编译，可跳转源码，适用于多种 JDK 和编译器。其原理基于将字节码转换为抽象语法树 (AST)，再通过反编译生成代码。尽管程序可能带来安全风险，但可通过代码混淆降低可读性。最新版修复了多项识别错误并优化了内存管理。
34789737
6337 1
pickstar-33775
|
9月前
|
机器学习/深度学习 消息中间件 存储
【高薪程序员必看】万字长文拆解Java并发编程！(9-2)：并发工具-线程池
🌟 ​大家好，我是摘星！​ 🌟今天为大家带来的是并发编程中的强力并发工具-线程池，废话不多说让我们直接开始。
pickstar-33775
355 0

热门文章

最新文章

  • 1
    深入分析Java线程中断机制
  • 2
    在java 8 stream表达式中实现if/else逻辑
  • 3
    JAVA并行框架：Fork/Join
  • 4
    fastdfs java 使用
  • 5
    Java“AccessControlException”报错解决
  • 6
    推荐几个值得收藏的 Java 网站
  • 7
    Java中不同包下类与类之间的访问
  • 8
    栈的链表实现_JAVA描述《数据结构与算法分析》
  • 9
    【JAVA百炼成仙】渡劫篇 下——Map集合（HashMap、TreeMap）
  • 10
    Java弱引用(WeakReferences)
  • 1
    Java 核心知识与技术全景解析
    154
  • 2
    Java 17 及以上版本核心特性在现代开发实践中的深度应用与高效实践方法 Java 开发实践
    334
  • 3
    Java 核心知识点与实战应用解析
    137
  • 4
    Java 基础知识点全面梳理包含核心要点及难点解析 Java 基础知识点
    294
  • 5
    Java泛型类型擦除以及类型擦除带来的问题
    222
  • 6
    Java 17 新特性与微服务开发的实操指南
    355
  • 7
    从基础语法到实战应用的 Java 入门必备知识全解析
    168
  • 8
    解决java.lang.IllegalArgumentException: Invalid uri由无效查询引起的问题
    886
  • 9
    Java 基础篇完整学习攻略
    135
  • 10
    Java int和Integer的区别
    255

    • 相关课程

    更多
  • Java面试疑难点解析 - 面试技巧及语言基础
  • Java面试疑难点解析 - Java Web开发
  • Java面试疑难点解析 - 系统架构及项目设计
  • Java编程入门
  • Java面向对象编程
  • Java高级编程

    • 相关电子书

    更多
  • Spring Cloud Alibaba - 重新定义 Java Cloud-Native
  • The Reactive Cloud Native Arch
  • JAVA开发手册1.5.0
    • 下一篇
    第五届伏魔挑战赛如约来袭，诚邀各路高手来战！