java操作Elasticsearch 动态创建自定义空间索引 geo_shape 批量更新数据

最新推荐文章于 2024-05-18 00:32:49 发布
最新推荐文章于 2024-05-18 00:32:49 发布
阅读量3k 收藏 9
点赞数 2
分类专栏： GIS Elasticsearch JAVA geo_shape wkt
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/G1994/article/details/91489873
版权
JAVA 同时被 3 个专栏收录
2 篇文章 0 订阅
订阅专栏
GIS
1 篇文章 0 订阅
订阅专栏
Elasticsearch
1 篇文章 0 订阅
订阅专栏

由于数据未知，所以无法使用bean的方式，只能使用map来操作。

首先创建客户端

import java.net.InetAddress;
import java.net.UnknownHostException;

import org.elasticsearch.client.transport.TransportClient;
import org.elasticsearch.common.settings.Settings;
import org.elasticsearch.common.transport.TransportAddress;
import org.elasticsearch.transport.client.PreBuiltTransportClient;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class MyESConfig {

    @Bean
    public TransportClient client() throws UnknownHostException {
        TransportAddress node=new TransportAddress(InetAddress.getByName("127.0.0.1“), 9300);
        Settings setting=Settings.builder()
                .put("cluster.name","my-application")
                .build();
        TransportClient client=new PreBuiltTransportClient(setting);
        client.addTransportAddress(node);
        return client;
    }
}

WKT工具类

import com.vividsolutions.jts.geom.*;
import com.vividsolutions.jts.io.ParseException;
import com.vividsolutions.jts.io.WKTReader;
import org.geotools.geometry.jts.JTSFactoryFinder;

public class WKTUtil {
 
    private final static WKTReader wktReader = new WKTReader(JTSFactoryFinder.getGeometryFactory());
 
    /**
     * 将WKT文本字符串转换为ES中的GeoShape字符串格式
     * @param wkt
     * @return
     * @throws ParseException
     */
    public static String getESGeoTextFromWkt(String wkt) throws ParseException {
        String result = null;
        Geometry geom = wktReader.read(wkt);
        String type = geom.getClass().getSimpleName().toLowerCase();
        Point point;
        MultiPoint multiPoint;
        LineString lineString;
        MultiLineString multiLineString;
        Polygon polygon;
        MultiPolygon multiPolygon;
        if(type.equals("point")){
            point = (Point) geom;
            result = getESPointText(point);
        }else if(type.equals("linestring")){
            lineString = (LineString) geom;
            result = getESLineStringText(lineString);
        }else if(type.equals("polygon")){
            polygon = (Polygon) geom;
            result = getESPolygonText(polygon);
        }else if(type.equals("multipoint")){
            multiPoint = (MultiPoint) geom;
            result = getESMultiPointText(multiPoint);
        }else if(type.equals("multilinestring")){
            multiLineString = (MultiLineString) geom;
            result = getESMultiLineStringText(multiLineString);
        }else if(type.equals("multipolygon")){
            multiPolygon = (MultiPolygon) geom;
            result = getESMultiPolygonText(multiPolygon);
        }
        return result;
    }
 
    /**
     * 通过MultiPolygon对象拼接中括号表示的字符串
     * @param multiPolygon
     * @return
     */
    private static String getESMultiPolygonText(MultiPolygon multiPolygon) throws ParseException {
        Polygon polygon;
        int num = multiPolygon.getNumGeometries();
        StringBuffer sb = new StringBuffer("[");
        for(int i = 0; i < num; i++){
            polygon = (Polygon) multiPolygon.getGeometryN(i);
            sb.append(getESPolygonText(polygon)+",");
        }
        sb.setCharAt(sb.length() - 1, ']');
        return sb.toString();
    }
 
    /**
     * 通过MultiLineString对象拼接中括号表示的字符串
     * @param multiLineString
     * @return
     */
    private static String getESMultiLineStringText(MultiLineString multiLineString) {
        LineString lineString;
        int num = multiLineString.getNumGeometries();
        StringBuffer sb = new StringBuffer("[");
        for(int i = 0; i < num; i++){
            lineString = (LineString) multiLineString.getGeometryN(i);
            sb.append(getESLineStringText(lineString)+",");
        }
        sb.setCharAt(sb.length() - 1, ']');
        return sb.toString();
    }
 
    /**
     * 通过MultiPoint对象拼接中括号表示的字符串
     * @param multiPoint
     * @return
     */
    private static String getESMultiPointText(MultiPoint multiPoint) {
        Point point;
        int num = multiPoint.getNumGeometries();
        StringBuffer sb = new StringBuffer("[");
        for(int i = 0; i < num; i++){
            point = (Point) multiPoint.getGeometryN(i);
            sb.append(getESPointText(point)+",");
        }
        sb.setCharAt(sb.length() - 1, ']');
        return sb.toString();
    }
 
    /**
     * 通过Polygon对象拼接中括号表示的字符串
     * @param polygon
     * @return
     * @throws ParseException
     */
    private static String getESPolygonText(Polygon polygon){
        String result;
        /**
         * 内部闭合环形的数量
         */
        int num = polygon.getNumInteriorRing();
        if(num > 0){
            StringBuffer sb = new StringBuffer("["+getESLineStringText(polygon.getExteriorRing())+",");
            for(int i = 0; i < num; i++){
                sb.append(getESLineStringText(polygon.getInteriorRingN(i))+",");
            }
            sb.setCharAt(sb.length() - 1, ']');
            result = sb.toString();
        }else{
            result = "["+getESLineStringText(polygon.getExteriorRing())+"]";
        }
        return result;
    }
 
    /**
     * 通过LineString对象拼接中括号表示的字符串
     * @param lineString
     * @return
     */
    public static String getESLineStringText(LineString lineString){
        Coordinate[] corrds = lineString.getCoordinates();
        StringBuffer sb = new StringBuffer("[");
        for(Coordinate corrd : corrds) {
            sb.append(getCoordinateText(corrd)+",");
        }
        sb.setCharAt(sb.length() - 1, ']');
        return sb.toString();
    }
 
    /**
     * 通过Point对象拼接中括号表示的字符串
     * @param point
     * @return
     */
    public static String getESPointText(Point point){
        return getCoordinateText(point.getCoordinate());
    }
 
    /**
     * 通过Coordinate对象拼接中括号表示的字符串
     * @param coord
     * @return
     */
    public static String getCoordinateText(Coordinate coord) {
        return "["+coord.x+","+coord.y+"]";
    }
     
}

ES工具类

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

import org.elasticsearch.action.admin.indices.create.CreateIndexResponse;
import org.elasticsearch.action.admin.indices.exists.indices.IndicesExistsRequest;
import org.elasticsearch.action.admin.indices.exists.indices.IndicesExistsResponse;
import org.elasticsearch.client.AdminClient;
import org.elasticsearch.client.IndicesAdminClient;
import org.elasticsearch.client.transport.TransportClient;
import org.elasticsearch.common.settings.Settings;
import org.elasticsearch.common.xcontent.XContentBuilder;
import org.elasticsearch.common.xcontent.XContentFactory;

import com.vividsolutions.jts.geom.Coordinate;
import com.vividsolutions.jts.geom.LineString;
import com.vividsolutions.jts.geom.Point;
import com.vividsolutions.jts.io.ParseException;
import com.vividsolutions.jts.io.WKTReader;

public class ESUtil {

	/**
	 * 获取mapping
	 * @param map
	 * @param id
	 * @return
	 * @throws IOException
	 * @throws ParseException
	 */
	public static XContentBuilder getMapping(Map<String, Object> map, String id) throws IOException, ParseException {
		// 字段mapping
		XContentBuilder mapping = XContentFactory.jsonBuilder().startObject();

		mapping.field("id", id);
		// 几何类型
		if (map.get("wkt") != null) {
			String polygon = map.get("wkt").toString();
			mapping.field("wkt", getConversionData(polygon));
		}
		// 循环添加字段和值
		for (String key : map.keySet()) {
			// 排除要不需要的字段
			if (key.equals("indexName") || key.equals("id") || key.equals("wkt")) {
				continue;
			}
			mapping.field(key, map.get(key));
		}
		mapping.endObject();
		return mapping;
	}

	/**
	 * 获取json数据
	 * @param map
	 * @param id
	 * @return
	 * @throws ParseException
	 */
	public static String getJsonData(Map<String, Object> map, String id) throws ParseException {
		String json = "{";
		json += "\"id\":\"" + id + "\",";
		if (map.get("id") != null) {
			map.remove("id");
		}
		if (map.get("wkt") != null) {
			// wkt数据
			String wkt = map.get("wkt").toString();
			// wkt类型
			String geometry = wkt.substring(0, wkt.indexOf("(")).trim().toLowerCase();
			//ES能存储的格式
			String data = "{\"coordinates\":";
			data += WKTUtil.getESGeoTextFromWkt(wkt) + ",\"type\":\"" + geometry + "\"},";
			json += "\"wkt\":" + data;
			map.remove("wkt");
		}
		int i = 1;
		for (String key : map.keySet()) {
			json += "\"" + key + "\":\"" + map.get(key).toString() + "\"";
			if (i != map.size()) {
				json += ",";
			}
			i++;
		}
		json += "}";
		return json;
	}
	
	/**
	 * 获取转换数据
	 * @param wkt
	 * @return
	 * @throws ParseException
	 */
	private static Map<String,Object> getConversionData(String wkt) throws ParseException {
    	//空间数据类型
		String type=wkt.substring(0,wkt.indexOf("(")).trim().toLowerCase();

		Map<String,Object> map = new HashMap<String,Object>();
		map.put("type",type);
		WKTReader wktReader = new WKTReader();
		if(type.equals("point")){
			Point geoPoint =(Point) wktReader.read(wkt);
			Coordinate coordinates = geoPoint.getCoordinate();
			double[] point=new double[2];
			point[0]=coordinates.x;
			point[1]=coordinates.y;
			map.put("coordinates",point);
		}else if(type.equals("linestring")) {
			LineString geoLineString =(LineString) wktReader.read(wkt);
			Coordinate[] coordinates = geoLineString.getCoordinates();
			double[][] lineString = new double[coordinates.length][2];
			for(int i=0;i<coordinates.length;i++) {
				lineString[i][0] = coordinates[i].x;
				lineString[i][1] = coordinates[i].y;
			}
			map.put("coordinates",lineString);
		}else if(type.equals("polygon")||type.equals("multilinestring")) {
			/*Geometry geometry = wktReader.read(wkt);
			List<double[][]> list=new ArrayList<>();
			int length = geometry.getNumGeometries();
			for(int i=0;i<length;i++) {
				Geometry geometryN = geometry.getGeometryN(i);
				Coordinate[] coordinates = geometryN.getCoordinates();
				double[][] position = new double[coordinates.length][2];
				for(int j=0;j<coordinates.length;j++) {
					position[j][0]=coordinates[j].x;
					position[j][1]=coordinates[j].y;
				}
				list.add(position);
			}
			map.put("coordinates",list);*/
			//数据
			String data=wkt.trim().substring(wkt.indexOf("(")+1).trim();
			data=data.substring(0,data.length()-1).trim();
			String[] split = data.split("\\)");
			List<double[][]> list=new ArrayList<>();
			for(int i=0;i<split.length;i++) {
				String trim = split[i].replace("(", "").replace(")", "").trim();
				if((trim.charAt(0)+"").equals(",")) {
					trim=trim.substring(trim.indexOf(",")+1);
				}
				String[] split2 = trim.split(",");
				double[][] position = new double[split2.length][2];
				for(int j=0;j<split2.length;j++) {
					String ptstr = split2[j].trim();
					String[] lon_lat = ptstr.split(" ");
					position[j][0] = Double.parseDouble(lon_lat[0]);
					position[j][1] = Double.parseDouble(lon_lat[1]);
				}
				list.add(position);
			}
			map.put("coordinates",list);
		}else if(type.equals("multipolygon")){
			map=null;
		}else{
			map=null;
		}
		return map;
	}
	
	/**
	 * 创建索引库
	 * @param client 客户端
	 * @param idnexName 索引名称
	 * @param type 类型
	 * @return
	 * @throws Exception
	 */
    public static boolean createIndex(TransportClient client,String idnexName, String type) throws Exception {  
    	boolean sign=false;
    	try {
    		 // 创建mapping
            XContentBuilder mapping = XContentFactory.jsonBuilder()
                .startObject()
                    .startObject("properties")
                    .startObject("id").field("type", "text").endObject()
                    .startObject("wkt").field("type", "geo_shape").endObject().endObject()
                .endObject();

            AdminClient admin = client.admin();
            IndicesAdminClient indicesAdminClient = admin.indices();
            CreateIndexResponse createIndexResponse = indicesAdminClient.prepareCreate(idnexName)
                    .setSettings(Settings.builder()
                            .put("index.number_of_shards", 5)   // 分片
                            .put("index.number_of_replicas", 1) // 副本
                    )
                    .addMapping(type, mapping) // mapping
                    .get();
            createIndexResponse.isAcknowledged();
            sign=true;
		} catch (Exception e) {
			e.getMessage();
		}
       return sign;
    }

    /**
     * 判断索引名称是否存在
     * @param client 客户端
     * @param indexName 索引名称
     * @return
     */
  	public static boolean isExistsIndex(TransportClient client,String indexName){
          IndicesExistsResponse  response = client.admin().indices()
          		.exists(new IndicesExistsRequest().indices(new String[]{indexName})).actionGet();
          return response.isExists();
  	}
	
}

在需要操作的类进行注入

@Autowired
private TransportClient  client;

 

批量插入方法，map要包含indexName和wkt数据

/**
	 * 添加集合索引
	 * @param list<map>
	 * @return
	 * @throws Exception 
	 */
	@RequestMapping(value="/addIndexs",method=RequestMethod.POST)
	@ResponseBody
	public ResultBean addIndexs(@RequestBody List<Map<String,Object>> list) throws Exception  {
		ResultBean result =new ResultBean();		
		try {
			//索引库名称和类型
			String indexName=list.get(0).get("indexName").toString();
			//判断索引是否存在，不存在就进行创建
			if(!ESUtil.isExistsIndex(client,indexName)) {
				ESUtil.createIndex(client,indexName,indexName);
			}			
			//批量请求生成器
			BulkRequestBuilder bulkRequest = client.prepareBulk();
			
			for(int i=0;i<list.size();i++) {
				//id
				String id=UUID.randomUUID().toString().replace("-", "");
				/*//字段mapping
				XContentBuilder mapping=getMapping(list.get(i),id);
				bulkRequest.add(client.prepareIndex(indexName, indexName,id).setSource(mapping));*/
				
				//字段json
				String json=ESUtil.getJsonData(list.get(i),id);
				bulkRequest.add(client.prepareIndex(indexName, indexName,id).setSource(json,XContentType.JSON));
				
				if(i==0) {
					continue;
				}
				if(i==list.size()-1) {
					bulkRequest.get();
					break;
				}
				if(i%2000==0) {
					bulkRequest.get();
					bulkRequest=client.prepareBulk();
				}
			}
			result.setCode(200);
			result.setMsg("插入成功");
		} catch (Exception e) {
			result.setCode(500);
			result.setMsg(e.getMessage());
		}
		return result;
	}

 

wkt数据

LINESTRING(104.06076431390831 30.66749572727531,104.06728744623253 30.66776275637494)
LINESTRING(104.06133651762504 30.66513061547994,104.06744003354108 30.66520690782454)
LINESTRING(104.06133651762504 30.662803649202033,104.06736374250615 30.663337707401297)
LINESTRING(104.06232833774995 30.660285949443278,104.06763076898643 30.660781860815405)

POLYGON((104.057874680002 30.65196990964523,104.0613269802998 30.6519889830588,104.05997276335258 30.64998626644865,104.057874680002 30.65196990964523))

MULTILINESTRING ((104.043827058631 30.64563751310743,104.04817581133102 30.640754698279125),(104.04817581133102 30.640754698279125,104.08449173090048 30.641326901995853))

POINT(104.12048340775073 30.710449228936344)
POINT(103.97399900481105 30.79467767471215)

 

 

 

heitaoc
关注
  • 2
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Elasticsearch 在地理信息空间索引的探索和演进
m0_56069948的博客
06-27 192
本文梳理了Elasticsearch对于数值索引实现方案的升级和优化思考，从2015年至今数值索引的方案经历了多个版本的迭代，实现思路从最初的字符串模拟到KD-Tree，技术越来越复杂，能力越来越强大，应用场景也越来越丰富。从地理位置信息建模到多维坐标，数据检索到数据分析洞察都可以看到Elasticsearch的身影。LBS服务是当前互联网重要的一环，涉及餐饮、娱乐、打车、零售等场景。在这些场景中，有很重要的一项基础能力：搜索附近的POI。比如搜索附近的美食，搜索附近的电影院，搜索附近的专车，搜索附近的门店
[ElasticSearch] 空间搜索 （一）
weixin_33946605的博客
08-01 264
依据索引文档的地理坐标来进行搜索。Elasticsearch 也可以处理这种搜索。——空间搜索 一、为空间搜索准备映射 PUT my_space_test { "mappings": { "poi": { "properties": { "name": { "type": "string" },
使用Java的@Setting和@Mapping定义elasticsearch索引
最新发布
高性价比服务器就选：蓝易云
05-18 443
首先，我需要说明的是，Java在Elasticsearch中没有直接使用@Setting和@Mapping这些注解的定义索引的方法。在此，我将指导你如何利用Java和Elasticsearch的官方Rest High Level Client来创建新的索引，并定义索引的Settings和Mappings。在这段代码中，我们为"test_index"设置了3个分片和2个副本，同时我们在Mappings中定义了两个字段：一个"text"类型的"name"字段和一个"integer"类型的"age"字段。
关于elaticsearch中更新数据的几种方式
三劫散仙
03-21 1079
作为一个成熟的框架，Elasticsearch里面提供了丰富的操作数据的api，本篇我们就来学习一下在es中更新数据的几种方式。 （一）更新文档 （1）部分更新： java api： [code="java"]```` ` HashMap data=new HashMap(); data.put("name","woshigcs")...
干货｜Elasticsearch 在地理信息空间索引的探索和演进
huzechen的博客
07-14 537
vivo 互联网服务器团队- Shuai Guangying本文梳理了Elasticsearch对于数值索引实现方案的升级和优化思考，从2015年至今数值索引的方案经历了多个版本的迭代，实现思路从最初的字符串模拟到KD-Tree，技术越来越复杂，能力越来越强大，应用场景也越来越丰富。从地理位置信息建模到多维坐标，数据检索到数据分析洞察都可以看到Elasticsearch的...
Spring Boot elasticsearch7.6.2基础操作：创建索引、新增数据、查询数据
04-29
在本文中，我们将深入探讨如何使用Spring Boot与Elasticsearch 7.6.2进行基本操作，包括创建索引、添加数据以及查询数据。Elasticsearch是一个强大的分布式搜索引擎，而Spring Boot是Java开发中的轻量级框架，两者...
python3实现elasticsearch批量更新数据
01-20
废话不多说，直接上代码！ updateBody = { query:{ range:{ write_date: { gte: 2019-01-15 12:30:17, lte: now } } }, script: { inline: ctx._source.index = params.index, params: { ...}
ElasticSearch java开发Demo(5.1.5)_Javaelasticsearch_ES使用java开发_ela
10-03
在Java环境中，我们可以使用官方提供的Java API来与Elasticsearch进行交互，实现数据的索引、查询、更新和删除等操作。 **一、Elasticsearch Java API** 1. **安装与配置**: 首先，你需要在项目中引入Elastic...
使用Python操作Elasticsearch数据索引的教程
12-24
Elasticsearch是一个分布式、Restful的搜索及分析服务器，Apache Solr一样，它也是基于Lucence的索引服务器，但我认为Elasticsearch对比Solr的优点在于： 轻量级：安装启动方便，下载文件之后一条命令就可以启动； ...
python elasticsearch从创建索引到写入数据的全过程
09-18
Python Elasticsearch 是一个用于操作Elasticsearch的客户端库，它提供了丰富的接口来实现对Elasticsearch的各种操作，包括创建索引、插入数据等。在本文中，我们将深入探讨如何使用Python Elasticsearch 从创建索引...
什么是 Elasticsearch 索引？
Elastic 中国社区官方博客
07-18 1446
索引这个术语在科技界已经被用满了。如果你问大多数开发人员什么是索引，他们可能会告诉你索引通常指的是关系数据库 (RDBMS) 中与表关联的数据结构，它提高了数据检索操作的速度。但什么是 Elasticsearch® 索引？Elasticsearch 索引是一个逻辑命名空间，它保存文档集合，其中每个文档都是字段的集合，而字段又是包含数据的键值对。
elasticsearch 插入 geo_point数据_5分钟掌握Elasticsearch空间查询之geo_point
weixin_42349135的博客
12-28 1539
我们都知道，Elasticsearch是一个全文检索引擎，其强大的全文检索能力可以支撑非常多的业务系统。但其实除了常规的数据类型，es还可以支持空间数据类型。目前Es可以支持两种空间数据类型，geo_point，geo_shape。笔者今天着重介绍一下Elasticsearch对geo_point数据类型的支持。kibana渲染geo_point数据geo_point类型，实际上是经纬度的组合，主...
ES geo_shape查询
weixin_40872468的博客
04-07 2425
ES geo_shape 查询 今天遇到一个网友询问关于一个地理位置查询的问题。 类似美团，饿了么是如何判断用户是否在商店的配送范围了？ 我的第一反应是以用户为中心，做矩形或者圆形范围查询，现在很多数据库Mongo 以及ES 都支持这种地理位置范围查询。以及距离查询算法等等 但是其实是我理会错了提问者的真实意图。因为类似美团，饿了么的查询都不是以用户为中心进行检索的，而是以商家为中心，判断用户是...
java连接Elasticsearch索引的创建、数据的增删改查操作
热门推荐
叫我一横
10-10 1万+
1、创建Maven工程 　　添加pom依赖，pom.xml代码如下 &lt;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...
Elasticsearch的索引机制分析
qq_43662627的博客
08-15 229
Elasticsearch一个开源的搜索搜索和分析引擎，具有存储和分析一体的非sql的文档搜索引擎。 新型的索引方式 Elasticsearch用于文档型数据的搜索，用于文档型数据的查询和分析。如果将直接将文档id绑定到关键词的正排的索引结构的k-v结构，在互联网中海量数据的使用，会产生大量的索引，占用巨大内存空间空间，降低索引的性能。 Elasticsearch摒弃了传统的结构化的数据库或者兴起的k-v结构，而采用v-k倒排索引。 什么是倒排索引？ 倒排索引是Elasticsearch将文档内具有关键字的
es空间检索
仅做个人笔记
02-02 621
方案优化的探索是没有没有止境的，Lucene的核心工程师 Michael McCandless受到论文《Bkd-Tree: A Dynamic Scalable kd-Tree》启发，基于BKD tree再次升级了地理位置数据索引建模和查询功能。在前面的版本中，对于数值区间查询的处理思路本质上都是term匹配，通过前缀实现了一个term管理一个区间，从而降低了区间查询需要遍历的term数量。搜索的时候，就不再是像Quadtree从整个世界开始定位，而是基于当前的点集合形成的空间来查找。
java es API 6.5.0 批量存储
qq_37524923的博客
02-25 657
private static String INDEX = "xxx"; private static String TYPE = "xxx"; JSONObject json = new JSONObject(); BulkRequestBuilder BULCREQUEST = client.prepareBulk(); BULCREQUEST.add(client.prepa...
elasticsearch geo_shape within
09-01
elasticsearch的geo_shape within是一个地理形状查询操作，用于查询位于指定形状内部的地理点或地理形状。 在elasticsearch中，地理形状由经纬度坐标点组成，可以表示一片地区的多边形或圆形等。而geo_shape within...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值