Lucene工作总结

最新推荐文章于 2024-09-30 14:30:57 发布
最新推荐文章于 2024-09-30 14:30:57 发布
阅读量56 收藏
点赞数
分类专栏： 开源程序 文章标签： 工作 lucene Java Oracle Apache
公司项目：portal中期刊文章内容作为大字段存储在Oracle中，首页有一个搜索功能：要求将所有包括搜索字段的文章的标题列出来（文章的内容存储在Oracle的CLOB字段中），也就是要用Lucene实现对数据库的大字段进行索引(索引通过计划任务定时建立索引)和搜索。。。

==================定时建立索引文件:===============

Main方法: 

 package zxt.lucene.index;

import java.util.Timer;
public class IndexerServer {


	/**
	 * 定时调用建立索引任务
	 * @author wulihai
	 * @create 2009-06-02
	 */
	public static void main(String[] args) {
		String propFile = "directory.properties";
		Config.setConfigFileName(propFile);
		Timer	timer = new Timer();
		LuceneDBIndexerTask luceneTask=LuceneDBIndexerTask.getInstance(); 
		timer.scheduleAtFixedRate(luceneTask, 0,DataTypeUtil.toLong(Constant.CREATE_INDEX_SLEEP_TIME));
	}

}




定时调用建立索引任务： 

package zxt.lucene.index;

import java.util.Timer;
public class IndexerServer {


	/**
	 * 定时调用建立索引任务
	 * @author wulihai
	 * @create 2009-06-02
	 */
	public static void main(String[] args) {
		String propFile = "directory.properties";
		Config.setConfigFileName(propFile);
		Timer	timer = new Timer();
		LuceneDBIndexerTask luceneTask=LuceneDBIndexerTask.getInstance(); 
		timer.scheduleAtFixedRate(luceneTask, 0,DataTypeUtil.toLong(Constant.CREATE_INDEX_SLEEP_TIME));
	}

}




建立索引的核心实现： 

package zxt.lucene.index;
import java.io.BufferedReader;
import java.io.File;
import java.io.IOException;
import java.io.StringWriter;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.text.SimpleDateFormat;
import java.util.Arrays;
import java.util.Date;
import java.util.TimerTask;

import oracle.sql.CLOB;

import org.apache.lucene.analysis.standard.StandardAnalyzer;
import org.apache.lucene.document.Document;
import org.apache.lucene.document.Field;
import org.apache.lucene.index.IndexWriter;

  /**
  * 建立索引的任务类
  * @author wulihai
  * @create 2009-06-02
 */
public class LuceneDBIndexerTask extends TimerTask {
	//缺省索引目录
	private static String DEFAULT_INDEX_DIR="C:\\IndexDB";
	 //临时索引目录的父目录
    private File parentDir=null;
     //被搜索的索引文件
	private static LuceneDBIndexerTask index=new LuceneDBIndexerTask();

	//构造方法
	private LuceneDBIndexerTask(){
		String dirStr=Constant.INDEX_STORE_DIRECTORY;
		if(dirStr!=null&&!"".equals(dirStr)){
			this.parentDir=new File(dirStr);

		}else{
			this.parentDir=new File(DEFAULT_INDEX_DIR);
		}

		if(!this.parentDir.exists()){
			this.parentDir.mkdir();
		}
	}

	/**
	 * 单实例访问接口
	 * @return
	 */
	public static LuceneDBIndexerTask getInstance(){
		return index;
	}

	 /**
	 * 锁定目录以及文件
	 * 只允许单线程访问
	 *
	 */
	/*public synchronized  void singleRunning(){
		if(flag==false){
			flag=true;
			run(parentDir);	
		}
	}*/

	 /**
	 * 为数据库字段建立索引
	 */
	public  void run()  {
		System.out.println("====LuceneDBIndexerTask$run()===============");

		System.out.println("~~~开始建立索引文件~~~~~~~~~~~~~~~");
		Connection conn=null;
		Statement stmt=null;
		ResultSet rs=null;
		try {
			Class.forName(Constant.DB_DRIVER_STRING);
			 conn = DriverManager.getConnection(Constant.DB_URI_STRING, Constant.DB_USERNAME, Constant.DB_PWD);
			 stmt = conn.createStatement();
			 rs = stmt.executeQuery(Constant.DB_QUERY_STRING);
			 File file=new File(parentDir+File.separator+new SimpleDateFormat("yyyyMMddHHmmss").format(new Date())+File.separator);
			 if(!file.exists()){
				 file.mkdir();
			 }
			IndexWriter writer = new IndexWriter(file,new StandardAnalyzer(), true);
			long startTime = new Date().getTime();
			while (rs.next()) {
				Document doc = new Document();
				 doc.add(new Field("ARTICLEID", rs.getString("ARTICLEID"), Field.Store.YES,Field.Index.TOKENIZED));
				 doc.add(new Field("TITLE", rs.getString("TITLE"), Field.Store.YES,Field.Index.TOKENIZED));
				 doc.add(new Field("USERNAME", rs.getString("USERNAME"), Field.Store.YES,Field.Index.TOKENIZED));
				 doc.add(new Field("USERID", rs.getString("USERID"), Field.Store.YES,Field.Index.TOKENIZED));
				 //对日期建立索引
				 String createdate=new SimpleDateFormat("yyyy-MM-dd").format(rs.getTimestamp("CREATEDATE"));
				 doc.add(new Field("CREATEDATE", createdate, Field.Store.YES,Field.Index.TOKENIZED));
			     //对大字段建立索引
			     BufferedReader in=null;
			     String content="";
			     CLOB clob =  (CLOB) rs.getClob("CONTENT");
			     if (clob != null) {
			    	//得到一个读入流
			      in=new BufferedReader(clob.getCharacterStream());
			      StringWriter out=new StringWriter();
                  int c;
                  while((c=in.read())!=-1){
                	  out.write(c);
                   }
                  content=out.toString();
			    }
			    doc.add(new Field("CONTENT", content, Field.Store.YES, Field.Index.TOKENIZED));
			    writer.addDocument(doc);
			}
			writer.optimize();
			writer.close();

			//测试一下索引的时间   
			long endTime = new Date().getTime();
			System.out.println("索引文件"+file.getPath()+"建立成功...");
			System.out.println("这花费了" + (endTime - startTime) + " 毫秒来把文档增加到索引里面去!");


			//判断文件目录file下的文件个数如果大于3，就将文件建立最早的文件给删除掉
			checkFiles(parentDir);

		} catch (IOException e) {
			e.printStackTrace();
		} catch (SQLException e) {
			e.printStackTrace();
		} catch (ClassNotFoundException e) {
			e.printStackTrace();

		}finally{
		 try {
			 if(rs!=null){
			   rs.close();	 
			 }
			 if(stmt!=null){
				 stmt.close();	 
		      }	
			 if(conn!=null){
				 conn.close();	 
		      }	
			} catch (SQLException e) {
				e.printStackTrace();
			}
		}
	}

	 /**
	 * 判断文件目录file下的文件个数如果大于3，就将文件建立最早的文件给删除掉
	 */
	public  void checkFiles(File dir) {
		int length=dir.listFiles().length;
		while(length>3){
			//删除生成最早的文件
		 File [] files=dir.listFiles();
		 String[] names=dir.list();
		 Arrays.sort(names);
		 File deletefile=files[0];
		 deleteDirectory(deletefile);
		 length--;
	   }

	}

	/*
	 * 递归删除一个目录以及下面的文件
	 */
	public boolean deleteDirectory(File path) {   
	    if( path.exists() ) {   
	      File[] files = path.listFiles();   
	      for(int i=0; i<files.length; i++) {   
	         if(files[i].isDirectory()) {   
	           deleteDirectory(files[i]);  

	         }   
	         else {   
	        	 //删除文件
	           files[i].delete();   
	         }   
	      }   
	    }   
	    //删除目录
	    boolean hasdelete=path.delete();
	    if(hasdelete){
	    	System.out.println("删除索引目录"+path);

	    }
		return hasdelete;


	  }   





	public static void main(String[] args) {
	  new LuceneDBIndexerTask().run();

	}


}





配置文件管理类： 

package zxt.lucene.index;

import java.io.IOException;
import java.io.InputStream;
import java.util.Properties;

/**
 * 
 * @author wulihai
 * @create 2009-06-02
 *
 */
public class Config {

	private static Config cfg = null;

	private static String configFileName = null;

	private Properties props;

	public Config() {
		props = new java.util.Properties();
	}

	/**
	 * 单例访问接口
	 * @return
	 */
	public synchronized static Config getInstance() {
		if (cfg == null) {
			cfg = new Config();
			cfg.loadConfig();
			return cfg;
		} else {
			return cfg;
		}

	}

	private int loadConfig() {
		if (configFileName != null || configFileName.length() > 0) {
			InputStream inputStream = Config.class.getClassLoader()
					.getResourceAsStream("directory.properties");
			System.out.println("configFileName=" + configFileName);
			try {
				props.load(inputStream);
			} catch (IOException e) {
				e.printStackTrace();
			}
			return 1;
		}
		return 0;

	}

	public static void setConfigFileName(String cfg) {
		configFileName = cfg;
	}

	public String getProperty(String keyName) {
		return props.getProperty(keyName);
	}

}



常量配置 

package zxt.lucene.index;

/**
 * 常量配置类 *
 * @author wulihai
 * @create 2009-06-02
 */
public class Constant {

	// 隔多长时间建立一次索引
	public static final String CREATE_INDEX_SLEEP_TIME = Config.getInstance()
			.getProperty("create_index_sleep_time");

	// 索引文件存放路径
	public static final String INDEX_STORE_DIRECTORY = Config.getInstance()
			.getProperty("index_store_directory");
	//数据库驱动程序
	public static final String DB_DRIVER_STRING = Config.getInstance()
	.getProperty("db_driver_string");
	//数据库连接URI
	public static final String DB_URI_STRING = Config.getInstance()
	.getProperty("db_uri_string");
	//数据库连接username
	public static final String DB_USERNAME= Config.getInstance()
	.getProperty("db_username");
     //数据库连接pwd
	public static final String DB_PWD= Config.getInstance()
	.getProperty("db_pwd");
	//数据库查询语句db_query_str
	public static final String DB_QUERY_STRING= Config.getInstance()
	.getProperty("db_query_string");

}




数据类型处理类： 

package zxt.lucene.index;

/**
 * 数据类型转换工具类
 * @author wulihai
 * @create 2009-06-02
 */
public class DataTypeUtil {
	 /**
     * 将对象转换为整数型
     * @param o  源对象
     * @return 对应的Long值,如果出错,则返回Long.MIN_VALUE
     */
    public static long toLong(Object o) {
        if (o == null) {
            throw new IllegalArgumentException("该对象为空");
        }
        String s = o.toString();
        try {
            return Long.parseLong(s);
        } catch (Exception ex) {
            return Long.MAX_VALUE;
        }
    }
}





配置文件 ： 



#== the directory for store lucene-index ========#
index_store_directory=D:/lucene/indexDB/

#======== two hours ========#
#create_index_sleep_time=7200000

#======== two minutes ========#
create_index_sleep_time=120000

db_driver_string=oracle.jdbc.driver.OracleDriver
db_uri_string=jdbc:oracle:thin:@localhost:1521:lportal
db_username=lportal
db_pwd=lportal
db_query_string=SELECT  * from journalarticle



==================搜索类:===============

核心搜索类： 

package com.liferay.portal.util;

import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Date;
import java.util.List;

import org.apache.lucene.analysis.Analyzer;
import org.apache.lucene.analysis.standard.StandardAnalyzer;
import org.apache.lucene.document.Document;
import org.apache.lucene.queryParser.ParseException;
import org.apache.lucene.queryParser.QueryParser;
import org.apache.lucene.search.Hits;
import org.apache.lucene.search.IndexSearcher;
import org.apache.lucene.search.Query;
import org.apache.lucene.store.Directory;
import org.apache.lucene.store.FSDirectory;
import com.liferay.portlet.journal.model.JournalArticle;

/**
 * 负责搜索的类
 */
public class LuceneDBQuery {

	private static LuceneDBQuery search = new LuceneDBQuery();

	// 构造方法
	private LuceneDBQuery() {

	}

	/**
	 * 单实例访问接口
	 * 
	 * @return
	 */
	public static LuceneDBQuery getInstance() {
		return search;
	}

	/**
	 * 搜索方法
	 * 
	 * @throws java.text.ParseException
	 * @throws Exception
	 */
	public List search(String queryString) {
		int count = 0;
		long startTime = new Date().getTime();
		Hits hits = null;

		// 搜索目录
		File searchDir = null;
		Query query = null;
		InputStream inputStream=null;;
         String filePath="index.xml";
         String indexDir="";
         indexDir= LuceneDBQueryUtil.getIndexPath();

		if (indexDir != null && !"".equals(indexDir)) {
			searchDir = new File(indexDir);
			if(!searchDir.exists()){
				searchDir.mkdir();
			}
		}
		// 这里注意索引存放的目录的父目录
		// searchDir=new File("E:\\index\\indexDB\\");
		File targetDir = getTargetDir(searchDir);
		IndexSearcher searcher = null;
		List results = new ArrayList();

		try {
			Directory dir=FSDirectory.getDirectory(targetDir,false);
			searcher = new IndexSearcher(dir);
		} catch (Exception e1) {
			e1.printStackTrace();
			System.out.println("创建索引对象出现异常...");
		} 
		Analyzer analyzer = new StandardAnalyzer();

		// 构建查询对象Query,对CONTENT字段进行搜索
		QueryParser qp = new QueryParser("CONTENT", analyzer);
		try {
			query = qp.parse(queryString);
		} catch (ParseException e1) {
			e1.printStackTrace();
		}

		if (searcher != null) {

			// 得到搜索结果Hits
			try {
				hits = searcher.search(query);
			} catch (IOException e1) {
				System.out.println("查询索引库出现异常...");
				e1.printStackTrace();
			}
			// 查到的记录条数
			count = hits.length();
			if (hits.length() > 0) {
				for (int i = 0; i < hits.length(); i++) {// 输出搜索信息
					JournalArticle article = new JournalArticle();
					Document document = null;
					try {
						document = hits.doc(i);
					} catch (Exception e1) {
						System.out.println("返回查询结果集出现异常...");
						e1.printStackTrace();
					} 
					try {
						article.setDisplayDate(new SimpleDateFormat("yyyyMMdd")
								.parse(document.get("CREATEDATE")));
						article.setCreateDate(new SimpleDateFormat("yyyyMMdd")
								.parse(document.get("CREATEDATE")));
					} catch (java.text.ParseException e) {
						e.printStackTrace();
					}
					article.setTitle(document.get("TITLE"));
					article.setArticleId(document.get("ARTICLEID"));
					article.setUserName(document.get("USERNAME"));
					article.setUserId(document.get("USERID"));
					results.add(article);
				}
				// 测试一下索引的时间
				long endTime = new Date().getTime();
				System.out.println("查询过程花费了" + (endTime - startTime) + " 毫秒!");
			} else {
				System.out.println("0个结果!");
			}
		}

		return results;

	}

	/**
	 * 确定搜索索引所在目录目录
	 */
	private File getTargetDir(File dir) {
		int length = dir.listFiles().length;
		File searchFile = null;

		// length=3的时候最多
		// 同时搜索和同时建索引的时候会出现length=4
		if (length >= 2) {
			// 找到次最新建立的索引文件
			String[] names = dir.list();
			Arrays.sort(names);
			searchFile = new File(dir + File.separator + names[length - 2]);
		}
		if (length == 1) {
			File files[] = dir.listFiles();
			searchFile = files[0];
		}
		if (length == 0) {
			// 如果没有索引文件则，建立第一个索引
			// TestDBIndexer.getInstance().isInstanceRunning();
			// search();
		}

		return searchFile;
	}
//
//	public static void main(String[] args) throws Exception {
//		new LuceneDBQuery().search("纳税人");
//	}

}




配置文件管理类: 


package com.liferay.portal.util;

import java.io.IOException;

import org.jdom.Document;
import org.jdom.Element;
import org.jdom.JDOMException;
import org.jdom.input.SAXBuilder;

public class LuceneDBQueryUtil {

 public static String getIndexPath(){

		String filePath = "zxt_index.xml";
		String indexPath="";
		SAXBuilder builder = new SAXBuilder(false);
		try {
			Document doc = builder.build(Thread.currentThread().getContextClassLoader().getResource(filePath));
			Element rootElement = doc.getRootElement();
			 Element index=rootElement.getChild("index");
			 indexPath=index.getText();
			 System.out.println(indexPath);
		} catch (JDOMException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}
		return indexPath;


 }
}



配置文件：zxt_index.xml 


<?xml version="1.0" encoding="UTF-8"?>
<list>
 <index>D:\\index\\IndexDB</index>
</list>


wlh269
关注
专栏目录
Java搜索工具——Lucene实例总结(一)
04-23
创建索引是Lucene工作的第一步。这涉及到添加文档到一个名为“IndexWriter”的对象，该对象负责将文档转化为倒排索引。例如： ```java Directory indexDir = FSDirectory.open(Paths.get("index_path")); ...
lucene个人总结
05-08
- **作用**：此包中的类主要用于对需要建立索引的文本进行分词、过滤等预处理工作。它是Lucene全文检索的基础。 - **核心类**： - **Analyzer**：抽象类，管理对文本内容的切分词规则。Analyzer类用于将文档分割成...
Lucene踩坑总结
zoroduyu的博客
09-25 4526
前言 感觉好久都没写博客了，前段时间工作忙，实在没时间写。这段时间稍微空闲下来，抽点空，记录下这段时间上工作遇到的问题。 文章概要 对自己这段时间在工作中使用Lucene遇到的一些问题进行总结和归纳，并将解决方法给出，以供大家学习和参考。 详述 问题1: 报错：Lock held by this virtual machine 问题描述： 不知道各位小伙伴在写Lucene的过程中有没有遇到Lock...
Lucene学习总结
让人生充满永动的势能
11-09 441
一）       什么是Lucene？    Lucene是apache软件基金会发布的一个开放源代码的全文检索引擎工具包，由资深全文检索专家Doug Cutting所撰写,它是一个全文检索引擎的架构，提供了完整的创建索引和查询索引，以及部分文本分析的引擎，Lucene的目的是为软件开发人员提供一个简单易用的工具包，以方便在目标系统中实现全文检索的功能，或者是以此为基础建立起完整的全文检索引
lucene4.7总结
sunshaoshan163的专栏
09-28 491
学习目录 （1）什么是lucene （2）lucene常用类详解 （3）lucene简单实例 （4）lucene常用分词器 （5）lucene多条件查询 （6）修改删除索引 （7）lucene优化、排序 （8）lucene高亮显示 （9）lucene分页 （10）lucene注意几点 一、什么是lucene         Lucene是一套用于全文检索和搜寻的开源程式
lucene中文分词总结
QSEFDWA的博客
07-12 420
全文检索几乎是所有内容管理系统软件（CMS）必备的功能，在对公司的CMS产品的开发维护过程中，全文检索始终是客户重点关注的模块，为满足客户各式各样越来越高的要求，对全文检索曾做过一段时间相对深入的研究，尤其是对分词机制，趁如今换工作比较空闲之际做个简单总结。   1、 什么是中文分词 学过英文的都知道，英文是以单词为单位的，单词与单词之间以空格或者逗号句号隔开。而中文则以字为单位，字又组成词
lucene4.7学习总结
zhao1949的专栏
10-24 414
http://blog.csdn.net/mdcmy/article/details/38167955?utm_source=tuicool&utm_medium=referral *******************************************************************************         花了一段时间学习lucene今
Lucene学习总结三
让人生充满永动的势能
11-11 444
前两篇，讲到了lucene的一些用法，这一篇，我们继续lucene的其他的特性 一）       索引库优化      1．1什么是索引库      索引库是Lucene的重要的存储结构，它包括二部份：原始记录表，词汇表      原始记录表：存放的是原始记录信息，Lucene为存入的内容分配一个唯一的编号      词汇表：存放的是经过分词器拆分出来的词汇和该词汇在原始记录表中的
Lucene总结
郑斑
03-26 211
一 认识 lucene的检索算法属于索引检索，即用空间来换取时间，对需要检索的文件、字符流进行全文索引，在检索的时候对索引进行快速的检索，得到检索位置，这个位置记录检索词出现的文件路径或者某个关键词。 在使用数据库的项目中，不使用数据库进行检索的原因主要是：数据库在非精确查询的时候使用查询语言“like %keyword%”，对数据库进行查询是对所有记录遍历，并对字段进行“%keyword%”...
lucene项目实战总结
qq_36812650的博客
03-08 530
 lucene:简单点说就是扫描文章，将每一句话拆分成词语，并用这些词建立一个索引，因为各个国家语言不同，词语拆分的方法也不同，所以分词器也是不同的,将这些索引存储在特殊的文件中，当用户查询时根据建立的索引查找，类似于通过字典的检索字表查字的过程Lucene 软件包分析Lucene 软件包的发布形式是一个 JAR 文件，下面我们分析一下这个 JAR 文件里面的主要的 JAVA 包Package: ...
Lucene
weixin_41942838的博客
04-26 357
Lucene 倒排索引讲解 顺序扫描 分词器 域(表的字段、JavaBean的属性) 1 Lucene介绍 1.1.1 为什么要学Lucene 实现商城里面的商品搜索功能，可以根据商品标题模糊查询商品。 原来的方式实现搜索功能，我们的搜索流程如下图： 上图就是原始搜索引擎技术，如果用户比较少而且数据库的数据量比较小，那么这种方式实现搜索功能在企业中是比较常见的。 但是数据量过多时，数据库的压力就会变得很大，查询速度会变得非常慢。我们需要使用更好的解决方案来分担数据库的压力。 现在的方案
Lucene学习总结之一：全文检索的基本原理[归纳].pdf
10-19
文档索引。在全文检索中，Lucene是一个关键的工具，它是一个高效的、基于Java的全文检索库。全文检索主要用于处理非结构化...理解和掌握全文检索的基本原理以及Lucene的工作机制，对于开发高效率的搜索引擎至关重要。
LuceneDemo
12-20
总结，Lucene是一个强大且灵活的全文检索库，它不仅提供了核心的搜索功能，还允许开发者通过定制化实现各种复杂的搜索需求。在实际项目中，结合如Solr或Elasticsearch这样的高级搜索服务器，可以构建出更强大的企业...
【Unity】Luban学习笔记
Davidorzs的博客
09-30 1086
自己学习Luban时的一些笔记，方便以后复习。
unity一键注释日志和反注释日志
yangjie6898862的专栏
09-30 841
1.先检测代码中是否存在不规范代码，类似if(a > 1) Debug.Log("11") 这种代码如果注释掉日志会引起业务逻辑问题需要先找出来，类似的不限于if else for foreach while这些 所以尽可能的要做这个检测，有这类问题直接报错。2.注释Debug.Log或者UnityEngine.Debug.Log，但是有一个问题就是注释之后再注释的问题，所以在调用这个接口前需要调用反注释然后调用注释，这样就可以保证注释是没有问题的。Log($"请使用括号封装你的日志！
微信小程序Artandw_eapp-artand.zip
10-04
微信小程序Artandw_eapp-artand
基于Vue和JavaScript的心旅途个性化推荐旅游平台设计源码
10-04
本项目是一款基于Vue和JavaScript开发的心旅途个性化推荐旅游平台设计源码，整合了513个Java文件、76个PNG图片、70个XML配置文件、62个JavaScript文件、42个Vue组件文件、28个CSS样式文件、22个HTML文件、18个YAML配置文件、16个属性文件、11个Vue模板文件，总计919个文件。平台采用现代化前端技术堆栈，旨在为用户提供个性化的旅游推荐服务。
微信小程序开发地图演示、地图导航、标记标注_echat-weapp-mpdemo.zip
最新发布
10-04
微信小程序开发地图演示、地图导航、标记标注_echat-weapp-mpdemo
Lucene工作原理与全文搜索引擎
"Lucene工作原理及其重要算法细节解析" Lucene是一个强大的全文搜索引擎库，源自Apache软件基金会，被广泛应用于各种全文检索应用的开发。它采用先进的倒排索引技术，提供高效的搜索性能。下面我们将深入探讨Lucene...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值