MongoDB学习-->Spring Data Mongodb-->MongodbTemplate

配置文件application-dev.yml：

server:
port: 8888

mongo:
host: localhost
port: 27017
timeout: 60000
db: mamabike

配置类MongoDBConfiguration：

package com.tangzhe.configuration;

import com.mongodb.MongoClient;
import com.mongodb.MongoClientOptions;
import com.mongodb.ServerAddress;
import com.tangzhe.autoid.SaveMongoEventListener;
import lombok.Data;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.mongodb.core.MongoTemplate;
import org.springframework.data.mongodb.core.SimpleMongoDbFactory;
import org.springframework.data.mongodb.core.convert.DefaultMongoTypeMapper;
import org.springframework.data.mongodb.core.convert.MappingMongoConverter;
import org.springframework.data.mongodb.core.mapping.MongoMappingContext;
import org.springframework.data.mongodb.gridfs.GridFsTemplate;

/**
 * Created by 唐哲
 * 2018-03-13 17:20
 * MongoDB配置
 */
@Configuration
@ConfigurationProperties(prefix = "mongo")
@Data
public class MongoDBConfiguration {

    //mongodb服务地址
    private String host;

    //mongodb服务端口号
    private Integer port;

    //连接超时
    private Integer timeout;

    //mongodb数据库名
    private String db;

    /**
     * 配置MongoDB模板
     */
    @Bean
    public MongoTemplate mongoTemplate(SimpleMongoDbFactory mongoDbFactory,
                                       MappingMongoConverter mappingMongoConverter) {
        return new MongoTemplate(mongoDbFactory, mappingMongoConverter);
    }

    /**
     * 配置自增ID监听器
     */
    @Bean
    public SaveMongoEventListener saveMongoEventListener() {
        return new SaveMongoEventListener();
    }

    /**
     * 配置GridFs模板，实现文件上传下载
     */
    @Bean
    public GridFsTemplate gridFsTemplate(SimpleMongoDbFactory mongoDbFactory,
                                         MappingMongoConverter mappingMongoConverter) {
        return new GridFsTemplate(mongoDbFactory, mappingMongoConverter);
    }

    /**
     * 配置mongoDbFactory
     */
    @Bean
    public SimpleMongoDbFactory mongoDbFactory() {
        MongoClientOptions options = MongoClientOptions.builder().connectTimeout(timeout).build();
        MongoClient client = new MongoClient(new ServerAddress(host, port), options);
        return new SimpleMongoDbFactory(client, db);
    }

    /**
     * 配置mongoMappingContext
     */
    @Bean
    public MongoMappingContext mongoMappingContext() {
        return new MongoMappingContext();
    }

    /**
     * 配置defaultMongoTypeMapper
     */
    @Bean
    public DefaultMongoTypeMapper defaultMongoTypeMapper() {
        //去掉_class字段
        return new DefaultMongoTypeMapper(null);
    }

    /**
     * 配置mappingMongoConverter
     */
    @Bean
    public MappingMongoConverter mappingMongoConverter(SimpleMongoDbFactory mongoDbFactory,
                                                       MongoMappingContext mongoMappingContext,
                                                       DefaultMongoTypeMapper defaultMongoTypeMapper) {
        MappingMongoConverter mappingMongoConverter = new MappingMongoConverter(mongoDbFactory, mongoMappingContext);
        mappingMongoConverter.setTypeMapper(defaultMongoTypeMapper);
        return mappingMongoConverter;
    }

}

测试类：

 package com.tangzhe.mongodb;

 import org.junit.runner.RunWith;
 import org.springframework.boot.test.context.SpringBootTest;
 import org.springframework.test.context.junit4.SpringRunner;

 /**
  * Created by 唐哲
  * 2018-03-13 17:25
  */
 @RunWith(SpringRunner.class)
 @SpringBootTest
 public class BaseTest {
 }

实体类：

 package com.tangzhe.mongodb;

 import lombok.Data;
 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.Date;
 import java.util.List;

 /**
  * Created by 唐哲
  * 2018-03-13 17:40
  */
 @Document(collection = "article_info")
 @Data
 public class Article {

     @Id
     private String id;

     @Field("title")
     private String title;

     @Field("v_count")
     private Long visitCount;

     @Field("tags")
     private List<String> tags;

     @Field("add_time")
     private Date addTime;

 }

测试mongodbTemplate：

 package com.tangzhe.mongodb.mongotemplate;

 import com.tangzhe.mongodb.Article;
 import com.tangzhe.mongodb.BaseTest;
 import org.bson.types.ObjectId;
 import org.junit.Test;
 import org.springframework.beans.factory.annotation.Autowired;
 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.Arrays;
 import java.util.Date;
 import java.util.List;

 /**
  * Created by 唐哲
  * 2018-03-13 17:27
  */
 public class MongoTemplateTest extends BaseTest {

     @Autowired
     private MongoTemplate mongoTemplate;

     /**
      * 查询某数据库中所有集合（表）
      */
     //@Test
     public void findAllCollections() {
         mongoTemplate.getCollectionNames().forEach(System.out::println);
     }

     /**
      * 批量插入数据
      */
     //@Test
     public void insertBatch() {
         List<Article> datas = new ArrayList<>();
         for(int i=0; i<10; i++) {
             Article article = new Article();
             article.setTitle("猿天地实战课程" + i);
             article.setVisitCount(10L);
             article.setTags(Arrays.asList("java", "python", "c#"));
             article.setAddTime(new Date());
             datas.add(article);
         }

         mongoTemplate.insert(datas, Article.class);
     }

     /**
      * 修改数据
      */
     @Test
     public void update() {
         //根据title修改
 //        mongoTemplate.updateFirst(
 //                Query.query(
 //                    new Criteria("title").is("猿天地实战课程0")
 //                ),
 //                Update.update("visitCount", 100L),
 //                Article.class
 //        );

         //存在就修改不存在就插入
 //        mongoTemplate.upsert(
 //                Query.query(
 //                        new Criteria("title").is("猿天地实战课程10")
 //                ),
 //                Update.update("visitCount", 200L),
 //                Article.class
 //        );

         //修改title，并将visitCount加1
 //        mongoTemplate.updateFirst(
 //                Query.query(
 //                        new Criteria("title").is("猿天地实战课程0")
 //                ),
 //                Update.update("title", "猿天地实战课程").inc("visitCount", 1),
 //                Article.class
 //        );

         //如果传入的是集合名称，则需要写苦衷原始的key名称，如果是实体类就写类中的字段名称
 //        mongoTemplate.updateFirst(
 //                Query.query(
 //                        new Criteria("title").is("猿天地实战课程")
 //                ),
 //                Update.update("v_count", 1L),
 //                "article_info"
 //        );

         //删除key
         mongoTemplate.updateFirst(
                 Query.query(
                         new Criteria("title").is("猿天地实战课程")
                 ),
                 new Update().unset("visitCount"),
                 Article.class
         );
     }

     /**
      * 删除数据
      */
     @Test
     public void delete() {
 //        mongoTemplate.remove(
 //                Query.query(
 //                        Criteria.where("title").is("猿天地实战课程")
 //                ),
 //                Article.class
 //        );

         //删除一条，并且返回这条数据
         Article article = mongoTemplate.findAndRemove(
                 Query.query(
                         Criteria.where("title").is("猿天地实战课程10")
                 ),
                 Article.class
         );
         System.out.println(article);

         //批量删除，并且返回数据列表
         List<Article> articles = mongoTemplate.findAllAndRemove(
                 Query.query(
                         Criteria.where("title").is("猿天地实战课程10")
                 ),
                 Article.class
         );

         //删除集合(表)的两种方式
         mongoTemplate.dropCollection(Article.class);
         mongoTemplate.dropCollection("article_info");

         //删除数据库
         mongoTemplate.getDb().dropDatabase();
     }

     /**
      * 查询数据
      */
     @Test
     public void select() {
         //数量查询
         long count = mongoTemplate.count(
                 Query.query(
                         Criteria.where("visitCount").is(10)
                 ),
                 Article.class
         );
         System.out.println(count);

         //查询第一条
         Article article = mongoTemplate.findOne(
                 Query.query(
                         Criteria.where("visitCount").is(10)
                 ),
                 Article.class
         );
         System.out.println(article);

         //查询所有
         List<Article> articles = mongoTemplate.findAll(Article.class);
         System.out.println(articles.size());

         //带条件查询
         mongoTemplate.find(
                 Query.query(
                         Criteria.where("visitCount").is(100)
                 ),
                 Article.class
         );

         //如果在大数据量的情况下，最好是排序，记住你上次最后一条数据的ID，
         //然后就是大于上次的ID，然后limit页数
         articles = mongoTemplate.find(
                 Query.query(
                         Criteria.where("visitCount").is(100)
                 ).skip(0).limit(10),
                 Article.class
         );
         System.out.println(articles.size());

         //根据ID查询
         mongoTemplate.findById(new ObjectId("5aa79ddecdb51518c073a247"), Article.class);

         //in查询
         articles = mongoTemplate.find(
                 Query.query(
                         Criteria.where("visitCount").in(100, 200, 300)
                 ),
                 Article.class
         );
         System.out.println(articles.size());

         //or查询
         articles = mongoTemplate.find(
                 Query.query(
                         new Criteria().orOperator(
                                 Criteria.where("visitCount").is(100),
                                 Criteria.where("visitCount").is(200),
                                 Criteria.where("visitCount").is(300)
                         )
                 ),
                 Article.class
         );
         System.out.println(articles.size());
     }

 }