• MongoDB基础学习（五）之在Springboot项目使用MongoTemplate进行操作

     springboot简单操作MongoDB——-增删改查 

    1.引入依赖

    1.     <!--MongoDB starter-->
    2. 	<dependency>
    3. 			<groupId>org.springframework.boot</groupId>
    4. 			<artifactId>spring-boot-starter-data-mongodb</artifactId>
    5. 		</dependency>

    2.在配置文件中进行配置

    application.properties配置数据源

    1. spring.data.mongodb.host=xxx.xxx.xxx.xxx
    2. spring.data.mongodb.port=xxxxxx
    3. spring.data.mongodb.database=xxxxx
    4. spring.data.mongodb.username=xxxx
    5. spring.data.mongodb.password=xxxxx

    1.建立实体类。

    1.  
    2. /**
    3.  * @Date: 2018/8/28 21:22
    4.  * @Description:
    5.  */
    6.  
    7. @Data
    8. @Document("Entry") // 声明文档为Entry 
    9. public class Entry {
    10.  
    11.  
    12.     private String id;
    13.  
    14.     private String name;
    15.  
    16.     private Integer age;
    17.  
    18.     private String remark;
    19.  
    20.     public String getId() {
    21.         return id;
    22.     }
    23.  
    24.     public void setId(String id) {
    25.         this.id = id;
    26.     }
    27.  
    28.     public String getName() {
    29.         return name;
    30.     }
    31.  
    32.     public void setName(String name) {
    33.         this.name = name;
    34.     }
    35.  
    36.     public Integer getAge() {
    37.         return age;
    38.     }
    39.  
    40.     public void setAge(Integer age) {
    41.         this.age = age;
    42.     }
    43.  
    44.     public String getRemark() {
    45.         return remark;
    46.     }
    47.  
    48.     public void setRemark(String remark) {
    49.         this.remark = remark;
    50.     }
    51. }

    springBoot2.3 使用MongoRepository整合mongoDb。

    创建Dao接口

    继承MongoRepository接口，第一个泛型是document文档对象，第二个参数是id的类型，一般直接设置为String类型就行了，让mongo自动生成id

    1. @Repository
    2. public interface EntryDao  extends MongoRepository<Entry, String> {
    3.  
    4. }

    Service接口

    1. /**
    2.  * 使用mongoRepository接口，基本能够完成增删改查操作，包括批量插入，批量修改，模糊查询，删除所有，删除满足条件的；
    3.  * 查询满足任一条件的数据，查询满足所有条件的数据；分页查询；查询结果排序
    4.  */
    5. public interface EntryService {
    6.  
    7.     /**
    8.      * 新增,插入（不能插入相同id的数据）
    9.      * @param po
    10.      * @return
    11.      */
    12.     Entry insertEntry(Entry po);
    13.  
    14.     /**
    15.      * 修改，如果id存在则修改，如果id不存在则新增
    16.      * @param po
    17.      * @return
    18.      */
    19.     Entry updateEntry(Entry po);
    20.  
    21.     /**
    22.      * 插入多条
    23.      * @param EntryList
    24.      * @return
    25.      */
    26.     List<Entry> insertManyEntry(List<Entry> EntryList);
    27.  
    28.     /**
    29.      * 查询一条（即使是有多条数据也只是返回第一条）
    30.      * @param po
    31.      * @return
    32.      */
    33.     EntryfindEntry(Entry po);
    34.  
    35.     /**
    36.      * 查询多条数据
    37.      * @param po
    38.      * @return
    39.      */
    40.     List<Entry> findEntryList(Entry po);
    41.  
    42.     /**
    43.      * 查询结果排序
    44.      * @param po
    45.      * @return
    46.      */
    47.     List<Entry> findEntryListSort(Entry po);
    48.  
    49.     /**
    50.      * 查询满足任意一个条件的多条数据
    51.      * @param po
    52.      * @return
    53.      */
    54.     List<Entry> findEntryListAny(Entry po);
    55.  
    56.     /**
    57.      * 模糊查询
    58.      * @param po
    59.      * @return
    60.      */
    61.     List<Entry> findEntryListLike(Entry po);
    62.  
    63.     /**
    64.      * 模糊查询2
    65.      * @param po
    66.      * @return
    67.      */
    68.     List<Entry> findEntryListLike2(Entry po);
    69.  
    70.     /**
    71.      * 分页查询
    72.      * @param po
    73.      * @return
    74.      */
    75.     Page<Entry> findEntryListByPage(Entry po, int page, int size);
    76.  
    77.     /**
    78.      * 删除所有
    79.      */
    80.     void deleteAll();
    81.  
    82.     /**
    83.      * 根据id删除
    84.      * @param id
    85.      */
    86.     void deleteById(String id);
    87.  
    88.     /**
    89.      * 判断是否存在
    90.      * @param po
    91.      * @return
    92.      */
    93.     Boolean exists(Entry po);
    94. }

    ServiceImpl 实现类

    1.  
    2. @Service
    3. public class EntryServiceImpl implements EntryService {
    4.  
    5.     @Autowired
    6.     private EntryDao entrydao;
    7.  
    8.     @Override
    9.     public Entry insertEntry(Entry po) {
    10.         // 新增
    11.         return entrydao.insert(po);
    12.     }
    13.  
    14.     @Override
    15.     public Entry updateEntry(Entry po) {
    16.         // 如果不存在则新增，存在则修改
    17.         return entrydao.save(po);
    18.     }
    19.  
    20.     @Override
    21.     public List<Entry> insertManyEntry(List<Entry> EntryList) {
    22.         return entrydao.insert(EntryList);
    23.     }
    24.  
    25.     @Override
    26.     public Entry findEntry(Entry po) {
    27.         Example<Entry> of = Example.of(po);
    28.         Optional<Entry> one = entrydao.findOne(of);
    29.         return one.get();
    30.     }
    31.  
    32.     @Override
    33.     public List<Entry> findEntryList(Entry po) {
    34.         // Example.of(po) 默认就是 ExampleMatcher.matching() 匹配模式
    35.         return entrydao.findAll(Example.of(po));
    36.     }
    37.  
    38.     @Override
    39.     public List<Entry> findEntryListSort(Entry po) {
    40.         // 构造排序器，按title字段降序排列，如果有多个字段则，分别按多个字段的进行降序
    41.         Sort sort = Sort.by(Sort.Direction.DESC,"title");
    42.         return entrydao.findAll(Example.of(po), sort);
    43.     }
    44.  
    45.     @Override
    46.     public List<Entry> findEntryListAny(Entry po) {
    47.         // 设置为或模式，默认是且模式，或表示查询条件中的任意一个条件满足都返回。是指不同的查询字段，而不是同一个字段的不同值
    48.         ExampleMatcher matcher = ExampleMatcher.matchingAny();
    49.         Example<Entry> example = Example.of(po, matcher);
    50.         return entrydao.findAll(example);
    51.     }
    52.  
    53.     @Override
    54.     public List<Entry> findEntryListLike(Entry po) {
    55.         // 设置不同字段的查询方式：模糊查询
    56.         // 必须是ExampleMatcher.matching().withMatcher("title", ExampleMatcher.GenericPropertyMatchers.contains())的方式写，
    57.         // 不能分开写成ExampleMatcher matcher = ExampleMatcher.matching(); matcher.withMatcher("title", ExampleMatcher.GenericPropertyMatchers.contains())
    58.         // 因为源码中就说了This instance is immutable and unaffected by this method call。
    59.         // title字段 以包含方式查询，即sql中的 like '%关键词%'
    60.         // description字段以查询结尾的方式查询，即sql中的 like '%关键词'
    61.         // 测试1："title"
    62.         ExampleMatcher matcher = ExampleMatcher.matching()
    63.                 .withMatcher("title", ExampleMatcher.GenericPropertyMatchers.contains())
    64.                 .withMatcher("description", ExampleMatcher.GenericPropertyMatchers.endsWith());
    65.  
    66.         // 测试2： 不写title时，默认应该是精确查询的
    67.         /*ExampleMatcher matcher = ExampleMatcher.matching()
    68.                 .withMatcher("description", ExampleMatcher.GenericPropertyMatchers.endsWith());*/
    69.         Example<Entry> example = Example.of(po, matcher);
    70.         return entrydao.findAll(example);
    71.     }
    72.  
    73.     public List<Entry> findEntryListLike2(Entry po) {
    74.         // 改变默认字符串匹配方式：直接把精确查询改为模糊查询
    75.         // 必须是ExampleMatcher.matching().withStringMatcher(ExampleMatcher.StringMatcher.CONTAINING);的方式写，
    76.         // 不能分开写成ExampleMatcher matcher = ExampleMatcher.matching(); matcher.withStringMatcher(ExampleMatcher.StringMatcher.CONTAINING);
    77.  
    78.         ExampleMatcher matcher = ExampleMatcher.matching()
    79.                 .withStringMatcher(ExampleMatcher.StringMatcher.CONTAINING);
    80.  
    81.         Example<Entry> example = Example.of(po, matcher);
    82.  
    83.         return entrydao.findAll(example);
    84.     }
    85.  
    86.     @Override
    87.     public Page<Entry> findEntryListByPage(Entry po, int page, int size) {
    88.         // 改为模糊查询
    89.         ExampleMatcher matcher = ExampleMatcher.matching()
    90.                 .withMatcher("title", ExampleMatcher.GenericPropertyMatchers.contains())
    91.                 .withMatcher("description", ExampleMatcher.GenericPropertyMatchers.endsWith());
    92.  
    93.         // 测试2： 不写title时，默认应该是精确查询的
    94.         /*ExampleMatcher matcher = ExampleMatcher.matching()
    95.                 .withMatcher("description", ExampleMatcher.GenericPropertyMatchers.endsWith());*/
    96.         Example<Entry> example = Example.of(po, matcher);
    97.         // 构造分页对象,带排序规则
    98. //        Pageable pageable = PageRequest.of(page, size, Sort.Direction.DESC, "title");
    99.         // 不带排序规则
    100.         Pageable pageable = PageRequest.of(page, size);
    101.         // 分页查询
    102.         return entrydao.findAll(example, pageable);
    103.     }
    104.  
    105.     @Override
    106.     public void deleteAll() {
    107.         entrydao.deleteAll();
    108.  
    109.     }
    110.  
    111.     @Override
    112.     public void deleteById(String id) {
    113.         entrydao.deleteById(id);
    114.     }
    115.  
    116.     @Override
    117.     public Boolean exists(Entry po) {
    118.         return entrydao.exists(Example.of(po));
    119.     }
    120. }

    测试
    日志使用lombok, 测试工具使用SpringBootTest

    1.  
    2. @Slf4j
    3. @SpringBootTest
    4. public class EntryTest {
    5. @Autowired
    6. private EntryService entryService;
    7.  
    8. @Test
    9. public void testInsertEntry() {
    10. Entry po = new Entry();
    11. // 有没有这个setId都可以，如果不设置则由mongodb自动生成一个id
    12. //  po.setId("1");
    13. po.setTitle("今日大事件2");
    14. po.setDescription("今日大事件的描述2");
    15. Entry Entry = entryService.insertEntry(po);
    16. log.info("【新增话术】Entry:{}", Entry);
    17. }
    18.  
    19. @Test
    20. public void testUpdateEntry() {
    21. Entry po = new Entry();
    22. po.setTitle("今日大事件3");
    23. Entry Entry = entryService.findEntry(po);
    24. Entry.setDescription("今日大事件3修改了呀2");
    25. EntryService.updateEntry(Entry);
    26. log.info("【修改话术】Entry:{}", Entry);
    27. }
    28.  
    29. @Test
    30. public void testInsertManyEntry() {
    31. List<Entry> list = new ArrayList<>();
    32. for (int i = 0; i < 20; i++) {
    33. Entry po = new Entry();
    34. po.setTitle("今日热榜" + i);
    35. po.setDescription("今日热榜描述A" + i);
    36. list.add(po);
    37. }
    38. List<Entry> Entryes = entryService.insertManyEntry(list);
    39. log.info("【新增话术】Entry:{}", Entryes);
    40. }
    41.  
    42. @Test
    43. public void testFindEntry() {
    44. Entry po = new Entry();
    45. po.setTitle("今日大事件2");
    46. Entry Entry = entryService.findEntry(po);
    47. log.info("【查询话术】Entry:{}", Entry);
    48. }
    49.  
    50. @Test
    51. public void testFindEntryList() {
    52. Entry po = new Entry();
    53. po.setTitle("今日大事件2");
    54. List<Entry> EntryList = entryService.findEntryList(po);
    55. log.info("【查询话术】Entry:{}", EntryList);
    56. }
    57.  
    58. @Test
    59. public void testFindEntryListByPage() {
    60. Entry po = new Entry();
    61. po.setTitle("今日热榜");
    62. Page<Entry> EntryListByPage = entryService.findEntryListByPage(po, 0, 10);
    63. int totalPages = EntryListByPage.getTotalPages();
    64. List<Entry> content = EntryListByPage.getContent();
    65. int number = EntryListByPage.getSize();
    66. int numberOfElements = EntryListByPage.getNumberOfElements();
    67. log.info("【分页查询话术】totalPage:{} number:{} , numberOfElements:{}, Entry:{}, ", totalPages, number,numberOfElements, content);
    68. }
    69.  
    70. @Test
    71. public void testFindEntryListSort() {
    72. Entry po = new Entry();
    73. //  po.setTitle("今日大事件2");
    74. List<Entry> EntryList = entryService.findEntryListSort(po);
    75. log.info("【话术查询结果排序】Entry:{}", EntryList);
    76. }
    77.  
    78. @Test
    79. public void testFindEntryListAny() {
    80. Entry po = new Entry();
    81. po.setTitle("今日大事件2");
    82. po.setDescription("今日大事件的描述3");
    83. List<Entry> EntryList = entryService.findEntryListAny(po);
    84. log.info("【话术查询或】Entry:{}", EntryList);
    85. }
    86.  
    87. @Test
    88. public void testFindEntryListLike() {
    89. Entry po = new Entry();
    90. po.setTitle("大事件3");
    91. //  po.setDescription("3修改了呀2");
    92. //  po.setTitle("今日大事件3");
    93. List<Entry> EntryList = entryService.findEntryListLike(po);
    94. log.info("【话术模糊查询】Entry:{}", EntryList);
    95. }
    96.  
    97. @Test
    98. public void testFindEntryListLike2() {
    99. Entry po = new Entry();
    100. po.setTitle("大");
    101. po.setDescription("3");
    102. //  po.setTitle("今日大事件3");
    103. List<Entry> EntryList = entryService.findEntryListLike2(po);
    104. log.info("【话术模糊查询】Entry:{}", EntryList);
    105. }
    106.  
    107. @Test
    108. public void testDeleteAll() {
    109. EntryService.deleteAll();
    110. }
    111.  
    112. @Test
    113. public void testDeleteById() {
    114. Entry po = new Entry();
    115. po.setTitle("今日大事件2");
    116. Entry Entry = entryService.findEntry(po);
    117. EntryService.deleteById(Entry.getId());
    118. log.info("【删除】Entry:{}", Entry);
    119. }
    120.  
    121. @Test
    122. public void testExists() {
    123. Entry po = new Entry();
    124. po.setTitle("今日大事件3");
    125. Boolean exist = entryService.exists(po);
    126. log.info("【判断是否存在】:{}", exist);
    127. }
    128. }

    使用MongoTemplate进行简单的增删改查

    1.  
    2. import org.junit.Test;
    3. import org.junit.runner.RunWith;
    4. import org.springframework.boot.test.context.SpringBootTest;
    5. import org.springframework.data.mongodb.core.MongoTemplate;
    6. import org.springframework.data.mongodb.core.query.Criteria;
    7. import org.springframework.data.mongodb.core.query.Query;
    8. import org.springframework.data.mongodb.core.query.Update;
    9. import org.springframework.test.context.junit4.SpringRunner;
    10.  
    11. import java.util.List;
    12.  
    13. /**
    14.  * @Date: 2018/8/28 21:30
    15.  * @Description:
    16.  */
    17. @RunWith(SpringRunner.class)
    18. @SpringBootTest
    19. public class EntryTest {
    20.  
    21.     /**
    22.      * 直接注入mongoTemplate即可使用
    23.      * */
    24.     private MongoTemplate mongoTemplate;
    25.  
    26.     //增
    27.     @Test
    28.     public void add(Entry entry){
    29.         entry.setId("1");
    30.         entry.setName("张三");
    31.         entry.setAge(15);
    32.         entry.setRemark("喜欢打球、喜欢喝茶");
    33.         //存储操作
    34.         mongoTemplate.save(entry);
    35.         //指定集合名
    36.         mongoTemplate.save(entry,"人员表");
    37.     }
    38.  
    39.     //删除
    40.     @Test
    41.     public void delete(String id){
    42.         mongoTemplate.remove("1");
    43.         mongoTemplate.remove("1","人员表");
    44.         Query query = new Query();
    45.         //拼装删除数据
    46.         query.addCriteria(Criteria.where("id").is("1"));
    47.         mongoTemplate.remove(query,"人员表");
    48.         mongoTemplate.remove(query,Entry.class);
    49.     }
    50.     //改
    51.     @Test
    52.     public void edit(Entry entry){
    53.         Query query = new Query(Criteria.where("id").is(entry.getId()));
    54.         //拼装修改数据
    55.         Update update = new Update();
    56.         update.set("name","李四");
    57.         update.set("remark","喜欢画画");
    58.         mongoTemplate.updateFirst(query, update, Entry.class);
    59.     }
    60.    
    61.  
    62.      //简单查
    63.     @Test
    64.     public void query(String id){
    65.         //单条
    66.         Query query = new Query(Criteria.where("id").is(id));//可累加条件
    67.         Entry entrY = mongoTemplate.findOne(query,Entry.class);
    68.         //多条
    69.         Query query2 = new Query(Criteria.where("remark").regex("喜欢"));//可累加条件
    70.         List<Entry> entries = mongoTemplate.find(query, Entry.class);
    71.     }
    72.     
    73.  
    74.     //查询所有
    75.     @Test
    76.     public void findAll(){
    77.      List<Entry> entries = mongoTemplate.find(Entry.class);
    78.     }
    79.  
    80.     //根据id查询
    81.     @Test
    82.     public void findById(Integer id){
    83.     Query query=new Query(Criteria.where("_id").is(id));//可累加条件
    84.         Entry student = mongoTemplate.findOne(query, Entry.class);
    85.     }
    86.  
    87. }

    分页查询——此处我写了两个工具类

    1.  
    2. import org.springframework.data.domain.Sort;
    3.  
    4. import java.io.Serializable;
    5.  
    6. /**
    7.  * @Auther:
    8.  * @Date: 2018/8/22 08:48
    9.  * @Description:
    10.  * @Version: 1.0
    11.  */
    12. public class MongoDBPageModel implements Serializable {
    13.     /**
    14.      * @Fields: serialVersionUID
    15.      * @Todo: TODO
    16.      */
    17.     private static final long serialVersionUID = 1L;
    18.     // 当前页
    19.     private Integer pagenumber = 1;
    20.     // 当前页面条数
    21.     private Integer pagesize = 10;
    22.     // 排序条件
    23.     private Sort sort;
    24.     public Integer getPagenumber() {
    25.         return pagenumber;
    26.     }
    27.     public void setPagenumber(Integer pagenumber) {
    28.         this.pagenumber = pagenumber;
    29.     }
    30.     public Integer getPagesize() {
    31.         return pagesize;
    32.     }
    33.     public void setPagesize(Integer pagesize) {
    34.         this.pagesize = pagesize;
    35.     }
    36.     public Sort getSort() {
    37.         return sort;
    38.     }
    39.     public void setSort(Sort sort) {
    40.         this.sort = sort;
    41.     }
    42.  
    43. }
    1.  
    2. import java.io.Serializable;
    3. import org.springframework.data.domain.Pageable;
    4. import org.springframework.data.domain.Sort;
    5. /**
    6.  * @Auther:
    7.  * @Date: 2018/8/22 10:19
    8.  * @Description:
    9.  * @Version: 1.0
    10.  */
    11. public class SpringbootMongoDBPageable implements Serializable,Pageable{
    12.     /**
    13.      * @Fields: serialVersionUID
    14.      * @Todo: TODO
    15.      */
    16.     private static final long serialVersionUID = 1L;
    17.  
    18.     MongoDBPageModel page;
    19.  
    20.     public MongoDBPageModel getPage() {
    21.         return page;
    22.     }
    23.  
    24.     public void setPage(MongoDBPageModel page) {
    25.         this.page = page;
    26.     }
    27.  
    28.     @Override
    29.     public Pageable first() {
    30.         // TODO Auto-generated method stub
    31.         return null;
    32.     }
    33.  
    34.     @Override
    35.     public int getOffset() {
    36.         // TODO Auto-generated method stub
    37.         return (page.getPagenumber() - 1) * page.getPagesize();
    38.     }
    39.  
    40.     @Override
    41.     public int getPageNumber() {
    42.         // TODO Auto-generated method stub
    43.         return page.getPagenumber();
    44.     }
    45.  
    46.     @Override
    47.     public int getPageSize() {
    48.         // TODO Auto-generated method stub
    49.         return page.getPagesize();
    50.     }
    51.  
    52.  
    53.     @Override
    54.     public boolean hasPrevious() {
    55.         // TODO Auto-generated method stub
    56.         return false;
    57.     }
    58.  
    59.     @Override
    60.     public Pageable next() {
    61.         // TODO Auto-generated method stub
    62.         return null;
    63.     }
    64.  
    65.     @Override
    66.     public Pageable previousOrFirst() {
    67.         // TODO Auto-generated method stub
    68.         return null;
    69.     }
    70.  
    71.     @Override
    72.     public Sort getSort() {
    73.         // TODO Auto-generated method stub
    74.         return page.getSort();
    75.     }
    76. }

    分页查询+分页聚合查询（多表多条件关联分页查询+结果集解析）——-依然测试类

    1.  
    2. /**
    3.  * @Date: 2018/8/28 21:30
    4.  * @Description:
    5.  */
    6. @RunWith(SpringRunner.class)
    7. @SpringBootTest
    8. public class EntryTest {
    9.  
    10.     /**
    11.      * 直接注入mongoTemplate即可使用
    12.      * */
    13.     private MongoTemplate mongoTemplate;
    14.  
    15.     //分页查询
    16.     @Test
    17.     public void PageQuery(){
    18.         //利用工具类拼装分页信息
    19.         SpringbootMongoDBPageable pageable = new SpringbootMongoDBPageable();
    20.         MongoDBPageModel pm=new MongoDBPageModel();
    21.         pm.setPagesize(3);
    22.         pm.setPagenumber(1);
    23.         List<Order> orders = new ArrayList<>();  //排序信息
    24.         orders.add(new Order(Direction.DESC, "age"));
    25.         Sort sort = new Sort(orders);
    26.         pm.setSort(sort);
    27.         pageable.setPage(pm);
    28.         //拼装查询信息
    29.         Query query = new Query();
    30.         Criteria criteria = new Criteria();
    31.         query.addCriteria(criteria.where("age").gte(6).lte(18));//检索6-18岁的
    32.         query.addCriteria(criteria.where("name").regex("文"));//模糊查询名字
    33.         Long count = mongoTemplate.count(query, OrdersData.class);//查询总记录数
    34.         List<Entry> list = mongoTemplate.find(query.with(pageable), Entry.class);
    35.     }
    36.     //分页聚合查询（多表多条件关联分页查询）
    37.     @Test
    38.     public void PageQuery2(){
    39.         //mongodb中有两个表，一个是人物表 一个是宠物表，一个人可以有多个宠物
    40.         //人物表字段为 String id, Integer age,String remark;
    41.         //宠物表字段为 String id, String manId,String age,String remark;
    42.         //拼装分页信息
    43.         SpringbootMongoDBPageable pageable = new SpringbootMongoDBPageable();
    44.         MongoDBPageModel pm=new MongoDBPageModel();
    45.         pm.setPagesize(2);
    46.         pm.setPagenumber(1);
    47.         List<Order> orders = new ArrayList<>();  //排序
    48.         orders.add(new Order(Direction.DESC, "age"));
    49.         Sort sort = new Sort(orders);
    50.         pm.setSort(sort);
    51.         pageable.setPage(pm);
    52.  
    53.         //拼装关联信息
    54.         LookupOperation lookupOperation = LookupOperation.newLookup().
    55.                 from("dogData").//关联表名
    56.                 localField("_id").//关联字段
    57.                 foreignField("manId").//主表关联字段对应的次表字段
    58.                 as("dogs");//查询结果集合名
    59.  
    60.         //拼装具体查询信息
    61.         //次表
    62.         Criteria ordercri = Criteria.where("dogs").not().size(0);//只查询有宠物的人
    63.         ordercri.and("age").gte(1).lte(5);//只查询1岁到5岁的宠物
    64.         AggregationOperation match = Aggregation.match(ordercri);
    65.         //主表
    66.         Criteria qqq=Criteria.where("name").regex("文");//只查询名字中带有文的人
    67.         AggregationOperation match1= Aggregation.match(qqq);
    68.  
    69.         //分页查询
    70.         Aggregation aggregation = Aggregation.newAggregation(match1,lookupOperation,match,Aggregation.sort(pageable.getSort()),//排序
    71.                 Aggregation.skip(pageable.getPageNumber()>1?(pageable.getPageNumber()-1)*pageable.getPageSize():0),//pagenumber
    72.                 Aggregation.limit(pageable.getPageSize()));//pagesize
    73.         //总数查询
    74.         Aggregation counts = Aggregation.newAggregation(match1,lookupOperation,match).;
    75.         int count = mongoTemplate.aggregate(counts, "manEntry", BasicDBObject.class).getMappedResults().size();
    76.         List<BasicDBObject> results = mongoTemplate.aggregate(aggregation, "manEntry", BasicDBObject.class).getMappedResults();
    77.         //查询出的结果集为BasicDBObject类型
    78.         //解析过程
    79.         for (BasicDBObject b :results
    80.                 ) {
    81.             //转化为jsonobject对象
    82.             JSONObject jsonObject = new JSONObject(b);
    83.             String id = jsonObject.get("id").toString();
    84.             Integer age = ((int) jsonObject.get("age"));
    85.             String remark = jsonObject.get("remark").toString();
    86.             //转化为jsonarray
    87.             JSONArray dogs = jsonObject.getJSONArray("dogs");
    88.             if (dogs.size() > 0) {
    89.                 for (int i = 0; i < dogs.size(); i++) {
    90.                     JSONObject job = dogs.getJSONObject(i);
    91.                     String dogId = job.get("id").toString();
    92.                     String manId = job.get("manId").toString();
    93.                     }
    94.                 }
    95.  
    96.             }
    97.     }
    98.  
    99.  
    100. }

    4.在Controller中进行引入

    1. @Autowired
    2. private MongoTemplate mongoTemplate;

    带条件查询

    1.         Query query = new Query();
    2.         if (code!=0) {
    3.             query.addCriteria(Criteria.where("buiness_core").is(code));//is:等于
    4.         }
    5.         // query.fields().exclude("details.details");//exclude:不需要查询这个字段
    6.         List<Station> list = mongoTemplate.find(query, 对应实体类的名称.class);//fin:查询集合中所有的对象

    多表联查

    1.     /**
    2.      * 两表联查
    3.      *
    4.      * @return
    5.      */
    6.     @GetMapping("/DeviceAndStation")
    7.     public Object findStudentAndGrade(String stationId){
    8.         LookupOperation lookupOperation=LookupOperation.newLookup().
    9.                 from("t_wlw_station").  //关联从表名
    10.                         localField("station_id").     //主表关联字段
    11.                         foreignField("_id").//从表关联的字段
    12.                         as("DeviceAndStation");   //查询结果名
    13. //带条件查询可以选择添加下面的条件
    14.  
    15.         Aggregation aggregation=Aggregation.newAggregation(lookupOperation);
    16.         List<Map> results = mongoTemplate.aggregate(aggregation,"t_device", Map.class).getMappedResults();
    17.         //上面的student必须是查询的主表名
    18.         System.out.println(JSON.toJSONString(results));
    19.         return results;
    20.     }

    分页查询

    后端代码:

    1.  @Override
    2.     public Page<StrategyComment> queryPage(StrategyCommentQuery qo) {
    3.         // totalPage  prePage nextPage
    4.         Query query = new Query();
    5.         Criteria criteria = new Criteria();
    6.         if (qo.getStrategyId() != null) {
    7.             criteria = Criteria.where("strategyId").in(qo.getStrategyId());
    8.             query.addCriteria(criteria);
    9.         }
    10.         // 模糊匹配
    11.         if (qo.getKeyword() != null) {
    12.             String keyword = qo.getKeyword();
    13.             String pattern = ".*" + keyword + ".*"; // 正则表达式
    14.             criteria.orOperator(Criteria.where("strategyTitle").regex(pattern),Criteria.where("content").regex(pattern));// 多条件模糊查询
    15.             query.addCriteria(criteria);
    16.         }
    17.         // totalCount
    18.         long totalCount = mongoTemplate.count(query, StrategyComment.class);
    19.         // 如果没数据,可以优化性能不用继续执行了
    20.         if (totalCount == 0) {
    21.             return Page.empty();
    22.         }
    23.         // data
    24.         // 第一个参数 从 0 开始
    25.         Sort orderBy = Sort.by(Sort.Direction.DESC, "createTime"); //倒序
    26.         Pageable pageable = PageRequest.of(qo.getCurrentPage() - 1, qo.getPageSize(),orderBy);
    27.         query.with(pageable);
    28.         List<StrategyComment> data = mongoTemplate.find(query, StrategyComment.class);
    29.         // 三个参数 List<T> content, Pageable pageable, long total
    30.         return new PageImpl<StrategyComment>(data, pageable, totalCount);
    31.     }

    前端代码:

    1. <div th:fragment="mongoPage" style="text-align: center;">
    2.     <ul id="pagination" class="pagination"></ul>
    3.     <script>
    4.         //分页
    5.         $(function () {
    6.             var totalPages = [[${page.totalPages}]]
    7.             var startPage = [[${page.pageable.pageNumber}+1]]
    8.  
    9.             $("#pagination").twbsPagination({
    10.                 totalPages: totalPages || 1,
    11.                 startPage: startPage || 1,
    12.                 visiblePages: 5,
    13.                 first: "首页",
    14.                 prev: "上页",
    15.                 next: "下页",
    16.                 last: "尾页",
    17.                 initiateStartPageClick: false,
    18.                 onPageClick: function (event, page) {
    19.                     $("#currentPage").val(page);
    20.                     $("#searchForm").submit();
    21.                 }
    22.             });
    23.         })
    24.     </script>
    25. </div>

    多表联查

    1. @Test
    2.     public void saveMany() {// 批处理(10万条数据1127)（100万条条数据测试75773）qps13197
    3.         Long startTime = System.currentTimeMillis();
    4.         List<Aqz> aqzList = new ArrayList<>();
    5.         for (int i = 0; i < 1000000; i++) {
    6.             Aqz aqz = new Aqz();
    7.             int random = (int) (Math.random() * 2);
    8.             aqz.setABoolean(random == 0 ? false : true);
    9.             aqz.setCreateDate(new Date());
    10.             aqz.setString("string2" + i);
    11.             aqz.setAnInt(i + 20000);
    12.             aqz.setADouble(Math.random() * 2);
    13.             List list = new ArrayList<>();
    14.             list.add("aaa2" + i);
    15.             list.add("bbb2" + i);
    16.             list.add("ccc2" + i);
    17.             aqz.setList(list);
    18.             aqzList.add(aqz);
    19.             System.out.println(i);
    20.         }
    21.         mongoTemplate.insertAll(aqzList);
    22.  
    23.         Long endtTime = System.currentTimeMillis();
    24.         Long resultTime = endtTime - startTime;
    25.         System.out.println("[总共执行耗时]" + resultTime);
    26.  
    27.     }
    28. ###分页，范围，模糊，排序###########################################################@Test
    29.     public void saveClazz() {// 添加课堂
    30.         Clazz clazz = new Clazz();
    31.         clazz.setClazzName("天天课堂3");
    32.         mongoTemplate.insert(clazz);
    33.     }
    34.  
    35.     @Test
    36.     public void saveStudent() {// 添加学生
    37.         String clazzName = "天天课堂";
    38.         Query query = new Query(Criteria.where("clazzName").is(clazzName));
    39.         Clazz clazz = mongoTemplate.findOne(query, Clazz.class);
    40.         Student student = new Student();
    41.         student.setStudentName("小红2");
    42.         student.setAge(18);
    43.         student.setClazzId(clazz.getId());
    44.         mongoTemplate.save(student);
    45.  
    46.     }
    47.  
    48.     @Test
    49.     public void findOneClazz() {
    50.         Query query = new Query(Criteria.where("_id").is("60e10203d31e2641ecb748ee"));
    51.         Clazz clazz = mongoTemplate.findOne(query, Clazz.class);
    52.         // clazz】】】" + clazz);
    53.     }
    55.     @Test
    56.     public void findByManyStudent1() {// 多条件1
    57.         Query query = new Query();
    58.         query.addCriteria(Criteria.where("studentName").is("小红"));
    59.         query.addCriteria(Criteria.where("age").is(18));
    60.         List students = mongoTemplate.find(query, Student.class);
    61.         // students);
    62.     }
    64.     @Test
    65.     public void findByManyStudent0() {// 多条件0
    66.         Query query = new Query(Criteria.where("studentName").is("小红"));
    67.         query.addCriteria(Criteria.where("age").is(18));
    68.         List students = mongoTemplate.find(query, Student.class);
    69.         // students);
    70.     }
    72.     @Test
    73.     public void findByManyStudent3() {// 多条件3
    74.         Query query = new Query(Criteria.where("studentName").is("小红").and("age").is(18));
    75.         List students = mongoTemplate.find(query, Student.class);
    76.         // students);
    77.     }
    79.     @Test
    80.     public void findByManyStudent2() {// 多条件2
    81.         Student student = new Student();
    82.         student.setStudentName("小红");
    83.         student.setAge(18);
    84.         Query query = new Query(Criteria.byExample(student));
    85.         List students = mongoTemplate.find(query, Student.class);
    86.         // students);
    87.     }
    89.     @Test
    90.     public void findByManyStudentOr() {// 多条件0 or
    91.         Query query = new Query(Criteria.where("studentName").regex("小"));
    92.         query.addCriteria(new Criteria().orOperator(Criteria.where("age").is(18),
    93.                 new Criteria().andOperator(Criteria.where("studentName").is("小明"), Criteria.where("age").is(16))));
    94.         List students = mongoTemplate.find(query, Student.class);
    95.         // students);
    96.     }
    99.     @Test
    100.     public void searchClazzByIn() {// in操作
    101.         List str = new ArrayList<>();
    102.         str.add("天天课堂");
    103.         Query query = new Query(Criteria.where("name").in(str));
    104.         List clazzList = mongoTemplate.find(query, Clazz.class);
    105.         // clazzList】】】" + clazzList);
    106.  
    107.     }
    108.  
    109.     @Test
    110.     public void findListStudentSort() {// 排序
    111.         Query query = new Query();
    112.         query.with(Sort.by(Sort.Direction.DESC, "age"));
    113.         List<Student> students = mongoTemplate.find(query, Student.class);
    114.         // students】】】" + students);
    116.     }
    118.     @Test
    119.     public void findFenYeList() {// 分页
    120.         // 设置分页参数
    121.         Query query = new Query();
    122.         int currentPage = 2;// 0,1相同
    123.         int pageSize = 2;
    124.         // 设置分页信息
    125.         query.limit(pageSize);
    126.         query.skip(pageSize * (currentPage - 1));
    127.         // query.addCriteria(Criteria.where("clazzName").regex("天"));
    128.         List clazzes = mongoTemplate.find(query, Clazz.class);
    129.         // clazzs】】】" + clazzes);
    130.     }
    131.  
    132.     @Test
    133.     public void update() {// 更新
    134.         Query query = Query.query(Criteria.where("id").is("60e103fcd31e2615bcaf91ed"));// 添加查询条件
    135.         // query.addCriteria(Criteria.where("time").gte(beginTime).lte(endTime))；
    136.         Update update = new Update();
    137.         update.set("clazzName", "111");
    138.         UpdateResult updateResult = mongoTemplate.updateFirst(query, update, Clazz.class);
    139.         // updateResult.toString());
    140.  
    141.     }
    142.  
    143.     @Test
    144.     public void delete() {// 删除
    145.         Query query = Query.query(Criteria.where("id").is("60e103fcd31e2615bcaf91ed"));
    146.         mongoTemplate.remove(query, Clazz.class);
    147.     }
    148.  
    149.     @Test
    150.     public void findZongHe() {// 分页+范围+模糊查询+排序
    151.         // 拼装查询信息
    152.         Query query = new Query();
    153.         query.addCriteria(Criteria.where("age").gte(6).lte(18));
    154.         query.with(Sort.by(Sort.Direction.ASC, "age"));
    155.         query.addCriteria(Criteria.where("name").regex("小"));
    156.         // 模糊查询名字
    157.         Long count = mongoTemplate.count(query, Student.class);
    158.         // 查询总记录数
    159.         List<Student> list = mongoTemplate.find(query, Student.class);
    160.  
    161.     }
    162. ####分组，两表三表联查###########################################################
    163. import com.csw.mongodbspringbootdemo.entity.Chair;
    164. import com.csw.mongodbspringbootdemo.entity.Desk;
    165. import com.csw.mongodbspringbootdemo.entity.Room;
    166. import com.mongodb.BasicDBObject;
    167. import org.junit.Test;
    168. import org.junit.runner.RunWith;
    169. import org.springframework.beans.factory.annotation.Autowired;
    170. import org.springframework.boot.test.context.SpringBootTest;
    171. import org.springframework.data.domain.Sort;
    172. import org.springframework.data.mongodb.core.MongoTemplate;
    173. import org.springframework.data.mongodb.core.aggregation.Aggregation;
    174. import org.springframework.data.mongodb.core.aggregation.AggregationOperation;
    175. import org.springframework.data.mongodb.core.aggregation.AggregationResults;
    176. import org.springframework.data.mongodb.core.aggregation.LookupOperation;
    177. import org.springframework.data.mongodb.core.query.Criteria;
    178. import org.springframework.data.mongodb.core.query.Query;
    179. import org.springframework.test.context.junit4.SpringRunner;
    180.  
    181. import java.util.ArrayList;
    182. import java.util.List;
    183. import java.util.Map;
    184. import java.util.UUID;
    185.  
    186. @SpringBootTest
    187. @RunWith(SpringRunner.class)
    188. public class RoomDeskRecommend {
    189.     @Autowired
    190.     private MongoTemplate mongoTemplate;
    191.  
    192.     @Test
    193.     public void saveRoom() {// 添加房间
    194.         Room room = new Room();
    195.         room.setName("空房间2");
    196.         room.setUnitCode(UUID.randomUUID().toString());
    197.         mongoTemplate.save(room);
    198.         Room room2 = new Room();
    199.         room2.setName("空房间1");
    200.         room2.setUnitCode(UUID.randomUUID().toString());
    201.         mongoTemplate.save(room2);
    202.  
    203.     }
    204.  
    205.     @Test
    206.     public void saveDesk() {// 添加桌子
    207.         String roomName = "光明房间";
    208.         String deskName = "5号桌子";
    209.         Query query = new Query(Criteria.where("name").is(roomName));
    210.         Room room = mongoTemplate.findOne(query, Room.class);
    211.         Desk desk = new Desk();
    212.         desk.setName(deskName);
    213.         assert room != null;
    214.         desk.setUnitCode(room.getUnitCode());
    215.         mongoTemplate.save(desk);
    216.         System.out.println(room);
    217.  
    218.         Query query2 = new Query(Criteria.where("name").is(deskName));
    219.         Desk desk2 = mongoTemplate.findOne(query2, Desk.class);
    220.         System.out.println(desk2);
    221.  
    222.     }
    223.  
    224.     @Test
    225.     public void groupBy() {// group
    226.         List<AggregationOperation> aggs = new ArrayList<>();
    227.         // aggs.add(Aggregation.match(Criteria.where("name").is("log")));
    228.         aggs.add(Aggregation.group("name").count().as("count"));
    229.         aggs.add(Aggregation.project().and("_id").as("name").and("count").as("count"));
    230.  
    231.         Aggregation agg = Aggregation.newAggregation(aggs);
    232.  
    233.         AggregationResults<Map> results = mongoTemplate.aggregate(agg, Desk.class, Map.class);
    234.         for (Map result : results) {
    235.             System.out.println(result);
    236.         }
    237.     }
    238.  
    239.     @Test
    240.     public void findMoreTable() {// 两表联查
    241.  
    242.         LookupOperation lookupOperation = LookupOperation.newLookup().from("room"). // 关联表名
    243.                 localField("unitCode"). // 主关联字段
    244.                 foreignField("unitCode").// 从表关联字段对应的次表字段
    245.                 as("rooms");// 查询结果集合名
    246.         Criteria ordercri = Criteria.where("rooms").not().size(0);// 只查询有宠物的人
    247.         // ordercri.and("age").gte(1).lte(5);//只查询1岁到5岁的宠物
    248.         AggregationOperation matchZi = Aggregation.match(ordercri);
    249.         Aggregation aggregation = Aggregation.newAggregation(lookupOperation, matchZi);// 排序
    250.         List<Map> results = mongoTemplate.aggregate(aggregation, "desk", Map.class).getMappedResults(); // 查询出的结果集为BasicDBObject类型
    251.         for (Map result : results) {
    252.             System.out.println(result);
    253.         }
    254.     }
    255.  
    256.     @Test
    257.     public void findMoreTable2() {// 两表联查
    258.  
    259.         LookupOperation lookupOperation = LookupOperation.newLookup().from("desk"). // 关联表名
    260.                 localField("unitCode"). // 主关联字段
    261.                 foreignField("unitCode").// 从表关联字段对应的次表字段
    262.                 as("desks");// 查询结果集合名
    263.  
    264.         Criteria ordercri = Criteria.where("desks").not().size(0);// 只查询有宠物的人
    265.         // ordercri.and("age").gte(1).lte(5);//只查询1岁到5岁的宠物
    266.         AggregationOperation matchZi = Aggregation.match(ordercri);
    267.         Aggregation aggregation = Aggregation.newAggregation(lookupOperation, matchZi);// 排序
    268.         List<Map> results = mongoTemplate.aggregate(aggregation, "room", Map.class).getMappedResults(); // 查询出的结果集为BasicDBObject类型
    269.         for (Map result : results) {
    270.             System.out.println(result);
    271.         }
    272.     }
    273.  
    274.     @Test
    275.     public void findMoreTableZongHe() {// 两表联查
    276.  
    277.         int pageNumber = 2;// 0,1相同
    278.         int pageSize = 2;
    279.         // 拼装关联信息
    280.         LookupOperation lookupOperation = LookupOperation.newLookup().from("room"). // 关联表名
    281.                 localField("unitCode"). // 主关联字段
    282.                 foreignField("unitCode").// 从表关联字段对应的次表字段
    283.                 as("ClazzStudents");// 查询结果集合名
    284.         // 拼装具体查询信息
    285.         // 次表
    286.         Criteria ordercri = Criteria.where("ClazzStudents").not().size(0);// 只查询有宠物的人
    287.         // ordercri.and("age").gte(1).lte(5);//只查询1岁到5岁的宠物
    288.         AggregationOperation matchZi = Aggregation.match(ordercri);
    289.         // 主表
    290.         Criteria qqq = Criteria.where("name").regex("号");// 只查询名字中带有文的人
    291.         AggregationOperation matchFu = Aggregation.match(qqq);
    292.         // 分页查询
    293.         Aggregation aggregation = Aggregation.newAggregation(matchFu, lookupOperation, matchZi,
    294.                 Aggregation.sort(Sort.Direction.DESC, "name"),
    295.                 Aggregation.skip(pageSize > 1 ? (pageNumber - 1) * pageSize : 0), Aggregation.limit(pageSize));// 排序
    296.                                                                                                                 // Aggregation.skip(pageable.getPageNumber()>1?(pageable.getPageNumber()-1)*pageable.getPageSize():0),//pagenumber
    297.         // 分页
    298.         /*
    299.          * Aggregation.skip(pageSize>1?(pageNumber-1)*pageSize:0);
    300.          * Aggregation.limit(pageSize);
    301.          */
    302.         // Aggregation.group("name");
    303.  
    304.         // 总数查询
    305.         Aggregation counts = Aggregation.newAggregation(matchFu, lookupOperation, matchZi);
    306.         int count = mongoTemplate.aggregate(counts, Desk.class, BasicDBObject.class).getMappedResults().size();
    307.         System.out.println("【count】" + count);
    308.         List<Map> results = mongoTemplate.aggregate(aggregation, "desk", Map.class).getMappedResults(); // 查询出的结果集为BasicDBObject类型
    309.         for (Map result : results) {
    310.             System.out.println(result);
    311.         }
    312.     }
    313.  
    314.     /*
    315.      * public PageResult pagination(Class clazz, int pageSize, int pageNum,
    316.      * Query query) { long total = this.mongoTemplate.count(query, clazz); Integer
    317.      * pages = (int)Math.ceil((double)total / (double)pageSize); if (pageNum <= 0 ||
    318.      * pageNum > pages) { pageNum = 1; } int skip = pageSize * (pageNum - 1);
    319.      * query.skip(skip).limit(pageSize); List list = mongoTemplate.find(query,
    320.      * clazz); PageResult pageResult = new PageResult(); pageResult.setTotal(total);
    321.      * pageResult.setPages(pages); pageResult.setPageSize(pageSize);
    322.      * pageResult.setPageNum(pageNum); pageResult.setList(list); return pageResult;
    323.      * }
    324.      */
    325.     @Test
    326.     public void saveChair() {// 添加椅子
    327.         String roomName = "光明房间";
    328.         String chairName = "1号椅子";
    329.         Query query = new Query(Criteria.where("name").is(roomName));
    330.         Room room = mongoTemplate.findOne(query, Room.class);
    331.         Chair chair = new Chair();
    332.         chair.setName(chairName);
    333.         assert room != null;
    334.         chair.setUnitCode(room.getUnitCode());
    335.         mongoTemplate.save(chair);
    336.  
    337.     }
    338.  
    339.     @Test
    340.     public void findMoreTable3_0() {// 三表联查测试，第一个表关联第二个人表（关联字段1），第一个表关联第三个表（关联字段1）
    341.  
    342.         LookupOperation lookupOperation = LookupOperation.newLookup().from("desk"). // 关联表名
    343.                 localField("unitCode"). // 主关联字段
    344.                 foreignField("unitCode").// 从表关联字段对应的次表字段
    345.                 as("desks");// 查询结果集合名
    346.  
    347.         Criteria ordercri = Criteria.where("desks").not().size(0);// 只查询有宠物的人
    348.         // ordercri.and("age").gte(1).lte(5);//只查询1岁到5岁的宠物
    349.         AggregationOperation matchZi = Aggregation.match(ordercri);
    350.         LookupOperation lookupOperation2 = LookupOperation.newLookup().from("chair"). // 关联表名
    351.                 localField("unitCode"). // 主关联字段
    352.                 foreignField("unitCode").// 从表关联字段对应的次表字段
    353.                 as("chairs");// 查询结果集合名
    354.  
    355.         Criteria ordercri2 = Criteria.where("chairs").not().size(0);// 只查询有宠物的人
    356.         // ordercri.and("age").gte(1).lte(5);//只查询1岁到5岁的宠物
    357.         AggregationOperation matchZi2 = Aggregation.match(ordercri2);
    358.         Aggregation aggregation = Aggregation.newAggregation(lookupOperation, matchZi, lookupOperation2, matchZi2);// 排序
    359.         List<Map> results = mongoTemplate.aggregate(aggregation, "room", Map.class).getMappedResults(); // 查询出的结果集为BasicDBObject类型
    360.         for (Map result : results) {
    361.             System.out.println(result);
    362.         }
    363.     }
    364.  
    365.     // 数据模拟
    366.     @Test
    367.     public void findMoreTable3_1() {// 三表联查测试，第一个表关联第二个人表（关联字段1），第一个表关联第三个表（关联字段2）
    368.  
    369.         LookupOperation lookupOperation = LookupOperation.newLookup().from("desk"). // 关联表名
    370.                 localField("unitCode"). // 主关联字段
    371.                 foreignField("unitCode").// 从表关联字段对应的次表字段
    372.                 as("desks");// 查询结果集合名
    373.  
    374.         Criteria ordercri = Criteria.where("desks").not().size(0);// 只查询有宠物的人
    375.         // ordercri.and("age").gte(1).lte(5);//只查询1岁到5岁的宠物
    376.         AggregationOperation matchZi = Aggregation.match(ordercri);
    377.         LookupOperation lookupOperation2 = LookupOperation.newLookup().from("chair"). // 关联表名
    378.                 localField("lastCode"). // 主关联字段
    379.                 foreignField("lastCode").// 从表关联字段对应的次表字段
    380.                 as("chairs");// 查询结果集合名
    381.  
    382.         Criteria ordercri2 = Criteria.where("chairs").not().size(0);// 只查询有宠物的人
    383.         // ordercri.and("age").gte(1).lte(5);//只查询1岁到5岁的宠物
    384.         AggregationOperation matchZi2 = Aggregation.match(ordercri2);
    385.         Aggregation aggregation = Aggregation.newAggregation(lookupOperation, matchZi, lookupOperation2, matchZi2);// 排序
    386.         List<Map> results = mongoTemplate.aggregate(aggregation, "room", Map.class).getMappedResults(); // 查询出的结果集为BasicDBObject类型
    387.         for (Map result : results) {
    388.             System.out.println(result);
    389.         }
    390.     }
    391.  
    392.     // 数据模拟
    393.     @Test
    394.     public void findMoreTable3_3() {// 三表联查测试，第一个表关联第二个人表（关联字段1），第二个表关联第三个表（关联字段2）
    395.         LookupOperation lookupOperation = LookupOperation.newLookup().from("room"). // 关联表名
    396.                 localField("unitCode"). // 主关联字段
    397.                 foreignField("unitCode").// 从表关联字段对应的次表字段
    398.                 as("rooms");// 查询结果集合名
    399.  
    400.         Criteria ordercri = Criteria.where("rooms").not().size(0);// 只查询有宠物的人
    401.         // ordercri.and("age").gte(1).lte(5);//只查询1岁到5岁的宠物
    402.         AggregationOperation matchZi = Aggregation.match(ordercri);
    403.         LookupOperation lookupOperation2 = LookupOperation.newLookup().from("chair"). // 关联表名
    404.                 localField("rooms.lastCode"). // 主关联字段
    405.                 foreignField("lastCode").// 从表关联字段对应的次表字段
    406.                 as("chairs");// 查询结果集合名
    407.  
    408.         Criteria ordercri2 = Criteria.where("chairs").not().size(0);// 只查询有宠物的人
    409.         // ordercri.and("age").gte(1).lte(5);//只查询1岁到5岁的宠物
    410.         AggregationOperation matchZi2 = Aggregation.match(ordercri2);
    411.         Aggregation aggregation = Aggregation.newAggregation(lookupOperation, matchZi, lookupOperation2, matchZi2);// 排序
    412.         List<Map> results = mongoTemplate.aggregate(aggregation, "desk", Map.class).getMappedResults(); // 查询出的结果集为BasicDBObject类型
    413.         for (Map result : results) {
    414.             System.out.println(result);
    415.         }
    416.     }
    417.  
    418. }


     

  • 相关阅读:
    Java 变得越来越像 Rust？
    谈谈你对mvc和mvvm的理解
    删除字符串字符，使输出结果不包含回文串
    火车头采集器保存任意格式-免费火车头采集发布配置教程
    sql优化最新干货---mysql存储过程、索引和锁
    前端通过Blob或File文件获取二进制数据
    二叉树的遍历-树-数据结构和算法(Java)
    为零售业敲响警钟：关注行业数字化转型的未来趋势
    git初步使用
    基于SSM框架实现学生管理系统
  • 原文地址：https://blog.csdn.net/weixin_53998054/article/details/127516787