MapReduce 高级应用练习：二次排序及Join

最新推荐文章于 2023-07-18 15:13:09 发布
最新推荐文章于 2023-07-18 15:13:09 发布
阅读量624 收藏
点赞数
分类专栏： 笔记 大数据学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/haoyuexihuai/article/details/53288723
版权

二次排序

-》第一点组合key，key是一个组合的字段（自定义数据类型） -》继承WrtiableComparable
-》第二点保证原来的分区不变，需要自定义分区规则 -》继承partitioner
-》第三点保证原来的分组不变，需要自定义分组规则 -》继承RawComparator

  1. 创建文件路径
    bin/hdfs dfs -mkdir -p sort/input
    这里写图片描述

  2. 创建测试数据
    vi /opt/datas/sort.txt
    这里写图片描述

  3. 上传测试数据
    bin/hdfs dfs -put /opt/datas/sort.txt /user/beifeng/sort/input
    这里写图片描述
  4. 一次排序之后的结果，没有二次排序
    这里写图片描述
  5. 主要代码解释
    1. Mapper端
      这里写图片描述
    2. Reducer端
      这里写图片描述
    3. Driver端
      这里写图片描述
    4. PairWritable
      这里写图片描述
      这里写图片描述
    5. FirstGroupingComparator 分组类
      这里写图片描述
    6. FirstPartitioner分区类
      这里写图片描述
  6. 二次排序后的结果
    中间运行时一直出不来正确的结果，最后发现是// reduce number 设置为了2 //job.setNumReduceTasks(2);
    这里写图片描述

Join

  1. 上传测试数据到/opt/datas
    这里写图片描述
  2. 创建hdfs文件路径
    bin/hdfs dfs -mkdir -p order/input
  3. 上传文件到hdfs中
    bin/hdfs dfs -put /opt/datas/orders.csv /opt/datas/customers.csv /user/beifeng/order/input
    这里写图片描述
    这里写图片描述
  4. 原始数据格式
    这里写图片描述
  5. 运行程序
  6. 查看结果
    这里写图片描述
  7. 代码解释
    1. Mapper端
      这里写图片描述
      这里写图片描述
    2. Reducer端
      这里写图片描述

具体代码

二次排序代码
package com.ibeifeng.bigdata.senior.hadoop.mapreduce.sort;

import java.io.IOException;

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.conf.Configured;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.IntWritable;
import org.apache.hadoop.io.LongWritable;
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.Tool;
import org.apache.hadoop.util.ToolRunner;

/**
 * @author beifeng
 * 
 */
public class SecondarySortMapReduce extends Configured implements Tool {

    // step 1 : Mapper Class
    public static class SortMapper extends
            Mapper<LongWritable, Text, PairWritable, IntWritable> {
        private PairWritable mapOutputKey = new PairWritable();
        private IntWritable mapOutputValue = new IntWritable();

        @Override
        public void map(LongWritable key, Text value, Context context)
                throws IOException, InterruptedException {
            // line value
            String lineValue = value.toString();
            // split
            String[] strs = lineValue.split(",");
            // invalidate
            if (2 != strs.length) {
                return;
            }
            // set map output key
            mapOutputKey.set(strs[0], Integer.valueOf(strs[1]));
            mapOutputValue.set(Integer.valueOf(strs[1]));
            // output
            context.write(mapOutputKey, mapOutputValue);
        }
    }

    // step 2 : Reducer Class
    public static class SortReducer extends
            Reducer<PairWritable, IntWritable, Text, IntWritable> {
        private Text outputKey = new Text();

        @Override
        protected void reduce(PairWritable key, Iterable<IntWritable> values,
                Context context) throws IOException, InterruptedException {
            // iterator
            for (IntWritable value : values) {
                outputKey.set(key.getFirst());
                context.write(outputKey, value);
            }
        }
    }

    /**
     * 
     * @param args
     * @return
     * @throws Exception
     *             int run(String [] args) throws Exception;
     */
    // step 3 : Driver
    public int run(String[] args) throws Exception {
        Configuration configuration = this.getConf();
        Job job = Job.getInstance(configuration, this.getClass().getSimpleName());
        job.setJarByClass(SecondarySortMapReduce.class);
        // set job
        // input
        Path inpath = new Path(args[0]);
        FileInputFormat.addInputPath(job, inpath);
        // output
        Path outpath = new Path(args[1]);
        FileOutputFormat.setOutputPath(job, outpath);
        // Mapper
        job.setMapperClass(SortMapper.class);
        job.setMapOutputKeyClass(PairWritable.class);
        job.setMapOutputValueClass(IntWritable.class);
        // partitioner
        job.setPartitionerClass(FirstPartitioner.class);
        // group
        job.setGroupingComparatorClass(FirstGroupingComparator.class);
        // Reducer
        job.setReducerClass(SortReducer.class);
        job.setOutputKeyClass(Text.class);
        job.setOutputValueClass(IntWritable.class);
        // reduce number
        // job.setNumReduceTasks(2);
        // submit job
        boolean isSuccess = job.waitForCompletion(true);
        return isSuccess ? 0 : 1;
    }

    public static void main(String[] args) throws Exception {

        Configuration configuration = new Configuration();
        args = new String[] {
                "hdfs://hadoop-senior01.ibeifeng.com:8020/user/beifeng/sort/input",
                "hdfs://hadoop-senior01.ibeifeng.com:8020/user/beifeng/sort/output2" };
        // run job
        int status = ToolRunner.run(configuration,
                new SecondarySortMapReduce(), args);

        // exit program
        System.exit(status);
    }

}

package com.ibeifeng.bigdata.senior.hadoop.mapreduce.sort;

import java.io.DataInput;
import java.io.DataOutput;
import java.io.IOException;
import org.apache.hadoop.io.WritableComparable;
import org.apache.hadoop.io.WritableComparator;

public class PairWritable implements WritableComparable<PairWritable> {

    private String first;
    private int second;

    public PairWritable() {
    }

    public PairWritable(String first, int second) {
        this.set(first, second);
    }

    public void set(String first, int second) {
        this.setFirst(first);
        this.setSecond(second);
    }

    public String getFirst() {
        return first;
    }

    public void setFirst(String first) {
        this.first = first;
    }

    public int getSecond() {
        return second - Integer.MAX_VALUE;
    }

    public void setSecond(int second) {
        this.second = second + Integer.MAX_VALUE;
    }

    public void write(DataOutput out) throws IOException {
        out.writeUTF(first);
        out.writeInt(second);
    }

    public void readFields(DataInput in) throws IOException {
        this.first = in.readUTF();
        this.second = in.readInt();
    }

    public int compareTo(PairWritable o) {
        // compare first
        int comp = this.first.compareTo(o.getFirst());

        // equals
        if (0 != comp) {
            return comp;
        }

        // compare second
        return Integer.valueOf(getSecond()).compareTo(
                Integer.valueOf(o.getSecond()));
    }

    @Override
    public String toString() {
        return first + "\t" + second;
    }

    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + ((first == null) ? 0 : first.hashCode());
        result = prime * result + second;
        return result;
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        PairWritable other = (PairWritable) obj;
        if (first == null) {
            if (other.first != null)
                return false;
        } else if (!first.equals(other.first))
            return false;
        if (second != other.second)
            return false;
        return true;
    }



    /** A Comparator optimized for LongWritable. */ 
      public static class Comparator extends WritableComparator {
        public Comparator() {
          super(PairWritable.class);
        }

        @Override
        public int compare(byte[] b1, int s1, int l1,
                           byte[] b2, int s2, int l2) {
          long thisValue = readLong(b1, s1);
          long thatValue = readLong(b2, s2);
          return (thisValue<thatValue ? -1 : (thisValue==thatValue ? 0 : 1));
        }
      }
}

package com.ibeifeng.bigdata.senior.hadoop.mapreduce.sort;

import org.apache.hadoop.io.RawComparator;
import org.apache.hadoop.io.WritableComparator;

public class FirstGroupingComparator implements RawComparator<PairWritable> {

    public int compare(PairWritable o1, PairWritable o2) {
        return o1.getFirst().compareTo(o2.getFirst());
    }

    public int compare(byte[] b1, int s1, int l1, byte[] b2, int s2, int l2) {
        return WritableComparator.compareBytes(b1, 0, l1 - 4, b2, 0, l2 - 4);
    }

}

package com.ibeifeng.bigdata.senior.hadoop.mapreduce.sort;

import org.apache.hadoop.io.IntWritable;
import org.apache.hadoop.mapreduce.Partitioner;

public class FirstPartitioner extends Partitioner<PairWritable, IntWritable> {

    @Override
    public int getPartition(PairWritable key, IntWritable value,
            int numPartitions) {
        return (key.getFirst().hashCode() & Integer.MAX_VALUE) % numPartitions;
    }
}
Mapreduce Join代码
package com.ibeifeng.bigdata.senior.hadoop.mapreduce.join;

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

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.conf.Configured;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.LongWritable;
import org.apache.hadoop.io.NullWritable;
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.Tool;
import org.apache.hadoop.util.ToolRunner;

/**
 * @author beifeng
 * 
 */
public class DataJoinMapReduce extends Configured implements Tool {

    // step 1 : Mapper Class

    public static class DataJoinMapper extends
            Mapper<LongWritable, Text, LongWritable, DataJoinWritable> {

        // map output key
        private LongWritable mapOutputKey = new LongWritable();

        // map output value
        private DataJoinWritable mapOutputValue = new DataJoinWritable();

        @Override
        protected void setup(Context context) throws IOException,
                InterruptedException {
        }

        @Override
        public void map(LongWritable key, Text value, Context context)
                throws IOException, InterruptedException {
            // line value
            String linevalue = value.toString();

            // split
            String[] vals = linevalue.split(",");

            int length = vals.length;
            if ((length != 3) && (length != 4)) {
                return;
            }

            // get cid
            long cid = Long.valueOf(vals[0]);

            // get name
            String name = vals[1];

            // set customer
            if (3 == length) {
                String phone = vals[2];
                mapOutputKey.set(cid);
                mapOutputValue.set("customer", name + "," + phone);
            }

            // set order
            if (4 == length) {
                String price = vals[2];
                String date = vals[3];
                mapOutputKey.set(cid);
                mapOutputValue.set("order", name + "," + price + "," + date);
            }
            //output
            context.write(mapOutputKey, mapOutputValue);
        }

        @Override
        protected void cleanup(Context context) throws IOException,
                InterruptedException {
        }
    }

    // step 2 : Reducer Class
    public static class DataJoinReducer extends
            Reducer<LongWritable, DataJoinWritable, NullWritable, Text> {

        private Text outputValue = new Text();

        @Override
        protected void setup(Context context) throws IOException,
                InterruptedException {
        }

        @Override
        protected void reduce(LongWritable key,
                Iterable<DataJoinWritable> values, Context context)
                throws IOException, InterruptedException {
            String customerInfo = null;
            List<String> orderList = new ArrayList<String>();

            // iterator
            for (DataJoinWritable value : values) {
                if ("customer".equals(value.getTag())) {
                    customerInfo = value.getData();
                } else if ("order".equals(value.getTag())) {
                    orderList.add(value.getData());
                }
            }

            // output
            for (String order : orderList) {
                // set output value
                outputValue.set(key.get() + "," + customerInfo + "," + order);
                // output
                context.write(NullWritable.get(), outputValue);
            }

        }

        @Override
        protected void cleanup(Context context) throws IOException,
                InterruptedException {
        }

    }

    /**
     * 
     * @param args
     * @return
     * @throws Exception
     *             int run(String [] args) throws Exception;
     */
    // step 3 : Driver
    public int run(String[] args) throws Exception {

        Configuration configuration = this.getConf();

        Job job = Job.getInstance(configuration, this.getClass()
                .getSimpleName());
        job.setJarByClass(DataJoinMapReduce.class);

        // set job
        // input
        Path inpath = new Path(args[0]);
        FileInputFormat.addInputPath(job, inpath);

        // output
        Path outpath = new Path(args[1]);
        FileOutputFormat.setOutputPath(job, outpath);

        // Mapper
        job.setMapperClass(DataJoinMapper.class);
        // TODD
        job.setMapOutputKeyClass(LongWritable.class);
        job.setMapOutputValueClass(DataJoinWritable.class);

        // Reducer
        job.setReducerClass(DataJoinReducer.class);
        // TODD
        job.setOutputKeyClass(NullWritable.class);
        job.setOutputValueClass(Text.class);

        // submit job
        boolean isSuccess = job.waitForCompletion(true);

        return isSuccess ? 0 : 1;

    }

    public static void main(String[] args) throws Exception {

        Configuration configuration = new Configuration();
        // 传递两个参数，设置路径
        args = new String[] {
                "hdfs://hadoop-senior01.ibeifeng.com:8020/user/beifeng/order/input",
                "hdfs://hadoop-senior01.ibeifeng.com:8020/user/beifeng/order/output3" };


        // run job
        int status = ToolRunner.run(configuration, new DataJoinMapReduce(),
                args);

        // exit program
        System.exit(status);
    }

}

package com.ibeifeng.bigdata.senior.hadoop.mapreduce.join;

import java.io.DataInput;
import java.io.DataOutput;
import java.io.IOException;

import org.apache.hadoop.io.Writable;

public class DataJoinWritable implements Writable {

    //makr,customer /oder
    private String tag;

    //info
    private String data;

    public DataJoinWritable(){

    }


    public DataJoinWritable(String tag, String data) {
        this.set(tag, data);
    }

    public void set(String tag, String data){
        this.setTag(tag);
        this.setData(data);
    }
    public String getTag() {
        return tag;
    }

    public void setTag(String tag) {
        this.tag = tag;
    }

    public String getData() {
        return data;
    }

    public void setData(String data) {
        this.data = data;
    }

    public void write(DataOutput out) throws IOException {
        out.writeUTF(this.getTag());
        out.writeUTF(this.getData());
    }

    public void readFields(DataInput in) throws IOException {
        this.setTag(in.readUTF());
        this.setData(in.readUTF());

    }


    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + ((data == null) ? 0 : data.hashCode());
        result = prime * result + ((tag == null) ? 0 : tag.hashCode());
        return result;
    }


    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        DataJoinWritable other = (DataJoinWritable) obj;
        if (data == null) {
            if (other.data != null)
                return false;
        } else if (!data.equals(other.data))
            return false;
        if (tag == null) {
            if (other.tag != null)
                return false;
        } else if (!tag.equals(other.tag))
            return false;
        return true;
    }


    @Override
    public String toString() {
        return tag + "," + data ;
    }

}
H_Hao
关注
专栏目录
MapReduce三次排序
sunsiyuan521的博客
05-07 1033
题目： 20170308,小强,小牛斗地主,22,360手机助手,0.2版本,北京 20170308,小强,小牛斗地主,14,360手机助手,0.3版本,北京 20170308,小强,小牛斗地主,13,360手机助手,0.3版本,北京 20170308,小强,小牛斗地主,16,360手机助手,0.4版本,北京 20170308,小强,小牛斗地主,18,360手机助手,0.4版本,北京
大数据从入门到实战 - 第3章 MapReduce基础实战，cz教你MapReduce实战操作
05-26 6207
第1关：成绩统计： 为了完成本关任务，你需要掌握：1.什么是MapReduce，2.如何使用MapReduce进行运算。 什么是MapReduce MapReduce是一种可用于数据处理的编程模型，我们现在设想一个场景，你接到一个任务，任务是：挖掘分析我国气象中心近年来的数据日志，该数据日志大小有3T,让你分析计算出每一年的最高气温，如果你现在只有一台计算机，如何处理呢？我想你应该会读取这些数据，并且将读取到的数据与目前的最大气温值进行比较。比较完所有的数据之后就可以得出最高气温了。不过以我们的经验都
MapReduce编程实战之“高级特性”
Java之旅
05-14 1933
本篇介绍MapReduce的一些高级特性，如计数器、数据集的排序和连接。计数器是一种收集作业统计信息的有效手段，排序是MapReduce的核心技术，MapReduce也能够执行大型数据集间的“”连接（join）操作。
MapReduce 高级
zhzsdiligence的博客
10-21 86
1. MapReduce Counter 计数器
MapReduce之二次排序
劫无忧
04-14 1942
本文介绍了MapReduce的二次排序实现细节
MapReduce高级案例①①
kamisamak的博客
06-17 130
WordCount案例 数据 hello world dog fish hadoop spark hello world dog fish hadoop spark hello world dog fish hadoop spark 统计一堆文件中单词出现的个数(WordCount案例) 在一堆给定的文本文件中统计输出每一个...
【Python排序可视化】：动态展示排序过程的技巧
本文将对Python中的排序算法进行概述，为读者提供一个关于如何在Python环境中选择和实现排序算法的基础知识框架。 接下来，我们将深入探讨排序算法的理论基础，包括不同排序算法的分类和各自的
Hive高级查询（join查询，装载数据（load，insert），数据导入导出（import，export），数据排序，聚合运算，窗口函数）（三）
May_J_Oldhu的博客
09-21 686
Hive高级查询一.Hive的数据查询1.基本数据查询（1）SELECT基础（2）CTE和嵌套查询2.join关联查询（1）基本概念（2）示例（3）练习-SELECT及关联查询3.Hive join-mapjoin4.Hive集合操作（UNION）（1）基本概念（2）示例二.装载数据1.装载数据：insert（1）基本语法（2）示例三.Hive数据插入文件1.基本概念2.示例四.Hive数据交换-IMPORT/EXPORT1.基本概念五.Hive数据排序1.ORDER BY（1）基本概念（2）示例2.SOR
【Python数据结构与算法通关指南】：从基础到高级的学习路线图
![【Python数据结构与...本章将带您概览Python与数据结构及算法的关系，并揭示它们如何相辅相成。 首先，我们将解释数据结构与算法在软件开发中的重要性，数据结构作为存储和组织数据的方式，决定了数据处理的效率，
Hive SQL练习之影评案例
软件手的博客
06-04 1638
找的练习hive，内容非原创链接 https://www.cnblogs.com/frankdeng/p/9309668.html 一、建表，导入数据 1、建表 [root@master hadoop]# hive Logging initialized using configuration in jar:file:/usr/local/src/apache-hive-1.2.2-bin/lib/hive-common-1.2.2.jar!/hive-log4j.properties hive&gt.
MapReduce之join(练习)
sjw2020的博客
04-26 158
static { System.setProperty(“hadoop.home.dir”, “D:\software\hadoop-2.9.2”); } public static class MyMapper extends Mapper<LongWritable, Text, Text, Text> { @Override protected void map(L...
MapReduce练习:DataJoin联结练习
Oeljeklaus的博客
08-09 1411
练习题如下：需要输出每个顾客的订单详情。 涉及到的文件： Customers 1,Stephanie Leung,555-555-5555 2,Edward Kim,123-456-7890 3,Jose Madrize,281-330-8004 4,Davia Stork,408-555-0000 Orders 3,A,12.95,02-Jun-2008 1,B,88.25,2
Hadoop自学笔记之：reduce端利用辅助排序手动实现连接
IT_Lee_J_H的博客
12-17 601
Hadoop自学笔记之：reduce端利用辅助排序手动实现连接1.简述：hadoop在开发过程中可能需要将输入的数据集像操作数据库时，对关系型数据库表的连接这样的操作，将输入的数据将进行连接操作
MapReduce练习之二次排序
weixin_44222965的博客
12-22 518
MapReduce练习之二次排序 （所有文章均做为本人笔记使用，可以指点，但是不要喷我，谢谢。） 　　本次练习的数据为历年世界气候数据，其数据格式为： 0010999999999991992010100004-24000-045700FM-13+9999KNFG V02099999999999999999N9999999N9+99999+99999999999ADDAG12000 00169999...
Mapreduce实现二次排序
月牙儿
01-12 562
SecondarySortMR 1.应用场景：MR默认会对键进行排序，然而有的时候我们也有对值进行排序的需求。满足这种需求一是可以在reduce阶段排序收集过来的values，但是，如果有数量巨大的values可能就会导致内存溢出等问题，这就是二次排序应用的场景——将对值的排序也安排到MR计算过程之中，而不是单独来做。 2.需求： name money zhangsan 125
hadoop中MapReduce多种join实现实例分析
weixin_33972649的博客
04-09 155
一、概述    对于RDBMS中的join操作大伙一定非常熟悉，写sql的时候要十分注意细节，稍有差池就会耗时巨久造成很大的性能瓶颈，而在Hadoop中使用MapReduce框架进行join的操作时同样耗时，但是由于hadoop的分布式设计理念的特殊性，因此对于这种join操作同样也具备了一定的特殊性。本文主要对MapReduce框架对表之间的join操作的几种实现方式进行详细分析，并且根据我在实...
MapReduce排序的Join多种应用(超级详细)
最新发布
互联网知识分享
07-18 206
4）右连接（Right Join）：右连接用于返回右侧数据集中的所有记录，以及左侧数据集中与右侧匹配的记录。3）左连接（Left Join）：左连接用于返回左侧数据集中的所有记录，以及右侧数据集中与左侧匹配的记录。2）内连接（Inner Join）：内连接是最常用的Join操作类型之一，它用于返回两个数据集中键值匹配的记录。执行左连接操作，输出左侧数据集中的所有记录以及与左侧匹配的右侧记录。执行右连接操作，输出右侧数据集中的所有记录以及与右侧匹配的左侧记录。执行内连接操作，输出键值匹配的记录。
MapReduce高级特性
小黑
05-10 2897
计数器因为计数器的查看往往比查看集群日志来的方便快捷 所以有些情况下计数器信息比集群日志更加有效用户自定义的计数器关于Hadoop的内置计数器的介绍可以参考Hadoop权威指南第九章MapReduce Features中的Build-in Counts小节 这里限于篇幅不再说明MapReduce允许用户在程序中使用枚举或者字符串的格式类自定义计数器 一个作业可以定义的计数器不限，使用枚举类型时
MapperReduce的使用及高级功能
cp_Mark的博客
05-06 2219
涉及到的知识： Yarn调度MapReduce的过程 Mapper Reduce 排序 分区 Combiner Shuffle Yarn调度MapReduce的过程 Yarn和MapReduce的关系，就跟我们web项目中和tomcat的关系一样，Yarn是MapReduce运行的容器。下面我们先介绍一下Yarn的一些概念。 Yarn也是主从结构：ResourceManager（主...
MapReduce高级特性：应用实例与排序Join解析
"这篇文档是关于MapReduce的高级特性，主要涵盖了各种应用场景的实例，包括内存排序、自定义数据类型、二次排序、内存排序找出每组最大值以及两个表的简单JOIN操作。文档通过实际案例深入浅出地解析了MR的重要知识点...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值