redis分布式锁

工具类：
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
package redis;

import org.apache.commons.lang3.math.NumberUtils;
import redis.clients.jedis.Jedis;

import java.util.Objects;

/**
 * <pre>https://blog.csdn.net/rich_family/article/details/79034808</pre>
 *
 * @author: zhengyong Date: 2018/7/6 Time: 下午5:32
 */
public class RedisDistributedLock {


    /**
     * 获取锁直到成功
     *
     * @param jedis   redis客户端
     * @param key     锁key
     * @param timeout 锁超时时间
     */
    public void tryLockSuccess(Jedis jedis, String key, long timeout) {
        // 一直循环直到获取到锁
        while (!this.tryLock(jedis, key, timeout)) {
        }
    }

    /**
     * 获取锁
     *
     * @param jedis   redis客户端
     * @param key     锁key
     * @param timeout 锁超时时间
     * @return true / false
     */
    public boolean tryLock(Jedis jedis, String key, long timeout) {
        long currentTime = System.currentTimeMillis();
        String expires = String.valueOf(timeout + currentTime);
        //设置互斥量
        if (jedis.setnx(key, expires) > 0) {
            return true;
        } else {
            // 未获取到锁，判断锁是否超时
            String currentLockTime = jedis.get(key);
            //检查锁是否超时, 如果超时，尝试获取锁
            if (currentLockTime != null && Long.parseLong(currentLockTime) < currentTime) {
                //获取旧的锁时间并设置互斥量
                String oldLockTime = jedis.getSet(key, expires);
                //旧值与当前时间比较
                if (oldLockTime != null && Objects.equals(oldLockTime, currentLockTime)) {
                    return true;
                }
            }
            return false;
        }
    }

    /**
     * 释放锁（如果锁已超时，那么锁可能已由其他线程获得，这时直接执行 DEL lock.id 操作会导致把其他线程已获得的锁释放掉。所以这里只删除未超时的lock.id）
     *
     * @param jedis redis客户端
     * @param key   锁key
     * @return true / false
     */
    public boolean unlock(Jedis jedis, String key) {
        //判断锁是否超时，没有超时才将互斥量删除
        String expire = jedis.get(key);
        long lockExpiresTime = NumberUtils.toLong(expire);
        if (lockExpiresTime > System.currentTimeMillis()) {
            jedis.del(key);
        }
        return true;
    }

}
测试类：
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
package redis;

import redis.clients.jedis.Jedis;

/**
 * @author: zhengyong Date: 2018/7/6 Time: 下午5:56
 */
public class RedisTest {
    /**
     * redis ip
     */
    private static final String redisHost = "127.0.0.1";
    /**
     * redis 端口
     */
    private static final int redisPort = 6379;
    /**
     * redis读取超时时间
     */
    private static final int redisTimeout = 1000000;
    /**
     * 锁超时2秒
     */
    private static final long lockTimeout = 2000;

    private static RedisDistributedLock lock = new RedisDistributedLock();

    private static int count = 0;

    public static void main(String[] args) throws InterruptedException {
        // 多线程测试分布式锁
        for (int i = 0; i < 100; i++) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    Jedis jedis = new Jedis(redisHost, redisPort, redisTimeout);
                    execute(jedis);
                }
            }).start();
        }
        Thread.sleep(3000);
        System.out.println(count);
    }

    private static void execute(Jedis jedis) {
        String key = "execute";
        // 获取分布式锁
        lock.tryLockSuccess(jedis, key, lockTimeout);
        try {
            count++;
        } finally {
            lock.unlock(jedis, key);
        }
    }
}

展开全文 >>

java8-lambda表达式之stream

Stream API

新添加的Stream API（java.util.stream） 把真正的函数式编程风格引入到Java中。

示列代码：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
package java8.lambda;

import java.util.Arrays;
import java.util.IntSummaryStatistics;
import java.util.List;
import java.util.stream.Collectors;

/**
 * java 8 lambada 基础操作（http://www.runoob.com/java/java8-streams.html）
 *
 * @author: zhengyong Date: 2018/11/1 Time: 上午10:49
 */
public class Test {

    public static void main(String[] args) {

        //Runnable是一个函数接口，只包含了有个无参数的，返回void的run方法；
        //所以lambda表达式左边没有参数，右边也没有return，只是单纯的打印一句话
        new Thread(() -> System.out.println("Test Java8 lambda!")).start();

        //In Java 8:
        List<String> features = Arrays.asList("Lambdas", "Default Method", "Stream API", "Date and Time API");

        // 1. forEach: 迭代流中的每个数据
        System.out.println("\n... 1. start forEach");
        features.forEach(n -> System.out.println(n));

        System.out.println("\n... 2. start stream ");
        System.out.println("... 3. start map");
        // 2. stream: 为集合创建串行流
        // 3. map: 映射每个元素到对应的结果
        features.stream().map((s) -> s + "***").forEach(System.out::println);

        // 4. filter: 用于通过设置的条件过滤出元素
        System.out.println("\n... 4. start filter");
        features.stream().filter(f -> f.startsWith("L")).forEach(System.out::println);

        // 5. limit: 用于获取指定数量的流
        System.out.println("\n... 5. start limit");
        features.stream().limit(2).forEach(System.out::println);

        // 6. sorted: 用于对流进行排序
        System.out.println("\n... 6. start sorted");
        features.stream().sorted().forEach(System.out::println);

        // 7. parallel: 为集合创建并行流
        System.out.println("\n... 7. start parallel stream");
        features.parallelStream().filter(f -> f.startsWith("L")).forEach(System.out::println);

        // 8.Collectors :实现了很多归约操作
        System.out.println("\n... 8. start Collectors");
        List<String> list = features.stream().filter(f -> f.startsWith("L")).collect(Collectors.toList());
        String str = features.stream().filter(f -> !f.isEmpty()).collect(Collectors.joining(","));
        System.out.println("Collectors list=" + list);
        System.out.println("Collectors str=" + str);

        // 9. summaryStatistics: 统计结果的收集器也非常有用。它们主要用于int、double、long等基本类型上
        System.out.println("\n... 8. start summaryStatistics");
        List<Integer> numbers = Arrays.asList(3, 2, 2, 3, 7, 3, 5);
        IntSummaryStatistics stats = numbers.stream().mapToInt(x -> x).summaryStatistics();
        System.out.println("列表中最大的数 : " + stats.getMax());
        System.out.println("列表中最小的数 : " + stats.getMin());
        System.out.println("所有数之和 : " + stats.getSum());
        System.out.println("平均数 : " + stats.getAverage());
    }
}
运行结果：
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
Test Java8 lambda!

... 1. start forEach
Lambdas
Default Method
Stream API
Date and Time API

... 2. start stream 
... 3. start map
Lambdas***
Default Method***
Stream API***
Date and Time API***

... 4. start filter
Lambdas

... 5. start limit
Lambdas
Default Method

... 6. start sorted
Date and Time API
Default Method
Lambdas
Stream API

... 7. start parallel stream
Lambdas

... 8. start Collectors
Collectors list=[Lambdas]
Collectors str=Lambdas,Default Method,Stream API,Date and Time API

... 8. start summaryStatistics
列表中最大的数 : 7
列表中最小的数 : 2
所有数之和 : 25
平均数 : 3.5714285714285716

展开全文 >>

awk使用

首先建立文本log.txt:

1
2
3
4
2 this is a test
3 Are you like awk
This's a test
10 There are orange,apple,mongo

A. 每行按空格或TAB分割，输出文本中的1、4项, 例如：awk '{print $1,$4}' log.txt

1
2
3
4
5
6
$ awk '{print $1,$4}' log.txt

2 a
3 like
This's
10 orange,apple,mongo

B. 使用”,”分割，例如：awk -F, '{print $1,$2}' log.txt

1
2
3
4
5
6
$ awk -F, '{print $1,$2}' log.txt

2 this is a test
3 Are you like awk
This's a test
10 There are orange apple

C. 使用多个分隔符.先使用空格分割，然后对分割结果再使用”,”分割. 例如：awk -F '[ ,]' '{print $1,$2,$5}' log.txt

1
2
3
4
5
6
$ awk -F '[ ,]'  '{print $1,$2,$5}' log.txt

2 this test
3 Are awk
This's a
10 There apple

D. 使用awk -v设置变量a=1, 例如：awk -v a=1 '{print $1,$1+a}' log.txt

1
2
3
4
5
6
$ awk -v a=1 '{print $1,$1+a}' log.txt

2 3
3 4
This's 1
10 11

E. 使用脚本，例如：awk -f cal.awk log.txt

F. awk使用运算符

1) 过滤第一例大于2的行. 例如：awk '$1>2' log.txt

2) 过滤第一列大于2并且第二列等于’Are’的行. 例如：awk '$1>2 && $2=="Are" {print $1,$2,$3}' log.txt

G. awk正使用则表达式

注意：~ 表示模式开始。// 中是模式。

例子：

1
2
3
4
# 输出第二列包含 "th"，并打印第二列与第四列
$ awk '$2 ~ /th/ {print $2,$4}' log.txt
---------------------------------------------
this a
1
2
3
4
5
# 输出包含"re" 的行
$ awk '/re/ ' log.txt
---------------------------------------------
3 Are you like awk
10 There are orange,apple,mongo
1
2
3
4
5
# 忽略大小写
$ awk 'BEGIN{IGNORECASE=1} /this/' log.txt
---------------------------------------------
2 this is a test
This's a test

H. awk脚本

BEGIN{ 这里面放的是执行前的语句 }

END {这里面放的是处理完所有的行后要执行的语句 }

{这里面放的是处理每一行时要执行的语句}

例如cal.awk内容如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
#!/bin/awk -f
#运行前
BEGIN {
    math = 0
    english = 0
    computer = 0
 
    printf "NAME    NO.   MATH  ENGLISH  COMPUTER   TOTAL\n"
    printf "---------------------------------------------\n"
}
#运行中
{
    math+=$3
    english+=$4
    computer+=$5
    printf "%-6s %-6s %4d %8d %8d %8d\n", $1, $2, $3,$4,$5, $3+$4+$5
}
#运行后
END {
    printf "---------------------------------------------\n"
    printf "  TOTAL:%10d %8d %8d \n", math, english, computer
    printf "AVERAGE:%10.2f %8.2f %8.2f\n", math/NR, english/NR, computer/NR
}

G. 统计行数

1
awk '/error/' app.log | awk 'END {print NR}'

或者：

1
grep -c 'error' app.log

参考：http://www.runoob.com/linux/linux-comm-awk.html

展开全文 >>

docker使用

一、简介

Docker 和传统虚拟化方式的不同之处。传统虚拟机技术是虚拟出一套硬件后，在其上运行一个完整操作系统，在该系统上再运行所需应用进程；而容器内的应用进程直接运行于宿主的内核，容器内没有自己的内核，而且也没有进行硬件虚拟。因此容器要比传统虚拟机更为轻便

镜像（Image）和容器（Container）的关系，就像是面向对象程序设计中的类和实例一样，镜像是静态的定义，容器是镜像运行时的实体。容器可以被创建、启动、停止、删除、暂停等

二、安装须知

操作系统: Mac OS Yosemite 10.10.5

Mac地址：https://download.docker.com/mac/stable/Docker.dmg

Docker.dmg：安装提供Docker Engine，Docker CLI客户端，Docker Compose和Docker Machine

三、安装

1）运行Docker.dmg安装

2）配置个人加速镜像（我使用阿里云https://cr.console.aliyun.com/#/accelerator）

3) 运行docker version和docker info检查

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
➜ docker version
Client:
 Version:      17.03.0-ce
 API version:  1.26
 Go version:   go1.7.5
 Git commit:   60ccb22
 Built:        Thu Feb 23 10:40:59 2017
 OS/Arch:      darwin/amd64

Server:
 Version:      17.03.0-ce
 API version:  1.26 (minimum version 1.12)
 Go version:   go1.7.5
 Git commit:   3a232c8
 Built:        Tue Feb 28 07:52:04 2017
 OS/Arch:      linux/amd64
 Experimental: true
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
➜ docker info
Containers: 1
 Running: 1
 Paused: 0
 Stopped: 0
Images: 1
Server Version: 17.03.0-ce
Storage Driver: overlay2
 Backing Filesystem: extfs
 Supports d_type: true
 Native Overlay Diff: true
Logging Driver: json-file
Cgroup Driver: cgroupfs
Plugins:
 Volume: local
 Network: bridge host ipvlan macvlan null overlay
Swarm: inactive
Runtimes: runc
Default Runtime: runc
Init Binary: docker-init
containerd version: 977c511eda0925a723debdc94d09459af49d082a
runc version: a01dafd48bc1c7cc12bdb01206f9fea7dd6feb70
init version: 949e6fa
Security Options:
 seccomp
  Profile: default
Kernel Version: 4.9.12-moby
Operating System: Alpine Linux v3.5
OSType: linux
Architecture: x86_64
CPUs: 2
Total Memory: 1.952 GiB
Name: moby
ID: V5PN:CAOJ:YYKT:B7IK:PTP3:OQKS:Q26Q:UJYZ:OG2K:HSPK:WRME:KJP5
Docker Root Dir: /var/lib/docker
Debug Mode (client): false
Debug Mode (server): true
 File Descriptors: 23
 Goroutines: 32
 System Time: 2017-03-27T03:33:06.945792584Z
 EventsListeners: 1
No Proxy: 127.0.0.1
Registry: https://index.docker.io/v1/
Experimental: true
Insecure Registries:
 127.0.0.0/8
Registry Mirrors:
 https://xxxxx.mirror.aliyuncs.com
Live Restore Enabled: false

四、运行nginx

启动运行nginx, 执行docker run -d -p 80:80 --name webserver nginx

1
2
3
4
5
6
7
8
9
➜ docker run -d -p 80:80 --name webserver nginx
Unable to find image 'nginx:latest' locally
latest: Pulling from library/nginx
693502eb7dfb: Pull complete
6decb850d2bc: Pull complete
c3e19f087ed6: Pull complete
Digest: sha256:52a189e49c0c797cfc5cbfe578c68c225d160fb13a42954144b29af3fe4fe335
Status: Downloaded newer image for nginx:latest
4b11e6ed897d6df195936f60916ffda704d55f75645270f338a10b68480112e7

启动bash命令交互操作客户端

1
2
➜ docker exec -it webserver bash
root@2964bd62006a:/#

停止niginx, 运行docker stop webserver

1
2
➜ docker stop webserver
webserver

删除nginx, 运行docker rm webserver

1
2
➜ docker rm webserver
webserver

五、运行ubuntu

镜像官方仓库：https://hub.docker.com/explore/

下载ubuntu

1
2
3
4
5
6
7
8
9
➜ docker pull ubuntu:14.04
14.04: Pulling from library/ubuntu
30d541b48fc0: Pull complete
8ecd7f80d390: Pull complete
46ec9927bb81: Pull complete
2e67a4d67b44: Pull complete
7d9dd9155488: Pull complete
Digest: sha256:62a5dce5ceccd7f1cb2672a571ebee52cad1f08eec9b57fe4965fb0968a9602e
Status: Downloaded newer image for ubuntu:14.04

启动运行ubuntu

-it：这是两个参数，一个是 -i：交互式操作，一个是 -t 终端。我们这里打算进入 bash 执行一些命令并查看返回结果，因此我们需要交互式终端。

–rm：这个参数是说容器退出后随之将其删除。默认情况下，为了排障需求，退出的容器并不会立即删除，除非手动 docker rm。我们这里只是随便执行个命令，看看结果，不需要排障和保留结果，因此使用 –rm 可以避免浪费空间。

ubuntu:14.04：这是指用 ubuntu:14.04 镜像为基础来启动容器。

–name myUbuntu：给容器取一个别名叫myUbuntu

1
2
➜ docker run -it --rm --name myUbuntu ubuntu:14.04
root@2ef73a93ef7b:/#

或者不指定ubuntu版本，直接启动时，直接下载最新版本ubuntu:latest

1
2
3
4
5
6
7
8
9
10
11
➜ docker run -it --name myUbuntu ubuntu:14.04
Unable to find image 'ubuntu:latest' locally
latest: Pulling from library/ubuntu
d54efb8db41d: Pull complete
f8b845f45a87: Pull complete
e8db7bf7c39f: Pull complete
9654c40e9079: Pull complete
6d9ef359eaaa: Pull complete
Digest: sha256:dd7808d8792c9841d0b460122f1acf0a2dd1f56404f8d1e56298048885e45535
Status: Downloaded newer image for ubuntu:latest
root@366ea11633cf:/#

停止ubuntu容器

1
2
➜ docker stop myUbuntu
myUbuntu

删除ubuntu容器

1
2
➜ docker rm myUbuntu
myUbuntu

查看历史镜像

1
2
3
4
➜ docker images
REPOSITORY          TAG                 IMAGE ID            CREATED             SIZE
nginx               latest              6b914bbcb89e        3 weeks ago         182 MB
ubuntu              14.04               7c09e61e9035        3 weeks ago         188 MB

删除ubuntu镜像

使用docker rmi <IMAGE ID>删除，但是必须先要docker rm myUbuntu才能删除镜像

1
2
3
4
5
6
7
8
9
➜ docker rmi 7c09e61e9035
Untagged: ubuntu:14.04
Untagged: ubuntu@sha256:62a5dce5ceccd7f1cb2672a571ebee52cad1f08eec9b57fe4965fb0968a9602e
Deleted: sha256:7c09e61e90350e8f5c0cba2979003bdfe32c2d027b68b4f0cf9063cdd7b4bafd
Deleted: sha256:304aecb5e13929f85d3ce2e9d83d0212866c8e55a460c94cf24bd75da1c7c153
Deleted: sha256:f302be18d46a45c0edbbd9b4bc02db764a4b0b8cd9bd0490f33dfaff039a3b62
Deleted: sha256:c523f3173f6028e5329fd401331c375f7b9b9e831d915fafaf358f55e36e3747
Deleted: sha256:94e631422130dc414878fd05efe3d59de44c9d8904696a7c299a83f378a92845
Deleted: sha256:c29b5eadf94a90a2abda13e765d4fad4825fd15621dea1d9a98b60b89b835c2a

查看docker进程

1
2
3
➜ docker ps -a
CONTAINER ID        IMAGE               COMMAND             CREATED              STATUS                      PORTS               NAMES
366ea11633cf        ubuntu              "/bin/bash"         About a minute ago   Exited (0) 59 seconds ago                       myUbuntu

六、制作自定义nginx

1) 启动nginx

1
2
3
4
5
6
7
8
9
➜  docker run -d -p 80:80 --name webserver nginx
Unable to find image 'nginx:latest' locally
latest: Pulling from library/nginx
693502eb7dfb: Pull complete
6decb850d2bc: Pull complete
c3e19f087ed6: Pull complete
Digest: sha256:52a189e49c0c797cfc5cbfe578c68c225d160fb13a42954144b29af3fe4fe335
Status: Downloaded newer image for nginx:latest
2964bd62006acd43611ea045e8152f651905e213c392e008a59eebe667080b3d

2） 启动bash控制台并修改index.html内容

1
2
3
4
5
6
➜  docker exec -it webserver bash
root@2964bd62006a:/# ls
bin  boot  dev	etc  home  lib	lib64  media  mnt  opt	proc  root  run  sbin  srv  sys  tmp  usr  var
root@2964bd62006a:/# echo '<h1>Hello, Docker!</h1>' > /usr/share/nginx/html/index.html
root@2964bd62006a:/# exit
exit

3）查看容器修改内容

1
2
3
4
5
6
7
8
9
10
11
12
➜  docker diff webserver
C /root
A /root/.bash_history
C /run
A /run/nginx.pid
C /usr/share/nginx/html/index.html
C /var/cache/nginx
A /var/cache/nginx/client_temp
A /var/cache/nginx/fastcgi_temp
A /var/cache/nginx/proxy_temp
A /var/cache/nginx/scgi_temp
A /var/cache/nginx/uwsgi_temp

4）制作v2版本tag的nginx

1
2
➜  docker commit --author "zhengyong" --message "update index.htm" webserver nigix:v2
sha256:b86a71250cf4e41a34af24b7e2924e3909ecdf74262195d6ac30fd57bbdbaf35

5) 启动v2版本nginx

1
2
➜  docker run -d -p 80:80 --name ng nigix:v2
72f15356de38c26456cdee8a68651a2de25e59d8f8e4ce31e82c434927ff4b4f

七、Dockerfile

1）创建工程目录和Dockerfile文件

1
2
3
➜ mkdir mynginx
➜ cd mynginx
➜ touch Dockerfile

2）Dockerfile文件内容

1
2
FROM nginx
RUN echo '<h1>Hello, Docker!</h1>' > /usr/share/nginx/html/index.html

3) 构建docker镜像

使用命令docker build -t nginx:v3 .构建：

1
2
3
4
5
6
7
8
9
➜ docker build -t nginx:v3 .
Sending build context to Docker daemon 2.048 kB
Step 1/2 : FROM nginx
 ---> 6b914bbcb89e
Step 2/2 : RUN echo '<h1>Hello, Docker!</h1>' > /usr/share/nginx/html/index.html
 ---> Running in a41235243cb9
 ---> 7a2e14fdfefb
Removing intermediate container a41235243cb9
Successfully built 7a2e14fdfefb

docker导致mac硬盘空间不足：

1
2
3
4
docker rm $(docker ps -a -q)
docker rmi $(docker images -q)
docker volume rm $(docker volume ls |awk '{print $2}')
rm -rf ~/Library/Containers/com.docker.docker/Data/*

展开全文 >>

Drools使用

Maven dependency

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
<dependency>
    <groupId>org.kie</groupId>
    <artifactId>kie-api</artifactId>
    <version>6.5.0.Final</version>
</dependency>
<dependency>
    <groupId>org.drools</groupId>
    <artifactId>drools-core</artifactId>
    <version>6.5.0.Final</version>
</dependency>
<dependency>
    <groupId>org.drools</groupId>
    <artifactId>drools-compiler</artifactId>
    <version>6.5.0.Final</version>
</dependency>

Rule Syntax

1. Conditions in Rules

A rule can contain many conditions and patterns such as:

1
2
Account (balance == 200)
Customer (name == “Vivek”)

The above conditions check if the Account balance is 200 or the Customer name is “Vivek”.

2. Variables in Rules

A variable name in Drools starts with a Dollar($) symbol.

1
2
$account : Account( )
$account is the variable for Account() class

Drools can work with all the native Java types and even Enum.

3. Comments in Rules

The special characters, # or //, can be used to mark single-line comments.

For multi-line comments, use the following format:

1
2
3
4
5
/*
   Another line
   .........
   .........
*/
4.Functions in Rules

Functions are a convenience feature. They can be used in conditions and consequences. Functions represent an alternative to the utility/helper classes. For example:

1
2
3
function double calculateSquare (double value) {
   return value * value;
}
5. Salience (same as priority)

Salience is a very important feature of Rule Syntax. Salience is used by the conflict resolution strategy to decide which rule to fire first. By default, it is the main criterion.

We can use salience to define the order of firing rules. Salience has one attribute, which takes any expression that returns a number of type int (positive as well as negative numbers are valid). The higher the value, the more likely a rule will be picked up by the conflict resolution strategy to fire.

1
salience ($account.balance * 5)

The default salience value is 0. We should keep this in mind when assigning salience values to some rules only.

参考地址

https://www.tutorialspoint.com/drools/drools_rule_syntax.htm

展开全文 >>

HashMap(JDK-1.8)

一：resize扩容

  1. 当前table Node数组赋给临时变量，并记录老table的初始化容量和加载因子
  2. 如果老初始化容量大于0，新表初始化容量直接扩大为原来的2倍
  3. 循环老table，对新table赋值

1) 如果如果链表只有一个，则进行直接赋值newTab[e.hash & (newCap - 1)] = e

2）如果红黑二叉树：……

3）链表赋值，如果新表位置变化e.hash & oldCap) == 0, 则老表数据在新表位置为（老数组位置i+老数组容量oldCap）

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
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
final Node<K, V>[] resize() {
      Node<K, V>[] oldTab = table;
      int oldCap = (oldTab == null) ? 0 : oldTab.length;// 数组长度
      int oldThr = threshold;// 临界值
      int newCap, newThr = 0;
      if (oldCap > 0) {
          // 扩容
          if (oldCap >= MAXIMUM_CAPACITY) {
              // 原数组长度大于最大容量(1073741824) 则将threshold设为Integer.MAX_VALUE=2147483647
              // 接近MAXIMUM_CAPACITY的两倍
              threshold = Integer.MAX_VALUE;
              return oldTab;
          } else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY && oldCap >= DEFAULT_INITIAL_CAPACITY) {
              // 新数组长度 是原来的2倍，
              // 临界值也扩大为原来2倍
              newThr = oldThr << 1;
          }
      } else if (oldThr > 0) {
          // 如果原来的thredshold大于0则将容量设为原来的thredshold
          // 在第一次带参数初始化时候会有这种情况
          newCap = oldThr;
      } else {
          // 在默认无参数初始化会有这种情况
          newCap = DEFAULT_INITIAL_CAPACITY;// 16
          newThr = (int) (DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);// 0.75*16=12
      }
      if (newThr == 0) {
          // 如果新 的容量 ==0
          float ft = (float) newCap * loadFactor;// loadFactor 哈希加载因子 默认0.75,可在初始化时传入,16*0.75=12 可以放12个键值对
          newThr = (newCap < MAXIMUM_CAPACITY && ft < (float) MAXIMUM_CAPACITY ? (int) ft : Integer.MAX_VALUE);
      }
      threshold = newThr;// 将临界值设置为新临界值
      @SuppressWarnings({ "rawtypes", "unchecked" })
      // 扩容
      Node<K, V>[] newTab = (Node<K, V>[]) new Node[newCap];
      table = newTab;
      // 如果原来的table有数据，则将数据复制到新的table中
      if (oldTab != null) {
          // 根据容量进行循环整个数组，将非空元素进行复制
          for (int j = 0; j < oldCap; ++j) {
              Node<K, V> e;
              // 获取数组的第j个元素
              if ((e = oldTab[j]) != null) {
                  oldTab[j] = null;
                  // 如果链表只有一个，则进行直接赋值
                  if (e.next == null)
                      // e.hash & (newCap - 1) 确定元素存放位置
                      newTab[e.hash & (newCap - 1)] = e;
                  //  此处省略红黑树
                  else {
                      // 进行链表复制
                      // 方法比较特殊： 它并没有重新计算元素在数组中的位置
                      // 而是采用了 原始位置加原数组长度的方法计算得到位置
                      Node<K, V> loHead = null, loTail = null;
                      Node<K, V> hiHead = null, hiTail = null;
                      Node<K, V> next;
                      do {
                          next = e.next;
                          // 注意：不是(e.hash & (oldCap-1));而是(e.hash & oldCap)

                          // (e.hash & oldCap) 得到的是 元素的在数组中的位置是否需要移动,示例如下
                          // 示例1：
                          // e.hash=10 0000 1010
                          // oldCap=16 0001 0000
                          //   &   =0  0000 0000       比较高位的第一位 0
                          //结论：元素位置在扩容后数组中的位置没有发生改变

                          // 示例2：
                          // e.hash=17 0001 0001
                          // oldCap=16 0001 0000
                          //   &   =1  0001 0000      比较高位的第一位   1
                          //结论：元素位置在扩容后数组中的位置发生了改变，新的下标位置是原下标位置+原数组长度

                          // (e.hash & (oldCap-1)) 得到的是下标位置,示例如下
                          //   e.hash=10 0000 1010
                          // oldCap-1=15 0000 1111
                          //      &  =10 0000 1010

                          //   e.hash=17 0001 0001
                          // oldCap-1=15 0000 1111
                          //      &  =1  0000 0001

                          //新下标位置
                          //   e.hash=17 0001 0001
                          // newCap-1=31 0001 1111    newCap=32
                          //      &  =17 0001 0001    1+oldCap = 1+16

                          //元素在重新计算hash之后，因为n变为2倍，那么n-1的mask范围在高位多1bit(红色)，因此新的index就会发生这样的变化：
                          // 0000 0001->0001 0001

                          if ((e.hash & oldCap) == 0) {
                              // 如果原元素位置没有发生变化
                              if (loTail == null)
                                  loHead = e;// 确定首元素
                              // 第一次进入时     e   -> aa  ; loHead-> aa
                              else
                                  loTail.next = e;
                              //第二次进入时        loTail-> aa  ;    e  -> bb ;  loTail.next -> bb;而loHead和loTail是指向同一块内存的，所以loHead.next 地址为 bb  
                              //第三次进入时        loTail-> bb  ;    e  -> cc ;  loTail.next 地址为 cc;loHead.next.next = cc
                              loTail = e;
                              // 第一次进入时         e   -> aa  ; loTail-> aa loTail指向了和  loHead相同的内存空间
                              // 第二次进入时               e   -> bb  ; loTail-> bb loTail指向了和  loTail.next（loHead.next）相同的内存空间   loTail=loTail.next
                              // 第三次进入时               e   -> cc  ; loTail-> cc loTail指向了和  loTail.next(loHead.next.next)相同的内存
                          } else {
                              //与上面同理

                              if (hiTail == null)
                                  hiHead = e;
                              else
                                  hiTail.next = e;
                              hiTail = e;
                          }
                      } while ((e = next) != null);//这一块就是 旧链表迁移新链表
                      //总结：1.8中 旧链表迁移新链表    链表元素相对位置没有变化; 实际是对对象的内存地址进行操作 
                      //在1.7中  旧链表迁移新链表        如果在新表的数组索引位置相同，则链表元素会倒置
                      if (loTail != null) {
                          loTail.next = null;// 将链表的尾节点 的next 设置为空
                          newTab[j] = loHead;
                      }
                      if (hiTail != null) {
                          hiTail.next = null;// 将链表的尾节点 的next 设置为空
                          newTab[j + oldCap] = hiHead;
                      }
                  }
              }
          }
      }
      return newTab;
  }

二、线程安全

JDK-1.7 线程不安全

resize()导致线程不安全

1
2
3
4
5
6
7
transfer()函数逻辑
1. 对索引数组中的元素遍历
2. 对链表上的每一个节点遍历：用 next 取得要转移那个元素的下一个，将 e 转移到新 Hash 表的头部，使用头插法插入节点。
3. 循环2，直到链表节点全部转移
4. 循环1，直到所有索引数组全部转移

经过这几步，我们会发现转移的时候是逆序的。假如转移前链表顺序是1->2->3，那么转移后就会变成3->2->1。这时候就有点头绪了，死锁问题不就是因为1->2的同时2->1造成的吗？所以，HashMap 的死锁问题就出在这个transfer()函数上。

展开全文 >>

Mockito单元测试

Maven依赖

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
<dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>4.11</version>
    <scope>test</scope>
</dependency>
<dependency>
    <groupId>org.mockito</groupId>
    <artifactId>mockito-all</artifactId>
    <version>2.0.2-beta</version>
    <scope>test</scope>
</dependency>
<dependency>
    <groupId>org.powermock</groupId>
    <artifactId>powermock-module-junit4</artifactId>
    <version>1.6.5</version>
    <scope>test</scope>
</dependency>
<dependency>
    <groupId>org.powermock</groupId>
    <artifactId>powermock-api-mockito</artifactId>
    <version>1.6.5</version>
    <scope>test</scope>
</dependency>

普通类mock

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
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.MockitoAnnotations;
import org.mockito.invocation.InvocationOnMock;
import org.mockito.stubbing.Answer;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.File;
import java.io.PrintWriter;

public class DataHandlerTest {

    @InjectMocks
    DataHandler                   dataHandler = new DataHandler();

    @Mock
    protected HttpServletRequest  request;

    @Mock
    protected HttpServletResponse response;

    @Before
    public void before() throws Exception {
        MockitoAnnotations.initMocks(this);
    }

    @Test
    public void testPrintString() throws Exception {
        JsonResult result = new JsonResult();
        Mockito.doNothing().doAnswer(new Answer() {

            @Override
            public Object answer(InvocationOnMock invocation) throws Throwable {
                return null;
            }
        }).when(response).setHeader("Content-Type", "application/json");

        String path = DataHandlerTest.class.getResource("/").getPath() + "dataHandler.txt";
        File file = new File(path);
        if (!file.exists()) {
            file.createNewFile();
        }
        PrintWriter writer = new PrintWriter(file);
        Mockito.when(response.getWriter()).thenReturn(writer);
        dataHandler.print(result);

        if (file != null && file.exists()) {
            file.delete();
        }
    }
}

静态类mock

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
@RunWith(PowerMockRunner.class)
@PrepareForTest(ThreadContext.class)
public class CartTest {


    @InjectMocks
    private Cart cart = new Cart();

    @Mock
    ThreadContext threadContext;

    @Mock
    protected HttpServletRequest request;
    
    @Mock
    protected HttpServletResponse response;

    @Before
    public void before() throws Exception { 
        MockitoAnnotations.initMocks(this);
        PowerMockito.mockStatic(ThreadContext.class);

        ThreadContext threadContext2 = new ThreadContext();
        threadContext2.setLoginId("123");

        //Mock当前用户信息 currentUser
        Mockito.when(ThreadContext.getCurrentUser()).thenReturn(threadContext2);

        //Mock response.setHeader方法
        Mockito.doAnswer(new Answer<Object>() {
            public Object answer(InvocationOnMock invocation) {
                Object[] args = invocation.getArguments();
                return "called with arguments: " + args;
            }
        }).when(response).setHeader(Mockito.anyString(),Mockito.anyString());

    }
    
        
   /** 
    * 
    * Method: screen(Context context) 
    * 
    */ 
    @Test
    public void test() throws Exception {
        Map<String, String> map = Maps.newHashMap();
        map.put("Login","test");
        Context context = new MappedContext();

        //Mock request中获取回调函数名的方法
        Mockito.when(request.getParameter(Mockito.any(String.class))).thenReturn("callback");
        cart.screen(context);

    }

展开全文 >>

MySQL事务级别

幻读：事务1读取数据时，事务2增加并提交，事务1再次读取数据时，可以看到事务B新增的数据。

不可重复读：事务1读取数据时，事务2修改并提交该数据，事务1再次读取事务时，可以看到事务B修改后的记录

脏读：事务1更新了记录，但没有提交，事务2读取了更新后的行，然后事务T1回滚，现在T2读取无效。

事务级别

  1. read uncommit：可能出现脏读，幻读，不可重复读
  2. read commit : 不允许出现脏读，可能出现幻读，不可重复读
  3. repeaable commit : 不会出现脏读、不可重复读，可能出现幻读
  4. seralizeable : 不会出现脏读，幻读，不可重复读

http://www.cnblogs.com/hustcat/archive/2009/10/28/1591648.html

展开全文 >>

spring schema扩展

介绍

Spring 2.5在2.0的基于Schema的Bean配置的基础之上，再增加了扩展XML配置的机制。通过该机制，我们可以编写自己的Schema，并根据自定义的Schema用自定的标签配置Bean。要使用的Spring的扩展XML配置机制，也比较简单，有以下4个步骤：

  1. 编写自定义Schema文件；
  2. 编写自定义NamespaceHandler；
  3. 编写解析BeanDefinition的parser
  4. 在Spring中注册上述组建

Maven依赖

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
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-core</artifactId>
    <version>3.2.4.RELEASE</version>
</dependency>
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-beans</artifactId>
    <version>3.2.4.RELEASE</version>
</dependency>
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-aop</artifactId>
    <version>3.2.4.RELEASE</version>
</dependency>
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context</artifactId>
    <version>3.2.4.RELEASE</version>
</dependency>
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context-support</artifactId>
    <version>3.2.4.RELEASE</version>
</dependency>
```      

#### 一、编写schema文件

参考：[http://www.w3school.com.cn/schema/schema_elements_ref.asp](http://www.w3school.com.cn/schema/schema_elements_ref.asp) , 如下`people.xsd`文件:

```xml
<?xml version="1.0" encoding="UTF-8"?>
<xsd:schema xmlns="http://www.pomelo.com/schema/people"
            xmlns:xsd="http://www.w3.org/2001/XMLSchema"
            xmlns:beans="http://www.springframework.org/schema/beans"
            targetNamespace="http://www.pomelo.com/schema/people"
            elementFormDefault="qualified"
            attributeFormDefault="unqualified">
    <xsd:import namespace="http://www.springframework.org/schema/beans"/>

    <xsd:element name="student">
        <xsd:complexType>
            <xsd:complexContent>
                <xsd:extension base="beans:identifiedType">

                    <xsd:attribute name="name" type="xsd:string">
                        <xsd:annotation>
                            <xsd:documentation>姓名</xsd:documentation>
                        </xsd:annotation>
                    </xsd:attribute>

                    <xsd:attribute name="age" type="xsd:string">
                        <xsd:annotation>
                            <xsd:documentation>年龄</xsd:documentation>
                        </xsd:annotation>
                    </xsd:attribute>

                </xsd:extension>
            </xsd:complexContent>
        </xsd:complexType>
    </xsd:element>
</xsd:schema>

二、编写自定义NamespaceHandler

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

import org.springframework.beans.factory.xml.NamespaceHandlerSupport;

public class StudentNamespaceHandler extends NamespaceHandlerSupport {

    @Override
    public void init() {
        registerBeanDefinitionParser("student", new StudentBeanDefinitionParser());
    }

}

三、编写BeanDefinition

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

import org.springframework.beans.factory.support.BeanDefinitionBuilder;
import org.springframework.beans.factory.xml.AbstractSingleBeanDefinitionParser;
import org.springframework.util.StringUtils;
import org.w3c.dom.Element;

public class StudentBeanDefinitionParser extends AbstractSingleBeanDefinitionParser {

    protected Class getBeanClass(Element element) {
        return Student.class;
    }

    protected void doParse(Element element, BeanDefinitionBuilder bean) {
        String name = element.getAttribute("name");
        bean.addPropertyValue("name", name);

        String age = element.getAttribute("age");
        if (StringUtils.hasText(age)) {
            bean.addPropertyValue("age", Integer.valueOf(age));
        }
    }
}

实体类：

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
package schema;

public class Student {
      
    private String name;  
      
    private int 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;  
    }  
      
}

四、注册schema组件

最后在META-INF目录下添加两个配置文件(spring.handler和spring.schema):

spring.handler配置如下：

1
http\://www.pomelo.com/schema/people=schema.StudentNamespaceHandler

spring.schema配置如下：

1
http\://www.pomelo.com/schema/people.xsd=META-INF/people.xsd

五、测试

新建applicationContext.xml放在clasapath下面：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:people="http://www.pomelo.com/schema/people"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.pomelo.com/schema/people http://www.pomelo.com/schema/people.xsd">

    <people:student id="student1" name="student1" age="18"/>

    <people:student id="student2" name="student2" age="20" />


    <bean id="student3" class="schema.Student">
        <property name="name" value="student3"/>
        <property name="age" value="23"/>
    </bean>

</beans>

java调用：

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

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
 * Created by zhengyong on 17/3/3.
 */
public class SchemaTest {

    public static void main(String[] args) {

        ApplicationContext ctx = new ClassPathXmlApplicationContext("/applicationContext.xml");
        Student student1 = (Student) ctx.getBean("student1");
        Student student2 = (Student) ctx.getBean("student2");
        Student student3 = (Student) ctx.getBean("student3");

        System.out.println("name: " + student1.getName() + " age :" + student1.getAge());
        System.out.println("name: " + student2.getName() + " age :" + student2.getAge());
        System.out.println("name: " + student3.getName() + " age :" + student3.getAge());
    }
}

具体代码详见：https://github.com/zyongjava/pomelo/blob/master/src/main/resources/META-INF/people.xsd

展开全文 >>

swagger自动生成API文档

一、pom.xml配置

1
2
3
4
5
6
7
8
9
10
11
<!--swagger -->
<dependency>
    <groupId>io.springfox</groupId>
    <artifactId>springfox-swagger2</artifactId>
    <version>2.8.0</version>
</dependency>
<dependency>
    <groupId>io.springfox</groupId>
    <artifactId>springfox-swagger-ui</artifactId>
    <version>2.8.0</version>
</dependency>

二、spring boot配置

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
package cn.pomelo.web.config;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import springfox.documentation.builders.ApiInfoBuilder;
import springfox.documentation.builders.PathSelectors;
import springfox.documentation.builders.RequestHandlerSelectors;
import springfox.documentation.service.ApiInfo;
import springfox.documentation.service.Contact;
import springfox.documentation.spi.DocumentationType;
import springfox.documentation.spring.web.plugins.Docket;
import springfox.documentation.swagger2.annotations.EnableSwagger2;

/**
 * swagger自动生成API文档 (http://127.0.0.1:8080/swagger-ui.html)
 */
@EnableSwagger2
@Configuration
public class SwaggerConfig {
 
    //是否开启swagger，正式环境一般是需要关闭的，可根据springboot的多环境配置进行设置
    @Value(value = "${swagger.enabled}")
    Boolean swaggerEnabled;
 
    @Bean
    public Docket createRestApi() {
        return new Docket(DocumentationType.SWAGGER_2).apiInfo(apiInfo())
                // 是否开启
                .enable(swaggerEnabled).select()
                // 扫描的路径包
                .apis(RequestHandlerSelectors.basePackage("cn.pomelo.web.controller"))
                // 指定路径处理PathSelectors.any()代表所有的路径
                .paths(PathSelectors.any()).build().pathMapping("/");
    }
 
    private ApiInfo apiInfo() {
        return new ApiInfoBuilder()
                .title("SpringBoot-Swagger2集成和使用-demo示例")
                .description("spring boot swagger restful api document")
                // 作者信息
                .contact(new Contact("yong.zheng", "https://blog.csdn.net/zhengyong15984285623?viewmode=contents", "zyongjava@163.com"))
                .version("1.0.0")
                .build();
    }
}

三、swagger-ui.html配置

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.ResourceHandlerRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurerAdapter;

/**
 * MVC配置
 *
 */
@Configuration
public class CustomMvcConfig extends WebMvcConfigurerAdapter {
    @Override
    public void addResourceHandlers(ResourceHandlerRegistry registry) {
        super.addResourceHandlers(registry);
        registry.addResourceHandler("swagger-ui.html")
                .addResourceLocations("classpath:/META-INF/resources/");

        registry.addResourceHandler("/webjars/**")
                .addResourceLocations("classpath:/META-INF/resources/webjars/");

    }
}

四、注解说明

常用到的注解：

1
2
3
4
5
6
7
8
@Api
@ApiModel
@ApiModelProperty
@ApiOperation
@ApiParam
@ApiResponse
@ApiResponses
@ResponseHeader

地址：https://www.cnblogs.com/hyl8218/p/8520994.html

展开全文 >>

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

我是码农<br>我为搬砖代言<br/>搬砖很快乐<br><br> 很惭愧<br>只会干体力活<br>谢谢大家