Spring Data Mongodb

Spring Data Mongodb

创建项目

修改POM文件添加依赖

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-mongodb</artifactId>
</dependency>

修改配置文件

spring:
  data:
    mongodb:
      database: latte
      host: xxx
      username: latteitcjz
      password: smallminglatte7
      authentication-database: admin

MongoTemplate的使用

创建实体

@Document 参数表示操作的集合名称，如果没有@Document表示操作的集合名为实体类名首字母变小写（由大驼峰变成小驼峰）。
@Id 标识主键。当主键叫做_id或id时可以省略此属性
@Field 放在普通属性上，如果希望对属性改名或其他限制需要此注解。可以省略，表示实体类属性名为Mongodb集合中field名称

@Document("collection1")
public class People {
    @Id
    private String id;
    private String name;
    private int age;

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    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 "People{" +
                "id='" + id + '\'' +
                ", name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

添加文档

insert方法返回值是新增的Document对象，里面包含了新增后_id的值。
如果集合不存在会自动创建集合。通过Spring Data MongoDB还会给集合中多加一个_class的属性，存储新增时Document对应Java中类的全限定路径。这么做为了查询时能把Document转换为Java中类类型。

@Test
public void insert() {
    People people = new People();
    people.setAge(12);
    people.setName("测试名字");
    People people = mongoTemplate.insert(people);
}

修改文档

在Mongodb中无论是使用客户端API还是使用Spring Data，更新返回结果一定是受影响行数。如果更新后的结果和更新前的结果是相同，返回0。
如果使用对象方式进行修改（save方法）必须要保证对象中所有属性都是有值得，否则只能使用update方法

使用save修改

使用save时，如果主键值已经存在，则表示修改操作。

void contextLoads() {
    HousePojo hp = new HousePojo();
    hp.setId("5e478e0c41b522522ab11099");
    hp.setArea(129.0);
    hp.setHno("x003");
    hp.setTime(new Date());
    hp.setType("三室一厅");
    // 重点是返回的结果带有主键_id
    HousePojo hpResult = mongoTemplate.save(hp);
    System.out.println(hpResult);
}

使用特定运算符进行更新

底层使用mongodb更新运算符完成。
Update的set方法底层就是$set.可以通过set方法更新特定的属性值。
有两个更新方法：
updateFirst（）只更新满足条件的第一个值
updateMulti() 更新所有满足条件的值

updateFirst

使用Update设置修改结果时，注意update.set()函数第一个参数的类型。如果name是字符串取值张三要有双引号。如果set方法第一个参数是age,第二个参数要没有双引号

// 设置查询体，查询条件具体内容
Criteria criteria = Criteria.where("name").is("张三");
// query设置查询条件
Query query = new Query(criteria);
// 设置修改哪些属性
Update update = new Update();
update.set("name","张三");
// People.class 告诉Spring Data MognoDB 上面的属性是哪个类。
// 类对应集合，就知道具体操作集合的哪个属性
UpdateResult result = mongoTemplate.updateFirst(query, update, People.class);
// 修改数量，如果修改前和修改后相同，返回0
System.out.println(result.getModifiedCount());
// 匹配数量。最多返回1，即使有多个张三返回也是1.
System.out.println(result.getMatchedCount());

updateMulti

// 设置查询体，查询条件具体内容
Criteria criteria = Criteria.where("name").is("张三");
// query设置查询条件
Query query = new Query(criteria);
// 设置修改哪些属性
Update update = new Update();
update.set("age",18);
// People.class 告诉Spring Data MognoDB 上面的属性是哪个类。
// 类对应集合，就知道具体操作集合的哪个属性
UpdateResult result = mongoTemplate.updateMulti(query, update, People.class);
// 修改数量。返回所有匹配结果中真实被修改数量
System.out.println(result.getModifiedCount());
// 匹配数量
System.out.println(result.getMatchedCount());

删除

根据主键删除

使用remove(Object)实现根据主键进行删除。
只判断对象的主键，其他属性是否有值没有影响。但是主键必须不能是null的。

People peo = new People();
peo.setId("5e83fe26a7641113b6a4d71d");
peo.setName("随意");
DeleteResult result = mongoTemplate.remove(peo);
System.out.println(result.getDeletedCount());

根据条件进行删除

只要是Spring Data MongoDB中涉及到条件都提供了两种方式，一种根据POJO中属性名进行匹配，另一种是根据集合中属性名进行匹配。

修改POJO

此处特意把属性name配置@Field设置MongoDB集合中属性名称为username

@Data
@NoArgsConstructor
@AllArgsConstructor
public class People {
    // 主键可以叫做id也能映射上_id
    private String id;
    @Field("username")
    private String name;
    private Integer age;
    private String address;
}

通过实体类属性名设置条件

里面where方法参数name是People类的属性名。
remove方法第二个参数是类类型。

Query query = new Query(Criteria.where("name").is("张三"));
// 第二个参数告诉Spring Data Mongodb ，name属性对应的类类型。
DeleteResult result = mongoTemplate.remove(query, People.class);
System.out.println(result.getDeletedCount());

通过集合属性名设置条件

其中where方法参数username是集合people的属性名
remove第二个参数是MongoDB中集合名称。

Query query = new Query(Criteria.where("username").is("张三"));
// 第二个参数告诉Spring Data Mongodb ，name属性对应的类类型。
DeleteResult result = mongoTemplate.remove(query,"people");
System.out.println(result.getDeletedCount());

查询文档

Criteria是标准查询的接口，可以引用静态的Criteria.where的把多个条件组合在一起，就可以轻松地将多个方法标准和查询连接起来，方便我们操作查询语句。
例如： 查询条件username=“smallming”
mongoTemplate.find (new Query(Criteria.where(“username”).is("latte)))

多个条件组合查询时：
例如：username=“smallming” and userage=“20”
mongoTemplate.find(new Query(Criteria.where(“username”).is(“latte”).and(“userage”).is(“20”)))

例如：username=“smallming” or userage=“20”
mongoTemplate.findOne(new Query(new Criteria().orOperator(Criteria.where(“username”).is(“latte”),Criteria.where(“userage”).is(“20”))));

查询全部文档

@Test
public void select() {
    List<People> list = mongoTemplate.findAll(People.class);
    System.out.println(list);
}

查询单个对象

如果查询结果是多个，返回其中第一个文档对象

@Test
void selectOne(){
    // 获取到结果中第一条数据
    // new Query() 表示没有条件
    People people = mongoTemplate.findOne(new Query(), People.class);
    System.out.println(people);
}

带有条件的查询多个

注意： 带有条件的查询多个时，使用find（）方法

@Test
void find(){
    Query query = new Query(Criteria.where("age").gte(3));
    List<People> list = mongoTemplate.find(query, People.class);
    System.out.println(list);
}

根据主键进行查询

@Test
void findById(){
    People peo = mongoTemplate.findById("5e84317c2b937833016218bf", People.class);
    System.out.println(peo);
}

根据字段是否为空进行查询

@Test
void exists(){
    Query query = new Query(Criteria.where("age").exists(true));
    List<People> list = mongoTemplate.find(query, People.class);
    System.out.println(list);
}

根据大于并且小于查询

Criteria所有方法的返回值都是当前类对象，所以支持连缀写法。

@Test
void range(){
    Query query = new Query(Criteria.where("age").gte(1).lte(19));
    List<People> list = mongoTemplate.find(query, People.class);
    System.out.println(list);
}

根据正则查询（模糊查询）

@Test
void regex() {
    // java中正则不需要有//
    Query query = new Query(Criteria.where("name").regex("张"));
    List<People> list = mongoTemplate.find(query, People.class);
    System.out.println(list);
}

查询去重复结果

findDistinct() 参数说明：
第一个参数： 查询条件query
第二个参数： 根据哪个属性去重复。是POJO的属性名称。返回值为此属性去重后的集合。
第三个参数： 属性所在实体类。
第四个参数： 属性的类型，此类型作为结果中List集合的泛型。

@Test
void findDistinct(){
    List<String> list = mongoTemplate.findDistinct(new Query(), "name", People.class, String.class);
    System.out.println(list);
}

多条件查询

and

@Test
void and(){
    Criteria c = new Criteria();
    c.andOperator(Criteria.where("name").is("张三"),Criteria.where("age").is(18));
    Query query = new Query(c);
    List<People> list = mongoTemplate.find(query, People.class);
    System.out.println(list);
}

Or
查询姓名为张三或者年龄是998岁的用户

@Test
void or(){
    Criteria c = new Criteria();
    c.orOperator(Criteria.where("name").is("张三"),Criteria.where("age").is(998));
    List<People> list = mongoTemplate.find(new Query(c), People.class);
    System.out.println(list);
}

混合应用

查询姓名为张三并且年龄为18岁或者姓名为李四年龄为20的用户

@Test
void orAnd(){

    Criteria and1 = new Criteria();
    and1.andOperator(Criteria.where("name").is("张三"),Criteria.where("age").is(18));
    Criteria and2 = new Criteria();
    and2.andOperator(Criteria.where("name").is("李四"),Criteria.where("age").is(20));

    Criteria c = new Criteria();
    c.orOperator(and1,and2);

    List<People> list = mongoTemplate.find(new Query(c), People.class);
    System.out.println(list);
}

结果排序

Sort只有私有构造，但是提供给了静态的by方法
Direction是Sort内部枚举。
age按照那个属性进行排序。属性一定是find方法第二个参数类中的属性。

@Test
void sort(){
    Query query = new Query(Criteria.where("age").gte(2));
    query.with(Sort.by(Sort.Direction.DESC,"age"));
    List<People> list = mongoTemplate.find(query, People.class);
    System.out.println(list);
}

分页查询

PageRequest是Pageable接口的实现类。里面有protected的构造方法和名称为of的静态方法。
PageRequest.of(page,size)
PageRequest.of(page,size,Sort) 先排序后分页
PageRequest.of(page,size,Direction,properties) 排序后分页
page表示第几页，0表示第一页
size表示一页显示几个

    @Test
    void page(){
        Query query = new Query();
//        query.with(PageRequest.of(0,2));
        query.with(PageRequest.of(0,2, Sort.Direction.DESC,"age"));
        List<People> list = mongoTemplate.find(query, People.class);
        System.out.println(list);
    }

聚合操作

查询文档总数

Aggregation.group(String …)设置分组条件，如果没有分组，参数省略。
count() 取总条数
as() 给查询出来的总条数起别名
aggregate() 执行聚合命令，第二个参数Map表示返回结果放入到Map中。
result.getUniqueMappedResult() 获取到返回结果。

@Test
void aggregate(){
    TypedAggregation<People> aggregation  = TypedAggregation.newAggregation(People.class, Aggregation.group().count().as("count"));
    AggregationResults<Map> result = mongoTemplate.aggregate(aggregation, Map.class);
    System.out.println(result.getUniqueMappedResult());
    System.out.println(result.getUniqueMappedResult().get("count"));
}

分组计算每组总数

此处要求group()参数必须是在People类中存在。
设置group参数，表示按照哪个属性进行分组。
getMappedResults() 当执行聚合函数返回结果为多行时使用此方法。

@Test
void aggregate(){
    TypedAggregation<People> aggregation  = TypedAggregation.newAggregation(People.class, Aggregation.group("name").count().as("count"));
    AggregationResults<Map> result = mongoTemplate.aggregate(aggregation, Map.class);
    List<Map> list = result.getMappedResults();
    for(Map map : list){
        System.out.println(map.get("count")+"---"+map.get("_id"));
    }
}

带有查询条件的分组计算

Aggregation.match写在group前面表示先过滤条件在分组。写在后面表示先分组在过滤条件

@Test
void aggregate(){
    TypedAggregation<People> aggregation  = TypedAggregation.newAggregation(People.class,Aggregation.match(Criteria.where("name").is("张三")), Aggregation.group("name").count().as("count"));
    AggregationResults<Map> result = mongoTemplate.aggregate(aggregation, Map.class);
    List<Map> list = result.getMappedResults();
    for(Map map : list){
        System.out.println(map.get("count")+"---"+map.get("_id"));
    }
}