MongoDBJava操作--整合Spring Data

1. 基于Java基本操作

package com.czxy.xuecheng;

import com.mongodb.MongoClient;
import com.mongodb.MongoClientURI;
import com.mongodb.client.FindIterable;
import com.mongodb.client.MongoCollection;
import com.mongodb.client.MongoCursor;
import com.mongodb.client.MongoDatabase;
import com.mongodb.client.model.Filters;
import org.bson.Document;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.test.context.junit4.SpringRunner;

import java.util.ArrayList;

@RunWith(SpringRunner.class)
public class MongoTest {
    /**
     * 连接本地数据库
     */
    @Test
    public void testConnection(){
    //    创建mongo对象
        MongoClient mongoClient = new MongoClient("localhost", 27017);
        System.out.println(mongoClient);
    }

    /**
     * 查询第一个数据
     */
    @Test
    public void FindFirst(){
        //采用连接字符串
        MongoClientURI connectionString = new MongoClientURI("mongodb://root:root@localhost:27017");
        MongoClient mongoClient = new MongoClient(connectionString);
        // 连接数据库
        MongoDatabase database = mongoClient.getDatabase("user");
    //    连接collection
        MongoCollection<Document> student = database.getCollection("student");
    //    查询第一个文档
        Document first = student.find().first();
    //    转为json格式
        String s = first.toJson();
        System.out.println(s);
    }

    /**
     * 创建一个表
     */
    @Test
    public void testCollection(){
    //    采用连接字符串
        MongoClientURI mongoClientURI = new MongoClientURI("mongodb://root:root@localhost:27017");
        MongoClient mongoClient = new MongoClient(mongoClientURI);
    //    连接数据库
        MongoDatabase database = mongoClient.getDatabase("user");
    //    创建集合
        database.createCollection("teacher");
    }

    /**
     * 创建一个表数据
     */
    @Test
    public void testDocument(){
        MongoClientURI mongoClientURI = new MongoClientURI("mongodb://root:root@localhost:27017");
        MongoClient mongoClient = new MongoClient(mongoClientURI);
    //    连接数据库
        MongoDatabase database = mongoClient.getDatabase("user");
    //    获得集合
        MongoCollection<Document> collection = database.getCollection("teacher");
    //    插入数据
        Document document = new Document();
        document.append("name","L老师");
        document.append("age",18);
        document.append("phone","18181818181");
        document.append("sex","男");
        collection.insertOne(document);
    }

    /**
     * 批量添加数据
     */
    @Test
    public void ArrayCollection(){
    //    获取连接
        MongoClientURI mongoClientURI = new MongoClientURI("mongodb://root:root@localhost:27017");
        MongoClient mongoClient = new MongoClient(mongoClientURI);
    //    获取数据库
        MongoDatabase database = mongoClient.getDatabase("user");
    //    获取表连接
        MongoCollection<Document> collection = database.getCollection("teacher");
        Document dco1 = new Document();
        dco1.append("name","M老师");
        dco1.append("age",19);
        dco1.append("phone","18191819181");
        dco1.append("sex","男");
        Document dco2 = new Document();
        dco2.append("name","Z老师");
        dco2.append("age",18);
        dco2.append("phone","19191919191");
        dco2.append("sex","女");
        ArrayList<Document> documents = new ArrayList<>();
        documents.add(dco1);
        documents.add(dco2);
        collection.insertMany(documents);
    }

    /**
     * 查询所有表数据
     */
    @Test
    public void testSelectAll(){
    //    创建连接
        MongoClientURI mongoClientURI = new MongoClientURI("mongodb://root:root@localhost:27017");
        MongoClient mongoClient = new MongoClient(mongoClientURI);
    //    连接数据库
        MongoDatabase database = mongoClient.getDatabase("user");
    //    连接表
        MongoCollection<Document> teacher = database.getCollection("teacher");
    //    查询
        FindIterable<Document> documents = teacher.find();
    //    使用迭代器遍历
        MongoCursor<Document> iterator = documents.iterator();
        while (iterator.hasNext()){
            Document document = iterator.next();
            String name = document.get("name", String.class);
            Integer age = document.get("age", Integer.class);
            String phone = document.get("phone", String.class);
            String sex = document.get("sex", String.class);
            System.out.println(name+","+age+","+phone+","+sex);
        }
    }

    /**
     * 更新数据
     */
    @Test
    public void testUpdate(){
    //    获得连接
        MongoClientURI mongoClientURI = new MongoClientURI("mongodb://root:root@localhost:27017");
        MongoClient mongoClient = new MongoClient(mongoClientURI);
    //    获得数据库
        MongoDatabase database = mongoClient.getDatabase("user");
    //    获得表
        MongoCollection<Document> teacher = database.getCollection("teacher");
    //    更新数据
        teacher.updateMany(Filters.eq("age",18),new Document("$set",new Document("age",20)));
    }

    /**
     * 删除数据
     */
    @Test
    public void testDelete(){
    //    获得连接
        MongoClientURI mongoClientURI = new MongoClientURI("mongodb://root:root@localhost:27017");
        MongoClient mongoClient = new MongoClient(mongoClientURI);
    //    获得数据库
        MongoDatabase database = mongoClient.getDatabase("user");
    //    获得表
        MongoCollection<Document> teacher = database.getCollection("teacher");
    //    删除
        teacher.deleteOne(Filters.eq("age",19));
    }
}

2. 整合 Spring Data

• 步骤一：修改pom文件，更新依赖

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

• 步骤二：修改yml文件，配置mongo连接字符串

spring:
  data:
    mongodb:
      uri:  mongodb://root:root@localhost:27017/user

• 步骤三：编写JavaBean，配置文档对应集合

package com.czxy.xuecheng.domain;

import lombok.Data;
import org.springframework.data.annotation.Id;
import org.springframework.data.mongodb.core.mapping.Document;

@Document(collection = "teacher")
@Data
public class Teachers {
    @Id
    private String id;
    private String name;
    private Integer age;
    private String phone;
    private String sex;
}

• 步骤四：编写dao，继承 MongoRepository

package com.czxy.xuecheng.dao;

import com.czxy.xuecheng.domain.Teacher;
import org.springframework.data.mongodb.repository.MongoRepository;
public interface TeacherRepository extends MongoRepository<Teacher,String> {
}

• 步骤五：编写启动类，使用 @ComponentScan 扫描dao

package com.czxy.xuecheng;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.ComponentScan;

@SpringBootApplication
@ComponentScan(basePackages = "com.czxy.xuecheng.dao")
public class TeacherApplication {
    public static void main(String[] args) {
        SpringApplication.run(TeacherApplication.class,args);
    }
}

• 步骤五: 测试代码

package com.czxy.xuecheng;

import com.czxy.xuecheng.dao.TeacherRepository;
import com.czxy.xuecheng.domain.Teachers;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.PageRequest;
import org.springframework.data.domain.Sort;
import org.springframework.test.context.junit4.SpringRunner;

import javax.annotation.Resource;
import java.util.List;
import java.util.Optional;
import java.util.stream.Collectors;

@RunWith(SpringRunner.class)
@SpringBootTest(classes = TeacherApplication.class)
public class SpringMongoDBTest {
    @Resource
    private TeacherRepository teacherRepository;

    /**
     *  查询所有数据
     */
    @Test
    public void FindAll(){
        List<Teachers> tlist = teacherRepository.findAll();
        System.err.println(tlist);
    }

    /**
     * 排序查找 按年龄排序
     */
    @Test
    public void FindListBySort(){
        List<Teachers> tlist = teacherRepository.findAll(Sort.by(Sort.Order.desc("age")));
        for (Teachers teachers : tlist) {
            System.err.println(teachers);
        }
    }

    /**
     * 分页
     */
    @Test
    public void FindListByPage(){
        int page = 0;
        int size = 1;
        Page<Teachers> pi = teacherRepository.findAll(PageRequest.of(page, size));
        //获得分页内容
        List<Teachers> teachersList = pi.getContent();
        System.err.println("总条数:"+pi.getTotalElements());
        for (Teachers teachers : teachersList) {
            System.err.println(teachers);
        }
    }

    /**
     * 添加数据
     */
    @Test
    public void AddTeacher(){
        Teachers t = new Teachers();
        t.setName("Z老师");
        t.setAge(18);
        t.setPhone("11111111111");
        t.setSex("女");
        teacherRepository.insert(t);
    }

    /**
     * 更新用户
     */
    @Test
    public void UpdateTeacher(){
        Optional<Teachers> teachersOptional = teacherRepository.findById("5ee6e9efcc77594068db7e0f");
        if (teachersOptional.isPresent()){
            Teachers teachers = teachersOptional.get();
            teachers.setName("梁老师");
            teacherRepository.save(teachers);
        }
    }

    /**
     * 通过ID查询数据
     */
    @Test
    public void FindTeacherByID(){
        Optional<Teachers> Optional = teacherRepository.findById("5ee6e9efcc77594068db7e0f");
        //     用于控制针异常  判断查到的数据是否为空
        if (Optional.isPresent()){
            Teachers teachers = Optional.get();
            System.err.println(teachers);
        }else{
            System.err.println("没有数据");
        }

    }

    /**
     * 根据ID删除数据
     */
    @Test
    public void deleteByID(){
        teacherRepository.deleteById("5ee8968f21ea5353500148c9");
    }

自定义Dao

/**
     * 根据名称查数据
     */
    @Test
    public void FindTeacherByName(){
       Teachers teacher =  teacherRepository.findByName("梁老师");
        System.err.println(teacher);
    }


    // /**
    //  * 模糊查询
    //  */
    // @Test
    // public void findByNameLike(){
    //    List<Teachers> tlist = teacherRepository.findByNameLike("老师");
    //     for (Teachers teachers : tlist) {
    //         System.err.println(teachers);
    //     }
    // }

    /**
     * 根据姓名模糊查询还有年龄
     */
    @Test
    public void findByNameLikeAndAge(){
        List<Teachers> tlist = teacherRepository.findByNameLikeAndAge("老师",20);
        for (Teachers teachers : tlist) {
            System.err.println(teachers);
        }
    }

    /**
     * 根据名称进行分页
     */
    @Test
    public void findByNameLike(){
        int Page = 0;
        int Size = 2;
        PageRequest pageRequest = PageRequest.of(Page, Size);
        org.springframework.data.domain.Page<Teachers> page = teacherRepository.findByNameLike("老师",pageRequest);
        List<Teachers> teachersList = page.get().collect(Collectors.toList());
        for (Teachers teachers : teachersList) {
            System.err.println(teachers);
        }
    }
    }

条件查询 模板MongoTemplate

• 只要能使用 MongoRepository的，就可以直接使用MongoTemplate，Repository底层使用的就是Template。
• 编写测试类，获得Template

package com.czxy.xuecheng;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.data.mongodb.core.MongoTemplate;
import org.springframework.test.context.junit4.SpringRunner;

import javax.annotation.Resource;
@RunWith(SpringRunner.class)
@SpringBootTest(classes = TestMongo2Application.class )
public class TestMongoTemplate {

    @Resource
    private MongoTemplate mongoTemplate;

    @Test
    public void testFind(){
        System.out.println(mongoTemplate);
    }
}

• 条件查询：等值查询

@Test
    public void testFind(){
        //等值查询
        //1 创建查询条件对象 Query
        Query query = new Query();

        //2 设置等值查询条件   where age = 21
        query.addCriteria( Criteria.where("age").is(20) );

        //3 查询
        List<Teacher> list = mongoTemplate.find(query, Teacher.class);

        //4 处理数据
        list.forEach(System.out::println);

    }

• 条件查询：条件运算符

@Test
    public void testFind2(){
        // gte 大于等于，gt 大于，lte小于等于，lt小于
        //查询 age 大于等于25
        Query query = new Query();
        query.addCriteria( Criteria.where("age").gte(25) );
        List<Teacher> list = mongoTemplate.find(query, Teacher.class);
        for (Teacher teacher : list) {
            System.out.println(teacher);
        }
    }

• 条件查询：分页

@Test
    public void testFind3(){
        //分页查询

        //1 分页条件
        int pageNum = 0;
        int pageSize = 2;
        PageRequest pageRequest = PageRequest.of(pageNum, pageSize);

        //2 查询条件
        // 2.1 查询条件对象
        Query query = new Query();
        // 2.2 拼凑查询条件
        query.addCriteria(Criteria.where("age").is(21));

        // 查询总条数
        long count = mongoTemplate.count(query, Teacher.class);
        System.out.println(count);

        // 2.3 添加分页条件
        query.with(pageRequest);

        //3 查询
        List<Teacher> list = mongoTemplate.find(query, Teacher.class);

        //4 处理结果
        list.forEach(System.out::println);
    }

• 条件查询：分页 + 排序

@Test
    public void testFind4(){
        //分页 + 排序

        //0 排序
//        Sort sort = Sort.by(Sort.Order.desc("age"));
        Sort sort = Sort.by(Sort.Order.asc("age"));

        //1 分页条件
        int pageNum = 0;
        int pageSize = 2;
        PageRequest pageRequest = PageRequest.of(pageNum, pageSize,sort);

        //2 查询条件
        // 2.1 查询条件对象
        Query query = new Query();
        // 2.2 拼凑查询条件
        query.addCriteria(Criteria.where("password").is("666777"));

        // 查询总条数
        long count = mongoTemplate.count(query, Teacher.class);
        System.out.println(count);

        // 2.3 添加分页条件
        query.with(pageRequest);

        //3 查询
        List<Teacher> list = mongoTemplate.find(query, Teacher.class);

        //4 处理结果
        list.forEach(System.out::println);
    }

• 模糊查询：

@Test
    public void testFind5(){
        //模糊查询
        String username = "o";

        //1 查询条件对象
        Query query = new Query();

        //2 添加模糊查询--按照正则表达式进行匹配
        //  ^ 开始， $ 结束
        //  . 匹配任意一个字符
        // *  匹配个数大于等于0
        Pattern pattern = Pattern.compile("^.*"+username+".*$", Pattern.CASE_INSENSITIVE);
        query.addCriteria( Criteria.where("username").regex(pattern));

        //3 查询
        List<Teacher> list = mongoTemplate.find(query,Teacher.class);

        //4 处理
        list.forEach(System.out::println);
    }