Spark 從零到開發（七）Spark SQL和DataFrame

話不多說，直接代碼。概念還是spark sql中的概念。

方式一：使用java反射來推斷RDD元數據

從文本文件拿到RDD對象->利用反射機制將RDD轉換爲DataFrame->註冊爲一個臨時表->執行sql語句->再次轉換爲RDD->將RDD中的數據進行映射->收集數據

先創建一個實體類：Student.java

public class Student implements Serializable {

    private int id;
    private String name;
    private int age;

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Student{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

    public static void main(String[] args) {
        SparkConf conf = new SparkConf().setAppName("RDD2DataFrameReflection").setMaster("local");
        JavaSparkContext sc = new JavaSparkContext(conf);
        sc.setLogLevel("ERROR");

        SQLContext sqlContext = new SQLContext(sc);

        JavaRDD<String> lines = sc.textFile("C:\\Users\\84407\\Desktop\\student.txt");
        JavaRDD<Student> students = lines.map((Function<String, Student>) line -> {
            String[] lineSplited = line.split(",");
            Student student = new Student();
            student.setId(Integer.parseInt(lineSplited[0].trim()));
            student.setAge(Integer.parseInt(lineSplited[2].trim()));
            student.setName(lineSplited[1].trim());
            return student;
        });
        /**
         * 使用反射方式，將RDD轉換爲DataFrame
         * 將student.class 傳入進去，其實就是用反射的方式來創建DataFrame
         * 因爲Student.class本身就是反射的一個應用
         * 然後底層還得通過對Student.class進行反射，來獲取其中的field
         * 這裏要求，JavaBean必須實現Serializable接口，可序列化
         */
        DataFrame studentDF = sqlContext.createDataFrame(students,Student.class);
        /**
         * 拿到一個DataFrame之後，就可以將其註冊爲一個臨時表，然後針對其中的數據執行sql語句
         */
        studentDF.registerTempTable("students");
        /**
         * 針對students 臨時表執行sql語句，查詢年齡小於等於18歲的學生，就是excellent
         */
        DataFrame excellentDF = sqlContext.sql("select * from students where age <= 18");
        /**
         * 將查詢出來的DataFrame ，再次轉換爲RDD
         */
        JavaRDD<Row> excellentRDD = excellentDF.javaRDD();
        /**
         * 將RDD中的數據進行映射，映射爲Student
         */
        JavaRDD<Student> excellentStudentRDD = excellentRDD.map((Function<Row, Student>) row -> {
            //row 中的數據的順序，可能和我們期望的不一樣
            Student student = new Student();
            student.setAge((Integer) row.get(0));
            student.setId(row.getInt(1));
            student.setName(row.getString(2));
            return student;
        });

        /**
         * 將數據collect回來，然後打印
         */
        List<Student> studentList = excellentStudentRDD.collect();
        for (Student stu:studentList){
            System.out.println(stu);
        }
    }

執行結果：

Student{id=1, name='FantJ', age=18}
Student{id=2, name='Fantj2', age=18}
Student{id=3, name='Fantj3', age=18}
Student{id=4, name='FantJ4', age=18}
Student{id=5, name='FantJ5', age=18}
Student{id=6, name='FantJ6', age=18}

方式二：通過編程接口來創建DF：在程序中構建元數據

從文本中拿到JavaRDD<Row> --> 動態構造元數據 --> 將RDD轉換成DF --> 註冊臨時表 --> 執行sql --> 收集數據

    public static void main(String[] args) {
        /**
         * 創建sparkConf、javaSparkContext、SqlContext
         */
        SparkConf conf = new SparkConf().setAppName("RDD2DataFrameProgrammatically").setMaster("local");

        JavaSparkContext sc = new JavaSparkContext(conf);

        SQLContext sqlContext = new SQLContext(sc);
        /**
         * 第一步：創建一個普通的，但是必須將其轉換成RDD<row>的形式
         */
        JavaRDD<String> lines = sc.textFile("C:\\Users\\84407\\Desktop\\student.txt");

        JavaRDD<Row> studentRDD = lines.map(new Function<String, Row>() {
            @Override
            public Row call(String line) {
                String[] split = line.split(",");
                return RowFactory.create(Integer.valueOf(split[0]), String.valueOf(split[1]), Integer.valueOf(split[2]));
            }
        });

        /**
         * 第二步：動態構造元數據
         * 字段的數據可能都是在程序運行中才能知道其類型
         * 所以我們需要用編程的方式來動態構造元數據
         */
        List<StructField> structFields = new ArrayList<>();
        structFields.add(DataTypes.createStructField("id",DataTypes.IntegerType,true));
        structFields.add(DataTypes.createStructField("name",DataTypes.StringType,true));
        structFields.add(DataTypes.createStructField("age",DataTypes.IntegerType,true));

        StructType structType = DataTypes.createStructType(structFields);

        /**
         * 第三步：將RDD轉換成DF
         */
        DataFrame studentDF = sqlContext.createDataFrame(studentRDD, structType);
        studentDF.registerTempTable("students");

        DataFrame excellentDF = sqlContext.sql("select * from students where name='FantJ'");

        List<Row> rows = excellentDF.collectAsList();
        for (Row row:rows){
            System.out.println(row);
        }


    }

執行結果：

[1,FantJ,18]

總結

方式一和方式二最大的區別在哪呢，通俗點說就是獲取字段類型的手段不同。

方式一通過java反射，但是要有javabean當字段模版。
方式二通過手動編碼設置line的split對象的每個數據段的類型，不用創建javabean。