神坑之 6666 端口 (默认非安全端口)

今天用 Spring Boot 做个小 demo 程序，本来轻车熟路，结果怎么都访问不了，后来浪费半天时间才发现是因为手滑把端口设置成了 6666, 而 6666 刚好在 Chrome 浏览器的默认非安全端口列表里。。。

避免采坑更多默认非安全端口，请搜索：默认非安全端口列表

展开全文 >>

MongoTemplate 移除 _class 字段 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
@Configuration
public class ApplicationReadyListener implements ApplicationListener<ContextRefreshedEvent> {
 
  @Autowired
  MongoTemplate mongoTemplate;
 
  @Override
  public void onApplicationEvent(ContextRefreshedEvent contextRefreshedEvent) {
    MongoConverter converter = mongoTemplate.getConverter();
    if (converter.getTypeMapper().isTypeKey("_class")) {
      ((MappingMongoConverter) converter).setTypeMapper(new DefaultMongoTypeMapper(null));
    }
  }
}

参考：

Spring Boot 学习笔记：MongoTemplate 移除 _class 字段

展开全文 >>

在 CentOS 7 安装 RabbitMQ

一、安装 Erlang

RabbitMQ 是使用 Erlang 开发的，所以需要首先安装 Erlang，本文安装其最新版本

添加 repo 文件：

1
sudo vim /etc/yum.repos.d/rabbitmq_erlang.repo

文件内容：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
[rabbitmq_erlang]
name=rabbitmq_erlang
baseurl=https://packagecloud.io/rabbitmq/erlang/el/7/$basearch
repo_gpgcheck=1
gpgcheck=0
enabled=1
gpgkey=https://packagecloud.io/rabbitmq/erlang/gpgkey
sslverify=1
sslcacert=/etc/pki/tls/certs/ca-bundle.crt
metadata_expire=300

[rabbitmq_erlang-source]
name=rabbitmq_erlang-source
baseurl=https://packagecloud.io/rabbitmq/erlang/el/7/SRPMS
repo_gpgcheck=1
gpgcheck=0
enabled=1
gpgkey=https://packagecloud.io/rabbitmq/erlang/gpgkey
sslverify=1
sslcacert=/etc/pki/tls/certs/ca-bundle.crt
metadata_expire=300

安装：

1
sudo yum -y install erlang socat

二、安装 RabbitMQ

下载 RPM 包：

1
wget https://dl.bintray.com/rabbitmq/all/rabbitmq-server/3.7.17/rabbitmq-server-3.7.17-1.el7.noarch.rpm

导入 GPG key：

1
sudo rpm --import https://www.rabbitmq.com/rabbitmq-release-signing-key.asc

安装 RabbitMQ：

1
sudo rpm -Uvh rabbitmq-server-3.7.17-1.el7.noarch.rpm

启动 RabbitMQ：

1
sudo systemctl start rabbitmq-server

查看 RabbitMQ 运行状态

1
sudo systemctl status rabbitmq-server

将 RabbitMQ 加入开机自启动：

1
sudo systemctl enable rabbitmq-server

三、RabbitMQ 配置

放行端口：

1
2
3
4
5
6
7
8
9
sudo firewall-cmd --zone=public --permanent --add-port=4369/tcp
sudo firewall-cmd --zone=public --permanent --add-port=25672/tcp
sudo firewall-cmd --zone=public --permanent --add-port=5671-5672/tcp
sudo firewall-cmd --zone=public --permanent --add-port=15672/tcp
sudo firewall-cmd --zone=public --permanent --add-port=61613-61614/tcp
sudo firewall-cmd --zone=public --permanent --add-port=1883/tcp
sudo firewall-cmd --zone=public --permanent --add-port=8883/tcp

sudo firewall-cmd --reload

启用 RabbitMQ 网页管理插件

1
sudo rabbitmq-plugins enable rabbitmq_management

创建管理员用户并授权：

1
2
3
sudo rabbitmqctl add_user admin 你的密码
sudo rabbitmqctl set_user_tags admin administrator
sudo rabbitmqctl set_permissions -p / admin ".*" ".*" ".*"

在浏览器访问 http://IP:15672 即可进入到 RabbitMQ 网页管理页面

参考：

  1. How to Install RabbitMQ Server on CentOS 7
  2. github.com/rabbitmq/erlang-rpm

展开全文 >>

MongoDB 分片集群配置

本文测试环境为 CentOS 7 和 MongoDB 最新版 (4.0.12)

使用 root 操作 (实际操作中使用非 root 账户启动报错)

零、服务器分配

服务器 102 服务器 103 服务器 104
mongos mongos mongos
config server config server config server
shard server 1 主节点 shard server 1 副节点 shard server 1 仲裁
shard server 2 仲裁 shard server2 主节点 shard server 2 副节点
shard server 3 副节点 shard server 3 仲裁 shard server 3 主节点

端口：

1
2
3
4
5
mongos：20000
config：21000
shard1：27001
shard2：27002
shard3：27003

一、MongoDB 安装

在 3 台服务器分别操作

1.1. 下载

1
2
3
4
5
cd /usr/local
wget http://downloads.mongodb.org/linux/mongodb-linux-x86_64-rhel70-v4.0-latest.tgz

tar -xzvf mongodb-linux-x86_64-rhel70-v4.0-latest.tgz -C /usr/local/
mv mongodb-linux-x86_64-rhel70-4.0.12-rc0-3-gc57d7cb mongodb

1.2. 建立文件夹

1
2
3
4
5
6
7
8
9
10
mkdir -p /usr/local/mongodb/conf
mkdir -p /data/mongodb/mongos/log
mkdir -p /data/mongodb/config/data
mkdir -p /data/mongodb/config/log
mkdir -p /data/mongodb/shard1/data
mkdir -p /data/mongodb/shard1/log
mkdir -p /data/mongodb/shard2/data
mkdir -p /data/mongodb/shard2/log
mkdir -p /data/mongodb/shard3/data
mkdir -p /data/mongodb/shard3/log

1.3. 环境变量

1
2
vim /etc/profile

在文件末尾添加：

1
2
export MONGODB_HOME=/usr/local/mongodb
export PATH=$MONGODB_HOME/bin:$PATH

使配置立即生效：

1
source /etc/profile

二、config server 配置

在 3 台服务器分别操作

1
vim /usr/local/mongodb/conf/config.conf

内容：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
# where to write logging data.
systemLog:
  destination: file
  logAppend: true
  path: /data/mongodb/config/log/congigsrv.log

# Where and how to store data.
storage:
  dbPath: /data/mongodb/config/data
  journal:
    enabled: true

# how the process runs
processManagement:
  fork: true  # fork and run in background
  pidFilePath: /data/mongodb/config/log/configsrv.pid
  timeZoneInfo: /usr/share/zoneinfo

# network interfaces
net:
  port: 21000
  bindIp: 0.0.0.0

# sharding Options
sharding:
  clusterRole: configsvr
replication:
  replSetName: config

启动服务：

1
mongod -f /usr/local/mongodb/conf/config.conf

以下操作在任意一台服务器操作即可

1
mongo --port 21000
1
2
3
4
5
6
7
8
9
10
11
12
# config 变量
config = {
    _id : "config",
    members : [
        {_id: 0, host: "192.168.30.102:21000" },
        {_id: 1, host: "192.168.30.103:21000" },
        {_id: 2, host: "192.168.30.104:21000" }
    ]
}

# 初始化
rs.initiate(config)

三、shard server 配置

在 3 台服务器分别操作

1
vim /usr/local/mongodb/conf/shard1.conf

内容：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
# where to write logging data.
systemLog:
  destination: file
  logAppend: true
  path: /data/mongodb/shard1/log/shard1.log

# Where and how to store data.
storage:
  dbPath: /data/mongodb/shard1/data
  journal:
    enabled: true

# how the process runs
processManagement:
  fork: true  # fork and run in background
  pidFilePath: /data/mongodb/shard1/log/shard1.pid
  timeZoneInfo: /usr/share/zoneinfo

# network interfaces
net:
  port: 27001
  bindIp: 0.0.0.0

# sharding Options
sharding:
  clusterRole: shardsvr
replication:
  replSetName: shard1

启动服务：

1
mongod -f /usr/local/mongodb/conf/shard1.conf

以下操作在任意一台服务器操作即可 (实际操作中需要在非裁判服务器操作)

1
mongo --port 27001
1
2
3
4
5
6
7
8
9
10
11
12
13
use admin

# "arbiterOnly":true 代表其为仲裁节点
config = {
    _id: "shard1",
    members: [
        {_id: 0, host: "192.168.30.102:27001"},
        {_id: 1, host: "192.168.30.103:27001"},
        {_id: 2, host: "192.168.30.104:27001", arbiterOnly: true}
    ]
}
# 初始化
rs.initiate(config)

重复上述操作配置 shard2 和 shard3, 注意修改名称、端口和对应的 arbiterOnly

四、mongos 配置

在 3 台服务器分别操作

1
vim /usr/local/mongodb/conf/mongos.conf

内容：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
# where to write logging data.
systemLog:
  destination: file
  logAppend: true
  path: /data/mongodb/mongos/log/mongos.log

# how the process runs
processManagement:
  fork: true  # fork and run in background
  pidFilePath: /data/mongodb/mongos/log/mongos.pid
  timeZoneInfo: /usr/share/zoneinfo

# network interfaces
net:
  port: 20000
  bindIp: 0.0.0.0

# sharding Options
# config 为配置服务器的副本集名字
sharding:
  configDB: config/192.168.30.102:21000,192.168.30.103:21000,192.168.30.104:21000

启动服务:

1
mongos -f /usr/local/mongodb/conf/mongos.conf

以下操作在任意一台服务器操作即可

1
mongo --port 20000
1
2
3
4
5
6
use admin

# 串联路由服务器与分配副本集
sh.addShard("shard1/192.168.30.102:27001,192.168.30.103:27001,192.168.30.104:27001")
sh.addShard("shard2/192.168.30.102:27002,192.168.30.103:27002,192.168.30.104:27002")
sh.addShard("shard3/192.168.30.102:27003,192.168.30.103:27003,192.168.30.104:27003")

五、测试

在其中一台 mongos 继续操作：

1
2
3
4
5
6
7
8
# 指定 test 数据库分片生效
db.runCommand({ enablesharding :"test"})

# 指定数据库里需要分片的集合和片键
db.runCommand({ shardcollection : "test.table1",key : {id: 1}})

# 插入测试数据
for(var i = 1; i <= 100000; i++) db.table1.save({id:i,"test1":"testval1"})

六、在 Spring Boot 中使用

在其中一台 mongos 继续操作：

1
2
3
4
5
6
# 创建账户
db.createUser({
 user: 'test',
 pwd: '123456',
 roles: [{role: "readWrite", db: "test"}]
})

Spring Boot 连接字符串：

1
2
3
4
spring:
  data:
    mongodb:
      uri: mongodb://test:123456@192.168.30.102:20000,192.168.30.103:20000,192.168.30.104:20000/test

参考：

  1. mongodb 3.4 集群搭建：分片+副本集
  2. mongodb 3.4 集群搭建升级版 五台集群
  3. MongoDB Configuration File Options

展开全文 >>

基于 MongoDB 动态字段设计的探索 (二) 聚合操作

业务需求及设计见前文：基于 MongoDB 动态字段设计的探索

根据专业计算各科平均分 (总分、最高分、最低分)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public Object avg(String major){

    Aggregation aggregation = Aggregation.newAggregation(
            Aggregation.unwind("courseList"),
            Aggregation.match(Criteria.where("major").is(major)),
            Aggregation.group("courseList.name").avg("courseList.score").as("avg")
    ); // avg 可以替换成 sum, max, min 分别求各科总分、最高分、最低分

    AggregationResults<BasicDBObject> aggregationResults = mongoTemplate.aggregate(aggregation, Student.class, BasicDBObject.class);

    List<BasicDBObject> result = new ArrayList<>();
    for(Iterator<BasicDBObject> iterator = aggregationResults.iterator(); iterator.hasNext();){
        result.add(iterator.next());
    }

    return result;
}

计算个人总分数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public Object sum(String name){

    Aggregation aggregation = Aggregation.newAggregation(
            Aggregation.unwind("courseList"),
            Aggregation.match(Criteria.where("name").is(name)),
            Aggregation.group("name").sum("courseList.score").as("sum")
    );

    AggregationResults<BasicDBObject> aggregationResults = mongoTemplate.aggregate(aggregation, Student.class, BasicDBObject.class);

    List<BasicDBObject> result = new ArrayList<>();
    for(Iterator<BasicDBObject> iterator = aggregationResults.iterator(); iterator.hasNext();){
        result.add(iterator.next());
    }

    return result;
}

完整代码：GitHub

参考：MongoTemplate 聚合操作

展开全文 >>

基于 MongoDB 动态字段设计的探索

一、业务需求

假设某学校课程系统，不同专业课程不同 (可以动态增删)，但是需要根据专业不同显示该专业学生的各科课程的成绩，如下：

专业 姓名 高等数学 数据结构
计算机 张三 90 85
计算机 李四 78 87
专业 姓名 高等数学
数学 王五 86
数学 赵六 95

二、设计思路

开始的思路是根据配置的课程动态生成文档字段，使用非映射方式直接操作 MongoCollection, 有以下问题：

  1. 存取数据日期序列化问题 (亦可能是本人没有找到正确的处理方式)
  2. 返回结果集不能转换成实体对象，不方便做二次处理

所以最终使用内嵌数组的方式

三、代码示例

3.1 实体类

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

    private String name;
    private String major;
    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
    private LocalDateTime createTime;
    @JsonIgnore
    private List<Course> courseList;

    /* getter setter*/

}

public class Course {

    private String name;
    private Float score;

    /* getter setter*/
}

3.2 添加测试专业及课程

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
public class MajorConfig {

    private static MajorConfig computer;
    private static MajorConfig math;

    static {
        computer = new MajorConfig();
        computer.setName("计算机");

        List<String> courseList = new ArrayList<>();
        courseList.add("高等数学");
        courseList.add("数据结构");
        computer.setCourseList(courseList);

        math = new MajorConfig();
        math.setName("数学");
        courseList = new ArrayList<>();
        courseList.add("高等数学");
        math.setCourseList(courseList);


    }

    private String name;
    private List<String> courseList;

    /* getter setter*/
}

3.3 添加测试数据到 MongoDB

初始化数据 (createTime 在 MongoDB 存储为 ISODate)：

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
[
  {
    "name": "张三",
    "major": "计算机",
    "createTime": "2018-01-20 08:00:00",
    "courseList": [
      {
        "name": "高等数学",
        "score": 20.283026
      },
      {
        "name": "数据结构",
        "score": 30.612194
      }
    ]
  },
  {
    "name": "王五",
    "major": "数学",
    "createTime": "2018-01-20 08:00:00",
    "courseList": [
      {
        "name": "高等数学",
        "score": 91.78229
      }
    ]
  },
  {
    "name": "李四",
    "major": "计算机",
    "createTime": "2019-10-01 07:10:50",
    "courseList": [
      {
        "name": "高等数学",
        "score": 60.488556
      },
      {
        "name": "数据结构",
        "score": 80.66098
      }
    ]
  },
  {
    "name": "赵六",
    "major": "数学",
    "createTime": "2019-10-01 07:10:50",
    "courseList": [
      {
        "name": "高等数学",
        "score": 29.595625
      }
    ]
  }
]

3.4 根据专业获取学生课程分数列表

首先查询到对应的数据，然后根据配置的课程动态添加字段：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
public Object list(String major){

    MajorConfig majorConfig = getMajorConfig(major);

    Query query = new Query(Criteria.where("major").is(major));
    List<Student> studentList = mongoTemplate.find(query, Student.class);

    List<Object> result = new ArrayList<>();

    for(Student student:studentList){

        Map<String,Object> properties = Maps.newHashMap();
        for(String name : majorConfig.getCourseList()){
            properties.put(name,null);
            for(Course course : student.getCourseList()){
                if(name.equals(course.getName())){
                    properties.put(name,course.getScore());
                    break;
                }
            }
        }

        result.add(ReflectUtil.getTarget(student,properties));
    }

    return result;
}

各专业学生各科分数数据：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
[
  {
    "name": "王五",
    "major": "数学",
    "createTime": "2018-01-20 08:00:00",
    "高等数学": 91.78229
  },
  {
    "name": "赵六",
    "major": "数学",
    "createTime": "2019-10-01 07:10:50",
    "高等数学": 29.595625
  }
]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
[
  {
    "name": "张三",
    "major": "计算机",
    "createTime": "2018-01-20 08:00:00",
    "高等数学": 20.283026,
    "数据结构": 30.612194
  },
  {
    "name": "李四",
    "major": "计算机",
    "createTime": "2019-10-01 07:10:50",
    "高等数学": 60.488556,
    "数据结构": 80.66098
  }
]

ReflectUtil 代码：

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
public class ReflectUtil {

    public static Object getTarget(Object dest, Map<String, Object> addProperties) {
        PropertyUtilsBean propertyUtilsBean = new PropertyUtilsBean();
        PropertyDescriptor[] descriptors = propertyUtilsBean.getPropertyDescriptors(dest);

        Map<String, Class> propertyMap = Maps.newHashMap();

        for (PropertyDescriptor d : descriptors) {
            if (!"class".equalsIgnoreCase(d.getName())) {
                propertyMap.put(d.getName(), d.getPropertyType());
            }

        }
        // add extra properties
        addProperties.forEach((k, v) -> {
            if(v != null){
                propertyMap.put(k, v.getClass());
            }else{
                propertyMap.put(k, Object.class);
            }
        });
        // new dynamic bean
        DynamicBean dynamicBean = new DynamicBean(dest.getClass(), propertyMap);
        // add old value
        propertyMap.forEach((k, v) -> {
            try {
                // filter extra properties
                if (!addProperties.containsKey(k)) {
                    dynamicBean.setValue(k, propertyUtilsBean.getNestedProperty(dest, k));
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        });
        // add extra value
        addProperties.forEach((k, v) -> {
            try {
                dynamicBean.setValue(k, v);
            } catch (Exception e) {
                e.printStackTrace();
            }
        });
        Object target = dynamicBean.getTarget();
        return target;
    }
}

DynamicBean 代码：

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
public class DynamicBean {

    private Object target;

    private BeanMap beanMap;

    public DynamicBean(Class superclass, Map<String, Class> propertyMap) {
        this.target = generateBean(superclass, propertyMap);
        this.beanMap = BeanMap.create(this.target);
    }

    public void setValue(String property, Object value) {
        beanMap.put(property, value);
    }

    public Object getValue(String property) {
        return beanMap.get(property);
    }

    public Object getTarget() {
        return this.target;
    }

    private Object generateBean(Class superclass, Map<String, Class> propertyMap) {
        BeanGenerator generator =new BeanGenerator();
        if(null != superclass) {
            generator.setSuperclass(superclass);
        }
        BeanGenerator.addProperties(generator, propertyMap);
        return generator.create();
    }
}

3.5 添加课程并修改数据库

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
public Object add(String major, String name, Boolean updateDatabase){

        MajorConfig majorConfig = getMajorConfig(major);

        List<String> courseList = majorConfig.getCourseList();

        if(!courseList.contains(name))
        {
            courseList.add(name);
            majorConfig.setCourseList(courseList);
        }

        if(updateDatabase){

            Random random = new Random();

            Course course = new Course();
            course.setName(name);
            course.setScore(random.nextFloat() * 100);

            Update update = new Update();
            update.addToSet("courseList", course);
            Query query = Query.query(Criteria.where("major").is(majorConfig.getName()));
            mongoTemplate.updateMulti(query, update, Student.class);

        }

        return majorConfig;
    }

为数学专业添加计算机基础：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
[
  {
    "name": "王五",
    "major": "数学",
    "createTime": "2018-01-20 08:00:00",
    "计算机基础": 9.042096,
    "高等数学": 91.78229
  },
  {
    "name": "赵六",
    "major": "数学",
    "createTime": "2019-10-01 07:10:50",
    "计算机基础": 9.042096,
    "高等数学": 29.595625
  }
]

3.6 删除课程并修改数据库

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
public Object del(String major, String name, Boolean updateDatabase){

        MajorConfig majorConfig = getMajorConfig(major);

        List<String> courseList = majorConfig.getCourseList();

        if(courseList.contains(name)){
            courseList.remove(name);
            majorConfig.setCourseList(courseList);
        }


        if(updateDatabase){
            Update update = new Update();
            update.pull("courseList", new BasicDBObject("name", name));
            Query query = Query.query(Criteria.where("major").is(majorConfig.getName()));
            mongoTemplate.updateMulti(query,update,Student.class);
        }

        return majorConfig;
    }

把高等数学从计算机专业删除：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
[
  {
    "name": "张三",
    "major": "计算机",
    "createTime": "2018-01-20 08:00:00",
    "数据结构": 30.612194
  },
  {
    "name": "李四",
    "major": "计算机",
    "createTime": "2019-10-01 07:10:50",
    "数据结构": 80.66098
  }
]

3.7 修改某学生的某课程分数

1
2
3
4
5
6
7
8
9
10
11
public Object update(String name, String courseName, Float score){

    Query query = Query.query(Criteria.where("name").is(name).and("courseList.name").is(courseName));

    Update update = new Update();
    update.set("courseList.$.score", score);

    mongoTemplate.updateFirst(query, update, Student.class);

    return null;
}

完整代码：GitHub

展开全文 >>

Spring Boot + MongoDB 使用示例

本文分别使用 MongoRepository 和 MongoTemplate 实现 MongoDB 的简单的增删改查

本文使用 docker 安装 MongoDB：

使用示例

application.yml:

1
2
3
4
spring:
  data:
    mongodb:
      uri: mongodb://test:123456@192.168.30.101:27017/test

entity:

1
2
3
4
5
6
7
8
9
10
11
public class User {
    @Id
    private String id;
    private String name;
    private Integer gender;

    @DateTimeFormat(pattern = "yyyy-MM-dd")
    private LocalDate birthday;

    /*getter setter*/
}

service:

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

    User save(User user);

    void deleteById(String id);

    void deleteAll();

    Iterable<User> findAll();

    Iterable<User> findAll(Integer pageNum, Integer pageSize);

    List<User> findAllByName(String name);

    Page<User> findAllByName(Integer pageNum, Integer pageSize, String name);
}

1.1 使用 MongoRepository

1.1.1 新建 UserMongoRepository

1
2
3
4
public interface UserMongoRepository extends MongoRepository<User, String> {

    List<User> findByName(String name);
}

1.1.2 新建 UserServiceMongoRepository

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
@Profile("MongoRepository")
@Service
public class UserServiceMongoRepository implements UserService {

    @Autowired
    private UserMongoRepository userMongoRepository;

    @Override
    public User save(User user) {
        return userMongoRepository.save(user);
    }

    @Override
    public void deleteById(String id) {
        userMongoRepository.deleteById(id);
    }

    @Override
    public void deleteAll() {
        userMongoRepository.deleteAll();
    }

    @Override
    public Iterable<User> findAll() {
        return userMongoRepository.findAll();
    }

    @Override
    public Iterable<User> findAll(Integer pageNum, Integer pageSize) {

        Pageable pageable = PageRequest.of(pageNum, pageSize);
        return userMongoRepository.findAll(pageable);
    }

    @Override
    public List<User> findAllByName(String name) {
        return userMongoRepository.findByName(name);
    }

    @Override
    public Page<User> findAllByName(Integer pageNum, Integer pageSize, String name) {

        User user = new User();
        user.setName(name);

        ExampleMatcher matcher = ExampleMatcher.matching();
        Example<User> userExample = Example.of(user, matcher);

        Pageable pageable = PageRequest.of(pageNum, pageSize);

        return userMongoRepository.findAll(userExample, pageable);
    }
}

1.2 使用 MongoTemplate

1.2.1 新建 UserServiceMongoTemplate

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
@Profile("MongoTemplate")
@Service
public class UserServiceMongoTemplate implements UserService {

    @Autowired
    private MongoTemplate mongoTemplate;

    @Override
    public User save(User user) {
        return mongoTemplate.save(user);
    }

    @Override
    public void deleteById(String id) {
        Query query = new Query(Criteria.where("id").is(id));
        mongoTemplate.remove(query);
    }

    @Override
    public void deleteAll() {
        mongoTemplate.remove(User.class);
    }

    @Override
    public Iterable<User> findAll() {
        return mongoTemplate.findAll(User.class);
    }

    @Override
    public Iterable<User> findAll(Integer pageNum, Integer pageSize) {
        Query query = new Query();
        query.skip(pageNum * pageSize);
        query.limit(pageSize);

        return mongoTemplate.find(query, User.class);
    }

    @Override
    public List<User> findAllByName(String name) {
        Query query = new Query(Criteria.where("name").is(name));
        return mongoTemplate.find(query, User.class);
    }

    @Override
    public Page<User> findAllByName(Integer pageNum, Integer pageSize, String name) {

        Query query = new Query();
        query.skip(pageNum * pageSize);
        query.limit(pageSize);

        Criteria criteria = new Criteria();
        criteria.and("name").equals(name);

        query.addCriteria(criteria);

        List<User> userList = mongoTemplate.find(query, User.class);

        long total = mongoTemplate.count(query, User.class);

        Pageable pageable = PageRequest.of(pageNum, pageSize);

        Page<User> userPage = new PageImpl(userList, pageable, total);
        return userPage;
    }
}

完整代码：GitHub

存在问题

MongoRepository 中 deleteById 和 MongoTemplate 中 deleteById, deleteAll 未生效，暂不知原因

展开全文 >>

Spring Boot + Sharding-JDBC 读写分离

本文使用 Sharding-JDBC 实现读写分离，基于 CentOS 7 + MySQL 5.7

一、MySQL 安装及配置

1.1 安装

依次执行命令：

1
2
3
4
5
6
7
sudo wget -i -c http://dev.mysql.com/get/mysql57-community-release-el7-10.noarch.rpm

sudo yum -y install mysql57-community-release-el7-10.noarch.rpm

sudo yum -y install mysql-community-server

sudo yum -y remove mysql57-community-release-el7-10.noarch

启动：

1
sudo systemctl start  mysqld

1.2 修改密码

查看默认密码：

1
grep "password" /var/log/mysqld.log

进入数据库：

1
mysql -uroot -p

修改密码：

1
alter user 'root'@'localhost' identified by 'NEW PASSWORD';

远程访问：

1
2
3
use mysql;
grant all privileges on *.* TO 'root'@'%' identified by 'PASSWORD';
flush privileges;

1.3 主从配置

本文一主 (192.168.30.101) 两从 (192.168.30.102, 192.168.30.103)

1.3.1 主库

1
sudo vim /etc/my.cnf
1
2
3
4
5
6
7
8
9
10
11
12
13
14
# server-id 给数据库服务的唯一标识
server-id=101
# log-bin 设置此参数表示启用 binlog 功能，并指定路径名称
log-bin=/var/lib/mysql/mysql-bin
sync_binlog=0
# 设置日志过期天数
# binlog-ignore-db 表示同步时忽略的数据库
# binlog-do-db 表示需要同步的数据库
expire_logs_days=7
binlog-do-db=test
binlog-ignore-db=information_schema
binlog-ignore-db=sys
binlog-ignore-db=mysql
binlog-ignore-db=performance_schema

重启数据库，执行 SQL:

1
2
3
4
5
grant replication slave on *.* to 'root'@'192.168.30.102' identified by 'YOUR PASSWORD';
flush privileges;

grant replication slave on *.* to 'root'@'192.168.30.103' identified by 'YOUR PASSWORD';
flush privileges;

重启数据库，执行 SQL:

1
show master status;

记录下 File 和 Position

1.3.2 从库配置

以 192.168.30.102 为例：

1
2
3
4
5
6
7
8
9
10
log-bin=mysql-bin
server-id=102
binlog-ignore-db=information_schema
binlog-ignore-db=sys
binlog-ignore-db=mysql
replicate-do-db=test
replicate-ignore-db=mysql
log-slave-updates
slave-skip-errors=all
slave-net-timeout=60

重启数据库，执行 SQL:

1
2
3
stop slave;
change master to master_host='192.168.30.101',master_user='root',master_password='YOUR PASSWORD',master_log_file='mysql-bin.000002', master_log_pos=154;
start slave;

其中 master_log_file 和 master_log_pos 分别为上步记录主库的 File 和 Position

二、使用

2.1 pom.xml

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
    <groupId>org.mybatis.spring.boot</groupId>
    <artifactId>mybatis-spring-boot-starter</artifactId>
    <version>2.1.0</version>
</dependency>
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
</dependency>
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>druid-spring-boot-starter</artifactId>
    <version>1.1.18</version>
</dependency>
<dependency>
    <groupId>io.shardingsphere</groupId>
    <artifactId>sharding-jdbc-spring-boot-starter</artifactId>
    <version>3.1.0</version>
</dependency>

2.2. application.yml

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
spring:
  main:
    allow-bean-definition-overriding: true

mybatis:
  configuration:
    map-underscore-to-camel-case: true
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl
  mapper-locations: classpath:mapping/*.xml

sharding:
  jdbc:
    datasource:
      names: db-master-1,db-slave-1,db-slave-2

      db-master-1:
        type: com.alibaba.druid.pool.DruidDataSource
        driverClassName: com.mysql.cj.jdbc.Driver
        url: jdbc:mysql://192.168.30.101:3306/test
        username: root
        password: root
        maxPoolSize: 20

      db-slave-1:
        type: com.alibaba.druid.pool.DruidDataSource
        driverClassName: com.mysql.cj.jdbc.Driver
        url: jdbc:mysql://192.168.30.102:3306/test
        username: root
        password: root
        maxPoolSize: 20

      db-slave-2:
        type: com.alibaba.druid.pool.DruidDataSource
        driverClassName: com.mysql.cj.jdbc.Driver
        url: jdbc:mysql://192.168.30.103:3306/test
        username: root
        password: root
        maxPoolSize: 20

    config:
      masterslave:
        load-balance-algorithm-type: round_robin # random 随机, round_robin 轮询
        name: db1s2
        master-data-source-name: db-master-1
        slave-data-source-names: db-slave-1,db-slave-2

    props:
      sql:
        show: true

完整代码：GitHub

参考：

  1. CentOS7 yum方式安装MySQL5.7
  2. Sharding-JDBC教程：Mysql数据库主从搭建
  3. Sharding-JDBC教程：Spring Boot整合Sharding-JDBC实现读写分离

展开全文 >>

Spring Boot + Elasticsearch 使用示例

本文分别使用 Elasticsearch Repository 和 ElasticsearchTemplate 实现 Elasticsearch 的简单的增删改查

一、Elastic Stack

Elastic Stack 是 ELK Stack 在 5.0 版本加入 Beats 套件后的新称呼

  1. Elasticsearch: 一个基于 JSON 的分布式搜索和分析引擎
  2. Logstash: 动态数据收集管道，能够同时从多个来源采集数据，转换数据，然后将数据发送到您最喜欢的“存储库”
  3. Kibana: 探索数据并管理堆栈，实现数据可视化
  4. Beats: 一个面向轻量型采集器的平台，从成百上千或成千上万台机器和系统向 Logstash 或 Elasticsearch 发送数据，目前包含：
    1. Filebeat: 日志文件 (用于转发和汇总日志与文件)
    2. Metricbeat: 指标 (用于从系统和服务收集指标)
    3. Packetbeat: 网络数据 (用于深挖网线上传输的数据，了解应用程序动态)
    4. Winlogbeat: Windows 事件日志 (用于密切监控基于 Windows 的基础设施上发生的事件)
    5. Auditbeat: 审计数据 (收集 Linux 审计框架的数据，监控文件完整性)
    6. Heartbeat: 运行时间监控 (通过主动探测来监测服务的可用性)
    7. Functionbeat: 无需服务器的采集器 (收集、传送并监测来自云服务的相关数据)
  5. APM Server: 从 APM agents 接收数据并将其转换为 Elasticsearch 文档
  6. Elasticsearch Hadoop: 深度集成 Hadoop 和 ElasticSearch 的项目

二、安装 Elasticsearch

截至目前，spring-data-elasticsearch 支持的 ElasticSearch 的版本为 6.2

本文使用 docker 安装：

1
sudo docker pull docker.elastic.co/elasticsearch/elasticsearch:6.2.4

开发者模式运行：

1
sudo docker run -p 9200:9200 -p 9300:9300 -e "discovery.type=single-node" docker.elastic.co/elasticsearch/elasticsearch:6.2.4

三、使用示例

application.yml:

1
2
3
4
5
spring:
  data:
    elasticsearch:
      cluster-name: docker-cluster
      cluster-nodes: 192.168.30.101:9300

entity:

1
2
3
4
5
6
7
8
9
@Document(indexName = "user")
public class User {
    @Id
    private String Id;
    private String name;
    private Integer gender;
    
    /*getter setter*/
}

service:

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

    long count();

    User save(User user);

    void deleteById(String id);

    void deleteAll();

    Iterable<User> findAll();

    Iterable<User> findAll(Integer pageNum, Integer pageSize);

    List<User> findAllByName(String name);

    Page<User> findAllByName(Integer pageNum, Integer pageSize, String name);
}

3.1 使用 Elasticsearch Repository

3.1.1 新建 UserElasticsearchRepository

1
2
3
@Repository
public interface UserElasticsearchRepository extends ElasticsearchRepository<User, String> {
}

3.1.2 新建 UserServiceElasticsearchRepository

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
@Profile("ElasticsearchRepository")
@Service
public class UserServiceElasticsearchRepository implements UserService {

    @Autowired
    private UserElasticsearchRepository userElasticsearchRepository;

    @Override
    public long count() {
        return userElasticsearchRepository.count();
    }

    @Override
    public User save(User user) {
        return userElasticsearchRepository.save(user);
    }

    @Override
    public void deleteById(String id) {
        userElasticsearchRepository.deleteById(id);
    }

    @Override
    public void deleteAll() {
        userElasticsearchRepository.deleteAll();
    }

    @Override
    public Iterable<User> findAll() {
        return userElasticsearchRepository.findAll();
    }

    @Override
    public Iterable<User> findAll(Integer pageNum, Integer pageSize) {

        Pageable pageable = PageRequest.of(pageNum, pageSize);
        return userElasticsearchRepository.findAll(pageable);
    }

    @Override
    public List<User> findAllByName(String name) {

        MatchQueryBuilder matchQueryBuilder = new MatchQueryBuilder("name", name);

        Iterable<User> userIterable =  userElasticsearchRepository.search(matchQueryBuilder);

        List<User> userList = new ArrayList<>();
        userIterable.forEach(u -> userList.add(u));

        return userList;
    }

    @Override
    public Page<User> findAllByName(Integer pageNum, Integer pageSize, String name) {

        SearchQuery searchQuery = new NativeSearchQueryBuilder()
                .withQuery(QueryBuilders.matchPhraseQuery("name", name))
                .withPageable(PageRequest.of(pageNum, pageSize))
                .build();
        return userElasticsearchRepository.search(searchQuery);
    }
}

3.2 使用 ElasticsearchTemplate

3.2.1 新建 UserServiceElasticsearchTemplate

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
@Profile("ElasticsearchTemplate")
@Service
public class UserServiceElasticsearchTemplate implements UserService {

    @Autowired
    private ElasticsearchTemplate elasticsearchTemplate;

    @Override
    public long count() {

        SearchQuery searchQuery = new NativeSearchQueryBuilder()
                .build();
        return elasticsearchTemplate.count(searchQuery, User.class);
    }

    @Override
    public User save(User user) {

        IndexQuery indexQuery = new IndexQueryBuilder().withId(user.getId().toString()).withObject(user).build();
        elasticsearchTemplate.index(indexQuery);

        return user;
    }

    @Override
    public void deleteById(String id) {

        elasticsearchTemplate.delete(User.class, id);
    }

    @Override
    public void deleteAll() {

        elasticsearchTemplate.deleteIndex(User.class);
    }

    @Override
    public Iterable<User> findAll() {

        SearchQuery searchQuery = new NativeSearchQueryBuilder()
                .build();

        return elasticsearchTemplate.queryForList(searchQuery, User.class);
    }

    @Override
    public Iterable<User> findAll(Integer pageNum, Integer pageSize) {
        SearchQuery searchQuery = new NativeSearchQueryBuilder()
                .withPageable(PageRequest.of(pageNum, pageSize))
                .build();

        return elasticsearchTemplate.queryForList(searchQuery, User.class);
    }

    @Override
    public List<User> findAllByName(String name) {

        SearchQuery searchQuery = new NativeSearchQueryBuilder()
                .withQuery(QueryBuilders.matchPhraseQuery("name", name))
                .build();

        return elasticsearchTemplate.queryForList(searchQuery, User.class);
    }

    @Override
    public Page<User> findAllByName(Integer pageNum, Integer pageSize, String name) {

        SearchQuery searchQuery = new NativeSearchQueryBuilder()
                .withQuery(QueryBuilders.matchPhraseQuery("name", name))
                .withPageable(PageRequest.of(pageNum, pageSize))
                .build();

        return elasticsearchTemplate.queryForPage(searchQuery, User.class);
    }
}

完整代码：GitHub

未解决问题

实体类中有 LocalDate 类型时报错：failed to map source

参考：

  1. SpringBoot+Elasticsearch
  2. Spring Data Elasticsearch

展开全文 >>

百物看世界 - 大英博物馆藏品展@香港文化博物馆

展览的构思源自大英博物馆与英国广播公司空前成功的广播节目，以大英博物馆藏的 100 组物品娓娓道来横跨二百万年的人类故事。有别于以往以文化区域阐述人类历史的方式，展览以独特的角度回顾人类发展的轨迹，探索人类共通的故事。即使身处不同的文化环境，人类在权力、信仰、艺术、贸易及科技等方面都有着相同的渴求及发展脉络，从而引领观众在全球化的视野下，对自己身处的世界有新的认识。

尼斯柏能纳的外棺 (公元前 800 年)

卡尔帕索斯仕女 (公元前 4500 - 3200 年) 这个有点抽象。。。

埃及化妆调色盘 (公元前 4000 - 3600 年) 有种莫名的喜感

拉美西斯二世像 (公元前 1280 年)

乌尔军旗 (约公元前 2500 年)

阿马拉瓦蒂大佛塔雕刻 (公元 200 – 240 年)

密特拉神像 (公元 100 - 200 年)

阿拉伯铜手 (公元 100 – 300 年)

犍陀罗佛陀坐像 (公元 100 - 300 年)

萨珊国王狩猎图银盘 (公元 309 – 379 年)

莫切武士壶 (公元 100 - 700 年)

东方三王圣物柜 (公元 1200 – 1230年)

印加黄金羊驼 (公元 1400 – 1550 年)

湿婆与帕尔瓦蒂雕像 (公元 900 – 1000 年)

路易斯岛棋子(约公元 1150 – 1175 年)

希伯来星盘 (公元 1345 – 1355 年)

贝宁铜板 (公元 1500 – 1600 年)

神奈川冲~浪里 (公元 1831 年)

阿富汗战争地毡 (公元 1979 – 1985 年)

母亲 (公元 2011 年)

然后，后来不知怎么就有种看表情包的心情。。。

“闹钟响了，不想起床，要不要再睡一会”

“要矜持，不能笑” 卡花岗岩沙伯提俑 (公元前 644 年)

“傲娇，谁还不是小公举咋地”

“来~给大爷笑一个”

左：“好想卖萌，耶！”
右：“左边那逗逼笑得我肚子痛”

“有蚊子，啪”

“矮油，牙痛”

“你居然敢打我，委屈脸”

部分图片来自香港文化博物馆官网

展开全文 >>

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>谢谢大家