随笔-290  评论-26  文章-1  trackbacks-0
  2017年6月26日

在了解REST API URI设计的规则之前,让我们快速浏览一些我们将要讨论的术语。

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,而不仅仅是为你的数据。

posted @ 2017-06-26 09:50 华梦行 阅读(78) | 评论 (0)编辑 收藏
  2017年6月19日

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

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

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

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

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

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

posted @ 2017-06-19 14:45 华梦行 阅读(38) | 评论 (0)编辑 收藏
  2017年5月26日
package org.gdharley.activiti.integration.rest;

import com.fasterxml.jackson.annotation.JsonProperty;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.activiti.engine.ActivitiException;
import org.activiti.engine.delegate.DelegateExecution;
import org.activiti.engine.delegate.Expression;
import org.activiti.engine.delegate.JavaDelegate;
import org.apache.commons.lang3.StringUtils;
import org.apache.http.HttpResponse;
import org.apache.http.NameValuePair;
import org.apache.http.client.methods.*;
import org.apache.http.client.utils.URIBuilder;
import org.apache.http.client.utils.URLEncodedUtils;
import org.apache.http.conn.ssl.SSLConnectionSocketFactory;
import org.apache.http.conn.ssl.SSLContextBuilder;
import org.apache.http.conn.ssl.TrustSelfSignedStrategy;
import org.apache.http.entity.StringEntity;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClientBuilder;
import org.apache.http.message.BasicNameValuePair;
import org.apache.http.protocol.HTTP;
import org.apache.http.util.EntityUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.http.HttpMethod;

import java.io.IOException;
import java.net.URI;
import java.net.URISyntaxException;
import java.util.List;


/**
 * Created by gharley on 5/2/17.
 
*/
public class SimpleRestDelegate implements JavaDelegate {
    private static final Logger logger = LoggerFactory.getLogger(SimpleRestDelegate.class);

    protected Expression endpointUrl;
    protected Expression httpMethod;
    protected Expression isSecure;
    protected Expression payload;

//    一个Content-Type是application/json的请求,具体看起来是这样的:
//    POST /some-path HTTP/1.1
//    Content-Type: application/json
//
//    { "foo" : "bar", "name" : "John" }
//
//
//    { "foo" : "bar", "name" : "John" } 就是这个请求的payload



    protected Expression headers;
    protected Expression responseMapping;

    protected ObjectMapper objectMapper = new ObjectMapper();

    // Create a mixin to force the BasicNameValuePair constructor
    protected static abstract class BasicNameValuePairMixIn {
        private BasicNameValuePairMixIn(@JsonProperty("name") String name, @JsonProperty("value") String value) {
        }
    }

    public void execute(DelegateExecution execution) throws Exception {
        logger.info("Started Generic REST call delegate");

        if (endpointUrl == null || httpMethod == null) {
            throw new IllegalArgumentException("An endpoint URL and http method are required");
        }

        String restUrl = getExpressionAsString(endpointUrl, execution);
        String payloadStr = getExpressionAsString(payload, execution);
        String headersJSON = getExpressionAsString(headers, execution); // [{"name":"headerName", "value":"headerValue"}]
        String method = getExpressionAsString(httpMethod, execution);
        String rMapping = getExpressionAsString(responseMapping, execution);
        String secure = getExpressionAsString(isSecure, execution);
        String scheme = secure == "true" ? "https" : "http";

        // validate URI and create create request
        URI restEndpointURI = composeURI(restUrl, execution);

        logger.info("Using Generic REST URI " + restEndpointURI.toString());

        HttpRequestBase httpRequest = createHttpRequest(restEndpointURI, scheme, method, headersJSON, payloadStr, rMapping);

        // create http client
        CloseableHttpClient httpClient = createHttpClient(httpRequest, scheme, execution);

        // execute request
        HttpResponse response = executeHttpRequest(httpClient, httpRequest);

        // map response to process instance variables
        if (responseMapping != null) {
            mapResponse(response, rMapping, execution);
        }

        logger.info("Ended Generic REST call delegate");

    }

    protected URI composeURI(String restUrl, DelegateExecution execution)
            throws URISyntaxException {

        URIBuilder uriBuilder = null;
        uriBuilder = encodePath(restUrl, uriBuilder);
        return uriBuilder.build();
    }

    protected URIBuilder encodePath(String restUrl, URIBuilder uriBuilder) throws URISyntaxException {

        if (StringUtils.isNotEmpty(restUrl)) {

            // check if there are URL params
            if (restUrl.indexOf('?') > -1) {

                List<NameValuePair> params = URLEncodedUtils.parse(new URI(restUrl), "UTF-8");

                if (params != null && !params.isEmpty()) {
                    restUrl = restUrl.substring(0, restUrl.indexOf('?'));
                    uriBuilder = new URIBuilder(restUrl);
                    uriBuilder.addParameters(params);

                }
            } else {
                uriBuilder = new URIBuilder(restUrl);
            }
        }

        return uriBuilder;
    }

    protected HttpRequestBase createHttpRequest(URI restEndpointURI, String scheme, String httpMethod, String headers, String payload, String responseMapping) {

        if (StringUtils.isEmpty(httpMethod)) {
            throw new ActivitiException("no HTTP method provided");
        }
        if (restEndpointURI == null) {
            throw new ActivitiException("no REST endpoint URI provided");
        }

        HttpRequestBase httpRequest = null;
        HttpMethod parsedMethod = HttpMethod.valueOf(httpMethod.toUpperCase());
        StringEntity input;
        URIBuilder builder = new URIBuilder(restEndpointURI);

        switch (parsedMethod) {
            case GET:
                try {
                    httpRequest = new HttpGet(builder.build());
                    httpRequest = addHeadersToRequest(httpRequest, headers);
                } catch (URISyntaxException use) {
                    throw new ActivitiException("Error while building GET request", use);
                }
                break;
            case POST:
                try {
                    httpRequest = new HttpPost(builder.build());
                    input = new StringEntity(payload);
//                input.setContentType(new BasicHeader(HTTP.CONTENT_TYPE, "application/json"));
                    ((HttpPost) httpRequest).setEntity(input);
                    httpRequest = addHeadersToRequest(httpRequest, headers);
                    break;
                } catch (Exception e) {
                    throw new ActivitiException("Error while building POST request", e);
                }
            case PUT:
                try {
                    httpRequest = new HttpPut(builder.build());
                    input = new StringEntity(payload);
//                input.setContentType(new BasicHeader(HTTP.CONTENT_TYPE, "application/json"));
                    ((HttpPut) httpRequest).setEntity(input);
                    httpRequest = addHeadersToRequest(httpRequest, headers);
                    break;
                } catch (Exception e) {
                    throw new ActivitiException("Error while building PUT request", e);
                }
            case DELETE:
                try {
                    httpRequest = new HttpDelete(builder.build());
                    httpRequest = addHeadersToRequest(httpRequest, headers);
                } catch (URISyntaxException use) {
                    throw new ActivitiException("Error while building DELETE request", use);
                }
                break;
            default:
                throw new ActivitiException("unknown HTTP method provided");
        }

        return httpRequest;
    }


    protected CloseableHttpClient createHttpClient(HttpRequestBase request, String scheme, DelegateExecution execution) {

        SSLConnectionSocketFactory sslsf = null;

        // Allow self signed certificates and hostname mismatches.
        if (StringUtils.equalsIgnoreCase(scheme, "https")) {
            try {
                SSLContextBuilder builder = new SSLContextBuilder();
                builder.loadTrustMaterial(nullnew TrustSelfSignedStrategy());
                sslsf = new SSLConnectionSocketFactory(builder.build(), SSLConnectionSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER);
            } catch (Exception e) {
                logger.warn("Could not configure HTTP client to use SSL", e);
            }
        }

        HttpClientBuilder httpClientBuilder = HttpClientBuilder.create();

        if (sslsf != null) {
            httpClientBuilder.setSSLSocketFactory(sslsf);
        }

        return httpClientBuilder.build();
    }

    protected HttpResponse executeHttpRequest(CloseableHttpClient httpClient, HttpRequestBase httpRequest) {

        CloseableHttpResponse response = null;
        try {
            response = httpClient.execute(httpRequest);
        } catch (IOException e) {
            throw new ActivitiException("error while executing http request: " + httpRequest.getURI(), e);
        }

        if (response.getStatusLine().getStatusCode() >= 400) {
            throw new ActivitiException("error while executing http request " + httpRequest.getURI() + " with status code: "
                    + response.getStatusLine().getStatusCode());
        }

        return response;
    }

    protected void mapResponse(HttpResponse response, String responseMapping, DelegateExecution execution) {

        if (responseMapping == null || responseMapping.trim().length() == 0) {
            return;
        }

        JsonNode jsonNode = null;
        try {
            String jsonString = EntityUtils.toString(response.getEntity());
            jsonNode = objectMapper.readTree(jsonString);

        } catch (Exception e) {
            throw new ActivitiException("error while parsing response", e);
        }

        if (jsonNode == null) {
            throw new ActivitiException("didn't expect an empty response body");
        }
        execution.setVariable(responseMapping, jsonNode.toString());
    }

    protected HttpRequestBase addHeadersToRequest(HttpRequestBase httpRequest, String headerJSON) {
        Boolean contentTypeDetected = false;
        if (headerJSON != null) {
            // Convert JSON to array
            try {
                // configuration for Jackson/fasterxml
                objectMapper.addMixInAnnotations(BasicNameValuePair.class, BasicNameValuePairMixIn.class);
                NameValuePair[] headers = objectMapper.readValue(headerJSON, BasicNameValuePair[].class);
                for (NameValuePair header : headers) {
                    httpRequest.addHeader(header.getName(), header.getValue());
                    if (header.getName().equals(HTTP.CONTENT_TYPE)) {
                        contentTypeDetected = true;
                    }
                }
            } catch (Exception e) {
                throw new ActivitiException("Unable to parse JSON header array", e);
            }
        }
        // Now add content type if necessary
        if (!contentTypeDetected) {
            httpRequest.addHeader(HTTP.CONTENT_TYPE, "application/json");
        }
        return httpRequest;
    }

    /**
     * 
@return string value of expression.
     * 
@throws {@link IllegalArgumentException} when the expression resolves to a value which is not a string
     *                or if the value is null.
     
*/
    protected String getExpressionAsString(Expression expression, DelegateExecution execution) {
        if (expression == null) {
            return null;
        } else {
            Object value = expression.getValue(execution);
            if (value instanceof String) {
                return (String) value;
            } else {
                throw new IllegalArgumentException("Expression does not resolve to a string or is null: " + expression.getExpressionText());
            }
        }
    }
}
posted @ 2017-05-26 08:01 华梦行 阅读(59) | 评论 (0)编辑 收藏
  2017年5月16日

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(身份联系)

用户组ID(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个小时,还有很多问题不明白。后续慢慢开发过程中再理一次表之间关系吧,初步想法在系统中需要扩建表,把业务数据和流程数据分开。

posted @ 2017-05-16 16:31 华梦行 阅读(80) | 评论 (0)编辑 收藏
  2017年5月15日
     摘要: Activiti工作流引擎数据库表结构 数据库表的命名 Acitiviti数据库中表的命名都是以ACT_开头的。第二部分是一个两个字符用例表的标识。此用例大体与服务API是匹配的。 l  ACT_RE_*:’RE’表示repository。带此前缀的表包含的是静态信息,如,流程定义,流程的资源(图片,规则等)。 l  ACT_RU_*:̵...  阅读全文
posted @ 2017-05-15 22:23 华梦行 阅读(100) | 评论 (0)编辑 收藏
  2017年5月10日
@Transient 可选 @Transient表示该属性并非一个到数据库表的字段的映射,ORM框架将忽略该属性. 如果一个属性并非数据库表的字段映射,就务必将其标示为@Transient,否则,ORM框架默认其注解为@Basic 示例: //根据birth计算出age属性 @Transient public int getAge() { return getYear(new Date()) - getYear(birth); } 注意是加在get方法上的
posted @ 2017-05-10 16:59 华梦行 阅读(98) | 评论 (0)编辑 收藏
  2017年3月22日
Snmpwalk –v 2 –c public 192.168.20.114 1.3.6.1.2.1.2.2.1.3
snmpget -r:127.0.0.1 -o:.1.3.6.1.2.1.25.3.3.1.2
E:\>snmpget -r:127.0.0.1 -o:.1.3.6.1.2.1.1.1.0
SnmpGet v1.01 - Copyright (C) 2009 SnmpSoft Company
[ More useful network tools on http://www.snmpsoft.com ]
OID=.1.3.6.1.2.1.1.1.0
Type=OctetString
Value=Hardware: Intel64 Family 6 Model 60 Stepping 3 AT/AT COMPATIBLE - Software
: Windows Version 6.1 (Build 7601 Multiprocessor Free)
snmpwalk -v:2c -c:public -r:127.0.0.1
posted @ 2017-03-22 15:28 华梦行 阅读(33) | 评论 (0)编辑 收藏
  2017年3月21日

Druid是什么?

Druid是一个JDBC组件,它包括四个部分:

http://download.csdn.net/download/feelnature/1580901
http://tomcat.apache.org/tomcat-8.5-doc/monitoring.html#Enabling_JMX_Remote

http://download.csdn.net/detail/qq_21163257/9695557

 

  • 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提供了一些内置的扩展机制,包括StatLogTrace、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
 
posted @ 2017-03-21 00:11 华梦行 阅读(68) | 评论 (0)编辑 收藏
  2017年3月19日
http://repo.spring.io/release/org/springframework/spring/4.3.6.RELEASE/
http://spring.io/tools/sts http://www.loveweir.com/posts/view/19
https://github.com/rahulyewale/springmvcjpa
http://download.csdn.net/download/jiuqiyuliang/8640621
http://blog.csdn.net/suzunshou/article/details/49949005
https://repo1.maven.org/maven2/org/mybatis/mybatis/
http://blog.csdn.net/jiuqiyuliang/article/details/45132493/
https://github.com/mybatis/generator/releases
posted @ 2017-03-19 22:39 华梦行 阅读(45) | 评论 (0)编辑 收藏
  2016年7月21日
今天从windows上导出一个sql执行文件,再倒入到unbutn中,结果出现乱码,折腾7-8分钟, 
解决方式 
在导出mysql sql执行文件的时候,指定一下编码格式: 
复制代码 代码如下:
mysqldump -uroot -p --default-character-set=utf8 mo(dbname) > E://xxxx.sql 
导入的时候OK了 
执行如下 
复制代码 代码如下:
mysql -u root -p --default-character-set=utf8 
use dbname 
source /root/newsdata.sql 
posted @ 2016-07-21 13:33 华梦行 阅读(49) | 评论 (0)编辑 收藏
  2016年6月27日

CentOS
1、备份
mv /etc/yum.repos.d/CentOS-Base.repo /etc/yum.repos.d/CentOS-Base.repo.backup 
2、下载新的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  
CentOS 7
 wget -O /etc/yum.repos.d/CentOS-Base.repo http://mirrors.aliyun.com/repo/Centos-7.repo  
3、之后运行yum makecache生成缓存
相关链接
##官方主页: http://www.centos.org/
##邮件列表: http://www.centos.org/modules/tinycontent/index.php?id=16
##论坛: http://www.centos.org/modules/newbb/
##文档: http://www.centos.org/docs/
##Wiki: http://wiki.centos.org/
posted @ 2016-06-27 17:42 华梦行 阅读(41) | 评论 (0)编辑 收藏
  2016年5月11日

对输入数据进行正态化

 

为了使神经网络有效,我们必须对数据进行正态化。这是激活函数的正确计算所需要的。正态化是一种数学处理,将数据转换为 0..1 或 -1..1 的范围。正态化后的数据可以进行去正态化,即转换回原来的范围。

要将神经网络输出解码为人类可读的形式,需要对数据进行去正态化。谢天谢地,负责标准化和去标准化,因此不需要实施它。如果您对它的工作原理感到好奇,您可以分析以下代码:  


public static double INPUT_LOW = -20;
    public static double INPUT_HIGH = 20;
    public static double OUTPUT_HIGH = 1;
    public static double OUTPUT_LOW = -1;
    public static double normalize(final double value) {
        return ((value - INPUT_LOW) / (INPUT_HIGH - INPUT_LOW))
                * (OUTPUT_HIGH - OUTPUT_LOW) + OUTPUT_LOW;
        // return ((10f + 20f) / (40f)) * (2f) + OUTPUT_LOW;
    }
    public static double deNormalize(final double data) {
        double result = ((INPUT_LOW - INPUT_HIGH) * data - OUTPUT_HIGH
                * INPUT_LOW + INPUT_HIGH * OUTPUT_LOW)
                / (OUTPUT_LOW - OUTPUT_HIGH);
        return result;
    }

x=-5:.01:5;
   plot(x,tanh(x)),grid on;
posted @ 2016-05-11 18:27 华梦行 阅读(64) | 评论 (0)编辑 收藏
  2016年5月7日

1. Quickstart

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:

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
posted @ 2016-05-07 15:39 华梦行 阅读(1183) | 评论 (0)编辑 收藏
  2016年4月30日

阿里云Linux安装软件镜像源

阿里云是最近新出的一个镜像源。得益与阿里云的高速发展,这么大的需求,肯定会推出自己的镜像源。
阿里云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

posted @ 2016-04-30 21:11 华梦行 阅读(85) | 评论 (0)编辑 收藏
  2016年3月23日
 yum -y update
centos6 mysql5.5 yum安装
  
 
默认使用centos yum安装的mysql不是5.5版本的,我们需要增加两个新的repo
rpm -Uvh http://mirror.steadfast.net/epel/6/i386/epel-release-6-8.noarch.rpm
rpm -Uvh http://rpms.famillecollet.com/enterprise/remi-release-6.rpm
centos6下php php-fpm的yum安装
查看一下是不是有mysql 5.5了
yum --enablerepo=remi,remi-test list mysql mysql-server
安装mysql5.5
yum --enablerepo=remi,remi-test install mysql mysql-server
启动mysql5.5
/etc/init.d/mysqld start
设置开机启动
chkconfig --levels 345 mysqld on
要启用MySQL 安全设置请输入以下命令
/usr/bin/mysql_secure_installation


CentOS/RHEL 7.x:

rpm -Uvh https://dl.fedoraproject.org/pub/epel/epel-release-latest-7.noarch.rpm rpm -Uvh https://mirror.webtatic.com/yum/el7/webtatic-release.rpm

CentOS/RHEL 6.x:

rpm -Uvh https://dl.fedoraproject.org/pub/epel/epel-release-latest-6.noarch.rpm rpm -Uvh https://mirror.webtatic.com/yum/el6/latest.rpm

CentOS/RHEL 5.x:

rpm -Uvh https://dl.fedoraproject.org/pub/epel/epel-release-latest-5.noarch.rpm rpm -Uvh http://mirror.webtatic.com/yum/el5/latest.rpm

Now you can install PHP 5.5’s mod_php SAPI (along with an opcode cache) by doing:

yum install php55w php55w-opcache

You can alternatively install PHP 5.5’s php-fpm SAPI (along with an opcode cache by doing:





  rpm -Uvh http://mirror.webtatic.com/yum/el6/latest.rpm
  

rpm -Uvh https://mirror.webtatic.com/yum/el7/epel-release.rpm
rpm -Uvh https://mirror.webtatic.com/yum/el7/webtatic-release.rpm
如果想删除上面安装的包,重新安装
rpm -qa | grep webstatic
rpm -e  上面搜索到的包即可
3.运行yum install
  yum install php55w php55w-cli php55w-common php55w-gd php55w-ldap php55w-mbstring php55w-mcrypt php55w-mysql php55w-pdo php55w-xml
yum install php56w php56w-cli php56w-common php56w-gd php56w-ldap php56w-mbstring php56w-mcrypt php56w-mysql php56w-pdo php56w-xml

php 另外一种方式
 Remi官方网站:http://rpms.famillecollet.com/
添加Remi源,不管32位还是64位的系统,运行下面命令:
rpm -ivh http://rpms.famillecollet.com/enterprise/remi-release-6.rpm
 Remi源默认是没有启用的,我们来启用Remi源,修改 /etc/yum.repos.d/remi.repo 文件,把文件内的 enabled=0 改为 enabled=1 ,注意:改文件内有2个 enabled=0 我们修改 [remi]下面的,不要修改[remi-test]下面的。
 到这里yum源的配置结束,下面安装软件就简单了。安装时候有询问y/n的时候都是y
安装php,php-fpm以及php扩展:
yum install php php-fpm php-bcmatch php-gd php-mbstring php-mcrypt php-mysql php-pdo   php-dom


wget https://files.phpmyadmin.net/phpMyAdmin/4.0.10.15/phpMyAdmin-4.0.10.15-english.zip
 
posted @ 2016-03-23 15:15 华梦行 阅读(88) | 评论 (1)编辑 收藏

在CentOS安装PHP5.6

A-A+
 

美国时间2014年11月13日,PHP开发团队,在「PHP 5.6.3 is available|PHP: Hypertext Preprocessor」上公布了PHP5.6系的最新版本「PHP 5.6.3」。

在最新的版本5.6.3不仅修改了多个Bug,并且修改了fileinfo模块里存在的安全漏洞。

PHP团队推荐使用PHP5.6系列的用户,升级到最新版本5.6.3。

简单介绍一下,如何在CentOS上安装PHP5.6。

配置yum源

追加CentOS 6.5的epel及remi源。

# rpm -Uvh http://ftp.iij.ad.jp/pub/linux/fedora/epel/6/x86_64/epel-release-6-8.noarch.rpm 
# rpm -Uvh http://rpms.famillecollet.com/enterprise/remi-release-6.rpm

以下是CentOS 7.0的源。

# yum install epel-release # rpm -ivh http://rpms.famillecollet.com/enterprise/remi-release-7.rpm 

使用yum list命令查看可安装的包(Packege)。

# yum list --enablerepo=remi --enablerepo=remi-php56 | grep php 

安装PHP5.6

yum源配置好了,下一步就安装PHP5.6。

# yum install --enablerepo=remi --enablerepo=remi-php56 php php-opcache php-devel php-mbstring php-mcrypt php-mysqlnd php-phpunit-PHPUnit php-pecl-xdebug php-pecl-xhprof 

用PHP命令查看版本。

# php --version PHP 5.6.0 (cli) (built: Sep  3 2014 19:51:31) Copyright (c) 1997-2014 The PHP Group Zend Engine v2.6.0, Copyright (c) 1998-2014 Zend Technologies     with Zend OPcache v7.0.4-dev, Copyright (c) 1999-2014, by Zend Technologies     with Xdebug v2.2.5, Copyright (c) 2002-2014, by Derick Rethans 

在这里安装的版本是PHP5.6.0,细心的用户可能已经发现ZendGuardLoader变成Zend OPcahe了。

对从PHP5.5开始PHP代码缓存从APC变成了Zend OPcache了。

posted @ 2016-03-23 12:16 华梦行 阅读(70) | 评论 (0)编辑 收藏

Step1: 检测系统是否自带安装mysql

#yum list installed | grep mysql 

Step2: 删除系统自带的mysql及其依赖
命令:

# yum -y remove mysql-libs.x86_64 

Step3: 给CentOS添加rpm源,并且选择较新的源
命令:

#wget dev.mysql.com/get/mysql-community-release-el6-5.noarch.rpm 
#yum localinstall mysql-community-release-el6-5.noarch.rpm
# yum repolist all | grep mysql
# yum-config-manager --disable mysql55-community
# yum-config-manager --disable mysql56-community
# yum-config-manager --enable mysql57-community-dmr
# yum repolist enabled | grep mysql

Step4:安装mysql 服务器
命令:

# yum install mysql-community-server 

Step5: 启动mysql
命令:

#service mysqld start 

Step6: 查看mysql是否自启动,并且设置开启自启动
命令:

# chkconfig --list | grep mysqld # chkconfig mysqld on 

Step7: mysql安全设置
命令:

# mysql_secure_installation 

参考相关文档地址: 
http://www.rackspace.com/knowledge_center/article/installing-mysql-server-on-centos
http://dev.mysql.com/doc/refman/5.7/en/linux-installation-yum-repo.html
http://www.cnblogs.com/xiaoluo501395377/archive/2013/04/07/3003278.html

posted @ 2016-03-23 11:43 华梦行 阅读(63) | 评论 (0)编辑 收藏
  2016年2月24日
1、d:\mysql\bin\>mysql -h localhost -u root //这样应该可以进入MySQL服务器 2、mysql>GRANT ALL PRIVILEGES ON *.* TO 'root'@'%' WITH GRANT OPTION //赋予任何主机访问数据的权限 3、mysql>FLUSH PRIVILEGES //修改生效 4、mysql>EXIT //退出MySQL服务器 # For advice on how to change settings please see # http://dev.mysql.com/doc/refman/5.6/en/server-configuration-defaults.html 修改默认端口 [mysqld] port=3309
posted @ 2016-02-24 14:34 华梦行 阅读(51) | 评论 (0)编辑 收藏
  2015年12月7日

1. Change root user

su - ## OR ## sudo -i

2. Install Remi repository

## CentOS 6 and Red Hat (RHEL) 6 ## rpm -Uvh http://rpms.famillecollet.com/enterprise/remi-release-6.rpm

 

3. Check Available MySQL versions

yum --enablerepo=remi,remi-test list mysql mysql-server

Output:

Loaded plugins: changelog, fastestmirror, presto, refresh-packagekit ... remi                                                            | 3.0 kB     00:00      remi/primary_db                                                 | 106 kB     00:00      Available Packages mysql.i686                               5.5.37-1.fc18.remi                        @remi mysql-server.i686                        5.5.37-1.fc18.remi                        @remi

4. Update or Install MySQL 5.5.37

yum --enablerepo=remi install mysql mysql-server

 

5. Start MySQL server and autostart MySQL on boot

/etc/init.d/mysqld start ## use restart after update ## OR ## service mysqld start ## use restart after update   chkconfig --levels 235 mysqld on

 

6. MySQL Secure Installation

/usr/bin/mysql_secure_installation

 

7. Connect to MySQL database (localhost) with password

mysql -u root -p   ## OR ## mysql -h localhost -u root -p

 

8. Create Database, Create MySQL User and Enable Remote Connections to MySQL Database

复制代码
## CREATE DATABASE ## mysql> CREATE DATABASE webdb;   ## CREATE USER ## mysql> CREATE USER 'webdb_user'@'10.0.15.25' IDENTIFIED BY 'password123';   ## GRANT PERMISSIONS ## mysql> GRANT ALL ON webdb.* TO 'webdb_user'@'10.0.15.25';   ##  FLUSH PRIVILEGES, Tell the server TO reload the GRANT TABLES  ## mysql> FLUSH PRIVILEGES;
复制代码
posted @ 2015-12-07 19:36 华梦行 阅读(62) | 评论 (0)编辑 收藏
  2015年12月6日

mysql> use mysql;
 
  查询host值:
mysql> select user,host from user;
 
如果没有"%"这个host值,就执行下面这两句:
mysql> update user set host='%' where user='root';
mysql> flush privileges;
或者也可以执行:
mysql>grand all privileges on  *.*  to root@'%'  identifies  by ' xxxx';
其中 第一个*表示数据库名;第二个*表示该数据库的表名;如果像上面那样 *.*的话表示所有到数据库下到所有表都允许访问;
‘%':表示允许访问到mysql的ip地址;当然你也可以配置为具体到ip名称;%表示所有ip均可以访问;
 后面到‘xxxx'为root 用户的password;
 

举例:

任意主机以用户root和密码mypwd连接到mysql服务器
mysql> GRANT ALL PRIVILEGES ON *.* TO 'root'@'%' IDENTIFIED BY 'mypwd' WITH GRANT OPTION;
mysql> flush privileges;

IP为192.168.1.102的主机以用户myuser和密码mypwd连接到mysql服务器
mysql> GRANT ALL PRIVILEGES ON *.* TO 'myuser'@'192.168.1.102' IDENTIFIED BY 'mypwd' WITH GRANT OPTION;
mysql> flush privileges;

posted @ 2015-12-06 22:29 华梦行 阅读(49) | 评论 (0)编辑 收藏
仅列出标题  下一页