2017年3月21日

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

重啟mysql
sudo service mysql restart
mysql5.7以上版本在常會報(bào)關(guān)于only_full_group_by的錯誤，可以在sql_mode中關(guān)閉他，網(wǎng)上查找的解
查看參數(shù)是否存在
mysql> SELECT @@sql_mode;
+------------------------------------------------------------------------------------------------------------------------+
| @@sql_mode                                                                                                             |
+------------------------------------------------------------------------------------------------------------------------+
| STRICT_TRANS_TABLES,NO_ZERO_IN_DATE,NO_ZERO_DATE,ERROR_FOR_DIVISION_BY_ZERO,NO_AUTO_CREATE_USER,NO_ENGINE_SUBSTITUTION |
+------------------------------------------------------------------------------------------------------------------------+
1 row in set (0.00 sec)

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

MYSQL_HOME     解壓路徑   C:\DevelopTool\MySQL\mysql-5.7.25-winx64    

 Path     %MYSQL_HOME%\bin

net start MySQL【或者是MySQL57】

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

在了解REST API URI設(shè)計(jì)的規(guī)則之前，讓我們快速瀏覽一些我們將要討論的術(shù)語。

URIs

REST API使用統(tǒng)一資源標(biāo)識符（URI）來尋址資源。在當(dāng)今互聯(lián)網(wǎng)上，充斥著各種各樣的URI設(shè)計(jì)規(guī)則，既有像//api.example.com/louvre/leonardo-da-vinci/mona-lisa這樣能夠清楚的傳達(dá)API資源模型的文章，也有很難理解的文章，例如：//api.example.com/68dd0-a9d3-11e0-9f1c-0800200c9a66 ；Tim Berners-Lee在他的“Axioms of Web Architecture”一文中將URI的不透明度總結(jié)成一句話：

唯一可以使用標(biāo)識符的是引用對象。在不取消引用時，就不應(yīng)該查看URI字符串的內(nèi)容以獲取其他信息。 
——蒂姆·伯納斯 - 李

客戶端必須遵循Web的鏈接范例，將URI視為不透明標(biāo)識符。

REST API設(shè)計(jì)人員應(yīng)該在考慮將REST API資源模型傳達(dá)給潛在的客戶端開發(fā)者的前提下，創(chuàng)造URI。在這篇文章中，我將嘗試為REST API URI 引入一套設(shè)計(jì)規(guī)則。

先跳過規(guī)則，URI的通用語法也適用與本文中的URI。RFC 3986定義了通用URI語法，如下所示：

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

規(guī)則1：URI結(jié)尾不應(yīng)包含（/）

這是作為URI路徑中處理中最重要的規(guī)則之一，正斜杠（/）不會增加語義值，且可能導(dǎo)致混淆。REST API不允許一個尾部的斜杠，不應(yīng)該將它們包含在提供給客戶端的鏈接的結(jié)尾處。

許多Web組件和框架將平等對待以下兩個URI： 
http://api.canvas.com/shapes/ 
http://api.canvas.com/shapes

但是，實(shí)際上URI中的每個字符都會計(jì)入資源的唯一身份的識別中。

兩個不同的URI映射到兩個不同的資源。如果URI不同，那么資源也是如此，反之亦然。因此，REST API必須生成和傳遞精確的URI，不能容忍任何的客戶端嘗試不精確的資源定位。

有些API碰到這種情況，可能設(shè)計(jì)為讓客戶端重定向到相應(yīng)沒有尾斜杠的URI（也有可能會返回301 - 用來資源重定向）。

規(guī)則2：正斜杠分隔符（/）必須用來指示層級關(guān)系

URI的路徑中的正斜杠（/）字符用于指示資源之間的層次關(guān)系。

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

規(guī)則3：應(yīng)使用連字符（ - ）來提高URI的可讀性

為了使您的URI容易讓人們理解，請使用連字符（ - ）字符來提高長路徑中名稱的可讀性。在路徑中，應(yīng)該使用連字符代空格連接兩個單詞 。

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

規(guī)則4：不得在URI中使用下劃線（_）

一些文本查看器為了區(qū)分強(qiáng)調(diào)URI，常常會在URI下加上下劃線。這樣下劃線（_）字符可能被文本查看器中默認(rèn)的下劃線部分地遮蔽或完全隱藏。

為避免這種混淆，請使用連字符（ - ）而不是下劃線

規(guī)則5：URI路徑中首選小寫字母

方便時，URI路徑中首選小寫字母，因?yàn)榇髮懽帜赣袝r會導(dǎo)致一些問題。RFC 3986將URI定義為區(qū)分大小寫，但scheme 和 host components除外。

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

HTTP://API.EXAMPLE.COM/my-folder/my-doc 
這個URI很好。URI格式規(guī)范（RFC 3986）認(rèn)為該URI與URI＃1相同。

http://api.example.com/My-Folder/my-doc 
而這個URI與URI 1和2不同，這可能會導(dǎo)致不必要的混淆。

規(guī)則6：文件擴(kuò)展名不應(yīng)包含在URI中

在Web上，（.）字符通常用于分隔URI的文件名和擴(kuò)展名。 
REST API不應(yīng)在URI中包含人造文件擴(kuò)展名，來指示郵件實(shí)體的格式。相反，他們應(yīng)該依賴通過Content-Type中的header傳遞media type，來確定如何處理正文的內(nèi)容。

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

如上所示：不應(yīng)使用文件擴(kuò)展名來表示格式。

應(yīng)鼓勵REST API客戶端使用HTTP提供的格式選擇機(jī)制Accept request header。

為了是鏈接和調(diào)試更簡單，REST API應(yīng)該支持通過查詢參數(shù)來支持媒體類型的選擇。

規(guī)則7：端點(diǎn)名稱是單數(shù)還是復(fù)數(shù)？

keep-it-simple的原則在這里同樣適用。雖然一些”語法學(xué)家”會告訴你使用復(fù)數(shù)來描述資源的單個實(shí)例是錯誤的，但實(shí)際上為了保持URI格式的一致性建議使用復(fù)數(shù)形式。

本著API提供商更容易實(shí)施和API使用者更容易操作的原則，可以不必糾結(jié)一些奇怪的復(fù)數(shù)（person/people，goose/geese）。

但是應(yīng)該怎么處理層級關(guān)系呢？如果一個關(guān)系只能存在于另一個資源中，RESTful原則就會提供有用的指導(dǎo)。我們來看一下這個例子。學(xué)生有一些課程。這些課程在邏輯上映射到學(xué)生終端，如下所示：

http://api.college.com/students/3248234/courses - 檢索id為3248234的學(xué)生學(xué)習(xí)的所有課程的清單。 
http://api.college.com/students/3248234/courses/physics -檢索該學(xué)生的物理課程

結(jié)論

當(dāng)你在設(shè)計(jì)REST API服務(wù)時，您必須注意這些由URI定義的資源。

正在構(gòu)建的服務(wù)中的每個資源將至少有一個URI標(biāo)識它。這個URI最好是有意義的，且能充分描述資源。URI應(yīng)遵循可預(yù)測的層次結(jié)構(gòu)，用來提高其可理解性，可用性：可預(yù)測的意義在于它們是一致的，它的層次結(jié)構(gòu)在數(shù)據(jù)關(guān)系上是有意義的。

RESTful API是為使用者編寫的。URI的名稱和結(jié)構(gòu)應(yīng)該能夠向使用者傳達(dá)更清晰的含義。通過遵循上述規(guī)則，您將創(chuàng)建一個更清晰的的REST API與更友好的客戶端。這些并不是REST的規(guī)則或約束，僅僅是API的增強(qiáng)和補(bǔ)充。

我也建議你來看看http://blog.restcase.com/5-basic-rest-api-design-guidelines/這篇文章。

最后，望大家牢記：你在為你的客戶端設(shè)計(jì)API URI，而不僅僅是為你的數(shù)據(jù)。

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

       從classpath根目錄下加載指定名稱的文件

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

       從當(dāng)前包下加載指定名稱的文件

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

       從classpath根目錄下加載指定名稱的文件

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(null, new 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());
            }
        }
    }
}

Druid是什么？

Druid是一個JDBC組件，它包括四個部分：

• DruidDriver 代理Driver，能夠提供基于Filter－Chain模式的插件體系。
• DruidDataSource 高效可管理的數(shù)據(jù)庫連接池。
• SQLParser
• 擴(kuò)展組件
• 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可以做什么？

• 可以監(jiān)控?cái)?shù)據(jù)庫訪問性能，Druid內(nèi)置提供了一個功能強(qiáng)大的StatFilter插件，能夠詳細(xì)統(tǒng)計(jì)SQL的執(zhí)行性能，這對于線上分析數(shù)據(jù)庫訪問性能有幫助。
• 替換DBCP和C3P0。Druid提供了一個高效、功能強(qiáng)大、可擴(kuò)展性好的數(shù)據(jù)庫連接池。
• 數(shù)據(jù)庫密碼加密。直接把數(shù)據(jù)庫密碼寫在配置文件中，這是不好的行為，容易導(dǎo)致安全問題。DruidDruiver和DruidDataSource都支持PasswordCallback。
• SQL執(zhí)行日志，Druid提供了不同的LogFilter，能夠支持Common-Logging、Log4j和JdkLog，你可以按需要選擇相應(yīng)的LogFilter，監(jiān)控你應(yīng)用的數(shù)據(jù)庫訪問情況。
• 擴(kuò)展JDBC，如果你要對JDBC層有編程的需求，可以通過Druid提供的Filter機(jī)制，很方便編寫JDBC層的擴(kuò)展插件。

DruidDriver，是一個ProxyJdbcDriver，它提供了Filter-Chain模式的擴(kuò)展機(jī)制，使得在Jdbc擴(kuò)展編程特別方便。

Druid提供了一些內(nèi)置的擴(kuò)展機(jī)制，包括Stat、Log、Trace、HA等擴(kuò)展。

DruidDataSource是一個數(shù)據(jù)庫連接池的實(shí)現(xiàn)，它的設(shè)計(jì)目標(biāo)是提供一個當(dāng)前最好的數(shù)據(jù)庫連接池，在性能、擴(kuò)展性等方面取得最合適的平衡，取代DBCP、C3P0等連接池。

• 高性能。測試數(shù)據(jù)表明，Druid比DBCP、C3P0、BoneCP的性能都好很多。具體請看測試數(shù)據(jù)
• 可管理性，DruidDataSource本身提供了很多監(jiān)控屬性，具體看這里。DruidDataSource支持StatFilter，具體配置看 這里
• 可擴(kuò)展性，提供基于Filter-Chain模式的擴(kuò)展機(jī)制。具體自定義擴(kuò)展的例子看這里。
• 替換DBCP，配置和DBCP兼容，可以方便替換DBCP。
• 適合大規(guī)模應(yīng)用。結(jié)合Alibaba使用數(shù)據(jù)庫連接池的經(jīng)驗(yàn)，避免一些已知問題，例如數(shù)據(jù)庫不可用恢復(fù)之后產(chǎn)生的連接風(fēng)暴問題等。

設(shè)計(jì)

這是DruidDataSource的設(shè)計(jì)圖示：
http://code.alibabatech.com/svn/druid/trunk/doc/druid-pool.txt
如果發(fā)現(xiàn)有亂碼，請選擇utf-8的編碼方式查看。

Druid提供一個手工編寫的高性能的方便擴(kuò)展的SQL Parser。將會支持MySQL、Oracle等流行關(guān)系數(shù)據(jù)庫的SQL Parser。

Parser組件包括如下幾個部分：

• Lexer 詞法解析
• Parser，Parser包括ExprParser，各種StatementParser。
• AST, Abstract Syntax Tree。ParserParse出來的結(jié)果就是AST。
• Visitor。對AST做各種處理，比如FormatOutput，遍歷等等。

簡介

Druid提供了強(qiáng)大的監(jiān)控功能，能夠監(jiān)控連接池行為和SQL執(zhí)行情況，讓你能夠詳細(xì)了解應(yīng)用的數(shù)據(jù)庫訪問行為。

監(jiān)控對象

• Druid的統(tǒng)計(jì)信息定義代碼實(shí)現(xiàn)在com/alibaba/druid/stat下。所有的Stat都全局靜態(tài)變量的方式保存，這樣做使得外部獲取監(jiān)控信息更容易。
• 獲取Druid監(jiān)控信息的入口是com.alibaba.druid.stat.JdbcStatManager
• Druid的監(jiān)控統(tǒng)計(jì)信息都是通過StatFilter來實(shí)現(xiàn)的，如果你需要數(shù)據(jù)源進(jìn)行監(jiān)控，那你需要啟用StatFilter