<dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-mongodb</artifactId>
        </dependency>
        <!--swagger API獲取-->
        <dependency>
            <groupId>io.springfox</groupId>
            <artifactId>springfox-swagger2</artifactId>
            <version>2.9.2</version>
        </dependency>
        <!--swagger-ui API獲取-->
        <dependency>
            <groupId>io.springfox</groupId>
            <artifactId>springfox-swagger-ui</artifactId>
            <version>2.9.2</version>
        </dependency>
    </dependencies>

spring:
  data:
    mongodb:
      uri: mongodb://root:123456@IP地址:27017/book?authSource=admin&authMechanism=SCRAM-SHA-1
server:
  port: 8082

@Document(collection="book")
@Data
@AllArgsConstructor
@NoArgsConstructor
public class BookInfo {
    @Id
    private String id;
    @Field("name")
    private String name;
    @Field("price")
    private Integer price;
    @Field("publish_time")
    private String publishTime;
    @Field("comment")
    private String comment;
}

public interface BookRepository  extends MongoRepository<BookInfo,String> {
}

    @Autowired
    private BookService bookService;
	@PostMapping("/save")
    public String save(BookInfo bookInfo) {
        return bookService.saveBook(bookInfo);
    }
    @PostMapping("/update")
    public String update(BookInfo bookInfo) {
        return bookService.update(bookInfo);
    }
    @GetMapping("/delete")
    public String deleteById(String id) {
        return bookService.deleteById(id);
    }
    @PostMapping("/detail")
    public BookInfo findById(String id) {
        return bookService.findById(id);
    }

    @Autowired
    private BookRepository bookRepository;
    /**
     * 保存
     * @param bookInfo
     * @return
     */
    public String saveBook(BookInfo bookInfo){
        bookInfo.setId(IdUtil.generateId());
        bookRepository.save(bookInfo);
        return "save book info success";
    }
    /**
     * 修改
     * @param bookInfo
     * @return
     */
    public String update(BookInfo bookInfo) {
        if(StringUtils.isEmpty(bookInfo.getId())){
            throw new RuntimeException("ID不能為空");
        }
        bookRepository.save(bookInfo);
        return "save book info success";
    }
    /**
     * 根據ID刪除
     * @param id
     * @return
     */
    public String deleteById(String id) {
        bookRepository.deleteById(id);
        return "delete success";
    }
    /**
     * 查詢所有
     * @return
     */
    public List<BookInfo> findList() {
        return bookRepository.findAll();
    }
    /**
     * 根據ID獲取
     * @param id
     * @return
     */
    public BookInfo findById(String id) {
        Optional<BookInfo> bookInfoOptional = bookRepository.findById(id);
        return bookInfoOptional.isPresent() ? bookInfoOptional.get() : null;
    }

    /**
     * 模糊查詢
     * @param name
     * @return
     */
    public List<BookInfo> query(String name) {
        //構建匹配器對象
        ExampleMatcher matcher = ExampleMatcher.matching()
                .withStringMatcher(ExampleMatcher.StringMatcher.CONTAINING) //設置默認字符串匹配方式：模糊查詢
                .withIgnoreCase(true);      //設置默認大小寫忽略方式：true為忽略大小寫
        BookInfo bookInfo = new BookInfo();
        bookInfo.setName(name);
        Example<BookInfo> bookInfoExampleExample = Example.of(bookInfo,matcher);
        List<BookInfo> bookInfos = bookRepository.findAll(bookInfoExampleExample);
        return bookInfos;
    }

public Page<BookInfo> pageQuery(Integer pageNo,Integer pageSize,String name) {
        //構造排序器，設置排序字段
        Sort sort = Sort.by(Sort.Direction.ASC,"price");
        Pageable pageable = null;
        if(Objects.isNull(pageNo) || Objects.isNull(pageSize)){
            pageNo = 0;
            pageSize=10;
        }
        pageable = PageRequest.of(pageNo, pageSize, sort);
        //創(chuàng)建匹配器，設置查詢條件
        ExampleMatcher matcher = ExampleMatcher.matching() //構建匹配器對象
                .withStringMatcher(ExampleMatcher.StringMatcher.CONTAINING) //設置默認字符串匹配方式：模糊查詢
                .withIgnoreCase(true); //設置默認大小寫忽略方式：true為忽略大小寫
        //設置查詢條件
        BookInfo bookInfo = new BookInfo();
        bookInfo.setName(name);
        Example<BookInfo> bookExample = Example.of(bookInfo,matcher);
        //查詢
        Page<BookInfo> page = bookRepository.findAll(bookExample, pageable);
        return page;
    }

public interface BookRepository  extends MongoRepository<BookInfo,String> {
	//根據名稱查詢
    @Query("{name: ?0}")
    List<BookInfo> findByBookName(String name);
	//查詢價格大于某個數(shù)的集合
    @Query(value = "{price: { $gt: ?0 }}")
    List<BookInfo> findByBookPriceThan(int price);
	//查詢ID在某個集合中，類似mysql 的 in ()語法
    @Query(value = "{'_id':{$in:?0}}")
    List<BookInfo> findAllByIdIn(List<String> ids);
}

@RestController
@RequestMapping("/template")
public class BookTemplateController {
    @Autowired
    private BookTemplateService bookTemplateService;
    @PostMapping("/save")
    public BookInfo save(BookInfo bookInfo){
        return bookTemplateService.save(bookInfo);
    }
    @PostMapping("/update")
    public BookInfo update(BookInfo bookInfo){
        return bookTemplateService.update(bookInfo);
    }
    @GetMapping("/delete")
    public String delete(String id){
        return bookTemplateService.delete(id);
    }
    @GetMapping("/details")
    public BookInfo details(String id){
        return bookTemplateService.findById(id);
    }
}

@Service
public class BookTemplateService {
    @Autowired
    private MongoTemplate mongoTemplate;
    public BookInfo save(BookInfo bookInfo) {
        bookInfo.setId(IdUtil.generateId());
        BookInfo book = mongoTemplate.save(bookInfo);
        return book;
    }
    public BookInfo update(BookInfo bookInfo) {
        if(StringUtils.isEmpty(bookInfo.getId())){
            throw new RuntimeException("ID為空");
        }
        Query query = Query.query(Criteria.where("_id").is(bookInfo.getId()));
        BookInfo dbBook = mongoTemplate.findOne(query, BookInfo.class);
        if(Objects.isNull(dbBook)){
            return null;
        }
        Update update = new Update();
        if(!StringUtils.isEmpty(bookInfo.getName())){
            update.set("name",bookInfo.getName());
        }
        if(!StringUtils.isEmpty(bookInfo.getComment())){
            update.set("comment",bookInfo.getComment());
        }
        if(Objects.nonNull(bookInfo.getPrice())){
            update.set("price",bookInfo.getPrice());
        }
        mongoTemplate.updateFirst(query,update,BookInfo.class);
        return bookInfo;
    }
    public String delete(String id) {
        Query query = new Query(Criteria.where("_id").is(id));
        mongoTemplate.remove(query,BookInfo.class);
        return "deleted";
    }
    public BookInfo findById(String id) {
        BookInfo bookInfo = mongoTemplate.findById(id, BookInfo.class);
        return bookInfo;
    }
}

    public List<BookInfo> queryByJson(String name,String type,Integer price) {
        //String json1 = "{name:'" + name +"'}";
        String json2 = "{$or:[{price:{$gt: '" +price+"'}},{type: '"+type+"'}]}";
        Query query = new BasicQuery(json2);
        //查詢結果
        List<BookInfo> employees = mongoTemplate.find(query, BookInfo.class);
        return employees;
    }

    //模糊查詢
    public List<BookInfo> queryLike(String key){
        Query query = new Query(Criteria.where("name").regex(key));
        List<BookInfo> bookInfos = mongoTemplate.find(query, BookInfo.class);
        return bookInfos;
    }

    //查詢價格大于某個值
    public List<BookInfo> queryMoreThan(Integer price){
        Query query = new Query(Criteria.where("price").gte(price));
        List<BookInfo> bookInfos = mongoTemplate.find(query, BookInfo.class);
        return bookInfos;
    }

    //多條件查詢
    public List<BookInfo> queryMultiParams(String name,String type,Integer price){
        //or 條件查詢
        Criteria criteria = new Criteria();
        /*criteria.orOperator(
                Criteria.where("name").regex(name),
                Criteria.where("price").gte(price),
                Criteria.where("type").is(type)
        );*/
        //and 條件查詢
        criteria.andOperator(
                Criteria.where("price").gte(price),
                Criteria.where("type").is(type)
        );
        Query query = new Query(criteria);
        List<BookInfo> bookInfos = mongoTemplate.find(query, BookInfo.class);
        return bookInfos;
    }

    //分頁查詢
    public PageInfo<BookInfo> pageQuery(Integer pageIndex,Integer pageSize,String type){
        Criteria criteria = new Criteria();
        if(!StringUtils.isEmpty(type)){
            criteria = Criteria.where("price").gte(type);
        }
        //TODO 如果有更多的查詢條件，繼續(xù)拼接 ...
        Query query = new Query(criteria);
        if(Objects.isNull(pageIndex) || Objects.isNull(pageSize)){
            pageIndex = 1;
            pageSize = 2;
        }
        //查詢總數(shù)
        long total = mongoTemplate.count(query, BookInfo.class);
        System.out.println(total);
        //查詢結果根據價格排個序
        query.with(Sort.by(Sort.Order.desc("price")))
                .skip((pageIndex-1) * pageSize) //指定跳過記錄數(shù)
                .limit(pageSize); //每頁顯示記錄數(shù)
        List<BookInfo> bookInfos = mongoTemplate.find(query, BookInfo.class);
        PageInfo<BookInfo> pageInfo = new PageInfo(pageIndex,pageSize,total,bookInfos);
        return pageInfo;
    }

    public void groupQuery(){
        // 查詢條件
        Criteria criteria = new Criteria();
        MatchOperation matchOperation = Aggregation.match(criteria);
        // 查詢包括的字段
        ProjectionOperation projectionOperation = Aggregation.project("id", "name","price", "type","readCount","likeCount");
        // 分組統(tǒng)計
        GroupOperation groupOperation = Aggregation.group("type")
                //.first("type").as("type")
                .count().as("typeCount")
                .sum("likeCount").as("totalLike")
                .avg("likeCount").as("avgLikeCount")
                .sum("readCount").as("totalReadCount")
                .sum("readCount").as("avgReadCount");
        AggregationResults<Map> totalAuthorResult = mongoTemplate.aggregate(Aggregation.newAggregation(BookInfo.class,
                matchOperation, projectionOperation, groupOperation), Map.class);
        //獲取分類總數(shù)
        int typeCount = (int) totalAuthorResult.getMappedResults().size();
        System.out.println(typeCount);
        //得到最終分組聚合的結果
        List<Map> mappedResults = totalAuthorResult.getMappedResults();
        for(Map map :mappedResults){
            System.out.println(map.keySet());
        }
    }