MongoDB学习（三）springboot整合mongodb

MongoDB 学习

第一章： MongoDB学习（一） 详细安装教程 win10

第二章：MongoDB学习（二）sql语法

第三章：MongoDB学习（三）SpringBoot整合MongoDB

第四章：MongoDB学习（四）mongodb高级查询-Query/Criteria

第五章：MongoDB学习（五）mongodb终极查询-Aggregate

---

---

引入依赖 pom.xml

<!---mongodb相关依赖-->
 <dependency>
     <groupId>org.springframework.boot</groupId>
     <artifactId>spring-boot-starter-data-mongodb</artifactId>
 </dependency>

配置文件 application.yml

spring:
  data:
    mongodb:
      host: localhost
      port: 27017
      database: test

添加实体类

@Document 文档
@Id 主键
@Field 域
@Indexed 索引

@Data
@Document(collection = "student")
public class Student implements Serializable {

    @Id
    private String id;

    private String name;

    private Integer age;

    @Field(name = "class")
    private String classes;

    private List grade;
}

添加配置类

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationListener;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.event.ContextRefreshedEvent;
import org.springframework.data.mongodb.core.MongoTemplate;
import org.springframework.data.mongodb.core.convert.DefaultMongoTypeMapper;
import org.springframework.data.mongodb.core.convert.MappingMongoConverter;
import org.springframework.data.mongodb.core.convert.MongoConverter;

/**
 * @desc: 此类若不加，那么插入的一行会默认添加一个_class字段来存储实体类类型 如（com.practice.entity.Collection1）
 */
@Configuration
public class ApplicationReadyListener implements ApplicationListener<ContextRefreshedEvent> {

    @Autowired
    MongoTemplate mongoTemplate;

    private static final String TYPEKEY = "_class";

    @Override
    public void onApplicationEvent(ContextRefreshedEvent contextRefreshedEvent) {
        MongoConverter converter = mongoTemplate.getConverter();
        if (converter.getTypeMapper().isTypeKey(TYPEKEY)) {
            ((MappingMongoConverter) converter).setTypeMapper(new DefaultMongoTypeMapper(null));
        }
    }
}

Repository

import com.practice.entity.Student;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.Pageable;
import org.springframework.data.mongodb.repository.MongoRepository;
import org.springframework.data.mongodb.repository.Query;
import org.springframework.stereotype.Repository;

import java.util.List;

@Repository
public interface StudentRepository extends MongoRepository<Student, String> {

    public List<Student> findByName(String name);

    public List<Student> findByNameLike(String name);

    @Query(value = "{id:?0}",fields = "{'name':1,'age':1}")
    public Student findNameAndAgeById(String id);

    @Query(value = "{name:{$regex:?0}}",fields = "{'name':1,'age':1}")
    public Page<Student> findByNameLike(String name, Pageable pageRequest);

}

Service

public interface StudentService {

    /**
     * 查询
     */
    void find();
    /**
     * 添加
     */
    void insert(Student student);
    void batchInsert(List<Student> students);
    /**
     * 修改
     */
    void update(Student student);
    void batchUpdate(List<Student> students);
    /**
     * 删除
     */
    void delete(String id);
    void batchDelete(List<String> ids);
}

@Service
public class StudentServiceImpl implements StudentService {

    @Autowired
    private StudentRepository studentRepository;

    @Autowired
    private MongoTemplate mongoTemplate;

    @Override
    public void find() {
        //1. 全部查询
        List<Student> allList = studentRepository.findAll();
        System.out.println("----全部查询----"+allList);
        //2. 根据 name = '小红' 查询
        List<Student> byName = studentRepository.findByName("小红");
        System.out.println("----根据 name = '小红' 查询----"+byName);
        //3. 根据 name like '小%' 查询
        List<Student> byNameLike = studentRepository.findByNameLike("小");
        System.out.println("----根据 name like '小%' 查询----"+byNameLike);
        //4. 根据 age 正序 查询
        Sort sort = Sort.by(Sort.Direction.ASC, "age");
        List<Student> ageSort = studentRepository.findAll(sort);
        System.out.println("----根据 age 正序 查询----"+ageSort);
        //5. 分页查询
        Pageable pageRequest = PageRequest.of(0, 5);
        Page<Student> page = studentRepository.findAll(pageRequest);
        System.out.println("----根据 page=1,size=5 查询----"+page);
        //6. 条件查询并分页
        Page<Student> studentPage = studentRepository.findByNameLike("小",pageRequest);
        System.out.println("----只查询name和age并分页----"+studentPage);
        //7. 查询总数
        long count = studentRepository.count();
        System.out.println("----总条数为----"+count);
        Student student = new Student();
        student.setName("小");
        ExampleMatcher matcher = ExampleMatcher.matching()
                .withMatcher("name", ExampleMatcher.GenericPropertyMatchers.startsWith());
        long count1 = studentRepository.count(Example.of(student, matcher));
        System.out.println("----名字以’小‘开头的条数为----"+count1);
        //8. 只查询name和age
        Student nameAndAgeById = studentRepository.findNameAndAgeById("62a1beb0345f0000ab005e17");
        System.out.println("----只查询name和age----"+nameAndAgeById);
        //9. 分组查询
        Aggregation aggregation = Aggregation.newAggregation(
//                Aggregation.match(),
                Aggregation.group("classes","age").count().as("count"),
                Aggregation.project("count").andInclude("classes","age")
        );
        List<Map> mappedResults = mongoTemplate.aggregate(aggregation, Student.class, Map.class).getMappedResults();
        System.out.println("----分组查询----"+mappedResults);
    }

    @Override
    public void insert(Student student) {
        studentRepository.insert(student);
    }

    @Override
    public void batchInsert(List<Student> students) {
        studentRepository.insert(students);
    }

    @Override
    public void update(Student student) {
        boolean b = studentRepository.existsById(student.getId());
        if(b){
            studentRepository.save(student);
        }else{
            System.out.println("该学生不存在");;
        }
    }

    @Override
    public void batchUpdate(List<Student> students) {
        studentRepository.saveAll(students);
    }

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

    @Override
    public void batchDelete(List<String> ids) {
        Iterable<Student> allById = studentRepository.findAllById(ids);
        studentRepository.deleteAll(allById);
    }
}

Controller

@RestController
@RequestMapping("/student")
public class StudentController {

    @Autowired
    private StudentService studentService;

    /**
     * 查询
     */
    @GetMapping("/find")
    public void find(){
        studentService.find();
    }

    /**
     * 增加
     */
    @PostMapping("/insert")
    public void insert(@RequestBody Student student){
        studentService.insert(student);
    }

    /**
     * 批量增加
     */
    @PostMapping("/batchInsert")
    public void batchInsert(@RequestBody List<Student> students){
        studentService.batchInsert(students);
    }

    /**
     * 修改
     */
    @PostMapping("/update")
    public void update(@RequestBody Student student){
        studentService.update(student);
    }
    /**
     * 批量修改
     */
    @PostMapping("/batchUpdate")
    public void batchUpdate(@RequestBody List<Student> students){
        studentService.batchUpdate(students);
    }

    /**
     * 删除
     */
    @DeleteMapping("/delete/{id}")
    public void delete(@PathParam("id") String id){
        studentService.delete(id);
    }

    /**
     * 批量删除
     */
    @DeleteMapping("/batchDelete")
    public void batchDelete(@RequestBody List<String> ids){
        studentService.batchDelete(ids);
    }
}