小咖啊

小咖啊 查看完整档案

填写现居城市  |  填写毕业院校Java小咖秀  |  Java 编辑填写个人主网站
编辑
_ | |__ _ _ __ _ | '_ \| | | |/ _` | | |_) | |_| | (_| | |_.__/ \__,_|\__, | |___/ 该用户太懒什么也没留下

个人动态

小咖啊 发布了文章 · 7月6日

超实用 Nginx 极简教程,覆盖了常用场景

作者:dunwu

链接: https://github.com/dunwu/nginx-tutorial

概述

什么是 Nginx?

Nginx (engine x) 是一款轻量级的 Web 服务器 、反向代理服务器及电子邮件(IMAP/POP3)代理服务器。

什么是反向代理?

反向代理(Reverse Proxy)方式是指以代理服务器来接受 internet 上的连接请求,然后将请求转发给内部网络上的服务器,并将从服务器上得到的结果返回给 internet 上请求连接的客户端,此时代理服务器对外就表现为一个反向代理服务器。

Nginx入门

详细安装方法请参考:Nginx 运维 https://github.com/dunwu/nginx-tutorial/blob/master/docs/nginx-ops.md

使用

nginx 的使用比较简单,就是几条命令。

常用到的命令如下:

nginx -sstop      快速关闭Nginx,可能不保存相关信息,并迅速终止web服务。
nginx -squit       平稳关闭Nginx,保存相关信息,有安排的结束web服务。
nginx -sreload     因改变了Nginx相关配置,需要重新加载配置而重载。
nginx -sreopen     重新打开日志文件。
nginx -cfilename   为 Nginx 指定一个配置文件,来代替缺省的。
nginx -t          不运行,而仅仅测试配置文件。nginx 将检查配置文件的语法的正确性,并尝试打开配置文件中所引用到的文件。
nginx -v          显示 nginx 的版本。
nginx -V          显示 nginx 的版本,编译器版本和配置参数。

如果不想每次都敲命令,可以在 nginx 安装目录下新添一个启动批处理文件startup.bat,双击即可运行。内容如下:

@echo off
rem 如果启动前已经启动nginx并记录下pid文件,会kill指定进程
nginx.exe -sstop

rem 测试配置文件语法正确性
nginx.exe -t-cconf/nginx.conf

rem 显示版本信息
nginx.exe -v

rem 按照指定配置去启动nginx
nginx.exe -cconf/nginx.conf

如果是运行在 Linux 下,写一个 shell 脚本,大同小异。

Nginx 实战

我们先实现一个小目标:不考虑复杂的配置,仅仅是完成一个 http 反向代理。

nginx.conf 配置文件如下:

注:conf/nginx.conf 是 nginx 的默认配置文件。你也可以使用 nginx -c 指定你的配置文件

运行用户

user somebody;

启动进程,通常设置成和cpu的数量相等

worker_processes  1;

全局错误日志

error_log D:/Tools/nginx-1.10.1/logs/error.log;
error_log D:/Tools/nginx-1.10.1/logs/notice.log notice;
error_log D:/Tools/nginx-1.10.1/logs/info.log info;

PID文件,记录当前启动的nginx的进程ID

pid       D:/Tools/nginx-1.10.1/logs/nginx.pid;

工作模式及连接数上限

events {
worker_connections 1024;    #单个后台worker process进程的最大并发链接数
}

设定http服务器,利用它的反向代理功能提供负载均衡支持

http {
#设定mime类型(邮件支持类型),类型由mime.types文件定义
include       D:/Tools/nginx-1.10.1/conf/mime.types;
default_type application/octet-stream;

#设定日志
log_format main  '[$remote\_addr\] - \[$remote_user] [$time\_local\] "$request" '
'$status $body_bytes_sent "$http_referer" '
'"$http\_user\_agent" "$http_x_forwarded_for"';

access_log   D:/Tools/nginx-1.10.1/logs/access.log main;
rewrite_log     on;

#sendfile 指令指定 nginx 是否调用 sendfile 函数(zero copy 方式)来输出文件,对于普通应用,
#必须设为 on,如果用来进行下载等应用磁盘IO重负载应用,可设置为 off,以平衡磁盘与网络I/O处理速度,降低系统的uptime.
sendfile       on;
#tcp_nopush     on;

#连接超时时间
keepalive_timeout  120;
tcp_nodelay       on;

#gzip压缩开关
#gzip on;

#设定实际的服务器列表
upstream zp_server1{
server 127.0.0.1:8089;
}

#HTTP服务器
server {
#监听80端口,80端口是知名端口号,用于HTTP协议
listen       80;

#定义使用www.xx.com访问
server_name www.helloworld.com;

#首页
index index.html

#指向webapp的目录
root D:\01_Workspace\Project\github\zp\SpringNotes\spring-security\spring-shiro\src\main\webapp;

#编码格式
charset utf-8;

#代理配置参数
proxy_connect_timeout 180;
proxy_send_timeout 180;
proxy_read_timeout 180;
proxy_set_header Host $host;
proxy_set_header X-Forwarder-For $remote_addr;

#反向代理的路径(和upstream绑定),location 后面设置映射的路径
location / {
proxy_pass http://zp_server1;
}

#静态文件,nginx自己处理
location ~ ^/(images|javascript|js|css|flash|media|static)/ {
root D:\01_Workspace\Project\github\zp\SpringNotes\spring-security\spring-shiro\src\main\webapp\views;
#过期30天,静态文件不怎么更新,过期可以设大一点,如果频繁更新,则可以设置得小一点。
expires 30d;
}

#设定查看Nginx状态的地址
location /NginxStatus {
stub_status           on;
access_log           on;
auth_basic            "NginxStatus";
auth_basic_user_file conf/htpasswd;
}

#禁止访问 .htxxx 文件
location ~ /\.ht {
deny all;
}

#错误处理页面(可选择性配置)
#error_page   404             /404.html;
#error_page   500 502 503 504 /50x.html;
#location = /50x.html {
#   root   html;
#}
}
}

好了,让我们来试试吧: 1.启动 webapp,注意启动绑定的端口要和 nginx 中的 upstream 设置的端口保持一致。

2.更改 host:在 C:\Windows\System32\drivers\etc 目录下的 host 文件中添加一条 DNS 记录

127.0.0.1 www.helloworld.com

3.启动前文中 startup.bat 的命令

4.在浏览器中访问 www.helloworld.com,不出意外,已经可以访问了。

Https 反向代理

一些对安全性要求比较高的站点,可能会使用 HTTPS(一种使用 ssl 通信标准的安全 HTTP 协议)。

这里不科普 HTTP 协议和 SSL 标准。但是,使用 nginx 配置 https 需要知道几点:

HTTPS 的固定端口号是 443,不同于 HTTP 的 80 端口 SSL 标准需要引入安全证书,所以在 nginx.conf 中你需要指定证书和它对应的 key 其他和 http 反向代理基本一样,只是在 Server 部分配置有些不同。

HTTP服务器

server {
#监听443端口。443为知名端口号,主要用于HTTPS协议
listen       443ssl;

#定义使用www.xx.com访问
server_name www.helloworld.com;

#ssl证书文件位置(常见证书文件格式为:crt/pem)
ssl_certificate     cert.pem;
#ssl证书key位置
ssl_certificate_key cert.key;

#ssl配置参数(选择性配置)
ssl_session_cache   shared:SSL:1m;
ssl_session_timeout 5m;
#数字签名,此处使用MD5
ssl_ciphers HIGH:!aNULL:!MD5;
ssl_prefer_server_ciphers on;

location / {
root   /root;
index index.html index.htm;
}
}

负载均衡

前面的例子中,代理仅仅指向一个服务器。

但是,网站在实际运营过程中,大部分都是以集群的方式运行,这时需要使用负载均衡来分流。

nginx 也可以实现简单的负载均衡功能。

假设这样一个应用场景:将应用部署在 192.168.1.11:80、192.168.1.12:80、192.168.1.13:80 三台 linux 环境的服务器上。网站域名叫 www.helloworld.com,公网 IP 为 192.168.1.11。在公网 IP 所在的服务器上部署 nginx,对所有请求做负载均衡处理(下面例子中使用的是加权轮询策略)。

nginx.conf 配置如下:

http {
#设定mime类型,类型由mime.type文件定义
include       /etc/nginx/mime.types;
default_type application/octet-stream;
#设定日志格式
access_log   /var/log/nginx/access.log;

#设定负载均衡的服务器列表
upstream load_balance_server {
#weigth参数表示权值,权值越高被分配到的几率越大
server 192.168.1.11:80   weight=5;
server 192.168.1.12:80   weight=1;
server 192.168.1.13:80   weight=6;
}

#HTTP服务器
server {
#侦听80端口
listen       80;

#定义使用www.xx.com访问
server_name www.helloworld.com;

#对所有请求进行负载均衡请求
location / {
root       /root;                 #定义服务器的默认网站根目录位置
index       index.html index.htm;  #定义首页索引文件的名称
proxy_pass http://load_balance_server ;#请求转向load_balance_server 定义的服务器列表

#以下是一些反向代理的配置(可选择性配置)
#proxy_redirect off;
proxy_set_header Host $host;
proxy_set_header X-Real-IP $remote_addr;
#后端的Web服务器可以通过X-Forwarded-For获取用户真实IP
proxy_set_header X-Forwarded-For $remote_addr;
proxy_connect_timeout 90;          #nginx跟后端服务器连接超时时间(代理连接超时)
proxy_send_timeout 90;             #后端服务器数据回传时间(代理发送超时)
proxy_read_timeout 90;             #连接成功后,后端服务器响应时间(代理接收超时)
proxy_buffer_size 4k;              #设置代理服务器(nginx)保存用户头信息的缓冲区大小
proxy_buffers 432k;               #proxy_buffers缓冲区,网页平均在32k以下的话,这样设置
proxy_busy_buffers_size 64k;       #高负荷下缓冲大小(proxy_buffers*2)
proxy_temp_file_write_size 64k;    #设定缓存文件夹大小,大于这个值,将从upstream服务器传

client_max_body_size 10m;          #允许客户端请求的最大单文件字节数
client_body_buffer_size 128k;      #缓冲区代理缓冲用户端请求的最大字节数
}
}
}

负载均衡策略

Nginx 提供了多种负载均衡策略,让我们来一一了解一下:

负载均衡策略在各种分布式系统中基本上原理一致,对于原理有兴趣,不妨参考 负载均衡

轮询

upstream bck_testing_01 {
# 默认所有服务器权重为 1
server 192.168.250.220:8080
server 192.168.250.221:8080
server 192.168.250.222:8080
}

加权轮询

upstream bck_testing_01 {
server 192.168.250.220:8080   weight=3
server 192.168.250.221:8080              # default weight=1
server 192.168.250.222:8080              # default weight=1
}

最少连接

upstream bck_testing_01 {
least_conn;

# with default weight for all (weight=1)
server 192.168.250.220:8080
server 192.168.250.221:8080
server 192.168.250.222:8080
}

加权最少连接

upstream bck_testing_01 {
least_conn;

server 192.168.250.220:8080   weight=3
server 192.168.250.221:8080              # default weight=1
server 192.168.250.222:8080              # default weight=1
}

IP Hash

upstream bck_testing_01 {

ip_hash;

# with default weight for all (weight=1)
server 192.168.250.220:8080
server 192.168.250.221:8080
server 192.168.250.222:8080

}

普通 Hash

upstream bck_testing_01 {

hash $request_uri;

# with default weight for all (weight=1)
server 192.168.250.220:8080
server 192.168.250.221:8080
server 192.168.250.222:8080

}

网站有多个 webapp 的配置

当一个网站功能越来越丰富时,往往需要将一些功能相对独立的模块剥离出来,独立维护。这样的话,通常,会有多个 webapp。

举个例子:假如 www.helloworld.com 站点有好几个 webapp,finance(金融)、product(产品)、admin(用户中心)。访问这些应用的方式通过上下文(context)来进行区分:

www.helloworld.com/finance/

www.helloworld.com/product/

www.helloworld.com/admin/

我们知道,http 的默认端口号是 80,如果在一台服务器上同时启动这 3 个 webapp 应用,都用 80 端口,肯定是不成的。所以,这三个应用需要分别绑定不同的端口号。

那么,问题来了,用户在实际访问 www.helloworld.com 站点时,访问不同 webapp,总不会还带着对应的端口号去访问吧。所以,你再次需要用到反向代理来做处理。

配置也不难,来看看怎么做吧:

http {

此处省略一些基本配置


upstream product_server{
server www.helloworld.com:8081;
}

upstream admin_server{
server www.helloworld.com:8082;
}

upstream finance_server{
server www.helloworld.com:8083;
}

server {

此处省略一些基本配置

默认指向product的server

location / {
proxy_pass http://product_server;
}

location /product/{
proxy_pass http://product_server;
}

location /admin/ {
proxy_pass http://admin_server;
}

location /finance/ {
proxy_pass http://finance_server;
}
}
}

静态站点

有时候,我们需要配置静态站点(即 html 文件和一堆静态资源)。

举例来说:如果所有的静态资源都放在了 /app/dist 目录下,我们只需要在 nginx.conf 中指定首页以及这个站点的 host 即可。

配置如下:

worker_processes  1;

events {
worker_connections  1024;
}

http {
include       mime.types;
default_type application/octet-stream;
sendfile       on;
keepalive_timeout  65;

gzip on;
gzip_types text/plain application/x-javascript text/css application/xml text/javascript application/javascript image/jpeg image/gif image/png;
gzip_vary on;

server {
listen       80;
server_name static.zp.cn;

location / {
root /app/dist;
index index.html;

转发任何请求到 index.html

}
}
}

然后,添加 HOST:

127.0.0.1 static.zp.cn

此时,在本地浏览器访问 static.zp.cn ,就可以访问静态站点了。

搭建文件服务器

有时候,团队需要归档一些数据或资料,那么文件服务器必不可少。使用 Nginx 可以非常快速便捷的搭建一个简易的文件服务。

Nginx 中的配置要点:

将 autoindex 开启可以显示目录,默认不开启。

将 autoindex_exact_size 开启可以显示文件的大小。

将 autoindex_localtime 开启可以显示文件的修改时间。

root 用来设置开放为文件服务的根路径。

charset 设置为 charset utf-8,gbk;,可以避免中文乱码问题(windows 服务器下设置后,依然乱码,本人暂时没有找到解决方法)。 一个最简化的配置如下:

autoindex on;# 显示目录
autoindex_exact_size on;# 显示文件大小
autoindex_localtime on;# 显示文件时间

server {
charset     utf-8,gbk; # windows 服务器下设置后,依然乱码,暂时无解
listen       9050default_server;
listen       [::]:9050 default_server;
server_name _;
root         /share/fs;
}

解决跨域

web 领域开发中,经常采用前后端分离模式。这种模式下,前端和后端分别是独立的 web 应用程序,例如:后端是 Java 程序,前端是 React 或 Vue 应用。

各自独立的 web app 在互相访问时,势必存在跨域问题。解决跨域问题一般有两种思路:

1.CORS

在后端服务器设置 HTTP 响应头,把你需要允许访问的域名加入 Access-Control-Allow-Origin 中。

2.jsonp

把后端根据请求,构造 json 数据,并返回,前端用 jsonp 跨域。

这两种思路,本文不展开讨论。

需要说明的是,nginx 根据第一种思路,也提供了一种解决跨域的解决方案。

举例:www.helloworld.com 网站是由一个前端 app ,一个后端 app 组成的。前端端口号为 9000, 后端端口号为 8080。

前端和后端如果使用 http 进行交互时,请求会被拒绝,因为存在跨域问题。来看看,nginx 是怎么解决的吧:

首先,在 enable-cors.conf 文件中设置 cors :

# allow origin list
set$ACAO'*';

# set single origin
if($http\_origin~\* (www.helloworld.com)$){
set$ACAO$http_origin;
}

if($cors="trueget") {
add_header 'Access-Control-Allow-Origin'"$http_origin";
add_header 'Access-Control-Allow-Credentials''true';
add_header 'Access-Control-Allow-Methods''GET, POST, OPTIONS';
add_header 'Access-Control-Allow-Headers''DNT,X-Mx-ReqToken,Keep-Alive,User-Agent,X-Requested-With,If-Modified-Since,Cache-Control,Content-Type';
}

if($request_method='OPTIONS') {
set$cors"${cors}options";
}

if($request_method='GET') {
set$cors"${cors}get";
}

if($request_method='POST') {
set$cors"${cors}post";
}

接下来,在你的服务器中 include enable-cors.conf 来引入跨域配置:

\# ----------------------------------------------------
# 此文件为项目 nginx 配置片段
# 可以直接在 nginx config 中 include(推荐)
# 或者 copy 到现有 nginx 中,自行配置
# www.helloworld.com 域名需配合 dns hosts 进行配置
# 其中,api 开启了 cors,需配合本目录下另一份配置文件
# ----------------------------------------------------

upstream front\_server{
  server www.helloworld.com:9000;
}
upstream api\_server{
  server www.helloworld.com:8080;
}

server {
  listen       80;
  server\_name  www.helloworld.com;

  location ~ ^/api/ {
    include enable-cors.conf;
    proxy\_pass http://api\_server;
    rewrite "^/api/(.\*)$" /$1 break;
  }

  location ~ ^/ {
    proxy\_pass http://front\_server;
  }
}

到此,就完成了。

资源

Nginx 的中文维基 https://tool.oschina.net/apidocs/apidoc?api=nginx-zh Nginx 开发从入门到精通 http://tengine.taobao.org/book/index.html nginx-admins-handbook https://github.com/trimstray/nginx-admins-handbook nginxconfig.io - 一款 Nginx 配置生成器 https://www.digitalocean.com/community/tools/nginx#?

>微信搜索:【Java小咖秀】更多精彩等着您~

>回复手册获取博主15万字Java面试通关手册&2万字Linux命令实战书册~

查看原文

赞 0 收藏 0 评论 0

小咖啊 发布了文章 · 7月3日

SELECT * 效率低,面试官:为什么

为什么大家都说SELECT * 效率低

作者 : 陈哈哈
来源: https://urlify.cn/ZvM3qe

面试官:“小陈,说一下你常用的SQL优化方式吧。”

陈小哈:“那很多啊,比如不要用SELECT *,查询效率低。巴拉巴拉...”

面试官:“为什么不要用SELECT * ?它在哪些情况下效率低呢?”
陈小哈:“SELECT * 它好像比写指定列名多一次全表查询吧,还多查了一些无用的字段。”

面试官:“嗯...”
陈小哈:“emmm~ 没了”

陈小哈:“....??(几个意思)”

面试官:“嗯...好,那你还有什么要问我的么?”
陈小哈:“我问你个锤子,把老子简历还我!”


无论在工作还是面试中,关于SQL中不要用“SELECT *”,都是大家听烂了的问题,虽说听烂了,但普遍理解还是在很浅的层面,并没有多少人去追根究底,探究其原理。

废话不多说,本文带你深入了解一下"SELECT * "效率低的原因及场景。

本文很干!请自备茶水,没时间看记得先收藏 -- 来自一位被技术经理毒打多年的程序员的忠告

一、效率低的原因

先看一下最新《阿里java开发手册(泰山版)》中 MySQL 部分描述:

4 - 1. 【强制】在表查询中,一律不要使用 * 作为查询的字段列表,需要哪些字段必须明确写明。
说明:

增加查询分析器解析成本。

增减字段容易与 resultMap 配置不一致。

无用字段增加网络 消耗,尤其是 text 类型的字段。
开发手册中比较概括的提到了几点原因,让我们深入一些看看:

1. 不需要的列会增加数据传输时间和网络开销

用“SELECT * ”数据库需要解析更多的对象、字段、权限、属性等相关内容,在 SQL 语句复杂,硬解析较多的情况下,会对数据库造成沉重的负担。

增大网络开销;* 有时会误带上如log、IconMD5之类的无用且大文本字段,数据传输size会几何增涨。如果DB和应用程序不在同一台机器,这种开销非常明显

即使 mysql 服务器和客户端是在同一台机器上,使用的协议还是 tcp,通信也是需要额外的时间。

2. 对于无用的大字段,如 varchar、blob、text,会增加 io 操作

准确来说,长度超过 728 字节的时候,会先把超出的数据序列化到另外一个地方,因此读取这条记录会增加一次 io 操作。(MySQL InnoDB)

3. 失去MySQL优化器“覆盖索引”策略优化的可能性

SELECT * 杜绝了覆盖索引的可能性,而基于MySQL优化器的“覆盖索引”策略又是速度极快,效率极高,业界极为推荐的查询优化方式。

例如,有一个表为t(a,b,c,d,e,f),其中,a为主键,b列有索引。

那么,在磁盘上有两棵 B+ 树,即聚集索引和辅助索引(包括单列索引、联合索引),分别保存(a,b,c,d,e,f)和(a,b),如果查询条件中where条件可以通过b列的索引过滤掉一部分记录,查询就会先走辅助索引,如果用户只需要a列和b列的数据,直接通过辅助索引就可以知道用户查询的数据。

如果用户使用select *,获取了不需要的数据,则首先通过辅助索引过滤数据,然后再通过聚集索引获取所有的列,这就多了一次b+树查询,速度必然会慢很多。


由于辅助索引的数据比聚集索引少很多,很多情况下,通过辅助索引进行覆盖索引(通过索引就能获取用户需要的所有列),都不需要读磁盘,直接从内存取,而聚集索引很可能数据在磁盘(外存)中(取决于buffer pool的大小和命中率),这种情况下,一个是内存读,一个是磁盘读,速度差异就很显著了,几乎是数量级的差异。

二、索引知识延申

上面提到了辅助索引,在MySQL中辅助索引包括单列索引、联合索引(多列联合),单列索引就不再赘述了,这里提一下联合索引的作用

联合索引 (a,b,c)

联合索引 (a,b,c) 实际建立了 (a)、(a,b)、(a,b,c) 三个索引

我们可以将组合索引想成书的一级目录、二级目录、三级目录,如index(a,b,c),相当于a是一级目录,b是一级目录下的二级目录,c是二级目录下的三级目录。要使用某一目录,必须先使用其上级目录,一级目录除外。

如下:

联合索引的优势

1) 减少开销

建一个联合索引 (a,b,c) ,实际相当于建了 (a)、(a,b)、(a,b,c) 三个索引。每多一个索引,都会增加写操作的开销和磁盘空间的开销。对于大量数据的表,使用联合索引会大大的减少开销!

2)覆盖索引

对联合索引 (a,b,c),如果有如下 sql 的,

SELECT a,b,c from table where a='xx' and b = 'xx';

那么 MySQL 可以直接通过遍历索引取得数据,而无需回表,这减少了很多的随机 io 操作。减少 io 操作,特别是随机 io 其实是 DBA 主要的优化策略。所以,在真正的实际应用中,覆盖索引是主要的提升性能的优化手段之一。

3)效率高

索引列多,通过联合索引筛选出的数据越少。比如有 1000W 条数据的表,有如下SQL:

select col1,col2,col3 from table where col1=1 and col2=2 and col3=3;
假设:假设每个条件可以筛选出 10% 的数据。
A. 如果只有单列索引,那么通过该索引能筛选出 1000W10%=100w 条数据,然后再回表从 100w 条数据中找到符合 col2=2 and col3= 3 的数据,然后再排序,再分页,以此类推(递归);
B. 如果是(col1,col2,col3)联合索引,通过三列索引筛选出 1000w10% 10% *10%=1w,效率提升可想而知!

索引是建的越多越好吗

答案自然是否定的

数据量小的表不需要建立索引,建立会增加额外的索引开销

不经常引用的列不要建立索引,因为不常用,即使建立了索引也没有多大意义

经常频繁更新的列不要建立索引,因为肯定会影响插入或更新的效率

数据重复且分布平均的字段,因此他建立索引就没有太大的效果(例如性别字段,只有男女,不适合建立索引)

数据变更需要维护索引,意味着索引越多维护成本越高。

更多的索引也需要更多的存储空间

三、心得体会

相信能看到这里这老铁要么是对MySQL有着一腔热血的,要么就是喜欢滚鼠标的。来了就是缘分,如果从本文学到了东西,请不要吝啬手中的赞哦,拒绝白嫖~

有朋友问我,你对SQL规范那么上心,平时你写代码不会用SELECT * 吧?

咋可能啊,天天用。。代码里也在用(一脸羞愧),其实我们的项目普遍很小,数据量也上不去,性能上还没有遇到瓶颈,所以比较放纵。

写本篇文章主要是这个知识点网上总结的很少很散,也不规范,算是给自己也是给大家总结一份比较详细的,值得记一下的。以后给面试官说完让他没法找你茬

顺便吹波牛B,谢谢各位。

微信搜索:【Java小咖秀】更多精彩等着您~

回复手册获取博主15万字Java面试通关手册&1.4万字Linux命令实战书册~

查看原文

赞 1 收藏 1 评论 1

小咖啊 发布了文章 · 7月2日

点赞功能,你用 MySQL 还是 Redis ?

作者:一起web编程

链接:www.toutiao.com/i6825148720728769028

点赞功能是目前app开发基本的功能

今天我们就来聊聊 点赞、评论、收藏等这些场景的db数据库设计问题。

1. 我们先来看看场景的需求:

  • 显示点赞数量
  • 判断用户是否点过赞,用于去重,必须的判断
  • 显示个人点赞列表,一般在用户中心
  • 显示文章点赞列表

我们先看一下头条和微博的例子

这两个都是具有顶级流量的,后端肯定有复杂的架构,我们今天只谈大众化的方案。

方案

2.1 mysql方案

mysql方案, 随着nosql的流行,大数据的持续热点,但是mysql仍然不可替代,对于大多数的中小项目,低于千万级的数据量,采用mysql分表+cache,是完全可以胜任的,而且稳定性是其他方案无可比拟的:

-- 文章表

create table post {
        post_id int(11) NOT NULL AUTO_INCREMENT,

        ......

        star_num int(11) COMMENT '点赞数量'
}

-- 用户表

create table user {
        user_id int(11) NOT NULL AUTO_INCREMENT,

        ......

        star_num int(11) COMMENT '点赞数量'
}

-- 点赞表

create table star {
        id int(11) NOT NULL AUTO_INCREMENT,

        post_id,

        user_id,

        ......
}

常用的查询:

查询用户点赞过的文章 select post_id from star where user_id=?

查询文章的点赞用户 select user_id from star where post_id=?

点赞数量可以通过定时异步统计更新到post和user 表中。

数据量不大的时候,这种设计基本可以满足需求了。

缺点:

数据量大时,一张表在查询时压力巨大,需要分表,而不论用post_id还是user_id来hash分表都与我们的需求有冲突,唯一的办法就是做两个表冗余。这增加了存储空间和维护工作量,还可能有一致性问题。

2.2 redis方案

当数据量达到上亿的量,上cache是必经的阶段,由于点赞这种动作很随意,很多人看到大拇指就想点,所以数据量增长很快,数据规模上来后,对mysql读写都有很大的压力,这时就要考虑memcache、redis进行存储或cache。

为什么一般都选择redis, redis作为流行的nosql,有着丰富的数据类型,可以适应多个场景的需求。

采用redis有两种用途,一种是storage,一种是纯cache,需要+mysql一起。纯cache就是把数据从mysql先写入redis,用户先读cache,miss后再拉取MySQL,同时cache做同步。

多数场景二者是同时使用的,并不冲突。

下面说下redis作为storage的方案:

场景a :显示点赞数量

在点赞的地方,只是显示一个点赞数量,能区分用户是否点赞过,一般用户不关心这个列表,这个场景只要一个数字就可以了,当数量比较大时,一般显示为"7k" ,"10W" 这样。

以文章id为key

//以文章id=888为例 
127.0.0.1:6379[2]> set star:tid:888 898 //设置点赞数量 
OK 
127.0.0.1:6379[2]> incr star:tid:888 //实现数量自增 (integer) 
899

场景b:点赞去重,避免重复点赞

要实现这个需求,必须有文章点赞的uid列表,以uid为key场景c:一般在用户中心,可以看到用户自己的点赞列表

这个需求可以使用场景b的数据来实现。

场景d:文章的点赞列表,类似场景b,以文章id为key

//以文章id=888为例 
127.0.0.1:6379[2]> sadd star:list:tid:888 123 456 789  //点赞uid列表 (integer) 
3 
127.0.0.1:6379[2]> sismember star:list:tid:888 456  //判断是否点赞 (integer) 
1

点赞的地方,如果点赞过显示红色,没有则显示黑白色,

今日头条是没有地方可以看到点赞列表的,而微博点进去,详情页可以看到点赞列表,但是只会显示最近的几十条,没有分页显示。

如下图,我选了一条热点,拥有众多粉丝的“猪猪”


可能有人觉得,点赞列表没人关心,存储又会浪费大量资源,不如不存!但是,这个数据是必须要有的。两点:

a. 去重。点赞数可以不精确,但去重必须是精确的,

b.另外一个社交产品,用户行为的一点一滴都需要记录,对于后续的用户行为分析和数据挖掘都是有意义的。

上面使用string存储的用户点赞数量,除了string,还可以用hash来存储,对文章id分块,每100个存到一个hash,分别存入hash table,每个文章id为hash的一个key,value存储点赞的用户id,如果点赞用户很多,避免id过多产生性能问题,可以单列出来,用sorted set结构保存,热点的毕竟是少数。

方案优缺点比对

hash:使用了更少的全局key ,节省了内存空间;但是也带来了问题

如何根据文章id路由到对应的hash?

查找一个用户id是在hash还是set?存在不确定性

使用hash虽然节省了空间,但增加了复杂度,如何选择就看个人需求了。

除此之外,你还有其他的方法吗?

3. 数据一致性

redis作为storage使用时,一定要做好数据的持久化,必须开启 rdb 和 aof,这会导致业务只能使用一半的机器内存,所以要做好容量的监控,及时扩容。

另外只要有数据copy,就会有一致性问题,这就是另外一个很重要的话题了。以后有时间再细聊吧!

写在最后:把问题写明白,真不是一件容易的事情,请大家多多关注,留言,谢谢!

前几天写的一篇文章,受到众多同行的热情回复,能和众多同行一起交流,深感荣幸!对于工程类问题,没有标准的方案,一千个人有一千个方案,哪个最适合你只有你自己知道!期待你更好的思路和方法。

微信搜索:【Java小咖秀】更多精彩等着您~
回复手册获取博主15万字Java面试通关手册&1.4万字Linux命令实战书册~
查看原文

赞 0 收藏 0 评论 0

小咖啊 发布了文章 · 6月30日

日志系统新贵Loki,确实比笨重的ELK轻

作者: inkt1234

来源:https://blog.csdn.net/Linktha...

最近,在对公司容器云的日志方案进行设计的时候,发现主流的ELK或者EFK比较重,再加上现阶段对于ES复杂的搜索功能很多都用不上最终选择了Grafana开源的Loki日志系统,下面介绍下Loki的背景。

背景和动机

当我们的容器云运行的应用或者某个节点出现问题了,解决思路应该如下:

我们的监控使用的是基于prometheus体系进行改造的,prometheus中比较重要的是metric和alert,metric是来说明当前或者历史达到了某个值,alert设置metric达到某个特定的基数触发了告警,但是这些信息明显是不够的。我们都知道,k8s的基本单位是pod,pod把日志输出到stdout和stderr,平时有什么问题我们通常在界面或者通过命令查看相关的日志,举个例子:当我们的某个pod的内存变得很大,触发了我们的alert,这个时候管理员,去页面查询确认是哪个pod有问题,然后要确认pod内存变大的原因,我们还需要去查询pod的日志,如果没有日志系统,那么我们就需要到页面或者使用命令进行查询了:

如果,这个时候应用突然挂了,这个时候我们就无法查到相关的日志了,所以需要引入日志系统,统一收集日志,而使用ELK的话,就需要在Kibana和Grafana之间切换,影响用户体验。所以 ,loki的第一目的就是最小化度量和日志的切换成本,有助于减少异常事件的响应时间和提高用户的体验

ELK存在的问题

现有的很多日志采集的方案都是采用全文检索对日志进行索引(如ELK方案),优点是功能丰富,允许复杂的操作。但是,这些方案往往规模复杂,资源占用高,操作苦难。很多功能往往用不上,大多数查询只关注一定时间范围和一些简单的参数(如host、service等),使用这些解决方案就有点杀鸡用牛刀的感觉了。因此,Loki的第二个目的是,在查询语言的易操作性和复杂性之间可以达到一个权衡。


因此,Loki的第二个目的是,在查询语言的易操作性和复杂性之间可以达到一个权衡。

成本

全文检索的方案也带来成本问题,简单的说就是全文搜索(如ES)的倒排索引的切分和共享的成本较高。后来出现了其他不同的设计方案如:OKlog(https://github.com/oklog/oklo...、基于网格的分布策略。这两个设计决策提供了大量的成本降低和非常简单的操作,但是查询不够方便。因此,Loki的第三个目的是,提高一个更具成本效益的解决方案。

整体架构

Loki的架构如下:

不难看出,Loki的架构非常简单,使用了和prometheus一样的标签来作为索引,也就是说,你通过这些标签既可以查询日志的内容也可以查询到监控的数据,不但减少了两种查询之间的切换成本,也极大地降低了日志索引的存储。Loki将使用与prometheus相同的服务发现和标签重新标记库,编写了pormtail, 在k8s中promtail以daemonset方式运行在每个节点中,通过kubernetes api等到日志的正确元数据,并将它们发送到Loki。下面是日志的存储架构:

读写

日志数据的写主要依托的是Distributor和Ingester两个组件,整体的流程如下:

Distributor

一旦promtail收集日志并将其发送给loki,Distributor就是第一个接收日志的组件。由于日志的写入量可能很大,所以不能在它们传入时将它们写入数据库。这会毁掉数据库。我们需要批处理和压缩数据。
Loki通过构建压缩数据块来实现这一点,方法是在日志进入时对其进行gzip操作,组件ingester是一个有状态的组件,负责构建和刷新chunck,当chunk达到一定的数量或者时间后,刷新到存储中去。每个流的日志对应一个ingester,当日志到达Distributor后,根据元数据和hash算法计算出应该到哪个ingester上面。

此外,为了冗余和弹性,我们将其复制n(默认情况下为3)次。

Ingester

ingester接收到日志并开始构建chunk:


基本上就是将日志进行压缩并附加到chunk上面。一旦chunk“填满”(数据达到一定数量或者过了一定期限),ingester将其刷新到数据库。我们对块和索引使用单独的数据库,因为它们存储的数据类型不同。

刷新一个chunk之后,ingester然后创建一个新的空chunk并将新条目添加到该chunk中。

Querier

读取就非常简单了,由Querier负责给定一个时间范围和标签选择器,Querier查看索引以确定哪些块匹配,并通过greps将结果显示出来。它还从Ingester获取尚未刷新的最新数据。
对于每个查询,一个查询器将为您显示所有相关日志。实现了查询并行化,提供分布式grep,使即使是大型查询也是足够的。

可扩展性

Loki的索引存储可以是cassandra/bigtable/dynamodb,而chuncks可以是各种对象存储,Querier和Distributor都是无状态的组件。对于ingester他虽然是有状态的但是,当新的节点加入或者减少,整节点间的chunk会重新分配,已适应新的散列环。而Loki底层存储的实现Cortex已经 在实际的生产中投入使用多年了。有了这句话,我可以放心的在环境中实验一把了。

微信搜索:【Java小咖秀】更多精彩等着您~
回复手册获取博主15万字Java面试通关手册&1.4万字Linux命令实战书册~
查看原文

赞 0 收藏 0 评论 0

小咖啊 发布了文章 · 6月29日

MyBatis 标签 trim,其实很强大的~

作者:wt_better

链接: http://blog.csdn.net/wt_bette...

MyBatis的trim标签一般用于去除sql语句中多余的and关键字,逗号,或者给sql语句前拼接 “where“、“set“以及“values(“ 等前缀,或者添加“)“等后缀,可用于选择性插入、更新、删除或者条件查询等操作。

以下是trim标签中涉及到的属性:

下面使用几个例子来说明trim标签的使用。

1、使用trim标签去除多余的and关键字

有这样的一个例子:

<select id="findActiveBlogLike"
     resultType="Blog">
  SELECT * FROM BLOG 
  WHERE 
  <if test="state != null">
    state = #{state}
  </if> 
  <if test="title != null">
    AND title like #{title}
  </if>
  <if test="author != null and author.name != null">
    AND author_name like #{author.name}
  </if>
</select>

如果这些条件没有一个能匹配上会发生什么?最终这条 SQL 会变成这样:

SELECT * FROM BLOG
WHERE

这会导致查询失败。如果仅仅第二个条件匹配又会怎样?这条 SQL 最终会是这样:

SELECT * FROM BLOG
WHERE 
AND title like ‘someTitle’

你可以使用where标签来解决这个问题,where 元素只会在至少有一个子元素的条件返回 SQL 子句的情况下才去插入“WHERE”子句。而且,若语句的开头为“AND”或“OR”,where 元素也会将它们去除。

<select id="findActiveBlogLike"
     resultType="Blog">
  SELECT * FROM BLOG 
  <where> 
    <if test="state != null">
         state = #{state}
    </if> 
    <if test="title != null">
        AND title like #{title}
    </if>
    <if test="author != null and author.name != null">
        AND author_name like #{author.name}
    </if>
  </where>
</select>

trim标签也可以完成相同的功能,写法如下:

<trim prefix="WHERE" prefixOverrides="AND">
    <if test="state != null">
      state = #{state}
    </if> 
    <if test="title != null">
      AND title like #{title}
    </if>
    <if test="author != null and author.name != null">
      AND author_name like #{author.name}
    </if>
</trim>

2、使用trim标签去除多余的逗号

有如下的例子:

如果红框里面的条件没有匹配上,sql语句会变成如下:

INSERT INTO role(role_name,) VALUES(roleName,)

插入将会失败。

使用trim标签可以解决此问题,只需做少量的修改,如下所示:

其中最重要的属性是

suffixOverrides=","

表示去除sql语句结尾多余的逗号.

注:如果你有兴趣的话,也可以研究下Mybatis逆向工程生成的Mapper文件,其中也使用了trim标签,但结合了foreach、choose等标签,更多的是牵扯到Criterion的源码研究。不过研究完之后,你将熟练掌握mybatis各种标签的使用,学到Criterion的设计思想,对自己的启发将会很大。

微信搜索:【Java小咖秀】,更多精彩等着您~
回复【手册】获取博主15万字(80%原创) 《Java面试通关手册》 & 《Linux命令实战手册》~
查看原文

赞 0 收藏 0 评论 0

小咖啊 发布了文章 · 6月28日

玩转Java8中的 Stream 之从零认识 Stream

作者:litesky

来源: http://www.jianshu.com/p/11c9...

相信Java8的Stream 大家都已听说过了,但是可能大家不会用或者用的不熟,文章将带大家从零开始使用,循序渐进,带你走向Stream的巅峰。

操作符

什么是操作符呢?操作符就是对数据进行的一种处理工作,一道加工程序;就好像工厂的工人对流水线上的产品进行一道加工程序一样。

Stream的操作符大体上分为两种:中间操作符和终止操作符

中间操作符

对于数据流来说,中间操作符在执行制定处理程序后,数据流依然可以传递给下一级的操作符。

中间操作符包含8种(排除了parallel,sequential,这两个操作并不涉及到对数据流的加工操作):

map(mapToInt,mapToLong,mapToDouble) 转换操作符,把比如A->B,这里默认提供了转int,long,double的操作符。
flatmap(flatmapToInt,flatmapToLong,flatmapToDouble) 拍平操作比如把 int[]{2,3,4} 拍平 变成 2,3,4 也就是从原来的一个数据变成了3个数据,这里默认提供了拍平成int,long,double的操作符。
limit 限流操作,比如数据流中有10个 我只要出前3个就可以使用。
distint 去重操作,对重复元素去重,底层使用了equals方法。
filter 过滤操作,把不想要的数据过滤。
peek 挑出操作,如果想对数据进行某些操作,如:读取、编辑修改等。
skip 跳过操作,跳过某些元素。
sorted(unordered) 排序操作,对元素排序,前提是实现Comparable接口,当然也可以自定义比较器。

终止操作符

数据经过中间加工操作,就轮到终止操作符上场了;终止操作符就是用来对数据进行收集或者消费的,数据到了终止操作这里就不会向下流动了,终止操作符只能使用一次。

collect 收集操作,将所有数据收集起来,这个操作非常重要,官方的提供的Collectors 提供了非常多收集器,可以说Stream 的核心在于Collectors。
count 统计操作,统计最终的数据个数。
findFirst、findAny 查找操作,查找第一个、查找任何一个 返回的类型为Optional。
noneMatch、allMatch、anyMatch 匹配操作,数据流中是否存在符合条件的元素 返回值为bool 值。
min、max 最值操作,需要自定义比较器,返回数据流中最大最小的值。
reduce 规约操作,将整个数据流的值规约为一个值,count、min、max底层就是使用reduce。
forEach、forEachOrdered 遍历操作,这里就是对最终的数据进行消费了。
toArray 数组操作,将数据流的元素转换成数组。
这里只介绍了Stream,并没有涉及到IntStream、LongStream、DoubleStream,这三个流实现了一些特有的操作符,我将在后续文章中介绍到。Java知音公众号内回复“面试题聚合”,送你一份各大公司面试汇总宝典。

说了这么多,只介绍这些操作符还远远不够;俗话说,实践出真知。那么,Let‘s go。

代码演练

Stream 的一系列操作必须要使用终止操作,否者整个数据流是不会流动起来的,即处理操作不会执行。

map,可以看到 map 操作符要求输入一个Function的函数是接口实例,功能是将T类型转换成R类型的。

map操作将原来的单词 转换成了每个单的长度,利用了String自身的length()方法,该方法返回类型为int。这里我直接使用了lambda表达式,关于lambda表达式 还请读者们自行了解吧。

public class Main {

    public static void main(String[] args) {
        Stream.of("apple","banana","orange","waltermaleon","grape")
                .map(e->e.length()) //转成单词的长度 int
                .forEach(e->System.out.println(e)); //输出
    }
}

当然也可以这样,这里使用了成员函数引用,为了便于读者们理解,后续的例子中将使用lambda表达式而非函数引用。

public class Main {

    public static void main(String[] args) {
         Stream.of("apple","banana","orange","waltermaleon","grape")
                .map(String::length) //转成单词的长度 int
                .forEach(System.out::println);
    }
}

结果如图:

mapToInt 将数据流中得元素转成Int,这限定了转换的类型Int,最终产生的流为IntStream,及结果只能转化成int。

public class Main {

    public static void main(String[] args) {
         Stream.of("apple", "banana", "orange", "waltermaleon", "grape")
                .mapToInt(e -> e.length()) //转成int
                .forEach(e -> System.out.println(e));
    }
}

mapToInt如图:

mapToLong、mapToDouble 与mapToInt 类似

public class Main {

    public static void main(String[] args) {
         Stream.of("apple", "banana", "orange", "waltermaleon", "grape")
                .mapToLong(e -> e.length()) //转成long ,本质上是int 但是存在类型自动转换
                .forEach(e -> System.out.println(e));
    }
}

mapToLong 如图:

public class Main {

    public static void main(String[] args) {
         Stream.of("apple", "banana", "orange", "waltermaleon", "grape")
                .mapToDouble(e -> e.length()) //转成Double ,自动类型转换成Double
                .forEach(e -> System.out.println(e));
    }
}

mapToDouble如图:

flatmap 作用就是将元素拍平拍扁 ,将拍扁的元素重新组成Stream,并将这些Stream 串行合并成一条Stream

public class Main {

    public static void main(String[] args) {
        Stream.of("a-b-c-d","e-f-i-g-h")
                .flatMap(e->Stream.of(e.split("-")))
                .forEach(e->System.out.println(e));

    }
}

flatmap 如图:

flatmapToInt、flatmapToLong、flatmapToDouble 跟flatMap 都类似的,只是类型被限定了,这里就不在举例子了。

limit 限制元素的个数,只需传入 long 类型 表示限制的最大数

public class Main {

    public static void main(String[] args) {
        Stream.of(1,2,3,4,5,6)
                .limit(3) //限制三个
                .forEach(e->System.out.println(e)); //将输出 前三个 1,2,3
    }
}

limit如图:

public class Main {

    public static void main(String[] args) {

        Stream.of(1,2,3,1,2,5,6,7,8,0,0,1,2,3,1)
                .distinct() //去重
                .forEach(e->System.out.println(e));

    }
}

distinct 如图:

filter 对某些元素进行过滤,不符合筛选条件的将无法进入流的下游

public class Main {

    public static void main(String[] args) {
        Stream.of(1,2,3,1,2,5,6,7,8,0,0,1,2,3,1)
                .filter(e->e>=5) //过滤小于5的
                .forEach(e->System.out.println(e));
    }
}

filter 如图:

peek 挑选 ,将元素挑选出来,可以理解为提前消费

public class Main {

    public static void main(String[] args) {

        User w = new User("w",10);
        User x = new User("x",11);
        User y = new User("y",12);

        Stream.of(w,x,y)
                .peek(e->{e.setName(e.getAge()+e.getName());}) //重新设置名字 变成 年龄+名字
                .forEach(e->System.out.println(e.toString()));

    }

    static class User {

        private String name;

        private int age;

        public User(String name, int age) {
            this.name = name;
            this.age = age;
        }

        public String getName() {
            return name;
        }

        public void setName(String name) {
            this.name = name;
        }

        public int getAge() {
            return age;
        }

        public void setAge(int age) {
            this.age = age;
        }

        @Override
        public String toString() {
            return "User{" +
                    "name='" + name + '\'' +
                    ", age=" + age +
                    '}';
        }
    }

}

peek 如图:

skip 跳过 元素

public class Main {

    public static void main(String[] args) {
        Stream.of(1,2,3,4,5,6,7,8,9)
                .skip(4) //跳过前四个
                .forEach(e->System.out.println(e)); //输出的结果应该只有5,6,7,8,9
    }
}

skip 如图:

sorted 排序 底层依赖Comparable 实现,也可以提供自定义比较器
这里Integer 实现了比较器

public class Main {

    public static void main(String[] args) {
        Stream.of(2,1,3,6,4,9,6,8,0)
                .sorted()
                .forEach(e->System.out.println(e));
    }
}

sorted 默认比较器如图:

这里使用自定义比较,当然User 可以实现Comparable 接口

public class Main {

    public static void main(String[] args) {

        User x = new User("x",11);
        User y = new User("y",12);
        User w = new User("w",10);

        Stream.of(w,x,y)
                .sorted((e1,e2)->e1.age>e2.age?1:e1.age==e2.age?0:-1)
                .forEach(e->System.out.println(e.toString()));

    }

    static class User {

        private String name;

        private int age;

        public User(String name, int age) {
            this.name = name;
            this.age = age;
        }

        public String getName() {
            return name;
        }

        public void setName(String name) {
            this.name = name;
        }

        public int getAge() {
            return age;
        }

        public void setAge(int age) {
            this.age = age;
        }

        @Override
        public String toString() {
            return "User{" +
                    "name='" + name + '\'' +
                    ", age=" + age +
                    '}';
        }
    }

}

如图:

collect 收集,使用系统提供的收集器可以将最终的数据流收集到List,Set,Map等容器中。
这里我使用collect 将元素收集到一个set中

public class Main {

    public static void main(String[] args) {
        Stream.of("apple", "banana", "orange", "waltermaleon", "grape")
                .collect(Collectors.toSet()) //set 容器
                .forEach(e -> System.out.println(e));
    }
}

咦?,不是说终止操作符只能使用一次吗,为什么这里调用了forEach 呢?forEach不仅仅是是Stream 中得操作符还是各种集合中得一个语法糖,不信咋们试试。Java知音公众号内回复“面试题聚合”,送你一份各大公司面试汇总宝典。

public class Main {

    public static void main(String[] args) {

        Set<String> stringSet = Stream.of("apple", "banana", "orange", "waltermaleon", "grape")
                .collect(Collectors.toSet()); //收集的结果就是set
        stringSet.forEach(e->System.out.println(e)); set的语法糖forEach
}

结果如图:

count 统计数据流中的元素个数,返回的是long 类型

public class Main {

    public static void main(String[] args) {

        long count = Stream.of("apple", "banana", "orange", "waltermaleon", "grape")
                .count();

        System.out.println(count);
    }
}

count 如图:

findFirst 获取流中的第一个元素
这里找到第一个元素 apple

public class FindFirst {

    public static void main(String[] args) {
        Optional<String> stringOptional = Stream.of("apple", "banana", "orange", "waltermaleon", "grape")
                .findFirst();
        stringOptional.ifPresent(e->System.out.println(e));
    }
}

findFirst 结果如图:

findAny 获取流中任意一个元素

public class FindAny {

    public static void main(String[] args) {
        Optional<String> stringOptional = Stream.of("apple", "banana", "orange", "waltermaleon", "grape")
                .parallel()
                .findAny(); //在并行流下每次返回的结果可能一样也可能不一样
        stringOptional.ifPresent(e->System.out.println(e));
    }
}

findAny 在并行流下 使用结果:

输出了orange

输出了banana

noneMatch 数据流中得没有一个元素与条件匹配的
这里 的作用是是判断数据流中 一个都没有与aa 相等元素 ,但是流中存在 aa ,所以最终结果应该是false

public class NoneMatch {

    public static void main(String[] args) {
        boolean result = Stream.of("aa","bb","cc","aa")
                .noneMatch(e->e.equals("aa"));
        System.out.println(result);
    }
}

noneMatch 如图:

allMatch和anyMatch 一个是全匹配,一个是任意匹配 和noneMatch 类似,这里就不在举例了。

min 最小的一个,传入比较器,也可能没有(如果数据流为空)

public class Main {

    public static void main(String[] args) {

        Optional<Integer> integerOptional = Stream.of(0,9,8,4,5,6,-1)
                .min((e1,e2)->e1.compareTo(e2));

        integerOptional.ifPresent(e->System.out.println(e));

    }

min如图:

max 元素中最大的,需要传入比较器,也可能没有(流为Empty时)

public class Main {

    public static void main(String[] args) {

        Optional<Integer> integerOptional = Stream.of(0,9,8,4,5,6,-1)
                .max((e1,e2)->e1.compareTo(e2));

        integerOptional.ifPresent(e->System.out.println(e));

    }
}

max 如图:

reduce 是一个规约操作,所有的元素归约成一个,比如对所有元素求和,乘啊等。
这里实现了一个加法,指定了初始化的值

public class Main {
    public static void main(String[] args) {

        int sum = Stream.of(0,9,8,4,5,6,-1)
              .reduce(0,(e1,e2)->e1+e2);
        System.out.println(sum);
    }
}

reduce 如图:

forEach
forEach 其实前就已经见过了,对每个数据遍历迭代

forEachOrdered 适用用于并行流的情况下进行迭代,能保证迭代的有序性
这里通过并行的方式输出数字

public class ForEachOrdered {
    public static void main(String[] args) {
        Stream.of(0,2,6,5,4,9,8,-1)
                .parallel()
                .forEachOrdered(e->{
                    System.out.println(Thread.currentThread().getName()+": "+e);});
    }
}

forEachOrdered 如图:

toArray 转成数组,可以提供自定义数组生成器

public class ToArray {
    public static void main(String[] args) {
        Object[] objects=Stream.of(0,2,6,5,4,9,8,-1)
                .toArray();

        for (int i = 0; i < objects.length; i++) {
            System.out.println(objects[i]);
        }
    }
}

toArray 如图:

总结

Java8 Stream就带大家认识到这里,如果你能跟着我的文章把每一个例子都敲一遍,相信都能掌握这些操作符的初步用法。

微信搜索:Java小咖秀回复“手册”,获取Java核心面试手册+linux实用命令手册一份。
查看原文

赞 0 收藏 0 评论 0

小咖啊 发布了文章 · 6月26日

近两年流行面试题:Spring循环依赖问题

作者:Vt

原文:https://juejin.im/post/5e927e...

前言

Spring 如何解决的循环依赖,是近两年流行起来的一道Java 面试题。

其实笔者本人对这类框架源码题还是持一定的怀疑态度的。

如果笔者作为面试官,可能会问一些诸如 “如果注入的属性为 null,你会从哪几个方向去排查” 这些场景题

那么既然写了这篇文章,闲话少说,发车看看 Spring 是如何解决的循环依赖,以及带大家看清循环依赖的本质是什么。

正文

通常来说,如果问 Spring 内部如何解决循环依赖,一定是单默认的单例 Bean 中,属性互相引用的场景。

比如几个 Bean 之间的互相引用:

甚至自己 “循环” 依赖自己:

先说明前提:原型 (Prototype) 的场景是不支持循环依赖的,通常会走到AbstractBeanFactory类中下面的判断,抛出异常。

if (isPrototypeCurrentlyInCreation(beanName)) {
  throw new BeanCurrentlyInCreationException(beanName);
}

原因很好理解,创建新的 A 时,发现要注入原型字段 B,又创建新的 B 发现要注入原型字段 A...

这就套娃了, 你猜是先 StackOverflow 还是 OutOfMemory?

Spring 怕你不好猜,就先抛出了 BeanCurrentlyInCreationException

基于构造器的循环依赖,就更不用说了,官方文档都摊牌了,你想让构造器注入支持循环依赖,是不存在的,不如把代码改了。

那么默认单例的属性注入场景,Spring 是如何支持循环依赖的?

Spring 解决循环依赖

首先,Spring 内部维护了三个 Map,也就是我们通常说的三级缓存。

笔者翻阅 Spring 文档倒是没有找到三级缓存的概念,可能也是本土为了方便理解的词汇。

在 Spring 的DefaultSingletonBeanRegistry类中,你会赫然发现类上方挂着这三个 Map:

singletonObjects 它是我们最熟悉的朋友,俗称 “单例池”“容器”,缓存创建完成单例 Bean 的地方。

singletonFactories 映射创建 Bean 的原始工厂

earlySingletonObjects 映射 Bean 的早期引用,也就是说在这个 Map 里的 Bean 不是完整的,甚至还不能称之为 “Bean”,只是一个 Instance.

后两个 Map 其实是 “垫脚石” 级别的,只是创建 Bean 的时候,用来借助了一下,创建完成就清掉了。

所以笔者前文对 “三级缓存” 这个词有些迷惑,可能是因为注释都是以 Cache of 开头吧。

为什么成为后两个 Map 为垫脚石,假设最终放在 singletonObjects 的 Bean 是你想要的一杯 “凉白开”。

那么 Spring 准备了两个杯子,即 singletonFactories 和 earlySingletonObjects 来回 “倒腾” 几番,把热水晾成“凉白开” 放到 singletonObjects 中。

闲话不说,都浓缩在图里。

上面的是一张 GIF,如果你没看到可能还没加载出来。三秒一帧,不是你电脑卡。

笔者画了 17 张图简化表述了 Spring 的主要步骤,GIF 上方即是刚才提到的三级缓存,下方展示是主要的几个方法。

当然了,这个地步你肯定要结合 Spring 源码来看,要不肯定看不懂。

如果你只是想大概了解,或者面试,可以先记住笔者上文提到的 “三级缓存”,以及下文即将要说的本质。

循环依赖的本质

上文了解完 Spring 如何处理循环依赖之后,让我们跳出 “阅读源码” 的思维,假设让你实现一个有以下特点的功能,你会怎么做?

将指定的一些类实例为单例

类中的字段也都实例为单例

支持循环依赖

举个例子,假设有类 A:

public class A {
    private B b;
}
类 B:

public class B {
    private A a;
}

说白了让你模仿 Spring:假装 A 和 B 是被 @Component 修饰,
并且类中的字段假装是 @Autowired 修饰的,处理完放到 Map 中。

其实非常简单,笔者写了一份粗糙的代码,可供参考:

    /**
     * 放置创建好的bean Map
     */
    private static Map<String, Object> cacheMap = new HashMap<>(2);

    public static void main(String[] args) {
        // 假装扫描出来的对象
        Class[] classes = {A.class, B.class};
        // 假装项目初始化实例化所有bean
        for (Class aClass : classes) {
            getBean(aClass);
        }
        // check
        System.out.println(getBean(B.class).getA() == getBean(A.class));
        System.out.println(getBean(A.class).getB() == getBean(B.class));
    }

    @SneakyThrows
    private static <T> T getBean(Class<T> beanClass) {
        // 本文用类名小写 简单代替bean的命名规则
        String beanName = beanClass.getSimpleName().toLowerCase();
        // 如果已经是一个bean,则直接返回
        if (cacheMap.containsKey(beanName)) {
            return (T) cacheMap.get(beanName);
        }
        // 将对象本身实例化
        Object object = beanClass.getDeclaredConstructor().newInstance();
        // 放入缓存
        cacheMap.put(beanName, object);
        // 把所有字段当成需要注入的bean,创建并注入到当前bean中
        Field[] fields = object.getClass().getDeclaredFields();
        for (Field field : fields) {
            field.setAccessible(true);
            // 获取需要注入字段的class
            Class<?> fieldClass = field.getType();
            String fieldBeanName = fieldClass.getSimpleName().toLowerCase();
            // 如果需要注入的bean,已经在缓存Map中,那么把缓存Map中的值注入到该field即可
            // 如果缓存没有 继续创建
            field.set(object, cacheMap.containsKey(fieldBeanName)
                    ? cacheMap.get(fieldBeanName) : getBean(fieldClass));
        }
        // 属性填充完成,返回
        return (T) object;
    }

这段代码的效果,其实就是处理了循环依赖,并且处理完成后,cacheMap 中放的就是完整的 “Bean” 了

这就是 “循环依赖” 的本质,而不是 “Spring 如何解决循环依赖”。

之所以要举这个例子,是发现一小部分盆友陷入了 “阅读源码的泥潭”,而忘记了问题的本质。

为了看源码而看源码,结果一直看不懂,却忘了本质是什么。

如果真看不懂,不如先写出基础版本,逆推 Spring 为什么要这么实现,可能效果会更好。

what?问题的本质居然是 two sum!

看完笔者刚才的代码有没有似曾相识?没错,和 two sum 的解题是类似的。

不知道 two sum 是什么梗的,笔者和你介绍一下:

two sum 是刷题网站 leetcode 序号为 1 的题,也就是大多人的算法入门的第一题。

常常被人调侃,有算法面的公司,被面试官钦定了,合的来。那就来一道 two sum 走走过场。

问题内容是:给定一个数组,给定一个数字。返回数组中可以相加得到指定数字的两个索引。

比如:给定nums = [2, 7, 11, 15], target = 9
那么要返回 [0, 1],因为2 + 7 = 9

这道题的优解是,一次遍历 + HashMap:

class Solution {
    public int[] twoSum(int[] nums, int target) {
        Map<Integer, Integer> map = new HashMap<>();
        for (int i = 0; i < nums.length; i++) {
            int complement = target - nums[i];
            if (map.containsKey(complement)) {
                return new int[] { map.get(complement), i };
            }
            map.put(nums[i], i);
        }
        throw new IllegalArgumentException("No two sum solution");
    }
}

//作者:LeetCode
//链接:https://leetcode-cn.com/problems/two-sum/solution/liang-shu-zhi-he-by-leetcode-2/
//来源:力扣(LeetCode)

先去 Map 中找需要的数字,没有就将当前的数字保存在 Map 中,如果找到需要的数字,则一起返回。

和笔者上面的代码是不是一样?

先去缓存里找 Bean,没有则实例化当前的 Bean 放到 Map,如果有需要依赖当前 Bean 的,就能从 Map 取到。

结尾

如果你是上文笔者提到的 “陷入阅读源码的泥潭” 的读者,上文应该可以帮助到你。

可能还有盆友有疑问,为什么一道 “two-sum”,Spring 处理的如此复杂?
这个想想 Spring 支持多少功能就知道了,各种实例方式.. 各种注入方式.. 各种 Bean 的加载,校验.. 各种 callback,aop 处理等等..

Spring 可不只有依赖注入,同样 Java 也不仅是 Spring。如果我们陷入了某个 “牛角尖”,不妨跳出来看看,可能会更佳清晰哦。

本文已经被https://www.javaxks.com 收录
查看原文

赞 0 收藏 0 评论 0

小咖啊 发布了文章 · 6月24日

面试难题: 为什么HashMap的加载因子默认值是0.75呢?

来源:blog.csdn.net/NYfor2017/article/details/105454097

文前调侃:黄金比例是0.618

前言

有很多东西之前在学的时候没怎么注意,笔者也是在重温HashMap的时候发现有很多可以去细究的问题,最终是会回归于数学的,如HashMap的加载因子为什么是0.75?

本文主要对以下内容进行介绍:

  • 为什么HashMap需要加载因子?
  • 解决冲突有什么方法?
  • 为什么加载因子一定是0.75?而不是0.8,0.6?

(若文章有不正之处,或难以理解的地方,请多多谅解,欢迎指正)

为什么HashMap需要加载因子?

HashMap的底层是哈希表,是存储键值对的结构类型,它需要通过一定的计算才可以确定数据在哈希表中的存储位置:

static final int hash(Object key) {
 int h;

        return (key == null) ? 0: (h = key.hashCod()) ^ (h >>> 16);

    }

//AbstractMap

public int hashCode() {
   int h = 0;
  Iterator<Entry<K,V>> i = entrySet().iterator();
  while (i.hasNext())
     h += i.next().hashCode();
    return h;
}
   

一般的数据结构,不是查询快就是插入快,HashMap就是一个插入慢、查询快的数据结构。但这种数据结构容易产生两种问题:

① 如果空间利用率高,那么经过的哈希算法计算存储位置的时候,会发现很多存储位置已经有数据了(哈希冲突);

② 如果为了避免发生哈希冲突,增大数组容量,就会导致空间利用率不高。

而加载因子就是表示Hash表中元素的填满程度。

加载因子 = 填入表中的元素个数 / 散列表的长度

加载因子越大,填满的元素越多,空间利用率越高,但发生冲突的机会变大了;

加载因子越小,填满的元素越少,冲突发生的机会减小,但空间浪费了更多了,而且还会提高扩容rehash操作的次数。

冲突的机会越大,说明需要查找的数据还需要通过另一个途径查找,这样查找的成本就越高。因此,必须在“冲突的机会”与“空间利用率”之间,寻找一种平衡与折衷。

所以我们也能知道,影响查找效率的因素主要有这几种:

  • 散列函数是否可以将哈希表中的数据均匀地散列?
  • 怎么处理冲突?
  • 哈希表的加载因子怎么选择?

本文主要对后两个问题进行介绍。

解决冲突有什么方法?

1. 开放定址法

Hi= (H(key) + di) MOD m,其中i=1,2,...,k(k<=m-1)

H(key)为哈希函数,m为哈希表表长,di为增量序列,i为已发生冲突的次数。其中,开放定址法根据步长不同可以分为3种:

1.1 线性探查法(Linear Probing):di = 1,2,3,…,m-1

简单地说,就是以当前冲突位置为起点,步长为1循环查找,直到找到一个空的位置,如果循环完了都占不到位置,就说明容器已经满了。举个栗子,就像你在饭点去街上吃饭,挨家去看是否有位置一样。

1.2 平方探测法(Quadratic Probing):di = ±12, ±22,±32,…,±k2(k≤m/2)

相对于线性探查法,这就相当于的步长为di = i2来循环查找,直到找到空的位置。以上面那个例子来看,现在你不是挨家去看有没有位置了,而是拿手机算去第i2家店,然后去问这家店有没有位置。

1.3 伪随机探测法:di = 伪随机数序列

这个就是取随机数来作为步长。还是用上面的例子,这次就是完全按心情去选一家店问有没有位置了。

但开放定址法有这些缺点

  • 这种方法建立起来的哈希表,当冲突多的时候数据容易堆集在一起,这时候对查找不友好;
  • 删除结点的时候不能简单将结点的空间置空,否则将截断在它填入散列表之后的同义词结点查找路径。因此如果要删除结点,只能在被删结点上添加删除标记,而不能真正删除结点;
  • 如果哈希表的空间已经满了,还需要建立一个溢出表,来存入多出来的元素。

2. 再哈希法

Hi= RHi(key), 其中i=1,2,...,k

RHi()函数是不同于H()的哈希函数,用于同义词发生地址冲突时,计算出另一个哈希函数地址,直到不发生冲突位置。这种方法不容易产生堆集,但是会增加计算时间。

所以再哈希法的缺点是:

  • 增加了计算时间。

3. 建立一个公共溢出区

假设哈希函数的值域为[0, m-1],设向量HashTable[0,…,m-1]为基本表,每个分量存放一个记录,另外还设置了向量OverTable[0,…,v]为溢出表。基本表中存储的是关键字的记录,一旦发生冲突,不管他们哈希函数得到的哈希地址是什么,都填入溢出表

但这个方法的缺点在于:

  • 查找冲突数据的时候,需要遍历溢出表才能得到数据。

4. 链地址法(拉链法)

将冲突位置的元素构造成链表。在添加数据的时候,如果哈希地址与哈希表上的元素冲突,就放在这个位置的链表上。

拉链法的优点

  • 处理冲突的方式简单,且无堆集现象,非同义词绝不会发生冲突,因此平均查找长度较短;
  • 由于拉链法中各链表上的结点空间是动态申请的,所以它更适合造表前无法确定表长的情况;
  • 删除结点操作易于实现,只要简单地删除链表上的相应的结点即可。

拉链法的缺点

需要额外的存储空间。

从HashMap的底层结构中我们可以看到,HashMap采用是数组+链表/红黑树的组合来作为底层结构,也就是开放地址法+链地址法的方式来实现HashMap。

至于为什么在JDK1.8的时候要运用到红黑树,下篇文章会介绍。

为什么HashMap加载因子一定是0.75?而不是0.8,0.6?

从上文我们知道,HashMap的底层其实也是哈希表(散列表),而解决冲突的方式是链地址法。HashMap的初始容量大小默认是16,为了减少冲突发生的概率,当HashMap的数组长度到达一个临界值的时候,就会触发扩容,把所有元素rehash之后再放在扩容后的容器中,这是一个相当耗时的操作。

而这个临界值就是由加载因子和当前容器的容量大小来确定的:

临界值 = DEFAULT_INITIAL_CAPACITY * DEFAULT_LOAD_FACTOR

即默认情况下是16x0.75=12时,就会触发扩容操作。

那么为什么选择了0.75作为HashMap的加载因子呢?笔者不才,通过看源码解释和大佬的文章,才知道这个跟一个统计学里很重要的原理——泊松分布有关。

泊松分布是统计学和概率学常见的离散概率分布,适用于描述单位时间内随机事件发生的次数的概率分布。有兴趣的读者可以看看维基百科或者阮一峰老师的这篇文章:泊松分布和指数分布:10分钟教程

等号的左边,P 表示概率,N表示某种函数关系,t 表示时间,n 表示数量。等号的右边,λ 表示事件的频率。

在HashMap的源码中有这么一段注释:

/* Ideally, under random hashCodes, the frequency of

     * nodes in bins follows a Poisson distribution

     * (http://en.wikipedia.org/wiki/Poisson_distribution) with a

     * parameter of about 0.5 on average for the default resizing

     * threshold of 0.75, although with a large variance because of

     * resizing granularity. Ignoring variance, the expected

     * occurrences of list size k are (exp(-0.5) * pow(0.5, k) /

     * factorial(k)). The first values are:

     *

     * 0:    0.60653066

     * 1:    0.30326533

     * 2:    0.07581633

     * 3:    0.01263606

     * 4:    0.00157952

     * 5:    0.00015795

     * 6:    0.00001316

     * 7:    0.00000094

     * 8:    0.00000006

     * more: less than 1 in ten million

笔者拙译:在理想情况下,使用随机哈希码,在扩容阈值(加载因子)为0.75的情况下,节点出现在频率在Hash桶(表)中遵循参数平均为0.5的泊松分布。忽略方差,即X = λt,P(λt = k),其中λt = 0.5的情况,按公式:

计算结果如上述的列表所示,当一个bin中的链表长度达到8个元素的时候,概率为0.00000006,几乎是一个不可能事件。

所以我们可以知道,其实常数0.5是作为参数代入泊松分布来计算的,而加载因子0.75是作为一个条件,当HashMap长度为length/size ≥ 0.75时就扩容,在这个条件下,冲突后的拉链长度和概率结果为:

0:    0.60653066

1:    0.30326533

2:    0.07581633

3:    0.01263606

4:    0.00157952

5:    0.00015795

6:    0.00001316

7:    0.00000094

8:    0.00000006

那么为什么不可以是0.8或者0.6呢?

HashMap中除了哈希算法之外,有两个参数影响了性能:初始容量和加载因子。初始容量是哈希表在创建时的容量,加载因子是哈希表在其容量自动扩容之前可以达到多满的一种度量

在维基百科来描述加载因子:

对于开放定址法,加载因子是特别重要因素,应严格限制在0.7-0.8以下。超过0.8,查表时的CPU缓存不命中(cache missing)按照指数曲线上升。因此,一些采用开放定址法的hash库,如Java的系统库限制了加载因子为0.75,超过此值将resize散列表。

在设置初始容量时应该考虑到映射中所需的条目数及其加载因子,以便最大限度地减少扩容rehash操作次数,所以,一般在使用HashMap时建议根据预估值设置初始容量,以便减少扩容操作。

选择0、75作为默认的加载因子,完全是时间和空间成本上寻求的一种折衷选择

结语

曾经有一堆高数、线性代数、离散数学摆在我面前,但是我没有珍惜。等到碰到各种数学问题的时候,才后悔莫及。学计算机的时候最痛苦的事,莫过于此。如果老天可以再给我一个,再来一次的机会的话。我会跟当时的我,说三个字——“学数学!”
数学真的太重要。离开大学之后,该怎么学数学啊,有什么好的建议吗?

如果本文对你有帮助,请给一个赞吧,这会是我最大的动力~

微信搜索:Java小咖秀,回复‘610’获取博主收集的500套实用代码。
查看原文

赞 0 收藏 0 评论 0

小咖啊 发布了文章 · 6月23日

干掉if...else,让代码看起来更简单

作者:艾瑞克·邵

来源:http://39sd.cn/30CC3

不知道大家被没有比较深的if...else折磨过或者坑过,过多的if...else以及比较深的if...else会造成可读性的降低,使得维护成本变高,本文讲解如果去掉if...else。

前言

if...else 是所有高级编程语言都有的必备功能。但现实中的代码往往存在着过多的 if...else。虽然 if...else 是必须的,但滥用 if...else 会对代码的可读性、可维护性造成很大伤害,进而危害到整个软件系统。现在软件开发领域出现了很多新技术、新概念,但 if...else 这种基本的程序形式并没有发生太大变化。使用好 if...else 不仅对于现在,而且对于将来,都是十分有意义的。今天我们就来看看如何“干掉”代码中的 if...else,还代码以清爽。

问题一:if…else 过多

问题表现

if...else 过多的代码可以抽象为下面这段代码。其中只列出5个逻辑分支,但实际工作中,能见到一个方法包含10个、20个甚至更多的逻辑分支的情况。另外,if...else 过多通常会伴随着另两个问题:逻辑表达式复杂和 if...else 嵌套过深。对于后两个问题,本文将在下面两节介绍。本节先来讨论 if...else 过多的情况。

if (condition1) {

} else if (condition2) {

} else if (condition3) {

} else if (condition4) {

} else {

}

通常,if...else 过多的方法,通常可读性和可扩展性都不好。从软件设计角度讲,代码中存在过多的 if...else 往往意味着这段代码违反了违反单一职责原则和开闭原则。因为在实际的项目中,需求往往是不断变化的,新需求也层出不穷。所以,软件系统的扩展性是非常重要的。而解决 if...else 过多问题的最大意义,往往就在于提高代码的可扩展性。

如何解决

接下来我们来看如何解决 if...else 过多的问题。下面我列出了一些解决方法。

表驱动
职责链模式
注解驱动
事件驱动
有限状态机
Optional
Assert
多态

方法一:表驱动

介绍

对于逻辑表达模式固定的 if...else 代码,可以通过某种映射关系,将逻辑表达式用表格的方式表示;再使用表格查找的方式,找到某个输入所对应的处理函数,使用这个处理函数进行运算。

适用场景

逻辑表达模式固定的 if...else

实现与示例
if (param.equals(value1)) {
    doAction1(someParams);
} else if (param.equals(value2)) {
    doAction2(someParams);
} else if (param.equals(value3)) {
    doAction3(someParams);
}
// ...

可重构为

Map<?, Function<?> action> actionMappings = new HashMap<>(); // 这里泛型 ? 是为方便演示,实际可替换为你需要的类型

// When init
actionMappings.put(value1, (someParams) -> { doAction1(someParams)});
actionMappings.put(value2, (someParams) -> { doAction2(someParams)});
actionMappings.put(value3, (someParams) -> { doAction3(someParams)});

// 省略 null 判断
actionMappings.get(param).apply(someParams);

上面的示例使用了 Java 8 的 Lambda 和 Functional Interface,这里不做讲解。
表的映射关系,可以采用集中的方式,也可以采用分散的方式,即每个处理类自行注册。也可以通过配置文件的方式表达。总之,形式有很多。

还有一些问题,其中的条件表达式并不像上例中的那样简单,但稍加变换,同样可以应用表驱动。下面借用《编程珠玑》中的一个税金计算的例子:

if income <= 2200
  tax = 0
else if income <= 2700
  tax = 0.14 * (income - 2200)
else if income <= 3200
  tax = 70 + 0.15 * (income - 2700)
else if income <= 3700
  tax = 145 + 0.16 * (income - 3200)
......
else
  tax = 53090 + 0.7 * (income - 102200)

对于上面的代码,其实只需将税金的计算公式提取出来,将每一档的标准提取到一个表格,在加上一个循环即可。具体重构之后的代码不给出,大家自己思考。

方法二:职责链模式

介绍

当 if...else 中的条件表达式灵活多变,无法将条件中的数据抽象为表格并用统一的方式进行判断时,这时应将对条件的判断权交给每个功能组件。并用链的形式将这些组件串联起来,形成完整的功能。

适用场景

条件表达式灵活多变,没有统一的形式。

实现与示例

职责链的模式在开源框架的 Filter、Interceptor 功能的实现中可以见到很多。下面看一下通用的使用模式:

重构前:

public void handle(request) {
    if (handlerA.canHandle(request)) {
        handlerA.handleRequest(request);
    } else if (handlerB.canHandle(request)) {
        handlerB.handleRequest(request);
    } else if (handlerC.canHandle(request)) {
        handlerC.handleRequest(request);
    }
}

重构后:

public void handle(request) {
  handlerA.handleRequest(request);
}

public abstract class Handler {
  protected Handler next;
  public abstract void handleRequest(Request request);
  public void setNext(Handler next) { this.next = next; }
}

public class HandlerA extends Handler {
  public void handleRequest(Request request) {
    if (canHandle(request)) doHandle(request);
    else if (next != null) next.handleRequest(request);
  }
}

当然,示例中的重构前的代码为了表达清楚,做了一些类和方法的抽取重构。现实中,更多的是平铺式的代码实现。

注:职责链的控制模式

职责链模式在具体实现过程中,会有一些不同的形式。从链的调用控制角度看,可分为外部控制和内部控制两种。

外部控制不灵活,但是减少了实现难度。职责链上某一环上的具体实现不用考虑对下一环的调用,因为外部统一控制了。但是一般的外部控制也不能实现嵌套调用。如果有嵌套调用,并且希望由外部控制职责链的调用,实现起来会稍微复杂。具体可以参考 Spring Web Interceptor 机制的实现方法。

内部控制就比较灵活,可以由具体的实现来决定是否需要调用链上的下一环。但如果调用控制模式是固定的,那这样的实现对于使用者来说是不便的。

设计模式在具体使用中会有很多变种,大家需要灵活掌握

方法三:注解驱动

介绍

通过 Java 注解(或其它语言的类似机制)定义执行某个方法的条件。在程序执行时,通过对比入参与注解中定义的条件是否匹配,再决定是否调用此方法。具体实现时,可以采用表驱动或职责链的方式实现。

适用场景

适合条件分支很多多,对程序扩展性和易用性均有较高要求的场景。通常是某个系统中经常遇到新需求的核心功能。

实现与示例

很多框架中都能看到这种模式的使用,比如常见的 Spring MVC。因为这些框架很常用,demo 随处可见,所以这里不再上具体的演示代码了。

这个模式的重点在于实现。现有的框架都是用于实现某一特定领域的功能,例如 MVC。故业务系统如采用此模式需自行实现相关核心功能。主要会涉及反射、职责链等技术。具体的实现这里就不做演示了。

方法四:事件驱动

介绍

通过关联不同的事件类型和对应的处理机制,来实现复杂的逻辑,同时达到解耦的目的。

适用场景

从理论角度讲,事件驱动可以看做是表驱动的一种,但从实践角度讲,事件驱动和前面提到的表驱动有多处不同。具体来说:

表驱动通常是一对一的关系;事件驱动通常是一对多;
表驱动中,触发和执行通常是强依赖;事件驱动中,触发和执行是弱依赖

正是上述两者不同,导致了两者适用场景的不同。具体来说,事件驱动可用于如订单支付完成触发库存、物流、积分等功能。

实现与示例

实现方式上,单机的实践驱动可以使用 Guava、Spring 等框架实现。分布式的则一般通过各种消息队列方式实现。但是因为这里主要讨论的是消除 if...else,所以主要是面向单机问题域。因为涉及具体技术,所以此模式代码不做演示。
方法五:有限状态机

介绍

有限状态机通常被称为状态机(无限状态机这个概念可以忽略)。先引用维基百科上的定义:
有限状态机(英语:finite-state machine,缩写:FSM),简称状态机,是表示有限个状态以及在这些状态之间的转移和动作等行为的数学模型。
其实,状态机也可以看做是表驱动的一种,其实就是当前状态和事件两者组合与处理函数的一种对应关系。当然,处理成功之后还会有一个状态转移处理。

适用场景

虽然现在互联网后端服务都在强调无状态,但这并不意味着不能使用状态机这种设计。其实,在很多场景中,如协议栈、订单处理等功能中,状态机有这其天然的优势。因为这些场景中天然存在着状态和状态的流转。

实现与示例

实现状态机设计首先需要有相应的框架,这个框架需要实现至少一种状态机定义功能,以及对于的调用路由功能。状态机定义可以使用 DSL 或者注解的方式。原理不复杂,掌握了注解、反射等功能的同学应该可以很容易实现。

参考技术:
Apache Mina State Machine

Apache Mina 框架,虽然在 IO 框架领域不及 Netty,但它却提供了一个状态机的功能。https://mina.apache.org/mina-...。有自己实现状态机功能的同学可以参考其源码。

Spring State Machine

Spring 子项目众多,其中有个不显山不露水的状态机框架 —— Spring State Machine https://projects.spring.io/sp...。可以通过 DSL 和注解两种方式定义。

上述框架只是起到一个参考的作用,如果涉及到具体项目,需要根据业务特点自行实现状态机的核心功能。

方法六:Optional

介绍

Java 代码中的一部分 if...else 是由非空检查导致的。因此,降低这部分带来的 if...else 也就能降低整体的 if...else 的个数。

Java 从 8 开始引入了 Optional 类,用于表示可能为空的对象。这个类提供了很多方法,用于相关的操作,可以用于消除 if...else。开源框架 Guava 和 Scala 语言也提供了类似的功能。

使用场景

有较多用于非空判断的 if...else。

实现与示例

传统写法:

String str = "Hello World!";
if (str != null) {
    System.out.println(str);
} else {
    System.out.println("Null");
}
使用 Optional 之后:
1 Optional<String> strOptional = Optional.of("Hello World!");
2 strOptional.ifPresentOrElse(System.out::println, () -> System.out.println("Null"));

Optional 还有很多方法,这里不一一介绍了。但请注意,不要使用 get() 和 isPresent() 方法,否则和传统的 if...else 无异。

扩展:Kotlin Null Safety

Kotlin 带有一个被称为 Null Safety 的特性:
bob?.department?.head?.name

对于一个链式调用,在 Kotlin 语言中可以通过 ?. 避免空指针异常。如果某一环为 null,那整个链式表达式的值便为 null。

方法七:Assert 模式

介绍

上一个方法适用于解决非空检查场景所导致的 if...else,类似的场景还有各种参数验证,比如还有字符串不为空等等。很多框架类库,例如 Spring、Apache Commons 都提供了工具里,用于实现这种通用的功能。这样大家就不必自行编写 if...else 了。

Apache Commons Lang 中的 Validate 类:https://commons.apache.org/pr...
Spring 的 Assert 类:https://docs.spring.io/spring...

使用场景

通常用于各种参数校验

扩展:Bean Validation

类似上一个方法,介绍 Assert 模式顺便介绍一个有类似作用的技术 —— Bean Validation。Bean Validation 是 Java EE 规范中的一个。Bean Validation 通过在 Java Bean 上用注解的方式定义验证标准,然后通过框架统一进行验证。也可以起到了减少 if...else 的作用。

方法八:多态

介绍

使用面向对象的多态,也可以起到消除 if...else 的作用。在代码重构这本书中,对此也有介绍:
https://refactoring.com/catal...

使用场景

链接中给出的示例比较简单,无法体现适合使用多态消除 if...else 的具体场景。一般来说,当一个类中的多个方法都有类似于示例中的 if...else 判断,且条件相同,那就可以考虑使用多态的方式消除 if...else。

同时,使用多态也不是彻底消除 if...else。而是将 if...else 合并转移到了对象的创建阶段。在创建阶段的 if..,我们可以使用前面介绍的方法处理。

小结

上面这节介绍了 if...else 过多所带来的问题,以及相应的解决方法。除了本节介绍的方法,还有一些其它的方法。比如,在《重构与模式》一书中就介绍了“用 Strategy 替换条件逻辑”、“用 State 替换状态改变条件语句”和“用 Command 替换条件调度程序”这三个方法。其中的“Command 模式”,其思想同本文的“表驱动”方法大体一致。另两种方法,因为在《重构与模式》一书中已做详细讲解,这里就不再重复。

何时使用何种方法,取决于面对的问题的类型。上面介绍的一些适用场景,只是一些建议,更多的需要开发人员自己的思考。

问题二:if…else 嵌套过深

问题表现

if...else 多通常并不是最严重的的问题。有的代码 if...else 不仅个数多,而且 if...else 之间嵌套的很深,也很复杂,导致代码可读性很差,自然也就难以维护。

if (condition1) {
    action1();
    if (condition2) {
        action2();
        if (condition3) {
            action3();
            if (condition4) {
                action4();
            }
        }
    }
}

if...else 嵌套过深会严重地影响代码的可读性。当然,也会有上一节提到的两个问题。
如何解决

上一节介绍的方法也可用用来解决本节的问题,所以对于上面的方法,此节不做重复介绍。这一节重点一些方法,这些方法并不会降低 if...else 的个数,但是会提高代码的可读性:

抽取方法
卫语句

方法一:抽取方法

介绍

抽取方法是代码重构的一种手段。定义很容易理解,就是将一段代码抽取出来,放入另一个单独定义的方法。借
https://refactoring.com/catal... 中的定义:

适用场景

if...else 嵌套严重的代码,通常可读性很差。故在进行大型重构前,需先进行小幅调整,提高其代码可读性。抽取方法便是最常用的一种调整手段。

实现与示例

重构前:

public void add(Object element) {
  if (!readOnly) {
    int newSize = size + 1;
    if (newSize > elements.length) {
      Object[] newElements = new Object[elements.length + 10];
      for (int i = 0; i < size; i++) {
        newElements[i] = elements[i];
      }

      elements = newElements
    }
    elements[size++] = element;
  }
}

重构后:

public void add(Object element) {
  if (readOnly) {
    return;
  }

  if (overCapacity()) {
    grow();
  }

  addElement(element);
}

方法二:卫语句

介绍

在代码重构中,有一个方法被称为“使用卫语句替代嵌套条件语句”https://refactoring.com/catal...。直接看代码:

double getPayAmount() {
    double result;
    if (_isDead) result = deadAmount();
    else {
        if (_isSeparated) result = separatedAmount();
        else {
            if (_isRetired) result = retiredAmount();
            else result = normalPayAmount();
        };
    }
    return result;
}

重构之后

double getPayAmount() {
    if (_isDead) return deadAmount();
    if (_isSeparated) return separatedAmount();
    if (_isRetired) return retiredAmount();
    return normalPayAmount();
}
使用场景

当看到一个方法中,某一层代码块都被一个 if...else 完整控制时,通常可以采用卫语句。

问题三:if…else 表达式过于复杂

问题表现

if...else 所导致的第三个问题来自过于复杂的条件表达式。下面给个简单的例子,当 condition 1、2、3、4 分别为 true、false,请大家排列组合一下下面表达式的结果。

1 if ((condition1 && condition2 ) || ((condition2 || condition3) && condition4)) {
2   
3 }

我想没人愿意干上面的事情。关键是,这一大坨表达式的含义是什么?关键便在于,当不知道表达式的含义时,没人愿意推断它的结果。

所以,表达式复杂,并不一定是错。但是表达式难以让人理解就不好了。

如何解决

对于 if...else 表达式复杂的问题,主要用代码重构中的抽取方法、移动方法等手段解决。因为这些方法在《代码重构》一书中都有介绍,所以这里不再重复。

总结

本文一个介绍了10种(算上扩展有12种)用于消除、简化 if...else 的方法。还有一些方法,如通过策略模式、状态模式等手段消除 if...else 在《重构与模式》一书中也有介绍。

正如前言所说,if...else 是代码中的重要组成部分,但是过度、不必要地使用 if...else,会对代码的可读性、可扩展性造成负面影响,进而影响到整个软件系统。

“干掉”if...else 的能力高低反映的是程序员对软件重构、设计模式、面向对象设计、架构模式、数据结构等多方面技术的综合运用能力,反映的是程序员的内功。要合理使用 if...else,不能没有设计,也不能过度设计。这些对技术的综合、合理地运用都需要程序员在工作中不断的摸索总结。

新人博主求3连。微信搜索【Java小咖秀】,回复”610“获取博主收集的500套实用代码。
查看原文

赞 2 收藏 1 评论 1

小咖啊 发布了文章 · 6月21日

月薪10K、15K、20K的Java程序员分别需要掌握哪些技术?

作者:_MarkerHub_
链接:https://zhuanlan.zhihu.com/p/...

月薪10K、15K、20K的Java程序员分别需要掌握哪些技术?

大家好,我是吕一明,我们又见面了。今天我们聊聊一个大家普遍关心的问题,java程序员的工资,以及对应的技术水平。

一般来说,做技术都是工作经验越丰富越吃香,当然了也有很多人说35岁以后的程序员就很难找工作了!

所以在自己刚入行工作的前3年,一定要不断提升自己的技术能力。自己也要准备一份面试题大全,业余时间把面试的题目都去认真了解、研究一遍。做到随时都可以辞职面试的状态,有备无患!

ok,回到我们之前的话题,月薪10k,15k,20k分析需要掌握什么样的技术,相信这才是你最关心的。

月薪10K左右:

属于小白-1年经验,java入门级别。普遍学会java基础,常用框架中Springboot、mybatis能够灵活使用,懂得一下原理性的东西,然后自己做几个项目,简历再包装一下2年经验,好好准备一下面试,这样通过面试的概率就很高了。当然了,1年经验的同学如果技术还可以,包装一下3年经验也可以哈,工资的话13K、15k可以尝试一下。

所以,你应该准备这样一份面试题:

10K面试题:

1.抽象类和接口的关系和区别,以及你在时间开发过程中是怎么使用到的?

2.你知道反射机制和动态代理吗?

3.一个线程连续两次调用start方法会发生什么?简单谈谈线程的几种状态?

4.springmvc实现原理?

5.mybatis中#$的区别?

6.你知道设计模式吗?在实际运用中你会怎样去运用他?比如我这里有个策划打折活动,

比如VIP, 普通用户,顾客分别打不一样的折扣,你会用什么设计模式?

7.你知道索引失效嘛?举例看看?

8.多态在实际项目的使用?

9.你知道Spring IOC吗?Spring是怎么创建对象的?

10.你知道缓存机制不?

11.你的项目中有用到数据库分库分片吗?数据库分库分片规则?

12.在实际中你会怎样对sql语句进行优化?

13.常见的数据结构有哪些?在JAVA中是怎么使用到他们的?

14.JVM原理你知道嘛?有没自己调优过?

15.看你的项目里用到了springboot,谈谈你对springboot的理解?

16.你项目里用到了rocket MQ,那你知道rabbit MQ、rocket MQ和kafka他们之间的区别嘛?

能简单说说不?

17.redis常运用场景有哪些?你的项目中主要使用到redis是用到干嘛的?

18.有自己部署过redis嘛?redis是如何实现高可用的?

19.了解mysql的读写分离嘛?是如何实现高可用的?

20.Exception和Error的关系和区别?

21.基本数据类型转换为String时你有几种方法,分别是什么?

22.如何利用JDK不依赖外部工具,实现一个简单的缓存机制?请简述用到的技术和思路。

23.你项目中是怎样用到事务的?分布式锁呢?

24.Zookeeper有哪些运用场景?

月薪15K左右:

恭喜你,终于算个小高手啦,能独立搭建和负责完成一个完整项目。还记得我以前在外包公司,拿着15K工资,领导给了我一个项目,负责开发一个政府的资产管理管理系统,功能不会很复杂,会设计到资产的收纳、录入、报废等过程,其中还会涉及到条形码设计,和硬件标枪的扫码自动录入和识别等。是复杂也不算特别复杂,只要把各种表关系、字段等提前设计好,灵活运用代码生成工具,就会少写很多代码。

15K的能力,我们应该对springboot、springcloud、分布式锁、事务、多线程并发问题、JVM底层、网络层等知识要能理解并灵活运用!你应该准备这样一份面试题:

15K面试题

http://1.IO/NIO的区别,为什么要用NIO,使用IO中的Buffered..也能实现NIO的面向缓冲,什么情况下用NIO?

2.熟悉的排序算法有哪些,快速排序算法的实现原理?

3.HashMap与ConcurrentHashMap有什么区别?HashMap的存储结构?

4.vector、ArrayList、LinkedList区别及存储性能。

5.线程实现的几种方式,有什么区别,一般用哪个,为什么?

6.多线程中线程池怎样使用及其实现原理?

7.volatile关键字的作用是什么?

8.synchronized关键字的作用,使用该关键字后保证同步了,同步代码块与同步方法有什么区别?

9.一个线程可以多次start吗,会报错吗?

10.spring AOP IOC实现原理?

11.spring中的事务的传播方式怎样实现的?

12.spring中事务实现的原理?

13.为什么要使用数据库索引,数据库索引有哪些,索引的底层原理是什么?

14.sql查询缓慢怎么处理,sql优化方案有哪些,explain用过吗?

15.数据库中的锁有几种?

比如行锁、表锁等会深问

16.数据库为什么要使用事务,事务的原理?

17.数据库分库分表的方法,垂直分还是水平分,根据哪些来分?

18count(1) count(5) count(*)有什么区别,100万条数据的效率如何?

19.solr搜索实现原理、使用的排序算法是什么,怎样实现快速查询?

20.3次握手的原理是什么?

21.动态代理实现原理是什么和动态代理使用的方法、类有哪些?

22.redis的数据结构有哪些?

23.虚拟机了解多少?

24.spring默认是单利还是多例的?

25.常用的队列有哪些?什么情况下使用?

26.你知道的线程安全的类有哪些,方法有哪些?

27.数据库的乐观锁和悲观锁的原理及使用?(version)

28.对GC了解多少?

29.堆和栈的区别,堆中存放什么,栈中存放什么?

30.用过的中间件有哪些?

月薪20K以上:

你已经是个大神级别的人物了,技术牛逼,是公司里的高级工程师、项目经理,或者架构师,能独挡一面,下面会有几个小弟,主要负责公司的整体项目把控。服务宕机了,老板骂你;下属写了个Bug导致损失,老板骂你;半夜老板打电话给你,说临时有个想法;大早上甲方打电话给你,说需求再改改。我只能说,压力山大。

大神级的面试题:

20K面试题

1.您认为的“大规模高并发访问的Web”有哪些呢. 请举例2个知名的网站

2.您开发过的核心功能,哪些呢

3.如果让你对外开发一个接口,你会考虑哪些因素?

4.设计数据库的时候会考虑哪些因素,怎样去建表?

5.说说负载均衡,缓存,文件数据库技术的心得和要点。

6.性能评估机制,指哪方面呢。 您有这方面的经验和体会吗?

7.精通UML、以及熟练使用一种或多种建模工具。

8.您常去的技术网站是什么。工作做用过什么辅助软件呢?

结束语

非常羡慕拿这么高工资的人呀,我还特别羡慕那些年终奖有4,5个月工资甚至半年以上的,牛逼轰轰的。

好了,今天就先聊到这吧,朝着自己学习的方向奋斗,总有一天你也会拿着别人羡慕的工资,而每天再多努力一点,你就会让这一天提前一点到来。相信自己,我能行!

查看原文

赞 2 收藏 2 评论 0

认证与成就

  • 获得 8 次点赞
  • 获得 1 枚徽章 获得 0 枚金徽章, 获得 0 枚银徽章, 获得 1 枚铜徽章

擅长技能
编辑

(゚∀゚ )
暂时没有

开源项目 & 著作
编辑

(゚∀゚ )
暂时没有

注册于 5月5日
个人主页被 161 人浏览