准备工作，5台本地虚拟机，三台哨兵，2台redis（一主一从），安装好docker环境。（也可以在一台机器上启动5个实例，配置5个不同端口即可）

下载镜像

• 搜索redis镜像

  1	docker search redis

• 下载镜像

  1	docker pull docker.io/redis:5.0

redis 版本可在dockerhub仓库查看

主从配置

• 创建数据目录和配置目录

  1 2	mkdir /usr/redis/data mkdir /usr/redis/config

后面将会把容器内的文件挂载出来

主节点配置

在/usr/redis/config下创建配置文件redis.conf并添加配置参数：

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

#是否在后台执行，yes：后台运行；no：不是后台运行
daemonize no
#是否开启保护模式，默认开启。要是配置里没有指定bind和密码。开启该参数后，redis只会本地进行访问，拒绝外部访问。
protected-mode no
#redis监听的端口号。
port 6379
#指定 redis 只接收来自于该 IP 地址的请求，如果不进行设置，那么将处理所有请求，或者写成0.0.0.0
#bind 127.0.0.1
#指定了记录日志的文件。空字符串的话，日志会打印到标准输出设备。后台运行的redis标准输出是/dev/null。
logfile /logs/redis-server.log
# 900秒（15分钟）内至少1个key值改变（则进行数据库保存--持久化）
save 900 1
#当RDB持久化出现错误后，是否依然进行继续进行工作，yes：不能进行工作，no：可以继续进行工作，可以通过info中的rdb_last_bgsave_status了解RDB持久化是否有错误
stop-writes-on-bgsave-error yes
#数据目录，数据库的写入会在这个目录。rdb、aof文件也会写在这个目录
dir /data

从节点配置

除了以上配置项外，从节点还需增加主从相关配置

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

#是否在后台执行，yes：后台运行；no：不是后台运行
daemonize no
#是否开启保护模式，默认开启。要是配置里没有指定bind和密码。开启该参数后，redis只会本地进行访问，拒绝外部访问。
protected-mode no
#redis监听的端口号。
port 6379
#指定 redis 只接收来自于该 IP 地址的请求，如果不进行设置，那么将处理所有请求，或者写成0.0.0.0
#bind 127.0.0.1
#指定了记录日志的文件。空字符串的话，日志会打印到标准输出设备。后台运行的redis标准输出是/dev/null。
logfile /logs/redis-server.log
# 900秒（15分钟）内至少1个key值改变（则进行数据库保存--持久化）
save 900 1
#当RDB持久化出现错误后，是否依然进行继续进行工作，yes：不能进行工作，no：可以继续进行工作，可以通过info中的rdb_last_bgsave_status了解RDB持久化是否有错误
stop-writes-on-bgsave-error yes
#数据目录，数据库的写入会在这个目录。rdb、aof文件也会写在这个目录，下面的文件路径将会挂载出去，自定义。
dir /data

############### 主从复制 ###############

#作为从服务器，默认情况下是只读的（yes），可以修改成NO，用于写（不建议）。
slave-read-only yes
# 设定master的IP和端口号，redis配置文件中的默认端口号是6379
# 低版本的redis这里会是slaveof，意思是一样的，因为slave是比较敏感的词汇，所以在redis后面的版本中不在使用slave的概念，取而代之的是replica
# 将192.168.72.128做为主，其余一台机器做从。ip和端口号按照机器和配置做相应修改。
replicaof 192.168.72.128 6379

启动容器

1
2
3
4
5

docker run -d --name redis --restart=always -p 6379:6379 \
--privileged=true \
 -v /usr/redis/data/:/data \
 -v /usr/redis/redis.conf:/usr/local/etc/redis/redis.conf \
 17a9b6c90ffd redis-server /usr/local/etc/redis/redis.conf

参数说明：

验证主从配置

• 进入到容器中

  1 2 3 4 5 6

  # redis是容器名 docker exec -it redis bash # 进入redis 客户端,这里没设置密码 redis-cli # 查看节点信息 info replication

遇到的问题

• Can’t open the log file: Permission denied
  

  这是因为没给挂载的文件写权限，给整个redis目录赋权就行了

  1	chmod -R 777 /usr/redis

添加哨兵集群配置

哨兵本质上也是redis实例，只是配置不同而已，起到监控redis主从的作用，当主节点挂掉后将从节点提升为主节点，当主节点重新恢复后自动将其作为从节点加入到集群中。起到保证集群高可用的作用

添加配置文件

参考官方配置文件：http://download.redis.io/redis-stable/sentinel.conf

• 修改配置

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

#是否在后台执行，yes：后台运行；no：不是后台运行
daemonize no
#是否开启保护模式，默认开启。要是配置里没有指定bind和密码。开启该参数后，redis只会本地进行访问，拒绝外部访问。
protected-mode no
#redis监听的端口号。
port 6379
#指定 redis 只接收来自于该 IP 地址的请求，如果不进行设置，那么将处理所有请求
#bind 127.0.0.1
#指定了记录日志的文件。空字符串的话，日志会打印到标准输出设备。后台运行的redis标准输出是/dev/null。
logfile /logs/redis-server.log
# 900秒（15分钟）内至少1个key值改变（则进行数据库保存--持久化）
save 900 1
#当RDB持久化出现错误后，是否依然进行继续进行工作，yes：不能进行工作，no：可以继续进行工作，可以通过info中的rdb_last_bgsave_status了解RDB持久化是否有错误
stop-writes-on-bgsave-error yes
#数据目录，数据库的写入会在这个目录。rdb、aof文件也会写在这个目录
dir /data
#设置AOF模式开启（持久化）
appendonly yes

##############哨兵#################

# 最后一个2表示，两台机器判定主被动下线后，就进行failover(故障转移)，quorum是一个数字，指明当有多少个sentinel认为一个master失效时，master才算真正失效
sentinel monitor mymaster 192.168.72.128 6379 2
# 同时监控其他两台哨兵机器
#sentinel auth-pass <master-name> <password>

#这个配置项指定了需要多少失效时间，一个master才会被这个sentinel主观地认为是不可用的。 单位是毫秒，默认为30秒
sentinel down-after-milliseconds mymaster 10000

#failover-timeout 可以用在以下这些方面：     
#1. 同一个sentinel对同一个master两次failover之间的间隔时间。   
#2. 当一个slave从一个错误的master那里同步数据开始计算时间。直到slave被纠正为向正确的master那里同步数据时。    
#3.当想要取消一个正在进行的failover所需要的时间。    
#4.当进行failover时，配置所有slaves指向新的master所需的最大时间。不过，即使过了这个超时，slaves依然会被正确配置为指向master，但是就不按parallel-syncs所配置的规则来了。
sentinel failover-timeout mymaster 180000

• 启动哨兵

  1 2 3 4 5 6

  # 和启动主从类似，只需要把redis-server改为redis-sentinel即可 docker run -d --name redis --restart=always -p 6379:6379 \ --privileged=true -v /usr/redis/data:/data \ -v /usr/redis/config/redis.conf:/usr/local/etc/redis/redis.conf \ -v /usr/redis/logs/redis-server.log:/logs/redis-server.log \ 17a9b6c90ffd redis-sentinel /usr/local/etc/redis/redis.conf

查看哨兵是否启动成功

再次打开哨兵的配置文件，将会看到文件被改写，增加了3台哨兵之间的互相监控配置

验证哨兵的自动故障转移

• 先查看从节点信息
  

• 关闭主节点

  1	docker stop redis

• 等一会再次查看从节点信息
  

从节点自动变成了master节点。实现了自动转移

总结

填写配置文件一定要仔细，挂载文件也要仔细，即使挂载的文件不正确redis也能正常启动并采用默认的配置，导致主从配置不生效

间隔查询（intervals）

7.X的新特性，查询给定词组匹配指定间隔内的文档，例如：太极藿香，将分成 “太极” 和 “藿香”。可以设置两个词之间最多可有多大间隔才能匹配。若间隔设置为2，则“太极藿香正气液”间隔为0，可以匹配。

例：

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

{ "query": { "intervals" : { "name" : { "all_of" : { "ordered" : true, "intervals" : [ { "match" : { "query" : "太极藿香", "max_gaps" : 1, "ordered" : true } }, { "any_of": { "intervals": [ { "match": { "query": "口服液", "max_gaps":-1 } }, { "match": { "query": "匹配任一个", "max_gaps":-1 } } ] } } ] } } } } }

• 顶级参数 intervals

  1 2 3

  "intervals":{ "field":{规则} }

  field: 必填，要搜索的字段名
  值是一个规则字段，字段可选规则如下：

• match规则参数

  按match规则匹配分析文档

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

{
  "query": {
    "intervals" : {
      "name" : {
        "match" : {
              "query" : "太极藿香",
              "ordered": true,
              "max_gaps":1,
              "use_field":"productGeneralName"
        }
      }
    }
  }
}

• prefix 规则参数

  该prefix规则匹配以指定字符集开头的文档，该前缀可以扩展以匹配最多128个词(terms),超过128个返回错误也可以使用index-prefixes限制、

• wildcard 规则参数

  使用通配符模式匹配文档，最多可匹配128个词（terms）,如果超出则返回错误

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

{
  "query": {
    "intervals" : {
      "name" : {
        "wildcard" : {
              "pattern" : "龙胆?*",
              "use_field":"productGeneralName"
        }
      }
    }
  }
}

• all_of规则参数

  多用于嵌套查询，返回同时匹配多个组合规则的文档

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

{
  "query": {
    "intervals" : {
      "name" : {
        "all_of":
        {
          "max_gaps":2,
          "ordered":true,
          "intervals":[
          {
            "match" : {
                "query" : "复方龙胆",
                "use_field":"productGeneralName"
          }
          },
           {
            "match" : {
                "query" : "氢钠碳酸",
                "max_gaps":1,
                "ordered":false,
                "use_field":"productGeneralName"
          }
          }
          ]
        }
      }
    }
  }
}

• any_of规则参数

  返回匹配规则组中任何一组规则的文档

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

{
  "query": {
    "intervals" : {
      "name" : {
        "any_of":
        {
          "intervals":[
          {
            "match" : {
                "query" : "复方龙胆片",
                "ordered":true,
                "max_gaps":0
          }
          },
           {
            "match" : {
                "query" : "太极藿香正气",
                "max_gaps":1,
                "ordered":false,
                "use_field":"productGeneralName"
          }
          }
          ]
        }
      }
    }
  }
}

• filter规则参数

  返回基于查询的时间间隔，详情参考：
  规则文档：https://www.elastic.co/guide/en/elasticsearch/reference/7.3/query-dsl-intervals-query.html#intervals-top-level-params
  间隔过滤器文档：https://www.elastic.co/guide/en/elasticsearch/reference/7.3/query-dsl-intervals-query.html#interval-filter-rule-ex

匹配查询（match）

ES的标准查询，用于匹配搜索的文字，模糊查询

1
2
3
4
5
6
7
8
9
10

GET /_search
{
    "query": {
        "match" : {
            "productName" : {
                "query" : "阿莫西林"
            }
        }
    }
}

首先以query开头，查询方式为match，字段为productName
然后设置字段查询相关属性：

• query（必填）

  查询的内容。

• analyzer（可选，字符串）

  分词器，输入的keywords分词，若不设置则使用索引的分词器

• auto_generate_synonyms_phrase_query（可选，布尔值，默认为true）

  是否开启近义词组合查询

• fuzziness（可选，字符串）

  模糊性，解决一些拼写错误的场景，word 被写成world,那么要把world转换成word只需要将l删除，那么就是一次编辑，距离就是1，经过几次编辑距离就是几。该参数用于设置匹配允许的最大编辑距离，参考：https://www.elastic.co/guide/en/elasticsearch/reference/7.3/common-options.html#fuzziness

• max_expansions（可选，整数，默认50）

  terms查询能扩展的最大数

• prefix_length（可选，整数，默认0）

  为模糊匹配保留的起始字符数，配合fuzziness使用的，保留前几个字符精确匹配，后面的模糊

• transpositions（可选，布尔值，默认true）

  模糊匹配的编辑内容包括两个相邻字符的转置（ab→ba），如wodr转为word只需要转换一次，即为一次编辑，配合fuzziness使用

• fuzzy_rewrite（可选，字符串）

  用于重写查询的方法，配合fuzziness使用

• lenient（可选，布尔值，默认false）

  是否忽略格式错误，例如：数字字段输入字符串

• operator（可选，字符串，默认OR）

  值为OR或AND，比如搜索：i like you 会解析成：i OR like OR you，就是搜索词组是否全部要包含，and将包含所有词，OR只需要包含任一词就行

• minimum_should_match（可选，字符串）

  要返回的文档必须匹配的最小子句数：可填数字，百分比：参考：https://www.elastic.co/guide/en/elasticsearch/reference/7.3/query-dsl-minimum-should-match.html

• zero_terms_query（可选，字符串,默认none）

  指示如果analyzer 删除所有标记（例如使用stop过滤器时），是否不返回任何文档,可选值：none、all，参考：零条件查询

match_bool_prefix 查询

该查询会构造成一组bool组合查询，将最后一个词作为前缀查询.

例如：

1
2
3
4
5
6
7

{
    "query": {
        "match_bool_prefix" : {
            "message" : "quick brown f"
        }
    }
}

以上查询相当于下面的查询：

1
2
3
4
5
6
7
8
9
10
11

{
    "query": {
        "bool" : {
            "should": [
                { "term": { "message": "quick" }},
                { "term": { "message": "brown" }},
                { "prefix": { "message": "f"}}
            ]
        }
    }
}

前面的分词会被作为term查询，相当于普通分词查询，后面的作为前缀查询（prefix），使用should,满足任何一个条件就会命中

匹配词组查询（Match phrase query）

短语匹配，会将输入的搜索词分词后一 一匹配，当所有词语都匹配上时才返回，并且匹配的词语是挨着的(可通过slop调节)。相当于整句匹配

1
2
3
4
5
6
7
8
9
10

{
  "query": {
    "match_phrase": {
      "name": {
        "query": "藿香正气液",
        "slop": 0
      }
    }
  }
}

上面只会返回包含“藿香正气液”整句的文档，可通过slop设置两个词之间的间隔位置（默认0，就是紧挨着），也可analyzer指定分词器。

不调整参数使用默认的可以简写：

1
2
3
4
5
6
7

{
  "query": {
    "match_phrase": {
      "name": "藿香正气液"
    }
  }
}

匹配词组前缀查询

与短语匹配查询（Match phrase query）类似，只不过会把最后一个词作为前缀，类似于补全句子功能，比如：搜索quick brown f 就会匹配到quick brown fox结果，f就是fox的前缀，一般用于即时搜索，用于实时的查询结果。

1
2
3
4
5
6
7
8
9

{
    "query": {
        "match_phrase_prefix" : {
            "message" : {
                "query" : "quick brown f"
            }
        }
    }
}

多匹配查询

该multi_match查询基于该match查询， 以允许多字段查询

1
2
3
4
5
6
7
8

{
  "query": {
    "multi_match" : {
      "query":    "阿莫西林", 
      "fields": [ "name", "productGeneralName" ] 
    }
  }
}

字段可以使用通配符

1
2
3
4
5
6
7
8

{
  "query": {
    "multi_match" : {
      "query":    "阿莫西林", 
      "fields": [ "name", "*Name" ] 
    }
  }
}

可使用“ ^n ”来增强各个字段提升得分，如下面将name得分提高三倍

1
2
3
4
5
6
7
8

{
  "query": {
    "multi_match" : {
      "query":    "阿莫西林", 
      "fields": [ "name^3", "*Name" ] 
    }
  }
}

• multi_match 查询类型

1
2
3
4
5
6
7
8
9
10

{
  "query": {
    "multi_match" : {
      "query":      "Will Smith",
      "type":       "cross_fields",
      "fields":     [ "first_name", "last_name" ],
      "operator":   "and"
    }
  }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

{
  "query": {
    "bool": {
      "should": [
        {
          "multi_match" : {
            "query":      "Will Smith",
            "type":       "cross_fields",
            "fields":     [ "first", "last" ],
            "minimum_should_match": "50%" 
          }
        },
        {
          "multi_match" : {
            "query":      "Will Smith",
            "type":       "cross_fields",
            "fields":     [ "*.edge" ]
          }
        }
      ]
    }
  }
}

bool 查询

组合查询，组合多个查询类型

例子：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

{
  "query": { 
    "bool": { 
      "must": [
        { "match": { "name":   "液"        }},
        { "match": { "productGeneralName": "液" }}
      ],
      "filter": [ 
        { "term":  { "status": "1" }}
      ],
      "should":[{
        "term": {"name": "太极"}
      },{
        "term":{"name":"哟西"}
      }
      ],
      "must_not": [
        {"match": {
          "name": "筋骨"
        }}
      ]
    }
  }
}

结果：

bool采用“更好匹配”的原则，匹配条件越多的分数越高越靠前，must或should子句的得分将加在一起，通过_score返回最终得分，filter上下文中执行的条件（filter和must_not）得分为0

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

{
  "query": { 
    "bool": { 
     
      "filter": [ 
        { "term":  { "status": "1" }}
      ],
      "must_not": [
        {"match": {
          "name": "阿莫西林"
        }}
      ]
    }
  }
}

以上结果得分为0：

Boosting 查询

通过一定规则来影响得分，可以使用boosting查询来降级某些文档，而不必将它们从搜索结果中排除

例：

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

{
    "query": {
        "boosting" : {
            "positive" : {
                "term" : {
                    "text" : "apple"
                }
            },
            "negative" : {
                 "term" : {
                     "text" : "pie"
                }
            },
            "negative_boost" : 0.5
        }
    }
}

• positive(必需)：正向激励，查询出包含”apple”的数据。
• negative(必需)：负向激励，降低包含”pie”的得分，但不会排除
• negative_boost(必需)：降低得分的比重

  假如positive返回的数据得分为2，negative匹配后会将2*0.5 = 1，所以最终得分1，以此降低包含“pie”数据的得分

Constant score 查询（固定得分查询）

包装filter查询（filter的默认得分是0），给匹配的文档赋一个固定的得分

1
2
3
4
5
6
7
8
9
10

{
    "query": {
        "constant_score" : {
            "filter" : {
                "term" : { "user" : "kimchy"}
            },
            "boost" : 1.2
        }
    }
}

• filter（必需）：用于过滤出文档
• boost（可选，默认1.0）： 设置的固定得分

Disjunction max query(最佳匹配查询 or 分离最大化查询)

将任何与任一查询匹配的文档作为结果返回，但只将最佳匹配的评分作为查询的评分结果返回,也就是返回最高的一个得分

例：

1
2
3
4
5
6
7
8
9
10
11

{
    "query": {
        "dis_max" : {
            "queries" : [
                { "term" : { "title" : "Quick pets" }},
                { "term" : { "body" : "Quick pets" }}
            ],
            "tie_breaker" : 0.7
        }
    }
}

• queries（必需的查询对象数组）：包含一个或多个查询子句，并返回匹配分最高的一个得分
• tie_breaker(可选)：值是一个浮点数（0~1.0），该参数的作用是将除最高分外其他几个条件的匹配得分也考虑进去。例如：值为0.2，那么 最终得分= 最高分 + 其他得分 * 0.2

参考链接：https://www.elastic.co/guide/cn/elasticsearch/guide/current/_best_fields.html#_best_fields

Function score 查询 （功能得分查询）

就是为返回的结果计算一个新的得分，包含一个查询和一个或多个函数，这些函数为每个返回的文档计算一个新得分。也能用过滤器对结果的子集 应用不同的函数

例：

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

{
    "query": {
        "function_score": {
            "query": { "match": {
              "name": "太极"
            } },
            "functions": [
              {
                "filter": {"match":{"name":"液"}},
                "random_score": {}
              },
              {
                "filter": {"match":{"name":"通天"}},
                "weight": 50
              }
            ],
            "score_mode":"multiply"
        }
    }
}

如果没有给函数提供过滤器，则等同于指定 “match_all”: {}

• score_mode:指定如何组合计算出的分数

太多了，脑壳痛，参考链接：https://www.elastic.co/guide/en/elasticsearch/reference/7.3/query-dsl-function-score-query.html

添加文档数据

• 构建索引请求

  1 2 3 4 5 6

  IndexRequest request = new IndexRequest("posts"); request.id("1"); //文档ID //数据 String jsonString = "{" + "\"user\":\"kimchy\"," + "\"postDate\":\"2013-01-30\"," + "\"message\":\"trying out Elasticsearch\"" + "}"; request.source(jsonString, XContentType.JSON);

除了JSON字符串还可使用Map和XContentBuilder提供数据，另外还可使用 Object key-pairs 的方式：source(Object… source)

• 其他可选参数

1. 路由设置

   1	request.routing("routing");//指定分片

2. 超时时间设置

   1 2 3 4

   //两种方式均可 //主分片达到可用状态的超时时间 request.timeout(TimeValue.timeValueSeconds(1)); request.timeout("1s");

3. 刷新策略

   1 2 3 4

   //两种方式均可 //刷新策略不设置默认是NONE，不刷新 request.setRefreshPolicy(WriteRequest.RefreshPolicy.WAIT_UNTIL); request.setRefreshPolicy("wait_for");

刷新策略参考：https://blog.csdn.net/hanchao5272/article/details/89151166

4. 版本

   1 2	//常用于并发控制，比如两个人同时修改数据，如何保证自己的操作不会被覆盖？ request.version(2);

5. 版本类型

   1 2 3 4 5

   //两种方式均可 //设置为CREATE则请求会创建数据，如果已存在则会报错 //默认属性是DocWriteRequest.OpType.INDEX,存在则更新，不存在则添加 request.opType(DocWriteRequest.OpType.CREATE); request.opType("create");

6. 设置管道名称

   1	request.setPipeline("pipeline");

• 同步调用

  1	IndexResponse indexResponse = client.index(request, RequestOptions.DEFAULT);

• 异步调用
  先构建监听器

  1 2 3 4 5 6 7 8 9

  listener = new ActionListener<IndexResponse>() { @Override public void onResponse(IndexResponse indexResponse) { //成功的处理逻辑 } @Override public void onFailure(Exception e) { //失败的处理逻辑 } };

然后调用

1

client.indexAsync(request, RequestOptions.DEFAULT, listener);

• 响应结果处理

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

  String index = indexResponse.getIndex(); String id = indexResponse.getId(); if (indexResponse.getResult() == DocWriteResponse.Result.CREATED) { //当数据是insert时的逻辑 } else if (indexResponse.getResult() == DocWriteResponse.Result.UPDATED) { //当数据是update时的逻辑 } ReplicationResponse.ShardInfo shardInfo = indexResponse.getShardInfo(); if (shardInfo.getTotal() != shardInfo.getSuccessful()) { //当成功的分片数少于总分片数的情况处理 } if (shardInfo.getFailed() > 0) { //其他异常处理 for (ReplicationResponse.ShardInfo.Failure failure : shardInfo.getFailures()) { String reason = failure.reason(); } }

• 存在版本冲突报错：ElasticsearchException

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

IndexRequest request = new IndexRequest("posts")
    .id("1")
    .source("field", "value")
    .setIfSeqNo(10L)
    .setIfPrimaryTerm(20);
try {
    IndexResponse response = client.index(request, RequestOptions.DEFAULT);
} catch(ElasticsearchException e) {
    if (e.status() == RestStatus.CONFLICT) {
        
    }
}

版本冲突就会造成报异常，如设置request.opType(DocWriteRequest.OpType.CREATE);后添加了一条已存在的数据。或者设置了setIfSeqNo(10L)等操作

构建索引请求

1

CreateIndexRequest request = new CreateIndexRequest("product");

• 设置分片

  1	request.settings(Settings.builder() .put("index.number_of_shards", 3) .put("index.number_of_replicas", 2) );

• 设置mapping

  1	request.mapping( "{\n" + " \"properties\": {\n" + " \"message\": {\n" + " \"type\": \"text\"\n" + " }\n" + " }\n" + "}", XContentType.JSON);

1
2
3
4
5
6
7
8
9
10

# JSON 参考
{
    "properties": {
        "user": {
              "type": "text",
              "analyzer": "ik_max_word",
              "search_analyzer": "ik_smart"
            }
    }
}

es新版本不再推荐使用Type,这里不再设置type,不设置默认type为：_doc

除了提供JSON字符串设置mapping外还提供了Map和XContentBuilder方式提供

• 索引别名

  在elasticsearch里面给index起一个aliases（别名）能非常优雅的解决两个索引无缝切换的问题。
  比如电商的核心商品索引库，除了实时增量数据外，每天都要重建一遍索引，避免index里面的数据和db里面的数据不一致。全量索引重建完再切换

  1	request.alias(new Alias("product_alias").filter(QueryBuilders.termQuery("user", "kimchy")));

除了单独设置maping()和settings()外还可以调用source（）一次性设置。如下：

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

{ "mappings": { "properties": { "user": { "type": "text", "analyzer": "ik_max_word", "search_analyzer": "ik_smart" }, "title": { "type": "text", "analyzer": "ik_max_word", "search_analyzer": "ik_smart" }, "desc": { "type": "text", "analyzer": "ik_max_word", "search_analyzer": "ik_smart" } } }, "settings" : { "index" : { "number_of_shards" : 2, "number_of_replicas" : 2 } }, "aliases":{ "product_alias":{} } }

索引的其他可选参数

• 设置索引创建的超时时间

  1	request.setTimeout(TimeValue.timeValueMinutes(2));

• 设置连接到master（主节点）的超时时间

  1	request.setMasterTimeout(TimeValue.timeValueMinutes(1));

• 创建索引API返回响应之前要等待的活动分片副本数

  1	request.waitForActiveShards(ActiveShardCount.from(2));

索引请求返回前需要等待多少个分片写入成功

异步请求

• 构建listener监听请求

  1 2 3 4 5 6 7 8 9 10 11

  ActionListener<CreateIndexResponse> listener = new ActionListener<CreateIndexResponse>() { @Override public void onResponse(CreateIndexResponse createIndexResponse) { //请求成功的处理逻辑 } @Override public void onFailure(Exception e) { //请求失败的处理逻辑 } };

• 发送请求并监听

  1	client.indices().createAsync(request, RequestOptions.DEFAULT, listener);

接收处理响应

1
2
3
4

//所以节点是否都成功接收请求
boolean acknowledged = createIndexResponse.isAcknowledged(); 
//在超时之前是否为索引中的每个分片启动了必要数量的分片副本，副本数量就是上面设置的
boolean shardsAcknowledged = createIndexResponse.isShardsAcknowledged();

参考链接：https://www.elastic.co/guide/en/elasticsearch/client/java-rest/7.3/java-rest-high-create-index.html

1、 微服务带来的挑战

• 运维的新挑战
  微服务会导致部署的程序增多，合理的编排很重要
• 接口的一致性
  微服务虽然拆分了，但还是需要通过接口进行业务上的依赖，若接口改变了，需要提供方和调用方协调改动，不然会出现接口不一致问题。
• 分布式的复杂性
  由于拆分各个微服务都是独立运行各自的进程中，可能分布在不同的服务器、不同的地域，它们只能通过网络通信来进行合作，所以要考虑很多因素，如：网络延迟、分布式事务、异步消息、session同步等问题。

2、智能端口与哑管道

在单体应用中通过函数调用，在微服务中由于不在同一进程所以要通过网络调用，如果仅仅是改用RPC调用，会导致微服务之间产生繁琐的通信，使系统表现更为糟糕，所以需要更粗粒的的通信协议。

在微服务中通常采用以下两种调用方式：

• 使用HTTP 的RESTful API 或轻量级消息发送协议
• 通过在轻量级消息总线上传递消息，如：rabbitMQ

3、去中心化

采用微服务后，各个组件通过RESTful 接口进行调用依赖，各个应用组件可以使用自己的数据库，可以使用不同的数据库（如MongoDB），而且不用局限于某一种技术，各个组件都可以选择合适的技术栈，避免出现“杀鸡用牛刀”的局面。

4、容错设计

传统单体应用中，如果需要修改或增加一个功能则要将整个应用重新部署，如果某一组件出现问题就会出现一挂全挂的局面，而微服务架构中某一组件出现问题可以单独下线不影响其他功能使用。

5、为什么选用SpringCloud

一句话：SpringCloud包含微服务的方方面面，大而全、成熟、省心、社区活跃、Spring和Netflix背书。

6、SpringCloud简介

SpringCloud包含多个子项目，还会不断增加：

• SpringCloud Config :配置中心，支持使用git存储配置文件，提高项目配置灵活性

• SpringCloud Netflix: 核心组件，对Netflix OSS开源套件进行组合，包含：

  1. Eureka:注册中心，服务的发现与注册
  2. Hystrix: 容错管理组件，提供降级熔断等保护机制
  3. Ribbon： REST客户端调用组件，提供负载等功能
  4. Feign: 基于 Ribbon： 和 Hystrix的声明式组件调用组件
  5. Zuul: 网管组件，提供智能路由、访问过滤等功能
  6. Archaius: 外部化配置组件

• SpringCloud Bus ： 事件、消息总线

• SpringCloud Cluster: 针对ZooKeeper、Redis、Consul的选举算法和通用状态模式的实现
  ….

1.可读性好，一看泛型就知道里面装的什么类型的元素
2.泛型只在编译前存在，编译后会将类型擦除并替换成其限定类型，编译后就是一个普通类。泛型可以在编译前规范代码，防止放入一些不合格的对象导致运行期报错，提高程序健壮性。
3.使用泛型让程序更灵活，各类框架就大量使用泛型

个人理解：泛型可以大概分为两部分：定义泛型和使用泛型，大多数时候我们是在使用泛型，也就是用具体类型限制，比如：List《String》,而写一些通用工具或者框架的时候需要自己定义泛型类，泛型方法等提高程序的灵活性。

二、定义简单泛型类

例如：

定义泛型类：

1
2
3
4
5
6
7
8
9
10

public class Pair<T>{
    private T first;
    private T second;
    public Pair(){first = null;second = null}
    public pair(T first, T second){
        this.first = first;
        this.second = second;
    }
    //set get 略...
}

类型变量使用大写形式，且比较短，在java库中，E表示集合的元素类型，K和V分别表示Key和值，T表示任意值，也可以使用邻近的U和S

使用泛型：

1

Pair<String>

三、泛型方法

例：

定义泛型方法

1
2
3
4
5

public ArrayAlg {
    public static <T> T getMiddle(T... a){
        return a[a.length / 2];
    }
}

泛型的类型变量放在修饰符的后面（这里是public static） ，返回值的前面，泛型方法可以定义在可以定义在普通类中，也可以定义在泛型类中

使用泛型方法

1

String middle = ArrayAlg.<String>getMiddle("aaa","sss","sdsd");

上面限制了是String，如果放入一个int类型的参数就会报错，大多数情况下《String》可以省略的，编译器会自己推导出限制类型；

1

ArrayAlg.getMiddle("aaa",123,"sdsd");

上面这句代码不会报错，但是编译器推导的限制类型是String 和 Integer公共父类型，如果用String接收返回值会提示：

1

Incompatible types. Required String but 'getMiddle' was inferred to T: Incompatible types: Serializable & Comparable<? extends Serializable & Comparable<?>> is not convertible to String

大概意思是可以赋值给Serializable 或 Comparable类型

四、类型变量的限定

• 我们在定义泛型的时候可以限定其范围：
  如：

  1	public static <T extends Comparable> T min(T[] a)...

我们在使用时就只能使用实现了Comparable接口的类型来限制。

这里是接口但依然使用extends关键字，主要是为了表明是父子关系。不管是类还是接口泛型里都是使用extends

• 一个类型变量或通配符可以有多个限定
  如：

  1	T extends Comparable & Serializable

可以根据需要拥有多个接口超类型，但是限定中至多有一个类，而且这个类必须在列表的第一个

1

T extends class & interface & interface & interface //就像这样的格式，如果有类，放在第一个

五、类型擦除

无论何时定义一个泛型类型，都自动提供一个原始类型，原始类型用第一个限定的类型变量来替换

T 是一个无限定的变量，所以会直接用Object替换，如 private T first 编译后变成 private Object first

如果是

1

<T extends Comparable & Serializable>

则原始类型会用第一个（即Comparable）代替，private Comparable first;

在使用泛型的时候编译器会自动加入强制类型转换，转换成我们给定的类型

如：

1
2

Pair<String> b = ...
String ru = b.getName();

类型擦除后getName返回类型会用Object替换T，编译器会插入String强制类型转换

注意：要考虑类型擦除后带来的隐藏隐患

六、约束与局限性

1、不能用基本类型实例化类型参数

1

如：Pair<int>不行，只能用Pair<Integer>

2、运行时类型查询只适用于原始类型

1
2

例如：if(a instanceof Pair<String>) //报错
     ( Pair<String>) a //强转，报错

3、不能创建参数化类型的数组

1

Pair<String>[] table = new Pair<String>[10];//报错，声明不会报错，但初始化就会报错

4、不能实例化类型变量

如：new T[]

5、不能构造泛型数组

如：T[]

6、泛型类的静态上下文中类型变量无效

如：private static T abc;//报错

7、不能抛出或捕获泛型类的实例

如：

1
2
3
4
5

try{

}catch(T e){

}

不过，在异常规范中使用类型变量是允许的

1
2
3
4
5
6
7
8
9

public static <T extends Throwable> void doWork(T t) thows T{//ok
    try{

    }catch(Throwable realCause){
        t.initCause(realCause);
        throw t;
    }

}

8、注意泛型的继承

1
2

 A extends B
Pair<B> 不是 Pair<A>  的子类，会类型擦除的

七、通配符类型

能一定程度解决上面泛型不能继承的问题

1

Pair<? extends B>

如果调用上面方法的set方法会报错，不能设置值，因为不能确定是什么类型的值，可以get

• ? extends B 不能设置值，如果是集合（如List）就不能添加值。因为不能到是什么类型的值，但是能获取值，获取的值一定是B的子类，可以用B接收

• ？ super B 不能获取值，能设置/添加值，因为一定是B的子类，不能获取值，如果获取出来用什么接收呢？因为类型不确定。

• ？ 不能添加也不能获取，道理同上，但是能加入null，因为对象都能表示为null

八、反射和泛型

未完。。

Lambda不是所有方法都能使用的，得满足一定的条件，比如得满足函数式接口。

对于只有一个抽象方法的接口，需要这种借口的对象时，就可以提供一个Lambda表达式，这种接口称为函数式接口，也就是只有一个抽象方法的接口（不包括继承的）

函数式接口其实本质上还是一个接口，但是它是一种特殊的接口：SAM类型的接口（Single Abstract Method）。定义了这种类型的接口，使得以其为参数的方法，可以在调用时，使用一个lambda表达式作为参数。从另一个方面说，一旦我们调用某方法，可以传入lambda表达式作为参数，则这个方法的参数类型，必定是一个函数式的接口，(这个类型可以使用@FunctionalInterface进行修饰，好处是，如果无意中增加了方法或者不符合lambda接口规范，编译器会提示错误，另外javadoc中会指出是一个函数式接口，推荐使用注解

　　从SAM原则上讲，这个接口中， 只能有一个函数需要被实现 ，但是也可以有如下例外:

　　　　1. 默认方法与静态方法并不影响函数式接口的契约，可以任意使用，即

　　　　　　函数式接口中可以有静态方法，一个或者多个静态方法不会影响SAM接口成为函数式接口，并且静态方法可以提供方法实现

　　　　　　可以由 default 修饰的默认方法方法，这个关键字是Java8中新增的，为的目的就是使得某一些接口，原则上只有一个方法被实现，但是由于历史原因，不得不加入一些方法来兼容整个JDK中的API，所以就需要使用default关键字来定义这样的方法

Lambda语法

一例胜千言

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

 // =====Lambda
 //这里省略list的构造
List<String> names = ...;
Collections.sort(names, (o1, o2) -> o1.compareTo(o2));
 
 //===原始形态

//这里省略list的构造
List<String> names = ...;
Collections.sort(names, new Comparator<String>() {
  @Override
  public int compare(String o1, String o2) {
    return o1.compareTo(o2);
  }
});

完整一般语法：

1
2
3
4
5
6

(Type1 param1, Type2 param2, ..., TypeN paramN) -> {
  statment1;
  statment2;
  //.............
  return statmentM;
}

1. 参数类型省略–绝大多数情况，编译器都可以从上下文环境中推断出lambda表达式的参数类型。这样lambda表达式就变成了：

1
2
3
4
5
6

(param1,param2, ..., paramN) -> {
  statment1;
  statment2;
  //.............
  return statmentM;
}

2. 当lambda表达式的参数个数只有一个，可以省略小括号。lambda表达式简写为：

1
2
3
4
5
6

param1 -> {
  statment1;
  statment2;
  //.............
  return statmentM;
}

3. 当lambda表达式只包含一条语句时，可以省略大括号、return和语句结尾的分号。

   1	param1 -> statme

方法的引用

个人理解：上面的Lambda有点像是实现匿名内部类的一个简化版本，我们需要传入代码以实现函数式接口内的那个抽象方法，方法引用有点像是引用其他已经实现好的方法。我们就不用再实现了（当然得看引用的方法满不满足需求）

方法引用：

objectName::instanceMethod (对象.方法名)
ClassName::staticMethod (类名.静态方法)
ClassName::instanceMethod

前两种方式类似，等同于把lambda表达式的参数直接当成instanceMethod|staticMethod的参数来调用。比如System.out::println等同于x->System.out.println(x)；Math::max等同于(x, y)->Math.max(x,y)。

最后一种方式（类名+非静态方法），等同于把lambda表达式的第一个参数当成instanceMethod的目标对象，其他剩余参数当成该方法的参数。比如String::toLowerCase等同于x->x.toLowerCase()。

构造器引用

构造器引用语法如下：构造器引用和方法引用有点类似，只不过方法名为new,如：ClassName::new，把lambda表达式的参数当成ClassName构造器的参数 。例如BigDecimal::new等同于x->new BigDecimal(x)。

可以用数组类型建立构造器引用：
int[] :: new
他有一个参数即数组长度
等价于Lambda : x -> new int[x]

变量的作用域

Lambda表达式也可访问外部的变量(参考内部类)

lambda表达式的三个重要组成部分：

• 输入参数
• 可执行语句
• 自由变量的值，这是指非参数而且不在代码中定义的变量

1
2
3
4

String[] array = {"a", "b", "c"};
for(Integer i : Lists.newArrayList(1,2,3)){
  Stream.of(array).map(item -> Strings.padEnd(item, i, '@')).forEach(System.out::println);
}

上面的这个例子中，map中的lambda表达式访问外部变量Integer i。

不过lambda表达式访问外部变量有一个非常重要的限制：变量不可变（java是值传递，也就是说基本类型值不能变，只是引用不可变，而不是真正的不可变)可以参考内部类引用外部变量也是必须用final声明，不过在Lambda中编译器会隐式的当做final处理，不加fina也可以

1
2
3
4
5

String[] array = {"a", "b", "c"};
for(int i = 1; i<4; i++){
  Stream.of(array).map(item -> Strings.padEnd(item, i, '@')).forEach(System.out::println);
}

上面这个要报错

Lambda中的this

在lambda中，this不是指向lambda表达式产生的那个SAM对象，而是声明它的外部对象。

处理（接收）Lambda表达式

上面我们已经了解和使用了Lambda表达式，下面讨论下怎么接收处理Lambda表达式

使用Lambda的重点是延迟执行，像需要多次运行的场景就适合使用，jdk提供了很多常用的函数式接口，所以在自定义方法时可以使用这些函数式接口，不用自己再创建接口。还有一些基本类型的函数式接口，减少int double等的自动开装箱。

Go使用package来组织代码。每一个可独立运行的Go程序，必定包含一个package main，在这个main包中必定包含一个入口函数main，而这个函数既没有参数，也没有返回值。Go使用UTF-8字符串和标识符(因为UTF-8的发明者也就是Go的发明者之一)，所以它天生支持多语言。

1、http无状态协议

　　web应用采用browser/server架构，http作为通信协议。http是无状态协议，浏览器的每一次请求，服务器会独立处理，不与之前或之后的请求产生关联，这个过程用下图说明，三次请求/响应对之间没有任何联系

　　但这也同时意味着，任何用户都能通过浏览器访问服务器资源，如果想保护服务器的某些资源，必须限制浏览器请求；要限制浏览器请求，必须鉴别浏览器请求，响应合法请求，忽略非法请求；要鉴别浏览器请求，必须清楚浏览器请求状态。既然http协议无状态，那就让服务器和浏览器共同维护一个状态吧！这就是会话机制

2、会话机制

　　浏览器第一次请求服务器，服务器创建一个会话，并将会话的id作为响应的一部分发送给浏览器，浏览器存储会话id，并在后续第二次和第三次请求中带上会话id，服务器取得请求中的会话id就知道是不是同一个用户了，这个过程用下图说明，后续请求与第一次请求产生了关联

　　服务器在内存中保存会话对象，浏览器怎么保存会话id呢？你可能会想到两种方式

1.请求参数
2.cookie

　　将会话id作为每一个请求的参数，服务器接收请求自然能解析参数获得会话id，并借此判断是否来自同一会话，很明显，这种方式不靠谱。那就浏览器自己来维护这个会话id吧，每次发送http请求时浏览器自动发送会话id，cookie机制正好用来做这件事。cookie是浏览器用来存储少量数据的一种机制，数据以”key/value“形式存储，浏览器发送http请求时自动附带cookie信息

　　tomcat会话机制当然也实现了cookie，访问tomcat服务器时，浏览器中可以看到一个名为“JSESSIONID”的cookie，这就是tomcat会话机制维护的会话id，使用了cookie的请求响应过程如下图

3、登录状态

　　有了会话机制，登录状态就好明白了，我们假设浏览器第一次请求服务器需要输入用户名与密码验证身份，服务器拿到用户名密码去数据库比对，正确的话说明当前持有这个会话的用户是合法用户，应该将这个会话标记为“已授权”或者“已登录”等等之类的状态，既然是会话的状态，自然要保存在会话对象中，tomcat在会话对象中设置登录状态如下

1
2

HttpSession session = request.getSession();
session.setAttribute("isLogin", true);

　　用户再次访问时，tomcat在会话对象中查看登录状态

1
2

HttpSession session = request.getSession();
session.getAttribute("isLogin");

　　每次请求受保护资源时都会检查会话对象中的登录状态，只有 isLogin=true 的会话才能访问，登录机制因此而实现。

二、多系统的复杂性

　　web系统早已从久远的单系统发展成为如今由多系统组成的应用群，面对如此众多的系统，用户难道要一个一个登录、然后一个一个注销吗？

　　web系统由单系统发展成多系统组成的应用群，复杂性应该由系统内部承担，而不是用户。无论web系统内部多么复杂，对用户而言，都是一个统一的整体，也就是说，用户访问web系统的整个应用群与访问单个系统一样，登录/注销只要一次就够了

　　虽然单系统的登录解决方案很完美，但对于多系统应用群已经不再适用了，为什么呢？

　　单系统登录解决方案的核心是cookie，cookie携带会话id在浏览器与服务器之间维护会话状态。但cookie是有限制的，这个限制就是cookie的域（通常对应网站的域名），浏览器发送http请求时会自动携带与该域匹配的cookie，而不是所有cookie

　　既然这样，为什么不将web应用群中所有子系统的域名统一在一个顶级域名下，例如” ☀.baidu.com “，然后将它们的cookie域设置为“baidu.com”，这种做法理论上是可以的，甚至早期很多多系统登录就采用这种同域名共享cookie的方式。

　　然而，可行并不代表好，共享cookie的方式存在众多局限。首先，应用群域名得统一；其次，应用群各系统使用的技术（至少是web服务器）要相同，不然cookie的key值（tomcat为JSESSIONID）不同，无法维持会话，共享cookie的方式是无法实现跨语言技术平台登录的，比如java、php、.net系统之间；第三，cookie本身不安全。

　　因此，我们需要一种全新的登录方式来实现多系统应用群的登录，这就是单点登录

三、单点登录

　　什么是单点登录？单点登录全称Single Sign On（以下简称SSO），是指在多系统应用群中登录一个系统，便可在其他所有系统中得到授权而无需再次登录，包括单点登录与单点注销两部分

1、登录

　　相比于单系统登录，sso需要一个独立的认证中心，只有认证中心能接受用户的用户名密码等安全信息，其他系统不提供登录入口，只接受认证中心的间接授权。间接授权通过令牌实现，sso认证中心验证用户的用户名密码没问题，创建授权令牌，在接下来的跳转过程中，授权令牌作为参数发送给各个子系统，子系统拿到令牌，即得到了授权，可以借此创建局部会话，局部会话登录方式与单系统的登录方式相同。这个过程，也就是单点登录的原理，用下图说明

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

用户访问系统1的受保护资源，系统1发现用户未登录，跳转至sso认证中心，并将自己的地址作为参数
sso认证中心发现用户未登录，将用户引导至登录页面
用户输入用户名密码提交登录申请
sso认证中心校验用户信息，创建用户与sso认证中心之间的会话，称为全局会话，同时创建授权令牌
sso认证中心带着令牌跳转会最初的请求地址（系统1）
系统1拿到令牌，去sso认证中心校验令牌是否有效
sso认证中心校验令牌，返回有效，注册系统1
系统1使用该令牌创建与用户的会话，称为局部会话，返回受保护资源
用户访问系统2的受保护资源
系统2发现用户未登录，跳转至sso认证中心，并将自己的地址作为参数
sso认证中心发现用户已登录，跳转回系统2的地址，并附上令牌
系统2拿到令牌，去sso认证中心校验令牌是否有效
sso认证中心校验令牌，返回有效，注册系统2
系统2使用该令牌创建与用户的局部会话，返回受保护资源

　　用户登录成功之后，会与sso认证中心及各个子系统建立会话，用户与sso认证中心建立的会话称为全局会话，用户与各个子系统建立的会话称为局部会话，局部会话建立之后，用户访问子系统受保护资源将不再通过sso认证中心，全局会话与局部会话有如下约束关系

1
2
3

局部会话存在，全局会话一定存在
全局会话存在，局部会话不一定存在
全局会话销毁，局部会话必须销毁

　　你可以通过博客园、百度、csdn、淘宝等网站的登录过程加深对单点登录的理解，注意观察登录过程中的跳转url与参数

2、注销

　　单点登录自然也要单点注销，在一个子系统中注销，所有子系统的会话都将被销毁，用下面的图来说明

3b139d2e-0b83-4a69-b4f2-316adb8997ce

　　sso认证中心一直监听全局会话的状态，一旦全局会话销毁，监听器将通知所有注册系统执行注销操作

1
2
3
4
5
6

用户向系统1发起注销请求
系统1根据用户与系统1建立的会话id拿到令牌，向sso认证中心发起注销请求
sso认证中心校验令牌有效，销毁全局会话，同时取出所有用此令牌注册的系统地址
sso认证中心向所有注册系统发起注销请求
各注册系统接收sso认证中心的注销请求，销毁局部会话
sso认证中心引导用户至登录页面

四、部署图

　　单点登录涉及sso认证中心与众子系统，子系统与sso认证中心需要通信以交换令牌、校验令牌及发起注销请求，因而子系统必须集成sso的客户端，sso认证中心则是sso服务端，整个单点登录过程实质是sso客户端与服务端通信的过程

　　sso认证中心与sso客户端通信方式有多种，这里以简单好用的httpClient为例，web service、rpc、restful api都可以

五、实现

　　只是简要介绍下基于java的实现过程，不提供完整源码，明白了原理，我相信你们可以自己实现。sso采用客户端/服务端架构，我们先看sso-client与sso-server要实现的功能（下面：sso认证中心=sso-server）

　　sso-client

1
2
3
4
5
6

拦截子系统未登录用户请求，跳转至sso认证中心
接收并存储sso认证中心发送的令牌
与sso-server通信，校验令牌的有效性
建立局部会话
拦截用户注销请求，向sso认证中心发送注销请求
接收sso认证中心发出的注销请求，销毁局部会话

　　sso-server

1
2
3
4
5
6
7

验证用户的登录信息
创建全局会话
创建授权令牌
与sso-client通信发送令牌
校验sso-client令牌有效性
系统注册
接收sso-client注销请求，注销所有会话

　　接下来，我们按照原理来一步步实现sso吧！

1、sso-client拦截未登录请求

　　java拦截请求的方式有servlet、filter、listener三种方式，我们采用filter。在sso-client中新建LoginFilter.java类并实现Filter接口，在doFilter()方法中加入对未登录用户的拦截

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

public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
    HttpServletRequest req = (HttpServletRequest) request;
    HttpServletResponse res = (HttpServletResponse) response;
    HttpSession session = req.getSession();

    if (session.getAttribute("isLogin")) {
        chain.doFilter(request, response);
        return;
    }
    //跳转至sso认证中心
    res.sendRedirect("sso-server-url-with-system-url");
}

2、sso-server拦截未登录请求

　　拦截从sso-client跳转至sso认证中心的未登录请求，跳转至登录页面，这个过程与sso-client完全一样

3、sso-server验证用户登录信息

　　用户在登录页面输入用户名密码，请求登录，sso认证中心校验用户信息，校验成功，将会话状态标记为“已登录”

1
2
3
4
5
6

@RequestMapping("/login")
public String login(String username, String password, HttpServletRequest req) {
    this.checkLoginInfo(username, password);
    req.getSession().setAttribute("isLogin", true);
    return "success";
}

4、sso-server创建授权令牌

　　授权令牌是一串随机字符，以什么样的方式生成都没有关系，只要不重复、不易伪造即可，下面是一个例子

1

String token = UUID.randomUUID().toString();

5、sso-client取得令牌并校验

　　sso认证中心登录后，跳转回子系统并附上令牌，子系统（sso-client）取得令牌，然后去sso认证中心校验，在LoginFilter.java的doFilter()中添加几行

1
2
3
4
5
6
7
8
9
10
11

// 请求附带token参数
String token = req.getParameter("token");
if (token != null) {
    // 去sso认证中心校验token
    boolean verifyResult = this.verify("sso-server-verify-url", token);
    if (!verifyResult) {
        res.sendRedirect("sso-server-url");
        return;
    }
    chain.doFilter(request, response);
}

　　verify()方法使用httpClient实现，这里仅简略介绍，httpClient详细使用方法请参考官方文档

1
2

HttpPost httpPost = new HttpPost("sso-server-verify-url-with-token");
HttpResponse httpResponse = httpClient.execute(httpPost);

6、sso-server接收并处理校验令牌请求

　　用户在sso认证中心登录成功后，sso-server创建授权令牌并存储该令牌，所以，sso-server对令牌的校验就是去查找这个令牌是否存在以及是否过期，令牌校验成功后sso-server将发送校验请求的系统注册到sso认证中心（就是存储起来的意思）

　　令牌与注册系统地址通常存储在key-value数据库（如redis）中，redis可以为key设置有效时间也就是令牌的有效期。redis运行在内存中，速度非常快，正好sso-server不需要持久化任何数据。

　　令牌与注册系统地址可以用下图描述的结构存储在redis中，可能你会问，为什么要存储这些系统的地址？如果不存储，注销的时候就麻烦了，用户向sso认证中心提交注销请求，sso认证中心注销全局会话，但不知道哪些系统用此全局会话建立了自己的局部会话，也不知道要向哪些子系统发送注销请求注销局部会话

7、sso-client校验令牌成功创建局部会话

　　令牌校验成功后，sso-client将当前局部会话标记为“已登录”，修改LoginFilter.java，添加几行

1
2
3

if (verifyResult) {
    session.setAttribute("isLogin", true);
}

　　sso-client还需将当前会话id与令牌绑定，表示这个会话的登录状态与令牌相关，此关系可以用java的hashmap保存，保存的数据用来处理sso认证中心发来的注销请求

8、注销过程

　　用户向子系统发送带有“logout”参数的请求（注销请求），sso-client拦截器拦截该请求，向sso认证中心发起注销请求

1
2
3
4

String logout = req.getParameter("logout");
if (logout != null) {
    this.ssoServer.logout(token);
}

　　sso认证中心也用同样的方式识别出sso-client的请求是注销请求（带有“logout”参数），sso认证中心注销全局会话

1
2
3
4
5
6
7
8

@RequestMapping("/logout")
public String logout(HttpServletRequest req) {
    HttpSession session = req.getSession();
    if (session != null) {
        session.invalidate();//触发LogoutListener
    }
    return "redirect:/";
}

　　sso认证中心有一个全局会话的监听器，一旦全局会话注销，将通知所有注册系统注销

1
2
3
4
5
6
7
8

public class LogoutListener implements HttpSessionListener {
    @Override
    public void sessionCreated(HttpSessionEvent event) {}
    @Override
    public void sessionDestroyed(HttpSessionEvent event) {
        //通过httpClient向所有注册系统发送注销请求
    }
}

首先，要对异常有一个清晰的认识，刚学JAVA那会儿对异常的了解很是朦胧，只知道try catch 可以捕获异常，可以输出异常。打印出异常信息，对何时应该捕获，何时抛异常并不在乎。知道上班后才渐渐的对异常处理重视起来。
一个程序不可能不出异常情况，关键在于我们能尽可能的预见将要发生的异常并提前对可能发生的异常进行处理，提高程序的健壮性。（PS:今天看了猩球崛起3，有点失望）

Spring提供了多种方式将异常转换为响应：

• 特定的Spring异常将会自动映射为指定的HTTP状态码；
• 异常上可以添加@ResponseStatus注解，从而将其映射为某一个HTTP状态码；
• 在方法上可以添加@ExceptionHandler注解，使其用来处理异常

2.将异常映射为HTTP状态码

以上这些状态码是Spring默认使用的异常及对应状态码，我们也可自己映射到状态码用@ResponseStatus注解
例如：

1
2
3
4
5
6
7

import org.springframework.http.HttpStatus;
import org.springframework.web.bind.annotation.ResponseStatus;

@ResponseStatus(value=HttpStatus.NOT_FOUND/*404*/, reason="找不到页面")
public class SpittleNotFoundException extends RuntimeException {

}

3.编写异常处理方法

将异常映射为状态码是一个简单易用的处理方案，但是在实际开放中我们除了要返回状态码还要返回错误信息和其他一些参数，上面这种方案显然不够用。所以我们得捕获异常并返回错误信息

最常见的方式是，在每个请求的方法里捕获异常并返回相应的错误信息，JSON数据或者跳转到错误页面

也可以在每个Controller里写一个公用的方法来统一处理异常，并用@ExceptionHandler标注，这样，当有@RequestMapping的方法发生异常时，@ExceptionHandler标注的方法就会捕捉到你指定的异常并执行方法，
当然，也可以将这个异常方法写到一个BaseController里，其他Controller继承这个BaseController，甚至可以写一个全局的异常处理类，可以根据具体业务采取具体的方案

4.@ControllerAdvice为控制器添加通知

控制器通知（controller advice）是任意带有@ControllerAdvice注解的类，这个类会包含一个或多个如下类型的方法：

来一个个看：

@ExceptionHandler注解标注的方法；

有@RequestMapping的方法发生异常时会执行;

@InitBinder注解标注的方法；

前台传过来的参数都是String类型的，有些参数不能自动转换，比如Date，需要使用@initBinder注解为binder提供一个数据的转换器，这个转换器可以自己实现，也可以用spring官方的一些实现。

写个Double类型转换器

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

import org.springframework.beans.propertyeditors.PropertiesEditor;  

public class DoubleEditor extends PropertiesEditor {    
    @Override    
    public void setAsText(String text) throws IllegalArgumentException {    
        if (text == null || text.equals("")) {    
            text = "0";    
        }    
        setValue(Double.parseDouble(text));    
    }    

    @Override    
    public String getAsText() {    
        return getValue().toString();    
    }    
}

然后用@InitBinder注册

1
2
3
4
5

@InitBinder    
   protected void initBinder(WebDataBinder binder) {    
       binder.registerCustomEditor(Date.class, new CustomDateEditor(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"), true));//时间转换  
       binder.registerCustomEditor(double.class, new DoubleEditor());   //Double转换
   }

@ModelAttribute注解标注的方法。

被@ModelAttribute注释的方法会在此controller每个方法执行前被执行。

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

@Controller  
public class HelloModelController {  

    @ModelAttribute   
    public void populateModel(@RequestParam String abc, Model model) {    
       model.addAttribute("attributeName", abc);    
    }    

    @RequestMapping(value = "/helloWorld")    
    public String helloWorld() {    
       return "helloWorld.jsp";    
    }    

}

访问控制器方法helloWorld时，会首先调用populateModel方法，将页面参数abc(/helloWorld.ht?abc=text)放到model的attributeName属性中，在视图中可以直接访问。

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

@Controller  
public class Hello2ModelController {  

    @ModelAttribute   
    public User populateModel() {    
       User user=new User();  
       user.setAccount("ray");  
       return user;  
    }    
    @RequestMapping(value = "/helloWorld2")    
    public String helloWorld() {    
       return "helloWorld.jsp";    
    }    
}

前台可以通过user获取参数，如：${user.account}

在带有@ControllerAdvice注解的类中，以上所述的这些方法会运用到整个应用程序所有控制器中带有@RequestMapping注解的方法上。

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

@ControllerAdvice
public class AdviceHandler {

   /**
     * 全局异常处理
     */
    @ExceptionHandler({ UnauthenticatedException.class, AuthenticationException.class })
    @ResponseBody
    public ResponseData authenticationException(HttpServletRequest request, HttpServletResponse response) {
        // 输出JSON
        ResponseData res = new ResponseData();
        res.setCode(888).setMsg("未登录");
        return res;
    }
    /**
    *全局转换器
    */
    @InitBinder    
     protected void initBinder(WebDataBinder binder) {    
         binder.registerCustomEditor(Date.class, new CustomDateEditor(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"), true));//时间转换  
         binder.registerCustomEditor(double.class, new DoubleEditor());   //Double转换
     }
     /**
     *全局返回数据
     */
     @ModelAttribute   
     public User populateModel() {    
        User user=new User();  
        user.setAccount("ray");  
        return user;  
     }
}

5.URL重定向传参

通过URL传参

如果username属性的值是habuma并且spitterId属性的值是42，
那么结果得到的重定向URL路径将会是“/spitter/habuma?
spitterId=42”。

使用flash属性

略。。参考Spring in Action 第四版 7.5

文件上传我一直感觉是个麻烦事，一提到文件上传我脑海中浮现的是二进制、byte数组、输入输出流、读写文件
感觉头都大了，所以为了以后不再头大，正好最近在看Spring in Action 正好研究下，用各种姿势上传文件。传各种小黄片^-^。

1.Spring MVC中配置文件上传

下面是我随手上传一张图片的请求体：

1
2
3
4
5
6

------WebKitFormBoundaryiYXA5UiOJRgWnKnt
Content-Disposition: form-data; name="upfile"; filename="0.jpg"
Content-Type: image/jpeg


------WebKitFormBoundaryiYXA5UiOJRgWnKnt--

DispatcherServlet并没有实现任何解析multipart请求数据的功能。它将该任务委托给了Spring中MultipartResolver策略接口的实现，通过这个实现类来解析multipart请求中的内容。从Spring 3.1开始，Spring内置了两个MultipartResolver的实现供我们选择：

• CommonsMultipartResolver：使用Jakarta CommonsFileUpload解析multipart请求；
• StandardServletMultipartResolver：依赖于Servlet 3.0对multipart请求的支持（始于Spring 3.1）。

一般优选StandardServletMultipartResolver,不过为什么我更喜欢StandardServletMultipartResolver呢？

使用Servlet 3.0解析multipart请求（StandardServletMultipartResolver）

在Spring应用上下文中，将其声明为bean就会非常简单，如下所示：

1
2
3
4

@Bean
public MultipartResolver multipartResolver() throws IOException{
  return new StandardServletMultipartResolver();
}

上面配置还不能正常使用，我们还需要设置存放路径，限制文件大小、类型等
我们需在web.xml或Servlet初始化类中配置。
如果我们采用Servlet初始化类的方式来配置DispatcherServlet的话，这个初始化类应该已经实现了WebApplicationInitializer，那我们可以在Servlet registration上调用setMultipartConfig()方法，传入一
个MultipartConfigElement实例，

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

@Override
protected void customizeRegistration(Dynamic registration){
  registration.setMultipartConfig (
  new MultipartConfigElement(
            "/tem/uploads",//路径
            2097152,  //上传文件的最大容量（以字节为单位）。默认是没有限制的。
            4194304,  //整个multipart请求的最大容量（以字节为单位），默认是没有限制的
            0 //在上传的过程中，如果文件大小达到了一个指定最大容量（以字
              //节为单位），将会写入到临时文件路径中。默认值为0，也就是
              //所有上传的文件都会写入到磁盘上
  )
  );
}

配置类参考SpringMVC起步-构建Web应用程序

如果使用传统的xml配置，则在web.xml中配置如下：

使用Jakarta Commons FileUpload multipart解析器

Spring内置了CommonsMultipartResolver，可以作为StandardServletMultipartResolver的替代方案

将CommonsMultipartResolver声明为Spring bean的最简单方式如下：

2.处理multipart 请求（接收上传文件）

• 表单上设置enctype=multipart/form-data,也就是说Content-Type:multipart/form-data;
• 控制器接收参数上添加@RequestPart注解
  

这种用数组接收的方式很原始，没用文件类型，文件名等等，还要自己写流存文件。

接收MultipartFile

将数组换成MultipartFile接收，内置方法如下：

将MultipartFile保存到七牛云，阿里云等云存储中

也就是利用MultipartFile获取文件信息保存到远程服务器，暂不写

Part接口：Spring MultipartFile的替代方案

和上面的API差不多，值得一提的是，如果在编写控制器方法的时候，通过Part参数的形式
接受文件上传，那么就没有必要配置MultipartResolver了。只有使用MultipartFile的时候，我们才需要
MultipartResolver。

3.上传案列

下面是我在项目中随手写的一个上传文件类，本来项目使用的是百度的Ueditor上传文件，但是Ueditor是上传文件到项目的目录下面，每次部署war包都会覆盖原来的上传文件，必须先备份上传的文件，部署完项目后又重新传上去，很是麻烦。由于是前后端分离，前端静态资源部署在Nginx所以自己写了个上传请求将文件传到Nginx目录下边。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112

@Controller
@Api(tags="文件上传")
@RequestMapping("/file")
public class FileUploadController {
    /**文件存放主路径*/
    @Value("${cnct.upload.file.path}")
    private String baseFilePath;
    /**系统路径分隔符*/
    public static final String FILE_SEPARATOR = System.getProperty("file.separator");
    /**文件访问前缀，一般为Nginx路径*/
    @Value("${cnct.request.file.path}")
    private String requestFilePath;

    /**
     * 多文件上传
     * @param request
     * @return
     */
    @RequestMapping("/multipleFileUpload")
    @ResponseBody
    public List<Map<String, Object>> multipleFileUpload(HttpServletRequest request){
        List<Map<String,Object>> res = new ArrayList<>();
        List<MultipartFile> files = ((MultipartHttpServletRequest) request).getFiles("file");
        if(files == null || files.size() == 0){
            return null;
        }
        for(MultipartFile file : files){//遍历存文件
            Map<String,Object> map = new HashMap<>();
            try {
            // 截取上传文件的文件名
            String uploadFilePath = file.getOriginalFilename();
            String fileName = uploadFilePath
                    .substring(uploadFilePath.lastIndexOf('\\') + 1,
                            uploadFilePath.indexOf('.'));
            // 截取上传文件的后缀
            String suffixName = uploadFilePath.substring(
                    uploadFilePath.indexOf('.'), uploadFilePath.length());
            String filePath = baseFilePath + new DateTime().getYear()+FILE_SEPARATOR +new DateTime().getMonthOfYear()+FILE_SEPARATOR +new DateTime().getDayOfMonth();
            String realFileName = String.valueOf(new DateTime().getMillis()) + suffixName;
            File f = new File(filePath+FILE_SEPARATOR+realFileName);

            if(!f.getParentFile().exists()){
                f.getParentFile().mkdirs();
            }
                f.createNewFile();
                file.transferTo(f);
                map.put("original",fileName+suffixName);
                map.put("size",file.getSize());
                map.put("state","SUCCESS");
                map.put("title",realFileName);
                map.put("type",suffixName);
                map.put("url",requestFilePath+new DateTime().getYear()+
                        "/" +new DateTime().getMonthOfYear()+
                        "/" +new DateTime().getDayOfMonth()+
                        "/" +realFileName);
            } catch (IOException e) {
                System.err.println("文件不存在或者文件无权限");
                map.put("state","ERROR");
                e.printStackTrace();
            }
            res.add(map);
        }
        return res;
    }
    /**
     * 单文件上传
     * @param file
     * @return
     */
    @RequestMapping("/singleFileUpload")
    @ResponseBody
    public Map<String , Object> singleFileUpload(MultipartFile file){
        Map<String,Object> res = new HashMap<>();
        try {
        if (file.isEmpty()) {
            res.put("state","ERROR");
            return res;
        }
        // 截取上传文件的文件名
        String uploadFilePath = file.getOriginalFilename();
        String fileName = uploadFilePath
                .substring(uploadFilePath.lastIndexOf('\\') + 1,
                        uploadFilePath.indexOf('.'));
        // 截取上传文件的后缀
        String suffixName = uploadFilePath.substring(
                uploadFilePath.indexOf('.'), uploadFilePath.length());
        String filePath = baseFilePath + new DateTime().getYear()+FILE_SEPARATOR +new DateTime().getMonthOfYear()+FILE_SEPARATOR +new DateTime().getDayOfMonth();
        String realFileName = String.valueOf(new DateTime().getMillis()) + suffixName;
        File f = new File(filePath+FILE_SEPARATOR+realFileName);

            if(!f.getParentFile().exists()){
                f.getParentFile().mkdirs();
            }
            f.createNewFile();
            file.transferTo(f);
            res.put("original",fileName+suffixName);
            res.put("size",file.getSize());
            res.put("state","SUCCESS");
            res.put("title",realFileName);
            res.put("type",suffixName);
            res.put("url",requestFilePath+new DateTime().getYear()+
                    "/" +new DateTime().getMonthOfYear()+
                    "/" +new DateTime().getDayOfMonth()+
                    "/" +realFileName);
        } catch (IOException e) {
            System.err.println("文件不存在或者文件无权限");
            res.put("state","ERROR");
            e.printStackTrace();
        }
        return res;
    }
}

项目并发量不大，所以代码没过多优化设计。项目使用的是SpringBoot
spring:
http:
multipart:
max-file-size: 100MB
max-request-size: 100MB
enabled: true
SpringBoot大发好，multipart都不需要配那么多那么麻烦，真是浪费生命

上一篇讲到SpringMVC执行流程，DispatcherServlet会将模型和视图名交给视图解析器来解析生成响应视图

Spring MVC定义了一个名为ViewResolver的接口，它大致如下所示：

1
2
3

public interface ViewResolver{
  View resolveViewName(String viewName, Locale locale) throws Exception;
}

当给resolveViewName()方法传入一个视图名和Locale对象时，
它会返回一个View实例。View是另外一个接口，如下所示：

Locale对象，以便于恰当地格式化地域
相关的值，如日期和货币。信息标签可以借助Spring的信息资源和
Locale，从而选择适当的信息渲染到HTML之中。通例如：JSTL能够获得Locale对象以及Spring中配置的信息资源

1
2
3
4

public interface View{
  String getContentType();
  void render(Map<String,?> model, HttpServletRequest request,HttpServletResponse response) throws Exception;
}

View接口的任务就是接受模型以及Servlet的request和response对象，
并将输出结果渲染到response中。

我们常用的也就那么几个，InternalResourceViewResolver一般会
用于JSP，TilesViewResolver用于Apache Tiles视图（布局），而FreeMarkerViewResolver和VelocityViewResolver分别
对应FreeMarker和Velocity模板视图

2.配置JSP视图解析器

InternalResourceViewResolver会将视图名解析为JSP文件。另外，如果在你的JSP页面中使用了JSP标准标签库（JavaServer Pages Standard Tag Library，JSTL）的话，InternalResourceViewResolver能够将视图名解析为JstlView形式的JSP文件，从而将JSTL本地化和资源bundle变量暴露给JSTL的格式化（formatting）和信息（message）标签

1
2
3
4
5
6
7

@Bean
public ViewResolver viewResolver() {
  InternalResourceViewResolver resolver = new InternalResourceViewResolver();
  resolver.setPrefix("/WEB-INF/views/");
  resolver.setSuffix(".jsp");
  return resolver;
}

当然如果喜欢xml配置方式也可以用xml配置，我个人喜欢JavaConf方式

支持JSTL

如果想让InternalResourceViewResolver将视图解析为JstlView，而不是InternalResourceView的话，
那么我们只需设置它的viewClass属性即可：

1
2
3
4
5
6
7
8

@Bean
public ViewResolver viewResolver() {
  InternalResourceViewResolver resolver = new InternalResourceViewResolver();
  resolver.setPrefix("/WEB-INF/views/");
  resolver.setSuffix(".jsp");
  resolver.setViewClass(org.springframework.web.servlet.view.JstlView.class)
  return resolver;
}

3.表单校验

大多数项目都会有表单的提交，比如注册、登录等，我们通常会在前台通过JS对用户的输入进行校验，也可后台进行数据校验，
前台校验的优点是不用发送请求，速度快，缺点是不安全，前端校验可以被轻易的绕开。后端的校验恰好相反。
平时我们大多会在两端都进行校验，前端初步校验提高用户友好性，后端校验提高安全性。
下面我们谈谈后端的校验。

最简单粗暴的方法是在后端获取参数后逐个写逻辑判断。这种方式会让我们的Controller很乱很臃肿。与其让校验逻辑弄乱我们的处理器方法，还不如使用Spring对Java校验API（Java Validation API，又称JSR-303）的支持。从Spring 3.0开始，在Spring MVC中提供了对Java校验API的支持。在Spring MVC中要使用Java校验API的话，并不需要什么额外的配置。只要保证在类路径下包含这个Java API的实现即可，比如Hibernate Validator。Java校验API定义了多个注解，这些注解可以放到属性上，从而限制这些属性的值。所有的注解都位于javax.validation.constraints包中

以下是JAVA校验API提供的一些注解：

例如：

实体类：

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

package spittr;

import javax.validation.constraints.NotNull;
import javax.validation.constraints.Size;

import org.apache.commons.lang3.builder.EqualsBuilder;
import org.apache.commons.lang3.builder.HashCodeBuilder;
import org.hibernate.validator.constraints.Email;

public class Spitter {

  private Long id;

  @NotNull
  @Size(min=5, max=16)
  private String username;

  @NotNull
  @Size(min=5, max=25)
  private String password;

  @NotNull
  @Size(min=2, max=30)
  private String firstName;

  @NotNull
  @Size(min=2, max=30)
  private String lastName;

  @NotNull
  @Email
  private String email;
  //get  set 省略
}

Controller 方法

1
2
3
4
5
6
7
8
9
10
11

@RequestMapping(value="/register", method=POST)
  public String processRegistration(
      @Valid Spitter spitter, //校验输入
      Errors errors) {
    if (errors.hasErrors()) {
      return "registerForm"; //校验出现错误则返回表单
    }

    spitterRepository.save(spitter);
    return "redirect:/spitter/" + spitter.getUsername();
  }

如果有校验出现错误的话，那么这些错误可以通过Errors对象进行访问，现在这个对象已作为processRegistration()方法的参数。（很重要一点需要注意，Errors参数要紧跟在带有@Valid注解的参数后面，@Valid注解所标注的就是要检验的参数。）processRegistration()方法所做的第一件事就是调用Errors.hasErrors()来检查是否有错误。

但这时候返回表单页面会丢失之前填的数据

4.使用Spring的JSP库

使用这个标签库可以将错误信息友好的显示在页面，也会保留验证钱的数据（解决上面的问题），当然也可以自己写处理，方式很多，不局限这一种

当为JSP添加功能时，标签库是一种很强大的方式，能够避免在脚本块中直接编写Java代码。Spring提供了两个JSP标签库，用来帮助定义Spring MVC Web的视图。其中一个标签库会用来渲染HTML表单标签，这些标签可以绑定model中的某个属性。另外一个标签库包含了一些工具类标签，我们随时都可以非常便利地使用它们。

5.使用Apache Tiles视图定义布局

到现在为止，我们很少关心应用中Web页面的布局问题。每个JSP完全负责定义自身的布局，在这方面其实这些JSP也没有做太多工作。假设我们想为应用中的所有页面定义一个通用的头部和底部。最原始的方式就是查找每个JSP模板，并为其添加头部和底部的HTML。但是这种方法的扩展性并不好，也难以维护。为每个页面添加这些元素会有一些初始成本，而后续的每次变更都会耗费类似的成本。更好的方式是使用布局引擎，如Apache Tiles，定义适用于所有页面的通用页面布局。Spring MVC以视图解析器的形式为Apache Tiles提供了支持，这个视图解析器能够将逻辑视图名解析为Tile定义。

来感受下：

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

<?xml version="1.0" encoding="ISO-8859-1" ?>
<!DOCTYPE tiles-definitions PUBLIC
       "-//Apache Software Foundation//DTD Tiles Configuration 3.0//EN"
       "http://tiles.apache.org/dtds/tiles-config_3_0.dtd">
<tiles-definitions>

  <definition name="base" template="/WEB-INF/layout/page.jsp">
    <put-attribute name="header" value="/WEB-INF/layout/header.jsp" />
    <put-attribute name="footer" value="/WEB-INF/layout/footer.jsp" />
  </definition>

  <definition name="home" extends="base">
    <put-attribute name="body" value="/WEB-INF/views/home.jsp" />
  </definition>

  <definition name="registerForm" extends="base">
    <put-attribute name="body" value="/WEB-INF/views/registerForm.jsp" />
  </definition>

  <definition name="profile" extends="base">
    <put-attribute name="body" value="/WEB-INF/views/profile.jsp" />
  </definition>

  <definition name="spittles" extends="base">
    <put-attribute name="body" value="/WEB-INF/views/spittles.jsp" />
  </definition>

  <definition name="spittle" extends="base">
    <put-attribute name="body" value="/WEB-INF/views/spittle.jsp" />
  </definition>

</tiles-definitions>

其实本来真的没打算写这篇文章，主要是LZ得记忆力不是很好，不像一些记忆力强的人，面试完以后，几乎能把自己和面试官的对话都给记下来。LZ自己当初面试完以后，除了记住一些聊过的知识点以外，具体的内容基本上忘得一干二净，所以写这篇文章其实是很有难度的。

但是，最近问LZ的人实在是太多了，为了避免重复回答，给自己省点力气，干脆就在这里统一回复了。

其实之前LZ写过一篇文章，但是那篇文章更多的是在讨论“面试前该不该刷题”这个话题，而这篇文章将会更加聚焦在面试前如何准备，以及工作当中如何学习这个话题上，而且会尽量写出一些干货。

第一个问题：阿里面试都问什么？

这个是让LZ最头疼的一个问题，也是群里的猿友们问的最多的一个问题。

说实话，LZ只能隐约想起并发、JVM、分布式、TCP/IP协议这些个关键字，具体的问题真的是几乎都没记住。而且就算LZ记住了，也告诉你了，你也背会了，但LZ觉得，在面试中，你被问到一模一样问题的可能性依然很小。

甚至，就算你运气好被问到了，你也照着背下来了，也不一定就能对你的面试起到正面的作用，因为面试官万一多问一句，你可能就露馅了，那还不如干脆点说不会更好。

LZ参加的是阿里的社招面试，而社招不同于校招，问题的范围其实是很随机的。因为能参加一些比较知名的互联网公司社招的人，70%以上都会有个3-5年的经验。这倒不是说一两年经验的同学没有机会进这些公司，而是因为这种公司，大部分情况下只招一些比较资深的开发和应届生，而不招那些处于中间阶段的人。而1-2年经验的同学，往往就刚好处于这个尴尬的阶段。

对于能有3-5年经验的这部分人中，每个人的经历又都不同，所擅长的点也不一样，因此这就会导致每个人的问题和范围都不太一样。

很少说有哪个知名的互联网公司，比如BAT、京东、360、搜狐、网易等这些公司，其社招面试还有固定的问题和模式，让你可以像应届生面试一样，在面试前靠临时抱佛脚度过这一关。

大部分公司在社招的时候，不光是阿里，其它公司也都一样（因为LZ在一年多前也参加过很多其它知名互联网公司的面试，详情见《记录2015年年初跳槽的经历！》），基本上都分为两个阶段的提问。

第一个阶段是主语言本身以及它的高级特性，第二个阶段是讲述自己的项目，并在中间穿插着问题。

所以，LZ不妨就这两个阶段，谈谈社招面试的准备，而不是去把阿里面试的过程背一遍。说实话，LZ也确实记不住，所以不要再问LZ阿里面试都会问哪些问题了，你看看上面那个连接里的文章，也会发现，LZ里面也基本上没有写具体的问题，原因是一样的，真的记不住啊。（就是因为记忆力的问题，导致LZ从小偏科，文科成绩一直堪忧，

社招面试如何准备

LZ会分为四个部分来谈论这个问题，由于LZ本身是Java出身，因此关于主语言的问题，都是与Java相关，其它语言的同学可以选择性忽略。此外，面试的时候一般面试官的问题都是环环相扣，逐渐深入的，这点在下面大家可以更明显的感受出来。

1、主语言本身以及它的高级特性。

主语言当然就是你平日里拿来赚钱的家伙。不要告诉LZ你没有主语言，你会N多种语言，或者是你精通N多种语言，你要非这么说的话，你可以来杭州试试，LZ保证不打死你，最多打残。

LZ的主语言很显然是Java，那么对于Java来说，它的语言本身以及它的高级特性，都有哪些比较容易在面试中问到呢？

一般情况下，主要有以下知识点很容易被问到。（PS：以下所列举的，都是一些Java相对而言比较高级一点的知识点，因为这里谈的是社招，而不是校招）

1）Java的数据结构相关的类实现原理，比如LinkedList，ArrayList，HashMap，TreeMap这一类的。以下简单模拟一个数据结构的连环炮。

比如，面试官先问你HashMap是不是有序的？

你肯定回答说，不是有序的。那面试官就会继续问你，有没有有顺序的Map实现类？

你如果这个时候说不知道的话，那这个问题就到此结束了。如果你说有TreeMap和LinkedHashMap。

那么面试官接下来就可能会问你，TreeMap和LinkedHashMap是如何保证它的顺序的？

如果你回答不上来，那么到此为止。如果你依然回答上来了，那么面试官还会继续问你，你觉得它们两个哪个的有序实现比较好？

如果你依然可以回答的话，那么面试官会继续问你，你觉得还有没有比它更好或者更高效的实现方式？

如果你还能说出来的话，那么就你所说的实现方式肯定依然可以问你很多问题。

以上就是一个面试官一步一步提问的例子。所以，如果你了解的不多，千万不要敷衍，因为可能下一个问题你就暴露了，还不如直接说不会，把这个问题结束掉，赶紧切换到你熟悉的领域。

2）Java并发包当中的类，它们都有哪些作用，以及它们的实现原理，这些类就是java.concurrent包下面的。与上面一样，咱们也简单的模拟一个并发包的连环炮。

比如面试官可能会先问你，如果想实现所有的线程一起等待某个事件的发生，当某个事件发生时，所有线程一起开始往下执行的话，有什么好的办法吗？

这个时候你可能会说可以用栅栏（Java的并发包中的CyclicBarrier），那么面试官就会继续问你，你知道它的实现原理吗？

如果你继续回答的话，面试官可能会继续问你，你还知道其它的实现方式吗？

如果你还能说出很多种实现方式的话，那么继续问你，你觉得这些方式里哪个方式更好？

如果你说出来某一个方式比较好的话，面试官依然可以继续问你，那如果让你来写的话，你觉得还有比它更好的实现方式吗？

如果你这个时候依然可以说出来你自己更好的实现方式，那么面试官肯定还会揪着这个继续问你。

为什么说面试的时候要引导面试官，原因就在这了。因为面试官的提问很多时候都是有迹可循的，你如果抓住了他的轨迹，能够猜到他下面很可能会问什么，那你在回答的时候就可以往你想要谈的方向去说。这样面试时就会显得更加从容，更加的游刃有余。

3）IO包和NIO包中的内容。这部分里面NIO会是重点，IO包大部分都会比较熟悉，因此可能会直接略过，直接问你NIO的内容。

IO包和NIO包的内容相对来说不是很多，首先NIO模型要熟悉，特别是其中的selector一定要非常清楚它的职责和实现原理。其实NIO的核心是IO线程池，一定要记住这个关键点。有的时候，面试官可能也会问你IO包的设计模式（装饰器模式），为什么要这样设计？

有的面试官还会问你有没有更好的设计，这个时候如果你不知道请果断说自己现在的水平有限，想不出来更好的设计，千万不要信口开河，随意YY。

4）Java的虚拟机的内容。这部分主要包括三部分，GC、类加载机制，以及内存。

一个GC部分简单的连环炮。

面试官可以先问你什么时候一个对象会被GC？

接着继续问你为什么要在这种时候对象才会被GC？

接着继续问你GC策略都有哪些分类？

你如果说出来了，继续问你这些策略分别都有什么优劣势？都适用于什么场景？

你继续说出来了以后，给你举个实际的场景，让你选择一个GC策略？

你如果选出来了，继续问你，为什么要选择这个策略？

下面是关于类加载机制的简单连环炮。

首先肯定是先问你Java的类加载器都有哪些？

回答了这些以后，可能会问你每个类加载器都加载哪些类？

说完以后，可能会问你这些类加载之间的父子关系是怎样的？

你在回答的时候可能会提到双亲委派模型，那么可以继续问你什么是双亲委派模型？

你解释完了以后，可能会继续问你，为什么Java的类加载器要使用双亲委派模型？

你回答完以后，可能会继续问你如何自定义自己的类加载器，自己的类加载器和Java自带的类加载器关系如何处理？

再来一个关于内存的连环炮。

首先肯定就是问你内存分为哪几部分，这些部分分别都存储哪些数据？

然后继续问你一个对象从创建到销毁都是怎么在这些部分里存活和转移的？

接着可能会问你，内存的哪些部分会参与GC的回收？

完事以后，可能还会问你Java的内存模型是怎么设计的？

你回答了以后，还会继续问你为什么要这么设计？

问完以后，还可能会让你结合内存模型的设计谈谈volatile关键字的作用？

你在谈的时候，肯定会提到可见性，那么接着可见性这三个字，还可以继续问你并发的内容。

基本上Java语言本身以及语言稍微高级点的内容就是以上部分，如果你能把以上四部分了解的非常透彻，那基本上Java这部分就没啥问题了，因为光以上的内容就够你跟面试官聊很久了。你聊这些聊得久了，自然问你其它问题的时间就会短点。

你从LZ写这些问题的过程也应该能感受出来，很多时候，面试官都是顺着一条线一路问下去的，如果你觉得这条线你不熟悉的话，就要及时拐弯，引导面试官去问其它方面的问题。千万不要一直往下深入，直到自己跳不出来为止，那就尴了个尬了。

2、讲述自己的项目，并在中间穿插着问题

这一部分是面试过程中必问，也是聊得最久的一个阶段。除非你前面的语言部分非常扎实，扎实到面试官问了一两个小时，依旧没有探出你对语言本身的了解到底有多深。否则的话，你一定逃不过自己的项目这一关，而且一般情况下聊得时间不会太短。

这一部分内容，一般的模式就是你自己去讲你做过的项目，然后面试官会冷不丁的让你去解释其中某一部分，比如让你解释当时为什么要这么做，或者问你现在觉得有没有更好的办法。而这些穿插的问题，大部分与你的项目所用到的技术有关。而你需要做的，就是充分、再充分的去总结自己做过的项目（尤其是最近的一两个项目），挖掘出一个甚至N个亮点，以备于到时候可以让面试官产生眼前一亮的感觉。如果你能达到这种效果的话，基本上离你成功就不远了。

这部分内容由于和每个人自己的经历息息相关，因此这里也没法列举可能问到的问题。这篇文章《程序员面经：面试前到底该不该刷题以及面试前该如何准备》是LZ之前写的，里面大概讨论了下如何在面试前总结，有兴趣的可以去了解一下。

3、额外的加分项

上面两个阶段基本上是必问的，还有一些加分项。这些加分项中，有些内容面试官也会问你（比如TCP/IP协议、算法），但更多的是会先问你了解不了解，你了解的话再继续聊，不了解的话就直接略过了，不至于因为这种问题而直接把你打入地狱。

下面LZ列举一下这些加分项，如果可以的话，这些加分项还是要争取一下的。

计算机系统原理。
网络通信协议（TCP/IP，HTTP等）。
数据结构与算法。
著名开源项目的源码。
你自己有很棒的开源项目。
你的个人博客。
待评论区补充。
这几项当中，对于前1-3项，如果你之前就比较了解，只是由于时间问题忘记了的话，还是可以临时抱佛脚一下的。至于后面4-6项，就需要你日常的积累了，不是一时半会儿能做到的。如果你平日里没有积累，那么后面这三个加分项只能抛弃了。

4、与你职位相关的内容

其实这最后一项是对前面三项的补充，你应该尽量去主攻和你面试的职位相关的内容。比如你面试一个实时计算的职位，那么你的算法最好要厉害，对于著名的实时计算开源项目要熟悉，最好阅读过源码，而且还要对分布式系统有一定的见解。

因此，这个第4部分没有具体的内容，只是提醒你，如果你很明确自己的面试职位，最好在面试前准备的时候，尽量朝职位的需求方向靠拢，这样成功的可能性更大。

对于Java程序猿学习的建议

这一部分其实也算是今天的重点，这一部分用来回答很多群里的朋友所问过的问题，那就是LZ你是如何学习Java的，能不能给点建议？

今天LZ是打算来点干货，因此咱们就不说一些学习方法和技巧了，直接来谈每个阶段要学习的内容甚至是一些书籍。这一部分的内容，同样适用于一些希望转行到Java的同学。

在大家看之前，LZ要先声明两点。

1、由于LZ本人是Java后端开发出身，因此所推荐的学习内容是Java Web和Java后端开发的路线，非Java Web和Java后端开发的同学请适当参考其学习思想即可，切勿照搬。

2、下面对于【第一部分】的推荐内容，目的是让你尽快成为一个可以参加工作的Java开发者，更适用于处于待业状态，准备转行Java的同学。如果你是在校学生，务必要在学好基础（比如计算机系统、算法、编译原理等等）的前提下，再考虑去进行下面的学习。

第一部分：对于尚未做过Java工作的同学，包括一些在校生以及刚准备转行Java的同学。

一、Java基础

首先去找一个Java的基础教程学一下，这里可以推荐一个地址，或者你也可以参照这个地址上去找相应的视频。

学习Java基础的时候，应该尽量多动手，很多时候，你想当然的事情，等你写出来运行一下，你就会发现不是这么回事儿，不信你就试试。

学完以上内容以后，你应该对Java有一个基本的了解了，你可以用Java语言写出一些简单的程序，并且你用的是最简单的编辑器，比如记事本。

这个时候，不要急于进入下一部分，留下几天好好写一些程序，尽可能熟悉这些基础内容。

二、Web开发

等你写上几天程序以后，你往往会比较迷茫，因为你写的东西似乎看起来毫无用处，比如实现一个简单的计算器，读取一个文件等。这个时候你就应该去学着写一些让你觉得有意思的东西了，所以你应该学习更多的知识。

这些内容主要是Web开发相关的内容，包括HTML/CSS/JS（前端页面）、Servlet/JSP（J2EE）以及Mysql（数据库）相关的知识。

它们的学习顺序应该是从前到后，因此最先学习的应该是HTML/CSS/JS（前端页面），这部分内容你可以去上面的那个runoob网站上找。你可以试着自己写一些页面，当然，你可以尽你最大的努力让它变得最漂亮。这部分内容对于后端Java来说，理论上不是特别重要，但至少要达到可以自己写出一些简单页面的水平。

接下来，你需要学习的是Servlet/JSP（J2EE）部分，这部分是Java后端开发必须非常精通的部分，因此这部分是这三部分中最需要花精力的，而且这个时候，你要学会使用开发工具，而不能再使用记事本了，可以选择eclipse。

当你下载安装好eclipse以后，请视频中的教程一步一步去学习，一定要多动手。关于Servlet/Jsp部分视频的选择，业界比较认可马士兵的视频，因此推荐给大家。当然了，LZ本人并没有看过他的视频，所以不好说的太绝对，如果大家自己有更好的选择，可以坚持自己的，不要被LZ干扰。

原本LZ也是打算出教学视频的，但是由于时间问题，还是决定放弃了。但是如果你看视频的过程中遇到了问题，欢迎来LZ的交流群提问，或者去斗鱼观看LZ的直播提出你的问题，直播地址和群号都在LZ的个人博客左侧。

最后一步，你需要学会使用数据库，mysql是个不错的入门选择，而且Java领域里主流的关系型数据库就是mysql。这部分一般在你学习Servlet/Jsp的时候，就会接触到的，其中的JDBC部分就是数据库相关的部分。你不仅要学会使用JDBC操作数据库，还要学会使用数据库客户端工具，比如navicat，sqlyog，二选一即可。

三、开发框架

当你学会以上内容以后，这个时候你还不足以参加工作，你还需要继续深造。公司里为了提高开发的效率，会使用一些Java Web框架，因此你还需要学习一些开发框架。

目前比较主流的是SSM框架，即spring、springmvc、mybatis。你需要学会这三个框架的搭建，并用它们做出一个简单的增删改查的Web项目。你可以不理解那些配置都是什么含义，以及为什么要这么做，这些留着后面你去了解。但你一定要可以快速的利用它们三个搭建出一个Web框架，你可以记录下你第一次搭建的过程，相信我，你一定会用到的。

还要提一句的是，你在搭建SSM的过程中，可能会经常接触到一个叫maven的工具。这个工具也是你以后工作当中几乎是必须要使用的工具，所以你在搭建SSM的过程中，也可以顺便了解一下maven的知识。在你目前这个阶段，你只需要在网络上了解一下maven基本的使用方法即可，一些高端的用法随着你工作经验的增加，会逐渐接触到的。

关于学习SSM框架的地址给大家推荐一个，这里面有视频，大家可以去观看。

四、找工作

当你完成开发框架的学习以后，你就该找工作了，在校的找实习，毕业的找全职。与此同时，在找工作的同时，你不应该停下你的学习，准确的说，是你在以后都不能停下学习。

上面这些内容你只是囫囵吞枣的学会了使用，你可以逐步尝试着去了解更多的东西，网络是你最重要的老师。

第一部分：对于参加工作一年以内的同学。

恭喜你，这个时候，你已经拥有了一份Java的工作。这个阶段是你成长极快的阶段，而且你可能会经常加班。

但是加班不代表你就可以松懈了，永远记得LZ说的那句话，从你入行那一刻起，你就要不停的学习。在这一年里，你至少需要看完《Java编程思想》这本书。这本书的内容是帮助你对于Java有一个更加深入的了解，是Java基础的升级版。

这本书很厚，当初看这本书，LZ花了整整三个月。正常速度的话，应该可以在半年左右看完。LZ这里不要求过高，只要你在一年以内把这本书看完即可。当然了，LZ所说的看完，是充分吸收，而不是读一遍就完事了，因此有些内容你可能会看不止一遍。

总而言之，这个阶段的核心学习思想就是，在工作中实践，并且更加深入的了解Java基础。

第二部分：对于参加工作1年到2年的同学。

这部分时间段的同学，已经对Java有了一个更加深入的了解。但是对于面向对象的体会可能还不够深刻，编程的时候还停留在完成功能的层次，很少会去考虑设计的问题。

于是这个时候，设计模式就来了。LZ当时看的是《大话设计模式》这本书，并且写了完整版的设计模式博客。因此，LZ要求大家，最多在你工作一年的时候，必须开始写博客，而设计模式就是你博客的开端。

请记住，LZ所提的基本都是最低要求，因此不要有任何松懈的心理，否则五年后，你不要去羡慕别人高于你的工资，也不要去羡慕别人进入了某公司。

这一年，你必须对于设计模式了如指掌，《大话设计模式》可以作为你的开端。当然了，你也可以去看LZ的个人博客去学习，地址请点击这里。

此外，设计模式并不是你这一年唯一的任务，你还需要看一些关于代码编写优化的书。比如《重构 改善既有代码的设计》，《effective java》。

总而言之，这个阶段，你的核心任务就是提高你的代码能力，要能写出一手优雅的代码。

第三部分：对于参加工作2年到3年的同学

有的同学在这个时候觉得自己已经很牛逼了，于是忍不住开始慢慢松懈。请记住，你还嫩的多。

这个阶段，有一本书是你必须看的，它叫做《深入理解Java虚拟机》。这本书绝对是Java开发者最重要的书，没有之一。在LZ眼里，这本书的重要性还要高于《Java编程思想》。

这本书的内容是帮助你全面的了解Java虚拟机，在这个阶段，你一定已经知道Java是运行在JVM之上的。所以，对于JVM，你没有任何理由不了解它。LZ之前有写过JVM系列的知识，可以去看一下，地址请点击这里。

另外，在过去2年的工作当中，你肯定或多或少接触过并发。这个时候，你应该去更加深入的了解并发相关的知识，而这部分内容，LZ比较推荐《Java并发编程实战》这本书。只要你把这本书啃下来了，并发的部分基本已经了解了十之六七。

与此同时，这个阶段你要做的事情还远不止如此。这个时候，你应该对于你所使用的框架应该有了更深入的了解，对于Java的类库也有了更深入的了解。因此，你需要去看一些JDK中的类的源码，也包括你所使用的框架的源码。

这些源码能看懂的前提是，你必须对设计模式非常了解。否则的话，你看源码的过程中，永远会有这样那样的疑问，这段代码为什么要这么写？为什么要定义这个接口，它看起来好像很多余？

由此也可以看出，这些学习的过程是环环相扣的，如果你任何一个阶段拉下来了，那么你就真的跟不上了，或者说是一步慢步步慢。而且LZ很负责的告诉你，LZ在这个阶段的时候，所学习的东西远多于这里所罗列出来的。因此千万不要觉得你已经学的很多了，LZ所说的这些都只是最低要求，不光是LZ，很多人在这个时间段所学习的内容都远超本文的范围。

如果你不能跟上节奏的话，若干年后，如果不是程序猿市场还不错的话，你很可能不仅仅是工资比别人低，公司没别人好，而是根本就找不到工作。

总而言之，这个阶段，你需要做的是深入了解Java底层和Java类库（比如并发那本书就是Java并发包java.concurrent的内容），也就是JVM和JDK的相关内容。而且还要更深入的去了解你所使用的框架，方式比较推荐看源码或者看官方文档。

另外，还有一种学习的方式，在2年这个阶段，也应该启用了，那就是造轮子。

不要听信那套“不要重复造轮子”的论调，那是公司为了节省时间成本编造出来的。重复造轮子或许对别人没有价值，因为你造的轮子可能早就有了，而且一般情况下你造出来的轮子还没有现存的好。但是对别人没有价值，不代表对你自己没有价值。

一个造轮子的过程，是一个从无到有的过程。这个过程可以对你进行系统的锻炼，它不仅考察你的编码能力，还考察你的框架设计能力，你需要让你的轮子拥有足够好的扩展性、健壮性。

而且在造轮子的过程中，你会遇到各种各样的难题，这些难题往往又是你学习的契机。当你把轮子造好的时候，你一定会发现，其实你自己收获了很多。

所以，这个阶段，除了上面提到的了解JVM、JDK和框架源码以外，也请你根据别人优秀的源码，去造一个任何你能够想象出来的轮子。

第四部分：参加工作3年到4年的同学

这个阶段的同学，提升已经是很难了，而且这个阶段的学习往往会比较多样化。

因为在前3年的过程中，你肯定或多或少接触过一些其它的技术，比如大数据、分布式缓存、分布式消息服务、分布式计算、软负载均衡等等。这些技术，你能精通任何一项，都将是你未来面试时巨大的优势，因此如果你对某一项技术感兴趣的话，这个时候可以深入去研究一下。这项技术不一定是你工作所用到的，但一定是相关的。

而且在研究一门新技术时，切忌朝三暮四。有的同学今天去整整大数据，搞搞Hadoop、hbase一类的东西。过不了一段时间，就觉得没意思，又去研究分布式缓存，比如redis。然后又过不了一段时间，又去研究分布式计算，比如整整Mapreduce或者storm。

结果到最后，搞得自己好像什么都会一样，在简历上大言不惭的写上大数据、分布式缓存、分布式计算都了解，其实任何一个都只是浮于表面。到时候面试官随便一问，就把你给识破了。

一定要记住，作为一个程序猿，平日里所接触的技术可能会很多，但是想要让一门技术成为你的优势，那么一定是你对这门技术的了解强过绝大多数人才行。

因此在这个阶段，你就不能再简单的去学习前3年的内容了，虽然前面的学习如果还不够深入的话依旧要继续，但这个时候你应该更多的考虑建立你的优势，也可以称为差异性。

差异性相信不难理解，就是让你自己变得与众不同。你前面三年的学习足够你成为一名基本合格的Java开发者，但你离成为一名优秀的Java开发者还有很大的距离。

所谓优秀，即能别人所不能。而你前三年所学习的内容，是很多做过几年的Java开发都能够掌握的。那么为了让自己有差异性，你就需要另辟蹊径，找一个方向深入研究下去，以期在将来，你能够成为这个领域的专家，比如分布式计算领域的专家，大数据领域的专家，并发领域的专家等等。

此外，你除了建立你的差异性之外，还要去弥补你基础上的不足，直到现在，LZ都没有提及基础知识。原因是基础是很枯燥无味的，学的太早不仅容易懵逼，而且懵逼的同时还容易产生心理阴影，以至于以后再不想去研究这些基础。但基础又是你深入研究一些领域时所必须掌握的，比如你去研究分布式计算，你不懂算法你玩个毛毛？比如你去做分布式缓存，你对计算机系统的内存不了解，你如何去做缓存？

如果你的基础本来就非常强，那么恭喜你，相信你在之前的工作中已经充分体会到了这些基础对你的帮助。但LZ相信大部分人的基础都很薄弱，哪怕是科班毕业的人，很多人也不敢说自己当初的基础学的多么强大，比如算法、计算机系统原理、编译原理这些。

但是每个人时间都是有限的，而且这些基础的书籍每一本读下来，没个一年半载的，还真拿不下来，因此还是要有所抉择的。虽然艺多不压身，但问题是艺多是有代价的，是需要你付出时间和精力的，而LZ个人更赞成在同等代价的情况下获取最大的收获。

首先，LZ比较推崇的基础书籍有三本，分别是《深入理解计算机系统》，《tcp/ip详解 卷一、二、三》，《数据结构与算法》。其中TCP/IP有三本书，但我们这里把这三本看成是一本大书。

这三本分别适合三种人，《深入理解计算机系统》比较适合一直从事Java Web开发和APP后端开发工作的人群。《tcp/ip详解 卷一、二、三》比较适合做网络编程的人群，比如你使用netty去开发的话，那么就要对TCP/IP有更深入的了解。而《数据结构与算法》这本书，则比较适合做计算研究工作的人，比如刚才提到的分布式计算。

另外，LZ要强调的是，这里所说的适合，并不是其它两本对你就没有用。比如你做Java Web和APP后端开发，《tcp/ip详解 卷一、二、三》这本书对你的作用也是很大的。这里只是分出个主次关系而已，你要是时间足够的话，能把三本都精读那当然最好不过了。但如果时间有限的话，那么就先挑对你帮助最大的书去读。