2024/9/11黑马头条跟学笔记(七)

于 2024-09-11 18:32:17 发布
阅读量856 收藏 10
点赞数 17
分类专栏： java 服务器 spring-boot 文章标签： 笔记 spring boot 微服务 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Zwwxd666/article/details/142147234
版权
java 同时被 3 个专栏收录
25 篇文章 0 订阅
订阅专栏
spring-boot
24 篇文章 0 订阅
订阅专栏
服务器
18 篇文章 0 订阅
订阅专栏

1)今日内容介绍

image-20240910192910797

搜索结果，搜索记录，搜索联想

image-20240910193224853

搭建环境

索引，存储，分词

多条件复合查询

结果高亮处理

索引数据同步（文章发布后创建索引 kafka）

搭建mongodb，存储链和性能好过mysql

异步保存搜索历史

查看搜索历史列表

联想词初始化 ，来源

2)Es环境搭建

2.1)镜像拉取

docker pull elasticsearch:7.4.0

2.2)创建容器

docker run -id --name elasticsearch -d --restart=always -p 9200:9200 -p 9300:9300 -v /usr/share/elasticsearch/plugins:/usr/share/elasticsearch/plugins -e "discovery.type=single-node" elasticsearch:7.4.0

2.3)配置中文分词器

创建容器时映射了目录，自动创建出来了，我们在plugins目录下配置分词器，版本需对应

#切换目录
cd /usr/share/elasticsearch/plugins
#新建目录并进入
mkdir analysis-ik && cd analysis-ik
#移动文件
mv /root/elasticsearch-analysis-ik-7.4.0.zip /usr/share/elasticsearch/plugins/analysis-ik
#解压文件
cd /usr/share/elasticsearch/plugins/analysis-ik && unzip elasticsearch-analysis-ik-7.4.0.zip

2.4)postman测试

{
    "analyzer":"ik_max_word",
    "text":"欢迎来到黑马程序员学习"
}

image-20240910195219401

3)app端文章搜索

3.1)需求说明

image-20240910195448318

搜索出结果后展示，搜索的词与匹配的关键词高亮，点击后能查看文章的详情

3.2)思路分析

image-20240910195630394

  • 审核成功存es
  • 用户搜索查询es库，展示文章列表

3.3)创建索引和映射

image-20240910195859587

展示内容

标题，布局，封面，发布时间，作者， （文章作者id，和静态url不显示）

索引分词内容

标题和内容

3.3.1)映射表

java的实体类

image-20240910200124398

3.3.2)创建映射表

http://192.168.233.136:9200/app_info_article

请求体

{
    "mappings":{
        "properties":{
            "id":{
                "type":"long"
            },
            "publishTime":{
                "type":"date"
            },
            "layout":{
                "type":"integer"
            },
            "images":{
                "type":"keyword",
                "index": false
            },
            "staticUrl":{
                "type":"keyword",
                "index": false
            },
            "authorId": {
                "type": "long"
            },
            "authorName": {
                "type": "text"
            },
            "title":{
                "type":"text",
                "analyzer":"ik_smart"
            },
            "content":{
                "type":"text",
                "analyzer":"ik_smart"
            }
        }
    }
}

image-20240910201245595

3.3.3)GET查询所有映射

GET请求查询映射：http://192.168.233.136:9200/app_info_article

DELETE请求，删除索引及映射：http://192.168.233.136:9200/app_info_article

GET请求，查询所有文档：http://192.168.233.136:9200/app_info_article/_search

image-20240910201722470

3.4)初始化索引库数据

3.4.1)导入es-init初始化模块

image-20240910203251513
依赖

版本要和镜像容器版本一致

<!--elasticsearch-->
        <dependency>
            <groupId>org.elasticsearch.client</groupId>
            <artifactId>elasticsearch-rest-high-level-client</artifactId>
            <version>7.4.0</version>
        </dependency>
        <dependency>
            <groupId>org.elasticsearch.client</groupId>
            <artifactId>elasticsearch-rest-client</artifactId>
            <version>7.4.0</version>
        </dependency>
        <dependency>
            <groupId>org.elasticsearch</groupId>
            <artifactId>elasticsearch</artifactId>
            <version>7.4.0</version>
        </dependency>
配置类

image-20240910203613748

通过配置文件注入

ip不一致得来这里改吧改吧

image-20240910203702553

image-20240910203754956
mapper

image-20240910204024876

查询三张表，要求是上架和未删除的文章

pojo

对应上es映射中的所有字段

image-20240910204104189

3.4.2)查询所有的文章信息，批量导入到es索引库中

package com.heima.es;

import com.alibaba.fastjson.JSON;
import com.heima.es.mapper.ApArticleMapper;
import com.heima.es.pojo.SearchArticleVo;
import org.elasticsearch.action.bulk.BulkRequest;
import org.elasticsearch.action.index.IndexRequest;
import org.elasticsearch.client.RequestOptions;
import org.elasticsearch.client.RestHighLevelClient;
import org.elasticsearch.common.xcontent.XContentType;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

import java.util.List;


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

    @Autowired
    private ApArticleMapper apArticleMapper;

    @Autowired
    private RestHighLevelClient restHighLevelClient;


    /**
     * 注意：数据量的导入，如果数据量过大，需要分页导入
     * @throws Exception
     */
    @Test
    public void init() throws Exception {

        //1.查询所有符合条件的文章数据
        List<SearchArticleVo> searchArticleVos = apArticleMapper.loadArticleList();

        //2.批量导入到es索引库

            BulkRequest bulkRequest = new BulkRequest("app_info_article");

        for (SearchArticleVo searchArticleVo : searchArticleVos) {

            IndexRequest indexRequest = new IndexRequest().id(searchArticleVo.getId().toString())
                    .source(JSON.toJSONString(searchArticleVo), XContentType.JSON);

            //批量添加数据
            bulkRequest.add(indexRequest);

        }
        restHighLevelClient.bulk(bulkRequest, RequestOptions.DEFAULT);

    }

}

  1. 查所有文章

  2. 指定大批导入请求的索引库名称

  3. 循环创建索引index，和对应的文档信息source（存储的是json格式需转一下，当然文章id也得从Long类型转为string）

  4. 构建好请求之后批量添加数据（感觉有点像jdbc还是什么的数据库连接池，存放多条statement最后在一次性传输过去）

  5. 最后调用bulk方法，传递大批请求传递到es索引库，后面的常量类型值无所谓

再次发送请求查看索引库的值
image-20240910210840316

导入了40条数据

3.5)搜索微服务创建

步骤

3.5.1）导入工程
image-20240910211626953

记得修改配置文件的IP地址

image-20240910212209983

3.5.2）nacos添加服务
spring:
  autoconfigure:
    exclude: org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration
elasticsearch:
  host: 192.168.233.136
  port: 9200
接口搜索定义

​

image-20240910211303209

最小时间和前面 分页的那玩意差不多应该

dtos
image-20240910215334402 
package com.heima.model.search.dtos;

import lombok.Data;

import java.util.Date;


@Data
public class UserSearchDto {

    /**
    * 搜索关键字
    */
    String searchWords;
    /**
    * 当前页
    */
    int pageNum;
    /**
    * 分页条数
    */
    int pageSize;
    /**
    * 最小时间
    */
    Date minBehotTime;

    public int getFromIndex(){
        if(this.pageNum<1)return 0;
        if(this.pageSize<1) this.pageSize = 10;
        return this.pageSize * (pageNum-1);
    }
}
service
package com.heima.search.service;

import com.heima.model.common.dtos.ResponseResult;
import com.heima.model.search.dtos.UserSearchDto;
import org.springframework.web.bind.annotation.RequestBody;

import java.io.IOException;

public interface ArticleSearchService {
    /**
     * 文章分页检索
     * @param dto
     * @return
     */
    public ResponseResult search( UserSearchDto dto) ;
}
impl

实现思路

  1. 参数校验
  2. 查询条件
    • 关键词分词之后查询
    • 小于mindate数据
    • 分页查询
    • 时间降序
    • 设置高亮title
  3. 结果封装返回
package com.heima.search.service.impl;

import com.alibaba.fastjson.JSON;
import com.heima.model.common.dtos.ResponseResult;
import com.heima.model.common.enums.AppHttpCodeEnum;
import com.heima.model.search.dtos.UserSearchDto;
import com.heima.model.user.pojos.ApUser;
import com.heima.search.service.ApUserSearchService;
import com.heima.search.service.ArticleSearchService;
import com.heima.utils.thread.AppThreadLocalUtil;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.elasticsearch.action.search.SearchRequest;
import org.elasticsearch.action.search.SearchResponse;
import org.elasticsearch.client.RequestOptions;
import org.elasticsearch.client.RestHighLevelClient;
import org.elasticsearch.common.text.Text;
import org.elasticsearch.index.query.*;
import org.elasticsearch.search.SearchHit;
import org.elasticsearch.search.builder.SearchSourceBuilder;
import org.elasticsearch.search.fetch.subphase.highlight.HighlightBuilder;
import org.elasticsearch.search.sort.SortOrder;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;

@Service
@Slf4j
public class ArticleSearchServiceImpl implements ArticleSearchService {

    @Autowired
    private RestHighLevelClient restHighLevelClient;

    @Autowired
    private ApUserSearchService apUserSearchService;

    /**
     * es文章分页检索
     *
     * @param dto
     * @return
     */
    @Override
    public ResponseResult search(UserSearchDto dto) throws IOException {

        //1.检查参数
        if(dto == null || StringUtils.isBlank(dto.getSearchWords())){
            return ResponseResult.errorResult(AppHttpCodeEnum.PARAM_INVALID);
        }

        ApUser user = AppThreadLocalUtil.getUser();

        //异步调用 保存搜索记录
        if(user != null && dto.getFromIndex() == 0){
            apUserSearchService.insert(dto.getSearchWords(), user.getId());
        }


        //2.设置查询条件
        SearchRequest searchRequest = new SearchRequest("app_info_article");
        SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();

        //布尔查询
        BoolQueryBuilder boolQueryBuilder = QueryBuilders.boolQuery();

        //关键字的分词之后查询
        QueryStringQueryBuilder queryStringQueryBuilder = QueryBuilders.queryStringQuery(dto.getSearchWords()).field("title").field("content").defaultOperator(Operator.OR);
        boolQueryBuilder.must(queryStringQueryBuilder);

        //查询小于mindate的数据
        RangeQueryBuilder rangeQueryBuilder = QueryBuilders.rangeQuery("publishTime").lt(dto.getMinBehotTime().getTime());
        boolQueryBuilder.filter(rangeQueryBuilder);

        //分页查询
        searchSourceBuilder.from(0);
        searchSourceBuilder.size(dto.getPageSize());

        //按照发布时间倒序查询
        searchSourceBuilder.sort("publishTime", SortOrder.DESC);

        //设置高亮  title
        HighlightBuilder highlightBuilder = new HighlightBuilder();
        highlightBuilder.field("title");
        highlightBuilder.preTags("<font style='color: red; font-size: inherit;'>");
        highlightBuilder.postTags("</font>");
        searchSourceBuilder.highlighter(highlightBuilder);


        searchSourceBuilder.query(boolQueryBuilder);
        searchRequest.source(searchSourceBuilder);
        SearchResponse searchResponse = restHighLevelClient.search(searchRequest, RequestOptions.DEFAULT);


        //3.结果封装返回

        List<Map> list = new ArrayList<>();

        SearchHit[] hits = searchResponse.getHits().getHits();
        for (SearchHit hit : hits) {
            String json = hit.getSourceAsString();
            Map map = JSON.parseObject(json, Map.class);
            //处理高亮
            if(hit.getHighlightFields() != null && hit.getHighlightFields().size() > 0){
                Text[] titles = hit.getHighlightFields().get("title").getFragments();
                String title = StringUtils.join(titles);
                //高亮标题
                map.put("h_title",title);
            }else {
                //原始标题
                map.put("h_title",map.get("title"));
            }
            list.add(map);
        }

        return ResponseResult.okResult(list);

    }
}

思路

  1. 前面就设置一堆前置条件
  2. key命中了分词后的数据时，如果该字段为高亮字段，获取其片段，组装font标签高亮返回前端
接口
package com.heima.search.controller.v1;

import com.heima.model.common.dtos.ResponseResult;
import com.heima.model.search.dtos.UserSearchDto;
import com.heima.search.service.ArticleSearchService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.io.IOException;

@RestController
@RequestMapping("/api/v1/article/search")
public class ArticleSearchController {


    @Autowired
    private ArticleSearchService articleSearchService;

    @PostMapping("/search")
    public ResponseResult search(@RequestBody UserSearchDto dto) throws IOException {
        return articleSearchService.search(dto);
    }
}
app网关的nacos

image-20240911000516382

#搜索微服务
- id: leadnews-search
 uri: lb://leadnews-search
 predicates:
   - Path=/search/**
 filters:
   - StripPrefix= 1

重启微服务测试

image-20240911000746382

image-20240911135201467

如果出现503错误的话。应该是网关处理异常，

image-20240911135318686

我在这里 #号和 文字中间加了一个空格就好了，然后重启网关服务

3.6）新增文章时分词标题和内容索引

3.6.1）思路分析

image-20240911140256586

文章审核成功时使用kafka发消息 文章微服务作为生产者

搜索微服务接收消息，添加数据到索引库 搜索微服务作为消费者

image-20240911140521482

image-20240911140531655

添加文章，审核通过，在制作静态文件时调用制作vo方法（content和url，其余属性title。。。结合）

然后发消息，搜索服务收消息，指定索引库，保存该索引内容

3.6.2）文章微服务发消息

  1. model/search/pojos创建vo
package com.heima.model.search.vos;

import lombok.Data;

import java.util.Date;

@Data
public class SearchArticleVo {

    // 文章id
    private Long id;
    // 文章标题
    private String title;
    // 文章发布时间
    private Date publishTime;
    // 文章布局
    private Integer layout;
    // 封面
    private String images;
    // 作者id
    private Long authorId;
    // 作者名词
    private String authorName;
    //静态url
    private String staticUrl;
    //文章内容
    private String content;

}
  1. 文章微服务的ArticleFreemarkerService中的buildArticleToMinIO方法中收集数据并发送消息 （因为该方法中有content和path和apArticle）
package com.heima.article.service.impl;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONArray;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.heima.article.mapper.ApArticleContentMapper;
import com.heima.article.service.ApArticleService;
import com.heima.article.service.ArticleFreemarkerService;
import com.heima.common.constants.ArticleConstants;
import com.heima.file.service.FileStorageService;
import com.heima.model.article.pojos.ApArticle;
import com.heima.model.search.vos.SearchArticleVo;
import freemarker.template.Configuration;
import freemarker.template.Template;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.kafka.core.KafkaTemplate;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.io.ByteArrayInputStream;
import java.io.InputStream;
import java.io.StringWriter;
import java.util.HashMap;
import java.util.Map;

@Service
@Slf4j
@Transactional
public class ArticleFreemarkerServiceImpl implements ArticleFreemarkerService {

    @Autowired
    private ApArticleContentMapper apArticleContentMapper;

    @Autowired
    private Configuration configuration;

    @Autowired
    private FileStorageService fileStorageService;

    @Autowired
    private ApArticleService apArticleService;

    /**
     * 生成静态文件上传到minIO中
     * @param apArticle
     * @param content
     */
    @Async
    @Override
    public void buildArticleToMinIO(ApArticle apArticle, String content) {
        //已知文章的id
        //4.1 获取文章内容
        if(StringUtils.isNotBlank(content)){
            //4.2 文章内容通过freemarker生成html文件
            Template template = null;
            StringWriter out = new StringWriter();
            try {
                template = configuration.getTemplate("article.ftl");
                //数据模型
                Map<String,Object> contentDataModel = new HashMap<>();
                contentDataModel.put("content", JSONArray.parseArray(content));
                //合成
                template.process(contentDataModel,out);
            } catch (Exception e) {
                e.printStackTrace();
            }


            //4.3 把html文件上传到minio中
            InputStream in = new ByteArrayInputStream(out.toString().getBytes());
            String path = fileStorageService.uploadHtmlFile("", apArticle.getId() + ".html", in);


            //4.4 修改ap_article表，保存static_url字段
            apArticleService.update(Wrappers.<ApArticle>lambdaUpdate().eq(ApArticle::getId,apArticle.getId())
                    .set(ApArticle::getStaticUrl,path));

            //发送消息，创建索引
            createArticleESIndex(apArticle,content,path);

        }
    }

    @Autowired
    private KafkaTemplate<String,String> kafkaTemplate;

    /**
     * 送消息，创建索引
     * @param apArticle
     * @param content
     * @param path
     */
    private void createArticleESIndex(ApArticle apArticle, String content, String path) {
        SearchArticleVo vo = new SearchArticleVo();
        BeanUtils.copyProperties(apArticle,vo);
        vo.setContent(content);
        vo.setStaticUrl(path);

        kafkaTemplate.send(ArticleConstants.ARTICLE_ES_SYNC_TOPIC, JSON.toJSONString(vo));
    }

}

在ArticleConstants类中添加新的常量，完整代码如下

package com.heima.common.constants;

public class ArticleConstants {
    public static final Short LOADTYPE_LOAD_MORE = 1;
    public static final Short LOADTYPE_LOAD_NEW = 2;
    public static final String DEFAULT_TAG = "__all__";

    public static final String ARTICLE_ES_SYNC_TOPIC = "article.es.sync.topic";

    public static final Integer HOT_ARTICLE_LIKE_WEIGHT = 3;
    public static final Integer HOT_ARTICLE_COMMENT_WEIGHT = 5;
    public static final Integer HOT_ARTICLE_COLLECTION_WEIGHT = 8;

    public static final String HOT_ARTICLE_FIRST_PAGE = "hot_article_first_page_";
}

指定了ARTICLE_ES_SYNC_TOPIC 为文章索引

3.文章微服务集成kafka发送消息

文章服务nacos配置中心添加

image-20240911142953944 
kafka:
    bootstrap-servers: 192.168.233.136:9092
    producer:
      retries: 10
      key-serializer: org.apache.kafka.common.serialization.StringSerializer
      value-serializer: org.apache.kafka.common.serialization.StringSerializer

3.6.3)搜索微服务接收消息并创建索引

  1. 搜索微服务nacos添加如下配置
spring:
  kafka:
    bootstrap-servers: 192.168.233.136:9092
    consumer:
      group-id: ${spring.application.name}
      key-deserializer: org.apache.kafka.common.serialization.StringDeserializer
      value-deserializer: org.apache.kafka.common.serialization.StringDeserializer

2.定义监听接收消息,保存索引数据

建listener包

package com.heima.search.listener;

import com.alibaba.fastjson.JSON;
import com.heima.common.constants.ArticleConstants;
import com.heima.model.search.vos.SearchArticleVo;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.elasticsearch.action.index.IndexRequest;
import org.elasticsearch.client.RequestOptions;
import org.elasticsearch.client.RestHighLevelClient;
import org.elasticsearch.common.xcontent.XContentType;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.kafka.annotation.KafkaListener;
import org.springframework.stereotype.Component;

import java.io.IOException;

@Component
@Slf4j
public class SyncArticleListener {

    @Autowired
    private RestHighLevelClient restHighLevelClient;

    @KafkaListener(topics = ArticleConstants.ARTICLE_ES_SYNC_TOPIC)
    public void onMessage(String message){
        if(StringUtils.isNotBlank(message)){

            log.info("SyncArticleListener,message={}",message);

            SearchArticleVo searchArticleVo = JSON.parseObject(message, SearchArticleVo.class);
            IndexRequest indexRequest = new IndexRequest("app_info_article");
            indexRequest.id(searchArticleVo.getId().toString());
            indexRequest.source(message, XContentType.JSON);
            try {
                restHighLevelClient.index(indexRequest, RequestOptions.DEFAULT);
            } catch (IOException e) {
                e.printStackTrace();
                log.error("sync es error={}",e);
            }
        }

    }
}

指定topic，参数校验，指定索引库名，索引id，索引值，发送添加索引

3.6.4）启动微服务测试

image-20240911143909742

image-20240911144741883

​

image-20240911144754428 image-20240911144815487

3.7）搜索记录

3.7.1需求

image-20240911145023000

展示搜索记录十条，时间降序排列，可删除，保存10条历史记录，多余删除

3.7.2springboot集成

镜像拉取

docker pull mongo

创建容器

docker run -di --name mongo-service --restart=always -p 27017:27017 -v ~/data/mongodata:/data mongo

导模块包

image-20240911152310481

依赖

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

配置文件

server:
  port: 9998
spring:
  data:
    mongodb:
      host: 192.168.233.136
      port: 27017
      database: leadnews-history

映射

package com.itheima.mongo.pojo;

import lombok.Data;
import org.springframework.data.mongodb.core.mapping.Document;

import java.io.Serializable;
import java.util.Date;

/**
 * <p>
 * 联想词表
 * </p>
 *
 * @author itheima
 */
@Data
@Document("ap_associate_words")
public class ApAssociateWords implements Serializable {

    private static final long serialVersionUID = 1L;

    private String id;

    /**
     * 联想词
     */
    private String associateWords;

    /**
     * 创建时间
     */
    private Date createdTime;

}

指定好了database（库）和document文档（表）后teset插入

3.7.3核心方法

package com.itheima.mongo.test;


import com.itheima.mongo.MongoApplication;
import com.itheima.mongo.pojo.ApAssociateWords;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
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 org.springframework.test.context.junit4.SpringRunner;

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

@SpringBootTest(classes = MongoApplication.class)
@RunWith(SpringRunner.class)
public class MongoTest {


    @Autowired
    private MongoTemplate mongoTemplate;

    //保存
    @Test
    public void saveTest(){
        /*for (int i = 0; i < 10; i++) {
            ApAssociateWords apAssociateWords = new ApAssociateWords();
            apAssociateWords.setAssociateWords("黑马头条");
            apAssociateWords.setCreatedTime(new Date());
            mongoTemplate.save(apAssociateWords);
        }*/
        ApAssociateWords apAssociateWords = new ApAssociateWords();
        apAssociateWords.setAssociateWords("黑马直播");
        apAssociateWords.setCreatedTime(new Date());
        mongoTemplate.save(apAssociateWords);

    }

    //查询一个
    @Test
    public void saveFindOne(){
        ApAssociateWords apAssociateWords = mongoTemplate.findById("60bd973eb0c1d430a71a7928", ApAssociateWords.class);
        System.out.println(apAssociateWords);
    }

    //条件查询
    @Test
    public void testQuery(){
        Query query = Query.query(Criteria.where("associateWords").is("黑马头条"))
                .with(Sort.by(Sort.Direction.DESC,"createdTime"));
        List<ApAssociateWords> apAssociateWordsList = mongoTemplate.find(query, ApAssociateWords.class);
        System.out.println(apAssociateWordsList);
    }

    @Test
    public void testDel(){
        mongoTemplate.remove(Query.query(Criteria.where("associateWords").is("黑马头条")),ApAssociateWords.class);
    }
}

自行尝试crud

依赖，配置，映射，调用核心方法

3.8）保存搜索记录

image-20240911153134911

image-20240911153250680

用户输入关键字进行搜索的异步记录关键字

image-20210709154053892

搜索时，查搜索记录，如果已存在，更新为最新时间，不存在，查看总的数据量，大于10干掉最古老的一条，确保永远是最近的记录呈现

3.8.1）实现步骤

1.搜索微服务集成mongodb

①：pom依赖

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

②：nacos配置（在search下添加）

spring:
  data:
   mongodb:
    host: 192.168.233.136
    port: 27017
    database: leadnews-history

③：实体类

放在search下的pojos而非model下

package com.heima.search.pojos;

import lombok.Data;
import org.springframework.data.mongodb.core.mapping.Document;

import java.io.Serializable;
import java.util.Date;

/**
 * <p>
 * APP用户搜索信息表
 * </p>
 * @author itheima
 */
@Data
@Document("ap_user_search")
public class ApUserSearch implements Serializable {

    private static final long serialVersionUID = 1L;

    /**
     * 主键
     */
    private String id;

    /**
     * 用户ID
     */
    private Integer userId;

    /**
     * 搜索词
     */
    private String keyword;

    /**
     * 创建时间
     */
    private Date createdTime;

}

④：导入sql脚本
右下角选为* 否则不显示

image-20240911155804818

2.创建ApUserSearchService新增insert方法
service

参数：1搜索记录 2谁搜的，后期展示

当前方法为Articlesearch调用，其keyword包含在userSearchDto中

image-20240911160105951 
public interface ApUserSearchService {

    /**
     * 保存用户搜索历史记录
     * @param keyword
     * @param userId
     */
    public void insert(String keyword,Integer userId);
}
impl

思路

这种远程调用一般都是用了spring集成的 template进行crud，redis，和elasticSearch和kafka都是如此

1.查记录是否存在
构建查询条件 条件为 当前用户，记录
2.存在则更新最新时间
3.不存在就新增，判断总记录有无大于10
初始化记录
初始化查询条件

package com.heima.search.service.impl;

import com.heima.search.pojos.ApUserSearch;
import com.heima.search.service.ApUserSearchService;
import lombok.extern.slf4j.Slf4j;
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 org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;

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

@Service
@Slf4j
public class ApUserSearchServiceImpl implements ApUserSearchService {

    @Autowired
    private MongoTemplate mongoTemplate;

    /**
     * 保存用户搜索历史记录
     *
     * @param keyword
     * @param userId
     */
    @Override
    @Async
    public void insert(String keyword, Integer userId) {
        // 1.查记录是否存在
        // 构建查询条件 条件为 当前用户，记录
        Query query = Query.query(Criteria.where("userId").is(userId).and("keyword").is(keyword));
        ApUserSearch apUserSearch = mongoTemplate.findOne(query, ApUserSearch.class);
        // 2.存在则更新最新时间
        if (apUserSearch != null) {
            apUserSearch.setCreatedTime(new Date());
            mongoTemplate.save(apUserSearch);
            return;
        }
        // 3.不存在就新增，判断总记录有无大于10
        // 初始化记录
        apUserSearch = new ApUserSearch();
        apUserSearch.setUserId(userId);
        apUserSearch.setCreatedTime(new Date());
        apUserSearch.setKeyword(keyword);
        // 初始化查询条件
        Query query1 = Query.query(Criteria.where("userId").is(userId));
        query1.with(Sort.by(Sort.Direction.DESC, "createdTime"));
        List<ApUserSearch> apUserSearches = mongoTemplate.find(query1, ApUserSearch.class);
        if (apUserSearches==null||apUserSearches.size() < 10) {
            mongoTemplate.save(apUserSearch);
        } else {
            //不小于10那就替换
            // 先查出来到数第一个，然后获取id调用替换方法
            ApUserSearch userSearch = apUserSearches.get(apUserSearches.size() - 1);
            mongoTemplate.findAndReplace(Query.query(Criteria.where("id").is(userSearch.getId())),apUserSearch);
        }
    }
}

ok搞完了，接下来就是让别人来调用该方法了

3.搜索微服务获取当前用户

模仿wmedia中的获取用户id，（）

之前存素材库和查询文章的时候用到过

具体做法是，网关请求头设置user，转发给服务时请求拦截器拦截获取，设置到全局线程，当请求结束后清理线程

image-20240911163647279

同样的我们给他设置到app的网关headers

image-20240911163916284 
//获取用户id
            Object userId = claimsBody.get("id");
            //将用户id放到请求头中
            // request.mutate()：创建一个请求的副本，以便对其进行修改。
            // headers(httpHeaders -> { ... })：提供一个函数，用于修改请求头。httpHeaders是一个HttpHeaders对象，表示请求头。
            // httpHeaders.add("userId", userId.toString())：向请求头中添加一个名为userId的字段，其值为userId变量的字符串表示。
            // build()：构建修改后的请求。
            ServerHttpRequest httpRequest = request.mutate().headers(httpHeaders -> {
                httpHeaders.add("userId",userId.toString());
            }).build();
            // 1. 更新请求信息
            // 在处理请求时，您可能需要在请求头中添加或修改某些信息（例如用户 ID）。
            // 通过重置请求，您确保后续的处理逻辑（如过滤器、拦截器或控制器）能够获取到这些更新后的请求头。
            exchange.mutate().request(httpRequest);
拦截器appInterceptor

image-20240911164353629

package com.heima.search.interceptor;

import com.heima.model.user.pojos.ApUser;
import com.heima.utils.thread.AppThreadLocalUtil;
import org.springframework.web.servlet.HandlerInterceptor;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

public class AppTokenInterceptor implements HandlerInterceptor {

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        String userId = request.getHeader("userId");
        if(userId != null){
            //存入到当前线程中
            ApUser apUser = new ApUser();
            apUser.setId(Integer.valueOf(userId));
            AppThreadLocalUtil.setUser(apUser);

        }
        return true;
    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        AppThreadLocalUtil.clear();
    }
}

这里的拦截器和wmInterceptor不同之处是之前postHandler那个在 controller抛异常后不会清理

而afterCom… 抛异常后仍清理，这里我们切换为这种模式

image-20240911164927136
webmvcConfig注册拦截器
package com.heima.search.config;


import com.heima.search.interceptor.AppTokenInterceptor;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

@Configuration
public class WebMvcConfig implements WebMvcConfigurer {
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(new AppTokenInterceptor()).addPathPatterns("/**");
    }
}
appThreadUtil
package com.heima.utils.thread;

import com.heima.model.user.pojos.ApUser;

public class AppThreadLocalUtil {

    private final static ThreadLocal<ApUser> WM_USER_THREAD_LOCAL = new ThreadLocal<>();

    //存入线程中
    public static void setUser(ApUser apUser){
        WM_USER_THREAD_LOCAL.set(apUser);
    }

    //从线程中获取
    public static ApUser getUser(){
        return WM_USER_THREAD_LOCAL.get();
    }

    //清理
    public static void clear(){
        WM_USER_THREAD_LOCAL.remove();
    }

}

4.search方法顺便把记录save了

image-20240911165317465

注入并调用

   @Autowired
    private ApUserSearchService apUserSearchService;
ApUser user = AppThreadLocalUtil.getUser();
        if (user!=null&&dto.getFromIndex()==0){
        apUserSearchService.insert(dto.getSearchWords(), AppThreadLocalUtil.getUser().getId());
        }

getFromIndex()为0意思是搜索完结果会跳转到首页，

之后每切换一页都会进行search查询，切换页面说明用户已经查到结果了，不需要search

5.保存历史记录异步注解，引导类开启注解

image-20240911170803399

6.测试，搜索后查看结果

我们修改了search微服务和app网关，重启这俩即可

image-20240911171257889

搜索同样的搜索记录，查看时间有无更新

image-20240911172250598

我们搜索超过10条，看下最老的那条有没有被替换

image-20240911172713273

3.9）搜索历史加载

3.9.1）思路分析

image-20240911173231241

根据用户id，降序查询

3.9.2）业务层

在ApUserSearchService中新增方法

/**
     查询搜索历史
     @return
     */
ResponseResult findUserSearch();

impl

 /**
     * 查询搜索历史
     *
     * @return
     */
@Override
public ResponseResult findUserSearch() {
    //获取当前用户
    ApUser user = AppThreadLocalUtil.getUser();
    if(user == null){
        return ResponseResult.errorResult(AppHttpCodeEnum.NEED_LOGIN);
    }

    //根据用户查询数据，按照时间倒序
    List<ApUserSearch> apUserSearches = mongoTemplate.find(Query.query(Criteria.where("userId").is(user.getId())).with(Sort.by(Sort.Direction.DESC, "createdTime")), ApUserSearch.class);
    return ResponseResult.okResult(apUserSearches);
}

判断user不为空的目的是 有游客登录的可能

3.9.3）controller

/**
 * <p>
 * APP用户搜索信息表 前端控制器
 * </p>
 * @author itheima
 */
@Slf4j
@RestController
@RequestMapping("/api/v1/history")
public class ApUserSearchController{

    @Autowired
    private ApUserSearchService apUserSearchService;

    @PostMapping("/load")
    public ResponseResult findUserSearch() {
        return apUserSearchService.findUserSearch();
    }

}

3.9.4）测试

image-20240911174007578

3.10）删除历史搜索记录

image-20240911174101216

dto

@Data
public class HistorySearchDto {
    /**
    * 接收搜索历史记录id
    */
    String id;
}

业务层

service

 /**
     删除搜索历史
     @param historySearchDto
     @return
     */
ResponseResult delUserSearch(HistorySearchDto historySearchDto);

impl

/**
     * 删除历史记录
     *
     * @param dto
     * @return
     */
@Override
public ResponseResult delUserSearch(HistorySearchDto dto) {
    //1.检查参数
    if(dto.getId() == null){
        return ResponseResult.errorResult(AppHttpCodeEnum.PARAM_INVALID);
    }

    //2.判断是否登录
    ApUser user = AppThreadLocalUtil.getUser();
    if(user == null){
        return ResponseResult.errorResult(AppHttpCodeEnum.NEED_LOGIN);
    }

    //3.删除
    mongoTemplate.remove(Query.query(Criteria.where("userId").is(user.getId()).and("id").is(dto.getId())),ApUserSearch.class);
    return ResponseResult.okResult(AppHttpCodeEnum.SUCCESS);
}

controller

@PostMapping("/del")
public ResponseResult delUserSearch(@RequestBody HistorySearchDto historySearchDto) {
    return apUserSearchService.delUserSearch(historySearchDto);
}

小提问

image-20240911174652386

为什么这个方法不能用线程获取id？ 异步进程无线程记录，其为新线程

测测测

image-20240911175025170

3.11）关键字联想词

b友发言

es是点击后搜索才用，联想词是自动展示可能需要的词语

老师这个是先用mongoDB查询到你想搜索的词条，之后再发送给es的查询接口进行分词查询。直接用es也有实现方案，可以自己去了解一下

3.11.1）需求分析

image-20240911175834142

3.11.2）联想词数据来源

image-20240911175935855

这里我们用黑马提供的长尾词

image-20240911182042088

3.11.3）所需类

实体
package com.heima.search.pojos;

import lombok.Data;
import org.springframework.data.mongodb.core.mapping.Document;

import java.io.Serializable;
import java.util.Date;

/**
 * <p>
 * 联想词表
 * </p>
 *
 * @author itheima
 */
@Data
@Document("ap_associate_words")
public class ApAssociateWords implements Serializable {

    private static final long serialVersionUID = 1L;

    private String id;

    /**
     * 联想词
     */
    private String associateWords;

    /**
     * 创建时间
     */
    private Date createdTime;

}
业务层
service
package com.heima.search.service;

import com.heima.model.common.dtos.ResponseResult;
import com.heima.model.search.dtos.UserSearchDto;

/**
 * <p>
 * 联想词表 服务类
 * </p>
 *
 * @author itheima
 */
public interface ApAssociateWordsService {

    /**
     联想词
     @param userSearchDto
     @return
     */
    ResponseResult findAssociate(UserSearchDto userSearchDto);

}
impl
package com.heima.search.service.impl;

import com.heima.model.common.dtos.ResponseResult;
import com.heima.model.common.enums.AppHttpCodeEnum;
import com.heima.model.search.dtos.UserSearchDto;
import com.heima.search.pojos.ApAssociateWords;
import com.heima.search.service.ApAssociateWordsService;
import org.apache.commons.lang3.StringUtils;
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.stereotype.Service;

import java.util.List;

/**
 * @Description:
 * @Version: V1.0
 */
@Service
public class ApAssociateWordsServiceImpl implements ApAssociateWordsService {

    @Autowired
    MongoTemplate mongoTemplate;

    /**
     * 联想词
     * @param userSearchDto
     * @return
     */
    @Override
    public ResponseResult findAssociate(UserSearchDto userSearchDto) {
        //1 参数检查
        if(userSearchDto == null || StringUtils.isBlank(userSearchDto.getSearchWords())){
            return ResponseResult.errorResult(AppHttpCodeEnum.PARAM_INVALID);
        }
        //分页检查
        if (userSearchDto.getPageSize() > 20) {
            userSearchDto.setPageSize(20);
        }

        //3 执行查询 模糊查询
        Query query = Query.query(Criteria.where("associateWords").regex(".*?\\" + userSearchDto.getSearchWords() + ".*"));
        query.limit(userSearchDto.getPageSize());
        List<ApAssociateWords> wordsList = mongoTemplate.find(query, ApAssociateWords.class);

        return ResponseResult.okResult(wordsList);
    }
}
  1. Query.query(...):
    • 这是创建一个查询对象的方法。
  2. Criteria.where("associateWords"):
    • 这里指定了查询的字段名，即 "associateWords"。查询将会在这个字段中查找匹配的记录。
  3. .regex(...):
    • 这个方法用于指定一个正则表达式，用于匹配 associateWords 字段中的内容。
  4. ".\*?\" + userSearchDto.getSearchWords() + ".\*":
    • 这是构建的正则表达式。
    • .*? 表示可以匹配任意字符（包括零个字符），? 表示尽可能少地匹配（非贪婪模式）。
    • userSearchDto.getSearchWords() 是从 userSearchDto 对象中获取的用户搜索词。
    • 整个表达式的意思是匹配包含用户搜索词的字符串。
  5. "\\":
    • 这个双反斜杠是为了在字符串中正确转义字符，确保在正则表达式中将用户输入的特殊字符（如果有的话）处理正确。
controller
package com.heima.search.controller.v1;

import com.heima.model.common.dtos.ResponseResult;
import com.heima.model.search.dtos.UserSearchDto;
import com.heima.search.service.ApAssociateWordsService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

/**
 * <p>
 * 联想词表 前端控制器
 * </p>
 * @author itheima
 */
@Slf4j
@RestController
@RequestMapping("/api/v1/associate")
public class ApAssociateWordsController{

    @Autowired
    private ApAssociateWordsService apAssociateWordsService;

    @PostMapping("/search")
    public ResponseResult findAssociate(@RequestBody UserSearchDto userSearchDto) {
        return apAssociateWordsService.findAssociate(userSearchDto);
    }
}
重启测试

image-20240911182931045

Zww0891
关注
  • 17
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
2024/9/4黑马头条跟学笔记(二)
Zwwxd666的博客
09-04 958
​​​​​​​模板引擎模板+数据生成HTML模板编写全拼为 freemarker template language FTL常见java模板引擎jsp（javaWeb里的servlet，前后端不分离），freemarker 好，快thymeleaf 好，但慢velocity 不好作为springmvc视图格式，且支持渲染视图开源，保存大空间单行命令运行支持云存储迁移接口，可控大小。
2024/9/6黑马头条跟学笔记(四)
Zwwxd666的博客
09-07 1170
D4内容介绍 阿里三方安全审核 分布式主键 异步调用 feign 熔断降级 1.自媒体文章自动审核 1.1审核流程 查文章——调接口文本审核——minio下载图片图片审核——审核通过保存文章——发布 草稿1，失败2，人工3，发布9 1.2接口获取 注册阿里云，开通内容安全 获取akey和skey 1.3文本内容审核接口 文本垃圾内容检测：https://help.aliyun.com/document_detail/70439.html?spm=a2c4g.11186623.6.659.35ac
2024/9/3黑马头条跟学笔记(一)
Zwwxd666的博客
09-03 1602
D1 视频链接 Day1-05-nacos环境搭建_哔哩哔哩_bilibili 内容介绍 搭建微服务开发环境，登录接口包含注册中心和nacos配置中心 服务端用户…微服务。网关负载均衡转发接口请求 实现微服务间互相通信 接口测试 前后端联调 前置知识 背景介绍 类似今日头条，qq看点 功能架构图 用户前台，内容浏览，登录注册。。。类似于看小说的人 用户后台，内容发布，私信管理。。。类似于小说家 超级管理员后台，对所有作者，其发布内容管理，类似于上帝 效果预览 用户群众 用户，吃瓜
2024/9/6黑马头条跟学笔记(三)
Zwwxd666的博客
09-06 1451
D3 内容介绍 jdk8新特性，stream流，lambda表达式 ​ 自媒体前后端搭建 步骤 sql—— 实体—— 微服务拷贝，配置nacos—— spring: datasource: driver-class-name: com.mysql.jdbc.Driver url: jdbc:mysql://192.168.233.136:3306/leadnews_wemedia?useUnicode=true&characterEncoding=UTF-8&se
黑马头条项目开发笔记111111
01-28
DAY1讲义
黑马头条笔记记录
hdjnd的博客
07-22 145
黑马头条学习笔记
黑马头条项目笔记黑马头条项目笔记
08-27
黑马头条项目笔记是针对黑马程序员头条项目的学习笔记。这个项目通常是作为Android应用开发的学习实践，旨在通过开发一个具有新闻阅读功能的移动应用来加深对Android应用开发技术的理解和应用。在黑马头条项目笔记中...
基于黑马和尚硅谷视频的SSM框架学习笔记
03-28
这是一个基于黑马和尚硅谷视频的SSM框架学习笔记，主要使用Java语言编写，同时包含JavaScript和CSS文件。项目包含100个文件，其中主要文件类型包括78个PNG图片文件、12个Markdown文档、3个JPG图片文件、3个CSS文件、...
黑马头条测试
qq_43431863的博客
02-16 1796
项目介绍 项目简介 功能架构 前端功能 后端功能 技术架构 负载均衡 消息列队 应用场景 测试功能模块 待测功能模块 文章发布流程 新建文章（自媒体端） 审核文章（后台管理系统） 查看文章（APP端） UI自动化测试 Selenium Grid介绍-实现分布式执行测试用例 1.1 Selenium Grid工作原理 Selenium Grid环境部署 安装包地址 启动主控服务-Hub 1）进入命令行窗口 cmd 2)切换到.
STM32学习笔记（二、初识stm32单片机）
tommorrowwill的博客
09-10 557
首先stm32是意法半导体公司（ST）使用ARM公司的Cortex-M为核心生产的32位的单片机。其中，ST---意法半导体公司，即SOC厂商。M---为Microelectronics的缩写，即微型处理器。32---表示控制器为32位的。103---表示F系列的子系列。
维度不固定的多维数组形参笔记
H2z1220的博客
09-05 214
假如我有多个元素个数都不一致的多维数组都需要调用这个函数进行处理，这个形参问题就凸显出来了，总不能创建N个不同的函数来进行处理吧？这样也太繁琐了，而且也适用度不高。这个函数可以传入多维数组，但元素个数必须是固定的，假如传入一个str[][20]，元素个数不一样的数组，那么这个函数就不适用了，且会报错。所有数据在存储空间里面都是有地址的，那么就可利用指针寻址来获取到相应的数据。在查找了一些资料后受到了一点启发。而这里也可利用指针来指向多维数组。
【机器人工具箱Robotics Toolbox开发笔记（十）】机器人微分运动学
m0_72676510的博客
09-07 288
机器人工具箱中，可用函数SerialLink.jacob0（）求出对应某个位姿下绝对坐标系中的雅可比矩阵，用SerialLink.jacobn（）求出对应某个位姿下工具坐标系中的雅可比矩阵。
【C++学习笔记】数组与指针（三）
qq_38196449的博客
09-09 1127
0（空字符）
C++学习笔记（10）
qq_60098634的博客
09-07 671
unordered_multimap 和 unordered_map 的区别在：unordered_multimap 允许关键字重复，而。unordered_multiset 和 unordered_set 的区别在：unordered_multiset 允许关键字重复，而。
sheng的学习笔记-AI-规则学习（rule learning）
coldstarry的专栏
09-09 834
机器学习中的“规则”(rule)通常是指语义明确、能描述数据分布所隐含的客观规律或领域概念、可写成“若……，则……”形式的逻辑规则。​“规则学习”(rule learning)是从训练数据中学习出一组能用于对未见示例进行判别的规则。一条规则形如：在数理逻辑中“文字”专指原子公式(atom)及其否定。与神经网络、支持向量机这样的“黑箱模型”相比，规则学习具有更好的可解释性，能使用户更直观地对判别过程有所了解。另一方面，数理逻辑具有极强的表达能力，绝大多数人类知识都能通过数理逻辑进行简洁的刻画和表达。
区块链学习笔记2--区块链技术的形成 以太坊
最新发布
weixin_61074128的博客
09-10 234
以太坊的定义：以太坊是运行在一个计算机网络中的软件，他确保数据以及智能合约的小程序可以在没有宗信协调者的情况下，被所有网络中的计算机复制和处理。以太坊的改进： 交易速度加快；pow+pos算法，逐步向pos算法过渡；智能合约：不受人为因素影响，没有黑幕；比特币的出现让经济贸易变得简单，而比特币系统的不足，也同样被人诟病。于是出现了致力解决比特币不足的“V神”。以太坊的愿景是创建一个无法停止，抗屏蔽（审查）和自我维持的去中心化世界计算机。比特币的不足：交易速度慢；仅仅完成了货币的去中心化。
golang学习笔记15——golang依赖管理方法
GoppViper的博客
09-10 1693
Golang 的依赖管理是项目开发中非常重要的一个环节。通过合理地使用 Go Modules 进行依赖管理，可以提高项目的可维护性、可扩展性和稳定性。在使用依赖管理时，应该遵循一些最佳实践，如固定依赖版本、使用语义化版本号、定期更新依赖和管理依赖的范围等。这样可以确保项目能够顺利地进行开发和维护。关注我看更多有意思的文章哦！👉👉。
【学习笔记】SSL证书之前向保密
Taki_UP的博客
09-10 541
本篇介绍了密码学中前向保密（Forward Secrecy）的相关内容
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值