MapReduce的编程开发——自定义格式输入输出

最新推荐文章于 2023-07-18 16:20:10 发布
最新推荐文章于 2023-07-18 16:20:10 发布
阅读量436 收藏 3
点赞数
分类专栏： 大数据 文章标签： 大数据 mapreduce hadoop
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Comet_sgf/article/details/113455744
版权

文章目录

前言

本文主要是学习MapReduce的学习笔记，对所学内容进行记录。
实验环境：
1.Linux Ubuntu 16.04

2.hadoop3.0.0

3.eclipse4.5.1

一、启动Hadoop

  1. 进入Hadoop启动目录cd /apps/hadoop/sbin
  2. 启动Hadoop./start-all.sh
  3. 输入‘jps’，启动后显示如下信息
    在这里插入图片描述

二、环境搭配

  1. 打开eclipse->Window->Preferences;

  2. 选择Hadoop Map/Reduce,选择Hadoop包根目录，/apps/hadoop，点击Apply，点击OK;

  3. 点击window–>show view–>other–>mapreduce tools–>map/reduce locations，之后页面会出现对应的标签页；
    界面

  4. 点击3中图标1，在Local name输入myhadoop，在DFS Master 框下Port输入8020，点击Finish，出现3中右侧页面；
    在这里插入图片描述

  5. 点击3中

  6. 图标2，选择下图内容，出现第3步图中左侧内容
    在这里插入图片描述
    完成环境配置环境。

三、格式实验

  1. 新建test项目，将hadoop配置文件复制到src文件夹下cp /apps/hadoop/etc/hadoop/{core-site.xml,hdfs-site.xml,log4j.properties} /home/dolphin/workspace/test/src，新建名为mr的package；
  2. 新建Point3D.java文件代码如下：
package mr;
 
import java.io.DataInput;
import java.io.DataOutput;
import java.io.IOException;
 
import org.apache.hadoop.io.WritableComparable;
 
public class Point3D implements WritableComparable<Point3D> {
	public float x, y, z;
	public Point3D(float fx, float fy, float fz) {
		this.x = fx;
		this.y = fy;
		this.z = fz;
	}
	public Point3D() {
		this(0.0f, 0.0f, 0.0f);
	}
	public void readFields(DataInput in) throws IOException {
		x = in.readFloat();
		y = in.readFloat();
		z = in.readFloat();
	}
	@Override
	public void write(DataOutput out) throws IOException {
		out.writeFloat(x);
		out.writeFloat(y);
		out.writeFloat(z);
	}
	public String toString() {
		return "X:"+Float.toString(x) + ", "
				+ "Y:"+Float.toString(y) + ", "
				+ "Z:"+Float.toString(z);
	}
	public float distanceFromOrigin() {
		return (float) Math.sqrt( x*x + y*y +z*z);
	}
	public int compareTo(Point3D other) {
		return Float.compare(
				distanceFromOrigin(), 
				 other.distanceFromOrigin());
	}
	public boolean equals(Object o) {
		if( !(o instanceof Point3D)) {
			return false;
		}
		Point3D other = (Point3D) o;
		return this.x == other.x && this.y == other.y && this.z == other.z;
	}
	public int hashCode() {
		return Float.floatToIntBits(x)
				^ Float.floatToIntBits(y)
				^ Float.floatToIntBits(z);
	}
	
}
  1. 新建Point3DDriver.java文件，代码如下：
package mr;
import java.io.IOException;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Job;
import org.apache.hadoop.mapreduce.Mapper;
import org.apache.hadoop.mapreduce.Reducer;
import org.apache.hadoop.mapreduce.lib.input.FileInputFormat;
import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;
import org.apache.hadoop.util.GenericOptionsParser;

public class Point3DDriver {
	static int count=0;
	public static class MyMapper extends Mapper<Text, Text, Text, Point3D> {
		protected void map(Text key, Text value, Mapper<Text, Text, Text, Point3D>.Context context)
				throws IOException, InterruptedException {
			count++;
			String[] vs = value.toString().split(",");
			Point3D p = new Point3D(Float.parseFloat(vs[0].split(":")[1]), Float.parseFloat(vs[1].split(":")[1]), Float.parseFloat(vs[2].split(":")[1])	);
				context.write(new Text(key), p);
				System.out.println("map==========>"+count);
		}
	}
	public static class MyReducer extends Reducer<Text, Point3D, Text, Point3D>{
		
		protected void reduce(Text key, Point3D value,
				Reducer<Text, Point3D, Text, Point3D>.Context context) throws IOException, InterruptedException {
			
			context.write(key, value);
		}
		
	}
 
	public static void main(String[] args) {
 
		try {
			Configuration conf = new Configuration();
			String[] paths = new GenericOptionsParser(conf, args).getRemainingArgs();
			if (paths.length < 2) {
				throw new RuntimeException("usage <input> <output>");
			}
 
			Job job = Job.getInstance(conf, "Point3DDriver");
			job.setJarByClass(Point3DDriver.class);
 
			job.setMapperClass(MyMapper.class);
			job.setReducerClass(MyReducer.class);
			job.setInputFormatClass(MyInputFormat.class);
			
			job.setMapOutputKeyClass(Text.class);
			job.setMapOutputValueClass(Point3D.class);
			job.setOutputFormatClass(MyOutputFormat.class);
			//job.setOutputFormatClass(MyOutputFormat2.class);
			FileInputFormat.addInputPaths(job, paths[0]);
			FileOutputFormat.setOutputPath(job, new Path(paths[1] + System.currentTimeMillis()));
			System.exit(job.waitForCompletion(true) ? 0 : 1);
		} catch (IOException e) {
			e.printStackTrace();
		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}
 
}
  1. 新建MyInputFormat.java文件，代码如下：
package mr;

import java.io.IOException;
 
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.io.compress.CompressionCodec;
import org.apache.hadoop.io.compress.CompressionCodecFactory;
import org.apache.hadoop.io.compress.SplittableCompressionCodec;
import org.apache.hadoop.mapreduce.InputSplit;
import org.apache.hadoop.mapreduce.JobContext;
import org.apache.hadoop.mapreduce.RecordReader;
import org.apache.hadoop.mapreduce.TaskAttemptContext;
import org.apache.hadoop.mapreduce.lib.input.FileInputFormat;
 
 
public class MyInputFormat extends FileInputFormat<Text,Text> {
	@Override
	  protected boolean isSplitable(JobContext context, Path file) {
	    final CompressionCodec codec =
	      new CompressionCodecFactory(context.getConfiguration()).getCodec(file);
	    if (null == codec) {
	      return true;
	    }
	    return codec instanceof SplittableCompressionCodec;
	  }
	
	@Override
	public RecordReader<Text, Text> createRecordReader(InputSplit genericSplit, TaskAttemptContext context)
			throws IOException, InterruptedException {
		context.setStatus(genericSplit.toString());
		return new MyRecordReader(context.getConfiguration());
	}
 
}
  1. 新建MyOutputFormat.java文件，代码如下：
package mr;

import java.io.DataOutputStream;
import java.io.IOException;
import java.io.UnsupportedEncodingException;
 
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.FSDataOutputStream;
import org.apache.hadoop.fs.FileSystem;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.NullWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.io.compress.CompressionCodec;
import org.apache.hadoop.io.compress.GzipCodec;
import org.apache.hadoop.mapreduce.JobContext;
import org.apache.hadoop.mapreduce.RecordWriter;
import org.apache.hadoop.mapreduce.TaskAttemptContext;
import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;
import org.apache.hadoop.util.ReflectionUtils;
 
public class MyOutputFormat<K, V> extends FileOutputFormat<K, V> {
	public static String SEPERATOR = "mapreduce.output.textoutputformat.separator";
 
	protected static class MyLineRecordWriter<K, V> extends RecordWriter<K, V> {
		private static final String utf8 = "UTF-8";
		private static final byte[] newline;
 
		static {
			try {
				newline = "\n".getBytes(utf8);
			} catch (UnsupportedEncodingException uee) {
				throw new IllegalArgumentException("can't find " + utf8 + " encoding");
			}
		}
 
		protected DataOutputStream out;
		private final byte[] keyValueSeparator;
 
		public MyLineRecordWriter(DataOutputStream out, String keyValueSeparator) {
			this.out = out;
			try {
				this.keyValueSeparator = keyValueSeparator.getBytes(utf8);
			} catch (UnsupportedEncodingException uee) {
				throw new IllegalArgumentException("can't find " + utf8 + " encoding");
			}
		}
		public MyLineRecordWriter(DataOutputStream out) {
			this(out, "=========>");
		}
 
		/**
		 * Write the object to the byte stream, handling Text as a special case.
		 * 
		 * @param o
		 *            the object to print
		 * @throws IOException
		 *             if the write throws, we pass it on
		 */
		private void writeObject(Object o) throws IOException {
			if (o instanceof Text) {
				Text to = (Text) o;
				out.write(to.getBytes(), 0, to.getLength());
			} else {
				out.write(o.toString().getBytes(utf8));
			}
		}
 
		public synchronized void write(K key, V value) throws IOException {
 
			boolean nullKey = key == null || key instanceof NullWritable;
			boolean nullValue = value == null || value instanceof NullWritable;
			if (nullKey && nullValue) {
				return;
			}
			if (!nullKey) {
				writeObject(key);
			}
			if (!(nullKey || nullValue)) {
				out.write(keyValueSeparator);
			}
			if (!nullValue) {
				writeObject(value);
			}
			out.write(newline);
		}
 
		public synchronized void close(TaskAttemptContext context) throws IOException {
			out.close();
		}
	}
 
	public RecordWriter<K, V> getRecordWriter(TaskAttemptContext job) throws IOException, InterruptedException {
		Configuration conf = job.getConfiguration();
		boolean isCompressed = getCompressOutput(job);
		String keyValueSeparator = conf.get(SEPERATOR, "=========>");
		CompressionCodec codec = null;
		String extension = "";
		if (isCompressed) {
			Class<? extends CompressionCodec> codecClass = getOutputCompressorClass(job, GzipCodec.class);
			codec = (CompressionCodec) ReflectionUtils.newInstance(codecClass, conf);
			extension = codec.getDefaultExtension();
		}
		Path file = getDefaultWorkFile(job, extension);
		FileSystem fs = file.getFileSystem(conf);
		if (!isCompressed) {
			FSDataOutputStream fileOut = fs.create(file, false);
			return new MyLineRecordWriter<K, V>(fileOut, keyValueSeparator);
		} else {
			FSDataOutputStream fileOut = fs.create(file, false);
			return new MyLineRecordWriter<K, V>(new DataOutputStream(codec.createOutputStream(fileOut)),
					keyValueSeparator);
		}
	}
}
  1. 新建MyRecordReader.java文件，代码如下：
package mr;

import java.io.IOException;
 
import org.apache.hadoop.classification.InterfaceAudience;
import org.apache.hadoop.classification.InterfaceStability;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.InputSplit;
import org.apache.hadoop.mapreduce.RecordReader;
import org.apache.hadoop.mapreduce.TaskAttemptContext;
import org.apache.hadoop.mapreduce.lib.input.LineRecordReader;
@InterfaceAudience.Public
@InterfaceStability.Stable
public class MyRecordReader extends RecordReader<Text, Text> {
 
	 public static final String KEY_VALUE_SEPERATOR = 
			    "mapreduce.input.mylinerecordreader.key.value.separator";
			  
			  private final LineRecordReader lineRecordReader;
			  private byte separator = (byte) '=';
 
			  private Text innerValue;
 
			  private Text key;
			  
			  private Text value;
			  
			  public Class<Text> getKeyClass() { return Text.class; }
			  
			  public MyRecordReader(Configuration conf)
			    throws IOException {
			    
			    lineRecordReader = new LineRecordReader();
			    String sepStr = conf.get(KEY_VALUE_SEPERATOR, "=");
			    this.separator = (byte) sepStr.charAt(0);
			  }
 
			  public void initialize(InputSplit genericSplit,
			      TaskAttemptContext context) throws IOException {
			    lineRecordReader.initialize(genericSplit, context);
			   
				
			  }
			  
			  public static int findSeparator(byte[] utf, int start, int length, 
			      byte sep) {
			    for (int i = start; i < (start + length); i++) {
			      if (utf[i] == sep) {
			        return i;
			      }
			    }
			    return -1;
			  }
 
			  public static void setKeyValue(Text key, Text value, byte[] line,
			      int lineLen, int pos) {
			    if (pos == -1) {
			      key.set(line, 0, lineLen);
			      value.set("");
			    } else {
			      key.set(line, 0, pos);
			      value.set(line, pos + 1, lineLen - pos - 1);
			    }
			  }
			  /** Read key/value pair in a line. */
			  public synchronized boolean nextKeyValue()
			    throws IOException {
			    byte[] line = null;
			    int lineLen = -1;
			    if (lineRecordReader.nextKeyValue()) {
			      innerValue = lineRecordReader.getCurrentValue();
			      line = innerValue.getBytes();
			      lineLen = innerValue.getLength();
			    } else {
			      return false;
			    }
			    if (line == null)
			      return false;
			    if (key == null) {
			      key = new Text();
			    }
			    if (value == null) {
			      value = new Text();
			    }
			    int pos = findSeparator(line, 0, lineLen, this.separator);
			    setKeyValue(key, value, line, lineLen, pos);
			    return true;
			  }
			  
			  public Text getCurrentKey() {
			    return key;
			  }
 
			  public Text getCurrentValue() {
			    return value;
			  }
 
			  public float getProgress() throws IOException {
			    return lineRecordReader.getProgress();
			  }
			  
			  public synchronized void close() throws IOException { 
			    lineRecordReader.close();
			  }
}
  1. 向hadoop创建数据文件夹，指令如下，上传数据，数据如下：
//指令
hadoop fs -mkdir /test/
hadoop fs -mkdir /test/input/
//数据
one=x:1,y:2,z:3
two=x:4,y:5,z:6
three=x:7,y:8,z:9
//数据上传到Hadoop
hadoop fs -put /home/dolphin/Desktop/text.txt /test/input/

8.在Point3DDriver.java的Run Configurations的Java Application栏目的(x)=Arguments栏目下输入参数hdfs://localhost:8020/test/input/text.txt hdfs://localhost:8020/test/output/，然后点击Apply，Run运行程序，得到如下图输出：
在这里插入图片描述

总结

本次实验代码量较大，需要仔细研读类之间的调用关系和作用，达到掌握自定义格式输出的目的。

Comet_sgf
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
MapReduce的编程开发-格式整理
Junds0的博客
11-20 877
采用 name-m-nnnnn 形式的文件用于 map 输出，采用 name-r-nnnnn 形式的文件名用于 reduce 输出。我们考虑这样一个需求：按学生的年龄段，将数据输出到不同的文件路径下。有时可能需要对输出的文件名进行控制或让每个 reducer 输出多个文件。要求根据部门编号对员工进行分区，如果编号为 10，则放置在 1 分区，编号为 20 放置在 2 分区，其余全部放在 3 分区；本类主要用于描述输出数据的格式，它能够将用户提供的 key/value 对写入特定格式的文件中。
【MapReduce】Mapreduce基础知识整理 (七) 自定义输出
人生所向，皆是美好
12-25 261
自定义输出 默认输出： FileOutputFormat TextOutputFormat RecordWriter LineRecordWriter 自定义输出： 创建一个类继承FileOutputFormat 重写getRecordWriter 创建一个文件真正的写入器，继承RecordRecordWriter 重写write() close() job中指定自定义的输...
MapReduce的输出格式
weixin_34025051的博客
02-18 388
2019独角兽企业重金招聘Python工程师标准>>> ...
Hadoop-MapReduce的自定义输入输出
互联网知识分享
05-09 510
如果输出有二进制,就使用下面二进制流,如果没有,就使用默认的TextOuttputFormat;注意 这里使用的是自定义的，所以每写一次的内容不会自动换行，所以每个文件的内容都会拼接在一起，注意 我们是自定义输出的,写出去的数据所有的内容会拼接在一起，所以key要加换行。因为读取的就是文本类型的，而默认TextIntputFormat,所以略写，*/获取job里面传递的输出目录，并且job的输出路径的产生下面自定义的文件名。如果输入有二进制,就使用下面二进制流,如果没有,就不用写,
0070-mapreduce自定义输出类
登峰小蚁
03-14 2403
文章目录1. 需求背景2. 场景3. 具体实现3.1 自定义输出类3.2 Mapper类3.3 Reducer类3.4 job类-标准写法4. 总结 1. 需求背景 mapper-reducer程序只能输入键值对，如果需要输出多个字段信息，必须对键或值进行自定义封装。 2. 场景 // 手机号码 上行流量 下行流量 其他字段 13576119010 11 22 aa1 bb1 1367611901...
大数据实验四-MapReduce编程实践
最新发布
04-03
MapReduce编程实践： 使用MapReduce实现多个文本文件中WordCount词频统计功能，实验编写Map处理逻辑、编写Reduce处理逻辑、编写main方法。 二．实验目的 1、通过实验掌握基本的MapReduce编程方法。 2、实现统计HDFS...
实验项目 MapReduce 编程
04-18
2. 在 Hadoop 集群主节点上搭建 MapReduce 开发环境 Eclipse。 3. 查看 Hadoop 自带的 MR-App 单词计数源代码 WordCount.java，在 Eclipse 项目 MapReduceExample 下建立新包 com.xijing.mapreduce，模仿内置的 ...
MapReduce多路径输入输出
06-18
这是 MapReduce 的多路径输入输出示例代码。有关大数据的相关文章可以阅读我的专栏：《大数据之Hadoop》 http://blog.csdn.net/column/details/bumblebee-hadoop.html
实验3MapReduce编程初级实践
10-27
具体来说，对于两个输入文件，即文件A和文件B，学生需要编写MapReduce程序，对两个文件进行合并，并剔除其中重复的内容，得到一个新的输出文件C。 MapReduce编程 MapReduce编程模型由两个阶段组成：map阶段和...
MapReduce的自定义输入输出(超级详细)
互联网知识分享
07-18 782
MapReduce 是一种分布式计算框架，用于处理大规模数据集。它将一个大的输入数据集分割成多个小的数据块，并在多台计算机上并行处理这些小的数据块。而自定义输入输出是指开发者可以根据自己的需求，使用自定义的输入和输出格式来处理数据。在 MapReduce 中，默认的输入和输出格式是文本文件（TextInputFormat 和 TextOutputFormat）。但是，在一些特定的场景中，文本格式可能无法满足需求，因此我们需要使用自定义的输入输出格式。
MapReduce 自定义输入输出(很有用)
千里之行始于足下
11-22 2204
As We Know : Mapper<输入key，输入Value，输出Key，输出Value> Reduce<输入key，输入Value，输出Key，输出Value> 其中mapper的输出key，输出value 一定等于reduce的输入key，输入value自定义输入： map的默认输入key是行的偏移值 value是每一行的数据
MapReduce自定义输入输出组件
lodestone wisdom
03-20 707
多个小文件合并， 一个key-value，value是小文件的所有内容。 套路：模仿org.apache.hadoop.mapreduce.lib.input.LineRecordReader 和org.apache.hadoop.mapreduce.lib.input.TextInputFormat 把输入控件设置成自定义的控件类 job.setInputFormatClass...
大数据之Hadoop_MapReduce自定义输出和输入类型
WuBoooo的博客
08-21 568
自定义输出和输入类型介绍 我们在使用MapReduce处理需要两次聚合的数据时,我们会进行两次输出,第二次输出的结果是读取第一次输出的结果进程聚合处理的,但我们只需要看到第二次的聚合的结果就可以了,第一次聚合的结果我们是否能看懂都无所谓, 此时我们在进行第一次输出时,我们可以将输出类型由原来(当我们未自定义时默认的输入和输出类型都是TextInputFormat和TextOutputFormat)改为SequenceFileOutputFormat,Sequence相对于Text类型处理速度较快,且更节约内
实现mapreduce多文件自定义输出
hududumo
07-13 159
普通maprduce中通常是有map和reduce两个阶段，在不做设置的情况下，计算结果会以part-000*输出成多个文件，并且输出的文件数量和reduce数量一样，文件内容格式也不能随心所欲。这样不利于后续结果处理。 在hadoop中，reduce支持多个输出,输出的文件名也是可控的，就是继承MultipleTextOutputFormat类，重写generateFileNameFor...
Hadoop MapReduce编程 API入门系列之自定义多种输入格式数据类型和排序多种输出格式（十一）...
weixin_33729196的博客
12-12 90
  　　推荐 MapReduce分析明星微博数据     http://git.oschina.net/ljc520313/codeexample/tree/master/bigdata/hadoop/mapreduce/05.%E6%98%8E%E6%98%9F%E5%BE%AE%E5%8D%9A%E6%95%B0%E6%8D%AE%E5%88%86%E6%9E%90?dir=1&am...
【MapReduce】Mapreduce基础知识整理 (四) 自定义输入
人生所向，皆是美好
12-14 426
目录1. 为什么需要自定义输入2. 默认输入源码分析2.1 org.apache.hadoop.mapreduce.Mapper2.2 org.apache.hadoop.mapred.MapTask2.3 org.apache.hadoop.mapreduce.lib.map.WrappedMapper2.4 org.apache.hadoop.mapreduce.task.MapContext...
干货--Hadoop自定义数据类型和自定义输入输出格式整合项目案例
热门推荐
至道
05-03 1万+
数据输入格式（InputFormat） 用于描述MapReduce作业的数据输入规范。MapReduce框架依靠数据输入格式完成输入规范检查(比如输入文件目录的检查)、对数据文件进行输入分块(也叫分片，InputSplit)，以及提供从输入分块(分片)中将数据记录逐一读出，并转化为Map过程的输入键值对等功能 Hadoop提供了丰富的内置数据输入格式。最常用的数据输入格式包括：TextInputFormat和KeyValueInputFormat TextInputFormat是系统默认的数据输入格式，可
mapreduce--使用自定义类做value
jianjian1992的专栏
07-30 1815
在mapreduce编程中，有挺多实现了Comparable, Writable接口的内置变量类型，比如 Text， IntWritable，LongWritable等等。 这次我要自己定义一个类，将它用作设计自定义类MyData按照需求，这个类应该有4个变量，分别记录手机号，上行流量，下行流量以及总流量。 这个类需要实现Writable接口，所以需要实现两个函数： write函数 ，将MyD
MapReduce编程实例——词频统计
10-12
好的，我了解了。关于MapReduce编程实例——词频统计，这是一种常见的数据处理方法，可以用于大规模数据的分布式处理。具体实现步骤如下： 1. Map阶段：将输入数据按照一定的规则进行切分，生成<key, value>键值对。 2. Shuffle阶段：将Map阶段输出的键值对按照key进行排序和分组，将相同key的value放在一起。 3. Reduce阶段：对每个key所对应的value进行处理，生成新的输出结果。 在词频统计中，Map阶段的输入是文本文件，输出是<word, 1>键值对；Shuffle阶段将相同word的键值对分到同一个Reduce任务中；Reduce阶段对每个word所对应的1进行累加，得到该word在文本中出现的次数。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值