MongoDB应用实战-1

//创建查询,查出此条件下,总记录数
Query query = new Query();
Criteria criteria = new Criteria();
criteria.and("systemId").is(params.getSystemId());
criteria.and("platformId").is(params.getPlatformId());
if (StringUtils.isNotBlank(params.getTitle())) {
    criteria.and("title").is(params.getTitle());
}
query.addCriteria(criteria);
// 总数
int count = mongoTemplate.count(query, CarouselInfo.class);
// 分页查询
params.setCurPage(params.getCurPage() == null ? PageParameter.DEFAULT_CURR_PAGE : params.getCurPage());
params.setPageSize(params.getPageSize() == null ? PageParameter.DEFAULT_PAGE_SIZE : params.getPageSize());
//此处为第几页,从第几条开始查,公式和sql一样,根据业务自行设置
query.skip((params.getCurPage() - 1) * params.getPageSize());
//每页条数
query.limit(params.getPageSize());
//调用find(),查出符合条件的数据
List<CarouselInfo> carouselInfos = mongoTemplate.find(query, CarouselInfo.class);

private static MongoClient mongoClient;
// 静态代码块，项目启动前进行类加载就执行了
static {
    try {
        //连接到MongoDB服务 如果是远程连接可以替换“localhost”为服务器所在IP地址
        mongoClient = MongoClients.create("mongodb://test:test@127.0.0.1:27017/test_db");
        System.out.println("Connect to database successfully");
    } catch (Exception e) {
        System.err.println( e.getClass().getName() + ": " + e.getMessage() );
    }
}

/**
 * 创建集合
 * @param args
 */
public static void main(String[] args) {
    // 连接到数据库
    MongoDatabase mongoDatabase = mongoClient.getDatabase("test_db");
    System.out.println("Connect to database successfully");
    mongoDatabase.createCollection("tb_role");
    System.out.println("集合创建成功");
}

/**
 * 删除集合
 * @param args
 */
public static void main(String[] args) {
    // 连接到数据库
    MongoDatabase mongoDatabase = mongoClient.getDatabase("test_db");
    System.out.println("Connect to database successfully");
    mongoDatabase.getCollection("tb_role").drop();
    System.out.println("集合 tb_role 删除成功");
}

/**
 * 插入文档
 * @param args
 */
public static void main(String[] args) {
    // 连接到数据库
    MongoDatabase mongoDatabase = mongoClient.getDatabase("test_db");
    System.out.println("Connect to database successfully");
    //获取集合
    MongoCollection<Document> collection = mongoDatabase.getCollection("tb_role");

    //向集合中插入文档
    Document document = new Document("name", "管理员").
            append("code", "manager").
            append("sort", 100);
    List<Document> documents = new ArrayList<>();
    documents.add(document);
    collection.insertMany(documents);
    System.out.println("文档插入成功");
}

/**
 * 更新文档
 * @param args
 */
public static void main(String[] args) {
    // 连接到数据库
    MongoDatabase mongoDatabase = mongoClient.getDatabase("test_db");
    System.out.println("Connect to database successfully");
    //获取集合
    MongoCollection<Document> collection = mongoDatabase.getCollection("tb_role");

    //更新文档
    collection.updateMany(Filters.eq("code", "manager"), new Document("$set",new Document("name","经理")));

    //遍历所有文档
    FindIterable<Document> findIterable = collection.find();
    MongoCursor<Document> mongoCursor = findIterable.iterator();
    while(mongoCursor.hasNext()){
        System.out.println(mongoCursor.next());
    }
}

/**
 * 删除文档
 * @param args
 */
public static void main(String[] args) {
    // 连接到数据库
    MongoDatabase mongoDatabase = mongoClient.getDatabase("test_db");
    System.out.println("Connect to database successfully");
    //获取集合
    MongoCollection<Document> collection = mongoDatabase.getCollection("tb_role");

    //删除符合条件的第一个文档
    collection.deleteOne(Filters.eq("code", "manager"));
    //删除所有符合条件的文档
    collection.deleteMany (Filters.eq("code", "manager"));

    //遍历所有文档
    FindIterable<Document> findIterable = collection.find();
    MongoCursor<Document> mongoCursor = findIterable.iterator();
    while(mongoCursor.hasNext()){
        System.out.println(mongoCursor.next());
    }
}

/**
 * 查询文档
 * @param args
 */
public static void main(String[] args) {
    // 连接到数据库
    MongoDatabase mongoDatabase = mongoClient.getDatabase("test_db");
    System.out.println("Connect to database successfully");
    //获取集合
    MongoCollection<Document> collection = mongoDatabase.getCollection("tb_role");

    //遍历所有文档
    FindIterable<Document> findIterable = collection.find();
    MongoCursor<Document> mongoCursor = findIterable.iterator();
    while(mongoCursor.hasNext()){
        System.out.println(mongoCursor.next());
    }

    //查询当前集合所有文档数量
    long count = collection.countDocuments();
    System.out.println("当前文档数量:" + count);

    //带条件遍历文档
    FindIterable<Document> documentFindIterable = collection.find(Filters.eq("code", "manager"));
    MongoCursor<Document> documentMongoCursor = documentFindIterable.iterator();
    while(documentMongoCursor.hasNext()){
        System.out.println(documentMongoCursor.next());
    }
}

package com.macro.mall.tiny.nosql.mongodb.document;

import org.springframework.data.annotation.Id;
import org.springframework.data.mongodb.core.index.Indexed;
import org.springframework.data.mongodb.core.mapping.Document;
import java.util.Date;

/**
     * 用户商品浏览历史记录
     * Created by macro on 2018/8/3.
     */
@Document // 映射到Mongodb文档上的领域对象
public class MemberReadHistory {
  @Id // 文档的ID字段
  private String id;
  @Indexed // 映射到Mongodb文档的索引字段
  private Long memberId;
  private String memberNickname;
  private String memberIcon;
  @Indexed
  private Long productId;
  private String productName;
  private String productPic;
  private String productSubTitle;
  private String productPrice;
  private Date createTime;
  
  //省略了所有getter和setter方法
}

@Document(collection="persons")
public class Person implements Serializable {
    private static final long serialVersionUID = -3258839839160856613L;

 /**
     * 使用@Id注解指定MongoDB中的 _id 主键
     */
    @Id
    private Long id;

    private String userName;

    private String passWord;

    private Integer age;

    private Date createTime;

    //...get/set

    @Override
    public String toString() {
        return "Person{" +
                "id=" + id +
                ", userName='" + userName + '\'' +
                ", passWord='" + passWord + '\'' +
                ", age=" + age +
                ", createTime=" + createTime +
                '}';
    }
}

public interface MemberReadHistoryRepository extends MongoRepository<MemberReadHistory,String> {
    /**
     * 自定义的文档查询方法
     * 根据会员id按时间倒序获取浏览记录
     * @param memberId 会员id
     */
    List<MemberReadHistory> findByMemberIdOrderByCreateTimeDesc(Long memberId);
}

@Query("{ 'memberId' : ?0 }")
List<MemberReadHistory> findByMemberId(Long memberId);

import com.macro.mall.tiny.nosql.mongodb.document.MemberReadHistory;
import java.util.List;

/**
 * 会员浏览记录管理Service
 * Created by macro on 2018/8/3.
 */
public interface MemberReadHistoryService {
    /**
     * 生成浏览记录
     */
    int create(MemberReadHistory memberReadHistory);

    /**
     * 批量删除浏览记录
     */
    int delete(List<String> ids);

    /**
     * 获取用户浏览历史记录
     */
    List<MemberReadHistory> list(Long memberId);
}

import com.macro.mall.tiny.nosql.mongodb.document.MemberReadHistory;

import com.macro.mall.tiny.nosql.mongodb.repository.MemberReadHistoryRepository;
import com.macro.mall.tiny.service.MemberReadHistoryService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.ArrayList;
import java.util.Date;
import java.util.List;

/**
 * 会员浏览记录管理Service实现类
 * Created by macro on 2018/8/3.
 */
@Service
public class MemberReadHistoryServiceImpl implements MemberReadHistoryService {

    @Autowired
    private MemberReadHistoryRepository memberReadHistoryRepository;

    @Override
    public int create(MemberReadHistory memberReadHistory) {
        memberReadHistory.setId(null);
        memberReadHistory.setCreateTime(new Date());
        memberReadHistoryRepository.save(memberReadHistory);
        return 1;

    }

    @Override
    public int delete(List<String> ids) {
        List<MemberReadHistory> deleteList = new ArrayList<>();
        for(String id:ids){
            MemberReadHistory memberReadHistory = new MemberReadHistory();
            memberReadHistory.setId(id);
            deleteList.add(memberReadHistory);
        }
        memberReadHistoryRepository.deleteAll(deleteList);
        return ids.size();
    }

    @Override
    public List<MemberReadHistory> list(Long memberId) {
        return memberReadHistoryRepository.findByMemberIdOrderByCreateTimeDesc(memberId);
    }
}

import com.macro.mall.tiny.common.api.CommonResult;
import com.macro.mall.tiny.nosql.mongodb.document.MemberReadHistory;
import com.macro.mall.tiny.service.MemberReadHistoryService;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.*;
import java.util.List;


/**
 * 会员商品浏览记录管理Controller
 * Created by macro on 2018/8/3.
 */
@Controller
@Api(tags = "MemberReadHistoryController", description = "会员商品浏览记录管理")
@RequestMapping("/member/readHistory")
public class MemberReadHistoryController {
    @Autowired
    private MemberReadHistoryService memberReadHistoryService;

    @ApiOperation("创建浏览记录")
    @RequestMapping(value = "/create", method = RequestMethod.POST)
    @ResponseBody
    public CommonResult create(@RequestBody MemberReadHistory memberReadHistory) {
        int count = memberReadHistoryService.create(memberReadHistory);
        if (count > 0) {
            return CommonResult.success(count);
        } else {
            return CommonResult.failed();
        }
    }

    @ApiOperation("删除浏览记录")
    @RequestMapping(value = "/delete", method = RequestMethod.POST)
    @ResponseBody
    public CommonResult delete(@RequestParam("ids") List<String> ids) {
        int count = memberReadHistoryService.delete(ids);
        if (count > 0) {
            return CommonResult.success(count);
        } else {
            return CommonResult.failed();
        }
    }

    @ApiOperation("展示浏览记录")
    @RequestMapping(value = "/list", method = RequestMethod.GET)
    @ResponseBody
    public CommonResult<List<MemberReadHistory>> list(Long memberId) {
        List<MemberReadHistory> memberReadHistoryList = memberReadHistoryService.list(memberId);
        return CommonResult.success(memberReadHistoryList);
    }
}

@RunWith(SpringRunner.class)
@SpringBootTest
public class PersonServiceTest {

    @Autowired
    private MongoTemplate mongoTemplate;

    /**
     * 插入文档
     * @throws Exception
     */
    @Test
    public void insert() throws Exception {
        Person person =new Person();
        person.setId(1l);
        person.setUserName("张三");
        person.setPassWord("123456");
        person.setCreateTime(new Date());
        mongoTemplate.insert(person);
    }
}

@Test
public void insertCustomCollection() throws Exception {
  Person person =new Person();
  person.setId(1l);
  person.setUserName("张三");
  person.setPassWord("123456");
  person.setCreateTime(new Date());
  mongoTemplate.insert(person, "custom_person");
}

@Test
public void insertBatch() throws Exception {
  List<Person> personList = new ArrayList<>();
  Person person1 =new Person();
  person1.setId(10l);
  person1.setUserName("张三");
  person1.setPassWord("123456");
  person1.setCreateTime(new Date());
  personList.add(person1);

  Person person2 =new Person();
  person2.setId(11l);
  person2.setUserName("李四");
  person2.setPassWord("123456");
  person2.setCreateTime(new Date());
  personList.add(person2);

  mongoTemplate.insert(personList, "custom_person");
}

/**
     * 存储文档，如果没有插入，否则更新
     * @throws Exception
     */
@Test
public void save() throws Exception {
  Person person =new Person();
  person.setId(13l);
  person.setUserName("八八");
  person.setPassWord("123456");
  person.setAge(40);
  person.setCreateTime(new Date());
  mongoTemplate.save(person);
}

/**
     * 更新文档，匹配查询到的文档数据中的第一条数据
     * @throws Exception
     */
@Test
public void updateFirst() throws Exception {
  //更新对象
  Person person =new Person();
  person.setId(1l);
  person.setUserName("张三123");
  person.setPassWord("123456");
  person.setCreateTime(new Date());

  //更新条件
  Query query= new Query(Criteria.where("id").is(person.getId()));

  //更新值
  Update update= new Update().set("userName", person.getUserName()).set("passWord", person.getPassWord());
  //更新查询满足条件的文档数据（第一条）
  UpdateResult result =mongoTemplate.updateFirst(query,update, Person.class);
  if(result!=null){
    System.out.println("更新条数：" + result.getMatchedCount());
  }
}

/**
更新文档，匹配查询到的文档数据中的所有数据
**/
@Test
public void updateMany() throws Exception {
  //更新对象
  Person person =new Person();
  person.setId(1l);
  person.setUserName("张三");
  person.setPassWord("123456");
  person.setCreateTime(new Date());

  //更新条件
  Query query= new Query(Criteria.where("id").is(person.getId()));

  //更新值
  Update update= new Update().set("userName", person.getUserName()).set("passWord", person.getPassWord());
  //更新查询满足条件的文档数据（全部）
  UpdateResult result = mongoTemplate.updateMulti(query, update, Person.class);
  if(result!=null){
    System.out.println("更新条数：" + result.getMatchedCount());
  }
}

/**
upsert 插入或更新数据
**/
@Override
public void save(SysConfigSaveVO sysConfig) {
    Query query = new Query(Criteria.where("key").is(sysConfig.getKey()));
    Date now = new Date();
    Update update = new Update();
    update.setOnInsert(SysConfig.FIELD_KEY,sysConfig.getKey());
    update.setOnInsert(SysConfig.FIELD_CREATE_TIME,now);
    update.set(SysConfig.FIELD_VALUE,sysConfig.getValue());
    update.set(SysConfig.FIELD_UPDATE_TIME,now);
    if(StringUtils.isNotBlank(sysConfig.getRemark())){
        update.set(SysConfig.FIELD_REMARK,sysConfig.getRemark());
    }
    mongoTemplate.upsert(query,update,"sys_config");
}

/**
     * 删除符合条件的所有文档
     * @throws Exception
     */
@Test
public void remove() throws Exception {
  Person person =new Person();
  person.setId(1l);
  person.setUserName("张三");
  person.setPassWord("123456");
  person.setCreateTime(new Date());

  Query query = new Query(Criteria.where("userName").is(person.getUserName()));
  DeleteResult result = mongoTemplate.remove(query, Person.class);
  System.out.println("删除条数：" + result.getDeletedCount());
}

 /**
     * 删除符合条件的单个文档，并返回删除的文档
     * @throws Exception
     */
@Test
public void findAndRemove() throws Exception {
  Person person =new Person();
  person.setId(1l);
  person.setUserName("张三");
  person.setPassWord("123456");
  person.setCreateTime(new Date());

  Query query = new Query(Criteria.where("id").is(person.getId()));
  Person result = mongoTemplate.findAndRemove(query, Person.class);
  System.out.println("删除的文档数据：" + result.toString());
}

/**
     * 删除符合条件的所有文档，并返回删除的文档
     * @throws Exception
     */
@Test
public void findAllAndRemove() throws Exception {
  Person person =new Person();
  person.setId(1l);
  person.setUserName("张三");
  person.setPassWord("123456");
  person.setCreateTime(new Date());

  Query query = new Query(Criteria.where("id").is(person.getId()));
  List<Person> result = mongoTemplate.findAllAndRemove(query, Person.class);
  System.out.println("删除的文档数据：" + result.toString());
}

// 1、查询集合中的全部文档数据
@Test
public void findAll() throws Exception {
  List<Person> result = mongoTemplate.findAll(Person.class);
  System.out.println("查询结果：" + result.toString());
}

// 2、查询集合中指定的ID文档数据
@Test
public void findById() {
  long id = 1l;
  Person result = mongoTemplate.findById(id, Person.class);
  System.out.println("查询结果：" + result.toString());
}

// 3、根据条件查询集合中符合条件的文档，返回第一条数据
@Test
public void findOne() {
  String userName = "张三";
  Query query = new Query(Criteria.where("userName").is(userName));
  Person result = mongoTemplate.findOne(query, Person.class);
  System.out.println("查询结果：" + result.toString());
}

// 4、根据条件查询集合中符合条件的文档
@Test
public void findByCondition() {
  String userName = "张三";
  Query query = new Query(Criteria.where("userName").is(userName));
  List<Person> result = mongoTemplate.find(query, Person.class);
  System.out.println("查询结果：" + result.toString());
}

// 5、根据【AND】关联多个查询条件，查询集合中的文档数据
@Test
public void findByAndCondition() {
  // 创建条件
  Criteria criteriaUserName = Criteria.where("userName").is("张三");
  Criteria criteriaPassWord = Criteria.where("passWord").is("123456");
  // 创建条件对象，将上面条件进行 AND 关联
  Criteria criteria = new Criteria().andOperator(criteriaUserName, criteriaPassWord);
  // 创建查询对象，然后将条件对象添加到其中
  Query query = new Query(criteria);
  List<Person> result = mongoTemplate.find(query, Person.class);
  System.out.println("查询结果：" + result.toString());
}

// 6、根据【OR】关联多个查询条件，查询集合中的文档数据
@Test
public void findByOrCondition() {
  // 创建条件
  Criteria criteriaUserName = Criteria.where("userName").is("张三");
  Criteria criteriaPassWord = Criteria.where("passWord").is("123456");
  // 创建条件对象，将上面条件进行 OR 关联
  Criteria criteria = new Criteria().orOperator(criteriaUserName, criteriaPassWord);
  // 创建查询对象，然后将条件对象添加到其中
  Query query = new Query(criteria);
  List<Person> result = mongoTemplate.find(query, Person.class);
  System.out.println("查询结果：" + result.toString());
}

// 7、根据【IN】关联多个查询条件，查询集合中的文档数据
@Test
public void findByInCondition() {
  // 设置查询条件参数
  List<Long> ids = Arrays.asList(1l, 10l, 11l);
  // 创建条件
  Criteria criteria = Criteria.where("id").in(ids);
  // 创建查询对象，然后将条件对象添加到其中
  Query query = new Query(criteria);
  List<Person> result = mongoTemplate.find(query, Person.class);
  System.out.println("查询结果：" + result.toString());
}

// 8、根据【逻辑运算符】查询集合中的文档数据
@Test
public void findByOperator() {
  // 设置查询条件参数
  int min = 20;
  int max = 35;
  Criteria criteria = Criteria.where("age").gt(min).lte(max);
  // 创建查询对象，然后将条件对象添加到其中
  Query query = new Query(criteria);
  List<Person> result = mongoTemplate.find(query, Person.class);
  System.out.println("查询结果：" + result.toString());
}

// 9、根据【正则表达式】查询集合中的文档数据
@Test
public void findByRegex() {
  // 设置查询条件参数
  String regex = "^张*";
  Criteria criteria = Criteria.where("userName").regex(regex);
  // 创建查询对象，然后将条件对象添加到其中
  Query query = new Query(criteria);
  List<Person> result = mongoTemplate.find(query, Person.class);
  System.out.println("查询结果：" + result.toString());
}

// 10、根据条件查询集合中符合条件的文档，获取其文档列表并排序
@Test
public void findByConditionAndSort() {
  String userName = "张三";
  Query query = new Query(Criteria.where("userName").is(userName)).with(Sort.by("age"));
  List<Person> result = mongoTemplate.find(query, Person.class);
  System.out.println("查询结果：" + result.toString());
}

// 11、根据单个条件查询集合中的文档数据，并按指定字段进行排序与限制指定数目
@Test
public void findByConditionAndSortLimit() {
  String userName = "张三";
  //从第一行开始，查询2条数据返回
  Query query = new Query(Criteria.where("userName").is(userName)).with(Sort.by("createTime")).limit(2).skip(1);
  List<Person> result = mongoTemplate.find(query, Person.class);
  System.out.println("查询结果：" + result.toString());
}

// 12、统计集合中符合【查询条件】的文档【数量】
@Test
public void countNumber() {
  // 设置查询条件参数
  String regex = "^张*";
  Criteria criteria = Criteria.where("userName").regex(regex);
  // 创建查询对象，然后将条件对象添加到其中
  Query query = new Query(criteria);
  long count = mongoTemplate.count(query, Person.class);
  System.out.println("统计结果：" + count);
}

@RunWith(SpringRunner.class)
@SpringBootTest
public class PersonServiceTest {
  @Autowired
  private MongoTemplate mongoTemplate;

  // 1、创建升序索引
  @Test
  public void createAscendingIndex() {
    // 设置字段名称
    String field = "userName";
    // 创建索引    
  mongoTemplate.getCollection("persons").createIndex(Indexes.ascending(field));
  }
  
  // 2、根据索引名称移除索引
  @Test
  public void removeIndex() {
    // 设置字段名称
    String field = "userName";
    // 删除索引
    mongoTemplate.getCollection("persons").dropIndex(field);
  }
  
  // 3、查询集合中所有的索引
  @Test
  public void getIndexAll() {
    // 获取集合中所有列表
    ListIndexesIterable<Document> indexList = mongoTemplate.getCollection("persons").listIndexes();
    // 获取集合中全部索引信息
    for (Document document : indexList) {
      System.out.println("索引列表：" + document);
    }
  }
}

@Document(collection="persons")
public class Person implements Serializable {
    private static final long serialVersionUID = -3258839839160856613L;

 /**
     * 使用@Id注解指定MongoDB中的 _id 主键
     */
    @Id
    private Long id;

    private String userName;

    private String passWord;

    private Integer age;

 /**
     * 创建一个5秒之后文档自动删除的索引
     */
    @Indexed(expireAfterSeconds=5)
    private Date createTime;

    //...get/set

    @Override
    public String toString() {
        return "Person{" +
                "id=" + id +
                ", userName='" + userName + '\'' +
                ", passWord='" + passWord + '\'' +
                ", age=" + age +
                ", createTime=" + createTime +
                '}';
    }
}

@EnableMongoPlus
@SpringBootApplication
public class Application {

    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

/**
 * 配置事务管理器
 */
@Configuration
public class TransactionConfig {
    @Bean
    MongoTransactionManager transactionManager(MongoDatabaseFactory dbFactory) {
        return new MongoTransactionManager(dbFactory);
    }
}

@Service
public class TransactionExample {
    @Autowired
    private MongoTemplate mongoTemplate;

    @Transactional(rollbackFor = Exception.class)
    public Object transactionTest(){
        Person person =new Person();
        person.setId(1l);
        person.setUserName("张三");
        person.setPassWord("123456");
        person.setCreateTime(new Date());
        Person newPerson = mongoTemplate.insert(person);
        // 抛出异常，观察数据是否进行回滚
        if(1 == 1){
            throw new RuntimeException("异常");
        }
        return newPerson;
    }
}