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());
    }

}