idea整合redis、kafka、es

最新推荐文章于 2022-04-18 08:52:42 发布
最新推荐文章于 2022-04-18 08:52:42 发布
阅读量322 收藏
点赞数
文章标签： elasticsearch redis
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_46981685/article/details/106379687
版权

idea整合redis、kafka、es

在这里插入图片描述

package com.example.demokafkaredises;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class DemoKafkaRedisEsApplication {

    public static void main(String[] args) {
        System.setProperty("es.set.netty.runtime.available.processors", "false");
        SpringApplication.run(DemoKafkaRedisEsApplication.class, args);
    }

}


package com.example.demokafkaredises;
import java.lang.reflect.Field;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;

import com.github.pagehelper.PageInfo;
import org.elasticsearch.action.search.SearchResponse;
import org.elasticsearch.index.query.QueryBuilder;
import org.elasticsearch.index.query.QueryBuilders;
import org.elasticsearch.search.SearchHit;
import org.elasticsearch.search.SearchHits;
import org.elasticsearch.search.fetch.subphase.highlight.HighlightBuilder;
import org.elasticsearch.search.fetch.subphase.highlight.HighlightField;
import org.springframework.data.domain.PageRequest;
import org.springframework.data.domain.Pageable;
import org.springframework.data.domain.Sort;
import org.springframework.data.elasticsearch.core.ElasticsearchTemplate;
import org.springframework.data.elasticsearch.core.SearchResultMapper;
import org.springframework.data.elasticsearch.core.aggregation.AggregatedPage;
import org.springframework.data.elasticsearch.core.aggregation.impl.AggregatedPageImpl;
import org.springframework.data.elasticsearch.core.query.GetQuery;
import org.springframework.data.elasticsearch.core.query.IndexQuery;
import org.springframework.data.elasticsearch.core.query.IndexQueryBuilder;
import org.springframework.data.elasticsearch.core.query.NativeSearchQueryBuilder;
import org.springframework.data.elasticsearch.core.query.SearchQuery;
/**
 * Es工具类
 */
public class EsUtils {
	/**
	 * 保存及更新方法
	 * @param elasticsearchTemplate
	 * @param id
	 * @param object
	 */
	public static void saveObject(ElasticsearchTemplate elasticsearchTemplate, String id, Object object) {
		// 创建所以对象
		IndexQuery query = new IndexQueryBuilder().withId(id).withObject(object).build();
		// 建立索引
		elasticsearchTemplate.index(query);
	}

	/**
	 * 批量删除
	 * @param elasticsearchTemplate
	 * @param clazz
	 * @param ids
	 */
	public static void deleteObject(ElasticsearchTemplate elasticsearchTemplate, Class<?> clazz, Integer ids[]) {
		for (Integer id : ids) {
			elasticsearchTemplate.delete(clazz, id + "");
		}
	}

	/**
	 *
	 * @Title: selectById
	 * @Description: 根据id在es服务启中查询对象
	 * @param elasticsearchTemplate
	 * @param clazz 对象的Class
	 * @param id 主键
	 * @return: Object
	 */
	public static Object selectById(ElasticsearchTemplate elasticsearchTemplate, Class<?> clazz, Integer id) {
		GetQuery query = new GetQuery();
		query.setId(id + "");
		return elasticsearchTemplate.queryForObject(query, clazz);
	}

	/**
	 * 根据关键词查询文档，支持关键词高亮、可以指定排序字段
	 * @param elasticsearchTemplate
	 * @param keyword 搜索关键词
	 * @param clazz 返回实体类class
	 * @param sortField
	 * @param pageNum
	 * @param pageSize
	 * @param highLightNames
	 * @return
	 */
	@SuppressWarnings({ "rawtypes", "unchecked" })
	public static  PageInfo<?> findByKeyword(ElasticsearchTemplate elasticsearchTemplate, String keyword,
			Class<?> clazz, String sortField,Integer pageNum,Integer pageSize, String highLightfieldNames) {
		/** 定义要返回结果PageInfo **/
		PageInfo<?> pageInfo = new PageInfo<>();
		/** ES的查询结果  **/
		AggregatedPage<?> page = null;
		/** 创建Pageable对象,主键的实体类属性名 **/
		final Pageable pageable = PageRequest.of(pageNum - 1, pageSize, Sort.by(Sort.Direction.ASC, sortField));
		/** 定义查询对象 **/
		SearchQuery searchQuery = null;
		/** 查询条件高亮的构建对象 **/
		QueryBuilder queryBuilder = null;
		/** 高亮拼接的前缀与后缀 **/
		String preTags = "<font color=\"red\">";
		String postTags = "</font>";
		/** 定义创建高亮的构建集合对象 **/
		String[] fieldNames = highLightfieldNames.split(",");
		HighlightBuilder.Field highlightFields[] = new HighlightBuilder.Field[fieldNames.length];
		for (int i = 0; i < fieldNames.length; i++) {
			// 这个代码有问题
			highlightFields[i] = new HighlightBuilder.Field(fieldNames[i]).preTags(preTags).postTags(postTags);
		}
		/** 查询数据 **/
		if (keyword != null && !"".equals(keyword)) {
			/** 创建queryBuilder对象 **/
			queryBuilder = QueryBuilders.multiMatchQuery(keyword, fieldNames);
			searchQuery = new NativeSearchQueryBuilder()
					.withQuery(queryBuilder)
					.withHighlightFields(highlightFields)
					.withPageable(pageable).build();
			/** 查询数据 **/
			page = elasticsearchTemplate.queryForPage(searchQuery, clazz, new SearchResultMapper() {
				public <T> AggregatedPage<T> mapResults(SearchResponse response, Class<T> clazz, Pageable pageable1) {
					List<T> contentList = new ArrayList<T>();
					long total = 0l;
					try {
						/** 查询结果 **/
						SearchHits hits = response.getHits();
						/** 查询结果为空 **/
						if(hits==null) {
							return new AggregatedPageImpl<T>(contentList, pageable, total);
						}
						/** 获取总记录数 **/
						total = hits.getTotalHits();
						/** 获取结果数组 **/
						SearchHit[] searchHits = hits.getHits();
						/** 遍历封装查询的对象 **/
						for (SearchHit searchHit:searchHits) {
							/** 对象值  **/
							T entity = clazz.newInstance();
							/** 获取对象的所有的字段 **/
							Field[] fields = clazz.getDeclaredFields();
							/** 遍历字段对象 **/
							for (Field field:fields) {
								/** 暴力反射 **/
								field.setAccessible(true);
								/** 字段名称 **/
								String fieldName = field.getName();
								if("serialVersionUID".equals(fieldName) || "user".equals(fieldName)
										 || "channel".equals(fieldName)  || "category".equals(fieldName)) {
									continue;
								}
								/** 字段值 **/
								Object fieldValue = searchHit.getSourceAsMap().get(fieldName);
								/** 字段类型 **/
								Class<?> type = field.getType();
								if (type == Date.class) {
									fieldValue = new Date(Long.valueOf(fieldValue + ""));
								}
								/** 是否高亮字段 **/
								HighlightField highlightField = searchHit.getHighlightFields().get(fieldName);
								if(highlightField!=null) {
									/** 高亮 处理 拿到 被<font color='red'> </font>结束所包围的内容部分 **/
									fieldValue = highlightField.getFragments()[0].toString();
								}
								field.set(entity, fieldValue);
							}
							contentList.add(entity);
						}
					} catch (Exception e) {
						e.printStackTrace();
					}

					return new AggregatedPageImpl<T>(contentList, pageable, total);
				}

				@Override
				public <T> T mapSearchHit(SearchHit searchHit, Class<T> aClass) {
					return null;
				}
			});

		} else {
			/** 没有查询条件，分页获取ES中的全部数据  **/
			searchQuery = new NativeSearchQueryBuilder().withPageable(pageable).build();
			page = elasticsearchTemplate.queryForPage(searchQuery, clazz);
		}
		/** 封装PageInfo对象 **/
		int totalCount = (int) page.getTotalElements();
		int pages = (totalCount+ pageSize-1) / pageSize;
		//totalCount%pageSize==0?totalCount/pageSize:totalCount/pageNum+1;
		pageInfo.setTotal(page.getTotalElements());
		pageInfo.setPageNum(pageNum);
		pageInfo.setPageSize(pageSize);
		pageInfo.setPrePage(pageNum-1);
		pageInfo.setNextPage(pageNum+1);
		pageInfo.setPages(pages);
		pageInfo.setHasNextPage(pageNum!=pages);
		pageInfo.setHasPreviousPage(pageNum>1);
		int[] navigatepageNums = new int[pages];
		for(int i=0;i<pages;i++) {
			navigatepageNums[i] = i+1;
		}
		pageInfo.setNavigatepageNums(navigatepageNums);
		List content = page.getContent();
		pageInfo.setList(content);
		return pageInfo;
	}
}


package com.example.demokafkaredises;

import com.alibaba.fastjson.JSON;
import org.apache.kafka.clients.consumer.ConsumerRecord;
import org.springframework.kafka.annotation.KafkaListener;
import org.springframework.stereotype.Component;

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

@Component
public class KafkaConsumer {

    @KafkaListener(topics = {"testTopic"})
    public void listen(ConsumerRecord<String,Object> consumerRecord){
        System.out.println("the Message:"+consumerRecord.value());
        Object value = consumerRecord.value();
        User user = JSON.parseObject(value.toString(), User.class);
        System.out.println(user);
    }
}


package com.example.demokafkaredises;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.elasticsearch.core.ElasticsearchTemplate;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class TestController {
    @Autowired
    private ElasticsearchTemplate elasticsearchTemplate;


    @RequestMapping("es")
    public String es(){
        User user = new User();
        user.setId(1);
        user.setName("zhangsan");
        EsUtils.saveObject(elasticsearchTemplate,"1",user);
        Object o = EsUtils.selectById(elasticsearchTemplate, User.class, 1);
        System.out.println(o);
        return "es";
    }
}


package com.example.demokafkaredises;

import org.springframework.data.elasticsearch.annotations.Document;

@Document(indexName = "user", type = "user")
public class User {
    private Integer id;
    private String name;

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", username='" + name + '\'' +
                '}';
    }
}

配置文件

#redis配置
spring.redis.host=192.168.16.129
spring.redis.port=6379
spring.redis.database=0


#指定kafka 代理地址，可以多个
spring.kafka.bootstrap-servers=192.168.16.129:9092
spring.kafka.producer.retries=0
# 每次批量发送消息的数量
spring.kafka.producer.batch-size=16384
spring.kafka.producer.buffer-memory=33554432
# 指定消息key和消息体的编解码方式
spring.kafka.producer.key-serializer=org.apache.kafka.common.serialization.StringSerializer
spring.kafka.producer.value-serializer=org.apache.kafka.common.serialization.StringSerializer

# 指定默认消费者group id
spring.kafka.consumer.group-id=test-group
spring.kafka.consumer.auto-offset-reset=earliest
spring.kafka.consumer.enable-auto-commit=true
spring.kafka.consumer.auto-commit-interval=100
# 指定消息key和消息体的编解码方式
spring.kafka.consumer.key-deserializer=org.apache.kafka.common.serialization.StringDeserializer
spring.kafka.consumer.value-deserializer=org.apache.kafka.common.serialization.StringDeserializer

#spring.datasource.url=jdbc:mysql://localhost:3306/1711d?useUnicode=true&characterEncoding=utf8&serverTimezone=Asia/Shanghai
#spring.datasource.username=root
#spring.datasource.password=root
#spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver

# Elasticsearch
spring.data.elasticsearch.cluster-name=elasticsearch
spring.data.elasticsearch.cluster-nodes=192.168.16.129:9300

测试类

package com.example.demokafkaredises;

import com.alibaba.fastjson.JSON;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.data.elasticsearch.core.ElasticsearchTemplate;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.kafka.core.KafkaTemplate;

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

@SpringBootTest
class DemoKafkaRedisEsApplicationTests {
    @Autowired
    private RedisTemplate redisTemplate;

    @Autowired
    private KafkaTemplate kafkaTemplate;

    @Autowired
    private ElasticsearchTemplate elasticsearchTemplate;

    @Test
    void contextLoads() {
//        System.setProperty("es.set.netty.runtime.available.processors", "false");
       redisTemplate.opsForValue().set("name","张三");
        Object name = redisTemplate.opsForValue().get("name");
        System.out.println(name);
        Map<String,Object> userMap = new HashMap<>();
        userMap.put("id","1");
        userMap.put("name","张三");
        String userJsonStr = JSON.toJSONString(userMap);

        kafkaTemplate.send("testTopic",userJsonStr);


        User user = new User();
        user.setId(1);
        user.setName("zhangsan");
        EsUtils.saveObject(elasticsearchTemplate,"1",user);
        Object o = EsUtils.selectById(elasticsearchTemplate, User.class, 1);
        System.out.println(o);

    }

}

pom.xml

<?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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.2.5.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.example</groupId>
    <artifactId>demo-kafka-redis-es</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>demo-kafka-redis-es</name>
    <description>Demo project for Spring Boot</description>

    <properties>
        <java.version>1.8</java.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-elasticsearch</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.kafka</groupId>
            <artifactId>spring-kafka</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
            <exclusions>
                <exclusion>
                    <groupId>org.junit.vintage</groupId>
                    <artifactId>junit-vintage-engine</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
        <dependency>
            <groupId>org.springframework.kafka</groupId>
            <artifactId>spring-kafka-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.54</version>
        </dependency>
        <dependency>
            <groupId>com.github.pagehelper</groupId>
            <artifactId>pagehelper</artifactId>
            <version>5.1.2</version>
        </dependency>
        <dependency>
            <groupId>com.github.pagehelper</groupId>
            <artifactId>pagehelper</artifactId>
            <version>5.1.2</version>
            <scope>compile</scope>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>
weixin_46981685
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Storm集成Kafka和Redis
Simon的博客
04-17 1085
Storm集成Kafka和Redis 一、 新建Strom项目   二、 引入pom依赖 &lt;properties&gt; &lt;project.build.sourceEncoding&gt;UTF-8&lt;/project.build.sourceEncoding&gt; &lt;spring.version&gt;2.5.6&lt;/spring.version&g...
整合redis kafka es步骤
AKoalas的博客
04-06 760
一.整合kafka(生产者)步骤 1.导入依赖(pom.xml) 2.编写配置文件,修改配置文件的ip和端口号,修改主题(producer.xml) 3.如果再ssm项目中可以让spring.xml来加载这个配置文件 如果是再测试类中如何加载? @RunWith(SpringJUnit4ClassRunner.class) //加载生产者的配置 @ContextConfiguration(“cl...
项目1在线交流平台-7.构建安全高效的企业服务-7. Quartz定时任务应用-热帖排行-kafka、redis、ES
xingzhes_的博客
04-13 596
文章目录功能需求一、处理要计算分数的帖子1. 处理策略2. redis定义key及储存处理2.1 key的定义2.2 redis中储存帖子id的时机`Set数据结构``加精处理时``新增帖子时``对帖子评论时``对帖子点赞时`二、使用Quartz定期更新帖子分数1 定义更新帖子分数的任务`Job`1.1 绑定redis的key，取value`boundSetOps(postScoreKey)`-绑定key的set集合1.2. 处理任务：刷新帖子的分数，前后记录日志方便调试`operations.pop()`
Spark Streaming集成kafka和redis简单示例 - Java版
xbing的博客
06-29 1648
pom.xml中添加依赖：&lt;!-- https://mvnrepository.com/artifact/org.apache.spark/spark-streaming --&gt; &lt;dependency&gt; &lt;groupId&gt;org.apache.spark&lt;/groupId&gt; &lt;artifactId&gt;spark-strea...
Elasticsearch(五) idea es环境搭建以及对ES基本操作
m0_67400972的博客
04-18 1257
步骤一、创建一个SpringBoot工程，pom.xml 如下: <?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 https:/
iCommunity:一个基于Redis，Kafka，Elasticsearch的SpringBoot项目
05-13
中间件:分布式缓存Redis + 消息队列Kafka + 全文检索ElasticSearch + 本地缓存Caffeine + 定时任务Quartz 构建工具:Apache Maven 版本控制工具:Git 集成开发环境:IntelliJ IDEA 项目架构 功能简介 基于 SpringBoot ...
spring-boot-demo-master整合其他框架
08-08
Idea打开SpringBoot例子整合acitviti、redis、docker、kafka、es搜索等
基于SpringBoot的仿牛客论坛源码.zip
05-21
Redis、Kafka、Elasticsearch Spring Security、Spring Actuator 开发环境 构建工具：Apache Maven 集成开发工具：IntelliJ IDEA 数据库：MySQL、Redis 应用服务器：Apache Tomcat 版本控制工具：Git 软件架构 基础...
基于SSM + Spring Boot + Thymeleaf开发的论坛社区网站+源代码+文档说明
最新发布
11-11
引入Kafka的目的主要是为了异步生产消费事件，包括评论、点赞、关注时的系统通知，以及Elasticsearch服务器的更新。 使用Elasticsearch实现全文搜索。 基于Quartz定时任务实现热帖排行；使用Caffeine做热帖服务器...
1000道 互联网Java工程师面试题
09-30
本资源提供了互联网Java工程师面试题，涵盖了Java、MyBatis、ZooKeeper、Dubbo、Elasticsearch、Memcached、Redis、MySQL、Spring、Spring Boot、Spring Cloud、RabbitMQ、Kafka、Linux等技术栈目录。以下是该资源的...
SpringBoot集成Redis，Webservice，kafka，quartz，mybatis例子
08-22
最近学习springboot吧自己工作中需要用到的工具都做了集成例子。其中包括mybatis，cfx的webservice，定时器quartz，消息队列kafka以及redis其中redis包含了三种连接方式（单机模式，集群cluster，哨兵模式），给大家做一个参考 希望能让别人学习时少走弯路
springBoot整合kafka和elasticSearch,实现批量拉取日志以及批量更新到es里
01-15
从Kafka中批量拉去数据，然后批量更新到es里。一次拉取的数量可以设置，现在是10000，轻松运转，更新到es内部也是，目标是百万日志秒处理
分布式消息中间件（四）——Flume+Kafka+Storm+Redis生态架构实战
Think In JAVA—Max
06-15 6844
一、Kafka项目应用架构分析 1、Kafka生态架构        数据收集的速度，跟处理的速度不一定一致，故使用Kafka中间件作为数据收集和数据处理的一个Access入口，接收flume收集的数据，并通过kafkaSpout提交给Storm进行处理。 2、kafka 消息生产者 3、kafka 消息消费者   二、Kafka Producer  1、配置FlumeCl
Elasticsearch与Linux(第十天)-在IDEA下操作es (3)
qq_37208650的博客
09-11 171
1.聚合查询 /** * 聚合查询 */ @Test public void test3(){ // aggMax 是固定的，求最大值 /* AggregationBuilder agg = AggregationBuilders.max("aggMax").field("age"); S...
redis VS kafka
weixin_30819163的博客
08-06 461
redis VS kafka （1）redis是内存数据库，只是它的list数据类型刚好可以用作消息队列而已 kafka是消息队列，消息的存储模型只是其中的一个环节，还提供了消息ACK和队列容量、消费速率等消息相关的功能，更加完善 （2）redis 发布订阅除了表示不同的 topic 外，并不支持分组 kafka每个consumer属于一个特定的consumer group（defaul...
kafka
amor_1的博客
11-18 190
kafka 分布式的基于发布/订阅的消息系统 特点： 同时为发布和订阅提高吞吐量 消息持久化 分布式，支持服务器间的消息分区及分布式消费，同时保证每个partition内的消息顺序传输，其内部的Producer、Broker和Consumer都是分布式架构，这更易于向外扩展 消费消息采用pull模式，消息被处理的状态是在Consumer端维护的，而不是由服务器端维护，Broker无状态，Consumer自己保存offset 支持online和offline场景，同时支持离线数据处理和实时数据处理 基本概
kafka 和 redis 有什么区别？
qq_40673345的博客
12-31 2762
正常大家都这么问的，但是实际上应该是想问：kafka和redis queue有什么区别？ 因为redis是一个基于内存的kv数据库，而kafka是分布式发布订阅消息系统。两者本身不是同样一个层次的东西。 redis中有一个queue的数据类型，用来做发布/订阅系统，这个就可以和kafka进行比较了哈。 存储介质不同 redis queue数据是存储在内存，虽然有AOF和RDB的持久化方式，...
redis,kafka,es启动命令&多选框回显
qq_41458071的博客
04-14 161
redis启动 先进入redis目录 ./bin/redis-server redis.conf ./bin/redis-cli zookeeper启动 进入zk的bin目录 启动: ./zkServer.sh start 查看状态: ./zkServer.sh status 停止: ./zkServer.sh stop kafka启动 ...
怎么通过idea整合Redis
04-23
你可以按照以下步骤来通过idea整合Redis： 1. 首先，你需要在idea中安装Redis插件。可以通过打开idea的Plugins菜单，然后搜索Redis并安装相应的插件。 2. 安装完成后，你需要在idea中创建一个新的Redis连接。可以...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值