# mongo-learn

**Repository Path**: fengdudf/mongo-learn

## Basic Information

- **Project Name**: mongo-learn
- **Description**: mongodb学习：
安装、配置、集群管理
MongoTemplate基本使用、聚合操作
- **Primary Language**: Java
- **License**: Not specified
- **Default Branch**: master
- **Homepage**: None
- **GVP Project**: No

## Statistics

- **Stars**: 0
- **Forks**: 4
- **Created**: 2021-05-25
- **Last Updated**: 2021-05-25

## Categories & Tags

**Categories**: Uncategorized

**Tags**: None

## README

## mongo-learn

代码位置：D:\learnProject\mongo-learn\


###
is: 精确匹配,
regex: 模糊匹配

Criteria [kraɪˈtɪrɪə] 

Aggregation [ˌæɡrɪˈɡeʃən]


```java
Pattern pattern = Pattern.compile("^.*" + name + ".*$", Pattern.CASE_INSENSITIVE);
query.addCriteria(Criteria.where("userName").regex(pattern));
```

或者：
```java
query.addCriteria(Criteria.where("userName").regex(".*" + name + ".*"));
```

日期范围
```java
 Criteria criteria = Criteria.where("timeDate").gte(timeDateStart).lt(timeDateEnd);  
```

分页查询，带排序
```java
public List<UserEntity> pageQuery(String name, int pageSize, int pageNo) {
    Query query = new Query();

    //Pattern pattern = Pattern.compile("^.*" + name + ".*$", Pattern.CASE_INSENSITIVE);
    //query.addCriteria(Criteria.where("userName").regex(pattern));
    query.addCriteria(Criteria.where("userName").regex(".*" + name + ".*"));
    //时间比较
    //Criteria criteria = Criteria.where("timeDate").gte(timeDateStart).lt(timeDateEnd);
    //按照id升序
    Sort sort = new Sort(new Sort.Order(Sort.Direction.ASC, "id"));
    //分页查询
    return mongoTemplate.find(query.with(sort).limit(pageSize).skip((pageNo - 1) * pageSize), UserEntity.class);
}
```

查询非空
```java
    public List<UserEntity> queryNameNotEmpty() {
        Query query = new Query();
        Sort sort = new Sort(new Sort.Order(Sort.Direction.DESC, "id"));
        query.addCriteria(Criteria.where("name").ne("").ne(null));
        return mongoTemplate.find(query.with(sort), UserEntity.class);
    }
```

查询满足a||b||c
```java
    public List<UserEntity> queryByAge(int age1, int age2, int age3) {
        Query query = new Query();
        query.addCriteria(new Criteria().orOperator(
                Criteria.where("age").is(age1),//这里是可变参数
                Criteria.where("age").is(age2),
                Criteria.where("age").is(age3)
        ));
        return mongoTemplate.find(query, UserEntity.class);
    }
```

查询满足条件 a&&b
```java
    public List<UserEntity> queryByNameAndAge(String name, Integer age) {
        Query query = new Query();
        Criteria criteria = new Criteria();
        criteria.and("name").regex(".*" + name + ".*");
        criteria.and("age").gte(age);
        query.addCriteria(criteria);
        long count = mongoTemplate.count(query, UserEntity.class);
        System.out.println(age + "岁以上的人name like " + name + ",人数=" + count);

        return mongoTemplate.find(query, UserEntity.class);
    }
```

修改单条
```java
    public int updateUser(UserEntity user) {
        Query query = new Query(Criteria.where("id").is(user.getId()));
        Update update = new Update()
                .set("userName", user.getUserName())
                .set("passWord", user.getPassWord());
        //更新符合条件的第一个
        WriteResult result = mongoTemplate.updateFirst(query, update, UserEntity.class);
        if (result != null) {
            return result.getN();
        }
        return 0;
    }
```

修改多条
```java
    public int batchUpdate(List<Long> idList, String username) {
        Query query = new Query(Criteria.where("id").in(idList));
        Update update = new Update().set("userName", username);
        //更新查询出来的所有
        WriteResult result = mongoTemplate.updateMulti(query, update, UserEntity.class);
        if (null != result) {
            return result.getN();
        }
        return 0;
    }
```

### 聚合查询


![aaa](https://img-blog.csdn.net/20180208145011409)


命令行格式化显示：  
db.pt.find().pretty()

#### Q1: 统计各个年级人数  
这个比较简单，我们只需要按照年级分组然后进行sum就能得到结果
mongo命令：
```js
db.pt.aggregate([ { "$group" : { "_id" : "$grade_name" , "总人数" : { "$sum" : 1}}}] )
```

结果：

```java
    public void aggeByGrade() {
        Aggregation aggregation = Aggregation.newAggregation(Aggregation.group("grade_name").count().as("总人数"));
        //返回的是一个集合
        AggregationResults<BasicDBObject> aggregationResults = mongoTemplate.aggregate(aggregation, "pt", BasicDBObject.class);
        for (BasicDBObject obj : aggregationResults) {
            System.out.println(obj.toString());
        }
    }
```



```java
    //Q2："统计某个年级某一项测试在某个范围的人数" 只需要匹配 年级+测试项目+项目分数 between 分数1 and 分数2 然后根据年级分组统计
    public void aggregation2() {
        Aggregation aggregation = Aggregation.newAggregation(
                Aggregation.unwind("items"),//解开，展开
                Aggregation.match(Criteria.where("items.item_name").is("俯卧撑").and("items.score").gt(20).lt(50)),
                Aggregation.group("grade_name").count().as("俯卧撑合格的人数"));
        AggregationResults<BasicDBObject> results = mongoTemplate.aggregate(aggregation, "pt", BasicDBObject.class);

        for (BasicDBObject obj : results) {
            System.out.println(obj.toString());
        }
    }
```


```java
    public void aggregation3() {
        Aggregation aggregation3 = Aggregation.newAggregation(
                Aggregation.match(Criteria.where("grade_name").is("二年级")),
                Aggregation.unwind("items"),
                Aggregation.match(Criteria.where("items.item_name").is("中长跑1000米").orOperator(
                        Criteria.where("items.score").lte(130),
                        Criteria.where("items.score").gte(200))),
                Aggregation.group("grade_name").count().as("中长跑不合格的人数")
        );

        AggregationResults<BasicDBObject> outputTypeCount3 = mongoTemplate.aggregate(aggregation3, "pt", BasicDBObject.class);
        for (BasicDBObject obj : outputTypeCount3) {
            System.out.println(obj);
        }
    }
```

## 主从复制


## 副本集

![fbj](https://images2015.cnblogs.com/blog/907596/201706/907596-20170604013129524-1035525546.png)

![fbj2](https://images2015.cnblogs.com/blog/907596/201706/907596-20170604012944508-1544910602.png)


## 分片


![sharding](https://images2015.cnblogs.com/blog/907596/201706/907596-20170604042221071-857890203.png)

![sharding](https://images2015.cnblogs.com/blog/907596/201706/907596-20170604042624993-668182824.png)