谷粒商城 高级篇 (五) --------- 商品上架

最新推荐文章于 2023-06-16 15:19:43 发布
最新推荐文章于 2023-06-16 15:19:43 发布
阅读量944 收藏
点赞数 1
分类专栏： 微服务项目 文章标签： 全文检索
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_51111980/article/details/126820848
版权

目录

前言

上架的商品才可以在网站展示。
上架的商品需要可以被检索。

一、商品 Mapping

分析：商品上架在 es 中是存 sku 还是 spu？

1、检索的时候输入名字，是需要按照 sku 的 title 进行全文检索的

2、检索使用商品规格，规格是 spu 的公共属性，每个 spu 是一样的

3、按照分类 id 进去的都是直接列出 spu 的，还可以切换。

4、我们如果将 sku 的全量信息保存到 es 中 (包括 spu 属性) 就太多量字段了。

5、我们如果将 spu 以及他包含的 sku 信息保存到 es 中，也可以方便检索。但是 sku 属于spu 的级联对象，在 es 中需要 nested 模型，这种性能差点。

6、但是存储与检索我们必须性能折中。

7、如果我们分拆存储，spu 和 attr 一个索引，sku 单独一个索引可能涉及的问题。检索商品的名字，如“手机”，对应的 spu 有很多，我们要分析出这些spu 的所有关联属性，再做一次查询，就必须将所有 spu_id 都发出去。假设有 1 万个数据，数据传输一次就10000*4=4MB；并发情况下假设 1000 检索请求，那就是 4GB 的数据，，传输阻塞时间会很长，业务更加无法继续。

所以，我们如下设计，这样才是文档区别于关系型数据库的地方，宽表设计，不能去考虑数据库范式。

PUT product

product 的 mapping

{ 
	"mappings": { 
		"properties": { 
			"skuId": { 
				"type": "long"
			},
			"spuId": { 
				"type": "keyword"
			},
			"skuTitle": { 
				"type": "text", 
				"analyzer": "ik_smart"
			},
			"skuPrice": { 
				"type": "keyword"
			},
			"skuImg": { 
				"type": "keyword",
				"index": false, 
				"doc_values": false
			},
			"saleCount": { 
				"type": "long"
			},
			"hasStock": { 
				"type": "boolean"
			},
			"hotScore": { 
				"type": "long"
			},
			"brandId": { 
				"type": "long"
			},
			"catalogId": { 
				"type": "long"
			},
			"brandName": { 
				"type": "keyword", 
				"index": false, 
				"doc_values": false
			},
			"brandImg": { 
				"type": "keyword", 
				"index": false, 
				"doc_values": false
			},
			"catalogName": { 
				"type": "keyword", 
				"index": false, 
				"doc_values": false		
			},
			"attrs": { 
				"type": "nested", 
				"properties": { 
					"attrId": { 
						"type": "long"
					},
					"attrName": { 
						"type": "keyword", 
						"index": false, 
						"doc_values": false
					},
					"attrValue": { 
						"type": "keyword"
					 }
				}	
			}
		}
	}
}

index：

默认 true，如果为 false，表示该字段不会被索引，但是检索结果里面有，但字段本身不能当做检索条件。

doc_values：

默认 true，设置为 false，表示不可以做排序、聚合以及脚本操作，这样更节省磁盘空间。还可以通过设定 doc_values 为 true，index 为 false 来让字段不能被搜索但可以用于排序、聚合以及脚本操作。

二、上架细节

上架是将后台的商品放在 es 中可以提供检索和查询功能

1、hasStock：代表是否有库存。默认上架的商品都有库存。如果库存无货的时候才需要更新一下 es

2、库存补上以后，也需要重新更新一下 es

3、hotScore 是热度值，我们只模拟使用点击率更新热度。点击率增加到一定程度才更新热度值。

4、下架就是从 es 中移除检索项，以及修改 mysql 状态

商品上架步骤：

A、先在 es 中按照之前的 mapping 信息，建立 product 索引。

B、点击上架，查询出所有 sku 的信息，保存到 es 中。

C、es 保存成功返回，更新数据库的上架状态信息。

数据一致性

A、商品无库存的时候需要更新 es 的库存信息
B、商品有库存也要更新 es 的信息

三、具体实现

首先实现 SpuInfioController 下的 spuUp 接口

//商品上架
///product/spuinfo/{spuId}/up
@PostMapping(value = "/{spuId}/up")
public R spuUp(@PathVariable("spuId") Long spuId) {

    spuInfoService.up(spuId);

    return R.ok();
}

对应的 spuInfoServiceImpl 中实现 up 方法

@Override
public void up(Long spuId) {

    //1、查出当前spuid对应的所有sku信息，品牌的名字。
    List<SkuInfoEntity> skus = skuInfoService.getSkusBySpuId(spuId);
    List<Long> skuIdList = skus.stream().map(SkuInfoEntity::getSkuId).collect(Collectors.toList());

    //TODO 4、查询当前sku的所有可以被用来检索的规格属性，
    List<ProductAttrValueEntity> baseAttrs = attrValueService.baseAttrlistforspu(spuId);
    List<Long> attrIds = baseAttrs.stream().map(attr -> {
        return attr.getAttrId();
    }).collect(Collectors.toList());

    List<Long> searchAttrIds = attrService.selectSearchAttrIds(attrIds);

    Set<Long> idSet = new HashSet<>(searchAttrIds);

    List<SkuEsModel.Attrs> attrsList = baseAttrs.stream().filter(item -> {
        return idSet.contains(item.getAttrId());
    }).map(item -> {
        SkuEsModel.Attrs attrs1 = new SkuEsModel.Attrs();
        BeanUtils.copyProperties(item, attrs1);
        return attrs1;
    }).collect(Collectors.toList());

    //TODO 1、发送远程调用，库存系统查询是否有库存
    Map<Long, Boolean> stockMap = null;
    try{
        R r = wareFeignService.getSkusHasStock(skuIdList);
        //
        TypeReference<List<SkuHasStockVo>> typeReference = new TypeReference<List<SkuHasStockVo>>() {
        };
        stockMap = r.getData(typeReference).stream().collect(Collectors.toMap(SkuHasStockVo::getSkuId, item -> item.getHasStock()));
    }catch (Exception e){
        log.error("库存服务查询异常:原因{}",e);
    }


    //2、封装每个sku的信息
    Map<Long, Boolean> finalStockMap = stockMap;
    List<SkuEsModel> upProducts = skus.stream().map(sku -> {
        //组装需要的数据
        SkuEsModel esModel = new SkuEsModel();
        BeanUtils.copyProperties(sku,esModel);
        //skuPrice,skuImg,
        esModel.setSkuPrice(sku.getPrice());
        esModel.setSkuImg(sku.getSkuDefaultImg());
        //hasStock,hotScore
        //设置库存信息
        if(finalStockMap == null){
            esModel.setHasStock(true);
        }else {
            esModel.setHasStock(finalStockMap.get(sku.getSkuId()));
        }

        //TODO 2、热度评分。0
        esModel.setHotScore(0L);

        //TODO 3、查询品牌和分类的名字信息
        BrandEntity brand = brandService.getById(esModel.getBrandId());
        esModel.setBrandName(brand.getName());
        esModel.setBrandImg(brand.getLogo());

        CategoryEntity category = categoryService.getById(esModel.getCatalogId());
        esModel.setCatalogName(category.getName());

        //设置检索属性
        esModel.setAttrs(attrsList);

        return esModel;
    }).collect(Collectors.toList());

    //TODO 5、将数据发送给es进行保存；gulimall-search；
    R r = searchFeignService.productStatusUp(upProducts);
    if(r.getCode() == 0){
        //远程调用成功
        //TODO 6、修改当前spu的状态
        baseMapper.updateSpuStatus(spuId, ProductConstant.StatusEnum.SPU_UP.getCode());
    }else {
        //远程调用失败
        //TODO 7、重复调用？接口幂等性；重试机制？xxx
        //Feign调用流程
        /**
         * 1、构造请求数据，将对象转为json；
         *      RequestTemplate template = buildTemplateFromArgs.create(argv);
         * 2、发送请求进行执行（执行成功会解码响应数据）：
         *      executeAndDecode(template);
         * 3、执行请求会有重试机制
         *      while(true){
         *          try{
         *            executeAndDecode(template);
         *          }catch(){
         *              try{retryer.continueOrPropagate(e);}catch(){throw ex;}
         *              continue;
         *          }
         *
         *      }
         */
    }
}

我们来看这个方法，首先查出 spuid 对应的 sku 信息，即 getSkusBySpuId() 方法实现

@Override
public List<SkuInfoEntity> getSkusBySpuId(Long spuId) {
    List<SkuInfoEntity> list = this.list(new QueryWrapper<SkuInfoEntity>().eq("spu_id",spuId));
    return list;
}

然后 baseAttrlistforspu 的实现，查询可用来被检索的属性，这个我们之前已经实现过。

构造 es 检索基本数据 SkuEsModel，我们将其放到 common 模块下

package com.fancy.common.to.es;

import lombok.Data;

import java.math.BigDecimal;
import java.util.List;

@Data
public class SkuEsModel {

    private Long skuId;

    private Long spuId;

    private String skuTitle;

    private BigDecimal skuPrice;

    private String skuImg;

    private Long saleCount;

    private Boolean hasStock;

    private Long hotScore;

    private Long brandId;

    private Long catalogId;

    private String brandName;

    private String brandImg;

    private String catalogName;

    private List<Attrs> attrs;

    @Data
    public static class Attrs {

        private Long attrId;

        private String attrName;

        private String attrValue;

    }
}

远程调用 ware 模块相关接口的实现

在这里插入图片描述

WareSkuController 中：

//查询sku是否有库存
@PostMapping("/hasstock")
public R getSkusHasStock(@RequestBody List<Long> skuIds){

    //sku_id，stock
    List<SkuHasStockVo> vos =  wareSkuService.getSkusHasStock(skuIds);


    return R.ok().setData(vos);
}

R 工具类的相关调整：

package com.fancy.common.utils;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.TypeReference;
import org.apache.http.HttpStatus;

import java.util.HashMap;
import java.util.Map;

import static jdk.management.resource.internal.SimpleResourceContext.get;

public class R extends HashMap<String, Object> {
	private static final long serialVersionUID = 1L;

	//利用fastjson进行逆转
	public <T> T getData(String key, TypeReference<T> typeReference){
		Object data = get(key);//默认是map
		String s = JSON.toJSONString(data);
		T t = JSON.parseObject(s, typeReference);
		return t;
	}

	//利用fastjson进行逆转
	public <T> T getData(TypeReference<T> typeReference){
		Object data = get("data");//默认是map
		String s = JSON.toJSONString(data);
		T t = JSON.parseObject(s, typeReference);
		return t;
	}
	public R setData(Object data){
		put("data",data);
		return this;
	}

	public R() {
		put("code", 0);
		put("msg", "success");
	}

	public static R error() {
		return error(HttpStatus.SC_INTERNAL_SERVER_ERROR, "未知异常，请联系管理员");
	}

	public static R error(String msg) {
		return error(HttpStatus.SC_INTERNAL_SERVER_ERROR, msg);
	}

	public static R error(int code, String msg) {
		R r = new R();
		r.put("code", code);
		r.put("msg", msg);
		return r;
	}

	public static R ok(String msg) {
		R r = new R();
		r.put("msg", msg);
		return r;
	}

	public static R ok(Map<String, Object> map) {
		R r = new R();
		r.putAll(map);
		return r;
	}

	public static R ok() {
		return new R();
	}

	public R put(String key, Object value) {
		super.put(key, value);
		return this;
	}
	public  Integer getCode() {

		return (Integer) this.get("code");
	}

}

SkuHasStockVo 的封装

package com.fancy.gulimall.ware.vo;

import lombok.Data;

@Data
public class SkuHasStockVo {

    private Long skuId;
    private Boolean hasStock;
}

getSkusHasStock 的实现

在这里插入图片描述

getSkuStock 的 mapper 映射文件

在这里插入图片描述

将数据发送给 es 进行保存的相关实现

在这里插入图片描述
ElasticSaveController 的实现：

package com.fancy.gulimall.search.controller;


import com.fancy.common.exception.BizCodeEnum;
import com.fancy.common.to.es.SkuEsModel;
import com.fancy.common.utils.R;
import com.fancy.gulimall.search.service.ProductSaveService;
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;

import java.util.List;

@Slf4j
@RequestMapping("/search/save")
@RestController
public class ElasticSaveController {

    @Autowired
    ProductSaveService productSaveService;

    //上架商品
    @PostMapping("/product")
    public R productStatusUp(@RequestBody List<SkuEsModel> skuEsModels) {
        boolean b = false;
        try {
            b = productSaveService.productStatusUp(skuEsModels);
        } catch (Exception e) {
            log.error("ElasticSaveController商品上架错误：{}", e);
            return R.error(BizCodeEnum.PRODUCT_UP_EXCEPTION.getCode(), BizCodeEnum.PRODUCT_UP_EXCEPTION.getMsg());
        }

        if (!b) {
            return R.ok();
        } else {
            return R.error(BizCodeEnum.PRODUCT_UP_EXCEPTION.getCode(), BizCodeEnum.PRODUCT_UP_EXCEPTION.getMsg());
        }
    }
}

BizCodeEnum 的调整

package com.fancy.common.exception;
/***
 * 错误码和错误信息定义类
 * 1. 错误码定义规则为 5 为数字
 * 2. 前两位表示业务场景，最后三位表示错误码。例如：100001。10:通用001:系统未知异常
 * 3. 维护错误码后需要维护错误描述，将他们定义为枚举形式
 * 错误码列表：
 * 10: 通用
 * 001：参数格式校验
 * 11: 商品
 * 12: 订单
 * 13: 购物车
 * 14: 物流
 *
 *
 */
public enum BizCodeEnum {


    UNKNOWN_EXCEPTION(10000, "系统未知异常"),
    VALID_EXCEPTION(10001, "参数格式校验失败"),

    TOO_MANY_REQUEST(10002,"请求流量过大"),

    SMS_CODE_EXCEPTION(10002,"验证码获取频率太高，稍后再试"),
    PRODUCT_UP_EXCEPTION(11000,"商品上架异常"),

    USER_EXIST_EXCEPTION(15001,"用户存在"),

    PHONE_EXIST_EXCEPTION(15002,"手机号存在"),

    NO_STOCK_EXCEPTION(21000,"商品库存不足"),

    LOGINACCT_PASSWORD_INVAILD_EXCEPTION(15003,"账号密码错误");

    private int code;
    private String msg;

    BizCodeEnum(int code, String msg) {
        this.code = code;
        this.msg = msg;
    }

    public int getCode() {
        return code;
    }

    public String getMsg() {
        return msg;
    }
}

productStatusUp 方法的实现：

@Override
public boolean productStatusUp(List<SkuEsModel> skuEsModels) throws IOException {

    //保存到es
    //1、给es中建立索引。product，建立好映射关系。

    //2、给es中保存这些数据
    //BulkRequest bulkRequest, RequestOptions options
    BulkRequest bulkRequest = new BulkRequest();
    for (SkuEsModel model : skuEsModels) {
        //1、构造保存请求
        IndexRequest indexRequest = new IndexRequest(EsConstant.PRODUCT_INDEX);
        indexRequest.id(model.getSkuId().toString());
        String s = JSON.toJSONString(model);
        indexRequest.source(s, XContentType.JSON);

        bulkRequest.add(indexRequest);
    }

    BulkResponse bulk = restHighLevelClient.bulk(bulkRequest, ElasticSearchConfig.COMMON_OPTIONS);

    //TODO 1、如果批量错误
    boolean b = bulk.hasFailures();
    List<String> collect = Arrays.stream(bulk.getItems()).map(item -> {
        return item.getId();
    }).collect(Collectors.toList());
    log.info("商品上架完成：{}，返回数据：{}",collect,bulk.toString());


    return b;

}

ElasticSearchConfig 中：

package com.fancy.gulimall.search.config;

import org.apache.http.HttpHost;
import org.elasticsearch.client.RequestOptions;
import org.elasticsearch.client.RestClient;
import org.elasticsearch.client.RestClientBuilder;
import org.elasticsearch.client.RestHighLevelClient;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class ElasticSearchConfig {

    public static final RequestOptions COMMON_OPTIONS;
    static {
        RequestOptions.Builder builder = RequestOptions.DEFAULT.toBuilder();
//        builder.addHeader("Authorization", "Bearer " + TOKEN);
//        builder.setHttpAsyncResponseConsumerFactory(
//                new HttpAsyncResponseConsumerFactory
//                        .HeapBufferedResponseConsumerFactory(30 * 1024 * 1024 * 1024));
        COMMON_OPTIONS = builder.build();
    }

    @Bean
    public RestHighLevelClient esRestClient(@Value("${spring.elasticsearch.jest.uris}")String esUrl){

        //TODO 修改为线上的地址
        RestClientBuilder builder = null;
        //final String hostname, final int port, final String scheme

//        builder = RestClient.builder(new HttpHost("192.168.38.130", 9200, "http"));
        builder = RestClient.builder(HttpHost.create(esUrl));
        RestHighLevelClient client = new RestHighLevelClient(builder);
//        RestHighLevelClient client = new RestHighLevelClient(
//                RestClient.builder(
//                        new HttpHost("192.168.38.130", 9200, "http")));
        return client;
    }

}

在配置文件中，将spring.elasticsearch.jest.uris映射成 es 地址即可

在森林中麋了鹿
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
guli-mall:尚硅谷-谷粒商城
04-28
member会员模块会员服务mall-order订单模块订单服务mall-product商品模块商品服务mall-search搜索服务Elasticsearch 操作服务mall-third-party第三方整合服务第三方服务、阿里云OSS等mall-ware库存模块仓储服务...
谷粒商城第二天-项目环境搭建
06-15
这就是common模块下面的src下的mian文件夹下的类
【谷粒商城高级篇】商品服务 & 商品上架
知识输出、记录学习
02-05 631
商品服务 & 商品上架
谷粒商城-day13-es和商品上架
qq_39007838的博客
07-27 1588
尚硅谷谷粒商城es和商品上架部分
谷粒商城高级篇上
onlySunKim的博客
06-16 600
文章目录一、商品业务1.商品上架（ES+SpuInfo）1.1.商品json文档格式分析1.2.商品文档格式（nested、doc_values、analyzer）1.3.nested数据类型分析使用nested类型映射1.4.商品上架接口TO商品传输对象Service上架代码2、动静分离（Nginx）1.1.整合thymeleaf（模板引擎）1.2.渲染三级分类优化版三级分类1.3.动静分离二、nginx搭建域名访问环境1.正向代理与反向代理1.1.配置本地dns解析1.2.nginx作为反向代理1.3.
谷粒商城实现商品的上架（数据整合迁移到ES)
sdTAyhn的博客
08-03 1318
写这个文章主要是为了梳理业务，理清思路，方便以后使用 1.定义我们上传产品的映射 这是我们对上传产品的映射信息，主要是sku表的信息和attr属性表的信息。 attrs的类型是嵌套。属性表查得信息必须是可以检索的，比如我们可以在京东的搜索页面，通过选择cpu的型号进行搜索匹配。 然后热点值hitscore以后完善。然后需要查询我们是否具有库存hasStock,通过各种数据的处理来进行封装。 2 定义映射对象 @Data /** * 本质上传输对象 实际上在product和搜索微服务都应该有该对象 *
谷粒商城P133 product映射关系
study_slacker_的博客
11-20 314
谷粒商城P133 product映射关系 PUT product { mappings: { properties: { skuId: { type: long }, spuId: { type: keyword }, skuTitle: { type: text, analyzer: ik_smart }, skuPrice: { type: keyword }, skuImg: { type:
谷粒商城-电商项目--gulimall.zip
最新发布
11-01
谷粒商城-电商项目--gulimall
后台管理系统-Java
10-15
这套Base Admin是一套简单通用的后台管理系统，主要功能有：权限管理、菜单管理、用户管理，系统设置、实时日志，实时监控，API加密，以及登录用户修改密码、配置个性菜单等。
阶段性学习-谷粒商城-基础篇
03-12
详细的完整的项目代码资源
实战 - 谷粒商城项目：高级上篇First
你今天真好看呀
12-23 2258
文章目录SpringCloud 商城项目 - 高级篇1. ElaticSearch全文检索1.1 docker安装elasticsearch和kibana1.2 elasticsearch入门1.3 elasticsearch进阶1.4 Elasticsearch-Rest-Client2. 商城业务 - 商品上架2.1 构造基本数据2.2 查询当前sku可以被用来检索的规格属性2.3 远程调用gulimall-ware服务查询是否有库存2.4 远程调用gulimall-search将数据放在es保存实现上
商品管理系统——商品新增远程调用保存实现部分
实践求真知
11-08 678
一 SpuInfoServiceImpl.java /** * 功能描述：保存商品信息 * * @param vo 待保存的商品信息 * @author cakin * @date 2020/11/8 */ @Transactional @Override public void saveSpuInfo(SpuSaveVo vo) { // 1 保存spu基本信息 pms_spu_info SpuInfoEntity infoEntity = new SpuInfoEntity();
谷粒商城 拖拽功能（前端）
qq_51682771的博客
10-09 488
需求：点击拖拽功能后，拖拽树形数据，拖拽数据后，点击提交就会将拖拽完毕的信息自动保存到数据库。
谷粒商城(商品上架、首页、异步、商品详细)思路详解
m0_46388866的博客
09-22 1045
商品业务总结1.商品上架1.sku模型分析2.嵌入式3.构造基本数据4.检索属性5.设置库存信息6.保存model到es中7.R的修改2.首页1.新建页面2.获取一级目录。3.获取整个目录4.nginx反向代理服务器5.nginx通过网关访问首页3.检索服务1.配置检索页面2.修改检索页面3.抽取页面的Result主体4.检索测试5.聚合数据6.模糊查询（商品名称），过滤（属性、属性值、品牌、分类）7.排序、分页和高亮8.封装结果集9.页面筛选条件渲染10.分页数据渲染11.页面排序功能12.排序页面回显1
谷粒商城-商城业务（商品上架）
不管多大的困难都要跨过去
10-13 1325
在商城中搜索商品，只能搜索到已上架的商品。而商品上架时，需要把数据也同步到中以供搜索。但是肯定不能把完整的数据全部存到es中，因为es中的数据是存储在内存中的，就算es是分布式的，理论上可以存储非常多的数据，但是内存产品终究是比硬盘贵的。所以考虑到经济效益，我们是要取某些数据存到es中，而不是完整数据都存进去。哪些数据存储在es中？
《谷粒商城》开发实录：070-100 商品服务-发布商品
拉里小猪的博客
01-16 1173
接口文档，发布商品等。
谷粒商城-基础篇-商品服务6-商品维护（P83-P92）
ljn1046016768的博客
05-23 1042
谷粒商城 商品服务 新增商品
谷粒商城基础篇笔记
kedalao的博客
03-25 2280
谷粒商城个人简单笔记
谷粒商城-商品服务（新增商品）
不管多大的困难都要跨过去
09-28 385
谷粒商城-商品服务（新增商品）
从前慢-谷粒商城篇章6
08-17
根据引用中提供的信息，谷粒商城是一个B2C模式的电商平台，主要销售自营商品给客户。B2C模式指的是商对客的模式，即商家直接向消费者销售商品和服务。谷粒商城使用微服务架构，这是一种将应用程序拆分成独立且可独立...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

在森林中麋了鹿

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值