[系统运维] MongoDB

开发: C++知识库 Java知识库 JavaScript Python PHP知识库人工智能区块链大数据移动开发嵌入式开发工具数据结构与算法开发测试游戏开发网络协议系统运维
教程: HTML教程 CSS教程 JavaScript教程 Go语言教程 JQuery教程 VUE教程 VUE3教程 Bootstrap教程 SQL数据库教程 C语言教程 C++教程 Java教程 Python教程 Python3教程 C#教程
数码: 电脑笔记本显卡显示器固态硬盘硬盘耳机手机 iphone vivo oppo 小米华为单反装机图拉丁

-> 系统运维 -> MongoDB -> 正文阅读

[系统运维]MongoDB

为什么使用mogodb

数据量非常大

读多写少

价值较低

mongoDB数据结构非常类似于关系型数据库（数据类型非常丰富）

一条sql语句，单张表查询一定比多张表查询要快（设计表的时候尽量将数据设计到一张表，可以冗余字段）

什么是mongodb？

分步式文件存储c++高性能数据库（内存数据库，通过引擎异步同步数据到cipan）

通过docker安装mongoDB

#进入base目录
cd /root/docker-file/base/
#批量创建启动容器，其中已经包含了redis，zookeeper，mongodb容器
docker-compose up -d
#查看容器
docker ps -a

支持的数据类型

null，布尔型，数值，字符串，日期，正则表达式，数组，内嵌文档，对象id，二进制数据

在mongodb中，存储的文档结构是类似于json的结构，称之为bson

springboot整合mongoDB

使用Spring-Data-MongoDB很简单，只需要如下几步即可：

导入起步依赖
编写配置信息
编写实体类

导入依赖

<parent>
??? <groupId>org.springframework.boot</groupId>
??? <artifactId>spring-boot-starter-parent</artifactId>
??? <version>2.1.0.RELEASE</version>
</parent>

<dependency>
???? <groupId>org.springframework.boot</groupId>
???? <artifactId>spring-boot-starter-data-mongodb</artifactId>
</dependency>
<dependency>
??? <groupId>org.springframework.boot</groupId>
??? <artifactId>spring-boot-starter-test</artifactId>
??? <scope>test</scope>
</dependency>

编写application.yml配置文件

spring:
? data:
??? mongodb:
????? uri: mongodb://192.168.136.160:27017/test? #mongodb的数据库地址和名称

?探花今日佳人

今日佳人需求介绍

今日佳人功能分析

今日佳人功能实现

在用户登录成功之后，就会进入首页，首页有今日佳人，推荐好友，探花，搜附近等功能

今日佳人会根据缘分值最大的用户，进行展现出来。缘分值的计算是由用户的行为进行打分，如点赞评论学历婚姻状态等信息组合而成。

推荐结果是由大数据工程师来生成的，所以我们只需要从结果中查询到缘分值最高的用户就可以了。

当登录探花app后，在首页可以看到和自己最匹配的佳人信息(每天推荐的佳人是不一样的)首页佳人数据，是从推荐胸每天定时根据用户基本信息以及习惯，分析推荐类似用户。推荐系统会将分析结果写入一张表中，今日佳人表

服务提供者

1.根据当前用户id查询佳人用户信息

2.根据佳人用户id查询佳人用户信息

消费者

1.controller接收今日佳人请求

2.controller调用service业务处理

a.根据当前用户id 查询一条今日佳人数据（调用服务提供者） -- recommend_user

b.如果今日佳人数据不存在，则设置一条默认假数据（为了提升用户体验）

c.根据佳人用户id调用服务查询佳人用户信息 tb_userInfo

d.根据以上调用服务结果封装Vo返回

TodayBestVo

package com.tanhua.domain.vo;
import lombok.Data;
import java.io.Serializable;
@Data
public class TodayBestVo implements Serializable {
    private Long id;
    private String avatar;
    private String nickname;
    private String gender; //性别 man woman
    private Integer age;
    private String[] tags;
    private Long fateValue; //缘分值
}

服务提供者-今日佳人

导入依赖

tanhua-domain模块的pom.xml引入mongo依赖

<dependency>
??? <groupId>org.springframework.boot</groupId>
??? <artifactId>spring-boot-starter-data-mongodb</artifactId>
</dependency>
<dependency>
?? ?<groupId>org.mongodb</groupId>
??? <artifactId>mongodb-driver-sync</artifactId>
??? <version>3.9.1</version>
</dependency>

RecommendUser

package com.tanhua.dubbo.api.mongo;

import com.tanhua.domain.mongo.RecommendUser;
import com.tanhua.domain.vo.PageResult;

/**
 * 佳人服务接口
 */
public interface RecommendUserApi {
    /**
     * 根据当前登录的用户id查询佳人用户表 最匹配用户对象（1条记录）
     * @param toUserId
     * @return
     */
    RecommendUser queryMaxScoreByToUserId(Long toUserId);

    /**
     * 跟当前登录用户id 分页参数 分页查询佳人列表数据
     * @param page
     * @param pagesize
     * @param currentUserId
     * @return
     */
    PageResult<RecommendUser> queryPageByUserId(Integer page, Integer pagesize, Long currentUserId);

    /**
     * 根据佳人用户id 与 当前用户id 查询缘分值
     * @param userId 佳人用户id
     * @param toUserId 当前用户id
     * @return
     */
    Double queryForScore(Long userId,Long toUserId);
}

RecommendUserApiImpl

package com.tanhua.dubbo.api.mongo;
import com.tanhua.domain.mongo.RecommendUser;
import com.tanhua.domain.vo.PageResult;
import org.apache.dubbo.config.annotation.Service;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Sort;
import org.springframework.data.mongodb.core.MongoTemplate;
import org.springframework.data.mongodb.core.query.Criteria;
import org.springframework.data.mongodb.core.query.Query;

import java.util.List;

/**
 * 今日佳人服务实现类
 */
@Service
public class RecommendUserApiImpl implements RecommendUserApi {

    @Autowired
    private MongoTemplate mongoTemplate;

    /**
     * 根据当前登录的用户id查询佳人用户表 最匹配用户对象（1条记录）
     * db.recommend_user.find({toUserId:1}).sort({score:-1}).limit(1);
     *
     * @param toUserId
     * @return
     */
    @Override
    public RecommendUser queryMaxScoreByToUserId(Long toUserId) {
        Query query = new Query();
        //{toUserId:1}
        query.addCriteria(Criteria.where("toUserId").is(toUserId));
        //sort({score:-1})
        //query.with(Sort.by(Sort.Direction.DESC, "score"));
        query.with(Sort.by(Sort.Direction.ASC, "userId"));
        //limit(1)
        query.limit(1);
        return mongoTemplate.findOne(query, RecommendUser.class);
    }

    /**
     * 跟当前登录用户id 分页参数 分页查询佳人列表数据
     *
     * @param page
     * @param pagesize
     * @param currentUserId
     * @return
     */
    @Override
    public PageResult<RecommendUser> queryPageByUserId(Integer page, Integer pagesize, Long currentUserId) {
        //1.查询recommendUser表总记录数
        Query query = new Query();
        query.addCriteria(Criteria.where("toUserId").is(currentUserId));//当前用户id
        query.limit(pagesize).skip((page - 1) * pagesize);
        long counts = mongoTemplate.count(query, RecommendUser.class);
        //2.查询当前页面要展示的数据
        List<RecommendUser> recommendUserList = mongoTemplate.find(query, RecommendUser.class);
        //3.将数据封装返回
        long pages = (counts / pagesize) + (counts%pagesize > 0 ? 1:0);
        return new PageResult<>(counts,(long)pagesize,pages,(long)page,recommendUserList);
    }
    /**
     * 根据佳人用户id 与 当前用户id 查询缘分值
     * @param userId 佳人用户id
     * @param toUserId 当前用户id
     * @return
     */
    @Override
    public Double queryForScore(Long userId, Long toUserId) {
        Query query = new Query();
        //{toUserId:1}
        query.addCriteria(Criteria.where("userId").is(userId).and("toUserId").is(toUserId));
        RecommendUser recommendUser = mongoTemplate.findOne(query, RecommendUser.class);
        if(recommendUser == null){
            return 99d;
        }
        return recommendUser.getScore();
    }
}

消费者

TodayBestController

package com.tanhua.server.controller;

import com.tanhua.domain.db.UserInfo;
import com.tanhua.domain.vo.PageResult;
import com.tanhua.domain.vo.RecommendUserQueryParam;
import com.tanhua.domain.vo.TodayBestVo;
import com.tanhua.server.service.SettingService;
import com.tanhua.server.service.TodayBestService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;

import java.util.Map;

/**
 * 今日佳人控制层
 */
@RestController
@RequestMapping("/tanhua")
public class TodayBestController {

    @Autowired
    private TodayBestService todayBestService;

    /**
     * 首页-今日佳人
     */
    @RequestMapping(value = "/todayBest", method = RequestMethod.GET)
    public ResponseEntity todayBest() {
        TodayBestVo todayBestVo = todayBestService.todayBest();
        return ResponseEntity.ok(todayBestVo);
    }

    /**
     * 首页-佳人列表数据分页查询
     */
    @RequestMapping(value = "/recommendation", method = RequestMethod.GET)
    public ResponseEntity recommendation(RecommendUserQueryParam recommendUserQueryParam) {
        PageResult<TodayBestVo> pageResult = todayBestService.recommendation(recommendUserQueryParam);
        return ResponseEntity.ok(pageResult);
    }


    /**
     * 查看用户详情
     * {id}：佳人用户id
     */
    @RequestMapping(value = "/{id}/personalInfo", method = RequestMethod.GET)
    public ResponseEntity personalInfo(@PathVariable("id") Long personUserId) {
        TodayBestVo todayBestVo = todayBestService.personalInfo(personUserId);
        return ResponseEntity.ok(todayBestVo);
    }

    /**
     * 查询陌生人问题
     * userId:佳人用户id
     */
    @RequestMapping(value = "/strangerQuestions", method = RequestMethod.GET)
    public ResponseEntity strangerQuestions(Long userId) {
        String txt = todayBestService.strangerQuestions(userId);
        return ResponseEntity.ok(txt);
    }


    /**
     * 回复陌生人问题
     */
    @RequestMapping(value = "/strangerQuestions", method = RequestMethod.POST)
    public ResponseEntity strangerQuestions(@RequestBody Map params) {
        Long userId = Long.parseLong(params.get("userId").toString());
        String reply = (String) params.get("reply");//回复内容
        todayBestService.replyStrangerQuestions(userId, reply);
        return ResponseEntity.ok(null);
    }

    /**
     * 添加喜欢
     */
    @GetMapping("/{id}/love")
    public ResponseEntity addLikeUser(@PathVariable("id") String id) {
        todayBestService.addLikeUser(Long.valueOf(id));
        return ResponseEntity.ok(null);
    }

    /**
     * 添加黑名单
     */
    @GetMapping("/{id}/unlove")
    public ResponseEntity unLikeUser(@PathVariable("id") String id) {

        todayBestService.addBlackUser(Long.valueOf(id));
        return ResponseEntity.ok(null);
    }
}

TodayBestService

package com.tanhua.server.service;

import com.alibaba.fastjson.JSON;
import com.tanhua.commons.templates.HuanXinTemplate;
import com.tanhua.domain.db.BlackList;
import com.tanhua.domain.db.Question;
import com.tanhua.domain.db.UserInfo;
import com.tanhua.domain.mongo.Friend;
import com.tanhua.domain.mongo.RecommendUser;
import com.tanhua.domain.mongo.UserLike;
import com.tanhua.domain.vo.PageResult;
import com.tanhua.domain.vo.RecommendUserQueryParam;
import com.tanhua.domain.vo.TodayBestVo;
import com.tanhua.dubbo.api.db.BlackListApi;
import com.tanhua.dubbo.api.db.QuestionApi;
import com.tanhua.dubbo.api.db.UserInfoApi;
import com.tanhua.dubbo.api.mongo.FriendApi;
import com.tanhua.dubbo.api.mongo.RecommendUserApi;
import com.tanhua.dubbo.api.mongo.UserLikeApi;
import com.tanhua.server.interceptor.UserHolder;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.RandomUtils;
import org.apache.dubbo.config.annotation.Reference;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.util.CollectionUtils;
import org.springframework.util.StringUtils;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * 今日佳人业务处理层
 */
@Service
@Slf4j
public class TodayBestService {

    @Reference
    private RecommendUserApi recommendUserApi;

    @Reference
    private UserInfoApi userInfoApi;

    @Reference
    private BlackListApi blackListApi;

    @Reference
    private QuestionApi questionApi;

    @Reference
    private UserLikeApi userLikeApi;

    @Reference
    private FriendApi friendApi;


    @Autowired
    private HuanXinTemplate huanXinTemplate;

    /**
     * 首页-今日佳人
     */
    public TodayBestVo todayBest() {
        Long toUserId = UserHolder.getUserId();//当前登录用户id
        //a.根据当前用户id 查询一条今日佳人数据（调用服务提供者） -- recommend_user
        RecommendUser recommendUser = recommendUserApi.queryMaxScoreByToUserId(toUserId);
        //b.如果今日佳人数据不存在，则设置一条默认假数据（为了提升用户体验）
        if (recommendUser == null) {
            //默认数据
            recommendUser = new RecommendUser();
            recommendUser.setUserId(1l);
            recommendUser.setScore(99d);
        }
        //c.根据佳人用户id调用服务查询佳人用户信息 tb_userInfo
        Long userId = recommendUser.getUserId();//佳人用户id
        UserInfo userInfo = userInfoApi.queryUserInfo(userId);
        //d.根据以上调用服务结果封装Vo返回
        TodayBestVo todayBestVo = new TodayBestVo();
        BeanUtils.copyProperties(userInfo, todayBestVo);
        //设置tags
        if (!StringUtils.isEmpty(userInfo.getTags())) {
            todayBestVo.setTags(userInfo.getTags().split(","));
        }
        //设置缘分值
        todayBestVo.setFateValue(recommendUser.getScore().longValue());
        return todayBestVo;
    }

    /**
     * 首页-佳人列表数据分页查询
     */
    public PageResult<TodayBestVo> recommendation(RecommendUserQueryParam param) {
        //定义返回PageResultVo
        PageResult<TodayBestVo> voPageResult = new PageResult<>();

        Long currentUserId = UserHolder.getUserId();
        //1.跟当前登录用户id 分页参数 分页查询佳人列表数据
        PageResult<RecommendUser> pageResult = recommendUserApi.queryPageByUserId(param.getPage(), param.getPagesize(), currentUserId);
        //2.如果数据为空，设置默认数据
        List<RecommendUser> recommendUserList = new ArrayList<>();
        if (pageResult == null || CollectionUtils.isEmpty(pageResult.getItems())) {
            recommendUserList = defaultRecommend();
        } else {
            recommendUserList = pageResult.getItems();
        }
        //3.根据userId查询userInfo
        //4.将List<RecommendUser>转为List<TodayBestVo>
        List<TodayBestVo> todayBestVoList = new ArrayList<>();
        for (RecommendUser recommendUser : recommendUserList) {
            //根据以上调用服务结果封装Vo返回
            TodayBestVo todayBestVo = new TodayBestVo();
            Long userId = recommendUser.getUserId();//佳人用户id
            UserInfo userInfo = userInfoApi.queryUserInfo(userId);
            BeanUtils.copyProperties(userInfo, todayBestVo);
            //设置tags
            if (!StringUtils.isEmpty(userInfo.getTags())) {
                todayBestVo.setTags(userInfo.getTags().split(","));
            }
            //设置缘分值
            todayBestVo.setFateValue(recommendUser.getScore().longValue());
            todayBestVoList.add(todayBestVo);
        }
        //4.将数据封装返回
        BeanUtils.copyProperties(pageResult, voPageResult);//copy分页数据
        voPageResult.setItems(todayBestVoList);//将todayBestVoList设置到返回的Vo中
        return voPageResult;
    }


    //构造默认数据
    private List<RecommendUser> defaultRecommend() {
        String ids = "1,2,3,4,5,6,7,8,9,10";
        List<RecommendUser> records = new ArrayList<>();
        for (String id : ids.split(",")) {
            RecommendUser recommendUser = new RecommendUser();
            recommendUser.setUserId(Long.valueOf(id));
            recommendUser.setScore(RandomUtils.nextDouble(70, 98));
            records.add(recommendUser);
        }
        return records;
    }

    /**
     * 查看用户详情
     * {id}：佳人用户id
     */
    public TodayBestVo personalInfo(Long personUserId) {

        // a.根据佳人用户id查询userInfo
        UserInfo userInfo = userInfoApi.queryUserInfo(personUserId);
        //  b.调用服务获取缘分值
        Double score = recommendUserApi.queryForScore(personUserId, UserHolder.getUserId());
        //  c.封装vo
        TodayBestVo vo = new TodayBestVo();
        BeanUtils.copyProperties(userInfo, vo);
        if (userInfo != null && !StringUtils.isEmpty(userInfo.getTags())) {
            vo.setTags(userInfo.getTags().split(","));
        }
        vo.setFateValue(score.longValue());//缘分值
        return vo;

    }

    /**
     * 查询陌生人问题
     * userId:佳人用户id
     */
    public String strangerQuestions(Long userId) {
        String txt = "约吗？";
        Question question = questionApi.queryByUserId(userId);
        if (question != null && !StringUtils.isEmpty(question.getTxt())) {
            txt = question.getTxt();
        }
        return txt;
    }

    /**
     * 回复陌生人问题
     */
    public void replyStrangerQuestions(Long userId, String reply) {
        //a.UserHolder.getuserId()获取当前用户id
        Long currentUserId = UserHolder.getUserId();//当前用户id
        //b.根据当前登录用户id 查询userInfo 获取昵称
        UserInfo userInfo = userInfoApi.queryUserInfo(currentUserId);
        String nickname = userInfo.getNickname();

        //c.根据佳人用户id查询问题
        Question question = questionApi.queryByUserId(userId);
        String txt = "约吗？";
        if (question != null && !StringUtils.isEmpty(question.getTxt())) {
            txt = question.getTxt();
        }
        //d.将以上数据封装Map 并将Map转为String字符串
        Map<String, String> map = new HashMap();
        map.put("userId", currentUserId.toString());//当前用户id
        map.put("nickname", nickname);//当前用户昵称
        map.put("strangerQuestion", txt);//佳人问题
        map.put("reply", reply);//当前用户的回复
        String message = JSON.toJSONString(map); //将map转为message消息
        //e.调用环信云发送消息给userId佳人用户id target：佳人用户id msg:消息内容
        huanXinTemplate.sendMsg(userId.toString(), message);
        log.debug("用户{}发送消息给用户{},内容是{}", currentUserId, userId, message);
    }

    /**
     * 添加喜欢
     */
    public void addLikeUser(Long id) {
        Long userId = UserHolder.getUserId();//当前用户Id
        UserLike userLike = new UserLike();

        userLike.setUserId(userId);
        userLike.setLikeUserId(id);

        //添加喜欢的用户
        userLikeApi.addLikeUser(userLike);

        //查询对方是否喜欢我
        UserLike user = userLikeApi.findOne(id, userId);
        //判断，如果喜欢则成为好友
        if (user != null) {
            Friend friend = new Friend();
            friend.setUserId(userId);
            friend.setFriendId(id);

            friendApi.saveFriend(friend);
        }
    }

    /**
     * 添加黑名单
     */
    public void addBlackUser(Long id) {
        Long userId = UserHolder.getUserId();//当前用户Id

        BlackList user = blackListApi.findOne(userId, id);
        if (user == null) {
            BlackList blackList = new BlackList();
            blackList.setUserId(userId);
            blackList.setBlackUserId(id);
            blackListApi.addBlackUser(blackList);
        }

    }
}