springboot 整合 mongodb 增删改查，MongoTemplate 方式操作， 第二篇

1 添加依赖

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

2 application.yml文件

# 不需要认证的方式
spring:
  data:
    mongodb:
      uri: mongodb://localhost:27017/mydb_1

# mongodb需要用户名和密码
spring:
  data:
    mongodb:
      uri: mongodb://user1:123456@localhost:27017/mydb_2

3 pojo类编写

package cn.huawei.pojo;
import org.springframework.data.annotation.Id;
import org.springframework.data.mongodb.core.mapping.Document;
import org.springframework.data.mongodb.core.mapping.Field;
import java.util.List;

//@Document是mongodb驱动库提供设置操作的文档集合名称的注解，这里设置集合为user
@Document("user")
public class User {

    //mongodb会自动处理成 ObjectId("6082825b29a0083013d6a8ac")的类似样子
    @Id
    private String id;

    //普通字段
    @Field
    private Integer userId;

    @Field
    private Integer age;

    @Field
    private String name;

    @Field
    private String phone;

    @Field
    private String[] aihao;

    @Field
    private List<Order> orders;
}

4 测试类编写

import cn.huawei.JineErpApplication;
import cn.huawei.pojo.Address;
import cn.huawei.pojo.Order;
import cn.huawei.pojo.User;
import com.mongodb.client.result.DeleteResult;
import com.mongodb.client.result.UpdateResult;
import org.bson.types.ObjectId;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.data.domain.Sort;
import org.springframework.data.mongodb.core.MongoTemplate;
import org.springframework.data.mongodb.core.query.Criteria;
import org.springframework.data.mongodb.core.query.Query;
import org.springframework.data.mongodb.core.query.Update;
import java.util.ArrayList;
import java.util.List;
import java.util.regex.Pattern;

@SpringBootTest(classes = JineErpApplication.class)
public class Test_1 {

    @Autowired
    private MongoTemplate mongoTemplate;

    /**
     * 添加记录
     */
    @Test
    public void fangfa_1() {
        User user = new User(9, 93, "夏雨来", "15258742546");
        /*
        存到user表
        类似地，使用insert也可以达到保存数据的作用
         */
        mongoTemplate.save(user);
    }


    /*
    添加记录，复杂类型的数据
     */
    @Test
    public void fangfa_19(){
        User user = new User(10, 199, "雄霸天下", "15258742546");
        user.setAihao(new String[]{"money","car","lvren"});

        ArrayList<Order> orders = new ArrayList<>();
        orders.add(new Order("20210423163911","汽车",2));
        orders.add(new Order("20210423163945","房子",5));

        user.setOrders(orders);

        mongoTemplate.insert(user);
    }


    /*
    批量添加记录
     */
    @Test
    public void fangfa_2() {
        List<User> userList = new ArrayList<>();
        userList.add(new User(2, 12, "张三", "18888888888"));
        userList.add(new User(3, 21, "李四", "13333333333"));
        userList.add(new User(4, 55, "王麻子", "14444444444"));
        userList.add(new User(5, 63, "陈李厚", "15555555555"));
        userList.add(new User(6, 85, "村民", "16666666666"));
        //存到 yonghutable 表
        mongoTemplate.insert(userList, "yonghutable");
        //存到user表
        mongoTemplate.insert(userList, User.class);
    }


    /*
    删除数据
     */
    @Test
    public void fangfa_13() {
        Query query_1 = new Query();
        query_1.addCriteria(Criteria.where("userId").is(10));

        DeleteResult remove = mongoTemplate.remove(query_1, User.class);
        System.out.println(remove);
    }


    /*
    返回查询到的记录数据，同时也删除
     */
    @Test
    public void fangfa_17()
    {
        Query query = new Query();
        query.addCriteria(Criteria.where("_id").is(new ObjectId("60826407a0450757ccfde19d")));

        List<User> allAndRemove = mongoTemplate.findAllAndRemove(query, "user");
        System.out.println(allAndRemove);
    }


    /*
    返回所有数据
     */
    @Test
    public void fangfa_12() {
        List<User> all = mongoTemplate.findAll(User.class);
        System.out.println(all);
        System.out.println(all.size());
    }


    /*
    根据mongodb生成的id查询
     */
    @Test
    public void fangfa_14() {
        Query query = new Query();
        query.addCriteria(Criteria.where("_id").is(new ObjectId("60823dd8392f042f46614f10")));

        List<User> users = mongoTemplate.find(query, User.class);
        System.out.println(users);
    }


    /*
    查询记录，排序 并 分页显示
     */
    @Test
    public void fangfa_15() {
        Query query_1 = new Query();
        query_1.with(Sort.by(Sort.Direction.ASC, "userId"));

        //从那条记录开始
        query_1.skip(1);
        //取多少条记录
        query_1.limit(3);
        List<User> users = mongoTemplate.find(query_1, User.class);
        System.out.println(users);
    }


    /*
    简单 模糊查询用 “regex”
     */
    @Test
    public void fangfa_18()
    {
        Query query_1 = new Query(Criteria.where("name").regex("王麻"));
        List<User> users = mongoTemplate.find(query_1, User.class);
        System.out.println(users);
    }


    /*
    查询单条数据
     */
    @Test
    public void fangfa_3() {
        Pattern pattern = Pattern.compile("^.*6$", Pattern.CASE_INSENSITIVE);
        Query query_1 = new Query(Criteria.where("phone").regex(pattern));
        User one = mongoTemplate.findOne(query_1, User.class);
        System.out.println(one);
    }


    /*
    查询多条数据 多个条件查询
     */
    @Test
    public void fangfa_4() {
        //模糊查询以 ^开始 以$结束 .*相当于Mysql中的%
        Pattern pattern = Pattern.compile("^1.*$", Pattern.CASE_INSENSITIVE);
        Query query_1 = new Query(Criteria.where("phone").regex(pattern));
        //并且 name=张三
        query_1.addCriteria(Criteria.where("name").is("张三"));
        //排序
        query_1.with(Sort.by("age", "userId").descending());
        List<User> userList = mongoTemplate.find(query_1, User.class, "user");
        System.out.println(userList);
    }


    /*
    多个条件查询(格式1)
     */
    @Test
    public void fangfa_5() {
        Query query_1 = new Query();
        query_1.addCriteria(Criteria.where("name").is("王麻子"));
        query_1.addCriteria(Criteria.where("phone").is("14444444444"));
        List<User> userList = mongoTemplate.find(query_1, User.class, "user");
        System.out.println(userList);
    }


    /*
    多个条件查询(格式2)
     */
    @Test
    public void fangfa_6() {
        Criteria criteria = new Criteria();
        criteria.and("name").is("王麻子");
        criteria.and("phone").is("14444444444");

        Query query_1 = new Query(criteria);
        List<User> userList = mongoTemplate.find(query_1, User.class, "user");
        System.out.println(userList);
    }


    /*
    一个模糊关键字匹配多个字段
     */
    @Test
    public void fangfa_7() {
        Pattern pattern = Pattern.compile("^.*222$", Pattern.CASE_INSENSITIVE);
        Criteria criteria = new Criteria();

        //phone以222结尾的 或者 name以222结尾的
        criteria.orOperator(Criteria.where("phone").regex(pattern),
                Criteria.where("name").regex(pattern));

        //同时满足 phone以222结尾的，和name以222结尾的
        criteria.andOperator(Criteria.where("phone").regex(pattern),
                Criteria.where("name").regex(pattern));

        Query query_1 = new Query(criteria);
        List<User> userList = mongoTemplate.find(query_1, User.class, "user");
        System.out.println(userList);
    }


    /*
    更新
    age汪上递增5
     */
    @Test
    public void fangfa_16(){
        Query query = new Query();

        Update update = new Update();
        update.inc("age",5);

        UpdateResult updateResult = mongoTemplate.updateMulti(query, update, User.class);
        System.out.println(updateResult);
    }


    /*
    更新
    语法：public UpdateResult update(Query query, UpdateDefinition update, Class<?> entityClass)
     query参数是查询条件对象，update是需要更新的数据对象，entityClass就是对应的JavaBean对象（文档集合类）
     */
    @Test
    public void fangfa_8() {
        Query query = new Query();
        query.addCriteria(Criteria.where("userId").is(7));

        Update update = new Update();
        update.set("name", "飘过");
        update.set("other", "顶起");

        //查询，更新第一条
        UpdateResult updateResult_1 = mongoTemplate.updateFirst(query, update, User.class);

        //查询到的，全部更新
        UpdateResult updateResult_2 = mongoTemplate.updateMulti(query, update, User.class);

        //有则更新，没有则新增
        UpdateResult updateResult_3 = mongoTemplate.upsert(query, update, User.class);
        System.out.println(updateResult_1);
    }


}