MongoDB学习笔记

一、MongoDB简介

1.1、评论数据特点分析

评论两项功能存在以下特点：

• 数据量大
• 写入操作频繁
• 价值较低

对于这样的数据，更适合使用MongoDB来实现数据的存储

1.2、什么是MongonDB

MongoDB 的官方网站地址是：https://www.mongodb.com/

MongoDB 是一个跨平台的，面向文档的数据库，是当前 NoSQL 数据库产品中最热门的一种。它介于关系数据库和非关系数据库之间，是非关系数据库当中功能最丰富，最像关系数据库的产品。它支持的数据结构非常松散，是类似 JSON 的 BSON 格式，因此可以存储比较复杂的数据类型

1.3、MongonDB特点

MongoDB 最大的特点是他支持的查询语言非常强大，其语法有点类似于面向对象的查询语言，几乎可以实现类似关系数据库单表查询的绝大部分功能，而且还支持对数据建立索引。它是一个面向集合的,模式自由的文档型数据库。具体特点总结如下：

1. 面向集合存储，易于存储对象类型的数据
2. 模式自由
3. 支持动态查询
4. 支持完全索引，包含内部对象
5. 支持复制和故障恢复
6. 使用高效的二进制数据存储，包括大型对象（如视频等）
7. 自动处理碎片，以支持云计算层次的扩展性
8. 支持 Python，PHP，Ruby，Java，C，C#，Javascript，Perl 及 C++语言的驱动程序，社区中也提供了对 Erlang 及.NET 等平台的驱动程序
9. 文件存储格式为 BSON（一种 JSON 的扩展）

1.4、MongonDB体系结构

MongoDB 的逻辑结构是一种层次结构。主要由：文档(document)、集合(collection)、数据库(database)这三部分组成的。逻辑结构是面向用户的，用户使用 MongoDB 开发应用程序使用的就是逻辑结构。

1. MongoDB 的文档（document），相当于关系数据库中的一行记录。
2. 多个文档组成一个集合（collection），相当于关系数据库的表。
3. 多个集合（collection），逻辑上组织在一起，就是数据库（database）。
4. 一个 MongoDB 实例支持多个数据库（database）。

文档(document)、集合(collection)、数据库(database)的层次结构如下图:

MongoDB与MySQL数据库逻辑结构概念的对比：

MongoDB	MySQL
数据库（database）	数据库（database）
集合（collections）	表（table）
文档（document）	行（row）

1.5、数据类型

类型	解释
基本数据类型null	用于表示空值或者不存在的字段，{“x”:null}
布尔型	布尔类型有两个值true和false，{“x”:true}
数值	shell默认使用64为浮点型数值。{“x”：3.14}或{“x”：3}。对于整型值，可以使用NumberInt（4字节符号整数）或NumberLong（8字节符号整数），{“x”:NumberInt(“3”)}{“x”:NumberLong(“3”)}
字符串	UTF-8字符串都可以表示为字符串类型的数据，{“x”：“呵呵”}
日期	日期被存储为自新纪元依赖经过的毫秒数，不存储时区，{“x”:new Date()}
正则表达式	查询时，使用正则表达式作为限定条件，语法与JavaScript的正则表达式相同，{“x”: /[abc]/}
数组	数据列表或数据集可以表示为数组，{“x”： [“a“，“b”,”c”]}
内嵌文档	文档可以嵌套其他文档，被嵌套的文档作为值来处理，{“x”:{“y”:3 }}
对象Id	对象id是一个12字节的字符串，是文档的唯一标识，{“x”: objectId() }
二进制数据	二进制数据是一个任意字节的字符串。它不能直接在shell中使用。如果要将非utf-字符保存到数据库中，二进制数据是唯一的方式。
代码	查询和文档中可以包括任何JavaScript代码，{“x”:function(){/…/}}

二、MongoDB的安装和命令

2.1、安装和启动

下载地址：https://www.mongodb.com/try/download/community

这里将压缩包上传至/usr/local/leyou目录下

#这里我选择链接下载
wget https://fastdl.mongodb.org/linux/mongodb-linux-x86_64-rhel70-4.2.15.tgz
# 解压mongodb安装包
tar -zxvf mongodb-linux-x86_64-rhel70-4.2.15.tgz
#重命名
mv mongodb-linux-x86_64-rhel70-4.2.15 mongodb
#进入mongodb，创建data和logs目录
cd mongodb
mkdir data
mkdir logs

启动mongo

./mongod --dbpath=/usr/local/leyou/mongodb/data --logpath=/usr/local/leyou/mongodb/logs/mongod.log --logappend  --port=27017 --bind_ip=0.0.0.0 --fork

查看日志：

出现这些内容，即代表启动成功，开放阿里云安全组27017端口

2.2、常用命令

2.2.1、创建和选择数据库

语法格式：

use 数据库

use commentdb

如果数据库不存在则会自动创建数据库：

2.2.2、插入与查询文档

插入语法格式：

db.集合名称.insert(数据)

db.commentdb.insert({userId:"001",nickName:"Mr.Wang",content:"加油加油"})

查询全部文档格式：

db.集合名称.find()

db.commentdb.find()

这里会发现每条文档会有一个叫_id 的字段，这个相当于关系数据库中表的主键，若在插入文档记录时没有指定该字段，MongoDB会自动创建，其类型是ObjectID类型。如果在插入文档记录时指定该字段了，其类型是ObjectID类型，也可以是MongoDB支持的任意类型

条件查询

数据准备：

db.commentdb.insert({_id:"1",userId:"001",nickName:"Mr.Wang",content:"加油加油"})
db.commentdb.insert({_id:"2",userId:"002",nickName:"Mr.Wang",content:"加油加油"})
db.commentdb.insert({_id:"3",userId:"003",nickName:"Mr.Wang",content:"加油加油"})
db.commentdb.insert({_id:"4",userId:"004",nickName:"Mr.Wang",content:"加油加油"})
db.commentdb.insert({_id:"5",userId:"005",nickName:"Mr.Wang",content:"加油加油"})

查询出userId为004的数据：

db.集合名称.find(查询条件)

db.commentdb.find({userId:"004"})

查询符合条件的第一条数据，可以使用findOne命令来实现

db.集合名称.findOne(查询条件)

db.commentdb.findOne({nickName:"Mr.Wang"})

指定结果条数，可以在find方法后调用limit

db.集合名称.find().limit(数量)

db.commentdb.find().limit(3)

2.2.3、修改与删除文档

修改语法格式：

db.集合名称.update(条件,修改后的数据)

db.commentdb.update({_id:"1"},{content:"努力努力"})

执行后可以发现，这条文档除了被修改的字段其它字段都消失不见，使用修改器$set来实现则不会出现该问题

命令如下：

db.commentdb.update({_id:"2"},{$set:{content:"学习学习"}})

删除语法格式：

db.集合名称.remove(条件)  #删除单个
db.commentdb.remove({userId:"001"})

db.集合名称.remove({})	#删除全部
db.commentdb.remove({})

删除userId为001：

删除全部：

2.2.4、统计条数

语法格式：

db.集合名称.count() #重新插入5条数据

db.comment.count()

条件统计：

db.集合名称.count(条件)

db.comment.count({userId:"001"})

2.2.5、模糊查询

MongoDB的模糊查询是通过正则表达式的方式实现的

语法格式：

db.集合名称.find({ :/正则表达式/})

#查询评论内容包含“加油加油”的所有文档
db.comment.find({content:/加油加油/})

#查询评论内容中以“努力”开头的
db.comment.find({content:/^努力/})

2.2.6、大于 小于 不等于

<, <=, >, >= 这些操作符也是很常用的

语法格式如下：

db.集合名称.find({ "field" : { $gt: value }}) // 大于: field > value

db.集合名称.find({ "field" : { $lt: value }}) // 小于: field < value

db.集合名称.find({ "field" : { $gte: value }}) // 大于等于: field >= value

db.集合名称.find({ "field" : { $lte: value }}) // 小于等于: field <= value

db.集合名称.find({ "field" : { $ne: value }}) // 不等于: field != value

2.2.7、包含与不包含

包含使用$in操作符

包含语法格式如下：

db.集合名称.find({ "field" : { $in: [val, val] }})

#查询用户id为002，003
db.comment.find({userId:{$in:["002","003"]}})

不包含语法格式如下：

db.集合名称.find({ "field" : { $nin: [val, val] }})

#查询用户id不为002，003
db.comment.find({userId:{$nin:["002","003"]}})

2.2.8、条件连接

如果需要查询同时满足两个以上条件，需要使用$and操作符将条件进行关联，（相当于SQL的and）

语法格式如下：

db.集合名称.find({ $and : [条件，条件]})

#查询用户名称为Mr.Wang，且用户id为003
db.comment.find({$and:[{nickName:"Mr.Wang"},{userId:"003"}]})

如果两个以上条件之间是或者的关系，可以使用$or操作符进行关联，使用方式与前面and的相同

db.集合名称.find({ $or : [条件，条件]})

#查询用户id为003，或者content为"努力努力"
db.comment.find({$or:[{content:"努力努力"},{userId:"003"}]})

2.2.9、列值增长

如果想实现对某列值在原有值的基础上进行增加或减少，可以使用$inc运算符来实现

示例：db.comment.update({_id:"2"},{$inc:{num:NumberInt(1)}})

num保存的一个数值类型字段

三、Java操作MongoDB

mongodb-driver

mongodb-driver是mongo官方推出的Java连接mongoDB的驱动包，相当于JDBC驱动。通过一个入门的案例来了解mongodb-driver的基本使用。

3.1、引入依赖

创建一个普通moven项目，

<!--mongoDB依赖-->
<dependency>
    <groupId>org.mongodb</groupId>
    <artifactId>mongodb-driver</artifactId>
    <version>3.8.2</version>
</dependency>

3.2、查询全部记录

public class Test01 {
    public static void main(String[] args) {
        //新建连接
        MongoClient mongoClient = new MongoClient("ip地址", 27017);
        //获取数据库对象
        MongoDatabase commentdb = mongoClient.getDatabase("commentdb");
        //获取集合对象
        MongoCollection<Document> commentCollection = commentdb.getCollection("comment");
        //查询记录获取文档集合
        FindIterable<Document> documents = commentCollection.find();
        for (Document document : documents) {
            System.out.println(document);
            System.out.println("用户id：" + document.getString("userId"));
            System.out.println("用户昵称：" + document.getString("nickName"));
            System.out.println("评论内容：" + document.getString("content"));
        }
        // 关闭连接
        mongoClient.close();
    }
}

结果

3.3、单条件查询

public class Test02 {
    public static void main(String[] args) {
        //新建连接
        MongoClient mongoClient = new MongoClient("ip地址", 27017);
        //获取数据库对象
        MongoDatabase commentdb = mongoClient.getDatabase("commentdb");
        //获取集合对象
        MongoCollection<Document> collection = commentdb.getCollection("comment");
        //构建查询条件
        BasicDBObject basicDBObject = new BasicDBObject("userId", "002");
        //查询记录获取文档集合
        FindIterable<Document> documents = collection.find(basicDBObject);
        for (Document document : documents) {
            System.out.println(document);
            System.out.println("用户id：" + document.getString("userId"));
            System.out.println("用户昵称：" + document.getString("nickName"));
            System.out.println("评论内容：" + document.getString("content"));
        }
        // 关闭连接
        mongoClient.close();
    }
}

结果

3.4、插入数据

public class Test03 {
    public static void main(String[] args) {
        MongoClient mongoClient = new MongoClient("ip地址", 27017);
        MongoDatabase commentdb = mongoClient.getDatabase("commentdb");
        MongoCollection<Document> collection = commentdb.getCollection("comment");
        //构建新数据
        HashMap<String, Object> map = new HashMap<>();
        map.put("_id","6");
        map.put("userId","006");
        map.put("nickName","Mr.White");
        map.put("content","测试插入");
        //新字段
        map.put("visits",520);
        Document document = new Document(map);
        collection.insertOne(document);
        mongoClient.close();
    }
}

3.5、多条件查询

public class Test04 {
    public static void main(String[] args) {
        //新建连接
        MongoClient mongoClient = new MongoClient("ip地址", 27017);
        //获取数据库对象
        MongoDatabase commentdb = mongoClient.getDatabase("commentdb");
        //获取集合对象
        MongoCollection<Document> collection = commentdb.getCollection("comment");
        //构建查询条件，查询访问数 大于500的
        BasicDBObject basicDBObject = new BasicDBObject("visits", new BasicDBObject("$gt",500));
        //查询记录获取文档集合
        FindIterable<Document> documents = collection.find(basicDBObject);
        for (Document document : documents) {
            System.out.println(document);
            System.out.println("用户id：" + document.getString("userId"));
            System.out.println("用户昵称：" + document.getString("nickName"));
            System.out.println("评论内容：" + document.getString("content"));
            System.out.println("访问数：" + document.getInteger("visits"));
        }
        // 关闭连接
        mongoClient.close();
    }
}

结果

四、SpringDataMongoDB

官网主页： https://spring.io/projects/spring-data-mongodb

SpringData家族成员之一，用于操作MongoDb的持久层框架，底层封装了mongodb-driver

类似前面的SpringDataElasticSearch

乐优商城（17）–评论服务

一、需求分析

实现功能：

• 评论的增删改查
• 评论点赞回复

mongodb表结构

字段名称	字段含义	字段类型	备注
_id	ID	文本
orderid	订单id	文本
spuid	商品id	文本
userid	用户id	文本
nickname	评论人昵称	文本
parentid	评论id	文本	父评论id，顶级评论为0
isparent	是否是顶级评论	布尔型
publishtime	评论日期	日期
visits	浏览量	整型
thumbup	点赞数	整型
images	评论中的图片	数组
content	评论内容	文本
comment	回复数	整型
iscomment	是否允许回复	布尔型
type	评价类型	整型	0：非常差，1：差，2：一般，3：好，4：非常好，-1：表示评论的回复

设计参考tb_categoty

二、评论服务搭建

2.1、服务搭建

2.1.1、模块创建

父模块

子模块

一个接口模块，一个服务模块

2.1.2、Pom文件

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <parent>
        <artifactId>leyou-comment</artifactId>
        <groupId>com.leyou.comment</groupId>
        <version>0.0.1-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>leyou-comment-service</artifactId>

    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
    </properties>

    <dependencies>
        <!--服务注册中心-->
        <dependency>
            <groupId>com.alibaba.cloud</groupId>
            <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
        </dependency>
        <!-- feign -->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-openfeign</artifactId>
        </dependency>
        <!-- web -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <!--redis依赖-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>
        <!--mongodb依赖-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-mongodb</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-amqp</artifactId>
        </dependency>
        <dependency>
            <groupId>com.leyou.auth</groupId>
            <artifactId>leyou-auth-common</artifactId>
            <version>0.0.1-SNAPSHOT</version>
        </dependency>
        <dependency>
            <groupId>com.leyou.comment</groupId>
            <artifactId>leyou-comment-interface</artifactId>
            <version>0.0.1-SNAPSHOT</version>
        </dependency>
    </dependencies>

</project>

2.1.3、application.yaml配置文件

server:
  port: 8091
spring:
  application:
    name: comment-service
  cloud:
    nacos:
      discovery:
        server-addr: IP地址:8848
        username: nacos
        password: nacos
  data:
    mongodb:
      host: IP地址
      database: commentdb
  rabbitmq:
    host: IP地址
    virtual-host: /leyou
    username: leyou
    password: leyou
  redis:
    host: IP地址
    port: 8975
  jackson:
    default-property-inclusion: non_null
leyou:
  worker:
    workerId: 2
    datacenterId: 2
  jwt:
    pubKeyPath: F:\\leyou\\rsa\\rsa.pub # 公钥地址
    cookieName: LY_TOKEN # cookie的名称

2.1.4、启动类

@SpringBootApplication
@EnableDiscoveryClient
@EnableFeignClients
public class LeyouCommentApplication {
    public static void main(String[] args) {
        SpringApplication.run(LeyouCommentApplication.class,args);
    }
}

2.2、准备工作

2.2.1、实体类

public class Review implements Serializable {

    @Id
    private String _id;
    private String orderid;//订单id
    private String spuid;//商品id
    private String content;//评论内容
    private Date publishtime;//评论时间
    private String userid;//评论用户id
    private String nickname;//评论用户昵称
    private Integer visits;//评论的浏览量
    private Integer thumbup;//评论的点赞数
    private List<String> images;//评论中的图片
    private Integer comment;//评论的回复数
    private Boolean iscomment;//该评论是否可以被回复
    private String parentid;//该评论的上一级id
    private Boolean isparent;//是否是顶级评论
    private Integer type; //评论的类型

    //json转换需要
    public Review() {
    }

    public Review(String orderid, String spuid, String content, String userid, String nickname, List<String> images, Boolean iscomment, String parentid, Boolean isparent, Integer type) {
        this.orderid = orderid;
        this.spuid = spuid;
        this.content = content;
        this.userid = userid;
        this.nickname = nickname;
        this.images = images;
        this.iscomment = iscomment;
        this.parentid = parentid;
        this.isparent = isparent;
        this.type = type;
    }
    //get和set
}

2.2.2、ReviewRepository

public interface ReviewRepository extends MongoRepository<Review,String> {
}

2.2.3、网关路由

三、功能实现

3.1、分页查询评论

Controller

• 请求方式：GET

• 请求路径：/list

• 请求参数：商品id、当前页码、页面大小，封装一个请求参数对象：

• 返回结果：返回评论的分页信息

这里评论数显示固定的大小，每页20个，这里封装一个请求参数对象

CommentRequestParam

/**
 * 评论请求参数
 */
public class CommentRequestParam {
    
    private Long spuId;//商品id
    private Integer page;//当前页码
    //每页大小，不从前端接收，而是固定大小
    private static final Integer DEFAULT_SIZE = 20;
    private static final Integer DEFAULT_PAGE = 1;//默认页

    public Long getSpuId() {
        return spuId;
    }

    public void setSpuId(Long spuId) {
        this.spuId = spuId;
    }

    public Integer getPage() {
        if (page == null){
            return DEFAULT_PAGE;
        }
        //获取页码时做一些校验，不能小于1
        return Math.max(DEFAULT_PAGE,page);
    }

    public void setPage(Integer page) {
        this.page = page;
    }

    public Integer getDefaultSize() {
        return DEFAULT_SIZE;
    }
}

@RestController
@RequestMapping("/comment")
public class CommentController {

    @Autowired
    private CommentService commentService;

    /**
     *  分页查询商品评论
     * @param commentRequestParam
     * @return
     */
    @GetMapping("/list")
    public ResponseEntity<PageResult<Review>> findReviewBySpuId(@RequestBody CommentRequestParam commentRequestParam){
        Page<Review> reviews = this.commentService.findReviewBySpuId(commentRequestParam);
        if (null == reviews) return ResponseEntity.notFound().build();
        PageResult<Review> pageResult = new PageResult<>();
        pageResult.setTotalPage(reviews.getTotalPages());
        pageResult.setTotal(reviews.getTotalElements());
        pageResult.setItems(reviews.getContent());
        return ResponseEntity.ok(pageResult);
    }
}

ReviewRepository

提供一个方法，根据spuid查询评论

/**
 * 分页查询
 * @param spuid
 * @param pageable
 * @return
 */
Page<Review> findReviewBySpuid(String spuid, Pageable pageable);

Service

public interface CommentService {

    /**
     * 查询一商品下的所有顶级评论
     * @param commentRequestParam
     * @return
     */
    Page<Review> findReviewBySpuId(CommentRequestParam commentRequestParam);
}

实现类：

@Service
public class CommentServiceImpl implements CommentService {

    @Autowired
    private ReviewRepository reviewRepository;

    @Autowired
    private MongoTemplate mongoTemplate;

    /**
     * 查询一商品下的所有顶级评论
     *
     * @param commentRequestParam
     * @return
     */
    @Override
    public Page<Review> findReviewBySpuId(CommentRequestParam commentRequestParam) {
        PageRequest pageRequest = PageRequest.of(commentRequestParam.getPage() - 1, commentRequestParam.getDefaultSize());
        return this.reviewRepository.findReviewBySpuid(commentRequestParam.getSpuId()+"",pageRequest);
    }
}

3.2、发表评论

• 请求方式：POST

• 请求路径：无

• 请求参数：Review评论对象

• 返回结果：状态码201

Controller

/**
 * 添加一条评论
 * @param review
 * @return
 */
@PostMapping
public ResponseEntity<Void> addReview(@RequestBody Review review){
    boolean flag = this.commentService.addReview(review);
    if (!flag) return ResponseEntity.badRequest().build();
    return ResponseEntity.status(HttpStatus.CREATED).build();
}

Service

/**
 * 添加一条评论
 * @param review
 * @return
 */
boolean addReview(Review review);

实现类：

/**
 * 添加一条评论
 *
 * @param review
 * @return
 */
@Override
@Transactional
public boolean addReview(Review review) {
    //分两种情况，1.顶级父评论 2.追评或回复
    //判断是否为首条评论
    if (review.getIsparent()){
        //是 则去mongo查询是否存在评论
        Query query = new Query();
        //根据用户id、订单id、spuid可以确定一条评论
        query.addCriteria(Criteria.where("userid").is(review.getUserid()));
        query.addCriteria(Criteria.where("orderid").is(review.getOrderid()));
        query.addCriteria(Criteria.where("spuid").is(review.getSpuid()));
        List<Review> reviews = this.mongoTemplate.find(query, Review.class);
        if (reviews.size() > 0 && reviews.get(0).getIsparent()) return false;
    }
    review.set_id(this.idWorker.nextId()+"");
    review.setPublishtime(new Date());
    review.setComment(0);
    review.setThumbup(0);
    review.setVisits(0);
    //存在父类id
    if (null != review.getParentid() && !"".equals(review.getParentid())){
        //将父评论数量+1，浏览量+1，isparent设置为true
        Query query = new Query();
        query.addCriteria(Criteria.where("_id").is(review.getParentid()));
        Update update = new Update();
        update.inc("comment",1);
        update.inc("visits",1);
        update.set("isparent",true);
        this.mongoTemplate.updateFirst(query,update,"review");
    }
    //保存评论
    this.reviewRepository.save(review);
    return true;
}

这里判断了评论是否为用户对该商品的首次评论，评论类型分两种：1.父评论 2.追评或回复

3.3、修改评论

Controller

• 请求方式：PUT

• 请求路径：无

• 请求参数：Review评论对象

• 返回结果：状态码200

/**
 * 更新一条评论
 * @param review
 * @return
 */
@PutMapping
public ResponseEntity<Void> updateReview(@RequestBody Review review){
    this.commentService.updateReview(review);
    return ResponseEntity.ok().build();
}

Service

/**
 * 更新一条评论
 * @param review
 * @return
 */
void updateReview(Review review);

实现类：

/**
 * 更新一条评论
 *
 * @param review
 * @return
 */
@Override
public void updateReview(Review review) {
    this.reviewRepository.save(review);
}

3.4、删除评论

Controller

• 请求方式：DELETE

• 请求路径：无

• 请求参数：评论id

• 返回结果：状态码200

/**
 * 根据评论id删除评论
 * @param id
 * @return
 */
@DeleteMapping("/{id}")
public ResponseEntity<Void> deleteReview(@PathVariable("id") String id){
    this.commentService.deleteReview(id);
    return ResponseEntity.ok().build();
}

Service

/**
 * 根据评论id删除评论
 * @param id
 * @return
 */
void deleteReview(String id);

实现类：

/**
 * 根据评论id删除评论
 *
 * @param id
 * @return
 */
@Override
public void deleteReview(String id) {
    this.reviewRepository.deleteById(id);
}

3.5、根据id查询评论

Controller

• 请求方式：GET

• 请求路径：无

• 请求参数：评论id

• 返回结果：评论对象

/**
 * 根据评论id查询评论
 * @param id
 * @return
 */
@GetMapping("/{id}")
public ResponseEntity<Review> findReviewById(@PathVariable("id") String id){
    Review review = this.commentService.findOne(id);
    if (null == review) return ResponseEntity.notFound().build();
    return ResponseEntity.ok(review);
}

Service

/**
 * 根据评论id查询评论
 * @param id
 * @return
 */
Review findOne(String id);

实现类：

/**
 * 根据评论id查询评论
 *
 * @param id
 * @return
 */
@Override
public Review findOne(String id) {
    Optional<Review> optional = this.reviewRepository.findById(id);
    //判断是否为空
    return optional.orElse(null);
}

3.6、评论点赞

点赞就是让字段thumbup加一，使用MongoTemplate类来实现对某列的操作，不用全部查询出来，那样效率不高。使用自增函数inc实现thumbup加一

使用redis控制同用户不能重复点赞

这里将jwt鉴权相关类和配置引入

Controller

• 请求方式：PUT

• 请求路径：/thumb/{id}

• 请求参数：评论id

• 返回结果：boolean

@Autowired
private StringRedisTemplate redisTemplate;

private final String THUMBUP_PREFIX = "thumbup:";
/**
 * 为评论的点赞数+1
 * @param id
 * @return
 */
@PutMapping("/thumbup/{id}")
public ResponseEntity<Void> updateThumbup(@PathVariable("id") String id){
    //首先判断该用户是否已经点赞
    UserInfo userInfo = LoginInterceptor.getLoginUser();
    String result = this.redisTemplate.opsForValue().get(THUMBUP_PREFIX + userInfo.getId() + "-" + id);
    if (StringUtils.isNotBlank(result)) return ResponseEntity.badRequest().build();
    Boolean flag = this.commentService.updateThumbup(id);
    if (!flag) return ResponseEntity.badRequest().build();
    //redis保存该用户已经点赞的信息
    this.redisTemplate.opsForValue().set(THUMBUP_PREFIX + userInfo.getId() + "-" + id,"1");
    return ResponseEntity.ok().build();
}

Service

/**
 * 为评论的点赞数+1
 * @param id
 * @return
 */
Boolean updateThumbup(String id);

实现类：

/**
 * 为评论的点赞数+1
 *
 * @param id
 * @return
 */
@Override
public Boolean updateThumbup(String id) {
    Query query = new Query();
    query.addCriteria(Criteria.where("_id").is(id));
    Update update = new Update();
    update.inc("thumbup",1);
    UpdateResult result = this.mongoTemplate.updateFirst(query, update, "review");
    return result.wasAcknowledged();
}

3.7、评论访问量

Controller

• 请求方式：PUT

• 请求路径：/visit/{id}

• 请求参数：评论id

• 返回结果：状态码200

当用户点击一个评论查看后请求该接口，将该评论的访问数+1

/**
 * 为评论浏览量+1
 * @param id
 * @return
 */
@PutMapping("/visit/{id}")
public ResponseEntity<Void> updateVisit(@PathVariable("id")String id){
    Boolean flag = this.commentService.updateVisit(id);
    if (!flag) return ResponseEntity.badRequest().build();
    return ResponseEntity.ok().build();
}

Service

/**
 * 为评论浏览量+1
 * @param id
 * @return
 */
Boolean updateVisit(String id);

实现类：

/**
 * 为评论浏览量+1
 *
 * @param id
 * @return
 */
@Override
public Boolean updateVisit(String id) {
    Query query = new Query();
    query.addCriteria(Criteria.where("_id").is(id));
    Update update = new Update();
    update.inc("visits",1);
    UpdateResult result = this.mongoTemplate.updateFirst(query, update, "review");
    return result.wasAcknowledged();
}

四、接口测试

创建测试类：

@RunWith(SpringRunner.class)
@SpringBootTest(classes = LeyouCommentApplication.class)
public class CommentTest {

    @Autowired
    private ReviewRepository reviewRepository;

    /**
     * 为spuId为2的商品添加50条评顶级论数据
     */
    @Test
    public void createReview(){
        for (int i = 0; i < 50; i++) {
            String orderId = "123456789";
            String spuId = "2";
            String content = "华为真不卡"+i;
            String userId = (35 + i) + "";
            String nickname = "username"+i;
            List<String> images = new ArrayList<>();
            boolean iscomment = i % 2 == 0;
            String parentId = 0 + "";
            boolean isparent = true;
            int type = i % 5;
            Review review = new Review(orderId,spuId, content, userId, nickname, images, iscomment, parentId,isparent,type);
            this.reviewRepository.save(review);
        }
    }
}

通过ApiPost工具测试，开启全局cookie功后请求登录接口

4.1、分页查询

4.2、发表评论

数据输入：

{
    "orderid": "123456789",
    "spuid": "2",
    "content": "华为真的不卡",
    "publishtime": null,
    "userid": "35",
    "nickname": "username0",
    "images": [],
    "iscomment": true,
    "parentid": "0",
    "isparent": true,
    "type": 0
}

再次评论：

评论回复

数据输入：

{
    "spuid": "2",
    "content": "是真的！华为真的不卡",
    "userid": "35",
    "nickname": "username1",
    "images": [],
    "iscomment": true,
    "parentid": "611d00af1072831019162bdc",
    "isparent": false,
    "type": -1
}

查询父评论：

4.3、修改评论

4.4、根据id查询评论

通过分页查询获取到之前修改过评论的id：

通过id查询该数据：

4.5、删除评论

删除刚刚的评论

重新查询该评论：

4.6、评论点赞

为id为：611d00af1072831019162bdb的评论点赞

查询该评论

五、服务调用

5.1、订单状态修改

5.1.1、OrderApi

@RequestMapping("/order")
public interface OrderApi {
    /**
     * 更新订单状态
     * @param id
     * @param status
     * @return
     */
    @PutMapping("/{id}/{status}")
    Boolean updateOrderStatus(@PathVariable("id") Long id, @PathVariable("status") Integer status);
}

5.1.2、OrderClient

引入依赖

<dependency>
    <groupId>com.leyou.order</groupId>
    <artifactId>leyou-order-interface</artifactId>
    <version>0.0.1-SNAPSHOT</version>
</dependency>

@FeignClient(value = "order-service")
public interface OrderClient extends OrderApi {
}

5.1.3、CommentServieImpl

在CommentServieImpl中的addReview方法中添加：

标签：return,String,17,--,乐优,db,public,评论,id
来源： https://blog.csdn.net/m0_60551090/article/details/120145629