Rosy's 2019-04-10T11:33:40.000Z http://yoursite.com/ Rosy Hexo DSL检索语言 http://yoursite.com/2019/04/10/DSL检索语言/ 2019-04-10T11:16:44.000Z 2019-04-10T11:33:40.000Z ES中的聚合被分为两大类：Metric度量和bucket桶。metric很像SQL中的avg、max、min等方法，而bucket就有点类似group by。

1. 单值聚合

  • 求和：

    1
    2
    3
    "aggs" : {
           "intraday_return" : { "sum" : { "field" : "change" } }
       }

  • 求最大值、最小值和平均值

1
2
3
4
5
{
    "aggs" : {
        "min_price" : { "min" : { "field" : "price" } }
    }
}
1
2
3
4
5
{
    "aggs" : {
        "max_price" : { "max" : { "field" : "price" } }
    }
}
1
2
3
4
5
{
    "aggs" : {
        "avg_grade" : { "avg" : { "field" : "grade" } }
    }
}
  • 求唯一值，即不重复的字段有多少
1
2
3
4
5
6
7
8
9
{
    "aggs" : {
        "author_count" : {
            "cardinality" : {
                "field" : "author"
            }
        }
    }
}

2. 多值聚合

  • 求百分比
1
2
3
4
5
6
7
8
9
10
{
    "aggs" : {
        "load_time_outlier" : {
            "percentile_ranks" : {
                "field" : "load_time", 
                "values" : [15, 30]
            }
        }
    }
}
  • stats统计
1
2
3
4
5
{
    "aggs" : {
        "grades_stats" : { "stats" : { "field" : "grade" } }
    }
}
  • 扩展统计
1
2
3
4
5
{
    "aggs" : {
        "grades_stats" : { "extended_stats" : { "field" : "grade" } }
    }
}

3. terms聚合

terms聚合，它是按照某个字段中的值来分类：比如性别有男、女，就会创建两个桶，分别存放男女的信息。默认会搜集doc_count的信息，即记录有多少男生，有多少女生，然后返回给客户端，这样就完成了一个terms得统计

Bucket可以理解为一个桶，他会遍历文档中的内容，凡是符合要求的就放入按照要求创建的桶中。

  • terms聚合
1
2
3
4
5
6
7
{
    "aggs" : {
        "genders" : {
            "terms" : { "field" : "gender" }
        }
    }
}
  • order排序
1
2
3
4
5
6
7
8
9
10
{
    "aggs" : {
        "genders" : {
            "terms" : {
                "field" : "gender",
                "order" : { "_count" : "asc" }
            }
        }
    }
}

也可以通过order指定一个单值的metric聚合，来排序。

1
2
3
4
5
6
7
8
9
10
11
12
13
{
    "aggs" : {
        "genders" : {
            "terms" : {
                "field" : "gender",
                "order" : { "avg_height" : "desc" }
            },
            "aggs" : {
                "avg_height" : { "avg" : { "field" : "height" } }
            }
        }
    }
}
  • min_doc_count与shard_min_doc_count

聚合的字段可能存在一些频率很低的词条，如果这些词条数目比例很大，那么就会造成很多不必要的计算。
因此可以通过设置min_doc_count和shard_min_doc_count来规定最小的文档数目，只有满足这个参数要求的个数的词条才会被记录返回。

  • filter
1
2
3
4
5
6
7
8
9
10
11
{
    "aggs" : {
        "tags" : {
            "terms" : {
                "field" : "tags",
                "include" : ".*sport.*",
                "exclude" : "water_.*"
            }
        }
    }
}

4. Histogram 直方图聚合

Elasticsearch支持直方图聚合，它在数字字段自动创建桶，并会扫描全部文档，把文档放入相应的桶中。这个数字字段既可以是文档中的某个字段，也可以通过脚本创建得出的。举个例子，有一个price字段，这个字段描述了商品的价格，现在想每隔5就创建一个桶，统计每隔区间都有多少个文档（商品）。如果有一个商品的价格为32，那么它会被放入30的桶中。

  • min_doc_count过滤

如果不想要显示count为0的桶，可以通过min_doc_count来设置。

1
2
3
4
5
6
7
8
9
10
11
{
    "aggs" : {
        "prices" : {
            "histogram" : {
                "field" : "price",
                "interval" : 50,
                "min_doc_count" : 1
            }
        }
    }
}
  • extend_bounds

指定最小值和最大值边界.默认情况下，ES中的histogram聚合起始都是自动的，比如price字段，如果没有商品的价钱在0-5之间，0这个桶就不会显示。如果最便宜的商品是11，那么第一个桶就是10.
可以通过设置extend_bounds强制规定最小值和最大值，但是要求必须min_doc_count不能大于0，不然即便是规定了边界，也不会返回。

  • order排序
1
2
3
4
5
6
7
8
9
10
11
{
    "aggs" : {
        "prices" : {
            "histogram" : {
                "field" : "price",
                "interval" : 50,
                "order" : { "_key" : "desc" }
            }
        }
    }
}

5. Date Histogram聚合

Date histogram的用法与histogram差不多，只不过区间上支持了日期的表达式。interval字段支持多种关键字：year, quarter, month, week, day, hour, minute, second。

1
2
3
4
5
6
7
8
9
10
11
{
    "aggs":{
        "articles_over_time":{
            "date_histogram":{
                "field":"date",
                "interval":"1M",
                "format":"yyyy-MM-dd"
                }
            }
        }
    }
  • time_zone时区
1
2
3
4
5
6
7
8
9
10
11
{
    "aggs":{
        "by_day":{
            "date_histogram":{
                "field":"date",
                "interval":"day",
                "time_zone":"+08:00"
            }
        }
    }
}
  • offset 使用偏移值，改变时间区间
1
2
3
4
5
6
7
8
9
10
{"aggs":{
    "by_day":{
        "date_histogram":{
            "field":"date",
            "interval":"day",
            "offset":"+6h"
            }
        }
    }
}

6. Range区间聚合

  • 聚合
1
2
3
4
5
6
7
8
9
10
11
12
13
{
    "aggs":{
        "grade_ranges":{
            "range":{
                "field":"grade",
                "ranges":[
                    {"to":60},
                    {"from":60,"to":80},
                    {"from":80}]
                }
            }
        }
}
  • 聚合嵌套
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
{
    "aggs":{
        "price_ranges":{
            "range":{
                "field":"price",
                "ranges":[
                    {"to":50},
                    {"from":50,"to":100},
                    {"from":100}
                ]},
                "aggs":{
                    "price_stats":{
                        "stats":{
                            "field":"price"
                        }
                    }
                }
            }
        }
    }

7. DateRange日期范围聚合

相比于range聚合，date range就是范围可以由时间来指定。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
{
    "aggs":{
        "range":{
            "date_range":{
                "field":"date",
                "format":"MM-yyy",
                "ranges":[
                    {"to":"now-10M/M"},
                    {"from":"now-10M/M"}
                ]
            }
        }
    }
}

8. 查询的种类

  • Elasticsearch中的DSL主要由两部分组成：

Leaf query Cluase 叶查询子句

这种查询可以单独使用，针对某一特定的字段查询特定的值，比如match、term、range等

Compound query Cluase 复合查询子句

这种查询配合其他的叶查询或者复合查询，用于在逻辑上，组成更为复杂的查询，比如bool

  • Query与Filter

查询在Query查询上下文和Filter过滤器上下文中，执行的操作是不一样的：

查询上下文：

在查询上下文中，查询会回答这个问题——“这个文档匹不匹配这个查询，它的相关度高么？”

如何验证匹配很好理解，如何计算相关度呢？之前说过，ES中索引的数据都会存储一个_score分值，分值越高就代表越匹配。另外关于某个搜索的分值计算还是很复杂的，因此也需要一定的时间。

查询上下文 是在 使用query进行查询时的执行环境，比如使用search的时候。

过滤器上下文：

在过滤器上下文中，查询会回答这个问题——“这个文档匹不匹配？”

答案很简单，是或者不是。它不会去计算任何分值，也不会关心返回的排序问题，因此效率会高一点。

过滤上下文 是在使用filter参数时候的执行环境，比如在bool查询中使用Must_not或者filter

8. 布尔查询Bool Query

query的时候，会先比较查询条件，然后计算分值，最后返回文档结果；

而filter则是先判断是否满足查询条件，如果不满足，会缓存查询过程（记录该文档不满足结果）；满足的话，就直接缓存结果。

综上所述，filter快在两个方面：

1 对结果进行缓存

2 避免计算分值

bool查询也是采用more_matches_is_better的机制，因此满足must和should子句的文档将会合并起来计算分值。

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
{
    "bool" : {
        "must" : {
            "term" : { "user" : "kimchy" }
        },
        "filter": {
            "term" : { "tag" : "tech" }
        },
        "must_not" : {
            "range" : {
                "age" : { "from" : 10, "to" : 20 }
            }
        },
        "should" : [
            {
                "term" : { "tag" : "wow" }
            },
            {
                "term" : { "tag" : "elasticsearch" }
            }
        ],
        "minimum_should_match" : 1,
        "boost" : 1.0
    }
}

  • 使用named query给子句添加标记

如果想知道到底是bool里面哪个条件匹配，可以使用named query查询：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
{
    "bool" : {
        "should" : [
            {"match" : { "name.first" : {"query" : "shay", "_name" : "first"} }},
            {"match" : { "name.last" : {"query" : "banon", "_name" : "last"} }}
        ],
        "filter" : {
            "terms" : {
                "name.last" : ["banon", "kimchy"],
                "_name" : "test"
            }
        }
    }
}
]]> <p>ES中的聚合被分为两大类：Metric度量和bucket桶。metric很像SQL中的avg、max、min等方法，而bucket就有点类似group by。</p> <h2 id="1-单值聚合"><a href="#1-单值聚合" class="headerlink" logstash学习（五）—— aggregate插件使用 http://yoursite.com/2019/04/10/logstash-aggregate插件使用/ 2019-04-10T11:15:23.000Z 2019-04-10T11:33:21.000Z aggregate可以将将属于一个task的多个events的信息聚合在一起，并最终聚合到最后一个events中。使用时要注意一定要将worker数量设置成1（在logstash安装目录下的config目录下，logstash.yml文件，默认的worker数量和cpu的内核数量一致），否则处理顺序错乱会导致未知的结果。

1. 例一：输入有开始和结束标志的

输入日志如下

1
2
3
4
INFO - 12345 - TASK_START - start
INFO - 12345 - SQL - sqlQuery1 - 12
INFO - 12345 - SQL - sqlQuery2 - 34
INFO - 12345 - TASK_END - end

配置文件如下

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
filter {
   grok {
     match => [ "message", "%{LOGLEVEL:loglevel} - %{NOTSPACE:taskid} - %{NOTSPACE:logger} - %{WORD:label}( - %{INT:duration:int})?" ]
   }
   if [logger] == "TASK_START" {
     aggregate {
       task_id => "%{taskid}"
       code => "map['sql_duration'] = 0"
       map_action => "create"
     }
   }
   if [logger] == "SQL" {
     aggregate {
       task_id => "%{taskid}"
       code => "map['sql_duration'] += event.get('duration')"
       map_action => "update"
     }
   }
   if [logger] == "TASK_END" {
     aggregate {
       task_id => "%{taskid}"
       code => "event.set('sql_duration', map['sql_duration'])"
       map_action => "update"
       end_of_task => true
       timeout => 120
     }
   }
 }

最后一个event输出如下：

1
2
3
4
5
6
7
8
9
10
11
12
{
        "host" => "host-10-0-251-156",
      "logger" => "TASK_END",
      "taskid" => "12345",
       "label" => "end",
    "loglevel" => "INFO",
     "message" => " INFO - 12345 - TASK_END - end",
  "@timestamp" => 2018-12-14T01:00:04.414Z,
        "path" => "/root/logstash-6.5.0/config/test.txt",
    "@version" => "1",
"sql_duration" => 46
}

sql_duration字段用于记录sql请求用时的总和。

2. 例二：输入油结束标志没有开始标志

输入日志如下

1
2
3
INFO - 12345 - SQL - sqlQuery1 - 12
INFO - 12345 - SQL - sqlQuery2 - 34
INFO - 12345 - TASK_END - end

配置文件如下

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
filter {
  grok {
    match => [ "message", "%{LOGLEVEL:loglevel} - %{NOTSPACE:taskid} - %{NOTSPACE:logger} - %{WORD:label}( - %{INT:duration:int})?" ]
  }
  if [logger] == "SQL" {
    aggregate {
      task_id => "%{taskid}"
      code => "map['sql_duration'] ||= 0 ; map['sql_duration'] += event.get('duration')"
    }
  }
  if [logger] == "TASK_END" {
    aggregate {
      task_id => "%{taskid}"
      code => "event.set('sql_duration', map['sql_duration'])"
      end_of_task => true
      timeout => 120
    }
  }
}
  • 输出结果跟例一一样。
  • “||= “是ruby的操作符，例子中当map[‘sql_duration’]没有舒适化值的时候，将被初始化为0。

3. 例三：没有开始和结束标志

典型的应用场景是跟踪用户行为。通过用户id跟踪用户行为事件，一旦用户停止了交互，这个事件也就相应结束了。然而却没有一个特定的标记来表示用户交互的结束。这种场景我们可以使用push_map_as_event_on_timeout参数，设置timeout，当超时发生时，将map作为一个新的事件被输出。另外我们可以设置timecode用于timeout事件结束时执行。

输入日志如下

1
2
3
INFO - 12345 - Clicked One
INFO - 12345 - Clicked Two
INFO - 12345 - Clicked Three

聚合用户的点击量：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
filter {
  grok {
    match => [ "message", "%{LOGLEVEL:loglevel} - %{NOTSPACE:user_id} - %{GREEDYDATA:msg_text}" ]
  }
  aggregate {
    task_id => "%{user_id}"
    code => "map['clicks'] ||= 0; map['clicks'] += 1;"
    push_map_as_event_on_timeout => true
    timeout_task_id_field => "user_id"
    timeout => 600 # 10 minutes timeout
    timeout_tags => ['_aggregatetimeout']
    timeout_code => "event.set('several_clicks', event.get('clicks') > 1)"
  }
}

十分钟之后输出结果，最后事件的部分为：

1
2
3
4
5
6
7
8
9
10
{
    "several_clicks" => true,
          "@version" => "1",
        "@timestamp" => 2018-12-14T05:54:09.212Z,
            "clicks" => 3,
           "user_id" => "12345",
              "tags" => [
        [0] "_aggregatetimeout"
    ]
}

4. 例四：没有开始和结束标志，任务连续不断

和例三一样，事件没有开始和结束的标志，并且任务连续不断。这就表明你不能靠设置timeout来更新map。

典型的例子是通过jdbc的插件获取数据进行聚合。例如有这样的sql查询语句：

1
SELECT country_name, town_name FROM town

通过jdbc插件获得3个事件:

1
2
3
{ "country_name": "France", "town_name": "Paris" }
{ "country_name": "France", "town_name": "Marseille" }
{ "country_name": "USA", "town_name": "New-York" }

我们的目的是往es里存入两个数据：

1
2
{ "country_name": "France", "towns": [ {"town_name": "Paris"}, {"town_name": "Marseille"} ] }
{ "country_name": "USA", "towns": [ {"town_name": "New-York"} ] }

可以设置push_previous_map_as_event参数：

1
2
3
4
5
6
7
8
9
10
11
12
13
filter {
     aggregate {
       task_id => "%{country_name}"
       code => "
         map['country_name'] = event.get('country_name')
         map['towns'] ||= []
         map['towns'] << {'town_name' => event.get('town_name')}
         event.cancel()
       "
       push_previous_map_as_event => true
       timeout => 5
     }
   }
  • 每当检测出一个新的country_name的时候，就会将当前的聚合map作为一个新的事件被推出，然后为下一个国家创建一个新的空map。
  • 当5秒超时之后，最后一个聚合map会被作为一个新的事件推出。
  • event.cancel()会将起始的没有被聚合的事件丢弃。

5. 例五：没有开始和结束标志并且尽可能快的推送事件

这个例子也没有起始和结束标志，事件以不确定的间隔时间持续输入，并且希望用户最后交互后立即将事件推出而不用等超时时间，这要求聚合事件推送到输出的时间尽可能是实时的。典型的应场景是通过id跟踪用户行为的时候，一旦用户停止了交互，这个事件也就相应结束了。然而却没有一个特定的标记来表示用户交互的结束。如果对于同一个用户，如果没有事件输入时长达到了指定的inactivity_timeout时间，则认为交互结束。

从第一个事件开始，如果同一个用户交互时间长于我们设置的timeout时间，聚合的map被推出的同时会被删除。

和例三不同的是，当用户停止交互到达设定的inactivity_timeout时长，事件就会被推出而不是要等timeout的时间。

输入日志文件

1
2
3
INFO - 12345 - Clicked One
INFO - 12345 - Clicked Two
INFO - 12345 - Clicked Three

记录用户点击数量的logstash文件：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
filter {
 grok {
   match => [ "message", "%{LOGLEVEL:loglevel} - %{NOTSPACE:user_id} - %{GREEDYDATA:msg_text}" ]
 }
 aggregate {
   task_id => "%{user_id}"
   code => "map['clicks'] ||= 0; map['clicks'] += 1;"
   push_map_as_event_on_timeout => true
   timeout_task_id_field => "user_id"
   timeout => 3600 # 1 hour timeout, user activity will be considered finished one hour after the first event, even if events keep comming
   inactivity_timeout => 300 # 5 minutes timeout, user activity will be considered finished if no new events arrive 5 minutes after the last event
   timeout_tags => ['_aggregatetimeout']
   timeout_code => "event.set('several_clicks', event.get('clicks') > 1)"
 }
}

当超过五分钟没有输入或者从第一个事件开始到达了一个小时（超时时间），都会提交事件

1
2
3
4
5
6
7
8
{
 "user_id": "12345",
 "clicks": 3,
 "several_clicks": true,
   "tags": [
      "_aggregatetimeout"
   ]
}

Tips：

  • inactivity_timeout，是从某个task_id的最后一个输入开始计时，直到超过设定的时间开始执行timeout_code的内容并输出。如果有多个task_id交叉输入，则将会分别计时。比如task_id=1输入一次，然后task_id=2输入两次，然后task_id=1再输入一次。task_id=2最后一次输入在task_id=1之前，则将先输出task_id=2通过timeout_code计算后的内容。
  • timeout上一条需要发生在同一个task_id第一次输入到最后一次输入的时间不超过timeout设置的时间的情况下，如果超过了timeout设置的时间，则会立即执行timeout_code的内容。例如timeout设置5分钟，而task_id=1持续输入（输入间隔不超过inactivity_timeout设置的时间）超过五分钟，则在五分钟的时候这个事件将会被推入输出里。
]]> <p>aggregate可以将将属于一个task的多个events的信息聚合在一起，并最终聚合到最后一个events中。使用时要注意一定要将worker数量设置成1（在logstash安装目录下的config目录下，logstash.yml文件，默认的worker数量和cpu的内 logstash学习（四）—— 多管道 http://yoursite.com/2019/04/10/logstash多管道/ 2019-04-10T11:14:07.000Z 2019-04-10T11:33:12.000Z 1. 多管道配置

如果需要在同一个进程运行多个管道（pipeline），可以配置logstash的pipelines.yml文件，该文件在logstash/config目录下。配置文件的结构如下：

1
2
3
4
5
6
- pipeline.id: my-pipeline_1
  path.config: "/etc/path/to/p1.config"
  pipeline.workers: 3
- pipeline.id: my-other-pipeline
  path.config: "/etc/different/path/p2.cfg"
  queue.type: persisted

配置文件需要遵循yaml格式列出一组路径，每个路径都描述了一个管道信息，并且需要以键值对的形式对管道进行描述。上述例子展现了两种通过ID和路径信息描述管道的方式。对于第一个管道，pipeline.workers的值被设置为3，而在另一个则启用持久队列特性。管道之间的资源竞争是很重要的，因为默认值是为单个管道调优的，考虑减少每个管道使用的管道工人的数量可以对单个管道调优，因为默认情况下每个管道每个CPU核心将使用1个工人。在pipelines.yml文件中未显式设置值的将使用默认值。

2. 启动

在logstash的bin目录下：

1
# ./logstash

在没有参数的情况下启动logstash时，它将读取pipelines.yml文件并实例化文件中指定的所有管道，当使用-e或-f时，Logstash会忽略pipelines.yml文件，并记录对此的警告。

3. 注意事项

  • 当输入使用相同插件的时候，比如都用了s3插件，需要考虑了设置临时存储文件的路径。因为s3插件在没有设置文件下载路径的情况下，默认把文件下载到了“/tmp/logstash”路径下，当有多个管道进行一起下载的时候，如果对命名没有区分，则可能造成处理文件出现异常。解决方法是指定各自管道的临时存储路径，s3的指定方法是设置temporary_directory参数，并在路径下创建指定的目录。
  • 当数据导入出现异常，需要删除数据重新启动的时候，需要先删除对导入数据进度的记录文件，具体做法是将logstash\data\下的文件都删掉。
]]> <h2 id="1-多管道配置"><a href="#1-多管道配置" class="headerlink" title="1. 多管道配置"></a>1. 多管道配置</h2><p>如果需要在同一个进程运行多个管道（pipeline），可以配置logstash的pipeline logstash学习（三）—— 自动重载配置文件 http://yoursite.com/2019/04/10/logstash自动重载配置文件/ 2019-04-10T11:12:55.000Z 2019-04-10T11:21:25.000Z 1. 自动重启配置

从logstash2.3开始，当配置文件发生更改时，可以设置自动检测和重载配置文件而不用重启logstash。设置自动重载的命令如下：

1
# bin/logstash –f configFile.conf --config.reload.automatic

注意：

  • 当运行命令时（logstash指定-e运行）–config.reload.automatic参数不起作用。
  • 默认是每个3秒检测一次配置文件是否发生变化，当然检测间隔也可以自己设置，格式如下：
1
# bin/logstash –f configFile.conf --config.reload.automatic <interval>

如果已经运行了没有提供自动重启的logstash，可以发送一个挂起命令给logstash重新加载配置文件:

1
kill -1 <pid>

2. 工作原理

当检测到配置文件变化则通过停止所有输入来停止当前pipeline。然后用新的配置尝试创建一个新的pipeline。如果检查配置文件语法正确并且所有的输入和输出可以初始化，则使用新的pipeline替换当前的pipeline。如果检查失败,使用旧的继续工作。注意在重载过程中,jvm没有重启。

3. 注意事项

  • stdin输入插件不支持自动重启。
  • syslog作为输入源，当重载配置文件时会崩溃。

具体见官网：Reloading the Config File

]]> <h2 id="1-自动重启配置"><a href="#1-自动重启配置" class="headerlink" title="1. 自动重启配置"></a>1. 自动重启配置</h2><p>从logstash2.3开始，当配置文件发生更改时，可以设置自动检测和重载配置文件而不用 logstash学习（二）—— 配置文件运行 http://yoursite.com/2019/04/10/logstash配置文件运行/ 2019-04-10T11:12:29.000Z 2020-03-03T13:36:06.277Z 在实际生产环境中，logstash常常需要用到复杂的运行规则，使用命令行显然不可取。所以可以自定义规则文件，然后让Logstash根据规则进行工作。

1. 配置文件

配置文件结构如下：

1
2
3
4
5
6
7
8
9
10
11
input{
}
filter{
    
}
output{
}

配置文件主要有input，output和filter三个大的部分构成。input是数据的输入源，可以是来自文件，网站，redis，s3等。output是数据的输出，可以输出到文件，elasticsearch，邮件，kafka等。filter是过滤规则，根据需要进行内容的过滤。

将配置文件放在logstash下的config目录中。进入logstash的bin目录，运行配置文件：

1
2
# cd logstash-6.3.2/bin/
# ./logstash -f /root/logstash-6.5.0/config/test.conf

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
cat UGA-MTN.conf 
input {
  s3{
    access_key_id => "ACCESS_KEY_ID"
    secret_access_key => "SECRET_ACCESS_KEY"
    bucket => "your_bucket"
    region => "your_s3_region"
    interval => 600
    prefix => "……" 
    exclude_pattern => "……"
  }
}
filter {
  urldecode{
    all_fields => true
  }
  grok{
    match => {"message" => "%{TIMESTAMP_ISO8601:log_date}\s%{NOTSPACE:log_name}\s(?:%{NOTSPACE:request_body})"}
    remove_field => ["log_name"]
  }
  json {
    source => "request_body"
    remove_field => ["request_body"]
  }
  mutate{
    add_field => {
      "rack" => "……"
    }
    convert => {
      "request_time" => "integer"
      "status" => "integer"
      "bytes_sent" => "integer"
    }
  }
}
output {
  elasticsearch {
    action => "index"                                       #The operation on ES
    hosts => ["192.168.32.20:9200"]   #ElasticSearch host, can be array.
    index => "cache_log_%{+YYYY.MM.dd}"                     #The index to write data to.
    document_type => "logs"
  }
}

2.1 输入插件s3

s3插件可以从s3上获取数据。常用参数有：

  • access_key_id: String类型，没有默认值。用于获取s3的验证。
  • aws_credentials_file：String类型，没有默认值。用于获取s3的验证。当access_key_id和secret_access_key没有设置的时候，才会加载这个文件。
  • secret_access_key：String类型，默认值是“logstash”，根据实际情况进行修改。

注：常用的获取s3验证的方法有：

  1. access_key_id和ecret_access_key进行配置；
  2. 配置aws_credentials_file从外部文件进行获取；
  3. 将AWS_ACCESS_KEY_ID和AWS_SECRET_ACCESS_KEY配置到环境变量中。
  4. 将AMAZON_ACCESS_KEY_ID和AMAZON_SECRET_ACCESS_KEY配置到环境变量中。
  5. IAM实例的证书。
  • bucket，String类型必选参数且没有默认值。需要获取数据的s3的桶的名称。
  • region，String类型，默认值是“us-east-1”，表示AWS所在的位置区域。
  • interval，number类型，默认值是60，单位是秒。两次获取数据的间隔时间。
  • prefix，String类型，默认值是nil。表示表示在桶里面需要匹配的文件前缀，不是一个正则表达式。
  • exclude_pattern，String类型，默认值是nil。正则匹配需要从桶里面排除的文件。
  • temporary_directory，String类型，默认值是“/tmp/logstash”，用于临时保存从s3下载的文件，可以根据需求进行修改路径。

其他参数详见官方文档：s3插件说明

2.2 输出插件elasticsearch

elasticsearch只支持HTTP协议，logstash和elasticsearch的交互也优先使用HTTP协议。HTTP协议尽管稍微慢一点，但是很好控制和使用。

  • action，，String类型，默认值是index。表示elasticsearch要进行的操作。有效操作有: index：为文件编索引；delete：根据id删除文件；create：为文件指定创建的索引，如果索引已经存在，则创建失败；update：根据id更新文件信息。
  • hosts，类型是Uri，默认值是[//127.0.0.1]。设置远程实例的主机，可以在数组里放多个ip设置多台主机。
  • index，String类型，默认值是logstash-%{+YYYY.MM.dd}。用于设置数据写入的index名称。

其他参数详见官方文档：elasticsearch插件说明

2.3 filter插件

  • urldecode：Nginx作为反向代理服务器，部分日志在传输的过程中是通过“urlencoded”编码的，通过logstash收集上来的日志需要用urldecode将字符串还原为原来的格式。

Urldecode常用的配置选项：

  1. all_fields：对所有的值进行url的解码，默认值为false

  2. Charset：设置解码使用的字符集，默认为“utf-8”。

  • grok是通过系统预定义的正则表达式或者通过自己定义正则表达式来匹配日志中的各个值，在使用时自己可以根据自己的日志格式或者对匹配正则进行调整或者直接调用。如果，自己想在其他目录定义正则规则匹配日志，在使用时需要指定正则的路径。
  • mutate主要用来修改、替换、删除及重命名字段中的某些插件。
]]> <p>在实际生产环境中，logstash常常需要用到复杂的运行规则，使用命令行显然不可取。所以可以自定义规则文件，然后让Logstash根据规则进行工作。</p> <h2 id="1-配置文件"><a href="#1-配置文件" class="headerlink" title logstash学习（一）—— 安装配置 http://yoursite.com/2019/04/10/logstash安装配置/ 2019-04-10T11:11:01.000Z 2019-04-10T11:32:44.000Z Logstash是一个开源的服务器端数据处理管道，可以同时从多个源获取数据。面对海量的日志量，rsyslog和sed，awk等日志收集，处理工具已经显的力不从心。logstash是一个整合型的框架，可以用以日志的收集，存储，索引构建。

1. logstash安装

1.1 安装环境

  • centos 7.2
  • JDK：1.8.0_112

1.2 安装

直接下载压缩包，解压运行即可。

1
2
# wget https://artifacts.elastic.co/downloads/logstash/logstash-6.5.0.tar.gz
# tar -zxvf logstash-6.5.0.tar.gz

2. 验证

进入解压的logstash文件夹目录下的bin目录中，运行以命令行的形式运行logstash：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
# cd logstash-6.5.0/bin/
# ./logstash -e 'input{ stdin{} } output{ stdout{} }'
Sending Logstash logs to /root/logstash-6.5.0/logs which is now configured via log4j2.properties
[2018-11-19T14:30:25,975][INFO ][logstash.setting.writabledirectory] Creating directory {:setting=>"path.queue", :path=>"/root/logstash-6.5.0/data/queue"}
[2018-11-19T14:30:26,010][INFO ][logstash.setting.writabledirectory] Creating directory {:setting=>"path.dead_letter_queue", :path=>"/root/logstash-6.5.0/data/dead_letter_queue"}
[2018-11-19T14:30:27,642][WARN ][logstash.config.source.multilocal] Ignoring the 'pipelines.yml' file because modules or command line options are specified
[2018-11-19T14:30:27,848][INFO ][logstash.runner          ] Starting Logstash {"logstash.version"=>"6.5.0"}
[2018-11-19T14:30:28,051][INFO ][logstash.agent           ] No persistent UUID file found. Generating new UUID {:uuid=>"7e16bcaa-b50e-4751-9fac-7acd00dc1773", :path=>"/root/logstash-6.5.0/data/uuid"}
[2018-11-19T14:30:49,501][INFO ][logstash.pipeline        ] Starting pipeline {:pipeline_id=>"main", "pipeline.workers"=>4, "pipeline.batch.size"=>125, "pipeline.batch.delay"=>50}
[2018-11-19T14:30:50,690][INFO ][logstash.pipeline        ] Pipeline started successfully {:pipeline_id=>"main", :thread=>"#<Thread:0x2418c105 run>"}
The stdin plugin is now waiting for input:
[2018-11-19T14:30:51,118][INFO ][logstash.agent           ] Pipelines running {:count=>1, :running_pipelines=>[:main], :non_running_pipelines=>[]}
[2018-11-19T14:30:52,429][INFO ][logstash.agent           ] Successfully started Logstash API endpoint {:port=>9600}
hello world
{
      "@version" => "1",  # 版本号
       "message" => "hello world", # 输入内容
          "host" => "xxxxxx",  # 主机名，数据是从哪个节点发过来的
    "@timestamp" => 2018-11-19T06:31:03.697Z # 自动生成的时间戳
}
]]> <p> Logstash是一个开源的服务器端数据处理管道，可以同时从多个源获取数据。面对海量的日志量，rsyslog和sed，awk等日志收集，处理工具已经显的力不从心。logstash是一个整合型的框架，可以用以日志的收集，存储，索引构建。</p> <h2 id="1-log 微信公众号开发（三）——自定义菜单和响应 http://yoursite.com/2018/08/28/微信公众号开发（三）——自定义菜单和响应/ 2018-08-28T14:15:36.000Z 2020-03-03T13:35:08.359Z 1. 测试号申请

不同的公众号类型具备不同的接口权限，一般个人申请的是未认证订阅号，没有自定义菜单的功能，只有企业组织科申请工作好认证公众号。不同类型的公众号的不同接口权限详情见：公众号接口权限说明。

我们可以申请一个接口测试号，这个测试号几乎开放所有的接口，可以供测试使用， 接口测试号申请。测试号如下图，可以用测试号的appID和appsecret进行接口调用。

image

2. 创建自定义菜单

2.1 获取access_token

获取access_token的接口为GET：
https://api.weixin.qq.com/cgi-bin/token?grant_type=client_credential&appid=APPID

创建自定义菜单的接口为POST：https://api.weixin.qq.com/cgi-bin/menu/create?access_token=ACCESSTOKEN 其中需要传的body详见官网文档： 自定义菜单创建接口。

可以用postman进行接口调用。这里主要讲通过java程序进行创建。

获取access_token
TokenResponseDTO.java

1
2
3
4
5
6
7
public class TokenResponseDTO {
    private Integer errcode;
    private String errmsg;
    private String access_token;
    private String expires_in;
    //省略get set
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
private String getToken(String appId, String appSecret) {
    String queryTokenUrl = "https://api.weixin.qq.com/cgi-bin/token?grant_type=client_credential&appid={0}&secret={1}";
    String newQueryTokenUrl = MessageFormat.format(queryTokenUrl, appId,appSecret);
    try {
        ResponseEntity<TokenResponseDTO> response =restTemplate.getForEntity(newQueryTokenUrl, TokenResponseDTO.class);
        TokenResponseDTO tokenResponseDTO = null;
        if (response != null && response.getStatusCode() != null &&response.getStatusCode().value() == 200 && response.getBody() != null
                && response.getBody().getErrcode() == null &&response.getBody().getErrmsg() == null) {
            tokenResponseDTO = response.getBody();
            LOGGER.info("get token from weixin, Reponse: " +JsonUtils.encode(response));
        } else {
            throw new Exception("getToken error! " +response.getBody().getErrcode().toString() + ":" +response.getBody().getErrmsg());
        }
        return tokenResponseDTO.getAccess_token();
    } catch (Exception e) {
        LOGGER.error("getToken error!" + e.getMessage());
        throw new RuntimeException(e.getMessage());
    }
}

因为获取接口的access_token每日的调用次数是有上限的，每次token的过期时间有2个小时，所以可以另外搭一个存access_token的服务器，定时更新access_token。

2.2 创建自定义菜单

组body的json数据，可以通过组对象，然后转换成json格式的字符串，也可以自己组好json字符串，写在程序里。我们这里采用组对象转换json串的方式，组三个三种类型的一级按钮。

MenuDTO.java

1
2
3
4
public class MenuDTO {
    List<ButtonDTO> button;
    // get set
}

ButtonDTO.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public class ButtonDTO {
    private String type;
    private String name;
    private String key;
    private String url;
    ButtonDTO(){}
    ButtonDTO(String type, String name, String key, String url){
        this.type = type;
        this.name = name;
        this.key = key;
        this.url = url;
    }
    // get set
}

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
public void createMenu(String appId, String appSecret) {
    int result = 0;
    String accessToken = getToken(appId, appSecret);
    // 拼装创建菜单的url
    String menu_create_url ="https://api.weixin.qq.com/cgi-bin/menu/create?access_token=ACCESS_TOKEN";
    String url = menu_create_url.replace("ACCESS_TOKEN", accessToken);
    // 将菜单对象转换成json字符串
    MenuDTO menuDTO = new MenuDTO();
    ButtonDTO buttonDTO1 = new ButtonDTO("pic_photo_or_album", "上传照片", "11", null);
    ButtonDTO buttonDTO2 = new ButtonDTO("click", "click", "12", null);
    ButtonDTO buttonDTO3 = new ButtonDTO("view", "view", null, "https://weui.io/#uploader");
    List<ButtonDTO> buttonDTOList = new ArrayList<>();
    buttonDTOList.add(buttonDTO1);
    buttonDTOList.add(buttonDTO2);
    buttonDTOList.add(buttonDTO3);
    menuDTO.setButton(buttonDTOList);
    HttpHeaders headers = new HttpHeaders();
    headers.setContentType(MediaType.APPLICATION_JSON);
    MultiValueMap<String, String> params = new LinkedMultiValueMap<String,String>();
    params.add("data", JsonUtils.encode(menuDTO));
    System.out.println(JsonUtils.encode(menuDTO));
    HttpEntity<MultiValueMap<String, String>> requestEntity = newHttpEntity<MultiValueMap<String, String>>(params, headers);
    RestTemplate restTemplate = new RestTemplate();
    ResponseEntity<String> response = restTemplate.exchange(url,HttpMethod.POST, requestEntity, String.class);
    System.out.println(response.getBody());
}

运行方法，如果没有错误信息，则返回：

1
2
3
4
{
    "errcode": 0,
    "errmsg": "ok"
}

打开测试公众号，可以看到我们新加的自定义菜单。

image

菜单响应

这里的响应主要针对上传照片和click按钮，view按钮会自动跳转到初始化的url页面上。

在web.xml中配一个servlet

1
2
3
4
5
6
7
8
9
<servlet>
    <servlet-name>weixin</servlet-name>
    <servlet-class>com.star.ott.tokenmanage.api.business.CoreServlet</servlet-class>
</servlet>
<servlet-mapping>
    <servlet-name>weixin</servlet-name>
    <url-pattern>/wx</url-pattern>
</servlet-mapping>

CoreServlet.java

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
public class CoreServlet extends HttpServlet {
    private static final String OK = "OK";
    public String get() {
        return OK;
    }
    /**
     * 确认请求来自微信服务器
     */
    public void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        // 微信加密签名
        String signature = request.getParameter("signature");
        // 时间戳
        String timestamp = request.getParameter("timestamp");
        // 随机数
        String nonce = request.getParameter("nonce");
        // 随机字符串
        String echostr = request.getParameter("echostr");
        response.setHeader("content-type", "text/html;charset=UTF-8");
        PrintWriter out = response.getWriter();
        // 通过检验signature对请求进行校验，若校验成功则原样返回echostr，表示接入成功，否则接入失败
        if (SignUtil.checkSignature(signature, timestamp, nonce)) {
            out.print(echostr);
        }
        out.close();
        out = null;
    }
    /**
     * 处理微信服务器发来的消息
     */
    public void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        // 将请求、响应的编码均设置为UTF-8（防止中文乱码）
        request.setCharacterEncoding("UTF-8");
        response.setCharacterEncoding("UTF-8");
        // 调用核心业务类接收消息、处理消息
        String respMessage = processRequest(request);
        // 响应消息
        PrintWriter out = response.getWriter();
        out.print(respMessage);
        out.close();
    }
    private String processRequest(HttpServletRequest request) {
        String respMessage = null;
        try {
            // 默认返回的文本消息内容
            String respContent = "请求处理异常，请稍候尝试！";
            // xml请求解析
            Map<String, String> requestMap = MessageUtil.parseXml(request);
            // 发送方帐号（open_id）
            String fromUserName = requestMap.get("FromUserName");
            // 公众帐号
            String toUserName = requestMap.get("ToUserName");
            // 消息类型
            String msgType = requestMap.get("MsgType");
            // 回复文本消息
            TextMessage textMessage = new TextMessage();
            textMessage.setToUserName(fromUserName);
            textMessage.setFromUserName(toUserName);
            textMessage.setCreateTime(new Date().getTime());
            textMessage.setMsgType(MessageUtil.RESP_MESSAGE_TYPE_TEXT);
            textMessage.setFuncFlag(0);
            // 图片消息
            if (msgType.equals(MessageUtil.REQ_MESSAGE_TYPE_IMAGE)) {
                respContent = "您发送的是图片消息！";
            }
            // 事件推送
            if (msgType.equals(MessageUtil.REQ_MESSAGE_TYPE_EVENT)) {
                // 事件类型
                String eventType = requestMap.get("Event");
                if (eventType.equals(MessageUtil.EVENT_TYPE_CLICK)) {
                    // 事件KEY值，与创建自定义菜单时指定的KEY值对应
                    String eventKey = requestMap.get("EventKey");
                    if (eventKey.equals("12")) {
                        respContent = "被点击！";
                    }
                }
            }
            textMessage.setContent(respContent);
            respMessage = MessageUtil.textMessageToXml(textMessage);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return respMessage;
    }
}

SignUtil.java

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
public class SignUtil {
    private static String token = "weixintest";
    /**
     * 验证签名
     *
     * @param signature
     * @param timestamp
     * @param nonce
     * @return
     */
    public static boolean checkSignature(String signature, String timestamp, String nonce) {
        String[] arr = new String[]{token, timestamp, nonce};
        // 将token、timestamp、nonce三个参数进行字典序排序
        Arrays.sort(arr);
        StringBuilder content = new StringBuilder();
        for (int i = 0; i < arr.length; i++) {
            content.append(arr[i]);
        }
        MessageDigest md = null;
        String tmpStr = null;
        try {
            md = MessageDigest.getInstance("SHA-1");
            // 将三个参数字符串拼接成一个字符串进行sha1加密
            byte[] digest = md.digest(content.toString().getBytes());
            tmpStr = byteToStr(digest);
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        }
        content = null;
        // 将sha1加密后的字符串可与signature对比，标识该请求来源于微信
        return tmpStr != null ? tmpStr.equals(signature.toUpperCase()) : false;
    }
    /**
     * 将字节数组转换为十六进制字符串
     *
     * @param byteArray
     * @return
     */
    private static String byteToStr(byte[] byteArray) {
        String strDigest = "";
        for (int i = 0; i < byteArray.length; i++) {
            strDigest += byteToHexStr(byteArray[i]);
        }
        return strDigest;
    }
    /**
     * 将字节转换为十六进制字符串
     *
     * @param mByte
     * @return
     */
    private static String byteToHexStr(byte mByte) {
        char[] Digit = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'};
        char[] tempArr = new char[2];
        tempArr[0] = Digit[(mByte >>> 4) & 0X0F];
        tempArr[1] = Digit[mByte & 0X0F];
        String s = new String(tempArr);
        return s;
    }
}

MessageUtil.java

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
public class MessageUtil {
    /**
     * 返回消息类型：文本
     */
    public static final String RESP_MESSAGE_TYPE_TEXT = "text";
    /**
     * 请求消息类型：图片
     */
    public static final String REQ_MESSAGE_TYPE_IMAGE = "image";
    public static final String REQ_MESSAGE_TYPE_EVENT = "event";
    /**
     * 事件类型：CLICK(自定义菜单点击事件)
     */
    public static final String EVENT_TYPE_CLICK = "CLICK";
    public static final String EVENT_TYPE_PHOTO = "pic_photo_or_album";
    /**
     * 解析微信发来的请求（XML）
     *
     * @param request
     * @return
     * @throws Exception
     */
    @SuppressWarnings("unchecked")
    public static Map<String, String> parseXml(HttpServletRequest request) throws Exception {
        // 将解析结果存储在HashMap中
        Map<String, String> map = new HashMap<String, String>();
        // 从request中取得输入流
        InputStream inputStream = request.getInputStream();
        // 读取输入流
        SAXReader reader = new SAXReader();
        Document document = reader.read(inputStream);
        // 得到xml根元素
        Element root = document.getRootElement();
        // 得到根元素的所有子节点
        List<Element> elementList = root.elements();
        // 遍历所有子节点
        for (Element e : elementList)
            map.put(e.getName(), e.getText());
        // 释放资源
        inputStream.close();
        inputStream = null;
        return map;
    }
    /**
     * 文本消息对象转换成xml
     * @param textMessage 文本消息对象
     * @return xml
     */
    public static String textMessageToXml(TextMessage textMessage) {
        xstream.alias("xml", textMessage.getClass());
        return xstream.toXML(textMessage);
    }
    /**
     * 扩展xstream，使其支持CDATA块
     */
    private static XStream xstream = new XStream(new XppDriver() {
        public HierarchicalStreamWriter createWriter(Writer out) {
            return new PrettyPrintWriter(out) {
                // 对所有xml节点的转换都增加CDATA标记
                boolean cdata = true;
                @SuppressWarnings("unchecked")
                public void startNode(String name, Class clazz) {
                    super.startNode(name, clazz);
                }
                protected void writeText(QuickWriter writer, String text) {
                    if (cdata) {
                        writer.write("<![CDATA[");
                        writer.write(text);
                        writer.write("]]>");
                    } else {
                        writer.write(text);
                    }
                }
            };
        }
    });
}

参考文章：https://blog.csdn.net/lyq8479/article/details/8952173

]]> <h2 id="1-测试号申请"><a href="#1-测试号申请" class="headerlink" title="1. 测试号申请"></a>1. 测试号申请</h2><p>不同的公众号类型具备不同的接口权限，一般个人申请的是未认证订阅号，没有自定义菜单的功能，只有企业 微信公众号开发（二）——本地调试 http://yoursite.com/2018/08/28/微信公众号开发（二）——本地调试/ 2018-08-28T14:15:18.000Z 2020-03-03T13:35:20.200Z 微信用户发送信息到腾讯服务器，然后腾讯服务器把请求以post方式转发到自己的服务器上（需要有外网ip，并且token验证通过的服务器）。然后在自己的服务器上进行处理后把处理结果返回给腾讯服务器，腾讯服务器再把数据返回给用户，整个过程如下图。

image

因为腾讯服务器转发到自己的服务器要求该服务器有外网地址，而我们调试程序的服务器通常可能没有外网地址。因此需要在有外网地址的服务器上做流量转发，转发到本地进行调试。

可以用xshell或其他软件做内网穿透，具体见：https://my.oschina.net/AbnerLee/blog/348998

这种方法的优势在于方便，有xshell就能实现；但是实际使用时发现并不稳定，连接会经常断掉。

image

如上图所示，在有外网地址的服务器上搭一个流量转发工具（orange），将所有访问443或者80端口的流量（腾讯服务器只发送到这两个端口）转发到本地服务器的特定端口上，这样在本地起服务就能够进行调试了。本地服务器和有外网的服务器需要在同一网段里，才能进行转发。

这种方法进行本地测试比较稳定，缺点在于本地服务和有外网的服务器需要在同一网段内，这个本身如果服务器没有公网ip，也需要做内网穿透。

]]> <p>微信用户发送信息到腾讯服务器，然后腾讯服务器把请求以post方式转发到自己的服务器上（需要有外网ip，并且token验证通过的服务器）。然后在自己的服务器上进行处理后把处理结果返回给腾讯服务器，腾讯服务器再把数据返回给用户，整个过程如下图。</p> <p><img src= 微信公众号开发（一）——搭建环境 http://yoursite.com/2018/08/28/微信公众号开发（一）——搭建环境/ 2018-08-28T14:14:53.000Z 2020-03-03T13:34:56.997Z 1. 基础环境
  • 微信公众号一个（我的是个人订阅号，不同的类型权限不同）
  • 有外网ip的服务器（centos7）

2. 服务器配置（以官方demo为例，具体见：官方文档）

centos系统自带了python，因此不用再下载，如果没有自带python，需要先下载2.7及其以上版本的python。

2.1 安装依赖库

  • 安装pip
1
2
3
yum -y install epel-release
yum install python-pip
pip install --upgrade pip
  • 安装 web.py
1
pip install web.py
  • 安装libxml2, libxslt, lxml

这些库都是python自带的，如果没有需要安装。

  • 编辑代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
vi main.py
# -*- coding: utf-8 -*-
# filename: main.py
import web
urls = (
    '/wx', 'Handle',
)
class Handle(object):
    def GET(self):
        return "hello, this is handle view"
if __name__ == '__main__':
    app = web.application(urls, globals())
    app.run()
  • 启动
1
python main.py 80

打开浏览器，输入服务器ip和路径，可以看到

image

  • 添加 handle.py
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
vi handle.py
# -*- coding: utf-8 -*-
# filename: handle.py
import hashlib
import web
class Handle(object):
    def GET(self):
        try:
            data = web.input()
            if len(data) == 0:
                return "hello, this is handle view"
            signature = data.signature
            timestamp = data.timestamp
            nonce = data.nonce
            echostr = data.echostr
            token = "xxxx" #请按照公众平台官网\基本配置中信息填写
            list = [token, timestamp, nonce]
            list.sort()
            sha1 = hashlib.sha1()
            map(sha1.update, list)
            hashcode = sha1.hexdigest()
            print "handle/GET func: hashcode, signature: ", hashcode, signature
            if hashcode == signature:
                return echostr
            else:
                return ""
        except Exception, Argument:
            return Argument
  • 重新启动
1
python main.py 80

2. 微信公众号配置

在开发 > 基本配置中修改配置

image

image

其中的Token需要和服务器handle.py里的token一样。

点击“提交”之后，如果验证成功，则配置成功。

]]> <h2 id="1-基础环境"><a href="#1-基础环境" class="headerlink" title="1. 基础环境"></a>1. 基础环境</h2><ul> <li>微信公众号一个（我的是个人订阅号，不同的类型权限不同）</li> <li>有外网ip的服务器 mybatis使用tips http://yoursite.com/2018/08/28/mybatis使用tips/ 2018-08-28T14:00:15.000Z 2020-03-03T13:31:40.282Z mybatis作为一种灵活的orm框架，优点有目共睹：灵活！不管多复杂的查询，联表，多对多，联表count。。。只要能把sql语句写出来，就能查出来转成PO。然鹅，在使用的时候也充分暴露了，越是灵活的东西，越容易出bug。比如买个面包机，我只需要按照说明书，往里加面粉，酵母，糖等配料就行了，做出来的东西起码符合食物的最低标准——能吃！但是如果给你一个烤箱做面包，理论上你可以做各种形状各种口味的：牛角面包，吐司，法棍。。然而事实上，可能做出来的东西并不能称之为“食物”。mybatis就是一个烤箱，能做任何事情，又不能做任何事情。

1. 搜索条件传入参数类型是Integer，Long

例如枚举类型，前端传入的是枚举的名称，而数据库存的是枚举值对应的数字，我们的做法是，先找到枚举值对应的数字，然后用数字去数据库进行搜索。

例：

接口Mapper.java：

1
List<TaskApplicationBO> findTaskApplicationsByCondition(@Param("taskApplicationStatus") Integer taskApplicationStatus);

对应的Mapper.xml的搜索：

1
2
3
4
5
6
select ta.id id, ta.task_application_status task_application_status
from task_application ta
where ta.delete_flag = 1
<if test="taskApplicationStatus != null and taskApplicationStatus != ''">
    and ta.task_application_status = #{taskApplicationStatus}
</if>

这个时候，如果传入的taskApplicationStatus值是0，则会搜索出全部。

sql打印如下：

1
SELECT ta.id id, ta.task_application_status task_application_status FROM task_application ta WHERE ta.delete_flag = 1

传入的taskApplicationStatus值是其他值，则会拼接上搜索条件进行搜索。

1
2
SELECT ta.id id, ta.task_application_status task_application_status FROM task_application ta WHERE ta.delete_flag = 1 and ta.task_application_status = ?
Parameters: 1(Integer)

由打印出的sql可以看出，当taskApplicationStatus为0的时候，没有进入if条件里。

通过Debug MyBatis源找到了IfSqlNode类，该类用来处理动态SQL的节点。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
public class IfSqlNode implements SqlNode {
  private ExpressionEvaluator evaluator;
  private String test;
  private SqlNode contents;
  public IfSqlNode(SqlNode contents, String test) {
    this.test = test;
    this.contents = contents;
    this.evaluator = new ExpressionEvaluator();
  }
  public boolean apply(DynamicContext context) {
    if (evaluator.evaluateBoolean(test, context.getBindings())) {
      contents.apply(context);
      return true;
    }
    return false;
  }
}

其中方法public boolean apply(DynamicContext context)用来构造节点内的SQL语句。if (evaluator.evaluateBoolean(test, context.getBindings())该代码便是解析中test内表达式的关键，如果表达式为true则拼接SQL，否则忽略。

ExpressionEvaluator 类，通过OgnlCache.getValue(expression, parameterObject);可以看到表达式的值是从缓存中获取的，由此可知MyBatis竟然对表达式做了缓存，以提高性能。

1
2
3
4
5
6
7
public class ExpressionEvaluator {  
  public boolean evaluateBoolean(String expression, Object parameterObject) {  
    Object value = OgnlCache.getValue(expression, parameterObject);  
    if (value instanceof Boolean) return (Boolean) value;  
    if (value instanceof Number) return !new BigDecimal(String.valueOf(value)).equals(BigDecimal.ZERO);  
    return value != null;  
  }

解析表达式的方法private static Object parseExpression(String expression),该方法会先从缓存取值，如果没有便进行解析并放入缓存中，然后调用Ognl.getValue(parseExpression(expression), root)获得表达式的值。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
public class OgnlCache {
  private static final Map<String, ognl.Node> expressionCache = new ConcurrentHashMap<String, ognl.Node>();
  public static Object getValue(String expression, Object root) throws OgnlException {
    return Ognl.getValue(parseExpression(expression), root);
  }
  private static Object parseExpression(String expression) throws OgnlException {
    try {
      Node node = expressionCache.get(expression);
      if (node == null) {
        node = new OgnlParser(new StringReader(expression)).topLevelExpression();
        expressionCache.put(expression, node);
      }
      return node;
    } catch (ParseException e) {
      throw new ExpressionSyntaxException(expression, e);
    } catch (TokenMgrError e) {
      throw new ExpressionSyntaxException(expression, e);
    }
  }

MyBatis的表达式是用OGNL处理的，OGNL的官网中对表达式返回Boolean类型有以下解释：

image

如果对象是一个Number类型，值为0时将被解析为false，否则为true，浮点型0.00也是如此。


and ta.task_application_status = #{taskApplicationStatus}

时出现的问题了， taskApplicationStatus != ‘’被解析为false,而’’被解析为false，因此taskApplicationStatus!=’’是不成立的，表达式的值为false，导致无法拼接搜索条件。一般只有传入为String类型的时候才需要判断是否为String != ‘’。

解决方法

  • 去掉test表达式中的taskApplicationStatus != ‘’内容
  • 增加一个判断条件 or taskApplicationStatus == 0

另外如果你有类似于String str =”A”; 这样的写法时，因为单引号内如果为单个字符时，OGNL将会识别为Java 中的 char类型，显然String 类型与char类型做==运算会返回false，从而导致表达式不成立。解决方法很简单，修改为即可；也可以做toString的转化

2. 动态拼接sql时的特殊字符

严格来说这是mysql和url编码（通过http发起请求时参数识别）的问题，需要提前做个字符转化，且几乎无法穷举特殊字符，只能转化常见的。

比如“#”和“&”，在发起http请求时，“#”以后的内容会被忽略，而“&”作为参数拼接的符号，其后跟的内容会被认为是传入的参数，而本身作为参数传入时讲无法辨认。需要在前端进行转化。

mysql的特殊字符，比如“%”和“/”等。则是mysql的特殊字符，需要在拼接sql前进行转义。

1
2
3
4
value = value.replaceAll("/", ESCAPE_CHAR + "/");
value = value.replaceAll("%", ESCAPE_CHAR + "%");
value = value.replaceAll("_", ESCAPE_CHAR + "_");
value = value.replaceAll("'", "''");

3. 传入List组in语句

其实这也是mysql的问题，传入List，拼接in语句，如果传入的List集合是数字类型（如Integer，Long），查询返回的集合会根据数字大小进行升序排序（如果传入的List是String则不会）。因此如果需要原始顺序，需要对查询字段进行排序，具体如下：

1
2
3
4
5
6
7
<foreach collection="ids" item="item" open="(" separator="," close=")">
    #{item}
</foreach>
     ORDER BY FIELD
<foreach collection="ids" item="item" open="(id," separator="," close=")">
    #{item}
</foreach>

4. 其他

未完待续。。。。。。

]]> <p>mybatis作为一种灵活的orm框架，优点有目共睹：灵活！不管多复杂的查询，联表，多对多，联表count。。。只要能把sql语句写出来，就能查出来转成PO。然鹅，在使用的时候也充分暴露了，越是灵活的东西，越容易出bug。比如买个面包机，我只需要按照说明书，往里加面粉，酵母 hibernate实体类与数据库表的常见映射 http://yoursite.com/2018/07/31/hibernate实体类与数据库表的常见映射/ 2018-07-31T14:27:10.000Z 2018-07-31T14:34:50.000Z Hibernate的核心功能是根据数据库到实体类的映射，自动从数据库绑定数据到实体类。

这使我们操作实体类(Java对象)就能对数据库进行增、删、查、改，而不用调用JDBC API使数据操作变得简单而不繁琐。本文主要总结了实体类的各种属性类型到数据库表的映射以及各种关联关系的映射。

1. 基本类型的映射

在业务中常见的基本类型有Integer、Short、Float、Double、Long、Boolean、String。

1.1 Integer

实体类的属性用Integer可以映射数据的int类型的字段，模型为：

1
2
@Column(name = "integer_number")
private Integer integerNumber;

1.2 Short

实体类的属性用Short可以映射数据的tinyint类型的字段，模型为：

1
2
@Column(name = "short_num")
private Short shortNum;

1.3 Float

实体类的属性用Float可以映射数据的float类型的字段，模型为：

1
2
@Column(name = "float_num")
private Float floatNum;

1.3 Double

实体类的属性用Double可以映射数据的double类型的字段，模型为：

1
2
@Column(name = "Double_num")
private Double doubleNum;

1.4 Long

实体类的属性用Long可以映射数据的bigint类型的字段，模型为：

1
2
@Column(name = "long_num")
private Long longNum;

1.5 Boolean

实体类的属性用Boolean可以映射数据的tinyint类型的字段，模型为：

1
2
@Column(name = "boolean_type")
private Boolean booleanType;

1.6 String

实体类的属性用String可以映射数据的varchar或者char类型的字段，模型为：

1
2
@Column(name = "string_type")
private String stringType;

2. 枚举类型的映射

实体类的属性的枚举类型，在数据库表中可以被映射为int，或者tinyint类型的字段，具体视枚举数量的多少决定，模型为：

1
2
3
@Enumerated(EnumType.ORDINAL)
@Column(name = "sex")
private Sex sex;

其中Sex为枚举类型：

1
2
3
4
5
public enum Sex {
    MALE(0,"MALE"),
    FEMALE(1,"FEMALE"),
    UNKNOWN(2,"UNKNOWN");
}

3. BigDecimal

实体类的属性的BigDecimal类型，在数据库表中可以被映射为decimal，可以指定精度，模型为：

1
2
@Column(name = "charge")
private BigDecimal charge;

4. 时间相关

常用的时间相关的类型是Datetime和Instant，在数据库表中可以被映射为datetime，注意如果不指定datetime的精度，则默认四舍五入到秒，而Instant的默认精度是毫秒，实际值和存储值可能出现1秒的误差。模型为：

1
2
@Column(name = "instant_date")
private Instant instantDate;
]]> <p>Hibernate的核心功能是根据数据库到实体类的映射，自动从数据库绑定数据到实体类。</p> <p>这使我们操作实体类(Java对象)就能对数据库进行增、删、查、改，而不用调用JDBC API使数据操作变得简单而不繁琐。本文主要总结了实体类的各种属性类型到数据库表的映射以 mybatis pageHelper插件研究 http://yoursite.com/2018/07/31/mybatis-pageHelper插件研究/ 2018-07-31T14:26:50.000Z 2018-07-31T14:34:01.000Z 1. mybatis插件

在mybatis中使用插件，需要先实现接口Interceptor：

1
2
3
4
5
6
7
8
9
public interface Interceptor {
  Object intercept(Invocation invocation) throws Throwable;
  Object plugin(Object target);
  void setProperties(Properties properties);
}

Interceptor中有三个方法：

  • intercept方法：是插件的核心方法，它将直接覆盖你所拦截的对象原有的方法。intercept里有个参数Invocation对象，通过它可以反射调度原料对象的方法。
  • plugin方法：target是被拦截对象，plugin方法的作用是给被拦截对象生成一个代理对象并返回。
  • setProperties方法：允许在plugin中配置所需要的参数，该方法在插件初始化的时候就被调用一次，然后把插件对象存到配置中，以便后续取出。

2. PageHelper

PageHelper会使用ThreadLocal获取到同一线程中的变量信息，各个线程之间的Threadlocal不会相互干扰，也就是Thread1中的ThreadLocal1之后获取到Tread1中的变量的信息，不会获取到Thread2中的信息所以在多线程环境下，各个Threadlocal之间相互隔离，可以实现，不同thread使用不同的数据源或不同的Thread中执行不同的SQL语句，所以，PageHelper利用这一点通过拦截器获取到同一线程中的预编译好的SQL语句之后将SQL语句包装成具有分页功能的SQL语句，并将其再次赋值给下一步操作，所以实际执行的SQL语句就是有了分页功能的SQL语句。

startPage源码：

1
2
3
4
5
6
7
8
9
10
/**
 * 开始分页
 *
 * @param pageNum  页码
 * @param pageSize 每页显示数量
 * @param count    是否进行count查询
 */
public static Page startPage(int pageNum, int pageSize, boolean count) {
    return startPage(pageNum, pageSize, count, null);
}

最终执行的代码：

1
2
3
4
5
6
7
public static Page startPage(int pageNum, int pageSize, boolean count, Boolean reasonable, Boolean pageSizeZero) {
    Page page = new Page(pageNum, pageSize, count);
    page.setReasonable(reasonable);
    page.setPageSizeZero(pageSizeZero);
    SqlUtil.setLocalPage(page);
    return page;
}

其中SqlUtil.setLocalPage是：

1
2
3
public static void setLocalPage(Page page) {
    LOCAL_PAGE.set(page);
}

LOCAL_PAGE是：

1
private static final ThreadLocal<Page> LOCAL_PAGE = new ThreadLocal<Page>();

PageHelper就是使用ThreadLocal存储了Page对象，在这个对象中有我们设置的pageNum、pageSize，也会查询返回的pages、total。

3. PageHelper执行过程

1
Page page = PageHelper.startPage(pageNumber, pageSize, true);

配置好PageHelper后，在代码中使用PageHelper后，LOCAL_PAGE会存入分页信息。

在PageHelper下的第一个查询的方法会被PageHelper拦截住，然后重新组装sql语句。具体组装的源码为：

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
private Object _processPage(Invocation invocation) throws Throwable {
    final Object[] args = invocation.getArgs();
    RowBounds rowBounds = (RowBounds) args[2];
    if (SqlUtil.getLocalPage() == null && rowBounds == RowBounds.DEFAULT) {
        if (OrderByHelper.getOrderBy() != null) {
            OrderByHelper.processIntercept(invocation);
        }
        return invocation.proceed();
    } else {
        //获取原始的ms
        MappedStatement ms = (MappedStatement) args[0];
        //判断并处理为PageSqlSource
        if (!isPageSqlSource(ms)) {
            processMappedStatement(ms, parser);
        }
        //忽略RowBounds-否则会进行Mybatis自带的内存分页
        args[2] = RowBounds.DEFAULT;
        //分页信息
        Page page = getPage(rowBounds);
        //pageSizeZero的判断
        if ((page.getPageSizeZero() != null && page.getPageSizeZero()) && page.getPageSize() == 0) {
            COUNT.set(null);
            //执行正常（不分页）查询
            Object result = invocation.proceed();
            //得到处理结果
            page.addAll((List) result);
            //相当于查询第一页
            page.setPageNum(1);
            //这种情况相当于pageSize=total
            page.setPageSize(page.size());
            //仍然要设置total
            page.setTotal(page.size());
            //返回结果仍然为Page类型 - 便于后面对接收类型的统一处理
            return page;
        }
        //简单的通过total的值来判断是否进行count查询
        if (page.isCount()) {
            COUNT.set(Boolean.TRUE);
            //替换MS
            args[0] = msCountMap.get(ms.getId());
            //查询总数
            Object result = invocation.proceed();
            //还原ms
            args[0] = ms;
            //设置总数
            page.setTotal((Integer) ((List) result).get(0));
            if (page.getTotal() == 0) {
                return page;
            }
        }
        //pageSize>0的时候执行分页查询，pageSize<=0的时候不执行相当于可能只返回了一个count
        if (page.getPageSize() > 0 &&
                ((rowBounds == RowBounds.DEFAULT && page.getPageNum() > 0)
                        || rowBounds != RowBounds.DEFAULT)) {
            //将参数中的MappedStatement替换为新的qs
            COUNT.set(null);
            BoundSql boundSql = ms.getBoundSql(args[1]);
            args[1] = parser.setPageParameter(ms, args[1], boundSql, page);
            COUNT.set(Boolean.FALSE);
            //执行分页查询
            Object result = invocation.proceed();
            //得到处理结果
            page.addAll((List) result);
        }
        //返回结果
        return page;
    }
}

在实际查询中打印出sql为：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
ooo Using Connection [com.alibaba.druid.proxy.jdbc.ConnectionProxyImpl@25428560]
==>  Preparing: SELECT count(*) FROM translator t LEFT JOIN account a ON a.translator_id = t.id AND a.delete_flag = 1 WHERE t.delete_flag = 1 AND t.account_status != 0 AND t.account_status != 3 
==> Parameters: 
<==    Columns: count(*)
<==        Row: 5
<==      Total: 1
ooo Using Connection [com.alibaba.druid.proxy.jdbc.ConnectionProxyImpl@25428560]
==>  Preparing: SELECT a.name as name, a.account_id as account_id, a.nick_name as nick_name, t.sex as sex, a.phone_number as phone_number, t.id as id, t.translator_level as translator_level, t.account_status as account_status FROM translator t LEFT JOIN account a on a.translator_id= t.id AND a.delete_flag = 1 WHERE t.delete_flag = 1 and t.account_status != 0 and t.account_status != 3 limit ?,? 
==> Parameters: 0(Integer), 3(Integer)
<==    Columns: name, account_id, nick_name, sex, phone_number, id, translator_level, account_status
<==        Row: 121212@163.com, 1, 王五, 0, 13310101001, 1, null, 4
<==        Row: 222222@qq.com, 9, 张三, 1, 18811221122, 2, null, 4
<==        Row: lisi, 12, lisi, 0, 13899988223, 4, 1, 4
<==      Total: 3

不加PageHelper打印出的sql为：

1
2
3
4
5
6
7
8
9
10
ooo Using Connection [com.alibaba.druid.proxy.jdbc.ConnectionProxyImpl@30e836ca]
==>  Preparing: SELECT a.name as name, a.account_id as account_id, a.nick_name as nick_name, t.sex as sex, a.phone_number as phone_number, t.id as id, t.translator_level as translator_level, t.account_status as account_status FROM translator t LEFT JOIN account a on a.translator_id= t.id AND a.delete_flag = 1 WHERE t.delete_flag = 1 and t.account_status != 0 and t.account_status != 3 
==> Parameters: 
<==    Columns: name, account_id, nick_name, sex, phone_number, id, translator_level, account_status
<==        Row: 121212@163.com, 1, 王五, 0, 13310101001, 1, null, 4
<==        Row: 222222@qq.com, 9, 张三, 1, 18811221122, 2, null, 4
<==        Row: lisi, 12, lisi, 0, 13899988223, 4, 1, 4
<==        Row: wangmazi, 15, wangmazi, 0, 17722818182, 18, null, 1
<==        Row: xiaohua, 14, xiaohua, 1, 16322818182, 19, 0, 4
<==      Total: 5
]]> <h2 id="1-mybatis插件"><a href="#1-mybatis插件" class="headerlink" title="1. mybatis插件"></a>1. mybatis插件</h2><p>在mybatis中使用插件，需要先实现接口Interceptor hibernate和mybatis查询对比 http://yoursite.com/2018/07/31/hibernate和mybatis查询对比/ 2018-07-31T14:25:39.000Z 2020-03-03T13:34:40.154Z 1. 实体中没有引用对象

1.1 实体编写实例

  1. hibernate
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
@Entity
@Table(name = "translator_info_change_log")
@NamedQuery(name = "TranslatorInfoChangeLog.findAll", query = "SELECT o FROM TranslatorInfoChangeLog o")
public class TranslatorInfoChangeLog extends AbstractModel {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
   
    @Column(name = "translator_id")
    private Long translatorId;
    
    @Column(name = "details")
    private String details;
    
    @Enumerated(EnumType.ORDINAL)
    @Column(name = "account_status")
}

说明：

  • @Entity：标志这是一个数据库实体（pojo）
  • @Table：对应数据库的表名
  • @Id：标识此列是数据库中的主键
  • @GeneratedValue：数据库主键的生成方式，JPA提供的四种标准用法为TABLE（使用一个特定的数据库表格来保存主键），SEQUENCE（根据底层数据库的序列来生成主键，条件是数据库支持序列），IDENTITY（主键由数据库自动生成（主要是自动增长型）），AUTO（主键由程序控制）
  • @Column：对应数据库中的列名
  1. mybatis
    直接使用上面JPA的数据模型就可以，也可以不加上面的所有注解，为了JPA也能使用最好按上面的方式。

1.2 查询编写示例

  1. hibernate
1
2
3
4
5
6
7
8
9
10
11
12
13
14
public interface TranslatorInfoChangeLogRepository extends JpaRepository<TranslatorInfoChangeLog, Long>, JpaSpecificationExecutor<TranslatorInfoChangeLog> {
    // 使用sql语句查询
    // @Query(value = "select * from translator_info_change_log t where t.id = ?1", nativeQuery = true)
    // 使用hql语句查询
    @Query(value = "select t from TranslatorInfoChangeLog where t.id = ?1")
    TranslatorInfoChangeLog findChangeLog(Long id);
    
    @Modifying
    @Query("update TranslatorInfoChangeLog p set status=0 where p.id in :ids")
    void deleteTranslatorInfo(@Param("ids") List<Long> ids);
    
    TranslatorInfoChangeLog findById(Long id);
    
}

说明：

  • 需要继承JpaRepository、JpaSpecificationExecutor
  • 这里只能返回本实体及其父类
  • findById转化成的SQL语句为：select * from modify_log where id = ?
  • @Modifying：标识是个更改操作
  • @Query：要执行的SQL语句，这不是原生的SQL,可以设置参数（nativeQuery = true），这就可以写原生SQL
  • 示例中的findChangeLog和findById作用是一样的，findChangeLog是用sql语句进行查询，findById是jpa根据方法名称进行解析后查询。
  1. mybatis
  • 编写查询的接口
  • 直接在查询接口对应的xml文件写sql语句
1
List<TranslatorInfoChangeLog> queryModifyLog(@Param("id") Long id);
1
2
3
<select id="queryModifyLog" resultType="TranslatorInfoChangeLog" patameterType="Long">
select * from translator_info_change_log where id = ?
</select>

其中查询语句写在

1.3 建议

此类查询建议使用JPA完成，开发速度快，只需按规则定义方法名就可以根据不同的字段进行查询，而用mybatis需要编写不同的SQL语句。

2. 实体中存在单实体引用对象（一对一或者多对一）

2.1 实体编写实例（以多对一为例）

台词和人物信息的关系，多个台词可能都属于同一个人物的。在多的一端（台词表）添加外键（人物的id），与人物表相关联。

  1. hibernate
1
2
3
@ManyToOne(cascade = CascadeType.REFRESH, targetEntity = Character.class, optional = true)
@JoinColumn(name = "character_person_id")
private Character character;

其中：

  • @ManyToOne：标识关联关系，cascade标识相关级联操作，其中CascadeType.PERSIST：级联新增（又称级联保存，CascadeType.MERGE:级联合并（级联更新），CascadeType.REMOVE:级联删除，CascadeType.REFRESH:级联刷新，CascadeType.ALL:以上四种都是。
  • targetEntity 定义关系类的类型，默认是该成员属性对应的类类型，所以通常不需要提供定义。
  • optional标识是否可为空。
  • @JoinColumn：标识用于关联的字段
    @ ManyToOne和OneToOne的fetch 属性默认值是FetchType.EAGER
  1. Mybatis

直接使用上面JPA的数据模型就可以，也可以不加上面的所有注解，为了JPA也能使用最好按上面的方式。

2.2 查询编写示例

  1. hibernate

正常查询，因为设置了级联查询，会直接查询出来，OneToOne和ManyToOne默认不是延迟加载，所以不用设置就是及时加载.

  1. mybatis
  • 返回模型设置
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
……
<association property="character" column="character_person_id" javaType="com.star.ott.scriptsTranslation.domain.Character">
    <id property="id" column="c_id"/>
    <result property="name" column="name"/>
    <result property="englishName" column="english_name"/>
    <result property="age" column="age"/>
    <result property="sex" column="sexjavaType="com.star.ott.scriptsTranslation.domain.enums.Sex"
            typeHandler="org.apache.ibatis.type.EnumOrdinalTypeHandl"/>
    <result property="remarks" column="remarks"/>
    <result property="characterType" column="character_type"
            javaType="com.star.ott.scriptsTranslation.domain.enums.CracterType"
            typeHandler="org.apache.ibatis.type.EnumOrdinalTypeHandl"/>
    <result property="dramaId" column="dramaId"/>
</association>
……
  • 查询语言需要做关联
1
2
3
4
5
<select id="" resultMap="">
……
LEFT JOIN character_person c ON c.id = l.character_person_id AND c.delete_flag = 1
……
</select>
  • 一对一和多对一，实体映射用标签。

2.3 建议

此类查询建议使用JPA完成，开发速度快，只需要设置实体的注解，mybatis需要join语句，还需要设置返回的resultMap。

3. 实体中存在多实体引用对象（一对多）

例如剧集下存在多个台词，剧集是“一”的一方，台词是“多”的一方，在多的一端（台词表）添加外键（剧集的id），与剧集表相关联。

3.1 实体编写示例

  1. hibernate
1
2
3
4
5
6
7
……
@OneToMany(cascade = CascadeType.REFRESH, fetch = FetchType.LAZY)
@JoinColumn(name="episodeid")
@Where(clause = "delete_flag = 1")
@OrderBy(value = "id asc")
private List<Line> lines;
……

说明：

  • @OneToMany：标识关联关系，Cascade标识相关级联操作，fetch标识加载方式是懒加载还是及时加载。
  • @Where：过滤条件，只查询符合条件的级联表里的记录。
  • @OrderBy：对查询的记录进行按字段排序。
  • 默认是延迟加载。
  1. mybatis

直接使用上面JPA的数据模型就可以，也可以不加上面的所有注解，为了hibernate也能使用最好按上面的方式。

3.2 查询编写示例

  1. hibernate

正常查询，因为设置了级联查询，会直接查询出来，OneToMany默认是延迟加载

  1. Mybatis
  • 返回model设置
1
2
3
4
5
6
7
8
9
10
11
……
<collection property="sourceLanguages" column="line_id" ofType="com.star.ott.scriptsTranslation.domain.TranslationLine">
    <id property="id" column="tl_id"/>
    <result property="translationTaskId" column="translation_task_id"/>
    <result property="lineId" column="line_id"/>
    <result property="lineStr" column="line_str"/>
    <result property="language" column="language"
            javaType="com.star.ott.scriptsTranslation.domain.enums.Language"
            typeHandler="org.apache.ibatis.type.EnumOrdinalTypeHandler"/>
</collection>
……
  • 查询语言需要做关联
1
2
3
4
5
<select id="" resultMap="">
……
LEFT JOIN translation_line tl ON tl.line_id = l.id AND tl.delete_flag = 1 AND tl.translation_task_id IS NULL
……
</select>
  • 一对多，实体映射用标签。
  • collection和association标签的实体映射需要放在一起，不能交叉放置，否则会出现错误。

3.3 建议

此类查询建议使用hibernate完成，开发速度快，只需要设置实体的注解，mybatis需要join语句，还需要设置返回的resultMap但是执行效率上mybatis会更好一些，如果数据量大，就需要测试后选择。

4. 两个实体间存在中间实体关联（多对多）

4.1 两张表与关系表OneToMany级联，关系表与两张表ManyToOne级联。

例1： 用户组与权限的关系，一个用户组可以拥有多个权限，一个权限又可包含多个用户组。

image

4.1.1 实体编写示例
  1. hibernate

Role实体

1
2
3
4
5
6
7
8
9
10
11
@Entity
@Table(name="glw_role")
public class Role{
    @Id
    @GeneratedValue(strategy=GenerationType.TABLE)
    private Long id;
    @Column(length=50)
    private String name;
    @OneToMany(mappedBy="role",cascade=CascadeType.ALL)
    private Set<RoleResource> roleResources = new HashSet<RoleResource>();
}

Resource实体

1
2
3
4
5
6
7
8
9
10
11
@Entity
@Table(name="glw_resource")
public class Resource{
    @Id
    @GeneratedValue(strategy=GenerationType.TABLE)
    private Long id;
    @Column(length=50)
    private String name;
    @OneToMany(mappedBy="resource",cascade=CascadeType.ALL)
    private Set<RoleResource> roleResources = new HashSet<RoleResource>();
}

RoleResource辅助实体

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
@Entity
@Table(name="glw_role_resource")
public class Resource{
    @Id
    @GeneratedValue(strategy=GenerationType.TABLE)
    private Long id;
    @Column
    private Integer sort;
    @ManyToOne(cascade=Cascade.ALL)
    @JoinColumn(name="roleId",nullable=true)
    private Role role;
    @ManyToOne(cascade=Cascade.ALL)
    @JoinColumn(name="resourceId",nullable=true)
    private Resource resource;
}
  1. mybatis
    直接使用上面JPA的数据模型就可以，也可以不加上面的所有注解，为了JPA也能使用最好按上面的方式。
4.1.2 查询示例编写

  1. hibernate
    正常查询，因为设置了级联查询，会直接查询出来，（查询不同的Dao就会对应生成不同的实体）。

  2. mybatis

  • 返回model设置对应的 association 或 collection
  • 正常sql语句的链表查询

4.2 两张表与关系表相对各自独立，没有完整级联

例2： 例如在translator中的，译员的母语和语言tag之间是多对多关系，tag是数据字典，初始化值后便不会改变。因为语言tag不仅母语需要使用，擅长语言这个属性也需要使用，所以中间表需要加字段“tag类型”用以区分是tag是被谁在使用。

image

4.2.1 实体编写示例
  1. hibernate

translator和中间表之间一对多级联，中间表和数据字典之间不做级联，可以由translator对中间表进行crud操作，中间表和数据字典之间的关系需要手动维护。

translator

1
2
3
4
5
6
……
@OneToMany(cascade = {CascadeType.REFRESH, CascadeType.PERSIST, CascadeType.MERGE, CascadeType.REMOVE}, fetch = FetchType.LAZY, orphanRemoval = true)
@JoinColumn(name = "translator_id")
@Where(clause = "delete_flag = 1 and dict_type = 2")
private Set<TranslatorDictRelation> motherTongue;
……

tag

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
……
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;
/**
 * 数据字典类型
 */
@Enumerated(EnumType.ORDINAL)
@Column(name = "dict_type")
private DictType dictType;
/**
 * 标签号
 */
@Column(name = "tag_num")
private Integer tagNum;
/**
 * 标签值
 */
@Column(name = "tag_value")
private String tagValue;
……

TranslatorDictRelation

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
……
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;
/**
 * 译员id
 */
@Column(name = "translator_id")
private Long translatorId;
/**
 * tag id
 */
@Column(name = "dict_id")
private Long dictId;
/**
 * 数据字典类型
 */
@Enumerated(EnumType.ORDINAL)
@Column(name = "dict_type")
private DictType dictType;
……
  1. mybatis

直接使用上面JPA的数据模型就可以，也可以不加上面的所有注解，为了JPA也能使用最好按上面的方式。

4.2.2 查询示例编写

  1. hibernate
    正常查询，因为设置了级联查询，会直接查询出来，（查询不同的Dao就会对应生成不同的实体）。

  2. mybatis

  • 返回model设置对应的 association 或 collection
  • 正常sql语句的链表查询

4.3 两张表用ManyToMany级联，实体映射上不与关系表级联

例3： 两张多对多表关系均可能出现crud操作，中间表除了作为外键的字段和唯一id，没有其他字段。

4.3.1 实体编写示例

TranslatorTest

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
@Entity
@Table(name = "translator_test")
@NamedQuery(name = "TranslatorTest.findAll", query = "SELECT o FROM TranslatorTest o")
public class TranslatorTest {
    /**
     * 主键
     */
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    /**
     * 证件号
     */
    @Column(name = "credential_number")
    private String credentialNumber;
    /**
     * 空闲时段
     */
    @ManyToMany(fetch = FetchType.LAZY,cascade = CascadeType.ALL)
    @JoinTable(name = "translator_dict_relation_test",
            joinColumns = {@JoinColumn(name = "translator_id")},  // 由哪端进行维护
            inverseJoinColumns = {@JoinColumn(name = "dict_id")}) // 可由两张表进行维护关系和查询，用不同的dao就行
    @OrderBy("id")
    private Set<TagTest> freeTime = new HashSet<>();
    ……
}

TagTest

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
@Entity
@Table(name = "tag_test")
@NamedQuery(name = "TagTest.findAll", query = "SELECT o FROM TagTest o")
public class TagTest {
    /**
     * 主键
     */
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    /**
     * 标签值
     */
    @Column(name = "tag_value")
    private String tagValue;
    @ManyToMany(mappedBy = "freeTime", cascade = CascadeType.ALL) // 映射的字段
    private Set<TranslatorTest> translatorTestSet = new HashSet<>();
    ……
}

中间关系表不需要映射实体，但是需要创建出来：

1
2
3
4
5
6
7
8
9
10
11
12
CREATE TABLE `translator_dict_relation_test`(
  `id`                 bigint(20)       NOT NULL AUTO_INCREMENT               COMMENT '标识',
  `translator_id`      bigint(20)                                             COMMENT '译员项标识',
  `dict_id`            bigint(20)                                             COMMENT '数据字典标识',
  PRIMARY KEY (`id`),
  KEY `FK_translator_dict_id` (`translator_id`),
  KEY `FK_dict_translator_id` (`dict_id`),
  CONSTRAINT `FK_translator_dict_id` FOREIGN KEY (`translator_id`) REFERENCES `translator_test` (`id`),
  CONSTRAINT `FK_dict_translator_id` FOREIGN KEY (`dict_id`) REFERENCES `tag_test` (`id`)
)ENGINE=InnoDB
COMMENT = 'translator_dict_relation_test'
CHARACTER SET utf8 COLLATE utf8_general_ci;
4.3.2 查询示例编写
  1. JPA
    正常进行crud操作，JPA会自动对关联的表以及中间表进行相关操作。
  2. mybatis
    正常sql语句的链表查询。

4.4 建议

  • 此类查询建议使用mybatis完成，使用JPA设置关联关系存在限制性，又容易出现循环关联，查询时不灵活等问题。
  • 多对多关系的解除由关系维护端来完成，关系被维护端不能解除关系，但是此处需要注意，不建议用级联修改关系。
  • 多对多关系可以不做表间的外键，而是对单独的表进行增删改查，再维护对应关系表。
]]> <h3 id="1-实体中没有引用对象"><a href="#1-实体中没有引用对象" class="headerlink" title="1. 实体中没有引用对象"></a>1. 实体中没有引用对象</h3><h4 id="1-1-实体编写实例"><a href="#1-1-实 java BigDecimal比较大小compareTo和equals http://yoursite.com/2018/03/13/java-BigDecimal比较大小compareTo和equals/ 2018-03-13T11:41:57.000Z 2018-03-13T11:44:20.000Z Java在java.math包中提供的API类BigDecimal，用来对超过16位有效位的数进行精确的运算，常用BigDecimal来存金额。在对金额进行校验的时候发生异常，后来发现是比较大小的方法equals导致的。

BigDecimal的equals方法源码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
public boolean equals(Object x) {
    if (!(x instanceof BigDecimal))
        return false;
    BigDecimal xDec = (BigDecimal) x;
    if (x == this)
        return true;
    if (scale != xDec.scale)
        return false;
    long s = this.intCompact;
    long xs = xDec.intCompact;
    if (s != INFLATED) {
        if (xs == INFLATED)
            xs = compactValFor(xDec.intVal);
        return xs == s;
    } else if (xs != INFLATED)
        return xs == compactValFor(this.intVal);
    return this.inflated().equals(xDec.inflated());
}

equals方法不仅比较了两个数的大小，还比较了精度是否相等，当出现5和5.0这种，就会被认为是不相等的。

compareTo的源码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public int compareTo(BigDecimal val) {
    // Quick path for equal scale and non-inflated case.
    if (scale == val.scale) {
        long xs = intCompact;
        long ys = val.intCompact;
        if (xs != INFLATED && ys != INFLATED)
            return xs != ys ? ((xs > ys) ? 1 : -1) : 0;
    }
    int xsign = this.signum();
    int ysign = val.signum();
    if (xsign != ysign)
        return (xsign > ysign) ? 1 : -1;
    if (xsign == 0)
        return 0;
    int cmp = compareMagnitude(val);
    return (xsign > 0) ? cmp : -cmp;
}

compareTo方法只比较了两个数的大小，没有比较精度是否相等，当出现5和5.0这种，就会被认为是相等的。

BigDecimal常用方法：

  1. add(BigDecimal)：BigDecimal对象中的值相加，然后返回这个对象。
  2. subtract(BigDecimal)：BigDecimal对象中的值相减，然后返回这个对象。
  3. multiply(BigDecimal)：BigDecimal对象中的值相乘，然后返回这个对象。
  4. divide(BigDecimal)：BigDecimal对象中的值相除，然后返回这个对象。
  5. toString()：将BigDecimal对象的数值转换成字符串。
  6. doubleValue()：将BigDecimal对象中的值以双精度数返回。
  7. floatValue()：将BigDecimal对象中的值以单精度数返回。
  8. longValue()：将BigDecimal对象中的值以长整数返回。
  9. intValue()：将BigDecimal对象中的值以整数返回。

相关文章：http://blog.csdn.net/lisongjia123/article/details/51232657

]]> <p>Java在java.math包中提供的API类BigDecimal，用来对超过16位有效位的数进行精确的运算，常用BigDecimal来存金额。在对金额进行校验的时候发生异常，后来发现是比较大小的方法equals导致的。</p> <p>BigDecimal的equals方法 jpa联表查询对子表进行crud操作 http://yoursite.com/2018/03/13/jpa联表查询对子表进行crud操作/ 2018-03-13T11:41:05.000Z 2019-04-10T11:18:03.000Z jpa使用@OneToMany注解进行两个表之间一对多的关联以方便级联查询。当需要对关联的表进行增删改操作的时候，需要根据实际需求选择合适的方法。

order表的模型，省略get和set。其中order和installment是一对多关系

Order.java

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
@Entity
@Table(name = "order")
@NamedQuery(name = "Order.findAll", query = "SELECT o FROM Order o")
public class Order extends AbstractModel {
    /**
     * 主键
     */
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    /**
     * 订单号
     */
    @Column(name = "order_number")
    private String orderNumber;
    /**
     * 总价
     */
    @Column(name = "quoted_price")
    private BigDecimal quotedPrice;
    /**
     * 分期信息
     */
    @OneToMany(cascade = {CascadeType.REFRESH, CascadeType.PERSIST, CascadeType.MERGE}, fetch = FetchType.LAZY, orphanRemoval = true)
    @JoinColumn(name = "order_id")
    @Where(clause = "delete_flag = 1")
    private List<Installment> installments;
    /**
     * 删除状态
     */
    @Enumerated(EnumType.ORDINAL)
    @Column(name = "delete_flag")
    private Status status;
    ……

Installment.java

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
@Entity
@Table(name = "installment")
@NamedQuery(name = "Installment.findAll", query = "SELECT o FROM Installment o")
public class Installment extends AbstractModel {
    /**
     * 分期主键
     */
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    /**
     * 订单标识
     */
    @Column(name = "order_id")
    private Long orderId;
    /**
     * 分期金额
     */
    @Column(name = "quoted_price")
    private BigDecimal quotedPrice;
    /**
     * 删除标识
     */
    @Enumerated(EnumType.ORDINAL)
    @Column(name = "delete_flag")
    private Status status;
    ……

1. 被关联表的id不作为其他表的外键关联

如果被关联的表的id没有被其他表的外键关联，可以进行“全删全加”进行被关联表的进行增删改的操作。

fillingModifyPara

1
2
3
4
5
6
7
8
9
10
11
12
13
14
……
order.setOrderNumber(orderDTO.getOrderNumbber());
order.setQuotedPrice(orderDTO.getQuotedPrice());
List<InstallmentDTO> installmentDTOs = orderDTO.getInstallments();
List<Installment> installments = new ArrayList<>();
for (InstallmentDTO installmentDTO : installmentDTOs) {
//可以写构造函数进行初始操作
    Installment installment = new Installment();
    installment.setOrderId();//修改操作，orderId由前端传入
    installment.setQuotedPrice(installmentDTO.gettQuotedPrice());
    installments.add(installment);
}
order.getInstallments().clear();
order.getInstallments().addAll(installments);

这种方法将原来关联的表的相关内容先物理删除，再将新的内容全部添加上去。优点是方便简单，没有冗余数据；缺点是被关联的表的id不能作为其他表的外键关联。这里注意不要对installment再定义一个对象后进行order.set的操作，这样会出现两个对象而报错，详情可以参看hb源码。

2. 被关联表的id可能还关联了一堆乱七八糟的东西

当被关联表的id可能还关联了一堆乱七八糟的东西的时候，就不能进行简单的“全删全加”操作来修改关联表的内容。这个时候的做法是现将从数据库中查出的联表信息全部逻辑删除（status设为无效），然后与传入的进行比对，id相同的将status设置为有效，并修改内容；传入的DTO中没有id的作为新增的加入。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
order.setOrderNumber(orderDTO.getOrderNumbber());
order.setQuotedPrice(quotationDTO.getQuotedPrice());
List<Installment> installments = orders.getInstallments();
List<InstallmentDTO> installmentDTOS = quotationDTO.getInstallmentList();
List<Installment> newInstallments = new ArrayList<>();
installments.forEach(installment -> {installment.setStatus(Status.INVALID);});
for (InstallmentDTO installmentDTO : installmentDTOS) {
    for (Installment installment : installments) {
        if (installment.getId().equals(installmentDTO.getId())) {
            installment.setStatus(Status.VALID);
            installment.setQuotedPrice(installmentDTO.getQuotedPrice());
            installment.setOrderId();
                }
        }
        if (installmentDTO.getId() == null) {
            Installment installment = new Installment();
            installment.setOrderId();
            installment.setQuotedPrice(installmentDTO.gettQuotedPrice());
            newInstallments.add(newInstallment);
        }
    }
installments.addAll(newInstallments);
orders.setInstallments(installments);
]]> <p>jpa使用@OneToMany注解进行两个表之间一对多的关联以方便级联查询。当需要对关联的表进行增删改操作的时候，需要根据实际需求选择合适的方法。</p> <p>order表的模型，省略get和set。其中order和installment是一对多关系</p> <p>Ord Python2.7 pytesser提取图片中文字信息 http://yoursite.com/2017/11/30/Python2-7-pytesser提取图片中文字信息/ 2017-11-30T12:30:34.000Z 2020-03-03T13:27:52.797Z 图片中存在大段的文字，用手敲实在是费劲。很多在线转换的工具，速度慢，并且达到一定次数后会收费。贫穷让我自力更生，查到python可以通过安装pytesseract库来进行文字识别。而pytesser调用了tesseract，因此还需要安装Tesseract-OCR软件（OCR：Optical Character Recognition，即光学字符识别技术，专门用于对图片文字进行识别，并获取文本。tesseract-ocr引擎先由HP实验室研发，后来成为一个开源项目，主要由google进行改进优化）。另外还需要用的图像处理库PIL库。

网上相关资料很多，在安装过程中出现了很多问题，特将安装方法和遇到的问题做个记录，方便日后查阅。

运行环境为：OS X Yosemite 10.10.5

1.安装PIL和pytesseract库

1
2
RosyMacBook-Pro:~ Rosy$ pip install pytesseract
RosyMacBook-Pro:~ Rosy$ pip install PIL

2.安装Tesseract-OCR

2.1 安装homebrew

Homebrew是MacOS上的包管理器，类似于ubuntu中的apt-get，centos中的yum。

1
RosyMacBook-Pro:~ Rosy$ ruby -e "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/master/install)"

安装好后，可用 brew -v 查看认是否安装成功。

1
2
3
RosyMacBook-Pro:~ Rosy$ brew -v
Homebrew 1.3.8
Homebrew/homebrew-core (git revision e939; last commit 2017-11-29)

2.2 安装tesseract

安装tesseract会提示 tesseract:XQuartz is required to install this formula. X11Requirment unsatiffied!

需要先安装xquartz！

1
2
3
4
// 安装xquartz
RosyMacBook-Pro:~ Rosy$ brew cask install xquartz
// 安装tesseract的同时安装训练工具
RosyMacBook-Pro:~ Rosy$ brew install --with-training-tools tesseract

2.3 安装Tesseract-OCR语言包配置

默认安装的是eng英文语言包。如果需要对汉语进行提取，则需要安装汉语语言包。

语言包下载地址：https://github.com/tesseract-ocr/tessdata

下载chi_sim.traineddata（中文简体），将其拷贝到/usr/local/Cellar/tesseract/3.05.01/share/tessdata下。

image

验证Tesseract-OCR：

1
2
3
RosyMacBook-Pro:~ Rosy$ tesseract /Users/Rosy/Desktop/test.png /Users/Rosy/Desktop/test -l chi_sim
Tesseract Open Source OCR Engine v3.05.01 with Leptonica
RosyMacBook-Pro:~ Rosy$

其中 -l 表示识别的语言，test是输出到文件txt的名字。在指定路径下能够看到生成的txt文件。

png格式的图片，提前其中的文字信息

image

提取后的效果：
image

3.python程序提取图片信息

1
2
3
4
5
6
7
8
9
10
11
12
#coding:utf-8
import sys 
import pytesseract
from PIL import Image
reload(sys)
sys.setdefaultencoding('utf-8')
image = Image.open("/Users/Rosy/Desktop/test.png")
text = pytesseract.image_to_string(image,lang='chi_sim') 
with open("/Users/Rosy/Desktop/output.txt", "w") as f:
    print(text)
    f.write(str(text))

提取结果

image

其中需要说明：

  • import pytesseract报错如下
1
2
3
4
5
6
7
8
>>> import pytesseract
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "pytesseract.py", line 9, in <module>
    import Image
  File "/Library/Python/2.7/site-packages/PIL/Image.py", line 27, in <module>
    from . import VERSION, PILLOW_VERSION, _plugins
ValueError: Attempted relative import in non-package

说pytesseract.py无法引用Image这个包，在确认了PIL是正常安装且能够正常使用，于是找到了pytesseract.py报错的地方，源码是：

1
2
3
4
try:
    import Image
except ImportError:
    from PIL import Image

我的PIL的Image文件和pytesseract.py不在同一目录下，因此没法直接引用。并且没有走 from PIL import Image 这条语句，说明是异常没有捕获到，改一个范围更大的异常进行捕获就可以了：

1
2
3
4
try:
    import Image
except Exception:
    from PIL import Image
  • python不能够读取中午，加了 #coding:utf-8 也不行；查阅了网上的资料，加上如下三行，搞定！
1
2
3
import sys 
reload(sys)
sys.setdefaultencoding('utf-8')

具体添加的位置见完整代码。

另外，尝试了有背景花纹，颜色和背景接近和非正常字体的图片的文字提取信息。发现正常字体在颜色和背景接近的情况下，能够大致识别出文字信息，而在非正常字体的情况下几乎不能正确提前信息。见下图：

image

另外，对图片的处理和对Tesseract-OCR语言包的训练，可以提高识别率，以后可能会继续研究。

]]> <p>图片中存在大段的文字，用手敲实在是费劲。很多在线转换的工具，速度慢，并且达到一定次数后会收费。贫穷让我自力更生，查到python可以通过安装pytesseract库来进行文字识别。而pytesser调用了tesseract，因此还需要安装Tesseract-OCR软件（OC docker里用tomcat8下载文件 http://yoursite.com/2017/11/30/docker里用tomcat8下载文件/ 2017-11-30T12:30:04.000Z 2020-03-03T13:30:16.884Z 在docker中启动Tomcat作为下载文件服务器，如果存在中文名的文件，则需要对docker的容器编码格式进行修改，使其能够支持中文，否则将无法在下载中文名文件。

1. 修改docker容器编码格式

直接启动docker容器，发现中文文件在里面显示为乱码

image

查看docker容器编码格式，可以看到当前编码格式为POSIX，这种编码格式不支持中文.

image

我们需要自己修改容器的编码格式。

1.1 安装中文语言包

查看容器所有的语言环境，如果没有中文语言包，则需要自己安装。

image

安装中文语言包：

1
[root@e0f34910ee74 /]# yum install glibc-common

安装好后再次查看语言包信息，出现中文语言包。

image

1.2 docker build生成新的镜像

将下好语言包的容器commit成一个新的镜像

1
[root@host-10-0-251-159 dockerbuild]# docker commit c2eb75865693 webcrawler-service:test

基于这个新镜像写一个Dockerfile，然后基于Dockerfile生成我们需要的镜像。
Dockerfile为

1
2
3
[root@host-10-0-251-159 dockerbuild]# cat Dockerfile 
FROM webcrawler-service:test
ENV LANG zh_CN.UTF-8

docker build成新的镜像

1
[root@host-10-0-251-159 dockerbuild]# docker build -t webcrawler-service-new .

基于这个新镜像webcrawler-service-new启动一个容器，进入这个容器，我们可以看到容器编码为我们设置的zh_CN.UTF-8，生成一个新的中文名文件，不再出现乱码。

1
2
[root@host-10-0-251-159 /]# docker run -tid eec4bea /run.sh
[root@host-10-0-251-159 /]# docker exec -ti eec4bea /bin/bash

image

image

2. Tomcat8 HTTP文件下载文件

2.1 修改Tomcat配置文件

在Tomcat安装目录下，修改web.xml文件

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
[root@eec4bea40bab conf]# vi /usr/local/tomcat/conf/web.xml
……
    <servlet>
        <servlet-name>default</servlet-name>
        <servlet-class>org.apache.catalina.servlets.DefaultServlet</servlet-class>
        <init-param>
            <param-name>debug</param-name>
            <param-value>0</param-value>
        </init-param>
        <init-param>
            <param-name>listings</param-name>
            <param-value>true</param-value> （把原来的false改为true）
        </init-param>
        <load-on-startup>1</load-on-startup>
    </servlet>
……

2.2 创建用于下载的xml文件

在安装目录下的conf/Catalina/localhost/下新建一个xml文件，用于访问下载列表。

1
2
3
4
5
[root@eec4bea40bab conf]# vi /usr/local/tomcat/conf/web.xml 
[root@eec4bea40bab conf]# cat /usr/local/tomcat/conf/Catalina/localhost/download.xml 
<?xml version="1.0" encoding="utf-8"?>
<Context  reloadable="true" docBase="/usr/download" crossContext="true">
</Context>

其中docBase的路径为对外暴露的下载路径，需要存在该路径。
docker容器，对外暴露需要访问的端口，浏览器访问，出现下载列表：

image

因为有需求是文件名需要有中文。一开始中文出现乱码，导致无法下载文件。查阅了网上很多资料，都说是因为Tomcat默认的编码方式是iso8859-1，而iso8859-1不属于中文码表，故而出现乱码。建议修改server.xml文件，将编码方式修改为utf-8： URIEncoding=”utf-8”。我进行尝试后发现依然中文乱码。后来发现Tomcat8默认的编码已经是utf-8了，所以不需要修改server.xml文件 （如果从Tomcat早期版本迁移到Tomcat8需要注意这个问题）。后来多次测试，发现是系统环境的问题，如果系统本身不支持中文，则修改Tomcat后也不支持中文文件的下载，需要先修改系统环境语言。

]]> <p>在docker中启动Tomcat作为下载文件服务器，如果存在中文名的文件，则需要对docker的容器编码格式进行修改，使其能够支持中文，否则将无法在下载中文名文件。</p> <h2 id="1-修改docker容器编码格式"><a href="#1-修改docker容器编码 java基本数据类型及其封装类 http://yoursite.com/2017/11/30/java基本数据类型及其封装类/ 2017-11-30T12:28:58.000Z 2017-11-30T12:33:55.000Z 之前刚从python写java，碰到过两个String比较大小，习惯性用了“==”，发现不管我的String赋什么样的值，最后都是false。后来网上搜了一下，发现是封装类的原因。

1.相关说明

说到封装类，不得不提到栈内存和堆内存。
堆内存在Java运行时被使用来为对象和JRE类分配内存。不论什么时候我们创建了对象，它将一直会在堆内存上创建。垃圾回收运行在堆内存上来释放没有任何引用的对象所占的内存，任何在堆上被创建的对象都有一个全局的访问，并且可以在应用的任何位置被引用。

Java的栈内存被用来线程的执行，他们包含生命周期很短的具体值的方法和在堆中使用这个方法对象的引用。栈内存是LIFO（后进先出）序列。当方法被调用的时候，堆内存中一个新的块被创建，保存了本地原始值和在方法中对其他对象的引用。这个方法结束之后，这个块对其他方法就变成可用的了。和堆内存比，栈内存要小的多，因为明确使用了内存分配规则（LIFO），和堆内存相比栈内存非常快。

2. 封装类型和基本类型比较

2.1 封装类型和基本类型说明

Java的基本数据类型：int，double，float，long，byte，char，boolean。
对应的封装类：Integer，Double，Float，Long，Byte，Char，Boolean。
封装类型和基本类型的内存模型本质上是不一样的。基本数据类型直接存储在内存中的内存栈上的，数据本身的值就是存储在栈空间里面，不存在“引用”的概念。封装类型是按照Java里面存储对象的内存模型来进行数据存储的，使用Java内存堆和内存栈来进行这种类型的数据存储，对象本身的值存储在内存堆上，栈内存只包含原始值变量和堆中对象变量的引用。封装类型和基本类型有不同的默认值：封装类型默认值为null，基本类型的默认值于本身的类型有关。基本数据类型本身就是一个值。

2.2基本数据类型及其封装类的转换

定义基本数据类型转封装类：

1
2
intnum=3;
Integerinteger=newInteger(num);

在添加了自动装拆箱的功能之后:

1
Integer integer=3;

封装类转基本数据类型：

1
2
integer integer=newInteger(3);
int num=integer.intValue();

当然，也可以直接int num=integer，这里的自动拆箱，其实也是调用了封装类的intValue()方法来实现的。
将String类型字符串与基本数据类型进行转换。
字符串转基本数据类型：

1
2
String ageString="23";
int age=Integer.parseInt(ageString);

基本数据类型转字符串：

1
2
String age=23+"";
或者Stringage = String.valueOf(23);

封装类转字符串,直接调用封装类对象的toString()方法即可。

1
2
Integer age = 23;
String ageString=age.toString();

2.3 封装类型和基本类型数值直接的比较方法（equal和==）

例如：

1
2
int n=3;
int m=3;

变量n和变量m都是直接存储的“3”这个数值，所以用==比较的时候结果是true。
而对于非基本数据类型的变量，是引用类型的变量，引用类型的变量存储的并不是“值”本身，而是于其关联的对象在内存中的地址。例如：

1
String str1;

这句话声明了一个引用类型的变量，此时它并没有和任何对象关联。
而通过newString（”hello”）来产生一个对象（也称作为类String的一个实例），并将这个对象和str1、str2进行绑定：

1
2
str1=newString("hello");（或者：String str1="hello";）
str2=newString("hello");（或者：String str2="hello";）

那么str1指向了一个对象，此时变量str1中存储的是它指向的对象在内存中的存储地址，并不是“值”本身，也就是说并不是直接存储的字符串”hello”。这里面的引用和C/C++中的指针很类似。
因此在用==对str1和str2进行第一次比较时，得到的结果是false。因此它们分别指向的是不同的对象，也就是说它们实际存储的内存地址不同。
而在第二次比较时，都让str1和str2指向了str指向的对象，那么得到的结果毫无疑问是true。
equals方法是基类Object中的方法，因此对于所有的继承于Object的类都会有该方法。
在Object类中，equals方法是用来比较两个对象的引用是否相等，即是否指向同一个对象。String类对equals方法进行了重写，用来比较指向的字符串对象所存储的字符串是否相等。

对于封装过之后，每个类型都有对应的缓存：

类型 缓存情况
Byte 全部缓存
Boolean 全部缓存
Integer -128~127缓存
Character <=127缓存
Short -128~127缓存
Long -128~127缓存
Float 没有缓存
Double 没有缓存

例如：

1
2
3
4
5
6
Integer i1=127;// java在编译的时候，被翻译成->Integer i1=Integer.valueOf(127);
Integer i2=127;
System.out.println(i1==i2);// true
Integer _i1=128;
Integer _i2=128;
System.out.println(_i1==_i2);//false

对于-128到127之间的数，会进行缓存，Integer i1=127时，会将127进行缓存，下次再写Integer i2=127时，就会直接从缓存中取，就不会new了。所以i1 == i2 是true；而_i1 == _i2是false。

3.总结

3.1基本类型：

优点：

  • 用于计算效率高
  • 不会由于常量池引起比较大小错误

缺点：

  • 当数据库中查询出结果之后封装结果集时如果返回的值时null时，如果直接赋值给这个基本类型的字段时，会在运行时报出异常，不能将null赋给一个基本类型，而用Integer就不存在这样都的情况
  • 当用spring的表单对象时如果页面传来的值是只有字段没有值是如果表单对象中有基本类型的值时会抛出异常。需要设置在数据库中为该字段设置默认值，但是这经常会被忽略。

3.2封装类型

优点：

  • 可以存放null，从数据库中查出值时可能会有null
  • 表示一个值（不用于计算，只用于保存值时和int类型一样）;

缺点

  • 不能用于两个Integer对象双等判断两个对象的值相等，会出现错误的。

java中Integer，String判断相等与integer的比较大小不适合频繁的用于计算，要用双等判断两个对象的值是否相等时，要调用intValue方法
综上所述，在建立实体类时，用封装类型比较好；如果需要频发的计算，则用基本类型效率更高。

]]> <p>之前刚从python写java，碰到过两个String比较大小，习惯性用了“==”，发现不管我的String赋什么样的值，最后都是false。后来网上搜了一下，发现是封装类的原因。</p> <h2 id="1-相关说明"><a href="#1-相关说明" class="h JAVA写入word文档（用POI包） http://yoursite.com/2017/11/07/JAVA写入word文档（用POI包）/ 2017-11-07T08:14:06.000Z 2017-11-07T08:35:00.000Z Apache的POI是一种流行的API，允许程序员创建，修改和使用显示Java程序的MS-Office文件。它是开发和Apache软件基金会的分布式设计或修改使用Java程序MS-Office文件的开源库。它包含的类和方法来将用户输入的数据或文件到MS-Office文档解码。POI对Excel、Word、PowerPoint甚至是Visio都有组件。近期工作中有项目需要生成Word，并且有指定样式（字体、字号页眉页脚、水印等），特记录一下POI在Word上的用法。

官网地址：https://poi.apache.org/。

1. 创建docx文档（写入段落和表格）

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
public static void main(String[] args) throws XmlException, IOException
{
    //创建一个空白文档
    XWPFDocument document = new XWPFDocument();
    
    //给段落加下边框
    paragraph.setBorderBottom(Borders.BASIC_BLACK_DASHES);
    
    //给段落加左边框
    paragraph.setBorderLeft(Borders.BASIC_BLACK_DASHES);
    
    //给段落加右边框
    paragraph.setBorderRight(Borders.BASIC_BLACK_DASHES);
    
    //给段落加上边框
    paragraph.setBorderTop(Borders.BASIC_BLACK_DASHES);
    
    //创建一个段落
    XWPFParagraph paragraph = document.createParagraph();
    XWPFRun run = paragraph.createRun();
    run.setText("这是一个word文档，用于测试，用poi写入。  可以有空格，可以改写");
    
    //创建表格
    XWPFTable table = document.createTable();
    
    //创建第一行
    XWPFTableRow tableRowOne = table.getRow(0);
    tableRowOne.getCell(0).setText("col one, row one");
    tableRowOne.addNewTableCell().setText("col two, row one");
    tableRowOne.addNewTableCell().setText("col three, row one");
    
    //创建第二行
    XWPFTableRow tableRowTwo = table.createRow();
    tableRowTwo.getCell(0).setText("col one, row two");
    tableRowTwo.getCell(1).setText("col two, row two");
    tableRowTwo.getCell(2).setText("col three, row two");
    
    //Write the Document in file system
    FileOutputStream out = new FileOutputStream(new File("C:\\Users\\dell\\Desktop\\createparagraph.docx"));
    document.write(out);
    out.close();
}

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
public static void main(String[] args) throws XmlException, IOException
{
    XWPFDocument document = new XWPFDocument();
    //创建段落
    XWPFParagraph paragraphone = document.createParagraph();
    //设置段落右对齐样式
    paragraphone.setAlignment(ParagraphAlignment.RIGHT);
    XWPFRun runone=paragraphone.createRun();
    runone.setText("右对齐右对齐右对齐右对齐右对齐右对齐右对齐右对齐右对齐右对齐.");
    //创建一个新段落
    XWPFParagraph paragraphtwo=document.createParagraph();
    //设置段落居中对齐样式
    paragraphtwo.setAlignment(ParagraphAlignment.CENTER);
    XWPFRun runtwo=paragraphtwo.createRun();
    runtwo.setText("居中对齐居中对齐居中对齐居中对齐居中对齐居中对齐居中对齐居中对齐.");
    //创建一个新段落
    XWPFParagraph paragraphthree = document.createParagraph();
    
    //设置加粗和斜体
    XWPFRun paragraphOneRunOne = paragraphthree.createRun();
    paragraphOneRunOne.setBold(true);
    paragraphOneRunOne.setItalic(true);
    paragraphOneRunOne.setText("Font Style");
    paragraphOneRunOne.addBreak();
    
    //设置文本位置
    XWPFRun paragraphOneRunTwo = paragraphthree.createRun();
    paragraphOneRunTwo.setText("Font Style two");
    paragraphOneRunTwo.setTextPosition(100);
    
    //创建一个新段落
    XWPFRun paragraphOneRunThree = paragraphthree.createRun();
    
    //设置文字中划线样式（可能弃用）
    paragraphOneRunThree.setStrike(true);
    
    //设置文字大小
    paragraphOneRunThree.setFontSize(20);
    
    //设置文字段落内对齐，垂直对齐（垂直靠下对齐，垂直居中对齐，垂直向上对齐）
    paragraphOneRunThree.setSubscript(VerticalAlign.SUBSCRIPT);
    paragraphOneRunThree.setText(" Different Font Styles");
    
    //Write the Document in file system
    FileOutputStream out = new FileOutputStream(newFile("C:\\Users\\dell\\Desktop\\createparagraph.docx"));
    document.write(out);
    out.close();
}

3. 从已有的docx文件中获取信息

1
2
3
4
5
6
7
8
public static void main(String[] args) throws XmlException, IOException
{
    //传流构建XWPFDocument
    XWPFDocument docx = new XWPFDocument(new FileInputStream("C:\\Users\\dell\\Desktop\\createparagraph.docx"));
    
    //传路径构建XWPFDocument
    XWPFDocument document = new XWPFDocument(POIXMLDocument.openPackage("C:\\Users\\dell\\Desktop\\createparagraph.docx"));
}

4. 处理页眉页脚（由模板文件进行文字替换）

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
public static void replaceFooterAndHeader(XWPFDocument doc){
        List<XWPFParagraph> footers = doc.getHeaderFooterPolicy().getDefaultFooter().getParagraphs();
        List<XWPFParagraph> headers = doc.getHeaderFooterPolicy().getDefaultHeader().getParagraphs();
       
        //处理页脚
        for (XWPFParagraph paragraph : footers) {
            List<XWPFRun> runs = paragraph.getRuns();
            for (XWPFRun run : runs) {
                String text = run.getText(0);
                if(StringUtils.isNotEmpty(text)){
                    for(Entry<String, String> entry : params.entrySet()){
                        String key = entry.getKey();
                        if(text.indexOf(key) != -1){
                            Object value = entry.getValue();
                            if(value instanceof String){
                                text = text.replace(key, value.toString());
                                run.setText(text,0);
                            }
                        }
                    }
                }
            }
        }
       
        //处理页眉
        for (XWPFParagraph paragraph : headers) {
            List<XWPFRun> runs = paragraph.getRuns();
            for (XWPFRun run : runs) {
                String text = run.getText(0);
                if(StringUtils.isNotEmpty(text)){
                    for(Entry<String, String> entry : params.entrySet()){
                        String key = entry.getKey();
                        if(text.indexOf(key) != -1){
                            Object value = entry.getValue();
                            if(value instanceof String){
                                text = text.replace(key, value.toString());
                                run.setText(text,0);
                            }
                        }
                    }
                }
            }
        }
    }

5.获取docx文件中的图片

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public static void main(String[] args) throws XmlException, InvalidFormatException, FileNotFoundException, IOException{
    String path ="C:\\Users\\dell\\Desktop\\picture.docx";
    File file = new File(path);
    FileInputStream fis = new FileInputStream(file);
    XWPFDocument document = new XWPFDocument(fis);
    XWPFWordExtractor xwpfWordExtractor = new XWPFWordExtractor(document);
    String text = xwpfWordExtractor.getText();
    System.out.println(text);
    List<XWPFPictureData> picList = document.getAllPictures();
    for (XWPFPictureData pic : picList) {
        System.out.println(pic.getPictureType() + file.separator + pic.suggestFileExtension()+file.separator+pic.getFileName());
        byte[] bytev = pic.getData();
        FileOutputStream fos = new FileOutputStream("d:\\"+pic.getFileName());
        fos.write(bytev);
    }
    fis.close();
}

6. POI读取.doc 和.docx

6.1 HWPF和XWPF

HWPF：MS－Word 97-2003(.doc)，基于BIFF8格式的JAVA接口。只支持.doc文件简单的操作，读写能力有限。本API为POI项目早期开发，很不幸的 是主要负责HWPF模块开发的工程师已经离开Apache组织，现在该模块没有人维护、更新、完善。

XWPF：MS－Word 2007+(.docx)，基于OOXML格式的JAVA接口。较HWPF功能完善。

6.2 HSSF和XSSF

HSSF：MS－Excel 97-2003（.xls），基于BIFF8格式的JAVA接口。

XSSF：MS－Excel 2007+(.xlsx)，基于OOXML格式的JAVA接口。

具体见： POI读取.doc 和.docx的区别

另外很好的例子地址：http://www.cnblogs.com/unruly/p/7552998.html

]]> <p>Apache的POI是一种流行的API，允许程序员创建，修改和使用显示Java程序的MS-Office文件。它是开发和Apache软件基金会的分布式设计或修改使用Java程序MS-Office文件的开源库。它包含的类和方法来将用户输入的数据或文件到MS-Office文档解码 程序中的返回码 http://yoursite.com/2017/11/07/程序中的返回码/ 2017-11-07T08:09:04.000Z 2017-11-07T08:34:08.000Z HTTP状态码可以指明请求是否成功，还可以揭示请求失败的确切原因，是前后端进行“交流”的重要语言。在实际开发过程中，存在着对不同状态码应用场景不清楚，如何正确抛出合适的状态码的问题，使得前端开发人员不能很好的获取发起请求后后台的反应。本文旨在通过实际应用对现业务涉及的状态码进行探究记录，为以后开发中遇到类似问题作个参考。

1. 查询一个资源

例如：GET：/v1/characters/{id}

1.1 接口定义

1
2
3
4
5
6
7
8
9
public interface CharacterService {
    @GET
    @Path("{id}")
    @ApiOperation(value = "根据人物id查询人物详情", notes = "根据人物id查询人物详情", response = CharacterDTO.class, tags = {"CharacterService",})
    @ApiResponses(value = {
            @ApiResponse(code = 204, message = "没有数据"),
            @ApiResponse(code = 404, message = "@06404:请求参数错误"),
            @ApiResponse(code = 500, message = "@06500:服务器异常")})
    CharacterDTO getCharacterById(@ApiParam(value = "人物ID", required = true) @NotNull(message = "CharacterID must be not null") @PathParam("id") Long id);

1.2 接口实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
public CharacterDTO getCharacterById(Long characterId) {
        CharacterDTO characterDTO = null;
        try{
            Character character = characterRepository.findByIdAndStatus(characterId, Status.VALID);
            if (null == character){
                return null;
               //此处return null表示查询请求正确，但是没有资源，不抛异常，返回码204，表示没有数据。
               //LOGGER.error("can not query character from db and character is: " + characterId);
               // throw new WebApplicationException(ScriptsTranslationReturnCode.NOT_FOUND_MODEL, "can not find character");
            }
            return beanMapper.map(character,CharacterDTO.class);
        } catch (WebApplicationException we){
            LOGGER.error(we.getMessage(),we);
            throw we;
        } catch (Exception e){
            LOGGER.error("query character information by id error",e);
            throw new WebApplicationException(ScriptsTranslationReturnCode.SERVICE_EXCEPTION, "service exception");
        }
    }
  • 参数正确请求得到一个资源，返回200；
  • 参数正确资源不存在，返回204，或者404；
  • 参数类型错误（其他应该返回400），返回404，路径斜杠后的参数错误不会返回400.

2. 查询一个资源，该资源可能关联其他子资源。

例如：GET: {id}/lines-info

2.1 接口定义

1
2
3
4
5
6
7
8
9
@GET
    @Path("{id : \\d+}/device-models")
    @ApiOperation(value = "根据镜像id得到终端型号列表", notes = "根据镜像id得到终端型号列表", response = SimpleImageContentDTO.class, responseContainer = "List", tags={ "image content"})
    @ApiResponses(value = {
            @ApiResponse(code = 200, message = "OK", response = DeviceModelDTO.class, responseContainer = "List"),
            @ApiResponse(code = 204, message = "没有数据"),
            @ApiResponse(code = 422, message = "06450：无法处理的镜像资源", responseContainer = "Object"),
            @ApiResponse(code = 500, message = "06500：服务异常", responseContainer = "Object") })
    List<DeviceModelDTO> queryDeviceModelsById(@ApiParam(value = "镜像id",required = true) @NotNull(message = "The image content id must not be null") @PathParam("id") Long id);

2.2 接口实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
@Override
    public List<DeviceModelDTO> queryDeviceModelsById(Long id) {
        try{
            ImageContent imageContent = imageContentRepository.findByIdAndStatus(id, Status.VALID);
            if (imageContent==null){
                throw new UnprocessableEntityException(TerminalDeviceReturnCode.UNPROCESSABLE_IMAGE_CONTENT,"image content not found");
            }
            List<DeviceModel> deviceModelList = deviceModelRepository.queryDeviceModelsByImageContentId(id);
            if (CollectionUtils.isEmpty(deviceModelList)){
                return null;
            }
            return beanMapper.mapAsList(deviceModelList,DeviceModelDTO.class);
        } catch (WebApplicationException we) {
            LOGGER.error("query device models by Id error!" ,we);
            throw we;
        } catch (Exception e) {
            LOGGER.error("query device models by Id error!" ,e);
            throw new WebApplicationException(TerminalDeviceReturnCode.SERVICE_EXCEPTION, "service exception!");
        }
    }

根据A资源查询B资源

  • 正确查询，返回200；
  • 根据查不到A资源信息，返回422，抛异常UnprocessableException。
  • 可以查到A资源，但是根据A资源查不到B资源，返回204或者404；

3. 修改一个资源

例如：PUT:/translation-lines-info/{id}

3.1接口定义

1
2
3
4
5
6
7
8
9
10
@PUT
    @Path("{id}")
    @ApiOperation(value = "修改人物信息", notes = "修改人物信息", response = CharacterDTO.class, tags = {"CharacterService",})
    @ApiResponses(value = {
            @ApiResponse(code = 201, message = "修改成功"),
            @ApiResponse(code = 404, message = "@06404：人物信息不存在"),
            @ApiResponse(code = 400, message = "@06400: 请求参数错误"),
            @ApiResponse(code = 409, message = "@06411:人物名称冲突"),
            @ApiResponse(code = 500, message = "@06500：服务异常")})
    CharacterDTO modifyCharacter(@ApiParam(value = "人物id", required = true) @NotNull(message = "parameter must not be null") @PathParam("id") Long id, @NotNull(message = "parameter must be not null") @ApiParam(value = "人物信息", required = true) CharacterDTO characterDTO);

3.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
public CharacterDTO modifyCharacter(Long id, CharacterDTO characterDTO) {
        try {
            Character character = characterRepository.findByIdAndStatus(id,Status.VALID);
            if(character == null){
                throw new WebApplicationException(ScriptsTranslationReturnCode.NOT_FOUND_MODEL, "modify character error! can not found character info exception!");
            }
            String chName = characterDTO.getName();
            String enName = characterDTO.getEnglishName();
            Long dramaId = characterDTO.getDramaId();
            if(org.springframework.util.StringUtils.isEmpty(chName) || org.springframework.util.StringUtils.isEmpty(enName) || dramaId == null){
                throw new ClientErrorException(HttpStatus.BAD_REQUEST, ScriptsTranslationReturnCode.PARAM_ERROR, " chname or enname or dramaid is empty!");
            }
            List<Character> chNamesOrEnNames = characterRepository.findOtherIdExistNames(chName,enName,id,dramaId);
            if(chNamesOrEnNames.size() > 0){
                throw new ClientErrorException(HttpStatus.CONFLICT, ScriptsTranslationReturnCode.DRAMA_ADD_OR_UPDATE_CHARACTER_NAME_CONFICT, " chname or enname conflict");
            }
            Character modifyCharacher = fillingModifyParams(characterDTO, character);
            Character modifyResult = characterRepository.saveAndFlush(modifyCharacher);
            return beanMapper.map(modifyResult, CharacterDTO.class);
        }catch (ClientErrorException we){
            LOGGER.error(we.getMessage(),we);
            throw we;
        } catch (Exception e){
            LOGGER.error("modify character error",e);
            throw new WebApplicationException(ScriptsTranslationReturnCode.SERVICE_EXCEPTION, "service exception");
        }
    }
  • 修改成功返回201；
  • 根据路径上的id查询人物信息没查到，返回404；
  • 如果路径上的id为非数字类型，返回404；
  • 如果dto里的类型错误，返回400（body和？后的参数类型错误，返回400），抛出BadRequestException；
  • 修改的数据与原数据产生了冲突（根据业务定义），返回409，抛出ClienErrorException。

4. 总结

现在涉及到的状态码有以下几个：

  • 200：用于成功查询到信息。
  • 201：用于修改或添加成功。
  • 204：用于删除成功，也可用于找不到资源。
  • 400：body和“？”后的参数类型错误，抛出BadRequestException。
  • 404：“/”后的参数错误，或者找不到资源。
  • 409：修改的数据与原数据产生了冲突（根据业务定义），返回409，抛出ClienErrorException。
  • 422：当用户针对不存在的资源进行操作时，则返回404，当用户传入无效字段，则返回422，抛出异常UnprocessableException。
    例如：
    修改A资源，但A资源不存在，则返回404；
    根据A资源，添加A与B资源的关系，此时操作主体是A与B资源的关系表，当A和B都不存在时，则是属于创建某个资源，发生了一个验证错误，此时应该返回422。

附1. 常用http状态码

服务器向用户返回的状态码和提示信息，常见的有以下一些（方括号中是该状态码对应的HTTP动词）。

  • 200 OK - [GET]：服务器成功返回用户请求的数据，该操作是幂等的（Idempotent）（在编程中，一个幂等操作的特点是其任意多次执行所产生的影响均与一次执行的影响相同。）

  • 201 CREATED - [POST/PUT/PATCH]：用户新建或修改数据成功。

  • 202 Accepted - [*]：表示一个请求已经进入后台排队（异步任务）

  • 204 NO CONTENT - [DELETE]：用户删除数据成功。

  • 400 INVALID REQUEST - [POST/PUT/PATCH]：用户请求错误，参数格式不符合调用API规定、资源不存在、语义参数服务端无法处理等

  • 401 Unauthorized - [*] ：表示用户没有权限（令牌、用户名、密码错误）。

  • 403 Forbidden - [*]：表示用户得到授权（与401错误相对），但是访问是被禁止的。

  • 404 NOT FOUND - [*]：用户发出的请求针对的是不存在的记录，服务器没有进行操作，该操作是幂等的。

  • 406 Not Acceptable - [GET]：用户请求的格式不可得（比如用户请求JSON格式，但是只有XML格式）。

  • 410 Gone -[GET]：用户请求的资源被永久删除，且不会再得到的。

  • 422 Unprocesable entity - [POST/PUT/PATCH]：当创建一个对象时，发生一个验证错误。

  • 500 INTERNAL SERVER ERROR - [*]：服务器发生错误，用户将无法判断发出的请求是否成功。

附2. 服务接口方法名规

  • add开头方法代表添加数据：add

  • modify开头方法代表修改业务数据：modify

  • query开头方法代表查询多条数据：queryByCondition，queryByIDs

  • get开头方法代表返回一条数据：getByID

  • delete开头方法代表删除数据：deleteByID

  • 提供服务的方法不要有重载

  • 方法参数不要超过5个，多于5个请使用包装类（DTO）

  • 方法参数类型不能使用int/char/double/long/boolean/short/float，必须换成对应Integer/Character/Double/Long/Boolean/Short/Float类型

]]> <p>HTTP状态码可以指明请求是否成功，还可以揭示请求失败的确切原因，是前后端进行“交流”的重要语言。在实际开发过程中，存在着对不同状态码应用场景不清楚，如何正确抛出合适的状态码的问题，使得前端开发人员不能很好的获取发起请求后后台的反应。本文旨在通过实际应用对现业务涉及的状态码