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();
}
}
好啦，明天的文章就到这里，心愿能帮忙到屏幕前迷茫的你们！