solr6.0 -MySQL定时增量、全量更新索引

最新推荐文章于 2024-02-07 00:13:41 发布
最新推荐文章于 2024-02-07 00:13:41 发布
阅读量5.9k 收藏 2
点赞数 1
分类专栏： solr 文章标签： solr
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/alecf/article/details/52302783
版权

上一篇里面有增量更新索引
这里写图片描述

执行完就可以看到D:\search\solr\home\ask\conf下自动生成了一个dataimport.properties文件，里面是最后更新索引时间，就是根据这个时间来达到增量更新的
定时更新索引，还是借鉴以前有位哥们的
http://www.cnblogs.com/ezhangliang/archive/2012/04/11/2441945.html
solr6.0的只是引入资源文件的地方改一下，很多地方源码都不全，这里给出全部的
这里写图片描述

SolrDataImportProperties

package org.apache.solr.handler.dataimport.scheduler;

import org.apache.solr.core.SolrResourceLoader;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.util.Properties;

public class SolrDataImportProperties {
    private Properties properties;
    public static final String SYNC_ENABLED = "syncEnabled";
    public static final String SYNC_CORES = "syncCores";
    public static final String SERVER = "server";
    public static final String PORT = "port";
    public static final String WEBAPP = "webapp";
    public static final String PARAMS = "params";
    public static final String INTERVAL = "interval";
    public static final String REBUILDINDEXPARAMS = "reBuildIndexParams";
    public static final String REBUILDINDEXBEGINTIME = "reBuildIndexBeginTime";
    public static final String REBUILDINDEXINTERVAL = "reBuildIndexInterval";
    private static final Logger logger = LoggerFactory.getLogger(SolrDataImportProperties.class);

    public void loadProperties(boolean force) {
        try {
            SolrResourceLoader loader = new SolrResourceLoader();
            logger.info("Instance dir = " + loader.getInstancePath());
            String configDir = loader.getConfigDir();
            configDir = SolrResourceLoader.normalizeDir(configDir);
            if ((force) || (this.properties == null)) {
                this.properties = new Properties();
                String dataImportPropertiesPath = configDir + "dataimport.properties";
                FileInputStream fis = new FileInputStream(dataImportPropertiesPath);
                this.properties.load(fis);
            }
        } catch (FileNotFoundException fnfe) {
            logger.error(
                    "Error locating DataImportScheduler dataimport.properties file",
                    fnfe);
        } catch (IOException ioe) {
            logger.error(
                    "Error reading DataImportScheduler dataimport.properties file",
                    ioe);
        } catch (Exception e) {
            logger.error("Error loading DataImportScheduler properties", e);
        }
    }

    public String getProperty(String key) {
        return this.properties.getProperty(key);
    }
}

BaseTimerTask

package org.apache.solr.handler.dataimport.scheduler;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.io.IOException;
import java.net.HttpURLConnection;
import java.net.MalformedURLException;
import java.net.URL;
import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Timer;
import java.util.TimerTask;

public abstract class BaseTimerTask extends TimerTask {
    protected String syncEnabled;
    protected String[] syncCores;
    protected String server;
    protected String port;
    protected String webapp;
    protected String params;
    protected String interval;
    protected String cores;
    protected SolrDataImportProperties p;
    protected boolean singleCore;

    protected String reBuildIndexParams;
    protected String reBuildIndexBeginTime;
    protected String reBuildIndexInterval;

    protected static final Logger logger = LoggerFactory
            .getLogger(BaseTimerTask.class);

    public BaseTimerTask(String webAppName, Timer t) throws Exception {
        // load properties from global dataimport.properties
        p = new SolrDataImportProperties();
        reloadParams();
        fixParams(webAppName);

        if (!syncEnabled.equals("1"))
            throw new Exception("Schedule disabled");

        if (syncCores == null
                || (syncCores.length == 1 && syncCores[0].isEmpty())) {
            singleCore = true;
            logger.info("<index update process> Single core identified in dataimport.properties");
        } else {
            singleCore = false;
            logger.info("<index update process> Multiple cores identified in dataimport.properties. Sync active for: "
                    + cores);
        }
    }

    protected void reloadParams() {
        p.loadProperties(true);
        syncEnabled = p.getProperty(SolrDataImportProperties.SYNC_ENABLED);
        cores = p.getProperty(SolrDataImportProperties.SYNC_CORES);
        server = p.getProperty(SolrDataImportProperties.SERVER);
        port = p.getProperty(SolrDataImportProperties.PORT);
        webapp = p.getProperty(SolrDataImportProperties.WEBAPP);
        params = p.getProperty(SolrDataImportProperties.PARAMS);
        interval = p.getProperty(SolrDataImportProperties.INTERVAL);
        syncCores = cores != null ? cores.split(",") : null;

        reBuildIndexParams = p
                .getProperty(SolrDataImportProperties.REBUILDINDEXPARAMS);
        reBuildIndexBeginTime = p
                .getProperty(SolrDataImportProperties.REBUILDINDEXBEGINTIME);
        reBuildIndexInterval = p
                .getProperty(SolrDataImportProperties.REBUILDINDEXINTERVAL);

    }

    protected void fixParams(String webAppName) {
        if (server == null || server.isEmpty())
            server = "localhost";
        if (port == null || port.isEmpty())
            port = "8080";
        if (webapp == null || webapp.isEmpty())
            webapp = webAppName;
        if (interval == null || interval.isEmpty() || getIntervalInt() <= 0)
            interval = "30";
        if (reBuildIndexBeginTime == null || reBuildIndexBeginTime.isEmpty())
            interval = "00:00:00";
        if (reBuildIndexInterval == null || reBuildIndexInterval.isEmpty()
                || getReBuildIndexIntervalInt() <= 0)
            reBuildIndexInterval = "0";
    }

    protected void prepUrlSendHttpPost(String params) {
        String coreUrl = "http://" + server + ":" + port + "/" + webapp
                + params;
        sendHttpPost(coreUrl, null);
    }

    protected void prepUrlSendHttpPost(String coreName, String params) {
        String coreUrl = "http://" + server + ":" + port + "/" + webapp + "/"
                + coreName + params;
        sendHttpPost(coreUrl, coreName);
    }

    protected void sendHttpPost(String completeUrl, String coreName) {
        DateFormat df = new SimpleDateFormat("dd.MM.yyyy HH:mm:ss SSS");
        Date startTime = new Date();

        // prepare the core var
        String core = coreName == null ? "" : "[" + coreName + "] ";

        logger.info(core
                + "<index update process> Process started at .............. "
                + df.format(startTime));

        try {

            URL url = new URL(completeUrl);
            HttpURLConnection conn = (HttpURLConnection) url.openConnection();

            conn.setRequestMethod("POST");
            conn.setRequestProperty("type", "submit");
            conn.setDoOutput(true);

            // Send HTTP POST
            conn.connect();

            logger.info(core + "<index update process> Full URL\t\t\t\t"
                    + conn.getURL());
            logger.info(core + "<index update process> Response message\t\t\t"
                    + conn.getResponseMessage());
            logger.info(core + "<index update process> Response code\t\t\t"
                    + conn.getResponseCode());

            // listen for change in properties file if an error occurs
            if (conn.getResponseCode() != 200) {
                reloadParams();
            }

            conn.disconnect();
            logger.info(core
                    + "<index update process> Disconnected from server\t\t"
                    + server);
            Date endTime = new Date();
            logger.info(core
                    + "<index update process> Process ended at ................ "
                    + df.format(endTime));
        } catch (MalformedURLException mue) {
            logger.error("Failed to assemble URL for HTTP POST", mue);
        } catch (IOException ioe) {
            logger.error(
                    "Failed to connect to the specified URL while trying to send HTTP POST",
                    ioe);
        } catch (Exception e) {
            logger.error("Failed to send HTTP POST", e);
        }
    }

    public int getIntervalInt() {
        try {
            return Integer.parseInt(interval);
        } catch (NumberFormatException e) {
            logger.warn(
                    "Unable to convert 'interval' to number. Using default value (30) instead",
                    e);
            return 30; // return default in case of error
        }
    }

    public int getReBuildIndexIntervalInt() {
        try {
            return Integer.parseInt(reBuildIndexInterval);
        } catch (NumberFormatException e) {
            logger.info(
                    "Unable to convert 'reBuildIndexInterval' to number. do't rebuild index.",
                    e);
            return 0; // return default in case of error
        }
    }

    public Date getReBuildIndexBeginTime() {
        Date beginDate = null;
        try {
            SimpleDateFormat sdfDate = new SimpleDateFormat("yyyy-MM-dd");
            String dateStr = sdfDate.format(new Date());
            beginDate = sdfDate.parse(dateStr);
            if (reBuildIndexBeginTime == null
                    || reBuildIndexBeginTime.isEmpty()) {
                return beginDate;
            }
            if (reBuildIndexBeginTime.matches("\\d{2}:\\d{2}:\\d{2}")) {
                SimpleDateFormat sdf = new SimpleDateFormat(
                        "yyyy-MM-dd HH:mm:ss");
                beginDate = sdf.parse(dateStr + " " + reBuildIndexBeginTime);
            } else if (reBuildIndexBeginTime
                    .matches("\\d{4}-\\d{2}-\\d{2} \\d{2}:\\d{2}:\\d{2}")) {
                SimpleDateFormat sdf = new SimpleDateFormat(
                        "yyyy-MM-dd HH:mm:ss");
                beginDate = sdf.parse(reBuildIndexBeginTime);
            }
            return beginDate;
        } catch (ParseException e) {
            logger.warn(
                    "Unable to convert 'reBuildIndexBeginTime' to date. use now time.",
                    e);
            return beginDate;
        }
    }

}

DeltaImportHTTPPostScheduler

package org.apache.solr.handler.dataimport.scheduler;

import java.util.Timer;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class DeltaImportHTTPPostScheduler extends BaseTimerTask {

    private static final Logger logger = LoggerFactory
            .getLogger(DeltaImportHTTPPostScheduler.class);

    public DeltaImportHTTPPostScheduler(String webAppName, Timer t)
            throws Exception {
        super(webAppName, t);
        logger.info("<index update process> DeltaImportHTTPPostScheduler init");
    }

    public void run() {
        try {
            // check mandatory params
            if (server.isEmpty() || webapp.isEmpty() || params == null
                    || params.isEmpty()) {
                logger.warn("<index update process> Insuficient info provided for data import");
                logger.info("<index update process> Reloading global dataimport.properties");
                reloadParams();
                // single-core
            } else if (singleCore) {
                prepUrlSendHttpPost(params);

                // multi-core
            } else if (syncCores.length == 0
                    || (syncCores.length == 1 && syncCores[0].isEmpty())) {
                logger.warn("<index update process> No cores scheduled for data import");
                logger.info("<index update process> Reloading global dataimport.properties");
                reloadParams();

            } else {
                for (String core : syncCores) {
                    prepUrlSendHttpPost(core, params);
                }
            }
        } catch (Exception e) {
            logger.error("Failed to prepare for sendHttpPost", e);
            reloadParams();
        }
    }
}

FullImportHTTPPostScheduler

package org.apache.solr.handler.dataimport.scheduler;

import java.util.Timer;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class FullImportHTTPPostScheduler extends BaseTimerTask {

    private static final Logger logger = LoggerFactory
            .getLogger(FullImportHTTPPostScheduler.class);

    public FullImportHTTPPostScheduler(String webAppName, Timer t)
            throws Exception {
        super(webAppName, t);
        logger.info("<index update process> DeltaImportHTTPPostScheduler init");
    }

    public void run() {
        try {
            // check mandatory params
            if (server.isEmpty() || webapp.isEmpty()
                    || reBuildIndexParams == null
                    || reBuildIndexParams.isEmpty()) {
                logger.warn("<index update process> Insuficient info provided for data import, reBuildIndexParams is null");
                logger.info("<index update process> Reloading global dataimport.properties");
                reloadParams();
                // single-core
            } else if (singleCore) {
                prepUrlSendHttpPost(reBuildIndexParams);

                // multi-core
            } else if (syncCores.length == 0
                    || (syncCores.length == 1 && syncCores[0].isEmpty())) {
                logger.warn("<index update process> No cores scheduled for data import");
                logger.info("<index update process> Reloading global dataimport.properties");
                reloadParams();

            } else {
                for (String core : syncCores) {
                    prepUrlSendHttpPost(core, reBuildIndexParams);
                }
            }
        } catch (Exception e) {
            logger.error("Failed to prepare for sendHttpPost", e);
            reloadParams();
        }
    }
}

ApplicationListener

package org.apache.solr.handler.dataimport.scheduler;

import java.util.Calendar;
import java.util.Date;
import java.util.Timer;

import javax.servlet.ServletContext;
import javax.servlet.ServletContextEvent;
import javax.servlet.ServletContextListener;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class ApplicationListener implements ServletContextListener {

    private static final Logger logger = LoggerFactory
            .getLogger(ApplicationListener.class);

    @Override
    public void contextDestroyed(ServletContextEvent servletContextEvent) {
        ServletContext servletContext = servletContextEvent.getServletContext();

        // get our timer from the context
        Timer timer = (Timer) servletContext.getAttribute("timer");
        Timer fullImportTimer = (Timer) servletContext
                .getAttribute("fullImportTimer");

        // cancel all active tasks in the timers queue
        if (timer != null)
            timer.cancel();
        if (fullImportTimer != null)
            fullImportTimer.cancel();

        // remove the timer from the context
        servletContext.removeAttribute("timer");
        servletContext.removeAttribute("fullImportTimer");

    }

    @Override
    public void contextInitialized(ServletContextEvent servletContextEvent) {
        ServletContext servletContext = servletContextEvent.getServletContext();
        try {
            // 增量更新任务计划
            // create the timer and timer task objects
            Timer timer = new Timer();
            DeltaImportHTTPPostScheduler task = new DeltaImportHTTPPostScheduler(
                    servletContext.getServletContextName(), timer);

            // get our interval from HTTPPostScheduler
            int interval = task.getIntervalInt();

            // get a calendar to set the start time (first run)
            Calendar calendar = Calendar.getInstance();

            // set the first run to now + interval (to avoid fireing while the
            // app/server is starting)
            calendar.add(Calendar.MINUTE, interval);
            Date startTime = calendar.getTime();

            // schedule the task
            timer.scheduleAtFixedRate(task, startTime, 1000 * 60 * interval);

            // save the timer in context
            servletContext.setAttribute("timer", timer);

            // 重做索引任务计划
            Timer fullImportTimer = new Timer();
            FullImportHTTPPostScheduler fullImportTask = new FullImportHTTPPostScheduler(
                    servletContext.getServletContextName(), fullImportTimer);

            int reBuildIndexInterval = fullImportTask
                    .getReBuildIndexIntervalInt();
            if (reBuildIndexInterval <= 0) {
                logger.warn("Full Import Schedule disabled");
                return;
            }

            Calendar fullImportCalendar = Calendar.getInstance();
            Date beginDate = fullImportTask.getReBuildIndexBeginTime();
            fullImportCalendar.setTime(beginDate);
            fullImportCalendar.add(Calendar.MINUTE, reBuildIndexInterval);
            Date fullImportStartTime = fullImportCalendar.getTime();

            // schedule the task
            fullImportTimer.scheduleAtFixedRate(fullImportTask,
                    fullImportStartTime, 1000 * 60 * reBuildIndexInterval);

            // save the timer in context
            servletContext.setAttribute("fullImportTimer", fullImportTimer);

        } catch (Exception e) {
            if (e.getMessage().endsWith("disabled")) {
                logger.warn("Schedule disabled");
            } else {
                logger.error("Problem initializing the scheduled task: ", e);
            }
        }

    }

}

打完jar表直接丢到D:\search\apache-tomcat-8.0.36\webapps\solr\WEB-INF\lib下
然后修改web.xml，增加

<listener> 
       <listener-class>org.apache.solr.handler.dataimport.scheduler.ApplicationListener</listener-class>
</listener>

在D:\search\solr\home下新建conf增加dataimport.properties文件

# to sync or not to sync
# 1 - active; anything else - inactive
syncEnabled=1
# which cores to schedule
# in a multi-core environment you can decide which cores you want syncronized
# leave empty or comment it out if using single-core deployment
syncCores=ask,topic
# solr server name or IP address
# [defaults to localhost if empty]
server=localhost
# solr server port
# [defaults to 80 if empty]
port=8080
# application name/context
# [defaults to current ServletContextListener's context (app) name]
webapp=solr
params=/dataimport?command=delta-import&clean=false&commit=true&wt=json
# number of minutes between two runs
# [defaults to 30 if empty]
interval=1
# 重做索引的时间间隔，单位分钟，默认7200，即5天;
# 为空,为0,或者注释掉:表示永不重做索引
reBuildIndexInterval=7200
reBuildIndexParams=/dataimport?command=full-import&clean=true&commit=true&wt=json
# 两种格式：2016-08-08 03:10:00 或者 03:10:00，后一种会自动补全日期部分为服务启动时的日期
reBuildIndexBeginTime=03:10:00

这里是多个cores分别为ask,topic
为了做测试interval设为每1分钟增量更新一次索引

接下来就可以启动tomcat 查看结果了

solr-5.0.0 在windows下的安装和配置使用ik中文分词器（单机版）
zhangshaopeng的博客
06-21 1124
Solr它是一种开放源码的，是一个高性能，采用Java5开发，基于Lucene的全文搜索服务器。用户可以通过http请求，向搜索引擎服务器提交一定格式的XML文件，生成索引；也可以通过Http Get操作提出查找请求，并得到XML/JSON格式的返回结果。并且提供了一个完善的功能管理界面， 是一款非常优秀的全文搜索引擎。它易于安装和配置，而且附带了一个基于HTTP 的管理界面。可以使用 Solr ...
基于传统数据查询慢的优化方案
qq_42564058的博客
07-26 673
solr和springboot整合。初始化操作
Solr数据库插入(全量和增量)索引
11-19
Solr数据库插入(全量和增量)索引,全量一般用于第一次创建索引情况，批量一般更新数据部分创建索引。
solr全量更新和增量更新
WeiLan_的博客
08-30 1270
solr全量更新和增量更新 1.首先理解更新 数据库中的数据导入solr缓存中就是更新。 2.全量更新 全量更新，就是把数据库中的全部数据都导入solr缓存库中，一般会删除solr缓存库现有的数据。 全量的话，可以采用直接全部覆盖（使用“新”数据覆盖“旧”数据）；或者走更新逻辑（覆盖前判断下，如果新旧不一致，就更新）； 1.core/conf 目录下的 solrconfig.xml，新增如下配置 <requestHandler name="/dataimport" class="solr.DataIm
Solr 全量更新和增量更新 配置方式
最新发布
猫步轻移，以学求知。余于此方寸之地，如猫观鼠，细察技艺所得，思维所悟。灵思如猫之警觉，日积月累，终成智海；
02-07 1132
deltaImportQuery 指定的sql要求我们将满足PK的数据进行填充，需要配置在FieId中出现的属性，其作用和query类似，只不过该作用是将前面两个deltaQuery、deletedPkQuery过滤后进行了一次封装，以更新部分需更新的记录所对应的Solr的数据库索引。基于项目的特殊性，本项目将所有的文本类型记录的表全部读取进入Solr进行管理，但因文本记录的表比较多和复杂，导致了后面在使用solr自带功能增量更新时出现了问题。该配置在使用全量更新full-import显得尤为的突出；
solr增量索引问题
如风
07-25 924
关于solr增量索引问题在网上会搜索到一堆文章。我这里只对我做项目时遇到的问题问进行一个描述和解疑：         我所做项目的数据库是千万级以上的数据量。所以全量索引就不太现实了，但在进行增量索引配置时总是出现  id 无法解析等问题。后来查阅资料才了解到配置文件的信息不正确。如下图： 在data-config.xml文件中红色方框的字段名称要一致，之前我由于配置的并不一样，所
Solr的增量更新和全量更新介绍
Septemberer的博客
09-08 432
Solr的增量更新和全量更新介绍 一、solr 的全量更新 1.core/conf 目录下的 solrconfig.xml，新增如下配置 <!--添加如下配置 增加resultHandler配置 --> <requestHandler name="/dataimport" class="org.apache.solr.handler.dataimport.DataImportHandler"> <lst name="defaults"> <str
Solr6.0与MySQL及IK分词集成技术解析
标题中提到的是“solr6.0+mysql+IK分词集成”，这一描述暗示着在进行搜索引擎开发或全文检索系统构建时，需要将Solr搜索引擎与MySQL数据库以及IK分词器集成在一起。接下来，我将详细说明这些知识点。 ### Solr搜索...
从入门到精通 - Fayson带你玩转CDH
Hadoop_SC的博客
09-22 4096
Fayson保持每天推一篇文章，本文随之每天更新。 以下所有文章均为超链接，可以直接点击文章名跳转。 还没附上超链接的文章是还没上传的，会再后续更新后陆续补上 1.规划设计 1.1.on-premise部署规划 0001-《CDH网络要求(Lenovo参考架构)》 0062-《如何为Hadoop集群选择正确的硬件》 0158-《如何给Hadoop集群划分角色》 1.2.on private c...
基于《狂神说Java》Redis--学习笔记
wudidahuanggua的博客
06-19 1857
本笔记仅做学习与复习使用，不存在刻意抄袭。给各位学友强烈推荐《遇见狂神说》他的整套Java学习路线使我获益匪浅！！!
solr通过http方式全量更新索引
Truong的专栏
08-09 1729
启动tomcat，访问http://localhost:8080/solr/dataimport?command=full-import 将数据全部导入solr服务器进行索引 访问http://localhost:8080/solr/dataimport?command=status可以查看运行状态 当修改data-config.xml 文件配置时运行http://localhost:
solr定时任务dataimport报错解决
新的开始的专栏
12-08 5139
在做solr的dataimport的定时任务时，启动时报了如下的错误，一直搞不明白，最后发现是引的包有问题（apache-solr-dataimportscheduler-1.0.jar） 08-Dec-2016 11:57:06.563 INFO [localhost-startStop-1] org.apache.jasper.servlet.TldScanner.scanJars At l
solr之定时增量索引实现
weixin_33693070的博客
04-03 115
为什么80%的码农都做不了架构师？>>> ...
20161218-solr cloud 定时刷新数据 先开个坑已填
yehuang_0801的博客
12-16 3334
先开个坑
MySQL批量更新
Planing & Design & Arrange & Do & willWinner
01-03 2454
MySQL 常见的批量更新
mysql批量更新方法
yuanmeifang的博客
09-23 4863
mysql批量更新方法
solr7.2.1使用——定时增量更新数据
那些年我们踩过的坑
03-20 3620
1、下载JAR：http : //code.google.com/p/solr-data-import-scheduler/    添加至webapp lib目录下 2、创建dataimport.properties 文件内容： ################################################# # ...
MySql中4种批量更新的方法
热门推荐
az44yao的专栏
08-11 1万+
https://yq.aliyun.com/ziliao/59813 MySql中4种批量更新的方法 最近在完成MySql项目集成的情况下，需要增加批量更新的功能，根据网上的资料整理了一下，很好用，都测试过，可以直接使用。 mysql 批量更新共有以下四种办法1、.replace into 批量更新 replace into test_tbl (id,dr) values (1,'2'),(2,'3'),...(x,'y'); 例子：replace into book (`Id...
关于Solr定时更新的那些事
LuvSnow的博客
12-01 2315
关于Solr定时更新的那些事 Solr这个东西，本身已经是完美的存在了。但是。。。这个完美也只是暂时的。 就目前而言，我们经常遇到的定时更新问题，有大触早就解决了，不知道的去问度娘去。 然而，我们通常会给Solr添加权限控制。这里就会遇到一个问题，就是权限，因为目前定时更新支持的版本是solr5以及solr6的，然而，我看了一下这两个版本都不支持权限控制状态下的定时更新。 我有尝试在pro...
Solr6.0与MySQL集成：数据库索引增改指南
在`solrconfig.xml`中配置一个处理程序，用于定期轮询数据库，更新索引。 ```xml <requestHandler name="/update/extract" class="solr.UpdateRequestHandler"> <str name="update.chain">dataimport ``` 5....
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值