入门到精通！阿里码农熬了 2 晚整理的 Java 工具，真香

Hello，今天给各位童鞋们分享 Java 工具，赶紧拿出小本子记下来吧！

定时器的应用场景有哪些？

• 定时进行数据备份

• 对系统应用进行心跳监控

• 定时同步信息到持久化数据库

• 定时检测订单的支付状态

定时器开发工具有哪些？

• Elastic-job：分布式定时任务

  不支持动态添加任务

  分布式

  支持集群

• Quartz：企业级定时任务

  支持动态添加任务

  伪分布式

  支持集群

如何简单理解 Elastic-job？

最大特点-分布式定时任务：

概念：将一个任务拆分成多个独立的任务项，由分布式的服务器分别执行某一个或几个分片项。

例子：统计 100 个数值，两台服务器各执行计算 50 个数值，最后进行数据合并。

Elastic-job 主要作用：

• 不直接提供数据处理能力

• 将分片项分配至运行中的各个服务器

• 开发者自行处理分片项与数据的关系

• 宕机，会进行作业自动转移

简单使用：

• 引入依赖：

<dependency>

<groupId>com.dangdang</groupId>

<artifactId>elastic-job-lite-core</artifactId>

<version>2.1.5</version>

</dependency>

• dataflowJob 定义：

package com.miracle.javasimplejob.job;

import com.dangdang.ddframe.job.api.ShardingContext;

import com.dangdang.ddframe.job.api.dataflow.DataflowJob;

import com.miracle.javasimplejob.model.Order;

import java.time.LocalDateTime;

import java.util.ArrayList;

import java.util.List;

import java.util.stream.Collectors;

/**

* @author Miracle

* @date 2019/6/27 22:14

*/

public class MyDataflowJob implements DataflowJob<Order> {

private List<Order> orders = new ArrayList<>();

{

for (int i = 0; i < 100; i++){

Order order = new Order();

order.setOrderId(i + 1);

order.setStatus(0);

orders.add(order);

}

}

/**

* 抓取数据

* @param shardingContext

* @return

*/

@Override

public List<Order> fetchData(ShardingContext shardingContext) {

// 订单号 % 分片总数 == 当前分片项

List<Order> orderList = orders.stream().filter(o -> o.getStatus() == 0)

.filter(o -> o.getOrderId() % shardingContext.getShardingTotalCount() == shardingContext.getShardingItem())

.collect(Collectors.toList());

List<Order> subList = null;

if (orderList.size() > 0){

subList = orderList.subList(0,10);

}

try {

Thread.sleep(1000);

} catch (InterruptedException e) {

e.printStackTrace();

}

System.out.println(LocalDateTime.now() + ",我是分片项：" + shardingContext.getShardingItem()+",我抓取的数据是："+subList);

return subList;

}

/**

* 处理数据

* @param shardingContext

* @param list

*/

@Override

public void processData(ShardingContext shardingContext, List<Order> list){

list.forEach(o -> o.setStatus(1));

try {

Thread.sleep(1000);

} catch (InterruptedException e) {

e.printStackTrace();

}

System.out.println(LocalDateTime.now() + ",我是分片项：" + shardingContext.getShardingItem()+",我正在处理中");

}

}

• job 定义：

package com.miracle.javasimplejob.job;

import com.dangdang.ddframe.job.api.ShardingContext;

import com.dangdang.ddframe.job.api.simple.SimpleJob;

/**

* @author Miracle

* @date 2019/6/25 21:42

*/

public class MySimpleJob implements SimpleJob {

@Override

public void execute(ShardingContext shardingContext) {

System.out.println("我是分片项：" + shardingContext.getShardingItem() + ",总分片项：" + shardingContext.getShardingTotalCount());

}

}

• 主线程：

package com.miracle.javasimplejob;

import com.dangdang.ddframe.job.config.JobCoreConfiguration;

import com.dangdang.ddframe.job.config.JobTypeConfiguration;

import com.dangdang.ddframe.job.config.dataflow.DataflowJobConfiguration;

import com.dangdang.ddframe.job.config.script.ScriptJobConfiguration;

import com.dangdang.ddframe.job.config.simple.SimpleJobConfiguration;

import com.dangdang.ddframe.job.lite.api.JobScheduler;

import com.dangdang.ddframe.job.lite.config.LiteJobConfiguration;

import com.dangdang.ddframe.job.reg.base.CoordinatorRegistryCenter;

import com.dangdang.ddframe.job.reg.zookeeper.ZookeeperConfiguration;

import com.dangdang.ddframe.job.reg.zookeeper.ZookeeperRegistryCenter;

import com.miracle.javasimplejob.job.MyDataflowJob;

import com.miracle.javasimplejob.job.MySimpleJob;

import org.springframework.boot.SpringApplication;

import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication

public class JavaSimpleJobApplication {

public static void main(String[] args) {

SpringApplication.run(JavaSimpleJobApplication.class, args);

new JobScheduler(zkCenter(),configurationScript()).init();

}

/**

* Zookeeper 注册中心

* @return

*/

public static CoordinatorRegistryCenter zkCenter(){

// 配置 Zookeeper(地址（多个地址使用逗号隔开）,命名空间)

ZookeeperConfiguration zc = new ZookeeperConfiguration("localhost:8074","java-simple-job");

CoordinatorRegistryCenter crc = new ZookeeperRegistryCenter(zc);

// 注册中心初始化

crc.init();

return crc;

}

/**

* job 配置

* @return

*/

public static LiteJobConfiguration configuration(){

// job 核心配置 参数解析（任务名称，表达式“0/10 从零开始，每十秒执行一次,后面的星号分别对应分时年月星期”,分片总数）

JobCoreConfiguration jcc = JobCoreConfiguration.newBuilder("mySimpleJob","0/10 * * * * ?",2).build();

// job 类型配置

JobTypeConfiguration jtc = new SimpleJobConfiguration(jcc, MySimpleJob.class.getCanonicalName());

// job 根的配置（LiteJobConfiguration）

LiteJobConfiguration ljc = LiteJobConfiguration.newBuilder(jtc).overwrite(true).build();

return ljc;

}

/**

* 流式任务配置

* @return

*/

public static LiteJobConfiguration configurationDataflow(){

// job 核心配置 参数解析（任务名称，表达式“0/10 从零开始，每十秒执行一次,后面的星号分别对应分时年月星期”,分片总数）

JobCoreConfiguration jcc = JobCoreConfiguration.newBuilder("myDataflowJob","0/10 * * * * ?",2).build();

// job 类型配置,第三参数：是否开启流式任务

JobTypeConfiguration jtc = new DataflowJobConfiguration(jcc, MyDataflowJob.class.getCanonicalName(), true);

// job 根的配置（LiteJobConfiguration）

LiteJobConfiguration ljc = LiteJobConfiguration

.newBuilder(jtc)

// 是否覆盖 zookeeper 上原来的配置，如表达式、任务名字

.overwrite(true)

.build();

return ljc;

}

/**

* job 配置

* @return

*/

public static LiteJobConfiguration configurationScript(){

// job 核心配置 参数解析（任务名称，表达式“0/10 从零开始，每十秒执行一次,后面的星号分别对应分时年月星期”,分片总数）

JobCoreConfiguration jcc = JobCoreConfiguration.newBuilder("myScriptJob","0/10 * * * * ?",2).build();

// job 类型配置,第三参数：是否开启流式任务

JobTypeConfiguration jtc = new ScriptJobConfiguration(jcc, "F:/test.cmd");

// job 根的配置（LiteJobConfiguration）

LiteJobConfiguration ljc = LiteJobConfiguration

.newBuilder(jtc)

// 是否覆盖 zookeeper 上原来的配置，如表达式、任务名字

.overwrite(true)

.build();

return ljc;

}

}

如何简单理解 Quartz？

最大特点-动态添加任务：

• 在程序中定义后相应规则可以动态添加定时任务，非常适合充当定时器工具

简单使用：

• 引入依赖：

<dependency>

<groupId>org.quartz-scheduler</groupId>

<artifactId>quartz</artifactId>

<version>2.3.1</version>

</dependency>

• 配置 quartz.properties：

# 业务调度器的实例名称

org.quartz.scheduler.instanceName=myScheduler

# 工作线程总数

org.quartz.threadPool.threadCount=1

# 设置 job 存储机制为内存存储

org.quartz.jobStore.class=org.quartz.simpl.RAMJobStore

# 设置超时超过多长时间时触发 Misfire 机制

org.quartz.jobStore.misfireThreshold=1000

• 定时器任务执行实现：

/**

* 计时任务

* @author Miracle

* @date 2019/7/6 21:04

*/

public class MyJob implements Job {

@Override

public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {

LocalTime localTime = LocalTime.now();

System.out.println("我正在执行！" + localTime.toString());

}

}

• 主线程：

public class QuartzDemo {

public static void main(String[] args) throws SchedulerException, InterruptedException {

Scheduler scheduler = StdSchedulerFactory.getDefaultScheduler();

scheduler.start();

// 配置任务处理类

JobDetail jobDetail = JobBuilder.newJob(MyJob.class)

.withIdentity("jobDetail1", "group1")

.build();

// 配置任务信息

Trigger trigger = TriggerBuilder.newTrigger()

.withSchedule(SimpleScheduleBuilder.simpleSchedule()

.withIntervalInSeconds(10)

.repeatForever()

).build();

// 将配置引入计时器中

scheduler.scheduleJob(jobDetail, trigger);

Thread.sleep(60000);

// 关闭计时器

scheduler.shutdown();

}

}

好啦，今天的文章就到这里，希望能帮助到屏幕前迷茫的你们！