使用myeclipse及java构建自己的nifi 自定义processor

最新推荐文章于 2024-06-19 15:40:54 发布
最新推荐文章于 2024-06-19 15:40:54 发布
阅读量814 收藏 3
点赞数
分类专栏： nifi 文章标签： nifi processor myeclipse java maven
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq116165600/article/details/84857279
版权

自己最近开始摸索使用eclipse及java构建自己自定义的nifi processor，并部署到nifi lib中使用，最终构建好的nifi template如下图所示：

具体如何构建nifi template在这里就不做重复写了，可以自己先摸索个简单的template 跑起来后在构建自己自定义的processor

好了，这里开始进入正题，开始上代码：

工程的结构图如下：

1.定义自己的主要处理代码，我们在这里定义为changeDate，代码如下：

package com.nifi.test;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.concurrent.atomic.AtomicReference;
import org.apache.commons.io.IOUtils;
import org.apache.commons.lang3.builder.ToStringBuilder;
import org.apache.commons.lang3.builder.ToStringStyle;
import org.apache.nifi.annotation.behavior.SideEffectFree;
import org.apache.nifi.annotation.documentation.CapabilityDescription;
import org.apache.nifi.annotation.documentation.Tags;
import org.apache.nifi.components.PropertyDescriptor;
import org.apache.nifi.flowfile.FlowFile;
import org.apache.nifi.processor.AbstractProcessor;
import org.apache.nifi.processor.ProcessContext;
import org.apache.nifi.processor.ProcessSession;
import org.apache.nifi.processor.ProcessorInitializationContext;
import org.apache.nifi.processor.Relationship;
import org.apache.nifi.processor.exception.ProcessException;
import org.apache.nifi.processor.io.InputStreamCallback;
import org.apache.nifi.processor.io.OutputStreamCallback;
import org.apache.nifi.processor.util.StandardValidators;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.jayway.jsonpath.JsonPath;

@SideEffectFree
@Tags({"CheckDate","My Processor CheckDate"})
@CapabilityDescription("to format date,from 'year' to 'month'")
public class ChangeDate extends AbstractProcessor{
	private List<PropertyDescriptor> properties;
	private Set<Relationship> relationships;
	private static final Logger log = LoggerFactory.getLogger(ChangeDate.class);

	public static final PropertyDescriptor JSON_PATH = new PropertyDescriptor.Builder()
	        .name("Json Path")
	        .required(true)
	        .addValidator(StandardValidators.NON_EMPTY_VALIDATOR)
	        .build();

	public static final Relationship SUCCESS = new Relationship.Builder() 
	        .name("SUCCESS")
	        .description("success relationship")
	        .build();
	
	
	
	public static final Relationship FAILURE = new Relationship.Builder()
	        .name("FAILURE")
	        .description("failure relationship")
	        .build();
	
	
	@Override
	public void init(final ProcessorInitializationContext context){
	    List<PropertyDescriptor> properties = new ArrayList<PropertyDescriptor>();
	    properties.add(JSON_PATH);
	    this.properties = Collections.unmodifiableList(properties);

	    Set<Relationship> relationships = new HashSet<Relationship>();
	    relationships.add(SUCCESS);
	  
	    relationships.add(FAILURE);
	    this.relationships = Collections.unmodifiableSet(relationships);
	}

	@Override
	public Set<Relationship> getRelationships(){
	    return relationships;
	}

	@Override
	public List<PropertyDescriptor> getSupportedPropertyDescriptors(){
	    return properties;
	}
	@Override
	public void onTrigger(ProcessContext context, ProcessSession session) throws ProcessException {

	    FlowFile flowfile = session.get();
	    final AtomicReference<String> jsonIn = new AtomicReference<String>() ;
	    final AtomicReference<String> jsonOutAtom = new AtomicReference<String>() ;
	    
	    
	    final AtomicReference<FlowMsgOut> msgOut = new AtomicReference<FlowMsgOut>() ;
	    final AtomicReference<String> checkDate = new AtomicReference<String>();
	    final AtomicBoolean failure = new AtomicBoolean(false);
	    
	    session.read(flowfile, new InputStreamCallback() {
	    	
	    	@Override
	        public void process(InputStream in) throws IOException {
	        	
	            //try{
	            	
	            	//将输入流转换成对象
	            	/*
	                String json = "{\"phoneId\": \"111\"," + 
	                		"    \"phoneName\": \"huawei\"," + 
	                		"    \"phonePrice\": \"6856\"," + 
	                		"    \"repaymentPeriod\": \"2年\"}";
	                		*/
	                		
	            	getLogger().info("begin get inputStream and exchange this for json");
	            	//getLogger().info("inputStream is:",ToStringBuilder.reflectionToString(in, ToStringStyle.SHORT_PREFIX_STYLE));
	            	getLogger().info("current input is null:"+String.valueOf(in == null));
	            	
	                String json = IOUtils.toString(in); 
	            	
	            	
	            	
	                getLogger().info("current in String value is:"+json);
	                //jsonIn.set(json);
	                //log.info("RECEIVE :"+json);
	                System.out.println("RECEIVE:" + json); 
	                
	                
	                FlowMsgIn msgIn = getFlowMsg(json) ;
	                
	                //业务逻辑
	                checkDate.set(new Rules().newDate(msgIn)) ;
	                //checkDate.set("10") ;
	                
	                //构造输出对象
	                FlowMsgOut out = new FlowMsgOut() ;
	                out.setPhoneId(msgIn.getPhoneId());
	                out.setPhoneName(msgIn.getPhoneName());
	                out.setPhonePrice(msgIn.getPhonePrice());
	                out.setRepaymentPeriodProcessed(checkDate.get());
//	                out.setPhoneId("111");
//	                out.setPhoneName("华为");
//	                out.setPhonePrice("5555");
//	                out.setRepaymentPeriodProcessed("10");
	                msgOut.set(out) ;
	            /*
	            }catch(Exception ex){
	                ex.printStackTrace();
	                getLogger().error("Failed in InputStreamCallback.");
	                failure.set(true) ;
	            }
	            */
	        }
	    });
	    
	    ObjectMapper objectMapper = new ObjectMapper();  
	    String jsonOut = "" ;
		try {
			jsonOut = objectMapper.writeValueAsString(msgOut.get());
		} catch (JsonProcessingException e) {
			e.printStackTrace();
			failure.set(true) ;
		} 
		jsonOutAtom.set(jsonOut);
		
		//设置输出流内容
		if(failure != null && failure.get()){
		
			flowfile = session.putAttribute(flowfile,"jsonIn",jsonIn.get());
		}else{
			flowfile = session.putAttribute(flowfile,"jsonOut",jsonOut);
		}
		//flowfile = session.putAttribute(flowfile,"jsonOut",jsonOut);
		
	    //写输出流
	    flowfile = session.write(flowfile, new OutputStreamCallback() {

			@Override
			public void process(OutputStream out) throws IOException {
				// TODO Auto-generated method stub
				out.write(jsonOutAtom.get().getBytes());
				
			}

//	        public void process(OutputStream out) throws IOException {
//	        	out.write(jsonIn.get().getBytes());
//	        	
//	        }
	    });
	    //设置流向
	    if(failure.get()){
	    	
	    	session.transfer(flowfile, FAILURE);
	    }else{
	    	
	    	session.transfer(flowfile, SUCCESS) ;
	    }
	    
	    //session.transfer(flowfile, SUCCESS) ;
	    
	   // 
	}
	
	public FlowMsgIn getFlowMsg(String flowJson){
		
		FlowMsgIn msg = new FlowMsgIn() ;
		
		//getLogger().info("current flowJson is:"+flowJson);
		msg.setRepaymentPeriod((String) JsonPath.read(flowJson, "$.repaymentPeriod"));
		msg.setPhoneId((String) JsonPath.read(flowJson, "$.phoneId"));
		msg.setPhoneName((String) JsonPath.read(flowJson, "$.phoneName"));
		msg.setPhonePrice((String) JsonPath.read(flowJson, "$.phonePrice"));

		
		return msg ; 
	}
	
	
	public static void main(String[] args) {
		ChangeDate d = new ChangeDate();
		String flowJson = "{\"phoneId\":\"111\",\"phoneName\":\"华为\",\"phonePrice\":\"6856\",\"repaymentPeriod\":\"1年\"}";
		FlowMsgIn msgIn = d.getFlowMsg(flowJson);
		System.out.println(msgIn.toString());
		//d.getFlowMsg(flowJson);
		//final AtomicReference<String> checkDate = new AtomicReference<String>();
		//checkDate.set(new Rules().newDate(msgIn)) ;
		//System.out.println(ToStringBuilder.reflectionToString(checkDate.get().getBytes(), ToStringStyle.SHORT_PREFIX_STYLE));
	}
	
	@Override
    public String toString () {
        return ToStringBuilder.reflectionToString(this, ToStringStyle.SHORT_PREFIX_STYLE);
    } 
	

}





/*
 输入流示例
 {"phoneId":"111","phoneName":"华为","phonePrice":"6856","repaymentPeriod":"1年"}
 {"phoneId":"111","phoneName":"华为","phonePrice":"6856","repaymentPeriod":"24月"}
*/

/*
输入流示例
 {"phoneId":"111","phoneName":"华为","phonePrice":"6856","repaymentPeriodProcessed":"12月"}
 {"phoneId":"111","phoneName":"华为","phonePrice":"6856","repaymentPeriod":"24月"}

*/

这里面的代码，主要是要使用onTrigger()类，这里面才是自己处理数据的具体方法，放在这里面，

 

其中

@SideEffectFree
@Tags({"CheckDate","My Processor CheckDate"})  //这里的注解主要是使用在UI界面中 供检索到该processor使用
@CapabilityDescription("to format date,from 'year' to 'month'") ///这里为该processor的description

 

 

 

2.其他DAO层代码及Rule代码如下：

package com.nifi.test;

public class FlowMsgIn {

	private String phoneId;
	private String phoneName;
	private String phonePrice;
	private String repaymentPeriod;

	public String getPhoneId() {
		return phoneId;
	}

	public void setPhoneId(String phoneId) {
		this.phoneId = phoneId;
	}

	public String getPhoneName() {
		return phoneName;
	}

	public void setPhoneName(String phoneName) {
		this.phoneName = phoneName;
	}

	public String getPhonePrice() {
		return phonePrice;
	}

	public void setPhonePrice(String phonePrice) {
		this.phonePrice = phonePrice;
	}

	public String getRepaymentPeriod() {
		return repaymentPeriod;
	}

	public void setRepaymentPeriod(String repaymentPeriod) {
		this.repaymentPeriod = repaymentPeriod;
	}

	@Override
	public String toString() {
		return "FlowMsgIn [phoneId=" + phoneId + ", phoneName=" + phoneName
				+ ", phonePrice=" + phonePrice + ", repaymentPeriod="
				+ repaymentPeriod + "]";
	}
}














*************************************************
package com.nifi.test;

public class FlowMsgOut {

	private String phoneId;
	private String phoneName;
	private String phonePrice;
	private String repaymentPeriod;
	//private String repaymentPeriodProcessed ;

	public String getPhoneId() {
		return phoneId;
	}

	public void setPhoneId(String phoneId) {
		this.phoneId = phoneId;
	}

	public String getPhoneName() {
		return phoneName;
	}

	public void setPhoneName(String phoneName) {
		this.phoneName = phoneName;
	}

	public String getPhonePrice() {
		return phonePrice;
	}

	public void setPhonePrice(String phonePrice) {
		this.phonePrice = phonePrice;
	}

	public String getRepaymentPeriodProcessed() {
		return repaymentPeriod;
	}

	public void setRepaymentPeriodProcessed(String repaymentPeriod) {
		this.repaymentPeriod = repaymentPeriod;
	}

	@Override
	public String toString() {
		return "FlowMsgOut [phoneId=" + phoneId + ", phoneName=" + phoneName
				+ ", phonePrice=" + phonePrice + ", repaymentPeriod="
				+ repaymentPeriod + "]";
	}
}



******************************************
package com.nifi.test;

/**
 * 调用已有的手机贷款信息数据
 * 判断贷款年限是否为月
 * 如为年则转成月
 */
public class Rules {
	public String newDate(FlowMsgIn msg){
		
		String str = msg.getRepaymentPeriod();
		String a = str.substring(str.length() - 1);

		if ("Y".equals(a)) {
			String month = str.substring(0, str.length() - 1);
			Integer temp = Integer.parseInt(month);
			temp = temp * 12;
			StringBuffer buffer = new StringBuffer();
			buffer.append(temp.toString());
			buffer.append("月");
			return buffer.substring(0);
		} else {
			return str;
		}
	}
}

这部分的代码只是简单地DAO层及简单的数据处理方式

 

 

其中还需要在src/main/resources/META-INF/services文件夹中新建一个 org.apache.nifi.processor.Processor 文件 里面的内容为需要暴露出来作为processor接口函数的类的名称，本工程的实例如下：

 

 

3.最终的结果：

  通过以上代码生成的nar包 并放在nifi的lib文件中运行，最终的结果为，把json数据读取到了自定义的processor中，对年转换为月 在生成json 并最终输出到指定的文件中。

好啦 自己运行摸索吧，

附件POM文件配置：

<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 http://maven.apache.org/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0</modelVersion>

	<groupId>com.delta</groupId>
	<artifactId>ChangeDate</artifactId>
	<version>0.0.1</version>
	<packaging>nar</packaging>

	<name>nifi.json</name>
	<url>http://maven.apache.org</url>

	<properties>
		<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
		<java.version>1.8</java.version>
		<nifi.version>1.8.0</nifi.version>
	</properties>

	<dependencies>
		<!--<dependency>-->
			<!--<groupId>junit</groupId>-->
			<!--<artifactId>junit</artifactId>-->
			<!--<version>3.8.1</version>-->
			<!--<scope>test</scope>-->
		<!--</dependency>-->

		<!--<dependency>-->
			<!--<groupId>org.apache.nifi</groupId>-->
			<!--<artifactId>nifi-api</artifactId>-->
			<!--<version>${nifi.version}</version>-->
            <!--<scope>provided</scope>-->
		<!--</dependency>-->

		<dependency>
			<groupId>org.apache.nifi</groupId>
			<artifactId>nifi-utils</artifactId>
			<version>${nifi.version}</version>
			<!--<scope>provided</scope>-->
		</dependency>

		<!--<dependency>-->
			<!--<groupId>org.apache.nifi</groupId>-->
			<!--<artifactId>nifi-processor-utils</artifactId>-->
			<!--<version>${nifi.version}</version>-->
		<!--</dependency>-->

		<dependency>
			<groupId>org.apache.commons</groupId>
			<artifactId>commons-io</artifactId>
			<version>1.3.2</version>
		</dependency>

		<dependency>
			<groupId>com.jayway.jsonpath</groupId>
			<artifactId>json-path</artifactId>
			<version>1.2.0</version>
		</dependency>

		<!--<dependency>-->
			<!--<groupId>org.apache.nifi</groupId>-->
			<!--<artifactId>nifi-mock</artifactId>-->
			<!--<version>1.6.0</version>-->
			<!--&lt;!&ndash;<scope>test</scope>&ndash;&gt;-->
		<!--</dependency>-->

		<!--<dependency>-->
			<!--<groupId>junit</groupId>-->
			<!--<artifactId>junit</artifactId>-->
			<!--<version>4.10</version>-->
			<!--<scope>test</scope>-->
		<!--</dependency>-->

		<dependency>
			<groupId>com.fasterxml.jackson.core</groupId>
			<artifactId>jackson-databind</artifactId>
			<version>2.8.3</version>
		</dependency>

		<dependency>
			<groupId>org.apache.nifi</groupId>
			<artifactId>nifi-properties</artifactId>
			<version>${nifi.version}</version>
			<scope>provided</scope>
		</dependency>

		<dependency>
    		<groupId>org.apache.nifi</groupId>
    		<artifactId>nifi-distributed-cache-client-service-api</artifactId>
    		<version>${nifi.version}</version>
		</dependency>

	</dependencies>

	<build>
		<plugins>
			<plugin>
				<groupId>org.apache.nifi</groupId>
				<artifactId>nifi-nar-maven-plugin</artifactId>
				<version>1.2.0</version>
				<extensions>true</extensions>
			</plugin>
			 
			<plugin>
				<groupId>org.apache.maven.plugins</groupId>
				<artifactId>maven-surefire-plugin</artifactId>
				<version>2.19.1</version>
				<configuration>
      				<skipTests>true</skipTests>
   				</configuration>
			</plugin>

		</plugins>
	</build>
</project>

 

停车枫林有点晚
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
NiFi AbstractProcessor API介绍
小伙无限帅
07-16 398
AbstractProcessor API 由于绝大多数 Processor将通过 extending the AbstractProcessor来创建, 因此我们将在本节中研究AbstractProcessor。AbstractProcessor 提供了Processor开发人员感兴趣的几个方法。 Processor Initialization : Processor初始化 在创建Processor时, 在调用任何其他方法之前, 将调用AbstractProcessor的init方法。 该方法接收一个参
nifi自定义processor简单案例
01-02
nifi平台自定义processor的简单案例，代码实现，readme中有详细代码解读。
Java自定义AnnotationProcessor处理自己的Annotation
热门推荐
郑海波(莫川)的CSDN博客
03-30 1万+
Java使用Annotation Processor获取代码中的Annotation使用Java的Annotation Processing Tool (apt)可以在编译期获取Java代码文件中的Annotation。 项目源码：https://github.com/nuptboyzhb/CustomAnnotationProcessorAnnotation的定义如下，定义了一个MyMethodA
Apache NiFi 自定义Processor处理器编写
最新发布
qq_39228264的博客
06-19 650
当我们在使用ApacheNiFi时，当已有的processor不支持我们现有需求时，需要我们自己编写自定义处理器并且发布，以至于更好的支持我们的需求； 下面我写一个将JSON数据转化为Excel并且输出到本地文件的自定义Processor Demo
『NiFi 学习之路』自定义 —— 组件的自定义及使用
weixin_30686845的博客
06-13 390
一、概述 许多业务仅仅使用官方提供的组件不能够满足性能上的需求，往往要通过高度可定制的组件来完成特定的业务需求。 而 NiFi 提供了自定义组件的这种方式。 二、自定义 Processor 占坑待续 三、Debug Processor 目前似乎没有较好的方式，有一个邮件列表就此话题进行了探讨。 Getting started developing/debugging Nifi processors...
java调用远程rest服务,如何在NiFi中调用远程REST服务
weixin_28793831的博客
02-27 239
Is it possible to use xmlHttpRequest in NIFI processor to invoke remote rest service? In my case the ExecuteScript processor (using Javascript) can't evaluate XMLHttpRequest; is there any similar solu...
使用MyEclipse搭建java Web项目开发.docx
12-30
在本文中，我们将详细地介绍如何使用 MyEclipse 搭建 Java Web 项目开发环境，包括安装必要的工具、搭建 Web 项目开发环境、配置服务器等步骤。 首先，在开始搭建 MyEclipse 的开发环境之前，我们需要完成三步工具...
Java零基础-集成开发环境MyEclipse的使用.md
08-09
### Java零基础-集成开发环境MyEclipse的使用 #### 一、MyEclipse简介 MyEclipse是一款专为Java开发者设计的集成开发环境（Integrated Development Environment，简称IDE），广泛应用于Java开发及Web应用程序开发...
Myeclipse8.6java开发工具下载
05-23
JAVA早期的开发工具MyEclipse8.6版本，优势在于很稳定，另外破解也很方面，两种破解模式，一种是在网上搜索在线的序列号，另外一种是运行一个java程序，具体的baidu即可，Myeclipse8.6支持的组件较多，比如自动生成...
myeclipse开发Java WebService.zip
01-30
以下将详细介绍使用MyEclipse开发Java WebService的相关知识点。 1. **MyEclipse简介** MyEclipse是基于Eclipse的商业级Java开发工具，它集成了多种功能，如Java EE应用开发、Web开发、数据库管理等。对于Java ...
linux nifi指定jdk,[Java教程]nifi安装说明
weixin_39912984的博客
05-10 206
[Java教程]nifi安装说明0 2017-02-14 12:00:20系统环境：vmware安装的centos6.7虚拟机jdk1.8版本maven库3.3.9版本(在使用源码编译启动的时候需要修改配置文件与当前使用的maven版本匹配，最低使用版本好像是3.1.5，记不清了)其他的一些ssh工具随意。1、二进制工程①NIFI下载地址：http://nifi.apache.org...
Apache Nifi 概念介绍、源码解析、开发指南（中文）
03-06
Apache Nifi 从初步认知核心概念介绍、了解技术架构、到源码解析、开发指南翻译 （中文），希望对新接触Nifi的朋友有所帮助。
可视化编排的数据集成和分发开源框架Nifi轻松入门-上
itxiaoshen博客
12-14 1738
如何你正在为数据采集做技术选型，今天介绍一款功能极其强大性能也高且采用可视化编排的数据集成框架nifi可以列入选型范畴，是数仓开发的强大工具之一，只要使用后就能体会到其丰富的处理器和扩展性。先了解其特性、核心概念和架构，也支持分布式集群，了解常见处理器分类，最后通过源码安装并使用两个简单的处理器演示一个基础入门示例
nifi将mysql数据导到hdfs_用Nifi 从web api 取数据到HDFS
weixin_35888603的博客
01-28 205
import org.apache.commons.io.IOUtilsimport java.nio.charset.*import java.text.SimpleDateFormat;import java.lang.StringBuilder;import java.util.Calendar;def flowFile = session.create()def days = 10000f...
nifi自定义组件项目搭建教程
qq_39887703的博客
08-18 827
在nifi日常使用中，一些nifi原生组件过于灵活，导致非工程人员使用困难，所以开发自定义组件，比如将接口完全封装，比如将算法完全封装
学习 Apache Nifi 的心路历程
一个还没离职的程序员
04-15 403
写在前面：本文为个人学习过程，仅限于学习使用。学习使我快乐，大家加油 一、准备工作 首先，Nifi自行官网下载，我使用的是Nifi-1.9.2。 自行修改相关配置，并启动。（其实并没有修改什么配置，就修改了IP和端口号） 可以通过浏览器打开Nifi工作空间。 配置好相关数据源地址信息。（数据库配置如图配置，基本的填写好这5项） 二、大概流程 流程总览： 此过程大概意思是: 读取数据源A中的一张表中的两个字段TableName、Json_Data（TableName对应的是数据源B中的一张表，且Js
Apache Nifi 入门到精通（三）自定义processor
loki的博客
01-04 1527
目标：实现从restful接口读取到nifi 第一步：创建processor项目结构 创建maven项目 项目名nifi-rest-bundle 完成创建项目： 修改 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-...
Nifi初探 - 创建一个简单的自定义Nifi Processor
Sha0w的博客
07-19 1万+
网上关于Nifi自定义Processor的中文资料，要么是很古老的eclipse版本，要么太过于简单，学习Nifi的道路确实有点看不清楚，好在找到一篇从零构造一个JsonPROCESSOR的英文文章，单纯翻译外加心得记录，使用的Nifi版本是1.3.0，希望对大家有帮助。 源地址：http://www.nifi.rocks/developing-a-custom-apache-nifi-proces
NIFI 自定义 processor 实现
修行修心
03-27 4574
NIFI 自定义 processor 实现
myEclipse 8.5 SSH 整合教程：自定义JDK及Tomcat配置
1. **设置Java运行环境**：在Window -> Preferences -> Java:InstalledJREs中，不使用myEclipse默认JDK，而是添加自定义的JDK路径。 2. **配置Tomcat服务器**：在Window -> Preferences -> MyEclipse -> Servers中...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值