• mysql5.7以上版本在常会报关于only_full_group_by的错误，可以在sql_mode中关闭他，网上查找的解
• 在[mysqld]中添加代码

sql_mode ='STRICT_TRANS_TABLES,NO_ZERO_IN_DATE,NO_ZERO_DATE,ERROR_FOR_DIVISION_BY_ZERO,NO_AUTO_CREATE_USER,NO_ENGINE_SUBSTITUTION'

重启mysql
sudo service mysql restart
mysql5.7以上版本在常会报关于only_full_group_by的错误，可以在sql_mode中关闭他，网上查找的解
查看参数是否存在
mysql> SELECT @@sql_mode;
+------------------------------------------------------------------------------------------------------------------------+
| @@sql_mode                                                                                                             |
+------------------------------------------------------------------------------------------------------------------------+
| STRICT_TRANS_TABLES,NO_ZERO_IN_DATE,NO_ZERO_DATE,ERROR_FOR_DIVISION_BY_ZERO,NO_AUTO_CREATE_USER,NO_ENGINE_SUBSTITUTION |
+------------------------------------------------------------------------------------------------------------------------+
1 row in set (0.00 sec)

mysql> SELECT @@GLOBAL.sql_mode;
+------------------------------------------------------------------------------------------------------------------------+
| @@GLOBAL.sql_mode                                                                                                      |
+------------------------------------------------------------------------------------------------------------------------+
| STRICT_TRANS_TABLES,NO_ZERO_IN_DATE,NO_ZERO_DATE,ERROR_FOR_DIVISION_BY_ZERO,NO_AUTO_CREATE_USER,NO_ENGINE_SUBSTITUTION |
+------------------------------------------------------------------------------------------------------------------------+
1 row in set (0.00 sec)

 Path     %MYSQL_HOME%\bin

net start MySQL【或者是MySQL57】

use mysql;
GRANT ALL ON *.* TO root@'%' IDENTIFIED BY '密码' WITH GRANT OPTION;
flush privileges;

URIs

REST API使用统一资源标识符（URI）来寻址资源。在当今互联网上，充斥着各种各样的URI设计规则，既有像//api.example.com/louvre/leonardo-da-vinci/mona-lisa这样能够清楚的传达API资源模型的文章，也有很难理解的文章，例如：//api.example.com/68dd0-a9d3-11e0-9f1c-0800200c9a66 ；Tim Berners-Lee在他的“Axioms of Web Architecture”一文中将URI的不透明度总结成一句话：

唯一可以使用标识符的是引用对象。在不取消引用时，就不应该查看URI字符串的内容以获取其他信息。 
——蒂姆·伯纳斯 - 李

客户端必须遵循Web的链接范例，将URI视为不透明标识符。

REST API设计人员应该在考虑将REST API资源模型传达给潜在的客户端开发者的前提下，创造URI。在这篇文章中，我将尝试为REST API URI 引入一套设计规则。

先跳过规则，URI的通用语法也适用与本文中的URI。RFC 3986定义了通用URI语法，如下所示：

URI = scheme “://” authority “/” path [ “?” query ][ “#” fragment ]

规则1：URI结尾不应包含（/）

这是作为URI路径中处理中最重要的规则之一，正斜杠（/）不会增加语义值，且可能导致混淆。REST API不允许一个尾部的斜杠，不应该将它们包含在提供给客户端的链接的结尾处。

许多Web组件和框架将平等对待以下两个URI： 
http://api.canvas.com/shapes/ 
http://api.canvas.com/shapes

但是，实际上URI中的每个字符都会计入资源的唯一身份的识别中。

两个不同的URI映射到两个不同的资源。如果URI不同，那么资源也是如此，反之亦然。因此，REST API必须生成和传递精确的URI，不能容忍任何的客户端尝试不精确的资源定位。

有些API碰到这种情况，可能设计为让客户端重定向到相应没有尾斜杠的URI（也有可能会返回301 - 用来资源重定向）。

规则2：正斜杠分隔符（/）必须用来指示层级关系

URI的路径中的正斜杠（/）字符用于指示资源之间的层次关系。

例如： 
(http://api.canvas.com/shapes/polygons/quadrilaterals/squares ；

规则3：应使用连字符（ - ）来提高URI的可读性

为了使您的URI容易让人们理解，请使用连字符（ - ）字符来提高长路径中名称的可读性。在路径中，应该使用连字符代空格连接两个单词 。

例如： 
http://api.example.com/blogs/guy-levin/posts/this-is-my-first-post

规则4：不得在URI中使用下划线（_）

一些文本查看器为了区分强调URI，常常会在URI下加上下划线。这样下划线（_）字符可能被文本查看器中默认的下划线部分地遮蔽或完全隐藏。

为避免这种混淆，请使用连字符（ - ）而不是下划线

规则5：URI路径中首选小写字母

方便时，URI路径中首选小写字母，因为大写字母有时会导致一些问题。RFC 3986将URI定义为区分大小写，但scheme 和 host components除外。

例如： 
http://api.example.com/my-folder/my-doc

HTTP://API.EXAMPLE.COM/my-folder/my-doc 
这个URI很好。URI格式规范（RFC 3986）认为该URI与URI＃1相同。

http://api.example.com/My-Folder/my-doc 
而这个URI与URI 1和2不同，这可能会导致不必要的混淆。

规则6：文件扩展名不应包含在URI中

在Web上，（.）字符通常用于分隔URI的文件名和扩展名。 
REST API不应在URI中包含人造文件扩展名，来指示邮件实体的格式。相反，他们应该依赖通过Content-Type中的header传递media type，来确定如何处理正文的内容。

http://api.college.com/students/3248234/courses/2005/fall.json 
http://api.college.com/students/3248234/courses/2005/fall

如上所示：不应使用文件扩展名来表示格式。

应鼓励REST API客户端使用HTTP提供的格式选择机制Accept request header。

为了是链接和调试更简单，REST API应该支持通过查询参数来支持媒体类型的选择。

规则7：端点名称是单数还是复数？

keep-it-simple的原则在这里同样适用。虽然一些”语法学家”会告诉你使用复数来描述资源的单个实例是错误的，但实际上为了保持URI格式的一致性建议使用复数形式。

本着API提供商更容易实施和API使用者更容易操作的原则，可以不必纠结一些奇怪的复数（person/people，goose/geese）。

但是应该怎么处理层级关系呢？如果一个关系只能存在于另一个资源中，RESTful原则就会提供有用的指导。我们来看一下这个例子。学生有一些课程。这些课程在逻辑上映射到学生终端，如下所示：

http://api.college.com/students/3248234/courses - 检索id为3248234的学生学习的所有课程的清单。 
http://api.college.com/students/3248234/courses/physics -检索该学生的物理课程

结论

当你在设计REST API服务时，您必须注意这些由URI定义的资源。

正在构建的服务中的每个资源将至少有一个URI标识它。这个URI最好是有意义的，且能充分描述资源。URI应遵循可预测的层次结构，用来提高其可理解性，可用性：可预测的意义在于它们是一致的，它的层次结构在数据关系上是有意义的。

RESTful API是为使用者编写的。URI的名称和结构应该能够向使用者传达更清晰的含义。通过遵循上述规则，您将创建一个更清晰的的REST API与更友好的客户端。这些并不是REST的规则或约束，仅仅是API的增强和补充。

我也建议你来看看http://blog.restcase.com/5-basic-rest-api-design-guidelines/这篇文章。

最后，望大家牢记：你在为你的客户端设计API URI，而不仅仅是为你的数据。

       从classpath根目录下加载指定名称的文件

 * this.getClass().getResourceAsStream("testVariables.bpmn")   

       从当前包下加载指定名称的文件

 * this.getClass().getResourceAsStream("/testVariables.bpmn") 

       从classpath根目录下加载指定名称的文件

1、概述

activiti系统一共有23个表，包括流程定义表、一般数据信息表、流程运行实例表、流程历史记录表、用户用户组表。

2、Activiti 流程定义表

流程定义表，流程定义表也可以叫做是静态资源库，静态资源包括图片、定义规则等。它有部署信息表、流程模型表、流程定义表

1、ACT_RE_DEPLOYMENT（部署信息表）

包括：部署流程名称、类型、部署时间

2、ACT_RE_MODEL（模型表）

名称,key、类型、创建时间、最后修改时间、版本、数据源信息、部署ID、编辑源值ID、编辑源额外值ID（外键ACT_GE_BYTEARRAY ）

3、ACT_RE_PROCDEF（流程定义表） 

包括流程定义、类型、流程名称、流程key、版本号、部署ID、资源名称、图片资源名称、描述信息、是否从key启动、暂停状态。

3、Activiti 运行实例表

运行实例表记录流程流转过程中产生的数据，一般数据分为两个部分流程数据、业务数据。流程数据是指activiti流程引擎流转过程中的数据，包括流程执行实例数据接、任务数据、执行任务人员信息、变量信息。业务数据则是流程过程中保存的表单数据，例如：如请假的请假单数据、报销单数据、审批意见信息等，此部分数据一般需要自己建数据表进行保存，在之前的jbpm4中没有保存业务数据。

1、ACT_RU_EVENT_SUBSCR（事件子脚本）作用未知

事件名称（EVENT_NAME_）、事件类型(EVENT_TYPE_)、流程执行ID(EXECUTION_ID_)、流程实例ID(PROC_INST_ID_)、活动ID(ACTIVITY_ID_)、配置信息(CONFIGURATION_)、创建时间（CREATED_）

2、ACT_RU_EXECUTION（执行中流程执行）核心我的代办任务查询表

流程实例ID（PROC_INST_ID_），业务key（BUSINESS_KEY_）、父执行流程（PARENT_ID_）、流程定义Id（外键PROC_DEF_ID_）、实例id（ACT_ID_）、激活状态（IS_ACTIVE_）、并发状态（is_concurrent）、is_scope、is_evnet_scope、暂停状态（suspension_state）、缓存结束状态（cached_end_state）

3、ACT_RU_IDENTITYLINK（身份联系）

用户组ＩＤ（GROUP_ID_）、用户组类型(TYPE_)、用户ID(USER_ID_)、任务Id（外键：TASK_ID_）、流程实例ID（外键：PROC_INST_ID_）、流程定义Id（外键:PROC_DEF_ID_）

4、ACT_RU_JOB(运行中的任务)

5、ACT_RU_TASK（执行中实时任务）代办任务查询表

实例id（外键EXECUTION_ID_）、流程实例ID（外键PROC_INST_ID_）、流程定义ID（PROC_DEF_ID_）、任务名称（NAME_）、父节任务ID（PARENT_TASK_ID_）

、任务描述（DESCRIPTION_）、任务定义key（TASK_DEF_KEY_）、所属人（OWNER_）、代理人员 (ASSIGNEE_)、代理团（DELEGATION_）、优先权（PRIORITY_）、创建时间（CREATE_TIME_）、执行时间（DUE_DATE_）、暂停状态（SUSPENSION_STATE_）

6、ACT_RU_VARIABLE（实时变量）

变量名称（NAME_）、编码类型(TYPE_)、执行实例ID(EXECUTION_ID_)、流程实例Id(PROC_INST_ID_)、任务id(TASK_ID_)、字节组ID（BYTEARRAY_ID_）、DOUBLE_、LONG_、TEXT_、TEXT2_

3、流程历史记录

流程历史信息表，activiti历史记录表包括节点信息表、附件信息表、历史审批记录表、理想详细信息表、历史身份信息表、流程实例历史表、任务历史表、历史变量表。（节点信息表、附件信息表、历史审批记录表、理想详细信息表、历史身份信息表）这些表目前还未知是如何用的。（流程实例历史表、任务历史表、历史变量）三个表可以查询我已完成任务、任务追踪等。

1、ACT_HI_ACTINST（活动实例信息）

流程定义ID（PROC_DEF_ID_）、流程实例ID（PROC_INST_ID_）、流程执行ID（EXECUTION_ID_）、活动ID（ACT_ID_）、活动名称（TASK_ID_）、活动类型（ACT_TYPE_）、任务ID、（TASK_ID_）、请求流程实例ID（CALL_PROC_INST_ID_）、代理人员（ASSIGNEE_）、开始时间（START_TIME_）、结束时间(END_TIME_)、时长（DURATION_）

2、ACT_HI_ATTACHMENT（附件信息）

用户id（USER_ID_）、名称（NAME_）、描述（DESCRIPTION_）、类型（TYPE_）、任务Id（TASK_ID_）、流程实例ID（PROC_INST_ID_）、连接（URL_）、内容Id（CONTENT_ID_）

3、ACT_HI_COMMENT（历史审批信息）

类型（TYPE_）、时间（TIME_）、用户Id（USER_ID_）、任务Id（TASK_ID_）、流程实例Id（PROC_INST_ID_）、活动（ACTION_）、消息（MESSAGE_）、全部消息（FULL_MSG_）

4、ACT_HI_DETAIL（历史详细信息）

数据类型（TYPE_）、创建时间(TIME_)、名称(NAME_)、流程实例ID（PROC_INST_ID_）、执行实例Id(EXECUTION_ID_)、任务Id(TASK_ID_)、活动实例Id(ACT_INST_ID_)、变量类型(VAR_TYPE_)、字节数组Id、DOUBLE_、LONG_、值（TEXT_）、值2（TEXT2_）

5、ACT_HI_IDENTITYLINK（历史身份信息）

任务Id（TASK_ID_）、流程实例Id（PROC_INST_ID_）、userId（USER_ID_）、用户组类型Type（TYPE_）、用户组ID（GROUP_ID_）

6、ACT_HI_PROCINST（历史流程实例信息）核心表

流程实例ID（PROC_INST_ID_）、业务Key（BUSINESS_KEY_）、流程定义Id（PROC_DEF_ID_）、开始时间（START_TIME_）、结束时间（END_TIME_）、时长（DURATION_）、发起人员Id（START_USER_ID_）、开始节点（START_ACT_ID_）、结束节点（END_ACT_ID_）、超级流程实例Id（SUPER_PROCESS_INSTANCE_ID_）、删除理由（DELETE_REASON_）

7、ACT_HI_TASKINST（历史任务流程实例信息）核心表

流程实例ID（PROC_INST_ID_）、任务定义Key（BUSINESS_KEY_）、流程定义Id（PROC_DEF_ID_）、执行ID（EXECUTION_ID_）、名称（NAME_）、父任务iD（PARENT_TASK_ID_）、描述（DESCRIPTION_）、所属人（OWNER_）、代理人（ASSIGNEE_）、开始时间（START_TIME_）、结束时间（END_TIME_）、时长（DURATION_）、删除理由（DELETE_REASON__）、优先级（PRIORITY_）、应完成时间（DUE_DATE_）、表单key（FORM_KEY_）

8、ACT_HI_VARINST（历史变量信息）

流程实例ID（PROC_INST_ID_）、执行ID（EXECUTION_ID_）、任务Id、名称（NAME_）、变量（TASK_ID_）、类型（VAR_TYPE_）、字节数组ID（BYTEARRAY_ID_）、DOUBLE_、LONG_、TEXT_、TEXT2_

4、一般数据

1、ACT_GE_BYTEARRAY（字节数据表）

名称（NAME_）、部署Id（DEPLOYMENT_ID_）、字节数据（BYTES_）、发生的（GENERATED_）

2、ACT_GE_PROPERTY（一般属性表）

名称（NAMe_）、值(VALUe_)

5、用户用户组表

Activit 的用户用户组表，包括用户信息、用户组信息、用户与用户组间的关系、用户信息与用户之间的关系。在实际开发中未采用，用的实际系统中用户。

1、ACT_ID_GROUP（用户组表）

名称（NAME_）、类型(TYPE_)

2、ACT_ID_USER（用户表）

姓(FIRST_)、名称(LAST_)、邮件(EMAIL_)、密码(PWD_)、头像Id (PICTURE_ID_)

3、ACT_ID_INFO（用户信息表）

用户Id(USER_ID_)、类型(TYPE_)、formINPut名称(KEY_)、值(VALUE_)、密码(PASSWORD_)、父节点(PARENT_ID_)

4、ACT_ID_MEMBERSHIP（用户用户组关联表）

用户Id(user_ID_)、用户组Id（group_Id）

Activiti表结构分析完成，花了5个小时，还有很多问题不明白。后续慢慢开发过程中再理一次表之间关系吧，初步想法在系统中需要扩建表，把业务数据和流程数据分开。

Druid是一个JDBC组件，它包括四个部分：

• DruidDriver 代理Driver，能够提供基于Filter－Chain模式的插件体系。
• DruidDataSource 高效可管理的数据库连接池。
• SQLParser
• 扩展组件
• Binary: http://code.alibabatech.com/mvn/releases/com/alibaba/druid/0.1.2/druid-0.1.2.jar
• Source: http://code.alibabatech.com/mvn/releases/com/alibaba/druid/0.1.2/druid-0.1.2-sources.jar

Druid可以做什么？

• 可以监控数据库访问性能，Druid内置提供了一个功能强大的StatFilter插件，能够详细统计SQL的执行性能，这对于线上分析数据库访问性能有帮助。
• 替换DBCP和C3P0。Druid提供了一个高效、功能强大、可扩展性好的数据库连接池。
• 数据库密码加密。直接把数据库密码写在配置文件中，这是不好的行为，容易导致安全问题。DruidDruiver和DruidDataSource都支持PasswordCallback。
• SQL执行日志，Druid提供了不同的LogFilter，能够支持Common-Logging、Log4j和JdkLog，你可以按需要选择相应的LogFilter，监控你应用的数据库访问情况。
• 扩展JDBC，如果你要对JDBC层有编程的需求，可以通过Druid提供的Filter机制，很方便编写JDBC层的扩展插件。

DruidDriver，是一个ProxyJdbcDriver，它提供了Filter-Chain模式的扩展机制，使得在Jdbc扩展编程特别方便。

Druid提供了一些内置的扩展机制，包括Stat、Log、Trace、HA等扩展。

DruidDataSource是一个数据库连接池的实现，它的设计目标是提供一个当前最好的数据库连接池，在性能、扩展性等方面取得最合适的平衡，取代DBCP、C3P0等连接池。

• 高性能。测试数据表明，Druid比DBCP、C3P0、BoneCP的性能都好很多。具体请看测试数据
• 可管理性，DruidDataSource本身提供了很多监控属性，具体看这里。DruidDataSource支持StatFilter，具体配置看 这里
• 可扩展性，提供基于Filter-Chain模式的扩展机制。具体自定义扩展的例子看这里。
• 替换DBCP，配置和DBCP兼容，可以方便替换DBCP。
• 适合大规模应用。结合Alibaba使用数据库连接池的经验，避免一些已知问题，例如数据库不可用恢复之后产生的连接风暴问题等。

设计

这是DruidDataSource的设计图示：
http://code.alibabatech.com/svn/druid/trunk/doc/druid-pool.txt
如果发现有乱码，请选择utf-8的编码方式查看。

Druid提供一个手工编写的高性能的方便扩展的SQL Parser。将会支持MySQL、Oracle等流行关系数据库的SQL Parser。

Parser组件包括如下几个部分：

• Lexer 词法解析
• Parser，Parser包括ExprParser，各种StatementParser。
• AST, Abstract Syntax Tree。ParserParse出来的结果就是AST。
• Visitor。对AST做各种处理，比如FormatOutput，遍历等等。

简介

Druid提供了强大的监控功能，能够监控连接池行为和SQL执行情况，让你能够详细了解应用的数据库访问行为。

监控对象

• Druid的统计信息定义代码实现在com/alibaba/druid/stat下。所有的Stat都全局静态变量的方式保存，这样做使得外部获取监控信息更容易。
• 获取Druid监控信息的入口是com.alibaba.druid.stat.JdbcStatManager
• Druid的监控统计信息都是通过StatFilter来实现的，如果你需要数据源进行监控，那你需要启用StatFilter

对输入数据进行正态化

The cron4j main entity is the scheduler. With a it.sauronsoftware.cron4j.Scheduler instance you can execute tasks at fixed moments, during all the year. A scheduler can execute a task once a minute, once every five minutes, Friday at 10:00, on February the 16th at 12:30 but only if it is Saturday, and so on.

The use of the cron4j scheduler is a four steps operation:

1. Create your Scheduler instance.
2. Schedule your actions. To schedule an action you have to tell the scheduler what it has to do and when. You can specify what using a java.lang.Runnable or a it.sauronsoftware.cron4j.Task instance, and you can specify when using a scheduling pattern, which can be represented with a string or with a it.sauronsoftware.cron4j.SchedulingPattern instance.
3. Starts the scheduler.
4. Stops the scheduler, when you don't need it anymore.

Consider this simple example:

import it.sauronsoftware.cron4j.Scheduler;  public class Quickstart {  	public static void main(String[] args) { 		// Creates a Scheduler instance. 		Scheduler s = new Scheduler(); 		// Schedule a once-a-minute task. 		s.schedule("* * * * *", new Runnable() { 			public void run() { 				System.out.println("Another minute ticked away..."); 			} 		}); 		// Starts the scheduler. 		s.start(); 		// Will run for ten minutes. 		try { 			Thread.sleep(1000L * 60L * 10L); 		} catch (InterruptedException e) { 			; 		} 		// Stops the scheduler. 		s.stop(); 	}  }

This example runs for ten minutes. At every minute change it will print the sad (but true) message "Another minute ticked away...".

Some other key concepts:

• You can schedule how many tasks you want.
• You can schedule a task when you want, also after the scheduler has been started.
• You can change the scheduling pattern of an already scheduled task, also while the scheduler is running (reschedule operation).
• You can remove a previously scheduled task, also while the scheduler is running (deschedule operation).
• You can start and stop a scheduler how many times you want.
• You can schedule from a file.
• You can schedule from any source you want.
• You can supply listeners to the scheduler in order to receive events about the executed task.
• You can control any ongoing task.
• You can manually launch a task, without using a scheduling pattern.
• You can change the scheduler working Time Zone.
• You can validate your scheduling patterns before using them with the scheduler.
• You can predict when a scheduling pattern will cause a task execution.

Back to index

2. Scheduling patterns

A UNIX crontab-like pattern is a string split in five space separated parts. Each part is intended as:

1. Minutes sub-pattern. During which minutes of the hour should the task been launched? The values range is from 0 to 59.
2. Hours sub-pattern. During which hours of the day should the task been launched? The values range is from 0 to 23.
3. Days of month sub-pattern. During which days of the month should the task been launched? The values range is from 1 to 31. The special value "L" can be used to recognize the last day of month.
4. Months sub-pattern. During which months of the year should the task been launched? The values range is from 1 (January) to 12 (December), otherwise this sub-pattern allows the aliases "jan", "feb", "mar", "apr", "may", "jun", "jul", "aug", "sep", "oct", "nov" and "dec".
5. Days of week sub-pattern. During which days of the week should the task been launched? The values range is from 0 (Sunday) to 6 (Saturday), otherwise this sub-pattern allows the aliases "sun", "mon", "tue", "wed", "thu", "fri" and "sat".

The star wildcard character is also admitted, indicating "every minute of the hour", "every hour of the day", "every day of the month", "every month of the year" and "every day of the week", according to the sub-pattern in which it is used.

Once the scheduler is started, a task will be launched when the five parts in its scheduling pattern will be true at the same time.

Scheduling patterns can be represented with it.sauronsoftware.cron4j.SchedulingPattern instances. Invalid scheduling patterns are cause of it.sauronsoftware.cron4j.InvalidPatternExceptions. The SchedulingPattern class offers also a static validate(String) method, that can be used to validate a string before using it as a scheduling pattern.

Some examples:

5 * * * *
This pattern causes a task to be launched once every hour, at the begin of the fifth minute (00:05, 01:05, 02:05 etc.).

* * * * *
This pattern causes a task to be launched every minute.

* 12 * * Mon
This pattern causes a task to be launched every minute during the 12th hour of Monday.

* 12 16 * Mon
This pattern causes a task to be launched every minute during the 12th hour of Monday, 16th, but only if the day is the 16th of the month.

Every sub-pattern can contain two or more comma separated values.

59 11 * * 1,2,3,4,5
This pattern causes a task to be launched at 11:59AM on Monday, Tuesday, Wednesday, Thursday and Friday.

Values intervals are admitted and defined using the minus character.

59 11 * * 1-5
This pattern is equivalent to the previous one.

The slash character can be used to identify step values within a range. It can be used both in the form */c and a-b/c. The subpattern is matched every c values of the range 0,maxvalue or a-b.

*/5 * * * *
This pattern causes a task to be launched every 5 minutes (0:00, 0:05, 0:10, 0:15 and so on).

3-18/5 * * * *
This pattern causes a task to be launched every 5 minutes starting from the third minute of the hour, up to the 18th (0:03, 0:08, 0:13, 0:18, 1:03, 1:08 and so on).

*/15 9-17 * * *
This pattern causes a task to be launched every 15 minutes between the 9th and 17th hour of the day (9:00, 9:15, 9:30, 9:45 and so on... note that the last execution will be at 17:45).

All the fresh described syntax rules can be used together.

* 12 10-16/2 * *
This pattern causes a task to be launched every minute during the 12th hour of the day, but only if the day is the 10th, the 12th, the 14th or the 16th of the month.

* 12 1-15,17,20-25 * *
This pattern causes a task to be launched every minute during the 12th hour of the day, but the day of the month must be between the 1st and the 15th, the 20th and the 25, or at least it must be the 17th.

Finally cron4j lets you combine more scheduling patterns into one, with the pipe character:

0 5 * * *|8 10 * * *|22 17 * * *
This pattern causes a task to be launched every day at 05:00, 10:08 and 17:22.

Back to index

3. How to schedule, reschedule and deschedule a task

The simplest manner to build a task is to implement the well-known java.lang.Runnable interface. Once the task is ready, it can be scheduled with the it.sauronsoftware.cron4j.Scheduler.schedule(String, Runnable) method. This method throws an it.sauronsoftware.cron4j.InvalidPatternException when the supplied string does not represent a valid scheduling pattern.

Another way to build a task is to extend the it.sauronsoftware.cron4j.Task abstract class, which is more powerful and let the developer access some other cron4j features. This is better discussed in the "Building your own task" paragraph. Task instances can be scheduled with the schedule(String, Task) and the schedule(SchedulingPattern, Task) methods.

Scheduling methods available in the scheduler always return an ID used to recognize and retrieve the scheduled operation. This ID can be used later to reschedule the task (changing its scheduling pattern) with the reschedule(String, String) or the reschedule(String, SchedulingPattern) methods, and to deschedule the task (remove the task from the scheduler) with the deschedule(String) method.

The same ID can also be used to retrieve the scheduling pattern associated with a scheduled task, with the getSchedulingPattern(String) method, or to retrieve the task itself, with the getTask(String) method.

Back to index

4. How to schedule a system process

System processes can be easily scheduled using the ProcessTask class:

ProcessTask task = new ProcessTask("C:\\Windows\\System32\\notepad.exe"); Scheduler scheduler = new Scheduler(); scheduler.schedule("* * * * *", task); scheduler.start(); // ... 

Arguments for the process can be supplied by using a string array instead of a single command string:

String[] command = { "C:\\Windows\\System32\\notepad.exe", "C:\\File.txt" }; ProcessTask task = new ProcessTask(command); // ...

Environment variables for the process can be supplied using a second string array, whose elements have to be in the NAME=VALUE form:

String[] command = { "C:\\tomcat\\bin\\catalina.bat", "start" }; String[] envs = { "CATALINA_HOME=C:\\tomcat", "JAVA_HOME=C:\\jdks\\jdk5" }; ProcessTask task = new ProcessTask(command, envs); // ...

The default working directory for the process can be changed using a third parameter in the constructor:

String[] command = { "C:\\tomcat\\bin\\catalina.bat", "start" }; String[] envs = { "CATALINA_HOME=C:\\tomcat", "JAVA_HOME=C:\\jdks\\jdk5" }; File directory = "C:\\MyDirectory"; ProcessTask task = new ProcessTask(command, envs, directory); // ...

If you want to change the default working directory but you have not any environment variable, the envs parameter of the constructor can be set to null:

ProcessTask task = new ProcessTask(command, null, directory);

When envs is null the process inherits every environment variable of the current JVM:

Environment variables and the working directory can also be set by calling the setEnvs(String[]) and setDirectory(java.io.File) methods.

The process standard output and standard error channels can be redirected to files by using the setStdoutFile(java.io.File) and setStderrFile(java.io.File) methods:

ProcessTask task = new ProcessTask(command, envs, directory); task.setStdoutFile(new File("out.txt")); task.setStderrFile(new File("err.txt"));

In a siminal manner, the standard input channel can be read from an existing file, calling the setStdinFile(java.io.File) method:

ProcessTask task = new ProcessTask(command, envs, directory); task.setStdinFile(new File("in.txt"));

5. How to schedule processes from a file

The cron4j scheduler can also schedule a set of processes from a file.

You have to prepare a file, very similar to the ones used by the UNIX crontab, and register it in the scheduler calling the scheduleFile(File) method. The file can be descheduled by calling the descheduleFile(File) method. Scheduled files can be retrieved by calling the getScheduledFiles() method.

Scheduled files are parsed every minute. The scheduler will launch every process declared in the file whose scheduling pattern matches the current system time.

Syntax rules for cron4j scheduling files are reported in the "Cron parser" paragraph.

Back to index

6. Building your own task

A java.lang.Runnable object is the simplest task ever possible, but to gain control you need to extend the it.sauronsoftware.cron4j.Task class. In the plainest form, implementing Runnable or extending Task are very similar operations: while the first requires a run() method, the latter requires the implementation of execute(TaskExecutionContext). The execute(TaskExecutionContext) method provides a it.sauronsoftware.cron4j.TaskExecutionContext instance, which the Runnable.run() method does not provide. The context can be used in the following ways:

• A task can communicate with its executor, by notifying its internal state with a textual description. This is called status tracking. If you are interested in supporting status tracking in your task, you have to override the supportsStatusTracking() method, which should return true. Once this has been done, within the execute(TaskExecutionContext) method you are enabled to call the context setStatusMessage(String) method. This will propagate your task status message to its executor. The status message, through the executor, can be retrieved by an external user (see the "Executors" paragraph).

• A task can communicate with its executor, by notifying its completeness level with a numeric value. This is called completeness tracking. If you are interested in supporting completeness tracking in your task, you have to override the supportsCompletenessTracking() method, which should return true. Once this has been done, within the execute(TaskExecutionContext) method you are enabled to call the context setCompleteness(double) method, with a value between 0 and 1. This will propagate your task completeness level to its executor. The completeness level, through the executor, can be retrieved by an external user (see the "Executors" paragraph).

• A task can be optionally paused. If you are interested in supporting pausing and resuming in your task, you have to override the canBePaused() method, which should return true. Once this has been done, within the execute(TaskExecutionContext) method you have to periodically call the context pauseIfRequested() method. This will pause the task execution until it will be resumed (or stopped) by an external user (see the "Executors" paragraph).

• A task can be optionally stopped. If you are interested in supporting stopping in your task, you have to override the canBeStopped() method, which should return true. Once this has been done, within the execute(TaskExecutionContext) method you have to periodically call the context isStopped() method. This will return true when the execution has be demanded to be stopped by an external user (see the "Executors" paragraph). Then it's your responsibility to handle the event, by letting your task gently stop its ongoing activities.

• Through the context, the task can retrieve the scheduler, calling getScheduler().

• Through the context, the task can retrieve its executor, calling getTaskExecutor().

A custom task can be scheduled, launched immediately or returned by a task collector.

Back to index

7. Building your own collector

You can build and plug within the scheduler your own task source, via the task collector API.

The cron4j scheduler supports the registration of one or more it.sauronsoftware.cron4j.TaskCollector instances, with the addTaskCollector(TaskCollector) method. Registered collectors can be retrieved with the scheduler getTaskCollectors() method. A previously registered collector can be removed from the scheduler with the removeTaskCollector(TaskCollector) method. Collectors can be added, queried or removed at every moment, also when the scheduler is started and it is running.

Each registered task collector is queried by the scheduler once a minute. The scheduler calls the collector getTasks() method. The implementation must return a it.sauronsoftware.cron4j.TaskTable instance. A TaskTable is a table that associates tasks and scheduling patterns. The scheduler, once the table has been retrieved, will examine the reported entries, and it will execute every task whose scheduling pattern matches the current system time.

A custom collector can be used to tie the scheduler with an external task source, i.e. a database or a XML file, which can be managed and changed in its contents also at run time.

Back to index

8. Building your own scheduler listener

The it.sauronsoftware.cron4j.SchedulerListener API can be used to listen to scheduler events.

The SchedulerListener interface requires the implementation of the following methods:

• taskLaunching(TaskExecutor)
  This one is called every time a task is launched by the scheduler.

• taskSucceeded(TaskExecutor)
  This one is called every time a task execution has been successfully completed.

• taskFailed(TaskExecutor, Throwable)
  This one is called every time a task execution fails due to an uncaught exception.

See the "Executors" paragraph for more info about task executors.

Once your SchedulerListener instance is ready, you can register it on a Scheduler object by calling its addSchedulerListener(SchedulerListener) method. Already registered listeners can be removed by calling the removeSchedulerListener(SchedulerListener) method. The scheduler can also give back any registered listener, with the getSchedulerListeners() method.

SchedulerListeners can be added and removed at every moment, also while the scheduler is running.

Back to index

9. Executors

The scheduler, once it has been started and it is running, can be queried to give back its executors. An executor is similar to a thread. Executors is used by the scheduler to execute tasks.

By calling the Scheduler.getExecutingTasks() method you can obtain the currently ongoing executors.

You can also obtain an executor through a SchedulerListener instance (see the "Building your own scheduler listener" paragraph).

Each executor, represented by a it.sauronsoftware.cron4j.TaskExecutor instance, performs a different task execution.

The task can be retrieved with the getTask() method.

The executor status can be checked with the isAlive() method: it returns true if the executor is currently running.

If the executor is running, the current thread can be paused until the execution will be completed, calling the join() method.

The supportsStatusTracking() method returns true if the currently executing task supports status tracking. It means that the task communicates to the executor its status, represented by a string. The current status message can be retrieved by calling the executor getStatusMessage() method.

The supportsCompletenessTracking() method returns true if the currently executing task supports completeness tracking. It means that the task communicates to the executor its own completeness level. The current completeness level can be retrieved by calling the executor getCompleteness() method. Returned values are between 0 (task just started and still nothing done) and 1 (task completed).

The canBePaused() method returns true if the currently executing task supports execution pausing. It means that the task execution can be paused by calling the executor pause() method. The pause status of the executor can be checked with the isPaused() method. A paused executor can be resumed by calling its resume() method.

The canBeStopped() method returns true if the currently executing task supports execution interruption. It means that the task execution can be stopped by calling the executor stop() method. The interruption status of the executor can be checked with the isStopped() method. Stopped executors cannot be resumed.

The getStartTime() method returns a time stamp reporting the start time of the executor, or a value less than 0 if the executor has not been yet started.

The getScheduler() method returns the scheduler which is the owner of the executor.

The getGuid() method returns a textual GUID for the executor.

Executors offer also an event-driven API, through the it.sauronsoftware.cron4j.TaskExecutorListener class. A TaskExecutorListener can be added to a TaskExecutor with its addTaskExecutorListener(TaskExecutorListener) method. Listeners can be removed with the removeTaskExecutorListener(TaskExecutorListener) method, and they can also be retrieved with the getTaskExecutorListeners() method. A TaskExecutorListener must implement the following methods:

• executionPausing(TaskExecutor)
  Called when the executor is requested to pause the ongoing task. The given parameter represents the source TaskExecutor instance.

• executionResuming(TaskExecutor)
  Called when the executor is requested to resume the execution of the previously paused task. The given parameter represents the source TaskExecutor instance.

• executionStopping(TaskExecutor)
  Called when the executor is requested to stop the task execution. The given parameter represents the source TaskExecutor instance.

• executionTerminated(TaskExecutor, Throwable)
  Called when the executor has completed the task execution. The first parameter represents the source TaskExecutor instance, while the second is the optional exception that has caused the task to be terminated. If the task has been completed successfully, the given value is null.

• statusMessageChanged(TaskExecutor, String)
  Called every time the execution status message changes. The first parameter represents the source TaskExecutor instance, while the second is the new message issued by the task.

• completenessValueChanged(TaskExecutor, double)
  Called every time the execution completeness value changes. The first parameter represents the source TaskExecutor instance, while the second is the new completeness value (between 0 and 1) issued by the task.

Back to index

10. Manual task launch

If the scheduler is started and running, it is possible to manually launch a task, without scheduling it with a pattern. The method is Scheduler.launch(Task). The task will be immediately launched, and a TaskExecutor instace is returned to the caller. The returned object can be used to control the task execution (see the "Executors" paragraph).

Back to index

11. Working with Time Zones

Scheduler instances, by default, work with the system default Time Zone. I.e. a scheduling pattern whose value is 0 2 * * * will activate its task at 02:00 AM according to the default system Time Zone. The scheduler can be requested to work with a different Time Zone, which is not the system default one. Call Scheduler.setTimeZone(TimeZone) and Scheduler.getTimeZone() to control this feature.

Once the default Time Zone has been changed, system current time is adapted to the supplied zone before comparing it with registered scheduling patterns. The result is that any supplied scheduling pattern is treated according to the specified Time Zone. Suppose this situation:

• System time: 10:00
• System time zone: GMT+1
• Scheduler time zone: GMT+3

The scheduler, before comparing system time with patterns, translates 10:00 from GMT+1 to GMT+3. It means that 10:00 becomes 12:00. The resulted time is then used by the scheduler to activate tasks. So, in the given configuration at the given moment, any task scheduled as 0 12 * * * will be executed, while any 0 10 * * * will not.

Back to index

12. Daemon threads

The Java Virtual Machine exits when the only threads running are all daemon threads. The cron4j scheduler can be configured to spawn only daemon threads. To control this feature call the Scheduler.setDaemon(boolean) method. This method must be called before the scheduler is started. Default value is false. To check the scheduler current daemon status call the Scheduler.isDaemon() method.

Back to index

13. Predictor

The it.sauronsoftware.cron4j.Predictor class is able to predict when a scheduling pattern will be matched.

Suppose you want to know when the scheduler will execute a task scheduled with the pattern 0 3 * jan-jun,sep-dec mon-fri. You can predict the next n execution of the task using a Predictor instance:

String pattern = "0 3 * jan-jun,sep-dec mon-fri"; Predictor p = new Predictor(pattern); for (int i = 0; i < n; i++) { 	System.out.println(p.nextMatchingDate()); }

Back to index

14. Cron parser

The it.sauronsoftware.cron4j.CronParser class can be used to parse crontab-like formatted file and character streams.

If you want to schedule a list of tasks declared in a crontab-like file you don't need the CronParser, since you can do it by adding the file to the scheduler, with the Scheduler.scheduleFile(File) method.

Consider to use the CronParser if the Scheduler.scheduleFile(File) method is not enough for you. In example, you may need to fetch the task list from a remote source which is not representable as a java.io.File object (a document on a remote server, a DBMS result set and so on). To solve the problem you can implement your own it.sauronsoftware.cron4j.TaskCollector, getting the advantage of the CronParser to easily parse any crontab-like content.

You can parse a whole file/stream, but you can also parse a single line.

A line can be empty, can contain a comment or it can be a scheduling line.

A line containing no characters or a line with only space characters is considered an empty line.

A line whose first non-space character is a number sign (#) is considered a comment.

Empty lines and comment lines are ignored by the parser.

Any other kind of line is parsed as a scheduling line.

A valid scheduling line respects the following structure:

scheduling-pattern [options] command [args]

• scheduling-pattern is a valid scheduling pattern, according with the definition given by the it.sauronsoftware.cron4j.SchedulingPattern class.
• options is a list of optional information used by cron4j to prepare the task execution environment. See below for a more detailed description.
• command is a system valid command, such an executable call.
• args is a list of optional arguments for the command.

After the scheduling pattern item, other tokens in each line are space separated or delimited with double quotation marks (").

Double quotation marks delimited items can take advantage of the following escape sequences:

• \" - quotation mark
• \\ - back slash
• \/ - slash
• \b - back space
• \f - form feed
• \n - new line
• \r - carriage return
• \t - horizontal tab
• \ufour-hex-digits - the character at the given Unicode index

The options token collection can include one or more of the following elements:

• IN:file-path - Redirects the command standard input channel to the specified file.
• OUT:file-path - Redirects the command standard output channel to the specified file.
• ERR:file-path - Redirects the command standard error channel to the specified file.
• ENV:name=value - Defines an environment variable in the scope of the command.
• DIR:directory-path - Sets the path of the working directory for the command. This feature is not supported if the executing JVM is less than 1.3.

It is also possible to schedule the invocation of a method of a Java class in the scope of the parser ClassLoader. The method has to be static and it must accept an array of strings as its sole argument. To invoke a method of this kind the syntax is:

scheduling-pattern java:className#methodName [args]

The #methodName part can be omitted: in this case the main(String[]) method will be assumed.

Please note that static methods are invoked within the scheduler same JVM, without spawning any external process. Thus IN, OUT, ERR, ENV and DIR options can't be applied.

Invalid scheduling lines are discarded without blocking the parsing procedure, but an error message is sent to the application standard error channel.

Valid examples:

0 5 * * * sol.exe 0,30 * * * * OUT:C:\ping.txt ping 10.9.43.55 0,30 4 * * * "OUT:C:\Documents and Settings\Carlo\ping.txt" ping 10.9.43.55 0 3 * * * ENV:JAVA_HOME=C:\jdks\1.4.2_15 DIR:C:\myproject OUT:C:\myproject\build.log C:\myproject\build.bat "Nightly Build" 0 4 * * * java:mypackage.MyClass#startApplication myOption1 myOption2

阿里云是最近新出的一个镜像源。得益与阿里云的高速发展，这么大的需求，肯定会推出自己的镜像源。
阿里云Linux安装镜像源地址：http://mirrors.aliyun.com/

CentOS系统更换软件安装源
第一步：备份你的原镜像文件，以免出错后可以恢复。

mv /etc/yum.repos.d/CentOS-Base.repo /etc/yum.repos.d/CentOS-Base.repo.backup
第二步：下载新的CentOS-Base.repo 到/etc/yum.repos.d/
CentOS 5

wget -O /etc/yum.repos.d/CentOS-Base.repo http://mirrors.aliyun.com/repo/Centos-5.repo
CentOS 6

wget -O /etc/yum.repos.d/CentOS-Base.repo http://mirrors.aliyun.com/repo/Centos-6.repo
第三步：运行yum makecache生成缓存

yum clean all

yum makecache