0%

同学们有福了,花了一些时间,重新整理了一个最完整的Mybatis Generator(简称MBG)的最完整配置文件,带详解,再也不用去看EN的User Guide了;

复制代码

<generatorConfiguration>

<context id=“mysql” defaultModelType=“hierarchical” targetRuntime=“MyBatis3Simple” >

<!-- 自动识别数据库关键字,默认false,如果设置为true,根据SqlReservedWords中定义的关键字列表;
    一般保留默认值,遇到数据库关键字(Java关键字),使用columnOverride覆盖 \-->
<property name\="autoDelimitKeywords" value\="false"/>
<!-- 生成的Java文件的编码 \-->
<property name\="javaFileEncoding" value\="UTF-8"/>
<!-- 格式化java代码 \-->
<property name\="javaFormatter" value\="org.mybatis.generator.api.dom.DefaultJavaFormatter"/>
<!-- 格式化XML代码 \-->
<property name\="xmlFormatter" value\="org.mybatis.generator.api.dom.DefaultXmlFormatter"/>

<!-- beginningDelimiter和endingDelimiter:指明数据库的用于标记数据库对象名的符号,比如ORACLE就是双引号,MYSQL默认是\`反引号; \-->
<property name\="beginningDelimiter" value\="\`"/>
<property name\="endingDelimiter" value\="\`"/>

<!-- 必须要有的,使用这个配置链接数据库
    @TODO:是否可以扩展 \-->
<jdbcConnection driverClass\="com.mysql.jdbc.Driver" connectionURL\="jdbc:mysql:///pss" userId\="root" password\="admin"\>
    <!-- 这里面可以设置property属性,每一个property属性都设置到配置的Driver上 \-->
</jdbcConnection\>

<!-- java类型处理器 
    用于处理DB中的类型到Java中的类型,默认使用JavaTypeResolverDefaultImpl;
    注意一点,默认会先尝试使用Integer,Long,Short等来对应DECIMAL和 NUMERIC数据类型; \-->
<javaTypeResolver type\="org.mybatis.generator.internal.types.JavaTypeResolverDefaultImpl"\>
    <!-- true:使用BigDecimal对应DECIMAL和 NUMERIC数据类型
        false:默认,
            scale>0;length>18:使用BigDecimal;
            scale=0;length\[10,18\]:使用Long;
            scale=0;length\[5,9\]:使用Integer;
            scale=0;length<5:使用Short; \-->
    <property name\="forceBigDecimals" value\="false"/>
</javaTypeResolver\>

<!-- java模型创建器,是必须要的元素
    负责:1,key类(见context的defaultModelType);2,java类;3,查询类
    targetPackage:生成的类要放的包,真实的包受enableSubPackages属性控制;
    targetProject:目标项目,指定一个存在的目录下,生成的内容会放到指定目录中,如果目录不存在,MBG不会自动建目录 \-->
<javaModelGenerator targetPackage\="com.\_520it.mybatis.domain" targetProject\="src/main/java"\>
    <!-- for MyBatis3/MyBatis3Simple
        自动为每一个生成的类创建一个构造方法,构造方法包含了所有的field;而不是使用setter; \-->
    <property name\="constructorBased" value\="false"/>

    <!-- 在targetPackage的基础上,根据数据库的schema再生成一层package,最终生成的类放在这个package下,默认为false \-->
    <property name\="enableSubPackages" value\="true"/>

    <!-- for MyBatis3 / MyBatis3Simple
        是否创建一个不可变的类,如果为true,
        那么MBG会创建一个没有setter方法的类,取而代之的是类似constructorBased的类 \-->
    <property name\="immutable" value\="false"/>

    <!-- 设置一个根对象,
        如果设置了这个根对象,那么生成的keyClass或者recordClass会继承这个类;在Table的rootClass属性中可以覆盖该选项
        注意:如果在key class或者record class中有root class相同的属性,MBG就不会重新生成这些属性了,包括:
            1,属性名相同,类型相同,有相同的getter/setter方法; \-->
    <property name\="rootClass" value\="com.\_520it.mybatis.domain.BaseDomain"/>

    <!-- 设置是否在getter方法中,对String类型字段调用trim()方法 \-->
    <property name\="trimStrings" value\="true"/>
</javaModelGenerator\>

<!-- 生成SQL map的XML文件生成器,
    注意,在Mybatis3之后,我们可以使用mapper.xml文件+Mapper接口(或者不用mapper接口),
        或者只使用Mapper接口+Annotation,所以,如果 javaClientGenerator配置中配置了需要生成XML的话,这个元素就必须配置
    targetPackage/targetProject:同javaModelGenerator \-->
<sqlMapGenerator targetPackage\="com.\_520it.mybatis.mapper" targetProject\="src/main/resources"\>
    <!-- 在targetPackage的基础上,根据数据库的schema再生成一层package,最终生成的类放在这个package下,默认为false \-->
    <property name\="enableSubPackages" value\="true"/>
</sqlMapGenerator\>

<!-- 对于mybatis来说,即生成Mapper接口,注意,如果没有配置该元素,那么默认不会生成Mapper接口 
    targetPackage/targetProject:同javaModelGenerator
    type:选择怎么生成mapper接口(在MyBatis3/MyBatis3Simple下):
        1,ANNOTATEDMAPPER:会生成使用Mapper接口+Annotation的方式创建(SQL生成在annotation中),不会生成对应的XML;
        2,MIXEDMAPPER:使用混合配置,会生成Mapper接口,并适当添加合适的Annotation,但是XML会生成在XML中;
        3,XMLMAPPER:会生成Mapper接口,接口完全依赖XML;
    注意,如果context是MyBatis3Simple:只支持ANNOTATEDMAPPER和XMLMAPPER \-->
<javaClientGenerator targetPackage\="com.\_520it.mybatis.mapper" type\="ANNOTATEDMAPPER" targetProject\="src/main/java"\>
    <!-- 在targetPackage的基础上,根据数据库的schema再生成一层package,最终生成的类放在这个package下,默认为false \-->
    <property name\="enableSubPackages" value\="true"/>

    <!-- 可以为所有生成的接口添加一个父接口,但是MBG只负责生成,不负责检查
    <property name="rootInterface" value=""/> \-->
</javaClientGenerator\>

<!-- 选择一个table来生成相关文件,可以有一个或多个table,必须要有table元素
    选择的table会生成一下文件:
    1,SQL map文件
    2,生成一个主键类;
    3,除了BLOB和主键的其他字段的类;
    4,包含BLOB的类;
    5,一个用户生成动态查询的条件类(selectByExample, deleteByExample),可选;
    6,Mapper接口(可选)

    tableName(必要):要生成对象的表名;
    注意:大小写敏感问题。正常情况下,MBG会自动的去识别数据库标识符的大小写敏感度,在一般情况下,MBG会
        根据设置的schema,catalog或tablename去查询数据表,按照下面的流程:
        1,如果schema,catalog或tablename中有空格,那么设置的是什么格式,就精确的使用指定的大小写格式去查询;
        2,否则,如果数据库的标识符使用大写的,那么MBG自动把表名变成大写再查找;
        3,否则,如果数据库的标识符使用小写的,那么MBG自动把表名变成小写再查找;
        4,否则,使用指定的大小写格式查询;
    另外的,如果在创建表的时候,使用的""把数据库对象规定大小写,就算数据库标识符是使用的大写,在这种情况下也会使用给定的大小写来创建表名;
    这个时候,请设置delimitIdentifiers="true"即可保留大小写格式;

    可选:
    1,schema:数据库的schema;
    2,catalog:数据库的catalog;
    3,alias:为数据表设置的别名,如果设置了alias,那么生成的所有的SELECT SQL语句中,列名会变成:alias\_actualColumnName
    4,domainObjectName:生成的domain类的名字,如果不设置,直接使用表名作为domain类的名字;可以设置为somepck.domainName,那么会自动把domainName类再放到somepck包里面;
    5,enableInsert(默认true):指定是否生成insert语句;
    6,enableSelectByPrimaryKey(默认true):指定是否生成按照主键查询对象的语句(就是getById或get);
    7,enableSelectByExample(默认true):MyBatis3Simple为false,指定是否生成动态查询语句;
    8,enableUpdateByPrimaryKey(默认true):指定是否生成按照主键修改对象的语句(即update);
    9,enableDeleteByPrimaryKey(默认true):指定是否生成按照主键删除对象的语句(即delete);
    10,enableDeleteByExample(默认true):MyBatis3Simple为false,指定是否生成动态删除语句;
    11,enableCountByExample(默认true):MyBatis3Simple为false,指定是否生成动态查询总条数语句(用于分页的总条数查询);
    12,enableUpdateByExample(默认true):MyBatis3Simple为false,指定是否生成动态修改语句(只修改对象中不为空的属性);
    13,modelType:参考context元素的defaultModelType,相当于覆盖;
    14,delimitIdentifiers:参考tableName的解释,注意,默认的delimitIdentifiers是双引号,如果类似MYSQL这样的数据库,使用的是\`(反引号,那么还需要设置context的beginningDelimiter和endingDelimiter属性)
    15,delimitAllColumns:设置是否所有生成的SQL中的列名都使用标识符引起来。默认为false,delimitIdentifiers参考context的属性

    注意,table里面很多参数都是对javaModelGenerator,context等元素的默认属性的一个复写; \-->
<table tableName\="userinfo" \>

    <!-- 参考 javaModelGenerator 的 constructorBased属性\-->
    <property name\="constructorBased" value\="false"/>

    <!-- 默认为false,如果设置为true,在生成的SQL中,table名字不会加上catalog或schema; \-->
    <property name\="ignoreQualifiersAtRuntime" value\="false"/>

    <!-- 参考 javaModelGenerator 的 immutable 属性 \-->
    <property name\="immutable" value\="false"/>

    <!-- 指定是否只生成domain类,如果设置为true,只生成domain类,如果还配置了sqlMapGenerator,那么在mapper XML文件中,只生成resultMap元素 \-->
    <property name\="modelOnly" value\="false"/>

    <!-- 参考 javaModelGenerator 的 rootClass 属性 
    <property name="rootClass" value=""/> \-->

    <!-- 参考javaClientGenerator 的  rootInterface 属性
    <property name="rootInterface" value=""/> \-->

    <!-- 如果设置了runtimeCatalog,那么在生成的SQL中,使用该指定的catalog,而不是table元素上的catalog 
    <property name="runtimeCatalog" value=""/> \-->

    <!-- 如果设置了runtimeSchema,那么在生成的SQL中,使用该指定的schema,而不是table元素上的schema 
    <property name="runtimeSchema" value=""/> \-->

    <!-- 如果设置了runtimeTableName,那么在生成的SQL中,使用该指定的tablename,而不是table元素上的tablename 
    <property name="runtimeTableName" value=""/> \-->

    <!-- 注意,该属性只针对MyBatis3Simple有用;
        如果选择的runtime是MyBatis3Simple,那么会生成一个SelectAll方法,如果指定了selectAllOrderByClause,那么会在该SQL中添加指定的这个order条件; \-->
    <property name\="selectAllOrderByClause" value\="age desc,username asc"/>

    <!-- 如果设置为true,生成的model类会直接使用column本身的名字,而不会再使用驼峰命名方法,比如BORN\_DATE,生成的属性名字就是BORN\_DATE,而不会是bornDate \-->
    <property name\="useActualColumnNames" value\="false"/>

    <!-- generatedKey用于生成生成主键的方法,
        如果设置了该元素,MBG会在生成的<insert>元素中生成一条正确的<selectKey>元素,该元素可选
        column:主键的列名;
        sqlStatement:要生成的selectKey语句,有以下可选项:
            Cloudscape:相当于selectKey的SQL为: VALUES IDENTITY\_VAL\_LOCAL()
            DB2       :相当于selectKey的SQL为: VALUES IDENTITY\_VAL\_LOCAL()
            DB2\_MF    :相当于selectKey的SQL为:SELECT IDENTITY\_VAL\_LOCAL() FROM SYSIBM.SYSDUMMY1
            Derby      :相当于selectKey的SQL为:VALUES IDENTITY\_VAL\_LOCAL()
            HSQLDB      :相当于selectKey的SQL为:CALL IDENTITY()
            Informix  :相当于selectKey的SQL为:select dbinfo('sqlca.sqlerrd1') from systables where tabid=1
            MySql      :相当于selectKey的SQL为:SELECT LAST\_INSERT\_ID()
            SqlServer :相当于selectKey的SQL为:SELECT SCOPE\_IDENTITY()
            SYBASE      :相当于selectKey的SQL为:SELECT @@IDENTITY
            JDBC      :相当于在生成的insert元素上添加useGeneratedKeys="true"和keyProperty属性
    <generatedKey column="" sqlStatement=""/> \-->

    <!-- 该元素会在根据表中列名计算对象属性名之前先重命名列名,非常适合用于表中的列都有公用的前缀字符串的时候,
        比如列名为:CUST\_ID,CUST\_NAME,CUST\_EMAIL,CUST\_ADDRESS等;
        那么就可以设置searchString为"^CUST\_",并使用空白替换,那么生成的Customer对象中的属性名称就不是
        custId,custName等,而是先被替换为ID,NAME,EMAIL,然后变成属性:id,name,email;

        注意,MBG是使用java.util.regex.Matcher.replaceAll来替换searchString和replaceString的,
        如果使用了columnOverride元素,该属性无效;

    <columnRenamingRule searchString="" replaceString=""/> \-->

     <!-- 用来修改表中某个列的属性,MBG会使用修改后的列来生成domain的属性;
         column:要重新设置的列名;
         注意,一个table元素中可以有多个columnOverride元素哈~ \-->
     <columnOverride column\="username"\>
         <!-- 使用property属性来指定列要生成的属性名称 \-->
         <property name\="property" value\="userName"/>

         <!-- javaType用于指定生成的domain的属性类型,使用类型的全限定名
         <property name="javaType" value=""/> \-->

         <!-- jdbcType用于指定该列的JDBC类型 
         <property name="jdbcType" value=""/> \-->

         <!-- typeHandler 用于指定该列使用到的TypeHandler,如果要指定,配置类型处理器的全限定名
             注意,mybatis中,不会生成到mybatis-config.xml中的typeHandler
             只会生成类似:where id = #{id,jdbcType=BIGINT,typeHandler=com.\_520it.mybatis.MyTypeHandler}的参数描述
         <property name="jdbcType" value=""/> \-->

         <!-- 参考table元素的delimitAllColumns配置,默认为false
         <property name="delimitedColumnName" value=""/> \-->
     </columnOverride\>

     <!-- ignoreColumn设置一个MGB忽略的列,如果设置了改列,那么在生成的domain中,生成的SQL中,都不会有该列出现 
         column:指定要忽略的列的名字;
         delimitedColumnName:参考table元素的delimitAllColumns配置,默认为false

         注意,一个table元素中可以有多个ignoreColumn元素
     <ignoreColumn column="deptId" delimitedColumnName=""/> \-->
</table\>

</context>

</generatorConfiguration>

复制代码

1.Quartz的作用

定时自动执行任务

2.预备

相关包官方网站

1
2
quartz2.2.1
quartz-jobs2.2.1

POM文件

1
2
3
4
5
6
7
8
9
10
<dependency>
<groupId>org.quartz-scheduler</groupId>
<artifactId>quartz</artifactId>
<version>2.2.1</version>
</dependency>
<dependency>
<groupId>org.quartz-scheduler</groupId>
<artifactId>quartz-jobs</artifactId>
<version>2.2.1</version>
</dependency>

3.Quartz核心

3.1.Job接口

被调度的任务,只有一个方法execute(JobExecutionContext xontext),Job运行时的信息保存在JobDataMap中

3.2.JobDetail类

实现Job接口,用来描述Job的相关信息,包含Name,Group,JobDataMap等

3.3 JobExecutionContext类

定时程序执行的run-time的上下文环境,用于得到Job的名字、配置的参数等

3.3 JobDataMap类

用来描述一个作业的参数,参数可以为金和基本类型或者某个对象的引用

3.3 JobListener接口

监听作业状态

3.3 TriggaerListener接口

监听触发器状态

3.3 JobStore

3.3.Tigger抽象类

触发器,描述执行Job的触发规则,有SimpleTrigger和CronTrigger两个子类

3.3.1.SimpleTrigger类

继承自Trigger类,每隔xx毫秒/秒执行一次,主要实现固定一次或者固定时间周期类任务的触发

3.3.2.CronTrigger类

继承自Trigger类,使用Cron表达式,实现各种复杂时间规则调度方案,如每天的某个时间,或每周的某几天触发执行之类

3.4.Calendar包

一些日历特定时间点的集合,包内包含以下几个类

3.4.1 BaseCalendar类

3.4.2 AnnualCalendar类

排除每一年中指定的一天或者多天

3.4.3 CalendarComparator类

3.4.4 CronCalendar类

使用表达式排除某时间段不执行

3.4.5 DailyCalendar类

指定的时间范围内每天不执行

3.4.6 HolidayCalendar类

排除节假日

3.4.7 MonthlyCalendar类

配出月份中的数天

3.4.8 WeeklyCalendar类

排除没周中的一天或者多天

3.5.Scheduler类

任务调度器,代表一个Quartz独立容器。

Scheduler可以将JobDetail和Trigger绑定,当Trigger触发时,对应的Job就会被执行,Job和Trigger是1:n(一对多)的关系

3.6Misfire类

错误的任务,本该执行单没有执行的任务调度

4.实现

1.单任务实现

1.定义一个任务,新建任务类继承自Job类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
package com;

import java.text.SimpleDateFormat;
import java.util.Date;

import org.quartz.Job;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;

public class DemoJob implements Job {

@Override
public void execute(JobExecutionContext arg0) throws JobExecutionException {
System.out.println(new SimpleDateFormat("HH:mm:ss").format(new Date()));
}

}

2.新建类执行这个任务(SimpleTrigger)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
package com;

import java.util.Date;

import org.quartz.DateBuilder;
import org.quartz.JobBuilder;
import org.quartz.JobDetail;
import org.quartz.Scheduler;
import org.quartz.SchedulerException;
import org.quartz.SchedulerFactory;
import org.quartz.SimpleScheduleBuilder;
import org.quartz.Trigger;
import org.quartz.TriggerBuilder;
import org.quartz.impl.StdSchedulerFactory;

public class QuartzDemo {

public void simpleRun() throws SchedulerException {

SchedulerFactory factory = new StdSchedulerFactory();



Date runTime = DateBuilder.evenSecondDateAfterNow();


JobDetail jobDetail = JobBuilder.newJob(DemoJob.class)
.withIdentity("demo_job", "demo_group")
.build();

Trigger trigger = TriggerBuilder.newTrigger()
.withIdentity("demo_trigger", "demo_group")

.startAt(new Date())
.withSchedule(
SimpleScheduleBuilder
.simpleSchedule()
.withIntervalInSeconds(1)
.withRepeatCount(5)
).build();


Scheduler scheduler = factory.getScheduler();

scheduler.scheduleJob(jobDetail,trigger);
System.out.println(jobDetail.getKey() + " 运行在: " + runTime);
scheduler.start();
}

public static void main(String[] args) {
QuartzDemo demo = new QuartzDemo();
try {
demo.simpleRun();
} catch (SchedulerException e) {
e.printStackTrace();
}
}
}

2.多任务实现

  1. 测试任务类
    新建两个DemoJonOne和DemoJobTwo,都实现Job接口,内容如下
1
2
3
4
@Override
public void execute(JobExecutionContext arg0) throws JobExecutionException {
System.out.println(new SimpleDateFormat("HH:mm:ss").format(new Date())+" Runed "+getClass().getName());
}

2.新建QuartzUtil类,内容如下

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
package com;

import org.quartz.Job;
import org.quartz.JobBuilder;
import org.quartz.JobDetail;
import org.quartz.Scheduler;
import org.quartz.SchedulerException;
import org.quartz.SchedulerFactory;
import org.quartz.SimpleScheduleBuilder;
import org.quartz.Trigger;
import org.quartz.TriggerBuilder;
import org.quartz.impl.StdSchedulerFactory;

public class QuartzUtil {
private final static String JOB_GROUP_NAME = "QUARTZ_JOBGROUP_NAME";
private final static String TRIGGER_GROUP_NAME = "QUARTZ_TRIGGERGROUP_NAME";


public static void addJob(String jobName, String triggerName, Class<? extends Job> jobClass, int seconds)
throws SchedulerException {


SchedulerFactory sf = new StdSchedulerFactory();

Scheduler sche = sf.getScheduler();

JobDetail jobDetail = JobBuilder.newJob(jobClass).withIdentity(jobName, JOB_GROUP_NAME).build();

Trigger trigger = TriggerBuilder.newTrigger()
.withIdentity(triggerName, TRIGGER_GROUP_NAME)
.startNow()
.withSchedule(
SimpleScheduleBuilder
.simpleSchedule()
.withIntervalInSeconds(seconds)
.repeatForever()
).build();


sche.scheduleJob(jobDetail, trigger);

sche.start();
}

public static void main(String[] args) {
try {

QuartzUtil.addJob("job1", "trigger1", DemoJobOne.class, 2);


QuartzUtil.addJob("Job2", "trigger2", DemoJobTwo.class, 5);
} catch (SchedulerException e) {
e.printStackTrace();
}
}
}

以上方法属于手动调用,如果是web项目中就不同了
添加POM

1
2
3
4
5
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>servlet-api</artifactId>
<version>2.5</version>
</dependency>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
package servlet;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;

import org.quartz.SchedulerException;

import com.DemoJobOne;
import com.DemoJobTwo;
import com.QuartzUtil;

public class InitServlet extends HttpServlet {

private static final long serialVersionUID = 8507188690597926975L;


public void init() throws ServletException {
try {

QuartzUtil.addJob("job1", "trigger1", DemoJobOne.class, 2);

QuartzUtil.addJob("Job2", "trigger2", DemoJobTwo.class, 5);
} catch (SchedulerException e) {
e.printStackTrace();
}
}

}

2.注册servlet

1
2
3
4
5
6
7
8
9
10
11
<servlet>
<servlet-name>InitServlet</servlet-name>
<servlet-class>servlet.InitServlet</servlet-class>

<load-on-startup>0</load-on-startup>
</servlet>

<servlet-mapping>
<servlet-name>InitServlet</servlet-name>
<url-pattern>/InitServlet</url-pattern>
</servlet-mapping>

3.复杂规则任务调度(CronTrigger)

在每分钟的1-30秒执行示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
package com;

import org.quartz.CronScheduleBuilder;
import org.quartz.JobBuilder;
import org.quartz.JobDetail;
import org.quartz.Scheduler;
import org.quartz.SchedulerException;
import org.quartz.SchedulerFactory;
import org.quartz.Trigger;
import org.quartz.TriggerBuilder;
import org.quartz.impl.StdSchedulerFactory;

public class CronTriggerDemo {
public static void main(String[] args) throws SchedulerException {

SchedulerFactory factory = new StdSchedulerFactory();
Scheduler scheduler = factory.getScheduler();

JobDetail job = JobBuilder
.newJob(DemoJobOne.class)
.withIdentity("job","group")
.build();

Trigger trigger = TriggerBuilder
.newTrigger()
.withIdentity("trigger", "group")
.startNow().withSchedule(
CronScheduleBuilder
.cronSchedule("1-30 * * * * ?")
).build();

scheduler.scheduleJob(job,trigger);
scheduler.start();

}
}

5.Cron表达式

规则

格式

1
s M h d m w [y]

s:seconds,取值0-59,允许- * /;

M:minutes,取值0-59,允许- * /;

h:hour,取值0-23,允许- * /;

d:day of month,取值1-31,允许- * ? / L W;

m:month,取值1-12/JAN-DEC,允许- * /;

w:day of week,取值1-7/SUN-SAT,允许- * ? / L #;

y:year,可选,取值empty、1970-2099,允许- * /;

符号解释

、 指定枚举值,如在秒字段使用10、12,则表示只有第10秒和第12秒执行
- 指定区间范围,配合使用,如在小时字段使用10-12,表示在10、11、12时都会触发

* 代表所有值,单独使用,如在秒字段使用,表示每秒触发

? 代表不确定值,单独使用,不用关心的值

/ 用于递增触发,配合使用,n/m,从n开始,每次增加m,如在秒字段设置5/15,表示从第5秒开始,每15秒触发一次

L 表示最后,单独使用,如在秒字段使用,代表第59秒触发,如果在前面加上数字,则表示该数据的最后一个,如在周字段使用6L,则表示本月最后一个周五
W 表示最近的工作日,不会跨月,比如30W,30号是周六,则不会顺延至下周一来执行,如在月字段使用15W,则表示到本月15日最近的工作日(周一到周五)
# 用来指定x的第n个工作日,如在周字段使用6#3则表示该月的第三个星期五

月取值

一月:JAN/0
二月:FEB/1
三月:MAR/2
四月:APR/3
五月:MAY/4
六月:JUN/5
七月:JUL/6
八月:AUG/7
九月:SEP/8
十月:OCT/9
十一月:NOV/10
十二月:DEC/11

周取值

周日:SUN/1
周一:MON/2
周二:TUE/3
周三:WED/4
周四:THU/5
周五:FRI/6
周六:SAT/7

示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
0/20 * * * * ? 每20秒执行一次
1-30 * * * * ? 在1-30秒执行
15 0/2 * * * ? 偶数分钟的第15秒执行
0 0/2 8-17 * * ? 从8时到17时 ,每个偶数分钟执行一次
0 0/3 17-23 * * ? 从17时到23时,每3分钟运行一次
0 0 10am 1,15 * ? 每个月的1号和15号的上午10点 运行
0,30 * * ? * MON-FRI 周一至周五,每30秒运行一次
0,30 * * ? * SAT,SUN 周六、周日,每30秒运行一次
0 0 12 * * ? 每天12点触发
0 15 10 ? * * 每天10点15分触发
0 15 10 * * ? 每天10点15分触发
0 15 10 * * ? * 每天10点15分触发
0 15 10 * * ? 2005 2005年每天10点15分触发
0 * 14 * * ? 每天下午的 2点到2点59分每分触发
0 0/5 14 * * ? 每天下午的 2点到2点59分(整点开始,每隔5分触发)
0 0/5 14,18 * * ? 每天下午的 2点到2点59分(整点开始,每隔5分触发) 每天下午的 18点到18点59分(整点开始,每隔5分触发)
0 0-5 14 * * ? 每天下午的 2点到2点05分每分触发
0 10,44 14 ? 3 WED 3月分每周三下午的 2点10分和2点44分触发
0 15 10 ? * MON-FRI 从周一到周五每天上午的10点15分触发
0 15 10 15 * ? 每月15号上午10点15分触发
0 15 10 L * ? 每月最后一天的10点15分触发
0 15 10 ? * 6L 每月最后一周的星期五的10点15分触发
0 15 10 ? * 6L 2002-2005 从2002年到2005年每月最后一周的星期五的10点15分触发
0 15 10 ? * 6#3 每月的第三周的星期五开始触发
0 0 12 1/5 * ? 每月的第一个中午开始每隔5天触发一次
0 11 11 11 11 ? 每年的11月11号 11点11分触发(光棍节)

6.Spring整合Quartz

需要Spring-context-support包支持,POM如下

1
2
3
4
5
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context-support</artifactId>
<version>4.3.5.RELEASE</version>
</dependency>

新建两种Job测试类–>DemoSimpleJob类和DemoCronJob类,并继承自QuartzJobBean,代码如下

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
package com;

import java.text.SimpleDateFormat;
import java.util.Date;

import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import org.springframework.scheduling.quartz.QuartzJobBean;

public class DemoJob extends QuartzJobBean {

@Override
protected void executeInternal(JobExecutionContext arg0) throws JobExecutionException {
System.out.println(new SimpleDateFormat("hh:mm:ss").format(new Date()) + " 输出自:" + getClass().getName());
}

}

配置spring bean如下

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
<?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:context="http://www.springframework.org/schema/context"
xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-4.3.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-4.3.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop-4.3.xsd
http://www.springframework.org/schema/tx
http://www.springframework.org/schema/tx/spring-tx-4.3.xsd">




<bean id="demoCronJob"
class="org.springframework.scheduling.quartz.JobDetailFactoryBean">
<property name="jobClass" value="com.DemoCronJob" />
</bean>
<bean id="demoSimpleJob"
class="org.springframework.scheduling.quartz.JobDetailFactoryBean">
<property name="jobClass" value="com.DemoSimpleJob" />
</bean>


<bean id="simpleTrigger"
class="org.springframework.scheduling.quartz.SimpleTriggerFactoryBean">
<property name="jobDetail" ref="demoSimpleJob" />
<property name="startDelay" value="1000" />
<property name="repeatInterval" value="2000" />
</bean>
<bean id="cornTrigger"
class="org.springframework.scheduling.quartz.CronTriggerFactoryBean">
<property name="jobDetail" ref="demoCronJob" />
<property name="cronExpression" value="1-30 * * * * ?" />
</bean>

<bean class="org.springframework.scheduling.quartz.SchedulerFactoryBean">
<property name="triggers">
<list>
<ref bean="cornTrigger" />
<ref bean="simpleTrigger" />
</list>
</property>
</bean>

启动

1
2
3
4
5
6
7
8
9
10
11
package com;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Demo {
public static void main(String[] args) {
ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");

}
}

有待补充

  1. WinForm程序

1)第一种方法,使用委托:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

private delegate void SetTextCallback(string text);
private void SetText(string text)
{
// InvokeRequired需要比较调用线程ID和创建线程ID
// 如果它们不相同则返回true
if (this.txt_Name.InvokeRequired)
{
SetTextCallback d = new SetTextCallback(SetText);
this.Invoke(d, new object[] { text });
}
else {
this.txt_Name.Text = text;
}
}

2)第二种方法,使用匿名委托

1
2
3
4
5
6
7
8
9
10
11
12
private void SetText(Object obj)
{
if (this.InvokeRequired)
{
this.Invoke(new MethodInvoker(delegate {
this.txt_Name.Text = obj;
}));
}
else {
this.txt_Name.Text = obj;
}
}

这里说一下BeginInvoke和Invoke和区别:BeginInvoke会立即返回,Invoke会等执行完后再返回。

  1. WPF程序

1)可以使用Dispatcher线程模型来修改

如果是窗体本身可使用类似如下的代码:

this.lblState.Dispatcher.Invoke(new Action(delegate
{
this.lblState.Content = “状态:” + this._statusText;
}));

那么假如是在一个公共类中弹出一个窗口、播放声音等呢?这里我们可以使用:System.Windows.Application.Current.Dispatcher,如下所示

复制代码

System.Windows.Application.Current.Dispatcher.Invoke(new Action(() =>
{
if (path.EndsWith(“.mp3”) || path.EndsWith(“.wma”) || path.EndsWith(“.wav”))
{
_player.Open(new Uri(path));
_player.Play();
}
}));

关键问题:多个视频同时播放,以上几种方法不足以解决,多个视频播放中主界面卡死和播放显示刷新不了的问题。

目前笔者的解决方法是

 pinturebox.CreateGraphics().DrawImage(imgSrc.Bitmap, new System.Drawing.Rectangle(0, 0, pinturebox.Width, pinturebox.Height));

EmguCV中的Capture类可以完成视频文件的读取,并捕捉每一帧,可以利用Capture类完成实现WinForm中视频检测跟踪环境的搭建。本文只实现最简陋的WinForm + EmguCV上的avi文件读取和播放框架,复杂的检测和跟踪算法在之后添加进去。

        这里使用WinForm实现视频的播放,主要是PictureBox类,它是支持基于事件的异步模式的典型组件,不使用EmguCV自带的UI控件等。

效果图

图1.效果图

        直接在UI线程中完成视频的播放的话整个程序只有一个线程,由于程序只能同步执行,播放视频的时候UI将停止响应用户的输入,造成界面的假死。所以视频的播放需要实现异步模式。主要有三种方法:第一是使用异步委托;第二种是使用BackgroundWorker组件;最后一种就是使用多线程(不使用CheckForIllegalCrossThreadCalls =false的危险做法)。

        Windows窗体控件,唯一可以从创建它的线程之外的线程中调用的是Invoke()、BegionInvoke()、EndInvoke()方法和InvokeRequired属性。其中BegionInvoke()、EndInvoke()方法是Invoke()方法的异步版本。这些方法会切换到创建控件的线程上,以调用赋予一个委托参数的方法,该委托参数可以传递给这些方法。

        (一)   使用多线程
        首先定义监控的类及其对应的事件参数类和异常类:
        判断是否继续执行的布尔型成员会被调用线程改变,因此声名为volatile,不进行优化。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
/// <summary>
/// 红外检测子。
/// </summary>
public class ThermalSurveillant
{
#region Private Fields

/// <summary>
/// 是否停止线程,此变量供多个线程访问。
/// </summary>
private volatile bool shouldStop = false;

#endregion
#region Public Properties

#endregion
#region Public Events

/// <summary>
/// 帧刷新事件。
/// </summary>
public EventHandler<FrameRefreshEventArgs> FrameRefresh;

/// <summary>
/// 播放完成。
/// </summary>
public EventHandler<CompletedEventArgs> Completed;

#endregion
#region Protected Methods

/// <summary>
/// 处理帧刷新事件。
/// </summary>
/// <param name="e"></param>
protected virtual void OnFrameRefresh(FrameRefreshEventArgs e)
{
if (this.FrameRefresh != null)
{
this.FrameRefresh(this, e);
}
}

/// <summary>
/// 处理视频读完事件。
/// </summary>
/// <param name="e"></param>
protected virtual void OnCompleted(CompletedEventArgs e)
{
if (this.Completed != null)
{
this.Completed(this, e);
}
}

#endregion
#region Public Methods

/// <summary>
/// 视频监控。
/// </summary>
/// <param name="capture">捕捉。</param>
public void DoSurveillance(Object oCapture)
{
Capture capture = oCapture as Capture;
int id = 1;
if (capture == null)
{
throw new InvalidCaptureObjectException("传递的Capture类型无效。");
}
while (!shouldStop)
{
Image<Bgr, byte> frame = capture.QueryFrame();
if (frame != null)
{
FrameRefreshEventArgs e = new FrameRefreshEventArgs(frame.ToBitmap(), id++);
// 触发刷新事件
this.OnFrameRefresh(e);
}
else
{
break;
}
}
// 触发完成事件
this.OnCompleted(new CompletedEventArgs(id));
}

/// <summary>
/// 请求停止线程。
/// </summary>
public void Cancel()
{
this.shouldStop = true;
}

#endregion
}

        UI线程中启动播放线程:

声明:

1
2
3
4
5
6
7
8
9
10
11
12
/// <summary>
/// 监控线程。
/// </summary>
private Thread threadSurveillance = null;
/// <summary>
/// 捕获视频帧。
/// </summary>
private Capture captureSurveillance;
/// <summary>
/// 监控子。
/// </summary>
private ThermalSurveillant surveillant = new ThermalSurveillant();

读入视频文件:

1
2
3
4
5
captureSurveillance = new Capture(this.videoFilePath);
captureSurveillance.SetCaptureProperty(CAP_PROP.CV_CAP_PROP_FRAME_WIDTH, this.width);
captureSurveillance.SetCaptureProperty(CAP_PROP.CV_CAP_PROP_FRAME_HEIGHT, this.height);
Image<Bgr, byte> frame = captureSurveillance.QueryFrame();
this.pictureBox.Image = frame.ToBitmap();

播放视频文件:

        UI线程中响应监控类的事件:

定义异步调用的委托:

添加事件委托:

1
2
this.surveillant.FrameRefresh += OnRefreshFrame;
this.surveillant.Completed += OnCompleted;

        以下方法中都是由监控线程中的事件委托方法,应该使用BeginInvoke方法,这样可以优雅的结束线程,如果使用Invoke方法,则调用方式为同步调用,此时如果使用Thread.Join()方法终止线程将引发死锁(正常播放没有问题),Thread.Join()方法的使用使调用线程阻塞等待当前线程完成,在这里即UI线程阻塞等待监控线程完成,而监控线程中又触发UI线程中pictureBox的刷新,使用Invoke方法就造成了监控线程等待UI线程刷新结果,而UI线程已经阻塞,形成了死锁。死锁时只能用Thread.Abort()方法才能结束线程。或者直接强制结束应用程序。

        使用BeginInvoke方法时为异步调用,监控线程不等待刷新结果直接继续执行,可以正常结束。结束后UI才进行刷新,不会造成死锁。

图2.线程关系

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
/// <summary>
/// 刷新UI线程的pixtureBox的方法。
/// </summary>
/// <param name="frame">要刷新的帧。</param>
private void RefreshFrame(Bitmap frame)
{
this.pictureBox.Image = frame;
// 这里一定不能刷新!2012年8月2日1:50:16
//this.pictureBox.Refresh();
}


/// <summary>
/// 响应pictureBox刷新。
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void OnRefreshFrame(object sender, FrameRefreshEventArgs e)
{
// 判断是否需要跨线程调用
if (this.pictureBox.InvokeRequired == true)
{
FrameRefreshDelegate fresh = this.RefreshFrame;
this.BeginInvoke(fresh, e.Frame);
}
else
{
this.RefreshFrame(e.Frame);
}
}


/// <summary>
/// 响应Label刷新信息。
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void OnCompleted(object sender, CompletedEventArgs e)
{
// 判断是否需要跨线程调用
CompletedDelegate fresh = this.RefreshStatus;
string message = "视频结束,共 " + e.FrameCount + " 帧。";
this.BeginInvoke(fresh, message);
}
  

关闭时需要中止播放线程之后再退出:

/// <summary>
/// 关闭窗体时发生。
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void OnFormClosed(object sender, FormClosedEventArgs e)
{
// 检测子算法请求终止
surveillant.Cancel();

// 阻塞调用线程直到检测子线程终止
if (threadSurveillance != null)
{
if (threadSurveillance.IsAlive == true)
{
threadSurveillance.Join();
}
}
}

        (二)   使用异步委托

        创建线程的一个更简单的方法是定义一个委托,并异步调用它。委托是方法的类型安全的引用。Delegate类还支持异步地调用方法。在后台,Delegate类会创建一个执行任务的线程。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
// asynchronous by using a delegate
PlayVideoDelegate play = this.PlayVideoFile;
IAsyncResult status = play.BeginInvoke(null, null);

/// <summary>
/// 播放视频文件。
/// </summary>
private void PlayVideoFile()
{
while (true)
{
Image<Bgr, byte> frame = capture.QueryFrame();
if (frame != null)
{
Image<Gray, byte> grayFrame = frame.Convert<Gray, byte>();
grayFrame.Resize(this.width, this.height, INTER.CV_INTER_CUBIC);
RefreshPictureBoxDelegate fresh = this.RefreshPictureBox;
try
{
this.BeginInvoke(fresh, grayFrame.ToBitmap());
}
catch (ObjectDisposedException ex)
{
Thread.CurrentThread.Abort();
}
}
else
{
break;
}
}
}

/// <summary>
/// 刷新UI线程的pixtureBox的方法。
/// </summary>
/// <param name="frame">要刷新的帧。</param>
private void RefreshPictureBox(Bitmap frame)
{
this.pictureBox.Image = frame;
}

        (三)   使用BackgroundWorker组件

        BackgroundWorker类是异步事件的一种实现方案,异步组件可以选择性的支持取消操作,并提供进度信息。RunWorkerAsync()方法启动异步调用。CancelAsync()方法取消。

图3.BackgroundWorker组件

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
/// <summary>
/// 播放视频文件。
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void detectItemPlay_Click(object sender, EventArgs e)
{
if (this.videoFilePath != null)
{
// run async
this.backgroundWorker.RunWorkerAsync(capture);
}
}

/// <summary>
/// 异步调用。
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void OnDoWork(object sender, DoWorkEventArgs e)
{
Emgu.CV.Capture capture = e.Argument as Emgu.CV.Capture;
while (!e.Cancel)
{
Image<Bgr, byte> frame = capture.QueryFrame();
if (frame != null)
{
Image<Gray, byte> grayFrame = frame.Convert<Gray, byte>();
grayFrame.Resize(this.width, this.height, INTER.CV_INTER_CUBIC);
if (this.backgroundWorker.CancellationPending == true)
{
e.Cancel = true;
break;
}
else
{
if (this.pictureBox.InvokeRequired == true)
{
RefreshPictureBoxDelegate fresh = this.RefreshPictureBox;
this.BeginInvoke(fresh, grayFrame.ToBitmap());
}
else
{
this.RefreshPictureBox(grayFrame.ToBitmap());
}
}
}
else
{
break;
}
}
}

/// <summary>
/// 关闭窗体时发生。
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void MainForm_FormClosed(object sender, FormClosedEventArgs e)
{
if (this.backgroundWorker.IsBusy)
{
this.backgroundWorker.CancelAsync();
}
}

在 WPF 中总会修改 Button 的 Style,比如一个自定义的 Close 按钮。刚入门的可能会用一张 PNG 格式的图片来做这个按钮的 Icon,但这个是不优雅的。而且你要改的时候还得去操作文件,想想都痛苦。

但是很多人苦于不知道去哪里获取 Path,当然网上已经有不少使用 Photoshop 获取图片的 Path ,但如果图片的质量不好,获取的 Path 歪歪曲曲的也不好看,更何况在这之前你还得会使用 Photoshop。

现在分享一个我经常使用的解决方案,阿里巴巴矢量图,这上面可以说有海量的图标可以用到。

流程:

  1,进入 阿里巴巴矢量图 并搜索你想要的图标

  2,下载 Icon 时使用 SVG 下载

  3,用记事本或文本编辑器打开,标签 Path 下的 d 属性就是 Path 的 Data 数据(很多复杂一点的 Icon 可能是多个 Data 组成,使用时只要用空格把几个 Data 隔开就行)

  例子:

  <svg t=“1491032725422” class=“icon” style=“” viewBox=“0 0 1024 1024” version=“1.1” xmlns=“http://www.w3.org/2000/svg“ p-id=“2372” xmlns:xlink=“http://www.w3.org/1999/xlink“ width=“248” height=“248”>
  <defs>
    <style type=“text/css”></style>
  </defs>
  <path d=“M503.2868 510.9903m-349.4226 0a341.233 341.233 0 1 0 698.8452 0 341.233 341.233 0 1 0-698.8452 0Z” p-id=“2373”></path>
  <path d=“M106.1386 263.9677a110 100 0 1 1 121.6696 248.2668Z” p-id=“2374”></path>
</svg>

  在WPF中使用时:

<Path Data=“M503.2868 510.9903m-349.4226 0a341.233 341.233 0 1 0 698.8452 0 341.233 341.233 0 1 0-698.8452 0Z M106.1386 263.9677a110 100 0 1 1 121.6696 248.2668Z”/>

Data 也可以作为资源放在独立的资源字典里,使用的 Geometry 标签

<Geometry x:Key=“logo”>M503.2868 510.9903m-349.4226 0a341.233 341.233 0 1 0 698.8452 0 341.233 341.233 0 1 0-698.8452 0Z M106.1386 263.9677a110 100 0 1 1 121.6696 248.2668Z</Geometry>

XAML:

<Path Data=“{StaticResource logo}” Fill=“White” Stretch=“Fill” Stroke=“White” StrokeThickness=“1.5” />

介绍

在实际项目使用中quartz.net中,都希望有一个管理界面可以动态添加job,而避免每次都要上线发布。 

也看到有园子的同学问过。这里就介绍下实现动态添加job的几种方式, 也是二次开发的核心模块。

阅读目录:

  1. 传统方式
  2. 框架反射方式
  3. 进程方式
  4. URL方式
  5. 框架配置方式

传统方式

 继承IJob,实现业务逻辑,添加到scheduler。

public class MonitorJob : IJob
{ public void Execute(IJobExecutionContext context)
{ //do something
Console.WriteLine(“test”);
}
} //var job = JobBuilder.Create() // .WithIdentity(“test”, “value”) // .Build(); //var trigger = (ICronTrigger) TriggerBuilder.Create() // .WithIdentity(“test”, “value”) // .WithCronSchedule(“0 0/5 * * * ?”) // .Build(); //scheduler.ScheduleJob(job, trigger);

也可以使用CrystalQuartz远程管理暂停取消。之前的博客CrystalQuartz远程管理(二)

框架反射方式

这种方式需要定义一套接口框架。 比如:

interface IcustomJob
{ void Excute(string context); void Failed(string error); void Complete(string msg);
}

1:当我们写job时同一实现这个框架接口,类库形式。

2:写完后编译成DLL,上传到我们的作业执行节点。

3:在执行节点中,通过反射拿到DLL的job信息。

4:然后构建quartz的job,添加到scheduler。

这种方式缺点: 耦合性太高,开发量较大。 优点:集中式管理。

系统结构如图:

进程方式

这个方式和windows任务计划类似。

1:使用方编写自己的job,无需实现任何接口,可执行应用程序形式。

2:将程序发送到执行节点,由执行节点起进程调用job程序。

执行节点调用,示例如下:

public class ConsoleJob:IJob
{ public void Execute(IJobExecutionContext context)
{
JobDataMap dataMap = context.JobDetail.JobDataMap; string content = dataMap.GetString(“jobData”); var jd = new JavaScriptSerializer().Deserialize(content);

        Process p \= new Process();
        p.StartInfo.UseShellExecute \= true;
        p.StartInfo.FileName \= jd.Path;
        p.StartInfo.Arguments \= jd.Parameters;   //空格分割
        p.StartInfo.WindowStyle = ProcessWindowStyle.Minimized;
        p.Start();
    }
}

这种方式相对来说: 耦合性中等,执行节点和job相互不关心,没有依赖,开发量较小。

系统结构如图:

URL方式

URL方式和第三种类似,不过调用的不在是执行程序,而是URL。

1: 使用方在网页或服务中,实现业务逻辑。

2: 然后将Url,交给执行节点post或get执行。

执行节点调用,示例如下:

public class HttpJob : IJob
{ public void Execute(IJobExecutionContext context)
{ var dataMap = context.JobDetail.JobDataMap; var content = dataMap.GetString(“jobData”); var jd = new JavaScriptSerializer().Deserialize(content); if (jd.Parameters == null)
jd.Parameters = string.Empty; if (jd.Timeout == 0)
jd.Timeout = 5*60; var result = RequestHelper.Post(jd.Url, jd.ContentType, jd.Timeout, jd.Parameters, jd.heads);
}
}

这种方式耦合比较低,使用方不需要单独写应用程序了,和平常业务开发一样。

执行节点的职权,仅仅作为一个触发器。

有2点需要注意的是:

1:请求URL时,注意双方约定token加密,防止非执行节点执行调用。

2:使用方,如果有耗时操作,建议异步执行。 

系统结构如图:

框架配置方式

1:使用方直接使用quartz.net框架,实现自己的job。从管理方拉取执行节点配置,然后自行管理执行节点。

2:使用方也可以暴露端口给管理方,以实现监控,修改配置。

这种形式,耦合性最低。是把管理方当成一个配置中心。 ps:几乎和传统方式+CrystalQuartz一样了。

通过context.JobDetail.JobDataMap,可以保存job的需要的信息。

本篇介绍主流的几种实现方案,供大家参考使用。

介绍

在实际使用quartz.net中,持久化能保证实例重启后job不丢失、 集群能均衡服务器压力和解决单点问题。

quartz.net在这两方面配置都比较简单。

持久化

quartz.net的持久化,是把job、trigger一些信息存储到数据库里面,以解决内存存储重启丢失。

下载sql脚本

           https://github.com/quartznet/quartznet/blob/master/database/tables/tables\_sqlServer.sql

创建个数据库,并执行脚本

  QRTZ_BLOB_TRIGGERS  以Blob 类型存储的触发器。

  QRTZ_CALENDARS   存放日历信息, quartz.net可以指定一个日历时间范围。

  QRTZ_CRON_TRIGGERS  cron表达式触发器。

  QRTZ_JOB_DETAILS      job详细信息。

  QRTZ_LOCKS       集群实现同步机制的行锁表

  QRTZ_SCHEDULER_STATE   实例信息,集群下多使用。

quartz.net 配置

//===持久化==== //存储类型
properties[“quartz.jobStore.type”] = “Quartz.Impl.AdoJobStore.JobStoreTX, Quartz”; //表明前缀
properties[“quartz.jobStore.tablePrefix”] = “QRTZ_“; //驱动类型
properties[“quartz.jobStore.driverDelegateType”] = “Quartz.Impl.AdoJobStore.SqlServerDelegate, Quartz”; //数据源名称
properties[“quartz.jobStore.dataSource”] = “myDS”; //连接字符串
properties[“quartz.dataSource.myDS.connectionString”] = @”Data Source=(local);Initial Catalog=JobScheduler;User ID=sa;Password=123465”; //sqlserver版本
properties[“quartz.dataSource.myDS.provider”] = “SqlServer-20”;

启动客户端

var properties = JobsManager.GetProperties(); var schedulerFactory = new StdSchedulerFactory(properties);
scheduler = schedulerFactory.GetScheduler();
scheduler.Start(); //var job = JobBuilder.Create() // .WithIdentity(“test”, “value”) // .Build(); //var trigger = (ICronTrigger) TriggerBuilder.Create() // .WithIdentity(“test”, “value”) // .WithCronSchedule(“0 0/5 * * * ?”) // .Build(); //scheduler.ScheduleJob(job, trigger);

补充

     1: 持久化后,job只有添加一次了(数据库已经有了),所以不能再执行端写添加job的行为。这时候需要一个管理工具,动态添加操作。

     2: quartz.net 支持sql server、sqlite、mysql、oracle、mongodb(非官方版)。

部署图:

 

如图quartz.net 的集群模式是依赖数据库表的,所以要持久化配置。  集群节点之间是不通信的,这样分布式的架构,很方便进行水平扩展。

1: 除了线程池数量,instanceId可以不同外,各个节点的配置必须是一样的。

2:集群中节点的系统时间一致。  

3:多线程、集群中。quartz.net 利用数据库锁来保证job不会重复执行。

     源码在DBSemaphore.cs、UpdateLockRowSemaphore.cs、StdRowLockSemaphore.cs

4:集群化后,某节点失效后,剩余的节点能保证job继续执行下去。

实例配置后启动。

//cluster
properties[“quartz.jobStore.clustered”] = “true”;
properties[“quartz.scheduler.instanceId”] = “AUTO”;

简单管理界面:

介绍

前面介绍Quartz.Net的基本用法,但在实际应用中,往往有更多的特性需求,比如记录job执行的执行历史,发邮件等。

阅读目录

  1. Quartz.Net插件
  2. TriggerListener,JobListener
  3. Cron表达式
  4. Quartz.Net线程池
  5. 总结

Quartz.Net插件

     Quartz.net 自身提供了一个插件接口(ISchedulerPlugin)用来增加附加功能,看下官方定义:

1

2

3

4

5

6

7

8

public interface ISchedulerPlugin

{

void Initialize(``string pluginName, IScheduler sched);

void Shutdown();

void Start();

}

 继承接口,实现自己的插件。

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

public class MyPlugin : ISchedulerPlugin

{

public void  Initialize(``string pluginName, IScheduler sched)

{

Console.WriteLine(``"实例化"``);

}

public  void Start()

{

Console.WriteLine(``"启动"``);

}

public  void Shutdown()

{

Console.WriteLine(``"关闭"``);

}

}

  主函数里面配置要实现的插件,注释部分,一句话搞定。

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

static void Main(``string``[] args)

{

var properties = new NameValueCollection();

properties[``"quartz.plugin.MyPlugin.type"``] = "QuartzDemo3.MyPlugin,QuartzDemo3"``;

var schedulerFactory = new StdSchedulerFactory(properties);

var scheduler = schedulerFactory.GetScheduler();

var job = JobBuilder.Create<HelloJob>()

.WithIdentity(``"myJob"``, "group1"``)

.Build();

var trigger = TriggerBuilder.Create()

.WithIdentity(``"mytrigger"``, "group1"``)

.WithCronSchedule(``"/2 * * ? * *"``)

.Build();

scheduler.ScheduleJob(job, trigger);

scheduler.Start();

Thread.Sleep(6000);

scheduler.Shutdown(``true``);

Console.ReadLine();

}

运行结果如下:

  — Quartz.Net进阶/172151135196757.png)

TriggerListener,JobListener

这2个是对触发器和job本身的行为监听器,这样更好方便跟踪Job的状态及运行情况。  

ITriggerListener是官方定义的接口,这里我们直接继承实现。 

public class MyTriggerListener : ITriggerListener
{ private string name; public void TriggerComplete(ITrigger trigger, IJobExecutionContext context, SchedulerInstruction triggerInstructionCode)
{
Console.WriteLine(“job完成时调用”);
} public void TriggerFired(ITrigger trigger, IJobExecutionContext context)
{
Console.WriteLine(“job执行时调用”);
} public void TriggerMisfired(ITrigger trigger)
{
Console.WriteLine(“错过触发时调用(例:线程不够用的情况下)”);
} public bool VetoJobExecution(ITrigger trigger, IJobExecutionContext context)
{ //Trigger触发后,job执行时调用本方法。true即否决,job后面不执行。
return false;
} public string Name { get { return name; } set { name = value; } }
}

主函数添加:

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

scheduler.ListenerManager.AddTriggerListener(myJobListener, KeyMatcher<TriggerKey>.KeyEquals(``new TriggerKey(``"mytrigger"``, "group1"``)));

////添加监听器到指定分类的所有监听器。

////添加监听器到指定分类的所有监听器。

////添加监听器到指定的2个分组。

////添加监听器到所有的触发器上。

scheduler.Start();

JobListener同理,这里不多做描述。

Cron表达式

quartz中的cron表达式和Linux下的很类似,比如 “/5 * * ? * * *“ 这样的7位表达式,最后一位年非必选。

表达式从左到右,依此是秒、分、时、月第几天、月、周几、年。下面表格是要遵守的规范:

字段名

允许的值

允许的特殊字符

Seconds

0-59

, - * /

Minutes

0-59

, - * /

Hours

0-23

, - * /

Day of month

1-31

, - * ? / L W

Month

1-12 or JAN-DEC

, - * /

Day of week

1-7 or SUN-SAT

, - * ? / L #

Year

空, 1970-2099

, - * /

特殊字符

解释

,

或的意思。例:分钟位 5,10  即第5分钟或10分都触发。 

/

a/b。 a:代表起始时间,b频率时间。 例; 分钟位  3/5,  从第三分钟开始,每5分钟执行一次。

*

频率。 即每一次波动。    例;分钟位 *  即表示每分钟 

-

区间。  例: 分钟位   5-10 即5到10分期间。 

?

任意值 。   即每一次波动。只能用在DayofMonth和DayofWeek,二者冲突。指定一个另一个一个要用?

L

表示最后。 只能用在DayofMonth和DayofWeek,4L即最后一个星期三

W

工作日。  表示最后。 只能用在DayofWeek

4#2。 只能用DayofMonth。 某月的第二个星期三  

实例介绍

”0 0 10,14,16 * * ?”    每天10点,14点,16点 触发。

“0 0/5 14,18 * * ?”    每天14点或18点中,每5分钟触发 。

“0 4/15 14-18 * * ?”       每天14点到18点期间,  从第四分钟触发,每15分钟一次。

“0 15 10 ? * 6L”        每月的最后一个星期五上午10:15触发。

Quartz.Net线程池

线程池数量设置:

properties[“quartz.threadPool.threadCount”] = “5”;

这个线程池的设置,是指同时间,调度器能执行Job的最大数量。

quartz是用每个线程跑一个job。上面的设置可以解释是job并发时能执行5个job,剩下的job如果触发时间恰好到了,当前job会进入暂停状态,直到有可用的线程。

如果在指定的时间范围依旧没有可用线程,会触发misfired时间。

quartz 提供了IThreadPool接口,也可以用自定义线程池来实现。

配置如下:

properties[“quartz.threadPool.type”] = “Quartz.Simpl.SimpleThreadPool, Quartz”;

一般来说作业调度很少并发触发大量job,如果有上百个JOB,可在服务器承受范围内适量增加线程数量。     

总结

官方有LoggingTriggerHistoryPlugin,LoggingJobHistoryPlugin  已实现的,触发器和job历史记录的插件。

Quartz.Plugin 命名空间下有官方实现的其他一些插件,也可以自己增加扩展。

quartz中监听器还有SchedulerListener,使用方法基本一样。 

本文基于自用经验和官方文档代码来写的,部分是直接翻译的。 

Quartz.Net官方教程http://www.quartz-scheduler.net/documentation/quartz-2.x/tutorial/index.html

介绍

上篇已经了解Quartz.NET的基本使用方法了。但如果想方便的知道某个作业执行情况,需要暂停,启动等操作行为,这时候就需要个Job管理的界面。

本文介绍Quartz.NET如何进行远程job管理,如图:

-CrystalQuartz远程管理/011755051751192.png)

实战

一:作业服务端

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

static void Main(``string``[] args)

{

var properties = new NameValueCollection();

properties[``"quartz.scheduler.instanceName"``] = "RemoteServerSchedulerClient"``;

properties[``"quartz.threadPool.type"``] = "Quartz.Simpl.SimpleThreadPool, Quartz"``;

properties[``"quartz.threadPool.threadCount"``] = "5"``;

properties[``"quartz.threadPool.threadPriority"``] = "Normal"``;

properties[``"quartz.scheduler.exporter.type"``] = "Quartz.Simpl.RemotingSchedulerExporter, Quartz"``;

properties[``"quartz.scheduler.exporter.port"``] = "556"``;

properties[``"quartz.scheduler.exporter.bindName"``] = "QuartzScheduler"``;

properties[``"quartz.scheduler.exporter.channelType"``] = "tcp"``;

var schedulerFactory = new StdSchedulerFactory(properties);

var scheduler = schedulerFactory.GetScheduler();

var job = JobBuilder.Create<PrintMessageJob>()

.WithIdentity(``"myJob"``, "group1"``)

.Build();

var trigger = TriggerBuilder.Create()

.WithIdentity(``"myJobTrigger"``, "group1"``)

.StartNow()

.WithCronSchedule(``"/10 * * ? * *"``)

.Build();

scheduler.ScheduleJob(job, trigger);

scheduler.Start();

}

1

2

3

4

5

6

7

public class PrintMessageJob : IJob

{

public void Execute(IJobExecutionContext context)

{

Console.WriteLine(``"Hello!"``);

}

}

启动如下

-CrystalQuartz远程管理/011801015192327.png)

二:作业远程管理端,无需写任何代码,引用官方程序集,嵌入到已有的web网站。 

      PM> Install-Package CrystalQuartz.Remote

      Webconfig 需要配置的地方

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

<configuration>

<crystalQuartz>

<provider>

<add property=``"Type" value=``"CrystalQuartz.Core.SchedulerProviders.RemoteSchedulerProvider, CrystalQuartz.Core" />

<add property=``"SchedulerHost" value=``"tcp://127.0.0.1:556/QuartzScheduler" /> <!--TCP监听的地址-->

</provider>

</crystalQuartz>

<system.webServer>

<!-- Handler拦截处理了,输出作业监控页面-->

<handlers>

<add name=``"CrystalQuartzPanel" verb=``"*" path=``"CrystalQuartzPanel.axd" type=``"CrystalQuartz.Web.PagesHandler, CrystalQuartz.Web" />

</handlers>

</system.webServer>

</configuration>

 Web管理界面

-CrystalQuartz远程管理/011811269404890.png)

其他

CrystalQuartz 提供基础功能,可以继续在此基础上进行二次开发,另外推荐使用Window服务寄宿,比较方法。

参考资源

张善友               http://www.cnblogs.com/shanyou/archive/2012/01/15/2323011.html

CrystalQuartz开源的地址   https://github.com/guryanovev/CrystalQuartz

背景

很多时候,项目需要在不同时刻,执行一个或很多个不同的作业。

Windows执行计划这时并不能很好的满足需求了,迫切需要一个更为强大,方便管理,集群部署的作业调度框架。

介绍

Quartz 一个开源的作业调度框架,OpenSymphony的开源项目。Quartz.Net 是Quartz的C#移植版本。

它一些很好的特性:

1:支持集群,作业分组,作业远程管理。 

2:自定义精细的时间触发器,使用简单,作业和触发分离。

3:数据库支持,可以寄宿Windows服务,WebSite,winform等。

实战

Quartz框架的一些基础概念解释:

   Scheduler     作业调度器。

   IJob             作业接口,继承并实现Execute, 编写执行的具体作业逻辑。

  JobBuilder       根据设置,生成一个详细作业信息(JobDetail)。

  TriggerBuilder   根据规则,生产对应的Trigger

Nuget安装 

PM> Install-Package Quartz

下面是简单使用例子,附带详细的注释:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

static void Main(string[] args)
{
IScheduler scheduler = StdSchedulerFactory.GetDefaultScheduler();
scheduler.Start();

IJobDetail job1 = JobBuilder.Create<HelloJob>()
.WithIdentity("作业名称", "作业组")
.Build();

ITrigger trigger1 = TriggerBuilder.Create()
.WithIdentity("触发器名称", "触发器组")
.StartNow()
.WithSimpleSchedule(x => x
.WithIntervalInSeconds(5)
.RepeatForever())
.Build();

scheduler.ScheduleJob(job1, trigger1);

IJobDetail job2= JobBuilder.Create<DumbJob>()
.WithIdentity("myJob", "group1")
.UsingJobData("jobSays", "Hello World!")
.Build();

ITrigger trigger2 = TriggerBuilder.Create()
.WithIdentity("mytrigger", "group1")
.StartNow()
.WithCronSchedule("/5 * * ? * *")
.Build();
scheduler.ScheduleJob(job2, trigger2);
}

声明要执行的作业,HelloJob:

1
2
3
4
5
6
7
8
9
10
11
12

/// <summary>
/// 作业
/// </summary>
public class HelloJob : IJob
{
public void Execute(IJobExecutionContext context)
{
Console.WriteLine("作业执行!");
}
}

声明要执行的作业,DumbJob:

public class DumbJob : IJob

{

/// <summary>

///  context 可以获取当前Job的各种状态。

/// </summary>

/// <param name="context"></param>

public void Execute(IJobExecutionContext context)

{

JobDataMap dataMap = context.JobDetail.JobDataMap;

string content = dataMap.GetString(``"jobSays"``);

Console.WriteLine(``"作业执行,jobSays:" + content);

}

}

其WithCronSchedule(“”) 拥有强大的Cron时间表达式,正常情况下_WithSimpleSchedule(x)_ 已经满足大部分对日期设置的要求了。

Quartz.Net官方2.X教程  http://www.quartz-scheduler.net/documentation/quartz-2.x/tutorial/index.html

Quartz.Net开源地址   https://github.com/quartznet/quartznet

C#实现

单例模式: [[DotNet/23种设计模式/单例模式|单例模式]]

Golang实现

单例模式: [[Golang/23种设计模式/单例模式|单例模式]]

Python实现

单例模式: [[Python/23种设计模式/单例模式|单例模式]]