今天完成的事情：（一定要写非常细致的内容，比如说学会了盒子模型，了解了Margin） 

昨天终于将方案评审了,明天早上进行晨会跟前端对一下功能的分工.(基本一天都是做方案上的一些修修改改,所以没做啥事情.)

web

1.前台polyFinance-GirlsDream-home-web:

登录注册，银行卡管理，消息中心，查看交易流水，查看产品列表，查看产品详情，产品投资，产品续投

2.后台polyFinance-GirlsDream-admin-web:

用户管理，实名认证，产品管理，债权管理， 内容管理，消息管理， 银行管理，参数设置，意见反馈，版本管理，销量统计，后台管理

service

1.polyFinance-common-service:

短信模块，第三方存储模块，内容管理，版本管理，意见反馈

2.polyFinance-public-service:

登录注册，实名认证，银行卡管理，后台管理

3.polyFinance-business-service:

查看产品列表，查看产品详情，产品投资，产品续投，查看交易流水，消息中心， 产品管理，债权管理， 银行管理，销量统计，参数设置

4.polyFinance-etl-service

主要执行定时任务

core

polyFinance-GirlsDream-home-core:

实体类对应的model,工具类（排序、编号转换等）

cache

使用redis缓存

DB

关系型数据库mysql

学习了一下Quartz定时任务插件.

今日完成

1.动态定时任务的实现

（1）定义任务，就是需要做的事情

public class MyJob implements Job {
@Override
   public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {
System.out.println(new Date() + ":do something...........就是他 ");
   }
}

定义任务管理类

public class QuartzManager {

private static SchedulerFactory schedulerFactory = new StdSchedulerFactory();
   
   /**
    * @param jobName          任务名
    * @param jobGroupName     任务组名
    * @param triggerName      触发器名
    * @param triggerGroupName 触发器组名
    * @param jobClass         任务
    * @param cron             时间设置，参考quartz说明文档
    * @Description: 添加一个定时任务
    */
   public static void addJob(String jobName, String jobGroupName, String triggerName, String triggerGroupName, Class jobClass, String cron) {

try {
Scheduler scheduler = schedulerFactory.getScheduler();
           JobDetail jobDetail = JobBuilder.newJob(jobClass).withIdentity(jobName, jobGroupName).build();
           TriggerBuilder<Trigger> triggerBuilder = TriggerBuilder.newTrigger();
           // 触发器名,触发器组
           triggerBuilder.withIdentity(triggerName, triggerGroupName);
           triggerBuilder.startNow();
           // 触发器时间设定
           triggerBuilder.withSchedule(CronScheduleBuilder.cronSchedule(cron));
           // 创建Trigger对象
           CronTrigger trigger = (CronTrigger) triggerBuilder.build();
           
           // 调度容器设置JobDetail和Trigger
           scheduler.scheduleJob(jobDetail, trigger);
           
           // 启动
           if (!scheduler.isShutdown()) {
scheduler.start();
           }
} catch (SchedulerException e) {
e.printStackTrace();
       }

}

/**
    * @param jobName
    * @param jobGroupName
    * @param triggerName      触发器名
    * @param triggerGroupName 触发器组名
    * @param cron             时间设置，参考quartz说明文档
    * @Description: 修改一个任务的触发时间
    */
   public static void modifyJobTime(String jobName, String jobGroupName, String triggerName, String triggerGroupName, String cron) {
try {

Scheduler sched = schedulerFactory.getScheduler();
           TriggerKey triggerKey = TriggerKey.triggerKey(triggerName, triggerGroupName);
           CronTrigger trigger = (CronTrigger) sched.getTrigger(triggerKey);
           if (trigger == null) {
return;
           }

String oldTime = trigger.getCronExpression();
           if (!oldTime.equalsIgnoreCase(cron)) {
/** 方式一 ：调用 rescheduleJob 开始 */
               // 触发器
               TriggerBuilder<Trigger> triggerBuilder = TriggerBuilder.newTrigger();
               // 触发器名,触发器组
               triggerBuilder.withIdentity(triggerName, triggerGroupName);
               triggerBuilder.startNow();
               // 触发器时间设定
               triggerBuilder.withSchedule(CronScheduleBuilder.cronSchedule(cron));
               // 创建Trigger对象
               trigger = (CronTrigger) triggerBuilder.build();
               // 方式一 ：修改一个任务的触发时间
               sched.rescheduleJob(triggerKey, trigger);
               /** 方式一 ：调用 rescheduleJob 结束 */
               
               /** 方式二：先删除，然后在创建一个新的Job  */
               //JobDetail jobDetail = sched.getJobDetail(JobKey.jobKey(jobName, jobGroupName));
               //Class<? extends Job> jobClass = jobDetail.getJobClass();
               //removeJob(jobName, jobGroupName, triggerName, triggerGroupName);
               //addJob(jobName, jobGroupName, triggerName, triggerGroupName, jobClass, cron);
               /** 方式二 ：先删除，然后在创建一个新的Job */
           }
} catch (Exception e) {
throw new RuntimeException(e);
       }
}


/**
    * @param jobName
    * @param jobGroupName
    * @param triggerName
    * @param triggerGroupName
    * @Description: 移除一个任务
    */
   public static void removeJob(String jobName, String jobGroupName,
                                String triggerName, String triggerGroupName) {
try {
Scheduler sched = schedulerFactory.getScheduler();
           
           TriggerKey triggerKey = TriggerKey.triggerKey(triggerName, triggerGroupName);
           // 停止触发器
           sched.pauseTrigger(triggerKey);
           // 移除触发器
           sched.unscheduleJob(triggerKey);
           // 删除任务
           sched.deleteJob(JobKey.jobKey(jobName, jobGroupName));
       } catch (Exception e) {
throw new RuntimeException(e);
       }

}

/**
    * @Description:启动所有定时任务
    */
   public static void startJobs() {
try {
Scheduler sched = schedulerFactory.getScheduler();
           sched.start();
       } catch (Exception e) {
throw new RuntimeException(e);
       }
}

/**
    * @Description:关闭所有定时任务
    */
   public static void shutdownJobs() {
try {
Scheduler sched = schedulerFactory.getScheduler();
           if (!sched.isShutdown()) {
sched.shutdown();
           }
} catch (Exception e) {
throw new RuntimeException(e);
       }
}

}

测试定时任务

public class Test {
public static String JOB_NAME = "动态任务调度";
   public static String TRIGGER_NAME = "动态任务触发器";
   public static String JOB_GROUP_NAME = "XLXXCC_JOB_GROUP";
   public static String TRIGGER_GROUP_NAME = "XLXXCC_JOB_GROUP";
   
   public static void main(String[] args) {
try {
System.out.println("【系统启动】开始(每1秒输出一次)...");
           QuartzManager.addJob(JOB_NAME, JOB_GROUP_NAME, TRIGGER_NAME, TRIGGER_GROUP_NAME, MyJob.class, "0/1 * * * * ?");
           
           Thread.sleep(5000);
           System.out.println("【修改时间】开始(每5秒输出一次)...");
           QuartzManager.modifyJobTime(JOB_NAME, JOB_GROUP_NAME, TRIGGER_NAME, TRIGGER_GROUP_NAME, "0/5 * * * * ?");
           
           Thread.sleep(6000);
           System.out.println("//移除定时】开始...");
           QuartzManager.removeJob(JOB_NAME, JOB_GROUP_NAME, TRIGGER_NAME, TRIGGER_GROUP_NAME);
           System.out.println("【移除定时】成功");
       } catch (Exception e) {
e.printStackTrace();
       }
}

}

里面的一些类的功能

• 1、org.quartz.Job 
  它是一个抽象接口，表示一个工作，也就是我们要执行的具体内容，他只定义了一个几口方法： 
  void execute(JobExecutionContext context) 
  作用等同Spring的： 
  org.springframework.scheduling.quartz.QuartzJobBean
• 2、org.quartz.JobDetail 
  JobDetail表示一个具体的可执行的调度程序，Job是这个可执行程调度程序所要执行的内容，它包含了这个任务调度的方案和策略。 
  他的实现类： 
  org.quartz.impl.JobDetailImpl 
  作用等同Spring： 
  org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean
• 3、org.quartz.Trigger 
  它是一个抽象接口，表示一个调度参数的配置，通过配置它，来告诉调度容器什么时候去调用JobDetail。 
  他的两个实现类: 
  org.quartz.impl.triggers.SimpleTriggerImpl 
  org.quartz.impl.triggers.CronTriggerImpl 
  等同于Spring的: 
  org.springframework.scheduling.quartz.SimpleTriggerBean 
  org.springframework.scheduling.quartz.CronTriggerBean 
  前者只支持按照一定频度调用任务，如每隔30分钟运行一次。 
  后者既支持按照一定频度调用任务，又支持定时任务。
• 4、org.quartz.Scheduler 
  代表一个调度容器，一个调度容器中可以注册多个JobDetail和Trigger。当Trigger与JobDetail组合，就可以被Scheduler容器调度了。它的方法有start()、shutdown()等方法，负责管理整个调度作业。 
  等同Spring的： org.springframework.scheduling.quartz.SchedulerFactoryBean

明天计划的事情：（一定要写非常细致的内容） 

进行晨会并且进行服务接口的分工.
遇到的问题：（遇到什么困难，怎么解决的） 

还是有不少逻辑上的问题,需要后面在做的工程中理清.
收获：（通过今天的学习，学到了什么知识）

通过对方案的修改,加强了自己对需求的理解.